Remove the old riscv backend
This commit is contained in:
bjorn3
@@ -1,14 +0,0 @@
|
||||
; Test the legalization of function signatures for RV32E.
|
||||
test legalizer
|
||||
target riscv32 enable_e
|
||||
|
||||
; regex: V=v\d+
|
||||
|
||||
function %f() {
|
||||
; Spilling into the stack args after %x15 since %16 and up are not
|
||||
; available in RV32E.
|
||||
sig0 = (i64, i64, i64, i64) -> i64 system_v
|
||||
; check: sig0 = (i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13], i32 [%x14], i32 [%x15], i32 [0], i32 [4]) -> i32 [%x10], i32 [%x11] system_v
|
||||
block0:
|
||||
return
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
; Test the legalization of function signatures.
|
||||
test legalizer
|
||||
target riscv32
|
||||
|
||||
; regex: V=v\d+
|
||||
|
||||
function %f() {
|
||||
sig0 = (i32) -> i32 system_v
|
||||
; check: sig0 = (i32 [%x10]) -> i32 [%x10] system_v
|
||||
|
||||
sig1 = (i64) -> b1 system_v
|
||||
; check: sig1 = (i32 [%x10], i32 [%x11]) -> b1 [%x10] system_v
|
||||
|
||||
; The i64 argument must go in an even-odd register pair.
|
||||
sig2 = (f32, i64) -> f64 system_v
|
||||
; check: sig2 = (f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10] system_v
|
||||
|
||||
; Spilling into the stack args.
|
||||
sig3 = (f64, f64, f64, f64, f64, f64, f64, i64) -> f64 system_v
|
||||
; check: sig3 = (f64 [%f10], f64 [%f11], f64 [%f12], f64 [%f13], f64 [%f14], f64 [%f15], f64 [%f16], i32 [0], i32 [4]) -> f64 [%f10] system_v
|
||||
|
||||
; Splitting vectors.
|
||||
sig4 = (i32x4) system_v
|
||||
; check: sig4 = (i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13]) system_v
|
||||
|
||||
; Splitting vectors, then splitting ints.
|
||||
sig5 = (i64x4) system_v
|
||||
; check: sig5 = (i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13], i32 [%x14], i32 [%x15], i32 [%x16], i32 [%x17]) system_v
|
||||
|
||||
block0:
|
||||
return
|
||||
}
|
||||
@@ -1,189 +0,0 @@
|
||||
; Binary emission of 32-bit code.
|
||||
test binemit
|
||||
target riscv32
|
||||
|
||||
function %RV32I(i32 link [%x1]) -> i32 link [%x1] {
|
||||
sig0 = ()
|
||||
fn0 = %foo()
|
||||
|
||||
block0(v9999: i32):
|
||||
[-,%x10] v1 = iconst.i32 1
|
||||
[-,%x21] v2 = iconst.i32 2
|
||||
|
||||
; Integer Register-Register Operations.
|
||||
; add
|
||||
[-,%x7] v10 = iadd v1, v2 ; bin: 015503b3
|
||||
[-,%x16] v11 = iadd v2, v1 ; bin: 00aa8833
|
||||
; sub
|
||||
[-,%x7] v12 = isub v1, v2 ; bin: 415503b3
|
||||
[-,%x16] v13 = isub v2, v1 ; bin: 40aa8833
|
||||
; and
|
||||
[-,%x7] v20 = band v1, v2 ; bin: 015573b3
|
||||
[-,%x16] v21 = band v2, v1 ; bin: 00aaf833
|
||||
; or
|
||||
[-,%x7] v22 = bor v1, v2 ; bin: 015563b3
|
||||
[-,%x16] v23 = bor v2, v1 ; bin: 00aae833
|
||||
; xor
|
||||
[-,%x7] v24 = bxor v1, v2 ; bin: 015543b3
|
||||
[-,%x16] v25 = bxor v2, v1 ; bin: 00aac833
|
||||
; sll
|
||||
[-,%x7] v30 = ishl v1, v2 ; bin: 015513b3
|
||||
[-,%x16] v31 = ishl v2, v1 ; bin: 00aa9833
|
||||
; srl
|
||||
[-,%x7] v32 = ushr v1, v2 ; bin: 015553b3
|
||||
[-,%x16] v33 = ushr v2, v1 ; bin: 00aad833
|
||||
; sra
|
||||
[-,%x7] v34 = sshr v1, v2 ; bin: 415553b3
|
||||
[-,%x16] v35 = sshr v2, v1 ; bin: 40aad833
|
||||
; slt
|
||||
[-,%x7] v42 = icmp slt v1, v2 ; bin: 015523b3
|
||||
[-,%x16] v43 = icmp slt v2, v1 ; bin: 00aaa833
|
||||
; sltu
|
||||
[-,%x7] v44 = icmp ult v1, v2 ; bin: 015533b3
|
||||
[-,%x16] v45 = icmp ult v2, v1 ; bin: 00aab833
|
||||
|
||||
; Integer Register-Immediate Instructions
|
||||
|
||||
; addi
|
||||
[-,%x7] v100 = iadd_imm v1, 1000 ; bin: 3e850393
|
||||
[-,%x16] v101 = iadd_imm v2, -905 ; bin: c77a8813
|
||||
; andi
|
||||
[-,%x7] v110 = band_imm v1, 1000 ; bin: 3e857393
|
||||
[-,%x16] v111 = band_imm v2, -905 ; bin: c77af813
|
||||
; ori
|
||||
[-,%x7] v112 = bor_imm v1, 1000 ; bin: 3e856393
|
||||
[-,%x16] v113 = bor_imm v2, -905 ; bin: c77ae813
|
||||
; xori
|
||||
[-,%x7] v114 = bxor_imm v1, 1000 ; bin: 3e854393
|
||||
[-,%x16] v115 = bxor_imm v2, -905 ; bin: c77ac813
|
||||
|
||||
; slli
|
||||
[-,%x7] v120 = ishl_imm v1, 31 ; bin: 01f51393
|
||||
[-,%x16] v121 = ishl_imm v2, 8 ; bin: 008a9813
|
||||
; srli
|
||||
[-,%x7] v122 = ushr_imm v1, 31 ; bin: 01f55393
|
||||
[-,%x16] v123 = ushr_imm v2, 8 ; bin: 008ad813
|
||||
; srai
|
||||
[-,%x7] v124 = sshr_imm v1, 31 ; bin: 41f55393
|
||||
[-,%x16] v125 = sshr_imm v2, 8 ; bin: 408ad813
|
||||
|
||||
; slti
|
||||
[-,%x7] v130 = icmp_imm slt v1, 1000 ; bin: 3e852393
|
||||
[-,%x16] v131 = icmp_imm slt v2, -905 ; bin: c77aa813
|
||||
; sltiu
|
||||
[-,%x7] v132 = icmp_imm ult v1, 1000 ; bin: 3e853393
|
||||
[-,%x16] v133 = icmp_imm ult v2, -905 ; bin: c77ab813
|
||||
|
||||
; lui
|
||||
[-,%x7] v140 = iconst.i32 0x12345000 ; bin: 123453b7
|
||||
[-,%x16] v141 = iconst.i32 0xffffffff_fedcb000 ; bin: fedcb837
|
||||
; addi
|
||||
[-,%x7] v142 = iconst.i32 1000 ; bin: 3e800393
|
||||
[-,%x16] v143 = iconst.i32 -905 ; bin: c7700813
|
||||
|
||||
; Copies alias to iadd_imm.
|
||||
[-,%x7] v150 = copy v1 ; bin: 00050393
|
||||
[-,%x16] v151 = copy v2 ; bin: 000a8813
|
||||
|
||||
; Control Transfer Instructions
|
||||
|
||||
; jal %x1, fn0
|
||||
call fn0() ; bin: Call(%foo) 000000ef
|
||||
|
||||
; jalr %x1, %x10
|
||||
call_indirect sig0, v1() ; bin: 000500e7
|
||||
call_indirect sig0, v2() ; bin: 000a80e7
|
||||
|
||||
brz v1, block3
|
||||
fallthrough block4
|
||||
|
||||
block4:
|
||||
brnz v1, block1
|
||||
fallthrough block5
|
||||
|
||||
block5:
|
||||
; jalr %x0, %x1, 0
|
||||
return v9999 ; bin: 00008067
|
||||
|
||||
block1:
|
||||
; beq 0x000
|
||||
br_icmp eq v1, v2, block1 ; bin: 01550063
|
||||
fallthrough block100
|
||||
|
||||
block100:
|
||||
; bne 0xffc
|
||||
br_icmp ne v1, v2, block1 ; bin: ff551ee3
|
||||
fallthrough block101
|
||||
|
||||
block101:
|
||||
; blt 0xff8
|
||||
br_icmp slt v1, v2, block1 ; bin: ff554ce3
|
||||
fallthrough block102
|
||||
|
||||
block102:
|
||||
; bge 0xff4
|
||||
br_icmp sge v1, v2, block1 ; bin: ff555ae3
|
||||
fallthrough block103
|
||||
|
||||
block103:
|
||||
; bltu 0xff0
|
||||
br_icmp ult v1, v2, block1 ; bin: ff5568e3
|
||||
fallthrough block104
|
||||
|
||||
block104:
|
||||
; bgeu 0xfec
|
||||
br_icmp uge v1, v2, block1 ; bin: ff5576e3
|
||||
fallthrough block105
|
||||
|
||||
block105:
|
||||
|
||||
; Forward branches.
|
||||
fallthrough block106
|
||||
|
||||
block106:
|
||||
; beq 0x018
|
||||
br_icmp eq v2, v1, block2 ; bin: 00aa8c63
|
||||
fallthrough block107
|
||||
|
||||
block107:
|
||||
; bne 0x014
|
||||
br_icmp ne v2, v1, block2 ; bin: 00aa9a63
|
||||
fallthrough block108
|
||||
|
||||
block108:
|
||||
; blt 0x010
|
||||
br_icmp slt v2, v1, block2 ; bin: 00aac863
|
||||
fallthrough block109
|
||||
|
||||
block109:
|
||||
; bge 0x00c
|
||||
br_icmp sge v2, v1, block2 ; bin: 00aad663
|
||||
fallthrough block110
|
||||
|
||||
block110:
|
||||
; bltu 0x008
|
||||
br_icmp ult v2, v1, block2 ; bin: 00aae463
|
||||
fallthrough block111
|
||||
|
||||
block111:
|
||||
; bgeu 0x004
|
||||
br_icmp uge v2, v1, block2 ; bin: 00aaf263
|
||||
|
||||
fallthrough block2
|
||||
|
||||
block2:
|
||||
; jal %x0, 0x00000
|
||||
jump block2 ; bin: 0000006f
|
||||
|
||||
block3:
|
||||
; beq x, %x0
|
||||
brz v1, block3 ; bin: 00050063
|
||||
fallthrough block6
|
||||
|
||||
block6:
|
||||
; bne x, %x0
|
||||
brnz v1, block3 ; bin: fe051ee3
|
||||
|
||||
; jal %x0, 0x1ffff4
|
||||
jump block2 ; bin: ff5ff06f
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
test legalizer
|
||||
target riscv32 supports_m=1
|
||||
|
||||
function %int32(i32, i32) {
|
||||
block0(v1: i32, v2: i32):
|
||||
v10 = iadd v1, v2
|
||||
; check: [R#0c]
|
||||
; sameln: v10 = iadd
|
||||
|
||||
v11 = isub v1, v2
|
||||
; check: [R#200c]
|
||||
; sameln: v11 = isub
|
||||
|
||||
v12 = imul v1, v2
|
||||
; check: [R#10c]
|
||||
; sameln: v12 = imul
|
||||
|
||||
return
|
||||
; check: [Iret#19]
|
||||
; sameln: return
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
; Test the legalization of i32 instructions that don't have RISC-V versions.
|
||||
test legalizer
|
||||
|
||||
target riscv32 supports_m=1
|
||||
|
||||
target riscv64 supports_m=1
|
||||
|
||||
; regex: V=v\d+
|
||||
|
||||
function %carry_out(i32, i32) -> i32, b1 {
|
||||
block0(v1: i32, v2: i32):
|
||||
v3, v4 = iadd_cout v1, v2
|
||||
return v3, v4
|
||||
}
|
||||
; check: v3 = iadd v1, v2
|
||||
; check: v4 = icmp ult v3, v1
|
||||
; check: return v3, v4
|
||||
|
||||
; Expanding illegal immediate constants.
|
||||
; Note that at some point we'll probably expand the iconst as well.
|
||||
function %large_imm(i32) -> i32 {
|
||||
block0(v0: i32):
|
||||
v1 = iadd_imm v0, 1000000000
|
||||
return v1
|
||||
}
|
||||
; check: $(cst=$V) = iconst.i32 0x3b9a_ca00
|
||||
; check: v1 = iadd v0, $cst
|
||||
; check: return v1
|
||||
|
||||
function %bitclear(i32, i32) -> i32 {
|
||||
block0(v0: i32, v1: i32):
|
||||
v2 = band_not v0, v1
|
||||
; check: iconst.i32 -1
|
||||
; check: bxor
|
||||
; check: band
|
||||
return v2
|
||||
}
|
||||
@@ -1,134 +0,0 @@
|
||||
; Test legalizer's handling of ABI boundaries.
|
||||
test legalizer
|
||||
target riscv32
|
||||
|
||||
; regex: V=v\d+
|
||||
; regex: SS=ss\d+
|
||||
; regex: WS=\s+
|
||||
|
||||
function %int_split_args(i64) -> i64 {
|
||||
block0(v0: i64):
|
||||
; check: block0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32):
|
||||
; check: v0 = iconcat $v0l, $v0h
|
||||
v1 = iadd_imm v0, 1
|
||||
; check: $(v1l=$V), $(v1h=$V) = isplit v1
|
||||
; check: return $v1l, $v1h, $link
|
||||
return v1
|
||||
}
|
||||
|
||||
function %split_call_arg(i32) {
|
||||
fn1 = %foo(i64)
|
||||
fn2 = %foo(i32, i64)
|
||||
block0(v0: i32):
|
||||
v1 = uextend.i64 v0
|
||||
call fn1(v1)
|
||||
; check: $(v1h=$V) = iconst.i32 0
|
||||
; check: call fn1(v0, $v1h)
|
||||
call fn2(v0, v1)
|
||||
; check: call fn2(v0, $V, $V)
|
||||
return
|
||||
}
|
||||
|
||||
function %split_ret_val() {
|
||||
fn1 = %foo() -> i64
|
||||
block0:
|
||||
v1 = call fn1()
|
||||
; check: block0($(link=$V): i32):
|
||||
; nextln: $(v1l=$V), $(v1h=$V) = call fn1()
|
||||
; check: v1 = iconcat $v1l, $v1h
|
||||
jump block1(v1)
|
||||
; check: jump block1(v1)
|
||||
|
||||
block1(v10: i64):
|
||||
jump block1(v10)
|
||||
}
|
||||
|
||||
; First return value is fine, second one is expanded.
|
||||
function %split_ret_val2() {
|
||||
fn1 = %foo() -> i32, i64
|
||||
block0:
|
||||
v1, v2 = call fn1()
|
||||
; check: block0($(link=$V): i32):
|
||||
; nextln: v1, $(v2l=$V), $(v2h=$V) = call fn1()
|
||||
; check: v2 = iconcat $v2l, $v2h
|
||||
jump block1(v1, v2)
|
||||
; check: jump block1(v1, v2)
|
||||
|
||||
block1(v9: i32, v10: i64):
|
||||
jump block1(v9, v10)
|
||||
}
|
||||
|
||||
function %int_ext(i8, i8 sext, i8 uext) -> i8 uext {
|
||||
block0(v1: i8, v2: i8, v3: i8):
|
||||
; check: block0(v1: i8, $(v2x=$V): i32, $(v3x=$V): i32, $(link=$V): i32):
|
||||
; check: v2 = ireduce.i8 $v2x
|
||||
; check: v3 = ireduce.i8 $v3x
|
||||
; check: $(v1x=$V) = uextend.i32 v1
|
||||
; check: return $v1x, $link
|
||||
return v1
|
||||
}
|
||||
|
||||
; Function produces single return value, still need to copy.
|
||||
function %ext_ret_val() {
|
||||
fn1 = %foo() -> i8 sext
|
||||
block0:
|
||||
v1 = call fn1()
|
||||
; check: block0($V: i32):
|
||||
; nextln: $(rv=$V) = call fn1()
|
||||
; check: v1 = ireduce.i8 $rv
|
||||
jump block1(v1)
|
||||
; check: jump block1(v1)
|
||||
|
||||
block1(v10: i8):
|
||||
jump block1(v10)
|
||||
}
|
||||
|
||||
function %vector_split_args(i64x4) -> i64x4 {
|
||||
block0(v0: i64x4):
|
||||
; check: block0($(v0al=$V): i32, $(v0ah=$V): i32, $(v0bl=$V): i32, $(v0bh=$V): i32, $(v0cl=$V): i32, $(v0ch=$V): i32, $(v0dl=$V): i32, $(v0dh=$V): i32, $(link=$V): i32):
|
||||
; check: $(v0a=$V) = iconcat $v0al, $v0ah
|
||||
; check: $(v0b=$V) = iconcat $v0bl, $v0bh
|
||||
; check: $(v0ab=$V) = vconcat $v0a, $v0b
|
||||
; check: $(v0c=$V) = iconcat $v0cl, $v0ch
|
||||
; check: $(v0d=$V) = iconcat $v0dl, $v0dh
|
||||
; check: $(v0cd=$V) = vconcat $v0c, $v0d
|
||||
; check: v0 = vconcat $v0ab, $v0cd
|
||||
v1 = bxor v0, v0
|
||||
; check: $(v1ab=$V), $(v1cd=$V) = vsplit v1
|
||||
; check: $(v1a=$V), $(v1b=$V) = vsplit $v1ab
|
||||
; check: $(v1al=$V), $(v1ah=$V) = isplit $v1a
|
||||
; check: $(v1bl=$V), $(v1bh=$V) = isplit $v1b
|
||||
; check: $(v1c=$V), $(v1d=$V) = vsplit $v1cd
|
||||
; check: $(v1cl=$V), $(v1ch=$V) = isplit $v1c
|
||||
; check: $(v1dl=$V), $(v1dh=$V) = isplit $v1d
|
||||
; check: return $v1al, $v1ah, $v1bl, $v1bh, $v1cl, $v1ch, $v1dl, $v1dh, $link
|
||||
return v1
|
||||
}
|
||||
|
||||
function %indirect(i32) {
|
||||
sig1 = () system_v
|
||||
block0(v0: i32):
|
||||
call_indirect sig1, v0()
|
||||
return
|
||||
}
|
||||
|
||||
; The first argument to call_indirect doesn't get altered.
|
||||
function %indirect_arg(i32, f32x2) {
|
||||
sig1 = (f32x2) system_v
|
||||
block0(v0: i32, v1: f32x2):
|
||||
call_indirect sig1, v0(v1)
|
||||
; check: call_indirect sig1, v0($V, $V)
|
||||
return
|
||||
}
|
||||
|
||||
; Call a function that takes arguments on the stack.
|
||||
function %stack_args(i32) {
|
||||
; check: $(ss0=$SS) = outgoing_arg 4
|
||||
fn1 = %foo(i64, i64, i64, i64, i32)
|
||||
block0(v0: i32):
|
||||
v1 = iconst.i64 1
|
||||
call fn1(v1, v1, v1, v1, v0)
|
||||
; check: [GPsp#48,$ss0]$WS $(v0s=$V) = spill v0
|
||||
; check: call fn1($(=.*), $v0s)
|
||||
return
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
; Test the legalization of i64 arithmetic instructions.
|
||||
test legalizer
|
||||
target riscv32 supports_m=1
|
||||
|
||||
; regex: V=v\d+
|
||||
|
||||
function %bitwise_and(i64, i64) -> i64 {
|
||||
block0(v1: i64, v2: i64):
|
||||
v3 = band v1, v2
|
||||
return v3
|
||||
}
|
||||
; check: block0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
|
||||
; check: [R#ec
|
||||
; sameln: $(v3l=$V) = band $v1l, $v2l
|
||||
; check: [R#ec
|
||||
; sameln: $(v3h=$V) = band $v1h, $v2h
|
||||
; check: v3 = iconcat $v3l, $v3h
|
||||
; check: return $v3l, $v3h, $link
|
||||
|
||||
function %bitwise_or(i64, i64) -> i64 {
|
||||
block0(v1: i64, v2: i64):
|
||||
v3 = bor v1, v2
|
||||
return v3
|
||||
}
|
||||
; check: block0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
|
||||
; check: [R#cc
|
||||
; sameln: $(v3l=$V) = bor $v1l, $v2l
|
||||
; check: [R#cc
|
||||
; sameln: $(v3h=$V) = bor $v1h, $v2h
|
||||
; check: v3 = iconcat $v3l, $v3h
|
||||
; check: return $v3l, $v3h, $link
|
||||
|
||||
function %bitwise_xor(i64, i64) -> i64 {
|
||||
block0(v1: i64, v2: i64):
|
||||
v3 = bxor v1, v2
|
||||
return v3
|
||||
}
|
||||
; check: block0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
|
||||
; check: [R#8c
|
||||
; sameln: $(v3l=$V) = bxor $v1l, $v2l
|
||||
; check: [R#8c
|
||||
; sameln: $(v3h=$V) = bxor $v1h, $v2h
|
||||
; check: v3 = iconcat $v3l, $v3h
|
||||
; check: return $v3l, $v3h, $link
|
||||
|
||||
function %arith_add(i64, i64) -> i64 {
|
||||
; Legalizing iadd.i64 requires two steps:
|
||||
; 1. Narrow to iadd_cout.i32, then
|
||||
; 2. Expand iadd_cout.i32 since RISC-V has no carry flag.
|
||||
block0(v1: i64, v2: i64):
|
||||
v3 = iadd v1, v2
|
||||
return v3
|
||||
}
|
||||
; check: block0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
|
||||
; check: [R#0c
|
||||
; sameln: $(v3l=$V) = iadd $v1l, $v2l
|
||||
; check: $(c=$V) = icmp ult $v3l, $v1l
|
||||
; check: [R#0c
|
||||
; sameln: $(v3h1=$V) = iadd $v1h, $v2h
|
||||
; check: $(c_int=$V) = bint.i32 $c
|
||||
; check: [R#0c
|
||||
; sameln: $(v3h=$V) = iadd $v3h1, $c_int
|
||||
; check: v3 = iconcat $v3l, $v3h
|
||||
; check: return $v3l, $v3h, $link
|
||||
@@ -1,55 +0,0 @@
|
||||
test legalizer
|
||||
target riscv32
|
||||
|
||||
; regex: V=v\d+
|
||||
|
||||
function %icmp_imm_eq(i64) -> b1 {
|
||||
block0(v0: i64):
|
||||
v1 = icmp_imm eq v0, 0x20202020_10101010
|
||||
return v1
|
||||
}
|
||||
; check: block0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32):
|
||||
; nextln: $(v2l=$V) -> $(v0l)
|
||||
; nextln: $(v2h=$V) -> $(v0h)
|
||||
; nextln: v0 = iconcat $(v0l), $(v0h)
|
||||
; nextln: $(imm_low=$V) = iconst.i32 0x1010_1010
|
||||
; nextln: $(imm_high=$V) = iconst.i32 0x2020_2020
|
||||
; nextln: $(v3=$V) = icmp eq $(v2l), $(imm_low)
|
||||
; nextln: $(v4=$V) = icmp eq $(v2h), $(imm_high)
|
||||
; nextln: v1 = band $(v3), $(v4)
|
||||
; nextln: return v1, $(link)
|
||||
|
||||
function %icmp_imm_ne(i64) -> b1 {
|
||||
block0(v0: i64):
|
||||
v1 = icmp_imm ne v0, 0x33333333_44444444
|
||||
return v1
|
||||
}
|
||||
; check: block0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32):
|
||||
; nextln: $(v2l=$V) -> $(v0l)
|
||||
; nextln: $(v2h=$V) -> $(v0h)
|
||||
; nextln: v0 = iconcat $(v0l), $(v0h)
|
||||
; nextln: $(imm_low=$V) = iconst.i32 0x4444_4444
|
||||
; nextln: $(imm_high=$V) = iconst.i32 0x3333_3333
|
||||
; nextln: $(v3=$V) = icmp ne $(v2l), $(imm_low)
|
||||
; nextln: $(v4=$V) = icmp ne $(v2h), $(imm_high)
|
||||
; nextln: v1 = bor $(v3), $(v4)
|
||||
; nextln: return v1, $(link)
|
||||
|
||||
function %icmp_imm_sge(i64) -> b1 {
|
||||
block0(v0: i64):
|
||||
v1 = icmp_imm sge v0, 0x01020304_05060708
|
||||
return v1
|
||||
}
|
||||
; check: block0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32):
|
||||
; nextln: $(v2l=$V) -> $(v0l)
|
||||
; nextln: $(v2h=$V) -> $(v0h)
|
||||
; nextln: v0 = iconcat $(v0l), $(v0h)
|
||||
; nextln: $(imm_low=$V) = iconst.i32 0x0506_0708
|
||||
; nextln: $(imm_high=$V) = iconst.i32 0x0102_0304
|
||||
; nextln: $(v3=$V) = icmp sgt $(v2h), $(imm_high)
|
||||
; nextln: $(v4=$V) = icmp slt $(v2h), $(imm_high)
|
||||
; nextln: $(v5=$V) = icmp uge $(v2l), $(imm_low)
|
||||
; nextln: $(v6=$V) = bnot $v4
|
||||
; nextln: $(v7=$V) = band $v6, $v5
|
||||
; nextln: v1 = bor $(v3), $(v7)
|
||||
; nextln: return v1, $(link)
|
||||
@@ -1,36 +0,0 @@
|
||||
; Test the parser's support for encoding annotations.
|
||||
test legalizer
|
||||
target riscv32
|
||||
|
||||
function %parse_encoding(i32 [%x5]) -> i32 [%x10] {
|
||||
; check: function %parse_encoding(i32 [%x5], i32 link [%x1]) -> i32 [%x10], i32 link [%x1] fast {
|
||||
|
||||
sig0 = (i32 [%x10]) -> i32 [%x10] system_v
|
||||
; check: sig0 = (i32 [%x10]) -> i32 [%x10] system_v
|
||||
|
||||
sig1 = (i32 [%x10], i32 [%x11]) -> b1 [%x10] system_v
|
||||
; check: sig1 = (i32 [%x10], i32 [%x11]) -> b1 [%x10] system_v
|
||||
|
||||
sig2 = (f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10] system_v
|
||||
; check: sig2 = (f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10] system_v
|
||||
|
||||
; Arguments on stack where not necessary
|
||||
sig3 = (f64 [%f10], i32 [0], i32 [4]) -> f64 [%f10] system_v
|
||||
; check: sig3 = (f64 [%f10], i32 [0], i32 [4]) -> f64 [%f10] system_v
|
||||
|
||||
; Stack argument before register argument
|
||||
sig4 = (f32 [72], i32 [%x10]) system_v
|
||||
; check: sig4 = (f32 [72], i32 [%x10]) system_v
|
||||
|
||||
; Return value on stack
|
||||
sig5 = () -> f32 [0] system_v
|
||||
; check: sig5 = () -> f32 [0] system_v
|
||||
|
||||
; function + signature
|
||||
fn0 = %bar(i32 [%x10]) -> b1 [%x10] system_v
|
||||
; check: sig6 = (i32 [%x10]) -> b1 [%x10] system_v
|
||||
; nextln: fn0 = %bar sig6
|
||||
|
||||
block0(v0: i32):
|
||||
return v0
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
; Test tracking of register moves.
|
||||
test binemit
|
||||
target riscv32
|
||||
|
||||
function %regmoves(i32 link [%x1]) -> i32 link [%x1] {
|
||||
block0(v9999: i32):
|
||||
[-,%x10] v1 = iconst.i32 1
|
||||
[-,%x7] v2 = iadd_imm v1, 1000 ; bin: 3e850393
|
||||
regmove v1, %x10 -> %x11 ; bin: 00050593
|
||||
[-,%x7] v3 = iadd_imm v1, 1000 ; bin: 3e858393
|
||||
regmove v1, %x11 -> %x10 ; bin: 00058513
|
||||
[-,%x7] v4 = iadd_imm v1, 1000 ; bin: 3e850393
|
||||
|
||||
return v9999
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
; Test the legalization of block arguments that are split.
|
||||
test legalizer
|
||||
target riscv32
|
||||
|
||||
; regex: V=v\d+
|
||||
|
||||
function %simple(i64, i64) -> i64 {
|
||||
block0(v1: i64, v2: i64):
|
||||
; check: block0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
|
||||
jump block1(v1)
|
||||
; check: jump block1($v1l, $v1h)
|
||||
|
||||
block1(v3: i64):
|
||||
; check: block1($(v3l=$V): i32, $(v3h=$V): i32):
|
||||
v4 = band v3, v2
|
||||
; check: $(v4l=$V) = band $v3l, $v2l
|
||||
; check: $(v4h=$V) = band $v3h, $v2h
|
||||
return v4
|
||||
; check: return $v4l, $v4h, $link
|
||||
}
|
||||
|
||||
function %multi(i64) -> i64 {
|
||||
block1(v1: i64):
|
||||
; check: block1($(v1l=$V): i32, $(v1h=$V): i32, $(link=$V): i32):
|
||||
jump block2(v1, v1)
|
||||
; check: jump block2($v1l, $v1l, $v1h, $v1h)
|
||||
|
||||
block2(v2: i64, v3: i64):
|
||||
; check: block2($(v2l=$V): i32, $(v3l=$V): i32, $(v2h=$V): i32, $(v3h=$V): i32):
|
||||
jump block3(v2)
|
||||
; check: jump block3($v2l, $v2h)
|
||||
|
||||
block3(v4: i64):
|
||||
; check: block3($(v4l=$V): i32, $(v4h=$V): i32):
|
||||
v5 = band v4, v3
|
||||
; check: $(v5l=$V) = band $v4l, $v3l
|
||||
; check: $(v5h=$V) = band $v4h, $v3h
|
||||
return v5
|
||||
; check: return $v5l, $v5h, $link
|
||||
}
|
||||
|
||||
function %loop(i64, i64) -> i64 {
|
||||
block0(v1: i64, v2: i64):
|
||||
; check: block0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
|
||||
jump block1(v1)
|
||||
; check: jump block1($v1l, $v1h)
|
||||
|
||||
block1(v3: i64):
|
||||
; check: block1($(v3l=$V): i32, $(v3h=$V): i32):
|
||||
v4 = band v3, v2
|
||||
; check: $(v4l=$V) = band $v3l, $v2l
|
||||
; check: $(v4h=$V) = band $v3h, $v2h
|
||||
jump block1(v4)
|
||||
; check: jump block1($v4l, $v4h)
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
test verifier
|
||||
target riscv32
|
||||
|
||||
function %RV32I(i32 link [%x1]) -> i32 link [%x1] {
|
||||
fn0 = %foo()
|
||||
|
||||
block0(v9999: i32):
|
||||
; iconst.i32 needs legalizing, so it should throw a
|
||||
[R#0,-] v1 = iconst.i32 0xf0f0f0f0f0 ; error: Instruction failed to re-encode
|
||||
[Iret#19] return v9999
|
||||
}
|
||||
|
||||
function %RV32I(i32 link [%x1]) -> i32 link [%x1] {
|
||||
fn0 = %foo()
|
||||
|
||||
block0(v9999: i32):
|
||||
v1 = iconst.i32 1
|
||||
v2 = iconst.i32 2
|
||||
[R#0,-] v3 = iadd v1, v2 ; error: encoding R#00 should be R#0c
|
||||
[Iret#19] return v9999
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
test cat
|
||||
|
||||
target riscv32
|
||||
|
||||
; regex: WS=[ \t]*
|
||||
|
||||
function %foo(i32, i32) {
|
||||
block1(v0: i32 [%x8], v1: i32):
|
||||
[-,-] v2 = iadd v0, v1
|
||||
[-] trap heap_oob
|
||||
[R#1234, %x5, %x11] v6, v7 = iadd_ifcout v2, v0
|
||||
[Rshamt#beef, %x25] v8 = ishl_imm v6, 2
|
||||
@55 v9 = iadd v8, v7
|
||||
@a5 [Iret#5] return v0, v8
|
||||
}
|
||||
; sameln: function %foo(i32, i32) fast {
|
||||
; nextln: block1(v0: i32 [%x8], v1: i32):
|
||||
; nextln: [-,-]$WS v2 = iadd v0, v1
|
||||
; nextln: [-]$WS trap heap_oob
|
||||
; nextln: [R#1234,%x5,%x11]$WS v6, v7 = iadd_ifcout v2, v0
|
||||
; nextln: [Rshamt#beef,%x25]$WS v8 = ishl_imm v6, 2
|
||||
; nextln: @0055 [-,-]$WS v9 = iadd v8, v7
|
||||
; nextln: @00a5 [Iret#05]$WS return v0, v8
|
||||
; nextln: }
|
||||
@@ -3,7 +3,7 @@ use core::mem;
|
||||
use cranelift_codegen::binemit::{NullRelocSink, NullStackMapSink, NullTrapSink};
|
||||
use cranelift_codegen::data_value::DataValue;
|
||||
use cranelift_codegen::ir::{condcodes::IntCC, Function, InstBuilder, Signature};
|
||||
use cranelift_codegen::isa::{BackendVariant, TargetIsa};
|
||||
use cranelift_codegen::isa::TargetIsa;
|
||||
use cranelift_codegen::{ir, settings, CodegenError, Context};
|
||||
use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
|
||||
use cranelift_native::builder_with_options;
|
||||
|
||||
Reference in New Issue
Block a user