[wasm] asm.js - Check stdlib.NaN is valid, prepare for the rest.

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
 
+var stdlib = this;
+
 function assertWasm(expected, func, ffi) {
   print("Testing " + func.name + "...");
   assertEquals(expected, Wasm.instantiateModuleFromAsm(
-      func.toString(), ffi).caller());
+      func.toString(), stdlib, ffi).caller());
 }
 
 function EmptyTest() {
   "use asm";
   function caller() {
     empty();
     return 11;
   }
   function empty() {
   }
@@ skipping 77 matching lines @@
   }
 
   function caller() {
     return call(1, 2)|0;
   }
 
   return {caller: caller};
 }
 
 assertThrows(function() {
-  Wasm.instantiateModuleFromAsm(BadModule.toString()).caller();
+  Wasm.instantiateModuleFromAsm(BadModule.toString(), stdlib).caller();
 });
 
 
 function TestReturnInBlock() {
   "use asm";
 
   function caller() {
     if(1) {
       {
         {
@@ skipping 373 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(), null, memory);
+      TestInt32HeapAccess.toString(), stdlib, null, memory);
   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, null, memory);
+    var module = Wasm.instantiateModuleFromAsm(code, stdlib, null, memory);
     assertEquals(7, module.caller());
     assertEquals(7, memory_view[2]);
-    assertEquals(7, Wasm.instantiateModuleFromAsm(code).caller());
+    assertEquals(7, Wasm.instantiateModuleFromAsm(code, stdlib).caller());
   }
 }
 
 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()).caller());
+      TestFloatHeapAccess.toString(), stdlib).caller());
 
 
 function TestFloatHeapAccessExternal() {
   var memory = new ArrayBuffer(1024);
   var memory_float64 = new Float64Array(memory);
   var module = Wasm.instantiateModuleFromAsm(
-      TestFloatHeapAccess.toString(), null, memory);
+      TestFloatHeapAccess.toString(), stdlib, null, memory);
   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());
+var module = Wasm.instantiateModuleFromAsm(
+  TestNamedFunctions.toString(), stdlib);
 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());
+var module = Wasm.instantiateModuleFromAsm(
+  TestGlobalsWithInit.toString(), stdlib);
 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 116 matching lines @@
 (function () {
 function TestInitFunctionWithNoGlobals() {
   "use asm";
   function caller() {
     return 51;
   }
   return {caller};
 }
 
 var module = Wasm.instantiateModuleFromAsm(
-    TestInitFunctionWithNoGlobals.toString());
+    TestInitFunctionWithNoGlobals.toString(), stdlib);
 assertEquals(51, module.caller());
 })();
 
 (function () {
 function TestExportNameDifferentFromFunctionName() {
   "use asm";
   function caller() {
     return 55;
   }
   return {alt_caller:caller};
 }
 
 var module = Wasm.instantiateModuleFromAsm(
-    TestExportNameDifferentFromFunctionName.toString());
+    TestExportNameDifferentFromFunctionName.toString(), stdlib);
 assertEquals(55, module.alt_caller());
 })();
 
 function TestFunctionTableSingleFunction() {
   "use asm";
 
   function dummy() {
     return 71;
   }
 
@@ skipping 75 matching lines @@
     }
     return 0;
   }
 
   var funBin = [add, sub, sub, add];
   var fun = [inc];
 
   return {caller:caller};
 }
 
-var module = Wasm.instantiateModuleFromAsm(TestFunctionTable.toString());
+var module = Wasm.instantiateModuleFromAsm(
+    TestFunctionTable.toString(), 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(),
-                                                  foreign, null);
+  var module = Wasm.instantiateModuleFromAsm(
+      AsmModule.toString(), stdlib, foreign, null);
 
   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(),
-                                                  foreign, null);
+  var module = Wasm.instantiateModuleFromAsm(
+      AsmModule.toString(), stdlib, foreign, null);
 
   assertEquals(89, module.caller(83, 83.25));
 }
 
 TestForeignFunctionMultipleUse();
 
 
 function TestForeignVariables() {
   function AsmModule(stdlib, foreign, buffer) {
     "use asm";
@@ skipping 18 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(), env);
+        AsmModule.toString(), stdlib, env);
     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 71 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());
+      TestByteHeapAccessCompat.toString(), stdlib);
   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());
+  var m = Wasm.instantiateModuleFromAsm(
+      CommaModule.toString(), stdlib);
   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 49 matching lines @@
     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};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString());
+  var m = Wasm.instantiateModuleFromAsm(
+      Module.toString(), stdlib);
   assertEquals(3, m.func());
 })();
 
 
 (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};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString());
+  var m = Wasm.instantiateModuleFromAsm(
+      Module.toString(), stdlib);
   assertEquals(3, m.func());
 })();
 
 
 (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};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString());
+  var m = Wasm.instantiateModuleFromAsm(
+      Module.toString(), stdlib);
   assertEquals(1.23, m.func());
 });
 
 
 (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};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString());
+  var m = Wasm.instantiateModuleFromAsm(
+      Module.toString(), stdlib);
   assertEquals(7, m.func());
 })();
 
 
 (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());
+    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   });
 })();
 
 
 (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());
+    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   });
 })();
 
 
 (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());
+    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   });
 })();
 
 
 (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());
+    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   });
 })();
 
 
 (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};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString());
+  var m = Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   assertEquals(3, m.func());
 })();
 
 
 (function TestNegativeDouble() {
   function Module() {
     "use asm";
     function func() {
       var x = -(34359738368.25);
       var y = -2.5;
       return +(x + y);
     }
     return {func: func};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString());
+  var m = Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   assertEquals(-34359738370.75, m.func());
 })();
 
 
 (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());
+    Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   });
 })();
 
 
 (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};
   }
 
-  var m = Wasm.instantiateModuleFromAsm(Module.toString());
+  var m = Wasm.instantiateModuleFromAsm(Module.toString(), stdlib);
   assertEquals(0, m.func());
 })();
 
 (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 };
   }
-  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString(), stdlib);
   assertEquals(1321347704, wasm.main());
 })();
 
 (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());
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString(), stdlib);
   assertEquals(0xffffffff, wasm.u0xffffffff());
   assertEquals(0x80000000, wasm.u0x80000000());
   assertEquals(0x87654321, wasm.u0x87654321());
 })();
 
 (function TestBadNoDeclaration() {
   assertThrows(function() {
-    Wasm.instantiateModuleFromAsm('33;');
+    Wasm.instantiateModuleFromAsm('33;', stdlib);
   });
 })();
 
 (function TestBadVarDeclaration() {
   assertThrows(function() {
-    Wasm.instantiateModuleFromAsm('var x = 3;');
+    Wasm.instantiateModuleFromAsm('var x = 3;', stdlib);
   });
 })();
 
 (function TestIfWithUnsigned() {
   function asmModule() {
     "use asm";
     function main() {
       if (2147483658) { // 2^31 + 10
         return 231;
       }
       return 0;
     }
     return {main:main};
   }
-  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  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;) {
@@ skipping 15 matching lines @@
           break;
         }
       } while (0xffffffff);
       if ((val>>>0) == 2147483668) {
         return 323;
       }
       return 0;
     }
     return {main:main};
   }
-  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString());
+  var wasm = Wasm.instantiateModuleFromAsm(asmModule.toString(), stdlib);
   assertEquals(323, wasm.main());
 })();