[X86] improve split-stack machine BB placement

[thanm]

Summary

The conditional branch created to support -fsplit-stack for X86 is
left unbiased/unhinted, resulting in less than ideal block placement:
the __morestack call block is kept on the main hot path. Bias the
branch to insure that the stack allocation block is treated as a
"cold" block during machine basic block placement.

[cherry]

LGTM. Thanks.

Patch description: s/idea/ideal/.

[thanm]

Thanks for the review. I've fixed up the header comment.

[thanm]

Comment change only.

lib/Target/X86/X86FrameLowering.cpp

void X86FrameLowering::adjustForSegmentedStacks(
 
   if (IsNested)
     BuildMI(allocMBB, DL, TII.get(X86::MORESTACK_RET_RESTORE_R10));
   else
     BuildMI(allocMBB, DL, TII.get(X86::MORESTACK_RET));
 
   allocMBB->addSuccessor(&PrologueMBB);
 
-  checkMBB->addSuccessor(allocMBB);
-  checkMBB->addSuccessor(&PrologueMBB);
+  checkMBB->addSuccessor(allocMBB, BranchProbability::getZero());
+  checkMBB->addSuccessor(&PrologueMBB, BranchProbability::getOne());
 
 #ifdef EXPENSIVE_CHECKS
   MF.verify();
 #endif
 }
 
 /// Lookup an ERTS parameter in the !hipe.literals named metadata node.
 /// HiPE provides Erlang Runtime System-internal parameters, such as PCB offsets

test/CodeGen/X86/segmented-stacks-dynamic.ll

 false:
         %newlen = sub i32 %l, 1
         %retvalue = call i32 @test_basic(i32 %newlen)
         ret i32 %retvalue
 
 ; X32-LABEL:      test_basic:
 
 ; X32:      cmpl %gs:48, %esp
-; X32-NEXT: ja      .LBB0_2
-
-; X32:      pushl $4
-; X32-NEXT: pushl $12
-; X32-NEXT: calll __morestack
-; X32-NEXT: ret
+; X32-NEXT: jbe .LBB0_1
 
 ; X32:      movl %esp, %eax
 ; X32:      subl %ecx, %eax
 ; X32-NEXT: cmpl %eax, %gs:48
 
 ; X32:      movl %eax, %esp
 
 ; X32:      subl $12, %esp
 ; X32-NEXT: pushl %ecx
 ; X32-NEXT: calll __morestack_allocate_stack_space
 ; X32-NEXT: addl $16, %esp
 
+; X32:      pushl $4
+; X32-NEXT: pushl $12
+; X32-NEXT: calll __morestack
+; X32-NEXT: ret
+
 ; X64-LABEL:      test_basic:
 
 ; X64:      cmpq %fs:112, %rsp
-; X64-NEXT: ja      .LBB0_2
-
-; X64:      movabsq $24, %r10
-; X64-NEXT: movabsq $0, %r11
-; X64-NEXT: callq __morestack
-; X64-NEXT: ret
+; X64-NEXT: jbe      .LBB0_1
 
 ; X64:      movq %rsp, %[[RDI:rdi|rax]]
 ; X64:      subq %{{.*}}, %[[RDI]]
 ; X64-NEXT: cmpq %[[RDI]], %fs:112
 
 ; X64:      movq %[[RDI]], %rsp
 
 ; X64:      movq %{{.*}}, %rdi
 ; X64-NEXT: callq __morestack_allocate_stack_space
 ; X64:      movq %rax, %rdi
 
+; X64:      movabsq $24, %r10
+; X64-NEXT: movabsq $0, %r11
+; X64-NEXT: callq __morestack
+; X64-NEXT: ret
+
 ; X32ABI-LABEL:      test_basic:
 
 ; X32ABI:      cmpl %fs:64, %esp
-; X32ABI-NEXT: ja      .LBB0_2
-
-; X32ABI:      movl $24, %r10d
-; X32ABI-NEXT: movl $0, %r11d
-; X32ABI-NEXT: callq __morestack
-; X32ABI-NEXT: ret
+; X32ABI-NEXT: jbe      .LBB0_1
 
 ; X32ABI:      movl %esp, %[[EDI:edi|eax]]
 ; X32ABI:      subl %{{.*}}, %[[EDI]]
 ; X32ABI-NEXT: cmpl %[[EDI]], %fs:64
 
 ; X32ABI:      movl %[[EDI]], %esp
 
 ; X32ABI:      movl %{{.*}}, %edi
 ; X32ABI-NEXT: callq __morestack_allocate_stack_space
 ; X32ABI:      movl %eax, %edi
 
