Remove jumps over empty blocks.

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 241 matching lines @@
   // list.  This can invalidate iterators, so don't use an iterator.
   SizeT NumNodes = getNumNodes();
   for (SizeT I = 0; I < NumNodes; ++I)
     Nodes[I]->advancedPhiLowering();
 }
 
 // Find a reasonable placement for nodes that have not yet been
 // placed, while maintaining the same relative ordering among already
 // placed nodes.
 void Cfg::reorderNodes() {
+  // TODO(ascull): it would be nice if the switch tests were always followed
+  // by the default case to allow for fall through.
   typedef std::list<CfgNode *> PlacedList;
   PlacedList Placed;      // Nodes with relative placement locked down
   PlacedList Unreachable; // Unreachable nodes
   PlacedList::iterator NoPlace = Placed.end();
   // Keep track of where each node has been tentatively placed so that
   // we can manage insertions into the middle.
   std::vector<PlacedList::iterator> PlaceIndex(Nodes.size(), NoPlace);
   for (CfgNode *Node : Nodes) {
     // The "do ... while(0);" construct is to factor out the
     // --PlaceIndex and assert() statements before moving to the next
     // node.
     do {
+      if (Node != getEntryNode() && Node->getInEdges().empty()) {
+        // The node has essentially been deleted since it is not a
+        // successor of any other node.
+        Unreachable.push_back(Node);
+        PlaceIndex[Node->getIndex()] = Unreachable.end();
+        Node->setNeedsPlacement(false);
+        continue;
+      }
       if (!Node->needsPlacement()) {
         // Add to the end of the Placed list.
         Placed.push_back(Node);
         PlaceIndex[Node->getIndex()] = Placed.end();
         continue;
       }
       Node->setNeedsPlacement(false);
-      if (Node != getEntryNode() && Node->getInEdges().empty()) {
-        // The node has essentially been deleted since it is not a
-        // successor of any other node.
-        Unreachable.push_back(Node);
-        PlaceIndex[Node->getIndex()] = Unreachable.end();
-        continue;
-      }
       // Assume for now that the unplaced node is from edge-splitting
       // and therefore has 1 in-edge and 1 out-edge (actually, possibly
       // more than 1 in-edge if the predecessor node was contracted).
       // If this changes in the future, rethink the strategy.
       assert(Node->getInEdges().size() >= 1);
       assert(Node->getOutEdges().size() == 1);
 
       // If it's a (non-critical) edge where the successor has a single
       // in-edge, then place it before the successor.
       CfgNode *Succ = Node->getOutEdges().front();
@@ skipping 216 matching lines @@
   if (Ctx->getFlags().getDecorateAsm())
     return;
   for (CfgNode *Node : Nodes) {
     Node->contractIfEmpty();
   }
 }
 
 void Cfg::doBranchOpt() {
   TimerMarker T(TimerStack::TT_doBranchOpt, this);
   for (auto I = Nodes.begin(), E = Nodes.end(); I != E; ++I) {
-    auto NextNode = I;
-    ++NextNode;
+    auto NextNode = I + 1;
     (*I)->doBranchOpt(NextNode == E ? nullptr : *NextNode);
   }
 }
 
 // ======================== Dump routines ======================== //
 
 // emitTextHeader() is not target-specific (apart from what is
 // abstracted by the Assembler), so it is defined here rather than in
 // the target lowering class.
 void Cfg::emitTextHeader(const IceString &MangledName, GlobalContext *Ctx,
@@ skipping 83 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice