mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-31 20:51:52 +01:00
4bf7d5872e
Upgrade of the IR text tests should be the only thing blocking making typed byval mandatory. Partially done through regex and partially manual.
266 lines
7.9 KiB
LLVM
266 lines
7.9 KiB
LLVM
; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+tail-call | FileCheck --check-prefixes=CHECK,SLOW %s
|
|
; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -fast-isel -mattr=+tail-call | FileCheck --check-prefixes=CHECK,FAST %s
|
|
; RUN: llc < %s --filetype=obj -mattr=+tail-call | obj2yaml | FileCheck --check-prefix=YAML %s
|
|
|
|
; Test that the tail calls lower correctly
|
|
|
|
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
|
target triple = "wasm32-unknown-unknown"
|
|
|
|
%fn = type <{i32 (%fn, i32, i32)*}>
|
|
declare i1 @foo(i1)
|
|
declare i1 @bar(i1)
|
|
|
|
; CHECK-LABEL: recursive_notail_nullary:
|
|
; CHECK: {{^}} call recursive_notail_nullary{{$}}
|
|
; CHECK-NEXT: return
|
|
define void @recursive_notail_nullary() {
|
|
notail call void @recursive_notail_nullary()
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: recursive_musttail_nullary:
|
|
; CHECK: return_call recursive_musttail_nullary{{$}}
|
|
define void @recursive_musttail_nullary() {
|
|
musttail call void @recursive_musttail_nullary()
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: recursive_tail_nullary:
|
|
; SLOW: return_call recursive_tail_nullary{{$}}
|
|
; FAST: {{^}} call recursive_tail_nullary{{$}}
|
|
; FAST-NEXT: return{{$}}
|
|
define void @recursive_tail_nullary() {
|
|
tail call void @recursive_tail_nullary()
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: recursive_notail:
|
|
; CHECK: call $push[[L:[0-9]+]]=, recursive_notail, $0, $1{{$}}
|
|
; CHECK-NEXT: return $pop[[L]]{{$}}
|
|
define i32 @recursive_notail(i32 %x, i32 %y) {
|
|
%v = notail call i32 @recursive_notail(i32 %x, i32 %y)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: recursive_musttail:
|
|
; CHECK: return_call recursive_musttail, $0, $1{{$}}
|
|
define i32 @recursive_musttail(i32 %x, i32 %y) {
|
|
%v = musttail call i32 @recursive_musttail(i32 %x, i32 %y)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: recursive_tail:
|
|
; SLOW: return_call recursive_tail, $0, $1{{$}}
|
|
; FAST: call $push[[L:[0-9]+]]=, recursive_tail, $0, $1{{$}}
|
|
; FAST-NEXT: return $pop[[L]]{{$}}
|
|
define i32 @recursive_tail(i32 %x, i32 %y) {
|
|
%v = tail call i32 @recursive_tail(i32 %x, i32 %y)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: indirect_notail:
|
|
; CHECK: call_indirect $push[[L:[0-9]+]]=, $0, $1, $2, $0{{$}}
|
|
; CHECK-NEXT: return $pop[[L]]{{$}}
|
|
define i32 @indirect_notail(%fn %f, i32 %x, i32 %y) {
|
|
%p = extractvalue %fn %f, 0
|
|
%v = notail call i32 %p(%fn %f, i32 %x, i32 %y)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: indirect_musttail:
|
|
; CHECK: return_call_indirect , $0, $1, $2, $0{{$}}
|
|
define i32 @indirect_musttail(%fn %f, i32 %x, i32 %y) {
|
|
%p = extractvalue %fn %f, 0
|
|
%v = musttail call i32 %p(%fn %f, i32 %x, i32 %y)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: indirect_tail:
|
|
; CHECK: return_call_indirect , $0, $1, $2, $0{{$}}
|
|
define i32 @indirect_tail(%fn %f, i32 %x, i32 %y) {
|
|
%p = extractvalue %fn %f, 0
|
|
%v = tail call i32 %p(%fn %f, i32 %x, i32 %y)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: choice_notail:
|
|
; CHECK: call_indirect $push[[L:[0-9]+]]=, $0, $pop{{[0-9]+}}{{$}}
|
|
; CHECK-NEXT: return $pop[[L]]{{$}}
|
|
define i1 @choice_notail(i1 %x) {
|
|
%p = select i1 %x, i1 (i1)* @foo, i1 (i1)* @bar
|
|
%v = notail call i1 %p(i1 %x)
|
|
ret i1 %v
|
|
}
|
|
|
|
; CHECK-LABEL: choice_musttail:
|
|
; CHECK: return_call_indirect , $0, $pop{{[0-9]+}}{{$}}
|
|
define i1 @choice_musttail(i1 %x) {
|
|
%p = select i1 %x, i1 (i1)* @foo, i1 (i1)* @bar
|
|
%v = musttail call i1 %p(i1 %x)
|
|
ret i1 %v
|
|
}
|
|
|
|
; CHECK-LABEL: choice_tail:
|
|
; SLOW: return_call_indirect , $0, $pop{{[0-9]+}}{{$}}
|
|
; FAST: call_indirect $push[[L:[0-9]+]]=, $0, $pop{{[0-9]+}}{{$}}
|
|
; FAST: return $pop[[L]]{{$}}
|
|
define i1 @choice_tail(i1 %x) {
|
|
%p = select i1 %x, i1 (i1)* @foo, i1 (i1)* @bar
|
|
%v = tail call i1 %p(i1 %x)
|
|
ret i1 %v
|
|
}
|
|
|
|
; It is an LLVM validation error for a 'musttail' callee to have a different
|
|
; prototype than its caller, so the following tests can only be done with
|
|
; 'tail'.
|
|
|
|
; CHECK-LABEL: mismatched_prototypes:
|
|
; SLOW: return_call baz, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
|
; FAST: call $push[[L:[0-9]+]]=, baz, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
|
; FAST: return $pop[[L]]{{$}}
|
|
declare i32 @baz(i32, i32, i32)
|
|
define i32 @mismatched_prototypes() {
|
|
%v = tail call i32 @baz(i32 0, i32 42, i32 6)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: mismatched_return_void:
|
|
; CHECK: call $drop=, baz, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
|
; CHECK: return{{$}}
|
|
define void @mismatched_return_void() {
|
|
%v = tail call i32 @baz(i32 0, i32 42, i32 6)
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: mismatched_return_f32:
|
|
; CHECK: call $push[[L:[0-9]+]]=, baz, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}}
|
|
; CHECK: f32.reinterpret_i32 $push[[L1:[0-9]+]]=, $pop[[L]]{{$}}
|
|
; CHECK: return $pop[[L1]]{{$}}
|
|
define float @mismatched_return_f32() {
|
|
%v = tail call i32 @baz(i32 0, i32 42, i32 6)
|
|
%u = bitcast i32 %v to float
|
|
ret float %u
|
|
}
|
|
|
|
; CHECK-LABEL: mismatched_indirect_void:
|
|
; CHECK: call_indirect $drop=, $0, $1, $2, $0{{$}}
|
|
; CHECK: return{{$}}
|
|
define void @mismatched_indirect_void(%fn %f, i32 %x, i32 %y) {
|
|
%p = extractvalue %fn %f, 0
|
|
%v = tail call i32 %p(%fn %f, i32 %x, i32 %y)
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: mismatched_indirect_f32:
|
|
; CHECK: call_indirect $push[[L:[0-9]+]]=, $0, $1, $2, $0{{$}}
|
|
; CHECK: f32.reinterpret_i32 $push[[L1:[0-9]+]]=, $pop[[L]]{{$}}
|
|
; CHECK: return $pop[[L1]]{{$}}
|
|
define float @mismatched_indirect_f32(%fn %f, i32 %x, i32 %y) {
|
|
%p = extractvalue %fn %f, 0
|
|
%v = tail call i32 %p(%fn %f, i32 %x, i32 %y)
|
|
%u = bitcast i32 %v to float
|
|
ret float %u
|
|
}
|
|
|
|
; CHECK-LABEL: mismatched_byval:
|
|
; CHECK: i32.store
|
|
; CHECK: return_call quux, $pop{{[0-9]+}}{{$}}
|
|
declare i32 @quux(i32* byval(i32))
|
|
define i32 @mismatched_byval(i32* %x) {
|
|
%v = tail call i32 @quux(i32* byval(i32) %x)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: varargs:
|
|
; CHECK: i32.store
|
|
; CHECK: call $0=, var, $1{{$}}
|
|
; CHECK: return $0{{$}}
|
|
declare i32 @var(...)
|
|
define i32 @varargs(i32 %x) {
|
|
%v = tail call i32 (...) @var(i32 %x)
|
|
ret i32 %v
|
|
}
|
|
|
|
; Type transformations inhibit tail calls, even when they are nops
|
|
|
|
; CHECK-LABEL: mismatched_return_zext:
|
|
; CHECK: call
|
|
define i32 @mismatched_return_zext() {
|
|
%v = tail call i1 @foo(i1 1)
|
|
%u = zext i1 %v to i32
|
|
ret i32 %u
|
|
}
|
|
|
|
; CHECK-LABEL: mismatched_return_sext:
|
|
; CHECK: call
|
|
define i32 @mismatched_return_sext() {
|
|
%v = tail call i1 @foo(i1 1)
|
|
%u = sext i1 %v to i32
|
|
ret i32 %u
|
|
}
|
|
|
|
; CHECK-LABEL: mismatched_return_trunc:
|
|
; CHECK: call
|
|
declare i32 @int()
|
|
define i1 @mismatched_return_trunc() {
|
|
%v = tail call i32 @int()
|
|
%u = trunc i32 %v to i1
|
|
ret i1 %u
|
|
}
|
|
|
|
; Stack-allocated arguments inhibit tail calls
|
|
|
|
; CHECK-LABEL: stack_arg:
|
|
; CHECK: call
|
|
define i32 @stack_arg(i32* %x) {
|
|
%a = alloca i32
|
|
%v = tail call i32 @stack_arg(i32* %a)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: stack_arg_gep:
|
|
; CHECK: call
|
|
define i32 @stack_arg_gep(i32* %x) {
|
|
%a = alloca { i32, i32 }
|
|
%p = getelementptr { i32, i32 }, { i32, i32 }* %a, i32 0, i32 1
|
|
%v = tail call i32 @stack_arg_gep(i32* %p)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: stack_arg_cast:
|
|
; CHECK: global.get $push{{[0-9]+}}=, __stack_pointer
|
|
; CHECK: global.set __stack_pointer, $pop{{[0-9]+}}
|
|
; FAST: call ${{[0-9]+}}=, stack_arg_cast, $pop{{[0-9]+}}
|
|
; CHECK: global.set __stack_pointer, $pop{{[0-9]+}}
|
|
; SLOW: return_call stack_arg_cast, ${{[0-9]+}}
|
|
define i32 @stack_arg_cast(i32 %x) {
|
|
%a = alloca [64 x i32]
|
|
%i = ptrtoint [64 x i32]* %a to i32
|
|
%v = tail call i32 @stack_arg_cast(i32 %i)
|
|
ret i32 %v
|
|
}
|
|
|
|
; Check that the signatures generated for external indirectly
|
|
; return-called functions include the proper return types
|
|
|
|
; YAML-LABEL: - Index: 8
|
|
; YAML-NEXT: ParamTypes:
|
|
; YAML-NEXT: - I32
|
|
; YAML-NEXT: - F32
|
|
; YAML-NEXT: - I64
|
|
; YAML-NEXT: - F64
|
|
; YAML-NEXT: ReturnTypes:
|
|
; YAML-NEXT: - I32
|
|
define i32 @unique_caller(i32 (i32, float, i64, double)** %p) {
|
|
%f = load i32 (i32, float, i64, double)*, i32 (i32, float, i64, double)** %p
|
|
%v = tail call i32 %f(i32 0, float 0., i64 0, double 0.)
|
|
ret i32 %v
|
|
}
|
|
|
|
; CHECK-LABEL: .section .custom_section.target_features
|
|
; CHECK-NEXT: .int8 1
|
|
; CHECK-NEXT: .int8 43
|
|
; CHECK-NEXT: .int8 9
|
|
; CHECK-NEXT: .ascii "tail-call"
|