optimized switch implementation

test/mjsunit/wasm/asm-wasm-switch.js

Index: test/mjsunit/wasm/asm-wasm-switch.js
diff --git a/test/mjsunit/wasm/asm-wasm-switch.js b/test/mjsunit/wasm/asm-wasm-switch.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea7a4f561f6dcb2d19e9849675f2c71617ec6c7a
--- /dev/null
+++ b/test/mjsunit/wasm/asm-wasm-switch.js
@@ -0,0 +1,401 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-wasm
+
+(function TestSwitch() {
+  function asmModule() {
+    "use asm"
+
+    function caller() {
+      var ret = 0;
+      var x = 7;
+      switch (x) {
+        case 1: return 0;
+        case 7: {
+          ret = 12;
+          break;
+        }
+        default: return 0;
+      }
+      switch (x) {
+        case 1: return 0;
+        case 8: return 0;
+        default: ret = (ret + 11)|0;
+      }
+      return ret|0;
+    }
+
+    return {caller:caller};
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(23, wasm.caller());
+})();
+
+(function TestSwitchFallthrough() {
+  function asmModule() {
+    "use asm"
+
+    function caller() {
+      var x = 17;
+      var ret = 0;
+      switch (x) {
+        case 17:
+        case 14: ret = 39;
+        case 1: ret = (ret + 3)|0;
+        case 4: break;
+        default: ret = (ret + 1)|0;
+      }
+      return ret|0;
+    }
+
+    return {caller:caller};
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(42, wasm.caller());
+})();
+
+(function TestNestedSwitch() {
+  function asmModule() {
+    "use asm"
+
+    function caller() {
+      var x = 3;
+      var y = -13;
+      switch (x) {
+        case 1: return 0;
+        case 3: {
+          switch (y) {
+            case 2: return 0;
+            case -13: return 43;
+            default: return 0;
+          }
+        }
+        default: return 0;
+      }
+      return 0;
+    }
+
+    return {caller:caller};
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(43, wasm.caller());
+})();
+
+(function TestSwitchWithDefaultOnly() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      switch(x|0) {
+        default: return -10;
+      }
+      return 0;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(-10, wasm.main(2));
+  assertEquals(-10, wasm.main(54));
+})();
+
+(function TestEmptySwitch() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      switch(x|0) {
+      }
+      return 73;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(73, wasm.main(7));
+})();
+
+(function TestSwitchWithBrTable() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      switch(x|0) {
+        case 14: return 14;
+        case 12: return 12;
+        case 15: return 15;
+        case 19: return 19;
+        case 18: return 18;
+        case 16: return 16;
+        default: return -1;
+      }
+      return 0;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(12, wasm.main(12));
+  assertEquals(14, wasm.main(14));
+  assertEquals(15, wasm.main(15));
+  assertEquals(16, wasm.main(16));
+  assertEquals(18, wasm.main(18));
+  assertEquals(19, wasm.main(19));
+  assertEquals(-1, wasm.main(-1));
+})();
+
+(function TestSwitchWithBalancedTree() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      switch(x|0) {
+        case 5: return 5;
+        case 1: return 1;
+        case 6: return 6;
+        case 9: return 9;
+        case -4: return -4;
+      }
+      return 0;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(-4, wasm.main(-4));
+  assertEquals(1, wasm.main(1));
+  assertEquals(5, wasm.main(5));
+  assertEquals(6, wasm.main(6));
+  assertEquals(9, wasm.main(9));
+  assertEquals(0, wasm.main(11));
+})();
+
+(function TestSwitchHybrid() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      switch(x|0) {
+        case 1: return 1;
+        case 2: return 2;
+        case 3: return 3;
+        case 4: return 4;
+        case 7: return 7;
+        case 10: return 10;
+        case 11: return 11;
+        case 12: return 12;
+        case 13: return 13;
+        case 16: return 16;
+        default: return -1;
+      }
+      return 0;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(1, wasm.main(1));
+  assertEquals(2, wasm.main(2));
+  assertEquals(3, wasm.main(3));
+  assertEquals(4, wasm.main(4));
+  assertEquals(7, wasm.main(7));
+  assertEquals(10, wasm.main(10));
+  assertEquals(11, wasm.main(11));
+  assertEquals(12, wasm.main(12));
+  assertEquals(13, wasm.main(13));
+  assertEquals(16, wasm.main(16));
+  assertEquals(-1, wasm.main(20));
+})();
+
+(function TestSwitchFallthroughWithBrTable() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      var ret = 0;
+      switch(x|0) {
+        case 1: {
+          ret = 1;
+          break;
+        }
+        case 2: {
+          ret = 2;
+          break;
+        }
+        case 3: {
+          ret = 3;
+        }
+        case 4: {
+          ret = 4;
+          break;
+        }
+        default: {
+          ret = 10;
+          break;
+        }
+      }
+      return ret|0;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(2, wasm.main(2));
+  assertEquals(10, wasm.main(10));
+  assertEquals(4, wasm.main(3));
+})();
+
+(function TestSwitchFallthroughHybrid() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      var ret = 0;
+      switch(x|0) {
+        case 1: {
+          ret = 1;
+          break;
+        }
+        case 2: {
+          ret = 2;
+          break;
+        }
+        case 3: {
+          ret = 3;
+          break;
+        }
+        case 4: {
+          ret = 4;
+        }
+        case 7: {
+          ret = 7;
+          break;
+        }
+        case 10: {
+          ret = 10;
+        }
+        case 16: {
+          ret = 16;
+          break;
+        }
+        case 17: {
+          ret = 17;
+          break;
+        }
+        case 18: {
+          ret = 18;
+          break;
+        }
+        case 19: {
+          ret = 19;
+        }
+        default: {
+          ret = -1;
+          break;
+        }
+      }
+      return ret|0;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(7, wasm.main(4));
+  assertEquals(16, wasm.main(10));
+  assertEquals(-1, wasm.main(19));
+  assertEquals(-1, wasm.main(23));
+})();
+
+(function TestSwitchHybridWithNoDefault() {
+  function asmModule() {
+    "use asm";
+    function main(x) {
+      x = x|0;
+      var ret = 19;
+      switch(x|0) {
+        case 1: {
+          ret = 1;
+          break;
+        }
+        case 2: {
+          ret = 2;
+          break;
+        }
+        case 3: {
+          ret = 3;
+          break;
+        }
+        case 4: {
+          ret = 4;
+          break;
+        }
+        case 7: {
+          ret = 7;
+          break;
+        }
+      }
+      return ret|0;
+    }
+    return {
+      main: main,
+    };
+  }
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  assertEquals(2, wasm.main(2));
+  assertEquals(7, wasm.main(7));
+  assertEquals(19, wasm.main(-1));
+})();
+
+(function TestLargeSwitchWithBrTable() {
+  var str = "function asmModule() {\
+    \"use asm\";\
+    function main(x) {\
+      x = x|0;\
+      switch(x|0) {";
+  for (var i = 0; i < 512; i++) {
+    str = str.concat("case ", i.toString(), ": return ", i.toString(), ";");

[bradn, 2016/04/07 23:46:59]

Can you set this and the one below it up as a function to call to get the module
(with a gap value between items?)
generateSwitchModule(gap, size);
Then test more than one size (maybe some non-powers of 2).

Then also add a parameter to it to emit something else at certain values.
generateSwitchModule(gap, size, handle_case)
That would be something like this normally:
generateSwitchModule(3, 512, function(i) { return 'return ' + i ';'; });
But could also be used like:
generateSwitchModule(3, 512, function(i) { if (i % 7 == 0) { return 'break;'; }
else { return 'return ' + i + ';';})

That way you can have tests that the right thing happens if you have breaks in
some of the cases or even fall thrus:
generateSwitchModule(3, 512, function(i) { if (i % 7 == 0) { return 'return ' +
i + ';'; } else { return ''; })

You might also want to have a value map function parameter instead of the gap:
generateSwitchModule(size, order_func, case_func)
i.e.
generateSwitchModule(512, function(i) { return i * 3; },
function(i) { return 'return ' + i + ';' })

Using the above check:
breaking every nth item.
fall thru for a large number of items.
conditionally breaking inside each case.
emitting a small switch inside each case.

[aseemgarg, 2016/04/11 20:59:19]

Added some cases that I think should stress the implementation (in terms of
properly using LEBs instead of single bytes).  These plus the other tests should
be covering most corner cases.

+  }
+  str = str.concat("default: return -1;\
+      }\
+      return -2;\
+    }\
+    return {main: main}; }");
+
+  var wasm = Wasm.instantiateModuleFromAsm(str);
+  for (var i = 0; i < 512; i++) {
+    assertEquals(i, wasm.main(i));
+  }
+  assertEquals(-1, wasm.main(-1));
+})();
+
+(function TestLargeSwitchWithBalancedTree() {
+  var str = "function asmModule() {\
+    \"use asm\";\
+    function main(x) {\
+      x = x|0;\
+      switch(x|0) {";
+  for (var i = 0; i < 512; i++) {
+    str = str.concat("case ", (3*i).toString(), ": return ", (3*i).toString(), ";");

[bradn, 2016/04/07 23:46:59]

use string concat to wrap this to 80 columns

[aseemgarg, 2016/04/11 20:59:19]

Done.

+  }
+  str = str.concat("default: return -1;\
+      }\
+      return -2;\
+    }\
+    return {main: main}; }");
+
+  var wasm = Wasm.instantiateModuleFromAsm(str);
+  for (var i = 0; i < 512; i++) {
+    assertEquals(3*i, wasm.main(3*i));
+  }
+  assertEquals(-1, wasm.main(2));
+  assertEquals(-1, wasm.main(-1));
+})();