Understanding alignment in g++

[Yang Zhang]

Hi, consider this simple program:

#include <cstdio>
#include <cstring>
#include <iostream>
#include <type_traits>
using namespace std;

enum { sz = 8 };

int main() {
   cout << alignment_of<int>::value << endl;

   char a[sz];
   cout << (void*)a << endl;
   bzero(a, sz);

   *((int*)(a+1)) = -1;
   for (int i = 0; i < sz; ++i) printf("%02hhx ", a[i]);
   cout << endl;

   return 0;
}

Here's the stdout on x86_64:

4
0x7fff0710a2b0
00 ff ff ff ff 00 00 00

I expected a cast-align warning or something.  How did gcc make the 
unaligned write work?  It didn't generate any inefficient code or 
anything; here's an excert from objdump -DE:

   *((int*)(a+1)) = -1;
   400a4a:       48 8d 45 f0             lea    -0x10(%rbp),%rax
   400a4e:       48 83 c0 01             add    $0x1,%rax
   400a52:       c7 00 ff ff ff ff       movl   $0xffffffff,(%rax)

Is the alignment_of value incorrect?  I also tried __alignof__ and got 
the same result.

Related: Is there an example of a type that actually has non-1 alignment 
on x86(_64)?  What happens if I try to use it as shown above (unaligned) 
- does the compiler just produce inefficient code?  Does the memory 
access fall into alignment (thus producing unexpected results)?

Thanks in advance for any answers.
-- 
Yang Zhang
http://www.mit.edu/~y_z/