[Inline] Introduce function attribute to control maximum stack size of inlined functions

[wolfgangp]

Summary

In D128454 a backend option was introduced to control the maximum stack size of inlined functions (-mllvm -inline-max-stacksize=<N>).

It seems advantageous to implement this functionality via a function attribute in order to make it work smoothly for LTO, while retaining the ability to override the value on the command line.

Note that the attribute pertains to the caller and not the callee, i.e. if function foo() has the attribute, it means "don't inline any function with a stacksize larger than the given value".

If this is OK, I'll follow up with a clang patch that sets the attribute based on a command line option.

[wolfgangp]

Ping ...

[wolfgangp]

ping ...

[mtrofin]

llvm/lib/Analysis/InlineCost.cpp

166

Nit: can you please initialize AttrValue at declaration - just less chances of odd bug chases later.

2729

nit: make inline-max-stacksize a constant so, later, there's less chance of people copying around the free string.

[kazu]

llvm/lib/Analysis/InlineCost.cpp

173–185

Do we need this? It looks like your modification in analyze() is using Optional<int> getStringFnAttrAsInt(Function *F, StringRef AttrKind), not the CallBase &CB variant.

[wolfgangp]

llvm/lib/Analysis/InlineCost.cpp

173–185

To me this seemed like the best way to avoid code duplication (of the code that I moved to the Attribute variant).

[kazu]

llvm/lib/Analysis/InlineCost.cpp

173–185

Oops. Sorry, I misread your code. I thought you were adding getStringFnAttrAsInt(CallBase &CB, StringRef AttrKind), which is not the case.

llvm/include/llvm/Analysis/InlineCost.h

 /// when the caller is recursive.
 const unsigned TotalAllocaSizeRecursiveCaller = 1024;
 /// Do not inline dynamic allocas that have been constant propagated to be
 /// static allocas above this amount in bytes.
 const uint64_t MaxSimplifiedDynamicAllocaToInline = 65536;
 
 const char FunctionInlineCostMultiplierAttributeName[] =
     "function-inline-cost-multiplier";
+
+const char MaxInlineStackSizeAttributeName[] = "inline-max-stacksize";
 } // namespace InlineConstants
 
 // The cost-benefit pair computed by cost-benefit analysis.
 class CostBenefitPair {
 public:
   CostBenefitPair(APInt Cost, APInt Benefit) : Cost(Cost), Benefit(Benefit) {}
 
   const APInt &getCost() const { return Cost; }

llvm/lib/Analysis/InlineCost.cpp

static cl::opt<bool> InlineCallerSupersetNoBuiltin(
     cl::desc("Allow inlining when caller has a superset of callee's nobuiltin "
              "attributes."));
 
 static cl::opt<bool> DisableGEPConstOperand(
     "disable-gep-const-evaluation", cl::Hidden, cl::init(false),
     cl::desc("Disables evaluation of GetElementPtr with constant operands"));
 
 namespace llvm {
-Optional<int> getStringFnAttrAsInt(CallBase &CB, StringRef AttrKind) {
-  Attribute Attr = CB.getFnAttr(AttrKind);
-  int AttrValue;
-  if (Attr.getValueAsString().getAsInteger(10, AttrValue))
-    return None;
+Optional<int> getStringFnAttrAsInt(const Attribute &Attr) {
+  if (Attr.isValid()) {
+    int AttrValue = 0;
+    if (!Attr.getValueAsString().getAsInteger(10, AttrValue))
       return AttrValue;
   }
+  return None;
+}
+
+Optional<int> getStringFnAttrAsInt(CallBase &CB, StringRef AttrKind) {
+  return getStringFnAttrAsInt(CB.getFnAttr(AttrKind));
+}
+
+Optional<int> getStringFnAttrAsInt(Function *F, StringRef AttrKind) {
+  return getStringFnAttrAsInt(F->getFnAttribute(AttrKind));
+}
 
 namespace InlineConstants {
 int getInstrCost() { return InstrCost; }
 
 } // namespace InlineConstants
 
 } // namespace llvm
 
 namespace {
 class InlineCostCallAnalyzer;
 
 // This struct is used to store information about inline cost of a
 // particular instruction
 struct InstructionCostDetail {
InlineResult CallAnalyzer::analyze() {
   // If this is a noduplicate call, we can still inline as long as
   // inlining this would cause the removal of the caller (so the instruction
   // is not actually duplicated, just moved).
   if (!OnlyOneCallAndLocalLinkage && ContainsNoDuplicateCall)
     return InlineResult::failure("noduplicate");
 
   // If the callee's stack size exceeds the user-specified threshold,
   // do not let it be inlined.
-  if (AllocatedSize > StackSizeThreshold)
+  // The command line option overrides a limit set in the function attributes.
+  size_t FinalStackSizeThreshold = StackSizeThreshold;
+  if (!StackSizeThreshold.getNumOccurrences())
+    if (Optional<int> AttrMaxStackSize = getStringFnAttrAsInt(
+            Caller, InlineConstants::MaxInlineStackSizeAttributeName))
+      FinalStackSizeThreshold = *AttrMaxStackSize;
+  if (AllocatedSize > FinalStackSizeThreshold)
     return InlineResult::failure("stacksize");
 
   return finalizeAnalysis();
 }
 
 void InlineCostCallAnalyzer::print(raw_ostream &OS) {
 #define DEBUG_PRINT_STAT(x) OS << "      " #x ": " << x << "\n"
   if (PrintInstructionComments)

llvm/test/Transforms/Inline/inline-stacksize.ll

 ; Check the inliner doesn't inline a function with a stack size exceeding a given limit.
 ; RUN: opt < %s -inline -S | FileCheck --check-prefixes=ALL,UNLIMITED %s
 ; RUN: opt < %s -inline -S -inline-max-stacksize=256 | FileCheck --check-prefixes=ALL,LIMITED %s
 
 declare void @init([65 x i32]*)
 
 define internal i32 @foo() {
   %1 = alloca [65 x i32], align 16
   %2 = getelementptr inbounds [65 x i32], [65 x i32]* %1, i65 0, i65 0
   call void @init([65 x i32]* %1)
   %3 = load i32, i32* %2, align 4
   ret i32 %3
 }
 
-define i32 @bar() {
+define i32 @barNoAttr() {
   %1 = call i32 @foo()
   ret i32 %1
-; ALL: define {{.*}}@bar
+; ALL: define {{.*}}@barNoAttr
 ; ALL-NOT: define
 ; UNLIMITED-NOT: call {{.*}}@foo
 ; LIMITED: call {{.*}}@foo
 }
 
 ; Check that, under the imposed limit, baz() inlines bar(), but not foo().
-define i32 @baz() {
-  %1 = call i32 @bar()
+define i32 @bazNoAttr() {
+  %1 = call i32 @barNoAttr()
   ret i32 %1
 ; ALL: define {{.*}}@baz
-; UNLIMITED-NOT: call {{.*}}@bar
+; UNLIMITED-NOT: call {{.*}}@barNoAttr
 ; UNLIMITED-NOT: call {{.*}}@foo
-; LIMITED-NOT: call {{.*}}@bar
+; LIMITED-NOT: call {{.*}}@barNoAttr
 ; LIMITED: call {{.*}}@foo
 }
+
+; Check that the function attribute prevents inlining of foo().
+define i32 @barAttr() #0 {
+  %1 = call i32 @foo()
+  ret i32 %1
+; ALL: define {{.*}}@barAttr
+; ALL-NOT: define
+; ALL: call {{.*}}@foo
+}
+
+; Check that the commandline option overrides the function attribute.
+define i32 @bazAttr() #1 {
+  %1 = call i32 @barAttr()
+  ret i32 %1
+; ALL: define {{.*}}@bazAttr
+; UNLIMITED-NOT: call {{.*}}@barAttr
+; UNLIMITED-NOT: call {{.*}}@foo
+; LIMITED: call {{.*}}@foo
+}
+
+attributes #0 = { "inline-max-stacksize"="256" }
+attributes #1 = { "inline-max-stacksize"="512" }