Add a calling convention to all function signatures.

A CallConv enum on every function signature makes it possible to
generate calls to functions with different calling conventions within
the same ISA / within a single function.

The calling conventions also serve as a way of customizing Cretonne's
behavior when embedded inside a VM. As an example, the SpiderWASM
calling convention is used to compile WebAssembly functions that run
inside the SpiderMonkey virtual machine.

All function signatures must have a calling convention at the end, so
this changes the textual IL syntax.

Before:

    sig1 = signature(i32, f64) -> f64

After

    sig1 = (i32, f64) -> f64 native
    sig2 = (i32) spiderwasm

When printing functions, the signature goes after the return types:

    function %r1() -> i32, f32 spiderwasm {
    ebb1:
        ...
    }

In the parser, this calling convention is optional and defaults to
"native". This is mostly to avoid updating all the existing test cases
under filetests/. When printing a function, the calling convention is
always included, including for "native" functions.

cranelift/docs/example.cton

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

cranelift/docs/langref.rst

@@ -410,13 +410,6 @@ This simple example illustrates direct function calls and signatures::
 
 Indirect function calls use a signature declared in the preamble.
 
-.. inst:: SIG = signature signature
-
-    Declare a function signature for use with indirect calls.
-
-    :arg signature: Function signature. See :token:`signature`.
-    :result SIG: A signature identifier.
-
 .. autoinst:: call_indirect
 
 .. todo:: Define safe indirect function calls.

cranelift/filetests/isa/intel/abi64.cton

@@ -6,14 +6,14 @@ isa intel
 ; regex: V=v\d+
 
 function %f() {
-    sig0 = signature(i32) -> i32
+    sig0 = (i32) -> i32 native
-    ; check: sig0 = signature(i32 [%rdi]) -> i32 [%rax]
+    ; check: sig0 = (i32 [%rdi]) -> i32 [%rax] native
 
-    sig1 = signature(i64) -> b1
+    sig1 = (i64) -> b1 native
-    ; check: sig1 = signature(i64 [%rdi]) -> b1 [%rax]
+    ; check: sig1 = (i64 [%rdi]) -> b1 [%rax] native
 
-    sig2 = signature(f32, i64) -> f64
+    sig2 = (f32, i64) -> f64 native
-    ; check: sig2 = signature(f32 [%xmm0], i64 [%rdi]) -> f64 [%xmm0]
+    ; check: sig2 = (f32 [%xmm0], i64 [%rdi]) -> f64 [%xmm0] native
 
 ebb0:
     return

cranelift/filetests/isa/intel/binary32.cton

@@ -9,7 +9,7 @@ isa intel haswell
 
 function %I32() {
     fn0 = function %foo()
-    sig0 = signature()
+    sig0 = ()
 
 ebb0:
     ; asm: movl $1, %ecx

cranelift/filetests/isa/intel/binary64.cton

@@ -11,7 +11,7 @@ isa intel haswell
 ; Tests for i64 instructions.
 function %I64() {
     fn0 = function %foo()
-    sig0 = signature()
+    sig0 = ()
 
 ebb0:
 
@@ -457,7 +457,7 @@ ebb2:
 ; be done by an instruction shrinking pass.
 function %I32() {
     fn0 = function %foo()
-    sig0 = signature()
+    sig0 = ()
 
 ebb0:
 

cranelift/filetests/isa/riscv/abi-e.cton

@@ -7,8 +7,8 @@ isa riscv enable_e
 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
+    sig0 = (i64, i64, i64, i64) -> i64 native
-    ; check: sig0 = signature(i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13], i32 [%x14], i32 [%x15], i32 [0], i32 [4]) -> i32 [%x10], i32 [%x11]
+    ; check: sig0 = (i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13], i32 [%x14], i32 [%x15], i32 [0], i32 [4]) -> i32 [%x10], i32 [%x11] native
 ebb0:
     return
 }

cranelift/filetests/isa/riscv/abi.cton

@@ -5,27 +5,27 @@ isa riscv
 ; regex: V=v\d+
 
 function %f() {
-    sig0 = signature(i32) -> i32
+    sig0 = (i32) -> i32 native
-    ; check: sig0 = signature(i32 [%x10]) -> i32 [%x10]
+    ; check: sig0 = (i32 [%x10]) -> i32 [%x10] native
 
-    sig1 = signature(i64) -> b1
+    sig1 = (i64) -> b1 native
-    ; check: sig1 = signature(i32 [%x10], i32 [%x11]) -> b1 [%x10]
+    ; check: sig1 = (i32 [%x10], i32 [%x11]) -> b1 [%x10] native
 
     ; The i64 argument must go in an even-odd register pair.
-    sig2 = signature(f32, i64) -> f64
+    sig2 = (f32, i64) -> f64 native
-    ; check: sig2 = signature(f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10]
+    ; check: sig2 = (f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10] native
 
     ; Spilling into the stack args.
-    sig3 = signature(f64, f64, f64, f64, f64, f64, f64, i64) -> f64
+    sig3 = (f64, f64, f64, f64, f64, f64, f64, i64) -> f64 native
-    ; check: sig3 = signature(f64 [%f10], f64 [%f11], f64 [%f12], f64 [%f13], f64 [%f14], f64 [%f15], f64 [%f16], i32 [0], i32 [4]) -> f64 [%f10]
+    ; check: sig3 = (f64 [%f10], f64 [%f11], f64 [%f12], f64 [%f13], f64 [%f14], f64 [%f15], f64 [%f16], i32 [0], i32 [4]) -> f64 [%f10] native
 
     ; Splitting vectors.
-    sig4 = signature(i32x4)
+    sig4 = (i32x4) native
-    ; check: sig4 = signature(i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13])
+    ; check: sig4 = (i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13]) native
 
     ; Splitting vectors, then splitting ints.
-    sig5 = signature(i64x4)
+    sig5 = (i64x4) native
-    ; check: sig5 = signature(i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13], i32 [%x14], i32 [%x15], i32 [%x16], i32 [%x17])
+    ; check: sig5 = (i32 [%x10], i32 [%x11], i32 [%x12], i32 [%x13], i32 [%x14], i32 [%x15], i32 [%x16], i32 [%x17]) native
 
 ebb0:
     return

cranelift/filetests/isa/riscv/binary32.cton

@@ -4,7 +4,7 @@ isa riscv
 
 function %RV32I(i32 link [%x1]) -> i32 link [%x1] {
     fn0 = function %foo()
-    sig0 = signature()
+    sig0 = ()
 
 ebb0(v9999: i32):
     [-,%x10]            v1 = iconst.i32 1

cranelift/filetests/isa/riscv/legalize-abi.cton

@@ -106,7 +106,7 @@ ebb0(v0: i64x4):
 }
 
 function %indirect(i32) {
-    sig1 = signature()
+    sig1 = () native
 ebb0(v0: i32):
     call_indirect sig1, v0()
     return
@@ -114,7 +114,7 @@ ebb0(v0: i32):
 
 ; The first argument to call_indirect doesn't get altered.
 function %indirect_arg(i32, f32x2) {
-    sig1 = signature(f32x2)
+    sig1 = (f32x2) native
 ebb0(v0: i32, v1: f32x2):
     call_indirect sig1, v0(v1)
     ; check: call_indirect $sig1, $v0($V, $V)

cranelift/filetests/isa/riscv/parse-encoding.cton

@@ -3,32 +3,32 @@ 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] {
+    ; check: function %parse_encoding(i32 [%x5], i32 link [%x1]) -> i32 [%x10], i32 link [%x1] native {
 
-    sig0 = signature(i32 [%x10]) -> i32 [%x10]
+    sig0 = (i32 [%x10]) -> i32 [%x10] native
-    ; check: sig0 = signature(i32 [%x10]) -> i32 [%x10]
+    ; check: sig0 = (i32 [%x10]) -> i32 [%x10] native
 
-    sig1 = signature(i32 [%x10], i32 [%x11]) -> b1 [%x10]
+    sig1 = (i32 [%x10], i32 [%x11]) -> b1 [%x10] native
-    ; check: sig1 = signature(i32 [%x10], i32 [%x11]) -> b1 [%x10]
+    ; check: sig1 = (i32 [%x10], i32 [%x11]) -> b1 [%x10] native
 
-    sig2 = signature(f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10]
+    sig2 = (f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10] native
-    ; check: sig2 = signature(f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10]
+    ; check: sig2 = (f32 [%f10], i32 [%x12], i32 [%x13]) -> f64 [%f10] native
 
     ; Arguments on stack where not necessary
-    sig3 = signature(f64 [%f10], i32 [0], i32 [4]) -> f64 [%f10]
+    sig3 = (f64 [%f10], i32 [0], i32 [4]) -> f64 [%f10] native
-    ; check: sig3 = signature(f64 [%f10], i32 [0], i32 [4]) -> f64 [%f10]
+    ; check: sig3 = (f64 [%f10], i32 [0], i32 [4]) -> f64 [%f10] native
 
     ; Stack argument before register argument
-    sig4 = signature(f32 [72], i32 [%x10])
+    sig4 = (f32 [72], i32 [%x10]) native
-    ; check: sig4 = signature(f32 [72], i32 [%x10])
+    ; check: sig4 = (f32 [72], i32 [%x10]) native
 
     ; Return value on stack
-    sig5 = signature() -> f32 [0]
+    sig5 = () -> f32 [0] native
-    ; check: sig5 = signature() -> f32 [0]
+    ; check: sig5 = () -> f32 [0] native
 
     ; function + signature
-    fn15 = function %bar(i32 [%x10]) -> b1 [%x10]
+    fn15 = function %bar(i32 [%x10]) -> b1 [%x10] native
-    ; check: sig6 = signature(i32 [%x10]) -> b1 [%x10]
+    ; check: sig6 = (i32 [%x10]) -> b1 [%x10] native
     ; nextln: fn0 = sig6 %bar
 
 ebb0(v0: i32):

cranelift/filetests/licm/basic.cton

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

cranelift/filetests/licm/complex.cton

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

cranelift/filetests/parser/branch.cton

@@ -9,7 +9,7 @@ ebb0:
 ebb1:
     jump ebb0()
 }
-; sameln: function %minimal() {
+; sameln: function %minimal() native {
 ; nextln: ebb0:
 ; nextln:     jump ebb1
 ; nextln: 
@@ -25,7 +25,7 @@ ebb0(v90: i32):
 ebb1(v91: i32):
     jump ebb0(v91)
 }
-; sameln: function %onearg(i32) {
+; sameln: function %onearg(i32) native {
 ; nextln: ebb0($v90: i32):
 ; nextln:     jump ebb1($v90)
 ; nextln: 
@@ -41,7 +41,7 @@ ebb0(v90: i32, v91: f32):
 ebb1(v92: i32, v93: f32):
     jump ebb0(v92, v93)
 }
-; sameln: function %twoargs(i32, f32) {
+; sameln: function %twoargs(i32, f32) native {
 ; nextln: ebb0($v90: i32, $v91: f32):
 ; nextln:     jump ebb1($v90, $v91)
 ; nextln: 
@@ -57,7 +57,7 @@ ebb0(v90: i32):
 ebb1:
     brnz v90, ebb1()
 }
-; sameln: function %minimal(i32) {
+; sameln: function %minimal(i32) native {
 ; nextln: ebb0($v90: i32):
 ; nextln:     brz $v90, ebb1
 ; nextln: 
@@ -72,7 +72,7 @@ ebb0(v90: i32, v91: f32):
 ebb1(v92: i32, v93: f32):
     brnz v90, ebb0(v92, v93)
 }
-; sameln: function %twoargs(i32, f32) {
+; sameln: function %twoargs(i32, f32) native {
 ; nextln: ebb0($v90: i32, $v91: f32):
 ; nextln:     brz $v90, ebb1($v90, $v91)
 ; nextln: 
@@ -94,7 +94,7 @@ ebb30:
 ebb40:
     trap
 }
-; sameln: function %jumptable(i32) {
+; sameln: function %jumptable(i32) native {
 ; nextln:     jt0 = jump_table 0
 ; nextln:     jt1 = jump_table 0, 0, ebb0, ebb3, ebb1, ebb2
 ; nextln: 

cranelift/filetests/parser/call.cton

@@ -5,18 +5,18 @@ function %mini() {
 ebb1:
     return
 }
-; sameln: function %mini() {
+; sameln: function %mini() native {
 ; nextln: ebb0:
 ; nextln:     return
 ; nextln: }
 
-function %r1() -> i32, f32 {
+function %r1() -> i32, f32 spiderwasm {
 ebb1:
     v1 = iconst.i32 3
     v2 = f32const 0.0
     return v1, v2
 }
-; sameln: function %r1() -> i32, f32 {
+; sameln: function %r1() -> i32, f32 spiderwasm {
 ; nextln: ebb0:
 ; nextln:     $v1 = iconst.i32 3
 ; nextln:     $v2 = f32const 0.0
@@ -24,15 +24,15 @@ ebb1:
 ; nextln: }
 
 function %signatures() {
-    sig10 = signature()
+    sig10 = ()
-    sig11 = signature(i32, f64) -> i32, b1
+    sig11 = (i32, f64) -> i32, b1 spiderwasm
     fn5 = sig11 %foo
     fn8 = function %bar(i32) -> b1
 }
-; sameln: function %signatures() {
+; sameln: function %signatures() native {
-; nextln:     $sig10 = signature()
+; nextln:     $sig10 = () native
-; nextln:     $sig11 = signature(i32, f64) -> i32, b1
+; nextln:     $sig11 = (i32, f64) -> i32, b1 spiderwasm
-; nextln:     sig2 = signature(i32) -> b1
+; nextln:     sig2 = (i32) -> b1 native
 ; nextln:     $fn5 = $sig11 %foo
 ; nextln:     $fn8 = sig2 %bar
 ; nextln: }
@@ -54,9 +54,9 @@ ebb0:
 ; check: return
 
 function %indirect(i64) {
-    sig0 = signature(i64)
+    sig0 = (i64)
-    sig1 = signature() -> i32
+    sig1 = () -> i32
-    sig2 = signature() -> i32, f32
+    sig2 = () -> i32, f32
 
 ebb0(v0: i64):
     v1 = call_indirect sig1, v0()
@@ -74,7 +74,7 @@ function %special1(i32 sret, i32 fp, i32 csr, i32 link) -> i32 link, i32 fp, i32
 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 native {
 ; check: ebb0($v1: i32, $v2: i32, $v3: i32, $v4: i32):
 ; check:     return $v4, $v2, $v3, $v1
 ; check: }

cranelift/filetests/parser/instruction_encoding.cton

@@ -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) native {
 ; nextln: $ebb1($v0: i32, $v1: i32):
 ; nextln:     [-,-]$WS $v2 = iadd $v0, $v1
 ; nextln:     [-]$WS trap

cranelift/filetests/parser/keywords.cton

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

cranelift/filetests/parser/rewrite.cton

@@ -15,7 +15,7 @@ ebb100(v20: i32):
     v9200 = f64const 0x4.0p0
     trap
 }
-; sameln: function %defs() {
+; sameln: function %defs() native {
 ; nextln: $ebb100($v20: i32):
 ; nextln:     $v1000 = iconst.i32x8 5
 ; nextln:     $v9200 = f64const 0x1.0000000000000p2
@@ -29,7 +29,7 @@ ebb100(v20: i32):
     v200 = iadd v20, v1000
     jump ebb100(v1000)
 }
-; sameln: function %use_value() {
+; sameln: function %use_value() native {
 ; nextln: ebb0($v20: i32):
 ; nextln:     $v1000 = iadd_imm $v20, 5
 ; nextln:     $v200 = iadd $v20, $v1000

cranelift/filetests/parser/tiny.cton

@@ -5,7 +5,7 @@ function %minimal() {
 ebb0:
     trap
 }
-; sameln: function %minimal() {
+; sameln: function %minimal() native {
 ; nextln: ebb0:
 ; nextln:     trap
 ; nextln: }
@@ -18,7 +18,7 @@ ebb0:
     v1 = iconst.i8 6
     v2 = ishl v0, v1
 }
-; sameln: function %ivalues() {
+; sameln: function %ivalues() native {
 ; nextln: ebb0:
 ; nextln:     $v0 = iconst.i32 2
 ; nextln:     $v1 = iconst.i8 6
@@ -34,7 +34,7 @@ ebb0:
     v2 = bextend.b32 v1
     v3 = bxor v0, v2
 }
-; sameln: function %bvalues() {
+; sameln: function %bvalues() native {
 ; nextln: ebb0:
 ; nextln:     $v0 = bconst.b32 true
 ; nextln:     $v1 = bconst.b8 false
@@ -47,7 +47,7 @@ function %select() {
 ebb0(v90: i32, v91: i32, v92: b1):
     v0 = select v92, v90, v91
 }
-; sameln: function %select() {
+; sameln: function %select() native {
 ; nextln: ebb0($v90: i32, $v91: i32, $v92: b1):
 ; nextln:     $v0 = select $v92, $v90, $v91
 ; nextln: }
@@ -59,7 +59,7 @@ ebb0:
     v1 = extractlane v0, 3
     v2 = insertlane v0, 1, v1
 }
-; sameln: function %lanes() {
+; sameln: function %lanes() native {
 ; nextln: ebb0:
 ; nextln:     $v0 = iconst.i32x4 2
 ; nextln:     $v1 = extractlane $v0, 3
@@ -75,7 +75,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) native {
 ; nextln: ebb0($v90: i32, $v91: i32):
 ; nextln:     $v0 = icmp eq $v90, $v91
 ; nextln:     $v1 = icmp ult $v90, $v91
@@ -91,7 +91,7 @@ ebb0(v90: f32, v91: f32):
     v1 = fcmp uno v90, v91
     v2 = fcmp lt v90, v91
 }
-; sameln: function %fcmp(f32, f32) {
+; sameln: function %fcmp(f32, f32) native {
 ; nextln: ebb0($v90: f32, $v91: f32):
 ; nextln:     $v0 = fcmp eq $v90, $v91
 ; nextln:     $v1 = fcmp uno $v90, $v91
@@ -105,7 +105,7 @@ ebb0(v90: i32, v91: f32):
     v0 = bitcast.i8x4 v90
     v1 = bitcast.i32 v91
 }
-; sameln: function %bitcast(i32, f32) {
+; sameln: function %bitcast(i32, f32) native {
 ; nextln: ebb0($v90: i32, $v91: f32):
 ; nextln:     $v0 = bitcast.i8x4 $v90
 ; nextln:     $v1 = bitcast.i32 $v91
@@ -124,7 +124,7 @@ ebb0:
     stack_store v1, ss10+2
     stack_store v2, ss2
 }
-; sameln: function %stack() {
+; sameln: function %stack() native {
 ; nextln:    $ss10 = spill_slot 8
 ; nextln:    $ss2 = local 4
 ; nextln:    $ss3 = incoming_arg 4, offset 8
@@ -144,7 +144,7 @@ ebb0(v1: i32):
     v3 = heap_load.f32 v1+12
     heap_store v3, v1
 }
-; sameln: function %heap(i32) {
+; sameln: function %heap(i32) native {
 ; nextln: ebb0($v1: i32):
 ; nextln:     $v2 = heap_load.f32 $v1
 ; nextln:     $v3 = heap_load.f32 $v1+12
@@ -164,7 +164,7 @@ ebb0(v1: i32):
     store aligned v3, v1+12
     store notrap aligned v3, v1-12
 }
-; sameln: function %memory(i32) {
+; sameln: function %memory(i32) native {
 ; nextln: ebb0($v1: i32):
 ; nextln:     $v2 = load.i64 $v1
 ; nextln:     $v3 = load.i64 aligned $v1
@@ -185,7 +185,7 @@ ebb0(v1: i32):
     regmove v1, %20 -> %10
     return
 }
-; sameln: function %diversion(i32) {
+; sameln: function %diversion(i32) native {
 ; nextln: ebb0($v1: i32):
 ; nextln:     regmove $v1, %10 -> %20
 ; nextln:     regmove $v1, %20 -> %10

cranelift/filetests/regalloc/spill.cton

@@ -93,7 +93,7 @@ ebb0(v0: i32):
 
 ; The same value used as indirect callee and argument.
 function %doubleuse_icall1(i32) {
-    sig0 = signature(i32)
+    sig0 = (i32) native
 ebb0(v0: i32):
     ; not:copy
     call_indirect sig0, v0(v0)
@@ -102,7 +102,7 @@ ebb0(v0: i32):
 
 ; The same value used as indirect callee and two arguments.
 function %doubleuse_icall2(i32) {
-    sig0 = signature(i32, i32)
+    sig0 = (i32, i32) native
 ebb0(v0: i32):
     ; check: $(c=$V) = copy $v0
     call_indirect sig0, v0(v0, v0)

cranelift/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) native {
             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) native {
             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) native {
             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) native {
             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) native {
             ebb0(v0: i32):
                 brz v0, ebb1
                 jump ebb2

lib/cretonne/src/ir/extfunc.rs

@@ -25,6 +25,9 @@ pub struct Signature {
     /// Types returned from the function.
     pub return_types: Vec<ArgumentType>,
 
+    /// Calling convention.
+    pub call_conv: CallConv,
+
     /// When the signature has been legalized to a specific ISA, this holds the size of the
     /// argument array on the stack. Before legalization, this is `None`.
     ///
@@ -35,10 +38,11 @@ pub struct Signature {
 
 impl Signature {
     /// Create a new blank signature.
-    pub fn new() -> Signature {
+    pub fn new(call_conv: CallConv) -> Signature {
         Signature {
             argument_types: Vec::new(),
             return_types: Vec::new(),
+            call_conv,
             argument_bytes: None,
         }
     }
@@ -94,7 +98,7 @@ impl<'a> fmt::Display for DisplaySignature<'a> {
             write!(f, " -> ")?;
             write_list(f, &self.0.return_types, self.1)?;
         }
-        Ok(())
+        write!(f, " {}", self.0.call_conv)
     }
 }
 
@@ -278,6 +282,46 @@ impl fmt::Display for ExtFuncData {
     }
 }
 
+/// A Calling convention.
+///
+/// A function's calling convention determines exactly how arguments and return values are passed,
+/// and how stack frames are managed. Since all of these details depend on both the instruction set
+/// architecture and possibly the operating system, a function's calling convention is only fully
+/// determined by a `(TargetIsa, CallConv)` tuple.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CallConv {
+    /// The C calling convention.
+    ///
+    /// This is the native calling convention that a C compiler would use on the platform.
+    Native,
+
+    /// A JIT-compiled WebAssembly function in the SpiderMonkey VM.
+    SpiderWASM,
+}
+
+impl fmt::Display for CallConv {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use self::CallConv::*;
+        f.write_str(match *self {
+                        Native => "native",
+                        SpiderWASM => "spiderwasm",
+                    })
+    }
+}
+
+impl FromStr for CallConv {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use self::CallConv::*;
+        match s {
+            "native" => Ok(Native),
+            "spiderwasm" => Ok(SpiderWASM),
+            _ => Err(()),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -306,19 +350,26 @@ mod tests {
         }
     }
 
+    #[test]
+    fn call_conv() {
+        for &cc in &[CallConv::Native, CallConv::SpiderWASM] {
+            assert_eq!(Ok(cc), cc.to_string().parse())
+        }
+    }
+
     #[test]
     fn signatures() {
-        let mut sig = Signature::new();
+        let mut sig = Signature::new(CallConv::SpiderWASM);
-        assert_eq!(sig.to_string(), "()");
+        assert_eq!(sig.to_string(), "() spiderwasm");
         sig.argument_types.push(ArgumentType::new(I32));
-        assert_eq!(sig.to_string(), "(i32)");
+        assert_eq!(sig.to_string(), "(i32) spiderwasm");
         sig.return_types.push(ArgumentType::new(F32));
-        assert_eq!(sig.to_string(), "(i32) -> f32");
+        assert_eq!(sig.to_string(), "(i32) -> f32 spiderwasm");
         sig.argument_types
             .push(ArgumentType::new(I32.by(4).unwrap()));
-        assert_eq!(sig.to_string(), "(i32, i32x4) -> f32");
+        assert_eq!(sig.to_string(), "(i32, i32x4) -> f32 spiderwasm");
         sig.return_types.push(ArgumentType::new(B8));
-        assert_eq!(sig.to_string(), "(i32, i32x4) -> f32, b8");
+        assert_eq!(sig.to_string(), "(i32, i32x4) -> f32, b8 spiderwasm");
 
         // Test the offset computation algorithm.
         assert_eq!(sig.argument_bytes, None);
@@ -332,6 +383,7 @@ mod tests {
         assert_eq!(sig.argument_bytes, Some(28));
 
         // Writing ABI-annotated signatures.
-        assert_eq!(sig.to_string(), "(i32 [24], i32x4 [8]) -> f32, b8");
+        assert_eq!(sig.to_string(),
+                   "(i32 [24], i32x4 [8]) -> f32, b8 spiderwasm");
     }
 }

lib/cretonne/src/ir/function.rs

@@ -4,7 +4,7 @@
 //! instructions.
 
 use entity_map::{EntityMap, PrimaryEntityData};
-use ir::{FunctionName, Signature, JumpTableData, DataFlowGraph, Layout};
+use ir::{FunctionName, CallConv, Signature, JumpTableData, DataFlowGraph, Layout};
 use ir::{JumpTables, InstEncodings, ValueLocations, StackSlots, EbbOffsets};
 use isa::TargetIsa;
 use std::fmt;
@@ -67,9 +67,9 @@ impl Function {
         }
     }
 
-    /// Create a new empty, anonymous function.
+    /// Create a new empty, anonymous function with a native calling convention.
     pub fn new() -> Function {
-        Self::with_name_signature(FunctionName::default(), Signature::new())
+        Self::with_name_signature(FunctionName::default(), Signature::new(CallConv::Native))
     }
 
     /// Return an object that can display this function with correct ISA-specific annotations.

lib/cretonne/src/ir/mod.rs

@@ -18,7 +18,8 @@ mod progpoint;
 mod valueloc;
 
 pub use ir::funcname::FunctionName;
-pub use ir::extfunc::{Signature, ArgumentType, ArgumentExtension, ArgumentPurpose, ExtFuncData};
+pub use ir::extfunc::{Signature, CallConv, ArgumentType, ArgumentExtension, ArgumentPurpose,
+                      ExtFuncData};
 pub use ir::types::Type;
 pub use ir::entities::{Ebb, Inst, Value, StackSlot, JumpTable, FuncRef, SigRef};
 pub use ir::instructions::{Opcode, InstructionData, VariableArgs, ValueList, ValueListPool};

lib/cretonne/src/write.rs

@@ -54,7 +54,7 @@ fn write_preamble(w: &mut Write,
     for sig in func.dfg.signatures.keys() {
         any = true;
         writeln!(w,
-                 "    {} = signature{}",
+                 "    {} = {}",
                  sig,
                  func.dfg.signatures[sig].display(regs))?;
     }
@@ -366,26 +366,27 @@ mod tests {
     #[test]
     fn basic() {
         let mut f = Function::new();
-        assert_eq!(f.to_string(), "function %() {\n}\n");
+        assert_eq!(f.to_string(), "function %() native {\n}\n");
 
         f.name = FunctionName::new("foo");
-        assert_eq!(f.to_string(), "function %foo() {\n}\n");
+        assert_eq!(f.to_string(), "function %foo() native {\n}\n");
 
         f.stack_slots
             .push(StackSlotData::new(StackSlotKind::Local, 4));
-        assert_eq!(f.to_string(), "function %foo() {\n    ss0 = local 4\n}\n");
+        assert_eq!(f.to_string(),
+                   "function %foo() native {\n    ss0 = local 4\n}\n");
 
         let ebb = f.dfg.make_ebb();
         f.layout.append_ebb(ebb);
         assert_eq!(f.to_string(),
-                   "function %foo() {\n    ss0 = local 4\n\nebb0:\n}\n");
+                   "function %foo() native {\n    ss0 = local 4\n\nebb0:\n}\n");
 
         f.dfg.append_ebb_arg(ebb, types::I8);
         assert_eq!(f.to_string(),
-                   "function %foo() {\n    ss0 = local 4\n\nebb0(v0: i8):\n}\n");
+                   "function %foo() native {\n    ss0 = local 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 = local 4\n\nebb0(v0: i8, v1: f32x4):\n}\n");
+                   "function %foo() native {\n    ss0 = local 4\n\nebb0(v0: i8, v1: f32x4):\n}\n");
     }
 }

lib/frontend/src/frontend.rs

@@ -572,7 +572,7 @@ impl<'a, Variable> FunctionBuilder<'a, Variable>
 mod tests {
 
     use cretonne::entity_ref::EntityRef;
-    use cretonne::ir::{FunctionName, Function, Signature, ArgumentType, InstBuilder};
+    use cretonne::ir::{FunctionName, Function, CallConv, Signature, ArgumentType, InstBuilder};
     use cretonne::ir::types::*;
     use frontend::{ILBuilder, FunctionBuilder};
     use cretonne::verifier::verify_function;
@@ -600,7 +600,7 @@ mod tests {
 
     #[test]
     fn sample_function() {
-        let mut sig = Signature::new();
+        let mut sig = Signature::new(CallConv::Native);
         sig.return_types.push(ArgumentType::new(I32));
         sig.argument_types.push(ArgumentType::new(I32));
 

lib/frontend/src/lib.rs

@@ -36,7 +36,7 @@
 //! extern crate cton_frontend;
 //!
 //! use cretonne::entity_ref::EntityRef;
-//! use cretonne::ir::{FunctionName, Function, Signature, ArgumentType, InstBuilder};
+//! use cretonne::ir::{FunctionName, CallConv, Function, Signature, ArgumentType, InstBuilder};
 //! use cretonne::ir::types::*;
 //! use cton_frontend::{ILBuilder, FunctionBuilder};
 //! use cretonne::verifier::verify_function;
@@ -62,7 +62,7 @@
 //! }
 //!
 //! fn main() {
-//!     let mut sig = Signature::new();
+//!     let mut sig = Signature::new(CallConv::Native);
 //!     sig.return_types.push(ArgumentType::new(I32));
 //!     sig.argument_types.push(ArgumentType::new(I32));
 //!     let mut il_builder = ILBuilder::<Variable>::new();

lib/reader/src/parser.rs

@@ -9,9 +9,9 @@ use std::collections::HashMap;
 use std::str::FromStr;
 use std::{u16, u32};
 use std::mem;
-use cretonne::ir::{Function, Ebb, Opcode, Value, Type, FunctionName, StackSlotData, JumpTable,
+use cretonne::ir::{Function, Ebb, Opcode, Value, Type, FunctionName, CallConv, StackSlotData,
-                   JumpTableData, Signature, ArgumentType, ArgumentExtension, ExtFuncData, SigRef,
+                   JumpTable, JumpTableData, Signature, ArgumentType, ArgumentExtension,
-                   FuncRef, StackSlot, ValueLoc, ArgumentLoc, MemFlags};
+                   ExtFuncData, SigRef, FuncRef, StackSlot, ValueLoc, ArgumentLoc, MemFlags};
 use cretonne::ir::types::VOID;
 use cretonne::ir::immediates::{Imm64, Offset32, Uoffset32, Ieee32, Ieee64};
 use cretonne::ir::entities::AnyEntity;
@@ -767,13 +767,14 @@ impl<'a> Parser<'a> {
 
     // Parse a function signature.
     //
-    // signature ::=  * "(" [arglist] ")" ["->" retlist] [call_conv]
+    // signature ::=  * "(" [arglist] ")" ["->" retlist] [callconv]
     //
     fn parse_signature(&mut self, unique_isa: Option<&TargetIsa>) -> Result<Signature> {
-        let mut sig = Signature::new();
+        // Calling convention defaults to `native`, but can be changed.
+        let mut sig = Signature::new(CallConv::Native);
 
         self.match_token(Token::LPar, "expected function signature: ( args... )")?;
-        // signature ::=  "(" * [arglist] ")" ["->" retlist] [call_conv]
+        // signature ::=  "(" * [arglist] ")" ["->" retlist] [callconv]
         if self.token() != Some(Token::RPar) {
             sig.argument_types = self.parse_argument_list(unique_isa)?;
         }
@@ -782,12 +783,21 @@ impl<'a> Parser<'a> {
             sig.return_types = self.parse_argument_list(unique_isa)?;
         }
 
+        // The calling convention is optional.
+        if let Some(Token::Identifier(text)) = self.token() {
+            match text.parse() {
+                Ok(cc) => {
+                    self.consume();
+                    sig.call_conv = cc;
+                }
+                _ => return err!(self.loc, "unknown calling convention: {}", text),
+            }
+        }
+
         if sig.argument_types.iter().all(|a| a.location.is_assigned()) {
             sig.compute_argument_bytes();
         }
 
-        // TBD: calling convention.
-
         Ok(sig)
     }
 
@@ -951,12 +961,11 @@ impl<'a> Parser<'a> {
 
     // Parse a signature decl.
     //
-    // signature-decl ::= SigRef(sigref) "=" "signature" signature
+    // signature-decl ::= SigRef(sigref) "=" signature
     //
     fn parse_signature_decl(&mut self, unique_isa: Option<&TargetIsa>) -> Result<(u32, Signature)> {
         let number = self.match_sig("expected signature number: sig«n»")?;
         self.match_token(Token::Equal, "expected '=' in signature decl")?;
-        self.match_identifier("signature", "expected 'signature'")?;
         let data = self.parse_signature(unique_isa)?;
         Ok((number, data))
     }
@@ -1755,7 +1764,7 @@ impl<'a> Parser<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cretonne::ir::{ArgumentExtension, ArgumentPurpose};
+    use cretonne::ir::{CallConv, ArgumentExtension, ArgumentPurpose};
     use cretonne::ir::types;
     use cretonne::ir::StackSlotKind;
     use cretonne::ir::entities::AnyEntity;
@@ -1777,7 +1786,7 @@ mod tests {
 
     #[test]
     fn aliases() {
-        let (func, details) = Parser::new("function %qux() {
+        let (func, details) = Parser::new("function %qux() native {
                                            ebb0:
                                              v4 = iconst.i8 6
                                              v3 -> v4
@@ -1801,15 +1810,26 @@ mod tests {
 
     #[test]
     fn signature() {
-        let sig = Parser::new("()").parse_signature(None).unwrap();
+        let sig = Parser::new("()native").parse_signature(None).unwrap();
         assert_eq!(sig.argument_types.len(), 0);
         assert_eq!(sig.return_types.len(), 0);
+        assert_eq!(sig.call_conv, CallConv::Native);
 
-        let sig2 = Parser::new("(i8 uext, f32, f64, i32 sret) -> i32 sext, f64")
+        let sig2 = Parser::new("(i8 uext, f32, f64, i32 sret) -> i32 sext, f64 spiderwasm")
             .parse_signature(None)
             .unwrap();
         assert_eq!(sig2.to_string(),
-                   "(i8 uext, f32, f64, i32 sret) -> i32 sext, f64");
+                   "(i8 uext, f32, f64, i32 sret) -> i32 sext, f64 spiderwasm");
+        assert_eq!(sig2.call_conv, CallConv::SpiderWASM);
+
+        // Old-style signature without a calling convention.
+        assert_eq!(Parser::new("()").parse_signature(None).unwrap().to_string(),
+                   "() native");
+        assert_eq!(Parser::new("() notacc")
+                       .parse_signature(None)
+                       .unwrap_err()
+                       .to_string(),
+                   "1: unknown calling convention: notacc");
 
         // `void` is not recognized as a type by the lexer. It should not appear in files.
         assert_eq!(Parser::new("() -> void")
@@ -1831,7 +1851,7 @@ mod tests {
 
     #[test]
     fn stack_slot_decl() {
-        let (func, _) = Parser::new("function %foo() {
+        let (func, _) = Parser::new("function %foo() native {
                                        ss3 = incoming_arg 13
                                        ss1 = spill_slot 1
                                      }")
@@ -1850,7 +1870,7 @@ mod tests {
         assert_eq!(iter.next(), None);
 
         // Catch duplicate definitions.
-        assert_eq!(Parser::new("function %bar() {
+        assert_eq!(Parser::new("function %bar() native {
                                     ss1  = spill_slot 13
                                     ss1  = spill_slot 1
                                 }")
@@ -1862,7 +1882,7 @@ mod tests {
 
     #[test]
     fn ebb_header() {
-        let (func, _) = Parser::new("function %ebbs() {
+        let (func, _) = Parser::new("function %ebbs() native {
                                      ebb0:
                                      ebb4(v3: i32):
                                      }")
@@ -1884,7 +1904,7 @@ mod tests {
     #[test]
     fn comments() {
         let (func, Details { comments, .. }) = Parser::new("; before
-                         function %comment() { ; decl
+                         function %comment() native { ; decl
                             ss10  = outgoing_arg 13 ; stackslot.
                             ; Still stackslot.
                             jt10 = jump_table ebb0
@@ -1924,7 +1944,7 @@ mod tests {
                              test verify
                              set enable_float=false
                              ; still preamble
-                             function %comment() {}")
+                             function %comment() native {}")
                 .unwrap();
         assert_eq!(tf.commands.len(), 2);
         assert_eq!(tf.commands[0].command, "cfg");
@@ -1947,17 +1967,17 @@ mod tests {
     #[cfg(build_riscv)]
     fn isa_spec() {
         assert!(parse_test("isa
-                            function %foo() {}")
+                            function %foo() native {}")
                         .is_err());
 
         assert!(parse_test("isa riscv
                             set enable_float=false
-                            function %foo() {}")
+                            function %foo() native {}")
                         .is_err());
 
         match parse_test("set enable_float=false
                           isa riscv
-                          function %foo() {}")
+                          function %foo() native {}")
                       .unwrap()
                       .isa_spec {
             IsaSpec::None(_) => panic!("Expected some ISA"),
@@ -1971,7 +1991,7 @@ mod tests {
     #[test]
     fn binary_function_name() {
         // Valid characters in the name.
-        let func = Parser::new("function #1234567890AbCdEf() {
+        let func = Parser::new("function #1234567890AbCdEf() native {
                                            ebb0:
                                              trap
                                            }")
@@ -1981,21 +2001,21 @@ mod tests {
         assert_eq!(func.name.to_string(), "#1234567890abcdef");
 
         // Invalid characters in the name.
-        let mut parser = Parser::new("function #12ww() {
+        let mut parser = Parser::new("function #12ww() native {
                                            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() {
+        let mut parser = Parser::new("function #1() native {
                                            ebb0:
                                              trap
                                            }");
         assert!(parser.parse_function(None).is_err());
 
         // Empty binary function name should be valid.
-        let func = Parser::new("function #() {
+        let func = Parser::new("function #() native {
                                            ebb0:
                                              trap
                                            }")