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

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph 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 Cfg class, including constant pool
@@ skipping 10 matching lines @@
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 Cfg::Cfg(GlobalContext *Ctx)
     : Ctx(Ctx), FunctionName(""), ReturnType(IceType_void),
       IsInternalLinkage(false), HasError(false), ErrorMessage(""), Entry(NULL),
       NextInstNumber(1), Live(NULL),
       Target(TargetLowering::createLowering(Ctx->getTargetArch(), this)),
-      CurrentNode(NULL) {}
+      VMetadata(new VariablesMetadata(this)), CurrentNode(NULL) {}
 
 Cfg::~Cfg() {}
 
 void Cfg::setError(const IceString &Message) {
   HasError = true;
   ErrorMessage = Message;
   Ctx->getStrDump() << "ICE translation error: " << ErrorMessage << "\n";
 }
 
 CfgNode *Cfg::makeNode(const IceString &Name) {
   SizeT LabelIndex = Nodes.size();
   CfgNode *Node = CfgNode::create(this, LabelIndex, Name);
   Nodes.push_back(Node);
   return Node;
 }
 
-Variable *Cfg::makeVariable(Type Ty, const CfgNode *Node,
-                            const IceString &Name) {
-  return makeVariable<Variable>(Ty, Node, Name);
+Variable *Cfg::makeVariable(Type Ty, const IceString &Name) {
+  return makeVariable<Variable>(Ty, Name);
 }
 
 void Cfg::addArg(Variable *Arg) {
-  Arg->setIsArg(this);
+  Arg->setIsArg();
   Args.push_back(Arg);
 }
 
 // Returns whether the stack frame layout has been computed yet.  This
 // is used for dumping the stack frame location of Variables.
 bool Cfg::hasComputedFrame() const { return getTarget()->hasComputedFrame(); }
 
 void Cfg::translate() {
   if (hasError())
     return;
@@ skipping 75 matching lines @@
     if (Node->getHasReturn())
       getTarget()->addEpilog(Node);
   }
 }
 
 // This is a lightweight version of live-range-end calculation.  Marks
 // the last use of only those variables whose definition and uses are
 // completely with a single block.  It is a quick single pass and
 // doesn't need to iterate until convergence.
 void Cfg::livenessLightweight() {
+  getVMetadata()->init();
   for (NodeList::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I) {
     (*I)->livenessLightweight();
   }
 }
 
 void Cfg::liveness(LivenessMode Mode) {
   Live.reset(new Liveness(this, Mode));
+  getVMetadata()->init();
   Live->init();
   // Initialize with all nodes needing to be processed.
   llvm::BitVector NeedToProcess(Nodes.size(), true);
   while (NeedToProcess.any()) {
     // Iterate in reverse topological order to speed up convergence.
     for (NodeList::reverse_iterator I = Nodes.rbegin(), E = Nodes.rend();
          I != E; ++I) {
       CfgNode *Node = *I;
       if (NeedToProcess[Node->getIndex()]) {
         NeedToProcess[Node->getIndex()] = false;
@@ skipping 187 matching lines @@
       Args[i]->dump(this);
     }
     Str << ") {\n";
   }
   resetCurrentNode();
   if (getContext()->isVerbose(IceV_Liveness)) {
     // Print summary info about variables
     for (VarList::const_iterator I = Variables.begin(), E = Variables.end();
          I != E; ++I) {
       Variable *Var = *I;
-      Str << "//"
-          << " multiblock=" << Var->isMultiblockLife() << " "
-          << " weight=" << Var->getWeight() << " ";
+      Str << "// multiblock=";
+      if (getVMetadata()->isTracked(Var))
+        Str << getVMetadata()->isMultiBlock(Var);
+      else
+        Str << "?";
+      Str << " weight=" << Var->getWeight() << " ";
       Var->dump(this);
       if (Variable *Pref = Var->getPreferredRegister()) {
         Str << " pref=";
         Pref->dump(this);
         if (Var->getRegisterOverlap())
           Str << ",overlap";
         Str << " ";
       }
       Str << " LIVE=" << Var->getLiveRange() << "\n";
     }
   }
   // Print each basic block
   for (NodeList::const_iterator I = Nodes.begin(), E = Nodes.end(); I != E;
        ++I) {
     (*I)->dump(this);
   }
   if (getContext()->isVerbose(IceV_Instructions)) {
     Str << "}\n";
   }
 }
 
 } // end of namespace Ice