How can I inform the compiler that a pointer value is expected to be aligned at a specific boundary?

Question

I'm wondering if it's possible to hint to gcc that a pointer points to an aligned boundary. if I have a function:

void foo ( void * pBuf ) {
    uint64_t *pAligned = pBuf;
    pAligned = ((pBuf + 7) & ~0x7);
    var = *pAligned;   // I want this to be aligned 64 bit access
}

And I know that pBuf is 64 bit aligned, is there any way to tell gcc that pAligned points to a 64 bit boundary? If I do:

uint64_t *pAligned __attribute__((aligned(16)));   

I believe that means that the address of the pointer is 64 bit aligned, but it doesn't tell the compiler that the what it points to is aligned, and therefore the compiler would likely tell it to do an unaligned fetch here. This could slow things down if I'm looping through a large array.

Answer 1

There are several ways to inform GCC about alignment.

Firstly you can attach align attribute to pointee, rather than pointer:

int foo() {
  int __attribute__((aligned(16))) *p;
  return (unsigned long long)p & 3;
}

Or you can use (relatively new) builtin:

int bar(int *p) {
  int *pa = __builtin_assume_aligned(p, 16);
  return (unsigned long long)pa & 3;
}

Both variants optimize to return 0 due to alignment.

Unfortunately the following does not seem to work:

typedef int __attribute__((aligned(16))) *aligned_ptr;

int baz(aligned_ptr p) {
  return (unsigned long long)p & 3;
}

and this one does not either

typedef int aligned_int __attribute__((aligned (16)));

int braz(aligned_int *p) {
  return (unsigned long long)p & 3;
}

even though docs suggest the opposite.