+; X32ABI:      movl $24, %r10d
+; X32ABI-NEXT: movl $0, %r11d
+; X32ABI-NEXT: callq __morestack
+; X32ABI-NEXT: ret
+
 }
 
 attributes #0 = { "split-stack" }

test/CodeGen/X86/segmented-stacks.ll

 define void @test_basic() #0 {
         %mem = alloca i32, i32 10
         call void @dummy_use (i32* %mem, i32 10)
   ret void
 
 ; X32-Linux-LABEL:       test_basic:
 
 ; X32-Linux:       cmpl %gs:48, %esp
-; X32-Linux-NEXT:  ja      .LBB0_2
+; X32-Linux-NEXT:  jbe  .LBB0_1
 
 ; X32-Linux:       pushl $0
 ; X32-Linux-NEXT:  pushl $44
 ; X32-Linux-NEXT:  calll __morestack
 ; X32-Linux-NEXT:  ret
 
 ; X64-Linux-LABEL:       test_basic:
 
 ; X64-Linux:       cmpq %fs:112, %rsp
-; X64-Linux-NEXT:  ja      .LBB0_2
+; X64-Linux-NEXT:  jbe  .LBB0_1
 
 ; X64-Linux:       movabsq $40, %r10
 ; X64-Linux-NEXT:  movabsq $0, %r11
 ; X64-Linux-NEXT:  callq __morestack
 ; X64-Linux-NEXT:  ret
 
 ; X64-Linux-Large-LABEL:       test_basic:
 
 ; X64-Linux-Large:       cmpq %fs:112, %rsp
-; X64-Linux-Large-NEXT:  ja      .LBB0_2
+; X64-Linux-Large-NEXT:  jbe  .LBB0_1
 
 ; X64-Linux-Large:       movabsq $40, %r10
 ; X64-Linux-Large-NEXT:  movabsq $0, %r11
 ; X64-Linux-Large-NEXT:  callq *__morestack_addr(%rip)
 ; X64-Linux-Large-NEXT:  ret
 
 ; X32ABI-LABEL:       test_basic:
 
 ; X32ABI:       cmpl %fs:64, %esp
-; X32ABI-NEXT:  ja      .LBB0_2
+; X32ABI-NEXT:  jbe .LBB0_1
 
 ; X32ABI:       movl $40, %r10d
 ; X32ABI-NEXT:  movl $0, %r11d
 ; X32ABI-NEXT:  callq __morestack
 ; X32ABI-NEXT:  ret
 
 ; X32-Darwin-LABEL:      test_basic:
 
 ; X32-Darwin:      movl $432, %ecx
 ; X32-Darwin-NEXT: cmpl %gs:(%ecx), %esp
-; X32-Darwin-NEXT: ja      LBB0_2
+; X32-Darwin-NEXT: jbe  LBB0_1
 
 ; X32-Darwin:      pushl $0
 ; X32-Darwin-NEXT: pushl $60
 ; X32-Darwin-NEXT: calll ___morestack
 ; X32-Darwin-NEXT: ret
 
 ; X64-Darwin-LABEL:      test_basic:
 
 ; X64-Darwin:      cmpq %gs:816, %rsp
-; X64-Darwin-NEXT: ja      LBB0_2
+; X64-Darwin-NEXT: jbe  LBB0_1
 
 ; X64-Darwin:      movabsq $40, %r10
 ; X64-Darwin-NEXT: movabsq $0, %r11
 ; X64-Darwin-NEXT: callq ___morestack
 ; X64-Darwin-NEXT: ret
 
 ; X32-MinGW-LABEL:       test_basic:
 
 ; X32-MinGW:       cmpl %fs:20, %esp
-; X32-MinGW-NEXT:  ja      LBB0_2
+; X32-MinGW-NEXT:  jbe      LBB0_1
 
 ; X32-MinGW:       pushl $0
 ; X32-MinGW-NEXT:  pushl $40
 ; X32-MinGW-NEXT:  calll ___morestack
 ; X32-MinGW-NEXT:  ret
 
 ; X64-MinGW-LABEL:       test_basic:
 
 ; X64-MinGW:       cmpq %gs:40, %rsp
-; X64-MinGW-NEXT:  ja      .LBB0_2
+; X64-MinGW-NEXT:  jbe      .LBB0_1
 
 ; X64-MinGW:       movabsq $72, %r10
 ; X64-MinGW-NEXT:  movabsq $32, %r11
 ; X64-MinGW-NEXT:  callq __morestack
 ; X64-MinGW-NEXT:  retq
 
 ; X64-FreeBSD-LABEL:       test_basic:
 
 ; X64-FreeBSD:       cmpq %fs:24, %rsp
