[docs] More CMAKE variable documentation

[urnathan]

Summary

This follows from my D102481 collation of cmake variables by breaking out some (more) common llvm-specific variables. Controlling the subprojects and target architectures, along with clues about restricting build parallelism when linking. 'more common' is somewhat subjective, I take what I use defines that? :)

ok?

[aaron.ballman]

llvm/docs/CMake.rst

187 ↗

(On Diff #357959)

224 ↗

(On Diff #357959)

I'd move this up above the rarely-used section so that the list goes in order of most-used to least-used. WDYT?

225 ↗

(On Diff #357959)

Underlines are off here, so sphinx will complain about this.

228 ↗

(On Diff #357959)

One thing that's interesting about this is that I don't know that they're LLVM variables or not. LLVM_ENABLE_PROJECTS isn't really LLVM-specific, it decides what to build as part of the whole project. Similar logic applies to a lot of these items. The only one that's really LLVM-specific in this list is LLVM_TARGETS_TO_BUILD, but even that one impacts Clang.

261 ↗

(On Diff #357959)

[urnathan]

llvm/docs/CMake.rst

224 ↗

(On Diff #357959)

I wasn;t sure myself, your comment is enough to do the ordering you suggest.

225 ↗

(On Diff #357959)

I don't know what that means -- I tried to figure out how to sphinx it, but failed. I (attempted to) match the formatting of other section headers.

228 ↗

(On Diff #357959)

Agreed, there's an unfortunate use of LLVM to mean both 'LLVM library' and 'LLVM project'. I don't know the best way to disambiguate that -- or how to categorize these variables.

261 ↗

(On Diff #357959)

muscle memory for the lose!

[urnathan]

thanks for the comments. I've addressed what I can, but I don't understand the sphinx thing.

[aaron.ballman]

llvm/docs/CMake.rst

213–214 ↗

(On Diff #358740)

225 ↗

(On Diff #357959)

The count of underlines needs to match the count of characters on the line. I made a suggested edit to show what I mean.

228 ↗

(On Diff #357959)

How about using LLVM-related instead of LLVM-specific in the section title and prose? Alternatively, we could just stick them under frequently used and not call out LLVM at all?

[xgupta]

I think newcomers first visit getting started to know the common practice or frequently used variable. It will be duplication to write a similar heading in CMake.rst

llvm/docs/CMake.rst

211 ↗

(On Diff #358740)

I think similar documentation is available on getting started page - https://llvm.org/docs/GettingStarted.html#getting-the-source-code-and-building-llvm, https://llvm.org/docs/GettingStarted.html#local-llvm-configuration and https://llvm.org/docs/GettingStarted.html#common-problems.

And again the same variables are listed on the same cmake.rst page below so again a duplication.

[urnathan]

llvm/docs/CMake.rst

225 ↗

(On Diff #357959)

ah, I see, thanks.

[aaron.ballman]

I think you may have uploaded the wrong patch, @urnathan. ;-)

[urnathan]

Let's try that again

[aaron.ballman]

LGTM, thank you for the improvements!

llvm/docs/CMake.rst

195–198 ↗

(On Diff #358950)

You can re-flow these lines to 80 col.

211 ↗

(On Diff #358740)

Good catch on the repeated documentation in places. As a follow-up, it might be nice to have all of those places point to this documentation so we have everything funneled into one place. But I don't think that needs to happen as part of this patch.

[xgupta]

llvm/docs/CMake.rst

211 ↗

(On Diff #358740)

Sounds good to me

llvm/test/CodeGen/X86/sibcall.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -verify-machineinstrs < %s -mtriple=i686-linux   -mcpu=core2 -mattr=+sse2 | FileCheck %s --check-prefix=X86
 ; RUN: llc -verify-machineinstrs < %s -mtriple=x86_64-linux -mcpu=core2 -mattr=+sse2 | FileCheck %s --check-prefix=X64
 ; RUN: llc -verify-machineinstrs < %s -mtriple=x86_64-linux-gnux32 -mcpu=core2 -mattr=+sse2  | FileCheck %s --check-prefix=X32
+; RUN: llc -verify-machineinstrs < %s -mtriple=x86_64-win64 -mcpu=core2 -mattr=+sse2 | FileCheck %s --check-prefix=X64
 
+; Tailcall legal: Incomming arg is discarded (and maybe popped by caller)
 define dso_local void @t1(i32 %x) nounwind ssp {
+  tail call void @foo() nounwind
+  ret void
+}
 ; X86-LABEL: t1:
 ; X86:       # %bb.0:
 ; X86-NEXT:    jmp foo # TAILCALL
 ;
 ; X64-LABEL: t1:
 ; X64:       # %bb.0:
 ; X64-NEXT:    jmp foo # TAILCALL
 ;
 ; X32-LABEL: t1:
 ; X32:       # %bb.0:
 ; X32-NEXT:    jmp foo # TAILCALL
-  tail call void @foo() nounwind
-  ret void
-}
 
 declare dso_local void @foo()
 
+; Tailcall legal: Caller and callee return nothing
 define dso_local void @t2() nounwind ssp {
+  %t0 = tail call i32 @foo2() nounwind
+  ret void
+}
 ; X86-LABEL: t2:
 ; X86:       # %bb.0:
 ; X86-NEXT:    jmp foo2 # TAILCALL
 ;
 ; X64-LABEL: t2:
 ; X64:       # %bb.0:
 ; X64-NEXT:    jmp foo2 # TAILCALL
 ;
 ; X32-LABEL: t2:
 ; X32:       # %bb.0:
 ; X32-NEXT:    jmp foo2 # TAILCALL
-  %t0 = tail call i32 @foo2() nounwind
-  ret void
-}
 
 declare dso_local i32 @foo2()
 
+; Tailcall legal: callee's result is discarded
 define dso_local void @t3() nounwind ssp {
+  %t0 = tail call i32 @foo3() nounwind
+  ret void
+}
 ; X86-LABEL: t3:
 ; X86:       # %bb.0:
 ; X86-NEXT:    jmp foo3 # TAILCALL
 ;
 ; X64-LABEL: t3:
 ; X64:       # %bb.0:
 ; X64-NEXT:    jmp foo3 # TAILCALL
 ;
 ; X32-LABEL: t3:
 ; X32:       # %bb.0:
 ; X32-NEXT:    jmp foo3 # TAILCALL
-  %t0 = tail call i32 @foo3() nounwind
-  ret void
-}
 
 declare dso_local i32 @foo3()
 
+; Tailcall legal: nothing special about function pointers
+; QOI: We fail on i686, which passes args on the stack.  We don't
+; consider rewriting that.  (The ABI might specify that the incoming
+; args are not callee-clobberable? And such rewriting can get hairy
+; due to RAW conflicts)
 define dso_local void @t4(void (i32)* nocapture %x) nounwind ssp {
+  tail call void %x(i32 0) nounwind
+  ret void
+}
 ; X86-LABEL: t4:
 ; X86:       # %bb.0:
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    movl $0, (%esp)
 ; X86-NEXT:    calll *{{[0-9]+}}(%esp)
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t4:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movq %rdi, %rax
 ; X64-NEXT:    xorl %edi, %edi
 ; X64-NEXT:    jmpq *%rax # TAILCALL
 ;
 ; X32-LABEL: t4:
 ; X32:       # %bb.0:
 ; X32-NEXT:    movq %rdi, %rax
 ; X32-NEXT:    xorl %edi, %edi
 ; X32-NEXT:    jmpq *%rax # TAILCALL
-  tail call void %x(i32 0) nounwind
-  ret void
-}
 
+; Tailcall legal: nothing special about function pointers
 define dso_local void @t5(void ()* nocapture %x) nounwind ssp {
+  tail call void %x() nounwind
+  ret void
+}
 ; X86-LABEL: t5:
 ; X86:       # %bb.0:
 ; X86-NEXT:    jmpl *{{[0-9]+}}(%esp) # TAILCALL
 ;
 ; X64-LABEL: t5:
 ; X64:       # %bb.0:
 ; X64-NEXT:    jmpq *%rdi # TAILCALL
 ;
 ; X32-LABEL: t5:
 ; X32:       # %bb.0:
 ; X32-NEXT:    jmpq *%rdi # TAILCALL
+
+; Tailcall legal: basically the same test as t5, except pass the
+; function pointer on the stack for all ABI tested.
+define dso_local void @t5_x64(i32, i32, i32, i32, i32, i32, void ()* nocapture %x) nounwind ssp {
   tail call void %x() nounwind
   ret void
 }
-
-; Basically the same test as t5, except pass the function pointer on the stack
-; for x86_64.
-
-define dso_local void @t5_x64(i32, i32, i32, i32, i32, i32, void ()* nocapture %x) nounwind ssp {
 ; X86-LABEL: t5_x64:
 ; X86:       # %bb.0:
 ; X86-NEXT:    jmpl *{{[0-9]+}}(%esp) # TAILCALL
 ;
 ; X64-LABEL: t5_x64:
 ; X64:       # %bb.0:
 ; X64-NEXT:    jmpq *{{[0-9]+}}(%rsp) # TAILCALL
 ;
 ; X32-LABEL: t5_x64:
 ; X32:       # %bb.0:
 ; X32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X32-NEXT:    jmpq *%rax # TAILCALL
-  tail call void %x() nounwind
-  ret void
-}
-
 
+; Tailcall legal: Both @bar and @t6 can be tailcalled.
+; QOI we don't tailcall @t6 when args are on the stack for the same
+; reason as t4.
 define dso_local i32 @t6(i32 %x) nounwind ssp {
+  %t0 = icmp slt i32 %x, 10
+  br i1 %t0, label %bb, label %bb1
+
+bb:
+  %t1 = add nsw i32 %x, -1
+  %t2 = tail call i32 @t6(i32 %t1) nounwind ssp
+  ret i32 %t2
+
+bb1:
+  %t3 = tail call i32 @bar(i32 %x) nounwind
+  ret i32 %t3
+}
 ; X86-LABEL: t6:
 ; X86:       # %bb.0:
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    cmpl $9, %eax
 ; X86-NEXT:    jg .LBB6_2
 ; X86-NEXT:  # %bb.1: # %bb
 ; X86-NEXT:    decl %eax

 ; X32:       # %bb.0:
 ; X32-NEXT:    cmpl $9, %edi
 ; X32-NEXT:    jg .LBB6_2
 ; X32-NEXT:  # %bb.1: # %bb
 ; X32-NEXT:    decl %edi
 ; X32-NEXT:    jmp t6 # TAILCALL
 ; X32-NEXT:  .LBB6_2: # %bb1
 ; X32-NEXT:    jmp bar # TAILCALL
-  %t0 = icmp slt i32 %x, 10
-  br i1 %t0, label %bb, label %bb1
-
-bb:
-  %t1 = add nsw i32 %x, -1
-  %t2 = tail call i32 @t6(i32 %t1) nounwind ssp
-  ret i32 %t2
-
-bb1:
-  %t3 = tail call i32 @bar(i32 %x) nounwind
-  ret i32 %t3
-}
 
 declare dso_local i32 @bar(i32)
 
+;; Tailcall legal: we're just a forwarding function.
 define dso_local i32 @t7(i32 %a, i32 %b, i32 %c) nounwind ssp {
+  %t0 = tail call i32 @bar2(i32 %a, i32 %b, i32 %c) nounwind
+  ret i32 %t0
+}
 ; X86-LABEL: t7:
 ; X86:       # %bb.0:
 ; X86-NEXT:    jmp bar2 # TAILCALL
 ;
 ; X64-LABEL: t7:
 ; X64:       # %bb.0:
 ; X64-NEXT:    jmp bar2 # TAILCALL
 ;
 ; X32-LABEL: t7:
 ; X32:       # %bb.0:
 ; X32-NEXT:    jmp bar2 # TAILCALL
-  %t0 = tail call i32 @bar2(i32 %a, i32 %b, i32 %c) nounwind
-  ret i32 %t0
-}
 
 declare dso_local i32 @bar2(i32, i32, i32)
 
+; Tailcall legal: still forwarding.
 define signext i16 @t8() nounwind ssp {
+entry:
+  %0 = tail call signext i16 @bar3() nounwind      ; <i16> [#uses=1]
+  ret i16 %0
+}
 ; X86-LABEL: t8:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    jmp bar3 # TAILCALL
 ;
 ; X64-LABEL: t8:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    jmp bar3 # TAILCALL
 ;
 ; X32-LABEL: t8:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    jmp bar3 # TAILCALL
-entry:
-  %0 = tail call signext i16 @bar3() nounwind      ; <i16> [#uses=1]
-  ret i16 %0
-}
 
 declare dso_local signext i16 @bar3()
 
+; Tailcall legal: Caller and callee agree on sign extension.
+; QOI: As with t4, fail to overwrite stack-based arguments
 define signext i16 @t9(i32 (i32)* nocapture %x) nounwind ssp {
+entry:
+  %0 = bitcast i32 (i32)* %x to i16 (i32)*
+  %1 = tail call signext i16 %0(i32 0) nounwind
+  ret i16 %1
+}
 ; X86-LABEL: t9:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    movl $0, (%esp)
 ; X86-NEXT:    calll *{{[0-9]+}}(%esp)
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t9:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    movq %rdi, %rax
 ; X64-NEXT:    xorl %edi, %edi
 ; X64-NEXT:    jmpq *%rax # TAILCALL
 ;
 ; X32-LABEL: t9:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    movq %rdi, %rax
 ; X32-NEXT:    xorl %edi, %edi
 ; X32-NEXT:    jmpq *%rax # TAILCALL
-entry:
-  %0 = bitcast i32 (i32)* %x to i16 (i32)*
-  %1 = tail call signext i16 %0(i32 0) nounwind
-  ret i16 %1
-}
 
+; Tailcall legal: Just forwarding
+; QOI: We don't sibcall this for unknown reasons (the unreachable
+; rather than a ret?)
 define dso_local void @t10() nounwind ssp {
+entry:
+  %0 = tail call i32 @foo4() noreturn nounwind
+  unreachable
+}
 ; X86-LABEL: t10:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    calll foo4
 ;
 ; X64-LABEL: t10:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    pushq %rax
 ; X64-NEXT:    callq foo4
 ;
 ; X32-LABEL: t10:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    pushq %rax
 ; X32-NEXT:    callq foo4
-entry:
-  %0 = tail call i32 @foo4() noreturn nounwind
-  unreachable
-}
 
 declare dso_local i32 @foo4()
 
-; In 32-bit mode, it's emitting a bunch of dead loads that are not being
-; eliminated currently.
-
+; Tailcall legal: we're a conditional forwarding function.
 define dso_local i32 @t11(i32 %x, i32 %y, i32 %z.0, i32 %z.1, i32 %z.2) nounwind ssp {
+entry:
+  %0 = icmp eq i32 %x, 0
+  br i1 %0, label %bb6, label %bb
+
+bb:
+  %1 = tail call i32 @foo5(i32 %x, i32 %y, i32 %z.0, i32 %z.1, i32 %z.2) nounwind
+  ret i32 %1
+
+bb6:
+  ret i32 0
+}
 ; X86-LABEL: t11:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    cmpl $0, {{[0-9]+}}(%esp)
 ; X86-NEXT:    je .LBB11_1
 ; X86-NEXT:  # %bb.2: # %bb
 ; X86-NEXT:    jmp foo5 # TAILCALL
 ; X86-NEXT:  .LBB11_1: # %bb6
 ; X86-NEXT:    xorl %eax, %eax

 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    testl %edi, %edi
 ; X32-NEXT:    je .LBB11_1
 ; X32-NEXT:  # %bb.2: # %bb
 ; X32-NEXT:    jmp foo5 # TAILCALL
 ; X32-NEXT:  .LBB11_1: # %bb6
 ; X32-NEXT:    xorl %eax, %eax
 ; X32-NEXT:    retq
+
+declare dso_local i32 @foo5(i32, i32, i32, i32, i32)
+
+%struct.t = type { i32, i32, i32, i32, i32 }
+
+; Tailcall legal: still a conditional forwarding function.
+define dso_local i32 @t12(i32 %x, i32 %y, %struct.t* byval(%struct.t) align 4 %z) nounwind ssp {
 entry:
   %0 = icmp eq i32 %x, 0
-  br i1 %0, label %bb6, label %bb
+  br i1 %0, label %bb2, label %bb
 
 bb:
-  %1 = tail call i32 @foo5(i32 %x, i32 %y, i32 %z.0, i32 %z.1, i32 %z.2) nounwind
+  %1 = tail call i32 @foo6(i32 %x, i32 %y, %struct.t* byval(%struct.t) align 4 %z) nounwind
   ret i32 %1
 
-bb6:
+bb2:
   ret i32 0
 }
-
-declare dso_local i32 @foo5(i32, i32, i32, i32, i32)
-
-%struct.t = type { i32, i32, i32, i32, i32 }
-
-define dso_local i32 @t12(i32 %x, i32 %y, %struct.t* byval(%struct.t) align 4 %z) nounwind ssp {
 ; X86-LABEL: t12:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    cmpl $0, {{[0-9]+}}(%esp)
 ; X86-NEXT:    je .LBB12_1
 ; X86-NEXT:  # %bb.2: # %bb
 ; X86-NEXT:    jmp foo6 # TAILCALL
 ; X86-NEXT:  .LBB12_1: # %bb2
 ; X86-NEXT:    xorl %eax, %eax

 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    testl %edi, %edi
 ; X32-NEXT:    je .LBB12_1
 ; X32-NEXT:  # %bb.2: # %bb
 ; X32-NEXT:    jmp foo6 # TAILCALL
 ; X32-NEXT:  .LBB12_1: # %bb2
 ; X32-NEXT:    xorl %eax, %eax
 ; X32-NEXT:    retq
-entry:
-  %0 = icmp eq i32 %x, 0
-  br i1 %0, label %bb2, label %bb
-
-bb:
-  %1 = tail call i32 @foo6(i32 %x, i32 %y, %struct.t* byval(%struct.t) align 4 %z) nounwind
-  ret i32 %1
-
-bb2:
-  ret i32 0
-}
 
 declare dso_local i32 @foo6(i32, i32, %struct.t* byval(%struct.t) align 4)
 
 ; rdar://r7717598
 %struct.ns = type { i32, i32 }
 %struct.cp = type { float, float, float, float, float }
 
+; Tailcall not possible: need to copy incoming struct to stack-based
+; outgoing.
 define %struct.ns* @t13(%struct.cp* %yy) nounwind ssp {
+entry:
+  %0 = tail call fastcc %struct.ns* @foo7(%struct.cp* byval(%struct.cp) align 4 %yy, i8 signext 0) nounwind
+  ret %struct.ns* %0
+}
 ; X86-LABEL: t13:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $28, %esp
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl 16(%eax), %ecx
 ; X86-NEXT:    movl %ecx, {{[0-9]+}}(%esp)
 ; X86-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
 ; X86-NEXT:    movsd {{.*#+}} xmm1 = mem[0],zero

 ; X32-NEXT:    pushq %rax
 ; X32-NEXT:    pushq %rdx
 ; X32-NEXT:    pushq %rcx
 ; X32-NEXT:    callq foo7
 ; X32-NEXT:    addl $32, %esp
 ; X32-NEXT:    movl %eax, %eax
 ; X32-NEXT:    popq %rcx
 ; X32-NEXT:    retq
-entry:
-  %0 = tail call fastcc %struct.ns* @foo7(%struct.cp* byval(%struct.cp) align 4 %yy, i8 signext 0) nounwind
-  ret %struct.ns* %0
-}
 
+; Tailcall legal:
 ; rdar://6195379
-; llvm can't do sibcall for this in 32-bit mode (yet).
+; QOI: llvm can't do sibcall for this in 32-bit mode (yet). (probably
+; same as t4)
+
 declare dso_local fastcc %struct.ns* @foo7(%struct.cp* byval(%struct.cp) align 4, i8 signext) nounwind ssp
 
 %struct.__block_descriptor = type { i64, i64 }
 %struct.__block_descriptor_withcopydispose = type { i64, i64, i8*, i8* }
 %struct.__block_literal_1 = type { i8*, i32, i32, i8*, %struct.__block_descriptor* }
 %struct.__block_literal_2 = type { i8*, i32, i32, i8*, %struct.__block_descriptor_withcopydispose*, void ()* }
 
 define dso_local void @t14(%struct.__block_literal_2* nocapture %.block_descriptor) nounwind ssp {
+entry:
+  %0 = getelementptr inbounds %struct.__block_literal_2, %struct.__block_literal_2* %.block_descriptor, i64 0, i32 5 ; <void ()**> [#uses=1]
+  %1 = load void ()*, void ()** %0, align 8                 ; <void ()*> [#uses=2]
+  %2 = bitcast void ()* %1 to %struct.__block_literal_1* ; <%struct.__block_literal_1*> [#uses=1]
+  %3 = getelementptr inbounds %struct.__block_literal_1, %struct.__block_literal_1* %2, i64 0, i32 3 ; <i8**> [#uses=1]
+  %4 = load i8*, i8** %3, align 8                      ; <i8*> [#uses=1]
+  %5 = bitcast i8* %4 to void (i8*)*              ; <void (i8*)*> [#uses=1]
+  %6 = bitcast void ()* %1 to i8*                 ; <i8*> [#uses=1]
+  tail call void %5(i8* %6) nounwind
+  ret void
+}
 ; X86-LABEL: t14:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl 20(%eax), %eax
 ; X86-NEXT:    movl %eax, (%esp)
 ; X86-NEXT:    calll *12(%eax)
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t14:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    movq 32(%rdi), %rdi
 ; X64-NEXT:    jmpq *16(%rdi) # TAILCALL
 ;
 ; X32-LABEL: t14:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    movl 20(%edi), %edi
 ; X32-NEXT:    movl 12(%edi), %eax
 ; X32-NEXT:    jmpq *%rax # TAILCALL
-entry:
-  %0 = getelementptr inbounds %struct.__block_literal_2, %struct.__block_literal_2* %.block_descriptor, i64 0, i32 5 ; <void ()**> [#uses=1]
-  %1 = load void ()*, void ()** %0, align 8                 ; <void ()*> [#uses=2]
-  %2 = bitcast void ()* %1 to %struct.__block_literal_1* ; <%struct.__block_literal_1*> [#uses=1]
-  %3 = getelementptr inbounds %struct.__block_literal_1, %struct.__block_literal_1* %2, i64 0, i32 3 ; <i8**> [#uses=1]
-  %4 = load i8*, i8** %3, align 8                      ; <i8*> [#uses=1]
-  %5 = bitcast i8* %4 to void (i8*)*              ; <void (i8*)*> [#uses=1]
-  %6 = bitcast void ()* %1 to i8*                 ; <i8*> [#uses=1]
-  tail call void %5(i8* %6) nounwind
-  ret void
-}
 
 ; rdar://7726868
 %struct.foo = type { [4 x i32] }
 
+; Tailcall legal: Forwarding our sret to an sret callee
+; QOI: we don't tailcall due to the sret.
 define dso_local void @t15(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind  {
+  tail call fastcc void @f(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind
+  ret void
+}
 ; X86-LABEL: t15:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %esi
 ; X86-NEXT:    movl %esi, %ecx
 ; X86-NEXT:    calll f
 ; X86-NEXT:    movl %esi, %eax

 ; X32-LABEL: t15:
 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    callq f
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  tail call fastcc void @f(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind
-  ret void
-}
 
 declare dso_local void @f(%struct.foo* noalias sret(%struct.foo)) nounwind
 
+; Tailcall conditionally legal: Forwarding from void and disregard the
+; callee's result. Except with i686/387 where we need to drop the
+; disregarded result.
 define dso_local void @t16() nounwind ssp {
+entry:
+  %0 = tail call double @bar4() nounwind
+  ret void
+}
 ; X86-LABEL: t16:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    calll bar4
 ; X86-NEXT:    fstp %st(0)
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t16:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    jmp bar4 # TAILCALL
 ;
 ; X32-LABEL: t16:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    jmp bar4 # TAILCALL
-entry:
-  %0 = tail call double @bar4() nounwind
-  ret void
-}
 
 declare dso_local double @bar4()
 
+; Tailcall legal: variadic args all in registers
 ; rdar://6283267
 define dso_local void @t17() nounwind ssp {
+entry:
+  tail call void (...) @bar5() nounwind
+  ret void
+}
 ; X86-LABEL: t17:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    jmp bar5 # TAILCALL
 ;
 ; X64-LABEL: t17:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    xorl %eax, %eax
 ; X64-NEXT:    jmp bar5 # TAILCALL
 ;
 ; X32-LABEL: t17:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    xorl %eax, %eax
 ; X32-NEXT:    jmp bar5 # TAILCALL
-entry:
-  tail call void (...) @bar5() nounwind
-  ret void
-}
 
 declare dso_local void @bar5(...)
 
+; Tailcall conditionally legal: Same as t16, applied to t17.
 ; rdar://7774847
 define dso_local void @t18() nounwind ssp {
+entry:
+  %0 = tail call double (...) @bar6() nounwind
+  ret void
+}
 ; X86-LABEL: t18:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    calll bar6
 ; X86-NEXT:    fstp %st(0)
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t18:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    xorl %eax, %eax
 ; X64-NEXT:    jmp bar6 # TAILCALL
 ;
 ; X32-LABEL: t18:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    xorl %eax, %eax
 ; X32-NEXT:    jmp bar6 # TAILCALL
-entry:
-  %0 = tail call double (...) @bar6() nounwind
-  ret void
-}
 
 declare dso_local double @bar6(...)
 
+; Tailcall disallowed: we realign the stack.
 define dso_local void @t19() alignstack(32) nounwind {
+entry:
+  tail call void @foo() nounwind
+  ret void
+}
 ; X86-LABEL: t19:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    pushl %ebp
 ; X86-NEXT:    movl %esp, %ebp
 ; X86-NEXT:    andl $-32, %esp
 ; X86-NEXT:    subl $32, %esp
 ; X86-NEXT:    calll foo
 ; X86-NEXT:    movl %ebp, %esp

 ; X32-NEXT:    pushq %rbp
 ; X32-NEXT:    movl %esp, %ebp
 ; X32-NEXT:    andl $-32, %esp
 ; X32-NEXT:    subl $32, %esp
 ; X32-NEXT:    callq foo
 ; X32-NEXT:    movl %ebp, %esp
 ; X32-NEXT:    popq %rbp
 ; X32-NEXT:    retq
-entry:
-  tail call void @foo() nounwind
-  ret void
-}
 
 ; If caller / callee calling convention mismatch then check if the return
 ; values are returned in the same registers.
 ; rdar://7874780
 
+; Tailcall conditionally legal: The return value might be done
+; differently across Calling Conventions. Differs on fastcc<->i686/387
 define dso_local double @t20(double %x) nounwind {
+entry:
+  %0 = tail call fastcc double @foo20(double %x) nounwind
+  ret double %0
+}
 ; X86-LABEL: t20:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
 ; X86-NEXT:    calll foo20
 ; X86-NEXT:    movsd %xmm0, (%esp)
 ; X86-NEXT:    fldl (%esp)
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t20:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    jmp foo20 # TAILCALL
 ;
 ; X32-LABEL: t20:
 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    jmp foo20 # TAILCALL
-entry:
-  %0 = tail call fastcc double @foo20(double %x) nounwind
-  ret double %0
-}
 
 declare dso_local fastcc double @foo20(double) nounwind
 
 ; bug 28417
+; Tailcall legal: we're forwarding sret to sret
+; QOI: We fail to determine the sret argument is our sret parameter
 define fastcc void @t21_sret_to_sret(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind  {
+  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    calll t21_f_sret
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $8, %esp

 ; X32-LABEL: t21_sret_to_sret:
 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    callq t21_f_sret
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind
-  ret void
-}
 
+; Tailcall disallowed: Passing pointer to our stack frame.
+; Note that we never initialize the sret object we're
+; returnining. That is not UB.
 define fastcc void @t21_sret_to_sret_alloca(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind  {
+  %a = alloca %struct.foo, align 8
+  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %a) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret_alloca:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $24, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    leal {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    calll t21_f_sret
 ; X86-NEXT:    movl %esi, %eax

 ; X32-NEXT:    subl $16, %esp
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    movl %esp, %edi
 ; X32-NEXT:    callq t21_f_sret
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    addl $16, %esp
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  %a = alloca %struct.foo, align 8
-  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %a) nounwind
-  ret void
-}
 
+; Tailcall legal: We're just forwarding everything.
+; QOI: We fail to track sret propagation to determine callee returns that.
 define fastcc void @t21_sret_to_sret_more_args(%struct.foo* noalias sret(%struct.foo) %agg.result, i32 %a, i32 %b) nounwind  {
+  tail call fastcc void @f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result, i32 %a, i32 %b) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret_more_args:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, (%esp)
 ; X86-NEXT:    calll f_sret@PLT

 ; X32-LABEL: t21_sret_to_sret_more_args:
 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    callq f_sret@PLT
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  tail call fastcc void @f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result, i32 %a, i32 %b) nounwind
-  ret void
-}
 
+; Tailcall disallowed: callee does not return our sret.
 define fastcc void @t21_sret_to_sret_second_arg_sret(%struct.foo* noalias %agg.result, %struct.foo* noalias sret(%struct.foo) %ret) nounwind  {
+  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %ret) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret_second_arg_sret:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %edx, %esi
 ; X86-NEXT:    movl %edx, %ecx
 ; X86-NEXT:    calll t21_f_sret
 ; X86-NEXT:    movl %esi, %eax

 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rsi, %rbx
 ; X32-NEXT:    movq %rsi, %rdi
 ; X32-NEXT:    callq t21_f_sret
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %ret) nounwind
-  ret void
-}
 
+; Tailcall legal: we're just a forwarding function.
+; QOI: we fail to trace sret propagation.
 define fastcc void @t21_sret_to_sret_more_args2(%struct.foo* noalias sret(%struct.foo) %agg.result, i32 %a, i32 %b) nounwind  {
+  tail call fastcc void @f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result, i32 %b, i32 %a) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret_more_args2:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %edx, (%esp)
 ; X86-NEXT:    movl %eax, %edx

 ; X32-NEXT:    movl %esi, %eax
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    movl %edx, %esi
 ; X32-NEXT:    movl %eax, %edx
 ; X32-NEXT:    callq f_sret@PLT
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  tail call fastcc void @f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result, i32 %b, i32 %a) nounwind
-  ret void
-}
-
 
+; Tailcall disallowed: Callee does not return our sret
 define fastcc void @t21_sret_to_sret_args_mismatch(%struct.foo* noalias sret(%struct.foo) %agg.result, %struct.foo* noalias %ret) nounwind  {
+  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %ret) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret_args_mismatch:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    movl %edx, %ecx
 ; X86-NEXT:    calll t21_f_sret
 ; X86-NEXT:    movl %esi, %eax

 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    movq %rsi, %rdi
 ; X32-NEXT:    callq t21_f_sret
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
+
+; Tailcall disallowed: Callee doesn't return our sret
+define fastcc void @t21_sret_to_sret_args_mismatch2(%struct.foo* noalias sret(%struct.foo) %agg.result, %struct.foo* noalias %ret) nounwind  {
   tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %ret) nounwind
   ret void
 }
-
-define fastcc void @t21_sret_to_sret_args_mismatch2(%struct.foo* noalias sret(%struct.foo) %agg.result, %struct.foo* noalias %ret) nounwind  {
 ; X86-LABEL: t21_sret_to_sret_args_mismatch2:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    movl %edx, %ecx
 ; X86-NEXT:    calll t21_f_sret
 ; X86-NEXT:    movl %esi, %eax

 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    movq %rsi, %rdi
 ; X32-NEXT:    callq t21_f_sret
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %ret) nounwind
-  ret void
-}
 
+; Tailcall disallowed: callee doesn't return our sret.
 define fastcc void @t21_sret_to_sret_arg_mismatch(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind  {
+  %a = call fastcc %struct.foo* @ret_struct()
+  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %a) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret_arg_mismatch:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    calll ret_struct@PLT
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    calll t21_f_sret

 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    callq ret_struct@PLT
 ; X32-NEXT:    movl %eax, %edi
 ; X32-NEXT:    callq t21_f_sret
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  %a = call fastcc %struct.foo* @ret_struct()
-  tail call fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo) %a) nounwind
-  ret void
-}
 
+; Tailcall disallowed: callee fails to return our sret.
 define fastcc void @t21_sret_to_sret_structs_mismatch(%struct.foo* noalias sret(%struct.foo) %agg.result, %struct.foo* noalias %a) nounwind  {
+  %b = call fastcc %struct.foo* @ret_struct()
+  tail call fastcc void @t21_f_sret2(%struct.foo* noalias sret(%struct.foo) %a, %struct.foo* noalias %b) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_sret_structs_mismatch:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %edi
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    pushl %eax
 ; X86-NEXT:    movl %edx, %esi
 ; X86-NEXT:    movl %ecx, %edi
 ; X86-NEXT:    calll ret_struct@PLT

 ; X32-NEXT:    movl %eax, %esi
 ; X32-NEXT:    movq %rbx, %rdi
 ; X32-NEXT:    callq t21_f_sret2
 ; X32-NEXT:    movl %r14d, %eax
 ; X32-NEXT:    addl $8, %esp
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    popq %r14
 ; X32-NEXT:    retq
-  %b = call fastcc %struct.foo* @ret_struct()
-  tail call fastcc void @t21_f_sret2(%struct.foo* noalias sret(%struct.foo) %a, %struct.foo* noalias %b) nounwind
-  ret void
-}
 
 declare ccc %struct.foo* @ret_struct() nounwind
 
-
+; Tailcall disallowed: Callee doesn't return our sret.
 define fastcc void @t21_sret_to_non_sret(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind  {
+  tail call fastcc void @t21_f_non_sret(%struct.foo* %agg.result) nounwind
+  ret void
+}
 ; X86-LABEL: t21_sret_to_non_sret:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $8, %esp
 ; X86-NEXT:    movl %ecx, %esi
 ; X86-NEXT:    calll t21_f_non_sret
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    addl $8, %esp

 ; X32-LABEL: t21_sret_to_non_sret:
 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rbx
 ; X32-NEXT:    movq %rdi, %rbx
 ; X32-NEXT:    callq t21_f_non_sret
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    popq %rbx
 ; X32-NEXT:    retq
-  tail call fastcc void @t21_f_non_sret(%struct.foo* %agg.result) nounwind
-  ret void
-}
-
 
+; Tailcall legal: We don't have an sret.
+; QOI: We fail to tailcall.
 define ccc void @t22_non_sret_to_sret(%struct.foo* %agg.result) nounwind  {
+  tail call ccc void @t22_f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind
+  ret void
+}
 ; X86-LABEL: t22_non_sret_to_sret:
 ; X86:       # %bb.0:
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, (%esp)
 ; X86-NEXT:    calll t22_f_sret@PLT
 ; X86-NEXT:    addl $8, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t22_non_sret_to_sret:
 ; X64:       # %bb.0:
 ; X64-NEXT:    pushq %rax
 ; X64-NEXT:    callq t22_f_sret@PLT
 ; X64-NEXT:    popq %rax
 ; X64-NEXT:    retq
 ;
 ; X32-LABEL: t22_non_sret_to_sret:
 ; X32:       # %bb.0:
 ; X32-NEXT:    pushq %rax
 ; X32-NEXT:    callq t22_f_sret@PLT
 ; X32-NEXT:    popq %rax
 ; X32-NEXT:    retq
-  tail call ccc void @t22_f_sret(%struct.foo* noalias sret(%struct.foo) %agg.result) nounwind
-  ret void
-}
 
 declare dso_local fastcc void @t21_f_sret(%struct.foo* noalias sret(%struct.foo)) nounwind
 declare dso_local fastcc void @t21_f_sret2(%struct.foo* noalias sret(%struct.foo), %struct.foo* noalias) nounwind
 declare dso_local fastcc void @t21_f_non_sret(%struct.foo*) nounwind
 
 declare ccc void @t22_f_sret(%struct.foo* noalias sret(%struct.foo)) nounwind
 
 declare ccc void @f_sret(%struct.foo* noalias sret(%struct.foo), i32, i32) nounwind