Strict aliasing in flexible array member? - c

Question

I'm writing an Arena Allocator and it works, but I feel like it violates strict aliasing rules. I want to know if I'm right or wrong. Here's the relevant part of the code:
typedef struct ArenaNode ArenaNode;
struct ArenaNode {
ArenaNode *next;
size_t dataSize;
u8 data[];
};
typedef struct {
ArenaNode *head;
ArenaNode *current;
size_t currentIndex;
} Arena;
static ArenaNode *ArenaNodeNew(size_t dataSize, ArenaNode *next)
{
ArenaNode *n = malloc(sizeof(ArenaNode) + dataSize);
n->next = NULL;
n->dataSize = dataSize;
return n;
}
void *ArenaAlloc(Arena *a, size_t size)
{
const size_t maxAlign = alignof(max_align_t);
size_t offset = nextHigherMultiplePow2(offsetof(ArenaNode, data), maxAlign) - offsetof(ArenaNode, data);
size_t dataSize = offset + max(size, ARENA_SIZE);
// first time
void *ptr;
if (a->head == NULL) {
ArenaNode *n = ArenaNodeNew(dataSize, NULL);
a->head = n;
a->current = n;
ptr = n->data + offset;
a->currentIndex = nextHigherMultiplePow2(offset + size, maxAlign);
} else {
// enough space
if (a->currentIndex + size <= a->current->dataSize) {
ptr = &a->current->data[a->currentIndex];
a->currentIndex = nextHigherMultiplePow2(a->currentIndex + size, maxAlign);
} else {
ArenaNode *n = ArenaNodeNew(dataSize, NULL);
a->current->next = n;
a->current = n;
ptr = n->data + offset;
a->currentIndex = nextHigherMultiplePow2(offset + size, maxAlign);
}
}
return ptr;
}
The Arena is a linked list of Nodes and a Node is a header followed by data u8 data[]. u8 is unsigned char.
I maintain the next available index (currentIndex) and advance data by this index and return it as void * (ptr = &a->current->data[a->currentIndex]). Does this violate strict aliasing rule because I'm converting a pointer to u8 to something else and using that?
My confusion comes from the fact that memory returned by malloc has no effective type. But since I'm casting the malloc'd pointer to ArenaNode * and setting its data members (next and dataSize) after allocating it (in ArenaNodeNew), the effective type becomes ArenaNode. Or does it? I didn't set data field of that.
Basically, I think the question can be simplified to this: If I malloc a memory region of say, size 10, cast the pointer to struct {int a;} * (assume 4 bytes int), set it a to something, what happens to the rest of the 6 bytes? Does it have any effective type? Does the presence of flexible array member affect this in any way?

Answer 1

The extra bytes that are part of the flexible array member will have the effective type of that member as you write to them.
You can safely declare ptr as u8 * and define your function to return that type as well.
In your example of allocating 10 bytes and treating the first 4 as a struct of the given type, the remaining bytes have no effective type yet. You can use those for any type, assuming the pointer you use is aligned correctly, i.e. you can point a int * to the following bytes but not a long long *. due to alignment.

Answer 2

Does this violate strict aliasing rule because I'm converting a pointer to u8 to something else and using that?
No, you are not violating strict aliasing, but your code might violate the constraints imposed by 7.22.3 Memory management functions, paragraph 1:
The pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to a pointer to any type of object with a fundamental alignment requirement and then used to access such an object or an array of such objects in the space allocated ...
You don't appear to be making sure the memory you use for any object is "suitably aligned" for any object. Given 6.3.2.3 Pointers, paragraph 7's statement:
A pointer to an object type may be converted to a pointer to a different object type. If the resulting pointer is not correctly aligned for the referenced type, the behavior is undefined.
you appear to be risking undefined behavior.
"Suitably aligned" is extremely platform-dependent.