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 1d65562f58d80bb4ce58651413376633a57d2105..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) {}
 
@@ -63,7 +62,7 @@ bool IPCP::runOnModule(Module &M) {
       if (!I->isDeclaration()) {
         // Delete any klingons.
         I->removeDeadConstantUsers();
-        if (I->hasInternalLinkage())
+        if (I->hasLocalLinkage())
           LocalChange |= PropagateConstantsIntoArguments(*I);
         Changed |= PropagateConstantReturn(*I);
       }
@@ -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());
@@ -170,10 +174,6 @@ bool IPCP::PropagateConstantReturn(Function &F) {
   unsigned NumNonConstant = 0;
   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
     if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {
-      // Return type does not match operand type, this is an old style multiple
-      // return
-      bool OldReturn = (F.getReturnType() != RI->getOperand(0)->getType());
-
       for (unsigned i = 0, e = RetVals.size(); i != e; ++i) {
         // Already found conflicting return values?
         Value *RV = RetVals[i];
@@ -182,7 +182,7 @@ bool IPCP::PropagateConstantReturn(Function &F) {
 
         // Find the returned value
         Value *V;
-        if (!STy || OldReturn)
+        if (!STy)
           V = RI->getOperand(i);
         else
           V = FindInsertedValue(RI->getOperand(0), i);
@@ -223,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?
@@ -244,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))