Add a "probe-stack" attribute

[Zoxc]

Summary

This attribute is used to ensure the guard page is triggered on stack overflow. Stack frames larger than the guard page size will generate a call to __probestack to touch each page so the guard page won't be skipped.

[silvas]

Has this been discussed on LLVMdev? Our development process requires
changes to the IR to have a design discussion on LLVMdev first.

• Sean Silva

[Zoxc]

No, this has not yet been discussed on LLVMdev.

[Zoxc]

This now uses the string attribute "probe-stack". Dynamic allocations will have stack probes added. I also added a fast path for smaller frames.

[Zoxc]

Fixed up the tests some.

[Zoxc]

Used the right scale value on the OR instruction. Change the relocation to the __probestack call on non-Windows x86-64 platforms.

[rnk]

This seems like a reasonable implementation of useful functionality.

lib/Target/X86/X86FrameLowering.cpp

675–706

This change seems like a separable optimization, correct? I'd like to have a separate patch for it.

749

Should be 2 space indentation

[Zoxc]

This is originally 4 commits: https://github.com/Zoxc/llvm/compare/llvm-mirror:master...stprobe

lib/Target/X86/X86FrameLowering.cpp

749

The original code has 4 space indentation here. Don't blame me.

[reames]

Overall, I like the direction of the change, but there's a number of details which need adjusted before it's ready for submission. The biggest is that this patch seems to combine a bunch of separate pieces and it would be better to factor this apart into a series of patches which each do one thing. This would make it much easier to review.

include/llvm/CodeGen/MachineFunction.h

271

Could you define the term "probing the stack" here? This is likely be where an LLVM developer might encounter the concept. One short sentence is fine.

lib/Target/ARM/ARMFrameLowering.cpp

304

Seems like you should rename WindowsRequiredStackProbe since this is no longer Windows specific.

lib/Target/X86/X86FrameLowering.cpp

500

What is this magic constant? At minimum, comment it.

This looks like it might be an independent bugfix? If so, please submit separately.

673

This section is a large diff that I'm having trouble understanding. If you can split this up into a set of smaller patches, that would help a lot.

675–705

Magic numbers? What do these mean?

708–709

In a separate change, exacting out this code out as a helper function (getStackProbeSymbol(..)) would make the functional diff easier to follow.

712

I don't understand this section at all. What's the motivation here?

Again, could this be separate patch?

lib/Target/X86/X86ISelLowering.cpp

18214

This condition "feels" wrong. It looks like you're only avoiding this case for 32 bit Windows? Why? The old code didn't.

18249

I'm not clear on what this change is doing. In addition to the changed symbol, it looks like you're adding 64 vs 32 bit case? Is this an unrelated bugfix?

lib/Transforms/IPO/Inliner.cpp

140

Add a comment to justify.

Would it be better to just prevent inlining when only one has probe-stack? (i.e. is this expected to ever happen?)

test/CodeGen/X86/mingw-alloca.ll

32

Why are you modifying the existing test rather than adding a new one? Is this test incorrect? It doesn't seem to be on first read.

test/CodeGen/X86/pr17631.ll

21

This looks like it goes with an optimization?

Can you add a test case for the unoptimized case?

Again, optimizations should be separate patches.

test/CodeGen/X86/stack-probes.ll

2

Why bother with a custom prefix if they are the same? You can just use the default CHECK prefix.

24

A comment describing what each test is checking for would be helpful.

test/CodeGen/X86/win64_alloca_dynalloca.ll

13

Why are you modify existing tests rather than adding new ones? Is this because of a new optimization?

[Zoxc]

A newer version was posted to the mailing list.

lib/Target/X86/X86ISelLowering.cpp

18214

The old code did also just avoid 32-bit Windows (the only other case was 64-bit Windows)

18249

This calls the x86-32 probestack function the same way as x86-64 chkstk/__probestack. I'll make this more explicit.

test/CodeGen/X86/stack-probes.ll

2

A custom prefix seems to be the pattern, and it makes sense if tests for other platforms will be added.

include/llvm/CodeGen/MachineFunction.h

   /// Should we be emitting segmented stack stuff for the function
   bool shouldSplitStack();
 
+  /// Should we be probing the stack for the function
+  bool shouldProbeStack();
+
   /// getNumBlockIDs - Return the number of MBB ID's allocated.
   ///
   unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }

lib/CodeGen/MachineFunction.cpp

   return getFunction()->hasFnAttribute("split-stack");
 }
 
+/// Should we be probing the stack for the function
+bool MachineFunction::shouldProbeStack() {
+  return getFunction()->hasFnAttribute("probe-stack");
+}
+
 /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
 /// recomputes them.  This guarantees that the MBB numbers are sequential,
 /// dense, and match the ordering of the blocks within the function.  If a

lib/Target/ARM/ARMFrameLowering.cpp

   } else
     NumBytes = DPRCSOffset;
 
-  if (STI.isTargetWindows() && WindowsRequiresStackProbe(MF, NumBytes)) {
+  if ((STI.isTargetWindows() || MF.shouldProbeStack())
+      && WindowsRequiresStackProbe(MF, NumBytes)) {
     uint32_t NumWords = NumBytes >> 2;
 
     if (NumWords < 65536)

         .addImm(NumWords)
         .setMIFlags(MachineInstr::FrameSetup);
 
+    const char *StackProbeSymbol = STI.isTargetWindows() ?
+        "__chkstk" : "__probestack";
+
     switch (TM.getCodeModel()) {
     case CodeModel::Small:
     case CodeModel::Medium:

     case CodeModel::Kernel:
       BuildMI(MBB, MBBI, dl, TII.get(ARM::tBL))
         .addImm((unsigned)ARMCC::AL).addReg(0)
-        .addExternalSymbol("__chkstk")
+        .addExternalSymbol(StackProbeSymbol)
         .addReg(ARM::R4, RegState::Implicit)
         .setMIFlags(MachineInstr::FrameSetup);
       break;
     case CodeModel::Large:
     case CodeModel::JITDefault:
       BuildMI(MBB, MBBI, dl, TII.get(ARM::t2MOVi32imm), ARM::R12)
-        .addExternalSymbol("__chkstk")
+        .addExternalSymbol(StackProbeSymbol)
         .setMIFlags(MachineInstr::FrameSetup);
 
       BuildMI(MBB, MBBI, dl, TII.get(ARM::tBLXr))

lib/Target/X86/X86FrameLowering.cpp

     X86FI->setCalleeSavedFrameSize(
       X86FI->getCalleeSavedFrameSize() - TailCallReturnAddrDelta);
 
+  bool UseRedZone = false;
+  bool UseStackProbe = (STI.isOSWindows() && !STI.isTargetMacho()) ||
+                       MF.shouldProbeStack();
+
   // If this is x86-64 and the Red Zone is not disabled, if we are a leaf
   // function, and use up to 128 bytes of stack space, don't have a frame
   // pointer, calls, or dynamic alloca then we do not need to adjust the

       !MFI->hasVarSizedObjects() &&                     // No dynamic alloca.
       !MFI->adjustsStack() &&                           // No calls.
       !IsWin64 &&                                       // Win64 has no Red Zone
+      !(UseStackProbe && StackSize > 128) &&            // No stack probes
       !usesTheStack(MF) &&                              // Don't push and pop.
       !MF.shouldSplitStack()) {                         // Regular stack
     uint64_t MinSize = X86FI->getCalleeSavedFrameSize();
     if (HasFP) MinSize += SlotSize;
     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
     MFI->setStackSize(StackSize);
+    UseRedZone = true;
   }
 
   // Insert stack pointer adjustment for later moving of return addr.  Only

   // responsible for adjusting the stack pointer.  Touching the stack at 4K
   // increments is necessary to ensure that the guard pages used by the OS
   // virtual memory manager are allocated in correct sequence.
-  if (NumBytes >= 4096 && STI.isOSWindows() && !STI.isTargetMacho()) {
-    const char *StackProbeSymbol;
+  if (NumBytes >= 4096 && UseStackProbe) {
+    assert(!UseRedZone && "The Red Zone is not accounted for in stack probes");
 
-    if (Is64Bit) {
-      if (STI.isTargetCygMing()) {
-        StackProbeSymbol = "___chkstk_ms";
+    if (NumBytes <= 0x5000) {
+      BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::SUB64ri32 : X86::SUB32ri),
+              StackPtr)
+          .addReg(StackPtr)
+          .addImm(NumBytes)
+        .setMIFlag(MachineInstr::FrameSetup);
+
+      for (uint64_t i = 0; i < NumBytes / 0x1000; ++i) {
+        BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::OR64mi8 : X86::OR32mi8))
+          .addReg(StackPtr)
+          .addImm(0)
+          .addReg(0)
+          .addImm(NumBytes - (i + 1) * 0x1000)
+          .addReg(0)
+          .addImm(0)
+          .setMIFlag(MachineInstr::FrameSetup);
+      }
+    } else {
+      const char *StackProbeSymbol;
+
+      if (STI.isOSWindows()) {
+        if (Is64Bit) {
+          if (STI.isTargetCygMing()) {
+            StackProbeSymbol = "___chkstk_ms";
+          } else {
+            StackProbeSymbol = "__chkstk";
+          }
+        } else if (STI.isTargetCygMing())
+          StackProbeSymbol = "_alloca";
+        else
+          StackProbeSymbol = "_chkstk";
       } else {
-        StackProbeSymbol = "__chkstk";
+        StackProbeSymbol = "__probestack";
       }
-    } else if (STI.isTargetCygMing())
-      StackProbeSymbol = "_alloca";
-    else
-      StackProbeSymbol = "_chkstk";
 
-    // Check whether EAX is livein for this function.
-    bool isEAXAlive = isEAXLiveIn(MF);
+      // Check whether the accumulator register is livein for this function.
+      bool isRegAccAlive = isEAXLiveIn(MF);
+      auto RegAcc = Is64Bit ? X86::RAX : X86::EAX;
 
-    if (isEAXAlive) {
-      // Sanity check that EAX is not livein for this function.
-      // It should not be, so throw an assert.
-      assert(!Is64Bit && "EAX is livein in x64 case!");
+      if (isRegAccAlive) {
+        // Save RegAcc
+        BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
+          .addReg(RegAcc, RegState::Kill)
+          .setMIFlag(MachineInstr::FrameSetup);
+      }
 
-      // Save EAX
-      BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH32r))
-        .addReg(X86::EAX, RegState::Kill)
-        .setMIFlag(MachineInstr::FrameSetup);
-    }
+      uint64_t NumBytesAdj = isRegAccAlive ? NumBytes - (Is64Bit ? 8 : 4) :
+                                           NumBytes;
 
-    if (Is64Bit) {
-      // Handle the 64-bit Windows ABI case where we need to call __chkstk.
-      // Function prologue is responsible for adjusting the stack pointer.
-      BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64ri), X86::RAX)
-        .addImm(NumBytes)
+      // Allocate NumBytesAdj bytes on stack in case of isRegAccAlive.
+      // We'll also use 8/4 already allocated bytes for EAX.
+      BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::MOV64ri : X86::MOV32ri),
+              RegAcc)
+        .addImm(NumBytesAdj)
         .setMIFlag(MachineInstr::FrameSetup);
-    } else {
-      // Allocate NumBytes-4 bytes on stack in case of isEAXAlive.
-      // We'll also use 4 already allocated bytes for EAX.
-      BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
-        .addImm(isEAXAlive ? NumBytes - 4 : NumBytes)
-        .setMIFlag(MachineInstr::FrameSetup);
-    }
 
       BuildMI(MBB, MBBI, DL,
               TII.get(Is64Bit ? X86::W64ALLOCA : X86::CALLpcrel32))
         .addExternalSymbol(StackProbeSymbol)
         .addReg(StackPtr,    RegState::Define | RegState::Implicit)
         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit)
-      .setMIFlag(MachineInstr::FrameSetup);
-
-    if (Is64Bit) {
-      // MSVC x64's __chkstk and cygwin/mingw's ___chkstk_ms do not adjust %rsp
-      // themself. It also does not clobber %rax so we can reuse it when
-      // adjusting %rsp.
-      BuildMI(MBB, MBBI, DL, TII.get(X86::SUB64rr), StackPtr)
-        .addReg(StackPtr)
-        .addReg(X86::RAX)
         .setMIFlag(MachineInstr::FrameSetup);
-    }
-    if (isEAXAlive) {
-        // Restore EAX
-        MachineInstr *MI = addRegOffset(BuildMI(MF, DL, TII.get(X86::MOV32rm),
-                                                X86::EAX),
-                                        StackPtr, false, NumBytes - 4);
-        MI->setFlag(MachineInstr::FrameSetup);
-        MBB.insert(MBBI, MI);
+
+      if (Is64Bit || !STI.isOSWindows()) {
+        // MSVC x64's __chkstk and cygwin/mingw's ___chkstk_ms do not adjust %rsp
+        // themself. It also does not clobber %rax so we can reuse it when
+        // adjusting %rsp.
+        BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::SUB64rr : X86::SUB32rr),
+                StackPtr)
+          .addReg(StackPtr)
+          .addReg(RegAcc)
+          .setMIFlag(MachineInstr::FrameSetup);
+      }
+      if (isRegAccAlive) {
+          // Restore RegAcc
+          auto MIB = BuildMI(MF, DL,
+                             TII.get(Is64Bit ? X86::MOV64rm : X86::MOV32rm),
+                             RegAcc);
+          MachineInstr *MI = addRegOffset(MIB, StackPtr, false, NumBytesAdj);
+          MI->setFlag(MachineInstr::FrameSetup);
+          MBB.insert(MBBI, MI);
+      }
     }
   } else if (NumBytes) {
     emitSPUpdate(MBB, MBBI, StackPtr, -(int64_t)NumBytes, Is64Bit, IsLP64,

lib/Target/X86/X86ISelLowering.cpp

   MachineFunction &MF = DAG.getMachineFunction();
   bool SplitStack = MF.shouldSplitStack();
   bool Lower = (Subtarget->isOSWindows() && !Subtarget->isTargetMacho()) ||
-               SplitStack;
+               SplitStack || MF.shouldProbeStack();
   SDLoc dl(Op);
 
   if (!Lower) {

   // The lowering is pretty easy: we're just emitting the call to _alloca.  The
   // non-trivial part is impdef of ESP.
 
-  if (Subtarget->isTargetWin64()) {
+  if (Subtarget->isTargetWin64() || !Subtarget->isOSWindows()) {
     if (Subtarget->isTargetCygMing()) {
       // ___chkstk(Mingw64):
       // Clobbers R10, R11, RAX and EFLAGS.

         .addReg(X86::RSP, RegState::Define | RegState::Implicit)
         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
     } else {
-      // __chkstk(MSVCRT): does not update stack pointer.
-      // Clobbers R10, R11 and EFLAGS.
-      BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
-        .addExternalSymbol("__chkstk")
-        .addReg(X86::RAX, RegState::Implicit)
-        .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
-      // RAX has the offset to be subtracted from RSP.
-      BuildMI(*BB, MI, DL, TII->get(X86::SUB64rr), X86::RSP)
-        .addReg(X86::RSP)
-        .addReg(X86::RAX);
+      const char *StackProbeSymbol =
+        Subtarget->isOSWindows() ? "__chkstk" : "__probestack";
+      if (Subtarget->is64Bit()) {
+        // __chkstk(MSVCRT): does not update stack pointer.
+        // Clobbers R10, R11 and EFLAGS.
+        BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
+          .addExternalSymbol(StackProbeSymbol)
+          .addReg(X86::RAX, RegState::Implicit)
+          .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
+        // RAX has the offset to be subtracted from RSP.
+        BuildMI(*BB, MI, DL, TII->get(X86::SUB64rr), X86::RSP)
+          .addReg(X86::RSP)
+          .addReg(X86::RAX);
+      } else {
+        BuildMI(*BB, MI, DL, TII->get(X86::CALLpcrel32))
+          .addExternalSymbol(StackProbeSymbol)
+          .addReg(X86::EAX, RegState::Implicit)
+          .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
+        // EAX has the offset to be subtracted from ESP.
+        BuildMI(*BB, MI, DL, TII->get(X86::SUB32rr), X86::ESP)
+          .addReg(X86::ESP)
+          .addReg(X86::EAX);
+      }
     }
   } else {
     const char *StackProbeSymbol =

lib/Transforms/IPO/Inliner.cpp

 
   AdjustCallerSSPLevel(Caller, Callee);
 
+  if (Callee->hasFnAttribute("probe-stack")) {
+    Caller->addFnAttr("probe-stack", "");
+  }
+
   // Look at all of the allocas that we inlined through this call site.  If we
   // have already inlined other allocas through other calls into this function,
   // then we know that they have disjoint lifetimes and that we can merge them.

test/CodeGen/X86/mingw-alloca.ll

 ; COFF: andl $-16, %esp
 ; COFF: pushl %eax
 ; COFF: calll __alloca
-; COFF: movl  8028(%esp), %eax
+; COFF: movl  80028(%esp), %eax
 ; ELF: foo2:
 ; ELF: andl $-16, %esp
 ; ELF: pushl %eax
 ; ELF: calll _alloca
-; ELF: movl 8028(%esp), %eax
-  %A2 = alloca [2000 x i32], align 16    ; <[2000 x i32]*> [#uses=1]
-  %A2.sub = getelementptr [2000 x i32]* %A2, i32 0, i32 0    ; <i32*> [#uses=1]
+; ELF: movl 80028(%esp), %eax
+  %A2 = alloca [20000 x i32], align 16    ; <[20000 x i32]*> [#uses=1]
+  %A2.sub = getelementptr [20000 x i32]* %A2, i32 0, i32 0    ; <i32*> [#uses=1]
   call void @bar2( i32* %A2.sub, i32 %N )
   ret void
 }

test/CodeGen/X86/pr17631.ll

 
 ; CHECK: equal
 ; CHECK-NOT: vzeroupper
-; CHECK: _chkstk
+; CHECK: orl $0, 64(%esp)
 ; CHECK: ret
 
 define <8 x float> @foo(<8 x float> %y, i64* %p, double %x) {

test/CodeGen/X86/stack-probes.ll

+; RUN: llc -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck --check-prefix=X86-Linux %s
+; RUN: llc -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefix=X64-Linux %s
+
+declare void @use([40096 x i8]*)
+
+define void @test() "probe-stack" {
+  %array = alloca [40096 x i8], align 16
+  call void @use([40096 x i8]* %array)
+  ret void
+
+; X86-Linux-LABEL: test:
+; X86-Linux:       movl $40124, %eax
+; X86-Linux-NEXT:  calll __probestack
+; X86-Linux-NEXT:  subl %eax, %esp
+; X86-Linux:       leal 16(%esp), %eax
+; X86-Linux-NEXT:  movl %eax, (%esp)
+; X86-Linux-NEXT:  calll use
+; X86-Linux-NEXT:  addl $40124, %esp
+; X86-Linux-NEXT:  retl
+
+; X64-Linux-LABEL: test:
+; X64-Linux:       movabsq $40104, %rax
+; X64-Linux-NEXT:  callq __probestack
+; X64-Linux-NEXT:  subq %rax, %rsp
+; X64-Linux:       leaq (%rsp), %rdi
+; X64-Linux-NEXT:  callq use
+; X64-Linux-NEXT:  addq $40104, %rsp
+; X64-Linux-NEXT:  retq
+  
+}

test/CodeGen/X86/win64_alloca_dynalloca.ll

 ; EFI-LABEL: unaligned:
 entry:
 
-  %buf0 = alloca i8, i64 4096, align 1
+  %buf0 = alloca i8, i64 40096, align 1
 
 ; ___chkstk_ms does not adjust %rsp.
 ; M64: movq  %rsp, %rbp
-; M64:       $4096, %rax
+; M64:       $40096, %rax
 ; M64: callq ___chkstk_ms
 ; M64: subq  %rax, %rsp
 
 ; __chkstk does not adjust %rsp.
 ; W64: movq  %rsp, %rbp
-; W64:       $4096, %rax
+; W64:       $40096, %rax
 ; W64: callq __chkstk
 ; W64: subq  %rax, %rsp
 
 ; Freestanding
 ; EFI: movq  %rsp, %rbp
-; EFI:       $[[B0OFS:4096|4104]], %rsp
+; EFI:       $[[B0OFS:40096|40104]], %rsp
 ; EFI-NOT:   call
 
   %buf1 = alloca i8, i64 %n, align 1

 
 ; M64: subq  $48, %rsp
 ; M64: movq  %rax, 32(%rsp)
-; M64: leaq  -4096(%rbp), %r9
+; M64: leaq  -40096(%rbp), %r9
 ; M64: callq bar
 
 ; W64: subq  $48, %rsp
 ; W64: movq  %rax, 32(%rsp)
-; W64: leaq  -4096(%rbp), %r9
+; W64: leaq  -40096(%rbp), %r9
 ; W64: callq bar
 
 ; EFI: subq  $48, %rsp

test/CodeGen/X86/win64_eh.ll

 }
 ; WIN64-LABEL: foo2:
 ; WIN64: .seh_proc foo2
-; WIN64: movabsq $8000, %rax
-; WIN64: callq {{__chkstk|___chkstk_ms}}
-; WIN64: subq %rax, %rsp
+; WIN64: subq    $8000, %rsp
+; WIN64: orq     $0, 3904(%rsp)
 ; WIN64: .seh_stackalloc 8000
 ; WIN64: .seh_endprologue
 ; WIN64: addq $8000, %rsp

test/CodeGen/X86/win_chkstk.ll

 ; RUN: llc < %s -mtriple=i686-pc-win32 | FileCheck %s -check-prefix=WIN_X32
 ; RUN: llc < %s -mtriple=x86_64-pc-win32 | FileCheck %s -check-prefix=WIN_X64
-; RUN: llc < %s -mtriple=i686-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X32
-; RUN: llc < %s -mtriple=x86_64-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X64
-; RUN: llc < %s -mtriple=i386-pc-linux | FileCheck %s -check-prefix=LINUX
-; RUN: llc < %s -mtriple=x86_64-pc-win32-macho | FileCheck %s -check-prefix=LINUX
+; RUN: llc < %s -mtriple=i686-pc-mingw32 | FileCheck %s -check-prefix=WIN_X32
+; RUN: llc < %s -mtriple=x86_64-pc-mingw32 | FileCheck %s -check-prefix=WIN_X64
+; RUN: llc < %s -mtriple=i386-pc-linux | FileCheck %s -check-prefix=LINUX_X32
+; RUN: llc < %s -mtriple=x86_64-pc-win32-macho | FileCheck %s -check-prefix=LINUX_X64
 
 ; Windows and mingw require a prologue helper routine if more than 4096 bytes area
 ; allocated on the stack.  Windows uses __chkstk and mingw uses __alloca.  __alloca

 ; Stack allocation >= 4096 bytes will require call to __chkstk in the Windows ABI.
 define i32 @main4k() nounwind {
 entry:
-; WIN_X32:    calll __chkstk
-; WIN_X64:    callq __chkstk
-; MINGW_X32:  calll __alloca
-; MINGW_X64:  callq ___chkstk_ms
-; LINUX-NOT:  call __chkstk
+; WIN_X32:       orl     $0, 16(%esp)
+; LINUX_X32-NOT: orl     $0, 16(%esp)
+; WIN_X64:       orq     $0, 8(%rsp)
+; LINUX_X64-NOT: orq     $0, 8(%rsp)
   %array4096 = alloca [4096 x i8], align 16       ; <[4096 x i8]*> [#uses=0]
   ret i32 0
 }

 define i32 @main128() nounwind {
 entry:
 ; WIN_X32:       # BB#0:
-; WIN_X32-NOT:   calll __chkstk
+; WIN_X32-NOT:   orl     $0, 16(%esp)
 ; WIN_X32:       ret
 
+; LINUX_X32:     # BB#0:
+; LINUX_X32-NOT: orl     $0, 16(%esp)
+; LINUX_X32:     ret
+
 ; WIN_X64:       # BB#0:
-; WIN_X64-NOT:   callq __chkstk
+; WIN_X64-NOT:   orq     $0, 8(%rsp)
 ; WIN_X64:       ret
 
-; MINGW_X64:     # BB#0:
-; MINGW_X64-NOT: callq ___chkstk_ms
-; MINGW_X64:     ret
-
-; LINUX:         # BB#0:
 ; LINUX-NOT:     call __chkstk
-; LINUX:         ret
+
+; LINUX_X64:     # BB#0:
+; LINUX_X64-NOT: orq     $0, 8(%rsp)
+; LINUX_X64:     ret
+
   %array128 = alloca [128 x i8], align 16         ; <[128 x i8]*> [#uses=0]
   ret i32 0
 }

 ; caller has the Win64 calling convention.
 define x86_64_win64cc i32 @main4k_win64() nounwind {
 entry:
-; WIN_X32:    calll __chkstk
-; WIN_X64:    callq __chkstk
-; MINGW_X32:  calll __alloca
-; MINGW_X64:  callq ___chkstk_ms
-; LINUX-NOT:  call __chkstk
+; WIN_X32:       orl     $0, 16(%esp)
+; WIN_X64:       orq     $0, 8(%rsp)
+; LINUX_X32-NOT: orl     $0, 16(%esp)
+; LINUX_X64-NOT: orq     $0, 8(%rsp)
   %array4096 = alloca [4096 x i8], align 16       ; <[4096 x i8]*> [#uses=0]
   ret i32 0
 }