Move the deadargelim code for intrinsically alive functions into its own

[oota-llvm.git] / lib / Analysis / LoadValueNumbering.cpp

diff --git a/lib/Analysis/LoadValueNumbering.cpp b/lib/Analysis/LoadValueNumbering.cpp
index f1ade951f34b79e5f9e93dd276a340ef9a12a357..f99ebb4a83d3b50bdbef4a6c9d0105502d44e54e 100644 (file)
--- a/lib/Analysis/LoadValueNumbering.cpp
+++ b/lib/Analysis/LoadValueNumbering.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -82,14 +82,15 @@ namespace {
     void getCallEqualNumberNodes(CallInst *CI,
                                  std::vector<Value*> &RetVals) const;
   };
+}
 
-  char LoadVN::ID = 0;
-  // Register this pass...
-  RegisterPass<LoadVN> X("load-vn", "Load Value Numbering");
+char LoadVN::ID = 0;
+// Register this pass...
+static RegisterPass<LoadVN>
+X("load-vn", "Load Value Numbering", false, true);
 
-  // Declare that we implement the ValueNumbering interface
-  RegisterAnalysisGroup<ValueNumbering> Y(X);
-}
+// Declare that we implement the ValueNumbering interface
+static RegisterAnalysisGroup<ValueNumbering> Y(X);
 
 FunctionPass *llvm::createLoadValueNumberingPass() { return new LoadVN(); }
 
@@ -116,9 +117,9 @@ static bool isPathTransparentTo(BasicBlock *CurBlock, BasicBlock *Dom,
 
   // Check whether this block is known transparent or not.
   std::map<BasicBlock*, bool>::iterator TBI =
-    TransparentBlocks.lower_bound(CurBlock);
+    TransparentBlocks.find(CurBlock);
 
-  if (TBI == TransparentBlocks.end() || TBI->first != CurBlock) {
+  if (TBI == TransparentBlocks.end()) {
     // If this basic block can modify the memory location, then the path is not
     // transparent!
     if (AA.canBasicBlockModify(*CurBlock, Ptr, Size)) {
@@ -148,7 +149,7 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI,
   Function *CF = CI->getCalledFunction();
   if (CF == 0) return;  // Indirect call.
   AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
-  AliasAnalysis::ModRefBehavior MRB = AA.getModRefBehavior(CF, CI);
+  AliasAnalysis::ModRefBehavior MRB = AA.getModRefBehavior(CI);
   if (MRB != AliasAnalysis::DoesNotAccessMemory &&
       MRB != AliasAnalysis::OnlyReadsMemory)
     return;  // Nothing we can do for now.
@@ -157,10 +158,10 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI,
   // global.  In particular, we would prefer to have an argument or instruction
   // operand to chase the def-use chains of.
   Value *Op = CF;
-  for (unsigned i = 1, e = CI->getNumOperands(); i != e; ++i)
-    if (isa<Argument>(CI->getOperand(i)) ||
-        isa<Instruction>(CI->getOperand(i))) {
-      Op = CI->getOperand(i);
+  for (User::op_iterator i = CI->op_begin() + 1, e = CI->op_end(); i != e; ++i)
+    if (isa<Argument>(*i) ||
+        isa<Instruction>(*i)) {
+      Op = *i;
       break;
     }
 
@@ -175,8 +176,9 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI,
           C->getOperand(0) == CI->getOperand(0) &&
           C->getParent()->getParent() == CIFunc && C != CI) {
         bool AllOperandsEqual = true;
-        for (unsigned i = 1, e = CI->getNumOperands(); i != e; ++i)
-          if (C->getOperand(i) != CI->getOperand(i)) {
+        for (User::op_iterator i = CI->op_begin() + 1, j = C->op_begin() + 1,
+             e = CI->op_end(); i != e; ++i, ++j)
+          if (*j != *i) {
             AllOperandsEqual = false;
             break;
           }
@@ -227,8 +229,7 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI,
               CantEqual = true;
               break;
             } else if (CallInst *CI = dyn_cast<CallInst>(I)) {
-              if (CI->getCalledFunction() == 0 ||
-                  !AA.onlyReadsMemory(CI->getCalledFunction())) {
+              if (!AA.onlyReadsMemory(CI)) {
                 CantEqual = true;
                 break;
               }
@@ -293,7 +294,7 @@ void LoadVN::getEqualNumberNodes(Value *V,
   Function *F = LoadBB->getParent();
 
   // Find out how many bytes of memory are loaded by the load instruction...
-  unsigned LoadSize = getAnalysis<TargetData>().getTypeSize(LI->getType());
+  unsigned LoadSize = getAnalysis<TargetData>().getTypeStoreSize(LI->getType());
   AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
 
   // Figure out if the load is invalidated from the entry of the block it is in