mov rax, qword 12345678ABCDEFh ; 10 bytes function address
jmp rax ; 2 bytes
payload times N db 0 ; closure environmentleah cul,ver[rip] but you can have write access at the start and after that remove it and give it exec access, right?That is a lot of non-portable work. Moreover, mprotect isn't guaranteed to succeed on non-mmaped pages. I.e. if you prefer bss allocation, mprotect may fail.
_Alignas, _Alignof instead of alignas, alignof, _Noreturn instead of noreturn, _Thread_local instead of thread_local, _Atomic instead of atomic
_Reserved form; if you don't have name clashes in existing code you just can include the appropriate header (which the standard also provides for) and use lower case via preprocessor macros._Static_assert instead of static_Assert (it is also badly designed)
[2]: no overflow checking functions
other kind of unsafe functions (like atoi, shit like strftime)
lack of ssize_t (that can hold everything size_t can + atleast 1 bit)
sizeof(size_t) != sizeof(ssize_t).lack of [s]size_t function that can hold the maximum value of size_t * CHAR_BIT
intptr_t/uintptr_t are optional and
lack of a byte type that is atleast 1 bit instead of char (char is atleast 8 bit and can be more even if you have 8-bit bytes if the encoding is more than 8 bit)
int is for. Because not all architectures interpret integers as pointers into a flat address space.x86 uses two integers to define a pointer, but you can still define default segment to emulate singe-integer pointers.
if you don't have name clashes in existing code you just can include the appropriate headerI though that it is undefined behavior if you redefine things that are used in headers even if you do not include them but I can not find where the standard says that so ignore this point
Because not every architecture has a flags register.This is not what I mean at all, I am thinking of a function like checkOverflow_mul (int, int)
All shit yes; but too old and widely used to remove at this point.I am not proposing to remove them, I am just saying that the older standards suck because of introducing them and new standards suck because of not introducing new ones that fix these problems
Not possible unless you're comfortable with having sizeof(size_t) != sizeof(ssize_t).I can not see a problem with this, most people are using ssize_t as a size_t with the ability to ``throw'' an error (if 0 is a valid value) or in other cases like this
And this is useful because you address bits when?many times for example if you want to create a array of char, int or anything that you access it per bit
bitArray *createBitArray (bit_size_t numberOfElements);
bool getbit (const bitArray *bitarray, bit_size_t N);
void setbit (bitArray *bitarray, bit_size_t N, bool something);Because not all architectures interpret integers as pointers into a flat address space.I did not have them in my mind for usage of them as pointers but for being able to do things like counting the items of a linked list, a type that can hold all the possible addresses would be the only one that for sure would be able to fit the maximum number
That's what int is for.
int is not a byte last time I checked and it is atleast 16 bits many times for example if you want to create a array of char, int or anything that you access it per bit
CHAR_BIT of your address space? Just typedef unsigned long bit_size_t and be done with it.I did not have them in my mind for usage of them as pointers but for being able to do things like counting the items of a linked list, a type that can hold all the possible addresses would be the only one that for sure would be able to fit the maximum number
size_t is supposed to be for. Just typedef unsigned long bit_size_t and be done with it.This is very limited
That's exactly what size_t is supposed to be for.this is not the case at all, size_t is guaranteed to be big enough to contain the size of the biggest object your system can handle. a linked list has many nodes, it is not one object in C
Not possible unless you're comfortable with having sizeof(size_t) != sizeof(ssize_t).How is this a problem? What if you want the (signed) difference between two size_t values?
size_t a = (size_t)-1;
size_t b = 0;
ssize_t c = a - b;