[Inline] Add ability to restrict inlining pass to hinted functions only

[Ilod]

Summary

This adds an OnlyHint parameter to createFunctionInliningPass functions, and a -inline-restrict-to-hint command line parameter.
These allows to restrict the inlining pass to hinted functions only.

Before this, the only way to achieve something similar was to use the -inline-threshold and -inlinehint-threshold command line arguments, while using a negative enough value for -inline-threshold to avoid any inlining (even thoses reducing the size). Moreover, there was no clear interface for this other than the command line arguments.

Adding it will allow a straightforward implementation for /Ob1 in clang-cl.

[Ilod]

Pinging about this

[Ilod]

Updated to head revision, and pinging on this.

[eraman]

I'll defer to Chandler on this patch. I have some minor comments and some questions. Is there a practical use case for this or is this more for debugging purposes? Is there a reason why one would want to prevent inlining of, say, a static function with only one callsite that is not marked inline? If it is for debugging/tuning purposes, as you indicate above, using a large negative value for inline-threshold flag will get the job done.

include/llvm/Transforms/IPO.h

104

Nit: restric -> restrict

test/Transforms/Inline/inline-hint.ll

29

I typically specify the checks next to the actual statements (for example, place the above label check next to bar's definition) and I typically see that in all the test cases. I don't know if that is the enforced style, but it does make the test cases more readable.

[Ilod]

It's an equivalent of /Ob1 on MSVC. We usually use this option on build where we want only optimizations that do not hinder debugging. I want to use this to add support for /Ob1 in clang-cl mode.
It seems I could push -mllvm -inline-threshold=-1000 args or something like this when I get the /Ob1 argument instead of adding an API control in LLVM. It feels a little hackish to me (mainly because of the "arbitrary negative enough threshold" I would need to hardcode in clang), the inlining pass would need to compute the size even if it could be avoided, but it would work just fine. I would rather have an API access than pushing -mllvm command line parameters from clang, but I can live with it if you think it's better to keep it this way.

Fixed the typo, moved the test checks.

[davidxl]

lib/Transforms/IPO/InlineSimple.cpp

61

RestrictedToHinted = (OnlyHint || RestrictedInlinetoHinted);

[eraman]

In D20603#460461, @Ilod wrote:

It's an equivalent of /Ob1 on MSVC. We usually use this option on build where we want only optimizations that do not hinder debugging. I want to use this to add support for /Ob1 in clang-cl mode.
It seems I could push -mllvm -inline-threshold=-1000 args or something like this when I get the /Ob1 argument instead of adding an API control in LLVM. It feels a little hackish to me (mainly because of the "arbitrary negative enough threshold" I would need to hardcode in clang), the inlining pass would need to compute the size even if it could be avoided, but it would work just fine. I would rather have an API access than pushing -mllvm command line parameters from clang, but I can live with it if you think it's better to keep it this way.

Fixed the typo, moved the test checks.

Ah! I saw the mention of /Ob 1, but ignored it due to my unfamiliarity with MSVC options. Now the patch makes more sense to me. I also see that you have another patch to add inline hints to implicitly defined functions.

lib/Transforms/IPO/InlineSimple.cpp

61

This is not equivalent. The expected behavior when --inline-restrict-to-hint=false is to disable this even when the OnlyHint param is true. This is documented above.

[davidxl]

lib/Transforms/IPO/InlineSimple.cpp

61

maybe making the option an enum one to make it clearer?

[rnk]

As mentioned in D20647, I think we can handle this entirely in the frontend.

include/llvm/Transforms/IPO.h

 /// createFunctionInliningPass - Return a new pass object that uses a heuristic
 /// to inline direct function calls to small functions.
 ///
 /// The Threshold can be passed directly, or asked to be computed from the
 /// given optimization and size optimization arguments.
 ///
 /// The -inline-threshold command line option takes precedence over the
 /// threshold given here.
+///
+/// The OnlyHint flag allow to restrict inlining analysis to function with
+/// InlineHint attribute.
+///
+/// The inline-restrict-to-hint command line option takes precedence over the
+/// flag given here.
 Pass *createFunctionInliningPass();
-Pass *createFunctionInliningPass(int Threshold);
-Pass *createFunctionInliningPass(unsigned OptLevel, unsigned SizeOptLevel);
+Pass *createFunctionInliningPass(int Threshold, bool OnlyHint = false);
+Pass *createFunctionInliningPass(unsigned OptLevel, unsigned SizeOptLevel,
+                                 bool OnlyHint = false);
 
 //===----------------------------------------------------------------------===//
 /// createAlwaysInlinerPass - Return a new pass object that inlines only
 /// functions that are marked as "always_inline".
 Pass *createAlwaysInlinerPass();
 Pass *createAlwaysInlinerPass(bool InsertLifetime);
 
 //===----------------------------------------------------------------------===//

lib/Transforms/IPO/InlineSimple.cpp

 #include "llvm/IR/Type.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/InlinerPass.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "inline"
 
+static cl::opt<bool> RestrictInlineToHinted(
+    "inline-restrict-to-hint", cl::Hidden, cl::init(false),
+    cl::desc("Flag to restrict inlining to InlineHint functions only"));
+
 namespace {
 
 /// \brief Actual inliner pass implementation.
 ///
 /// The common implementation of the inlining logic is shared between this
 /// inliner pass and the always inliner pass. The two passes use different cost
 /// analyses to determine when to inline.
 class SimpleInliner : public Inliner {
   // This field is populated based on one of the following:
   //  * optimization or size-optimization levels,
   //  * the --inline-threshold flag, or
   //  * a user specified value.
   int DefaultThreshold;
 
 public:
   SimpleInliner()
-      : Inliner(ID), DefaultThreshold(llvm::getDefaultInlineThreshold()) {
+      : Inliner(ID), DefaultThreshold(llvm::getDefaultInlineThreshold()),
+        RestrictToHinted(RestrictInlineToHinted) {
     initializeSimpleInlinerPass(*PassRegistry::getPassRegistry());
   }
 
-  explicit SimpleInliner(int Threshold)
+  explicit SimpleInliner(int Threshold, bool OnlyHint)
       : Inliner(ID), DefaultThreshold(Threshold) {
+    RestrictToHinted = RestrictInlineToHinted.getNumOccurrences() > 0 ?
+      RestrictInlineToHinted : OnlyHint;
     initializeSimpleInlinerPass(*PassRegistry::getPassRegistry());
   }
 
   static char ID; // Pass identification, replacement for typeid
 
   InlineCost getInlineCost(CallSite CS) override {
+    if (RestrictToHinted && !CS.hasFnAttr(llvm::Attribute::InlineHint))
+      return InlineCost::getNever();
     Function *Callee = CS.getCalledFunction();
     TargetTransformInfo &TTI = TTIWP->getTTI(*Callee);
     return llvm::getInlineCost(CS, DefaultThreshold, TTI, ACT, PSI);
   }
 
   bool runOnSCC(CallGraphSCC &SCC) override;
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
 private:
   TargetTransformInfoWrapperPass *TTIWP;
+  bool RestrictToHinted;
 };
 
 } // end anonymous namespace
 
 char SimpleInliner::ID = 0;
 INITIALIZE_PASS_BEGIN(SimpleInliner, "inline",
                 "Function Integration/Inlining", false, false)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(SimpleInliner, "inline",
                 "Function Integration/Inlining", false, false)
 
 Pass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
 
-Pass *llvm::createFunctionInliningPass(int Threshold) {
-  return new SimpleInliner(Threshold);
+Pass *llvm::createFunctionInliningPass(int Threshold, bool OnlyHint) {
+  return new SimpleInliner(Threshold, OnlyHint);
 }
 
 Pass *llvm::createFunctionInliningPass(unsigned OptLevel,
-                                       unsigned SizeOptLevel) {
+                                       unsigned SizeOptLevel, bool OnlyHint) {
   return new SimpleInliner(
-      llvm::computeThresholdFromOptLevels(OptLevel, SizeOptLevel));
+      llvm::computeThresholdFromOptLevels(OptLevel, SizeOptLevel), OnlyHint);
 }
 
 bool SimpleInliner::runOnSCC(CallGraphSCC &SCC) {
   TTIWP = &getAnalysis<TargetTransformInfoWrapperPass>();
   return Inliner::runOnSCC(SCC);
 }
 
 void SimpleInliner::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<TargetTransformInfoWrapperPass>();
   Inliner::getAnalysisUsage(AU);
 }

test/Transforms/Inline/inline-hint.ll

+; Test that -inline-restrict-to-hint correctly restrict to hinted functions
+; RUN: opt < %s -inline -inline-restrict-to-hint=true -S  | FileCheck %s -check-prefix=RESTRICT
+; RUN: opt < %s -inline -S  | FileCheck %s -check-prefix=INLINE
+
+; Function Attrs: nounwind readnone uwtable
+define i32 @simpleFunction(i32 %a) #0 {
+entry:
+  %add = add i32 %a, %a
+  ret i32 %add
+}
+
+; Function Attrs: inlinehint nounwind readnone uwtable
+define i32 @hintFunction(i32 %a) #1 {
+entry:
+  %add = add i32 %a, %a
+  ret i32 %add
+}
+
+; INLINE-LABEL: @bar
+; RESTRICT-LABEL: @bar
+; Function Attrs: nounwind readnone uwtable
+define i32 @bar(i32 %a) #0 {
+entry:
+; INLINE-NOT: call i32 @simpleFunction
+; RESTRICT: call i32 @simpleFunction(i32 5)
+  %0 = tail call i32 @simpleFunction(i32 5)
+; INLINE-NOT: call i32 @hintFunction
+; RESTRICT-NOT: call i32 @hintFunction
+  %1 = tail call i32 @hintFunction(i32 6)
+  %add = add i32 %0, %1
+; INLINE: ret
+; RESTRICT: ret
+  ret i32 %add
+}
+
+attributes #0 = { nounwind readnone uwtable }
+attributes #1 = { inlinehint nounwind readnone uwtable }