T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Binary function names (#91)

Browse Source 
* Function names should start with %

* Create FunctionName from string

* Implement displaying of FunctionName as %nnnn with fallback to #xxxx

* Run rustfmt and fix FunctionName::with_string in parser

* Implement FunctionName::new as a generic function

* Binary function names should start with #

* Implement NameRepr for function name

* Fix examples in docs to reflect that function names start with %

* Rebase and fix filecheck tests
This commit is contained in:
Aleksey Kuznetsov
2017-06-10 22:30:37 +05:00
committed by Jakob Stoklund Olesen
parent 731278aad8
commit 8b484b1c77
41 changed files with 306 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
docs/example.cton
View File

@@ -1,6 +1,6 @@
test verifier test verifier
function average(i32, i32) -> f32 { function %average(i32, i32) -> f32 {
ss1 = stack_slot 8 ; Stack slot for ``sum``. ss1 = stack_slot 8 ; Stack slot for ``sum``.
ebb1(v1: i32, v2: i32): ebb1(v1: i32, v2: i32):

6
docs/langref.rst
View File

@@ -389,8 +389,8 @@ preamble`:
This simple example illustrates direct function calls and signatures:: This simple example illustrates direct function calls and signatures::
function gcd(i32 uext, i32 uext) -> i32 uext "C" { function %gcd(i32 uext, i32 uext) -> i32 uext "C" {
fn1 = function divmod(i32 uext, i32 uext) -> i32 uext, i32 uext fn1 = function %divmod(i32 uext, i32 uext) -> i32 uext, i32 uext
ebb1(v1: i32, v2: i32): ebb1(v1: i32, v2: i32):
brz v2, ebb2 brz v2, ebb2
@@ -530,7 +530,7 @@ and address computations from the memory accesses.
A small example using heaps:: A small example using heaps::
function vdup(i32, i32) { function %vdup(i32, i32) {
h1 = heap "main" h1 = heap "main"
ebb1(v1: i32, v2: i32): ebb1(v1: i32, v2: i32):

20
docs/testing.rst
View File

@@ -130,7 +130,7 @@ The ``set`` lines apply settings cumulatively::
set is_64bit=0 set is_64bit=0
isa riscv supports_m=false isa riscv supports_m=false
function foo() {} function %foo() {}
This example will run the legalizer test twice. Both runs will have This example will run the legalizer test twice. Both runs will have
``opt_level=best``, but they will have different ``is_64bit`` settings. The 32-bit ``opt_level=best``, but they will have different ``is_64bit`` settings. The 32-bit
@@ -184,13 +184,13 @@ against the associated filecheck directives.
Example:: Example::
function r1() -> i32, f32 { function %r1() -> i32, f32 {
ebb1: ebb1:
v10 = iconst.i32 3 v10 = iconst.i32 3
v20 = f32const 0.0 v20 = f32const 0.0
return v10, v20 return v10, v20
} }
; sameln: function r1() -> i32, f32 { ; sameln: function %r1() -> i32, f32 {
; nextln: ebb0: ; nextln: ebb0:
; nextln: v0 = iconst.i32 3 ; nextln: v0 = iconst.i32 3
; nextln: v1 = f32const 0.0 ; nextln: v1 = f32const 0.0
@@ -201,13 +201,13 @@ Notice that the values ``v10`` and ``v20`` in the source were renumbered to
``v0`` and ``v1`` respectively during parsing. The equivalent test using ``v0`` and ``v1`` respectively during parsing. The equivalent test using
filecheck variables would be:: filecheck variables would be::
function r1() -> i32, f32 { function %r1() -> i32, f32 {
ebb1: ebb1:
v10 = iconst.i32 3 v10 = iconst.i32 3
v20 = f32const 0.0 v20 = f32const 0.0
return v10, v20 return v10, v20
} }
; sameln: function r1() -> i32, f32 { ; sameln: function %r1() -> i32, f32 {
; nextln: ebb0: ; nextln: ebb0:
; nextln: $v10 = iconst.i32 3 ; nextln: $v10 = iconst.i32 3
; nextln: $v20 = f32const 0.0 ; nextln: $v20 = f32const 0.0
@@ -226,7 +226,7 @@ reported location of the error is verified::
test verifier test verifier
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
jump ebb1 ; error: terminator jump ebb1 ; error: terminator
return return
@@ -250,8 +250,8 @@ command::
test print-cfg test print-cfg
test verifier test verifier
function nonsense(i32, i32) -> f32 { function %nonsense(i32, i32) -> f32 {
; check: digraph nonsense { ; check: digraph %nonsense {
; regex: I=\binst\d+\b ; regex: I=\binst\d+\b
; check: label="{ebb0 | <$(BRZ=$I)>brz ebb2 | <$(JUMP=$I)>jump ebb1}"] ; check: label="{ebb0 | <$(BRZ=$I)>brz ebb2 | <$(JUMP=$I)>jump ebb1}"]
@@ -276,7 +276,7 @@ Compute the dominator tree of each function and validate it against the
test domtree test domtree
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
jump ebb1 ; dominates: ebb1 jump ebb1 ; dominates: ebb1
ebb1: ebb1:
@@ -328,7 +328,7 @@ that instruction is compared to the directive::
test binemit test binemit
isa riscv isa riscv
function int32() { function %int32() {
ebb0: ebb0:
[-,%x5] v1 = iconst.i32 1 [-,%x5] v1 = iconst.i32 1
[-,%x6] v2 = iconst.i32 2 [-,%x6] v2 = iconst.i32 2

4
filetests/cfg/loop.cton
View File

@@ -2,8 +2,8 @@
test print-cfg test print-cfg
test verifier test verifier
function nonsense(i32, i32) -> f32 { function %nonsense(i32, i32) -> f32 {
; check: digraph nonsense { ; check: digraph %nonsense {
; regex: I=\binst\d+\b ; regex: I=\binst\d+\b
; check: label="{ebb0 | <$(BRZ=$I)>brz ebb2 | <$(JUMP=$I)>jump ebb1}"] ; check: label="{ebb0 | <$(BRZ=$I)>brz ebb2 | <$(JUMP=$I)>jump ebb1}"]

4
filetests/cfg/traps_early.cton
View File

@@ -3,8 +3,8 @@
test print-cfg test print-cfg
test verifier test verifier
function nonsense(i32) { function %nonsense(i32) {
; check: digraph nonsense { ; check: digraph %nonsense {
ebb0(v1: i32): ebb0(v1: i32):
trap ; error: terminator instruction was encountered before the end trap ; error: terminator instruction was encountered before the end

4
filetests/cfg/unused_node.cton
View File

@@ -1,8 +1,8 @@
; For testing cfg generation where some block is never reached. ; For testing cfg generation where some block is never reached.
test print-cfg test print-cfg
function not_reached(i32) -> i32 { function %not_reached(i32) -> i32 {
; check: digraph not_reached { ; check: digraph %not_reached {
; check: ebb0 [shape=record, label="{ebb0 | <inst0>brnz ebb2}"] ; check: ebb0 [shape=record, label="{ebb0 | <inst0>brnz ebb2}"]
; check: ebb1 [shape=record, label="{ebb1 | <inst4>jump ebb0}"] ; check: ebb1 [shape=record, label="{ebb1 | <inst4>jump ebb0}"]
; check: ebb2 [shape=record, label="{ebb2}"] ; check: ebb2 [shape=record, label="{ebb2}"]

2
filetests/domtree/basic.cton
View File

@@ -1,6 +1,6 @@
test domtree test domtree
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
jump ebb1 ; dominates: ebb1 jump ebb1 ; dominates: ebb1
ebb1: ebb1:

2
filetests/domtree/loops.cton
View File

@@ -1,6 +1,6 @@
test domtree test domtree
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb1 ; dominates: ebb1 ebb3 ebb4 ebb5 brz v0, ebb1 ; dominates: ebb1 ebb3 ebb4 ebb5
jump ebb2 ; dominates: ebb2 jump ebb2 ; dominates: ebb2

2
filetests/domtree/loops2.cton
View File

@@ -1,6 +1,6 @@
test domtree test domtree
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb1 ; dominates: ebb1 ebb6 brz v0, ebb1 ; dominates: ebb1 ebb6
brnz v0, ebb2 ; dominates: ebb2 ebb9 brnz v0, ebb2 ; dominates: ebb2 ebb9

2
filetests/domtree/tall-tree.cton
View File

@@ -1,6 +1,6 @@
test domtree test domtree
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb1 ; dominates: ebb1 brz v0, ebb1 ; dominates: ebb1
brnz v0, ebb2 ; dominates: ebb2 ebb5 brnz v0, ebb2 ; dominates: ebb2 ebb5

2
filetests/domtree/wide-tree.cton
View File

@@ -1,6 +1,6 @@
test domtree test domtree
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb13 ; dominates: ebb13 brz v0, ebb13 ; dominates: ebb13
jump ebb1 ; dominates: ebb1 jump ebb1 ; dominates: ebb1

2
filetests/isa/intel/binary32.cton
View File

@@ -7,7 +7,7 @@ isa intel
; sed -ne 's/^ *; asm: *//p' filetests/isa/intel/binary32.cton | llvm-mc -show-encoding -triple=i386 ; sed -ne 's/^ *; asm: *//p' filetests/isa/intel/binary32.cton | llvm-mc -show-encoding -triple=i386
; ;
function I32() { function %I32() {
ebb0: ebb0:
[-,%rcx] v1 = iconst.i32 1 [-,%rcx] v1 = iconst.i32 1
[-,%rsi] v2 = iconst.i32 2 [-,%rsi] v2 = iconst.i32 2

2
filetests/isa/riscv/abi-e.cton
View File

@@ -4,7 +4,7 @@ isa riscv enable_e
; regex: V=v\d+ ; regex: V=v\d+
function f() { function %f() {
; Spilling into the stack args after %x15 since %16 and up are not ; Spilling into the stack args after %x15 since %16 and up are not
; available in RV32E. ; available in RV32E.
sig0 = signature(i64, i64, i64, i64) -> i64 sig0 = signature(i64, i64, i64, i64) -> i64

2
filetests/isa/riscv/abi.cton
View File

@@ -4,7 +4,7 @@ isa riscv
; regex: V=v\d+ ; regex: V=v\d+
function f() { function %f() {
sig0 = signature(i32) -> i32 sig0 = signature(i32) -> i32
; check: sig0 = signature(i32 [%x10]) -> i32 [%x10] ; check: sig0 = signature(i32 [%x10]) -> i32 [%x10]

4
filetests/isa/riscv/binary32.cton
View File

@@ -2,8 +2,8 @@
test binemit test binemit
isa riscv isa riscv
function RV32I(i32 link [%x1]) -> i32 link [%x1] { function %RV32I(i32 link [%x1]) -> i32 link [%x1] {
fn0 = function foo() fn0 = function %foo()
ebb0(v9999: i32): ebb0(v9999: i32):
[-,%x10] v1 = iconst.i32 1 [-,%x10] v1 = iconst.i32 1

2
filetests/isa/riscv/encoding.cton
View File

@@ -1,7 +1,7 @@
test legalizer test legalizer
isa riscv supports_m=1 isa riscv supports_m=1
function int32(i32, i32) { function %int32(i32, i32) {
ebb0(v1: i32, v2: i32): ebb0(v1: i32, v2: i32):
v10 = iadd v1, v2 v10 = iadd v1, v2
; check: [R#0c] ; check: [R#0c]

4
filetests/isa/riscv/expand-i32.cton
View File

@@ -9,7 +9,7 @@ isa riscv supports_m=1
; regex: V=v\d+ ; regex: V=v\d+
function carry_out(i32, i32) -> i32, b1 { function %carry_out(i32, i32) -> i32, b1 {
ebb0(v1: i32, v2: i32): ebb0(v1: i32, v2: i32):
v3, v4 = iadd_cout v1, v2 v3, v4 = iadd_cout v1, v2
return v3, v4 return v3, v4
@@ -20,7 +20,7 @@ ebb0(v1: i32, v2: i32):
; Expanding illegal immediate constants. ; Expanding illegal immediate constants.
; Note that at some point we'll probably expand the iconst as well. ; Note that at some point we'll probably expand the iconst as well.
function large_imm(i32) -> i32 { function %large_imm(i32) -> i32 {
ebb0(v0: i32): ebb0(v0: i32):
v1 = iadd_imm v0, 1000000000 v1 = iadd_imm v0, 1000000000
return v1 return v1

28
filetests/isa/riscv/legalize-abi.cton
View File

@@ -4,7 +4,7 @@ isa riscv
; regex: V=v\d+ ; regex: V=v\d+
function int_split_args(i64) -> i64 { function %int_split_args(i64) -> i64 {
ebb0(v0: i64): ebb0(v0: i64):
; check: $ebb0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32): ; check: $ebb0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32):
; check: $v0 = iconcat $v0l, $v0h ; check: $v0 = iconcat $v0l, $v0h
@@ -14,9 +14,9 @@ ebb0(v0: i64):
return v1 return v1
} }
function split_call_arg(i32) { function %split_call_arg(i32) {
fn1 = function foo(i64) fn1 = function %foo(i64)
fn2 = function foo(i32, i64) fn2 = function %foo(i32, i64)
ebb0(v0: i32): ebb0(v0: i32):
v1 = uextend.i64 v0 v1 = uextend.i64 v0
call fn1(v1) call fn1(v1)
@@ -27,8 +27,8 @@ ebb0(v0: i32):
return return
} }
function split_ret_val() { function %split_ret_val() {
fn1 = function foo() -> i64 fn1 = function %foo() -> i64
ebb0: ebb0:
v1 = call fn1() v1 = call fn1()
; check: $ebb0($(link=$V): i32): ; check: $ebb0($(link=$V): i32):
@@ -42,8 +42,8 @@ ebb1(v10: i64):
} }
; First return value is fine, second one is expanded. ; First return value is fine, second one is expanded.
function split_ret_val2() { function %split_ret_val2() {
fn1 = function foo() -> i32, i64 fn1 = function %foo() -> i32, i64
ebb0: ebb0:
v1, v2 = call fn1() v1, v2 = call fn1()
; check: $ebb0($(link=$V): i32): ; check: $ebb0($(link=$V): i32):
@@ -56,7 +56,7 @@ ebb1(v9: i32, v10: i64):
jump ebb1(v9, v10) jump ebb1(v9, v10)
} }
function int_ext(i8, i8 sext, i8 uext) -> i8 uext { function %int_ext(i8, i8 sext, i8 uext) -> i8 uext {
ebb0(v1: i8, v2: i8, v3: i8): ebb0(v1: i8, v2: i8, v3: i8):
; check: $ebb0($v1: i8, $(v2x=$V): i32, $(v3x=$V): i32, $(link=$V): i32): ; check: $ebb0($v1: i8, $(v2x=$V): i32, $(v3x=$V): i32, $(link=$V): i32):
; check: $v2 = ireduce.i8 $v2x ; check: $v2 = ireduce.i8 $v2x
@@ -67,8 +67,8 @@ ebb0(v1: i8, v2: i8, v3: i8):
} }
; Function produces single return value, still need to copy. ; Function produces single return value, still need to copy.
function ext_ret_val() { function %ext_ret_val() {
fn1 = function foo() -> i8 sext fn1 = function %foo() -> i8 sext
ebb0: ebb0:
v1 = call fn1() v1 = call fn1()
; check: $ebb0($V: i32): ; check: $ebb0($V: i32):
@@ -81,7 +81,7 @@ ebb1(v10: i8):
jump ebb1(v10) jump ebb1(v10)
} }
function vector_split_args(i64x4) -> i64x4 { function %vector_split_args(i64x4) -> i64x4 {
ebb0(v0: i64x4): ebb0(v0: i64x4):
; check: $ebb0($(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: $ebb0($(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: $(v0a=$V) = iconcat $v0al, $v0ah
@@ -103,7 +103,7 @@ ebb0(v0: i64x4):
return v1 return v1
} }
function indirect(i32) { function %indirect(i32) {
sig1 = signature() sig1 = signature()
ebb0(v0: i32): ebb0(v0: i32):
call_indirect sig1, v0() call_indirect sig1, v0()
@@ -111,7 +111,7 @@ ebb0(v0: i32):
} }
; The first argument to call_indirect doesn't get altered. ; The first argument to call_indirect doesn't get altered.
function indirect_arg(i32, f32x2) { function %indirect_arg(i32, f32x2) {
sig1 = signature(f32x2) sig1 = signature(f32x2)
ebb0(v0: i32, v1: f32x2): ebb0(v0: i32, v1: f32x2):
call_indirect sig1, v0(v1) call_indirect sig1, v0(v1)

8
filetests/isa/riscv/legalize-i64.cton
View File

@@ -4,7 +4,7 @@ isa riscv supports_m=1
; regex: V=v\d+ ; regex: V=v\d+
function bitwise_and(i64, i64) -> i64 { function %bitwise_and(i64, i64) -> i64 {
ebb0(v1: i64, v2: i64): ebb0(v1: i64, v2: i64):
v3 = band v1, v2 v3 = band v1, v2
return v3 return v3
@@ -17,7 +17,7 @@ ebb0(v1: i64, v2: i64):
; check: $v3 = iconcat $v3l, $v3h ; check: $v3 = iconcat $v3l, $v3h
; check: return $v3l, $v3h, $link ; check: return $v3l, $v3h, $link
function bitwise_or(i64, i64) -> i64 { function %bitwise_or(i64, i64) -> i64 {
ebb0(v1: i64, v2: i64): ebb0(v1: i64, v2: i64):
v3 = bor v1, v2 v3 = bor v1, v2
return v3 return v3
@@ -30,7 +30,7 @@ ebb0(v1: i64, v2: i64):
; check: $v3 = iconcat $v3l, $v3h ; check: $v3 = iconcat $v3l, $v3h
; check: return $v3l, $v3h, $link ; check: return $v3l, $v3h, $link
function bitwise_xor(i64, i64) -> i64 { function %bitwise_xor(i64, i64) -> i64 {
ebb0(v1: i64, v2: i64): ebb0(v1: i64, v2: i64):
v3 = bxor v1, v2 v3 = bxor v1, v2
return v3 return v3
@@ -43,7 +43,7 @@ ebb0(v1: i64, v2: i64):
; check: $v3 = iconcat $v3l, $v3h ; check: $v3 = iconcat $v3l, $v3h
; check: return $v3l, $v3h, $link ; check: return $v3l, $v3h, $link
function arith_add(i64, i64) -> i64 { function %arith_add(i64, i64) -> i64 {
; Legalizing iadd.i64 requires two steps: ; Legalizing iadd.i64 requires two steps:
; 1. Narrow to iadd_cout.i32, then ; 1. Narrow to iadd_cout.i32, then
; 2. Expand iadd_cout.i32 since RISC-V has no carry flag. ; 2. Expand iadd_cout.i32 since RISC-V has no carry flag.

8
filetests/isa/riscv/parse-encoding.cton
View File

@@ -2,8 +2,8 @@
test legalizer test legalizer
isa riscv isa riscv
function parse_encoding(i32 [%x5]) -> i32 [%x10] { function %parse_encoding(i32 [%x5]) -> i32 [%x10] {
; check: function parse_encoding(i32 [%x5], i32 link [%x1]) -> i32 [%x10], i32 link [%x1] { ; check: function %parse_encoding(i32 [%x5], i32 link [%x1]) -> i32 [%x10], i32 link [%x1] {
sig0 = signature(i32 [%x10]) -> i32 [%x10] sig0 = signature(i32 [%x10]) -> i32 [%x10]
; check: sig0 = signature(i32 [%x10]) -> i32 [%x10] ; check: sig0 = signature(i32 [%x10]) -> i32 [%x10]
@@ -27,9 +27,9 @@ function parse_encoding(i32 [%x5]) -> i32 [%x10] {
; check: sig5 = signature() -> f32 [0] ; check: sig5 = signature() -> f32 [0]
; function + signature ; function + signature
fn15 = function bar(i32 [%x10]) -> b1 [%x10] fn15 = function %bar(i32 [%x10]) -> b1 [%x10]
; check: sig6 = signature(i32 [%x10]) -> b1 [%x10] ; check: sig6 = signature(i32 [%x10]) -> b1 [%x10]
; nextln: fn0 = sig6 bar ; nextln: fn0 = sig6 %bar
ebb0(v0: i32): ebb0(v0: i32):
return v0 return v0

6
filetests/isa/riscv/split-args.cton
View File

@@ -4,7 +4,7 @@ isa riscv
; regex: V=v\d+ ; regex: V=v\d+
function simple(i64, i64) -> i64 { function %simple(i64, i64) -> i64 {
ebb0(v1: i64, v2: i64): ebb0(v1: i64, v2: i64):
; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32): ; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
jump ebb1(v1) jump ebb1(v1)
@@ -19,7 +19,7 @@ ebb1(v3: i64):
; check: return $v4l, $v4h, $link ; check: return $v4l, $v4h, $link
} }
function multi(i64) -> i64 { function %multi(i64) -> i64 {
ebb1(v1: i64): ebb1(v1: i64):
; check: $ebb1($(v1l=$V): i32, $(v1h=$V): i32, $(link=$V): i32): ; check: $ebb1($(v1l=$V): i32, $(v1h=$V): i32, $(link=$V): i32):
jump ebb2(v1, v1) jump ebb2(v1, v1)
@@ -39,7 +39,7 @@ ebb3(v4: i64):
; check: return $v5l, $v5h, $link ; check: return $v5l, $v5h, $link
} }
function loop(i64, i64) -> i64 { function %loop(i64, i64) -> i64 {
ebb0(v1: i64, v2: i64): ebb0(v1: i64, v2: i64):
; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32): ; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
jump ebb1(v1) jump ebb1(v1)

8
filetests/isa/riscv/verify-encoding.cton
View File

@@ -1,8 +1,8 @@
test verifier test verifier
isa riscv isa riscv
function RV32I(i32 link [%x1]) -> i32 link [%x1] { function %RV32I(i32 link [%x1]) -> i32 link [%x1] {
fn0 = function foo() fn0 = function %foo()
ebb0(v9999: i32): ebb0(v9999: i32):
; iconst.i32 needs legalizing, so it should throw a ; iconst.i32 needs legalizing, so it should throw a
@@ -10,8 +10,8 @@ ebb0(v9999: i32):
return v9999 return v9999
} }
function RV32I(i32 link [%x1]) -> i32 link [%x1] { function %RV32I(i32 link [%x1]) -> i32 link [%x1] {
fn0 = function foo() fn0 = function %foo()
ebb0(v9999: i32): ebb0(v9999: i32):
v1 = iconst.i32 1 v1 = iconst.i32 1

4
filetests/licm/basic.cton
View File

@@ -1,6 +1,6 @@
test licm test licm
function simple_loop(i32) -> i32 { function %simple_loop(i32) -> i32 {
ebb1(v0: i32): ebb1(v0: i32):
v1 = iconst.i32 1 v1 = iconst.i32 1
@@ -14,7 +14,7 @@ ebb2(v5: i32):
return v5 return v5
} }
; sameln: function simple_loop(i32) -> i32 { ; sameln: function %simple_loop(i32) -> i32 {
; nextln: ebb2(v6: i32): ; nextln: ebb2(v6: i32):
; nextln: v1 = iconst.i32 1 ; nextln: v1 = iconst.i32 1
; nextln: v2 = iconst.i32 2 ; nextln: v2 = iconst.i32 2

4
filetests/licm/complex.cton
View File

@@ -1,6 +1,6 @@
test licm test licm
function complex(i32) -> i32 { function %complex(i32) -> i32 {
ebb0(v0: i32): ebb0(v0: i32):
v1 = iconst.i32 1 v1 = iconst.i32 1
@@ -39,7 +39,7 @@ ebb5(v16: i32):
return v17 return v17
} }
; sameln: function complex(i32) -> i32 { ; sameln: function %complex(i32) -> i32 {
; nextln: ebb6(v20: i32): ; nextln: ebb6(v20: i32):
; nextln: v1 = iconst.i32 1 ; nextln: v1 = iconst.i32 1
; nextln: v2 = iconst.i32 4 ; nextln: v2 = iconst.i32 4

4
filetests/licm/multiple-blocks.cton
View File

@@ -1,6 +1,6 @@
test licm test licm
function multiple_blocks(i32) -> i32 { function %multiple_blocks(i32) -> i32 {
ebb0(v0: i32): ebb0(v0: i32):
jump ebb1(v0) jump ebb1(v0)
@@ -23,7 +23,7 @@ ebb3(v30: i32):
jump ebb1(v30) jump ebb1(v30)
} }
; sameln:function multiple_blocks(i32) -> i32 { ; sameln:function %multiple_blocks(i32) -> i32 {
; nextln: ebb0(v0: i32): ; nextln: ebb0(v0: i32):
; nextln: v2 = iconst.i32 1 ; nextln: v2 = iconst.i32 1
; nextln: v3 = iconst.i32 2 ; nextln: v3 = iconst.i32 2

4
filetests/licm/nested_loops.cton
View File

@@ -1,6 +1,6 @@
test licm test licm
function nested_loops(i32) -> i32 { function %nested_loops(i32) -> i32 {
ebb0(v0: i32): ebb0(v0: i32):
v1 = iconst.i32 1 v1 = iconst.i32 1
@@ -25,7 +25,7 @@ ebb3(v30: i32):
} }
; sameln:function nested_loops(i32) -> i32 { ; sameln:function %nested_loops(i32) -> i32 {
; nextln: ebb4(v12: i32): ; nextln: ebb4(v12: i32):
; nextln: v1 = iconst.i32 1 ; nextln: v1 = iconst.i32 1
; nextln: v2 = iconst.i32 2 ; nextln: v2 = iconst.i32 2

24
filetests/parser/branch.cton
View File

@@ -2,14 +2,14 @@
test cat test cat
; Jumps with no arguments. The '()' empty argument list is optional. ; Jumps with no arguments. The '()' empty argument list is optional.
function minimal() { function %minimal() {
ebb0: ebb0:
jump ebb1 jump ebb1
ebb1: ebb1:
jump ebb0() jump ebb0()
} }
; sameln: function minimal() { ; sameln: function %minimal() {
; nextln: ebb0: ; nextln: ebb0:
; nextln: jump ebb1 ; nextln: jump ebb1
; nextln: ; nextln:
@@ -18,14 +18,14 @@ ebb1:
; nextln: } ; nextln: }
; Jumps with 1 arg. ; Jumps with 1 arg.
function onearg(i32) { function %onearg(i32) {
ebb0(v90: i32): ebb0(v90: i32):
jump ebb1(v90) jump ebb1(v90)
ebb1(v91: i32): ebb1(v91: i32):
jump ebb0(v91) jump ebb0(v91)
} }
; sameln: function onearg(i32) { ; sameln: function %onearg(i32) {
; nextln: ebb0($v90: i32): ; nextln: ebb0($v90: i32):
; nextln: jump ebb1($v90) ; nextln: jump ebb1($v90)
; nextln: ; nextln:
@@ -34,14 +34,14 @@ ebb1(v91: i32):
; nextln: } ; nextln: }
; Jumps with 2 args. ; Jumps with 2 args.
function twoargs(i32, f32) { function %twoargs(i32, f32) {
ebb0(v90: i32, v91: f32): ebb0(v90: i32, v91: f32):
jump ebb1(v90, v91) jump ebb1(v90, v91)
ebb1(v92: i32, v93: f32): ebb1(v92: i32, v93: f32):
jump ebb0(v92, v93) jump ebb0(v92, v93)
} }
; sameln: function twoargs(i32, f32) { ; sameln: function %twoargs(i32, f32) {
; nextln: ebb0($v90: i32, $v91: f32): ; nextln: ebb0($v90: i32, $v91: f32):
; nextln: jump ebb1($v90, $v91) ; nextln: jump ebb1($v90, $v91)
; nextln: ; nextln:
@@ -50,14 +50,14 @@ ebb1(v92: i32, v93: f32):
; nextln: } ; nextln: }
; Branches with no arguments. The '()' empty argument list is optional. ; Branches with no arguments. The '()' empty argument list is optional.
function minimal(i32) { function %minimal(i32) {
ebb0(v90: i32): ebb0(v90: i32):
brz v90, ebb1 brz v90, ebb1
ebb1: ebb1:
brnz v90, ebb1() brnz v90, ebb1()
} }
; sameln: function minimal(i32) { ; sameln: function %minimal(i32) {
; nextln: ebb0($v90: i32): ; nextln: ebb0($v90: i32):
; nextln: brz $v90, ebb1 ; nextln: brz $v90, ebb1
; nextln: ; nextln:
@@ -65,14 +65,14 @@ ebb1:
; nextln: brnz.i32 $v90, ebb1 ; nextln: brnz.i32 $v90, ebb1
; nextln: } ; nextln: }
function twoargs(i32, f32) { function %twoargs(i32, f32) {
ebb0(v90: i32, v91: f32): ebb0(v90: i32, v91: f32):
brz v90, ebb1(v90, v91) brz v90, ebb1(v90, v91)
ebb1(v92: i32, v93: f32): ebb1(v92: i32, v93: f32):
brnz v90, ebb0(v92, v93) brnz v90, ebb0(v92, v93)
} }
; sameln: function twoargs(i32, f32) { ; sameln: function %twoargs(i32, f32) {
; nextln: ebb0($v90: i32, $v91: f32): ; nextln: ebb0($v90: i32, $v91: f32):
; nextln: brz $v90, ebb1($v90, $v91) ; nextln: brz $v90, ebb1($v90, $v91)
; nextln: ; nextln:
@@ -80,7 +80,7 @@ ebb1(v92: i32, v93: f32):
; nextln: brnz.i32 $v90, ebb0($v92, $v93) ; nextln: brnz.i32 $v90, ebb0($v92, $v93)
; nextln: } ; nextln: }
function jumptable(i32) { function %jumptable(i32) {
jt200 = jump_table 0, 0 jt200 = jump_table 0, 0
jt2 = jump_table 0, 0, ebb10, ebb40, ebb20, ebb30 jt2 = jump_table 0, 0, ebb10, ebb40, ebb20, ebb30
@@ -94,7 +94,7 @@ ebb30:
ebb40: ebb40:
trap trap
} }
; sameln: function jumptable(i32) { ; sameln: function %jumptable(i32) {
; nextln: jt0 = jump_table 0 ; nextln: jt0 = jump_table 0
; nextln: jt1 = jump_table 0, 0, ebb0, ebb3, ebb1, ebb2 ; nextln: jt1 = jump_table 0, 0, ebb0, ebb3, ebb1, ebb2
; nextln: ; nextln:

34
filetests/parser/call.cton
View File

@@ -1,46 +1,46 @@
; Parser tests for call and return syntax. ; Parser tests for call and return syntax.
test cat test cat
function mini() { function %mini() {
ebb1: ebb1:
return return
} }
; sameln: function mini() { ; sameln: function %mini() {
; nextln: ebb0: ; nextln: ebb0:
; nextln: return ; nextln: return
; nextln: } ; nextln: }
function r1() -> i32, f32 { function %r1() -> i32, f32 {
ebb1: ebb1:
v1 = iconst.i32 3 v1 = iconst.i32 3
v2 = f32const 0.0 v2 = f32const 0.0
return v1, v2 return v1, v2
} }
; sameln: function r1() -> i32, f32 { ; sameln: function %r1() -> i32, f32 {
; nextln: ebb0: ; nextln: ebb0:
; nextln: $v1 = iconst.i32 3 ; nextln: $v1 = iconst.i32 3
; nextln: $v2 = f32const 0.0 ; nextln: $v2 = f32const 0.0
; nextln: return $v1, $v2 ; nextln: return $v1, $v2
; nextln: } ; nextln: }
function signatures() { function %signatures() {
sig10 = signature() sig10 = signature()
sig11 = signature(i32, f64) -> i32, b1 sig11 = signature(i32, f64) -> i32, b1
fn5 = sig11 foo fn5 = sig11 %foo
fn8 = function bar(i32) -> b1 fn8 = function %bar(i32) -> b1
} }
; sameln: function signatures() { ; sameln: function %signatures() {
; nextln: $sig10 = signature() ; nextln: $sig10 = signature()
; nextln: $sig11 = signature(i32, f64) -> i32, b1 ; nextln: $sig11 = signature(i32, f64) -> i32, b1
; nextln: sig2 = signature(i32) -> b1 ; nextln: sig2 = signature(i32) -> b1
; nextln: $fn5 = $sig11 foo ; nextln: $fn5 = $sig11 %foo
; nextln: $fn8 = sig2 bar ; nextln: $fn8 = sig2 %bar
; nextln: } ; nextln: }
function direct() { function %direct() {
fn0 = function none() fn0 = function %none()
fn1 = function one() -> i32 fn1 = function %one() -> i32
fn2 = function two() -> i32, f32 fn2 = function %two() -> i32, f32
ebb0: ebb0:
call fn0() call fn0()
@@ -53,7 +53,7 @@ ebb0:
; check: $v2, $v3 = call $fn2() ; check: $v2, $v3 = call $fn2()
; check: return ; check: return
function indirect(i64) { function %indirect(i64) {
sig0 = signature(i64) sig0 = signature(i64)
sig1 = signature() -> i32 sig1 = signature() -> i32
sig2 = signature() -> i32, f32 sig2 = signature() -> i32, f32
@@ -70,11 +70,11 @@ ebb0(v0: i64):
; check: return ; check: return
; Special purpose function arguments ; Special purpose function arguments
function special1(i32 sret, i32 fp, i32 csr, i32 link) -> i32 link, i32 fp, i32 csr, i32 sret { function %special1(i32 sret, i32 fp, i32 csr, i32 link) -> i32 link, i32 fp, i32 csr, i32 sret {
ebb0(v1: i32, v2: i32, v3: i32, v4: i32): ebb0(v1: i32, v2: i32, v3: i32, v4: i32):
return v4, v2, v3, v1 return v4, v2, v3, v1
} }
; check: function special1(i32 sret, i32 fp, i32 csr, i32 link) -> i32 link, i32 fp, i32 csr, i32 sret { ; check: function %special1(i32 sret, i32 fp, i32 csr, i32 link) -> i32 link, i32 fp, i32 csr, i32 sret {
; check: ebb0($v1: i32, $v2: i32, $v3: i32, $v4: i32): ; check: ebb0($v1: i32, $v2: i32, $v3: i32, $v4: i32):
; check: return $v4, $v2, $v3, $v1 ; check: return $v4, $v2, $v3, $v1
; check: } ; check: }

4
filetests/parser/instruction_encoding.cton
View File

@@ -4,7 +4,7 @@ isa riscv
; regex: WS=[ \t]* ; regex: WS=[ \t]*
function foo(i32, i32) { function %foo(i32, i32) {
ebb1(v0: i32, v1: i32): ebb1(v0: i32, v1: i32):
[-,-] v2 = iadd v0, v1 [-,-] v2 = iadd v0, v1
[-] trap [-] trap
@@ -13,7 +13,7 @@ ebb1(v0: i32, v1: i32):
v9 = iadd v8, v7 v9 = iadd v8, v7
[Iret#5] return v0, v8 [Iret#5] return v0, v8
} }
; sameln: function foo(i32, i32) { ; sameln: function %foo(i32, i32) {
; nextln: $ebb1($v0: i32, $v1: i32): ; nextln: $ebb1($v0: i32, $v1: i32):
; nextln: [-,-]$WS $v2 = iadd $v0, $v1 ; nextln: [-,-]$WS $v2 = iadd $v0, $v1
; nextln: [-]$WS trap ; nextln: [-]$WS trap

4
filetests/parser/keywords.cton
View File

@@ -1,5 +1,5 @@
test cat test cat
; 'function' is not a keyword, and can be used as the name of a function too. ; 'function' is not a keyword, and can be used as the name of a function too.
function function() {} function %function() {}
; check: function function() ; check: function %function()

8
filetests/parser/rewrite.cton
View File

@@ -9,13 +9,13 @@
test cat test cat
; Check that defining numbers are rewritten. ; Check that defining numbers are rewritten.
function defs() { function %defs() {
ebb100(v20: i32): ebb100(v20: i32):
v1000 = iconst.i32x8 5 v1000 = iconst.i32x8 5
v9200 = f64const 0x4.0p0 v9200 = f64const 0x4.0p0
trap trap
} }
; sameln: function defs() { ; sameln: function %defs() {
; nextln: $ebb100($v20: i32): ; nextln: $ebb100($v20: i32):
; nextln: $v1000 = iconst.i32x8 5 ; nextln: $v1000 = iconst.i32x8 5
; nextln: $v9200 = f64const 0x1.0000000000000p2 ; nextln: $v9200 = f64const 0x1.0000000000000p2
@@ -23,13 +23,13 @@ ebb100(v20: i32):
; nextln: } ; nextln: }
; Using values. ; Using values.
function use_value() { function %use_value() {
ebb100(v20: i32): ebb100(v20: i32):
v1000 = iadd_imm v20, 5 v1000 = iadd_imm v20, 5
v200 = iadd v20, v1000 v200 = iadd v20, v1000
jump ebb100(v1000) jump ebb100(v1000)
} }
; sameln: function use_value() { ; sameln: function %use_value() {
; nextln: ebb0($v20: i32): ; nextln: ebb0($v20: i32):
; nextln: $v1000 = iadd_imm $v20, 5 ; nextln: $v1000 = iadd_imm $v20, 5
; nextln: $v200 = iadd $v20, $v1000 ; nextln: $v200 = iadd $v20, $v1000

4
filetests/parser/ternary.cton
View File

@@ -1,7 +1,7 @@
test cat test cat
test verifier test verifier
function add_i96(i32, i32, i32, i32, i32, i32) -> i32, i32, i32 { function %add_i96(i32, i32, i32, i32, i32, i32) -> i32, i32, i32 {
ebb1(v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32): ebb1(v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
v10, v11 = iadd_cout v1, v4 v10, v11 = iadd_cout v1, v4
;check: $v10, $v11 = iadd_cout $v1, $v4 ;check: $v10, $v11 = iadd_cout $v1, $v4
@@ -12,7 +12,7 @@ ebb1(v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
return v10, v20, v30 return v10, v20, v30
} }
function sub_i96(i32, i32, i32, i32, i32, i32) -> i32, i32, i32 { function %sub_i96(i32, i32, i32, i32, i32, i32) -> i32, i32, i32 {
ebb1(v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32): ebb1(v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
v10, v11 = isub_bout v1, v4 v10, v11 = isub_bout v1, v4
;check: $v10, $v11 = isub_bout $v1, $v4 ;check: $v10, $v11 = isub_bout $v1, $v4

44
filetests/parser/tiny.cton
View File

@@ -1,24 +1,24 @@
test cat test cat
; The smallest possible function. ; The smallest possible function.
function minimal() { function %minimal() {
ebb0: ebb0:
trap trap
} }
; sameln: function minimal() { ; sameln: function %minimal() {
; nextln: ebb0: ; nextln: ebb0:
; nextln: trap ; nextln: trap
; nextln: } ; nextln: }
; Create and use values. ; Create and use values.
; Polymorphic instructions with type suffix. ; Polymorphic instructions with type suffix.
function ivalues() { function %ivalues() {
ebb0: ebb0:
v0 = iconst.i32 2 v0 = iconst.i32 2
v1 = iconst.i8 6 v1 = iconst.i8 6
v2 = ishl v0, v1 v2 = ishl v0, v1
} }
; sameln: function ivalues() { ; sameln: function %ivalues() {
; nextln: ebb0: ; nextln: ebb0:
; nextln: $v0 = iconst.i32 2 ; nextln: $v0 = iconst.i32 2
; nextln: $v1 = iconst.i8 6 ; nextln: $v1 = iconst.i8 6
@@ -26,23 +26,23 @@ ebb0:
; nextln: } ; nextln: }
; Polymorphic istruction controlled by second operand. ; Polymorphic istruction controlled by second operand.
function select() { function %select() {
ebb0(v90: i32, v91: i32, v92: b1): ebb0(v90: i32, v91: i32, v92: b1):
v0 = select v92, v90, v91 v0 = select v92, v90, v91
} }
; sameln: function select() { ; sameln: function %select() {
; nextln: ebb0($v90: i32, $v91: i32, $v92: b1): ; nextln: ebb0($v90: i32, $v91: i32, $v92: b1):
; nextln: $v0 = select $v92, $v90, $v91 ; nextln: $v0 = select $v92, $v90, $v91
; nextln: } ; nextln: }
; Lane indexes. ; Lane indexes.
function lanes() { function %lanes() {
ebb0: ebb0:
v0 = iconst.i32x4 2 v0 = iconst.i32x4 2
v1 = extractlane v0, 3 v1 = extractlane v0, 3
v2 = insertlane v0, 1, v1 v2 = insertlane v0, 1, v1
} }
; sameln: function lanes() { ; sameln: function %lanes() {
; nextln: ebb0: ; nextln: ebb0:
; nextln: $v0 = iconst.i32x4 2 ; nextln: $v0 = iconst.i32x4 2
; nextln: $v1 = extractlane $v0, 3 ; nextln: $v1 = extractlane $v0, 3
@@ -50,7 +50,7 @@ ebb0:
; nextln: } ; nextln: }
; Integer condition codes. ; Integer condition codes.
function icmp(i32, i32) { function %icmp(i32, i32) {
ebb0(v90: i32, v91: i32): ebb0(v90: i32, v91: i32):
v0 = icmp eq v90, v91 v0 = icmp eq v90, v91
v1 = icmp ult v90, v91 v1 = icmp ult v90, v91
@@ -58,7 +58,7 @@ ebb0(v90: i32, v91: i32):
v3 = irsub_imm v91, 45 v3 = irsub_imm v91, 45
br_icmp eq v90, v91, ebb0(v91, v90) br_icmp eq v90, v91, ebb0(v91, v90)
} }
; sameln: function icmp(i32, i32) { ; sameln: function %icmp(i32, i32) {
; nextln: ebb0($v90: i32, $v91: i32): ; nextln: ebb0($v90: i32, $v91: i32):
; nextln: $v0 = icmp eq $v90, $v91 ; nextln: $v0 = icmp eq $v90, $v91
; nextln: $v1 = icmp ult $v90, $v91 ; nextln: $v1 = icmp ult $v90, $v91
@@ -68,13 +68,13 @@ ebb0(v90: i32, v91: i32):
; nextln: } ; nextln: }
; Floating condition codes. ; Floating condition codes.
function fcmp(f32, f32) { function %fcmp(f32, f32) {
ebb0(v90: f32, v91: f32): ebb0(v90: f32, v91: f32):
v0 = fcmp eq v90, v91 v0 = fcmp eq v90, v91
v1 = fcmp uno v90, v91 v1 = fcmp uno v90, v91
v2 = fcmp lt v90, v91 v2 = fcmp lt v90, v91
} }
; sameln: function fcmp(f32, f32) { ; sameln: function %fcmp(f32, f32) {
; nextln: ebb0($v90: f32, $v91: f32): ; nextln: ebb0($v90: f32, $v91: f32):
; nextln: $v0 = fcmp eq $v90, $v91 ; nextln: $v0 = fcmp eq $v90, $v91
; nextln: $v1 = fcmp uno $v90, $v91 ; nextln: $v1 = fcmp uno $v90, $v91
@@ -83,19 +83,19 @@ ebb0(v90: f32, v91: f32):
; The bitcast instruction has two type variables: The controlling type variable ; The bitcast instruction has two type variables: The controlling type variable
; controls the outout type, and the input type is a free variable. ; controls the outout type, and the input type is a free variable.
function bitcast(i32, f32) { function %bitcast(i32, f32) {
ebb0(v90: i32, v91: f32): ebb0(v90: i32, v91: f32):
v0 = bitcast.i8x4 v90 v0 = bitcast.i8x4 v90
v1 = bitcast.i32 v91 v1 = bitcast.i32 v91
} }
; sameln: function bitcast(i32, f32) { ; sameln: function %bitcast(i32, f32) {
; nextln: ebb0($v90: i32, $v91: f32): ; nextln: ebb0($v90: i32, $v91: f32):
; nextln: $v0 = bitcast.i8x4 $v90 ; nextln: $v0 = bitcast.i8x4 $v90
; nextln: $v1 = bitcast.i32 $v91 ; nextln: $v1 = bitcast.i32 $v91
; nextln: } ; nextln: }
; Stack slot references ; Stack slot references
function stack() { function %stack() {
ss10 = stack_slot 8 ss10 = stack_slot 8
ss2 = stack_slot 4 ss2 = stack_slot 4
@@ -105,7 +105,7 @@ ebb0:
stack_store v1, ss10+2 stack_store v1, ss10+2
stack_store v2, ss2 stack_store v2, ss2
} }
; sameln: function stack() { ; sameln: function %stack() {
; nextln: $ss10 = stack_slot 8 ; nextln: $ss10 = stack_slot 8
; nextln: $ss2 = stack_slot 4 ; nextln: $ss2 = stack_slot 4
@@ -116,21 +116,21 @@ ebb0:
; nextln: stack_store $v2, $ss2 ; nextln: stack_store $v2, $ss2
; Heap access instructions. ; Heap access instructions.
function heap(i32) { function %heap(i32) {
; TODO: heap0 = heap %foo ; TODO: heap0 = heap %foo
ebb0(v1: i32): ebb0(v1: i32):
v2 = heap_load.f32 v1 v2 = heap_load.f32 v1
v3 = heap_load.f32 v1+12 v3 = heap_load.f32 v1+12
heap_store v3, v1 heap_store v3, v1
} }
; sameln: function heap(i32) { ; sameln: function %heap(i32) {
; nextln: ebb0($v1: i32): ; nextln: ebb0($v1: i32):
; nextln: $v2 = heap_load.f32 $v1 ; nextln: $v2 = heap_load.f32 $v1
; nextln: $v3 = heap_load.f32 $v1+12 ; nextln: $v3 = heap_load.f32 $v1+12
; nextln: heap_store $v3, $v1 ; nextln: heap_store $v3, $v1
; Memory access instructions. ; Memory access instructions.
function memory(i32) { function %memory(i32) {
ebb0(v1: i32): ebb0(v1: i32):
v2 = load.i64 v1 v2 = load.i64 v1
v3 = load.i64 aligned v1 v3 = load.i64 aligned v1
@@ -143,7 +143,7 @@ ebb0(v1: i32):
store aligned v3, v1+12 store aligned v3, v1+12
store notrap aligned v3, v1-12 store notrap aligned v3, v1-12
} }
; sameln: function memory(i32) { ; sameln: function %memory(i32) {
; nextln: ebb0($v1: i32): ; nextln: ebb0($v1: i32):
; nextln: $v2 = load.i64 $v1 ; nextln: $v2 = load.i64 $v1
; nextln: $v3 = load.i64 aligned $v1 ; nextln: $v3 = load.i64 aligned $v1
@@ -158,13 +158,13 @@ ebb0(v1: i32):
; Register diversions. ; Register diversions.
; This test file has no ISA, so we can unly use register unit numbers. ; This test file has no ISA, so we can unly use register unit numbers.
function diversion(i32) { function %diversion(i32) {
ebb0(v1: i32): ebb0(v1: i32):
regmove v1, %10 -> %20 regmove v1, %10 -> %20
regmove v1, %20 -> %10 regmove v1, %20 -> %10
return return
} }
; sameln: function diversion(i32) { ; sameln: function %diversion(i32) {
; nextln: ebb0($v1: i32): ; nextln: ebb0($v1: i32):
; nextln: regmove $v1, %10 -> %20 ; nextln: regmove $v1, %10 -> %20
; nextln: regmove $v1, %20 -> %10 ; nextln: regmove $v1, %20 -> %10

8
filetests/regalloc/basic.cton
View File

@@ -5,7 +5,7 @@ isa riscv
; regex: RX=%x\d+ ; regex: RX=%x\d+
function add(i32, i32) { function %add(i32, i32) {
ebb0(v1: i32, v2: i32): ebb0(v1: i32, v2: i32):
v3 = iadd v1, v2 v3 = iadd v1, v2
; check: [R#0c,%x5] ; check: [R#0c,%x5]
@@ -14,7 +14,7 @@ ebb0(v1: i32, v2: i32):
} }
; Function with a dead argument. ; Function with a dead argument.
function dead_arg(i32, i32) -> i32{ function %dead_arg(i32, i32) -> i32{
ebb0(v1: i32, v2: i32): ebb0(v1: i32, v2: i32):
; not: regmove ; not: regmove
; check: return $v1 ; check: return $v1
@@ -22,7 +22,7 @@ ebb0(v1: i32, v2: i32):
} }
; Return a value from a different register. ; Return a value from a different register.
function move1(i32, i32) -> i32 { function %move1(i32, i32) -> i32 {
ebb0(v1: i32, v2: i32): ebb0(v1: i32, v2: i32):
; not: regmove ; not: regmove
; check: regmove $v2, %x11 -> %x10 ; check: regmove $v2, %x11 -> %x10
@@ -31,7 +31,7 @@ ebb0(v1: i32, v2: i32):
} }
; Swap two registers. ; Swap two registers.
function swap(i32, i32) -> i32, i32 { function %swap(i32, i32) -> i32, i32 {
ebb0(v1: i32, v2: i32): ebb0(v1: i32, v2: i32):
; not: regmove ; not: regmove
; check: regmove $v2, %x11 -> $(tmp=$RX) ; check: regmove $v2, %x11 -> $(tmp=$RX)

4
filetests/simple_gvn/basic.cton
View File

@@ -1,6 +1,6 @@
test simple-gvn test simple-gvn
function simple_redundancy(i32, i32) -> i32 { function %simple_redundancy(i32, i32) -> i32 {
ebb0(v0: i32, v1: i32): ebb0(v0: i32, v1: i32):
v2 = iadd v0, v1 v2 = iadd v0, v1
v3 = iadd v0, v1 v3 = iadd v0, v1
@@ -9,7 +9,7 @@ ebb0(v0: i32, v1: i32):
return v4 return v4
} }
function cascading_redundancy(i32, i32) -> i32 { function %cascading_redundancy(i32, i32) -> i32 {
ebb0(v0: i32, v1: i32): ebb0(v0: i32, v1: i32):
v2 = iadd v0, v1 v2 = iadd v0, v1
v3 = iadd v0, v1 v3 = iadd v0, v1

4
filetests/verifier/bad_layout.cton
View File

@@ -1,6 +1,6 @@
test verifier test verifier
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
jump ebb1 ; error: terminator jump ebb1 ; error: terminator
return return
@@ -13,7 +13,7 @@ function test(i32) {
return return
} }
function test(i32) { ; Ok function %test(i32) { ; Ok
ebb0(v0: i32): ebb0(v0: i32):
return return
} }

138
lib/cretonne/src/ir/funcname.rs
View File

@@ -6,73 +6,119 @@
use std::fmt::{self, Write}; use std::fmt::{self, Write};
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
/// The name of a function can be any UTF-8 string. /// The name of a function can be any sequence of bytes.
/// ///
/// Function names are mostly a testing and debugging tool. /// Function names are mostly a testing and debugging tool.
/// In particular, `.cton` files use function names to identify functions. /// In particular, `.cton` files use function names to identify functions.
#[derive(Debug, Clone, PartialEq, Eq, Default)] #[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct FunctionName(String); pub struct FunctionName(NameRepr);
impl FunctionName { impl FunctionName {
/// Create new function name equal to `s`. /// Creates a new function name from a sequence of bytes.
pub fn new<S: Into<String>>(s: S) -> FunctionName { ///
FunctionName(s.into()) /// # Examples
///
/// ```rust
/// # use cretonne::ir::FunctionName;
/// // Create `FunctionName` from a string.
/// let name = FunctionName::new("hello");
/// assert_eq!(name.to_string(), "%hello");
///
/// // Create `FunctionName` from a sequence of bytes.
/// let bytes: &[u8] = &[10, 9, 8];
/// let name = FunctionName::new(bytes);
/// assert_eq!(name.to_string(), "#0a0908");
/// ```
pub fn new<T>(v: T) -> FunctionName
where T: Into<Vec<u8>>
{
let vec = v.into();
if vec.len() <= NAME_LENGTH_THRESHOLD {
let mut bytes = [0u8; NAME_LENGTH_THRESHOLD];
for (i, &byte) in vec.iter().enumerate() {
bytes[i] = byte;
} }
} FunctionName(NameRepr::Short {
length: vec.len() as u8,
fn is_id_start(c: char) -> bool { bytes: bytes,
c.is_ascii() && (c == '_' || c.is_alphabetic()) })
}
fn is_id_continue(c: char) -> bool {
c.is_ascii() && (c == '_' || c.is_alphanumeric())
}
// The function name may need quotes if it doesn't parse as an identifier.
fn needs_quotes(name: &str) -> bool {
let mut iter = name.chars();
if let Some(ch) = iter.next() {
!is_id_start(ch) || !iter.all(is_id_continue)
} else { } else {
// A blank function name needs quotes. FunctionName(NameRepr::Long(vec))
true }
}
}
/// Tries to interpret bytes as ASCII alphanumerical characters and `_`.
fn try_as_name(bytes: &[u8]) -> Option<String> {
let mut name = String::with_capacity(bytes.len());
for c in bytes.iter().map(|&b| b as char) {
if c.is_ascii() && c.is_alphanumeric() || c == '_' {
name.push(c);
} else {
return None;
}
}
Some(name)
}
const NAME_LENGTH_THRESHOLD: usize = 22;
#[derive(Debug, Clone, PartialEq, Eq)]
enum NameRepr {
Short {
length: u8,
bytes: [u8; NAME_LENGTH_THRESHOLD],
},
Long(Vec<u8>),
}
impl AsRef<[u8]> for NameRepr {
fn as_ref(&self) -> &[u8] {
match *self {
NameRepr::Short { length, ref bytes } => &bytes[0..length as usize],
NameRepr::Long(ref vec) => vec.as_ref(),
}
}
}
impl Default for NameRepr {
fn default() -> Self {
NameRepr::Short {
length: 0,
bytes: [0; NAME_LENGTH_THRESHOLD],
}
} }
} }
impl fmt::Display for FunctionName { impl fmt::Display for FunctionName {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if needs_quotes(&self.0) { if let Some(name) = try_as_name(self.0.as_ref()) {
f.write_char('"')?; write!(f, "%{}", name)
for c in self.0.chars().flat_map(char::escape_default) {
f.write_char(c)?;
}
f.write_char('"')
} else { } else {
f.write_str(&self.0) f.write_char('#')?;
for byte in self.0.as_ref() {
write!(f, "{:02x}", byte)?;
}
Ok(())
} }
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{needs_quotes, FunctionName}; use super::FunctionName;
#[test] #[test]
fn quoting() { fn displaying() {
assert_eq!(needs_quotes(""), true); assert_eq!(FunctionName::new("").to_string(), "%");
assert_eq!(needs_quotes("x"), false); assert_eq!(FunctionName::new("x").to_string(), "%x");
assert_eq!(needs_quotes(" "), true); assert_eq!(FunctionName::new("x_1").to_string(), "%x_1");
assert_eq!(needs_quotes("0"), true); assert_eq!(FunctionName::new(" ").to_string(), "#20");
assert_eq!(needs_quotes("x0"), false); assert_eq!(FunctionName::new("кретон").to_string(),
} "#d0bad180d0b5d182d0bed0bd");
assert_eq!(FunctionName::new("印花棉布").to_string(),
#[test] "#e58db0e88ab1e6a389e5b883");
fn escaping() { assert_eq!(FunctionName::new(vec![0, 1, 2, 3, 4, 5]).to_string(),
assert_eq!(FunctionName::new("").to_string(), "\"\""); "#000102030405");
assert_eq!(FunctionName::new("x").to_string(), "x");
assert_eq!(FunctionName::new(" ").to_string(), "\" \"");
assert_eq!(FunctionName::new(" \n").to_string(), "\" \\n\"");
assert_eq!(FunctionName::new("a\u{1000}v").to_string(),
"\"a\\u{1000}v\"");
} }
} }

14
lib/cretonne/src/write.rs
View File

@@ -365,26 +365,26 @@ mod tests {
#[test] #[test]
fn basic() { fn basic() {
let mut f = Function::new(); let mut f = Function::new();
assert_eq!(f.to_string(), "function \"\"() {\n}\n"); assert_eq!(f.to_string(), "function %() {\n}\n");
f.name = FunctionName::new("foo".to_string()); f.name = FunctionName::new("foo");
assert_eq!(f.to_string(), "function foo() {\n}\n"); assert_eq!(f.to_string(), "function %foo() {\n}\n");
f.stack_slots.push(StackSlotData::new(4)); f.stack_slots.push(StackSlotData::new(4));
assert_eq!(f.to_string(), assert_eq!(f.to_string(),
"function foo() {\n ss0 = stack_slot 4\n}\n"); "function %foo() {\n ss0 = stack_slot 4\n}\n");
let ebb = f.dfg.make_ebb(); let ebb = f.dfg.make_ebb();
f.layout.append_ebb(ebb); f.layout.append_ebb(ebb);
assert_eq!(f.to_string(), assert_eq!(f.to_string(),
"function foo() {\n ss0 = stack_slot 4\n\nebb0:\n}\n"); "function %foo() {\n ss0 = stack_slot 4\n\nebb0:\n}\n");
f.dfg.append_ebb_arg(ebb, types::I8); f.dfg.append_ebb_arg(ebb, types::I8);
assert_eq!(f.to_string(), assert_eq!(f.to_string(),
"function foo() {\n ss0 = stack_slot 4\n\nebb0(v0: i8):\n}\n"); "function %foo() {\n ss0 = stack_slot 4\n\nebb0(v0: i8):\n}\n");
f.dfg.append_ebb_arg(ebb, types::F32.by(4).unwrap()); f.dfg.append_ebb_arg(ebb, types::F32.by(4).unwrap());
assert_eq!(f.to_string(), assert_eq!(f.to_string(),
"function foo() {\n ss0 = stack_slot 4\n\nebb0(v0: i8, v1: f32x4):\n}\n"); "function %foo() {\n ss0 = stack_slot 4\n\nebb0(v0: i8, v1: f32x4):\n}\n");
} }
} }

82
lib/reader/src/parser.rs
View File

@@ -723,10 +723,25 @@ impl<'a> Parser<'a> {
// //
fn parse_function_name(&mut self) -> Result<FunctionName> { fn parse_function_name(&mut self) -> Result<FunctionName> {
match self.token() { match self.token() {
Some(Token::Identifier(s)) => { Some(Token::Name(s)) => {
self.consume(); self.consume();
Ok(FunctionName::new(s)) Ok(FunctionName::new(s))
} }
Some(Token::HexSequence(s)) => {
if s.len() % 2 != 0 {
return err!(self.loc,
"expected binary function name to have length multiple of two");
}
let mut bin_name = Vec::with_capacity(s.len() / 2);
let mut i = 0;
while i + 2 <= s.len() {
let byte = u8::from_str_radix(&s[i..i + 2], 16).unwrap();
bin_name.push(byte);
i += 2;
}
self.consume();
Ok(FunctionName::new(bin_name))
}
_ => err!(self.loc, "expected function name"), _ => err!(self.loc, "expected function name"),
} }
} }
@@ -1723,7 +1738,7 @@ mod tests {
#[test] #[test]
fn aliases() { fn aliases() {
let (func, details) = Parser::new("function qux() { let (func, details) = Parser::new("function %qux() {
ebb0: ebb0:
v4 = iconst.i8 6 v4 = iconst.i8 6
v3 -> v4 v3 -> v4
@@ -1731,7 +1746,7 @@ mod tests {
}") }")
.parse_function(None) .parse_function(None)
.unwrap(); .unwrap();
assert_eq!(func.name.to_string(), "qux"); assert_eq!(func.name.to_string(), "%qux");
let v4 = details.map.lookup_str("v4").unwrap(); let v4 = details.map.lookup_str("v4").unwrap();
assert_eq!(v4.to_string(), "v0"); assert_eq!(v4.to_string(), "v0");
let v3 = details.map.lookup_str("v3").unwrap(); let v3 = details.map.lookup_str("v3").unwrap();
@@ -1777,13 +1792,13 @@ mod tests {
#[test] #[test]
fn stack_slot_decl() { fn stack_slot_decl() {
let (func, _) = Parser::new("function foo() { let (func, _) = Parser::new("function %foo() {
ss3 = stack_slot 13 ss3 = stack_slot 13
ss1 = stack_slot 1 ss1 = stack_slot 1
}") }")
.parse_function(None) .parse_function(None)
.unwrap(); .unwrap();
assert_eq!(func.name.to_string(), "foo"); assert_eq!(func.name.to_string(), "%foo");
let mut iter = func.stack_slots.keys(); let mut iter = func.stack_slots.keys();
let ss0 = iter.next().unwrap(); let ss0 = iter.next().unwrap();
assert_eq!(ss0.to_string(), "ss0"); assert_eq!(ss0.to_string(), "ss0");
@@ -1794,7 +1809,7 @@ mod tests {
assert_eq!(iter.next(), None); assert_eq!(iter.next(), None);
// Catch duplicate definitions. // Catch duplicate definitions.
assert_eq!(Parser::new("function bar() { assert_eq!(Parser::new("function %bar() {
ss1 = stack_slot 13 ss1 = stack_slot 13
ss1 = stack_slot 1 ss1 = stack_slot 1
}") }")
@@ -1806,13 +1821,13 @@ mod tests {
#[test] #[test]
fn ebb_header() { fn ebb_header() {
let (func, _) = Parser::new("function ebbs() { let (func, _) = Parser::new("function %ebbs() {
ebb0: ebb0:
ebb4(v3: i32): ebb4(v3: i32):
}") }")
.parse_function(None) .parse_function(None)
.unwrap(); .unwrap();
assert_eq!(func.name.to_string(), "ebbs"); assert_eq!(func.name.to_string(), "%ebbs");
let mut ebbs = func.layout.ebbs(); let mut ebbs = func.layout.ebbs();
@@ -1828,7 +1843,7 @@ mod tests {
#[test] #[test]
fn comments() { fn comments() {
let (func, Details { comments, .. }) = Parser::new("; before let (func, Details { comments, .. }) = Parser::new("; before
function comment() { ; decl function %comment() { ; decl
ss10 = stack_slot 13 ; stackslot. ss10 = stack_slot 13 ; stackslot.
; Still stackslot. ; Still stackslot.
jt10 = jump_table ebb0 jt10 = jump_table ebb0
@@ -1839,7 +1854,7 @@ mod tests {
; More trailing.") ; More trailing.")
.parse_function(None) .parse_function(None)
.unwrap(); .unwrap();
assert_eq!(func.name.to_string(), "comment"); assert_eq!(func.name.to_string(), "%comment");
assert_eq!(comments.len(), 8); // no 'before' comment. assert_eq!(comments.len(), 8); // no 'before' comment.
assert_eq!(comments[0], assert_eq!(comments[0],
Comment { Comment {
@@ -1868,7 +1883,7 @@ mod tests {
test verify test verify
set enable_float=false set enable_float=false
; still preamble ; still preamble
function comment() {}") function %comment() {}")
.unwrap(); .unwrap();
assert_eq!(tf.commands.len(), 2); assert_eq!(tf.commands.len(), 2);
assert_eq!(tf.commands[0].command, "cfg"); assert_eq!(tf.commands[0].command, "cfg");
@@ -1884,23 +1899,23 @@ mod tests {
assert_eq!(tf.preamble_comments[0].text, "; before"); assert_eq!(tf.preamble_comments[0].text, "; before");
assert_eq!(tf.preamble_comments[1].text, "; still preamble"); assert_eq!(tf.preamble_comments[1].text, "; still preamble");
assert_eq!(tf.functions.len(), 1); assert_eq!(tf.functions.len(), 1);
assert_eq!(tf.functions[0].0.name.to_string(), "comment"); assert_eq!(tf.functions[0].0.name.to_string(), "%comment");
} }
#[test] #[test]
fn isa_spec() { fn isa_spec() {
assert!(parse_test("isa assert!(parse_test("isa
function foo() {}") function %foo() {}")
.is_err()); .is_err());
assert!(parse_test("isa riscv assert!(parse_test("isa riscv
set enable_float=false set enable_float=false
function foo() {}") function %foo() {}")
.is_err()); .is_err());
match parse_test("set enable_float=false match parse_test("set enable_float=false
isa riscv isa riscv
function foo() {}") function %foo() {}")
.unwrap() .unwrap()
.isa_spec { .isa_spec {
IsaSpec::None(_) => panic!("Expected some ISA"), IsaSpec::None(_) => panic!("Expected some ISA"),
@@ -1910,4 +1925,41 @@ mod tests {
} }
} }
} }
#[test]
fn binary_function_name() {
// Valid characters in the name.
let func = Parser::new("function #1234567890AbCdEf() {
ebb0:
trap
}")
.parse_function(None)
.unwrap()
.0;
assert_eq!(func.name.to_string(), "#1234567890abcdef");
// Invalid characters in the name.
let mut parser = Parser::new("function #12ww() {
ebb0:
trap
}");
assert!(parser.parse_function(None).is_err());
// The length of binary function name should be multiple of two.
let mut parser = Parser::new("function #1() {
ebb0:
trap
}");
assert!(parser.parse_function(None).is_err());
// Empty binary function name should be valid.
let func = Parser::new("function #() {
ebb0:
trap
}")
.parse_function(None)
.unwrap()
.0;
assert_eq!(func.name.to_string(), "%");
}
} }

2
lib/reader/src/sourcemap.rs
View File

@@ -222,7 +222,7 @@ mod tests {
#[test] #[test]
fn details() { fn details() {
let tf = parse_test("function detail() { let tf = parse_test("function %detail() {
ss10 = stack_slot 13 ss10 = stack_slot 13
jt10 = jump_table ebb0 jt10 = jump_table ebb0
ebb0(v4: i32, v7: i32): ebb0(v4: i32, v7: i32):

10
tests/cfg_traversal.rs
View File

@@ -27,7 +27,7 @@ fn test_reverse_postorder_traversal(function_source: &str, ebb_order: Vec<u32>)
#[test] #[test]
fn simple_traversal() { fn simple_traversal() {
test_reverse_postorder_traversal(" test_reverse_postorder_traversal("
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb1 brz v0, ebb1
jump ebb2 jump ebb2
@@ -56,7 +56,7 @@ fn simple_traversal() {
#[test] #[test]
fn loops_one() { fn loops_one() {
test_reverse_postorder_traversal(" test_reverse_postorder_traversal("
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
jump ebb1 jump ebb1
ebb1: ebb1:
@@ -74,7 +74,7 @@ fn loops_one() {
#[test] #[test]
fn loops_two() { fn loops_two() {
test_reverse_postorder_traversal(" test_reverse_postorder_traversal("
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb1 brz v0, ebb1
jump ebb2 jump ebb2
@@ -99,7 +99,7 @@ fn loops_two() {
#[test] #[test]
fn loops_three() { fn loops_three() {
test_reverse_postorder_traversal(" test_reverse_postorder_traversal("
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb1 brz v0, ebb1
jump ebb2 jump ebb2
@@ -129,7 +129,7 @@ fn loops_three() {
#[test] #[test]
fn back_edge_one() { fn back_edge_one() {
test_reverse_postorder_traversal(" test_reverse_postorder_traversal("
function test(i32) { function %test(i32) {
ebb0(v0: i32): ebb0(v0: i32):
brz v0, ebb1 brz v0, ebb1
jump ebb2 jump ebb2