diff --git a/docs/example.cton b/docs/example.cton
index db87e891d1..8b9c43c6b9 100644
--- a/docs/example.cton
+++ b/docs/example.cton
@@ -1,6 +1,6 @@
 test verifier
 
-function average(i32, i32) -> f32 {
+function %average(i32, i32) -> f32 {
     ss1 = stack_slot 8            ; Stack slot for ``sum``.
 
 ebb1(v1: i32, v2: i32):
diff --git a/docs/langref.rst b/docs/langref.rst
index e6a0e2b3d5..24b5961ec3 100644
--- a/docs/langref.rst
+++ b/docs/langref.rst
@@ -389,8 +389,8 @@ preamble`:
 
 This simple example illustrates direct function calls and signatures::
 
-    function gcd(i32 uext, i32 uext) -> i32 uext "C" {
-        fn1 = function divmod(i32 uext, i32 uext) -> i32 uext, i32 uext
+    function %gcd(i32 uext, i32 uext) -> i32 uext "C" {
+        fn1 = function %divmod(i32 uext, i32 uext) -> i32 uext, i32 uext
 
     ebb1(v1: i32, v2: i32):
         brz v2, ebb2
@@ -530,7 +530,7 @@ and address computations from the memory accesses.
 
 A small example using heaps::
 
-    function vdup(i32, i32) {
+    function %vdup(i32, i32) {
         h1 = heap "main"
 
     ebb1(v1: i32, v2: i32):
diff --git a/docs/testing.rst b/docs/testing.rst
index d4aa1a881c..b72ace08d3 100644
--- a/docs/testing.rst
+++ b/docs/testing.rst
@@ -130,7 +130,7 @@ The ``set`` lines apply settings cumulatively::
     set is_64bit=0
     isa riscv supports_m=false
 
-    function foo() {}
+    function %foo() {}
 
 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
@@ -184,13 +184,13 @@ against the associated filecheck directives.
 
 Example::
 
-    function r1() -> i32, f32 {
+    function %r1() -> i32, f32 {
     ebb1:
         v10 = iconst.i32 3
         v20 = f32const 0.0
         return v10, v20
     }
-    ; sameln: function r1() -> i32, f32 {
+    ; sameln: function %r1() -> i32, f32 {
     ; nextln: ebb0:
     ; nextln:     v0 = iconst.i32 3
     ; 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
 filecheck variables would be::
 
-    function r1() -> i32, f32 {
+    function %r1() -> i32, f32 {
     ebb1:
         v10 = iconst.i32 3
         v20 = f32const 0.0
         return v10, v20
     }
-    ; sameln: function r1() -> i32, f32 {
+    ; sameln: function %r1() -> i32, f32 {
     ; nextln: ebb0:
     ; nextln:     $v10 = iconst.i32 3
     ; nextln:     $v20 = f32const 0.0
@@ -226,7 +226,7 @@ reported location of the error is verified::
 
     test verifier
     
-    function test(i32) {
+    function %test(i32) {
         ebb0(v0: i32):
             jump ebb1       ; error: terminator
             return
@@ -250,8 +250,8 @@ command::
     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}"]
     
@@ -276,7 +276,7 @@ Compute the dominator tree of each function and validate it against the
 
     test domtree
     
-    function test(i32) {
+    function %test(i32) {
         ebb0(v0: i32):
             jump ebb1     ; dominates: ebb1
         ebb1:
@@ -328,7 +328,7 @@ that instruction is compared to the directive::
     test binemit
     isa riscv
 
-    function int32() {
+    function %int32() {
     ebb0:
         [-,%x5]             v1 = iconst.i32 1
         [-,%x6]             v2 = iconst.i32 2
diff --git a/filetests/cfg/loop.cton b/filetests/cfg/loop.cton
index 3f7892a9d9..06aa848c7f 100644
--- a/filetests/cfg/loop.cton
+++ b/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}"]
 
diff --git a/filetests/cfg/traps_early.cton b/filetests/cfg/traps_early.cton
index 9648190bc5..814e251f51 100644
--- a/filetests/cfg/traps_early.cton
+++ b/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
diff --git a/filetests/cfg/unused_node.cton b/filetests/cfg/unused_node.cton
index d4be2deddd..cbde9757bc 100644
--- a/filetests/cfg/unused_node.cton
+++ b/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}"]
diff --git a/filetests/domtree/basic.cton b/filetests/domtree/basic.cton
index 0b8536effd..e46c73e67e 100644
--- a/filetests/domtree/basic.cton
+++ b/filetests/domtree/basic.cton
@@ -1,6 +1,6 @@
 test domtree
 
-function test(i32) {
+function %test(i32) {
     ebb0(v0: i32):
         jump ebb1     ; dominates: ebb1
     ebb1:
diff --git a/filetests/domtree/loops.cton b/filetests/domtree/loops.cton
index cdc88544cc..43ad1e1c08 100644
--- a/filetests/domtree/loops.cton
+++ b/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
diff --git a/filetests/domtree/loops2.cton b/filetests/domtree/loops2.cton
index d2e3ba4f2c..eeac8343bd 100644
--- a/filetests/domtree/loops2.cton
+++ b/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
diff --git a/filetests/domtree/tall-tree.cton b/filetests/domtree/tall-tree.cton
index 3dd6f51da6..89821d0744 100644
--- a/filetests/domtree/tall-tree.cton
+++ b/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
diff --git a/filetests/domtree/wide-tree.cton b/filetests/domtree/wide-tree.cton
index f4e822cd81..3a9b4fff37 100644
--- a/filetests/domtree/wide-tree.cton
+++ b/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
diff --git a/filetests/isa/intel/binary32.cton b/filetests/isa/intel/binary32.cton
index 5cac489f77..818335d349 100644
--- a/filetests/isa/intel/binary32.cton
+++ b/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
diff --git a/filetests/isa/riscv/abi-e.cton b/filetests/isa/riscv/abi-e.cton
index f770a3558f..543b55079f 100644
--- a/filetests/isa/riscv/abi-e.cton
+++ b/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
diff --git a/filetests/isa/riscv/abi.cton b/filetests/isa/riscv/abi.cton
index eba5609f3e..f26c7686cf 100644
--- a/filetests/isa/riscv/abi.cton
+++ b/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]
 
diff --git a/filetests/isa/riscv/binary32.cton b/filetests/isa/riscv/binary32.cton
index f62a6187e0..052342f233 100644
--- a/filetests/isa/riscv/binary32.cton
+++ b/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
diff --git a/filetests/isa/riscv/encoding.cton b/filetests/isa/riscv/encoding.cton
index fdd3ee4329..71961ba353 100644
--- a/filetests/isa/riscv/encoding.cton
+++ b/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]
diff --git a/filetests/isa/riscv/expand-i32.cton b/filetests/isa/riscv/expand-i32.cton
index fe93521567..2bffad234c 100644
--- a/filetests/isa/riscv/expand-i32.cton
+++ b/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
diff --git a/filetests/isa/riscv/legalize-abi.cton b/filetests/isa/riscv/legalize-abi.cton
index a3632edca3..4d6f4e6e7f 100644
--- a/filetests/isa/riscv/legalize-abi.cton
+++ b/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)
diff --git a/filetests/isa/riscv/legalize-i64.cton b/filetests/isa/riscv/legalize-i64.cton
index 516502c4d4..e7a3441ee9 100644
--- a/filetests/isa/riscv/legalize-i64.cton
+++ b/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.
diff --git a/filetests/isa/riscv/parse-encoding.cton b/filetests/isa/riscv/parse-encoding.cton
index 69a25ce744..cd02a3ca47 100644
--- a/filetests/isa/riscv/parse-encoding.cton
+++ b/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
diff --git a/filetests/isa/riscv/split-args.cton b/filetests/isa/riscv/split-args.cton
index a568204658..be1370dc12 100644
--- a/filetests/isa/riscv/split-args.cton
+++ b/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)
diff --git a/filetests/isa/riscv/verify-encoding.cton b/filetests/isa/riscv/verify-encoding.cton
index 73d28c842a..52b8d6d79c 100644
--- a/filetests/isa/riscv/verify-encoding.cton
+++ b/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
diff --git a/filetests/licm/basic.cton b/filetests/licm/basic.cton
index 637b910f53..36b7864cfe 100644
--- a/filetests/licm/basic.cton
+++ b/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
diff --git a/filetests/licm/complex.cton b/filetests/licm/complex.cton
index fead0cf746..b5063d807f 100644
--- a/filetests/licm/complex.cton
+++ b/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
diff --git a/filetests/licm/multiple-blocks.cton b/filetests/licm/multiple-blocks.cton
index 54db640501..4738081d9a 100644
--- a/filetests/licm/multiple-blocks.cton
+++ b/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
diff --git a/filetests/licm/nested_loops.cton b/filetests/licm/nested_loops.cton
index e2d3846a0f..a32dd4b498 100644
--- a/filetests/licm/nested_loops.cton
+++ b/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
diff --git a/filetests/parser/branch.cton b/filetests/parser/branch.cton
index ac979bbb26..4adb4b5d27 100644
--- a/filetests/parser/branch.cton
+++ b/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: 
diff --git a/filetests/parser/call.cton b/filetests/parser/call.cton
index 67472f7efc..9d7c2c3d16 100644
--- a/filetests/parser/call.cton
+++ b/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: }
diff --git a/filetests/parser/instruction_encoding.cton b/filetests/parser/instruction_encoding.cton
index 4971cba510..bc2e1dd239 100644
--- a/filetests/parser/instruction_encoding.cton
+++ b/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
diff --git a/filetests/parser/keywords.cton b/filetests/parser/keywords.cton
index eb15f2624d..37d0390a58 100644
--- a/filetests/parser/keywords.cton
+++ b/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()
diff --git a/filetests/parser/rewrite.cton b/filetests/parser/rewrite.cton
index e01391d156..f7ebfa3876 100644
--- a/filetests/parser/rewrite.cton
+++ b/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
diff --git a/filetests/parser/ternary.cton b/filetests/parser/ternary.cton
index 99cb15b566..3f320a61f0 100644
--- a/filetests/parser/ternary.cton
+++ b/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
diff --git a/filetests/parser/tiny.cton b/filetests/parser/tiny.cton
index 5ad2f7a39d..1414668a52 100644
--- a/filetests/parser/tiny.cton
+++ b/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
diff --git a/filetests/regalloc/basic.cton b/filetests/regalloc/basic.cton
index 9046aeb711..36c0e5c81c 100644
--- a/filetests/regalloc/basic.cton
+++ b/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)
diff --git a/filetests/simple_gvn/basic.cton b/filetests/simple_gvn/basic.cton
index 06d0989d1e..c76ec12b88 100644
--- a/filetests/simple_gvn/basic.cton
+++ b/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
diff --git a/filetests/verifier/bad_layout.cton b/filetests/verifier/bad_layout.cton
index ac29452958..fd597359be 100644
--- a/filetests/verifier/bad_layout.cton
+++ b/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
 }
diff --git a/lib/cretonne/src/ir/funcname.rs b/lib/cretonne/src/ir/funcname.rs
index 0074c97502..4ab76d2001 100644
--- a/lib/cretonne/src/ir/funcname.rs
+++ b/lib/cretonne/src/ir/funcname.rs
@@ -6,73 +6,119 @@
 use std::fmt::{self, Write};
 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.
 /// In particular, `.cton` files use function names to identify functions.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct FunctionName(String);
+pub struct FunctionName(NameRepr);
 
 impl FunctionName {
-    /// Create new function name equal to `s`.
-    pub fn new<S: Into<String>>(s: S) -> FunctionName {
-        FunctionName(s.into())
+    /// Creates a new function name from a sequence of bytes.
+    ///
+    /// # 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,
+                             bytes: bytes,
+                         })
+        } else {
+            FunctionName(NameRepr::Long(vec))
+        }
     }
 }
 
-fn is_id_start(c: char) -> bool {
-    c.is_ascii() && (c == '_' || c.is_alphabetic())
+/// 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)
 }
 
-fn is_id_continue(c: char) -> bool {
-    c.is_ascii() && (c == '_' || c.is_alphanumeric())
+const NAME_LENGTH_THRESHOLD: usize = 22;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum NameRepr {
+    Short {
+        length: u8,
+        bytes: [u8; NAME_LENGTH_THRESHOLD],
+    },
+    Long(Vec<u8>),
 }
 
-// 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 {
-        // A blank function name needs quotes.
-        true
+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 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if needs_quotes(&self.0) {
-            f.write_char('"')?;
-            for c in self.0.chars().flat_map(char::escape_default) {
-                f.write_char(c)?;
-            }
-            f.write_char('"')
+        if let Some(name) = try_as_name(self.0.as_ref()) {
+            write!(f, "%{}", name)
         } else {
-            f.write_str(&self.0)
+            f.write_char('#')?;
+            for byte in self.0.as_ref() {
+                write!(f, "{:02x}", byte)?;
+            }
+            Ok(())
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{needs_quotes, FunctionName};
+    use super::FunctionName;
 
     #[test]
-    fn quoting() {
-        assert_eq!(needs_quotes(""), true);
-        assert_eq!(needs_quotes("x"), false);
-        assert_eq!(needs_quotes(" "), true);
-        assert_eq!(needs_quotes("0"), true);
-        assert_eq!(needs_quotes("x0"), false);
-    }
-
-    #[test]
-    fn escaping() {
-        assert_eq!(FunctionName::new("").to_string(), "\"\"");
-        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\"");
+    fn displaying() {
+        assert_eq!(FunctionName::new("").to_string(), "%");
+        assert_eq!(FunctionName::new("x").to_string(), "%x");
+        assert_eq!(FunctionName::new("x_1").to_string(), "%x_1");
+        assert_eq!(FunctionName::new(" ").to_string(), "#20");
+        assert_eq!(FunctionName::new("кретон").to_string(),
+                   "#d0bad180d0b5d182d0bed0bd");
+        assert_eq!(FunctionName::new("印花棉布").to_string(),
+                   "#e58db0e88ab1e6a389e5b883");
+        assert_eq!(FunctionName::new(vec![0, 1, 2, 3, 4, 5]).to_string(),
+                   "#000102030405");
     }
 }
diff --git a/lib/cretonne/src/write.rs b/lib/cretonne/src/write.rs
index af66cc8868..818e4d9700 100644
--- a/lib/cretonne/src/write.rs
+++ b/lib/cretonne/src/write.rs
@@ -365,26 +365,26 @@ mod tests {
     #[test]
     fn basic() {
         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());
-        assert_eq!(f.to_string(), "function foo() {\n}\n");
+        f.name = FunctionName::new("foo");
+        assert_eq!(f.to_string(), "function %foo() {\n}\n");
 
         f.stack_slots.push(StackSlotData::new(4));
         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();
         f.layout.append_ebb(ebb);
         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);
         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());
         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");
     }
 }
diff --git a/lib/reader/src/parser.rs b/lib/reader/src/parser.rs
index fa9f31df5a..3529bc95a3 100644
--- a/lib/reader/src/parser.rs
+++ b/lib/reader/src/parser.rs
@@ -723,10 +723,25 @@ impl<'a> Parser<'a> {
     //
     fn parse_function_name(&mut self) -> Result<FunctionName> {
         match self.token() {
-            Some(Token::Identifier(s)) => {
+            Some(Token::Name(s)) => {
                 self.consume();
                 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"),
         }
     }
@@ -1723,7 +1738,7 @@ mod tests {
 
     #[test]
     fn aliases() {
-        let (func, details) = Parser::new("function qux() {
+        let (func, details) = Parser::new("function %qux() {
                                            ebb0:
                                              v4 = iconst.i8 6
                                              v3 -> v4
@@ -1731,7 +1746,7 @@ mod tests {
                                            }")
                 .parse_function(None)
                 .unwrap();
-        assert_eq!(func.name.to_string(), "qux");
+        assert_eq!(func.name.to_string(), "%qux");
         let v4 = details.map.lookup_str("v4").unwrap();
         assert_eq!(v4.to_string(), "v0");
         let v3 = details.map.lookup_str("v3").unwrap();
@@ -1777,13 +1792,13 @@ mod tests {
 
     #[test]
     fn stack_slot_decl() {
-        let (func, _) = Parser::new("function foo() {
+        let (func, _) = Parser::new("function %foo() {
                                        ss3 = stack_slot 13
                                        ss1 = stack_slot 1
                                      }")
                 .parse_function(None)
                 .unwrap();
-        assert_eq!(func.name.to_string(), "foo");
+        assert_eq!(func.name.to_string(), "%foo");
         let mut iter = func.stack_slots.keys();
         let ss0 = iter.next().unwrap();
         assert_eq!(ss0.to_string(), "ss0");
@@ -1794,7 +1809,7 @@ mod tests {
         assert_eq!(iter.next(), None);
 
         // Catch duplicate definitions.
-        assert_eq!(Parser::new("function bar() {
+        assert_eq!(Parser::new("function %bar() {
                                     ss1  = stack_slot 13
                                     ss1  = stack_slot 1
                                 }")
@@ -1806,13 +1821,13 @@ mod tests {
 
     #[test]
     fn ebb_header() {
-        let (func, _) = Parser::new("function ebbs() {
+        let (func, _) = Parser::new("function %ebbs() {
                                      ebb0:
                                      ebb4(v3: i32):
                                      }")
                 .parse_function(None)
                 .unwrap();
-        assert_eq!(func.name.to_string(), "ebbs");
+        assert_eq!(func.name.to_string(), "%ebbs");
 
         let mut ebbs = func.layout.ebbs();
 
@@ -1828,7 +1843,7 @@ mod tests {
     #[test]
     fn comments() {
         let (func, Details { comments, .. }) = Parser::new("; before
-                         function comment() { ; decl
+                         function %comment() { ; decl
                             ss10  = stack_slot 13 ; stackslot.
                             ; Still stackslot.
                             jt10 = jump_table ebb0
@@ -1839,7 +1854,7 @@ mod tests {
                          ; More trailing.")
                 .parse_function(None)
                 .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[0],
                    Comment {
@@ -1868,7 +1883,7 @@ mod tests {
                              test verify
                              set enable_float=false
                              ; still preamble
-                             function comment() {}")
+                             function %comment() {}")
                 .unwrap();
         assert_eq!(tf.commands.len(), 2);
         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[1].text, "; still preamble");
         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]
     fn isa_spec() {
         assert!(parse_test("isa
-                            function foo() {}")
+                            function %foo() {}")
                         .is_err());
 
         assert!(parse_test("isa riscv
                             set enable_float=false
-                            function foo() {}")
+                            function %foo() {}")
                         .is_err());
 
         match parse_test("set enable_float=false
                           isa riscv
-                          function foo() {}")
+                          function %foo() {}")
                       .unwrap()
                       .isa_spec {
             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(), "%");
+    }
 }
diff --git a/lib/reader/src/sourcemap.rs b/lib/reader/src/sourcemap.rs
index f84c792d89..824eb97621 100644
--- a/lib/reader/src/sourcemap.rs
+++ b/lib/reader/src/sourcemap.rs
@@ -222,7 +222,7 @@ mod tests {
 
     #[test]
     fn details() {
-        let tf = parse_test("function detail() {
+        let tf = parse_test("function %detail() {
                                ss10 = stack_slot 13
                                jt10 = jump_table ebb0
                              ebb0(v4: i32, v7: i32):
diff --git a/tests/cfg_traversal.rs b/tests/cfg_traversal.rs
index 21e2a086b2..a0c9a64d90 100644
--- a/tests/cfg_traversal.rs
+++ b/tests/cfg_traversal.rs
@@ -27,7 +27,7 @@ fn test_reverse_postorder_traversal(function_source: &str, ebb_order: Vec<u32>)
 #[test]
 fn simple_traversal() {
     test_reverse_postorder_traversal("
-        function test(i32) {
+        function %test(i32) {
             ebb0(v0: i32):
                brz v0, ebb1
                jump ebb2
@@ -56,7 +56,7 @@ fn simple_traversal() {
 #[test]
 fn loops_one() {
     test_reverse_postorder_traversal("
-        function test(i32) {
+        function %test(i32) {
             ebb0(v0: i32):
                 jump ebb1
             ebb1:
@@ -74,7 +74,7 @@ fn loops_one() {
 #[test]
 fn loops_two() {
     test_reverse_postorder_traversal("
-        function test(i32) {
+        function %test(i32) {
             ebb0(v0: i32):
                 brz v0, ebb1
                 jump ebb2
@@ -99,7 +99,7 @@ fn loops_two() {
 #[test]
 fn loops_three() {
     test_reverse_postorder_traversal("
-        function test(i32) {
+        function %test(i32) {
             ebb0(v0: i32):
                 brz v0, ebb1
                 jump ebb2
@@ -129,7 +129,7 @@ fn loops_three() {
 #[test]
 fn back_edge_one() {
     test_reverse_postorder_traversal("
-        function test(i32) {
+        function %test(i32) {
             ebb0(v0: i32):
                 brz v0, ebb1
                 jump ebb2