maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/test/CodeGen/WebAssembly/call.ll

128 lines
3.3 KiB
LLVM
Raw Normal View History

call llvm-svn: 245882
2015-08-25 05:59:51 +08:00
; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test that basic call operations assemble as expected.
[WebAssembly] Update target datalayout strings. llvm-svn: 247187
2015-09-10 04:54:31 +08:00
target datalayout = "e-p:32:32-i64:64-n32:64-S128"
call llvm-svn: 245882
2015-08-25 05:59:51 +08:00
target triple = "wasm32-unknown-unknown"
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
declare i32 @i32_nullary()
declare i32 @i32_unary(i32)
[WebAssembly] Fix lowering of calls with more than one argument. llvm-svn: 247118
2015-09-09 09:52:45 +08:00
declare i32 @i32_binary(i32, i32)
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
declare i64 @i64_nullary()
declare float @float_nullary()
declare double @double_nullary()
[WebAssembly] Implement calls with void return types. llvm-svn: 247158
2015-09-10 00:13:47 +08:00
declare void @void_nullary()
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_i32_nullary:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Don't special-case call operand order. With the '=' suffix now indicating which operands are output operands, it's no longer as important to distinguish between a call's inputs and its outputs using operand ordering, so we can go back to printing them in the normal order. llvm-svn: 253925
2015-11-24 06:04:06 +08:00
; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i32_nullary{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return $pop[[NUM]]{{$}}
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
define i32 @call_i32_nullary() {
%r = call i32 @i32_nullary()
ret i32 %r
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_i64_nullary:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .result i64{{$}}
[WebAssembly] Don't special-case call operand order. With the '=' suffix now indicating which operands are output operands, it's no longer as important to distinguish between a call's inputs and its outputs using operand ordering, so we can go back to printing them in the normal order. llvm-svn: 253925
2015-11-24 06:04:06 +08:00
; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i64_nullary{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return $pop[[NUM]]{{$}}
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
define i64 @call_i64_nullary() {
%r = call i64 @i64_nullary()
ret i64 %r
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_float_nullary:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .result f32{{$}}
[WebAssembly] Don't special-case call operand order. With the '=' suffix now indicating which operands are output operands, it's no longer as important to distinguish between a call's inputs and its outputs using operand ordering, so we can go back to printing them in the normal order. llvm-svn: 253925
2015-11-24 06:04:06 +08:00
; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, float_nullary{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return $pop[[NUM]]{{$}}
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
define float @call_float_nullary() {
%r = call float @float_nullary()
ret float %r
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_double_nullary:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .result f64{{$}}
[WebAssembly] Don't special-case call operand order. With the '=' suffix now indicating which operands are output operands, it's no longer as important to distinguish between a call's inputs and its outputs using operand ordering, so we can go back to printing them in the normal order. llvm-svn: 253925
2015-11-24 06:04:06 +08:00
; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, double_nullary{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return $pop[[NUM]]{{$}}
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
define double @call_double_nullary() {
%r = call double @double_nullary()
ret double %r
call llvm-svn: 245882
2015-08-25 05:59:51 +08:00
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_void_nullary:
[WebAssembly] Reapply r252858, with svn add for the new file. Switch to MC for instruction printing. This encompasses several changes which are all interconnected: - Use the MC framework for printing almost all instructions. - AsmStrings are now live. - This introduces an indirection between LLVM vregs and WebAssembly registers, and a new pass, WebAssemblyRegNumbering, for computing a basic the mapping. This addresses some basic issues with argument registers and unused registers. - The way ARGUMENT instructions are handled no longer generates redundant get_local+set_local for every argument. This also changes the assembly syntax somewhat; most notably, MC's printing does not use sigils on label names, so those are no longer present, and push/pop now have a sigil to keep them unambiguous. The usage of set_local/get_local/$push/$pop will continue to evolve significantly. This patch is just one step of a larger change. llvm-svn: 252910
2015-11-13 01:04:33 +08:00
; CHECK-NEXT: call void_nullary{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return{{$}}
[WebAssembly] Implement calls with void return types. llvm-svn: 247158
2015-09-10 00:13:47 +08:00
define void @call_void_nullary() {
call void @void_nullary()
ret void
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_i32_unary:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Don't special-case call operand order. With the '=' suffix now indicating which operands are output operands, it's no longer as important to distinguish between a call's inputs and its outputs using operand ordering, so we can go back to printing them in the normal order. llvm-svn: 253925
2015-11-24 06:04:06 +08:00
; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i32_unary, $0{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return $pop[[NUM]]{{$}}
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
define i32 @call_i32_unary(i32 %a) {
%r = call i32 @i32_unary(i32 %a)
ret i32 %r
}
call llvm-svn: 245882
2015-08-25 05:59:51 +08:00
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_i32_binary:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .param i32, i32{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Don't special-case call operand order. With the '=' suffix now indicating which operands are output operands, it's no longer as important to distinguish between a call's inputs and its outputs using operand ordering, so we can go back to printing them in the normal order. llvm-svn: 253925
2015-11-24 06:04:06 +08:00
; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i32_binary, $0, $1{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return $pop[[NUM]]{{$}}
[WebAssembly] Fix lowering of calls with more than one argument. llvm-svn: 247118
2015-09-09 09:52:45 +08:00
define i32 @call_i32_binary(i32 %a, i32 %b) {
%r = call i32 @i32_binary(i32 %a, i32 %b)
ret i32 %r
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_indirect_void:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .param i32{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: call_indirect $0{{$}}
; CHECK-NEXT: return{{$}}
[WebAssembly] Support for direct call and call_indirect. llvm-svn: 248716
2015-09-29 00:22:39 +08:00
define void @call_indirect_void(void ()* %callee) {
call void %callee()
ret void
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: call_indirect_i32:
[WebAssembly] Emit .param, .result, and .local through MC. This eliminates one of the main remaining uses of EmitRawText. llvm-svn: 253878
2015-11-24 00:50:18 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Don't special-case call operand order. With the '=' suffix now indicating which operands are output operands, it's no longer as important to distinguish between a call's inputs and its outputs using operand ordering, so we can go back to printing them in the normal order. llvm-svn: 253925
2015-11-24 06:04:06 +08:00
; CHECK-NEXT: call_indirect $push[[NUM:[0-9]+]]=, $0{{$}}
[WebAssembly] Enable register coloring and register stackifying. This also takes the push/pop syntax another step forward, introducing stack slot numbers to make it easier to see how expressions are connected. For example, the value pushed in $push7 is popped in $pop7. And, this begins an experiment with making get_local and set_local implicit when an operation directly uses or defines a register. This greatly reduces clutter. If this experiment succeeds, it may make sense to do this for const instructions as well. And, this introduces more special code for ARGUMENTS; hopefully this code will soon be obviated by proper support for live-in virtual registers. llvm-svn: 253465
2015-11-19 00:12:01 +08:00
; CHECK-NEXT: return $pop[[NUM]]{{$}}
[WebAssembly] Support for direct call and call_indirect. llvm-svn: 248716
2015-09-29 00:22:39 +08:00
define i32 @call_indirect_i32(i32 ()* %callee) {
%t = call i32 %callee()
ret i32 %t
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: tail_call_void_nullary:
[WebAssembly] Reapply r252858, with svn add for the new file. Switch to MC for instruction printing. This encompasses several changes which are all interconnected: - Use the MC framework for printing almost all instructions. - AsmStrings are now live. - This introduces an indirection between LLVM vregs and WebAssembly registers, and a new pass, WebAssemblyRegNumbering, for computing a basic the mapping. This addresses some basic issues with argument registers and unused registers. - The way ARGUMENT instructions are handled no longer generates redundant get_local+set_local for every argument. This also changes the assembly syntax somewhat; most notably, MC's printing does not use sigils on label names, so those are no longer present, and push/pop now have a sigil to keep them unambiguous. The usage of set_local/get_local/$push/$pop will continue to evolve significantly. This patch is just one step of a larger change. llvm-svn: 252910
2015-11-13 01:04:33 +08:00
; CHECK-NEXT: call void_nullary{{$}}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-NEXT: return{{$}}
[WebAssembly] Support calls marked as "tail", fastcc, and coldcc. llvm-svn: 249184
2015-10-03 04:54:23 +08:00
define void @tail_call_void_nullary() {
tail call void @void_nullary()
ret void
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: fastcc_tail_call_void_nullary:
[WebAssembly] Reapply r252858, with svn add for the new file. Switch to MC for instruction printing. This encompasses several changes which are all interconnected: - Use the MC framework for printing almost all instructions. - AsmStrings are now live. - This introduces an indirection between LLVM vregs and WebAssembly registers, and a new pass, WebAssemblyRegNumbering, for computing a basic the mapping. This addresses some basic issues with argument registers and unused registers. - The way ARGUMENT instructions are handled no longer generates redundant get_local+set_local for every argument. This also changes the assembly syntax somewhat; most notably, MC's printing does not use sigils on label names, so those are no longer present, and push/pop now have a sigil to keep them unambiguous. The usage of set_local/get_local/$push/$pop will continue to evolve significantly. This patch is just one step of a larger change. llvm-svn: 252910
2015-11-13 01:04:33 +08:00
; CHECK-NEXT: call void_nullary{{$}}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-NEXT: return{{$}}
[WebAssembly] Support calls marked as "tail", fastcc, and coldcc. llvm-svn: 249184
2015-10-03 04:54:23 +08:00
define void @fastcc_tail_call_void_nullary() {
tail call fastcc void @void_nullary()
ret void
}
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-LABEL: coldcc_tail_call_void_nullary:
[WebAssembly] Reapply r252858, with svn add for the new file. Switch to MC for instruction printing. This encompasses several changes which are all interconnected: - Use the MC framework for printing almost all instructions. - AsmStrings are now live. - This introduces an indirection between LLVM vregs and WebAssembly registers, and a new pass, WebAssemblyRegNumbering, for computing a basic the mapping. This addresses some basic issues with argument registers and unused registers. - The way ARGUMENT instructions are handled no longer generates redundant get_local+set_local for every argument. This also changes the assembly syntax somewhat; most notably, MC's printing does not use sigils on label names, so those are no longer present, and push/pop now have a sigil to keep them unambiguous. The usage of set_local/get_local/$push/$pop will continue to evolve significantly. This patch is just one step of a larger change. llvm-svn: 252910
2015-11-13 01:04:33 +08:00
; CHECK-NEXT: call void_nullary
[WebAssembly] Switch to a more traditional assembly syntax This new syntax is built around putting each instruction on its own line in a "mnemonic op, op, op" like syntax. It also uses conventional data section directives like ".byte" and so on rather than requiring everything to be in hierarchical S-expression format. This is a more natural syntax for a ".s" file format from the perspective of LLVM MC and related tools, while remaining easy to translate into other forms as needed. llvm-svn: 249364
2015-10-06 08:27:55 +08:00
; CHECK-NEXT: return{{$}}
[WebAssembly] Support calls marked as "tail", fastcc, and coldcc. llvm-svn: 249184
2015-10-03 04:54:23 +08:00
define void @coldcc_tail_call_void_nullary() {
tail call coldcc void @void_nullary()
ret void
}
WebAssembly: Implement call Summary: Support function calls. Reviewers: sunfish, sunfishcode Subscribers: sunfishcode, jfb, llvm-commits Differential revision: http://reviews.llvm.org/D12219 llvm-svn: 245887
2015-08-25 06:16:48 +08:00
; FIXME test the following:
; - More argument combinations.
; - Tail call.
; - Interesting returns (struct, multiple).
; - Vararg.