[PATCH 1/2] 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.

[majnemer]

The MachineFunction changes should be in D9654. The inliner changes need a testcase.

include/llvm/CodeGen/MachineFunction.h

286 ↗

(On Diff #25443)

Please make this function const.

[Zoxc]

Added the test

[majnemer]

lib/Transforms/IPO/Inliner.cpp

100

Any reason why this can't just be Caller->addFnAttr("probe-stack"); ?

[Zoxc]

No.

[Zoxc]

majnemer: Do you have any objections to merging this?

[majnemer]

In D9653#206756, @Zoxc wrote:

majnemer: Do you have any objections to merging this?

I'd be far more comfortable if probe-stack took an argument instead of hard coding the name a specific stack probing function.

[Zoxc]

"probe-stack" is only intended to guarantee that a guard page can be triggered, not to dictate how. __probestack is intended to be added to compiler-rt as to aid implementation (and Windows toolchains have existing functions for this). Ideally LLVM would inline it (as GCC does), but that would require more invasive changes to X86FrameLowering (emitPrologue does not seem like the ideal place to emit a loop).

[Zoxc]

Added documentation.

[Zoxc]

Rebased patch

[whitequark]

@majnemer ping? I am also interested in this.

docs/LangRef.rst

* ``"prologue-short-redirect"`` - This style of patchable
        the patchable instruction larger than a short jump.
 
        ``"prologue-short-redirect"`` is currently only supported on
        x86-64.
 
     This attribute by itself does not imply restrictions on
     inter-procedural optimizations.  All of the semantic effects the
     patching may have to be separately conveyed via the linkage type.
+``"probe-stack"``
+    This attribute indicates that the function will trigger a guard region
+    in the end of the stack. It ensures that accesses to the stack must be
+    no further apart than the size of the guard region to a previous
+    access of the stack.
+
+    If a function that has a ``"probe-stack"`` attribute is inlined into a
+    function that doesn't have a ``"probe-stack"`` attribute, then the
+    resulting function will have a ``"probe-stack"`` attribute.
 ``readnone``
     On a function, this attribute indicates that the function computes its
     result (or decides to unwind an exception) based strictly on its arguments,
     without dereferencing any pointer arguments or otherwise accessing
     any mutable state (e.g. memory, control registers, etc) visible to
     caller functions. It does not write through any pointer arguments
     (including ``byval`` arguments) and never changes any state visible
     to callers. This means that it cannot unwind exceptions by calling

lib/Transforms/IPO/Inliner.cpp

static bool InlineCallIfPossible(Pass &P, CallSite CS, InlineFunctionInfo &IFI,
 
   // Try to inline the function.  Get the list of static allocas that were
   // inlined.
   if (!InlineFunction(CS, IFI, &AAR, InsertLifetime))
     return false;
 
   AttributeFuncs::mergeAttributesForInlining(*Caller, *Callee);
 
+  // If the callee requires stack probes, we ensure that the caller will
+  // require those too
+  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.
   //
   // There are many heuristics possible for merging these allocas, and the
   // different options have different tradeoffs.  One thing that we *really*
   // don't want to hurt is SRoA: once inlining happens, often allocas are no
   // longer address taken and so they can be promoted.

test/Transforms/Inline/inline-probe-stack.ll

+; RUN: opt %s -inline -S | FileCheck %s
+
+define internal void @inner() "probe-stack" {
+  ret void
+}
+
+define void @outer() {
+  call void @inner()
+  ret void
+}
+; CHECK: define void @outer() #0
+; CHECK: attributes #0 = { "probe-stack" }