Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/ExpandI64.cpp

 //===- ExpandI64.cpp - Expand i64 and wider integer types -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===------------------------------------------------------------------===//
 //
 // This pass expands and lowers all operations on integers i64 and wider
@@ skipping 20 matching lines @@
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
-#include "llvm/Target/TargetLibraryInfo.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Transforms/NaCl.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <map>
 #include <vector>
 
 #include "llvm/Support/raw_ostream.h"
 
 #ifdef NDEBUG
 #undef assert
 #define assert(x) { if (!(x)) report_fatal_error(#x); }
@@ skipping 57 matching lines @@
 
   public:
     static char ID;
     ExpandI64() : ModulePass(ID) {
       initializeExpandI64Pass(*PassRegistry::getPassRegistry());
 
       Add = Sub = Mul = SDiv = UDiv = SRem = URem = LShr = AShr = Shl = GetHigh = SetHigh = NULL;
     }
 
     virtual bool runOnModule(Module &M);
-    virtual void getAnalysisUsage(AnalysisUsage &AU) const;
   };
 }
 
 char ExpandI64::ID = 0;
 INITIALIZE_PASS(ExpandI64, "expand-illegal-ints",
                 "Expand and lower illegal >i32 operations into 32-bit chunks",
                 false, false)
 
 // Utilities
 
@@ skipping 197 matching lines @@
       SmallVector<Value*, 2> NewOps;
       for (unsigned i = 1, e = I->getNumOperands(); i != e; ++i) {
         Value *Op = I->getOperand(i);
         if (isIllegal(Op->getType())) {
           // Truncate the operand down to one chunk.
           NewOps.push_back(getChunks(Op)[0]);
         } else {
           NewOps.push_back(Op);
         }
       }
-      Value *NewGEP = CopyDebug(GetElementPtrInst::Create(GEP->getPointerOperand(), NewOps, "", GEP), GEP);
+      Value *NewGEP = CopyDebug(GetElementPtrInst::Create(GEP->getPointerOperand()->getType(), GEP->getPointerOperand(), NewOps, "", GEP), GEP);
       Chunks.push_back(NewGEP);
       I->replaceAllUsesWith(NewGEP);
       break;
     }
     case Instruction::SExt: {
       ChunksVec InputChunks;
       Value *Op = I->getOperand(0);
       if (isIllegal(Op->getType())) {
         InputChunks = getChunks(Op);
       } else {
@@ skipping 247 matching lines @@
           // shifted the complement-fractional amount to the other side
           if (Comp != Zero && H != Zero) {
             if (Fraction == 0) {
               H = TopFiller;
             } else {
               H = CopyDebug(BinaryOperator::Create(Reverse, H, Comp, "", I), I);
             }
           }
 
           // Or the parts together. Since we may have zero, try to fold it away.
-          if (Value *V = SimplifyBinOp(Instruction::Or, L, H, DL)) {
+          if (Value *V = SimplifyBinOp(Instruction::Or, L, H, *DL)) {
             Chunks.push_back(V);
           } else {
             Chunks.push_back(CopyDebug(BinaryOperator::Create(Instruction::Or, L, H, "", I), I));
           }
         }
       }
       break;
     }
     case Instruction::ICmp: {
       ICmpInst *CE = cast<ICmpInst>(I);
@@ skipping 102 matching lines @@
     case Instruction::Or:
     case Instruction::Xor: {
       BinaryOperator *BO = cast<BinaryOperator>(I);
       ChunksVec LeftChunks = getChunks(BO->getOperand(0));
       ChunksVec RightChunks = getChunks(BO->getOperand(1));
       int Num = getNumChunks(BO->getType());
       for (int i = 0; i < Num; i++) {
         // If there's a constant operand, it's likely enough that one of the
         // chunks will be a trivial operation, so it's worth calling
         // SimplifyBinOp here.
-        if (Value *V = SimplifyBinOp(BO->getOpcode(), LeftChunks[i], RightChunks[i], DL)) {
+        if (Value *V = SimplifyBinOp(BO->getOpcode(), LeftChunks[i], RightChunks[i], *DL)) {
           Chunks.push_back(V);
         } else {
           Chunks.push_back(CopyDebug(BinaryOperator::Create(BO->getOpcode(), LeftChunks[i], RightChunks[i], "", BO), BO));
         }
       }
       break;
     }
     case Instruction::Call: {
       CallInst *CI = cast<CallInst>(I);
       Function *F = CI->getCalledFunction();
@@ skipping 209 matching lines @@
   if (isa<UndefValue>(V))
     return ChunksVec(Num, UndefValue::get(i32));
 
   if (Constant *C = dyn_cast<Constant>(V)) {
     ChunksVec Chunks;
     for (unsigned i = 0; i < Num; i++) {
       Constant *Count = ConstantInt::get(C->getType(), i * 32);
       Constant *NewC = ConstantExpr::getTrunc(ConstantExpr::getLShr(C, Count), i32);
       TargetLibraryInfo *TLI = 0; // TODO
       if (ConstantExpr *NewCE = dyn_cast<ConstantExpr>(NewC)) {
-        if (Constant *FoldedC = ConstantFoldConstantExpression(NewCE, DL, TLI)) {
+        if (Constant *FoldedC = ConstantFoldConstantExpression(NewCE, *DL, TLI)) {
           NewC = FoldedC;
         }
       }
 
       Chunks.push_back(NewC);
     }
     return Chunks;
   }
 
   if (Splits.find(V) == Splits.end()) {
@@ skipping 93 matching lines @@
                            "SItoD", TheModule);
   UItoD = Function::Create(ItoDFunc, GlobalValue::ExternalLinkage,
                            "UItoD", TheModule);
 
   BItoD = Function::Create(ItoDFunc, GlobalValue::ExternalLinkage,
                            "BItoD", TheModule);
 }
 
 bool ExpandI64::runOnModule(Module &M) {
   TheModule = &M;
-  DL = &getAnalysis<DataLayoutPass>().getDataLayout();
+  DL = &M.getDataLayout();
   Splits.clear();
   Changed = false;
 
   // pre pass - legalize functions
   for (Module::iterator Iter = M.begin(), E = M.end(); Iter != E; ) {
     Function *Func = Iter++;
     ensureLegalFunc(Func);
   }
 
   // first pass - split
@@ skipping 67 matching lines @@
   // post pass - clean up illegal functions that were legalized. We do this
   // after the full walk of the functions so that all uses are replaced first.
   for (Module::iterator Iter = M.begin(), E = M.end(); Iter != E; ) {
     Function *Func = Iter++;
     removeIllegalFunc(Func);
   }
 
   return Changed;
 }
 
-void ExpandI64::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequired<DataLayoutPass>();
-  ModulePass::getAnalysisUsage(AU);
-}
-
 ModulePass *llvm::createExpandI64Pass() {
   return new ExpandI64();
 }