[wasm] Add support for import section.

test/mjsunit/wasm/import-table.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
 
 load("test/mjsunit/wasm/wasm-constants.js");
 
-function testCallFFI(func, check) {
+function testCallImport(func, check) {
   var kBodySize = 6;
-  var kNameFunOffset = 24 + kBodySize + 1;
+  var kNameFunOffset = 29 + kBodySize + 1;
   var kNameMainOffset = kNameFunOffset + 4;
 
   var ffi = new Object();
   ffi.fun = func;
 
   var data = bytes(
     // signatures
     kDeclSignatures, 1,
     2, kAstI32, kAstF64, kAstF64, // (f64,f64) -> int
-    // -- foreign function
-    kDeclFunctions, 2,
-    kDeclFunctionName | kDeclFunctionImport,
-    0, 0,
-    kNameFunOffset, 0, 0, 0,    // name offset
     // -- main function
+    kDeclFunctions,
+    1,
     kDeclFunctionName | kDeclFunctionExport,
     0, 0,
-    kNameMainOffset, 0, 0, 0,   // name offset
+    kNameMainOffset, 0, 0, 0,    // name offset
     kBodySize, 0,
     // main body
-    kExprCallFunction, 0,       // --
-    kExprGetLocal, 0,           // --
-    kExprGetLocal, 1,           // --
+    kExprCallImport, 0,          // --
+    kExprGetLocal, 0,            // --
+    kExprGetLocal, 1,            // --
+    // imports
+    kDeclImportTable,
+    1,
+    0, 0,                        // sig index
+    0, 0, 0, 0,                  // module name offset
+    kNameFunOffset, 0, 0, 0,     // function name offset
     // names
     kDeclEnd,
-    'f', 'u', 'n', 0,           //  --
-    'm', 'a', 'i', 'n', 0       //  --
+    'f', 'u', 'n', 0,            // --
+    'm', 'a', 'i', 'n', 0        // --
   );
 
   var module = _WASMEXP_.instantiateModule(data, ffi);
 
   assertEquals("function", typeof module.main);
 
   for (var i = 0; i < 100000; i += 10003) {
     var a = 22.5 + i, b = 10.5 + i;
     var r = module.main(a, b);
     check(r, a, b);
@@ skipping 16 matching lines @@
 
 function check_FOREIGN_SUB(r, a, b) {
     assertEquals(a - b | 0, r);
     assertTrue(was_called);
 //    assertEquals(global, params[0]);  // sloppy mode
     assertEquals(a, params[1]);
     assertEquals(b, params[2]);
     was_called = false;
 }
 
-testCallFFI(FOREIGN_SUB, check_FOREIGN_SUB);
+testCallImport(FOREIGN_SUB, check_FOREIGN_SUB);
 
 
 function FOREIGN_ABCD(a, b, c, d) {
   print("FOREIGN_ABCD(" + a + ", " + b + ", " + c + ", " + d + ")");
   was_called = true;
   params[0] = this;
   params[1] = a;
   params[2] = b;
   params[3] = c;
   params[4] = d;
   return (a * b * 6) | 0;
 }
 
 function check_FOREIGN_ABCD(r, a, b) {
     assertEquals((a * b * 6) | 0, r);
     assertTrue(was_called);
 //    assertEquals(global, params[0]);  // sloppy mode.
     assertEquals(a, params[1]);
     assertEquals(b, params[2]);
     assertEquals(undefined, params[3]);
     assertEquals(undefined, params[4]);
     was_called = false;
 }
 
-testCallFFI(FOREIGN_ABCD, check_FOREIGN_ABCD);
+testCallImport(FOREIGN_ABCD, check_FOREIGN_ABCD);
 
 function FOREIGN_ARGUMENTS0() {
   print("FOREIGN_ARGUMENTS0");
   was_called = true;
   length = arguments.length;
   for (var i = 0; i < arguments.length; i++) {
     params[i] = arguments[i];
   }
   return (arguments[0] * arguments[1] * 7) | 0;
 }
@@ skipping 41 matching lines @@
 function check_FOREIGN_ARGUMENTS(r, a, b) {
   assertEquals((a * b * 7) | 0, r);
   assertTrue(was_called);
   assertEquals(2, length);
   assertEquals(a, params[0]);
   assertEquals(b, params[1]);
   was_called = false;
 }
 
 // Check a bunch of uses of the arguments object.
-testCallFFI(FOREIGN_ARGUMENTS0, check_FOREIGN_ARGUMENTS);
-testCallFFI(FOREIGN_ARGUMENTS1, check_FOREIGN_ARGUMENTS);
-testCallFFI(FOREIGN_ARGUMENTS2, check_FOREIGN_ARGUMENTS);
-testCallFFI(FOREIGN_ARGUMENTS3, check_FOREIGN_ARGUMENTS);
-testCallFFI(FOREIGN_ARGUMENTS4, check_FOREIGN_ARGUMENTS);
+testCallImport(FOREIGN_ARGUMENTS0, check_FOREIGN_ARGUMENTS);
+testCallImport(FOREIGN_ARGUMENTS1, check_FOREIGN_ARGUMENTS);
+testCallImport(FOREIGN_ARGUMENTS2, check_FOREIGN_ARGUMENTS);
+testCallImport(FOREIGN_ARGUMENTS3, check_FOREIGN_ARGUMENTS);
+testCallImport(FOREIGN_ARGUMENTS4, check_FOREIGN_ARGUMENTS);
 
 function returnValue(val) {
   return function(a, b) {
     print("RETURN_VALUE ", val);
     return val;
   }
 }
 
 
 function checkReturn(expected) {
   return function(r, a, b) { assertEquals(expected, r); }
 }
 
 // Check that returning weird values doesn't crash
-testCallFFI(returnValue(undefined), checkReturn(0));
-testCallFFI(returnValue(null), checkReturn(0));
-testCallFFI(returnValue("0"), checkReturn(0));
-testCallFFI(returnValue("-77"), checkReturn(-77));
+testCallImport(returnValue(undefined), checkReturn(0));
+testCallImport(returnValue(null), checkReturn(0));
+testCallImport(returnValue("0"), checkReturn(0));
+testCallImport(returnValue("-77"), checkReturn(-77));
 
 var objWithValueOf = {valueOf: function() { return 198; }}
 
-testCallFFI(returnValue(objWithValueOf), checkReturn(198));
+testCallImport(returnValue(objWithValueOf), checkReturn(198));
 
 
 function testCallBinopVoid(type, func, check) {
   var kBodySize = 10;
   var kNameFunOffset = 28 + kBodySize + 1;
   var kNameMainOffset = kNameFunOffset + 4;
 
   var ffi = new Object();
 
   var passed_length = -1;
@@ skipping 125 matching lines @@
 
   assertEquals("function", typeof module.main);
 
   for (var i = -9; i < 900; i += 6.125) {
       module.main(i);
   }
 }
 
 testCallPrint();
 testCallPrint();