webruby 0.2.4 → 0.2.5

data/modules/emscripten/src/relooper/Relooper.h

@@ -57,7 +57,7 @@ struct Block {
   BlockBranchMap ProcessedBranchesOut;
   BlockSet ProcessedBranchesIn;
   Shape *Parent; // The shape we are directly inside
-  int Id; // A unique identifier
+  int Id; // A unique identifier, defined when added to relooper
   const char *Code; // The string representation of the code in this block. Owning pointer (we copy the input)
   const char *BranchVar; // If we have more than one branch out, the variable whose value determines where we go
   bool IsCheckedMultipleEntry; // If true, we are a multiple entry, so reaching us requires setting the label variable
@@ -69,9 +69,6 @@ struct Block {
 
   // Prints out the instructions code and branchings
   void Render(bool InLoop);
-
-  // INTERNAL
-  static int IdCounter;
 };
 
 // Represents a structured control flow shape, one of
@@ -96,20 +93,22 @@ 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.
+  int Id; // A unique identifier. Used to identify loops, labels are Lx where x is the Id. Defined when added to relooper
   Shape *Next; // The shape that will appear in the code right after this one
   Shape *Natural; // The shape that control flow gets to naturally (if there is Next, then this is Next)
 
   enum ShapeType {
     Simple,
     Multiple,
-    Loop
+    Loop,
+    Emulated
   };
   ShapeType Type;
 
-  Shape(ShapeType TypeInit) : Id(Shape::IdCounter++), Next(NULL), Type(TypeInit) {}
+  Shape(ShapeType TypeInit) : Id(-1), Next(NULL), Type(TypeInit) {}
   virtual ~Shape() {}
 
   virtual void Render(bool InLoop) = 0;
@@ -118,9 +117,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; }
-
-  // INTERNAL
-  static int IdCounter;
+  static EmulatedShape *IsEmulated(Shape *It) { return It && It->Type == Emulated ? (EmulatedShape*)It : NULL; }
 };
 
 struct SimpleShape : public Shape {
@@ -162,12 +159,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 +184,9 @@ struct Relooper {
   std::deque<Block*> Blocks;
   std::deque<Shape*> Shapes;
   Shape *Root;
+  bool Emulate;
+  int BlockIdCounter;
+  int ShapeIdCounter;
 
   Relooper();
   ~Relooper();
@@ -204,6 +207,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;

data/modules/emscripten/src/relooper/fuzzer.py

@@ -87,6 +87,12 @@ int main() {
   Relooper r;
 '''
 
+  if random.random() < 0.1:
+    print 'emulate'
+    fast += '''
+  r.SetEmulate(true);
+'''
+
   for i in range(num):
     fast += '''  r.AddBlock(b%d);
 ''' % i

data/modules/emscripten/src/relooper/test.cpp

@@ -258,5 +258,33 @@ int main() {
 
     puts(buffer);
   }
+
+  if (1) {
+    Relooper::SetOutputBuffer(buffer, sizeof(buffer));
+
+    printf("\n\n-- If pattern, emulated --\n\n", "the_var");
+
+    Block *b_a = new Block("// block A\n", NULL);
+    Block *b_b = new Block("// block B\n", "b_check()");
+    Block *b_c = new Block("// block C\n", NULL);
+
+    b_a->AddBranchTo(b_b, "check == 10", "atob();");
+    b_a->AddBranchTo(b_c, NULL, "atoc();");
+
+    b_b->AddBranchTo(b_c, "case 17:", "btoc();");
+    b_b->AddBranchTo(b_a, NULL, NULL);
+
+    Relooper r;
+    r.SetEmulate(true);
+    r.AddBlock(b_a);
+    r.AddBlock(b_b);
+    r.AddBlock(b_c);
+
+    r.Calculate(b_a);
+    printf("\n\n", "the_var");
+    r.Render();
+
+    puts(buffer);
+  }
 }
 

data/modules/emscripten/src/relooper/test.txt

@@ -4,23 +4,23 @@
 
 
 
-// block A
-switch (the_var) {
-check == 10 {
- atob();
- // block B
+ // block A
  switch (the_var) {
+ check == 10 {
+  atob();
+  // block B
+  switch (the_var) {
+  default: {
+   btoc();
+  }
+  }
+  break;
+ }
  default: {
-  btoc();
+  atoc();
  }
  }
- break;
-}
-default: {
- atoc();
-}
-}
-// block C
+ // block C
 
 
 
@@ -28,25 +28,25 @@ default: {
 
 
 
-// block A
-switch (the_var) {
-check == 15 {
- // block B
+ // block A
  switch (the_var) {
- default: {
- }
+ check == 15 {
+  // block B
+  switch (the_var) {
+  default: {
+  }
+  }
+  break;
  }
- break;
-}
-default: {
- // block C
- switch (the_var) {
  default: {
+  // block C
+  switch (the_var) {
+  default: {
+  }
+  }
  }
  }
-}
-}
-// block D
+ // block D
 
 
 
@@ -54,81 +54,81 @@ default: {
 
 
 
-L9: while(1) {
- // block A
- var check = maybe();
- switch (the_var) {
- default: {
- }
- }
- // block B
- switch (the_var) {
- check == 41 {
-  break;
- }
- default: {
-  break L9;
- }
+ L0: while(1) {
+  // block A
+  var check = maybe();
+  switch (the_var) {
+  default: {
+  }
+  }
+  // block B
+  switch (the_var) {
+  check == 41 {
+   break;
+  }
+  default: {
+   break L0;
+  }
+  }
  }
-}
-// block C
+ // block C
 
 
 
 -- Loop with phi to head 
 
-// code 1
-switch (the_var) {
-default: {
- var $i_0 = 0;var $x_0 = 5; 
-}
-}
-L14: while(1) {
- // code 2
+ // code 1
  switch (the_var) {
- $2 {
-  break;
- }
  default: {
-  var $x_1 = $x_0; 
-  label = 18;
-  break L14;
+  var $i_0 = 0;var $x_0 = 5; 
+ }
+ }
+ L1: while(1) {
+  // code 2
+  switch (the_var) {
+  $2 {
+   break;
+  }
+  default: {
+   var $x_1 = $x_0; 
+   label = -1;
+   break L1;
+  }
+  }
+  // code 3
+  switch (the_var) {
+  $6 {
+   break L1;
+   break;
+  }
+  default: {
+   var $i_0 = $7;var $x_0 = $5; 
+  }
+  }
  }
+ if (label == -1) {
+  // code 7
  }
- // code 3
+ // code 4
  switch (the_var) {
- $6 {
-  break L14;
+ $10 {
+  // code 5
+  switch (the_var) {
+  default: {
+  }
+  }
   break;
  }
  default: {
-  var $i_0 = $7;var $x_0 = $5; 
  }
  }
-}
-if (label == 18) {
- // code 7
-}
-// code 4
-switch (the_var) {
-$10 {
- // code 5
+ // code 6
  switch (the_var) {
  default: {
+  var $x_1 = $13; 
  }
  }
- break;
-}
-default: {
-}
-}
-// code 6
-switch (the_var) {
-default: {
- var $x_1 = $13; 
-}
-}
-// code 7
+ // code 7
 
 
 
@@ -136,30 +136,30 @@ default: {
 
 
 
-// block A...................................................................................................
-switch (the_var) {
-chak() {
- atob();
- // block B...................................................................................................
+ // block A...................................................................................................
  switch (the_var) {
- default: {
-  btod();
- }
+ chak() {
+  atob();
+  // block B...................................................................................................
+  switch (the_var) {
+  default: {
+   btod();
+  }
+  }
+  // block D
+  break;
  }
- // block D
- break;
-}
-default: {
- atoc();
- // block C...................................................................................................
- switch (the_var) {
  default: {
-  ctod2();
+  atoc();
+  // block C...................................................................................................
+  switch (the_var) {
+  default: {
+   ctod2();
+  }
+  }
+  // block D
  }
  }
- // block D
-}
-}
 
 
 
@@ -167,27 +167,27 @@ default: {
 
 
 
-// block A
-switch (the_var) {
-check == 10 {
- break;
-}
-default: {
- return C;
-}
-}
-while(1) {
- // block B
+ // block A
  switch (the_var) {
- default: {
- }
+ check == 10 {
+  break;
  }
- // block D
- switch (the_var) {
  default: {
+  return C;
  }
  }
-}
+ while(1) {
+  // block B
+  switch (the_var) {
+  default: {
+  }
+  }
+  // block D
+  switch (the_var) {
+  default: {
+  }
+  }
+ }
 
 
 
@@ -195,51 +195,51 @@ while(1) {
 
 
 
-// block A
-L37: do {
- switch (the_var) {
- expensive() {
-  label = 33;
-  break;
- }
- default: {
-  // block B
+ // block A
+ L1: do {
   switch (the_var) {
-  expensive2() {
-   label = 33;
-   break L37;
+  expensive() {
+   label = 3;
    break;
   }
   default: {
+   // block B
+   switch (the_var) {
+   expensive2() {
+    label = 3;
+    break L1;
+    break;
+   }
+   default: {
+   }
+   }
+   // block D
+   switch (the_var) {
+   default: {
+   }
+   }
   }
   }
-  // block D
+ } while(0);
+ if (label == 3) {
+  // block C;
   switch (the_var) {
   default: {
   }
   }
  }
+ while(1) {
+  // block E
+  switch (the_var) {
+  default: {
+  }
+  }
+  // block F
+  switch (the_var) {
+  default: {
+  }
+  }
  }
-} while(0);
-if (label == 33) {
- // block C;
- switch (the_var) {
- default: {
- }
- }
-}
-while(1) {
- // block E
- switch (the_var) {
- default: {
- }
- }
- // block F
- switch (the_var) {
- default: {
- }
- }
-}
 
 
 
@@ -247,26 +247,71 @@ while(1) {
 
 
 
-// block A
-L46: do {
- switch (the_var) {
- shouldLoop() {
-  while(1) {
-   // block B
-   switch (the_var) {
-   moarLoop() {
+ // block A
+ L1: do {
+  switch (the_var) {
+  shouldLoop() {
+   while(1) {
+    // block B
+    switch (the_var) {
+    moarLoop() {
+     break;
+    }
+    default: {
+     break L1;
+    }
+    }
+   }
+   break;
+  }
+  default: {
+  }
+  }
+ } while(0);
+ // block C
+
+
+
+-- If pattern, emulated --
+
+
+
+ label = 1;
+ L0:  while(1) {
+  switch(label|0) {
+   case 3: {
+    // block C
     break;
    }
-   default: {
-    break L46;
+   case 1: {
+    // block A
+    if (check == 10) {
+     atob();
+     label = 2;
+     continue L0;
+    } else {
+     atoc();
+     label = 3;
+     continue L0;
+    }
+    break;
    }
+   case 2: {
+    // block B
+    switch (b_check()) {
+    case 17: {
+     btoc();
+     label = 3;
+     continue L0;
+     break;
+    }
+    default: {
+     label = 1;
+     continue L0;
+    }
+    }
+    break;
    }
   }
-  break;
- }
- default: {
- }
  }
-} while(0);
-// block C
 

data/modules/emscripten/src/relooper/test2.txt

@@ -1,26 +1,26 @@
-ep
-L1: do {
- switch (var) {
- ep -> LBB1 {
-  LBB1
-  switch (the_var) {
-  LBB1 -> LBB2 {
+ ep
+ L1: do {
+  switch (var) {
+  ep -> LBB1 {
+   LBB1
+   switch (the_var) {
+   LBB1 -> LBB2 {
+    break;
+   }
+   default: {
+    break L1;
+   }
+   }
+   LBB2
+   switch (the_var) {
+   default: {
+   }
+   }
    break;
   }
   default: {
-   break L1;
   }
   }
-  LBB2
-  switch (the_var) {
-  default: {
-  }
-  }
-  break;
- }
- default: {
- }
- }
-} while(0);
-LBB3
+ } while(0);
+ LBB3