[X86] Add -malign-double support

[phosek]

Summary

The -malign-double flag causes i64 and f64 types to have alignment 8
instead of 4. On x86-64, -malign-double is enabled by default.

[jfb]

GCC's description is:

-malign-double
-mno-align-double
Control whether GCC aligns double, long double, and long long variables on a two word boundary or a one word boundary. Aligning double variables on a two word boundary will produce code that runs somewhat faster on a `Pentium' at the expense of more memory.
On x86-64, -malign-double is enabled by default.

Warning: if you use the -malign-double switch, structures containing the above types will be aligned differently than the published application binary interface specifications for the 386 and will not be binary compatible with structures in code compiled without that switch.

I think this should be similar.

Could you also check stack spill alignment?

Could you also test the following from GCC's test suite:

./gcc/testsuite/g++.old-deja/g++.abi/bitfields.C
./gcc/testsuite/g++.old-deja/g++.abi/aggregates.C
./gcc/testsuite/g++.old-deja/g++.abi/align.C

[phosek]

Superseded by http://reviews.llvm.org/D19740

lib/Target/X86/X86TargetMachine.cpp

 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetOptions.h"
 using namespace llvm;
 
 static cl::opt<bool> EnableMachineCombinerPass("x86-machine-combiner",
                                cl::desc("Enable the machine combiner pass"),
                                cl::init(true), cl::Hidden);
 
+static cl::opt<bool>
+MalignDouble("malign-double", cl::Hidden,
+             cl::desc("Align i64 and f64 types to 8 bytes"));
+
 namespace llvm {
 void initializeWinEHStatePassPass(PassRegistry &);
 }
 
 extern "C" void LLVMInitializeX86Target() {
   // Register the target.
   RegisterTargetMachine<X86TargetMachine> X(TheX86_32Target);
   RegisterTargetMachine<X86TargetMachine> Y(TheX86_64Target);
static std::string computeDataLayout(const Triple &TT) {
   Ret += DataLayout::getManglingComponent(TT);
   // X86 and x32 have 32 bit pointers.
   if ((TT.isArch64Bit() &&
        (TT.getEnvironment() == Triple::GNUX32 || TT.isOSNaCl())) ||
       !TT.isArch64Bit())
     Ret += "-p:32:32";
 
   // Some ABIs align 64 bit integers and doubles to 64 bits, others to 32.
-  if (TT.isArch64Bit() || TT.isOSWindows() || TT.isOSNaCl())
+  if (TT.isArch64Bit() || TT.isOSWindows() || TT.isOSNaCl() || MalignDouble)
     Ret += "-i64:64";
   else
     Ret += "-f64:32:64";
 
   // Some ABIs align long double to 128 bits, others to 32.
   if (TT.isOSNaCl())
     ; // No f80
   else if (TT.isArch64Bit() || TT.isOSDarwin())

test/CodeGen/X86/llc-malign-double.ll

+; RUN: llc -mtriple=i386-pc-linux -filetype=asm %s -o - | FileCheck %s
+; RUN: llc -mtriple=i386-pc-linux -malign-double -filetype=asm %s -o -| FileCheck %s --check-prefix=MALIGN
+
+; Test that the -malign-double flag causes i64 and f64 types to have alignment
+; 8 instead of 4.
+
+%structi64 = type { i32, i64 }
+
+define i32 @check_i64_size() {
+; CHECK-LABEL: check_i64_size:
+  %starti = ptrtoint %structi64* null to i32
+  %endp = getelementptr %structi64, %structi64* null, i32 1
+  %endi = ptrtoint %structi64* %endp to i32
+  %diff = sub i32 %endi, %starti
+; CHECK: movl $12, %eax
+; MALIGN: movl $16, %eax
+  ret i32 %diff
+}
+
+define i32 @check_i64_offset() {
+; CHECK-LABEL: check_i64_offset:
+  %starti = ptrtoint %structi64* null to i32
+  %endp = getelementptr %structi64, %structi64* null, i32 0, i32 1
+  %endi = ptrtoint i64* %endp to i32
+  %diff = sub i32 %endi, %starti
+; CHECK: movl $4, %eax
+; MALIGN: movl $8, %eax
+  ret i32 %diff
+}
+
+%structf64 = type { i32, double }
+
+define i32 @check_f64_size() {
+; CHECK-LABEL: check_f64_size:
+  %starti = ptrtoint %structf64* null to i32
+  %endp = getelementptr %structf64, %structf64* null, i32 1
+  %endi = ptrtoint %structf64* %endp to i32
+  %diff = sub i32 %endi, %starti
+; CHECK: movl $12, %eax
+; MALIGN: movl $16, %eax
+  ret i32 %diff
+}
+
+define i32 @check_f64_offset() {
+; CHECK-LABEL: check_f64_offset:
+  %starti = ptrtoint %structf64* null to i32
+  %endp = getelementptr %structf64, %structf64* null, i32 0, i32 1
+  %endi = ptrtoint double* %endp to i32
+  %diff = sub i32 %endi, %starti
+; CHECK: movl $4, %eax
+; MALIGN: movl $8, %eax
+  ret i32 %diff
+}