[llvm-commits] [llvm] r40811 - /llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp

[Chris Lattner]

Author: lattner
Date: Fri Aug  3 21:32:22 2007
New Revision: 40811

URL: http://llvm.org/viewvc/llvm-project?rev=40811&view=rev
Log:
Three improvements:
  1. Check for revisiting a block before checking domination, which is faster.
  2. If the stored value isn't an instruction, we don't have to check for domination.
  3. If we have a value used in the same block more than once, make sure to remove the
     block from the UsingBlocks vector.  Not doing so forces us to go through the slow
     path for the alloca.

The combination of these improvements increases the number of allocas on the fastpath
from 8935 to 8982 on PR1432.  This speeds it up from 2.90s to 2.20s (31%)


Modified:
    llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp

Modified: llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp?rev=40811&r1=40810&r2=40811&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp Fri Aug  3 21:32:22 2007
@@ -532,17 +532,26 @@
 void PromoteMem2Reg::RewriteSingleStoreAlloca(AllocaInst *AI,
                                               AllocaInfo &Info) {
   StoreInst *OnlyStore = Info.OnlyStore;
+  bool StoringGlobalVal = !isa<Instruction>(OnlyStore->getOperand(0));
   
   // Be aware of loads before the store.
   SmallPtrSet<BasicBlock*, 32> ProcessedBlocks;
   for (unsigned i = 0, e = Info.UsingBlocks.size(); i != e; ++i) {
-    // If the store dominates the block and if we haven't processed it yet,
-    // do so now.
-    if (!dominates(OnlyStore->getParent(), Info.UsingBlocks[i]))
+    BasicBlock *UseBlock = Info.UsingBlocks[i];
+    
+    // If we already processed this block, don't reprocess it.
+    if (!ProcessedBlocks.insert(UseBlock)) {
+      Info.UsingBlocks[i] = Info.UsingBlocks.back();
+      Info.UsingBlocks.pop_back();
+      --i; --e;
       continue;
+    }
     
-    BasicBlock *UseBlock = Info.UsingBlocks[i];
-    if (!ProcessedBlocks.insert(UseBlock))
+    // If the store dominates the block and if we haven't processed it yet,
+    // do so now.  We can't handle the case where the store doesn't dominate a
+    // block because there may be a path between the store and the use, but we
+    // may need to insert phi nodes to handle dominance properly.
+    if (StoringGlobalVal || !dominates(OnlyStore->getParent(), UseBlock))
       continue;
     
     // If the use and store are in the same block, do a quick scan to
@@ -553,7 +562,8 @@
         if (isa<LoadInst>(I) && I->getOperand(0) == AI)
           break;
       }
-      if (&*I != OnlyStore) break;  // Do not handle this case.
+      if (&*I != OnlyStore)
+        break;  // Do not handle this alloca.
     }
     
     // Otherwise, if this is a different block or if all uses happen