Fix hardcoded stack probe space

[majnemer]

Summary

The LLVM stack probe space (e.g. used for issuing chkstk() calls when compiling to Windows targets) is hard coded to 4096 bytes. However, in order to suppress chkstk() calls, it should be possible to specify a minimum value for issuing stack probe calls that is greater than 4096 bytes.

This code makes the number of bytes that variables can occupy before a stack probe is initiated configurable.

This should fix http://llvm.org/bugs/show_bug.cgi?id=21895

[majnemer]

lib/Target/X86/X86Subtarget.cpp

230

Please indent this.

[AndrewH]

Use spaces instead of tabs.

[AndrewH]

I took the liberty to add some reviewers based on the commit history. Is anything blocking this? I would be happy to help.

[hans]

Looks good to me with the comment below.

lib/Target/X86/X86Subtarget.h

280

I think the parameter should be named StackProbeSizeOverride here?

[hans]

Sorry, forgot to mention that this needs to be tested.

Look in the test/ directory for tests using -stack-alignment=. It should be possible to test this similarly.

[AndrewH]

Fixed parameter naming in method prototype, thanks!

[AndrewH]

Testing: OK, I will look into that.

[AndrewH]

Fixed handling of -stack-probe-size=0. In contrast to the stack alignment override, zero is a valid value for the stack probe size override (i.e. always generate stack probing calls, regardless of how many bytes the local variables occupy). Unfortunately that means a little bit more management overhead, as there is no magic value for the stack probe size that indicates that the users wants to use the default size. On the plus side, the driver does not need to know any internals, like that the default page size is 4096 bytes.

Added test cases.

[majnemer]

What happens if we do LTO? Don't we need to record the probe size on the function?

It wouldn't make sense to make it a command line flag if we supported this on a per function basis.

[AndrewH]

What happens if we do LTO?

Well, if nothing else is specified, it will take the default stack probe size; that means that the behavior with LTO is as it was before.

Don't we need to record the probe size on the function?

Great suggestion! That might be useful.

It wouldn't make sense to make it a command line flag if we supported this on a per function basis.

I think that the stack alignment is also tracked on a per function basis, and there is still a command line flag for overriding that.

My aim is currently to get MSVC's /Gs into LLVM, and I cannot see how one could do that without a command line flag.

I will look how the stack alignment is specified when using LTO and will report back if that is also useful in this case.

[AndrewH]

This revision adds the StackProbeSize function attribute, which behaves similarly to the already existing StackAlignment attribute.

[majnemer]

In D6684#104236, @AndrewH wrote:

What happens if we do LTO?

Well, if nothing else is specified, it will take the default stack probe size; that means that the behavior with LTO is as it was before.

Sure, but MSVC also supports LTO (under the name LTCG). I'd imagine that they have some sort of behavior when a function with probe size X gets inlined into a function with probe size Y. My guess would be that they'd just take the max of the two functions.

Don't we need to record the probe size on the function?

Great suggestion! That might be useful.

It wouldn't make sense to make it a command line flag if we supported this on a per function basis.

I think that the stack alignment is also tracked on a per function basis, and there is still a command line flag for overriding that.

My aim is currently to get MSVC's /Gs into LLVM, and I cannot see how one could do that without a command line flag.

Well, we need a command line flag at the clang level. I don't see why we would need one at the LLVM level because clang can translate the /Gs value into a function attribute.

I will look how the stack alignment is specified when using LTO and will report back if that is also useful in this case.

[AndrewH]

Well, we need a command line flag at the clang level. I don't see why we would need one at the LLVM level because clang can translate the /Gs value into a function attribute.

This revision has now those command line flags removed. Furthermore, the stackprobesize(n) function attribute is only added iff clang has received an overriding flag (specified via -stack-probe-size=n or /Gsn).

If LLVM generates code in the X86 target, is uses the default stack probe size if the function has no stackprobesize(n) function attribute, otherwise it uses the stack probe size of n.

Sure, but MSVC also supports LTO (under the name LTCG). I'd imagine that they have some sort of behavior when a function with probe size X gets inlined into a function with probe size Y. My guess would be that they'd just take the max of the two functions.

Unfortunately, I must admit that I do not see myself capable of that task, as I am pretty unfamiliar with LTO in LLVM. This revision implements /Gs when LTO is not used, and shows the same behavior for code generation as before when LTO is used. Can this or a later revision be accepted with such a behavior? That would of course only be a partial fix for the initial bug report, but I think would be useful nonetheless.

[majnemer]

include/llvm/Target/TargetOptions.h

182 ↗

(On Diff #17634)

This seems unused.

[AndrewH]

This seems unused.

Yup, correct! It was used in D6685, but is not needed anymore. Updated revision.

[AndrewH]

Ping

[reames]

Minor drive by comments. I'm explicitly deferring giving a LGTM to previous reviewers.

@majnemer -- I would suggest we let this land without addressing your LTO concerns. While I agree that's an issue, this is a strict improvement over what we have. If someone files a bug, adding the inliner logic wouldn't be too hard and I'd probably even get to it.

lib/Target/X86/X86FrameLowering.cpp

540

Why not use: Fn->hasFnAttribute and Fn->getFnAttribute

lib/Target/X86/X86Subtarget.cpp

232

Your comment here is unclear. Specifically, many x86 targets support variable page sizes. I think what you want here is document the fact that we're *assuming* the page size for a page of stack space is *at least* 4k.

I'm not sure having this extracted as a named constant adds anything here.

lib/Target/X86/X86Subtarget.h

302

I might name this getDefaultStackProbeSize just to make it clear it's overridable.

[AndrewH]

Why not use: Fn->hasFnAttribute and Fn->getFnAttribute

Done.

Your comment here is unclear. Specifically, many x86 targets support variable page sizes. I think what you want here is document the fact that we're *assuming* the page size for a page of stack space is *at least* 4k.

I read a little bit up on this topic and you are correct. Updated comment.

I'm not sure having this extracted as a named constant adds anything here.

Before this commit X86FrameLowering::emitPrologue had a similarly named constant. So I thought it would be good style in LLVM and adapted it in my last revisions. Removed named constant.

I might name this getDefaultStackProbeSize just to make it clear it's overridable.

Done.

[majnemer]

This is looking great so far.

Please update the LangRef with your new function attribute, the file is docs/LangRef.rst.

It should go with all the others: http://llvm.org/docs/LangRef.html#function-attributes
Be sure to mention that this attribute only has an effect on specific targets (MingW, Cygwin, MSVC) and that other targets will ignore the attribute.

lib/Target/X86/X86FrameLowering.cpp

532–533

Please format this according to the style guide, the brace should be on the same line as the if.

lib/Target/X86/X86Subtarget.h

237

This should start with a capital letter.

[AndrewH]

Please format this according to the style guide, the brace should be on the same line as the if.

Done.

This should start with a capital letter.

Done.

Please update the LangRef with your new function attribute, the file is docs/LangRef.rst.

Done.

[majnemer]

LGTM with nits.

Thanks for your hard work on this!

lib/IR/Attributes.cpp

563

Can this be a range-based for loop?

[AndrewH]

Can this be a range-based for loop?

Yep, fixed.

[AndrewH]

Sorry, I changed code in the wrong function. Fixed again.

[majnemer]

Do you need someone to apply this patch for you?

[AndrewH]

Do you need someone to apply this patch for you?

Yes, that would be great.

[majnemer]

I found that this patch could be made considerably simpler, I've attached
my version of it.

Andrew, let me know what you think.

• t.patch3 KBDownload

[AndrewH]

Andrew, let me know what you think.

Looks great. If you apply this patch it to trunk, I can continue with clang integration at D6685.

[majnemer]

Committed in rL225360.

docs/LangRef.rst

     If a function that has an ``sspstrong`` attribute is inlined into a
     function that doesn't have an ``sspstrong`` attribute, then the
     resulting function will have an ``sspstrong`` attribute.
+``stackprobesize(<n>)``
+    This attribute indicates that, when emitting the prologue, the backend
+    should emit a call to a prologue helper routine (the so called stack probe
+    function) when allocating more than ``n`` bytes on the stack. Specify the
+    desired size in parentheses.
+    
+    When the function allocates more than a certain amount of stack space,
+    some targets require such a stack probe call so that the function can
+    access its stack memory safely.
+    
+    A value of 0 is legal for ``n`` and indicates that stack probe function
+    calls are emitted regardless of the amount of stack space the function
+    uses.
+    
+    This attribute has only an effect on specific targets (MingW, Cygwin,
+    MSVC) and other targets will ignore this attribute. When this attribute is
+    omitted on such targets, the backend uses a safe default value for the
+    respective target.
 ``uwtable``
     This attribute indicates that the ABI being targeted requires that
     an unwind table entry be produce for this function even if we can

include/llvm-c/Core.h

     LLVMNonNullAttribute = 1ULL << 37,
     LLVMJumpTableAttribute = 1ULL << 38,
     LLVMDereferenceableAttribute = 1ULL << 39,
+    LLVMStackProbeSizeAttribute = 1ULL << 40,
     */
 } LLVMAttribute;
 

include/llvm/Bitcode/LLVMBitCodes.h

     ATTR_KIND_IN_ALLOCA = 38,
     ATTR_KIND_NON_NULL = 39,
     ATTR_KIND_JUMP_TABLE = 40,
-    ATTR_KIND_DEREFERENCEABLE = 41
+    ATTR_KIND_DEREFERENCEABLE = 41,
+    ATTR_KIND_STACK_PROBE_SIZE = 42
   };
 
   enum ComdatSelectionKindCodes {

include/llvm/IR/Attributes.h

                            ///< stored as log2 of alignment with +1 bias 0
                            ///< means unaligned (different from
                            ///< alignstack=(1))
+    StackProbeSize,        ///< Size the local variables may occupy before a
+                           ///< stack probe call is generated.
     StackProtect,          ///< Stack protection.
     StackProtectReq,       ///< Stack protection required.
     StackProtectStrong,    ///< Strong Stack protection.

 
   /// \brief Return a uniquified Attribute object.
   static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0);
+  static Attribute getZeroValue(LLVMContext &Context, 
+                                Attribute::AttrKind Kind, uint64_t Val = 0);
   static Attribute get(LLVMContext &Context, StringRef Kind,
                        StringRef Val = StringRef());
 

   /// alignment set.
   static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align);
   static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align);
+  static Attribute getWithStackProbeSize(LLVMContext &Context, uint64_t Size);
   static Attribute getWithDereferenceableBytes(LLVMContext &Context,
                                               uint64_t Bytes);
 

   /// alignment value.
   unsigned getStackAlignment() const;
 
+  /// \brief Returns the stack probe size field of an attribute as a byte
+  /// value.
+  unsigned getStackProbeSize() const;
+
   /// \brief Returns the number of dereferenceable bytes from the
   /// dereferenceable attribute (or zero if unknown).
   uint64_t getDereferenceableBytes() const;

   /// \brief Get the stack alignment.
   unsigned getStackAlignment(unsigned Index) const;
 
+  /// \brief Get the stack alignment.
+  unsigned getStackProbeSize(unsigned Index) const;
+
   /// \brief Get the number of dereferenceable bytes (or zero if unknown).
   uint64_t getDereferenceableBytes(unsigned Index) const;
 

   std::map<std::string, std::string> TargetDepAttrs;
   uint64_t Alignment;
   uint64_t StackAlignment;
+  uint64_t StackProbeSize;
   uint64_t DerefBytes;
 public:
-  AttrBuilder() : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {}
+  AttrBuilder() : Attrs(0), Alignment(0), StackAlignment(0), StackProbeSize(0),
+                  DerefBytes(0) {}
   explicit AttrBuilder(uint64_t Val)
-    : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {
+    : Attrs(0), Alignment(0), StackAlignment(0), StackProbeSize(0),
+      DerefBytes(0) {
     addRawValue(Val);
   }
   AttrBuilder(const Attribute &A)
-    : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {
+    : Attrs(0), Alignment(0), StackAlignment(0), StackProbeSize(0),
+      DerefBytes(0) {
     addAttribute(A);
   }
   AttrBuilder(AttributeSet AS, unsigned Idx);

   /// \brief Retrieve the stack alignment attribute, if it exists.
   uint64_t getStackAlignment() const { return StackAlignment; }
 
+  /// \brief Retrieve the stack probe size attribute, if it exists.
+  uint64_t getStackProbeSize() const { return StackProbeSize; }
+
   /// \brief Retrieve the number of dereferenceable bytes, if the dereferenceable
   /// attribute exists (zero is returned otherwise).
   uint64_t getDereferenceableBytes() const { return DerefBytes; }

   /// the form used internally in Attribute.
   AttrBuilder &addStackAlignmentAttr(unsigned Align);
 
+  /// \brief This turns an int stack probe size into the form used internally
+  /// in Attribute.
+  AttrBuilder &addStackProbeSizeAttr(unsigned Size);
+
   /// \brief This turns the number of dereferenceable bytes into the form used
   /// internally in Attribute.
   AttrBuilder &addDereferenceableAttr(uint64_t Bytes);

include/llvm/Target/TargetFrameLowering.h

 private:
   StackDirection StackDir;
   unsigned StackAlignment;
+  unsigned StackProbeSize;
   unsigned TransientStackAlignment;
   int LocalAreaOffset;
   bool StackRealignable;
 public:
-  TargetFrameLowering(StackDirection D, unsigned StackAl, int LAO,
+  TargetFrameLowering(StackDirection D, unsigned StackAl, 
+                      unsigned StackProbeS, int LAO,
                       unsigned TransAl = 1, bool StackReal = true)
-    : StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl),
-      LocalAreaOffset(LAO), StackRealignable(StackReal) {}
+    : StackDir(D), StackAlignment(StackAl), StackProbeSize(StackProbeS),
+      TransientStackAlignment(TransAl), LocalAreaOffset(LAO), 
+      StackRealignable(StackReal) {}
 
   virtual ~TargetFrameLowering();
 

   ///
   unsigned getStackAlignment() const { return StackAlignment; }
 
+  /// getStackProbeSize - This method returns the number of bytes which local
+  /// may occupy before a stack probe call is being generated.
+  ///
+  unsigned getStackProbeSize() const { return StackProbeSize; }
+
   /// getTransientStackAlignment - This method returns the number of bytes to
   /// which the stack pointer must be aligned at all times, even between
   /// calls.

lib/AsmParser/LLLexer.cpp

   KEYWORD(asm);
   KEYWORD(sideeffect);
   KEYWORD(alignstack);
+  KEYWORD(stackprobesize);
   KEYWORD(inteldialect);
   KEYWORD(gc);
   KEYWORD(prefix);

lib/AsmParser/LLParser.h

                                AtomicOrdering &Ordering);
     bool ParseOrdering(AtomicOrdering &Ordering);
     bool ParseOptionalStackAlignment(unsigned &Alignment);
+    bool ParseOptionalStackProbeSize(unsigned &Size);
     bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma);
     bool ParseOptionalCommaInAlloca(bool &IsInAlloca);
     bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,bool &AteExtraComma);

lib/AsmParser/LLParser.cpp

       B.addStackAlignmentAttr(Alignment);
       continue;
     }
+    case lltok::kw_stackprobesize: {
+      unsigned Size;
+      if (inAttrGrp) {
+        Lex.Lex();
+        if (ParseToken(lltok::equal, "expected '=' here") ||
+            ParseUInt32(Size))
+          return true;
+      } else {
+        if (ParseOptionalStackProbeSize(Size))
+          return true;
+      }
+      B.addStackProbeSizeAttr(Size);
+      continue;
+    }
     case lltok::kw_alwaysinline:      B.addAttribute(Attribute::AlwaysInline); break;
     case lltok::kw_builtin:           B.addAttribute(Attribute::Builtin); break;
     case lltok::kw_cold:              B.addAttribute(Attribute::Cold); break;

     case lltok::kw_zeroext:         B.addAttribute(Attribute::ZExt); break;
 
     case lltok::kw_alignstack:
+    case lltok::kw_stackprobesize:
     case lltok::kw_alwaysinline:
     case lltok::kw_builtin:
     case lltok::kw_inlinehint:

   return false;
 }
 
+/// ParseOptionalStackProbeSize
+///   ::= /* empty */
+///   ::= 'stackprobesize' '(' 4096 ')'
+bool LLParser::ParseOptionalStackProbeSize(unsigned &Size) {
+  Size = 0;
+  if (!EatIfPresent(lltok::kw_stackprobesize))
+    return false;
+  LocTy ParenLoc = Lex.getLoc();
+  if (!EatIfPresent(lltok::lparen))
+    return Error(ParenLoc, "expected '('");
+  LocTy SizeLoc = Lex.getLoc();
+  if (ParseUInt32(Size)) return true;
+  ParenLoc = Lex.getLoc();
+  if (!EatIfPresent(lltok::rparen))
+    return Error(ParenLoc, "expected ')'");
+  return false;
+}
+
 /// ParseIndexList - This parses the index list for an insert/extractvalue
 /// instruction.  This sets AteExtraComma in the case where we eat an extra
 /// comma at the end of the line and find that it is followed by metadata.

lib/AsmParser/LLToken.h

     kw_asm,
     kw_sideeffect,
     kw_alignstack,
+    kw_stackprobesize,
     kw_inteldialect,
     kw_gc,
     kw_prefix,

lib/Bitcode/Reader/BitcodeReader.cpp

     return Attribute::SExt;
   case bitc::ATTR_KIND_STACK_ALIGNMENT:
     return Attribute::StackAlignment;
+  case bitc::ATTR_KIND_STACK_PROBE_SIZE:
+    return Attribute::StackProbeSize;
   case bitc::ATTR_KIND_STACK_PROTECT:
     return Attribute::StackProtect;
   case bitc::ATTR_KIND_STACK_PROTECT_REQ:

             B.addAlignmentAttr(Record[++i]);
           else if (Kind == Attribute::StackAlignment)
             B.addStackAlignmentAttr(Record[++i]);
+          else if (Kind == Attribute::StackProbeSize)
+            B.addStackProbeSizeAttr(Record[++i]);
           else if (Kind == Attribute::Dereferenceable)
             B.addDereferenceableAttr(Record[++i]);
         } else {                     // String attribute

lib/Bitcode/Writer/BitcodeWriter.cpp

     return bitc::ATTR_KIND_S_EXT;
   case Attribute::StackAlignment:
     return bitc::ATTR_KIND_STACK_ALIGNMENT;
+  case Attribute::StackProbeSize:
+    return bitc::ATTR_KIND_STACK_PROBE_SIZE;
   case Attribute::StackProtect:
     return bitc::ATTR_KIND_STACK_PROTECT;
   case Attribute::StackProtectReq:

lib/IR/AttributeImpl.h

       : EnumAttributeImpl(IntAttrEntry, Kind), Val(Val) {
     assert(
         (Kind == Attribute::Alignment || Kind == Attribute::StackAlignment ||
+         Kind == Attribute::StackProbeSize ||
          Kind == Attribute::Dereferenceable) &&
         "Wrong kind for int attribute!");
   }

 
   unsigned getAlignment() const;
   unsigned getStackAlignment() const;
+  unsigned getStackProbeSize() const;
   uint64_t getDereferenceableBytes() const;
   std::string getAsString(bool InAttrGrp) const;
 

lib/IR/Attributes.cpp

   return Attribute(PA);
 }
 
+Attribute Attribute::getZeroValue(LLVMContext &Context, 
+                                  Attribute::AttrKind Kind, uint64_t Val) {
+  LLVMContextImpl *pImpl = Context.pImpl;
+  FoldingSetNodeID ID;
+  ID.AddInteger(Kind);
+  ID.AddInteger(Val);
+
+  void *InsertPoint;
+  AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
+
+  if (!PA) {
+    PA = new IntAttributeImpl(Kind, Val);
+    pImpl->AttrsSet.InsertNode(PA, InsertPoint);
+  }
+
+  // Return the Attribute that we found or created.
+  return Attribute(PA);
+}
+
 Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {
   LLVMContextImpl *pImpl = Context.pImpl;
   FoldingSetNodeID ID;

   return get(Context, StackAlignment, Align);
 }
 
+Attribute Attribute::getWithStackProbeSize(LLVMContext &Context,
+                                           uint64_t Size) {
+  return getZeroValue(Context, StackProbeSize, Size);
+}
+
 Attribute Attribute::getWithDereferenceableBytes(LLVMContext &Context,
                                                 uint64_t Bytes) {
   assert(Bytes && "Bytes must be non-zero.");

   return pImpl->getValueAsInt();
 }
 
+/// This returns the stack probe size field of an attribute as a byte value.
+unsigned Attribute::getStackProbeSize() const {
+  assert(hasAttribute(Attribute::StackProbeSize) &&
+         "Trying to get stack probe size from non-size attribute!");
+  return pImpl->getValueAsInt();
+}
+
 /// This returns the number of dereferenceable bytes.
 uint64_t Attribute::getDereferenceableBytes() const {
   assert(hasAttribute(Attribute::Dereferenceable) &&

     return Result;
   }
 
+  if (hasAttribute(Attribute::StackProbeSize)) {
+    std::string Result;
+    Result += "stackprobesize";
+    if (InAttrGrp) {
+      Result += "=";
+      Result += utostr(getValueAsInt());
+    } else {
+      Result += "(";
+      Result += utostr(getValueAsInt());
+      Result += ")";
+    }
+    return Result;
+  }
+
   if (hasAttribute(Attribute::Dereferenceable)) {
     std::string Result;
     Result += "dereferenceable";

   case Attribute::JumpTable:       return 1ULL << 45;
   case Attribute::Dereferenceable:
     llvm_unreachable("dereferenceable attribute not supported in raw format");
+  case Attribute::StackProbeSize:
+    llvm_unreachable("stack probe size attribute not supported in raw format");
   }
   llvm_unreachable("Unsupported attribute type");
 }

   return 0;
 }
 
