ScalarRepl does not modify the CFG. Say so!

[oota-llvm.git] / lib / Transforms / Scalar / ScalarReplAggregates.cpp

diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index dc2d6864f13b6a4c5c75398ed2e95ba293ab5a7a..864f8764aa528bf700b7c9c4f6a06fc9846ed148 100644 (file)
--- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp
+++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
@@ -13,8 +13,9 @@
 #include "llvm/iMemory.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Constants.h"
-#include "Support/StringExtras.h"
+#include "Support/Debug.h"
 #include "Support/Statistic.h"
+#include "Support/StringExtras.h"
 
 namespace {
   Statistic<> NumReplaced("scalarrepl", "Number of alloca's broken up");
@@ -22,9 +23,14 @@ namespace {
   struct SROA : public FunctionPass {
     bool runOnFunction(Function &F);
 
+    // getAnalysisUsage - This pass does not require any passes, but we know it
+    // will not alter the CFG, so say so.
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.setPreservesCFG();
+    }
+
   private:
-    bool isSafeStructElementUse(Value *Ptr);
-    bool isSafeArrayElementUse(Value *Ptr);
+    bool isSafeElementUse(Value *Ptr);
     bool isSafeUseOfAllocation(Instruction *User);
     bool isSafeStructAllocaToPromote(AllocationInst *AI);
     bool isSafeArrayAllocaToPromote(AllocationInst *AI);
@@ -104,11 +110,7 @@ bool SROA::runOnFunction(Function &F) {
       Instruction *User = cast<Instruction>(*I);
       if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) {
         // We now know that the GEP is of the form: GEP <ptr>, 0, <cst>
-        uint64_t Idx;
-        if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(GEPI->getOperand(2)))
-          Idx = CSI->getValue();
-        else
-          Idx = cast<ConstantUInt>(GEPI->getOperand(2))->getValue();
+        uint64_t Idx = cast<ConstantInt>(GEPI->getOperand(2))->getRawValue();
         
         assert(Idx < ElementAllocas.size() && "Index out of range?");
         AllocaInst *AllocaToUse = ElementAllocas[Idx];
@@ -167,36 +169,10 @@ bool SROA::isSafeUseOfAllocation(Instruction *User) {
   return true;
 }
 
-/// isSafeStructElementUse - It is illegal in C to take the address of a
-/// structure sub-element, and then use pointer arithmetic to access other
-/// elements of the struct.  Despite the fact that this is illegal, some
-/// programs do this, so do at least a simple check to try to avoid breaking
-/// broken programs if possible.
-///
-bool SROA::isSafeStructElementUse(Value *Ptr) {
-  for (Value::use_iterator I = Ptr->use_begin(), E = Ptr->use_end();
-       I != E; ++I)
-    if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(*I)) {
-      if (GEP->getNumOperands() > 1) {
-        if (!isa<Constant>(GEP->getOperand(1)) ||
-            !cast<Constant>(GEP->getOperand(1))->isNullValue()) {
-          std::cerr << "WARNING: Undefined behavior found: " << *GEP
-                    << "   ... uses pointer arithmetic to access other struct "
-                    << "elements!\n";
-          return false;
-
-          return false;  // Using pointer arithmetic to navigate the array...
-        }
-      }
-    }
-
-  return true;
-}
-
-/// isSafeArrayElementUse - Check to see if this use is an allowed use for a
+/// isSafeElementUse - Check to see if this use is an allowed use for a
 /// getelementptr instruction of an array aggregate allocation.
 ///
-bool SROA::isSafeArrayElementUse(Value *Ptr) {
+bool SROA::isSafeElementUse(Value *Ptr) {
   for (Value::use_iterator I = Ptr->use_begin(), E = Ptr->use_end();
        I != E; ++I) {
     Instruction *User = cast<Instruction>(*I);
@@ -209,15 +185,8 @@ bool SROA::isSafeArrayElementUse(Value *Ptr) {
         if (!isa<Constant>(GEP->getOperand(1)) ||
             !cast<Constant>(GEP->getOperand(1))->isNullValue())
           return false;  // Using pointer arithmetic to navigate the array...
-        
-        // Check to see if there are any structure indexes involved in this GEP.
-        // If so, then we can safely break the array up until at least the
-        // structure.
-        for (unsigned i = 2, e = GEP->getNumOperands(); i != e; ++i)
-          if (GEP->getOperand(i)->getType()->isUnsigned())
-            break;
       }
-      return isSafeArrayElementUse(GEP);
+      return isSafeElementUse(GEP);
     }
     default:
       DEBUG(std::cerr << "  Transformation preventing inst: " << *User);
@@ -245,7 +214,7 @@ bool SROA::isSafeStructAllocaToPromote(AllocationInst *AI) {
 
     // Pedantic check to avoid breaking broken programs...
     if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(*I))
-      if (GEPI->getNumOperands() == 3 && !isSafeStructElementUse(GEPI))
+      if (GEPI->getNumOperands() == 3 && !isSafeElementUse(GEPI))
         return false;
   }
   return true;
@@ -285,7 +254,7 @@ bool SROA::isSafeArrayAllocaToPromote(AllocationInst *AI) {
       //   P = &A[0];  P = P + 1
       // is legal, and should prevent promotion.
       //
-      if (!isSafeArrayElementUse(GEPI)) {
+      if (!isSafeElementUse(GEPI)) {
         DEBUG(std::cerr << "Cannot transform: " << *AI
                         << "  due to uses of user: " << *GEPI);
         return false;