Binary function names (#91)

* 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

filetests/cfg/loop.cton

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

filetests/cfg/traps_early.cton

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

filetests/cfg/unused_node.cton

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

filetests/domtree/basic.cton

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

filetests/domtree/loops.cton

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

filetests/domtree/loops2.cton

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

filetests/domtree/tall-tree.cton

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

filetests/domtree/wide-tree.cton

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

filetests/isa/intel/binary32.cton

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

filetests/isa/riscv/abi-e.cton

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

filetests/isa/riscv/abi.cton

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

filetests/isa/riscv/binary32.cton

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

filetests/isa/riscv/encoding.cton

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

filetests/isa/riscv/expand-i32.cton

@@ -9,7 +9,7 @@ isa riscv supports_m=1
 
 ; regex: V=v\d+
 
-function carry_out(i32, i32) -> i32, b1 {
+function %carry_out(i32, i32) -> i32, b1 {
 ebb0(v1: i32, v2: i32):
     v3, v4 = iadd_cout v1, v2
     return v3, v4
@@ -20,7 +20,7 @@ ebb0(v1: i32, v2: i32):
 
 ; Expanding illegal immediate constants.
 ; 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):
     v1 = iadd_imm v0, 1000000000
     return v1

filetests/isa/riscv/legalize-abi.cton

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

filetests/isa/riscv/legalize-i64.cton

@@ -4,7 +4,7 @@ isa riscv supports_m=1
 
 ; regex: V=v\d+
 
-function bitwise_and(i64, i64) -> i64 {
+function %bitwise_and(i64, i64) -> i64 {
 ebb0(v1: i64, v2: i64):
     v3 = band v1, v2
     return v3
@@ -17,7 +17,7 @@ ebb0(v1: i64, v2: i64):
 ; check: $v3 = iconcat $v3l, $v3h
 ; check: return $v3l, $v3h, $link
 
-function bitwise_or(i64, i64) -> i64 {
+function %bitwise_or(i64, i64) -> i64 {
 ebb0(v1: i64, v2: i64):
     v3 = bor v1, v2
     return v3
@@ -30,7 +30,7 @@ ebb0(v1: i64, v2: i64):
 ; check: $v3 = iconcat $v3l, $v3h
 ; check: return $v3l, $v3h, $link
 
-function bitwise_xor(i64, i64) -> i64 {
+function %bitwise_xor(i64, i64) -> i64 {
 ebb0(v1: i64, v2: i64):
     v3 = bxor v1, v2
     return v3
@@ -43,7 +43,7 @@ ebb0(v1: i64, v2: i64):
 ; check: $v3 = iconcat $v3l, $v3h
 ; check: return $v3l, $v3h, $link
 
-function arith_add(i64, i64) -> i64 {
+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.

filetests/isa/riscv/parse-encoding.cton

@@ -2,8 +2,8 @@
 test legalizer
 isa riscv
 
-function parse_encoding(i32 [%x5]) -> i32 [%x10] {
-    ; check: function parse_encoding(i32 [%x5], i32 link [%x1]) -> i32 [%x10], i32 link [%x1] {
+function %parse_encoding(i32 [%x5]) -> i32 [%x10] {
+    ; check: function %parse_encoding(i32 [%x5], i32 link [%x1]) -> i32 [%x10], i32 link [%x1] {
 
     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]
 
     ; function + signature
-    fn15 = function bar(i32 [%x10]) -> b1 [%x10]
+    fn15 = function %bar(i32 [%x10]) -> b1 [%x10]
     ; check: sig6 = signature(i32 [%x10]) -> b1 [%x10]
-    ; nextln: fn0 = sig6 bar
+    ; nextln: fn0 = sig6 %bar
 
 ebb0(v0: i32):
     return v0

filetests/isa/riscv/split-args.cton

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

filetests/isa/riscv/verify-encoding.cton

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

filetests/licm/basic.cton

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

filetests/licm/complex.cton

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

filetests/licm/multiple-blocks.cton

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

filetests/licm/nested_loops.cton

@@ -1,6 +1,6 @@
 test licm
 
-function nested_loops(i32) -> i32 {
+function %nested_loops(i32) -> i32 {
 
 ebb0(v0: i32):
     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:     v1 = iconst.i32 1
 ; nextln:     v2 = iconst.i32 2

filetests/parser/branch.cton

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

filetests/parser/call.cton

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

filetests/parser/instruction_encoding.cton

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

filetests/parser/keywords.cton

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

filetests/parser/rewrite.cton

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

filetests/parser/ternary.cton

@@ -1,7 +1,7 @@
 test cat
 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):
     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
 }
 
-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):
     v10, v11 = isub_bout v1, v4
     ;check: $v10, $v11 = isub_bout $v1, $v4

filetests/parser/tiny.cton

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

filetests/regalloc/basic.cton

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

filetests/simple_gvn/basic.cton

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

filetests/verifier/bad_layout.cton

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