back out r101364, as it trips the linux nightlybot on some clang C++ tests

[oota-llvm.git] / lib / Transforms / IPO / IPConstantPropagation.cpp

diff --git a/lib/Transforms/IPO/IPConstantPropagation.cpp b/lib/Transforms/IPO/IPConstantPropagation.cpp
index 6ae8276d5247616f97f820b2ee09a2bf35706d32..df2456f9f2b7e59c981f3913f60883c9e4470e48 100644 (file)
--- a/lib/Transforms/IPO/IPConstantPropagation.cpp
+++ b/lib/Transforms/IPO/IPConstantPropagation.cpp
@@ -23,7 +23,6 @@
 #include "llvm/Pass.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Support/CallSite.h"
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/SmallVector.h"
 using namespace llvm;
@@ -34,7 +33,7 @@ STATISTIC(NumReturnValProped, "Number of return values turned into constants");
 namespace {
   /// IPCP - The interprocedural constant propagation pass
   ///
-  struct VISIBILITY_HIDDEN IPCP : public ModulePass {
+  struct IPCP : public ModulePass {
     static char ID; // Pass identification, replacement for typeid
     IPCP() : ModulePass(&ID) {}
 
@@ -86,13 +85,17 @@ bool IPCP::PropagateConstantsIntoArguments(Function &F) {
 
   unsigned NumNonconstant = 0;
   for (Value::use_iterator UI = F.use_begin(), E = F.use_end(); UI != E; ++UI) {
+    // Ignore blockaddress uses.
+    if (isa<BlockAddress>(*UI)) continue;
+    
     // Used by a non-instruction, or not the callee of a function, do not
     // transform.
-    if (UI.getOperandNo() != 0 ||
-        (!isa<CallInst>(*UI) && !isa<InvokeInst>(*UI)))
+    if (!isa<CallInst>(*UI) && !isa<InvokeInst>(*UI))
       return false;
     
     CallSite CS = CallSite::get(cast<Instruction>(*UI));
+    if (!CS.isCallee(UI))
+      return false;
 
     // Check out all of the potentially constant arguments.  Note that we don't
     // inspect varargs here.
@@ -128,7 +131,8 @@ bool IPCP::PropagateConstantsIntoArguments(Function &F) {
   Function::arg_iterator AI = F.arg_begin();
   for (unsigned i = 0, e = ArgumentConstants.size(); i != e; ++i, ++AI) {
     // Do we have a constant argument?
-    if (ArgumentConstants[i].second || AI->use_empty())
+    if (ArgumentConstants[i].second || AI->use_empty() ||
+        (AI->hasByValAttr() && !F.onlyReadsMemory()))
       continue;
   
     Value *V = ArgumentConstants[i].first;
@@ -150,14 +154,14 @@ bool IPCP::PropagateConstantsIntoArguments(Function &F) {
 // callers will be updated to use the value they pass in directly instead of
 // using the return value.
 bool IPCP::PropagateConstantReturn(Function &F) {
-  if (F.getReturnType() == Type::VoidTy)
+  if (F.getReturnType()->isVoidTy())
     return false; // No return value.
 
   // If this function could be overridden later in the link stage, we can't
   // propagate information about its results into callers.
   if (F.mayBeOverridden())
     return false;
-  
+    
   // Check to see if this function returns a constant.
   SmallVector<Value *,4> RetVals;
   const StructType *STy = dyn_cast<StructType>(F.getReturnType());
@@ -219,7 +223,7 @@ bool IPCP::PropagateConstantReturn(Function &F) {
 
     // Not a call instruction or a call instruction that's not calling F
     // directly?
-    if (!Call || UI.getOperandNo() != 0)
+    if (!Call || !CS.isCallee(UI))
       continue;
     
     // Call result not used?
@@ -240,15 +244,11 @@ bool IPCP::PropagateConstantReturn(Function &F) {
    
     for (Value::use_iterator I = Call->use_begin(), E = Call->use_end();
          I != E;) {
-      Instruction *Ins = dyn_cast<Instruction>(*I);
+      Instruction *Ins = cast<Instruction>(*I);
 
       // Increment now, so we can remove the use
       ++I;
 
-      // Not an instruction? Ignore
-      if (!Ins)
-        continue;
-
       // Find the index of the retval to replace with
       int index = -1;
       if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Ins))