Initial Subzero WASM prototype.

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 209 matching lines @@
 
   // The set of translation passes and their order are determined by the
   // target.
   getTarget()->translate();
 
   dump("Final output");
   if (getFocusedTiming())
     getContext()->dumpTimers();
 }
 
+void Cfg::fixPhiNodes() {
+  for (auto *Node : Nodes) {
+    // Fix all the phi edges since WASM can't tell how to make them correctly at
+    // the beginning.
+    assert(Node);
+    const auto InEdges = Node->getInEdges();

[Jim Stichnoth, 2016/03/29 17:49:57]

Should this be "const auto &" ?  I don't know.  getInEdges() returns a ref, and
I'm not sure whether you're accidentally making a copy here.

[Eric Holk, 2016/03/29 22:58:07]

Done.

+    for (auto &Inst : Node->getPhis()) {
+      auto Phi = llvm::cast<InstPhi>(&Inst);

[Jim Stichnoth, 2016/03/29 17:49:57]

auto *

[Eric Holk, 2016/03/29 22:58:07]

Done.

+      assert(Phi);
+      for (SizeT i = 0; i < InEdges.size(); ++i) {
+        Phi->setLabel(i, InEdges[i]);
+      }
+    }
+  }
+}
+
 void Cfg::computeInOutEdges() {
   // Compute the out-edges.
   for (CfgNode *Node : Nodes)
     Node->computeSuccessors();
 
   // Prune any unreachable nodes before computing in-edges.
   SizeT NumNodes = getNumNodes();
   BitVector Reachable(NumNodes);
   BitVector Pending(NumNodes);
   Pending.set(getEntryNode()->getIndex());
@@ skipping 137 matching lines @@
         Placed.push_back(Node);
         PlaceIndex[Node->getIndex()] = Placed.end();
         continue;
       }
       Node->setNeedsPlacement(false);
       // 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);
+      assert(Node->getOutEdges().size() == 1 ||
+             Node->getOutEdges()[0] == Node->getOutEdges()[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();
       if (Succ->getInEdges().size() == 1 &&
           PlaceIndex[Succ->getIndex()] != NoPlace) {
         Placed.insert(PlaceIndex[Succ->getIndex()], Node);
         PlaceIndex[Node->getIndex()] = PlaceIndex[Succ->getIndex()];
         continue;
       }
@@ skipping 737 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice