// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration("arm64"); include:codegen-arm64-test.js // Basic constant folding tests for ( [op, lhs, rhs, expect] of'add' , 5 , 8 , 'mov x0, #0xd' ],'sub' , 4 , 5 , 'mov x0, #0xffffffffffffffff' ],'mul' , 8 , 3 , 'mov x0, #0x18' ],'div_s' , -8 , 3 , 'mov x0, #0xfffffffffffffffe' ],'div_u' , 8 , 3 , 'mov x0, #0x2' ],'rem_s' , 8 , 5 , 'mov x0, #0x3' ],'rem_u' , -7 , 4 , 'mov x0, #0x1' ],'and' , 0 xfe, 0 x77, 'mov x0, #0x76' ],'or' , 0 xfe, 0 x77, 'mov x0, #0xff' ],'xor' , 0 xfe, 0 x77, 'mov x0, #0x89' ],'shl' , 3 , 4 , 'mov x0, #0x30' ],'shr_s' , -8 , 1 , 'mov x0, #0xfffffffffffffffc' ],'shr_u' , -8 , 1 , 'mov x0, #0x7ffffffffffffffc' ]] ) {"f" ) (result i64)const ${lhs}) (i64.const ${rhs}))))`,'f' ,// Basic tests that addition and multiplication identities are collapsed, use // arg 1 here to force an explicit move to be emitted. for ( [op, args, expect] of'add' , '(local.get 1) (i64.const 0)' , 'mov x0, x1' ],'add' , '(i64.const 0) (local.get 1)' , 'mov x0, x1' ],'mul' , '(local.get 1) (i64.const 1)' , 'mov x0, x1' ],'mul' , '(i64.const 1) (local.get 1)' , 'mov x0, x1' ]] ) {"f" ) (param i64) (param i64) (result i64)'f' ,// Test that multiplication by -1 yields negation. "f" ) (param i32) (result i32)0 ) (i32.const -1 ))))`;'f' ,'neg w0, w0' );37 ), 37 )42 ), -42 )"f" ) (param i64) (result i64)0 ) (i64.const -1 ))))`'f' ,'neg x0, x0' );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' ,'mov w0, wzr' );37 ), 0 )42 ), 0 )"f" ) (param i64) (result i64)0 ) (i64.const 0 ))))`'f' ,'mov x0, xzr' );37000000000 n), 0 n)42000000000 n), 0 n)// Test that multiplication by one yields no code (this optimization currently // exists both in constant folding and in lowering). "f" ) (param i32) (result i32)0 ) (i32.const 1 ))))`;'f' ,'' );37 ), -37 )42 ), 42 )"f" ) (param i64) (result i64)0 ) (i64.const 1 ))))`'f' ,'' );37000000000 n), -37000000000 n)42000000000 n), 42000000000 n)// Test that multiplication by two yields an add "f" ) (param i32) (result i32)0 ) (i32.const 2 ))))`;'f' ,'add w0, w0, w0' );37 ), -74 )42 ), 84 )"f" ) (param i64) (result i64)0 ) (i64.const 2 ))))`'f' ,'add x0, x0, x0' );37000000000 n), -74000000000 n)42000000000 n), 84000000000 n)// Test that multiplication by four yields a shift "f" ) (param i32) (result i32)0 ) (i32.const 4 ))))`;'f' ,'lsl w0, w0, #2' );37 ), -148 )42 ), 168 )"f" ) (param i64) (result i64)0 ) (i64.const 4 ))))`'f' ,'lsl x0, x0, #2' );37000000000 n), -148000000000 n)42000000000 n), 168000000000 n)// Test that multiplication by five yields a multiply "f" ) (param i32) (result i32)0 ) (i32.const 5 ))))`;'f' ,0 x537 ), -37 *5 )42 ), 42 *5 )"f" ) (param i64) (result i64)0 ) (i64.const 5 ))))`'f' ,0 x537000000000 n), -37000000000 n*5 n)42000000000 n), 42000000000 n*5 n)// Test that add/sub/and/or/xor don't need to reuse their input register. The // proof here is that the destination register does not equal any of the input // registers. // // We have adequate functionality tests for these elsewhere, so test only // codegen here. for ( [op, imm, expectVar, expectImm] of'and' , 64 ,'and x0, x1, x2' ,'and x0, x1, #0x40' ],'or' , 64 ,'orr x0, x1, x2' ,'orr x0, x1, #0x40' ],'xor' , 64 ,'eor x0, x1, x2' ,'eor x0, x1, #0x40' ],'add' , 64 ,'add x0, x1, x2' ,'add x0, x1, #0x40 \\(64\\)' ],'sub' , 64 ,'sub x0, x1, x2' ,'sub x0, x1, #0x40 \\(64\\)' ]] ) {"f" ) (param i64) (param i64) (param i64) (result i64)1 ) (local.get 2 ))))`,'f' ,"f" ) (param i64) (param i64) (result i64)1 ) (i64.const ${imm}))))`,'f' ,// Test that shifts and rotates with a constant don't need to reuse their input // register. The proof here is that the destination register does not equal any // of the input registers. // // We have adequate functionality tests for these elsewhere, so test only // codegen here. for ( [op, expect] of'shl' , 'lsl x0, x1, #2' ],'shr_s' , 'asr x0, x1, #2' ],'shr_u' , 'lsr x0, x1, #2' ],'rotl' , 'ror x0, x1, #62' ],'rotr' , 'ror x0, x1, #2' ]] ) {"f" ) (param i64) (param i64) (result i64)1 ) (i64.const 2 ))))`,'f' ,// Test that 0-n yields negation. "f" ) (param i32) (result i32)const 0 ) (local.get 0 ))))`'f' ,'neg w0, w0' );37 ), 37 )42 ), -42 )"f" ) (param i64) (result i64)const 0 ) (local.get 0 ))))`'f' ,'neg x0, x0' );37000000000 n), 37000000000 n)42000000000 n), -42000000000 n)// Test that select does something reasonable and does not tie its output to one // of its inputs. "f" ) (param i64) (param i64) (param i64) (param i32) (result i64)1 ) (local.get 2 ) (local.get 3 ))))`,'f' ,"f" ) (param f64) (param f64) (param f64) (param i32) (result f64)1 ) (local.get 2 ) (local.get 3 ))))`,'f' ,// Here we test that no boolean is generated and then re-tested, and that // operands are swapped so that we can use an immediate constant, and that the // input is not tied to the output. "f" ) (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32)const 0 ) (local.get $c)))))`,'f' ,0 x0 \\(0 \\)"f" ) (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64)const 0 ) (local.get $c)))))`,'f' ,0 x0// FP ABS should not tie its input to its output. "f" ) (param f32) (param f32) (result f32)1 ))))`,'f' ,'fabs s0, s1' );"f" ) (param f64) (param f64) (result f64)1 ))))`,'f' ,'fabs d0, d1' );// AND{32,64} followed by `== 0`: check the two operations are merged into a // single 'tst' 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_tst] of'i32' , 'tst w0, w1' ],'i64' , 'tst x0, x1' ]] ) {"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 xc \\(addr .*\\)0 x11d70 x8 \\(addr .*\\)0 x4d2`// AND64 followed by `== 0`, with one of the args being a constant. for ( [imm, expect1, expect2] of// as a valid logical-immediate => imm in insn '0x0F0F0F0F0F0F0F0F' ,'tst x0, #0xf0f0f0f0f0f0f0f' ,'' ],// anything else => imm synth'd into a reg '-0x4771' ,'mov x16, #0xffffffffffffb88f' ,'tst x0, x16' ]]"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 xc \\(addr .*\\)0 x11d70 x8 \\(addr .*\\)0 x4d2`// For integer comparison followed by select, check that the comparison result // isn't materialised into a register, for specific types. for ( [cmpTy, cmpOp, selTy, cmpRegPfx, cselRegPfx, armCC] of'i32' , 'le_s' , 'i32' , 'w' , 'w' , 'le' ],'i32' , 'lt_u' , 'i64' , 'w' , 'x' , 'lo' ],'i64' , 'le_s' , 'i32' , 'x' , 'w' , 'le' ],'i64' , 'lt_u' , 'i64' , 'x' , 'x' , 'lo' ],"f" )'f' ,0 , ${cmpRegPfx}1 0 , ${cselRegPfx}2 , ${cselRegPfx}3 , ${armCC}`
Messung V0.5 in Prozent C=93 H=86 G=89
¤ Dauer der Verarbeitung: 0.6 Sekunden
¤ *© Formatika GbR, Deutschland
