Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/FixVectorLoadStoreAlignment.cpp

 //===- FixVectorLoadStoreAlignment.cpp - Vector load/store alignment ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Fix vector load/store alignment by:
@@ skipping 12 matching lines @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/NaCl.h"
 
 using namespace llvm;
 
 namespace {
 class FixVectorLoadStoreAlignment : public BasicBlockPass {
 public:
   static char ID; // Pass identification, replacement for typeid
   FixVectorLoadStoreAlignment() : BasicBlockPass(ID), M(0), DL(0) {
     initializeFixVectorLoadStoreAlignmentPass(*PassRegistry::getPassRegistry());
   }
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<DataLayoutPass>();
-    BasicBlockPass::getAnalysisUsage(AU);
-  }
   using BasicBlockPass::doInitialization;
   bool doInitialization(Module &Mod) override {
     M = &Mod;
     return false; // Unchanged.
   }
   bool runOnBasicBlock(BasicBlock &BB) override;
 
 private:
   typedef SmallVector<Instruction *, 8> Instructions;
   const Module *M;
@@ skipping 138 matching lines @@
 
     // Fill in the vector element by element.
     IRBuilder<> IRB(VecLoad);
     Value *Loaded = UndefValue::get(LoadedVecTy);
     Value *Base =
         IRB.CreateBitCast(VecLoad->getPointerOperand(), ElemTy->getPointerTo());
 
     for (unsigned Elem = 0, NumElems = LoadedVecTy->getNumElements();
          Elem != NumElems; ++Elem) {
       unsigned Align = MinAlign(BaseAlign, ElemAllocSize * Elem);
-      Value *GEP = IRB.CreateConstInBoundsGEP1_32(Base, Elem);
+      Value *GEP = IRB.CreateConstInBoundsGEP1_32(ElemTy, Base, Elem);
       LoadInst *LoadedElem =
           IRB.CreateAlignedLoad(GEP, Align, VecLoad->isVolatile());
       LoadedElem->setSynchScope(VecLoad->getSynchScope());
       Loaded = IRB.CreateInsertElement(
           Loaded, LoadedElem,
           ConstantInt::get(Type::getInt32Ty(M->getContext()), Elem));
     }
 
     VecLoad->replaceAllUsesWith(Loaded);
     VecLoad->eraseFromParent();
@@ skipping 12 matching lines @@
     unsigned ElemAllocSize = DL->getTypeAllocSize(ElemTy);
 
     // Fill in the vector element by element.
     IRBuilder<> IRB(VecStore);
     Value *Base = IRB.CreateBitCast(VecStore->getPointerOperand(),
                                     ElemTy->getPointerTo());
 
     for (unsigned Elem = 0, NumElems = StoredVecTy->getNumElements();
          Elem != NumElems; ++Elem) {
       unsigned Align = MinAlign(BaseAlign, ElemAllocSize * Elem);
-      Value *GEP = IRB.CreateConstInBoundsGEP1_32(Base, Elem);
+      Value *GEP = IRB.CreateConstInBoundsGEP1_32(ElemTy, Base, Elem);
       Value *ElemToStore = IRB.CreateExtractElement(
           StoredVec, ConstantInt::get(Type::getInt32Ty(M->getContext()), Elem));
       StoreInst *StoredElem = IRB.CreateAlignedStore(ElemToStore, GEP, Align,
                                                      VecStore->isVolatile());
       StoredElem->setSynchScope(VecStore->getSynchScope());
     }
 
     VecStore->eraseFromParent();
   }
 }
 
 bool FixVectorLoadStoreAlignment::runOnBasicBlock(BasicBlock &BB) {
   bool Changed = false;
   if (!DL)
-    DL = &getAnalysis<DataLayoutPass>().getDataLayout();
+    DL = &BB.getParent()->getParent()->getDataLayout();

[jvoung (off chromium), 2015/05/26 20:39:45]

could be getModule()

[Derek Schuff, 2015/05/26 22:01:32]

Done.

   Instructions Loads;
   Instructions Stores;
   visitVectorLoadStore(BB, Loads, Stores);
   if (!(Loads.empty() && Stores.empty())) {
     Changed = true;
     scalarizeVectorLoadStore(BB, Loads, Stores);
   }
   return Changed;
 }
 
 BasicBlockPass *llvm::createFixVectorLoadStoreAlignmentPass() {
   return new FixVectorLoadStoreAlignment();
 }