You've already forked linux-packaging-mono
Imported Upstream version 5.18.0.225
Former-commit-id: 10196d987d5fc5564b9d3b33b1fdf13190f4d0b5
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
parent
32d52ae4ca
commit
f32dbaf0b2
676
external/llvm/test/CodeGen/WebAssembly/address-offsets.ll
vendored
Normal file
676
external/llvm/test/CodeGen/WebAssembly/address-offsets.ll
vendored
Normal file
File diff suppressed because it is too large
Load Diff
127
external/llvm/test/CodeGen/WebAssembly/byval.ll
vendored
Normal file
127
external/llvm/test/CodeGen/WebAssembly/byval.ll
vendored
Normal file
@ -0,0 +1,127 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs -fast-isel | FileCheck %s
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
%SmallStruct = type { i32 }
|
||||
%OddStruct = type { i32, i8, i32 }
|
||||
%AlignedStruct = type { double, double }
|
||||
%BigStruct = type { double, double, double, double, double, double, double, double, double, double, double, i8, i8, i8 }
|
||||
%EmptyStruct = type { }
|
||||
|
||||
%BigArray = type { [33 x i8] }
|
||||
|
||||
declare void @ext_func(%SmallStruct*)
|
||||
declare void @ext_func_empty(%EmptyStruct* byval)
|
||||
declare void @ext_byval_func(%SmallStruct* byval)
|
||||
declare void @ext_byval_func_align8(%SmallStruct* byval align 8)
|
||||
declare void @ext_byval_func_alignedstruct(%AlignedStruct* byval)
|
||||
declare void @ext_byval_func_bigarray(%BigArray* byval)
|
||||
declare void @ext_byval_func_empty(%EmptyStruct* byval)
|
||||
|
||||
; CHECK-LABEL: byval_arg
|
||||
define void @byval_arg(%SmallStruct* %ptr) {
|
||||
; CHECK: .param i32
|
||||
; Subtract 16 from SP (SP is 16-byte aligned)
|
||||
; CHECK-NEXT: get_global $push[[L2:.+]]=, __stack_pointer
|
||||
; CHECK-NEXT: i32.const $push[[L3:.+]]=, 16
|
||||
; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L2]], $pop[[L3]]
|
||||
; Ensure SP is stored back before the call
|
||||
; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}}
|
||||
; CHECK-NEXT: set_global __stack_pointer, $pop[[L10]]{{$}}
|
||||
; Copy the SmallStruct argument to the stack (SP+12, original SP-4)
|
||||
; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0)
|
||||
; CHECK-NEXT: i32.store 12($[[SP]]), $pop[[L0]]
|
||||
; Pass a pointer to the stack slot to the function
|
||||
; CHECK-NEXT: i32.const $push[[L5:.+]]=, 12{{$}}
|
||||
; CHECK-NEXT: i32.add $push[[ARG:.+]]=, $[[SP]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: call ext_byval_func@FUNCTION, $pop[[ARG]]{{$}}
|
||||
call void @ext_byval_func(%SmallStruct* byval %ptr)
|
||||
; Restore the stack
|
||||
; CHECK-NEXT: i32.const $push[[L6:.+]]=, 16
|
||||
; CHECK-NEXT: i32.add $push[[L8:.+]]=, $[[SP]], $pop[[L6]]
|
||||
; CHECK-NEXT: set_global __stack_pointer, $pop[[L8]]
|
||||
; CHECK-NEXT: return
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: byval_arg_align8
|
||||
define void @byval_arg_align8(%SmallStruct* %ptr) {
|
||||
; CHECK: .param i32
|
||||
; Don't check the entire SP sequence, just enough to get the alignment.
|
||||
; CHECK: i32.const $push[[L1:.+]]=, 16
|
||||
; CHECK-NEXT: i32.sub $push[[L11:.+]]=, {{.+}}, $pop[[L1]]
|
||||
; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}}
|
||||
; CHECK-NEXT: set_global __stack_pointer, $pop[[L10]]{{$}}
|
||||
; Copy the SmallStruct argument to the stack (SP+8, original SP-8)
|
||||
; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0){{$}}
|
||||
; CHECK-NEXT: i32.store 8($[[SP]]), $pop[[L0]]{{$}}
|
||||
; Pass a pointer to the stack slot to the function
|
||||
; CHECK-NEXT: i32.const $push[[L5:.+]]=, 8{{$}}
|
||||
; CHECK-NEXT: i32.add $push[[ARG:.+]]=, $[[SP]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: call ext_byval_func_align8@FUNCTION, $pop[[ARG]]{{$}}
|
||||
call void @ext_byval_func_align8(%SmallStruct* byval align 8 %ptr)
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: byval_arg_double
|
||||
define void @byval_arg_double(%AlignedStruct* %ptr) {
|
||||
; CHECK: .param i32
|
||||
; Subtract 16 from SP (SP is 16-byte aligned)
|
||||
; CHECK: i32.const $push[[L1:.+]]=, 16
|
||||
; CHECK-NEXT: i32.sub $push[[L14:.+]]=, {{.+}}, $pop[[L1]]
|
||||
; CHECK-NEXT: tee_local $push[[L13:.+]]=, $[[SP:.+]]=, $pop[[L14]]
|
||||
; CHECK-NEXT: set_global __stack_pointer, $pop[[L13]]
|
||||
; Copy the AlignedStruct argument to the stack (SP+0, original SP-16)
|
||||
; Just check the last load/store pair of the memcpy
|
||||
; CHECK: i64.load $push[[L4:.+]]=, 0($0)
|
||||
; CHECK-NEXT: i64.store 0($[[SP]]), $pop[[L4]]
|
||||
; Pass a pointer to the stack slot to the function
|
||||
; CHECK-NEXT: call ext_byval_func_alignedstruct@FUNCTION, $[[SP]]
|
||||
tail call void @ext_byval_func_alignedstruct(%AlignedStruct* byval %ptr)
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: byval_param
|
||||
define void @byval_param(%SmallStruct* byval align 32 %ptr) {
|
||||
; CHECK: .param i32
|
||||
; %ptr is just a pointer to a struct, so pass it directly through
|
||||
; CHECK: call ext_func@FUNCTION, $0
|
||||
call void @ext_func(%SmallStruct* %ptr)
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: byval_empty_caller
|
||||
define void @byval_empty_caller(%EmptyStruct* %ptr) {
|
||||
; CHECK: .param i32
|
||||
; CHECK: call ext_byval_func_empty@FUNCTION, $0
|
||||
call void @ext_byval_func_empty(%EmptyStruct* byval %ptr)
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: byval_empty_callee
|
||||
define void @byval_empty_callee(%EmptyStruct* byval %ptr) {
|
||||
; CHECK: .param i32
|
||||
; CHECK: call ext_func_empty@FUNCTION, $0
|
||||
call void @ext_func_empty(%EmptyStruct* %ptr)
|
||||
ret void
|
||||
}
|
||||
|
||||
; Call memcpy for "big" byvals.
|
||||
; CHECK-LABEL: big_byval:
|
||||
; CHECK: get_global $push[[L2:.+]]=, __stack_pointer{{$}}
|
||||
; CHECK-NEXT: i32.const $push[[L3:.+]]=, 131072
|
||||
; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L2]], $pop[[L3]]
|
||||
; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}}
|
||||
; CHECK-NEXT: set_global __stack_pointer, $pop[[L10]]{{$}}
|
||||
; CHECK-NEXT: i32.const $push[[L0:.+]]=, 131072
|
||||
; CHECK-NEXT: i32.call $push[[L11:.+]]=, memcpy@FUNCTION, $[[SP]], ${{.+}}, $pop{{.+}}
|
||||
; CHECK-NEXT: tee_local $push[[L9:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}}
|
||||
; CHECK-NEXT: call big_byval_callee@FUNCTION,
|
||||
%big = type [131072 x i8]
|
||||
declare void @big_byval_callee(%big* byval align 1)
|
||||
define void @big_byval(%big* byval align 1 %x) {
|
||||
call void @big_byval_callee(%big* byval align 1 %x)
|
||||
ret void
|
||||
}
|
||||
178
external/llvm/test/CodeGen/WebAssembly/call.ll
vendored
Normal file
178
external/llvm/test/CodeGen/WebAssembly/call.ll
vendored
Normal file
@ -0,0 +1,178 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-temporary-workarounds=false | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 -wasm-temporary-workarounds=false | FileCheck %s
|
||||
|
||||
; Test that basic call operations assemble as expected.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
declare i32 @i32_nullary()
|
||||
declare i32 @i32_unary(i32)
|
||||
declare i32 @i32_binary(i32, i32)
|
||||
declare i64 @i64_nullary()
|
||||
declare float @float_nullary()
|
||||
declare double @double_nullary()
|
||||
declare void @void_nullary()
|
||||
|
||||
; CHECK-LABEL: call_i32_nullary:
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @call_i32_nullary() {
|
||||
%r = call i32 @i32_nullary()
|
||||
ret i32 %r
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_i64_nullary:
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: {{^}} i64.call $push[[NUM:[0-9]+]]=, i64_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @call_i64_nullary() {
|
||||
%r = call i64 @i64_nullary()
|
||||
ret i64 %r
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_float_nullary:
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: {{^}} f32.call $push[[NUM:[0-9]+]]=, float_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define float @call_float_nullary() {
|
||||
%r = call float @float_nullary()
|
||||
ret float %r
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_double_nullary:
|
||||
; CHECK-NEXT: .result f64{{$}}
|
||||
; CHECK-NEXT: {{^}} f64.call $push[[NUM:[0-9]+]]=, double_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define double @call_double_nullary() {
|
||||
%r = call double @double_nullary()
|
||||
ret double %r
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_void_nullary:
|
||||
; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
define void @call_void_nullary() {
|
||||
call void @void_nullary()
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_i32_unary:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_unary@FUNCTION, $pop[[L0]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @call_i32_unary(i32 %a) {
|
||||
%r = call i32 @i32_unary(i32 %a)
|
||||
ret i32 %r
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_i32_binary:
|
||||
; CHECK-NEXT: .param i32, i32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_binary@FUNCTION, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @call_i32_binary(i32 %a, i32 %b) {
|
||||
%r = call i32 @i32_binary(i32 %a, i32 %b)
|
||||
ret i32 %r
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_indirect_void:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: {{^}} call_indirect $pop[[L0]]{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
define void @call_indirect_void(void ()* %callee) {
|
||||
call void %callee()
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_indirect_i32:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @call_indirect_i32(i32 ()* %callee) {
|
||||
%t = call i32 %callee()
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_indirect_arg:
|
||||
; CHECK-NEXT: .param i32, i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: {{^}} call_indirect $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
define void @call_indirect_arg(void (i32)* %callee, i32 %arg) {
|
||||
call void %callee(i32 %arg)
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_indirect_arg_2:
|
||||
; CHECK-NEXT: .param i32, i32, i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 2{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]], $pop[[L2]]{{$}}
|
||||
; CHECK-NEXT: drop $pop[[NUM]]{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
define void @call_indirect_arg_2(i32 (i32, i32)* %callee, i32 %arg, i32 %arg2) {
|
||||
call i32 %callee(i32 %arg, i32 %arg2)
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: tail_call_void_nullary:
|
||||
; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
define void @tail_call_void_nullary() {
|
||||
tail call void @void_nullary()
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fastcc_tail_call_void_nullary:
|
||||
; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
define void @fastcc_tail_call_void_nullary() {
|
||||
tail call fastcc void @void_nullary()
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: coldcc_tail_call_void_nullary:
|
||||
; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
define void @coldcc_tail_call_void_nullary() {
|
||||
tail call coldcc void @void_nullary()
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: call_constexpr:
|
||||
; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 2{{$}}
|
||||
; CHECK-NEXT: i32.const $push[[L1:[0-9]+]]=, 3{{$}}
|
||||
; CHECK-NEXT: call .Lbitcast@FUNCTION, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: call other_void_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: call void_nullary@FUNCTION{{$}}
|
||||
; CHECK-NEXT: return{{$}}
|
||||
declare void @vararg_func(...)
|
||||
declare void @other_void_nullary()
|
||||
define void @call_constexpr() {
|
||||
bb0:
|
||||
call void bitcast (void (...)* @vararg_func to void (i32, i32)*)(i32 2, i32 3)
|
||||
br label %bb1
|
||||
bb1:
|
||||
call void select (i1 0, void ()* @void_nullary, void ()* @other_void_nullary)()
|
||||
br label %bb2
|
||||
bb2:
|
||||
call void inttoptr (i32 ptrtoint (void ()* @void_nullary to i32) to void ()*)()
|
||||
ret void
|
||||
}
|
||||
|
||||
; TODO: test the following:
|
||||
; - More argument combinations.
|
||||
; - Tail call.
|
||||
; - Interesting returns (struct, multiple).
|
||||
; - Vararg.
|
||||
1336
external/llvm/test/CodeGen/WebAssembly/cfg-stackify.ll
vendored
Normal file
1336
external/llvm/test/CodeGen/WebAssembly/cfg-stackify.ll
vendored
Normal file
File diff suppressed because it is too large
Load Diff
53
external/llvm/test/CodeGen/WebAssembly/cfi.ll
vendored
Normal file
53
external/llvm/test/CodeGen/WebAssembly/cfi.ll
vendored
Normal file
@ -0,0 +1,53 @@
|
||||
; RUN: opt -S -lowertypetests < %s | llc -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
|
||||
|
||||
; Tests that we correctly assign indexes for control flow integrity.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
@0 = private unnamed_addr constant [2 x void (...)*] [void (...)* bitcast (void ()* @f to void (...)*), void (...)* bitcast (void ()* @g to void (...)*)], align 16
|
||||
|
||||
; CHECK-LABEL: h:
|
||||
; CHECK-NOT: .indidx
|
||||
define void @h() !type !0 {
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f:
|
||||
; CHECK: .indidx 1
|
||||
define void @f() !type !0 {
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: g:
|
||||
; CHECK: .indidx 2
|
||||
define void @g() !type !1 {
|
||||
ret void
|
||||
}
|
||||
|
||||
!0 = !{i32 0, !"typeid1"}
|
||||
!1 = !{i32 0, !"typeid2"}
|
||||
|
||||
declare i1 @llvm.type.test(i8* %ptr, metadata %bitset) nounwind readnone
|
||||
declare void @llvm.trap() nounwind noreturn
|
||||
|
||||
; CHECK-LABEL: foo:
|
||||
; CHECK: br_if
|
||||
; CHECK: br_if
|
||||
; CHECK: unreachable
|
||||
define i1 @foo(i8* %p) {
|
||||
%x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
|
||||
br i1 %x, label %contx, label %trap
|
||||
|
||||
trap:
|
||||
tail call void @llvm.trap() #1
|
||||
unreachable
|
||||
|
||||
contx:
|
||||
%y = call i1 @llvm.type.test(i8* %p, metadata !"typeid2")
|
||||
br i1 %y, label %conty, label %trap
|
||||
|
||||
conty:
|
||||
%z = add i1 %x, %y
|
||||
ret i1 %z
|
||||
}
|
||||
5
external/llvm/test/CodeGen/WebAssembly/comdat.ll
vendored
Normal file
5
external/llvm/test/CodeGen/WebAssembly/comdat.ll
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
; RUN: not llc < %s -mtriple wasm32-unknown-unknown-wasm 2>&1 | FileCheck %s
|
||||
|
||||
$f = comdat any
|
||||
@f = global i32 0, comdat
|
||||
; CHECK: LLVM ERROR: WebAssembly doesn't support COMDATs, 'f' cannot be lowered.
|
||||
227
external/llvm/test/CodeGen/WebAssembly/comparisons_f32.ll
vendored
Normal file
227
external/llvm/test/CodeGen/WebAssembly/comparisons_f32.ll
vendored
Normal file
@ -0,0 +1,227 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
|
||||
|
||||
; Test that basic 32-bit floating-point comparison operations assemble as
|
||||
; expected.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: ord_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM2]]{{$}}
|
||||
define i32 @ord_f32(float %x, float %y) {
|
||||
%a = fcmp ord float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: uno_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM2]]{{$}}
|
||||
define i32 @uno_f32(float %x, float %y) {
|
||||
%a = fcmp uno float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: oeq_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @oeq_f32(float %x, float %y) {
|
||||
%a = fcmp oeq float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: une_f32:
|
||||
; CHECK: f32.ne $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @une_f32(float %x, float %y) {
|
||||
%a = fcmp une float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: olt_f32:
|
||||
; CHECK: f32.lt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @olt_f32(float %x, float %y) {
|
||||
%a = fcmp olt float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ole_f32:
|
||||
; CHECK: f32.le $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ole_f32(float %x, float %y) {
|
||||
%a = fcmp ole float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ogt_f32:
|
||||
; CHECK: f32.gt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ogt_f32(float %x, float %y) {
|
||||
%a = fcmp ogt float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: oge_f32:
|
||||
; CHECK: f32.ge $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @oge_f32(float %x, float %y) {
|
||||
%a = fcmp oge float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; Expanded comparisons, which also check for NaN.
|
||||
|
||||
; CHECK-LABEL: ueq_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ueq_f32(float %x, float %y) {
|
||||
%a = fcmp ueq float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: one_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.eq $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]
|
||||
define i32 @one_f32(float %x, float %y) {
|
||||
%a = fcmp one float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ult_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.lt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ult_f32(float %x, float %y) {
|
||||
%a = fcmp ult float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ule_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.le $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ule_f32(float %x, float %y) {
|
||||
%a = fcmp ule float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ugt_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ugt_f32(float %x, float %y) {
|
||||
%a = fcmp ugt float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: uge_f32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ge $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @uge_f32(float %x, float %y) {
|
||||
%a = fcmp uge float %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
227
external/llvm/test/CodeGen/WebAssembly/comparisons_f64.ll
vendored
Normal file
227
external/llvm/test/CodeGen/WebAssembly/comparisons_f64.ll
vendored
Normal file
@ -0,0 +1,227 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
|
||||
|
||||
; Test that basic 64-bit floating-point comparison operations assemble as
|
||||
; expected.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: ord_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM2]]{{$}}
|
||||
define i32 @ord_f64(double %x, double %y) {
|
||||
%a = fcmp ord double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: uno_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM2]]{{$}}
|
||||
define i32 @uno_f64(double %x, double %y) {
|
||||
%a = fcmp uno double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: oeq_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @oeq_f64(double %x, double %y) {
|
||||
%a = fcmp oeq double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: une_f64:
|
||||
; CHECK: f64.ne $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @une_f64(double %x, double %y) {
|
||||
%a = fcmp une double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: olt_f64:
|
||||
; CHECK: f64.lt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @olt_f64(double %x, double %y) {
|
||||
%a = fcmp olt double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ole_f64:
|
||||
; CHECK: f64.le $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ole_f64(double %x, double %y) {
|
||||
%a = fcmp ole double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ogt_f64:
|
||||
; CHECK: f64.gt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ogt_f64(double %x, double %y) {
|
||||
%a = fcmp ogt double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: oge_f64:
|
||||
; CHECK: f64.ge $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @oge_f64(double %x, double %y) {
|
||||
%a = fcmp oge double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; Expanded comparisons, which also check for NaN.
|
||||
|
||||
; CHECK-LABEL: ueq_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ueq_f64(double %x, double %y) {
|
||||
%a = fcmp ueq double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: one_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.eq $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]
|
||||
define i32 @one_f64(double %x, double %y) {
|
||||
%a = fcmp one double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ult_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.lt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ult_f64(double %x, double %y) {
|
||||
%a = fcmp ult double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ule_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.le $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ule_f64(double %x, double %y) {
|
||||
%a = fcmp ule double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ugt_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @ugt_f64(double %x, double %y) {
|
||||
%a = fcmp ugt double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: uge_f64:
|
||||
; CHECK-NEXT: .param f64, f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ge $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}}
|
||||
; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM4]]{{$}}
|
||||
define i32 @uge_f64(double %x, double %y) {
|
||||
%a = fcmp uge double %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
101
external/llvm/test/CodeGen/WebAssembly/comparisons_i32.ll
vendored
Normal file
101
external/llvm/test/CodeGen/WebAssembly/comparisons_i32.ll
vendored
Normal file
@ -0,0 +1,101 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s
|
||||
|
||||
; Test that basic 32-bit integer comparison operations assemble as expected.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: eq_i32:
|
||||
; CHECK-NEXT: .param i32, i32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: i32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @eq_i32(i32 %x, i32 %y) {
|
||||
%a = icmp eq i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ne_i32:
|
||||
; CHECK: i32.ne $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ne_i32(i32 %x, i32 %y) {
|
||||
%a = icmp ne i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: slt_i32:
|
||||
; CHECK: i32.lt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @slt_i32(i32 %x, i32 %y) {
|
||||
%a = icmp slt i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: sle_i32:
|
||||
; CHECK: i32.le_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @sle_i32(i32 %x, i32 %y) {
|
||||
%a = icmp sle i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ult_i32:
|
||||
; CHECK: i32.lt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ult_i32(i32 %x, i32 %y) {
|
||||
%a = icmp ult i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ule_i32:
|
||||
; CHECK: i32.le_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ule_i32(i32 %x, i32 %y) {
|
||||
%a = icmp ule i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: sgt_i32:
|
||||
; CHECK: i32.gt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @sgt_i32(i32 %x, i32 %y) {
|
||||
%a = icmp sgt i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: sge_i32:
|
||||
; CHECK: i32.ge_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @sge_i32(i32 %x, i32 %y) {
|
||||
%a = icmp sge i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ugt_i32:
|
||||
; CHECK: i32.gt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ugt_i32(i32 %x, i32 %y) {
|
||||
%a = icmp ugt i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: uge_i32:
|
||||
; CHECK: i32.ge_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @uge_i32(i32 %x, i32 %y) {
|
||||
%a = icmp uge i32 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
101
external/llvm/test/CodeGen/WebAssembly/comparisons_i64.ll
vendored
Normal file
101
external/llvm/test/CodeGen/WebAssembly/comparisons_i64.ll
vendored
Normal file
@ -0,0 +1,101 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s
|
||||
|
||||
; Test that basic 64-bit integer comparison operations assemble as expected.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: eq_i64:
|
||||
; CHECK-NEXT: .param i64, i64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: i64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @eq_i64(i64 %x, i64 %y) {
|
||||
%a = icmp eq i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ne_i64:
|
||||
; CHECK: i64.ne $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ne_i64(i64 %x, i64 %y) {
|
||||
%a = icmp ne i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: slt_i64:
|
||||
; CHECK: i64.lt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @slt_i64(i64 %x, i64 %y) {
|
||||
%a = icmp slt i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: sle_i64:
|
||||
; CHECK: i64.le_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @sle_i64(i64 %x, i64 %y) {
|
||||
%a = icmp sle i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ult_i64:
|
||||
; CHECK: i64.lt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ult_i64(i64 %x, i64 %y) {
|
||||
%a = icmp ult i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ule_i64:
|
||||
; CHECK: i64.le_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ule_i64(i64 %x, i64 %y) {
|
||||
%a = icmp ule i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: sgt_i64:
|
||||
; CHECK: i64.gt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @sgt_i64(i64 %x, i64 %y) {
|
||||
%a = icmp sgt i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: sge_i64:
|
||||
; CHECK: i64.ge_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @sge_i64(i64 %x, i64 %y) {
|
||||
%a = icmp sge i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ugt_i64:
|
||||
; CHECK: i64.gt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @ugt_i64(i64 %x, i64 %y) {
|
||||
%a = icmp ugt i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: uge_i64:
|
||||
; CHECK: i64.ge_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @uge_i64(i64 %x, i64 %y) {
|
||||
%a = icmp uge i64 %x, %y
|
||||
%b = zext i1 %a to i32
|
||||
ret i32 %b
|
||||
}
|
||||
167
external/llvm/test/CodeGen/WebAssembly/conv-trap.ll
vendored
Normal file
167
external/llvm/test/CodeGen/WebAssembly/conv-trap.ll
vendored
Normal file
@ -0,0 +1,167 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-nontrapping-fptoint | FileCheck %s
|
||||
|
||||
; Test that basic conversion operations assemble as expected using
|
||||
; the trapping opcodes and explicit code to suppress the trapping.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: i32_trunc_s_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f32.abs $push[[ABS:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: f32.const $push[[LIMIT:[0-9]+]]=, 0x1p31{{$}}
|
||||
; CHECK-NEXT: f32.lt $push[[LT:[0-9]+]]=, $pop[[ABS]], $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[LT]]{{$}}
|
||||
; CHECK-NEXT: i32.const $push[[ALT:[0-9]+]]=, -2147483648{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i32.trunc_s/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_s_f32(float %x) {
|
||||
%a = fptosi float %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i32_trunc_u_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f32.const $push[[LIMIT:[0-9]+]]=, 0x1p32{{$}}
|
||||
; CHECK-NEXT: f32.lt $push[[LT:[0-9]+]]=, $0, $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: f32.const $push[[ZERO:[0-9]+]]=, 0x0p0{{$}}
|
||||
; CHECK-NEXT: f32.ge $push[[GE:[0-9]+]]=, $0, $pop[[ZERO]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[AND:[0-9]+]]=, $pop[[LT]], $pop[[GE]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[AND]]{{$}}
|
||||
; CHECK-NEXT: i32.const $push[[ALT:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i32.trunc_u/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_u_f32(float %x) {
|
||||
%a = fptoui float %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i32_trunc_s_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f64.abs $push[[ABS:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: f64.const $push[[LIMIT:[0-9]+]]=, 0x1p31{{$}}
|
||||
; CHECK-NEXT: f64.lt $push[[LT:[0-9]+]]=, $pop[[ABS]], $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[LT]]{{$}}
|
||||
; CHECK-NEXT: i32.const $push[[ALT:[0-9]+]]=, -2147483648{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i32.trunc_s/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_s_f64(double %x) {
|
||||
%a = fptosi double %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i32_trunc_u_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f64.const $push[[LIMIT:[0-9]+]]=, 0x1p32{{$}}
|
||||
; CHECK-NEXT: f64.lt $push[[LT:[0-9]+]]=, $0, $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: f64.const $push[[ZERO:[0-9]+]]=, 0x0p0{{$}}
|
||||
; CHECK-NEXT: f64.ge $push[[GE:[0-9]+]]=, $0, $pop[[ZERO]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[AND:[0-9]+]]=, $pop[[LT]], $pop[[GE]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[AND]]{{$}}
|
||||
; CHECK-NEXT: i32.const $push[[ALT:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i32.trunc_u/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_u_f64(double %x) {
|
||||
%a = fptoui double %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_s_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f32.abs $push[[ABS:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: f32.const $push[[LIMIT:[0-9]+]]=, 0x1p63{{$}}
|
||||
; CHECK-NEXT: f32.lt $push[[LT:[0-9]+]]=, $pop[[ABS]], $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[LT]]{{$}}
|
||||
; CHECK-NEXT: i64.const $push[[ALT:[0-9]+]]=, -9223372036854775808{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i64.trunc_s/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_s_f32(float %x) {
|
||||
%a = fptosi float %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_u_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f32.const $push[[LIMIT:[0-9]+]]=, 0x1p64{{$}}
|
||||
; CHECK-NEXT: f32.lt $push[[LT:[0-9]+]]=, $0, $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: f32.const $push[[ZERO:[0-9]+]]=, 0x0p0{{$}}
|
||||
; CHECK-NEXT: f32.ge $push[[GE:[0-9]+]]=, $0, $pop[[ZERO]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[AND:[0-9]+]]=, $pop[[LT]], $pop[[GE]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[AND]]{{$}}
|
||||
; CHECK-NEXT: i64.const $push[[ALT:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i64.trunc_u/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_u_f32(float %x) {
|
||||
%a = fptoui float %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_s_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f64.abs $push[[ABS:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: f64.const $push[[LIMIT:[0-9]+]]=, 0x1p63{{$}}
|
||||
; CHECK-NEXT: f64.lt $push[[LT:[0-9]+]]=, $pop[[ABS]], $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[LT]]{{$}}
|
||||
; CHECK-NEXT: i64.const $push[[ALT:[0-9]+]]=, -9223372036854775808{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i64.trunc_s/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_s_f64(double %x) {
|
||||
%a = fptosi double %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_u_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: block
|
||||
; CHECK-NEXT: f64.const $push[[LIMIT:[0-9]+]]=, 0x1p64{{$}}
|
||||
; CHECK-NEXT: f64.lt $push[[LT:[0-9]+]]=, $0, $pop[[LIMIT]]{{$}}
|
||||
; CHECK-NEXT: f64.const $push[[ZERO:[0-9]+]]=, 0x0p0{{$}}
|
||||
; CHECK-NEXT: f64.ge $push[[GE:[0-9]+]]=, $0, $pop[[ZERO]]{{$}}
|
||||
; CHECK-NEXT: i32.and $push[[AND:[0-9]+]]=, $pop[[LT]], $pop[[GE]]{{$}}
|
||||
; CHECK-NEXT: br_if 0, $pop[[AND]]{{$}}
|
||||
; CHECK-NEXT: i64.const $push[[ALT:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: return $pop[[ALT]]{{$}}
|
||||
; CHECK-NEXT: BB
|
||||
; CHECK-NEXT: end_block
|
||||
; CHECK-NEXT: i64.trunc_u/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_u_f64(double %x) {
|
||||
%a = fptoui double %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
255
external/llvm/test/CodeGen/WebAssembly/conv.ll
vendored
Normal file
255
external/llvm/test/CodeGen/WebAssembly/conv.ll
vendored
Normal file
@ -0,0 +1,255 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+nontrapping-fptoint | FileCheck %s
|
||||
|
||||
; Test that basic conversion operations assemble as expected.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: i32_wrap_i64:
|
||||
; CHECK-NEXT: .param i64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: i32.wrap/i64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_wrap_i64(i64 %x) {
|
||||
%a = trunc i64 %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_extend_s_i32:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: i64.extend_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_extend_s_i32(i32 %x) {
|
||||
%a = sext i32 %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_extend_u_i32:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: i64.extend_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_extend_u_i32(i32 %x) {
|
||||
%a = zext i32 %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i32_trunc_s_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: i32.trunc_s:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_s_f32(float %x) {
|
||||
%a = fptosi float %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i32_trunc_u_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: i32.trunc_u:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_u_f32(float %x) {
|
||||
%a = fptoui float %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i32_trunc_s_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: i32.trunc_s:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_s_f64(double %x) {
|
||||
%a = fptosi double %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i32_trunc_u_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i32{{$}}
|
||||
; CHECK-NEXT: i32.trunc_u:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i32 @i32_trunc_u_f64(double %x) {
|
||||
%a = fptoui double %x to i32
|
||||
ret i32 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_s_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: i64.trunc_s:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_s_f32(float %x) {
|
||||
%a = fptosi float %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_u_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: i64.trunc_u:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_u_f32(float %x) {
|
||||
%a = fptoui float %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_s_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: i64.trunc_s:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_s_f64(double %x) {
|
||||
%a = fptosi double %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: i64_trunc_u_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result i64{{$}}
|
||||
; CHECK-NEXT: i64.trunc_u:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define i64 @i64_trunc_u_f64(double %x) {
|
||||
%a = fptoui double %x to i64
|
||||
ret i64 %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f32_convert_s_i32:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: f32.convert_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define float @f32_convert_s_i32(i32 %x) {
|
||||
%a = sitofp i32 %x to float
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f32_convert_u_i32:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: f32.convert_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define float @f32_convert_u_i32(i32 %x) {
|
||||
%a = uitofp i32 %x to float
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f64_convert_s_i32:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result f64{{$}}
|
||||
; CHECK-NEXT: f64.convert_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define double @f64_convert_s_i32(i32 %x) {
|
||||
%a = sitofp i32 %x to double
|
||||
ret double %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f64_convert_u_i32:
|
||||
; CHECK-NEXT: .param i32{{$}}
|
||||
; CHECK-NEXT: .result f64{{$}}
|
||||
; CHECK-NEXT: f64.convert_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define double @f64_convert_u_i32(i32 %x) {
|
||||
%a = uitofp i32 %x to double
|
||||
ret double %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f32_convert_s_i64:
|
||||
; CHECK-NEXT: .param i64{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: f32.convert_s/i64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define float @f32_convert_s_i64(i64 %x) {
|
||||
%a = sitofp i64 %x to float
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f32_convert_u_i64:
|
||||
; CHECK-NEXT: .param i64{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: f32.convert_u/i64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define float @f32_convert_u_i64(i64 %x) {
|
||||
%a = uitofp i64 %x to float
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f64_convert_s_i64:
|
||||
; CHECK-NEXT: .param i64{{$}}
|
||||
; CHECK-NEXT: .result f64{{$}}
|
||||
; CHECK-NEXT: f64.convert_s/i64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define double @f64_convert_s_i64(i64 %x) {
|
||||
%a = sitofp i64 %x to double
|
||||
ret double %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f64_convert_u_i64:
|
||||
; CHECK-NEXT: .param i64{{$}}
|
||||
; CHECK-NEXT: .result f64{{$}}
|
||||
; CHECK-NEXT: f64.convert_u/i64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define double @f64_convert_u_i64(i64 %x) {
|
||||
%a = uitofp i64 %x to double
|
||||
ret double %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f64_promote_f32:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result f64{{$}}
|
||||
; CHECK-NEXT: f64.promote/f32 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define double @f64_promote_f32(float %x) {
|
||||
%a = fpext float %x to double
|
||||
ret double %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: f32_demote_f64:
|
||||
; CHECK-NEXT: .param f64{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: f32.demote/f64 $push[[NUM:[0-9]+]]=, $0{{$}}
|
||||
; CHECK-NEXT: return $pop[[NUM]]{{$}}
|
||||
define float @f32_demote_f64(double %x) {
|
||||
%a = fptrunc double %x to float
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; 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
|
||||
}
|
||||
|
||||
; 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
|
||||
}
|
||||
28
external/llvm/test/CodeGen/WebAssembly/copysign-casts.ll
vendored
Normal file
28
external/llvm/test/CodeGen/WebAssembly/copysign-casts.ll
vendored
Normal file
@ -0,0 +1,28 @@
|
||||
; RUN: llc < %s -asm-verbose=false | FileCheck %s
|
||||
|
||||
; DAGCombiner oddly folds casts into the rhs of copysign. Test that they get
|
||||
; unfolded.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
declare double @copysign(double, double) nounwind readnone
|
||||
declare float @copysignf(float, float) nounwind readnone
|
||||
|
||||
; CHECK-LABEL: fold_promote:
|
||||
; CHECK: f64.promote/f32 $push0=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK: f64.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}}
|
||||
define double @fold_promote(double %a, float %b) {
|
||||
%c = fpext float %b to double
|
||||
%t = call double @copysign(double %a, double %c)
|
||||
ret double %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fold_demote:{{$}}
|
||||
; CHECK: f32.demote/f64 $push0=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK: f32.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}}
|
||||
define float @fold_demote(float %a, double %b) {
|
||||
%c = fptrunc double %b to float
|
||||
%t = call float @copysignf(float %a, float %c)
|
||||
ret float %t
|
||||
}
|
||||
17
external/llvm/test/CodeGen/WebAssembly/cpus.ll
vendored
Normal file
17
external/llvm/test/CodeGen/WebAssembly/cpus.ll
vendored
Normal file
@ -0,0 +1,17 @@
|
||||
; This tests that llc accepts all valid WebAssembly CPUs.
|
||||
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=mvp 2>&1 | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=mvp 2>&1 | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=generic 2>&1 | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=generic 2>&1 | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=bleeding-edge 2>&1 | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=bleeding-edge 2>&1 | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID
|
||||
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID
|
||||
|
||||
; CHECK-NOT: is not a recognized processor for this target
|
||||
; INVALID: {{.+}} is not a recognized processor for this target
|
||||
|
||||
define i32 @f(i32 %i_like_the_web) {
|
||||
ret i32 %i_like_the_web
|
||||
}
|
||||
72
external/llvm/test/CodeGen/WebAssembly/dbgvalue.ll
vendored
Normal file
72
external/llvm/test/CodeGen/WebAssembly/dbgvalue.ll
vendored
Normal file
@ -0,0 +1,72 @@
|
||||
; RUN: llc < %s -O0 -verify-machineinstrs -mtriple=wasm32-unknown-unknown-wasm | FileCheck %s
|
||||
|
||||
; CHECK: %bb.0
|
||||
; CHECK: #DEBUG_VALUE: usage:self <- %4
|
||||
; CHECK: %bb.1
|
||||
; CHECK: DW_TAG_variable
|
||||
source_filename = "test/CodeGen/WebAssembly/dbgvalue.ll"
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
@key = external local_unnamed_addr global [15 x i8], align 1
|
||||
@.str = external unnamed_addr constant [33 x i8], align 1
|
||||
|
||||
define internal i32 @0(i8*) local_unnamed_addr !dbg !15 !type !23 {
|
||||
tail call void @llvm.dbg.value(metadata i8* %0, i64 0, metadata !22, metadata !24), !dbg !25
|
||||
%2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i32 0, i32 0), i8* %0), !dbg !26
|
||||
br i1 true, label %a, label %b
|
||||
|
||||
a: ; preds = %1
|
||||
%3 = add i32 %2, %2
|
||||
br label %c
|
||||
|
||||
b: ; preds = %1
|
||||
%4 = sub i32 %2, %2
|
||||
br label %c
|
||||
|
||||
c: ; preds = %b, %a
|
||||
%5 = phi i32 [ %3, %a ], [ %4, %b ]
|
||||
%6 = add i32 ptrtoint (i32 (i8*)* @0 to i32), %5
|
||||
ret i32 %6, !dbg !27
|
||||
}
|
||||
|
||||
declare i32 @printf(i8* nocapture readonly, ...) local_unnamed_addr
|
||||
|
||||
; Function Attrs: nounwind readnone
|
||||
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #0
|
||||
|
||||
attributes #0 = { nounwind readnone }
|
||||
|
||||
!llvm.dbg.cu = !{!0}
|
||||
!llvm.module.flags = !{!12, !13}
|
||||
!llvm.ident = !{!14}
|
||||
|
||||
!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
|
||||
!1 = !DIFile(filename: "crash.c", directory: "wasm/tests")
|
||||
!2 = !{}
|
||||
!3 = !{!4}
|
||||
!4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
|
||||
!5 = !DIGlobalVariable(name: "key", scope: !0, file: !1, line: 7, type: !6, isLocal: false, isDefinition: true)
|
||||
!6 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 120, align: 8, elements: !10)
|
||||
!7 = !DIDerivedType(tag: DW_TAG_typedef, name: "uint8_t", file: !8, line: 185, baseType: !9)
|
||||
!8 = !DIFile(filename: "wasm/emscripten/system/include/libc/bits/alltypes.h", directory: "wasm/tests")
|
||||
!9 = !DIBasicType(name: "unsigned char", size: 8, align: 8, encoding: DW_ATE_unsigned_char)
|
||||
!10 = !{!11}
|
||||
!11 = !DISubrange(count: 15)
|
||||
!12 = !{i32 2, !"Dwarf Version", i32 4}
|
||||
!13 = !{i32 2, !"Debug Info Version", i32 3}
|
||||
!14 = !{!"clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)"}
|
||||
!15 = distinct !DISubprogram(name: "usage", scope: !1, file: !1, line: 15, type: !16, isLocal: false, isDefinition: true, scopeLine: 15, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !21)
|
||||
!16 = !DISubroutineType(types: !17)
|
||||
!17 = !{!18, !19}
|
||||
!18 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
|
||||
!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !20, size: 32, align: 32)
|
||||
!20 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
|
||||
!21 = !{!22}
|
||||
!22 = !DILocalVariable(name: "self", arg: 1, scope: !15, file: !1, line: 15, type: !19)
|
||||
!23 = !{i64 0, !"_ZTSFiPcE"}
|
||||
!24 = !DIExpression()
|
||||
!25 = !DILocation(line: 15, column: 17, scope: !15)
|
||||
!26 = !DILocation(line: 16, column: 3, scope: !15)
|
||||
!27 = !DILocation(line: 17, column: 3, scope: !15)
|
||||
|
||||
51
external/llvm/test/CodeGen/WebAssembly/dead-vreg.ll
vendored
Normal file
51
external/llvm/test/CodeGen/WebAssembly/dead-vreg.ll
vendored
Normal file
@ -0,0 +1,51 @@
|
||||
; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s
|
||||
|
||||
; Check that unused vregs aren't assigned registers.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
define void @foo(i32* nocapture %a, i32 %w, i32 %h) {
|
||||
; CHECK-LABEL: foo:
|
||||
; CHECK-NEXT: .param i32, i32, i32{{$}}
|
||||
; CHECK-NEXT: .local i32, i32, i32, i32, i32, i32{{$}}
|
||||
entry:
|
||||
%cmp.19 = icmp sgt i32 %h, 0
|
||||
br i1 %cmp.19, label %for.cond.1.preheader.lr.ph, label %for.end.7
|
||||
|
||||
for.cond.1.preheader.lr.ph:
|
||||
%cmp2.17 = icmp sgt i32 %w, 0
|
||||
br label %for.cond.1.preheader
|
||||
|
||||
for.cond.1.preheader:
|
||||
%y.020 = phi i32 [ 0, %for.cond.1.preheader.lr.ph ], [ %inc6, %for.inc.5 ]
|
||||
br i1 %cmp2.17, label %for.body.3.lr.ph, label %for.inc.5
|
||||
|
||||
for.body.3.lr.ph:
|
||||
%mul4 = mul nsw i32 %y.020, %w
|
||||
br label %for.body.3
|
||||
|
||||
for.body.3:
|
||||
%x.018 = phi i32 [ 0, %for.body.3.lr.ph ], [ %inc, %for.body.3 ]
|
||||
%mul = mul nsw i32 %x.018, %y.020
|
||||
%add = add nsw i32 %x.018, %mul4
|
||||
%arrayidx = getelementptr inbounds i32, i32* %a, i32 %add
|
||||
store i32 %mul, i32* %arrayidx, align 4
|
||||
%inc = add nuw nsw i32 %x.018, 1
|
||||
%exitcond = icmp eq i32 %inc, %w
|
||||
br i1 %exitcond, label %for.inc.5.loopexit, label %for.body.3
|
||||
|
||||
for.inc.5.loopexit:
|
||||
br label %for.inc.5
|
||||
|
||||
for.inc.5:
|
||||
%inc6 = add nuw nsw i32 %y.020, 1
|
||||
%exitcond22 = icmp eq i32 %inc6, %h
|
||||
br i1 %exitcond22, label %for.end.7.loopexit, label %for.cond.1.preheader
|
||||
|
||||
for.end.7.loopexit:
|
||||
br label %for.end.7
|
||||
|
||||
for.end.7:
|
||||
ret void
|
||||
}
|
||||
62
external/llvm/test/CodeGen/WebAssembly/divrem-constant.ll
vendored
Normal file
62
external/llvm/test/CodeGen/WebAssembly/divrem-constant.ll
vendored
Normal file
@ -0,0 +1,62 @@
|
||||
; RUN: llc < %s -asm-verbose=false | FileCheck %s
|
||||
|
||||
; Test that integer div and rem by constant are optimized appropriately.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: test_udiv_2:
|
||||
; CHECK: i32.shr_u
|
||||
define i32 @test_udiv_2(i32 %x) {
|
||||
%t = udiv i32 %x, 2
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: test_udiv_5:
|
||||
; CHECK: i32.div_u
|
||||
define i32 @test_udiv_5(i32 %x) {
|
||||
%t = udiv i32 %x, 5
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: test_sdiv_2:
|
||||
; CHECK: i32.div_s
|
||||
define i32 @test_sdiv_2(i32 %x) {
|
||||
%t = sdiv i32 %x, 2
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: test_sdiv_5:
|
||||
; CHECK: i32.div_s
|
||||
define i32 @test_sdiv_5(i32 %x) {
|
||||
%t = sdiv i32 %x, 5
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: test_urem_2:
|
||||
; CHECK: i32.and
|
||||
define i32 @test_urem_2(i32 %x) {
|
||||
%t = urem i32 %x, 2
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: test_urem_5:
|
||||
; CHECK: i32.rem_u
|
||||
define i32 @test_urem_5(i32 %x) {
|
||||
%t = urem i32 %x, 5
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: test_srem_2:
|
||||
; CHECK: i32.rem_s
|
||||
define i32 @test_srem_2(i32 %x) {
|
||||
%t = srem i32 %x, 2
|
||||
ret i32 %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: test_srem_5:
|
||||
; CHECK: i32.rem_s
|
||||
define i32 @test_srem_5(i32 %x) {
|
||||
%t = srem i32 %x, 5
|
||||
ret i32 %t
|
||||
}
|
||||
22
external/llvm/test/CodeGen/WebAssembly/exception.ll
vendored
Normal file
22
external/llvm/test/CodeGen/WebAssembly/exception.ll
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
declare void @llvm.wasm.throw(i32, i8*)
|
||||
declare void @llvm.wasm.rethrow()
|
||||
|
||||
; CHECK-LABEL: throw:
|
||||
; CHECK-NEXT: i32.const $push0=, 0
|
||||
; CHECK-NEXT: throw 0, $pop0
|
||||
define void @throw() {
|
||||
call void @llvm.wasm.throw(i32 0, i8* null)
|
||||
ret void
|
||||
}
|
||||
|
||||
; CHECK-LABEL: rethrow:
|
||||
; CHECK-NEXT: rethrow 0
|
||||
define void @rethrow() {
|
||||
call void @llvm.wasm.rethrow()
|
||||
ret void
|
||||
}
|
||||
29
external/llvm/test/CodeGen/WebAssembly/f16.ll
vendored
Normal file
29
external/llvm/test/CodeGen/WebAssembly/f16.ll
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel | FileCheck %s
|
||||
|
||||
; Test that f16 is expanded.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
; CHECK-LABEL: demote:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: i32.call $push[[L1:[0-9]+]]=, __gnu_f2h_ieee@FUNCTION, $pop[[L0]]{{$}}
|
||||
; CHECK-NEXT: f32.call $push[[L2:[0-9]+]]=, __gnu_h2f_ieee@FUNCTION, $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[L2]]{{$}}
|
||||
define half @demote(float %f) {
|
||||
%t = fptrunc float %f to half
|
||||
ret half %t
|
||||
}
|
||||
|
||||
; CHECK-LABEL: promote:
|
||||
; CHECK-NEXT: .param f32{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: get_local $push0=, 0{{$}}
|
||||
; CHECK-NEXT: return $pop0{{$}}
|
||||
define float @promote(half %f) {
|
||||
%t = fpext half %f to float
|
||||
ret float %t
|
||||
}
|
||||
156
external/llvm/test/CodeGen/WebAssembly/f32.ll
vendored
Normal file
156
external/llvm/test/CodeGen/WebAssembly/f32.ll
vendored
Normal file
@ -0,0 +1,156 @@
|
||||
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
|
||||
|
||||
; Test that basic 32-bit floating-point operations assemble as expected.
|
||||
|
||||
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
||||
target triple = "wasm32-unknown-unknown-wasm"
|
||||
|
||||
declare float @llvm.fabs.f32(float)
|
||||
declare float @llvm.copysign.f32(float, float)
|
||||
declare float @llvm.sqrt.f32(float)
|
||||
declare float @llvm.ceil.f32(float)
|
||||
declare float @llvm.floor.f32(float)
|
||||
declare float @llvm.trunc.f32(float)
|
||||
declare float @llvm.nearbyint.f32(float)
|
||||
declare float @llvm.rint.f32(float)
|
||||
declare float @llvm.fma.f32(float, float, float)
|
||||
|
||||
; CHECK-LABEL: fadd32:
|
||||
; CHECK-NEXT: .param f32, f32{{$}}
|
||||
; CHECK-NEXT: .result f32{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
|
||||
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
|
||||
; CHECK-NEXT: f32.add $push[[LR:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @fadd32(float %x, float %y) {
|
||||
%a = fadd float %x, %y
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fsub32:
|
||||
; CHECK: f32.sub $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @fsub32(float %x, float %y) {
|
||||
%a = fsub float %x, %y
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fmul32:
|
||||
; CHECK: f32.mul $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @fmul32(float %x, float %y) {
|
||||
%a = fmul float %x, %y
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fdiv32:
|
||||
; CHECK: f32.div $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @fdiv32(float %x, float %y) {
|
||||
%a = fdiv float %x, %y
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fabs32:
|
||||
; CHECK: f32.abs $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @fabs32(float %x) {
|
||||
%a = call float @llvm.fabs.f32(float %x)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fneg32:
|
||||
; CHECK: f32.neg $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @fneg32(float %x) {
|
||||
%a = fsub float -0., %x
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: copysign32:
|
||||
; CHECK: f32.copysign $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @copysign32(float %x, float %y) {
|
||||
%a = call float @llvm.copysign.f32(float %x, float %y)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: sqrt32:
|
||||
; CHECK: f32.sqrt $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @sqrt32(float %x) {
|
||||
%a = call float @llvm.sqrt.f32(float %x)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: ceil32:
|
||||
; CHECK: f32.ceil $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @ceil32(float %x) {
|
||||
%a = call float @llvm.ceil.f32(float %x)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: floor32:
|
||||
; CHECK: f32.floor $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @floor32(float %x) {
|
||||
%a = call float @llvm.floor.f32(float %x)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: trunc32:
|
||||
; CHECK: f32.trunc $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @trunc32(float %x) {
|
||||
%a = call float @llvm.trunc.f32(float %x)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: nearest32:
|
||||
; CHECK: f32.nearest $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @nearest32(float %x) {
|
||||
%a = call float @llvm.nearbyint.f32(float %x)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; CHECK-LABEL: nearest32_via_rint:
|
||||
; CHECK: f32.nearest $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @nearest32_via_rint(float %x) {
|
||||
%a = call float @llvm.rint.f32(float %x)
|
||||
ret float %a
|
||||
}
|
||||
|
||||
; Min and max tests. LLVM currently only forms fminnan and fmaxnan nodes in
|
||||
; cases where there's a single fcmp with a select and it can prove that one
|
||||
; of the arms is never NaN, so we only test that case. In the future if LLVM
|
||||
; learns to form fminnan/fmaxnan in more cases, we can write more general
|
||||
; tests.
|
||||
|
||||
; CHECK-LABEL: fmin32:
|
||||
; CHECK: f32.min $push1=, $pop{{[0-9]+}}, $pop[[LR]]{{$}}
|
||||
; CHECK-NEXT: return $pop1{{$}}
|
||||
define float @fmin32(float %x) {
|
||||
%a = fcmp ult float %x, 0.0
|
||||
%b = select i1 %a, float %x, float 0.0
|
||||
ret float %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fmax32:
|
||||
; CHECK: f32.max $push1=, $pop{{[0-9]+}}, $pop[[LR]]{{$}}
|
||||
; CHECK-NEXT: return $pop1{{$}}
|
||||
define float @fmax32(float %x) {
|
||||
%a = fcmp ugt float %x, 0.0
|
||||
%b = select i1 %a, float %x, float 0.0
|
||||
ret float %b
|
||||
}
|
||||
|
||||
; CHECK-LABEL: fma32:
|
||||
; CHECK: {{^}} f32.call $push[[LR:[0-9]+]]=, fmaf@FUNCTION, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
||||
; CHECK-NEXT: return $pop[[LR]]{{$}}
|
||||
define float @fma32(float %a, float %b, float %c) {
|
||||
%d = call float @llvm.fma.f32(float %a, float %b, float %c)
|
||||
ret float %d
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user