-; X64-FreeBSD-NEXT:  ja      .LBB0_2
+; X64-FreeBSD-NEXT:  jbe      .LBB0_1
 
 ; X64-FreeBSD:       movabsq $40, %r10
 ; X64-FreeBSD-NEXT:  movabsq $0, %r11
 ; X64-FreeBSD-NEXT:  callq __morestack
 ; X64-FreeBSD-NEXT:  ret
 
 ; X32-DFlyBSD-LABEL:       test_basic:
 
 ; X32-DFlyBSD:       cmpl %fs:16, %esp
-; X32-DFlyBSD-NEXT:  ja      .LBB0_2
+; X32-DFlyBSD-NEXT:  jbe      .LBB0_1
 
 ; X32-DFlyBSD:       pushl $0
 ; X32-DFlyBSD-NEXT:  pushl $40
 ; X32-DFlyBSD-NEXT:  calll __morestack
 ; X32-DFlyBSD-NEXT:  ret
 
 ; X64-DFlyBSD-LABEL:       test_basic:
 
 ; X64-DFlyBSD:       cmpq %fs:32, %rsp
-; X64-DFlyBSD-NEXT:  ja      .LBB0_2
+; X64-DFlyBSD-NEXT:  jbe      .LBB0_1
 
 ; X64-DFlyBSD:       movabsq $40, %r10
 ; X64-DFlyBSD-NEXT:  movabsq $0, %r11
 ; X64-DFlyBSD-NEXT:  callq __morestack
 ; X64-DFlyBSD-NEXT:  ret
 
 }
 
 define i32 @test_nested(i32 * nest %closure, i32 %other) #0 {
        %addend = load i32 , i32 * %closure
        %result = add i32 %other, %addend
        %mem = alloca i32, i32 10
        call void @dummy_use (i32* %mem, i32 10)
        ret i32 %result
 
 ; X32-Linux:       cmpl %gs:48, %esp
-; X32-Linux-NEXT:  ja      .LBB1_2
+; X32-Linux-NEXT:  jbe  .LBB1_1
 
 ; X32-Linux:       pushl $4
 ; X32-Linux-NEXT:  pushl $44
 ; X32-Linux-NEXT:  calll __morestack
 ; X32-Linux-NEXT:  ret
 
 ; X64-Linux:       cmpq %fs:112, %rsp
-; X64-Linux-NEXT:  ja      .LBB1_2
+; X64-Linux-NEXT:  jbe  .LBB1_1
 
 ; X64-Linux:       movq %r10, %rax
 ; X64-Linux-NEXT:  movabsq $56, %r10
 ; X64-Linux-NEXT:  movabsq $0, %r11
 ; X64-Linux-NEXT:  callq __morestack
 ; X64-Linux-NEXT:  ret
 ; X64-Linux-NEXT:  movq %rax, %r10
 
 ; X32ABI:       cmpl %fs:64, %esp
-; X32ABI-NEXT:  ja      .LBB1_2
+; X32ABI-NEXT:  jbe .LBB1_1
 
 ; X32ABI:       movl %r10d, %eax
 ; X32ABI-NEXT:  movl $56, %r10d
 ; X32ABI-NEXT:  movl $0, %r11d
 ; X32ABI-NEXT:  callq __morestack
 ; X32ABI-NEXT:  ret
 ; X32ABI-NEXT:  movq %rax, %r10
 
 ; X32-Darwin:      movl $432, %edx
 ; X32-Darwin-NEXT: cmpl %gs:(%edx), %esp
-; X32-Darwin-NEXT: ja      LBB1_2
+; X32-Darwin-NEXT: jbe  LBB1_1
 
 ; X32-Darwin:      pushl $4
 ; X32-Darwin-NEXT: pushl $60
 ; X32-Darwin-NEXT: calll ___morestack
 ; X32-Darwin-NEXT: ret
 
 ; X64-Darwin:      cmpq %gs:816, %rsp
-; X64-Darwin-NEXT: ja      LBB1_2
+; X64-Darwin-NEXT: jbe  LBB1_1
 
 ; X64-Darwin:      movq %r10, %rax
 ; X64-Darwin-NEXT: movabsq $56, %r10
 ; X64-Darwin-NEXT: movabsq $0, %r11
 ; X64-Darwin-NEXT: callq ___morestack
 ; X64-Darwin-NEXT: ret
 ; X64-Darwin-NEXT: movq %rax, %r10
 
 ; X32-MinGW:       cmpl %fs:20, %esp
-; X32-MinGW-NEXT:  ja      LBB1_2
+; X32-MinGW-NEXT:  jbe      LBB1_1
 
 ; X32-MinGW:       pushl $4
 ; X32-MinGW-NEXT:  pushl $44
 ; X32-MinGW-NEXT:  calll ___morestack
 ; X32-MinGW-NEXT:  ret
 
 ; X64-MinGW-LABEL: test_nested:
 ; X64-MinGW:       cmpq %gs:40, %rsp
-; X64-MinGW-NEXT:  ja      .LBB1_2
+; X64-MinGW-NEXT:  jbe      .LBB1_1
 
 ; X64-MinGW:       movq %r10, %rax
 ; X64-MinGW-NEXT:  movabsq $88, %r10
 ; X64-MinGW-NEXT:  movabsq $32, %r11
 ; X64-MinGW-NEXT:  callq __morestack
 ; X64-MinGW-NEXT:  retq
 ; X64-MinGW-NEXT:  movq %rax, %r10
 
 ; X64-FreeBSD:       cmpq %fs:24, %rsp
-; X64-FreeBSD-NEXT:  ja      .LBB1_2
+; X64-FreeBSD-NEXT:  jbe      .LBB1_1
 
 ; X64-FreeBSD:       movq %r10, %rax
 ; X64-FreeBSD-NEXT:  movabsq $56, %r10
 ; X64-FreeBSD-NEXT:  movabsq $0, %r11
 ; X64-FreeBSD-NEXT:  callq __morestack
 ; X64-FreeBSD-NEXT:  ret
 ; X64-FreeBSD-NEXT:  movq %rax, %r10
 
 ; X32-DFlyBSD:       cmpl %fs:16, %esp
-; X32-DFlyBSD-NEXT:  ja      .LBB1_2
+; X32-DFlyBSD-NEXT:  jbe      .LBB1_1
 
 ; X32-DFlyBSD:       pushl $4
 ; X32-DFlyBSD-NEXT:  pushl $44
 ; X32-DFlyBSD-NEXT:  calll __morestack
 ; X32-DFlyBSD-NEXT:  ret
 
 ; X64-DFlyBSD:       cmpq %fs:32, %rsp
-; X64-DFlyBSD-NEXT:  ja      .LBB1_2
+; X64-DFlyBSD-NEXT:  jbe      .LBB1_1
 
 ; X64-DFlyBSD:       movq %r10, %rax
 ; X64-DFlyBSD-NEXT:  movabsq $56, %r10
 ; X64-DFlyBSD-NEXT:  movabsq $0, %r11
 ; X64-DFlyBSD-NEXT:  callq __morestack
 ; X64-DFlyBSD-NEXT:  ret
 ; X64-DFlyBSD-NEXT:  movq %rax, %r10
 
 }
 
 define void @test_large() #0 {
         %mem = alloca i32, i32 10000
-        call void @dummy_use (i32* %mem, i32 0)
+        call void @dummy_use (i32* %mem, i32 3)
         ret void
 
+; X32-Linux-LABEL:       test_large:
+
 ; X32-Linux:       leal -40012(%esp), %ecx
 ; X32-Linux-NEXT:  cmpl %gs:48, %ecx
-; X32-Linux-NEXT:  ja      .LBB2_2
+; X32-Linux-NEXT:  jbe  .LBB2_1
 
 ; X32-Linux:       pushl $0
 ; X32-Linux-NEXT:  pushl $40012
 ; X32-Linux-NEXT:  calll __morestack
 ; X32-Linux-NEXT:  ret
 
 ; X64-Linux:       leaq -40008(%rsp), %r11
 ; X64-Linux-NEXT:  cmpq %fs:112, %r11
-; X64-Linux-NEXT:  ja      .LBB2_2
+; X64-Linux-NEXT:  jbe  .LBB2_1
 
 ; X64-Linux:       movabsq $40008, %r10
 ; X64-Linux-NEXT:  movabsq $0, %r11
 ; X64-Linux-NEXT:  callq __morestack
 ; X64-Linux-NEXT:  ret
 
 ; X32ABI:       leal -40008(%rsp), %r11d
 ; X32ABI-NEXT:  cmpl %fs:64, %r11d
-; X32ABI-NEXT:  ja      .LBB2_2
+; X32ABI-NEXT:  jbe .LBB2_1
 
 ; X32ABI:       movl $40008, %r10d
 ; X32ABI-NEXT:  movl $0, %r11d
 ; X32ABI-NEXT:  callq __morestack
 ; X32ABI-NEXT:  ret
 
 ; X32-Darwin:      leal -40012(%esp), %ecx
 ; X32-Darwin-NEXT: movl $432, %eax
 ; X32-Darwin-NEXT: cmpl %gs:(%eax), %ecx
-; X32-Darwin-NEXT: ja      LBB2_2
+; X32-Darwin-NEXT: jbe  LBB2_1
 
 ; X32-Darwin:      pushl $0
 ; X32-Darwin-NEXT: pushl $40012
 ; X32-Darwin-NEXT: calll ___morestack
 ; X32-Darwin-NEXT: ret
 
 ; X64-Darwin:      leaq -40008(%rsp), %r11
 ; X64-Darwin-NEXT: cmpq %gs:816, %r11
-; X64-Darwin-NEXT: ja      LBB2_2
+; X64-Darwin-NEXT: jbe      LBB2_1
 
 ; X64-Darwin:      movabsq $40008, %r10
 ; X64-Darwin-NEXT: movabsq $0, %r11
 ; X64-Darwin-NEXT: callq ___morestack
 ; X64-Darwin-NEXT: ret
 
 ; X32-MinGW:       leal -40000(%esp), %ecx
 ; X32-MinGW-NEXT:  cmpl %fs:20, %ecx
-; X32-MinGW-NEXT:  ja      LBB2_2
+; X32-MinGW-NEXT:  jbe      LBB2_1
 
 ; X32-MinGW:       pushl $0
 ; X32-MinGW-NEXT:  pushl $40000
 ; X32-MinGW-NEXT:  calll ___morestack
 ; X32-MinGW-NEXT:  ret
 
 ; X64-MinGW-LABEL: test_large:
 ; X64-MinGW:       leaq -40040(%rsp), %r11
 ; X64-MinGW-NEXT:  cmpq %gs:40, %r11
-; X64-MinGW-NEXT:  ja      .LBB2_2
+; X64-MinGW-NEXT:  jbe      .LBB2_1
 
 ; X64-MinGW:       movabsq $40040, %r10
 ; X64-MinGW-NEXT:  movabsq $32, %r11
 ; X64-MinGW-NEXT:  callq __morestack
 ; X64-MinGW-NEXT:  retq
 
 ; X64-FreeBSD:       leaq -40008(%rsp), %r11
 ; X64-FreeBSD-NEXT:  cmpq %fs:24, %r11
-; X64-FreeBSD-NEXT:  ja      .LBB2_2
+; X64-FreeBSD-NEXT:  jbe      .LBB2_1
 
 ; X64-FreeBSD:       movabsq $40008, %r10
 ; X64-FreeBSD-NEXT:  movabsq $0, %r11
 ; X64-FreeBSD-NEXT:  callq __morestack
 ; X64-FreeBSD-NEXT:  ret
 
 ; X32-DFlyBSD:       leal -40000(%esp), %ecx
 ; X32-DFlyBSD-NEXT:  cmpl %fs:16, %ecx
-; X32-DFlyBSD-NEXT:  ja      .LBB2_2
+; X32-DFlyBSD-NEXT:  jbe      .LBB2_1
 
 ; X32-DFlyBSD:       pushl $0
 ; X32-DFlyBSD-NEXT:  pushl $40000
 ; X32-DFlyBSD-NEXT:  calll __morestack
 ; X32-DFlyBSD-NEXT:  ret
 
 ; X64-DFlyBSD:       leaq -40008(%rsp), %r11
 ; X64-DFlyBSD-NEXT:  cmpq %fs:32, %r11
-; X64-DFlyBSD-NEXT:  ja      .LBB2_2
+; X64-DFlyBSD-NEXT:  jbe      .LBB2_1
 
 ; X64-DFlyBSD:       movabsq $40008, %r10
 ; X64-DFlyBSD-NEXT:  movabsq $0, %r11
 ; X64-DFlyBSD-NEXT:  callq __morestack
 ; X64-DFlyBSD-NEXT:  ret
 
 }
 
 define fastcc void @test_fastcc() #0 {
         %mem = alloca i32, i32 10
         call void @dummy_use (i32* %mem, i32 10)
         ret void
 
 ; X32-Linux-LABEL:       test_fastcc:
 
 ; X32-Linux:       cmpl %gs:48, %esp
-; X32-Linux-NEXT:  ja      .LBB3_2
+; X32-Linux-NEXT:  jbe  .LBB3_1
 
 ; X32-Linux:       pushl $0
 ; X32-Linux-NEXT:  pushl $44
 ; X32-Linux-NEXT:  calll __morestack
 ; X32-Linux-NEXT:  ret
 
 ; X64-Linux-LABEL:       test_fastcc:
 
 ; X64-Linux:       cmpq %fs:112, %rsp
-; X64-Linux-NEXT:  ja      .LBB3_2
+; X64-Linux-NEXT:  jbe  .LBB3_1
 
 ; X64-Linux:       movabsq $40, %r10
 ; X64-Linux-NEXT:  movabsq $0, %r11
 ; X64-Linux-NEXT:  callq __morestack
 ; X64-Linux-NEXT:  ret
 
 ; X32ABI-LABEL:       test_fastcc:
 
 ; X32ABI:       cmpl %fs:64, %esp
