[SSAUpdater] Avoid scanning basic blocks to find instruction order.

llvm/lib/Transforms/Utils/SSAUpdater.cpp

@@ -432,26 +432,30 @@ void LoadAndStorePromoter::run(const SmallVectorImpl<Instruction *> &Insts) {
       }
     }
 
-    // If so, we can queue them all as live in loads.  We don't have an
-    // efficient way to tell which on is first in the block and don't want to
-    // scan large blocks, so just add all loads as live ins.
+    // If so, we can queue them all as live in loads.
     if (!HasStore) {
       for (Instruction *I : BlockUses)
         LiveInLoads.push_back(cast<LoadInst>(I));
       BlockUses.clear();
       continue;
     }
 
+    // Sort all of the interesting instructions in the block so that we don't
+    // have to scan a large block just to find a few instructions.
+    std::sort(BlockUses.begin(), BlockUses.end(),
+              [](Instruction *A, Instruction *B) { return A->comesBefore(B); });
+
     // Otherwise, we have mixed loads and stores (or just a bunch of stores).
     // Since SSAUpdater is purely for cross-block values, we need to determine
     // the order of these instructions in the block.  If the first use in the
     // block is a load, then it uses the live in value.  The last store defines
-    // the live out value.  We handle this by doing a linear scan of the block.
+    // the live out value.
     Value *StoredValue = nullptr;
-    for (Instruction &I : *BB) {
-      if (LoadInst *L = dyn_cast<LoadInst>(&I)) {
+    for (Instruction *I : BlockUses) {
+      if (LoadInst *L = dyn_cast<LoadInst>(I)) {
         // If this is a load from an unrelated pointer, ignore it.
-        if (!isInstInList(L, Insts)) continue;
+        if (!isInstInList(L, Insts))
+          continue;
 
         // If we haven't seen a store yet, this is a live in use, otherwise
         // use the stored value.
@@ -465,14 +469,15 @@ void LoadAndStorePromoter::run(const SmallVectorImpl<Instruction *> &Insts) {
         continue;
       }
 
-      if (StoreInst *SI = dyn_cast<StoreInst>(&I)) {
+      if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
         // If this is a store to an unrelated pointer, ignore it.
-        if (!isInstInList(SI, Insts)) continue;
+        if (!isInstInList(SI, Insts))
+          continue;
         updateDebugInfo(SI);
 
         // Remember that this is the active value in the block.
         StoredValue = SI->getOperand(0);
-      } else if (auto *AI = dyn_cast<AllocaInst>(&I)) {
+      } else if (auto *AI = dyn_cast<AllocaInst>(I)) {
         // Check if this an alloca, in which case we treat it as a store of
         // getValueToUseForAlloca.
         if (!isInstInList(AI, Insts))