Fix translator handling of basic block indices.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 43 matching lines @@
   ErrorMessage = Message;
 }
 
 CfgNode *Cfg::makeNode() {
   SizeT LabelIndex = Nodes.size();
   CfgNode *Node = CfgNode::create(this, LabelIndex);
   Nodes.push_back(Node);
   return Node;
 }
 
+void Cfg::swapNodes(NodeList &NewNodes) {
+  Nodes.swap(NewNodes);
+  for (SizeT I = 0, NumNodes = getNumNodes(); I < NumNodes; ++I)
+    Nodes[I]->resetIndex(I);
+}
+
 void Cfg::addArg(Variable *Arg) {
   Arg->setIsArg();
   Args.push_back(Arg);
 }
 
 void Cfg::addImplicitArg(Variable *Arg) {
   Arg->setIsImplicitArg();
   ImplicitArgs.push_back(Arg);
 }
 
@@ skipping 277 matching lines @@
         ++PredPosition;
       Placed.insert(PredPosition, Node);
       PlaceIndex[Node->getIndex()] = PredPosition;
     } while (0);
 
     --PlaceIndex[Node->getIndex()];
     assert(*PlaceIndex[Node->getIndex()] == Node);
   }
 
   // Reorder Nodes according to the built-up lists.
-  SizeT OldSize = Nodes.size();
-  (void)OldSize;
-  Nodes.clear();
+  NodeList Reordered;
+  Reordered.reserve(Placed.size() + Unreachable.size());
   for (CfgNode *Node : Placed)
-    Nodes.push_back(Node);
+    Reordered.push_back(Node);
   for (CfgNode *Node : Unreachable)
-    Nodes.push_back(Node);
-  assert(Nodes.size() == OldSize);
+    Reordered.push_back(Node);
+  assert(getNumNodes() == Reordered.size());
+  swapNodes(Reordered);
 }
 
 namespace {
 void getRandomPostOrder(CfgNode *Node, llvm::BitVector &ToVisit,
                         Ice::NodeList &PostOrder,
                         Ice::RandomNumberGenerator *RNG) {
   assert(ToVisit[Node->getIndex()]);
   ToVisit[Node->getIndex()] = false;
   NodeList Outs = Node->getOutEdges();
   Ice::RandomShuffle(Outs.begin(), Outs.end(),
@@ skipping 14 matching lines @@
   NodeList Unreachable;
   llvm::BitVector ToVisit(Nodes.size(), true);
   // Traverse from entry node.
   getRandomPostOrder(getEntryNode(), ToVisit, ReversedReachable,
                      &Ctx->getRNG());
   // Collect the unreachable nodes.
   for (CfgNode *Node : Nodes)
     if (ToVisit[Node->getIndex()])
       Unreachable.push_back(Node);
   // Copy the layout list to the Nodes.
-  SizeT OldSize = Nodes.size();
-  (void)OldSize;
-  Nodes.clear();
+  NodeList Shuffled;
+  Shuffled.reserve(ReversedReachable.size() + Unreachable.size());
   for (CfgNode *Node : reverse_range(ReversedReachable))
-    Nodes.emplace_back(Node);
-  for (CfgNode *Node : Unreachable) {
-    Nodes.emplace_back(Node);
-  }
-  assert(Nodes.size() == OldSize);
+    Shuffled.push_back(Node);
+  for (CfgNode *Node : Unreachable)
+    Shuffled.push_back(Node);
+  assert(Nodes.size() == Shuffled.size());
+  swapNodes(Shuffled);
 
   dump("After basic block shuffling");
 }
 
 void Cfg::doArgLowering() {
   TimerMarker T(TimerStack::TT_doArgLowering, this);
   getTarget()->lowerArguments();
 }
 
 void Cfg::doAddressOpt() {
@@ skipping 334 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice