Be conservative if getresult operand is neither call nor invoke.

[oota-llvm.git] / lib / CodeGen / MachineLICM.cpp

diff --git a/lib/CodeGen/MachineLICM.cpp b/lib/CodeGen/MachineLICM.cpp
index 4ba63bc9b50aee8a3a79e02b0c6881b26e8bbf7b..ffcc02e3b8326f4e5e1d0b4aae55c7eee70b1d78 100644 (file)
--- a/lib/CodeGen/MachineLICM.cpp
+++ b/lib/CodeGen/MachineLICM.cpp
@@ -17,7 +17,7 @@
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
-#include "llvm/Target/MRegisterInfo.h"
+#include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/ADT/SmallVector.h"
@@ -28,14 +28,6 @@
 
 using namespace llvm;
 
-namespace {
-  // Hidden options to help debugging
-  cl::opt<bool>
-  PerformLICM("machine-licm",
-              cl::init(false), cl::Hidden,
-              cl::desc("Perform loop-invariant code motion on machine code"));
-}
-
 STATISTIC(NumHoisted, "Number of machine instructions hoisted out of loops");
 
 namespace {
@@ -58,12 +50,14 @@ namespace {
 
     virtual bool runOnMachineFunction(MachineFunction &MF);
 
-    /// FIXME: Loop preheaders?
-    ///
+    // FIXME: Loop preheaders?
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.setPreservesCFG();
       AU.addRequired<MachineLoopInfo>();
       AU.addRequired<MachineDominatorTree>();
+      AU.addPreserved<MachineLoopInfo>();
+      AU.addPreserved<MachineDominatorTree>();
+      MachineFunctionPass::getAnalysisUsage(AU);
     }
   private:
     /// VisitAllLoops - Visit all of the loops in depth first order and try to
@@ -124,6 +118,9 @@ namespace {
           if (ToMBB->getBasicBlock())
             DOUT << " to MachineBasicBlock "
                  << ToMBB->getBasicBlock()->getName();
+          if (FromMBB->getBasicBlock())
+            DOUT << " from MachineBasicBlock "
+                 << FromMBB->getBasicBlock()->getName();
           DOUT << "\n";
         });
 
@@ -166,8 +163,6 @@ FunctionPass *llvm::createMachineLICMPass() { return new MachineLICM(); }
 /// loop.
 ///
 bool MachineLICM::runOnMachineFunction(MachineFunction &MF) {
-  if (!PerformLICM) return false; // For debugging.
-
   DOUT << "******** Machine LICM ********\n";
 
   Changed = false;
@@ -230,43 +225,61 @@ void MachineLICM::HoistRegion(MachineDomTreeNode *N) {
 /// effects that aren't captured by the operands or other flags.
 /// 
 bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
+  const TargetInstrDesc &TID = I.getDesc();
+  
+  // Ignore stuff that we obviously can't hoist.
+  if (TID.mayStore() || TID.isCall() || TID.isReturn() || TID.isBranch() ||
+      TID.hasUnmodeledSideEffects())
+    return false;
+  
+  if (TID.mayLoad()) {
+    // Okay, this instruction does a load.  As a refinement, allow the target
+    // to decide whether the loaded value is actually a constant.  If so, we
+    // can actually use it as a load.
+    if (!TII->isInvariantLoad(&I)) {
+      // FIXME: we should be able to sink loads with no other side effects if
+      // there is nothing that can change memory from here until the end of
+      // block.  This is a trivial form of alias analysis.
+      return false;
+    }
+  }
+
   DEBUG({
       DOUT << "--- Checking if we can hoist " << I;
-      if (I.getInstrDescriptor()->ImplicitUses) {
+      if (I.getDesc().getImplicitUses()) {
         DOUT << "  * Instruction has implicit uses:\n";
 
-        const MRegisterInfo *MRI = TM->getRegisterInfo();
-        const unsigned *ImpUses = I.getInstrDescriptor()->ImplicitUses;
-
-        for (; *ImpUses; ++ImpUses)
-          DOUT << "      -> " << MRI->getName(*ImpUses) << "\n";
+        const TargetRegisterInfo *TRI = TM->getRegisterInfo();
+        for (const unsigned *ImpUses = I.getDesc().getImplicitUses();
+             *ImpUses; ++ImpUses)
+          DOUT << "      -> " << TRI->getName(*ImpUses) << "\n";
       }
 
-      if (I.getInstrDescriptor()->ImplicitDefs) {
+      if (I.getDesc().getImplicitDefs()) {
         DOUT << "  * Instruction has implicit defines:\n";
 
-        const MRegisterInfo *MRI = TM->getRegisterInfo();
-        const unsigned *ImpDefs = I.getInstrDescriptor()->ImplicitDefs;
-
-        for (; *ImpDefs; ++ImpDefs)
-          DOUT << "      -> " << MRI->getName(*ImpDefs) << "\n";
+        const TargetRegisterInfo *TRI = TM->getRegisterInfo();
+        for (const unsigned *ImpDefs = I.getDesc().getImplicitDefs();
+             *ImpDefs; ++ImpDefs)
+          DOUT << "      -> " << TRI->getName(*ImpDefs) << "\n";
       }
 
-      if (TII->hasUnmodelledSideEffects(&I))
-        DOUT << "  * Instruction has side effects.\n";
+        //if (TII->hasUnmodelledSideEffects(&I))
+        //DOUT << "  * Instruction has side effects.\n";
     });
 
   // 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.getReg() && MO.isUse()))
+    if (!MO.isRegister() || !MO.isUse())
       continue;
 
     unsigned Reg = MO.getReg();
+    if (Reg == 0) continue;
 
     // Don't hoist instructions that access physical registers.
-    if (!MRegisterInfo::isVirtualRegister(Reg))
+    if (TargetRegisterInfo::isPhysicalRegister(Reg))
       return false;
 
     assert(RegInfo->getVRegDef(Reg)&&"Machine instr not mapped for this vreg?");
@@ -277,9 +290,6 @@ bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
       return false;
   }
 
-  // Don't hoist something that has unmodelled side effects.
-  if (TII->hasUnmodelledSideEffects(&I)) return false;
-
   // If we got this far, the instruction is loop invariant!
   return true;
 }