Subzero: Pull the node name out of the node structure.

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
 // of instruction insertion and in-edge calculation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "assembler.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceInst.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
-CfgNode::CfgNode(Cfg *Func, SizeT LabelNumber, IceString Name)
-    : Func(Func), Number(LabelNumber), Name(Name), HasReturn(false),
+CfgNode::CfgNode(Cfg *Func, SizeT LabelNumber)
+    : Func(Func), Number(LabelNumber), NameIndex(-1), HasReturn(false),
       NeedsPlacement(false), InstCountEstimate(0) {}
 
 // Returns the name the node was created with.  If no name was given,
 // it synthesizes a (hopefully) unique name.
 IceString CfgNode::getName() const {
-  if (!Name.empty())
-    return Name;
+  if (NameIndex >= 0)
+    return Func->getNodeName(NameIndex);
   return "__" + std::to_string(getIndex());
 }
 
 // Adds an instruction to either the Phi list or the regular
 // instruction list.  Validates that all Phis are added before all
 // regular instructions.
 void CfgNode::appendInst(Inst *Inst) {
   ++InstCountEstimate;
   if (InstPhi *Phi = llvm::dyn_cast<InstPhi>(Inst)) {
     if (!Insts.empty()) {
@@ skipping 168 matching lines @@
 // terminator instruction.  If there are multiple edges from Pred to
 // this node, only one edge is split, and the particular choice of
 // edge is undefined.  This could happen with a switch instruction, or
 // a conditional branch that weirdly has both branches to the same
 // place.  TODO(stichnot,kschimpf): Figure out whether this is legal
 // in the LLVM IR or the PNaCl bitcode, and if so, we need to
 // establish a strong relationship among the ordering of Pred's
 // out-edge list, this node's in-edge list, and the Phi instruction's
 // operand list.
 CfgNode *CfgNode::splitIncomingEdge(CfgNode *Pred, SizeT EdgeIndex) {
-  CfgNode *NewNode =
-      Func->makeNode("split_" + Pred->getName() + "_" + getName() + "_" +
+  CfgNode *NewNode = Func->makeNode();
+  if (ALLOW_DUMP)
+    NewNode->setName("split_" + Pred->getName() + "_" + getName() + "_" +
                      std::to_string(EdgeIndex));
   // The new node is added to the end of the node list, and will later
   // need to be sorted into a reasonable topological order.
   NewNode->setNeedsPlacement(true);
   // Repoint Pred's out-edge.
   bool Found = false;
   for (auto I = Pred->OutEdges.begin(), E = Pred->OutEdges.end();
        !Found && I != E; ++I) {
     if (*I == this) {
       *I = NewNode;
@@ skipping 773 matching lines @@
       if (!First)
         Str << ", ";
       First = false;
       Str << "%" << I->getName();
     }
     Str << "\n";
   }
 }
 
 } // end of namespace Ice