Attachment #295820 for bug #164724

View Details Raw Unified Return to Bug 164724

| Differences between



2016-11-29  JF Bastien  <jfbastien@apple.com>

        WebAssembly: update binary format to 0xD version
        https://bugs.webkit.org/show_bug.cgi?id=164724

        Reviewed by Saam Barati.

        As described in the following PR: https://github.com/WebAssembly/design/pull/836

        * wasm/Builder.js:
        (const._normalizeFunctionSignature):
        * wasm/Builder_WebAssemblyBinary.js:
        (const.emitters.Type):
        (const.emitters.Code):
        * wasm/LowLevelBinary.js:
        (export.default.LowLevelBinary.prototype.block_type):
        (export.default.LowLevelBinary.prototype.inline_signature_type): Deleted.
        * wasm/WASM.js:
        * wasm/js-api/test_basic_api.js:
        * wasm/self-test/test_BuilderWebAssembly.js:
        (EmptyModule):
        (CustomSection):
        * wasm/self-test/test_WASM.js:
        * wasm/wasm.json:

2016-11-30  JF Bastien  <jfbastien@apple.com>

        WebAssembly builder: don't throw when checker not implemented



    if (typeof(ret) === "undefined")
        ret = "void";
    assert.isNotArray(ret, `Multiple return values not supported by WebAssembly yet`);
    assert.truthy(WASM.isValidBlockType(ret), `Type return ${ret} must be valid block type`);
    return [params, ret];
};