-; X32ABI-NEXT:  ja      .LBB3_2
+; X32ABI-NEXT:  jbe .LBB3_1
 
 ; X32ABI:       movl $40, %r10d
 ; X32ABI-NEXT:  movl $0, %r11d
 ; X32ABI-NEXT:  callq __morestack
 ; X32ABI-NEXT:  ret
 
 ; X32-Darwin-LABEL:      test_fastcc:
 
 ; X32-Darwin:      movl $432, %eax
 ; X32-Darwin-NEXT: cmpl %gs:(%eax), %esp
-; X32-Darwin-NEXT: ja      LBB3_2
+; X32-Darwin-NEXT: jbe  LBB3_1
 
 ; X32-Darwin:      pushl $0
 ; X32-Darwin-NEXT: pushl $60
 ; X32-Darwin-NEXT: calll ___morestack
 ; X32-Darwin-NEXT: ret
 
 ; X64-Darwin-LABEL:      test_fastcc:
 
 ; X64-Darwin:      cmpq %gs:816, %rsp
-; X64-Darwin-NEXT: ja      LBB3_2
+; X64-Darwin-NEXT: jbe  LBB3_1
 
 ; X64-Darwin:      movabsq $40, %r10
 ; X64-Darwin-NEXT: movabsq $0, %r11
 ; X64-Darwin-NEXT: callq ___morestack
 ; X64-Darwin-NEXT: ret
 
 ; X32-MinGW-LABEL:       test_fastcc:
 
 ; X32-MinGW:       cmpl %fs:20, %esp
-; X32-MinGW-NEXT:  ja      LBB3_2
+; X32-MinGW-NEXT:  jbe      LBB3_1
 
 ; X32-MinGW:       pushl $0
 ; X32-MinGW-NEXT:  pushl $40
 ; X32-MinGW-NEXT:  calll ___morestack
 ; X32-MinGW-NEXT:  ret
 
 ; X64-MinGW-LABEL:       test_fastcc:
 
 ; X64-MinGW:       cmpq %gs:40, %rsp
-; X64-MinGW-NEXT:  ja      .LBB3_2
+; X64-MinGW-NEXT:  jbe      .LBB3_1
 
 ; X64-MinGW:       movabsq $72, %r10
 ; X64-MinGW-NEXT:  movabsq $32, %r11
 ; X64-MinGW-NEXT:  callq __morestack
 ; X64-MinGW-NEXT:  retq
 
 ; X64-FreeBSD-LABEL:       test_fastcc:
 
 ; X64-FreeBSD:       cmpq %fs:24, %rsp
-; X64-FreeBSD-NEXT:  ja      .LBB3_2
+; X64-FreeBSD-NEXT:  jbe    .LBB3_1
 
 ; X64-FreeBSD:       movabsq $40, %r10
 ; X64-FreeBSD-NEXT:  movabsq $0, %r11
 ; X64-FreeBSD-NEXT:  callq __morestack
 ; X64-FreeBSD-NEXT:  ret
 
 ; X32-DFlyBSD-LABEL:       test_fastcc:
 
 ; X32-DFlyBSD:       cmpl %fs:16, %esp
-; X32-DFlyBSD-NEXT:  ja      .LBB3_2
+; X32-DFlyBSD-NEXT:  jbe     .LBB3_1
 
 ; X32-DFlyBSD:       pushl $0
 ; X32-DFlyBSD-NEXT:  pushl $40
 ; X32-DFlyBSD-NEXT:  calll __morestack
 ; X32-DFlyBSD-NEXT:  ret
 
 ; X64-DFlyBSD-LABEL:       test_fastcc:
 
 ; X64-DFlyBSD:       cmpq %fs:32, %rsp
-; X64-DFlyBSD-NEXT:  ja      .LBB3_2
+; X64-DFlyBSD-NEXT:  jbe      .LBB3_1
 
 ; X64-DFlyBSD:       movabsq $40, %r10
 ; X64-DFlyBSD-NEXT:  movabsq $0, %r11
 ; X64-DFlyBSD-NEXT:  callq __morestack
 ; X64-DFlyBSD-NEXT:  ret
 
 }
 
 define fastcc void @test_fastcc_large() #0 {
         %mem = alloca i32, i32 10000
-        call void @dummy_use (i32* %mem, i32 0)
+        call void @dummy_use (i32* %mem, i32 3)
         ret void
 
 ; X32-Linux-LABEL:       test_fastcc_large:
 
 ; X32-Linux:       leal -40012(%esp), %eax
 ; X32-Linux-NEXT:  cmpl %gs:48, %eax
