[llvm-commits] [llvm] r53591 - /llvm/trunk/lib/Transforms/IPO/DeadArgumentElimination.cpp

[Matthijs Kooijman]

Author: matthijs
Date: Tue Jul 15 03:45:12 2008
New Revision: 53591

URL: http://llvm.org/viewvc/llvm-project?rev=53591&view=rev
Log:
Move the deadargelim code for intrinsically alive functions into its own
method, to slightly simplify control flow.

Modified:
    llvm/trunk/lib/Transforms/IPO/DeadArgumentElimination.cpp

Modified: llvm/trunk/lib/Transforms/IPO/DeadArgumentElimination.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/DeadArgumentElimination.cpp?rev=53591&r1=53590&r2=53591&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/IPO/DeadArgumentElimination.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/DeadArgumentElimination.cpp Tue Jul 15 03:45:12 2008
@@ -133,6 +133,7 @@
     void MarkValue(const RetOrArg &RA, Liveness L,
                    const UseVector &MaybeLiveUses);
     void MarkLive(RetOrArg RA);
+    void MarkLive(const Function &F);
     bool RemoveDeadStuffFromFunction(Function *F);
     bool DeleteDeadVarargs(Function &Fn);
   };
@@ -397,7 +398,6 @@
 // well as arguments to functions which have their "address taken".
 //
 void DAE::SurveyFunction(Function &F) {
-  bool FunctionIntrinsicallyLive = false;
   unsigned RetCount = NumRetVals(&F);
   // Assume all return values are dead
   typedef SmallVector<Liveness, 5> RetVals;
@@ -414,14 +414,15 @@
       if (RI->getNumOperands() != 0 && RI->getOperand(0)->getType()
           != F.getFunctionType()->getReturnType()) {
         // We don't support old style multiple return values.
-        FunctionIntrinsicallyLive = true;
-        break;
+        MarkLive(F);
+        return;
       }
 
-  if (!F.hasInternalLinkage() && (!ShouldHackArguments() || F.isIntrinsic()))
-    FunctionIntrinsicallyLive = true;
+  if (!F.hasInternalLinkage() && (!ShouldHackArguments() || F.isIntrinsic())) {
+    MarkLive(F);
+    return;
+  }
 
-  if (!FunctionIntrinsicallyLive) {
     DOUT << "DAE - Inspecting callers for fn: " << F.getName() << "\n";
     // Keep track of the number of live retvals, so we can skip checks once all
     // of them turn out to be live.
@@ -432,16 +433,16 @@
       // If the function is PASSED IN as an argument, its address has been
       // taken.
       if (I.getOperandNo() != 0) {
-        FunctionIntrinsicallyLive = true;
-        break;
+        MarkLive(F);
+        return;
       }
 
       // If this use is anything other than a call site, the function is alive.
       CallSite CS = CallSite::get(*I);
       Instruction *TheCall = CS.getInstruction();
       if (!TheCall) {   // Not a direct call site?
-        FunctionIntrinsicallyLive = true;
-        break;
+        MarkLive(F);
+        return;
       }
 
       // If we end up here, we are looking at a direct call to our function.
@@ -480,19 +481,6 @@
         }
       }
     }
-  }
-  if (FunctionIntrinsicallyLive) {
-    DOUT << "DAE - Intrinsically live fn: " << F.getName() << "\n";
-    // Mark all arguments as live.
-    unsigned i = 0;
-    for (unsigned i = 0, e = F.arg_size(); i != e; ++i)
-      MarkLive(CreateArg(&F, i));
-    // Mark all return values as live.
-    i = 0;
-    for (unsigned i = 0; i != RetCount; ++i)
-      MarkLive(CreateRet(&F, i));
-    return;
-  }
 
   // Now we've inspected all callers, record the liveness of our return values.
   for (unsigned i = 0; i != RetCount; ++i)
@@ -535,6 +523,20 @@
   }
 }
 
+/// MarkLive - Mark the given Function as alive, meaning that it cannot be
+/// changed in any way. Additionally,
+/// mark any values that are used as this function's parameters or by its return
+/// values (according to Uses) live as well.
+void DAE::MarkLive(const Function &F) {
+    DOUT << "DAE - Intrinsically live fn: " << F.getName() << "\n";
+    // Mark all arguments as live.
+    for (unsigned i = 0, e = F.arg_size(); i != e; ++i)
+      MarkLive(CreateArg(&F, i));
+    // Mark all return values as live.
+    for (unsigned i = 0, e = NumRetVals(&F); i != e; ++i)
+      MarkLive(CreateRet(&F, i));
+}
+
 /// MarkLive - Mark the given return value or argument as live. Additionally,
 /// mark any values that are used by this value (according to Uses) live as
 /// well.