type alignment non forwarded to malloc instruction in C and C++ frontends

[llvmbot]

Bugzilla Link	1531
Resolution	DUPLICATE
Resolved on	Feb 22, 2010 12:55
Version	unspecified
OS	All
Reporter	LLVM Bugzilla Contributor

Extended Description

In the following C code (with GCC extensions):

struct test
{
int a;
int b attribute((aligned(16)));
};

void do_something(struct test*);

int main()
{
struct test* t = malloc(sizeof *t);
do_something(t);

return 0;

}

The type "struct test" has an associated alignment of 16.

However, LLVM will do a normal malloc instruction, without saying it wants an
alignment of 16.
While it is true that GCC won't be able to do that anyway because to it malloc
is a regular function that only allocates with an alignment of 8, the malloc
instruction can be smart enough here to allocate with the appropriate alignment.

Actual output:

; ModuleID = '/tmp/webcompile/_30695_0.bc'
target datalayout =
"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64"
target triple = "i686-pc-linux-gnu"
%struct.test = type { i32, [12 x i8], i32, [12 x i8] }

define i32 @​main() {
entry:
%tmp16 = malloc %struct.test ; <%struct.test*> [#uses=1]
tail call void @​do_something( %struct.test* %tmp16 )
ret i32 0
}

declare void @​do_something(%struct.test*)

Expected output:

; ModuleID = '/tmp/webcompile/_30695_0.bc'
target datalayout =
"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64"
target triple = "i686-pc-linux-gnu"
%struct.test = type { i32, [12 x i8], i32, [12 x i8] }

define i32 @​main() {
entry:
%tmp16 = malloc %struct.test, align 16 ; <%struct.test*> [#uses=1]
tail call void @​do_something( %struct.test* %tmp16 )
ret i32 0
}

declare void @​do_something(%struct.test*)

[lattner]

In practice, there isn't much we can do here. The system malloc is supposed to return memory maximally
aligned for any data type on the system (e.g. mac os always returns 16-byte aligned memory due to
vectors).

Malloc itself doesn't take an alignment argument, and some systems don't provide memalign.

What do you suggest?

-Chris

[lattner]

Oh, also, there is no reason for the C front-end to turn this:

malloc(sizeof *t);

into an aligned malloc instruction. You're mallocing a type, you're mallocing 32 bytes of untyped space
here.

-Chris

[lattner]

rather, "You're not mallocing a type, you're mallocing 32 bytes of untyped space
here."

[llvmbot]

I agree with Criss on the problem with the example. However, codegening of
malloc instructions with alignment is bug 1362.

[lattner]

*** This bug has been marked as a duplicate of 1362 ***

[llvmbot]

Given that the malloc instruction can take an alignment argument, I would assume
that the frontend should do what it can to give the correct alignment argument.
It can already figure out that the type is indeed a struct.test and turn it into
a malloc instruction accordingly. It just needs to add the information about
struct.test's alignment.

Turning that malloc instruction with alignment info into the appropriate code is
another issue, a bug in is the code generation.
This is a "bug" (or rather, a non-feature) in the C/C++ frontend, which simply
doesn't add the alignment info to the malloc instruction.

It is true that the C malloc function is ill-designed and cannot align properly,
yet LLVM has the possibility to fix that issue and make C more usable.

[lattner]

Given that the malloc instruction can take an alignment argument, I would assume
that the frontend should do what it can to give the correct alignment argument.

Yes.

It can already figure out that the type is indeed a struct.test and turn it into
a malloc instruction accordingly. It just needs to add the information about
struct.test's alignment.

No. When you write that code in C, you are not saying anything about the alignment.

Turning that malloc instruction with alignment info into the appropriate code is
another issue, a bug in is the code generation.

Yep, this is Bug 1362

This is a "bug" (or rather, a non-feature) in the C/C++ frontend, which simply
doesn't add the alignment info to the malloc instruction.

No, C does not say you should do that. Doing it would be a bug.

It is true that the C malloc function is ill-designed and cannot align properly,
yet LLVM has the possibility to fix that issue and make C more usable.

Unfortunately, no that would mean that LLVM would mishandle C. :(

-Chris

[llvmbot]

Actually, according to the C standard, the C malloc function must allocate
memory suitably aligned for any type.
And in C, all types have an alignment requirement.
That means that when I allocate memory for the 'struct test' type, I should have
memory properly aligned for the 'struct test' type.

However, using GCC extensions, I was able to set the alignment that I wanted,
and that is higher that the highest alignment requirement of 8 that malloc uses.
malloc just can't handle the fact that I'm setting my own alignment requirements
on the types, because its design didn't take into account the fact that the user
could eventually choose his own alignment for the type.
Allowing a type to be of any alignment as an extension, but failing to fulfill
the alignment requirement when allocating memory for that type with malloc,
seems to be quite stupid to me.