3 files changed, 56 insertions, 13 deletions

diff --git a/lib/Target/CppBackend/CPPBackend.cpp b/lib/Target/CppBackend/CPPBackend.cpp
index 35f679185d..2b39b59613 100644
--- a/lib/Target/CppBackend/CPPBackend.cpp
+++ b/lib/Target/CppBackend/CPPBackend.cpp
@@ -288,6 +288,10 @@ namespace {
 
     void calculateNativizedVars(const Function *F);
 
+    // special analyses
+
+    bool canReloop(const Function *F);
+
     // main entry point
 
     void printModuleBody();
@@ -1143,6 +1147,7 @@ void JSWriter::printFunctionBody(const Function *F) {
   static char *buffer = new char[RELOOPER_BUFFER];
   Relooper::SetOutputBuffer(buffer, RELOOPER_BUFFER);
   Relooper R;
+  //if (!canReloop(F)) R.SetEmulate(true);
   R.SetAsmJSMode(1);
   Block *Entry = NULL;
   std::map<const BasicBlock*, Block*> LLVMToRelooper;
@@ -1688,6 +1693,12 @@ void JSWriter::calculateNativizedVars(const Function *F) {
   }
 }
 
+// special analyses
+
+bool JSWriter::canReloop(const Function *F) {
+  return true;
+}
+
 // main entry
 
 void JSWriter::printCommaSeparated(const HeapData data) {
diff --git a/lib/Target/CppBackend/Relooper.cpp b/lib/Target/CppBackend/Relooper.cpp
index d2a48f6356..fc7b3ea777 100644
--- a/lib/Target/CppBackend/Relooper.cpp
+++ b/lib/Target/CppBackend/Relooper.cpp
@@ -142,6 +142,7 @@ void Block::Render(bool InLoop) {
   if (!ProcessedBranchesOut.size()) return;
 
   bool SetLabel = true; // in some cases it is clear we can avoid setting label, see later
+  bool ForceSetLabel = Shape::IsEmulated(Parent);
 
   // A setting of the label variable (label = x) is necessary if it can
   // cause an impact. The main case is where we set label to x, then elsewhere
@@ -210,7 +211,7 @@ void Block::Render(bool InLoop) {
       Target = DefaultTarget;
       Details = ProcessedBranchesOut[DefaultTarget];
     }
-    bool SetCurrLabel = SetLabel && Target->IsCheckedMultipleEntry;
+    bool SetCurrLabel = (SetLabel && Target->IsCheckedMultipleEntry) || ForceSetLabel;
     bool HasFusedContent = Fused && contains(Fused->InnerMap, Target);
     bool HasContent = SetCurrLabel || Details->Type != Branch::Direct || HasFusedContent || Details->Code;
     if (iter != ProcessedBranchesOut.end()) {
@@ -330,16 +331,19 @@ void LoopShape::Render(bool InLoop) {
   if (Next) Next->Render(InLoop);
 };
 
-/*
 // EmulatedShape
 
 void EmulatedShape::Render(bool InLoop) {
+  PrintIndented("label = %d;\n", Entry->Id);
+  if (Labeled) {
+    PrintIndented("L%d: ", Id);
+  }
   PrintIndented("while(1) {\n");
   Indenter::Indent();
-  PrintIndented("switch(label) {\n");
+  PrintIndented("switch(label|0) {\n");
   Indenter::Indent();
-  for (int i = 0; i < Blocks.size(); i++) {
-    Block *Curr = Blocks[i];
+  for (BlockSet::iterator iter = Blocks.begin(); iter != Blocks.end(); iter++) {
+    Block *Curr = *iter;
     PrintIndented("case %d: {\n", Curr->Id);
     Indenter::Indent();
     Curr->Render(InLoop);
@@ -353,11 +357,10 @@ void EmulatedShape::Render(bool InLoop) {
   PrintIndented("}\n");
   if (Next) Next->Render(InLoop);
 };
-*/
 
 // Relooper
 
-Relooper::Relooper() : Root(NULL) {
+Relooper::Relooper() : Root(NULL), Emulate(false) {
 }
 
 Relooper::~Relooper() {
@@ -461,7 +464,7 @@ void Relooper::Calculate(Block *Entry) {
     }
   }
 
-  Pre.SplitDeadEnds();
+  if (!Emulate) Pre.SplitDeadEnds();
 
   // Recursively process the graph
 
@@ -526,6 +529,21 @@ void Relooper::Calculate(Block *Entry) {
       return Simple;
     }
 
+    Shape *MakeEmulated(BlockSet &Blocks, Block *Entry, BlockSet &NextEntries) {
+      PrintDebug("creating emulated block with entry #%d and everything it can reach, %d blocks\n", Entry->Id, Blocks.size());
+      EmulatedShape *Emulated = new EmulatedShape;
+      Notice(Emulated);
+      Emulated->Entry = Entry;
+      for (BlockSet::iterator iter = Blocks.begin(); iter != Blocks.end(); iter++) {
+        Block *Curr = *iter;
+        Emulated->Blocks.insert(Curr);
+        Curr->Parent = Emulated;
+        Solipsize(Curr, Branch::Continue, Emulated, Blocks);
+      }
+      Blocks.clear();
+      return Emulated;
+    }
+
     Shape *MakeLoop(BlockSet &Blocks, BlockSet& Entries, BlockSet &NextEntries) {
       // Find the inner blocks in this loop. Proceed backwards from the entries until
       // you reach a seen block, collecting as you go.
@@ -837,6 +855,9 @@ void Relooper::Calculate(Block *Entry) {
         if (Entries->size() == 0) return Ret;
         if (Entries->size() == 1) {
           Block *Curr = *(Entries->begin());
+          if (Parent->Emulate) {
+            Make(MakeEmulated(Blocks, Curr, *NextEntries));
+          }
           if (Curr->BranchesIn.size() == 0) {
             // One entry, no looping ==> Simple
             Make(MakeSimple(Blocks, Curr, *NextEntries));
@@ -844,6 +865,7 @@ void Relooper::Calculate(Block *Entry) {
           // One entry, looping ==> Loop
           Make(MakeLoop(Blocks, *Entries, *NextEntries));
         }
+
         // More than one entry, try to eliminate through a Multiple groups of
         // independent blocks from an entry/ies. It is important to remove through
         // multiples as opposed to looping since the former is more performant.
diff --git a/lib/Target/CppBackend/Relooper.h b/lib/Target/CppBackend/Relooper.h
index f3dedf8c0e..e78d18e713 100644
--- a/lib/Target/CppBackend/Relooper.h
+++ b/lib/Target/CppBackend/Relooper.h
@@ -96,6 +96,7 @@ class SimpleShape;
 class LabeledShape;
 class MultipleShape;
 class LoopShape;
+class EmulatedShape;
 
 struct Shape {
   int Id; // A unique identifier. Used to identify loops, labels are Lx where x is the Id.
@@ -105,7 +106,8 @@ struct Shape {
   enum ShapeType {
     Simple,
     Multiple,
-    Loop
+    Loop,
+    Emulated
   };
   ShapeType Type;
 
@@ -118,6 +120,7 @@ struct Shape {
   static MultipleShape *IsMultiple(Shape *It) { return It && It->Type == Multiple ? (MultipleShape*)It : NULL; }
   static LoopShape *IsLoop(Shape *It) { return It && It->Type == Loop ? (LoopShape*)It : NULL; }
   static LabeledShape *IsLabeled(Shape *It) { return IsMultiple(It) || IsLoop(It) ? (LabeledShape*)It : NULL; }
+  static EmulatedShape *IsEmulated(Shape *It) { return It && It->Type == Emulated ? (EmulatedShape*)It : NULL; }
 
   // INTERNAL
   static int IdCounter;
@@ -162,12 +165,15 @@ struct LoopShape : public LabeledShape {
   void Render(bool InLoop);
 };
 
-/*
-struct EmulatedShape : public Shape {
-  std::deque<Block*> Blocks;
+// TODO EmulatedShape is only partially functional. Currently it can be used for the
+//      entire set of blocks being relooped, but not subsets.
+struct EmulatedShape : public LabeledShape {
+  Block *Entry;
+  BlockSet Blocks;
+
+  EmulatedShape() : LabeledShape(Emulated) { Labeled = true; }
   void Render(bool InLoop);
 };
-*/
 
 // Implements the relooper algorithm for a function's blocks.
 //
@@ -184,6 +190,7 @@ struct Relooper {
   std::deque<Block*> Blocks;
   std::deque<Shape*> Shapes;
   Shape *Root;
+  bool Emulate;
 
   Relooper();
   ~Relooper();
@@ -204,6 +211,9 @@ struct Relooper {
 
   // Sets asm.js mode on or off (default is off)
   static void SetAsmJSMode(int On);
+
+  // Sets whether we must emulate everything with switch-loop code
+  void SetEmulate(int E) { Emulate = E; }
 };
 
 typedef std::map<Block*, BlockSet> BlockBlockSetMap;