// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration("x64") || getBuildConfiguration("simulator"); include:codegen-x64-test.js // There may be some redundant moves to set some operations up on x64 (that's // bug 1701164) so we avoid those with no_prefix/no_suffix flags when the issue // comes up. // Handle calling convention differences. function codegenTestX64_adhoc_call(module_text, export_name, expected, options = {}) {// Microsoft x64 calling convention passes the first four arguments in // registers rcx, rdx, r8, r9 (in that order). if (getBuildConfiguration("windows" )) {// Arguments passed on the stack not yet supported. "%r8" ) || expected.includes("%r9" ),false ,"too many arguments" "%rcx" , "%r9" )"%rdx" , "%r8" )"%rsi" , "%rdx" )"%rdi" , "%rcx" )"%esi" , "%edx" )"%edi" , "%ecx" );// Test that multiplication by -1 yields negation. "f" ) (param i32) (result i32)0 ) (i32.const -1 ))))`;'f' ,'neg %eax' , {no_prefix:true });37 ), 37 )42 ), -42 )"f" ) (param i64) (result i64)0 ) (i64.const -1 ))))`;'f' ,'neg %rax' , {no_prefix:true });37000000000 n), 37000000000 n)42000000000 n), -42000000000 n)// Test that multiplication by zero yields zero "f" ) (param i32) (result i32)0 ) (i32.const 0 ))))`;'f' ,'xor %eax, %eax' );37 ), 0 )42 ), 0 )"f" ) (param i64) (result i64)0 ) (i64.const 0 ))))`'f' ,'xor %rax, %rax' );37000000000 n), 0 n)42000000000 n), 0 n)// Test that multiplication by one yields no code "f" ) (param i32) (result i32)0 ) (i32.const 1 ))))`;'f' ,'' , {no_prefix:true });37 ), -37 )42 ), 42 )"f" ) (param i64) (result i64)0 ) (i64.const 1 ))))`'f' ,'' , {no_prefix:true });37000000000 n), -37000000000 n)42000000000 n), 42000000000 n)// Test that multiplication by two yields lea "f" ) (param i32) (result i32)0 ) (i32.const 2 ))))`;'f' ,'lea \\(%rdi,%rdi,1\\), %eax' );37 ), -74 )42 ), 84 )"f" ) (param i64) (result i64)0 ) (i64.const 2 ))))`'f' ,'lea \\(%rdi,%rdi,1\\), %rax' );37000000000 n), -74000000000 n)42000000000 n), 84000000000 n)// Test that multiplication by four yields lea "f" ) (param i32) (result i32)0 ) (i32.const 4 ))))`;'f' ,'lea \\(,%rdi,4\\), %eax' );37 ), -148 )42 ), 168 )"f" ) (param i64) (result i64)0 ) (i64.const 4 ))))`'f' ,'lea \\(,%rdi,4\\), %rax' );37000000000 n), -148000000000 n)42000000000 n), 168000000000 n)// Test that multiplication by five yields lea "f" ) (param i32) (result i32)0 ) (i32.const 5 ))))`;'f' ,'lea \\(%rdi,%rdi,4\\), %eax' );37 ), -37 *5 )42 ), 42 *5 )"f" ) (param i64) (result i64)0 ) (i64.const 5 ))))`'f' ,4 \\), %rax`)37000000000 n), -37000000000 n*5 n)42000000000 n), 42000000000 n*5 n)// Test that multiplication by six yields imul "f" ) (param i32) (result i32)0 ) (i32.const 6 ))))`;'f' ,'imul \\$0x06, %edi, %eax' );37 ), -37 *6 )42 ), 42 *6 )"f" ) (param i64) (result i64)0 ) (i64.const 6 ))))`'f' ,0 x06, %rdi, %rax`)37000000000 n), -37000000000 n*6 n)42000000000 n), 42000000000 n*6 n)// Test that multiplication by UINT32_MAX yields imul "f" ) (param i64) (result i64)0 ) (i64.const 0 xffffffff))))`'f' ,0 x01, %r11dtrue })37000000000 n), BigInt.asIntN(64 , -37000000000 n*0 xffffffffn))42000000000 n), BigInt.asIntN(64 , 42000000000 n*0 xffffffffn))// Test that 0-n yields negation. "f" ) (param i32) (result i32)const 0 ) (local.get 0 ))))`'f' ,'neg %eax' , {no_prefix:true });37 ), 37 )42 ), -42 )"f" ) (param i64) (result i64)const 0 ) (local.get 0 ))))`'f' ,'neg %rax' , {no_prefix:true });37000000000 n), 37000000000 n)42000000000 n), -42000000000 n)// AND{32,64} followed by `== 0`: check the two operations are merged into a // single 'test' insn, and no 'and' insn. The merging isn't done for // {OR,XOR}{32,64}. This is for both arguments being non-constant. for ( [ty, expect_test] of'i32' , 'test %e.., %e..' ],'i64' , 'test %r.., %r..' ]] ) {"f" ) (param $p1 ${ty}) (param $p2 ${ty}) (result i32)const 0 x4D2))if (${ty}.eq (${ty}.and (local.get $p1) (local.get $p2))const 0 ))const 0 x11D7)))'f' ,0 x00000000000000..0 x11D7, %eax0 x00000000000000..0 x4D2, %eax`// AND64 followed by `== 0`, with one of the args being a constant. Depending // on the constant we can get one of three forms. for ( [imm, expect1, expect2] of// in signed-32 range => imm in insn '0x17654321' ,'test \\$0x17654321, %e..' , // edi or ecx '' ],// in unsigned-32 range => imm in reg via movl '0x87654321' ,'mov \\$-0x789ABCDF, %r11d' ,'test %r11, %r..' ], // rdi or rcx // not in either range => imm in reg via mov(absq) '0x187654321' ,'mov \\$0x187654321, %r11' ,'test %r11, %r..' ]] // rdi or rcx "f" ) (param $p1 i64) (result i32)const 0 x4D2))if (i64.eq (i64.and (i64.const ${imm}) (local.get $p1))const 0 ))const 0 x11D7)))'f' ,0 x00000000000000..0 x11D7, %eax0 x00000000000000..0 x4D2, %eax`// For integer comparison followed by select, check that the comparison result // isn't materialised into a register, for specific types. function cmpSel32vs64(cmpTy, cmpOp, selTy) {return `(module"f" )if (getBuildConfiguration("windows" )) {for ( [cmpTy, cmpOp, selTy, insn1, insn2, insn3] of'i32' , 'le_s' , 'i32' , 'mov %ebx, %eax' ,'cmp %edx, %ecx' ,'cmovnle %r9d, %eax' ],'i32' , 'lt_u' , 'i64' , 'mov %rbx, %rax' ,'cmp %edx, %ecx' ,'cmovnb %r9, %rax' ],'i64' , 'le_s' , 'i32' , 'mov %ebx, %eax' ,'cmp %rdx, %rcx' ,'cmovnle %r9d, %eax' ],'i64' , 'lt_u' , 'i64' , 'mov %rbx, %rax' ,'cmp %rdx, %rcx' ,'cmovnb %r9, %rax' ]'f' ,else {for ( [cmpTy, cmpOp, selTy, insn1, insn2, insn3] of'i32' , 'le_s' , 'i32' , 'mov %edx, %eax' ,'cmp %esi, %edi' ,'cmovnle %ecx, %eax' ],'i32' , 'lt_u' , 'i64' , 'mov %rdx, %rax' ,'cmp %esi, %edi' ,'cmovnb %rcx, %rax' ],'i64' , 'le_s' , 'i32' , 'mov %edx, %eax' ,'cmp %rsi, %rdi' ,'cmovnle %ecx, %eax' ],'i64' , 'lt_u' , 'i64' , 'mov %rdx, %rax' ,'cmp %rsi, %rdi' ,'cmovnb %rcx, %rax' ]'f' ,// For integer comparison followed by select, check correct use of operands in // registers vs memory. At least for the 64-bit-cmp/64-bit-sel case. for ( [pAnyCmp, pAnySel, cmpArgL, cmovArgL ] of// r, r '$pReg1' , '$pReg2' ,'%r.+' , '%r.+' ],// r, m '$pReg1' , '$pMem2' ,'%r.+' , '0x..\\(%rbp\\)' ],// m, r '$pMem1' , '$pReg2' ,'0x..\\(%rbp\\)' , '%r.+' ],// m, m '$pMem1' , '$pMem2' ,'0x..\\(%rbp\\)' , '0x..\\(%rbp\\)' ]"f" )for both ABIsfor both ABIsfor both ABIs'f' ,// On Linux we have an extra move "windows" ) ? '' : 'mov %r.+, %r.+\n' ) +// 'q*' because the disassembler shows 'q' only for the memory cases
Messung V0.5 in Prozent C=92 H=65 G=79
¤ Dauer der Verarbeitung: 0.16 Sekunden
(vorverarbeitet am 2026-08-26)
¤ *© Formatika GbR, Deutschland