-; X32-Linux-NEXT:  ja      .LBB4_2
+; X32-Linux-NEXT:  jbe  .LBB4_1
 
 ; X32-Linux:       pushl $0
 ; X32-Linux-NEXT:  pushl $40012
 ; X32-Linux-NEXT:  calll __morestack
 ; X32-Linux-NEXT:  ret
 
 ; X64-Linux-LABEL:       test_fastcc_large:
 
 ; X64-Linux:       leaq -40008(%rsp), %r11
 ; X64-Linux-NEXT:  cmpq %fs:112, %r11
-; X64-Linux-NEXT:  ja      .LBB4_2
+; X64-Linux-NEXT:  jbe  .LBB4_1
 
 ; X64-Linux:       movabsq $40008, %r10
 ; X64-Linux-NEXT:  movabsq $0, %r11
 ; X64-Linux-NEXT:  callq __morestack
 ; X64-Linux-NEXT:  ret
 
 ; X32ABI-LABEL:       test_fastcc_large:
 
 ; X32ABI:       leal -40008(%rsp), %r11d
 ; X32ABI-NEXT:  cmpl %fs:64, %r11d
-; X32ABI-NEXT:  ja      .LBB4_2
+; X32ABI-NEXT:  jbe .LBB4_1
 
 ; X32ABI:       movl $40008, %r10d
 ; X32ABI-NEXT:  movl $0, %r11d
 ; X32ABI-NEXT:  callq __morestack
 ; X32ABI-NEXT:  ret
 
 ; X32-Darwin-LABEL:      test_fastcc_large:
 
 ; X32-Darwin:      leal -40012(%esp), %eax
 ; X32-Darwin-NEXT: movl $432, %ecx
 ; X32-Darwin-NEXT: cmpl %gs:(%ecx), %eax
-; X32-Darwin-NEXT: ja      LBB4_2
+; X32-Darwin-NEXT: jbe  LBB4_1
 
 ; X32-Darwin:      pushl $0
 ; X32-Darwin-NEXT: pushl $40012
 ; X32-Darwin-NEXT: calll ___morestack
 ; X32-Darwin-NEXT: ret
 
 ; X64-Darwin-LABEL:      test_fastcc_large:
 
 ; X64-Darwin:      leaq -40008(%rsp), %r11
 ; X64-Darwin-NEXT: cmpq %gs:816, %r11
-; X64-Darwin-NEXT: ja      LBB4_2
+; X64-Darwin-NEXT: jbe  LBB4_1
 
 ; X64-Darwin:      movabsq $40008, %r10
 ; X64-Darwin-NEXT: movabsq $0, %r11
 ; X64-Darwin-NEXT: callq ___morestack
 ; X64-Darwin-NEXT: ret
 
 ; X32-MinGW-LABEL:       test_fastcc_large:
 
 ; X32-MinGW:       leal -40000(%esp), %eax
 ; X32-MinGW-NEXT:  cmpl %fs:20, %eax
-; X32-MinGW-NEXT:  ja      LBB4_2
+; X32-MinGW-NEXT:  jbe      LBB4_1
 
 ; X32-MinGW:       pushl $0
 ; X32-MinGW-NEXT:  pushl $40000
 ; X32-MinGW-NEXT:  calll ___morestack
 ; X32-MinGW-NEXT:  ret
 
 ; X64-MinGW-LABEL:       test_fastcc_large:
 
 ; X64-MinGW:       leaq -40040(%rsp), %r11
 ; X64-MinGW-NEXT:  cmpq %gs:40, %r11
-; X64-MinGW-NEXT:  ja      .LBB4_2
+; X64-MinGW-NEXT:  jbe      .LBB4_1
 
 ; X64-MinGW:       movabsq $40040, %r10
 ; X64-MinGW-NEXT:  movabsq $32, %r11
 ; X64-MinGW-NEXT:  callq __morestack
 ; X64-MinGW-NEXT:  retq
 
 ; X64-FreeBSD-LABEL:       test_fastcc_large:
 
 ; X64-FreeBSD:       leaq -40008(%rsp), %r11
 ; X64-FreeBSD-NEXT:  cmpq %fs:24, %r11
-; X64-FreeBSD-NEXT:  ja      .LBB4_2
+; X64-FreeBSD-NEXT:  jbe     .LBB4_1
 
 ; X64-FreeBSD:       movabsq $40008, %r10
 ; X64-FreeBSD-NEXT:  movabsq $0, %r11
 ; X64-FreeBSD-NEXT:  callq __morestack
 ; X64-FreeBSD-NEXT:  ret
 
 ; X32-DFlyBSD-LABEL:       test_fastcc_large:
 
 ; X32-DFlyBSD:       leal -40000(%esp), %eax
 ; X32-DFlyBSD-NEXT:  cmpl %fs:16, %eax
