[wasm] Implement {Compile,Runtime}Error; fix traps from start function

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 65 matching lines @@
     // Copy the temporary buffer.
     this.push(...section);
   }
 }
 
 class WasmFunctionBuilder {
   constructor(module, name, type_index) {
     this.module = module;
     this.name = name;
     this.type_index = type_index;
+    this.body = [];
   }
 
   exportAs(name) {
     this.module.exports.push({name: name, kind: kExternalFunction, index: this.index});
     return this;
   }
 
   exportFunc() {
     this.exportAs(this.name);
     return this;
   }
 
   addBody(body) {
     this.body = body;
     return this;
   }
 
   addLocals(locals) {
     this.locals = locals;
     return this;
   }
+
+  end() {
+    return this.module;
+  }
 }
 
 class WasmGlobalBuilder {
   constructor(module, type, mutable) {
     this.module = module;
     this.type = type;
     this.mutable = mutable;
     this.init = 0;
   }
 
@@ skipping 14 matching lines @@
     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;
@@ skipping 39 matching lines @@
   addImportedGlobal(module, name, type) {
     let o = {module: module, name: name, kind: kExternalGlobal, type: type,
              mutable: false}
     this.imports.push(o);
     return this.num_imported_globals++;
   }
 
   addImportedMemory(module, name, initial = 0, maximum) {
     let o = {module: module, name: name, kind: kExternalMemory, initial: initial, maximum: maximum};
     this.imports.push(o);
+    return this;
   }
 
   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);
     return this;
   }
 
-  toArray(debug) {
+  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);
       binary.emit_section(kTypeSectionCode, section => {
@@ skipping 249 matching lines @@
           var name = func.name == undefined ? "" : func.name;
           section.emit_string(name);
           section.emit_u8(0);  // local names count == 0
         }
       });
     }
 
     return binary;
   }
 
-  toBuffer(debug) {
+  toBuffer(debug = false) {
     let bytes = this.toArray(debug);
     let buffer = new ArrayBuffer(bytes.length);
     let view = new Uint8Array(buffer);
     for (let i = 0; i < bytes.length; i++) {
       let val = bytes[i];
       if ((typeof val) == "string") val = val.charCodeAt(0);
       view[i] = val | 0;
     }
     return buffer;
   }
 
   instantiate(...args) {
     let module = new WebAssembly.Module(this.toBuffer());
     let instance = new WebAssembly.Instance(module, ...args);
     return instance;
   }
 }