From: Philip Reames Date: Tue, 12 Feb 2019 00:12:46 +0000 (+0000) Subject: [Test] Use autogenerated checks for more statepoint tests X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=6f6c9d03984579bea6a24ec3ad0537abedacf195;p=llvm [Test] Use autogenerated checks for more statepoint tests git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@353776 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/test/CodeGen/X86/statepoint-allocas.ll b/test/CodeGen/X86/statepoint-allocas.ll index bd820e0b83d..c7bae8ff18c 100644 --- a/test/CodeGen/X86/statepoint-allocas.ll +++ b/test/CodeGen/X86/statepoint-allocas.ll @@ -1,23 +1,28 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; RUN: llc -verify-machineinstrs < %s | FileCheck %s ; Check that we can lower a use of an alloca both as a deopt value (where the ; exact meaning is up to the consumer of the stackmap) and as an explicit spill -; slot used for GC. +; slot used for GC. target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-pc-linux-gnu" declare zeroext i1 @return_i1() -; Can we handle an explicit relocation slot (in the form of an alloca) given +; Can we handle an explicit relocation slot (in the form of an alloca) given ; to the statepoint? define i32 addrspace(1)* @test(i32 addrspace(1)* %ptr) gc "statepoint-example" { -; CHECK-LABEL: test -; CHECK: pushq %rax -; CHECK: movq %rdi, (%rsp) -; CHECK: callq return_i1 -; CHECK: movq (%rsp), %rax -; CHECK: popq %rcx -; CHECK: retq +; CHECK-LABEL: test: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: movq %rdi, (%rsp) +; CHECK-NEXT: callq return_i1 +; CHECK-NEXT: .Ltmp0: +; CHECK-NEXT: movq (%rsp), %rax +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: %alloca = alloca i32 addrspace(1)*, align 8 store i32 addrspace(1)* %ptr, i32 addrspace(1)** %alloca @@ -26,15 +31,19 @@ entry: ret i32 addrspace(1)* %rel } -; Can we handle an alloca as a deopt value? +; Can we handle an alloca as a deopt value? define i32 addrspace(1)* @test2(i32 addrspace(1)* %ptr) gc "statepoint-example" { -; CHECK-LABEL: test2 -; CHECK: pushq %rax -; CHECK: movq %rdi, (%rsp) -; CHECK: callq return_i1 -; CHECK: xorl %eax, %eax -; CHECK: popq %rcx -; CHECK: retq +; CHECK-LABEL: test2: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: movq %rdi, (%rsp) +; CHECK-NEXT: callq return_i1 +; CHECK-NEXT: .Ltmp1: +; CHECK-NEXT: xorl %eax, %eax +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: %alloca = alloca i32 addrspace(1)*, align 8 store i32 addrspace(1)* %ptr, i32 addrspace(1)** %alloca diff --git a/test/CodeGen/X86/statepoint-call-lowering.ll b/test/CodeGen/X86/statepoint-call-lowering.ll index 2020b8d43bf..bc312b71f6b 100644 --- a/test/CodeGen/X86/statepoint-call-lowering.ll +++ b/test/CodeGen/X86/statepoint-call-lowering.ll @@ -1,3 +1,4 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; RUN: llc -verify-machineinstrs < %s | FileCheck %s ; This file contains a collection of basic tests to ensure we didn't ; screw up normal call lowering when there are no deopt or gc arguments. @@ -15,13 +16,17 @@ declare %struct @return_struct() declare void @varargf(i32, ...) define i1 @test_i1_return() gc "statepoint-example" { -; CHECK-LABEL: test_i1_return +; CHECK-LABEL: test_i1_return: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: callq return_i1 +; CHECK-NEXT: .Ltmp0: +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq ; This is just checking that a i1 gets lowered normally when there's no extra ; state arguments to the statepoint -; CHECK: pushq %rax -; CHECK: callq return_i1 -; CHECK: popq %rcx -; CHECK: retq entry: %safepoint_token = tail call token (i64, i32, i1 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 ()* @return_i1, i32 0, i32 0, i32 0, i32 0) %call1 = call zeroext i1 @llvm.experimental.gc.result.i1(token %safepoint_token) @@ -29,11 +34,15 @@ entry: } define i32 @test_i32_return() gc "statepoint-example" { -; CHECK-LABEL: test_i32_return -; CHECK: pushq %rax -; CHECK: callq return_i32 -; CHECK: popq %rcx -; CHECK: retq +; CHECK-LABEL: test_i32_return: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: callq return_i32 +; CHECK-NEXT: .Ltmp1: +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: %safepoint_token = tail call token (i64, i32, i32 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i64 0, i32 0, i32 ()* @return_i32, i32 0, i32 0, i32 0, i32 0) %call1 = call zeroext i32 @llvm.experimental.gc.result.i32(token %safepoint_token) @@ -41,11 +50,15 @@ entry: } define i32* @test_i32ptr_return() gc "statepoint-example" { -; CHECK-LABEL: test_i32ptr_return -; CHECK: pushq %rax -; CHECK: callq return_i32ptr -; CHECK: popq %rcx -; CHECK: retq +; CHECK-LABEL: test_i32ptr_return: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: callq return_i32ptr +; CHECK-NEXT: .Ltmp2: +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: %safepoint_token = tail call token (i64, i32, i32* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p0i32f(i64 0, i32 0, i32* ()* @return_i32ptr, i32 0, i32 0, i32 0, i32 0) %call1 = call i32* @llvm.experimental.gc.result.p0i32(token %safepoint_token) @@ -53,11 +66,15 @@ entry: } define float @test_float_return() gc "statepoint-example" { -; CHECK-LABEL: test_float_return -; CHECK: pushq %rax -; CHECK: callq return_float -; CHECK: popq %rax -; CHECK: retq +; CHECK-LABEL: test_float_return: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: callq return_float +; CHECK-NEXT: .Ltmp3: +; CHECK-NEXT: popq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: %safepoint_token = tail call token (i64, i32, float ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_f32f(i64 0, i32 0, float ()* @return_float, i32 0, i32 0, i32 0, i32 0) %call1 = call float @llvm.experimental.gc.result.f32(token %safepoint_token) @@ -65,11 +82,15 @@ entry: } define %struct @test_struct_return() gc "statepoint-example" { -; CHECK-LABEL: test_struct_return -; CHECK: pushq %rax -; CHECK: callq return_struct -; CHECK: popq %rcx -; CHECK: retq +; CHECK-LABEL: test_struct_return: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: callq return_struct +; CHECK-NEXT: .Ltmp4: +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: %safepoint_token = tail call token (i64, i32, %struct ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_structf(i64 0, i32 0, %struct ()* @return_struct, i32 0, i32 0, i32 0, i32 0) %call1 = call %struct @llvm.experimental.gc.result.struct(token %safepoint_token) @@ -77,14 +98,17 @@ entry: } define i1 @test_relocate(i32 addrspace(1)* %a) gc "statepoint-example" { -; CHECK-LABEL: test_relocate +; CHECK-LABEL: test_relocate: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: movq %rdi, (%rsp) +; CHECK-NEXT: callq return_i1 +; CHECK-NEXT: .Ltmp5: +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq ; Check that an ununsed relocate has no code-generation impact -; CHECK: pushq %rax -; CHECK: callq return_i1 -; CHECK-NEXT: .Ltmp5: -; CHECK-NEXT: popq %rcx -; CHECK-NEXT: .cfi_def_cfa_offset 8 -; CHECK-NEXT: retq entry: %safepoint_token = tail call token (i64, i32, i1 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 ()* @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %a) %call1 = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(token %safepoint_token, i32 7, i32 7) @@ -93,9 +117,18 @@ entry: } define void @test_void_vararg() gc "statepoint-example" { -; CHECK-LABEL: test_void_vararg +; CHECK-LABEL: test_void_vararg: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: movl $42, %edi +; CHECK-NEXT: movl $43, %esi +; CHECK-NEXT: callq varargf +; CHECK-NEXT: .Ltmp6: +; CHECK-NEXT: popq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq ; Check a statepoint wrapping a *void* returning vararg function works -; CHECK: callq varargf entry: %safepoint_token = tail call token (i64, i32, void (i32, ...)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(i64 0, i32 0, void (i32, ...)* @varargf, i32 2, i32 0, i32 42, i32 43, i32 0, i32 0) ;; if we try to use the result from a statepoint wrapping a @@ -104,12 +137,17 @@ entry: } define i1 @test_i1_return_patchable() gc "statepoint-example" { -; CHECK-LABEL: test_i1_return_patchable +; CHECK-LABEL: test_i1_return_patchable: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: xorl %eax, %eax +; CHECK-NEXT: nopl (%rax) +; CHECK-NEXT: .Ltmp7: +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq ; A patchable variant of test_i1_return -; CHECK: pushq %rax -; CHECK: nopl -; CHECK: popq %rcx -; CHECK: retq entry: %safepoint_token = tail call token (i64, i32, i1 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 3, i1 ()*null, i32 0, i32 0, i32 0, i32 0) %call1 = call zeroext i1 @llvm.experimental.gc.result.i1(token %safepoint_token) @@ -119,13 +157,38 @@ entry: declare void @consume(i32 addrspace(1)* %obj) define i1 @test_cross_bb(i32 addrspace(1)* %a, i1 %external_cond) gc "statepoint-example" { -; CHECK-LABEL: test_cross_bb -; CHECK: movq -; CHECK: callq return_i1 -; CHECK: %left -; CHECK: movq -; CHECK-NEXT: callq consume -; CHECK: retq +; CHECK-LABEL: test_cross_bb: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rbp +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: pushq %rbx +; CHECK-NEXT: .cfi_def_cfa_offset 24 +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 32 +; CHECK-NEXT: .cfi_offset %rbx, -24 +; CHECK-NEXT: .cfi_offset %rbp, -16 +; CHECK-NEXT: movl %esi, %ebp +; CHECK-NEXT: movq %rdi, (%rsp) +; CHECK-NEXT: callq return_i1 +; CHECK-NEXT: .Ltmp8: +; CHECK-NEXT: testb $1, %bpl +; CHECK-NEXT: je .LBB8_2 +; CHECK-NEXT: # %bb.1: # %left +; CHECK-NEXT: movl %eax, %ebx +; CHECK-NEXT: movq (%rsp), %rdi +; CHECK-NEXT: callq consume +; CHECK-NEXT: movl %ebx, %eax +; CHECK-NEXT: jmp .LBB8_3 +; CHECK-NEXT: .LBB8_2: # %right +; CHECK-NEXT: movb $1, %al +; CHECK-NEXT: .LBB8_3: # %right +; CHECK-NEXT: addq $8, %rsp +; CHECK-NEXT: .cfi_def_cfa_offset 24 +; CHECK-NEXT: popq %rbx +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: popq %rbp +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: %safepoint_token = tail call token (i64, i32, i1 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 ()* @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %a) br i1 %external_cond, label %left, label %right @@ -145,17 +208,34 @@ right: declare void @consume_attributes(i32, i8* nest, i32, %struct2* byval) define void @test_attributes(%struct2* byval %s) gc "statepoint-example" { +; CHECK-LABEL: test_attributes: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: subq $8, %rsp +; CHECK-NEXT: .cfi_adjust_cfa_offset 8 +; CHECK-NEXT: movq {{[0-9]+}}(%rsp), %rax +; CHECK-NEXT: movq {{[0-9]+}}(%rsp), %rcx +; CHECK-NEXT: movq {{[0-9]+}}(%rsp), %rdx +; CHECK-NEXT: movl $42, %edi +; CHECK-NEXT: xorl %r10d, %r10d +; CHECK-NEXT: movl $17, %esi +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_adjust_cfa_offset 8 +; CHECK-NEXT: pushq %rdx +; CHECK-NEXT: .cfi_adjust_cfa_offset 8 +; CHECK-NEXT: pushq %rcx +; CHECK-NEXT: .cfi_adjust_cfa_offset 8 +; CHECK-NEXT: callq consume_attributes +; CHECK-NEXT: .Ltmp9: +; CHECK-NEXT: addq $32, %rsp +; CHECK-NEXT: .cfi_adjust_cfa_offset -32 +; CHECK-NEXT: popq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: -; CHECK-LABEL: test_attributes ; Check that arguments with attributes are lowered correctly. ; We call a function that has a nest argument and a byval argument. -; CHECK: movl $42, %edi -; CHECK: xorl %r10d, %r10d -; CHECK: movl $17, %esi -; CHECK: pushq -; CHECK: pushq -; CHECK: pushq -; CHECK: callq consume_attributes %statepoint_token = call token (i64, i32, void (i32, i8*, i32, %struct2*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi32p0i8i32p0s_struct2sf(i64 0, i32 0, void (i32, i8*, i32, %struct2*)* @consume_attributes, i32 4, i32 0, i32 42, i8* nest null, i32 17, %struct2* byval %s, i32 0, i32 0) ret void } diff --git a/test/CodeGen/X86/statepoint-far-call.ll b/test/CodeGen/X86/statepoint-far-call.ll index 9f9b684efae..487829857f8 100644 --- a/test/CodeGen/X86/statepoint-far-call.ll +++ b/test/CodeGen/X86/statepoint-far-call.ll @@ -1,3 +1,4 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; RUN: llc -verify-machineinstrs < %s | FileCheck %s ; Test to check that Statepoints with X64 far-immediate targets ; are lowered correctly to an indirect call via a scratch register. @@ -6,15 +7,19 @@ target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-pc-win64" define void @test_far_call() gc "statepoint-example" { -; CHECK-LABEL: test_far_call -; CHECK: pushq %rax -; CHECK: movabsq $140727162896504, %rax -; CHECK: callq *%rax -; CHECK: popq %rax -; CHECK: retq +; CHECK-LABEL: test_far_call: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: movabsq $140727162896504, %rax # imm = 0x7FFD988E0078 +; CHECK-NEXT: callq *%rax +; CHECK-NEXT: .Ltmp0: +; CHECK-NEXT: popq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq entry: - %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* inttoptr (i64 140727162896504 to void ()*), i32 0, i32 0, i32 0, i32 0) + %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* inttoptr (i64 140727162896504 to void ()*), i32 0, i32 0, i32 0, i32 0) ret void } diff --git a/test/CodeGen/X86/statepoint-invoke.ll b/test/CodeGen/X86/statepoint-invoke.ll index d4934e3b379..e0edac6e4e6 100644 --- a/test/CodeGen/X86/statepoint-invoke.ll +++ b/test/CodeGen/X86/statepoint-invoke.ll @@ -1,3 +1,4 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; RUN: llc -verify-machineinstrs < %s 2>&1 | FileCheck %s target triple = "x86_64-pc-linux-gnu" @@ -8,29 +9,43 @@ declare i64 addrspace(1)* @"some_other_call"(i64 addrspace(1)*) declare i32 @"personality_function"() define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, +; CHECK-LABEL: test_basic: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: subq $24, %rsp +; CHECK-NEXT: .cfi_def_cfa_offset 32 +; CHECK-NEXT: movq %rdi, {{[0-9]+}}(%rsp) +; CHECK-NEXT: movq %rsi, {{[0-9]+}}(%rsp) +; CHECK-NEXT: .Ltmp0: +; CHECK-NEXT: callq some_call +; CHECK-NEXT: .Ltmp3: +; CHECK-NEXT: .Ltmp1: +; CHECK-NEXT: # %bb.1: # %invoke_safepoint_normal_dest +; CHECK-NEXT: movq {{[0-9]+}}(%rsp), %rax +; CHECK-NEXT: addq $24, %rsp +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq +; CHECK-NEXT: .LBB0_2: # %exceptional_return +; CHECK-NEXT: .cfi_def_cfa_offset 32 +; CHECK-NEXT: .Ltmp2: +; CHECK-NEXT: movq {{[0-9]+}}(%rsp), %rax +; CHECK-NEXT: addq $24, %rsp +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @"personality_function" { entry: - ; CHECK: Ltmp{{[0-9]+}}: - ; CHECK: callq some_call - ; CHECK: Ltmp{{[0-9]+}}: %0 = invoke token (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) to label %invoke_safepoint_normal_dest unwind label %exceptional_return invoke_safepoint_normal_dest: - ; CHECK: movq %obj.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %0, i32 13, i32 13) %obj1.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %0, i32 14, i32 14) br label %normal_return normal_return: - ; CHECK: retq ret i64 addrspace(1)* %obj.relocated exceptional_return: - ; CHECK: Ltmp{{[0-9]+}}: - ; CHECK: movq - ; CHECK: retq %landing_pad = landingpad token cleanup %obj.relocated1 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %landing_pad, i32 13, i32 13) @@ -44,24 +59,37 @@ exceptional_return: ; CHECK: .p2align 4 define i64 addrspace(1)* @test_result(i64 addrspace(1)* %obj, +; CHECK-LABEL: test_result: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: movq %rdi, (%rsp) +; CHECK-NEXT: .Ltmp4: +; CHECK-NEXT: callq some_other_call +; CHECK-NEXT: .Ltmp7: +; CHECK-NEXT: .Ltmp5: +; CHECK-NEXT: # %bb.1: # %normal_return +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq +; CHECK-NEXT: .LBB1_2: # %exceptional_return +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: .Ltmp6: +; CHECK-NEXT: movq (%rsp), %rax +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function { entry: - ; CHECK: .Ltmp{{[0-9]+}}: - ; CHECK: callq some_other_call - ; CHECK: .Ltmp{{[0-9]+}}: %0 = invoke token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 0, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @some_other_call, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) to label %normal_return unwind label %exceptional_return normal_return: - ; CHECK: popq - ; CHECK: retq %ret_val = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(token %0) ret i64 addrspace(1)* %ret_val exceptional_return: - ; CHECK: .Ltmp{{[0-9]+}}: - ; CHECK: movq %landing_pad = landingpad token cleanup %obj.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %landing_pad, i32 13, i32 13) @@ -74,44 +102,80 @@ exceptional_return: ; CHECK: .p2align 4 define i64 addrspace(1)* @test_same_val(i1 %cond, i64 addrspace(1)* %val1, i64 addrspace(1)* %val2, i64 addrspace(1)* %val3) +; CHECK-LABEL: test_same_val: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rbx +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: subq $16, %rsp +; CHECK-NEXT: .cfi_def_cfa_offset 32 +; CHECK-NEXT: .cfi_offset %rbx, -16 +; CHECK-NEXT: movl %edi, %ebx +; CHECK-NEXT: testb $1, %bl +; CHECK-NEXT: je .LBB2_3 +; CHECK-NEXT: # %bb.1: # %left +; CHECK-NEXT: movq %rsi, (%rsp) +; CHECK-NEXT: movq %rdx, {{[0-9]+}}(%rsp) +; CHECK-NEXT: .Ltmp11: +; CHECK-NEXT: movq %rsi, %rdi +; CHECK-NEXT: callq some_call +; CHECK-NEXT: .Ltmp14: +; CHECK-NEXT: .Ltmp12: +; CHECK-NEXT: # %bb.2: # %left.relocs +; CHECK-NEXT: movq (%rsp), %rax +; CHECK-NEXT: movq {{[0-9]+}}(%rsp), %rcx +; CHECK-NEXT: jmp .LBB2_5 +; CHECK-NEXT: .LBB2_3: # %right +; CHECK-NEXT: movq %rdx, (%rsp) +; CHECK-NEXT: movq %rcx, {{[0-9]+}}(%rsp) +; CHECK-NEXT: .Ltmp8: +; CHECK-NEXT: movq %rsi, %rdi +; CHECK-NEXT: callq some_call +; CHECK-NEXT: .Ltmp15: +; CHECK-NEXT: .Ltmp9: +; CHECK-NEXT: # %bb.4: # %right.relocs +; CHECK-NEXT: movq (%rsp), %rcx +; CHECK-NEXT: movq {{[0-9]+}}(%rsp), %rax +; CHECK-NEXT: .LBB2_5: # %normal_return +; CHECK-NEXT: testb $1, %bl +; CHECK-NEXT: cmoveq %rcx, %rax +; CHECK-NEXT: .LBB2_6: # %normal_return +; CHECK-NEXT: addq $16, %rsp +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: popq %rbx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq +; CHECK-NEXT: .LBB2_9: # %exceptional_return.right +; CHECK-NEXT: .cfi_def_cfa_offset 32 +; CHECK-NEXT: .Ltmp10: +; CHECK-NEXT: movq (%rsp), %rax +; CHECK-NEXT: jmp .LBB2_6 +; CHECK-NEXT: .LBB2_7: # %exceptional_return.left +; CHECK-NEXT: .Ltmp13: +; CHECK-NEXT: movq (%rsp), %rax +; CHECK-NEXT: jmp .LBB2_6 gc "statepoint-example" personality i32 ()* @"personality_function" { entry: br i1 %cond, label %left, label %right left: - ; CHECK-LABEL: %left - ; CHECK: movq %rdx, 8(%rsp) - ; CHECK: movq - ; CHECK: callq some_call %sp1 = invoke token (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %val1, i64 addrspace(1)* %val2) to label %left.relocs unwind label %exceptional_return.left left.relocs: - ; CHECK: movq (%rsp), - ; CHECK: movq 8(%rsp), [[REGVAL2:%[a-z]+]] %val1.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %sp1, i32 13, i32 13) %val2.relocated_left = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %sp1, i32 14, i32 14) br label %normal_return right: - ; CHECK-LABEL: %right - ; CHECK: movq %rdx, (%rsp) - ; CHECK: movq - ; CHECK: callq some_call %sp2 = invoke token (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %val2, i64 addrspace(1)* %val3) to label %right.relocs unwind label %exceptional_return.right right.relocs: - ; CHECK: movq (%rsp), [[REGVAL2]] - ; CHECK: movq %val2.relocated_right = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %sp2, i32 13, i32 13) %val3.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %sp2, i32 14, i32 14) br label %normal_return normal_return: - ; CHECK-LABEL: %normal_return - ; CHECK: cmoveq {{.*}}[[REGVAL2]]{{.*}} - ; CHECK: retq %a1 = phi i64 addrspace(1)* [%val1.relocated, %left.relocs], [%val3.relocated, %right.relocs] %a2 = phi i64 addrspace(1)* [%val2.relocated_left, %left.relocs], [%val2.relocated_right, %right.relocs] %ret = select i1 %cond, i64 addrspace(1)* %a1, i64 addrspace(1)* %a2 @@ -131,19 +195,29 @@ exceptional_return.right: } define i64 addrspace(1)* @test_null_undef(i64 addrspace(1)* %val1) - gc "statepoint-example" personality i32 ()* @"personality_function" { ; CHECK-LABEL: test_null_undef: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: .Ltmp16: +; CHECK-NEXT: callq some_call +; CHECK-NEXT: .Ltmp19: +; CHECK-NEXT: .Ltmp17: +; CHECK-NEXT: .LBB3_1: # %normal_return +; CHECK-NEXT: xorl %eax, %eax +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq +; CHECK-NEXT: .LBB3_2: # %exceptional_return +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: .Ltmp18: +; CHECK-NEXT: jmp .LBB3_1 + gc "statepoint-example" personality i32 ()* @"personality_function" { entry: - ; CHECK: callq some_call %sp1 = invoke token (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* null, i64 addrspace(1)* undef) to label %normal_return unwind label %exceptional_return normal_return: - ; CHECK-LABEL: %normal_return - ; CHECK: xorl %eax, %eax - ; CHECK-NEXT: popq - ; CHECK-NEXT: .cfi_def_cfa_offset 8 - ; CHECK-NEXT: retq %null.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %sp1, i32 13, i32 13) %undef.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %sp1, i32 14, i32 14) ret i64 addrspace(1)* %null.relocated @@ -157,30 +231,40 @@ exceptional_return: } define i64 addrspace(1)* @test_alloca_and_const(i64 addrspace(1)* %val1) - gc "statepoint-example" personality i32 ()* @"personality_function" { ; CHECK-LABEL: test_alloca_and_const: +; CHECK: # %bb.0: # %entry +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: .Ltmp20: +; CHECK-NEXT: callq some_call +; CHECK-NEXT: .Ltmp23: +; CHECK-NEXT: .Ltmp21: +; CHECK-NEXT: # %bb.1: # %normal_return +; CHECK-NEXT: leaq {{[0-9]+}}(%rsp), %rax +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq +; CHECK-NEXT: .LBB4_2: # %exceptional_return +; CHECK-NEXT: .cfi_def_cfa_offset 16 +; CHECK-NEXT: .Ltmp22: +; CHECK-NEXT: movl $15, %eax +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: .cfi_def_cfa_offset 8 +; CHECK-NEXT: retq + gc "statepoint-example" personality i32 ()* @"personality_function" { entry: %a = alloca i32 %aa = addrspacecast i32* %a to i32 addrspace(1)* %c = inttoptr i64 15 to i64 addrspace(1)* - ; CHECK: callq %sp = invoke token (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %aa, i64 addrspace(1)* %c) to label %normal_return unwind label %exceptional_return normal_return: - ; CHECK: leaq - ; CHECK-NEXT: popq - ; CHECK-NEXT: .cfi_def_cfa_offset 8 - ; CHECK-NEXT: retq %aa.rel = call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(token %sp, i32 13, i32 13) %aa.converted = bitcast i32 addrspace(1)* %aa.rel to i64 addrspace(1)* ret i64 addrspace(1)* %aa.converted exceptional_return: - ; CHECK: movl $15 - ; CHECK-NEXT: popq - ; CHECK-NEXT: .cfi_def_cfa_offset 8 - ; CHECK-NEXT: retq %landing_pad = landingpad token cleanup %aa.rel2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %landing_pad, i32 14, i32 14)