Propagate alignment for _Complex

lib/CodeGen/CGExprComplex.cpp

 //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This contains code to emit Expr nodes with complex types as LLVM code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/StmtVisitor.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalValue.h" // @LOCALMOD not needed after merge
 using namespace clang;
 using namespace CodeGen;
 
 //===----------------------------------------------------------------------===//
 //                        Complex Expression Emitter
 //===----------------------------------------------------------------------===//
 
 typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
 
 namespace  {
@@ skipping 253 matching lines @@
 
 //===----------------------------------------------------------------------===//
 //                                Utilities
 //===----------------------------------------------------------------------===//
 
 /// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
 /// load the real and imaginary pieces, returning them as Real/Imag.
 ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr,
                                                     bool isVolatile) {
   llvm::Value *Real=0, *Imag=0;
+  // @LOCALMOD-START I submitted a fix upstream for this issue, but the code
+  //                 was re-written to use LValue instead of Value, so this
+  //                 fix will be wrong after the merge.
+  //                 We should cherry-pick my fix, which is past 3.3.
+  unsigned Align = 0;
+
+  if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(SrcPtr))
+    Align = GV->getAlignment();
 
   if (!IgnoreReal || isVolatile) {
     llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0,
                                                  SrcPtr->getName() + ".realp");
-    Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real");
+    Real = Builder.CreateAlignedLoad(RealP, Align, isVolatile,
+                                     SrcPtr->getName() + ".real");
   }
 
   if (!IgnoreImag || isVolatile) {
     llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1,
                                                  SrcPtr->getName() + ".imagp");
-    Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag");
+    Imag = Builder.CreateAlignedLoad(ImagP, Align, isVolatile,
+                                     SrcPtr->getName() + ".imag");
   }
   return ComplexPairTy(Real, Imag);
 }
 
 /// EmitStoreOfComplex - Store the specified real/imag parts into the
 /// specified value pointer.
 void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr,
                                             bool isVolatile) {
   llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
   llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
+  unsigned Align = 0;
 
-  Builder.CreateStore(Val.first, RealPtr, isVolatile);
-  Builder.CreateStore(Val.second, ImagPtr, isVolatile);
+  if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Ptr))
+    Align = GV->getAlignment();
+
+  Builder.CreateAlignedStore(Val.first, RealPtr, Align, isVolatile);
+  Builder.CreateAlignedStore(Val.second, ImagPtr, Align, isVolatile);
+  // @LOCALMOD-END
 }
 
 
 
 //===----------------------------------------------------------------------===//
 //                            Visitor Methods
 //===----------------------------------------------------------------------===//
 
 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
   CGF.ErrorUnsupported(E, "complex expression");
@@ skipping 504 matching lines @@
   case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break;
   case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break;
 
   default:
     llvm_unreachable("unexpected complex compound assignment");
   }
 
   ComplexPairTy Val; // ignored
   return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
 }