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/conv.ll

256 lines
7.0 KiB
LLVM
Raw Normal View History

[WebAssembly] Optimize away return instructions using fallthroughs. This saves a small amount of code size, and is a first small step toward passing values on the stack across block boundaries. Differential Review: http://reviews.llvm.org/D20450 llvm-svn: 270294
2016-05-21 08:21:56 +08:00
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
[WebAssembly] Implement int64-to-int32 conversion. llvm-svn: 247649
2015-09-15 08:55:19 +08:00
; Test that basic conversion operations assemble as expected.
[WebAssembly] Add -m:e to the target triple. This enables ELF-style name mangling, which primarily means using ".L" for private symbols. llvm-svn: 257020
2016-01-07 11:19:23 +08:00
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
[WebAssembly] Implement int64-to-int32 conversion. llvm-svn: 247649
2015-09-15 08:55:19 +08:00
target triple = "wasm32-unknown-unknown"
[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: i32_wrap_i64:
; CHECK-NEXT: .param i64{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i32.wrap/i64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i32 @i32_wrap_i64(i64 %x) {
[WebAssembly] Implement int64-to-int32 conversion. llvm-svn: 247649
2015-09-15 08:55:19 +08:00
%a = trunc i64 %x to i32
ret i32 %a
}
[WebAssembly] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +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: i64_extend_s_i32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i64.extend_s/i32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i64 @i64_extend_s_i32(i32 %x) {
%a = sext i32 %x to i64
ret i64 %a
}
[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: i64_extend_u_i32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i64.extend_u/i32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i64 @i64_extend_u_i32(i32 %x) {
%a = zext i32 %x to i64
ret i64 %a
}
[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: i32_trunc_s_f32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f32{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i32.trunc_s/f32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i32 @i32_trunc_s_f32(float %x) {
%a = fptosi float %x to i32
ret i32 %a
}
[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: i32_trunc_u_f32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f32{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i32.trunc_u/f32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i32 @i32_trunc_u_f32(float %x) {
%a = fptoui float %x to i32
ret i32 %a
}
[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: i32_trunc_s_f64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f64{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i32.trunc_s/f64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i32 @i32_trunc_s_f64(double %x) {
%a = fptosi double %x to i32
ret i32 %a
}
[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: i32_trunc_u_f64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f64{{$}}
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i32.trunc_u/f64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i32 @i32_trunc_u_f64(double %x) {
%a = fptoui double %x to i32
ret i32 %a
}
[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: i64_trunc_s_f32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f32{{$}}
; CHECK-NEXT: .result i64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i64.trunc_s/f32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i64 @i64_trunc_s_f32(float %x) {
%a = fptosi float %x to i64
ret i64 %a
}
[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: i64_trunc_u_f32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f32{{$}}
; CHECK-NEXT: .result i64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i64.trunc_u/f32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i64 @i64_trunc_u_f32(float %x) {
%a = fptoui float %x to i64
ret i64 %a
}
[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: i64_trunc_s_f64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f64{{$}}
; CHECK-NEXT: .result i64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i64.trunc_s/f64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i64 @i64_trunc_s_f64(double %x) {
%a = fptosi double %x to i64
ret i64 %a
}
[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: i64_trunc_u_f64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f64{{$}}
; CHECK-NEXT: .result i64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: i64.trunc_u/f64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define i64 @i64_trunc_u_f64(double %x) {
%a = fptoui double %x to i64
ret i64 %a
}
[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: f32_convert_s_i32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result f32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f32.convert_s/i32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define float @f32_convert_s_i32(i32 %x) {
%a = sitofp i32 %x to float
ret float %a
}
[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: f32_convert_u_i32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result f32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f32.convert_u/i32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define float @f32_convert_u_i32(i32 %x) {
%a = uitofp i32 %x to float
ret float %a
}
[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: f64_convert_s_i32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result f64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f64.convert_s/i32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define double @f64_convert_s_i32(i32 %x) {
%a = sitofp i32 %x to double
ret double %a
}
[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: f64_convert_u_i32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result f64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f64.convert_u/i32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define double @f64_convert_u_i32(i32 %x) {
%a = uitofp i32 %x to double
ret double %a
}
[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: f32_convert_s_i64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i64{{$}}
; CHECK-NEXT: .result f32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f32.convert_s/i64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define float @f32_convert_s_i64(i64 %x) {
%a = sitofp i64 %x to float
ret float %a
}
[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: f32_convert_u_i64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i64{{$}}
; CHECK-NEXT: .result f32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f32.convert_u/i64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define float @f32_convert_u_i64(i64 %x) {
%a = uitofp i64 %x to float
ret float %a
}
[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: f64_convert_s_i64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i64{{$}}
; CHECK-NEXT: .result f64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f64.convert_s/i64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define double @f64_convert_s_i64(i64 %x) {
%a = sitofp i64 %x to double
ret double %a
}
[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: f64_convert_u_i64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param i64{{$}}
; CHECK-NEXT: .result f64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f64.convert_u/i64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define double @f64_convert_u_i64(i64 %x) {
%a = uitofp i64 %x to double
ret double %a
}
[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: f64_promote_f32:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f32{{$}}
; CHECK-NEXT: .result f64{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f64.promote/f32 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define double @f64_promote_f32(float %x) {
%a = fpext float %x to double
ret double %a
}
[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: f32_demote_f64:
[WebAssembly] Make several tests more strict. llvm-svn: 254077
2015-11-26 01:33:15 +08:00
; CHECK-NEXT: .param f64{{$}}
; CHECK-NEXT: .result f32{{$}}
[WebAssembly] Suffix output operands with '='. This distinguishes input operands from output operands. This is something of a syntactic experiment to see whether the mild amount of clutter this adds is outweighed by the extra information it conveys to the reader. llvm-svn: 253922
2015-11-24 05:55:57 +08:00
; CHECK-NEXT: f32.demote/f64 $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] Implement the remaining conversion operations. This is a temporary assembly syntax that will likely evolve along with broader upcoming syntax changes. llvm-svn: 249225
2015-10-03 10:10:28 +08:00
define float @f32_demote_f64(double %x) {
%a = fptrunc double %x to float
ret float %a
}
[WebAssembly] Implement anyext. llvm-svn: 255179
2015-12-10 08:17:35 +08:00
; If the high its are unused, LLVM will optimize sext/zext into anyext, which
; we need to patterm-match back to a specific instruction.
; CHECK-LABEL: anyext:
; CHECK: i64.extend_u/i32 $push0=, $0{{$}}
define i64 @anyext(i32 %x) {
%y = sext i32 %x to i64
%w = shl i64 %y, 32
ret i64 %w
}
PeepholeOptimizer: Ignore dead implicit defs Target-specific instructions may have uninteresting physreg clobbers, for target-specific reasons. The peephole pass doesn't need to concern itself with such defs, as long as they're implicit and marked as dead. llvm-svn: 255182
2015-12-10 08:37:51 +08:00
; CHECK-LABEL: bitcast_i32_to_float:
; CHECK: f32.reinterpret/i32 $push0=, $0{{$}}
define float @bitcast_i32_to_float(i32 %a) {
%t = bitcast i32 %a to float
ret float %t
}
; CHECK-LABEL: bitcast_float_to_i32:
; CHECK: i32.reinterpret/f32 $push0=, $0{{$}}
define i32 @bitcast_float_to_i32(float %a) {
%t = bitcast float %a to i32
ret i32 %t
}
; CHECK-LABEL: bitcast_i64_to_double:
; CHECK: f64.reinterpret/i64 $push0=, $0{{$}}
define double @bitcast_i64_to_double(i64 %a) {
%t = bitcast i64 %a to double
ret double %t
}
; CHECK-LABEL: bitcast_double_to_i64:
; CHECK: i64.reinterpret/f64 $push0=, $0{{$}}
define i64 @bitcast_double_to_i64(double %a) {
%t = bitcast double %a to i64
ret i64 %t
}