// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || getBuildConfiguration("windows") || (!getBuildConfiguration("x64") && !getBuildConfiguration("x86") && !getBuildConfiguration("arm64") && !getBuildConfiguration("arm")); include:adhoc-multiplatform-test.js // // These tests push wasm functions through the ion pipe and specify an expected // disassembly output on all 4 primary targets, x64 / x86 / arm64 / arm(32). // Results must be provided for the first 3, but can optionally be skipped // for arm(32). // // Hence: disassembler is needed, compiler must be ion. // // Windows is disallowed because the argument registers are different from on // Linux, and matching both is both difficult and not of much value. // Tests are "end-to-end" in the sense that we don't care whether the // tested-for code improvement is done by MIR optimisation, or later in the // pipe. Observed defects are marked with FIXMEs for future easy finding. // Note that identities involving AND, OR and XOR are tested by // binop-x64-ion-folding.js // Multiplication with magic constant on the left // // 0 * x => 0 // 1 * x => x // -1 * x => -x // 2 * x => x + x // 4 * x => x << 2 "mul32_zeroL" ) (param $p1 i32) (result i32)const 0 ) (local.get $p1))))`,"mul32_zeroL" ,// FIXME move folding to MIR level // First we move edi to eax unnecessarily via ecx (bug 1752520), // then we overwrite eax. Presumably because the folding // 0 * x => 0 is done at the LIR level, not the MIR level, hence // the now-pointless WasmParameter node is not DCE'd away, since // DCE only happens at the MIR level. In fact all targets suffer // from the latter problem, but on x86 no_prefix_x86:true // hides it, and on arm32/64 the pointless move is correctly // transformed by RA into a no-op. 8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax33 c0 xor %eax, %eax`,33 c0 xor %eax, %eax`,2 a1f03e0 mov w0, wzr`,0 `},true }}"mul64_zeroL" ) (param $p1 i64) (result i64)const 0 ) (local.get $p1))))`,"mul64_zeroL" ,// FIXME folding happened, zero-creation insns could be improved // Same shenanigans as above. Also, on xor, REX.W is redundant. 48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 33 c0 xor %rax, %rax`,33 c0 xor %eax, %eax33 d2 xor %edx, %edx`,// bizarrely inconsistent with the 32-bit case true }}"mul32_oneL" ) (param $p1 i32) (result i32)const 1 ) (local.get $p1))))`,"mul32_oneL" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"mul64_oneL" ) (param $p1 i64) (result i64)const 1 ) (local.get $p1))))`,"mul64_oneL" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"mul32_minusOneL" ) (param $p1 i32) (result i32)const -1 ) (local.get $p1))))`,"mul32_minusOneL" ,4 b0003e0 neg w0, w0`,0 `},true }, x64: {no_prefix:true }}"mul64_minusOneL" ) (param $p1 i64) (result i64)const -1 ) (local.get $p1))))`,"mul64_minusOneL" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 f7 d8 neg %rax`,83 d2 00 adc \\$0 x00, %edx0 0 `},true }}"mul32_twoL" ) (param $p1 i32) (result i32)const 2 ) (local.get $p1))))`,"mul32_twoL" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax03 c0 add %eax, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax03 c0 add %eax, %eax`,0 b000000 add w0, w0, w0`,true }}"mul64_twoL" ) (param $p1 i64) (result i64)const 2 ) (local.get $p1))))`,"mul64_twoL" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 03 c0 add %rax, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax03 c0 add %eax, %eax13 d2 adc %edx, %edx`,8 b000000 add x0, x0, x0`,true }}"mul32_fourL" ) (param $p1 i32) (result i32)const 4 ) (local.get $p1))))`,"mul32_fourL" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax02 shl \\$0 x02, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax02 shl \\$0 x02, %eax`,531 e7400 lsl w0, w0, #2 `,2 `},true }}"mul64_fourL" ) (param $p1 i64) (result i64)const 4 ) (local.get $p1))))`,"mul64_fourL" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 c1 e0 02 shl \\$0 x02, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax0 f a4 c2 02 shld \\$0 x02, %eax, %edx02 shl \\$0 x02, %eax`,2 `,2 30 2 `},true }}// Multiplication with magic constant on the right // // x * 0 => 0 // x * 1 => x // x * -1 => -x // x * 2 => x + x // x * 4 => x << 2 "mul32_zeroR" ) (param $p1 i32) (result i32)const 0 ))))`,"mul32_zeroR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax33 c0 xor %eax, %eax`,33 c0 xor %eax, %eax`,2 a1f03e0 mov w0, wzr`,0 `},true }}"mul64_zeroR" ) (param $p1 i64) (result i64)const 0 ))))`,"mul64_zeroR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 33 c0 xor %rax, %rax`, // REX.W is redundant 33 c0 xor %eax, %eax33 d2 xor %edx, %edx`,true }}"mul32_oneR" ) (param $p1 i32) (result i32)const 1 ))))`,"mul32_oneR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"mul64_oneR" ) (param $p1 i64) (result i64)const 1 ))))`,"mul64_oneR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"mul32_minusOneR" ) (param $p1 i32) (result i32)const -1 ))))`,"mul32_minusOneR" ,4 b0003e0 neg w0, w0`,0 `},true }, x64: {no_prefix:true }}"mul64_minusOneR" ) (param $p1 i64) (result i64)const -1 ))))`,"mul64_minusOneR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 f7 d8 neg %rax`,83 d2 00 adc \\$0 x00, %edx0 0 `},true }}"mul32_twoR" ) (param $p1 i32) (result i32)const 2 ))))`,"mul32_twoR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax03 c0 add %eax, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax03 c0 add %eax, %eax`,0 b000000 add w0, w0, w0`,true }}"mul64_twoR" ) (param $p1 i64) (result i64)const 2 ))))`,"mul64_twoR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 03 c0 add %rax, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax03 c0 add %eax, %eax13 d2 adc %edx, %edx`,8 b000000 add x0, x0, x0`,true }}"mul32_fourR" ) (param $p1 i32) (result i32)const 4 ))))`,"mul32_fourR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax02 shl \\$0 x02, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax02 shl \\$0 x02, %eax`,531 e7400 lsl w0, w0, #2 `,2 `},true }}"mul64_fourR" ) (param $p1 i64) (result i64)const 4 ))))`,"mul64_fourR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 c1 e0 02 shl \\$0 x02, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax0 f a4 c2 02 shld \\$0 x02, %eax, %edx02 shl \\$0 x02, %eax`,2 `,2 30 2 `true }}// Shifts by zero (the right arg is zero) // // x >> 0 => x (any shift kind: shl, shrU, shrS) "shl32_zeroR" ) (param $p1 i32) (result i32)const 0 ))))`,"shl32_zeroR" ,// FIXME check these are consistently folded out at the MIR level 8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,// Regalloc badness, plus not folded out at the MIR level 2 a0003e2 mov w2, w02 a0203e1 mov w1, w253007 c20 lsr w0, w1, #0 `, // Uhh. lsr ?! true }}"shl64_zeroR" ) (param $p1 i64) (result i64)const 0 ))))`,"shl64_zeroR" ,// FIXME why is this code so much better than the 32-bit case? 48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,// no-op // no-op true }}"shrU32_zeroR" ) (param $p1 i32) (result i32)const 0 ))))`,"shrU32_zeroR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,2 a0003e2 mov w2, w02 a0203e1 mov w1, w22 a0103e0 mov w0, w1`,true }}"shrU64_zeroR" ) (param $p1 i64) (result i64)const 0 ))))`,"shrU64_zeroR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"shrS32_zeroR" ) (param $p1 i32) (result i32)const 0 ))))`,"shrS32_zeroR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,2 a0003e2 mov w2, w02 a0203e1 mov w1, w213007 c20 sbfx w0, w1, #0 , #32 `,true }}"shrS64_zeroR" ) (param $p1 i64) (result i64)const 0 ))))`,"shrS64_zeroR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}// Identities involving addition // // x + 0 => x // 0 + x => x // x + x => x << 1 "add32_zeroR" ) (param $p1 i32) (result i32)const 0 ))))`,"add32_zeroR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"add64_zeroR" ) (param $p1 i64) (result i64)const 0 ))))`,"add64_zeroR" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"add32_zeroL" ) (param $p1 i32) (result i32)const 0 ) (local.get $p1))))`,"add32_zeroL" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"add64_zeroL" ) (param $p1 i64) (result i64)const 0 ) (local.get $p1))))`,"add64_zeroL" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"add32_self" ) (param $p1 i32) (result i32)"add32_self" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax03 c1 add %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax03 45 10 addl 0 x10\\(%rbp\\), %eax`,0 b000000 add w0, w0, w0`,true }}"add64_self" ) (param $p1 i64) (result i64)"add64_self" ,// FIXME outstandingly bad 32-bit sequences, probably due to the RA 48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 03 c1 add %rcx, %rax`,// -0x21524111 is 0xDEADBEEF 8 b 5 d 14 movl 0 x14\\(%rbp\\), %ebx8 b 4 d 10 movl 0 x10\\(%rbp\\), %ecx0 x21524111, %edi8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax03 c1 add %ecx, %eax13 d3 adc %ebx, %edx`,8 b000000 add x0, x0, x0`,// play Musical Chairs for a while true }}// Identities involving subtraction // // x - 0 => x // 0 - x => -x // x - x => 0 "sub32_zeroR" ) (param $p1 i32) (result i32)const 0 ))))`,"sub32_zeroR" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax`,8 b 45 10 movl 0 x10\\(%rbp\\), %eax`,true }}"sub64_zeroR" ) (param $p1 i64) (result i64)const 0 ))))`,"sub64_zeroR" ,// FIXME folding missing for all 4 targets 48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 83 e8 00 sub \\$0 x00, %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax83 ea 00 sub \\$0 x00, %edx`,0 0 `true }}"sub32_zeroL" ) (param $p1 i32) (result i32)const 0 ) (local.get $p1))))`,"sub32_zeroL" ,8 b cf mov %edi, %ecx8 b c1 mov %ecx, %eax8 b 45 10 movl 0 x10\\(%rbp\\), %eax4 b0003e0 neg w0, w0 `,0 `true }}"sub64_zeroL" ) (param $p1 i64) (result i64)const 0 ) (local.get $p1))))`,"sub64_zeroL" ,48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 f7 d8 neg %rax`,8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax83 d2 00 adc \\$0 x00, %edx0 0 `true }}"sub32_self" ) (param $p1 i32) (result i32)"sub32_self" ,33 c0 xor %eax, %eax`,33 c0 xor %eax, %eax`,52800000 mov w0, #0 x0`,0 `true }}"sub64_self" ) (param $p1 i64) (result i64)"sub64_self" ,// FIXME folding missing for all 4 targets 48 89 f9 mov %rdi, %rcx48 89 c8 mov %rcx, %rax48 2 b c1 sub %rcx, %rax`,// -0x21524111 is 0xDEADBEEF 8 b 5 d 14 movl 0 x14\\(%rbp\\), %ebx8 b 4 d 10 movl 0 x10\\(%rbp\\), %ecx0 x21524111, %edi8 b 55 14 movl 0 x14\\(%rbp\\), %edx8 b 45 10 movl 0 x10\\(%rbp\\), %eax2 b c1 sub %ecx, %eax1 b d3 sbb %ebx, %edx`,true }}
Messung V0.5 in Prozent C=91 H=96 G=93
¤ Dauer der Verarbeitung: 0.15 Sekunden
(vorverarbeitet am 2026-06-06)
¤ *© Formatika GbR, Deutschland
