Skip to content

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.rs
index 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.rs
index 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.rs
index 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,
});
insts
diff --git a/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif b/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif
index 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.clif
index 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.clif
index 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
+