Subzero: Cleanly implement register allocation after phi lowering.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 128 matching lines @@
     return this;
   Variable *V = new (getCurrentCfgAllocator()->Allocate<Variable>())
       Variable(kVariable, Ty, Number);
   V->NameIndex = NameIndex;
   V->RegNum = RegNum;
   V->StackOffset = StackOffset;
   return V;
 }
 
 void VariableTracking::markUse(MetadataKind TrackingKind, const Inst *Instr,
-                               const CfgNode *Node, bool IsFromDef,
-                               bool IsImplicit) {
+                               CfgNode *Node, bool IsImplicit) {
   (void)TrackingKind;
   if (MultiBlock == MBS_MultiBlock)
     return;
   // TODO(stichnot): If the use occurs as a source operand in the
   // first instruction of the block, and its definition is in this
   // block's only predecessor, we might consider not marking this as a
   // separate use.  This may also apply if it's the first instruction
   // of the block that actually uses a Variable.
   assert(Node);
   bool MakeMulti = false;
   if (IsImplicit)
     MakeMulti = true;
   // A phi source variable conservatively needs to be marked as
   // multi-block, even if its definition is in the same block.  This
   // is because there can be additional control flow before branching
   // back to this node, and the variable is live throughout those
   // nodes.
-  if (!IsFromDef && Instr && llvm::isa<InstPhi>(Instr))
+  if (Instr && llvm::isa<InstPhi>(Instr))
     MakeMulti = true;
 
   if (!MakeMulti) {
     switch (MultiBlock) {
     case MBS_Unknown:
       MultiBlock = MBS_SingleBlock;
       SingleUseNode = Node;
       break;
     case MBS_SingleBlock:
       if (SingleUseNode != Node)
         MakeMulti = true;
       break;
     case MBS_MultiBlock:
       break;
     }
   }
 
   if (MakeMulti) {
     MultiBlock = MBS_MultiBlock;
     SingleUseNode = nullptr;
   }
 }
 
 void VariableTracking::markDef(MetadataKind TrackingKind, const Inst *Instr,
-                               const CfgNode *Node) {
+                               CfgNode *Node) {
   // TODO(stichnot): If the definition occurs in the last instruction
   // of the block, consider not marking this as a separate use.  But
   // be careful not to omit all uses of the variable if markDef() and
   // markUse() both use this optimization.
   assert(Node);
 // Verify that instructions are added in increasing order.
 #ifndef NDEBUG
   if (TrackingKind == VMK_All) {
     const Inst *LastInstruction =
         Definitions.empty() ? FirstOrSingleDefinition : Definitions.back();
     assert(LastInstruction == nullptr ||
            Instr->getNumber() >= LastInstruction->getNumber());
   }
 #endif
-  const bool IsFromDef = true;
-  const bool IsImplicit = false;
-  markUse(TrackingKind, Instr, Node, IsFromDef, IsImplicit);
+  constexpr bool IsImplicit = false;
+  markUse(TrackingKind, Instr, Node, IsImplicit);
   if (TrackingKind == VMK_Uses)
     return;
   if (FirstOrSingleDefinition == nullptr)
     FirstOrSingleDefinition = Instr;
   else if (TrackingKind == VMK_All)
     Definitions.push_back(Instr);
   switch (MultiDef) {
   case MDS_Unknown:
     assert(SingleDefNode == nullptr);
     MultiDef = MDS_SingleDef;
@@ skipping 48 matching lines @@
 }
 
 void VariablesMetadata::init(MetadataKind TrackingKind) {
   TimerMarker T(TimerStack::TT_vmetadata, Func);
   Kind = TrackingKind;
   Metadata.clear();
   Metadata.resize(Func->getNumVariables());
 
   // Mark implicit args as being used in the entry node.
   for (Variable *Var : Func->getImplicitArgs()) {
-    const Inst *NoInst = nullptr;
-    const CfgNode *EntryNode = Func->getEntryNode();
-    const bool IsFromDef = false;
-    const bool IsImplicit = true;
-    Metadata[Var->getIndex()].markUse(Kind, NoInst, EntryNode, IsFromDef,
-                                      IsImplicit);
+    constexpr Inst *NoInst = nullptr;
+    CfgNode *EntryNode = Func->getEntryNode();
+    constexpr bool IsImplicit = true;
+    Metadata[Var->getIndex()].markUse(Kind, NoInst, EntryNode, IsImplicit);
   }
 
   for (CfgNode *Node : Func->getNodes())
     addNode(Node);
 }
 
 void VariablesMetadata::addNode(CfgNode *Node) {
   if (Func->getNumVariables() >= Metadata.size())
     Metadata.resize(Func->getNumVariables());
 
   for (Inst &I : Node->getPhis()) {
     if (I.isDeleted())
       continue;
     if (Variable *Dest = I.getDest()) {
       SizeT DestNum = Dest->getIndex();
       assert(DestNum < Metadata.size());
       Metadata[DestNum].markDef(Kind, &I, Node);
     }
     for (SizeT SrcNum = 0; SrcNum < I.getSrcSize(); ++SrcNum) {
       if (const Variable *Var = llvm::dyn_cast<Variable>(I.getSrc(SrcNum))) {
         SizeT VarNum = Var->getIndex();
         assert(VarNum < Metadata.size());
-        const bool IsFromDef = false;
-        const bool IsImplicit = false;
-        Metadata[VarNum].markUse(Kind, &I, Node, IsFromDef, IsImplicit);
+        constexpr bool IsImplicit = false;
+        Metadata[VarNum].markUse(Kind, &I, Node, IsImplicit);
       }
     }
   }
 
   for (Inst &I : Node->getInsts()) {
     if (I.isDeleted())
       continue;
     // Note: The implicit definitions (and uses) from InstFakeKill are
     // deliberately ignored.
     if (Variable *Dest = I.getDest()) {
       SizeT DestNum = Dest->getIndex();
       assert(DestNum < Metadata.size());
       Metadata[DestNum].markDef(Kind, &I, Node);
     }
     for (SizeT SrcNum = 0; SrcNum < I.getSrcSize(); ++SrcNum) {
       Operand *Src = I.getSrc(SrcNum);
       SizeT NumVars = Src->getNumVars();
       for (SizeT J = 0; J < NumVars; ++J) {
         const Variable *Var = Src->getVar(J);
         SizeT VarNum = Var->getIndex();
         assert(VarNum < Metadata.size());
-        const bool IsFromDef = false;
-        const bool IsImplicit = false;
-        Metadata[VarNum].markUse(Kind, &I, Node, IsFromDef, IsImplicit);
+        constexpr bool IsImplicit = false;
+        Metadata[VarNum].markUse(Kind, &I, Node, IsImplicit);
       }
     }
   }
 }
 
 bool VariablesMetadata::isMultiDef(const Variable *Var) const {
   assert(Kind != VMK_Uses);
   if (Var->getIsArg())
     return false;
   if (!isTracked(Var))
@@ skipping 31 matching lines @@
 
 const InstDefList &
 VariablesMetadata::getLatterDefinitions(const Variable *Var) const {
   assert(Kind == VMK_All);
   if (!isTracked(Var))
     return NoDefinitions;
   SizeT VarNum = Var->getIndex();
   return Metadata[VarNum].getLatterDefinitions();
 }
 
-const CfgNode *VariablesMetadata::getLocalUseNode(const Variable *Var) const {
+CfgNode *VariablesMetadata::getLocalUseNode(const Variable *Var) const {
   if (!isTracked(Var))
     return nullptr; // conservative answer
   SizeT VarNum = Var->getIndex();
   return Metadata[VarNum].getNode();
 }
 
 const InstDefList VariablesMetadata::NoDefinitions;
 
 // ======================== dump routines ======================== //
 
@@ skipping 113 matching lines @@
   if (getType() != IceType_i32 && getType() != IceType_i16 &&
       getType() != IceType_i8)
     return false;
   // The Following checks if the signed representation of Value is between
   // -Threshold/2 and +Threshold/2
   bool largerThanThreshold = Threshold / 2 + Value >= Threshold;
   return largerThanThreshold;
 }
 
 } // end of namespace Ice