Misalignment of assigning the first element in void* arrays and malloc assigning more memory than necessary

Question

I'm confused as to why the following code still runs even though i have not allocated enough memory for the void* arr[]; i'm still able to write to those locations and not run into a segfault.

void** arr;

arr = realloc(NULL, 1); // 1 Byte allocated
arr[0] = (void *)1;     // able to store a 8B pointer

arr = realloc(arr, 2); // 2 Bytes allocated
arr[1] = (void *)2;    // able to store yet another 8B pointer

arr = realloc(arr, 4); // 4 Bytes allocated
arr[2] = (void *)3;    // able to store yet another 8B pointer
arr[3] = (void *)4;    // able to store yet another 8B pointer

// Error
arr = realloc(arr, 8); // realloc():invalid next size thrown presumaby 
                       // because we wrote into the space for malloc metadata

Also, looking at this [screenshot of the program's memory layout] it seems that the first assignment a[0] = 1 takes up only the first 4B chunk even though void*s are 8Bytes. The rest of the assignments do take up 8Bs so i'm also curious why the first a[0] only takes up 4Bytes.

Thank you!

A segfault is a *common manifestation* of the undefined behavior of overrunning the bounds of an object. It is not a guanranteed result -- that would make it a *defined* behavior. C does not hold your hand or, in most cases, check up on you. It tells you what the range of possible results will be for correct programs, and largely throws up its hands and says "you get what you get" when you try to build or run an incorrect program. — John Bollinger, Sep 22 '22 at 19:30
There are two different questions here. The first one is [already answered](https://stackoverflow.com/questions/57930992/how-many-members-calloc-allocates-in-c) — user253751, Sep 22 '22 at 19:31
You are misreading the gdb output when you conclude that it shows `arr[0]` occupying only four bytes. Compare the output of the `x/32bx arr` and `x/4gx arr` commands. — John Bollinger, Sep 22 '22 at 19:42

score 1 · Answer 1 · answered Sep 22 '22 at 19:31

realloc only reserves memory for use. Nothing in the C standard requires a C implementation to prevent you from using, or trying to use, memory you have not reserved.

When your program executes arr[0] = (void *)1;, it writes to memory it has not reserved. If nothing else is using that memory, you may “get away with it.” Memory allocation software generally does not reserve memory in one-byte pieces, so, when you ask for one byte, it actually provides whatever its smallest allocation unit is. (This does not mean you can safely use that memory. Compiler optimizers have become increasingly more aggressive and “knowledgeable” about C rules and semantics, so optimization effects may make a program that violates the rules go awry even if the memory is available.)

The screenshot does not show that only four bytes are written for that assignment. The high bytes are zeros, so they show up as “0x00000000”. The C implmentation you are using stores the low-value bytes in the low-addressed word and the high-value bytes in the high-addressed word, so a pointer to address 1 is stored as 0x00000001 in the first four bytes and 0x00000000 in the second four bytes.

0___________ · Accepted Answer · 2022-09-22T20:00:24.590

It is undefined behavour. In C nothing prevents you from writing to the invalid or not allocated memory.

it seems that the first assignment a[0] = 1 takes up only the first 4B chunk even though void*s are 8Bytes.

No, it is called little endian and less significant bytes are stored first.

example:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    unsigned long long x[] = {1,2,3};
    unsigned y[sizeof(x) / sizeof(unsigned)];

    memcpy(y,x,sizeof(x));
    for(int i = 0; i < sizeof(y) / sizeof(y[0]); i ++)
        printf("0x%08x ", y[i]);
    printf("\n");
}

result:

0x00000001 0x00000000 0x00000002 0x00000000 0x00000003 0x00000000

https://godbolt.org/z/a7vrrPWGx

You can also see it on the byte level: https://godbolt.org/z/b7xMMfxhc

or https://godbolt.org/z/scT7barvs

Misalignment of assigning the first element in void* arrays and malloc assigning more memory than necessary

2 Answers2