+unsigned AttributeSetNode::getStackProbeSize() const {
+  for (auto I : *this)
+    if (I.hasAttribute(Attribute::StackProbeSize))
+      return I.getStackProbeSize();
+  return 0;
+}
+
 uint64_t AttributeSetNode::getDereferenceableBytes() const {
   for (iterator I = begin(), E = end(); I != E; ++I)
     if (I->hasAttribute(Attribute::Dereferenceable))

         Mask |= (Log2_32(ASN->getAlignment()) + 1) << 16;
       else if (Kind == Attribute::StackAlignment)
         Mask |= (Log2_32(ASN->getStackAlignment()) + 1) << 26;
+      else if (Kind == Attribute::StackProbeSize)
+        llvm_unreachable("stack probe size not supported in bit mask");
       else if (Kind == Attribute::Dereferenceable)
         llvm_unreachable("dereferenceable not supported in bit mask");
       else

     else if (Kind == Attribute::StackAlignment)
       Attrs.push_back(std::make_pair(Index, Attribute::
                               getWithStackAlignment(C, B.getStackAlignment())));
+    else if (Kind == Attribute::StackProbeSize)
+      Attrs.push_back(std::make_pair(Index, Attribute::
+                              getWithStackProbeSize(C, B.getStackProbeSize())));
     else if (Kind == Attribute::Dereferenceable)
       Attrs.push_back(std::make_pair(Index,
                                      Attribute::getWithDereferenceableBytes(C,

 //===----------------------------------------------------------------------===//
 
 AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index)
-  : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {
+  : Attrs(0), Alignment(0), StackAlignment(0), StackProbeSize(0), 
+    DerefBytes(0) {
   AttributeSetImpl *pImpl = AS.pImpl;
   if (!pImpl) return;
 

 
 void AttrBuilder::clear() {
   Attrs.reset();
-  Alignment = StackAlignment = DerefBytes = 0;
+  Alignment = StackAlignment = StackProbeSize = DerefBytes = 0;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
   assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
   assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
-         Val != Attribute::Dereferenceable &&
+         Val != Attribute::StackProbeSize && Val != Attribute::Dereferenceable &&
          "Adding integer attribute without adding a value!");
   Attrs[Val] = true;
   return *this;

     Alignment = Attr.getAlignment();
   else if (Kind == Attribute::StackAlignment)
     StackAlignment = Attr.getStackAlignment();
+  else if (Kind == Attribute::StackProbeSize)
+    StackProbeSize = Attr.getStackProbeSize();
   else if (Kind == Attribute::Dereferenceable)
     DerefBytes = Attr.getDereferenceableBytes();
   return *this;

     Alignment = 0;
   else if (Val == Attribute::StackAlignment)
     StackAlignment = 0;
+  else if (Val == Attribute::StackProbeSize)
+    StackProbeSize = 0;
   else if (Val == Attribute::Dereferenceable)
     DerefBytes = 0;
 

         Alignment = 0;
       else if (Kind == Attribute::StackAlignment)
         StackAlignment = 0;
+      else if (Kind == Attribute::StackProbeSize)
+        StackProbeSize = 0;
       else if (Kind == Attribute::Dereferenceable)
         DerefBytes = 0;
     } else {

   return *this;
 }
 
+AttrBuilder &AttrBuilder::addStackProbeSizeAttr(unsigned Size) {
+  Attrs[Attribute::StackProbeSize] = true;
+  StackProbeSize = Size;
+  return *this;
+}
+
 AttrBuilder &AttrBuilder::addDereferenceableAttr(uint64_t Bytes) {
   if (Bytes == 0) return *this;
 

   if (!StackAlignment)
     StackAlignment = B.StackAlignment;
 
+  if (!StackProbeSize)
+    StackProbeSize = B.StackProbeSize;
+
   if (!DerefBytes)
     DerefBytes = B.DerefBytes;
 

       return false;
 
   return Alignment == B.Alignment && StackAlignment == B.StackAlignment &&
-         DerefBytes == B.DerefBytes;
+         StackProbeSize == B.StackProbeSize && DerefBytes == B.DerefBytes;
 }
 
 AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {

 
   for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
        I = Attribute::AttrKind(I + 1)) {
+    if (I == Attribute::StackProbeSize)
+      continue;
     if (I == Attribute::Dereferenceable)
       continue;
     if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {

lib/IR/Verifier.cpp

         I->getKindAsEnum() == Attribute::Naked ||
         I->getKindAsEnum() == Attribute::InlineHint ||
         I->getKindAsEnum() == Attribute::StackAlignment ||
+        I->getKindAsEnum() == Attribute::StackProbeSize ||
         I->getKindAsEnum() == Attribute::UWTable ||
         I->getKindAsEnum() == Attribute::NonLazyBind ||
         I->getKindAsEnum() == Attribute::ReturnsTwice ||

lib/Target/CppBackend/CPPBackend.cpp

         attrs.removeAttribute(Attribute::StackAlignment);
       }
 
+      if (attrs.contains(Attribute::StackProbeSize)) {
+        Out << "B.addStackProbeSizeAttr(" << attrs.getStackProbeSize()<<')';
+        nl(Out);
+        attrs.removeAttribute(Attribute::StackProbeSize);
+      }
+
       Out << "PAS = AttributeSet::get(mod->getContext(), ";
       if (index == ~0U)
         Out << "~0U,";

lib/Target/Hexagon/HexagonFrameLowering.h

   void determineFrameLayout(MachineFunction &MF) const;
 
 public:
-  explicit HexagonFrameLowering() : TargetFrameLowering(StackGrowsDown, 8, 0) {}
+  explicit HexagonFrameLowering()
+    : TargetFrameLowering(StackGrowsDown, 8, 0, 0) {}
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.

lib/Target/NVPTX/NVPTXFrameLowering.cpp

 using namespace llvm;
 
 NVPTXFrameLowering::NVPTXFrameLowering(NVPTXSubtarget &STI)
-    : TargetFrameLowering(TargetFrameLowering::StackGrowsUp, 8, 0),
+    : TargetFrameLowering(TargetFrameLowering::StackGrowsUp, 8, 0, 0),
       is64bit(STI.is64Bit()) {}
 
 bool NVPTXFrameLowering::hasFP(const MachineFunction &MF) const { return true; }

lib/Target/PowerPC/PPCFrameLowering.cpp

 
 PPCFrameLowering::PPCFrameLowering(const PPCSubtarget &STI)
     : TargetFrameLowering(TargetFrameLowering::StackGrowsDown,
-                          (STI.hasQPX() || STI.isBGQ()) ? 32 : 16, 0),
+                          (STI.hasQPX() || STI.isBGQ()) ? 32 : 16, 0, 0),
       Subtarget(STI) {}
 
 // With the SVR4 ABI, callee-saved registers have fixed offsets on the stack.

lib/Target/X86/X86FrameLowering.h

 
 class X86FrameLowering : public TargetFrameLowering {
 public:
-  explicit X86FrameLowering(StackDirection D, unsigned StackAl, int LAO)
-    : TargetFrameLowering(StackGrowsDown, StackAl, LAO) {}
+  explicit X86FrameLowering(StackDirection D, unsigned StackAl, 
+                            unsigned StackProbeS, int LAO)
+    : TargetFrameLowering(StackGrowsDown, StackAl, StackProbeS, LAO)
+  {}
 
   static void getStackProbeFunction(const X86Subtarget &STI,
                                     unsigned &CallOp,

lib/Target/X86/X86FrameLowering.cpp

       !IsWinEH && (MMI.hasDebugInfo() || Fn->needsUnwindTableEntry());
   bool UseLEA = STI.useLeaForSP();
   unsigned StackAlign = getStackAlignment();
+  unsigned StackProbeSize = getStackProbeSize();
   unsigned SlotSize = RegInfo->getSlotSize();
   unsigned FramePtr = RegInfo->getFrameRegister(MF);
   const unsigned MachineFramePtr = STI.isTarget64BitILP32() ?

 
   bool UseStackProbe = (STI.isOSWindows() && !STI.isTargetMachO());
 
+  if (Fn->hasFnAttribute(Attribute::StackProbeSize)) {
+    Attribute A = Fn->getFnAttribute(Attribute::StackProbeSize);
+    StackProbeSize = A.getStackProbeSize();
+  }
+
   // 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

 
   // Adjust stack pointer: ESP -= numbytes.
 
-  static const size_t PageSize = 4096;
-
   // Windows and cygwin/mingw require a prologue helper routine when allocating
   // more than 4K bytes on the stack.  Windows uses __chkstk and cygwin/mingw
   // uses __alloca.  __alloca and the 32-bit version of __chkstk will probe the

   // 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 >= PageSize && UseStackProbe) {
+  if (NumBytes >= StackProbeSize && UseStackProbe) {
     const char *StackProbeSymbol;
     unsigned CallOp;
 

lib/Target/X86/X86Subtarget.h

   /// entry to the function and which must be maintained by every function.
   unsigned stackAlignment;
 
+  /// DefaultStackProbeSize - When exceeding the stack probe size, stack probing
+  /// functions are inserted if the target requires them. This default value is
+  /// used if the function has no stackprobesize attribute.
+  unsigned DefaultStackProbeSize;
+
   /// Max. memset / memcpy size that is turned into rep/movs, rep/stos ops.
   ///
   unsigned MaxInlineSizeThreshold;

   /// function for this subtarget.
   unsigned getStackAlignment() const { return stackAlignment; }
 
+  /// getDefaultStackProbeSize - Returns the maximum size of stack memory that
+  /// can be safely accessed without calling stack probing functions.
+  unsigned getDefaultStackProbeSize() const { return DefaultStackProbeSize; }
+
   /// getMaxInlineSizeThreshold - Returns the maximum memset / memcpy size
   /// that still makes it profitable to inline the call.
   unsigned getMaxInlineSizeThreshold() const { return MaxInlineSizeThreshold; }

lib/Target/X86/X86Subtarget.cpp

   UseSqrtEst = false;
   UseReciprocalEst = false;
   stackAlignment = 4;
+
+  // By default, we assume that the page size for a page of stack space is at
+  // least 4096 bytes.
+  DefaultStackProbeSize = 4096;
+
   // FIXME: this is a known good value for Yonah. How about others?
   MaxInlineSizeThreshold = 128;
 }

                   TargetTriple.getEnvironment() == Triple::CODE16),
       TSInfo(DL), InstrInfo(initializeSubtargetDependencies(CPU, FS)),
       TLInfo(TM), FrameLowering(TargetFrameLowering::StackGrowsDown,
-                                getStackAlignment(), is64Bit() ? -8 : -4) {
+                                getStackAlignment(), 
+                                getDefaultStackProbeSize(), 
+                                is64Bit() ? -8 : -4) {
   // Determine the PICStyle based on the target selected.
   if (TM.getRelocationModel() == Reloc::Static) {
     // Unless we're in PIC or DynamicNoPIC mode, set the PIC style to None.

lib/Target/XCore/XCoreFrameLowering.cpp

 //===----------------------------------------------------------------------===//
 
 XCoreFrameLowering::XCoreFrameLowering(const XCoreSubtarget &sti)
-  : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 4, 0) {
+  : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 4, 0, 0) {
   // Do nothing
 }
 

test/CodeGen/X86/stack-probe-size.ll

+; This test is attempting to detect that the compiler correctly generates stack
+; probe calls when the size of the local variables exceeds the specified stack
+; probe size.
+;
+; Testing the default value of 4096 bytes makes sense, because the default
+; stack probe size equals the page size (4096 bytes for all x86 targets), and
+; this is unlikely to change in the future.
+;
+; RUN: llc < %s | FileCheck %s
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+target triple = "i686-pc-windows-msvc"
+
+define i32 @test1() stackprobesize(0) {
+  %buffer = alloca [4095 x i8]
+
+  ret i32 0
+
+; CHECK-LABEL: _test1:
+; CHECK-NOT: subl $4095, %esp
+; CHECK: movl $4095, %eax
+; CHECK: calll __chkstk
+}
+
+define i32 @test2() {
+  %buffer = alloca [4095 x i8]
+
+  ret i32 0
+
+; CHECK-LABEL: _test2:
+; CHECK-NOT: movl $4095, %eax
+; CHECK: subl $4095, %esp
+; CHECK-NOT: calll __chkstk
+}
+
+define i32 @test3() stackprobesize(8192) {
+  %buffer = alloca [4095 x i8]
+
+  ret i32 0
+
+; CHECK-LABEL: _test3:
+; CHECK-NOT: movl $4095, %eax
+; CHECK: subl $4095, %esp
+; CHECK-NOT: calll __chkstk
+}
+
+define i32 @test4() stackprobesize(0) {
+  %buffer = alloca [4096 x i8]
+
+  ret i32 0
+
+; CHECK-LABEL: _test4:
+; CHECK-NOT: subl $4096, %esp
+; CHECK: movl $4096, %eax
+; CHECK: calll __chkstk
+}
+
+define i32 @test5() {
+  %buffer = alloca [4096 x i8]
+
+  ret i32 0
+
+; CHECK-LABEL: _test5:
+; CHECK-NOT: subl $4096, %esp
+; CHECK: movl $4096, %eax
+; CHECK: calll __chkstk
+}
+
+define i32 @test6() stackprobesize(8192) {
+  %buffer = alloca [4096 x i8]
+
+  ret i32 0
+
+; CGECK-LABEL: _test6:
+; CGECK-NOT: movl $4096, %eax
+; CGECK: subl $4096, %esp
+; CGECK-NOT: calll __chkstk
+}