A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
cranelift: avoid scratch register clobber in large-offset address materialization (#15108)
Dhanushc0459152dde8
diff --git a/cranelift/codegen/src/isa/aarch64/inst/emit.rs b/cranelift/codegen/src/isa/aarch64/inst/emit.rsindex 8060d6312d..82ba06f524 100644--- a/cranelift/codegen/src/isa/aarch64/inst/emit.rs+++ b/cranelift/codegen/src/isa/aarch64/inst/emit.rs@@ -65,7 +65,11 @@ pub fn mem_finalize(};(smallvec![], mem)} else {- let tmp = writable_spilltmp_reg();+ let tmp = if basereg == spilltmp_reg() {+ writable_tmp2_reg()+ } else {+ writable_spilltmp_reg()+ };(Inst::load_constant(tmp, off as u64),AMode::RegExtended {diff --git a/cranelift/codegen/src/isa/aarch64/inst/mod.rs b/cranelift/codegen/src/isa/aarch64/inst/mod.rsindex 26f2782477..3390da875c 100644--- a/cranelift/codegen/src/isa/aarch64/inst/mod.rs+++ b/cranelift/codegen/src/isa/aarch64/inst/mod.rs@@ -3111,7 +3111,7 @@ impl Inst {};ret.push_str(&add.print_with_state(&mut EmitState::default()));} else {- let tmp = writable_spilltmp_reg();+ let tmp = writable_tmp2_reg();for inst in Inst::load_constant(tmp, abs_offset).into_iter() {ret.push_str(&inst.print_with_state(&mut EmitState::default()));}diff --git a/cranelift/codegen/src/isa/riscv64/inst/emit.rs b/cranelift/codegen/src/isa/riscv64/inst/emit.rsindex 483d93c8ad..c61fb6c380 100644--- a/cranelift/codegen/src/isa/riscv64/inst/emit.rs+++ b/cranelift/codegen/src/isa/riscv64/inst/emit.rs@@ -1047,8 +1047,12 @@ impl Inst {// Otherwise, if the offset does not fit into a imm12, we need to materialize it into a// register and load from that.- (Some(_), None, None) => {- let tmp = writable_spilltmp_reg();+ (Some(base), None, None) => {+ let tmp = if base == spilltmp_reg() {+ writable_spilltmp_reg2()+ } else {+ writable_spilltmp_reg()+ };Inst::LoadAddr { rd: tmp, mem: from }.emit(sink, emit_info, state);(tmp.to_reg(), Imm12::ZERO)}@@ -1122,9 +1126,21 @@ impl Inst {let (addr, imm12) = match (base, offset_imm12) {// If the offset fits into an imm12 we can directly encode it.(Some(base), Some(imm12)) => (base, imm12),- // Otherwise load the address it into a reg and load from it.+ // Otherwise load the address into a scratch register and store to it._ => {- let tmp = writable_spilltmp_reg();+ // Avoid clobbering `base` or `src` when loading a large-offset address.+ // Synthesized large stores never occupy both scratch registers simultaneously.+ let tmp = if base != Some(spilltmp_reg()) && src != spilltmp_reg() {+ writable_spilltmp_reg()+ } else {+ debug_assert!(+ base != Some(spilltmp_reg2()) && src != spilltmp_reg2(),+ "base ({base:?}) and src ({src:?}) cannot simultaneously occupy \+ both reserved scratch registers (x30 and x31) in a store with \+ a non-immediate offset"+ );+ writable_spilltmp_reg2()+ };Inst::LoadAddr { rd: tmp, mem: to }.emit(sink, emit_info, state);(tmp.to_reg(), Imm12::ZERO)}@@ -1585,11 +1601,20 @@ impl Inst {.emit(sink, emit_info, state);}(_, Some(rs), None) => {- let mut insts = Inst::load_constant_u64(rd, offset as u64);+ let tmp = if rs == rd.to_reg() {+ if rs == spilltmp_reg() {+ writable_spilltmp_reg2()+ } else {+ writable_spilltmp_reg()+ }+ } else {+ rd+ };+ let mut insts = Inst::load_constant_u64(tmp, offset as u64);insts.push(Inst::AluRRR {alu_op: AluOPRRR::Add,rd,- rs1: rd.to_reg(),+ rs1: tmp.to_reg(),rs2: rs,});instsdiff --git a/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif b/cranelift/filetests/filetests/isa/aarch64/stack-limit.clifindex 237695394e..1cbb0d438e 100644--- a/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif+++ b/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif@@ -212,3 +212,47 @@ block0(v0: i64):; ret; udf #0xc11f ; trap: stk_ovf+function %limit_preamble_nested_huge_offset(i64 vmctx) {+ gv0 = vmctx+ gv1 = load.i64 notrap aligned gv0+400000+ gv2 = load.i64 notrap aligned gv1+400000+ stack_limit = gv2+ ss0 = explicit_slot 20+block0(v0: i64):+ return+}++; VCode:+; stp fp, lr, [sp, #-16]!+; mov fp, sp+; movz w16, #6784 ; movk w16, w16, #6, LSL #16 ; ldr x16, [x0, x16, SXTX]+; movz w17, #6784 ; movk w17, w17, #6, LSL #16 ; ldr x16, [x16, x17, SXTX]+; add x16, x16, #32+; subs xzr, sp, x16, UXTX+; b.lo #trap=stk_ovf+; sub sp, sp, #32+; block0:+; add sp, sp, #32+; ldp fp, lr, [sp], #16+; ret+;+; Disassembled:+; block0: ; offset 0x0+; stp x29, x30, [sp, #-0x10]!+; mov x29, sp+; mov w16, #0x1a80+; movk w16, #6, lsl #16+; ldr x16, [x0, x16, sxtx]+; mov w17, #0x1a80+; movk w17, #6, lsl #16+; ldr x16, [x16, x17, sxtx]+; add x16, x16, #0x20+; cmp sp, x16+; b.lo #0x3c+; sub sp, sp, #0x20+; block1: ; offset 0x30+; add sp, sp, #0x20+; ldp x29, x30, [sp], #0x10+; ret+; udf #0xc11f ; trap: stk_ovf+diff --git a/cranelift/filetests/filetests/isa/riscv64/amodes.clif b/cranelift/filetests/filetests/isa/riscv64/amodes.clifindex 5647bba2e0..af900b189e 100644--- a/cranelift/filetests/filetests/isa/riscv64/amodes.clif+++ b/cranelift/filetests/filetests/isa/riscv64/amodes.clif@@ -582,3 +582,123 @@ block0:; ld a0, 8(sp) ; trap: heap_oob; ret+function %store_i64_imm_offset_large(i64, i64) {+block0(v0: i64, v1: i64):+ store.i64 v1, v0+5000+ return+}++; VCode:+; block0:+; sd a1,5000(a0)+; ret+;+; Disassembled:+; block0: ; offset 0x0+; lui t6, 1+; addi t6, t6, 0x388+; add t6, t6, a0+; sd a1, 0(t6) ; trap: heap_oob+; ret++function %store_i64_imm_offset_large_neg(i64, i64) {+block0(v0: i64, v1: i64):+ store.i64 v1, v0-5000+ return+}++; VCode:+; block0:+; sd a1,-5000(a0)+; ret+;+; Disassembled:+; block0: ; offset 0x0+; lui t6, 0xfffff+; addi t6, t6, -0x388+; add t6, t6, a0+; sd a1, 0(t6) ; trap: heap_oob+; ret++function %load_i64_imm_offset_large(i64) -> i64 {+block0(v0: i64):+ v1 = load.i64 v0+5000+ return v1+}++; VCode:+; block0:+; ld a0,5000(a0)+; ret+;+; Disassembled:+; block0: ; offset 0x0+; lui t6, 1+; addi t6, t6, 0x388+; add t6, t6, a0+; ld a0, 0(t6) ; trap: heap_oob+; ret++function %load_i64_imm_offset_large_neg(i64) -> i64 {+block0(v0: i64):+ v1 = load.i64 v0-5000+ return v1+}++; VCode:+; block0:+; ld a0,-5000(a0)+; ret+;+; Disassembled:+; block0: ; offset 0x0+; lui t6, 0xfffff+; addi t6, t6, -0x388+; add t6, t6, a0+; ld a0, 0(t6) ; trap: heap_oob+; ret++function %stack_addr_large_offset() -> i64 {+ ss0 = explicit_slot 5000+block0:+ v0 = stack_addr.i64 ss0+ return v0+}++; VCode:+; addi sp,sp,-16+; sd ra,8(sp)+; sd fp,0(sp)+; mv fp,sp+; lui t6,-1+; addi t6,t6,-912+; add sp,sp,t6+; block0:+; load_addr a0,0(slot)+; lui t6,1+; addi t6,t6,912+; add sp,sp,t6+; ld ra,8(sp)+; ld fp,0(sp)+; addi sp,sp,16+; ret+;+; Disassembled:+; block0: ; offset 0x0+; addi sp, sp, -0x10+; sd ra, 8(sp)+; sd s0, 0(sp)+; mv s0, sp+; lui t6, 0xfffff+; addi t6, t6, -0x390+; add sp, sp, t6+; block1: ; offset 0x1c+; mv a0, sp+; lui t6, 1+; addi t6, t6, 0x390+; add sp, sp, t6+; ld ra, 8(sp)+; ld s0, 0(sp)+; addi sp, sp, 0x10+; ret+diff --git a/cranelift/filetests/filetests/isa/riscv64/stack-limit.clif b/cranelift/filetests/filetests/isa/riscv64/stack-limit.clifindex 4f494f48bf..5bce47bed0 100644--- a/cranelift/filetests/filetests/isa/riscv64/stack-limit.clif+++ b/cranelift/filetests/filetests/isa/riscv64/stack-limit.clif@@ -244,3 +244,55 @@ block0(v0: i64):; addi sp, sp, 0x10; ret+function %limit_preamble_nested_huge_offset(i64 vmctx) {+ gv0 = vmctx+ gv1 = load.i64 notrap aligned gv0+400000+ gv2 = load.i64 notrap aligned gv1+400000+ stack_limit = gv2+ ss0 = explicit_slot 20+block0(v0: i64):+ return+}++; VCode:+; addi sp,sp,-16+; sd ra,8(sp)+; sd fp,0(sp)+; mv fp,sp+; ld t6,400000(a0)+; ld t6,400000(t6)+; addi t6,t6,32+; trap_if stk_ovf##(sp ult t6)+; addi sp,sp,-32+; block0:+; addi sp,sp,32+; ld ra,8(sp)+; ld fp,0(sp)+; addi sp,sp,16+; ret+;+; Disassembled:+; block0: ; offset 0x0+; addi sp, sp, -0x10+; sd ra, 8(sp)+; sd s0, 0(sp)+; mv s0, sp+; lui t6, 0x62+; addi t6, t6, -0x580+; add t6, t6, a0+; ld t6, 0(t6)+; lui t5, 0x62+; addi t5, t5, -0x580+; add t5, t5, t6+; ld t6, 0(t5)+; addi t6, t6, 0x20+; bgeu sp, t6, 8+; .byte 0x00, 0x00, 0x00, 0x00 ; trap: stk_ovf+; addi sp, sp, -0x20+; block1: ; offset 0x40+; addi sp, sp, 0x20+; ld ra, 8(sp)+; ld s0, 0(sp)+; addi sp, sp, 0x10+; ret+