Add comment; refactor; avoid pulling in DT if it's not used.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@93306 91177308-0d34-0410-b5e6-96231b3b80d8

lib/CodeGen/OptimizeExts.cpp

@@ -6,6 +6,16 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+//
+// This pass performs optimization of sign / zero extension instructions. It
+// may be extended to handle other instructions of similar property.
+//
+// On some targets, some instructions, e.g. X86 sign / zero extension, may
+// leave the source value in the lower part of the result. This pass will
+// replace (some) uses of the pre-extension value with uses of the sub-register
+// of the results.
+//
+//===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "ext-opt"
 #include "llvm/CodeGen/Passes.h"
@@ -40,9 +50,15 @@ namespace {
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.setPreservesCFG();
       MachineFunctionPass::getAnalysisUsage(AU);
+      if (Aggressive) {
         AU.addRequired<MachineDominatorTree>();
         AU.addPreserved<MachineDominatorTree>();
       }
+    }
+
+  private:
+    bool OptimizeInstr(MachineInstr *MI, MachineBasicBlock *MBB,
+                       SmallPtrSet<MachineInstr*, 8> &LocalMIs);
   };
 }
 
@@ -52,36 +68,29 @@ X("opt-exts", "Optimize sign / zero extensions");
 
 FunctionPass *llvm::createOptimizeExtsPass() { return new OptimizeExts(); }
 
-bool OptimizeExts::runOnMachineFunction(MachineFunction &MF) {
+/// OptimizeInstr - If instruction is a copy-like instruction, i.e. it reads
-  TM = &MF.getTarget();
+/// a single register and writes a single register and it does not modify
-  TII = TM->getInstrInfo();
+/// the source, and if the source value is preserved as a sub-register of
-  MRI = &MF.getRegInfo();
+/// the result, then replace all reachable uses of the source with the subreg
-  DT = &getAnalysis<MachineDominatorTree>();
+/// of the result.
-
+bool OptimizeExts::OptimizeInstr(MachineInstr *MI, MachineBasicBlock *MBB,
+                                 SmallPtrSet<MachineInstr*, 8> &LocalMIs) {
   bool Changed = false;
-
-  SmallPtrSet<MachineInstr*, 8> LocalMIs;
-  for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
-    MachineBasicBlock *MBB = &*I;
-    for (MachineBasicBlock::iterator MII = I->begin(), ME = I->end(); MII != ME;
-         ++MII) {
-      MachineInstr *MI = &*MII;
   LocalMIs.insert(MI);
 
   unsigned SrcReg, DstReg, SubIdx;
   if (TII->isCoalescableExtInstr(*MI, SrcReg, DstReg, SubIdx)) {
     if (TargetRegisterInfo::isPhysicalRegister(DstReg) ||
         TargetRegisterInfo::isPhysicalRegister(SrcReg))
-          continue;
+      return false;
 
     MachineRegisterInfo::use_iterator UI = MRI->use_begin(SrcReg);
     if (++UI == MRI->use_end())
       // No other uses.
-          continue;
+      return false;
 
     // Ok, the source has other uses. See if we can replace the other uses
     // with use of the result of the extension.
-        
     SmallPtrSet<MachineBasicBlock*, 4> ReachedBBs;
     UI = MRI->use_begin(DstReg);
     for (MachineRegisterInfo::use_iterator UE = MRI->use_end(); UI != UE;
@@ -89,7 +98,9 @@ bool OptimizeExts::runOnMachineFunction(MachineFunction &MF) {
       ReachedBBs.insert(UI->getParent());
 
     bool ExtendLife = true;
+    // Uses that are in the same BB of uses of the result of the instruction.
     SmallVector<MachineOperand*, 8> Uses;
+    // Uses that the result of the instruction can reach.
     SmallVector<MachineOperand*, 8> ExtendedUses;
 
     UI = MRI->use_begin(SrcReg);
@@ -142,6 +153,26 @@ bool OptimizeExts::runOnMachineFunction(MachineFunction &MF) {
       }
     }
   }
+
+  return Changed;
+}
+
+bool OptimizeExts::runOnMachineFunction(MachineFunction &MF) {
+  TM = &MF.getTarget();
+  TII = TM->getInstrInfo();
+  MRI = &MF.getRegInfo();
+  DT = Aggressive ? &getAnalysis<MachineDominatorTree>() : 0;
+
+  bool Changed = false;
+
+  SmallPtrSet<MachineInstr*, 8> LocalMIs;
+  for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
+    MachineBasicBlock *MBB = &*I;
+    LocalMIs.clear();
+    for (MachineBasicBlock::iterator MII = I->begin(), ME = I->end(); MII != ME;
+         ++MII) {
+      MachineInstr *MI = &*MII;
+      Changed |= OptimizeInstr(MI, MBB, LocalMIs);
     }
   }