Attachment #295790 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 NOBODY (OOPS!).

        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-29  Keith Miller  <keith_miller@apple.com>

        Add simple way to implement Wasm ops that require more than one B3 opcode



    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.



    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 150-157 export default class LowLevelBinary { a/JSTests/wasm/LowLevelBinary.js_sec1
- a/JSTests/wasm/LowLevelBinary.js -2 / +4 lines
150	throw new RangeError(`Invalid varuint7 ${v} range is [${varuint32Min}, ${varuint7Max}]`);	150	throw new RangeError(`Invalid varuint7 ${v} range is [${varuint32Min}, ${varuint7Max}]`);
151	this.varuint32(v);	151	this.varuint32(v);
152	}	152	}
153	inline_signature_type(v) {	153	block_type(v) {
154	this.varint7(WASM.valueTypeValue[v]);	154	if (!WASM.isValidBlockType(v))
		155	throw new Error(`Invalid block type ${v}`);
		156	this.varint7(WASM.typeValue[v]);
155	}	157	}
156	string(str) {	158	string(str) {
157	let patch = this.newPatchable("varuint32");	159	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 0f 0a 4f 00 48 00 48 \|·asm·······O·H·H\|",	30	["00000000 00 61 73 6d 0d 00 00 00 00 0f 0a 4f 00 48 00 48 \|·asm·······O·H·H\|",
31	"00000010 00 41 00 49 00 de ad c0 fe \|·A·I····· \|"].join("\n"));	31	"00000010 00 41 00 49 00 de ad c0 fe \|·A·I····· \|"].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 NOBODY (OOPS!).

        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-29  Keith Miller  <keith_miller@apple.com>

        Add simple way to implement Wasm ops that require more than one B3 opcode



    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();




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



#include "B3Compilation.h"
#include "B3Type.h"
#include "CodeLocation.h"
#include "WasmOps.h"
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>



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(const uint8_t* sourceBuffer, size_t sourceLength)
        : Parser(sourceBuffer, sourceLength)
    {




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



{
    "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 NOBODY (OOPS!).
		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-29 Keith Miller <keith_miller@apple.com>	26	2016-11-29 Keith Miller <keith_miller@apple.com>
2		27
3	Add simple way to implement Wasm ops that require more than one B3 opcode	28	Add simple way to implement Wasm ops that require more than one B3 opcode

Lines 51-57 const _normalizeFunctionSignature = (params, ret) => { a/JSTests/wasm/Builder.js_sec1
- a/JSTests/wasm/Builder.js -3 / +3 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 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 94-100 const emitters = { a/JSTests/wasm/Builder_WebAssemblyBinary.js_sec2
94	put(funcBin, "varuint32", localCount);	93	put(funcBin, "varuint32", localCount);
95	for (let i = func.parameterCount; i < func.locals.length; ++i) {	94	for (let i = func.parameterCount; i < func.locals.length; ++i) {
96	put(funcBin, "varuint32", 1);	95	put(funcBin, "varuint32", 1);
97	put(funcBin, "uint8", WASM.valueTypeValue[func.locals[i]]);	96	put(funcBin, "varint7", WASM.typeValue[func.locals[i]]);
98	}	97	}
99		98
100	for (const op of func.code) {	99	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 NOBODY (OOPS!).
		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-29 Keith Miller <keith_miller@apple.com>	38	2016-11-29 Keith Miller <keith_miller@apple.com>
2		39
3	Add simple way to implement Wasm ops that require more than one B3 opcode	40	Add simple way to implement Wasm ops that require more than one B3 opcode

Lines 33-54 a/Source/JavaScriptCore/wasm/WasmFormat.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmFormat.cpp -16 lines
33		33
34	namespace JSC { namespace Wasm {	34	namespace JSC { namespace Wasm {
35		35
36	const char* toString(Type type)
37	{
38	switch (type) {
39	case Void:
40	return "void";
41	case I32:
42	return "i32";
43	case I64:
44	return "i64";
45	case F32:
46	return "f32";
47	case F64:
48	return "f64";
49	}
50	}
51
52	ModuleInformation::~ModuleInformation() { }	36	ModuleInformation::~ModuleInformation() { }
53		37
54	} } // namespace JSC::Wasm	38	} } // namespace JSC::Wasm

Lines 30-35 a/Source/JavaScriptCore/wasm/WasmFormat.h_sec1
- a/Source/JavaScriptCore/wasm/WasmFormat.h -29 / +2 lines
30	#include "B3Compilation.h"	30	#include "B3Compilation.h"
31	#include "B3Type.h"	31	#include "B3Type.h"
32	#include "CodeLocation.h"	32	#include "CodeLocation.h"
		33	#include "WasmOps.h"
33	#include <wtf/Vector.h>	34	#include <wtf/Vector.h>
34	#include <wtf/text/WTFString.h>	35	#include <wtf/text/WTFString.h>
35		36
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 53-59 bool ModuleParser::parse() a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp -3 / +2 lines
53	return false;	53	return false;
54	}	54	}
55		55
56	// Skip the version number for now since we don't do anything with it.
57	uint32_t versionNumber;	56	uint32_t versionNumber;
58	if (!parseUInt32(versionNumber)) {	57	if (!parseUInt32(versionNumber)) {
59	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919	58	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919
Lines 61-67 bool ModuleParser::parse() a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp_sec2
61	return false;	60	return false;
62	}	61	}
63		62
64	if (versionNumber != magicNumber) {	63	if (versionNumber != expectedVersionNumber) {
65	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919	64	// FIXME improve error message https://bugs.webkit.org/show_bug.cgi?id=163919
66	m_errorMessage = "unexpected version number";	65	m_errorMessage = "unexpected version number";
67	return false;	66	return false;
Lines 167-173 bool ModuleParser::parseType() a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp_sec3
167	int8_t type;	166	int8_t type;
168	if (!parseInt7(type))	167	if (!parseInt7(type))
169	return false;	168	return false;
170	if (type != -0x20) // Function type constant.	169	if (type != Func)
171	return false;	170	return false;
172		171
173	if (verbose)	172	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(const uint8_t* sourceBuffer, size_t sourceLength)	40	ModuleParser(const uint8_t* sourceBuffer, size_t sourceLength)
43	: Parser(sourceBuffer, sourceLength)	41	: Parser(sourceBuffer, sourceLength)
44	{	42	{

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