const _checkStackArgs = (op, param) => {
    for (let expect of param) {
        if (WASM.isValidType(expect)) {
            // FIXME implement stack checks for arguments. https://bugs.webkit.org/show_bug.cgi?id=163421
        } else {
            // Handle our own meta-types.


const _checkStackReturn = (op, ret) => {
    for (let expect of ret) {
        if (WASM.isValidType(expect)) {
            // FIXME implement stack checks for return. https://bugs.webkit.org/show_bug.cgi?id=163421
        } else {
            // Handle our own meta-types.

        case "default_target": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
        case "relative_depth": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
        case "sig":
            assert.truthy(WASM.isValidBlockType(imms[idx]), `Invalid block type on ${op}: "${imms[idx]}"`);
            assert.truthy(imms[idx] === "void" || WASM.isValidValueType(imms[idx]), `Invalid block type on ${op}: "${imms[idx]}"`);
            break;
        case "target_count": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
        case "target_table": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421



    Type: (section, bin) => {
        put(bin, "varuint32", section.data.length);
        for (const entry of section.data) {
            put(bin, "varint7", WASM.typeValue["func"]);
            put(bin, "varint7", funcTypeConstructor);
            put(bin, "varuint32", entry.params.length);
            for (const param of entry.params)
                put(bin, "varint7", WASM.typeValue[param]);
            if (entry.ret === "void")
                put(bin, "varuint1", 0);
            else {
                put(bin, "varuint1", 1);
                put(bin, "varint7", WASM.typeValue[entry.ret]);
            }
        }
    },

            put(funcBin, "varuint32", localCount);
            for (let i = func.parameterCount; i < func.locals.length; ++i) {
                put(funcBin, "varuint32", 1);
                put(funcBin, "varint7", WASM.typeValue[func.locals[i]]);
            }

            for (const op of func.code) {

Lines 159-166 export default class LowLevelBinary { a/JSTests/wasm/LowLevelBinary.js_sec1
- a/JSTests/wasm/LowLevelBinary.js -2 / +4 lines
159	throw new RangeError(`Invalid varuint7 ${v} range is [${varuint32Min}, ${varuint7Max}]`);	159	throw new RangeError(`Invalid varuint7 ${v} range is [${varuint32Min}, ${varuint7Max}]`);
160	this.varuint32(v);	160	this.varuint32(v);
161	}	161	}
162	inline_signature_type(v) {	162	block_type(v) {
163	this.varint7(WASM.valueTypeValue[v]);	163	if (!WASM.isValidBlockType(v))
		164	throw new Error(`Invalid block type ${v}`);
		165	this.varint7(WASM.typeValue[v]);
164	}	166	}
165	string(str) {	167	string(str) {
166	let patch = this.newPatchable("varuint32");	168	let patch = this.newPatchable("varuint32");

Lines 33-42 const _mapValues = from => { a/JSTests/wasm/WASM.js_sec1
- a/JSTests/wasm/WASM.js -3 / +7 lines
33	};	33	};
34		34
35	export const description = utilities.json("wasm.json");	35	export const description = utilities.json("wasm.json");
36	export const valueType = Object.keys(description.value_type);	36	export const type = Object.keys(description.type);
37	const _valueTypeSet = new Set(valueType);	37	const _typeSet = new Set(type);
		38	export const isValidType = v => _typeSet.has(v);
		39	export const typeValue = _mapValues(description.type);
		40	const _valueTypeSet = new Set(description.value_type);
38	export const isValidValueType = v => _valueTypeSet.has(v);	41	export const isValidValueType = v => _valueTypeSet.has(v);
39	export const valueTypeValue = _mapValues(description.value_type);	42	const _blockTypeSet = new Set(description.block_type);
		43	export const isValidBlockType = v => _blockTypeSet.has(v);
40	export const externalKindValue = _mapValues(description.external_kind);	44	export const externalKindValue = _mapValues(description.external_kind);
41	export const sections = Object.keys(description.section);	45	export const sections = Object.keys(description.section);
42	export const sectionEncodingType = description.section[sections[0]].type;	46	export const sectionEncodingType = description.section[sections[0]].type;

Lines 1-7 a/JSTests/wasm/js-api/test_basic_api.js_sec1
- a/JSTests/wasm/js-api/test_basic_api.js -1 / +1 lines
1	import * as assert from '../assert.js';	1	import * as assert from '../assert.js';
2	import * as utilities from '../utilities.js';	2	import * as utilities from '../utilities.js';
3		3
4	const version = 0xC;	4	const version = 0x0D;
5	const emptyModuleArray = Uint8Array.of(0x0, 0x61, 0x73, 0x6d, version, 0x00, 0x00, 0x00);	5	const emptyModuleArray = Uint8Array.of(0x0, 0x61, 0x73, 0x6d, version, 0x00, 0x00, 0x00);
6	const invalidConstructorInputs = [undefined, null, "", 1, {}, []];	6	const invalidConstructorInputs = [undefined, null, "", 1, {}, []];
7	const invalidInstanceImports = [null, "", 1];	7	const invalidInstanceImports = [null, "", 1];

Lines 6-12 import Builder from '../Builder.js'; a/JSTests/wasm/self-test/test_BuilderWebAssembly.js_sec1
- a/JSTests/wasm/self-test/test_BuilderWebAssembly.js -2 / +2 lines
6	const bin = builder.WebAssembly();	6	const bin = builder.WebAssembly();
7	// Note: this will change as we update version number.	7	// Note: this will change as we update version number.
8	assert.eq(bin.hexdump().trim(),	8	assert.eq(bin.hexdump().trim(),
9	"00000000 00 61 73 6d 0c 00 00 00 \|·asm···· \|");	9	"00000000 00 61 73 6d 0d 00 00 00 \|·asm···· \|");
10	})();	10	})();
11		11
12	(function EmptyModule() {	12	(function EmptyModule() {
Lines 27-32 import Builder from '../Builder.js'; a/JSTests/wasm/self-test/test_BuilderWebAssembly.js_sec2
27	.End()	27	.End()
28	.WebAssembly();	28	.WebAssembly();
29	assert.eq(bin.hexdump().trim(),	29	assert.eq(bin.hexdump().trim(),
30	["00000000 00 61 73 6d 0c 00 00 00 00 0a 05 4f 48 48 41 49 \|·asm·······OHHAI\|",	30	["00000000 00 61 73 6d 0d 00 00 00 00 0a 05 4f 48 48 41 49 \|·asm·······OHHAI\|",
31	"00000010 de ad c0 fe \|···· \|"].join("\n"));	31	"00000010 de ad c0 fe \|···· \|"].join("\n"));
32	})();	32	})();



import * as WASM from '../WASM.js';

assert.isNotUndef(WASM.description);
assert.isNotUndef(WASM.type);
assert.ge(WASM.type.length, 7);

for (const v of WASM.type)
    if (!WASM.isValidType(v))
        throw new Error(`Expected value ${v} to be a valid type`);

const expectedFields = [
    "preamble",
    "type",
    "inline_signature_type",
    "external_kind",
    "section",
    "opcode",



{
    "comments": ["This file describes the WebAssembly ISA.",
                 "Scripts in this folder auto-generate C++ code for JavaScriptCore as well as the testing DSL which WebKit's WebAssembly tests use."
                 "When you update this file you need to re-generate the C++ code: jsc ./JSTests/stress/wasm/generate-wasmops-header.js > ./Source/JavaScriptCore/wasm/WASMOps.h"
                ],
    "preamble": [
        { "name": "magic number", "type": "uint32", "value": 1836278016, "description": "NULL character followed by 'asm'" },
        { "name": "version",      "type": "uint32", "value":         13, "description": "Version number, will be reset to 1 for MVP" }
    ],
    "type" : {
        "i32":     { "type": "varint7", "value":  -1, "b3type": "B3::Int32" },
        "i64":     { "type": "varint7", "value":  -2, "b3type": "B3::Int64" },
        "f32":     { "type": "varint7", "value":  -3, "b3type": "B3::Float" },
        "f64":     { "type": "varint7", "value":  -4, "b3type": "B3::Double" },
        "anyfunc": { "type": "varint7", "value": -16, "b3type": "B3::Void" },
        "func":    { "type": "varint7", "value": -32, "b3type": "B3::Void" },
        "void":    { "type": "varint7", "value": -64, "b3type": "B3::Void" }
        "i32":  { "type": "uint8", "value": 1 },
        "i64":  { "type": "uint8", "value": 2 },
        "f32":  { "type": "uint8", "value": 3 },
        "f64":  { "type": "uint8", "value": 4 }
    },
    "value_type": ["i32", "i64", "f32", "f64"],
    "block_type": ["i32", "i64", "f32", "f64", "void"],
    "elem_type": ["anyfunc"],
    "external_kind": {
        "Function": { "type": "uint8", "value": 0 },
        "Table":    { "type": "uint8", "value": 1 },

    },
    "opcode": {
        "unreachable":         { "category": "control",    "value":   0, "return": [],           "parameter": [],                      "immediate": [],                                                                                         "description": "trap immediately" },
        "block":               { "category": "control",    "value":   2, "return": ["control"],  "parameter": [],                      "immediate": [{"name": "sig", "type": "block_type"}],                                                    "description": "begin a sequence of expressions, yielding 0 or 1 values" },
        "loop":                { "category": "control",    "value":   3, "return": ["control"],  "parameter": [],                      "immediate": [{"name": "sig", "type": "block_type"}],                                                    "description": "begin a block which can also form control flow loops" },
        "if":                  { "category": "control",    "value":   4, "return": ["control"],  "parameter": ["bool"],                "immediate": [{"name": "sig", "type": "block_type"}],                                                    "description": "begin if expression" },
        "else":                { "category": "control",    "value":   5, "return": ["control"],  "parameter": [],                      "immediate": [],                                                                                         "description": "begin else expression of if" },
        "select":              { "category": "control",    "value":  27, "return": ["prev"],     "parameter": ["any", "prev", "bool"], "immediate": [],                                                                                         "description": "select one of two values based on condition" },
        "br":                  { "category": "control",    "value":  12, "return": [],           "parameter": [],                      "immediate": [{"name": "relative_depth", "type": "varuint32"}],                                          "description": "break that targets an outer nested block" },
        "br_if":               { "category": "control",    "value":  13, "return": [],           "parameter": [],                      "immediate": [{"name": "relative_depth", "type": "varuint32"}],                                          "description": "conditional break that targets an outer nested block" },
        "br_table":            { "category": "control",    "value":  14, "return": [],           "parameter": [],                      "immediate": [{"name": "target_count",   "type": "varuint32",                                            "description": "number of entries in the target_table"},
                                                                                                                                                     {"name": "target_table",   "type": "varuint32*",                                           "description": "target entries that indicate an outer block or loop to which to break"},
                                                                                                                                                     {"name": "default_target", "type": "varuint32",                                            "description": "an outer block or loop to which to break in the default case"}],
                                                                                                                                                                                                                                                "description": "branch table control flow construct" },
        "return":              { "category": "control",    "value":  15, "return": [],           "parameter": [],                       "immediate": [],                                                                                         "description": "return zero or one value from this function" },
        "drop":                { "category": "control",    "value":  26, "return": [],           "parameter": ["any"],                  "immediate": [],                                                                                         "description": "ignore value" },
        "nop":                 { "category": "control",    "value":   1, "return": [],           "parameter": [],                       "immediate": [],                                                                                         "description": "no operation" },
        "end":                 { "category": "control",    "value":  11, "return": [],           "parameter": [],                       "immediate": [],                                                                                         "description": "end a block, loop, or if" },
        "i32.const":           { "category": "special",    "value":  65, "return": ["i32"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "varint32"}],                                           "description": "a constant value interpreted as i32" },
        "i64.const":           { "category": "special",    "value":  66, "return": ["i64"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "varint64"}],                                           "description": "a constant value interpreted as i64" },
        "f64.const":           { "category": "special",    "value":  68, "return": ["f64"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "uint64"}],                                             "description": "a constant value interpreted as f64" },
        "f32.const":           { "category": "special",    "value":  67, "return": ["f32"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "uint32"}],                                             "description": "a constant value interpreted as f32" },
        "get_local":           { "category": "special",    "value":  32, "return": ["local"],    "parameter": [],                       "immediate": [{"name": "local_index",    "type": "varuint32"}],                                          "description": "read a local variable or parameter" },
        "set_local":           { "category": "special",    "value":  33, "return": [],           "parameter": ["local"],                "immediate": [{"name": "local_index",    "type": "varuint32"}],                                          "description": "write a local variable or parameter" },
        "tee_local":           { "category": "special",    "value":  34, "return": ["prev"],     "parameter": ["any"],                  "immediate": [{"name": "local_index",    "type": "varuint32"}],                                          "description": "write a local variable or parameter and return the same value" },
        "get_global":          { "category": "special",    "value":  35, "return": ["global"],   "parameter": [],                       "immediate": [{"name": "global_index",   "type": "varuint32"}],                                          "description": "read a global variable" },
        "set_global":          { "category": "special",    "value":  36, "return": [""],         "parameter": ["global"],               "immediate": [{"name": "global_index",   "type": "varuint32"}],                                          "description": "write a global variable" },
        "call":                { "category": "call",       "value":  16, "return": ["call"],     "parameter": ["call"],                 "immediate": [{"name": "function_index", "type": "varuint32"}],                                          "description": "call a function by its index" },
        "call_indirect":       { "category": "call",       "value":  17, "return": ["call"],     "parameter": ["call"],                 "immediate": [{"name": "type_index",     "type": "varuint32"}],                                          "description": "call a function indirect with an expected signature" },
        "i32.load8_s":         { "category": "memory",     "value":  44, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load8_u":         { "category": "memory",     "value":  45, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load16_s":        { "category": "memory",     "value":  46, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load16_u":        { "category": "memory",     "value":  47, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load8_s":         { "category": "memory",     "value":  48, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load8_u":         { "category": "memory",     "value":  49, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load16_s":        { "category": "memory",     "value":  50, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load16_u":        { "category": "memory",     "value":  51, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load32_s":        { "category": "memory",     "value":  52, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load32_u":        { "category": "memory",     "value":  53, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load":            { "category": "memory",     "value":  40, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load":            { "category": "memory",     "value":  41, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "f32.load":            { "category": "memory",     "value":  42, "return": ["f32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "f64.load":            { "category": "memory",     "value":  43, "return": ["f64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.store8":          { "category": "memory",     "value":  58, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i32.store16":         { "category": "memory",     "value":  59, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store8":          { "category": "memory",     "value":  60, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store16":         { "category": "memory",     "value":  61, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store32":         { "category": "memory",     "value":  62, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i32.store":           { "category": "memory",     "value":  54, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store":           { "category": "memory",     "value":  55, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "f32.store":           { "category": "memory",     "value":  56, "return": [],           "parameter": ["addr", "f32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "f64.store":           { "category": "memory",     "value":  57, "return": [],           "parameter": ["addr", "f64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "current_memory":      { "category": "operation",  "value":  63, "return": ["size"],     "parameter": [],                       "immediate": [],                                                                                         "description": "query the size of memory" },
        "grow_memory":         { "category": "operation",  "value":  64, "return": ["size"],     "parameter": ["size"],                 "immediate": [],                                                                                         "description": "grow the size of memory" },
        "i32.add":             { "category": "arithmetic", "value": 106, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Add"          },
        "i32.sub":             { "category": "arithmetic", "value": 107, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Sub"          },
        "i32.mul":             { "category": "arithmetic", "value": 108, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Mul"          },
        "i32.div_s":           { "category": "arithmetic", "value": 109, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Div"          },
        "i32.div_u":           { "category": "arithmetic", "value": 110, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "UDiv"         },
        "i32.rem_s":           { "category": "arithmetic", "value": 111, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Mod"          },
        "i32.rem_u":           { "category": "arithmetic", "value": 112, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "UMod"         },
        "i32.and":             { "category": "arithmetic", "value": 113, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BitAnd"       },
        "i32.or":              { "category": "arithmetic", "value": 114, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BitOr"        },
        "i32.xor":             { "category": "arithmetic", "value": 115, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BitXor"       },
        "i32.shl":             { "category": "arithmetic", "value": 116, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Shl"          },
        "i32.shr_u":           { "category": "arithmetic", "value": 118, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "SShr"         },
        "i32.shr_s":           { "category": "arithmetic", "value": 117, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "ZShr"         },
        "i32.rotr":            { "category": "arithmetic", "value": 120, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "RotR"         },
        "i32.rotl":            { "category": "arithmetic", "value": 119, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "RotL"         },
        "i32.eq":              { "category": "comparison", "value":  70, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Equal"        },
        "i32.ne":              { "category": "comparison", "value":  71, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "NotEqual"     },
        "i32.lt_s":            { "category": "comparison", "value":  72, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "LessThan"     },
        "i32.le_s":            { "category": "comparison", "value":  76, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "LessEqual"    },
        "i32.lt_u":            { "category": "comparison", "value":  73, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Below"        },
        "i32.le_u":            { "category": "comparison", "value":  77, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BelowEqual"   },
        "i32.gt_s":            { "category": "comparison", "value":  74, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "GreaterThan"  },
        "i32.ge_s":            { "category": "comparison", "value":  78, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "GreaterEqual" },
        "i32.gt_u":            { "category": "comparison", "value":  75, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Above"        },
        "i32.ge_u":            { "category": "comparison", "value":  79, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "AboveEqual"   },
        "i32.clz":             { "category": "arithmetic", "value": 103, "return": ["i32"],      "parameter": ["i32"],                  "immediate": [], "b3op": "Clz"          },
        "i32.ctz":             { "category": "arithmetic", "value": 104, "return": ["i32"],      "parameter": ["i32"],                  "immediate": []                         },
        "i32.popcnt":          { "category": "arithmetic", "value": 105, "return": ["i32"],      "parameter": ["i32"],                  "immediate": []                         },
        "i32.eqz":             { "category": "comparison", "value":  69, "return": ["bool"],     "parameter": ["i32"],                  "immediate": [], "b3op": "Equal(i32(0), @0)" },
        "i64.add":             { "category": "arithmetic", "value": 124, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Add"          },
        "i64.sub":             { "category": "arithmetic", "value": 125, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Sub"          },
        "i64.mul":             { "category": "arithmetic", "value": 126, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Mul"          },
        "i64.div_s":           { "category": "arithmetic", "value": 127, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Div"          },
        "i64.div_u":           { "category": "arithmetic", "value": 128, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "UDiv"         },
        "i64.rem_s":           { "category": "arithmetic", "value": 129, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Mod"          },
        "i64.rem_u":           { "category": "arithmetic", "value": 130, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "UDiv"         },
        "i64.and":             { "category": "arithmetic", "value": 131, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BitAnd"       },
        "i64.or":              { "category": "arithmetic", "value": 132, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BitOr"        },
        "i64.xor":             { "category": "arithmetic", "value": 133, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BitXor"       },
        "i64.shl":             { "category": "arithmetic", "value": 134, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Shl"          },
        "i64.shr_u":           { "category": "arithmetic", "value": 136, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "SShr"         },
        "i64.shr_s":           { "category": "arithmetic", "value": 135, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "ZShr"         },
        "i64.rotr":            { "category": "arithmetic", "value": 138, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "RotR"         },
        "i64.rotl":            { "category": "arithmetic", "value": 137, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "RotL"         },
        "i64.eq":              { "category": "comparison", "value":  81, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Equal"        },
        "i64.ne":              { "category": "comparison", "value":  82, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "NotEqual"     },
        "i64.lt_s":            { "category": "comparison", "value":  83, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "LessThan"     },
        "i64.le_s":            { "category": "comparison", "value":  87, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "LessEqual"    },
        "i64.lt_u":            { "category": "comparison", "value":  84, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Below"        },
        "i64.le_u":            { "category": "comparison", "value":  88, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BelowEqual"   },
        "i64.gt_s":            { "category": "comparison", "value":  85, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "GreaterThan"  },
        "i64.ge_s":            { "category": "comparison", "value":  89, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "GreaterEqual" },
        "i64.gt_u":            { "category": "comparison", "value":  86, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Above"        },
        "i64.ge_u":            { "category": "comparison", "value":  90, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "AboveEqual"   },
        "i64.clz":             { "category": "arithmetic", "value": 121, "return": ["i64"],      "parameter": ["i64"],                  "immediate": [], "b3op": "Clz"          },
        "i64.ctz":             { "category": "arithmetic", "value": 122, "return": ["i64"],      "parameter": ["i64"],                  "immediate": []                         },
        "i64.popcnt":          { "category": "arithmetic", "value": 123, "return": ["i64"],      "parameter": ["i64"],                  "immediate": []                         },
        "i64.eqz":             { "category": "comparison", "value":  80, "return": ["bool"],     "parameter": ["i64"],                  "immediate": [], "b3op": "Equal(i32(0), @0)" },
        "f32.add":             { "category": "arithmetic", "value": 146, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Add"          },
        "f32.sub":             { "category": "arithmetic", "value": 147, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Sub"          },
        "f32.mul":             { "category": "arithmetic", "value": 148, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Mul"          },
        "f32.div":             { "category": "arithmetic", "value": 149, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Div"          },
        "f32.min":             { "category": "arithmetic", "value": 150, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @0, @1)" },
        "f32.max":             { "category": "arithmetic", "value": 151, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @1, @0)" },
        "f32.abs":             { "category": "arithmetic", "value": 139, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Abs"          },
        "f32.neg":             { "category": "arithmetic", "value": 140, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Neg"          },
        "f32.copysign":        { "category": "arithmetic", "value": 152, "return": ["f32"],      "parameter": ["f32"],                  "immediate": []                         },
        "f32.ceil":            { "category": "arithmetic", "value": 141, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Ceil"         },
        "f32.floor":           { "category": "arithmetic", "value": 142, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Floor"        },
        "f32.trunc":           { "category": "arithmetic", "value": 143, "return": ["f32"],      "parameter": ["f32"],                  "immediate": []                         },
        "f32.nearest":         { "category": "arithmetic", "value": 144, "return": ["f32"],      "parameter": ["f32"],                  "immediate": []                         },
        "f32.sqrt":            { "category": "arithmetic", "value": 145, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Sqrt"         },
        "f32.eq":              { "category": "comparison", "value":  91, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Equal"        },
        "f32.ne":              { "category": "comparison", "value":  92, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "NotEqual"     },
        "f32.lt":              { "category": "comparison", "value":  93, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "LessThan"     },
        "f32.le":              { "category": "comparison", "value":  95, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "LessEqual"    },
        "f32.gt":              { "category": "comparison", "value":  94, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "GreaterThan"  },
        "f32.ge":              { "category": "comparison", "value":  96, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "GreaterEqual" },
        "f64.add":             { "category": "arithmetic", "value": 160, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Add"          },
        "f64.sub":             { "category": "arithmetic", "value": 161, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Sub"          },
        "f64.mul":             { "category": "arithmetic", "value": 162, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Mul"          },
        "f64.div":             { "category": "arithmetic", "value": 163, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Div"          },
        "f64.min":             { "category": "arithmetic", "value": 164, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @0, @1)" },
        "f64.max":             { "category": "arithmetic", "value": 165, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @1, @0)" },
        "f64.abs":             { "category": "arithmetic", "value": 153, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Abs"          },
        "f64.neg":             { "category": "arithmetic", "value": 154, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Neg"          },
        "f64.copysign":        { "category": "arithmetic", "value": 166, "return": ["f64"],      "parameter": ["f64"],                  "immediate": []                         },
        "f64.ceil":            { "category": "arithmetic", "value": 155, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Ceil"         },
        "f64.floor":           { "category": "arithmetic", "value": 156, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Floor"        },
        "f64.trunc":           { "category": "arithmetic", "value": 157, "return": ["f64"],      "parameter": ["f64"],                  "immediate": []                         },
        "f64.nearest":         { "category": "arithmetic", "value": 158, "return": ["f64"],      "parameter": ["f64"],                  "immediate": []                         },
        "f64.sqrt":            { "category": "arithmetic", "value": 159, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Sqrt"         },
        "f64.eq":              { "category": "comparison", "value":  97, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Equal"        },
        "f64.ne":              { "category": "comparison", "value":  98, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "NotEqual"     },
        "f64.lt":              { "category": "comparison", "value":  99, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "LessThan"     },
        "f64.le":              { "category": "comparison", "value": 101, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "LessEqual"    },
        "f64.gt":              { "category": "comparison", "value": 100, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "GreaterThan"  },
        "f64.ge":              { "category": "comparison", "value": 102, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "GreaterEqual" },
        "i32.trunc_s/f32":     { "category": "conversion", "value": 168, "return": ["i32"],      "parameter": ["f32"],                  "immediate": []                         },
        "i32.trunc_s/f64":     { "category": "conversion", "value": 170, "return": ["i32"],      "parameter": ["f64"],                  "immediate": []                         },
        "i32.trunc_u/f32":     { "category": "conversion", "value": 169, "return": ["i32"],      "parameter": ["f32"],                  "immediate": []                         },
        "i32.trunc_u/f64":     { "category": "conversion", "value": 171, "return": ["i32"],      "parameter": ["f64"],                  "immediate": []                         },
        "i32.wrap/i64":        { "category": "conversion", "value": 167, "return": ["i32"],      "parameter": ["i64"],                  "immediate": []                         },
        "i64.trunc_s/f32":     { "category": "conversion", "value": 174, "return": ["i64"],      "parameter": ["f32"],                  "immediate": []                         },
        "i64.trunc_s/f64":     { "category": "conversion", "value": 176, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         },
        "i64.trunc_u/f32":     { "category": "conversion", "value": 175, "return": ["i64"],      "parameter": ["f32"],                  "immediate": []                         },
        "i64.trunc_u/f64":     { "category": "conversion", "value": 177, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         },
        "i64.extend_s/i32":    { "category": "conversion", "value": 172, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "SExt32"       },
        "i64.extend_u/i32":    { "category": "conversion", "value": 173, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "ZExt32"       },
        "f32.convert_s/i32":   { "category": "conversion", "value": 178, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
        "f32.convert_u/i32":   { "category": "conversion", "value": 179, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
        "f32.convert_s/i64":   { "category": "conversion", "value": 180, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
        "f32.convert_u/i64":   { "category": "conversion", "value": 181, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
        "f32.demote/f64":      { "category": "conversion", "value": 182, "return": ["f32"],      "parameter": ["f64"],                  "immediate": [], "b3op": "DoubleToFloat"},
        "f32.reinterpret/i32": { "category": "conversion", "value": 190, "return": ["f32"],      "parameter": ["i32"],                  "immediate": [], "b3op": "BitwiseCast"  },
        "f64.convert_s/i32":   { "category": "conversion", "value": 183, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
        "f64.convert_u/i32":   { "category": "conversion", "value": 184, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
        "f64.convert_s/i64":   { "category": "conversion", "value": 185, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
        "f64.convert_u/i64":   { "category": "conversion", "value": 186, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
        "f64.promote/f32":     { "category": "conversion", "value": 187, "return": ["f64"],      "parameter": ["f32"],                  "immediate": [], "b3op": "FloatToDouble"},
        "f64.reinterpret/i64": { "category": "conversion", "value": 191, "return": ["f64"],      "parameter": ["i64"],                  "immediate": [], "b3op": "BitwiseCast"  },
        "i32.reinterpret/f32": { "category": "conversion", "value": 188, "return": ["i32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "BitwiseCast"  },
        "i64.reinterpret/f64": { "category": "conversion", "value": 189, "return": ["i64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "BitwiseCast"  }
    }
}



2016-11-29  JF Bastien  <jfbastien@apple.com>

        WebAssembly: update binary format to 0xD version
        https://bugs.webkit.org/show_bug.cgi?id=164724

        Reviewed by Saam Barati.

        As described in the following PR: https://github.com/WebAssembly/design/pull/836

        * wasm/WasmB3IRGenerator.cpp:
        (JSC::Wasm::B3IRGenerator::B3IRGenerator):
        (JSC::Wasm::B3IRGenerator::zeroForType):
        (JSC::Wasm::B3IRGenerator::addConstant):
        (JSC::Wasm::createJSWrapper):
        * wasm/WasmCallingConvention.h:
        (JSC::Wasm::CallingConvention::marshallArgument):
        * wasm/WasmFormat.cpp:
        (JSC::Wasm::toString): Deleted.
        * wasm/WasmFormat.h:
        (JSC::Wasm::isValueType):
        (JSC::Wasm::toB3Type): Deleted.
        * wasm/WasmFunctionParser.h:
        (JSC::Wasm::FunctionParser<Context>::parseExpression):
        * wasm/WasmModuleParser.cpp:
        (JSC::Wasm::ModuleParser::parse):
        (JSC::Wasm::ModuleParser::parseType):
        * wasm/WasmModuleParser.h:
        * wasm/WasmParser.h:
        (JSC::Wasm::Parser::parseResultType):
        * wasm/generateWasm.py:
        (Wasm.__init__):
        * wasm/generateWasmOpsHeader.py:
        (cppMacro):
        (typeMacroizer):
        (opcodeMacroizer):
        * wasm/wasm.json:

2016-11-30  Darin Adler  <darin@apple.com>

        Roll out StringBuilder changes from the previous patch.



    Vector<UnlinkedCall>& m_unlinkedCalls;
    GPRReg m_memoryBaseGPR;
    GPRReg m_memorySizeGPR;
    Value* m_zeroValues[numTypes];
};

B3IRGenerator::B3IRGenerator(Memory* memory, Procedure& procedure, Vector<UnlinkedCall>& unlinkedCalls)

{
    m_currentBlock = m_proc.addBlock();

    for (unsigned i = 0; i < numTypes; ++i) {
        switch (B3::Type b3Type = toB3Type(linearizedToType(i))) {
        case B3::Int32:
        case B3::Int64:
        case B3::Float:
        case B3::Double:
            m_zeroValues[i] = m_currentBlock->appendIntConstant(m_proc, Origin(), b3Type, 0);
            break;
        case B3::Void:
            m_zeroValues[i] = nullptr;
            break;
        }
    }

    if (m_memory) {
        m_memoryBaseGPR = m_memory->pinnedRegisters().baseMemoryPointer;

Value* B3IRGenerator::zeroForType(Type type)
{
    ASSERT(type != Void);
    Value* zeroValue = m_zeroValues[linearizeType(type)];
    ASSERT(zeroValue);
    return zeroValue;
}

bool B3IRGenerator::addLocal(Type type, uint32_t count)

B3IRGenerator::ExpressionType B3IRGenerator::addConstant(Type type, uint64_t value)
{
    switch (type) {
    case Wasm::I32:
        return m_currentBlock->appendNew<Const32Value>(m_proc, Origin(), static_cast<int32_t>(value));
    case Wasm::I64:
        return m_currentBlock->appendNew<Const64Value>(m_proc, Origin(), value);
    case Wasm::F32:
        return m_currentBlock->appendNew<ConstFloatValue>(m_proc, Origin(), bitwise_cast<float>(static_cast<int32_t>(value)));
    case Wasm::F64:
        return m_currentBlock->appendNew<ConstDoubleValue>(m_proc, Origin(), bitwise_cast<double>(value));
    case Wasm::Void:
    case Wasm::Func:
    case Wasm::Anyfunc:
        break;
    }
    RELEASE_ASSERT_NOT_REACHED();
    return nullptr;
}

B3IRGenerator::ControlData B3IRGenerator::addBlock(Type signature)


    // Return the result, if needed.
    switch (signature->returnType) {
    case Wasm::Void:
        block->appendNewControlValue(proc, B3::Return, Origin());
        break;
    case Wasm::F32:
    case Wasm::F64:
        result = block->appendNew<Value>(proc, BitwiseCast, Origin(), result);
        FALLTHROUGH;
    case Wasm::I32:
    case Wasm::I64:
        block->appendNewControlValue(proc, B3::Return, Origin(), result);
        break;
    case Wasm::Func:
    case Wasm::Anyfunc:
        RELEASE_ASSERT_NOT_REACHED();
    }

    return std::make_unique<Compilation>(vm, proc);

Lines 76-82 private: a/Source/JavaScriptCore/wasm/WasmCallingConvention.h_sec1
- a/Source/JavaScriptCore/wasm/WasmCallingConvention.h -1 / +1 lines
76	case B3::Float:	76	case B3::Float:
77	case B3::Double:	77	case B3::Double:
78	return marshallArgumentImpl(m_fprArgs, type, fpArgumentCount, stackOffset);	78	return marshallArgumentImpl(m_fprArgs, type, fpArgumentCount, stackOffset);
79	case Void:	79	case B3::Void:
80	break;	80	break;
81	}	81	}
82	RELEASE_ASSERT_NOT_REACHED();	82	RELEASE_ASSERT_NOT_REACHED();




#include "WasmMemory.h"

#if COMPILER(GCC) && ASSERT_DISABLED
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreturn-type"
#endif // COMPILER(GCC) && ASSERT_DISABLED

namespace JSC { namespace Wasm {

const char* toString(Type type)
{
    switch (type) {
    case Void:
        return "void";
    case I32:
        return "i32";
    case I64:
        return "i64";
    case F32:
        return "f32";
    case F64:
        return "f64";
    }
}

ModuleInformation::~ModuleInformation() { }

} } // namespace JSC::Wasm

#if COMPILER(GCC) && ASSERT_DISABLED
#pragma GCC diagnostic pop
#endif // COMPILER(GCC) && ASSERT_DISABLED

#endif // ENABLE(WEBASSEMBLY)



#include "B3Type.h"
#include "CodeLocation.h"
#include "Identifier.h"
#include "WasmOps.h"
#include <wtf/Vector.h>

namespace JSC {


namespace Wasm {

enum Type : uint8_t {
    Void,
    I32,
    I64,
    F32,
    F64,
    LastValueType = F64,
};

static_assert(I32 == 1, "Wasm needs I32 to have the value 1");
static_assert(I64 == 2, "Wasm needs I64 to have the value 2");
static_assert(F32 == 3, "Wasm needs F32 to have the value 3");
static_assert(F64 == 4, "Wasm needs F64 to have the value 4");

inline B3::Type toB3Type(Type type)
{
    switch (type) {
    case I32: return B3::Int32;
    case I64: return B3::Int64;
    case F32: return B3::Float;
    case F64: return B3::Double;
    case Void: return B3::Void;
    default: break;
    }
    RELEASE_ASSERT_NOT_REACHED();
}

inline bool isValueType(Type type)
{
    switch (type) {

    }
    return false;
}

const char* toString(Type);
    
struct External {
    enum Kind : uint8_t {
        // FIXME auto-generate this. https://bugs.webkit.org/show_bug.cgi?id=165231
        Function = 0,
        Table = 1,
        Memory = 2,



bool FunctionParser<Context>::parseExpression(OpType op)
{
    switch (op) {
#define CREATE_CASE(name, id, b3op, inc) case OpType::name: return binaryCase<OpType::name>();
    FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
#undef CREATE_CASE

#define CREATE_CASE(name, id, b3op, inc) case OpType::name: return unaryCase<OpType::name>();
    FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
#undef CREATE_CASE


        return true;
    }

#define CREATE_CASE(name, id, b3op, inc) case OpType::name:
    FOR_EACH_WASM_MEMORY_LOAD_OP(CREATE_CASE) {
        uint32_t alignment;
        if (!parseVarUInt32(alignment))



        return false;
    }

    // Skip the version number for now since we don't do anything with it.
    uint32_t versionNumber;
    if (!parseUInt32(versionNumber)) {
        // FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919

        return false;
    }

    if (versionNumber != expectedVersionNumber) {
        // FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919
        m_errorMessage = "unexpected version number";
        return false;

        int8_t type;
        if (!parseInt7(type))
            return false;
        if (type != Func)
            return false;

        if (verbose)



class ModuleParser : public Parser {
public:

    static const unsigned magicNumber = 0xc;

    ModuleParser(VM* vm, const uint8_t* sourceBuffer, size_t sourceLength)
        : Parser(sourceBuffer, sourceLength)
        , m_vm(vm)




ALWAYS_INLINE bool Parser::parseResultType(Type& result)
{
    int8_t value;
    if (!parseInt7(value))
        return false;
    if (!isValidType(value))
        return false;
    result = static_cast<Type>(value);
    return true;

Lines 33-38 class Wasm: a/Source/JavaScriptCore/wasm/generateWasm.py_sec1
- a/Source/JavaScriptCore/wasm/generateWasm.py +5 lines
33	wasmFile = open(jsonPath, "r")	33	wasmFile = open(jsonPath, "r")
34	wasm = json.load(open(jsonPath, "r"))	34	wasm = json.load(open(jsonPath, "r"))
35	wasmFile.close()	35	wasmFile.close()
		36	for pre in wasm["preamble"]:
		37	if pre["name"] == "version":
		38	self.expectedVersionNumber = str(pre["value"])
		39	self.preamble = wasm["preamble"]
		40	self.types = wasm["type"]
36	self.opcodes = wasm["opcode"]	41	self.opcodes = wasm["opcode"]
37	self.header = """/*	42	self.header = """/*
38	* Copyright (C) 2016 Apple Inc. All rights reserved.	43	* Copyright (C) 2016 Apple Inc. All rights reserved.



    parser.error(parser.usage)

wasm = Wasm(args[0], args[1])
types = wasm.types
opcodes = wasm.opcodes
wasmOpsHFile = open(args[2], "w")


def cppMacro(wasmOpcode, value, b3, inc):
    return " \\\n    macro(" + wasm.toCpp(wasmOpcode) + ", " + hex(int(value)) + ", " + b3 + ", " + str(inc) + ")"


def typeMacroizer():
    inc = 0
    for ty in wasm.types:
        yield cppMacro(ty, wasm.types[ty]["value"], wasm.types[ty]["b3type"], inc)
        inc += 1

type_definitions = ["#define FOR_EACH_WASM_TYPE(macro)"]
type_definitions.extend([t for t in typeMacroizer()])
type_definitions = "".join(type_definitions)


def opcodeMacroizer(filter):
    inc = 0
    for op in wasm.opcodeIterator(filter):
        b3op = "Oops"
        if isSimple(op["opcode"]):
            b3op = op["opcode"]["b3op"]
        yield cppMacro(op["name"], op["opcode"]["value"], b3op, inc)
        inc += 1

defines = ["#define FOR_EACH_WASM_SPECIAL_OP(macro)"]
defines.extend([op for op in opcodeMacroizer(lambda op: op["category"] == "special" or op["category"] == "call")])


namespace JSC { namespace Wasm {

static constexpr unsigned expectedVersionNumber = """ + wasm.expectedVersionNumber + """;

static constexpr unsigned numTypes = """ + str(len(types)) + """;

""" + type_definitions + """
#define CREATE_ENUM_VALUE(name, id, b3type, inc) name = id,
enum Type : int8_t {
    FOR_EACH_WASM_TYPE(CREATE_ENUM_VALUE)
};
#undef CREATE_ENUM_VALUE

#define CREATE_CASE(name, id, b3type, inc) case id: return true;
template <typename Int>
inline bool isValidType(Int i)
{
    switch (i) {
    default: return false;
    FOR_EACH_WASM_TYPE(CREATE_CASE)
    }
    RELEASE_ASSERT_NOT_REACHED();
    return false;
}
#undef CREATE_CASE

#define CREATE_CASE(name, id, b3type, inc) case name: return b3type;
inline B3::Type toB3Type(Type type)
{
    switch (type) {
    FOR_EACH_WASM_TYPE(CREATE_CASE)
    }
    RELEASE_ASSERT_NOT_REACHED();
    return B3::Void;
}
#undef CREATE_CASE

#define CREATE_CASE(name, id, b3type, inc) case name: return "name";
inline const char* toString(Type type)
{
    switch (type) {
    FOR_EACH_WASM_TYPE(CREATE_CASE)
    }
    RELEASE_ASSERT_NOT_REACHED();
    return nullptr;
}
#undef CREATE_CASE

#define CREATE_CASE(name, id, b3type, inc) case id: return inc;
inline int linearizeType(Type type)
{
    switch (type) {
    FOR_EACH_WASM_TYPE(CREATE_CASE)
    }
    RELEASE_ASSERT_NOT_REACHED();
    return 0;
}
#undef CREATE_CASE

#define CREATE_CASE(name, id, b3type, inc) case inc: return name;
inline Type linearizedToType(int i)
{
    switch (i) {
    FOR_EACH_WASM_TYPE(CREATE_CASE)
    }
    RELEASE_ASSERT_NOT_REACHED();
    return Void;
}
#undef CREATE_CASE


""" + defines + """
#define FOR_EACH_WASM_OP(macro) \\
    FOR_EACH_WASM_SPECIAL_OP(macro) \\

    FOR_EACH_WASM_MEMORY_LOAD_OP(macro) \\
    FOR_EACH_WASM_MEMORY_STORE_OP(macro)

#define CREATE_ENUM_VALUE(name, id, b3op, inc) name = id,

enum OpType : uint8_t {
    FOR_EACH_WASM_OP(CREATE_ENUM_VALUE)

inline bool isControlOp(OpType op)
{
    switch (op) {
#define CREATE_CASE(name, id, b3op, inc) case OpType::name:
    FOR_EACH_WASM_CONTROL_FLOW_OP(CREATE_CASE)
        return true;
#undef CREATE_CASE

inline bool isSimple(UnaryOpType op)
{
    switch (op) {
#define CREATE_CASE(name, id, b3op, inc) case UnaryOpType::name:
    FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
        return true;
#undef CREATE_CASE

inline bool isSimple(BinaryOpType op)
{
    switch (op) {
#define CREATE_CASE(name, id, b3op, inc) case BinaryOpType::name:
    FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
        return true;
#undef CREATE_CASE



    for (unsigned argIndex = 0; argIndex < state->argumentCount(); ++argIndex) {
        JSValue arg = state->uncheckedArgument(argIndex);
        switch (signature->arguments[argIndex]) {
        case Wasm::Void:
        case Wasm::I64:
            RELEASE_ASSERT_NOT_REACHED();
            break;
        case Wasm::I32:
            arg = JSValue::decode(arg.toInt32(state));
            break;

        case Wasm::F64:
            arg = JSValue::decode(bitwise_cast<uint64_t>(arg.toNumber(state)));
            break;
        case Wasm::Void:
        case Wasm::I64:
        case Wasm::Func:
        case Wasm::Anyfunc:
            RELEASE_ASSERT_NOT_REACHED();
        }
        RETURN_IF_EXCEPTION(scope, encodedJSValue());
        boxedArgs.append(arg);

    switch (signature->returnType) {
    case Wasm::Void:
        return JSValue::encode(jsUndefined());
    case Wasm::I64:
        RELEASE_ASSERT_NOT_REACHED();
    case Wasm::I32:
        return JSValue::encode(JSValue(static_cast<int32_t>(rawResult)));
    case Wasm::F32:
        return JSValue::encode(JSValue(bitwise_cast<float>(static_cast<int32_t>(rawResult))));
    case Wasm::F64:
        return JSValue::encode(JSValue(bitwise_cast<double>(rawResult)));
    case Wasm::I64:
    case Wasm::Func:
    case Wasm::Anyfunc:
        break;
    }

    RELEASE_ASSERT_NOT_REACHED();
    return EncodedJSValue();
}

WebAssemblyFunction* WebAssemblyFunction::create(VM& vm, JSGlobalObject* globalObject, int length, const String& name, JSWebAssemblyInstance* instance, CallableWebAssemblyFunction&& callable)



{
    "comments": ["This file describes the WebAssembly ISA.",
                 "Scripts in this folder auto-generate C++ code for JavaScriptCore as well as the testing DSL which WebKit's WebAssembly tests use."
                 "When you update this file you need to re-generate the C++ code: jsc ./JSTests/stress/wasm/generate-wasmops-header.js > ./Source/JavaScriptCore/wasm/WASMOps.h"
                ],
    "preamble": [
        { "name": "magic number", "type": "uint32", "value": 1836278016, "description": "NULL character followed by 'asm'" },
        { "name": "version",      "type": "uint32", "value":         13, "description": "Version number, will be reset to 1 for MVP" }
    ],
    "type" : {
        "i32":     { "type": "varint7", "value":  -1, "b3type": "B3::Int32" },
        "i64":     { "type": "varint7", "value":  -2, "b3type": "B3::Int64" },
        "f32":     { "type": "varint7", "value":  -3, "b3type": "B3::Float" },
        "f64":     { "type": "varint7", "value":  -4, "b3type": "B3::Double" },
        "anyfunc": { "type": "varint7", "value": -16, "b3type": "B3::Void" },
        "func":    { "type": "varint7", "value": -32, "b3type": "B3::Void" },
        "void":    { "type": "varint7", "value": -64, "b3type": "B3::Void" }
        "i32":  { "type": "uint8", "value": 1 },
        "i64":  { "type": "uint8", "value": 2 },
        "f32":  { "type": "uint8", "value": 3 },
        "f64":  { "type": "uint8", "value": 4 }
    },
    "value_type": ["i32", "i64", "f32", "f64"],
    "block_type": ["i32", "i64", "f32", "f64", "void"],
    "elem_type": ["anyfunc"],
    "external_kind": {
        "Function": { "type": "uint8", "value": 0 },
        "Table":    { "type": "uint8", "value": 1 },

    },
    "opcode": {
        "unreachable":         { "category": "control",    "value":   0, "return": [],           "parameter": [],                      "immediate": [],                                                                                         "description": "trap immediately" },
        "block":               { "category": "control",    "value":   2, "return": ["control"],  "parameter": [],                      "immediate": [{"name": "sig", "type": "block_type"}],                                                    "description": "begin a sequence of expressions, yielding 0 or 1 values" },
        "loop":                { "category": "control",    "value":   3, "return": ["control"],  "parameter": [],                      "immediate": [{"name": "sig", "type": "block_type"}],                                                    "description": "begin a block which can also form control flow loops" },
        "if":                  { "category": "control",    "value":   4, "return": ["control"],  "parameter": ["bool"],                "immediate": [{"name": "sig", "type": "block_type"}],                                                    "description": "begin if expression" },
        "else":                { "category": "control",    "value":   5, "return": ["control"],  "parameter": [],                      "immediate": [],                                                                                         "description": "begin else expression of if" },
        "select":              { "category": "control",    "value":  27, "return": ["prev"],     "parameter": ["any", "prev", "bool"], "immediate": [],                                                                                         "description": "select one of two values based on condition" },
        "br":                  { "category": "control",    "value":  12, "return": [],           "parameter": [],                      "immediate": [{"name": "relative_depth", "type": "varuint32"}],                                          "description": "break that targets an outer nested block" },
        "br_if":               { "category": "control",    "value":  13, "return": [],           "parameter": [],                      "immediate": [{"name": "relative_depth", "type": "varuint32"}],                                          "description": "conditional break that targets an outer nested block" },
        "br_table":            { "category": "control",    "value":  14, "return": [],           "parameter": [],                      "immediate": [{"name": "target_count",   "type": "varuint32",                                            "description": "number of entries in the target_table"},
                                                                                                                                                     {"name": "target_table",   "type": "varuint32*",                                           "description": "target entries that indicate an outer block or loop to which to break"},
                                                                                                                                                     {"name": "default_target", "type": "varuint32",                                            "description": "an outer block or loop to which to break in the default case"}],
                                                                                                                                                                                                                                                "description": "branch table control flow construct" },
        "return":              { "category": "control",    "value":  15, "return": [],           "parameter": [],                       "immediate": [],                                                                                         "description": "return zero or one value from this function" },
        "drop":                { "category": "control",    "value":  26, "return": [],           "parameter": ["any"],                  "immediate": [],                                                                                         "description": "ignore value" },
        "nop":                 { "category": "control",    "value":   1, "return": [],           "parameter": [],                       "immediate": [],                                                                                         "description": "no operation" },
        "end":                 { "category": "control",    "value":  11, "return": [],           "parameter": [],                       "immediate": [],                                                                                         "description": "end a block, loop, or if" },
        "i32.const":           { "category": "special",    "value":  65, "return": ["i32"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "varint32"}],                                           "description": "a constant value interpreted as i32" },
        "i64.const":           { "category": "special",    "value":  66, "return": ["i64"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "varint64"}],                                           "description": "a constant value interpreted as i64" },
        "f64.const":           { "category": "special",    "value":  68, "return": ["f64"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "uint64"}],                                             "description": "a constant value interpreted as f64" },
        "f32.const":           { "category": "special",    "value":  67, "return": ["f32"],      "parameter": [],                       "immediate": [{"name": "value",          "type": "uint32"}],                                             "description": "a constant value interpreted as f32" },
        "get_local":           { "category": "special",    "value":  32, "return": ["local"],    "parameter": [],                       "immediate": [{"name": "local_index",    "type": "varuint32"}],                                          "description": "read a local variable or parameter" },
        "set_local":           { "category": "special",    "value":  33, "return": [],           "parameter": ["local"],                "immediate": [{"name": "local_index",    "type": "varuint32"}],                                          "description": "write a local variable or parameter" },
        "tee_local":           { "category": "special",    "value":  34, "return": ["prev"],     "parameter": ["any"],                  "immediate": [{"name": "local_index",    "type": "varuint32"}],                                          "description": "write a local variable or parameter and return the same value" },
        "get_global":          { "category": "special",    "value":  35, "return": ["global"],   "parameter": [],                       "immediate": [{"name": "global_index",   "type": "varuint32"}],                                          "description": "read a global variable" },
        "set_global":          { "category": "special",    "value":  36, "return": [""],         "parameter": ["global"],               "immediate": [{"name": "global_index",   "type": "varuint32"}],                                          "description": "write a global variable" },
        "call":                { "category": "call",       "value":  16, "return": ["call"],     "parameter": ["call"],                 "immediate": [{"name": "function_index", "type": "varuint32"}],                                          "description": "call a function by its index" },
        "call_indirect":       { "category": "call",       "value":  17, "return": ["call"],     "parameter": ["call"],                 "immediate": [{"name": "type_index",     "type": "varuint32"}],                                          "description": "call a function indirect with an expected signature" },
        "i32.load8_s":         { "category": "memory",     "value":  44, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load8_u":         { "category": "memory",     "value":  45, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load16_s":        { "category": "memory",     "value":  46, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load16_u":        { "category": "memory",     "value":  47, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load8_s":         { "category": "memory",     "value":  48, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load8_u":         { "category": "memory",     "value":  49, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load16_s":        { "category": "memory",     "value":  50, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load16_u":        { "category": "memory",     "value":  51, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load32_s":        { "category": "memory",     "value":  52, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load32_u":        { "category": "memory",     "value":  53, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.load":            { "category": "memory",     "value":  40, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i64.load":            { "category": "memory",     "value":  41, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "f32.load":            { "category": "memory",     "value":  42, "return": ["f32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "f64.load":            { "category": "memory",     "value":  43, "return": ["f64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
        "i32.store8":          { "category": "memory",     "value":  58, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i32.store16":         { "category": "memory",     "value":  59, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store8":          { "category": "memory",     "value":  60, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store16":         { "category": "memory",     "value":  61, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store32":         { "category": "memory",     "value":  62, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i32.store":           { "category": "memory",     "value":  54, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "i64.store":           { "category": "memory",     "value":  55, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "f32.store":           { "category": "memory",     "value":  56, "return": [],           "parameter": ["addr", "f32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "f64.store":           { "category": "memory",     "value":  57, "return": [],           "parameter": ["addr", "f64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
        "current_memory":      { "category": "operation",  "value":  63, "return": ["size"],     "parameter": [],                       "immediate": [],                                                                                         "description": "query the size of memory" },
        "grow_memory":         { "category": "operation",  "value":  64, "return": ["size"],     "parameter": ["size"],                 "immediate": [],                                                                                         "description": "grow the size of memory" },
        "i32.add":             { "category": "arithmetic", "value": 106, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Add"          },
        "i32.sub":             { "category": "arithmetic", "value": 107, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Sub"          },
        "i32.mul":             { "category": "arithmetic", "value": 108, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Mul"          },
        "i32.div_s":           { "category": "arithmetic", "value": 109, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Div"          },
        "i32.div_u":           { "category": "arithmetic", "value": 110, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "UDiv"         },
        "i32.rem_s":           { "category": "arithmetic", "value": 111, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Mod"          },
        "i32.rem_u":           { "category": "arithmetic", "value": 112, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "UMod"         },
        "i32.and":             { "category": "arithmetic", "value": 113, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BitAnd"       },
        "i32.or":              { "category": "arithmetic", "value": 114, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BitOr"        },
        "i32.xor":             { "category": "arithmetic", "value": 115, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BitXor"       },
        "i32.shl":             { "category": "arithmetic", "value": 116, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Shl"          },
        "i32.shr_u":           { "category": "arithmetic", "value": 118, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "SShr"         },
        "i32.shr_s":           { "category": "arithmetic", "value": 117, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "ZShr"         },
        "i32.rotr":            { "category": "arithmetic", "value": 120, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "RotR"         },
        "i32.rotl":            { "category": "arithmetic", "value": 119, "return": ["i32"],      "parameter": ["i32", "i32"],           "immediate": [], "b3op": "RotL"         },
        "i32.eq":              { "category": "comparison", "value":  70, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Equal"        },
        "i32.ne":              { "category": "comparison", "value":  71, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "NotEqual"     },
        "i32.lt_s":            { "category": "comparison", "value":  72, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "LessThan"     },
        "i32.le_s":            { "category": "comparison", "value":  76, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "LessEqual"    },
        "i32.lt_u":            { "category": "comparison", "value":  73, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Below"        },
        "i32.le_u":            { "category": "comparison", "value":  77, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "BelowEqual"   },
        "i32.gt_s":            { "category": "comparison", "value":  74, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "GreaterThan"  },
        "i32.ge_s":            { "category": "comparison", "value":  78, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "GreaterEqual" },
        "i32.gt_u":            { "category": "comparison", "value":  75, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "Above"        },
        "i32.ge_u":            { "category": "comparison", "value":  79, "return": ["bool"],     "parameter": ["i32", "i32"],           "immediate": [], "b3op": "AboveEqual"   },
        "i32.clz":             { "category": "arithmetic", "value": 103, "return": ["i32"],      "parameter": ["i32"],                  "immediate": [], "b3op": "Clz"          },
        "i32.ctz":             { "category": "arithmetic", "value": 104, "return": ["i32"],      "parameter": ["i32"],                  "immediate": []                         },
        "i32.popcnt":          { "category": "arithmetic", "value": 105, "return": ["i32"],      "parameter": ["i32"],                  "immediate": []                         },
        "i32.eqz":             { "category": "comparison", "value":  69, "return": ["bool"],     "parameter": ["i32"],                  "immediate": [], "b3op": "Equal(i32(0), @0)" },
        "i64.add":             { "category": "arithmetic", "value": 124, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Add"          },
        "i64.sub":             { "category": "arithmetic", "value": 125, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Sub"          },
        "i64.mul":             { "category": "arithmetic", "value": 126, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Mul"          },
        "i64.div_s":           { "category": "arithmetic", "value": 127, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Div"          },
        "i64.div_u":           { "category": "arithmetic", "value": 128, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "UDiv"         },
        "i64.rem_s":           { "category": "arithmetic", "value": 129, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Mod"          },
        "i64.rem_u":           { "category": "arithmetic", "value": 130, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "UDiv"         },
        "i64.and":             { "category": "arithmetic", "value": 131, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BitAnd"       },
        "i64.or":              { "category": "arithmetic", "value": 132, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BitOr"        },
        "i64.xor":             { "category": "arithmetic", "value": 133, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BitXor"       },
        "i64.shl":             { "category": "arithmetic", "value": 134, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Shl"          },
        "i64.shr_u":           { "category": "arithmetic", "value": 136, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "SShr"         },
        "i64.shr_s":           { "category": "arithmetic", "value": 135, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "ZShr"         },
        "i64.rotr":            { "category": "arithmetic", "value": 138, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "RotR"         },
        "i64.rotl":            { "category": "arithmetic", "value": 137, "return": ["i64"],      "parameter": ["i64", "i64"],           "immediate": [], "b3op": "RotL"         },
        "i64.eq":              { "category": "comparison", "value":  81, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Equal"        },
        "i64.ne":              { "category": "comparison", "value":  82, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "NotEqual"     },
        "i64.lt_s":            { "category": "comparison", "value":  83, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "LessThan"     },
        "i64.le_s":            { "category": "comparison", "value":  87, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "LessEqual"    },
        "i64.lt_u":            { "category": "comparison", "value":  84, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Below"        },
        "i64.le_u":            { "category": "comparison", "value":  88, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "BelowEqual"   },
        "i64.gt_s":            { "category": "comparison", "value":  85, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "GreaterThan"  },
        "i64.ge_s":            { "category": "comparison", "value":  89, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "GreaterEqual" },
        "i64.gt_u":            { "category": "comparison", "value":  86, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "Above"        },
        "i64.ge_u":            { "category": "comparison", "value":  90, "return": ["bool"],     "parameter": ["i64", "i64"],           "immediate": [], "b3op": "AboveEqual"   },
        "i64.clz":             { "category": "arithmetic", "value": 121, "return": ["i64"],      "parameter": ["i64"],                  "immediate": [], "b3op": "Clz"          },
        "i64.ctz":             { "category": "arithmetic", "value": 122, "return": ["i64"],      "parameter": ["i64"],                  "immediate": []                         },
        "i64.popcnt":          { "category": "arithmetic", "value": 123, "return": ["i64"],      "parameter": ["i64"],                  "immediate": []                         },
        "i64.eqz":             { "category": "comparison", "value":  80, "return": ["bool"],     "parameter": ["i64"],                  "immediate": [], "b3op": "Equal(i32(0), @0)" },
        "f32.add":             { "category": "arithmetic", "value": 146, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Add"          },
        "f32.sub":             { "category": "arithmetic", "value": 147, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Sub"          },
        "f32.mul":             { "category": "arithmetic", "value": 148, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Mul"          },
        "f32.div":             { "category": "arithmetic", "value": 149, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Div"          },
        "f32.min":             { "category": "arithmetic", "value": 150, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @0, @1)" },
        "f32.max":             { "category": "arithmetic", "value": 151, "return": ["f32"],      "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @1, @0)" },
        "f32.abs":             { "category": "arithmetic", "value": 139, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Abs"          },
        "f32.neg":             { "category": "arithmetic", "value": 140, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Neg"          },
        "f32.copysign":        { "category": "arithmetic", "value": 152, "return": ["f32"],      "parameter": ["f32"],                  "immediate": []                         },
        "f32.ceil":            { "category": "arithmetic", "value": 141, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Ceil"         },
        "f32.floor":           { "category": "arithmetic", "value": 142, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Floor"        },
        "f32.trunc":           { "category": "arithmetic", "value": 143, "return": ["f32"],      "parameter": ["f32"],                  "immediate": []                         },
        "f32.nearest":         { "category": "arithmetic", "value": 144, "return": ["f32"],      "parameter": ["f32"],                  "immediate": []                         },
        "f32.sqrt":            { "category": "arithmetic", "value": 145, "return": ["f32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "Sqrt"         },
        "f32.eq":              { "category": "comparison", "value":  91, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "Equal"        },
        "f32.ne":              { "category": "comparison", "value":  92, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "NotEqual"     },
        "f32.lt":              { "category": "comparison", "value":  93, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "LessThan"     },
        "f32.le":              { "category": "comparison", "value":  95, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "LessEqual"    },
        "f32.gt":              { "category": "comparison", "value":  94, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "GreaterThan"  },
        "f32.ge":              { "category": "comparison", "value":  96, "return": ["bool"],     "parameter": ["f32", "f32"],           "immediate": [], "b3op": "GreaterEqual" },
        "f64.add":             { "category": "arithmetic", "value": 160, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Add"          },
        "f64.sub":             { "category": "arithmetic", "value": 161, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Sub"          },
        "f64.mul":             { "category": "arithmetic", "value": 162, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Mul"          },
        "f64.div":             { "category": "arithmetic", "value": 163, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Div"          },
        "f64.min":             { "category": "arithmetic", "value": 164, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @0, @1)" },
        "f64.max":             { "category": "arithmetic", "value": 165, "return": ["f64"],      "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Select(LessThan(@0, @1), @1, @0)" },
        "f64.abs":             { "category": "arithmetic", "value": 153, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Abs"          },
        "f64.neg":             { "category": "arithmetic", "value": 154, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Neg"          },
        "f64.copysign":        { "category": "arithmetic", "value": 166, "return": ["f64"],      "parameter": ["f64"],                  "immediate": []                         },
        "f64.ceil":            { "category": "arithmetic", "value": 155, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Ceil"         },
        "f64.floor":           { "category": "arithmetic", "value": 156, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Floor"        },
        "f64.trunc":           { "category": "arithmetic", "value": 157, "return": ["f64"],      "parameter": ["f64"],                  "immediate": []                         },
        "f64.nearest":         { "category": "arithmetic", "value": 158, "return": ["f64"],      "parameter": ["f64"],                  "immediate": []                         },
        "f64.sqrt":            { "category": "arithmetic", "value": 159, "return": ["f64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "Sqrt"         },
        "f64.eq":              { "category": "comparison", "value":  97, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "Equal"        },
        "f64.ne":              { "category": "comparison", "value":  98, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "NotEqual"     },
        "f64.lt":              { "category": "comparison", "value":  99, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "LessThan"     },
        "f64.le":              { "category": "comparison", "value": 101, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "LessEqual"    },
        "f64.gt":              { "category": "comparison", "value": 100, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "GreaterThan"  },
        "f64.ge":              { "category": "comparison", "value": 102, "return": ["bool"],     "parameter": ["f64", "f64"],           "immediate": [], "b3op": "GreaterEqual" },
        "i32.trunc_s/f32":     { "category": "conversion", "value": 168, "return": ["i32"],      "parameter": ["f32"],                  "immediate": []                         },
        "i32.trunc_s/f64":     { "category": "conversion", "value": 170, "return": ["i32"],      "parameter": ["f64"],                  "immediate": []                         },
        "i32.trunc_u/f32":     { "category": "conversion", "value": 169, "return": ["i32"],      "parameter": ["f32"],                  "immediate": []                         },
        "i32.trunc_u/f64":     { "category": "conversion", "value": 171, "return": ["i32"],      "parameter": ["f64"],                  "immediate": []                         },
        "i32.wrap/i64":        { "category": "conversion", "value": 167, "return": ["i32"],      "parameter": ["i64"],                  "immediate": []                         },
        "i64.trunc_s/f32":     { "category": "conversion", "value": 174, "return": ["i64"],      "parameter": ["f32"],                  "immediate": []                         },
        "i64.trunc_s/f64":     { "category": "conversion", "value": 176, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         },
        "i64.trunc_u/f32":     { "category": "conversion", "value": 175, "return": ["i64"],      "parameter": ["f32"],                  "immediate": []                         },
        "i64.trunc_u/f64":     { "category": "conversion", "value": 177, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         },
        "i64.extend_s/i32":    { "category": "conversion", "value": 172, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "SExt32"       },
        "i64.extend_u/i32":    { "category": "conversion", "value": 173, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "ZExt32"       },
        "f32.convert_s/i32":   { "category": "conversion", "value": 178, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
        "f32.convert_u/i32":   { "category": "conversion", "value": 179, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
        "f32.convert_s/i64":   { "category": "conversion", "value": 180, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
        "f32.convert_u/i64":   { "category": "conversion", "value": 181, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
        "f32.demote/f64":      { "category": "conversion", "value": 182, "return": ["f32"],      "parameter": ["f64"],                  "immediate": [], "b3op": "DoubleToFloat"},
        "f32.reinterpret/i32": { "category": "conversion", "value": 190, "return": ["f32"],      "parameter": ["i32"],                  "immediate": [], "b3op": "BitwiseCast"  },
        "f64.convert_s/i32":   { "category": "conversion", "value": 183, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
        "f64.convert_u/i32":   { "category": "conversion", "value": 184, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
        "f64.convert_s/i64":   { "category": "conversion", "value": 185, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
        "f64.convert_u/i64":   { "category": "conversion", "value": 186, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
        "f64.promote/f32":     { "category": "conversion", "value": 187, "return": ["f64"],      "parameter": ["f32"],                  "immediate": [], "b3op": "FloatToDouble"},
        "f64.reinterpret/i64": { "category": "conversion", "value": 191, "return": ["f64"],      "parameter": ["i64"],                  "immediate": [], "b3op": "BitwiseCast"  },
        "i32.reinterpret/f32": { "category": "conversion", "value": 188, "return": ["i32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "BitwiseCast"  },
        "i64.reinterpret/f64": { "category": "conversion", "value": 189, "return": ["i64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "BitwiseCast"  }
    }
}
- 

Return to Bug 164724

Lines 186-192 private: a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp -16 / +35 lines
186	Vector<UnlinkedCall>& m_unlinkedCalls;	186	Vector<UnlinkedCall>& m_unlinkedCalls;
187	GPRReg m_memoryBaseGPR;	187	GPRReg m_memoryBaseGPR;
188	GPRReg m_memorySizeGPR;	188	GPRReg m_memorySizeGPR;
189	Value* m_zeroValues[Type::LastValueType];	189	Value* m_zeroValues[numTypes];
190	};	190	};
191		191
192	B3IRGenerator::B3IRGenerator(Memory* memory, Procedure& procedure, Vector<UnlinkedCall>& unlinkedCalls)	192	B3IRGenerator::B3IRGenerator(Memory* memory, Procedure& procedure, Vector<UnlinkedCall>& unlinkedCalls)
Lines 196-203 B3IRGenerator::B3IRGenerator(Memory* memory, Procedure& procedure, Vector<Unlink a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp_sec2
196	{	196	{
197	m_currentBlock = m_proc.addBlock();	197	m_currentBlock = m_proc.addBlock();
198		198
199	for (unsigned i = 0; i < Type::LastValueType; ++i)	199	for (unsigned i = 0; i < numTypes; ++i) {
200	m_zeroValues[i] = m_currentBlock->appendIntConstant(m_proc, Origin(), toB3Type(static_cast<Type>(i + 1)), 0);	200	switch (B3::Type b3Type = toB3Type(linearizedToType(i))) {
		201	case B3::Int32:
		202	case B3::Int64:
		203	case B3::Float:
		204	case B3::Double:
		205	m_zeroValues[i] = m_currentBlock->appendIntConstant(m_proc, Origin(), b3Type, 0);
		206	break;
		207	case B3::Void:
		208	m_zeroValues[i] = nullptr;
		209	break;
		210	}
		211	}
201		212
202	if (m_memory) {	213	if (m_memory) {
203	m_memoryBaseGPR = m_memory->pinnedRegisters().baseMemoryPointer;	214	m_memoryBaseGPR = m_memory->pinnedRegisters().baseMemoryPointer;
Lines 218-224 B3IRGenerator::B3IRGenerator(Memory* memory, Procedure& procedure, Vector<Unlink a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp_sec3
218	Value* B3IRGenerator::zeroForType(Type type)	229	Value* B3IRGenerator::zeroForType(Type type)
219	{	230	{
220	ASSERT(type != Void);	231	ASSERT(type != Void);
221	return m_zeroValues[type - 1];	232	Value* zeroValue = m_zeroValues[linearizeType(type)];
		233	ASSERT(zeroValue);
		234	return zeroValue;
222	}	235	}
223		236
224	bool B3IRGenerator::addLocal(Type type, uint32_t count)	237	bool B3IRGenerator::addLocal(Type type, uint32_t count)
Lines 441-458 bool B3IRGenerator::addSelect(ExpressionType condition, ExpressionType nonZero, a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp_sec4
441	B3IRGenerator::ExpressionType B3IRGenerator::addConstant(Type type, uint64_t value)	454	B3IRGenerator::ExpressionType B3IRGenerator::addConstant(Type type, uint64_t value)
442	{	455	{
443	switch (type) {	456	switch (type) {
444	case Int32:	457	case Wasm::I32:
445	return m_currentBlock->appendNew<Const32Value>(m_proc, Origin(), static_cast<int32_t>(value));	458	return m_currentBlock->appendNew<Const32Value>(m_proc, Origin(), static_cast<int32_t>(value));
446	case Int64:	459	case Wasm::I64:
447	return m_currentBlock->appendNew<Const64Value>(m_proc, Origin(), value);	460	return m_currentBlock->appendNew<Const64Value>(m_proc, Origin(), value);
448	case Float:	461	case Wasm::F32:
449	return m_currentBlock->appendNew<ConstFloatValue>(m_proc, Origin(), bitwise_cast<float>(static_cast<int32_t>(value)));	462	return m_currentBlock->appendNew<ConstFloatValue>(m_proc, Origin(), bitwise_cast<float>(static_cast<int32_t>(value)));
450	case Double:	463	case Wasm::F64:
451	return m_currentBlock->appendNew<ConstDoubleValue>(m_proc, Origin(), bitwise_cast<double>(value));	464	return m_currentBlock->appendNew<ConstDoubleValue>(m_proc, Origin(), bitwise_cast<double>(value));
452	default:	465	case Wasm::Void:
453	RELEASE_ASSERT_NOT_REACHED();	466	case Wasm::Func:
454	return nullptr;	467	case Wasm::Anyfunc:
		468	break;
455	}	469	}
		470	RELEASE_ASSERT_NOT_REACHED();
		471	return nullptr;
456	}	472	}
457		473
458	B3IRGenerator::ControlData B3IRGenerator::addBlock(Type signature)	474	B3IRGenerator::ControlData B3IRGenerator::addBlock(Type signature)
Lines 701-717 static std::unique_ptr<Compilation> createJSWrapper(VM& vm, const Signature* sig a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp_sec5
701		717
702	// Return the result, if needed.	718	// Return the result, if needed.
703	switch (signature->returnType) {	719	switch (signature->returnType) {
704	case Void:	720	case Wasm::Void:
705	block->appendNewControlValue(proc, B3::Return, Origin());	721	block->appendNewControlValue(proc, B3::Return, Origin());
706	break;	722	break;
707	case F32:	723	case Wasm::F32:
708	case F64:	724	case Wasm::F64:
709	result = block->appendNew<Value>(proc, BitwiseCast, Origin(), result);	725	result = block->appendNew<Value>(proc, BitwiseCast, Origin(), result);
710	FALLTHROUGH;	726	FALLTHROUGH;
711	case I32:	727	case Wasm::I32:
712	case I64:	728	case Wasm::I64:
713	block->appendNewControlValue(proc, B3::Return, Origin(), result);	729	block->appendNewControlValue(proc, B3::Return, Origin(), result);
714	break;	730	break;
		731	case Wasm::Func:
		732	case Wasm::Anyfunc:
		733	RELEASE_ASSERT_NOT_REACHED();
715	}	734	}
716		735
717	return std::make_unique<Compilation>(vm, proc);	736	return std::make_unique<Compilation>(vm, proc);

Lines 207-217 template<typename Context> a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec1
- a/Source/JavaScriptCore/wasm/WasmFunctionParser.h -3 / +3 lines
207	bool FunctionParser<Context>::parseExpression(OpType op)	207	bool FunctionParser<Context>::parseExpression(OpType op)
208	{	208	{
209	switch (op) {	209	switch (op) {
210	#define CREATE_CASE(name, id, b3op) case OpType::name: return binaryCase<OpType::name>();	210	#define CREATE_CASE(name, id, b3op, inc) case OpType::name: return binaryCase<OpType::name>();
211	FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)	211	FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
212	#undef CREATE_CASE	212	#undef CREATE_CASE
213		213
214	#define CREATE_CASE(name, id, b3op) case OpType::name: return unaryCase<OpType::name>();	214	#define CREATE_CASE(name, id, b3op, inc) case OpType::name: return unaryCase<OpType::name>();
215	FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)	215	FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
216	#undef CREATE_CASE	216	#undef CREATE_CASE
217		217
Lines 236-242 bool FunctionParser<Context>::parseExpression(OpType op) a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec2
236	return true;	236	return true;
237	}	237	}
238		238
239	#define CREATE_CASE(name, id, b3op) case OpType::name:	239	#define CREATE_CASE(name, id, b3op, inc) case OpType::name:
240	FOR_EACH_WASM_MEMORY_LOAD_OP(CREATE_CASE) {	240	FOR_EACH_WASM_MEMORY_LOAD_OP(CREATE_CASE) {
241	uint32_t alignment;	241	uint32_t alignment;
242	if (!parseVarUInt32(alignment))	242	if (!parseVarUInt32(alignment))

Lines 1-3 a/JSTests/ChangeLog_sec1
- a/JSTests/ChangeLog +25 lines
		1	2016-11-29 JF Bastien <jfbastien@apple.com>
		2
		3	WebAssembly: update binary format to 0xD version
		4	https://bugs.webkit.org/show_bug.cgi?id=164724
		5
		6	Reviewed by Saam Barati.
		7
		8	As described in the following PR: https://github.com/WebAssembly/design/pull/836
		9
		10	* wasm/Builder.js:
		11	(const._normalizeFunctionSignature):
		12	* wasm/Builder_WebAssemblyBinary.js:
		13	(const.emitters.Type):
		14	(const.emitters.Code):
		15	* wasm/LowLevelBinary.js:
		16	(export.default.LowLevelBinary.prototype.block_type):
		17	(export.default.LowLevelBinary.prototype.inline_signature_type): Deleted.
		18	* wasm/WASM.js:
		19	* wasm/js-api/test_basic_api.js:
		20	* wasm/self-test/test_BuilderWebAssembly.js:
		21	(EmptyModule):
		22	(CustomSection):
		23	* wasm/self-test/test_WASM.js:
		24	* wasm/wasm.json:
		25
1	2016-11-30 JF Bastien <jfbastien@apple.com>	26	2016-11-30 JF Bastien <jfbastien@apple.com>
2		27
3	WebAssembly builder: don't throw when checker not implemented	28	WebAssembly builder: don't throw when checker not implemented

Lines 51-57 const _normalizeFunctionSignature = (params, ret) => { a/JSTests/wasm/Builder.js_sec1
- a/JSTests/wasm/Builder.js -5 / +4 lines
51	if (typeof(ret) === "undefined")	51	if (typeof(ret) === "undefined")
52	ret = "void";	52	ret = "void";
53	assert.isNotArray(ret, `Multiple return values not supported by WebAssembly yet`);	53	assert.isNotArray(ret, `Multiple return values not supported by WebAssembly yet`);
54	assert.falsy(ret !== "void" && !WASM.isValidValueType(ret), `Type return ${ret} must be valid value type`);	54	assert.truthy(WASM.isValidBlockType(ret), `Type return ${ret} must be valid block type`);
55	return [params, ret];	55	return [params, ret];
56	};	56	};
57		57
Lines 156-162 const _exportFunctionContinuation = (builder, section, nextBuilder) => { a/JSTests/wasm/Builder.js_sec2
156		156
157	const _checkStackArgs = (op, param) => {	157	const _checkStackArgs = (op, param) => {
158	for (let expect of param) {	158	for (let expect of param) {
159	if (WASM.isValidValueType(expect)) {	159	if (WASM.isValidType(expect)) {
160	// FIXME implement stack checks for arguments. https://bugs.webkit.org/show_bug.cgi?id=163421	160	// FIXME implement stack checks for arguments. https://bugs.webkit.org/show_bug.cgi?id=163421
161	} else {	161	} else {
162	// Handle our own meta-types.	162	// Handle our own meta-types.
Lines 177-183 const _checkStackArgs = (op, param) => { a/JSTests/wasm/Builder.js_sec3
177		177
178	const _checkStackReturn = (op, ret) => {	178	const _checkStackReturn = (op, ret) => {
179	for (let expect of ret) {	179	for (let expect of ret) {
180	if (WASM.isValidValueType(expect)) {	180	if (WASM.isValidType(expect)) {
181	// FIXME implement stack checks for return. https://bugs.webkit.org/show_bug.cgi?id=163421	181	// FIXME implement stack checks for return. https://bugs.webkit.org/show_bug.cgi?id=163421
182	} else {	182	} else {
183	// Handle our own meta-types.	183	// Handle our own meta-types.
Lines 221-228 const _checkImms = (op, imms, expectedImms, ret) => { a/JSTests/wasm/Builder.js_sec4
221	case "default_target": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421	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	222	case "relative_depth": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
223	case "sig":	223	case "sig":
224	// FIXME this should be isValidBlockType https://bugs.webkit.org/show_bug.cgi?id=164724	224	assert.truthy(WASM.isValidBlockType(imms[idx]), `Invalid block type on ${op}: "${imms[idx]}"`);
225	assert.truthy(imms[idx] === "void" \|\| WASM.isValidValueType(imms[idx]), `Invalid block type on ${op}: "${imms[idx]}"`);
226	break;	225	break;
227	case "target_count": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421	226	case "target_count": break; // improve checking https://bugs.webkit.org/show_bug.cgi?id=163421
228	case "target_table": 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

Lines 33-48 const emitters = { a/JSTests/wasm/Builder_WebAssemblyBinary.js_sec1
- a/JSTests/wasm/Builder_WebAssemblyBinary.js -5 / +4 lines
33	Type: (section, bin) => {	33	Type: (section, bin) => {
34	put(bin, "varuint32", section.data.length);	34	put(bin, "varuint32", section.data.length);
35	for (const entry of section.data) {	35	for (const entry of section.data) {
36	const funcTypeConstructor = -0x20; // FIXME Move this to wasm.json.	36	put(bin, "varint7", WASM.typeValue["func"]);
37	put(bin, "varint7", funcTypeConstructor);
38	put(bin, "varuint32", entry.params.length);	37	put(bin, "varuint32", entry.params.length);
39	for (const param of entry.params)	38	for (const param of entry.params)
40	put(bin, "uint8", WASM.valueTypeValue[param]);	39	put(bin, "varint7", WASM.typeValue[param]);
41	if (entry.ret === "void")	40	if (entry.ret === "void")
42	put(bin, "varuint1", 0);	41	put(bin, "varuint1", 0);
43	else {	42	else {
44	put(bin, "varuint1", 1);	43	put(bin, "varuint1", 1);
45	put(bin, "uint8", WASM.valueTypeValue[entry.ret]);	44	put(bin, "varint7", WASM.typeValue[entry.ret]);
46	}	45	}
47	}	46	}
48	},	47	},
Lines 107-113 const emitters = { a/JSTests/wasm/Builder_WebAssemblyBinary.js_sec2
107	put(funcBin, "varuint32", localCount);	106	put(funcBin, "varuint32", localCount);
108	for (let i = func.parameterCount; i < func.locals.length; ++i) {	107	for (let i = func.parameterCount; i < func.locals.length; ++i) {
109	put(funcBin, "varuint32", 1);	108	put(funcBin, "varuint32", 1);
110	put(funcBin, "uint8", WASM.valueTypeValue[func.locals[i]]);	109	put(funcBin, "varint7", WASM.typeValue[func.locals[i]]);
111	}	110	}
112		111
113	for (const op of func.code) {	112	for (const op of func.code) {

Lines 2-18 import * as assert from '../assert.js'; a/JSTests/wasm/self-test/test_WASM.js_sec1
- a/JSTests/wasm/self-test/test_WASM.js -7 / +6 lines
2	import * as WASM from '../WASM.js';	2	import * as WASM from '../WASM.js';
3		3
4	assert.isNotUndef(WASM.description);	4	assert.isNotUndef(WASM.description);
5	assert.isNotUndef(WASM.valueType);	5	assert.isNotUndef(WASM.type);
6	assert.ge(WASM.valueType.length, 4);	6	assert.ge(WASM.type.length, 7);
7		7
8	for (const v of WASM.valueType)	8	for (const v of WASM.type)
9	if (!WASM.isValidValueType(v))	9	if (!WASM.isValidType(v))
10	throw new Error(`Expected value ${v} to be a valid value type`);	10	throw new Error(`Expected value ${v} to be a valid type`);
11		11
12	const expectedFields = [	12	const expectedFields = [
13	"preamble",	13	"preamble",
14	"value_type",	14	"type",
15	"inline_signature_type",
16	"external_kind",	15	"external_kind",
17	"section",	16	"section",
18	"opcode",	17	"opcode",

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +37 lines
		1	2016-11-29 JF Bastien <jfbastien@apple.com>
		2
		3	WebAssembly: update binary format to 0xD version
		4	https://bugs.webkit.org/show_bug.cgi?id=164724
		5
		6	Reviewed by Saam Barati.
		7
		8	As described in the following PR: https://github.com/WebAssembly/design/pull/836
		9
		10	* wasm/WasmB3IRGenerator.cpp:
		11	(JSC::Wasm::B3IRGenerator::B3IRGenerator):
		12	(JSC::Wasm::B3IRGenerator::zeroForType):
		13	(JSC::Wasm::B3IRGenerator::addConstant):
		14	(JSC::Wasm::createJSWrapper):
		15	* wasm/WasmCallingConvention.h:
		16	(JSC::Wasm::CallingConvention::marshallArgument):
		17	* wasm/WasmFormat.cpp:
		18	(JSC::Wasm::toString): Deleted.
		19	* wasm/WasmFormat.h:
		20	(JSC::Wasm::isValueType):
		21	(JSC::Wasm::toB3Type): Deleted.
		22	* wasm/WasmFunctionParser.h:
		23	(JSC::Wasm::FunctionParser<Context>::parseExpression):
		24	* wasm/WasmModuleParser.cpp:
		25	(JSC::Wasm::ModuleParser::parse):
		26	(JSC::Wasm::ModuleParser::parseType):
		27	* wasm/WasmModuleParser.h:
		28	* wasm/WasmParser.h:
		29	(JSC::Wasm::Parser::parseResultType):
		30	* wasm/generateWasm.py:
		31	(Wasm.__init__):
		32	* wasm/generateWasmOpsHeader.py:
		33	(cppMacro):
		34	(typeMacroizer):
		35	(opcodeMacroizer):
		36	* wasm/wasm.json:
		37
1	2016-11-30 Darin Adler <darin@apple.com>	38	2016-11-30 Darin Adler <darin@apple.com>
2		39
3	Roll out StringBuilder changes from the previous patch.	40	Roll out StringBuilder changes from the previous patch.

Lines 31-65 a/Source/JavaScriptCore/wasm/WasmFormat.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmFormat.cpp -25 lines
31		31
32	#include "WasmMemory.h"	32	#include "WasmMemory.h"
33		33
34	#if COMPILER(GCC) && ASSERT_DISABLED
35	#pragma GCC diagnostic push
36	#pragma GCC diagnostic ignored "-Wreturn-type"
37	#endif // COMPILER(GCC) && ASSERT_DISABLED
38
39	namespace JSC { namespace Wasm {	34	namespace JSC { namespace Wasm {
40		35
41	const char* toString(Type type)
42	{
43	switch (type) {
44	case Void:
45	return "void";
46	case I32:
47	return "i32";
48	case I64:
49	return "i64";
50	case F32:
51	return "f32";
52	case F64:
53	return "f64";
54	}
55	}
56
57	ModuleInformation::~ModuleInformation() { }	36	ModuleInformation::~ModuleInformation() { }
58		37
59	} } // namespace JSC::Wasm	38	} } // namespace JSC::Wasm
60		39
61	#if COMPILER(GCC) && ASSERT_DISABLED
62	#pragma GCC diagnostic pop
63	#endif // COMPILER(GCC) && ASSERT_DISABLED
64
65	#endif // ENABLE(WEBASSEMBLY)	40	#endif // ENABLE(WEBASSEMBLY)

Lines 31-36 a/Source/JavaScriptCore/wasm/WasmFormat.h_sec1
- a/Source/JavaScriptCore/wasm/WasmFormat.h -29 / +2 lines
31	#include "B3Type.h"	31	#include "B3Type.h"
32	#include "CodeLocation.h"	32	#include "CodeLocation.h"
33	#include "Identifier.h"	33	#include "Identifier.h"
		34	#include "WasmOps.h"
34	#include <wtf/Vector.h>	35	#include <wtf/Vector.h>
35		36
36	namespace JSC {	37	namespace JSC {
Lines 39-71 class JSFunction; a/Source/JavaScriptCore/wasm/WasmFormat.h_sec2
39		40
40	namespace Wasm {	41	namespace Wasm {
41		42
42	enum Type : uint8_t {
43	Void,
44	I32,
45	I64,
46	F32,
47	F64,
48	LastValueType = F64,
49	};
50
51	static_assert(I32 == 1, "Wasm needs I32 to have the value 1");
52	static_assert(I64 == 2, "Wasm needs I64 to have the value 2");
53	static_assert(F32 == 3, "Wasm needs F32 to have the value 3");
54	static_assert(F64 == 4, "Wasm needs F64 to have the value 4");
55
56	inline B3::Type toB3Type(Type type)
57	{
58	switch (type) {
59	case I32: return B3::Int32;
60	case I64: return B3::Int64;
61	case F32: return B3::Float;
62	case F64: return B3::Double;
63	case Void: return B3::Void;
64	default: break;
65	}
66	RELEASE_ASSERT_NOT_REACHED();
67	}
68
69	inline bool isValueType(Type type)	43	inline bool isValueType(Type type)
70	{	44	{
71	switch (type) {	45	switch (type) {
Lines 79-89 inline bool isValueType(Type type) a/Source/JavaScriptCore/wasm/WasmFormat.h_sec3
79	}	53	}
80	return false;	54	return false;
81	}	55	}
82
83	const char* toString(Type);
84		56
85	struct External {	57	struct External {
86	enum Kind : uint8_t {	58	enum Kind : uint8_t {
		59	// FIXME auto-generate this. https://bugs.webkit.org/show_bug.cgi?id=165231
87	Function = 0,	60	Function = 0,
88	Table = 1,	61	Table = 1,
89	Memory = 2,	62	Memory = 2,

Lines 54-60 bool ModuleParser::parse() a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp -3 / +2 lines
54	return false;	54	return false;
55	}	55	}
56		56
57	// Skip the version number for now since we don't do anything with it.
58	uint32_t versionNumber;	57	uint32_t versionNumber;
59	if (!parseUInt32(versionNumber)) {	58	if (!parseUInt32(versionNumber)) {
60	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919	59	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919
Lines 62-68 bool ModuleParser::parse() a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp_sec2
62	return false;	61	return false;
63	}	62	}
64		63
65	if (versionNumber != magicNumber) {	64	if (versionNumber != expectedVersionNumber) {
66	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919	65	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919
67	m_errorMessage = "unexpected version number";	66	m_errorMessage = "unexpected version number";
68	return false;	67	return false;
Lines 169-175 bool ModuleParser::parseType() a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp_sec3
169	int8_t type;	168	int8_t type;
170	if (!parseInt7(type))	169	if (!parseInt7(type))
171	return false;	170	return false;
172	if (type != -0x20) // Function type constant. FIXME auto-generate from JSON file.	171	if (type != Func)
173	return false;	172	return false;
174		173
175	if (verbose)	174	if (verbose)

Lines 37-44 namespace JSC { namespace Wasm { a/Source/JavaScriptCore/wasm/WasmModuleParser.h_sec1
- a/Source/JavaScriptCore/wasm/WasmModuleParser.h -2 lines
37	class ModuleParser : public Parser {	37	class ModuleParser : public Parser {
38	public:	38	public:
39		39
40	static const unsigned magicNumber = 0xc;
41
42	ModuleParser(VM* vm, const uint8_t* sourceBuffer, size_t sourceLength)	40	ModuleParser(VM* vm, const uint8_t* sourceBuffer, size_t sourceLength)
43	: Parser(sourceBuffer, sourceLength)	41	: Parser(sourceBuffer, sourceLength)
44	, m_vm(vm)	42	, m_vm(vm)

Lines 169-178 ALWAYS_INLINE bool Parser::parseVarUInt1(uint8_t& result) a/Source/JavaScriptCore/wasm/WasmParser.h_sec1
- a/Source/JavaScriptCore/wasm/WasmParser.h -3 / +3 lines
169		169
170	ALWAYS_INLINE bool Parser::parseResultType(Type& result)	170	ALWAYS_INLINE bool Parser::parseResultType(Type& result)
171	{	171	{
172	uint8_t value;	172	int8_t value;
173	if (!parseUInt7(value))	173	if (!parseInt7(value))
174	return false;	174	return false;
175	if (value > static_cast<uint8_t>(Type::LastValueType))	175	if (!isValidType(value))
176	return false;	176	return false;
177	result = static_cast<Type>(value);	177	result = static_cast<Type>(value);
178	return true;	178	return true;

Lines 35-54 if len(args) != 3: a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py_sec1
- a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py -7 / +90 lines
35	parser.error(parser.usage)	35	parser.error(parser.usage)
36		36
37	wasm = Wasm(args[0], args[1])	37	wasm = Wasm(args[0], args[1])
		38	types = wasm.types
38	opcodes = wasm.opcodes	39	opcodes = wasm.opcodes
39	wasmOpsHFile = open(args[2], "w")	40	wasmOpsHFile = open(args[2], "w")
40		41
41		42
42	def cppMacro(wasmOpcode, value, b3Opcode):	43	def cppMacro(wasmOpcode, value, b3, inc):
43	return " \\\n macro(" + wasm.toCpp(wasmOpcode) + ", " + hex(int(value)) + ", " + b3Opcode + ")"	44	return " \\\n macro(" + wasm.toCpp(wasmOpcode) + ", " + hex(int(value)) + ", " + b3 + ", " + str(inc) + ")"
		45
		46
		47	def typeMacroizer():
		48	inc = 0
		49	for ty in wasm.types:
		50	yield cppMacro(ty, wasm.types[ty]["value"], wasm.types[ty]["b3type"], inc)
		51	inc += 1
		52
		53	type_definitions = ["#define FOR_EACH_WASM_TYPE(macro)"]
		54	type_definitions.extend([t for t in typeMacroizer()])
		55	type_definitions = "".join(type_definitions)
44		56
45		57
46	def opcodeMacroizer(filter):	58	def opcodeMacroizer(filter):
		59	inc = 0
47	for op in wasm.opcodeIterator(filter):	60	for op in wasm.opcodeIterator(filter):
48	b3op = "Oops"	61	b3op = "Oops"
49	if isSimple(op["opcode"]):	62	if isSimple(op["opcode"]):
50	b3op = op["opcode"]["b3op"]	63	b3op = op["opcode"]["b3op"]
51	yield cppMacro(op["name"], op["opcode"]["value"], b3op)	64	yield cppMacro(op["name"], op["opcode"]["value"], b3op, inc)
		65	inc += 1
52		66
53	defines = ["#define FOR_EACH_WASM_SPECIAL_OP(macro)"]	67	defines = ["#define FOR_EACH_WASM_SPECIAL_OP(macro)"]
54	defines.extend([op for op in opcodeMacroizer(lambda op: op["category"] == "special" or op["category"] == "call")])	68	defines.extend([op for op in opcodeMacroizer(lambda op: op["category"] == "special" or op["category"] == "call")])
Lines 101-106 contents = wasm.header + """ a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py_sec2
101		115
102	namespace JSC { namespace Wasm {	116	namespace JSC { namespace Wasm {
103		117
		118	static constexpr unsigned expectedVersionNumber = """ + wasm.expectedVersionNumber + """;
		119
		120	static constexpr unsigned numTypes = """ + str(len(types)) + """;
		121
		122	""" + type_definitions + """
		123	#define CREATE_ENUM_VALUE(name, id, b3type, inc) name = id,
		124	enum Type : int8_t {
		125	FOR_EACH_WASM_TYPE(CREATE_ENUM_VALUE)
		126	};
		127	#undef CREATE_ENUM_VALUE
		128
		129	#define CREATE_CASE(name, id, b3type, inc) case id: return true;
		130	template <typename Int>
		131	inline bool isValidType(Int i)
		132	{
		133	switch (i) {
		134	default: return false;
		135	FOR_EACH_WASM_TYPE(CREATE_CASE)
		136	}
		137	RELEASE_ASSERT_NOT_REACHED();
		138	return false;
		139	}
		140	#undef CREATE_CASE
		141
		142	#define CREATE_CASE(name, id, b3type, inc) case name: return b3type;
		143	inline B3::Type toB3Type(Type type)
		144	{
		145	switch (type) {
		146	FOR_EACH_WASM_TYPE(CREATE_CASE)
		147	}
		148	RELEASE_ASSERT_NOT_REACHED();
		149	return B3::Void;
		150	}
		151	#undef CREATE_CASE
		152
		153	#define CREATE_CASE(name, id, b3type, inc) case name: return "name";
		154	inline const char* toString(Type type)
		155	{
		156	switch (type) {
		157	FOR_EACH_WASM_TYPE(CREATE_CASE)
		158	}
		159	RELEASE_ASSERT_NOT_REACHED();
		160	return nullptr;
		161	}
		162	#undef CREATE_CASE
		163
		164	#define CREATE_CASE(name, id, b3type, inc) case id: return inc;
		165	inline int linearizeType(Type type)
		166	{
		167	switch (type) {
		168	FOR_EACH_WASM_TYPE(CREATE_CASE)
		169	}
		170	RELEASE_ASSERT_NOT_REACHED();
		171	return 0;
		172	}
		173	#undef CREATE_CASE
		174
		175	#define CREATE_CASE(name, id, b3type, inc) case inc: return name;
		176	inline Type linearizedToType(int i)
		177	{
		178	switch (i) {
		179	FOR_EACH_WASM_TYPE(CREATE_CASE)
		180	}
		181	RELEASE_ASSERT_NOT_REACHED();
182	return Void;
183	}
184	#undef CREATE_CASE
185
186
104	""" + defines + """	187	""" + defines + """
105	#define FOR_EACH_WASM_OP(macro) \\	188	#define FOR_EACH_WASM_OP(macro) \\
106	FOR_EACH_WASM_SPECIAL_OP(macro) \\	189	FOR_EACH_WASM_SPECIAL_OP(macro) \\
Lines 110-116 namespace JSC { namespace Wasm { a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py_sec3
110	FOR_EACH_WASM_MEMORY_LOAD_OP(macro) \\	193	FOR_EACH_WASM_MEMORY_LOAD_OP(macro) \\
111	FOR_EACH_WASM_MEMORY_STORE_OP(macro)	194	FOR_EACH_WASM_MEMORY_STORE_OP(macro)
112		195
113	#define CREATE_ENUM_VALUE(name, id, b3op) name = id,	196	#define CREATE_ENUM_VALUE(name, id, b3op, inc) name = id,
114		197
115	enum OpType : uint8_t {	198	enum OpType : uint8_t {
116	FOR_EACH_WASM_OP(CREATE_ENUM_VALUE)	199	FOR_EACH_WASM_OP(CREATE_ENUM_VALUE)
Lines 145-151 enum class StoreOpType : uint8_t { a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py_sec4
145	inline bool isControlOp(OpType op)	228	inline bool isControlOp(OpType op)
146	{	229	{
147	switch (op) {	230	switch (op) {
148	#define CREATE_CASE(name, id, b3op) case OpType::name:	231	#define CREATE_CASE(name, id, b3op, inc) case OpType::name:
149	FOR_EACH_WASM_CONTROL_FLOW_OP(CREATE_CASE)	232	FOR_EACH_WASM_CONTROL_FLOW_OP(CREATE_CASE)
150	return true;	233	return true;
151	#undef CREATE_CASE	234	#undef CREATE_CASE
Lines 158-164 inline bool isControlOp(OpType op) a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py_sec5
158	inline bool isSimple(UnaryOpType op)	241	inline bool isSimple(UnaryOpType op)
159	{	242	{
160	switch (op) {	243	switch (op) {
161	#define CREATE_CASE(name, id, b3op) case UnaryOpType::name:	244	#define CREATE_CASE(name, id, b3op, inc) case UnaryOpType::name:
162	FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)	245	FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
163	return true;	246	return true;
164	#undef CREATE_CASE	247	#undef CREATE_CASE
Lines 171-177 inline bool isSimple(UnaryOpType op) a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py_sec6
171	inline bool isSimple(BinaryOpType op)	254	inline bool isSimple(BinaryOpType op)
172	{	255	{
173	switch (op) {	256	switch (op) {
174	#define CREATE_CASE(name, id, b3op) case BinaryOpType::name:	257	#define CREATE_CASE(name, id, b3op, inc) case BinaryOpType::name:
175	FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)	258	FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
176	return true;	259	return true;
177	#undef CREATE_CASE	260	#undef CREATE_CASE

Lines 63-72 static EncodedJSValue JSC_HOST_CALL callWebAssemblyFunction(ExecState* state) a/Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp -6 / +10 lines
63	for (unsigned argIndex = 0; argIndex < state->argumentCount(); ++argIndex) {	63	for (unsigned argIndex = 0; argIndex < state->argumentCount(); ++argIndex) {
64	JSValue arg = state->uncheckedArgument(argIndex);	64	JSValue arg = state->uncheckedArgument(argIndex);
65	switch (signature->arguments[argIndex]) {	65	switch (signature->arguments[argIndex]) {
66	case Wasm::Void:
67	case Wasm::I64:
68	RELEASE_ASSERT_NOT_REACHED();
69	break;
70	case Wasm::I32:	66	case Wasm::I32:
71	arg = JSValue::decode(arg.toInt32(state));	67	arg = JSValue::decode(arg.toInt32(state));
72	break;	68	break;
Lines 76-81 static EncodedJSValue JSC_HOST_CALL callWebAssemblyFunction(ExecState* state) a/Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp_sec2
76	case Wasm::F64:	72	case Wasm::F64:
77	arg = JSValue::decode(bitwise_cast<uint64_t>(arg.toNumber(state)));	73	arg = JSValue::decode(bitwise_cast<uint64_t>(arg.toNumber(state)));
78	break;	74	break;
		75	case Wasm::Void:
		76	case Wasm::I64:
		77	case Wasm::Func:
		78	case Wasm::Anyfunc:
		79	RELEASE_ASSERT_NOT_REACHED();
79	}	80	}
80	RETURN_IF_EXCEPTION(scope, encodedJSValue());	81	RETURN_IF_EXCEPTION(scope, encodedJSValue());
81	boxedArgs.append(arg);	82	boxedArgs.append(arg);
Lines 99-115 static EncodedJSValue JSC_HOST_CALL callWebAssemblyFunction(ExecState* state) a/Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp_sec3
99	switch (signature->returnType) {	100	switch (signature->returnType) {
100	case Wasm::Void:	101	case Wasm::Void:
101	return JSValue::encode(jsUndefined());	102	return JSValue::encode(jsUndefined());
102	case Wasm::I64:
103	RELEASE_ASSERT_NOT_REACHED();
104	case Wasm::I32:	103	case Wasm::I32:
105	return JSValue::encode(JSValue(static_cast<int32_t>(rawResult)));	104	return JSValue::encode(JSValue(static_cast<int32_t>(rawResult)));
106	case Wasm::F32:	105	case Wasm::F32:
107	return JSValue::encode(JSValue(bitwise_cast<float>(static_cast<int32_t>(rawResult))));	106	return JSValue::encode(JSValue(bitwise_cast<float>(static_cast<int32_t>(rawResult))));
108	case Wasm::F64:	107	case Wasm::F64:
109	return JSValue::encode(JSValue(bitwise_cast<double>(rawResult)));	108	return JSValue::encode(JSValue(bitwise_cast<double>(rawResult)));
		109	case Wasm::I64:
		110	case Wasm::Func:
		111	case Wasm::Anyfunc:
		112	break;
110	}	113	}
111		114
112	RELEASE_ASSERT_NOT_REACHED();	115	RELEASE_ASSERT_NOT_REACHED();
		116	return EncodedJSValue();
113	}	117	}
114		118
115	WebAssemblyFunction* WebAssemblyFunction::create(VM& vm, JSGlobalObject* globalObject, int length, const String& name, JSWebAssemblyInstance* instance, CallableWebAssemblyFunction&& callable)	119	WebAssemblyFunction* WebAssemblyFunction::create(VM& vm, JSGlobalObject* globalObject, int length, const String& name, JSWebAssemblyInstance* instance, CallableWebAssemblyFunction&& callable)