diff options
Diffstat (limited to 'scripts')
| -rw-r--r-- | scripts/fuzz_opt.py | 60 | ||||
| -rwxr-xr-x | scripts/gen-s-parser.py | 289 | ||||
| -rw-r--r-- | scripts/strip_local_names.py | 2 |
3 files changed, 260 insertions, 91 deletions
diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py index 3330000c9..49a2c3f73 100644 --- a/scripts/fuzz_opt.py +++ b/scripts/fuzz_opt.py @@ -14,19 +14,29 @@ script covers different options being passed) ''' import os -import sys import difflib import subprocess import random import shutil import time +from test.shared import options + + # parameters + LOG_LIMIT = 125 INPUT_SIZE_LIMIT = 250 * 1024 +# utilities + + +def in_bin(tool): + return os.path.join(options.binaryen_root, 'bin', tool) + + def random_size(): return random.randint(1, INPUT_SIZE_LIMIT) @@ -50,9 +60,13 @@ def randomize_pass_debug(): del os.environ['BINARYEN_PASS_DEBUG'] +# Test outputs we want to ignore are marked this way. +IGNORE = '[binaryen-fuzzer-ignore]' + + def test_one(infile, opts): def compare(x, y, comment): - if x != y: + if x != y and x != IGNORE and y != IGNORE: message = ''.join([a.rstrip() + '\n' for a in difflib.unified_diff(x.split('\n'), y.split('\n'), fromfile='expected', tofile='actual')]) raise Exception(str(comment) + ": Expected to have '%s' == '%s', diff:\n\n%s" % ( x, y, @@ -88,9 +102,27 @@ def test_one(infile, opts): out = '\n'.join(map(lambda x: x if 'f32' not in x and 'f64' not in x else '', out.split('\n'))) return out + def run_vm(cmd): + # ignore some vm assertions, if bugs have already been filed + known_issues = [ + 'local count too large', # ignore this; can be caused by flatten, ssa, etc. passes + 'liftoff-assembler.cc, line 239\n', # https://bugs.chromium.org/p/v8/issues/detail?id=8631 + 'liftoff-register.h, line 86\n', # https://bugs.chromium.org/p/v8/issues/detail?id=8632 + ] + try: + return run(cmd) + except: + output = run_unchecked(cmd) + for issue in known_issues: + if issue in output: + return IGNORE + raise + results = [] # append to this list to add results from VMs - # results += [fix_output(run([os.path.expanduser('d8'), '--', prefix + 'js', prefix + 'wasm']))] + results += [fix_output(run_vm([os.path.expanduser('d8'), prefix + 'js', '--', prefix + 'wasm']))] + results += [fix_output(run_vm([os.path.expanduser('d8-debug'), '--wasm-tier-up', prefix + 'js', '--', prefix + 'wasm']))] + results += [fix_output(run_vm([os.path.expanduser('d8-debug'), '--no-wasm-tier-up', prefix + 'js', '--', prefix + 'wasm']))] # spec has no mechanism to not halt on a trap. so we just check until the first trap, basically # run(['../spec/interpreter/wasm', prefix + 'wasm']) # results += [fix_spec_output(run_unchecked(['../spec/interpreter/wasm', prefix + 'wasm', '-e', open(prefix + 'wat').read()]))] @@ -110,14 +142,14 @@ def test_one(infile, opts): # fuzz vms # gather VM outputs on input file - run(['bin/wasm-opt', infile, '-ttf', '--emit-js-wrapper=a.js', '--emit-spec-wrapper=a.wat', '-o', 'a.wasm']) + run([in_bin('wasm-opt'), infile, '-ttf', '--emit-js-wrapper=a.js', '--emit-spec-wrapper=a.wat', '-o', 'a.wasm', '--mvp-features']) wasm_size = os.stat('a.wasm').st_size bytes += wasm_size print('pre js size :', os.stat('a.js').st_size, ' wasm size:', wasm_size) before = run_vms('a.') print('----------------') # gather VM outputs on processed file - run(['bin/wasm-opt', 'a.wasm', '-o', 'b.wasm'] + opts) + run([in_bin('wasm-opt'), 'a.wasm', '-o', 'b.wasm'] + opts) wasm_size = os.stat('b.wasm').st_size bytes += wasm_size print('post js size:', os.stat('a.js').st_size, ' wasm size:', wasm_size) @@ -126,7 +158,11 @@ def test_one(infile, opts): for i in range(len(before)): compare(before[i], after[i], 'comparing between builds at ' + str(i)) # fuzz binaryen interpreter itself. separate invocation so result is easily fuzzable - run(['bin/wasm-opt', 'a.wasm', '--fuzz-exec', '--fuzz-binary'] + opts) + run([in_bin('wasm-opt'), 'a.wasm', '--fuzz-exec', '--fuzz-binary'] + opts) + # check for determinism + run([in_bin('wasm-opt'), 'a.wasm', '-o', 'b.wasm'] + opts) + run([in_bin('wasm-opt'), 'a.wasm', '-o', 'c.wasm'] + opts) + assert open('b.wasm').read() == open('c.wasm').read(), 'output must be deterministic' return bytes @@ -198,17 +234,9 @@ def get_multiple_opt_choices(): # main -if len(sys.argv) >= 2: - print('checking given input') - if len(sys.argv) >= 3: - test_one(sys.argv[1], sys.argv[2:]) - else: - for opts in opt_choices: - print(opts) - test_one(sys.argv[1], opts) -else: +if __name__ == '__main__': print('checking infinite random inputs') - random.seed(time.time()) + random.seed(time.time() * os.getpid()) temp = 'input.dat' counter = 0 bytes = 0 # wasm bytes tested diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py index f33107ea6..7e9e70a7c 100755 --- a/scripts/gen-s-parser.py +++ b/scripts/gen-s-parser.py @@ -30,11 +30,11 @@ instructions = [ ("call_indirect", "makeCallIndirect(s)"), ("drop", "makeDrop(s)"), ("select", "makeSelect(s)"), - ("get_local", "makeGetLocal(s)"), - ("set_local", "makeSetLocal(s)"), - ("tee_local", "makeTeeLocal(s)"), - ("get_global", "makeGetGlobal(s)"), - ("set_global", "makeSetGlobal(s)"), + ("local.get", "makeGetLocal(s)"), + ("local.set", "makeSetLocal(s)"), + ("local.tee", "makeTeeLocal(s)"), + ("global.get", "makeGetGlobal(s)"), + ("global.set", "makeSetGlobal(s)"), ("i32.load", "makeLoad(s, i32, /*isAtomic=*/false)"), ("i64.load", "makeLoad(s, i64, /*isAtomic=*/false)"), ("f32.load", "makeLoad(s, f32, /*isAtomic=*/false)"), @@ -162,31 +162,31 @@ instructions = [ ("f64.min", "makeBinary(s, BinaryOp::MinFloat64)"), ("f64.max", "makeBinary(s, BinaryOp::MaxFloat64)"), ("f64.copysign", "makeBinary(s, BinaryOp::CopySignFloat64)"), - ("i32.wrap/i64", "makeUnary(s, UnaryOp::WrapInt64)"), - ("i32.trunc_s/f32", "makeUnary(s, UnaryOp::TruncSFloat32ToInt32)"), - ("i32.trunc_u/f32", "makeUnary(s, UnaryOp::TruncUFloat32ToInt32)"), - ("i32.trunc_s/f64", "makeUnary(s, UnaryOp::TruncSFloat64ToInt32)"), - ("i32.trunc_u/f64", "makeUnary(s, UnaryOp::TruncUFloat64ToInt32)"), - ("i64.extend_s/i32", "makeUnary(s, UnaryOp::ExtendSInt32)"), - ("i64.extend_u/i32", "makeUnary(s, UnaryOp::ExtendUInt32)"), - ("i64.trunc_s/f32", "makeUnary(s, UnaryOp::TruncSFloat32ToInt64)"), - ("i64.trunc_u/f32", "makeUnary(s, UnaryOp::TruncUFloat32ToInt64)"), - ("i64.trunc_s/f64", "makeUnary(s, UnaryOp::TruncSFloat64ToInt64)"), - ("i64.trunc_u/f64", "makeUnary(s, UnaryOp::TruncUFloat64ToInt64)"), - ("f32.convert_s/i32", "makeUnary(s, UnaryOp::ConvertSInt32ToFloat32)"), - ("f32.convert_u/i32", "makeUnary(s, UnaryOp::ConvertUInt32ToFloat32)"), - ("f32.convert_s/i64", "makeUnary(s, UnaryOp::ConvertSInt64ToFloat32)"), - ("f32.convert_u/i64", "makeUnary(s, UnaryOp::ConvertUInt64ToFloat32)"), - ("f32.demote/f64", "makeUnary(s, UnaryOp::DemoteFloat64)"), - ("f64.convert_s/i32", "makeUnary(s, UnaryOp::ConvertSInt32ToFloat64)"), - ("f64.convert_u/i32", "makeUnary(s, UnaryOp::ConvertUInt32ToFloat64)"), - ("f64.convert_s/i64", "makeUnary(s, UnaryOp::ConvertSInt64ToFloat64)"), - ("f64.convert_u/i64", "makeUnary(s, UnaryOp::ConvertUInt64ToFloat64)"), - ("f64.promote/f32", "makeUnary(s, UnaryOp::PromoteFloat32)"), - ("i32.reinterpret/f32", "makeUnary(s, UnaryOp::ReinterpretFloat32)"), - ("i64.reinterpret/f64", "makeUnary(s, UnaryOp::ReinterpretFloat64)"), - ("f32.reinterpret/i32", "makeUnary(s, UnaryOp::ReinterpretInt32)"), - ("f64.reinterpret/i64", "makeUnary(s, UnaryOp::ReinterpretInt64)"), + ("i32.wrap_i64", "makeUnary(s, UnaryOp::WrapInt64)"), + ("i32.trunc_f32_s", "makeUnary(s, UnaryOp::TruncSFloat32ToInt32)"), + ("i32.trunc_f32_u", "makeUnary(s, UnaryOp::TruncUFloat32ToInt32)"), + ("i32.trunc_f64_s", "makeUnary(s, UnaryOp::TruncSFloat64ToInt32)"), + ("i32.trunc_f64_u", "makeUnary(s, UnaryOp::TruncUFloat64ToInt32)"), + ("i64.extend_i32_s", "makeUnary(s, UnaryOp::ExtendSInt32)"), + ("i64.extend_i32_u", "makeUnary(s, UnaryOp::ExtendUInt32)"), + ("i64.trunc_f32_s", "makeUnary(s, UnaryOp::TruncSFloat32ToInt64)"), + ("i64.trunc_f32_u", "makeUnary(s, UnaryOp::TruncUFloat32ToInt64)"), + ("i64.trunc_f64_s", "makeUnary(s, UnaryOp::TruncSFloat64ToInt64)"), + ("i64.trunc_f64_u", "makeUnary(s, UnaryOp::TruncUFloat64ToInt64)"), + ("f32.convert_i32_s", "makeUnary(s, UnaryOp::ConvertSInt32ToFloat32)"), + ("f32.convert_i32_u", "makeUnary(s, UnaryOp::ConvertUInt32ToFloat32)"), + ("f32.convert_i64_s", "makeUnary(s, UnaryOp::ConvertSInt64ToFloat32)"), + ("f32.convert_i64_u", "makeUnary(s, UnaryOp::ConvertUInt64ToFloat32)"), + ("f32.demote_f64", "makeUnary(s, UnaryOp::DemoteFloat64)"), + ("f64.convert_i32_s", "makeUnary(s, UnaryOp::ConvertSInt32ToFloat64)"), + ("f64.convert_i32_u", "makeUnary(s, UnaryOp::ConvertUInt32ToFloat64)"), + ("f64.convert_i64_s", "makeUnary(s, UnaryOp::ConvertSInt64ToFloat64)"), + ("f64.convert_i64_u", "makeUnary(s, UnaryOp::ConvertUInt64ToFloat64)"), + ("f64.promote_f32", "makeUnary(s, UnaryOp::PromoteFloat32)"), + ("i32.reinterpret_f32", "makeUnary(s, UnaryOp::ReinterpretFloat32)"), + ("i64.reinterpret_f64", "makeUnary(s, UnaryOp::ReinterpretFloat64)"), + ("f32.reinterpret_i32", "makeUnary(s, UnaryOp::ReinterpretInt32)"), + ("f64.reinterpret_i64", "makeUnary(s, UnaryOp::ReinterpretInt64)"), ("i32.extend8_s", "makeUnary(s, UnaryOp::ExtendS8Int32)"), ("i32.extend16_s", "makeUnary(s, UnaryOp::ExtendS16Int32)"), ("i64.extend8_s", "makeUnary(s, UnaryOp::ExtendS8Int64)"), @@ -210,64 +210,205 @@ instructions = [ ("i64.atomic.store16", "makeStore(s, i64, /*isAtomic=*/true)"), ("i64.atomic.store32", "makeStore(s, i64, /*isAtomic=*/true)"), ("i64.atomic.store", "makeStore(s, i64, /*isAtomic=*/true)"), - ("i32.atomic.rmw8_u.add", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i32.atomic.rmw16_u.add", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw8.add_u", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw16.add_u", "makeAtomicRMWOrCmpxchg(s, i32)"), ("i32.atomic.rmw.add", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i64.atomic.rmw8_u.add", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw16_u.add", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw32_u.add", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw8.add_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw16.add_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw32.add_u", "makeAtomicRMWOrCmpxchg(s, i64)"), ("i64.atomic.rmw.add", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i32.atomic.rmw8_u.sub", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i32.atomic.rmw16_u.sub", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw8.sub_u", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw16.sub_u", "makeAtomicRMWOrCmpxchg(s, i32)"), ("i32.atomic.rmw.sub", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i64.atomic.rmw8_u.sub", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw16_u.sub", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw32_u.sub", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw8.sub_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw16.sub_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw32.sub_u", "makeAtomicRMWOrCmpxchg(s, i64)"), ("i64.atomic.rmw.sub", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i32.atomic.rmw8_u.and", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i32.atomic.rmw16_u.and", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw8.and_u", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw16.and_u", "makeAtomicRMWOrCmpxchg(s, i32)"), ("i32.atomic.rmw.and", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i64.atomic.rmw8_u.and", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw16_u.and", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw32_u.and", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw8.and_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw16.and_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw32.and_u", "makeAtomicRMWOrCmpxchg(s, i64)"), ("i64.atomic.rmw.and", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i32.atomic.rmw8_u.or", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i32.atomic.rmw16_u.or", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw8.or_u", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw16.or_u", "makeAtomicRMWOrCmpxchg(s, i32)"), ("i32.atomic.rmw.or", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i64.atomic.rmw8_u.or", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw16_u.or", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw32_u.or", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw8.or_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw16.or_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw32.or_u", "makeAtomicRMWOrCmpxchg(s, i64)"), ("i64.atomic.rmw.or", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i32.atomic.rmw8_u.xor", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i32.atomic.rmw16_u.xor", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw8.xor_u", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw16.xor_u", "makeAtomicRMWOrCmpxchg(s, i32)"), ("i32.atomic.rmw.xor", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i64.atomic.rmw8_u.xor", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw16_u.xor", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw32_u.xor", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw8.xor_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw16.xor_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw32.xor_u", "makeAtomicRMWOrCmpxchg(s, i64)"), ("i64.atomic.rmw.xor", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i32.atomic.rmw8_u.xchg", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i32.atomic.rmw16_u.xchg", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw8.xchg_u", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw16.xchg_u", "makeAtomicRMWOrCmpxchg(s, i32)"), ("i32.atomic.rmw.xchg", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i64.atomic.rmw8_u.xchg", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw16_u.xchg", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw32_u.xchg", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw8.xchg_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw16.xchg_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw32.xchg_u", "makeAtomicRMWOrCmpxchg(s, i64)"), ("i64.atomic.rmw.xchg", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i32.atomic.rmw8_u.cmpxchg", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i32.atomic.rmw16_u.cmpxchg", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw8.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, i32)"), + ("i32.atomic.rmw16.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, i32)"), ("i32.atomic.rmw.cmpxchg", "makeAtomicRMWOrCmpxchg(s, i32)"), - ("i64.atomic.rmw8_u.cmpxchg", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw16_u.cmpxchg", "makeAtomicRMWOrCmpxchg(s, i64)"), - ("i64.atomic.rmw32_u.cmpxchg", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw8.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw16.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, i64)"), + ("i64.atomic.rmw32.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, i64)"), ("i64.atomic.rmw.cmpxchg", "makeAtomicRMWOrCmpxchg(s, i64)"), # nontrapping float-to-int instructions - ("i32.trunc_s:sat/f32", "makeUnary(s, UnaryOp::TruncSatSFloat32ToInt32)"), - ("i32.trunc_u:sat/f32", "makeUnary(s, UnaryOp::TruncSatUFloat32ToInt32)"), - ("i32.trunc_s:sat/f64", "makeUnary(s, UnaryOp::TruncSatSFloat64ToInt32)"), - ("i32.trunc_u:sat/f64", "makeUnary(s, UnaryOp::TruncSatUFloat64ToInt32)"), - ("i64.trunc_s:sat/f32", "makeUnary(s, UnaryOp::TruncSatSFloat32ToInt64)"), - ("i64.trunc_u:sat/f32", "makeUnary(s, UnaryOp::TruncSatUFloat32ToInt64)"), - ("i64.trunc_s:sat/f64", "makeUnary(s, UnaryOp::TruncSatSFloat64ToInt64)"), - ("i64.trunc_u:sat/f64", "makeUnary(s, UnaryOp::TruncSatUFloat64ToInt64)"), + ("i32.trunc_sat_f32_s", "makeUnary(s, UnaryOp::TruncSatSFloat32ToInt32)"), + ("i32.trunc_sat_f32_u", "makeUnary(s, UnaryOp::TruncSatUFloat32ToInt32)"), + ("i32.trunc_sat_f64_s", "makeUnary(s, UnaryOp::TruncSatSFloat64ToInt32)"), + ("i32.trunc_sat_f64_u", "makeUnary(s, UnaryOp::TruncSatUFloat64ToInt32)"), + ("i64.trunc_sat_f32_s", "makeUnary(s, UnaryOp::TruncSatSFloat32ToInt64)"), + ("i64.trunc_sat_f32_u", "makeUnary(s, UnaryOp::TruncSatUFloat32ToInt64)"), + ("i64.trunc_sat_f64_s", "makeUnary(s, UnaryOp::TruncSatSFloat64ToInt64)"), + ("i64.trunc_sat_f64_u", "makeUnary(s, UnaryOp::TruncSatUFloat64ToInt64)"), + # SIMD ops + ("v128.load", "makeLoad(s, v128, /*isAtomic=*/false)"), + ("v128.store", "makeStore(s, v128, /*isAtomic=*/false)"), + ("v128.const", "makeConst(s, v128)"), + ("v8x16.shuffle", "makeSIMDShuffle(s)"), + ("i8x16.splat", "makeUnary(s, UnaryOp::SplatVecI8x16)"), + ("i8x16.extract_lane_s", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneSVecI8x16, 16)"), + ("i8x16.extract_lane_u", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneUVecI8x16, 16)"), + ("i8x16.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI8x16, 16)"), + ("i16x8.splat", "makeUnary(s, UnaryOp::SplatVecI16x8)"), + ("i16x8.extract_lane_s", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneSVecI16x8, 8)"), + ("i16x8.extract_lane_u", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneUVecI16x8, 8)"), + ("i16x8.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI16x8, 8)"), + ("i32x4.splat", "makeUnary(s, UnaryOp::SplatVecI32x4)"), + ("i32x4.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI32x4, 4)"), + ("i32x4.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI32x4, 4)"), + ("i64x2.splat", "makeUnary(s, UnaryOp::SplatVecI64x2)"), + ("i64x2.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI64x2, 2)"), + ("i64x2.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI64x2, 2)"), + ("f32x4.splat", "makeUnary(s, UnaryOp::SplatVecF32x4)"), + ("f32x4.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecF32x4, 4)"), + ("f32x4.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecF32x4, 4)"), + ("f64x2.splat", "makeUnary(s, UnaryOp::SplatVecF64x2)"), + ("f64x2.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecF64x2, 2)"), + ("f64x2.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecF64x2, 2)"), + ("i8x16.eq", "makeBinary(s, BinaryOp::EqVecI8x16)"), + ("i8x16.ne", "makeBinary(s, BinaryOp::NeVecI8x16)"), + ("i8x16.lt_s", "makeBinary(s, BinaryOp::LtSVecI8x16)"), + ("i8x16.lt_u", "makeBinary(s, BinaryOp::LtUVecI8x16)"), + ("i8x16.gt_s", "makeBinary(s, BinaryOp::GtSVecI8x16)"), + ("i8x16.gt_u", "makeBinary(s, BinaryOp::GtUVecI8x16)"), + ("i8x16.le_s", "makeBinary(s, BinaryOp::LeSVecI8x16)"), + ("i8x16.le_u", "makeBinary(s, BinaryOp::LeUVecI8x16)"), + ("i8x16.ge_s", "makeBinary(s, BinaryOp::GeSVecI8x16)"), + ("i8x16.ge_u", "makeBinary(s, BinaryOp::GeUVecI8x16)"), + ("i16x8.eq", "makeBinary(s, BinaryOp::EqVecI16x8)"), + ("i16x8.ne", "makeBinary(s, BinaryOp::NeVecI16x8)"), + ("i16x8.lt_s", "makeBinary(s, BinaryOp::LtSVecI16x8)"), + ("i16x8.lt_u", "makeBinary(s, BinaryOp::LtUVecI16x8)"), + ("i16x8.gt_s", "makeBinary(s, BinaryOp::GtSVecI16x8)"), + ("i16x8.gt_u", "makeBinary(s, BinaryOp::GtUVecI16x8)"), + ("i16x8.le_s", "makeBinary(s, BinaryOp::LeSVecI16x8)"), + ("i16x8.le_u", "makeBinary(s, BinaryOp::LeUVecI16x8)"), + ("i16x8.ge_s", "makeBinary(s, BinaryOp::GeSVecI16x8)"), + ("i16x8.ge_u", "makeBinary(s, BinaryOp::GeUVecI16x8)"), + ("i32x4.eq", "makeBinary(s, BinaryOp::EqVecI32x4)"), + ("i32x4.ne", "makeBinary(s, BinaryOp::NeVecI32x4)"), + ("i32x4.lt_s", "makeBinary(s, BinaryOp::LtSVecI32x4)"), + ("i32x4.lt_u", "makeBinary(s, BinaryOp::LtUVecI32x4)"), + ("i32x4.gt_s", "makeBinary(s, BinaryOp::GtSVecI32x4)"), + ("i32x4.gt_u", "makeBinary(s, BinaryOp::GtUVecI32x4)"), + ("i32x4.le_s", "makeBinary(s, BinaryOp::LeSVecI32x4)"), + ("i32x4.le_u", "makeBinary(s, BinaryOp::LeUVecI32x4)"), + ("i32x4.ge_s", "makeBinary(s, BinaryOp::GeSVecI32x4)"), + ("i32x4.ge_u", "makeBinary(s, BinaryOp::GeUVecI32x4)"), + ("f32x4.eq", "makeBinary(s, BinaryOp::EqVecF32x4)"), + ("f32x4.ne", "makeBinary(s, BinaryOp::NeVecF32x4)"), + ("f32x4.lt", "makeBinary(s, BinaryOp::LtVecF32x4)"), + ("f32x4.gt", "makeBinary(s, BinaryOp::GtVecF32x4)"), + ("f32x4.le", "makeBinary(s, BinaryOp::LeVecF32x4)"), + ("f32x4.ge", "makeBinary(s, BinaryOp::GeVecF32x4)"), + ("f64x2.eq", "makeBinary(s, BinaryOp::EqVecF64x2)"), + ("f64x2.ne", "makeBinary(s, BinaryOp::NeVecF64x2)"), + ("f64x2.lt", "makeBinary(s, BinaryOp::LtVecF64x2)"), + ("f64x2.gt", "makeBinary(s, BinaryOp::GtVecF64x2)"), + ("f64x2.le", "makeBinary(s, BinaryOp::LeVecF64x2)"), + ("f64x2.ge", "makeBinary(s, BinaryOp::GeVecF64x2)"), + ("v128.not", "makeUnary(s, UnaryOp::NotVec128)"), + ("v128.and", "makeBinary(s, BinaryOp::AndVec128)"), + ("v128.or", "makeBinary(s, BinaryOp::OrVec128)"), + ("v128.xor", "makeBinary(s, BinaryOp::XorVec128)"), + ("v128.bitselect", "makeSIMDBitselect(s)"), + ("i8x16.neg", "makeUnary(s, UnaryOp::NegVecI8x16)"), + ("i8x16.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI8x16)"), + ("i8x16.all_true", "makeUnary(s, UnaryOp::AllTrueVecI8x16)"), + ("i8x16.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI8x16)"), + ("i8x16.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI8x16)"), + ("i8x16.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI8x16)"), + ("i8x16.add", "makeBinary(s, BinaryOp::AddVecI8x16)"), + ("i8x16.add_saturate_s", "makeBinary(s, BinaryOp::AddSatSVecI8x16)"), + ("i8x16.add_saturate_u", "makeBinary(s, BinaryOp::AddSatUVecI8x16)"), + ("i8x16.sub", "makeBinary(s, BinaryOp::SubVecI8x16)"), + ("i8x16.sub_saturate_s", "makeBinary(s, BinaryOp::SubSatSVecI8x16)"), + ("i8x16.sub_saturate_u", "makeBinary(s, BinaryOp::SubSatUVecI8x16)"), + ("i8x16.mul", "makeBinary(s, BinaryOp::MulVecI8x16)"), + ("i16x8.neg", "makeUnary(s, UnaryOp::NegVecI16x8)"), + ("i16x8.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI16x8)"), + ("i16x8.all_true", "makeUnary(s, UnaryOp::AllTrueVecI16x8)"), + ("i16x8.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI16x8)"), + ("i16x8.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI16x8)"), + ("i16x8.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI16x8)"), + ("i16x8.add", "makeBinary(s, BinaryOp::AddVecI16x8)"), + ("i16x8.add_saturate_s", "makeBinary(s, BinaryOp::AddSatSVecI16x8)"), + ("i16x8.add_saturate_u", "makeBinary(s, BinaryOp::AddSatUVecI16x8)"), + ("i16x8.sub", "makeBinary(s, BinaryOp::SubVecI16x8)"), + ("i16x8.sub_saturate_s", "makeBinary(s, BinaryOp::SubSatSVecI16x8)"), + ("i16x8.sub_saturate_u", "makeBinary(s, BinaryOp::SubSatUVecI16x8)"), + ("i16x8.mul", "makeBinary(s, BinaryOp::MulVecI16x8)"), + ("i32x4.neg", "makeUnary(s, UnaryOp::NegVecI32x4)"), + ("i32x4.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI32x4)"), + ("i32x4.all_true", "makeUnary(s, UnaryOp::AllTrueVecI32x4)"), + ("i32x4.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI32x4)"), + ("i32x4.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI32x4)"), + ("i32x4.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI32x4)"), + ("i32x4.add", "makeBinary(s, BinaryOp::AddVecI32x4)"), + ("i32x4.sub", "makeBinary(s, BinaryOp::SubVecI32x4)"), + ("i32x4.mul", "makeBinary(s, BinaryOp::MulVecI32x4)"), + ("i64x2.neg", "makeUnary(s, UnaryOp::NegVecI64x2)"), + ("i64x2.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI64x2)"), + ("i64x2.all_true", "makeUnary(s, UnaryOp::AllTrueVecI64x2)"), + ("i64x2.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI64x2)"), + ("i64x2.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI64x2)"), + ("i64x2.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI64x2)"), + ("i64x2.add", "makeBinary(s, BinaryOp::AddVecI64x2)"), + ("i64x2.sub", "makeBinary(s, BinaryOp::SubVecI64x2)"), + ("f32x4.abs", "makeUnary(s, UnaryOp::AbsVecF32x4)"), + ("f32x4.neg", "makeUnary(s, UnaryOp::NegVecF32x4)"), + ("f32x4.sqrt", "makeUnary(s, UnaryOp::SqrtVecF32x4)"), + ("f32x4.add", "makeBinary(s, BinaryOp::AddVecF32x4)"), + ("f32x4.sub", "makeBinary(s, BinaryOp::SubVecF32x4)"), + ("f32x4.mul", "makeBinary(s, BinaryOp::MulVecF32x4)"), + ("f32x4.div", "makeBinary(s, BinaryOp::DivVecF32x4)"), + ("f32x4.min", "makeBinary(s, BinaryOp::MinVecF32x4)"), + ("f32x4.max", "makeBinary(s, BinaryOp::MaxVecF32x4)"), + ("f64x2.abs", "makeUnary(s, UnaryOp::AbsVecF64x2)"), + ("f64x2.neg", "makeUnary(s, UnaryOp::NegVecF64x2)"), + ("f64x2.sqrt", "makeUnary(s, UnaryOp::SqrtVecF64x2)"), + ("f64x2.add", "makeBinary(s, BinaryOp::AddVecF64x2)"), + ("f64x2.sub", "makeBinary(s, BinaryOp::SubVecF64x2)"), + ("f64x2.mul", "makeBinary(s, BinaryOp::MulVecF64x2)"), + ("f64x2.div", "makeBinary(s, BinaryOp::DivVecF64x2)"), + ("f64x2.min", "makeBinary(s, BinaryOp::MinVecF64x2)"), + ("f64x2.max", "makeBinary(s, BinaryOp::MaxVecF64x2)"), + ("i32x4.trunc_sat_f32x4_s", "makeUnary(s, UnaryOp::TruncSatSVecF32x4ToVecI32x4)"), + ("i32x4.trunc_sat_f32x4_u", "makeUnary(s, UnaryOp::TruncSatUVecF32x4ToVecI32x4)"), + ("i64x2.trunc_sat_f64x2_s", "makeUnary(s, UnaryOp::TruncSatSVecF64x2ToVecI64x2)"), + ("i64x2.trunc_sat_f64x2_u", "makeUnary(s, UnaryOp::TruncSatUVecF64x2ToVecI64x2)"), + ("f32x4.convert_i32x4_s", "makeUnary(s, UnaryOp::ConvertSVecI32x4ToVecF32x4)"), + ("f32x4.convert_i32x4_u", "makeUnary(s, UnaryOp::ConvertUVecI32x4ToVecF32x4)"), + ("f64x2.convert_i64x2_s", "makeUnary(s, UnaryOp::ConvertSVecI64x2ToVecF64x2)"), + ("f64x2.convert_i64x2_u", "makeUnary(s, UnaryOp::ConvertUVecI64x2ToVecF64x2)") ] @@ -308,7 +449,7 @@ class Node: def do_insert(self, full_inst, inst, expr): if inst is "": - assert self.expr is None, "Repeated instruction" + assert self.expr is None, "Repeated instruction " + full_inst self.expr = expr self.inst = full_inst return diff --git a/scripts/strip_local_names.py b/scripts/strip_local_names.py index d617766bc..2e14b8e2b 100644 --- a/scripts/strip_local_names.py +++ b/scripts/strip_local_names.py @@ -7,7 +7,7 @@ to diff for structural changes, this can help. import sys for line in open(sys.argv[1]).readlines(): - if '(tee_local ' in line or '(set_local ' in line or '(get_local ' in line: + if '(local.tee ' in line or '(local.set ' in line or '(local.get ' in line: print line[:line.find('$')] else: print line, |