[wasm] asm.js - Remove Wasm.instantiateModuleFromAsm, use asm.js directly.

test/mjsunit/wasm/asm-wasm.js

 // Copyright 2015 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
+// Flags: --validate-asm --allow-natives-syntax
 
 var stdlib = this;
 
+function assertValidAsm(func) {
+  assertTrue(%IsAsmWasmCode(func));
+}
+
 function assertWasm(expected, func, ffi) {
   print("Testing " + func.name + "...");
-  assertEquals(expected, Wasm.instantiateModuleFromAsm(
-      func.toString(), stdlib, ffi).caller());
+  assertEquals(
+      expected, func(stdlib, ffi, new ArrayBuffer(1024)).caller());
+  assertValidAsm(func);
 }
 
-function EmptyTest() {
+function EmptyTest(a, b, c) {
   "use asm";
   function caller() {
     empty();
     return 11;
   }
   function empty() {
   }
   return {caller: caller};
 }
 
 assertWasm(11, EmptyTest);
 
-function VoidReturnTest() {
+function VoidReturnTest(a, b, c) {
   "use asm";
   function caller() {
     empty();
     return 19;
   }
   function empty() {
     var x = 0;
     if (x) return;
   }
   return {caller: caller};
 }
 
 assertWasm(19, VoidReturnTest);
 
-function IntTest() {
+function IntTest(a, b, c) {
   "use asm";
   function sum(a, b) {
     a = a|0;
     b = b|0;
     var c = 0;
     var d = 3.0;
     var e = 0;
     e = ~~d;  // double conversion
     c = (b + 1)|0
     return (a + c + 1)|0;
@@ skipping 45 matching lines @@
     return (a + c + 1)|0;
   }
 
   function caller() {
     return call(1, 2)|0;
   }
 
   return {caller: caller};
 }
 
-assertThrows(function() {
-  Wasm.instantiateModuleFromAsm(BadModule.toString(), stdlib).caller();
-});
+assertTrue(%IsNotAsmWasmCode(BadModule));
 
 
 function TestReturnInBlock() {
   "use asm";
 
   function caller() {
     if(1) {
       {
         {
           return 1;
@@ skipping 371 matching lines @@
 
   return {caller: caller};
 }
 
 assertWasm(7, TestInt32HeapAccess);
 
 
 function TestInt32HeapAccessExternal() {
   var memory = new ArrayBuffer(1024);
   var memory_int32 = new Int32Array(memory);
-  var module = Wasm.instantiateModuleFromAsm(
-      TestInt32HeapAccess.toString(), stdlib, null, memory);
+  var module_decl = eval('(' + TestInt32HeapAccess.toString() + ')');
+  var module = module_decl(stdlib, null, memory);
+  assertValidAsm(module_decl);
   assertEquals(7, module.caller());
   assertEquals(7, memory_int32[2]);
 }
 
 TestInt32HeapAccessExternal();
 
 
 function TestHeapAccessIntTypes() {
   var types = [
     [Int8Array, 'Int8Array', '>> 0'],
     [Uint8Array, 'Uint8Array', '>> 0'],
     [Int16Array, 'Int16Array', '>> 1'],
     [Uint16Array, 'Uint16Array', '>> 1'],
     [Int32Array, 'Int32Array', '>> 2'],
     [Uint32Array, 'Uint32Array', '>> 2'],
   ];
   for (var i = 0; i < types.length; i++) {
     var code = TestInt32HeapAccess.toString();
     code = code.replace('Int32Array', types[i][1]);
     code = code.replace(/>> 2/g, types[i][2]);
     var memory = new ArrayBuffer(1024);
     var memory_view = new types[i][0](memory);
-    var module = Wasm.instantiateModuleFromAsm(code, stdlib, null, memory);
+    var module_decl = eval('(' + code + ')');
+    var module = module_decl(stdlib, null, memory);
+    assertValidAsm(module_decl);
     assertEquals(7, module.caller());
     assertEquals(7, memory_view[2]);
-    assertEquals(7, Wasm.instantiateModuleFromAsm(code, stdlib).caller());
+    assertEquals(7, module_decl(stdlib).caller());
+    assertValidAsm(module_decl);
   }
 }
 
 TestHeapAccessIntTypes();
 
 
 function TestFloatHeapAccess(stdlib, foreign, buffer) {
   "use asm";
 
   var f32 = new stdlib.Float32Array(buffer);
   var f64 = new stdlib.Float64Array(buffer);
   var fround = stdlib.Math.fround;
   function caller() {
     var i = 8;
     var j = 8;
     var v = 6.0;
 
     f64[2] = v + 1.0;
     f64[i >> 3] = +f64[2] + 1.0;
     f64[j >> 3] = +f64[j >> 3] + 1.0;
     i = +f64[i >> 3] == 9.0;
     return i|0;
   }
 
   return {caller: caller};
 }
 
-assertEquals(1, Wasm.instantiateModuleFromAsm(
-      TestFloatHeapAccess.toString(), stdlib).caller());
+assertWasm(1, TestFloatHeapAccess);
 
 
 function TestFloatHeapAccessExternal() {
   var memory = new ArrayBuffer(1024);
   var memory_float64 = new Float64Array(memory);
-  var module = Wasm.instantiateModuleFromAsm(
-      TestFloatHeapAccess.toString(), stdlib, null, memory);
+  var module_decl = eval('(' + TestFloatHeapAccess.toString() + ')');
+  var module = module_decl(stdlib, null, memory);
+  assertValidAsm(module_decl);
   assertEquals(1, module.caller());
   assertEquals(9.0, memory_float64[1]);
 }
 
 TestFloatHeapAccessExternal();
 
 
 function TestConvertI32() {
   "use asm";
 
@@ skipping 126 matching lines @@
 
   function init() {
     a = 43.25;
     b = 34.25;
   }
 
   return {init:init,
           add:add};
 }
 
-var module = Wasm.instantiateModuleFromAsm(
-  TestNamedFunctions.toString(), stdlib);
+var module_decl = eval('(' + TestNamedFunctions.toString() + ')');
+var module = module_decl(stdlib);
+assertValidAsm(module_decl);
 module.init();
 assertEquals(77.5, module.add());
 })();
 
 
 (function () {
 function TestGlobalsWithInit() {
   "use asm";
 
   var a = 43.25;
   var b = 34.25;
 
   function add() {
     return +(a + b);
   }
 
   return {add:add};
 }
 
-var module = Wasm.instantiateModuleFromAsm(
-  TestGlobalsWithInit.toString(), stdlib);
+var module_decl = eval('(' + TestGlobalsWithInit.toString() + ')');
+var module = module_decl(stdlib);
+assertValidAsm(module_decl);
 assertEquals(77.5, module.add());
 })();
 
 function TestForLoop() {
   "use asm"
 
   function caller() {
     var ret = 0;
     var i = 0;
     for (i = 2; (i|0) <= 10; i = (i+1)|0) {
@@ skipping 106 matching lines @@
     var x = 1;
     return (((x|0) > 0) ? 41 : 71)|0;
   }
 
   return {caller:caller};
 }
 
 assertWasm(41, TestConditional);
 
 
-(function () {
 function TestInitFunctionWithNoGlobals() {
   "use asm";
   function caller() {
     return 51;
   }
   return {caller};
 }
 
-var module = Wasm.instantiateModuleFromAsm(
-    TestInitFunctionWithNoGlobals.toString(), stdlib);
-assertEquals(51, module.caller());
-})();
+assertWasm(51, TestInitFunctionWithNoGlobals);
+
 
 (function () {
 function TestExportNameDifferentFromFunctionName() {
   "use asm";
   function caller() {
     return 55;
   }
   return {alt_caller:caller};
 }
 
-var module = Wasm.instantiateModuleFromAsm(
-    TestExportNameDifferentFromFunctionName.toString(), stdlib);
+var module_decl = eval(
+  '(' + TestExportNameDifferentFromFunctionName.toString() + ')');
+var module = module_decl(stdlib);
+assertValidAsm(module_decl);
 assertEquals(55, module.alt_caller());
 })();
 
+
 function TestFunctionTableSingleFunction() {
   "use asm";
 
   function dummy() {
     return 71;
   }
 
   function caller() {
     // TODO(jpp): the parser optimizes function_table[0&0] to function table[0].
     var v = 0;
@@ skipping 33 matching lines @@
 
   var function_table = [inc1, inc2]
 
   return {caller:caller};
 }
 
 assertWasm(73, TestFunctionTableMultipleFunctions);
 
 
 (function () {
-function TestFunctionTable() {
+function TestFunctionTable(stdlib, foreign, buffer) {
   "use asm";
 
   function add(a, b) {
     a = a|0;
     b = b|0;
     return (a+b)|0;
   }
 
   function sub(a, b) {
     a = a|0;
@@ skipping 18 matching lines @@
     }
     return 0;
   }
 
   var funBin = [add, sub, sub, add];
   var fun = [inc];
 
   return {caller:caller};
 }
 
-var module = Wasm.instantiateModuleFromAsm(
-    TestFunctionTable.toString(), stdlib);
+var module = TestFunctionTable(stdlib);
 assertEquals(55, module.caller(0, 0, 33, 22));
 assertEquals(11, module.caller(0, 1, 33, 22));
 assertEquals(9, module.caller(0, 2, 54, 45));
 assertEquals(99, module.caller(0, 3, 54, 45));
 assertEquals(23, module.caller(0, 4, 12, 11));
 assertEquals(31, module.caller(1, 0, 30, 11));
 })();
 
 
 function TestForeignFunctions() {
@@ skipping 25 matching lines @@
 
     function setVal(new_val) {
       val = new_val;
     }
 
     return {getVal:getVal, setVal:setVal};
   }
 
   var foreign = new ffi(23);
 
-  var module = Wasm.instantiateModuleFromAsm(
-      AsmModule.toString(), stdlib, foreign, null);
+  var module = AsmModule({Math: Math}, foreign, null);
+  assertValidAsm(AsmModule);
 
   assertEquals(103, module.caller(23, 103));
 }
 
 TestForeignFunctions();
 
 
 function TestForeignFunctionMultipleUse() {
   function AsmModule(stdlib, foreign, buffer) {
     "use asm";
@@ skipping 17 matching lines @@
   function ffi() {
     function getVal() {
       return 83.25;
     }
 
     return {getVal:getVal};
   }
 
   var foreign = new ffi();
 
-  var module = Wasm.instantiateModuleFromAsm(
-      AsmModule.toString(), stdlib, foreign, null);
+  var module_decl = eval('(' + AsmModule.toString() + ')');
+  var module = module_decl(stdlib, foreign, null);
+  assertValidAsm(module_decl);
 
   assertEquals(89, module.caller(83, 83.25));
 }
 
 TestForeignFunctionMultipleUse();
 
 
 function TestForeignVariables() {
   function AsmModule(stdlib, foreign, buffer) {
     "use asm";
@@ skipping 17 matching lines @@
 
     function getf2() {
       return +f2;
     }
 
     return {geti1:geti1, getf1:getf1, geti2:geti2, getf2:getf2};
   }
 
   function TestCase(env, i1, f1, i2, f2) {
     print("Testing foreign variables...");
-    var module = Wasm.instantiateModuleFromAsm(
-        AsmModule.toString(), stdlib, env);
+    var module_decl = eval('(' + AsmModule.toString() + ')');
+    var module = module_decl(stdlib, env);
+    assertValidAsm(module_decl);
     assertEquals(i1, module.geti1());
     assertEquals(f1, module.getf1());
     assertEquals(i2, module.geti2());
     assertEquals(f2, module.getf2());
   }
 
   // Check normal operation.
   TestCase({foo: 123, bar: 234.5, baz: 345.7}, 123, 234.5, 345, 345.7);
   // Check partial operation.
   TestCase({baz: 345.7}, 0, NaN, 345, 345.7);
@@ skipping 70 matching lines @@
     }
 
     function iload(i) {
       i = i | 0;
       return HEAP8[HEAP32[i >> 2] | 0] | 0;
     }
 
     return {load: load, iload: iload, store: store, storeb: storeb};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(
-      TestByteHeapAccessCompat.toString(), stdlib);
+  var module_decl = eval('(' + TestByteHeapAccessCompat.toString() + ')');
+  var m = module_decl(stdlib);
+  assertValidAsm(module_decl);
   m.store(0, 20);
   m.store(4, 21);
   m.store(8, 22);
   m.storeb(20, 123);
   m.storeb(21, 42);
   m.storeb(22, 77);
   assertEquals(123, m.load(20));
   assertEquals(42, m.load(21));
   assertEquals(77, m.load(22));
   assertEquals(123, m.iload(0));
@@ skipping 28 matching lines @@
 
     function dfunc(a, b) {
       a = a | 0;
       b = +b;
       return +(a, b);
     }
 
     return {ifunc: ifunc, dfunc: dfunc};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(
-      CommaModule.toString(), stdlib);
+  var module_decl = eval('(' + CommaModule.toString() + ')');
+  var m = module_decl(stdlib);
+  assertValidAsm(module_decl);
   assertEquals(123, m.ifunc(456.7, 123));
   assertEquals(123.4, m.dfunc(456, 123.4));
 })();
 
 
 function TestFloatAsDouble(stdlib) {
   "use asm";
   var fround = stdlib.Math.fround;
   function func() {
     var x = fround(1.0);
@@ skipping 36 matching lines @@
     var x = 3;
     var y = 2;
     return (x ^ y) | 0;
   }
   return {caller: func};
 }
 
 assertWasm(1, TestXor);
 
 
-(function TestIntishAssignment() {
-  function Module(stdlib, foreign, heap) {
-    "use asm";
-    var HEAP32 = new stdlib.Int32Array(heap);
-    function func() {
-      var a = 1;
-      var b = 2;
-      HEAP32[0] = a + b;
-      return HEAP32[0] | 0;
-    }
-    return {func: func};
+function TestIntishAssignment(stdlib, foreign, heap) {
+  "use asm";
+  var HEAP32 = new stdlib.Int32Array(heap);
+  function func() {
+    var a = 1;
+    var b = 2;
+    HEAP32[0] = a + b;
+    return HEAP32[0] | 0;
   }
+  return {caller: func};
+}
 
-  var m = Wasm.instantiateModuleFromAsm(
-      Module.toString(), stdlib);
-  assertEquals(3, m.func());
-})();
+assertWasm(3, TestIntishAssignment);
 
 
-(function TestFloatishAssignment() {
-  function Module(stdlib, foreign, heap) {
-    "use asm";
-    var HEAPF32 = new stdlib.Float32Array(heap);
-    var fround = stdlib.Math.fround;
-    function func() {
-      var a = fround(1.0);
-      var b = fround(2.0);
-      HEAPF32[0] = a + b;
-      return +HEAPF32[0];
-    }
-    return {func: func};
+function TestFloatishAssignment(stdlib, foreign, heap) {
+  "use asm";
+  var HEAPF32 = new stdlib.Float32Array(heap);
+  var fround = stdlib.Math.fround;
+  function func() {
+    var a = fround(1.0);
+    var b = fround(2.0);
+    HEAPF32[0] = a + b;
+    return +HEAPF32[0];
   }
+  return {caller: func};
+}
 
-  var m = Wasm.instantiateModuleFromAsm(
-      Module.toString(), stdlib);
-  assertEquals(3, m.func());
-})();
+assertWasm(3, TestFloatishAssignment);
 
 
-(function TestDoubleToFloatAssignment() {
-  function Module(stdlib, foreign, heap) {
-    "use asm";
-    var HEAPF32 = new stdlib.Float32Array(heap);
-    var fround = stdlib.Math.fround;
-    function func() {
-      var a = 1.23;
-      HEAPF32[0] = a;
-      return +HEAPF32[0];
-    }
-    return {func: func};
+function TestDoubleToFloatAssignment(stdlib, foreign, heap) {
+  "use asm";
+  var HEAPF32 = new stdlib.Float32Array(heap);
+  var fround = stdlib.Math.fround;
+  function func() {
+    var a = 1.23;
+    HEAPF32[0] = a;
+    return +HEAPF32[0];
   }
+  return {caller: func};
+}
 
-  var m = Wasm.instantiateModuleFromAsm(
-      Module.toString(), stdlib);
-  assertEquals(1.23, m.func());
-});
+assertWasm(Math.fround(1.23), TestDoubleToFloatAssignment);
 
 
-(function TestIntegerMultiplyBothWays() {
-  function Module(stdlib, foreign, heap) {
-    "use asm";
-    function func() {
-      var a = 1;
-      return (((a * 3)|0) + ((4 * a)|0)) | 0;
-    }
-    return {func: func};
+function TestIntegerMultiplyBothWays(stdlib, foreign, heap) {
+  "use asm";
+  function func() {
+    var a = 1;
+    return (((a * 3)|0) + ((4 * a)|0)) | 0;
   }
+  return {caller: func};
+}
 
-  var m = Wasm.instantiateModuleFromAsm(
-      Module.toString(), stdlib);
-  assertEquals(7, m.func());
-})();
+assertWasm(7, TestIntegerMultiplyBothWays);
 
 
 (function TestBadAssignDoubleFromIntish() {
   function Module(stdlib, foreign, heap) {
     "use asm";
     function func() {
       var a = 1;
       var b = 3.0;
       b = a;
     }
     return {func: func};
   }
-  assertThrows(function() {
-    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  });
+  Module(stdlib);
+  assertTrue(%IsNotAsmWasmCode(Module));
 })();
 
 
 (function TestBadAssignIntFromDouble() {
   function Module(stdlib, foreign, heap) {
     "use asm";
     function func() {
       var a = 1;
       var b = 3.0;
       a = b;
     }
     return {func: func};
   }
-  assertThrows(function() {
-    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  });
+  Module(stdlib);
+  assertTrue(%IsNotAsmWasmCode(Module));
 })();
 
 
 (function TestBadMultiplyIntish() {
   function Module(stdlib, foreign, heap) {
     "use asm";
     function func() {
       var a = 1;
       return ((a + a) * 4) | 0;
     }
     return {func: func};
   }
-  assertThrows(function() {
-    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  });
+  Module(stdlib);
+  assertTrue(%IsNotAsmWasmCode(Module));
 })();
 
 
 (function TestBadCastFromInt() {
   function Module(stdlib, foreign, heap) {
     "use asm";
     function func() {
       var a = 1;
       return +a;
     }
     return {func: func};
   }
-  assertThrows(function() {
-    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  });
+  Module(stdlib);
+  assertTrue(%IsNotAsmWasmCode(Module));
 })();
 
 
-(function TestAndNegative() {
-  function Module() {
-    "use asm";
-    function func() {
-      var x = 1;
-      var y = 2;
-      var z = 0;
-      z = x + y & -1;
-      return z | 0;
-    }
-    return {func: func};
+function TestAndNegative() {
+  "use asm";
+  function func() {
+    var x = 1;
+    var y = 2;
+    var z = 0;
+    z = x + y & -1;
+    return z | 0;
   }
+  return {caller: func};
+}
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  assertEquals(3, m.func());
-})();
+assertWasm(3, TestAndNegative);
 
 
-(function TestNegativeDouble() {
-  function Module() {
-    "use asm";
-    function func() {
-      var x = -(34359738368.25);
-      var y = -2.5;
-      return +(x + y);
-    }
-    return {func: func};
+function TestNegativeDouble() {
+  "use asm";
+  function func() {
+    var x = -(34359738368.25);
+    var y = -2.5;
+    return +(x + y);
   }
+  return {caller: func};
+}
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  assertEquals(-34359738370.75, m.func());
-})();
+assertWasm(-34359738370.75, TestNegativeDouble);
 
 
 (function TestBadAndDouble() {
   function Module() {
     "use asm";
     function func() {
       var x = 1.0;
       var y = 2.0;
       return (x & y) | 0;
     }
     return {func: func};
   }
 
-  assertThrows(function() {
-    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  });
+  Module(stdlib);
+  assertTrue(%IsNotAsmWasmCode(Module));
 })();
 
 
-(function TestAndIntAndHeapValue() {
-  function Module(stdlib, foreign, buffer) {
-    "use asm";
-    var HEAP32 = new stdlib.Int32Array(buffer);
-    function func() {
-      var x = 0;
-      x = HEAP32[0] & -1;
-      return x | 0;
-    }
-    return {func: func};
+function TestAndIntAndHeapValue(stdlib, foreign, buffer) {
+  "use asm";
+  var HEAP32 = new stdlib.Int32Array(buffer);
+  function func() {
+    var x = 0;
+    x = HEAP32[0] & -1;
+    return x | 0;
   }
+  return {caller: func};
+}
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
-  assertEquals(0, m.func());
-})();
+assertWasm(0, TestAndIntAndHeapValue);
 
-(function TestOutOfBoundsConversion() {
-  function asmModule($a,$b,$c){'use asm';
-    function aaa() {
-      var f = 0.0;
-      var a = 0;
-      f = 5616315000.000001;
-      a = ~~f >>>0;
-      return a | 0;
-    }
-    return { main : aaa };
+
+function TestOutOfBoundsConversion($a,$b,$c){'use asm';
+  function aaa() {
+    var f = 0.0;
+    var a = 0;
+    f = 5616315000.000001;
+    a = ~~f >>>0;
+    return a | 0;
   }
-  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString(), stdlib);
-  assertEquals(1321347704, wasm.main());
-})();
+  return { caller : aaa };
+}
+
+assertWasm(1321347704, TestOutOfBoundsConversion);
+
 
 (function TestUnsignedLiterals() {
   function asmModule() {
     "use asm";
     function u0xffffffff() {
       var f = 0xffffffff;
       return +(f >>> 0);
     }
     function u0x80000000() {
       var f = 0x80000000;
       return +(f >>> 0);
     }
     function u0x87654321() {
       var f = 0x87654321;
       return +(f >>> 0);
     }
     return {
       u0xffffffff: u0xffffffff,
       u0x80000000: u0x80000000,
       u0x87654321: u0x87654321,
     };
   }
-  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString(), stdlib);
+  var decl = eval('(' + asmModule.toString() + ')');
+  var wasm = decl(stdlib);
+  assertValidAsm(decl);
   assertEquals(0xffffffff, wasm.u0xffffffff());
   assertEquals(0x80000000, wasm.u0x80000000());
   assertEquals(0x87654321, wasm.u0x87654321());
 })();
 
-(function TestBadNoDeclaration() {
-  assertThrows(function() {
-    Wasm.instantiateModuleFromAsm('33;', stdlib);
-  });
-})();
 
-(function TestBadVarDeclaration() {
-  assertThrows(function() {
-    Wasm.instantiateModuleFromAsm('var x = 3;', stdlib);
-  });
-})();
+function TestIfWithUnsigned() {
+  "use asm";
+  function main() {
+    if (2147483658) { // 2^31 + 10
+      return 231;
+    }
+    return 0;
+  }
+  return {caller:main};
+}
 
-(function TestIfWithUnsigned() {
-  function asmModule() {
-    "use asm";
-    function main() {
-      if (2147483658) { // 2^31 + 10
-        return 231;
-      }
-      return 0;
+assertWasm(231, TestIfWithUnsigned);
+
+
+function TestLoopsWithUnsigned() {
+  "use asm";
+  function main() {
+    var val = 1;
+    var count = 0;
+    for (val = 2147483648; 2147483648;) {
+      val = 2147483649;
+      break;
     }
-    return {main:main};
-  }
-  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString(), stdlib);
-  assertEquals(231, wasm.main());
-})();
-
-(function TestLoopsWithUnsigned() {
-  function asmModule() {
-    "use asm";
-    function main() {
-      var val = 1;
-      var count = 0;
-      for (val = 2147483648; 2147483648;) {
-        val = 2147483649;
+    while (val>>>0) {
+      val = (val + 1) | 0;
+      count = (count + 1)|0;
+      if ((count|0) == 9) {
         break;
       }
-      while (val>>>0) {
-        val = (val + 1) | 0;
-        count = (count + 1)|0;
-        if ((count|0) == 9) {
-          break;
-        }
+    }
+    count = 0;
+    do {
+      val = (val + 2) | 0;
+      count = (count + 1)|0;
+      if ((count|0) == 5) {
+        break;
       }
-      count = 0;
-      do {
-        val = (val + 2) | 0;
-        count = (count + 1)|0;
-        if ((count|0) == 5) {
-          break;
-        }
-      } while (0xffffffff);
-      if ((val>>>0) == 2147483668) {
-        return 323;
-      }
-      return 0;
+    } while (0xffffffff);
+    if ((val>>>0) == 2147483668) {
+      return 323;
     }
-    return {main:main};
+    return 0;
   }
-  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString(), stdlib);
-  assertEquals(323, wasm.main());
-})();
+  return {caller:main};
+}
+
+assertWasm(323, TestLoopsWithUnsigned);