Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/BackendCanonicalize.cpp

 //===- BackendCanonicalize.cpp --------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Clean up some toolchain-side PNaCl ABI simplification passes. These passes
@@ skipping 18 matching lines @@
 
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/InstVisitor.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"
 
 using namespace llvm;
 
 // =============================================================================
 // TODO(jfb) The following functions are as-is from instcombine. Make them
 //           reusable instead.
 
 /// CollectSingleShuffleElements - If V is a shuffle of values that ONLY returns
@@ skipping 168 matching lines @@
 namespace {
 
 class BackendCanonicalize : public FunctionPass,
                             public InstVisitor<BackendCanonicalize, bool> {
 public:
   static char ID; // Pass identification, replacement for typeid
   BackendCanonicalize() : FunctionPass(ID), DL(0), TLI(0) {
     initializeBackendCanonicalizePass(*PassRegistry::getPassRegistry());
   }
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<DataLayoutPass>();
-    AU.addRequired<TargetLibraryInfo>();
+    AU.addRequired<TargetLibraryInfoWrapperPass>();
     FunctionPass::getAnalysisUsage(AU);
   }
 
   virtual bool runOnFunction(Function &F);
 
   // InstVisitor implementation. Unhandled instructions stay as-is.
   bool visitInstruction(Instruction &I) { return false; }
   bool visitInsertElementInst(InsertElementInst &IE);
   bool visitBitCastInst(BitCastInst &C);
   bool visitLoadInst(LoadInst &L);
@@ skipping 15 matching lines @@
 };
 
 } // anonymous namespace
 
 char BackendCanonicalize::ID = 0;
 INITIALIZE_PASS(BackendCanonicalize, "backend-canonicalize",
                 "Canonicalize PNaCl bitcode for LLVM backends", false, false)
 
 bool BackendCanonicalize::runOnFunction(Function &F) {
   bool Modified = false;
-  DL = &getAnalysis<DataLayoutPass>().getDataLayout();
-  TLI = &getAnalysis<TargetLibraryInfo>();
+  DL = &F.getParent()->getDataLayout();
+  TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
 
   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI)
     for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
       Modified |= visit(&*BI);
   emptyKillList(Kill);
   return Modified;
 }
 
 // This function is *almost* as-is from instcombine, avoiding silly
 // cases that should already have been optimized.
@@ skipping 59 matching lines @@
 
 bool BackendCanonicalize::visitBitCastInst(BitCastInst &B) {
   return visitConstantFoldableInstruction(&B);
 }
 
 bool BackendCanonicalize::visitLoadInst(LoadInst &L) {
   return visitConstantFoldableInstruction(&L);
 }
 
 bool BackendCanonicalize::visitConstantFoldableInstruction(Instruction *I) {
-  if (Constant *Folded = ConstantFoldInstruction(I, DL, TLI)) {
+  if (Constant *Folded = ConstantFoldInstruction(I, *DL, TLI)) {
     I->replaceAllUsesWith(Folded);
     Kill.push_back(I);
     return true;
   }
   return false;
 }
 
 void BackendCanonicalize::emptyKillList(KillList &Kill) {
   while (!Kill.empty())
     RecursivelyDeleteTriviallyDeadInstructions(Kill.pop_back_val());
 }
 
 FunctionPass *llvm::createBackendCanonicalizePass() {
   return new BackendCanonicalize();
 }