[llvm-commits] [llvm] r45178 - /llvm/trunk/lib/CodeGen/MachineLICM.cpp

[Bill Wendling]

Author: void
Date: Tue Dec 18 15:38:04 2007
New Revision: 45178

URL: http://llvm.org/viewvc/llvm-project?rev=45178&view=rev
Log:
Add debugging info. Use the newly created "hasUnmodelledSideEffects" method.

Modified:
    llvm/trunk/lib/CodeGen/MachineLICM.cpp

Modified: llvm/trunk/lib/CodeGen/MachineLICM.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineLICM.cpp?rev=45178&r1=45177&r2=45178&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/MachineLICM.cpp (original)
+++ llvm/trunk/lib/CodeGen/MachineLICM.cpp Tue Dec 18 15:38:04 2007
@@ -103,25 +103,6 @@
       return LI->getLoopFor(BB) != CurLoop;
     }
 
-    /// CanHoistInst - Checks that this instructions is one that can be hoisted
-    /// out of the loop. I.e., it has no side effects, isn't a control flow
-    /// instr, etc.
-    ///
-    bool CanHoistInst(MachineInstr &I) const {
-#ifndef NDEBUG
-      DEBUG({
-          DOUT << "--- Checking if we can hoist " << I << "\n";
-          if (I.getInstrDescriptor()->ImplicitUses)
-            DOUT << "  * Instruction has implicit uses.\n";
-          else if (!TII->isTriviallyReMaterializable(&I))
-            DOUT << "  * Instruction has side effects.\n";
-        });
-#endif
-      // Don't hoist if this instruction implicitly reads physical registers.
-      if (I.getInstrDescriptor()->ImplicitUses) return false;
-      return TII->isTriviallyReMaterializable(&I);
-    }
-
     /// IsLoopInvariantInst - Returns true if the instruction is loop
     /// invariant. I.e., all virtual register operands are defined outside of
     /// the loop, physical registers aren't accessed (explicitly or implicitly),
@@ -272,13 +253,46 @@
 /// instruction is hoistable.
 /// 
 bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
-  if (!CanHoistInst(I)) return false;
+  DEBUG({
+      DOUT << "--- Checking if we can hoist " << I;
+      if (I.getInstrDescriptor()->ImplicitUses) {
+        DOUT << "  * Instruction has implicit uses:\n";
+
+        const TargetMachine &TM = CurMF->getTarget();
+        const MRegisterInfo *MRI = TM.getRegisterInfo();
+        const unsigned *ImpUses = I.getInstrDescriptor()->ImplicitUses;
+
+        for (; *ImpUses; ++ImpUses)
+          DOUT << "      -> " << MRI->getName(*ImpUses) << "\n";
+      }
+
+      if (I.getInstrDescriptor()->ImplicitDefs) {
+        DOUT << "  * Instruction has implicit defines:\n";
+
+        const TargetMachine &TM = CurMF->getTarget();
+        const MRegisterInfo *MRI = TM.getRegisterInfo();
+        const unsigned *ImpDefs = I.getInstrDescriptor()->ImplicitDefs;
+
+        for (; *ImpDefs; ++ImpDefs)
+          DOUT << "      -> " << MRI->getName(*ImpDefs) << "\n";
+      }
+
+      if (TII->hasUnmodelledSideEffects(&I))
+        DOUT << "  * Instruction has side effects.\n";
+    });
+
+#if 0
+  // FIXME: Don't hoist if this instruction implicitly reads physical registers.
+  if (I.getInstrDescriptor()->ImplicitUses ||
+      I.getInstrDescriptor()->ImplicitDefs)
+    return false;
+#endif
 
   // The instruction is loop invariant if all of its operands are loop-invariant
   for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
     const MachineOperand &MO = I.getOperand(i);
 
-    if (!MO.isRegister() || !MO.isUse())
+    if (!(MO.isRegister() && MO.getReg() && MO.isUse()))
       continue;
 
     unsigned Reg = MO.getReg();
@@ -295,6 +309,9 @@
       return false;
   }
 
+  // Don't hoist something that has side effects.
+  if (TII->hasUnmodelledSideEffects(&I)) return false;
+
   // If we got this far, the instruction is loop invariant!
   return true;
 }