-; X32-DFlyBSD-NEXT:  ja      .LBB4_2
+; X32-DFlyBSD-NEXT:  jbe      .LBB4_1
 
 ; X32-DFlyBSD:       pushl $0
 ; X32-DFlyBSD-NEXT:  pushl $40000
 ; X32-DFlyBSD-NEXT:  calll __morestack
 ; X32-DFlyBSD-NEXT:  ret
 
 ; X64-DFlyBSD-LABEL:       test_fastcc_large:
 
 ; X64-DFlyBSD:       leaq -40008(%rsp), %r11
 ; X64-DFlyBSD-NEXT:  cmpq %fs:32, %r11
-; X64-DFlyBSD-NEXT:  ja      .LBB4_2
+; X64-DFlyBSD-NEXT:  jbe      .LBB4_1
 
 ; X64-DFlyBSD:       movabsq $40008, %r10
 ; X64-DFlyBSD-NEXT:  movabsq $0, %r11
 ; X64-DFlyBSD-NEXT:  callq __morestack
 ; X64-DFlyBSD-NEXT:  ret
 
 }
 
 define fastcc void @test_fastcc_large_with_ecx_arg(i32 %a) #0 {
         %mem = alloca i32, i32 10000
         call void @dummy_use (i32* %mem, i32 %a)
         ret void
 
 ; This is testing that the Mac implementation preserves ecx
 
 ; X32-Darwin-LABEL:      test_fastcc_large_with_ecx_arg:
 
 ; X32-Darwin:      leal -40012(%esp), %eax
 ; X32-Darwin-NEXT: pushl %ecx
 ; X32-Darwin-NEXT: movl $432, %ecx
 ; X32-Darwin-NEXT: cmpl %gs:(%ecx), %eax
 ; X32-Darwin-NEXT: popl %ecx
-; X32-Darwin-NEXT: ja      LBB5_2
+; X32-Darwin-NEXT: jbe  LBB5_1
 
 ; X32-Darwin:      pushl $0
 ; X32-Darwin-NEXT: pushl $40012
 ; X32-Darwin-NEXT: calll ___morestack
 ; X32-Darwin-NEXT: ret
 
 }
 

test/CodeGen/X86/x86-shrink-wrap-unwind.ll

 
 ; Check that we generate correct code for segmented stack.
 ; We used to emit the code at the entry point of the function
 ; instead of just before the prologue.
 ; For now, shrink-wrapping is disabled on segmented stack functions: PR26107.
 ;
 ; CHECK-LABEL: segmentedStack:
 ; CHECK: cmpq
-; CHECK-NEXT: ja [[ENTRY_LABEL:LBB[0-9_]+]]
-;
-; CHECK: callq ___morestack
-; CHECK-NEXT: retq
-;
-; CHECK: [[ENTRY_LABEL]]:
-; Prologue
-; CHECK: push
+; CHECK-NEXT: jbe [[ENTRY_LABEL:LBB[0-9_]+]]
 ;
 ; In PR26107, we use to drop these two basic blocks, because
 ; the segmentedStack entry block was jumping directly to
 ; the place where the prologue is actually needed, which is
 ; the call to memcmp.
 ; Then, those two basic blocks did not have any predecessors
 ; anymore and were removed.
 ;
 ; Check if vk1 is null
 ; CHECK: testq %rdi, %rdi
 ; CHECK-NEXT: je [[STRINGS_EQUAL:LBB[0-9_]+]]
 ;
 ; Check if vk2 is null
 ; CHECK: testq %rsi, %rsi
 ; CHECK-NEXT:  je [[STRINGS_EQUAL]]
 ;
 ; CHECK: [[STRINGS_EQUAL]]
 ; CHECK: popq
+;
+; CHECK: [[ENTRY_LABEL]]:
+; CHECK: callq ___morestack
+; CHECK-NEXT: retq
+;
+
 define zeroext i1 @segmentedStack(i8* readonly %vk1, i8* readonly %vk2, i64 %key_size) #5 {
 entry:
   %cmp.i = icmp eq i8* %vk1, null
   %cmp1.i = icmp eq i8* %vk2, null
   %brmerge.i = or i1 %cmp.i, %cmp1.i
   %cmp1.mux.i = and i1 %cmp.i, %cmp1.i
   br i1 %brmerge.i, label %__go_ptr_strings_equal.exit, label %if.end4.i