Subzero: Loop Invariant Code Motion

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 425 matching lines @@
   }
 
   genTargetHelperCalls();
   Func->dump("After target helper call insertion");
 
   // Merge Alloca instructions, and lay out the stack.
   static constexpr bool SortAndCombineAllocas = true;
   Func->processAllocas(SortAndCombineAllocas);
   Func->dump("After Alloca processing");
 
+  // Run this early so it can be used to focus optimizations on potentially hot
+  // code.
+  // TODO(stichnot,ascull): currently only used for regalloc not
+  // expensive high level optimizations which could be focused on potentially
+  // hot code.
+  Func->generateLoopInfo();
+  Func->dump("After loop analysis");
+  if (getFlags().getLoopInvariantCodeMotion()) {
+    Func->loopInvariantCodeMotion();
+    Func->dump("After LICM");
+  }
+
   if (getFlags().getEnableExperimental()) {
     Func->localCSE();
     Func->dump("After Local CSE");
   }
   if (getFlags().getEnableShortCircuit()) {
     Func->shortCircuitJumps();
     Func->dump("After Short Circuiting");
   }
 
   if (!getFlags().getEnablePhiEdgeSplit()) {
     // Lower Phi instructions.
     Func->placePhiLoads();
     if (Func->hasError())
       return;
     Func->placePhiStores();
     if (Func->hasError())
       return;
     Func->deletePhis();
     if (Func->hasError())
       return;
     Func->dump("After Phi lowering");
   }
 
-  // Run this early so it can be used to focus optimizations on potentially hot
-  // code.
-  // TODO(stichnot,ascull): currently only used for regalloc not
-  // expensive high level optimizations which could be focused on potentially
-  // hot code.
-  Func->computeLoopNestDepth();
-  Func->dump("After loop nest depth analysis");
-
   // Address mode optimization.
   Func->getVMetadata()->init(VMK_SingleDefs);
   Func->doAddressOpt();
   Func->materializeVectorShuffles();
 
   // Find read-modify-write opportunities. Do this after address mode
   // optimization so that doAddressOpt() doesn't need to be applied to RMW
   // instructions as well.
   findRMW();
   Func->dump("After RMW transform");
@@ skipping 4926 matching lines @@
 
   OptAddr NewAddr;
   NewAddr.Base = llvm::dyn_cast<Variable>(Addr);
   if (NewAddr.Base == nullptr)
     return nullptr;
 
   // If the Base has more than one use or is live across multiple blocks, then
   // don't go further. Alternatively (?), never consider a transformation that
   // would change a variable that is currently *not* live across basic block
   // boundaries into one that *is*.
-  if (Func->getVMetadata()->isMultiBlock(
-          NewAddr.Base) /* || Base->getUseCount() > 1*/)
-    return nullptr;
-
+  if (!getFlags().getLoopInvariantCodeMotion()) {
+    // Need multi block address opt when licm is enabled.
+    // Might make sense to restrict to current node and loop header.
+    if (Func->getVMetadata()->isMultiBlock(
+            NewAddr.Base) /* || Base->getUseCount() > 1*/)
+      return nullptr;
+  }
   AddressOptimizer AddrOpt(Func);
   const bool MockBounds = getFlags().getMockBoundsCheck();
   const Inst *Reason = nullptr;
   bool AddressWasOptimized = false;
   // The following unnamed struct identifies the address mode formation steps
   // that could potentially create an invalid memory operand (i.e., no free
   // slots for RebasePtr.) We add all those variables to this struct so that we
   // can use memset() to reset all members to false.
   struct {
     bool AssignBase = false;
@@ skipping 2595 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H