Assume alignment when loading from pointer

[JohanEngelen]

As far as I know, unaligned memory access is UB in D. We don't yet make use of this in all cases.

align(64)
struct int64 {
    int i;
    alias i this;
}

int64* g();

int foo() {
    auto t = g();
    return *t;
}

int f(int64* i) { return *i;}

creates the IR:

define i32 @_D7example3fooFZi() local_unnamed_addr #1 {
  %1 = tail call %example.int64* @_D7example1gFZPSQo5int64() #0
  %2 = getelementptr inbounds %example.int64, %example.int64* %1, i64 0, i32 0
  %3 = load i32, i32* %2, align 4
  ret i32 %3
}

define i32 @_D7example1fFPSQn5int64Zi(%example.int64* nocapture readonly %i_arg) local_unnamed_addr #2 {
  %1 = getelementptr inbounds %example.int64, %example.int64* %i_arg, i64 0, i32 0
  %2 = load i32, i32* %1, align 4
  ret i32 %2
}

Note that align 4 instead of align 64. (The align 4 is actually deduced by LLVM (loading an i32), and not emitted by LDC.)

I think we can be aggressive here and emit align 64.
Clang does that too.

[p0nce]

Related: https://forum.dlang.org/thread/xntxnthytvnxdmhkerrj@forum.dlang.org would greatly appreciate your input!

[JohanEngelen]

My interpretation is that a pointer of type T does not always have to be aligned. But when you dereference the pointer (e.g. read or write), then it has to be aligned.

[p0nce]

Is there a transition path though?
That means *cast(int*)(any pointer to valid memory) would become UB because it needs an alignement of 4 bytes, but I think this kind of things happens lots of time in code in the wild ; it would have to be converted to ubyte* everytime?
(OTOH, if that leads to speed-up it will be very cool)

[JohanEngelen]

Is there a transition path though?
That means *cast(int*)(any pointer to valid memory) would become UB because it needs an alignement of 4 bytes, but I think this kind of things happens lots of time in code in the wild ; it would have to be converted to ubyte* everytime?
(OTOH, if that leads to speed-up it will be very cool)

Yes, this is already UB. In practice, the code will just crash on, say, some ARM architectures that do not support unaligned access in general.
It doesn't happen so often in practice, but indeed I believe it is one of the common problems when porting code from x86 to another architecture.

[JohanEngelen]

related: #4236