JSTests/wasm/Builder.js

   1 /*
   2  * Copyright (C) 2016 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 import * as assert from 'assert.js';
  27 import * as BuildWebAssembly from 'Builder_WebAssemblyBinary.js';
  28 import * as WASM from 'WASM.js';
  29
  30 const _toJavaScriptName = name => {
  31     const camelCase = name.replace(/([^a-z0-9].)/g, c => c[1].toUpperCase());
  32     const CamelCase = camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
  33     return CamelCase;
  34 };
  35
  36 const _isValidValue = (value, type) => {
  37     switch (type) {
  38     case "i32": return ((value & 0xFFFFFFFF) >>> 0) === value;
  39     case "i64": throw new Error(`Unimplemented: value check for ${type}`); // FIXME https://bugs.webkit.org/show_bug.cgi?id=163420 64-bit values
  40     case "f32": return typeof(value) === "number" && isFinite(value);
  41     case "f64": return typeof(value) === "number" && isFinite(value);
  42     default: throw new Error(`Implementation problem: unknown type ${type}`);
  43     }
  44 };
  45 const _unknownSectionId = 0;
  46
  47 const _normalizeFunctionSignature = (params, ret) => {
  48     assert.isArray(params);
  49     for (const p of params)
  50         assert.truthy(WASM.isValidValueType(p), `Type parameter ${p} needs a valid value type`);
  51     if (typeof(ret) === "undefined")
  52         ret = "void";
  53     assert.isNotArray(ret, `Multiple return values not supported by WebAssembly yet`);
  54     assert.truthy(WASM.isValidBlockType(ret), `Type return ${ret} must be valid block type`);
  55     return [params, ret];
  56 };
  57
  58 const _maybeRegisterType = (builder, type) => {
  59     const typeSection = builder._getSection("Type");
  60     if (typeof(type) === "number") {
  61         // Type numbers already refer to the type section, no need to register them.
  62         if (builder._checked) {
  63             assert.isNotUndef(typeSection, `Can not use type ${type} if a type section is not present`);
  64             assert.isNotUndef(typeSection.data[type], `Type ${type} does not exist in type section`);
  65         }
  66         return type;
  67     }
  68     assert.hasObjectProperty(type, "params", `Expected type to be a number or object with 'params' and optionally 'ret' fields`);
  69     const [params, ret] = _normalizeFunctionSignature(type.params, type.ret);
  70     assert.isNotUndef(typeSection, `Can not add type if a type section is not present`);
  71     // Try reusing an equivalent type from the type section.
  72     types:
  73     for (let i = 0; i !== typeSection.data.length; ++i) {
  74         const t = typeSection.data[i];
  75         if (t.ret === ret && params.length === t.params.length) {
  76             for (let j = 0; j !== t.params.length; ++j) {
  77                 if (params[j] !== t.params[j])
  78                     continue types;
  79             }
  80             type = i;
  81             break;
  82         }
  83     }
  84     if (typeof(type) !== "number") {
  85         // Couldn't reuse a pre-existing type, register this type in the type section.
  86         typeSection.data.push({ params: params, ret: ret });
  87         type = typeSection.data.length - 1;
  88     }
  89     return type;
  90 };
  91
  92 const _importFunctionContinuation = (builder, section, nextBuilder) => {
  93     return (module, field, type) => {
  94         assert.isString(module, `Import function module should be a string, got "${module}"`);
  95         assert.isString(field, `Import function field should be a string, got "${field}"`);
  96         const typeSection = builder._getSection("Type");
  97         type = _maybeRegisterType(builder, type);
  98         section.data.push({ field: field, type: type, kind: "Function", module: module });
  99         // Imports also count in the function index space. Map them as objects to avoid clashing with Code functions' names.
 100         builder._registerFunctionToIndexSpace({ module: module, field: field });
 101         return nextBuilder;
 102     };
 103 };
 104
 105 const _exportFunctionContinuation = (builder, section, nextBuilder) => {
 106     return (field, index, type) => {
 107         assert.isString(field, `Export function field should be a string, got "${field}"`);
 108         const typeSection = builder._getSection("Type");
 109         if (typeof(type) !== "undefined") {
 110             // Exports can leave the type unspecified, letting the Code builder patch them up later.
 111             type = _maybeRegisterType(builder, type);
 112         }
 113         // We can't check much about "index" here because the Code section succeeds the Export section. More work is done at Code().End() time.
 114         switch (typeof(index)) {
 115         case "string": break; // Assume it's a function name which will be revealed in the Code section.
 116         case "number": break; // Assume it's a number in the "function index space".
 117         case "object":
 118             // Re-exporting an import.
 119             assert.hasObjectProperty(index, "module", `Re-exporting "${field}" from an import`);
 120             assert.hasObjectProperty(index, "field", `Re-exporting "${field}" from an import`);
 121             break;
 122         case "undefined":
 123             // Assume it's the same as the field (i.e. it's not being renamed).
 124             index = field;
 125             break;
 126         default: throw new Error(`Export section's index must be a string or a number, got ${index}`);
 127         }
 128         const correspondingImport = builder._getFunctionFromIndexSpace(index);
 129         const importSection = builder._getSection("Import");
 130         if (typeof(index) === "object") {
 131             // Re-exporting an import using its module+field name.
 132             assert.isNotUndef(correspondingImport, `Re-exporting "${field}" couldn't find import from module "${index.module}" field "${index.field}"`);
 133             index = correspondingImport;
 134             if (typeof(type) === "undefined")
 135                 type = importSection.data[index].type;
 136             if (builder._checked)
 137                 assert.eq(type, importSection.data[index].type, `Re-exporting import "${importSection.data[index].field}" as "${field}" has mismatching type`);
 138         } else if (typeof(correspondingImport) !== "undefined") {
 139             // Re-exporting an import using its index.
 140             let exportedImport;
 141             for (const i of importSection.data) {
 142                 if (i.module === correspondingImport.module && i.field === correspondingImport.field) {
 143                     exportedImport = i;
 144                     break;
 145                 }
 146             }
 147             if (typeof(type) === "undefined")
 148                 type = exportedImport.type;
 149             if (builder._checked)
 150                 assert.eq(type, exportedImport.type, `Re-exporting import "${exportedImport.field}" as "${field}" has mismatching type`);
 151         }
 152         section.data.push({ field: field, type: type, kind: "Function", index: index });
 153         return nextBuilder;
 154     };
 155 };
 156
 157 const _checkStackArgs = (op, param) => {
 158     for (let expect of param) {
 159         if (WASM.isValidType(expect)) {
 160             // FIXME implement stack checks for arguments. https://bugs.webkit.org/show_bug.cgi?id=163421
 161         } else {
 162             // Handle our own meta-types.
 163             switch (expect) {
 164             case "addr": break; // FIXME implement addr. https://bugs.webkit.org/show_bug.cgi?id=163421
 165             case "any": break; // FIXME implement any. https://bugs.webkit.org/show_bug.cgi?id=163421
 166             case "bool": break; // FIXME implement bool. https://bugs.webkit.org/show_bug.cgi?id=163421
 167             case "call": break; // FIXME implement call stack argument checks based on function signature. https://bugs.webkit.org/show_bug.cgi?id=163421
 168             case "global": break; // FIXME implement global. https://bugs.webkit.org/show_bug.cgi?id=163421
 169             case "local": break; // FIXME implement local. https://bugs.webkit.org/show_bug.cgi?id=163421
 170             case "prev": break; // FIXME implement prev, checking for whetever the previous value was. https://bugs.webkit.org/show_bug.cgi?id=163421
 171             case "size": break; // FIXME implement size. https://bugs.webkit.org/show_bug.cgi?id=163421
 172             default: throw new Error(`Implementation problem: unhandled meta-type "${expect}" on "${op}"`);
 173             }
 174         }
 175     }
 176 }
 177
 178 const _checkStackReturn = (op, ret) => {
 179     for (let expect of ret) {
 180         if (WASM.isValidType(expect)) {
 181             // FIXME implement stack checks for return. https://bugs.webkit.org/show_bug.cgi?id=163421
 182         } else {
 183             // Handle our own meta-types.
 184             switch (expect) {
 185             case "bool": break; // FIXME implement bool. https://bugs.webkit.org/show_bug.cgi?id=163421
 186             case "call": break; // FIXME implement call stack return check based on function signature. https://bugs.webkit.org/show_bug.cgi?id=163421
 187             case "control": break; // FIXME implement control. https://bugs.webkit.org/show_bug.cgi?id=163421
 188             case "global": break; // FIXME implement global. https://bugs.webkit.org/show_bug.cgi?id=163421
 189             case "local": break; // FIXME implement local. https://bugs.webkit.org/show_bug.cgi?id=163421
 190             case "prev": break; // FIXME implement prev, checking for whetever the parameter type was. https://bugs.webkit.org/show_bug.cgi?id=163421
 191             case "size": break; // FIXME implement size. https://bugs.webkit.org/show_bug.cgi?id=163421
 192             default: throw new Error(`Implementation problem: unhandled meta-type "${expect}" on "${op}"`);
 193             }
 194         }
 195     }
 196 };
 197
 198 const _checkImms = (op, imms, expectedImms, ret) => {
 199     const minExpectedImms = expectedImms.filter(i => i.type.slice(-1) !== '*').length;
 200     if (minExpectedImms !== expectedImms.length)
 201         assert.ge(imms.length, minExpectedImms, `"${op}" expects at least ${minExpectedImms} immediate${minExpectedImms !== 1 ? 's' : ''}, got ${imms.length}`);
 202     else
 203          assert.eq(imms.length, minExpectedImms, `"${op}" expects exactly ${minExpectedImms} immediate${minExpectedImms !== 1 ? 's' : ''}, got ${imms.length}`);
 204     for (let idx = 0; idx !== expectedImms.length; ++idx) {
 205         const got = imms[idx];
 206         const expect = expectedImms[idx];
 207         switch (expect.name) {
 208         case "function_index":
 209             assert.truthy(_isValidValue(got, "i32"), `Invalid value on ${op}: got "${got}", expected i32`);
 210             // FIXME check function indices. https://bugs.webkit.org/show_bug.cgi?id=163421
 211             break;
 212         case "local_index": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 213         case "global_index": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 214         case "type_index": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 215         case "value":
 216             assert.truthy(_isValidValue(got, ret[0]), `Invalid value on ${op}: got "${got}", expected ${ret[0]}`);
 217             break;
 218         case "flags": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 219         case "offset": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 220             // Control:
 221         case "default_target": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 222         case "relative_depth": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 223         case "sig":
 224             assert.truthy(WASM.isValidBlockType(imms[idx]), `Invalid block type on ${op}: "${imms[idx]}"`);
 225             break;
 226         case "target_count": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 227         case "target_table": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
 228         default: throw new Error(`Implementation problem: unhandled immediate "${expect.name}" on "${op}"`);
 229         }
 230     }
 231 };
 232
 233 const _createFunctionBuilder = (func, builder, previousBuilder) => {
 234     let functionBuilder = {};
 235     for (const op in WASM.description.opcode) {
 236         const name = _toJavaScriptName(op);
 237         const value = WASM.description.opcode[op].value;
 238         const ret = WASM.description.opcode[op]["return"];
 239         const param = WASM.description.opcode[op].parameter;
 240         const imm = WASM.description.opcode[op].immediate;
 241
 242         const checkStackArgs = builder._checked ? _checkStackArgs : () => {};
 243         const checkStackReturn = builder._checked ? _checkStackReturn : () => {};
 244         const checkImms = builder._checked ? _checkImms : () => {};
 245
 246         functionBuilder[name] = (...args) => {
 247             let nextBuilder;
 248             switch (name) {
 249             default:
 250                 nextBuilder = functionBuilder;
 251                 break;
 252                 case "End":
 253                 nextBuilder = previousBuilder;
 254                     break;
 255             case "Block":
 256                 case "Loop":
 257             case "If":
 258                 nextBuilder = _createFunctionBuilder(func, builder, functionBuilder);
 259                 break;
 260             }
 261
 262             // Passing a function as the argument is a way to nest blocks lexically.
 263             const continuation = args[args.length - 1];
 264             const hasContinuation = typeof(continuation) === "function";
 265             const imms = hasContinuation ? args.slice(0, -1) : args; // FIXME: allow passing in stack values, as-if code were a stack machine. Just check for a builder to this function, and drop. https://bugs.webkit.org/show_bug.cgi?id=163422
 266             checkImms(op, imms, imm, ret);
 267             checkStackArgs(op, param);
 268             checkStackReturn(op, ret);
 269             const stackArgs = []; // FIXME https://bugs.webkit.org/show_bug.cgi?id=162706
 270             func.code.push({ name: op, value: value, arguments: stackArgs, immediates: imms });
 271             if (hasContinuation)
 272                 return continuation(nextBuilder).End();
 273             return nextBuilder;
 274         };
 275     }
 276     return functionBuilder;
 277 }
 278
 279 const _createFunction = (section, builder, previousBuilder) => {
 280     return (...args) => {
 281         const nameOffset = (typeof(args[0]) === "string") >>> 0;
 282         const functionName = nameOffset ? args[0] : undefined;
 283         let signature = args[0 + nameOffset];
 284         const locals = args[1 + nameOffset] === undefined ? [] : args[1 + nameOffset];
 285         for (const local of locals)
 286             assert.truthy(WASM.isValidValueType(local), `Type of local: ${local} needs to be a valid value type`);
 287
 288         if (typeof(signature) === "undefined")
 289             signature = { params: [] };
 290         assert.hasObjectProperty(signature, "params", `Expect function signature to be an object with a "params" field, got "${signature}"`);
 291         const [params, ret] = _normalizeFunctionSignature(signature.params, signature.ret);
 292         signature = { params: params, ret: ret };
 293         const func = {
 294             name: functionName,
 295             type: _maybeRegisterType(builder, signature),
 296             signature: signature,
 297             locals: params.concat(locals), // Parameters are the first locals.
 298             parameterCount: params.length,
 299             code: []
 300         };
 301
 302         const functionSection = builder._getSection("Function");
 303         if (functionSection)
 304             functionSection.data.push(func.type);
 305
 306         section.data.push(func);
 307         builder._registerFunctionToIndexSpace(functionName);
 308
 309         return _createFunctionBuilder(func, builder, previousBuilder);
 310     }
 311 };
 312
 313 export default class Builder {
 314     constructor() {
 315         this.setChecked(true);
 316         let preamble = {};
 317         for (const p of WASM.description.preamble)
 318             preamble[p.name] = p.value;
 319         this.setPreamble(preamble);
 320         this._sections = [];
 321         this._functionIndexSpace = {};
 322         this._functionIndexSpaceCount = 0;
 323         this._registerSectionBuilders();
 324     }
 325     setChecked(checked) {
 326         this._checked = checked;
 327         return this;
 328     }
 329     setPreamble(p) {
 330         this._preamble = Object.assign(this._preamble || {}, p);
 331         return this;
 332     }
 333     _registerFunctionToIndexSpace(name) {
 334         if (typeof(name) === "undefined") {
 335             // Registering a nameless function still adds it to the function index space. Register it as something that can't normally be registered.
 336             name = {};
 337         }
 338         // Collisions are fine: we'll simply count the function and forget the previous one.
 339         this._functionIndexSpace[name] = this._functionIndexSpaceCount++;
 340         // Map it both ways, the number space is distinct from the name space.
 341         this._functionIndexSpace[this._functionIndexSpace[name]] = name;
 342     }
 343     _getFunctionFromIndexSpace(name) {
 344         return this._functionIndexSpace[name];
 345     }
 346     _registerSectionBuilders() {
 347         for (const section in WASM.description.section) {
 348             switch (section) {
 349             case "Type":
 350                 this[section] = function() {
 351                     const s = this._addSection(section);
 352                     const builder = this;
 353                     const typeBuilder = {
 354                         End: () => builder,
 355                         Func: (params, ret) => {
 356                             [params, ret] = _normalizeFunctionSignature(params, ret);
 357                             s.data.push({ params: params, ret: ret });
 358                             return typeBuilder;
 359                         },
 360                     };
 361                     return typeBuilder;
 362                 };
 363                 break;
 364
 365             case "Import":
 366                 this[section] = function() {
 367                     const s = this._addSection(section);
 368                     const importBuilder = {
 369                         End: () => this,
 370                         Table: () => { throw new Error(`Unimplemented: import table`); },
 371                         Memory: () => { throw new Error(`Unimplemented: import memory`); },
 372                         Global: () => { throw new Error(`Unimplemented: import global`); },
 373                     };
 374                     importBuilder.Function = _importFunctionContinuation(this, s, importBuilder);
 375                     return importBuilder;
 376                 };
 377                 break;
 378
 379             case "Function":
 380                 this[section] = function() {
 381                     const s = this._addSection(section);
 382                     const exportBuilder = {
 383                         End: () => this
 384                         // FIXME: add ability to add this with whatever.
 385                     };
 386                     return exportBuilder;
 387                 };
 388                 break;
 389
 390             case "Table":
 391                 // FIXME Implement table https://bugs.webkit.org/show_bug.cgi?id=164135
 392                 this[section] = () => { throw new Error(`Unimplemented: section type "${section}"`); };
 393                 break;
 394
 395             case "Memory":
 396                 this[section] = function() {
 397                     const s = this._addSection(section);
 398                     const exportBuilder = {
 399                         End: () => this,
 400                         InitialMaxPages: (initial, max) => {
 401                             s.data.push({ initial, max });
 402                             return exportBuilder;
 403                         }
 404                     };
 405                     return exportBuilder;
 406                 };
 407                 break;
 408
 409             case "Global":
 410                 // FIXME implement global https://bugs.webkit.org/show_bug.cgi?id=164133
 411                 this[section] = () => { throw new Error(`Unimplemented: section type "${section}"`); };
 412                 break;
 413
 414             case "Export":
 415                 this[section] = function() {
 416                     const s = this._addSection(section);
 417                     const exportBuilder = {
 418                         End: () => this,
 419                         Table: () => { throw new Error(`Unimplemented: export table`); },
 420                         Memory: () => { throw new Error(`Unimplemented: export memory`); },
 421                         Global: () => { throw new Error(`Unimplemented: export global`); },
 422                     };
 423                     exportBuilder.Function = _exportFunctionContinuation(this, s, exportBuilder);
 424                     return exportBuilder;
 425                 };
 426                 break;
 427
 428             case "Start":
 429                 // FIXME implement start https://bugs.webkit.org/show_bug.cgi?id=161709
 430                 this[section] = () => { throw new Error(`Unimplemented: section type "${section}"`); };
 431                 break;
 432
 433             case "Element":
 434                 // FIXME implement element https://bugs.webkit.org/show_bug.cgi?id=161709
 435                 this[section] = () => { throw new Error(`Unimplemented: section type "${section}"`); };
 436                 break;
 437
 438             case "Code":
 439                 this[section] = function() {
 440                     const s = this._addSection(section);
 441                     const builder = this;
 442                     const codeBuilder =  {
 443                         End: () => {
 444                             // We now have enough information to remap the export section's "type" and "index" according to the Code section we're currently ending.
 445                             const typeSection = builder._getSection("Type");
 446                             const importSection = builder._getSection("Import");
 447                             const exportSection = builder._getSection("Export");
 448                             const codeSection = s;
 449                             if (exportSection) {
 450                                 for (const e of exportSection.data) {
 451                                     switch (typeof(e.index)) {
 452                                     default: throw new Error(`Unexpected export index "${e.index}"`);
 453                                     case "string": {
 454                                         const index = builder._getFunctionFromIndexSpace(e.index);
 455                                         assert.isNumber(index, `Export section contains undefined function "${e.index}"`);
 456                                         e.index = index;
 457                                     } // Fallthrough.
 458                                     case "number": {
 459                                         const index = builder._getFunctionFromIndexSpace(e.index);
 460                                         if (builder._checked)
 461                                             assert.isNotUndef(index, `Export "${e.field}" does not correspond to a defined value in the function index space`);
 462                                     } break;
 463                                     case "undefined":
 464                                         throw new Error(`Unimplemented: Function().End() with undefined export index`); // FIXME
 465                                     }
 466                                     if (typeof(e.type) === "undefined") {
 467                                         // This must be a function export from the Code section (re-exports were handled earlier).
 468                                         const functionIndexSpaceOffset = importSection ? importSection.data.length : 0;
 469                                         const functionIndex = e.index - functionIndexSpaceOffset;
 470                                         e.type = codeSection.data[functionIndex].type;
 471                                     }
 472                                 }
 473                             }
 474                             return builder;
 475                         },
 476
 477                     };
 478                     codeBuilder.Function = _createFunction(s, builder, codeBuilder);
 479                     return codeBuilder;
 480                 };
 481                 break;
 482
 483             case "Data":
 484                 // FIXME implement data https://bugs.webkit.org/show_bug.cgi?id=161709
 485                 this[section] = () => { throw new Error(`Unimplemented: section type "${section}"`); };
 486                 break;
 487
 488             default:
 489                 this[section] = () => { throw new Error(`Unknown section type "${section}"`); };
 490                 break;
 491             }
 492         }
 493
 494         this.Unknown = function(name) {
 495             const s = this._addSection(name);
 496             const builder = this;
 497             const unknownBuilder =  {
 498                 End: () => builder,
 499                 Byte: b => {
 500                     assert.eq(b & 0xFF, b, `Unknown section expected byte, got: "${b}"`);
 501                     s.data.push(b);
 502                     return unknownBuilder;
 503                 }
 504             };
 505             return unknownBuilder;
 506         };
 507     }
 508     _addSection(nameOrNumber, extraObject) {
 509         const name = typeof(nameOrNumber) === "string" ? nameOrNumber : "";
 510         const number = typeof(nameOrNumber) === "number" ? nameOrNumber : (WASM.description.section[name] ? WASM.description.section[name].value : _unknownSectionId);
 511         if (this._checked) {
 512             // Check uniqueness.
 513             for (const s of this._sections)
 514                 assert.falsy(s.name === name && s.id === number, `Cannot have two sections with the same name "${name}" and ID ${number}`);
 515             // Check ordering.
 516             if ((number !== _unknownSectionId) && (this._sections.length !== 0)) {
 517                 for (let i = this._sections.length - 1; i >= 0; --i) {
 518                     if (this._sections[i].id === _unknownSectionId)
 519                         continue;
 520                     assert.le(this._sections[i].id, number, `Bad section ordering: "${this._sections[i].name}" cannot precede "${name}"`);
 521                     break;
 522                 }
 523             }
 524         }
 525         const s = Object.assign({ name: name, id: number, data: [] }, extraObject || {});
 526         this._sections.push(s);
 527         return s;
 528     }
 529     _getSection(nameOrNumber) {
 530         switch (typeof(nameOrNumber)) {
 531         default: throw new Error(`Implementation problem: can not get section "${nameOrNumber}"`);
 532         case "string":
 533             for (const s of this._sections)
 534                 if (s.name === nameOrNumber)
 535                     return s;
 536             return undefined;
 537         case "number":
 538             for (const s of this._sections)
 539                 if (s.id === nameOrNumber)
 540                     return s;
 541             return undefined;
 542         }
 543     }
 544     optimize() {
 545         // FIXME Add more optimizations. https://bugs.webkit.org/show_bug.cgi?id=163424
 546         return this;
 547     }
 548     json() {
 549         const obj = {
 550             preamble: this._preamble,
 551             section: this._sections
 552         };
 553         return JSON.stringify(obj);
 554     }
 555     AsmJS() {
 556         "use asm"; // For speed.
 557         // FIXME Create an asm.js equivalent string which can be eval'd. https://bugs.webkit.org/show_bug.cgi?id=163425
 558         throw new Error("asm.js not implemented yet");
 559     }
 560     WebAssembly() { return BuildWebAssembly.Binary(this._preamble, this._sections); }
 561 };