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/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