Subzero: Refactor tracking of Defs and block-local Variables.

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the CfgNode class, including the complexities
@@ skipping 29 matching lines @@
 void CfgNode::appendInst(Inst *Inst) {
   if (InstPhi *Phi = llvm::dyn_cast<InstPhi>(Inst)) {
     if (!Insts.empty()) {
       Func->setError("Phi instruction added to the middle of a block");
       return;
     }
     Phis.push_back(Phi);
   } else {
     Insts.push_back(Inst);
   }
-  Inst->updateVars(this);
 }
 
 // Renumbers the non-deleted instructions in the node.  This needs to
 // be done in preparation for live range analysis.  The instruction
 // numbers in a block must be monotonically increasing.  The range of
 // instruction numbers in a block, from lowest to highest, must not
 // overlap with the range of any other block.
 void CfgNode::renumberInstructions() {
   for (PhiList::const_iterator I = Phis.begin(), E = Phis.end(); I != E; ++I) {
     (*I)->renumber(Func);
@@ skipping 24 matching lines @@
 // the new dest.  For example,
 //   a=phi(...)
 // changes to
 //   "a_phi=phi(...); a=a_phi".
 //
 // This is in preparation for part 2 which deletes the Phi
 // instructions and appends assignment instructions to predecessor
 // blocks.  Note that this transformation preserves SSA form.
 void CfgNode::placePhiLoads() {
   for (PhiList::iterator I = Phis.begin(), E = Phis.end(); I != E; ++I) {
-    Inst *Inst = (*I)->lower(Func, this);
+    Inst *Inst = (*I)->lower(Func);
     Insts.insert(Insts.begin(), Inst);
-    Inst->updateVars(this);
   }
 }
 
 // This does part 2 of Phi lowering.  For each Phi instruction at each
 // out-edge, create a corresponding assignment instruction, and add
 // all the assignments near the end of this block.  They need to be
 // added before any branch instruction, and also if the block ends
 // with a compare instruction followed by a branch instruction that we
 // may want to fuse, it's better to insert the new assignments before
 // the compare instruction. The tryOptimizedCmpxchgCmpBr() method
@@ skipping 98 matching lines @@
       // prefer each other for register allocation.
       if (Variable *Src = llvm::dyn_cast<Variable>(Operand)) {
         bool AllowOverlap = false;
         Dest->setPreferredRegister(Src, AllowOverlap);
         Src->setPreferredRegister(Dest, AllowOverlap);
       }
       if (CmpInstDest == Operand)
         Insts.insert(SafeInsertionPoint, NewInst);
       else
         Insts.insert(InsertionPoint, NewInst);
-      NewInst->updateVars(this);
     }
   }
 }
 
 // Deletes the phi instructions after the loads and stores are placed.
 void CfgNode::deletePhis() {
   for (PhiList::iterator I = Phis.begin(), E = Phis.end(); I != E; ++I) {
     (*I)->setDeleted();
   }
 }
@@ skipping 47 matching lines @@
 }
 
 void CfgNode::livenessLightweight() {
   SizeT NumVars = Func->getNumVariables();
   llvm::BitVector Live(NumVars);
   // Process regular instructions in reverse order.
   for (InstList::const_reverse_iterator I = Insts.rbegin(), E = Insts.rend();
        I != E; ++I) {
     if ((*I)->isDeleted())
       continue;
-    (*I)->livenessLightweight(Live);
+    (*I)->livenessLightweight(Func, Live);
   }
   for (PhiList::const_iterator I = Phis.begin(), E = Phis.end(); I != E; ++I) {
     if ((*I)->isDeleted())
       continue;
-    (*I)->livenessLightweight(Live);
+    (*I)->livenessLightweight(Func, Live);
   }
 }
 
 // Performs liveness analysis on the block.  Returns true if the
 // incoming liveness changed from before, false if it stayed the same.
 // (If it changes, the node's predecessors need to be processed
 // again.)
 bool CfgNode::liveness(Liveness *Liveness) {
   SizeT NumVars = Liveness->getNumVarsInNode(this);
   llvm::BitVector Live(NumVars);
@@ skipping 278 matching lines @@
          I != E; ++I) {
       if (I != OutEdges.begin())
         Str << ", ";
       Str << "%" << (*I)->getName();
     }
     Str << "\n";
   }
 }
 
 } // end of namespace Ice