Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/ExpandStructRegs.cpp

 //===- ExpandStructRegs.cpp - Expand out variables with struct type--------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass expands out some uses of LLVM variables
@@ skipping 25 matching lines @@
 //    padding fields are not defined anyway.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/NaCl.h"
 
 #define DEBUG_TYPE "expand-struct-regs"
 
 using namespace llvm;
 
 namespace {
@@ skipping 88 matching lines @@
         Select);
   }
   Select->replaceAllUsesWith(NewStruct);
   Select->eraseFromParent();
 
   return NeedsAnotherPass;
 }
 
 template <class InstType>
 static void ProcessLoadOrStoreAttrs(InstType *Dest, InstType *Src,
-                                    StructType* STy, const unsigned Index) {
+                                    StructType* STy, const unsigned Index,
+                                    const DataLayout *DL) {
   CopyDebug(Dest, Src);
   Dest->setVolatile(Src->isVolatile());
   if (Src->isAtomic()) {
     errs() << "Use: " << *Src << "\n";
     report_fatal_error("Atomic struct loads/stores not supported");
   }
 
   if (!Src->getAlignment()) {
     return;
   }
 
-  const DataLayout *DL = Src->getParent()->getDataLayout();
-  if (!DL) {
-    report_fatal_error("Need DataLayout");
-  }
   const StructLayout *SL = DL->getStructLayout(STy);
   const unsigned Alignment = Src->getAlignment();
   Dest->setAlignment(MinAlign(Alignment, SL->getElementOffset(Index)));
 }
 
-static bool SplitUpStore(StoreInst *Store) {
+static bool SplitUpStore(StoreInst *Store, const DataLayout *DL) {
   StructType *STy = cast<StructType>(Store->getValueOperand()->getType());
 
   bool NeedsAnotherPass = false;
   // Create a separate store instruction for each struct field.
   for (unsigned Index = 0; Index < STy->getNumElements(); ++Index) {
     SmallVector<Value *, 2> Indexes;
     Indexes.push_back(ConstantInt::get(Store->getContext(), APInt(32, 0)));
     Indexes.push_back(ConstantInt::get(Store->getContext(), APInt(32, Index)));
     Value *GEP =
         CopyDebug(GetElementPtrInst::Create(
+                      STy,
                       Store->getPointerOperand(), Indexes,
                       Store->getPointerOperand()->getName() + ".index", Store),
                   Store);
     NeedsAnotherPass =
         NeedsAnotherPass || DoAnotherPass(GEP->getType()->getContainedType(0));
 
     SmallVector<unsigned, 1> EVIndexes;
     EVIndexes.push_back(Index);
     Value *Field = ExtractValueInst::Create(Store->getValueOperand(), EVIndexes,
                                             "", Store);
     StoreInst *NewStore = new StoreInst(Field, GEP, Store);
-    ProcessLoadOrStoreAttrs(NewStore, Store, STy, Index);
+    ProcessLoadOrStoreAttrs(NewStore, Store, STy, Index, DL);
   }
   Store->eraseFromParent();
 
   return NeedsAnotherPass;
 }
 
-static bool SplitUpLoad(LoadInst *Load) {
+static bool SplitUpLoad(LoadInst *Load, const DataLayout *DL) {
   StructType *STy = cast<StructType>(Load->getType());
   Value *NewStruct = UndefValue::get(STy);
 
   bool NeedsAnotherPass = false;
   // Create a separate load instruction for each struct field.
   for (unsigned Index = 0; Index < STy->getNumElements(); ++Index) {
     SmallVector<Value *, 2> Indexes;
     Indexes.push_back(ConstantInt::get(Load->getContext(), APInt(32, 0)));
     Indexes.push_back(ConstantInt::get(Load->getContext(), APInt(32, Index)));
     Value *GEP =
-        CopyDebug(GetElementPtrInst::Create(Load->getPointerOperand(), Indexes,
+        CopyDebug(GetElementPtrInst::Create(STy,
+                                            Load->getPointerOperand(), Indexes,
                                             Load->getName() + ".index", Load),
                   Load);
     LoadInst *NewLoad = new LoadInst(GEP, Load->getName() + ".field", Load);
 
     NeedsAnotherPass = NeedsAnotherPass || DoAnotherPass(NewLoad);
-    ProcessLoadOrStoreAttrs(NewLoad, Load, STy, Index);
+    ProcessLoadOrStoreAttrs(NewLoad, Load, STy, Index, DL);
 
     // Reconstruct the struct value.
     SmallVector<unsigned, 1> EVIndexes;
     EVIndexes.push_back(Index);
     NewStruct =
         CopyDebug(InsertValueInst::Create(NewStruct, NewLoad, EVIndexes,
                                           Load->getName() + ".insert", Load),
                   Load);
   }
   Load->replaceAllUsesWith(NewStruct);
@@ skipping 186 matching lines @@
   for (Instruction *I : ToErase) {
     I->eraseFromParent();
   }
 
   return Changed;
 }
 
 bool ExpandStructRegs::runOnFunction(Function &Func) {
   bool Changed = false;
   bool NeedsAnotherPass;
+  const DataLayout *DL = &Func.getParent()->getDataLayout();
 
   do {
     NeedsAnotherPass = false;
     // Split up aggregate loads, stores and phi nodes into operations on
     // scalar types.  This inserts extractvalue and insertvalue
     // instructions which we will expand out later.
     for (Function::iterator BB = Func.begin(), E = Func.end(); BB != E; ++BB) {
       for (BasicBlock::iterator Iter = BB->begin(), E = BB->end(); Iter != E;) {
         Instruction *Inst = Iter++;
         if (StoreInst *Store = dyn_cast<StoreInst>(Inst)) {
           if (Store->getValueOperand()->getType()->isStructTy()) {
-            NeedsAnotherPass |= SplitUpStore(Store);
+            NeedsAnotherPass |= SplitUpStore(Store, DL);
             Changed = true;
           }
         } else if (LoadInst *Load = dyn_cast<LoadInst>(Inst)) {
           if (Load->getType()->isStructTy()) {
-            NeedsAnotherPass |= SplitUpLoad(Load);
+            NeedsAnotherPass |= SplitUpLoad(Load, DL);
             Changed = true;
           }
         } else if (PHINode *Phi = dyn_cast<PHINode>(Inst)) {
           if (Phi->getType()->isStructTy()) {
             NeedsAnotherPass |= SplitUpPHINode(Phi);
             Changed = true;
           }
         } else if (SelectInst *Select = dyn_cast<SelectInst>(Inst)) {
           if (Select->getType()->isStructTy()) {
             NeedsAnotherPass |= SplitUpSelect(Select);
             Changed = true;
           }
         }
       }
     }
   } while (NeedsAnotherPass);
 
   Changed |= ExpandExtractValues(Func);
 
   return Changed;
 }
 
 FunctionPass *llvm::createExpandStructRegsPass() {
   return new ExpandStructRegs();
 }