ethonion10/v86
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Avoid console.assert (doesn't throw)

Browse source
This commit is contained in:
Fabian 2020-12-31 19:14:30 -06:00
parent 5bbc11a51d
commit acb8ad5423
14 changed files with 93 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
gen/generate_analyzer.js
View file

@ -1,6 +1,7 @@
#!/usr/bin/env node #!/usr/bin/env node
"use strict"; "use strict";
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const path = require("path"); const path = require("path");
const x86_table = require("./x86_table"); const x86_table = require("./x86_table");
@ -19,7 +20,7 @@ const to_generate = {
analyzer0f_32: gen_all || table_arg === "analyzer0f_32", analyzer0f_32: gen_all || table_arg === "analyzer0f_32",
}; };
console.assert( assert(
Object.keys(to_generate).some(k => to_generate[k]), Object.keys(to_generate).some(k => to_generate[k]),
"Pass --table [analyzer|analyzer0f_16|analyzer0f_32] or --all to pick which tables to generate" "Pass --table [analyzer|analyzer0f_16|analyzer0f_32] or --all to pick which tables to generate"
); );
@ -49,7 +50,7 @@ function gen_read_imm_call(op, size_variant)
} }
else else
{ {
console.assert(op.imm1632 || op.imm16 || op.imm32); assert(op.imm1632 || op.imm16 || op.imm32);
if(op.imm1632 && size === 16 || op.imm16) if(op.imm1632 && size === 16 || op.imm16)
{ {
@ -57,7 +58,7 @@ function gen_read_imm_call(op, size_variant)
} }
else else
{ {
console.assert(op.imm1632 && size === 32 || op.imm32); assert(op.imm1632 && size === 32 || op.imm32);
return "cpu.read_imm32()"; return "cpu.read_imm32()";
} }
} }
@ -87,8 +88,8 @@ function make_instruction_name(encoding, size)
const second_prefix = (encoding.opcode & 0xFF0000) === 0 ? "" : hex(encoding.opcode >> 16 & 0xFF, 2); const second_prefix = (encoding.opcode & 0xFF0000) === 0 ? "" : hex(encoding.opcode >> 16 & 0xFF, 2);
const fixed_g_suffix = encoding.fixed_g === undefined ? "" : `_${encoding.fixed_g}`; const fixed_g_suffix = encoding.fixed_g === undefined ? "" : `_${encoding.fixed_g}`;
console.assert(first_prefix === "" || first_prefix === "0F" || first_prefix === "F2" || first_prefix === "F3"); assert(first_prefix === "" || first_prefix === "0F" || first_prefix === "F2" || first_prefix === "F3");
console.assert(second_prefix === "" || second_prefix === "66" || second_prefix === "F2" || second_prefix === "F3"); assert(second_prefix === "" || second_prefix === "66" || second_prefix === "F2" || second_prefix === "F3");
return `instr${suffix}_${second_prefix}${first_prefix}${opcode_hex}${fixed_g_suffix}`; return `instr${suffix}_${second_prefix}${first_prefix}${opcode_hex}${fixed_g_suffix}`;
} }
@ -112,12 +113,12 @@ function gen_instruction_body(encodings, size)
if(has_F2.length || has_F3.length) if(has_F2.length || has_F3.length)
{ {
console.assert((encoding.opcode & 0xFF0000) === 0 || (encoding.opcode & 0xFF00) === 0x0F00); assert((encoding.opcode & 0xFF0000) === 0 || (encoding.opcode & 0xFF00) === 0x0F00);
} }
if(has_66.length) if(has_66.length)
{ {
console.assert((encoding.opcode & 0xFF00) === 0x0F00); assert((encoding.opcode & 0xFF00) === 0x0F00);
} }
const code = []; const code = [];
@ -171,13 +172,13 @@ function gen_instruction_body_after_prefix(encodings, size)
if(encoding.fixed_g !== undefined) if(encoding.fixed_g !== undefined)
{ {
console.assert(encoding.e); assert(encoding.e);
// instruction with modrm byte where the middle 3 bits encode the instruction // instruction with modrm byte where the middle 3 bits encode the instruction
// group by opcode without prefix plus middle bits of modrm byte // group by opcode without prefix plus middle bits of modrm byte
let cases = encodings.reduce((cases_by_opcode, case_) => { let cases = encodings.reduce((cases_by_opcode, case_) => {
console.assert(typeof case_.fixed_g === "number"); assert(typeof case_.fixed_g === "number");
cases_by_opcode[case_.opcode & 0xFFFF | case_.fixed_g << 16] = case_; cases_by_opcode[case_.opcode & 0xFFFF | case_.fixed_g << 16] = case_;
return cases_by_opcode; return cases_by_opcode;
}, Object.create(null)); }, Object.create(null));
@ -207,7 +208,7 @@ function gen_instruction_body_after_prefix(encodings, size)
]; ];
} }
else { else {
console.assert(encodings.length === 1); assert(encodings.length === 1);
return gen_instruction_body_after_fixed_g(encodings[0], size); return gen_instruction_body_after_fixed_g(encodings[0], size);
} }
} }
@ -233,7 +234,7 @@ function gen_instruction_body_after_fixed_g(encoding, size)
const instruction_name = "::analysis::" + make_instruction_name(encoding, size) + "_analyze"; const instruction_name = "::analysis::" + make_instruction_name(encoding, size) + "_analyze";
const args = ["cpu", "analysis"]; const args = ["cpu", "analysis"];
console.assert(!imm_read); assert(!imm_read);
return [].concat( return [].concat(
gen_call(instruction_name, args), gen_call(instruction_name, args),
@ -246,7 +247,7 @@ function gen_instruction_body_after_fixed_g(encoding, size)
if(encoding.ignore_mod) if(encoding.ignore_mod)
{ {
console.assert(!imm_read, "Unexpected instruction (ignore mod with immediate value)"); assert(!imm_read, "Unexpected instruction (ignore mod with immediate value)");
// Has modrm byte, but the 2 mod bits are ignored and both // Has modrm byte, but the 2 mod bits are ignored and both
// operands are always registers (0f20-0f24) // operands are always registers (0f20-0f24)
@ -284,7 +285,7 @@ function gen_instruction_body_after_fixed_g(encoding, size)
if(encoding.conditional_jump) if(encoding.conditional_jump)
{ {
console.assert( assert(
(encoding.opcode & ~0xF) === 0x70 || (encoding.opcode & ~0xF) === 0x70 ||
(encoding.opcode & ~0xF) === 0x0F80 || (encoding.opcode & ~0xF) === 0x0F80 ||
(encoding.opcode & ~0x3) === 0xE0 (encoding.opcode & ~0x3) === 0xE0
@ -305,12 +306,12 @@ function gen_instruction_body_after_fixed_g(encoding, size)
if(encoding.extra_imm16) if(encoding.extra_imm16)
{ {
console.assert(imm_read); assert(imm_read);
body.push(gen_call("cpu.read_imm16")); body.push(gen_call("cpu.read_imm16"));
} }
else if(encoding.extra_imm8) else if(encoding.extra_imm8)
{ {
console.assert(imm_read); assert(imm_read);
body.push(gen_call("cpu.read_imm8")); body.push(gen_call("cpu.read_imm8"));
} }
@ -348,7 +349,7 @@ function gen_table()
for(let opcode = 0; opcode < 0x100; opcode++) for(let opcode = 0; opcode < 0x100; opcode++)
{ {
let encoding = by_opcode[opcode]; let encoding = by_opcode[opcode];
console.assert(encoding && encoding.length); assert(encoding && encoding.length);
let opcode_hex = hex(opcode, 2); let opcode_hex = hex(opcode, 2);
let opcode_high_hex = hex(opcode | 0x100, 2); let opcode_high_hex = hex(opcode | 0x100, 2);
@ -403,7 +404,7 @@ function gen_table()
{ {
let encoding = by_opcode0f[opcode]; let encoding = by_opcode0f[opcode];
console.assert(encoding && encoding.length); assert(encoding && encoding.length);
let opcode_hex = hex(opcode, 2); let opcode_hex = hex(opcode, 2);

31
gen/generate_interpreter.js
View file

@ -1,6 +1,7 @@
#!/usr/bin/env node #!/usr/bin/env node
"use strict"; "use strict";
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const path = require("path"); const path = require("path");
const x86_table = require("./x86_table"); const x86_table = require("./x86_table");
@ -19,7 +20,7 @@ const to_generate = {
interpreter0f_32: gen_all || table_arg === "interpreter0f_32", interpreter0f_32: gen_all || table_arg === "interpreter0f_32",
}; };
console.assert( assert(
Object.keys(to_generate).some(k => to_generate[k]), Object.keys(to_generate).some(k => to_generate[k]),
"Pass --table [interpreter|interpreter0f_16|interpreter0f_32] or --all to pick which tables to generate" "Pass --table [interpreter|interpreter0f_16|interpreter0f_32] or --all to pick which tables to generate"
); );
@ -54,7 +55,7 @@ function gen_read_imm_call(op, size_variant)
} }
else else
{ {
console.assert(op.imm1632 || op.imm16 || op.imm32); assert(op.imm1632 || op.imm16 || op.imm32);
if(op.imm1632 && size === 16 || op.imm16) if(op.imm1632 && size === 16 || op.imm16)
{ {
@ -62,7 +63,7 @@ function gen_read_imm_call(op, size_variant)
} }
else else
{ {
console.assert(op.imm1632 && size === 32 || op.imm32); assert(op.imm1632 && size === 32 || op.imm32);
return wrap_imm_call("read_imm32s()"); return wrap_imm_call("read_imm32s()");
} }
} }
@ -92,8 +93,8 @@ function make_instruction_name(encoding, size)
const second_prefix = (encoding.opcode & 0xFF0000) === 0 ? "" : hex(encoding.opcode >> 16 & 0xFF, 2); const second_prefix = (encoding.opcode & 0xFF0000) === 0 ? "" : hex(encoding.opcode >> 16 & 0xFF, 2);
const fixed_g_suffix = encoding.fixed_g === undefined ? "" : `_${encoding.fixed_g}`; const fixed_g_suffix = encoding.fixed_g === undefined ? "" : `_${encoding.fixed_g}`;
console.assert(first_prefix === "" || first_prefix === "0F" || first_prefix === "F2" || first_prefix === "F3"); assert(first_prefix === "" || first_prefix === "0F" || first_prefix === "F2" || first_prefix === "F3");
console.assert(second_prefix === "" || second_prefix === "66" || second_prefix === "F2" || second_prefix === "F3"); assert(second_prefix === "" || second_prefix === "66" || second_prefix === "F2" || second_prefix === "F3");
return `instr${suffix}_${second_prefix}${first_prefix}${opcode_hex}${fixed_g_suffix}`; return `instr${suffix}_${second_prefix}${first_prefix}${opcode_hex}${fixed_g_suffix}`;
} }
@ -117,12 +118,12 @@ function gen_instruction_body(encodings, size)
if(has_F2.length || has_F3.length) if(has_F2.length || has_F3.length)
{ {
console.assert((encoding.opcode & 0xFF0000) === 0 || (encoding.opcode & 0xFF00) === 0x0F00); assert((encoding.opcode & 0xFF0000) === 0 || (encoding.opcode & 0xFF00) === 0x0F00);
} }
if(has_66.length) if(has_66.length)
{ {
console.assert((encoding.opcode & 0xFF00) === 0x0F00); assert((encoding.opcode & 0xFF00) === 0x0F00);
} }
const code = []; const code = [];
@ -182,13 +183,13 @@ function gen_instruction_body_after_prefix(encodings, size)
if(encoding.fixed_g !== undefined) if(encoding.fixed_g !== undefined)
{ {
console.assert(encoding.e); assert(encoding.e);
// instruction with modrm byte where the middle 3 bits encode the instruction // instruction with modrm byte where the middle 3 bits encode the instruction
// group by opcode without prefix plus middle bits of modrm byte // group by opcode without prefix plus middle bits of modrm byte
let cases = encodings.reduce((cases_by_opcode, case_) => { let cases = encodings.reduce((cases_by_opcode, case_) => {
console.assert(typeof case_.fixed_g === "number"); assert(typeof case_.fixed_g === "number");
cases_by_opcode[case_.opcode & 0xFFFF | case_.fixed_g << 16] = case_; cases_by_opcode[case_.opcode & 0xFFFF | case_.fixed_g << 16] = case_;
return cases_by_opcode; return cases_by_opcode;
}, Object.create(null)); }, Object.create(null));
@ -218,7 +219,7 @@ function gen_instruction_body_after_prefix(encodings, size)
]; ];
} }
else { else {
console.assert(encodings.length === 1); assert(encodings.length === 1);
return gen_instruction_body_after_fixed_g(encodings[0], size); return gen_instruction_body_after_fixed_g(encodings[0], size);
} }
} }
@ -256,7 +257,7 @@ function gen_instruction_body_after_fixed_g(encoding, size)
if(encoding.ignore_mod) if(encoding.ignore_mod)
{ {
console.assert(!imm_read, "Unexpected instruction (ignore mod with immediate value)"); assert(!imm_read, "Unexpected instruction (ignore mod with immediate value)");
// Has modrm byte, but the 2 mod bits are ignored and both // Has modrm byte, but the 2 mod bits are ignored and both
// operands are always registers (0f20-0f24) // operands are always registers (0f20-0f24)
@ -326,12 +327,12 @@ function gen_instruction_body_after_fixed_g(encoding, size)
if(encoding.extra_imm16) if(encoding.extra_imm16)
{ {
console.assert(imm_read); assert(imm_read);
args.push(wrap_imm_call("read_imm16()")); args.push(wrap_imm_call("read_imm16()"));
} }
else if(encoding.extra_imm8) else if(encoding.extra_imm8)
{ {
console.assert(imm_read); assert(imm_read);
args.push(wrap_imm_call("read_imm8()")); args.push(wrap_imm_call("read_imm8()"));
} }
@ -370,7 +371,7 @@ function gen_table()
for(let opcode = 0; opcode < 0x100; opcode++) for(let opcode = 0; opcode < 0x100; opcode++)
{ {
let encoding = by_opcode[opcode]; let encoding = by_opcode[opcode];
console.assert(encoding && encoding.length); assert(encoding && encoding.length);
let opcode_hex = hex(opcode, 2); let opcode_hex = hex(opcode, 2);
let opcode_high_hex = hex(opcode | 0x100, 2); let opcode_high_hex = hex(opcode | 0x100, 2);
@ -429,7 +430,7 @@ function gen_table()
{ {
let encoding = by_opcode0f[opcode]; let encoding = by_opcode0f[opcode];
console.assert(encoding && encoding.length); assert(encoding && encoding.length);
let opcode_hex = hex(opcode, 2); let opcode_hex = hex(opcode, 2);

31
gen/generate_jit.js
View file

@ -1,6 +1,7 @@
#!/usr/bin/env node #!/usr/bin/env node
"use strict"; "use strict";
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const path = require("path"); const path = require("path");
const x86_table = require("./x86_table"); const x86_table = require("./x86_table");
@ -19,7 +20,7 @@ const to_generate = {
jit0f_32: gen_all || table_arg === "jit0f_32", jit0f_32: gen_all || table_arg === "jit0f_32",
}; };
console.assert( assert(
Object.keys(to_generate).some(k => to_generate[k]), Object.keys(to_generate).some(k => to_generate[k]),
"Pass --table [jit|jit0f_16|jit0f_32] or --all to pick which tables to generate" "Pass --table [jit|jit0f_16|jit0f_32] or --all to pick which tables to generate"
); );
@ -49,7 +50,7 @@ function gen_read_imm_call(op, size_variant)
} }
else else
{ {
console.assert(op.imm1632 || op.imm16 || op.imm32); assert(op.imm1632 || op.imm16 || op.imm32);
if(op.imm1632 && size === 16 || op.imm16) if(op.imm1632 && size === 16 || op.imm16)
{ {
@ -57,7 +58,7 @@ function gen_read_imm_call(op, size_variant)
} }
else else
{ {
console.assert(op.imm1632 && size === 32 || op.imm32); assert(op.imm1632 && size === 32 || op.imm32);
return "ctx.cpu.read_imm32()"; return "ctx.cpu.read_imm32()";
} }
} }
@ -87,8 +88,8 @@ function make_instruction_name(encoding, size)
const second_prefix = (encoding.opcode & 0xFF0000) === 0 ? "" : hex(encoding.opcode >> 16 & 0xFF, 2); const second_prefix = (encoding.opcode & 0xFF0000) === 0 ? "" : hex(encoding.opcode >> 16 & 0xFF, 2);
const fixed_g_suffix = encoding.fixed_g === undefined ? "" : `_${encoding.fixed_g}`; const fixed_g_suffix = encoding.fixed_g === undefined ? "" : `_${encoding.fixed_g}`;
console.assert(first_prefix === "" || first_prefix === "0F" || first_prefix === "F2" || first_prefix === "F3"); assert(first_prefix === "" || first_prefix === "0F" || first_prefix === "F2" || first_prefix === "F3");
console.assert(second_prefix === "" || second_prefix === "66" || second_prefix === "F2" || second_prefix === "F3"); assert(second_prefix === "" || second_prefix === "66" || second_prefix === "F2" || second_prefix === "F3");
return `instr${suffix}_${second_prefix}${first_prefix}${opcode_hex}${fixed_g_suffix}`; return `instr${suffix}_${second_prefix}${first_prefix}${opcode_hex}${fixed_g_suffix}`;
} }
@ -112,12 +113,12 @@ function gen_instruction_body(encodings, size)
if(has_F2.length || has_F3.length) if(has_F2.length || has_F3.length)
{ {
console.assert((encoding.opcode & 0xFF0000) === 0 || (encoding.opcode & 0xFF00) === 0x0F00); assert((encoding.opcode & 0xFF0000) === 0 || (encoding.opcode & 0xFF00) === 0x0F00);
} }
if(has_66.length) if(has_66.length)
{ {
console.assert((encoding.opcode & 0xFF00) === 0x0F00); assert((encoding.opcode & 0xFF00) === 0x0F00);
} }
const code = []; const code = [];
@ -171,13 +172,13 @@ function gen_instruction_body_after_prefix(encodings, size)
if(encoding.fixed_g !== undefined) if(encoding.fixed_g !== undefined)
{ {
console.assert(encoding.e); assert(encoding.e);
// instruction with modrm byte where the middle 3 bits encode the instruction // instruction with modrm byte where the middle 3 bits encode the instruction
// group by opcode without prefix plus middle bits of modrm byte // group by opcode without prefix plus middle bits of modrm byte
let cases = encodings.reduce((cases_by_opcode, case_) => { let cases = encodings.reduce((cases_by_opcode, case_) => {
console.assert(typeof case_.fixed_g === "number"); assert(typeof case_.fixed_g === "number");
cases_by_opcode[case_.opcode & 0xFFFF | case_.fixed_g << 16] = case_; cases_by_opcode[case_.opcode & 0xFFFF | case_.fixed_g << 16] = case_;
return cases_by_opcode; return cases_by_opcode;
}, Object.create(null)); }, Object.create(null));
@ -207,7 +208,7 @@ function gen_instruction_body_after_prefix(encodings, size)
]; ];
} }
else { else {
console.assert(encodings.length === 1); assert(encodings.length === 1);
return gen_instruction_body_after_fixed_g(encodings[0], size); return gen_instruction_body_after_fixed_g(encodings[0], size);
} }
} }
@ -276,7 +277,7 @@ function gen_instruction_body_after_fixed_g(encoding, size)
if(encoding.ignore_mod) if(encoding.ignore_mod)
{ {
console.assert(!imm_read, "Unexpected instruction (ignore mod with immediate value)"); assert(!imm_read, "Unexpected instruction (ignore mod with immediate value)");
// Has modrm byte, but the 2 mod bits are ignored and both // Has modrm byte, but the 2 mod bits are ignored and both
// operands are always registers (0f20-0f24) // operands are always registers (0f20-0f24)
@ -408,13 +409,13 @@ function gen_instruction_body_after_fixed_g(encoding, size)
if(encoding.extra_imm16) if(encoding.extra_imm16)
{ {
console.assert(imm_read); assert(imm_read);
imm_read_bindings.push(`let imm2 = ctx.cpu.read_imm16() as u32;`); imm_read_bindings.push(`let imm2 = ctx.cpu.read_imm16() as u32;`);
args.push("imm2"); args.push("imm2");
} }
else if(encoding.extra_imm8) else if(encoding.extra_imm8)
{ {
console.assert(imm_read); assert(imm_read);
imm_read_bindings.push(`let imm2 = ctx.cpu.read_imm8() as u32;`); imm_read_bindings.push(`let imm2 = ctx.cpu.read_imm8() as u32;`);
args.push("imm2"); args.push("imm2");
} }
@ -455,7 +456,7 @@ function gen_table()
for(let opcode = 0; opcode < 0x100; opcode++) for(let opcode = 0; opcode < 0x100; opcode++)
{ {
let encoding = by_opcode[opcode]; let encoding = by_opcode[opcode];
console.assert(encoding && encoding.length); assert(encoding && encoding.length);
let opcode_hex = hex(opcode, 2); let opcode_hex = hex(opcode, 2);
let opcode_high_hex = hex(opcode | 0x100, 2); let opcode_high_hex = hex(opcode | 0x100, 2);
@ -510,7 +511,7 @@ function gen_table()
{ {
let encoding = by_opcode0f[opcode]; let encoding = by_opcode0f[opcode];
console.assert(encoding && encoding.length); assert(encoding && encoding.length);
let opcode_hex = hex(opcode, 2); let opcode_hex = hex(opcode, 2);

10
gen/rust_ast.js
View file

@ -1,5 +1,7 @@
"use strict"; "use strict";
const assert = require("assert").strict;
function repeat(s, n) function repeat(s, n)
{ {
let out = ""; let out = "";
@ -24,13 +26,13 @@ function print_syntax_tree(statements)
} }
else if(statement.type === "switch") else if(statement.type === "switch")
{ {
console.assert(statement.condition); assert(statement.condition);
const cases = []; const cases = [];
for(let case_ of statement.cases) for(let case_ of statement.cases)
{ {
console.assert(case_.conditions.length >= 1); assert(case_.conditions.length >= 1);
cases.push(case_.conditions.join(" | ") + " => {"); cases.push(case_.conditions.join(" | ") + " => {");
cases.push.apply(cases, indent(print_syntax_tree(case_.body), 4)); cases.push.apply(cases, indent(print_syntax_tree(case_.body), 4));
@ -50,7 +52,7 @@ function print_syntax_tree(statements)
} }
else if(statement.type === "if-else") else if(statement.type === "if-else")
{ {
console.assert(statement.if_blocks.length >= 1); assert(statement.if_blocks.length >= 1);
let first_if_block = statement.if_blocks[0]; let first_if_block = statement.if_blocks[0];
@ -76,7 +78,7 @@ function print_syntax_tree(statements)
} }
else else
{ {
console.assert(false, "Unexpected type: " + statement.type, "In:", statement); assert(false, "Unexpected type: " + statement.type, "In:", statement);
} }
} }

5
lib/filesystem.js
View file

@ -161,10 +161,7 @@ FS.prototype.HandleEvent = function(id) {
FS.prototype.load_from_json = function(fs, done) FS.prototype.load_from_json = function(fs, done)
{ {
if(DEBUG) dbg_assert(fs, "Invalid fs passed to load_from_json");
{
console.assert(fs, "Invalid fs passed to load_from_json");
}
if(fs["version"] !== JSONFS_VERSION) if(fs["version"] !== JSONFS_VERSION)
{ {

3
tests/api/state.js
View file

@ -6,6 +6,7 @@ process.on("unhandledRejection", exn => { throw exn; });
const TEST_RELEASE_BUILD = +process.env.TEST_RELEASE_BUILD; const TEST_RELEASE_BUILD = +process.env.TEST_RELEASE_BUILD;
var V86 = require(`../../build/${TEST_RELEASE_BUILD ? "libv86" : "libv86-debug"}.js`).V86; var V86 = require(`../../build/${TEST_RELEASE_BUILD ? "libv86" : "libv86-debug"}.js`).V86;
const assert = require("assert").strict;
var fs = require("fs"); var fs = require("fs");
const config_async_cdrom = { const config_async_cdrom = {
@ -40,7 +41,7 @@ function run_test(name, config, done)
if(error) if(error)
{ {
console.error(error); console.error(error);
console.assert(false); assert(false);
} }
setTimeout(function() setTimeout(function()

5
tests/expect/run.js
View file

@ -3,6 +3,7 @@
const TEST_RELEASE_BUILD = +process.env.TEST_RELEASE_BUILD; const TEST_RELEASE_BUILD = +process.env.TEST_RELEASE_BUILD;
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const path = require("path"); const path = require("path");
const { spawnSync } = require("child_process"); const { spawnSync } = require("child_process");
@ -199,8 +200,8 @@ Hint: Use tests/expect/run.js --interactive to interactively accept changes.
else else
{ {
console.log("%s ok", name); console.log("%s ok", name);
console.assert(!result.stdout); assert(!result.stdout);
console.assert(!result.stderr); assert(!result.stderr);
} }
onfinished(); onfinished();

3
tests/full/run.js
View file

@ -21,6 +21,7 @@ catch(e)
process.exit(1); process.exit(1);
} }
const assert = require("assert").strict;
var cluster = require("cluster"); var cluster = require("cluster");
var os = require("os"); var os = require("os");
var fs = require("fs"); var fs = require("fs");
@ -517,7 +518,7 @@ function run_test(test, done)
console.log("Starting test: %s", test.name); console.log("Starting test: %s", test.name);
let image = test.fda || test.hda || test.cdrom || test.bzimage || test.filesystem.basefs; let image = test.fda || test.hda || test.cdrom || test.bzimage || test.filesystem.basefs;
console.assert(image, "Bootable drive expected"); assert(image, "Bootable drive expected");
if(!fs.existsSync(image)) if(!fs.existsSync(image))
{ {

17
tests/nasm/create_tests.js
View file

@ -4,6 +4,7 @@
// TODO // TODO
// - multiple random tests // - multiple random tests
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const encodings = require("../../gen/x86_table.js"); const encodings = require("../../gen/x86_table.js");
const Prand = require("./prand.js"); const Prand = require("./prand.js");
@ -88,7 +89,7 @@ function create_nasm_modrm_combinations_16()
let has_imm8 = mod === 1; let has_imm8 = mod === 1;
let has_imm16 = mod === 2 || rm === 6 && mod === 0; let has_imm16 = mod === 2 || rm === 6 && mod === 0;
console.assert(!has_imm8 || !has_imm16); assert(!has_imm8 || !has_imm16);
let line = ["db " + modrm]; let line = ["db " + modrm];
if(has_imm8) line.push("db 9ah"); if(has_imm8) line.push("db 9ah");
@ -117,7 +118,7 @@ function create_nasm_modrm_combinations_32()
let has_imm32 = mod === 2 || rm === 5 && mod === 0; let has_imm32 = mod === 2 || rm === 5 && mod === 0;
let has_sib = rm === 4; let has_sib = rm === 4;
console.assert(!has_imm8 || !has_imm32); assert(!has_imm8 || !has_imm32);
if(has_sib) if(has_sib)
{ {
@ -278,7 +279,7 @@ function create_nasm(op, config)
if(opcode === 0x8D) if(opcode === 0x8D)
{ {
// special case: lea: generate 16-bit addressing and all modrm combinations // special case: lea: generate 16-bit addressing and all modrm combinations
console.assert(is_modrm); assert(is_modrm);
codes.push([].concat( codes.push([].concat(
create_nasm_modrm_combinations_16().map(lines => ["db 67h", "db 8dh"].concat(lines).join("\n")), create_nasm_modrm_combinations_16().map(lines => ["db 67h", "db 8dh"].concat(lines).join("\n")),
@ -287,18 +288,18 @@ function create_nasm(op, config)
} }
else else
{ {
console.assert(opcode < 0x1000000); assert(opcode < 0x1000000);
if(opcode >= 0x10000) if(opcode >= 0x10000)
{ {
let c = opcode >> 16; let c = opcode >> 16;
console.assert(c === 0x66 || c === 0xF3 || c === 0xF2); assert(c === 0x66 || c === 0xF3 || c === 0xF2);
codes.push("db " + c); codes.push("db " + c);
opcode &= ~0xFF0000; opcode &= ~0xFF0000;
} }
if(opcode >= 0x100) if(opcode >= 0x100)
{ {
let c = opcode >> 8; let c = opcode >> 8;
console.assert(c === 0x0F || c === 0xF2 || c === 0xF3, "Expected 0F, F2, or F3 prefix, got " + c.toString(16)); assert(c === 0x0F || c === 0xF2 || c === 0xF3, "Expected 0F, F2, or F3 prefix, got " + c.toString(16));
codes.push("db " + c); codes.push("db " + c);
opcode &= ~0xFF00; opcode &= ~0xFF00;
} }
@ -353,7 +354,7 @@ function create_nasm(op, config)
} }
else else
{ {
console.assert(op.imm1632 || op.imm16 || op.imm32); assert(op.imm1632 || op.imm16 || op.imm32);
if(op.imm1632 && size === 16 || op.imm16) if(op.imm1632 && size === 16 || op.imm16)
{ {
@ -361,7 +362,7 @@ function create_nasm(op, config)
} }
else else
{ {
console.assert(op.imm1632 && size === 32 || op.imm32); assert(op.imm1632 && size === 32 || op.imm32);
codes.push("dd 1234abcdh"); codes.push("dd 1234abcdh");
} }
} }

3
tests/nasm/gen_fixtures.js
View file

@ -1,6 +1,7 @@
#!/usr/bin/env node #!/usr/bin/env node
"use strict"; "use strict";
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const os = require("os"); const os = require("os");
const path = require("path"); const path = require("path");
@ -47,7 +48,7 @@ function chunk(source, num_chunks)
} }
return ret; return ret;
} }
console.assert( assert(
JSON.stringify(chunk("0 0 1 1 2 2 2 3 3 3".split(" "), 4)) === JSON.stringify(chunk("0 0 1 1 2 2 2 3 3 3".split(" "), 4)) ===
JSON.stringify([["0", "0"], JSON.stringify([["0", "0"],
["1", "1"], ["1", "1"],

5
tests/nasm/run.js
View file

@ -15,6 +15,7 @@ process.on("unhandledRejection", exn => { throw exn; });
// A #UD might indicate a bug in the test generation // A #UD might indicate a bug in the test generation
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const path = require("path"); const path = require("path");
const os = require("os"); const os = require("os");
@ -58,8 +59,8 @@ catch(e) {
function float_equal(x, y) function float_equal(x, y)
{ {
console.assert(typeof x === "number"); assert(typeof x === "number");
console.assert(typeof y === "number"); assert(typeof y === "number");
if(x === Infinity && y === Infinity || x === -Infinity && y === -Infinity || isNaN(x) && isNaN(y)) if(x === Infinity && y === Infinity || x === -Infinity && y === -Infinity || isNaN(x) && isNaN(y))
{ {

3
tests/qemu/run-qemu.js
View file

@ -3,6 +3,7 @@
const QEMU = "qemu-system-x86_64"; const QEMU = "qemu-system-x86_64";
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const { spawn, spawnSync } = require("child_process"); const { spawn, spawnSync } = require("child_process");
const path = require("path"); const path = require("path");
@ -12,7 +13,7 @@ const share_dir_9p = fs.mkdtempSync("/tmp/v86-test-qemu-9p");
fs.copyFileSync(path.join(__dirname, "/test-i386"), path.join(share_dir_9p, "/test-i386")); fs.copyFileSync(path.join(__dirname, "/test-i386"), path.join(share_dir_9p, "/test-i386"));
const qemu_version = spawnSync(QEMU, ["--version"]); const qemu_version = spawnSync(QEMU, ["--version"]);
console.assert(qemu_version.status === 0, "QEMU not found, return code: " + qemu_version.status); assert(qemu_version.status === 0, "QEMU not found, return code: " + qemu_version.status);
console.error("Using QEMU:"); console.error("Using QEMU:");
console.error(qemu_version.stdout.toString("utf8")); console.error(qemu_version.stdout.toString("utf8"));

5
tests/rust/verify-wasmgen-dummy-output.js
View file

@ -3,6 +3,7 @@
process.on("unhandledRejection", exn => { throw exn; }); process.on("unhandledRejection", exn => { throw exn; });
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const path = require("path"); const path = require("path");
@ -29,5 +30,5 @@ function foo(arg) {
const i = new WebAssembly.Instance(wm, { "e": { m: mem, baz, foo } }); const i = new WebAssembly.Instance(wm, { "e": { m: mem, baz, foo } });
i.exports.f(); i.exports.f();
console.assert(baz_recd_arg === 2, `baz returned: "${baz_recd_arg}"`); assert(baz_recd_arg === 2, `baz returned: "${baz_recd_arg}"`);
console.assert(foo_recd_arg === 456, `foo returned: "${foo_recd_arg}"`); assert(foo_recd_arg === 456, `foo returned: "${foo_recd_arg}"`);

19
tools/wasm-patch-indirect-function-table.js
View file

@ -9,6 +9,7 @@
process.on("unhandledRejection", exn => { throw exn; }); process.on("unhandledRejection", exn => { throw exn; });
const assert = require("assert").strict;
const fs = require("fs"); const fs = require("fs");
const SECTION_IMPORT = 2; const SECTION_IMPORT = 2;
@ -25,11 +26,11 @@ function main()
var ptr = 0; var ptr = 0;
// magic // magic
console.assert(view.getUint32(ptr, true) === 0x6d736100); assert(view.getUint32(ptr, true) === 0x6d736100);
ptr += 4; ptr += 4;
// version // version
console.assert(view.getUint32(ptr, true) === 1); assert(view.getUint32(ptr, true) === 1);
ptr += 4; ptr += 4;
while(ptr < view.byteLength) while(ptr < view.byteLength)
@ -75,10 +76,10 @@ function patch_import_section(ptr, view)
{ {
const table_offset = ptr; const table_offset = ptr;
var { ptr, value: table_element_type } = read_leb_u32(ptr, view); var { ptr, value: table_element_type } = read_leb_u32(ptr, view);
console.assert(table_element_type === 0x70); assert(table_element_type === 0x70);
const maximum_present = new Uint8Array(view.buffer, ptr, 1); const maximum_present = new Uint8Array(view.buffer, ptr, 1);
console.assert(maximum_present[0] === 0 || maximum_present[0] === 1); assert(maximum_present[0] === 0 || maximum_present[0] === 1);
ptr++; ptr++;
var { ptr, value: initial_table_size, leb_view: initial_table_size_view } = read_leb_u32(ptr, view); var { ptr, value: initial_table_size, leb_view: initial_table_size_view } = read_leb_u32(ptr, view);
@ -111,7 +112,7 @@ function patch_import_section(ptr, view)
else if(kind === IMPORT_KIND_MEMORY) else if(kind === IMPORT_KIND_MEMORY)
{ {
const maximum_present = view.getUint8(ptr); const maximum_present = view.getUint8(ptr);
console.assert(maximum_present === 0 || maximum_present === 1); assert(maximum_present === 0 || maximum_present === 1);
ptr++; ptr++;
var { ptr, value: initial_memory_size } = read_leb_u32(ptr, view); var { ptr, value: initial_memory_size } = read_leb_u32(ptr, view);
@ -126,12 +127,12 @@ function patch_import_section(ptr, view)
const content_type = view.getUint8(ptr); const content_type = view.getUint8(ptr);
ptr++; ptr++;
const mutability = view.getUint8(ptr); const mutability = view.getUint8(ptr);
console.assert(mutability === 0 || mutability === 1); assert(mutability === 0 || mutability === 1);
ptr++; ptr++;
} }
else else
{ {
console.assert(false, `Unexpected import kind: 0x${kind.toString(16)} at offset ${ptr - 1}`); assert(false, `Unexpected import kind: 0x${kind.toString(16)} at offset ${ptr - 1}`);
} }
} }
} }
@ -143,7 +144,7 @@ function patch_maximum_limit(maximum_present, initial_size, maximum_size)
// set the highest bit of the initial size, in order to use it to pad the existing maximum size bytes // set the highest bit of the initial size, in order to use it to pad the existing maximum size bytes
const last_byte_initial_size = initial_size[initial_size.length - 1]; const last_byte_initial_size = initial_size[initial_size.length - 1];
console.assert((last_byte_initial_size & 0x80) === 0); assert((last_byte_initial_size & 0x80) === 0);
initial_size[initial_size.length - 1] = last_byte_initial_size | 0x80; initial_size[initial_size.length - 1] = last_byte_initial_size | 0x80;
for(let i = 0; i < maximum_size.length - 1; i++) for(let i = 0; i < maximum_size.length - 1; i++)
@ -174,7 +175,7 @@ function read_leb_u32(ptr, view)
} }
} }
console.assert(byte_length <= 4); assert(byte_length <= 4);
const leb_view = new Uint8Array(view.buffer, ptr - byte_length, byte_length); const leb_view = new Uint8Array(view.buffer, ptr - byte_length, byte_length);