[wasm] Use a Managed<WasmModule> to hold metadata about modules.

test/mjsunit/wasm/wasm-module-builder.js

 // 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.
 
 // Used for encoding f32 and double constants to bits.
 let __buffer = new ArrayBuffer(8);
 let byte_view = new Int8Array(__buffer);
 let f32_view = new Float32Array(__buffer);
 let f64_view = new Float64Array(__buffer);
 
@@ skipping 114 matching lines @@
   }
 }
 
 class WasmModuleBuilder {
   constructor() {
     this.types = [];
     this.imports = [];
     this.exports = [];
     this.globals = [];
     this.functions = [];
-    this.table = [];
+    this.function_table = [];
+    this.function_table_length = 0;
+    this.function_table_inits = [];
     this.segments = [];
     this.explicit = [];
-    this.pad = null;
     this.num_imported_funcs = 0;
     this.num_imported_globals = 0;
     return this;
   }
 
   addStart(start_index) {
     this.start_index = start_index;
     return this;
   }
 
   addMemory(min, max, exp) {
     this.memory = {min: min, max: max, exp: exp};
     return this;
   }
 
-  addPadFunctionTable(size) {
-    this.pad = size;
-    return this;
-  }
-
   addExplicitSection(bytes) {
     this.explicit.push(bytes);
     return this;
   }
 
   addType(type) {
     // TODO: canonicalize types?
     this.types.push(type);
     return this.types.length - 1;
   }
@@ skipping 44 matching lines @@
 
   addDataSegment(addr, data, is_global = false) {
     this.segments.push({addr: addr, data: data, is_global: is_global});
     return this.segments.length - 1;
   }
 
   exportMemoryAs(name) {
     this.exports.push({name: name, kind: kExternalMemory, index: 0});
   }
 
-  appendToTable(array) {
-    this.table.push(...array);
+  addFunctionTableInit(base, is_global, array) {
+    this.function_table_inits.push({base: base, is_global: is_global, array: array});
+    if (!is_global) {
+      var length = base + array.length;
+      if (length > this.function_table_length) this.function_table_length = length;
+    }
     return this;
   }
 
+  appendToTable(array) {
+    return this.addFunctionTableInit(this.function_table.length, false, array);
+  }
+
+  setFunctionTableLength(length) {
+    this.function_table_length = length;
+    return this;
+  }
+
   toArray(debug = false) {
     let binary = new Binary;
     let wasm = this;
 
     // Add header
     binary.emit_header();
 
     // Add type section
     if (wasm.types.length > 0) {
       if (debug) print("emitting types @ " + binary.length);
@@ skipping 47 matching lines @@
       binary.emit_section(kFunctionSectionCode, section => {
         section.emit_u32v(wasm.functions.length);
         for (let func of wasm.functions) {
           has_names = has_names || (func.name != undefined &&
                                    func.name.length > 0);
           section.emit_u32v(func.type_index);
         }
       });
     }
 
-    // Add table.
-    if (wasm.table.length > 0) {
+    // Add function_table.
+    if (wasm.function_table_length > 0) {
       if (debug) print("emitting table @ " + binary.length);
       binary.emit_section(kTableSectionCode, section => {
         section.emit_u8(1);  // one table entry
         section.emit_u8(kWasmAnyFunctionTypeForm);
         section.emit_u8(1);
-        section.emit_u32v(wasm.table.length);
-        section.emit_u32v(wasm.table.length);
+        section.emit_u32v(wasm.function_table_length);
+        section.emit_u32v(wasm.function_table_length);
       });
     }
 
     // Add memory section
     if (wasm.memory != undefined) {
       if (debug) print("emitting memory @ " + binary.length);
       binary.emit_section(kMemorySectionCode, section => {
         section.emit_u8(1);  // one memory entry
         section.emit_u32v(kResizableMaximumFlag);
         section.emit_u32v(wasm.memory.min);
@@ skipping 73 matching lines @@
 
     // Add start function section.
     if (wasm.start_index != undefined) {
       if (debug) print("emitting start function @ " + binary.length);
       binary.emit_section(kStartSectionCode, section => {
         section.emit_u32v(wasm.start_index);
       });
     }
 
     // Add table elements.
-    if (wasm.table.length > 0) {
+    if (wasm.function_table_inits.length > 0) {
       if (debug) print("emitting table @ " + binary.length);
       binary.emit_section(kElementSectionCode, section => {
-        section.emit_u8(1);
+        var inits = wasm.function_table_inits;
+        section.emit_u32v(inits.length);
         section.emit_u8(0); // table index
-        section.emit_u8(kExprI32Const);
-        section.emit_u8(0);
-        section.emit_u8(kExprEnd);
-        section.emit_u32v(wasm.table.length);
-        for (let index of wasm.table) {
-          section.emit_u32v(index);
+
+        for (let init of inits) {
+          if (init.is_global) {
+            section.emit_u8(kExprGetGlobal);
+          } else {
+            section.emit_u8(kExprI32Const);
+          }
+          section.emit_u32v(init.base);
+          section.emit_u8(kExprEnd);
+          section.emit_u32v(init.array.length);
+          for (let index of init.array) {
+            section.emit_u32v(index);
+          }
         }
       });
     }
 
     // Add function bodies.
     if (wasm.functions.length > 0) {
       // emit function bodies
       if (debug) print("emitting code @ " + binary.length);
       binary.emit_section(kCodeSectionCode, section => {
         section.emit_u32v(wasm.functions.length);
@@ skipping 88 matching lines @@
     }
     return buffer;
   }
 
   instantiate(...args) {
     let module = new WebAssembly.Module(this.toBuffer());
     let instance = new WebAssembly.Instance(module, ...args);
     return instance;
   }
 }