InlineCostAnnotationPrinterPass - Introducing the pass

[knaumov]

Summary

This patch introduces InlineCostAnnotationPrinterPass - a pass that allows us to use the functionality of InlineCostAnnotationWriter in others than debug builds. This pass performs InlineCostAnalysis on each function that is being called from the given one and then dumps the result, thus activating InlineCostAnnotationWriter.
The main purpose of this pass is to verify the inliner's decisions made in InlineCost. This pass provides functionality to see inliner's logic.
Future revisions will add new functionality to InlineCostAnnotationWriter.
This patch is the second part of D81016.

[knaumov]

A question to @mtrofin:
I have changed the creation of InlineParams from

const InlineParams Params = llvm::getInlineParams();

which invokes the creation of InlineParams with DefaultThreshold to

const InlineParams Params = llvm::getInlineParams(InlineThreshold);

Is this correct?

[mtrofin]

In D81743#2089888, @knaumov wrote:

A question to @mtrofin:
I have changed the creation of InlineParams from

const InlineParams Params = llvm::getInlineParams();

which invokes the creation of InlineParams with DefaultThreshold to

const InlineParams Params = llvm::getInlineParams(InlineThreshold);

Is this correct?

I think it depends on what the goal of the pass is. If it is to capture what costs (pre- any inlining) you'd see during a run of InlinerPass, the question is which run. See PassBuilder.cpp. There are different InlineParams used, for instance, see addPGOInstrPasses, buildInlinerPipeline, and buildLTODefaultPipeline.

I suppose you could pass the InlineParameters as a ctor parameter to the pass?

[knaumov]

Changed the creation of InlineParams back to default params and added a "to-do" comment.
For the purposes of this pass, the idea of which is to give access for non-debug builds to tests that use debug functionality, the InlineParams can be taken as default. My suggestion is to leave the extension of the pass to parametrization with different InlineParams as a "to-do" for now.

[mtrofin]

In D81743#2090561, @knaumov wrote:

Changed the creation of InlineParams back to default params and added a "to-do" comment.
For the purposes of this pass, the idea of which is to give access for non-debug builds to tests that use debug functionality, the InlineParams can be taken as default. My suggestion is to leave the extension of the pass to parametrization with different InlineParams as a "to-do" for now.

I apologize, maybe it's just me - but could you please elaborate the usage scenario, I don't fully follow. Here's what I understand and don't understand so far: in a non-Debug build (say, Release), a developer would run this pass (how?) and then use the results - but how, if the parameters are different from what clang used?

Otherwise the patch is fine, but I think it'd be valuable to capture the intended usage for maintainability - so others can understand why default params are fine there, for instance (or if not, how to correctly change the code, etc).

llvm/lib/Analysis/InlineCost.cpp

2525

nit: I think it's "FIXME: Redesign the usage <...>"

[knaumov]

• Refactored the comment

For now, my view of the pass is to be able to tell what optimizations are seen and predicted by InlineCost. E.g. is a follow-up patch D81024 which enables printing of constants to which the instruction will be simplified. For now, if you've written a simplification for InlineCost that constant-folds some sequence of instructions, you have no way of writing test for it except by setting the inline threshold so low, so the fact of simplification will inline the method. This pass provides an easy way to see such cases directly. Also, the fact of simplification itself is independent of InlineParams, so the pass would work as expected.

[knaumov]

Sorry, submitted wrong diff

[mtrofin]

In D81743#2095745, @knaumov wrote:

• Refactored the comment

For now, my view of the pass is to be able to tell what optimizations are seen and predicted by InlineCost. E.g. is a follow-up patch D81024 which enables printing of constants to which the instruction will be simplified. For now, if you've written a simplification for InlineCost that constant-folds some sequence of instructions, you have no way of writing test for it except by setting the inline threshold so low, so the fact of simplification will inline the method. This pass provides an easy way to see such cases directly. Also, the fact of simplification itself is independent of InlineParams, so the pass would work as expected.

Ah, OK! This description helps a lot, thank you!

If that's the case, could you update the patch description and the pass documentation to specify this is currently for tests, and the FIXME - basically, the FIXME is only if we want to scope this to more than tests.

[knaumov]

• Changed the comments to better reflect the usage of the pass
• Changed the summary of the differential

[mtrofin]

lgtm

1 more nit - in the description "given one and them dumps the result": s/them/then

llvm/lib/Analysis/InlineCost.cpp

2527

nit: the sentence doesn't finish

llvm/include/llvm/Analysis/InlineCost.h

Optional<int> getInliningCostEstimate(
     CallBase &Call, TargetTransformInfo &CalleeTTI,
     function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
     function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
     ProfileSummaryInfo *PSI = nullptr,
     OptimizationRemarkEmitter *ORE = nullptr);
 
 /// Minimal filter to detect invalid constructs for inlining.
 InlineResult isInlineViable(Function &Callee);
+
+// This pass is used to annotate instructions during the inline process for
+// debugging and analysis. The main purpose of the pass is to see and test
+// inliner's decisions when creating new optimizations to InlineCost.
+struct InlineCostAnnotationPrinterPass
+    : PassInfoMixin<InlineCostAnnotationPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit InlineCostAnnotationPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+};
 } // namespace llvm
 
 #endif

llvm/lib/Analysis/InlineCost.cpp

auto Params =
       getInlineParams(computeThresholdFromOptLevels(OptLevel, SizeOptLevel));
   // At O3, use the value of -locally-hot-callsite-threshold option to populate
   // Params.LocallyHotCallSiteThreshold. Below O3, this flag has effect only
   // when it is specified explicitly.
   if (OptLevel > 2)
     Params.LocallyHotCallSiteThreshold = LocallyHotCallSiteThreshold;
   return Params;
 }
+
+PreservedAnalyses
+InlineCostAnnotationPrinterPass::run(Function &F,
+                                     FunctionAnalysisManager &FAM) {
+  PrintInstructionComments = true;
+  std::function<AssumptionCache &(Function &)> GetAssumptionCache = [&](
+      Function &F) -> AssumptionCache & {
+    return FAM.getResult<AssumptionAnalysis>(F);
+  };
+  Module *M = F.getParent();
+  ProfileSummaryInfo PSI(*M);
+  DataLayout DL(M);
+  TargetTransformInfo TTI(DL);
+  // FIXME: Redesign the usage of InlineParams to expand the scope of this pass.
+  // In the current implementation, the type of InlineParams doesn't matter as
+  // the pass serves only for verification of inliner's decisions.
+  // We can add a flag which determines InlineParams for this run. Right now,
+  // the default InlineParams are used.
+  const InlineParams Params = llvm::getInlineParams();
+    for (BasicBlock &BB : F) {
+    for (Instruction &I : BB) {
+      if (CallInst *CI = dyn_cast<CallInst>(&I)) {
+        Function *CalledFunction = CI->getCalledFunction();
+        if (!CalledFunction || CalledFunction->isDeclaration())
+          continue;
+        OptimizationRemarkEmitter ORE(CalledFunction);
+        InlineCostCallAnalyzer ICCA(*CalledFunction, *CI, Params, TTI,
+                                    GetAssumptionCache, nullptr, &PSI, &ORE);
+        ICCA.analyze();
+        OS << "      Analyzing call of " << CalledFunction->getName()
+           << "... (caller:" << CI->getCaller()->getName() << ")\n";
+        ICCA.dump();
+      }
+    }
+  }
+  return PreservedAnalyses::all();
+}
 No newline at end of file

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("print<assumptions>", AssumptionPrinterPass(dbgs()))
 FUNCTION_PASS("print<block-freq>", BlockFrequencyPrinterPass(dbgs()))
 FUNCTION_PASS("print<branch-prob>", BranchProbabilityPrinterPass(dbgs()))
 FUNCTION_PASS("print<da>", DependenceAnalysisPrinterPass(dbgs()))
 FUNCTION_PASS("print<domtree>", DominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<postdomtree>", PostDominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<demanded-bits>", DemandedBitsPrinterPass(dbgs()))
 FUNCTION_PASS("print<domfrontier>", DominanceFrontierPrinterPass(dbgs()))
+FUNCTION_PASS("print<inline-cost>", InlineCostAnnotationPrinterPass(dbgs()))
 FUNCTION_PASS("print<loops>", LoopPrinterPass(dbgs()))
 FUNCTION_PASS("print<memoryssa>", MemorySSAPrinterPass(dbgs()))
 FUNCTION_PASS("print<phi-values>", PhiValuesPrinterPass(dbgs()))
 FUNCTION_PASS("print<regions>", RegionInfoPrinterPass(dbgs()))
 FUNCTION_PASS("print<scalar-evolution>", ScalarEvolutionPrinterPass(dbgs()))
 FUNCTION_PASS("print<stack-safety-local>", StackSafetyPrinterPass(dbgs()))
 FUNCTION_PASS("reassociate", ReassociatePass())
 FUNCTION_PASS("scalarizer", ScalarizerPass())

llvm/test/Transforms/Inline/debuginline-cost-delta.ll

-; Require asserts for -debug-only
-; REQUIRES: asserts
-
-; RUN: opt < %s -inline -debug-only=inline-cost -disable-output -print-instruction-comments 2>&1 | FileCheck %s
+; RUN: opt < %s -passes="print<inline-cost>" 2>&1 | FileCheck %s
 
 ; CHECK:       Analyzing call of callee1... (caller:foo)
-; CHECK: define i32 @callee1(i32 %x) {
-; CHECK: ; cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = 5
-; CHECK:   %x1 = add i32 %x, 1
-; CHECK: ; cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = 5
-; CHECK:   %x2 = add i32 %x1, 1
-; CHECK: ; cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = 5
-; CHECK:   %x3 = add i32 %x2, 1
-; CHECK: ; cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = 0
-; CHECK:   ret i32 %x3
-; CHECK: }
-; CHECK:      NumConstantArgs: 0
-; CHECK:      NumConstantOffsetPtrArgs: 0
-; CHECK:      NumAllocaArgs: 0
-; CHECK:      NumConstantPtrCmps: 0
-; CHECK:      NumConstantPtrDiffs: 0
-; CHECK:      NumInstructionsSimplified: 1
-; CHECK:      NumInstructions: 4
-; CHECK:      SROACostSavings: 0
-; CHECK:      SROACostSavingsLost: 0
-; CHECK:      LoadEliminationCost: 0
-; CHECK:      ContainsNoDuplicateCall: 0
-; CHECK:      Cost: {{.*}}
-; CHECK:      Threshold: {{.*}}
+; CHECK-NEXT: define i32 @callee1(i32 %x) {
+; CHECK-NEXT: cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = {{.*}}
+; CHECK-NEXT:   %x1 = add i32 %x, 1
+; CHECK-NEXT: cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = {{.*}}
+; CHECK-NEXT:   %x2 = add i32 %x1, 1
+; CHECK-NEXT: cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = {{.*}}
+; CHECK-NEXT:   %x3 = add i32 %x2, 1
+; CHECK-NEXT: cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = {{.*}}
+; CHECK-NEXT:   ret i32 %x3
+; CHECK-NEXT: }
 
 define i32 @foo(i32 %y) {
   %x = call i32 @callee1(i32 %y)
   ret i32 %x
 }
 
 define i32 @callee1(i32 %x) {
   %x1 = add i32 %x, 1
   %x2 = add i32 %x1, 1
   %x3 = add i32 %x2, 1
   ret i32 %x3
 }

llvm/test/Transforms/Inline/inline-cost-annotation-pass.ll

+; RUN: opt < %s -passes="print<inline-cost>" 2>&1 | FileCheck %s
+
+; CHECK:       Analyzing call of foo... (caller:main)
+; CHECK: define i8 addrspace(1)** @foo() {
+; CHECK:  cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = {{.*}}
+; CHECK:  %1 = inttoptr i64 754974720 to i8 addrspace(1)**
+; CHECK:  cost before = {{.*}}, cost after = {{.*}}, threshold before = {{.*}}, threshold after = {{.*}}, cost delta = {{.*}}
+; CHECK:  ret i8 addrspace(1)** %1
+; CHECK: }
+; CHECK:       NumConstantArgs: {{.*}}
+; CHECK:       NumConstantOffsetPtrArgs: {{.*}}
+; CHECK:       NumAllocaArgs: {{.*}}
+; CHECK:       NumConstantPtrCmps: {{.*}}
+; CHECK:       NumConstantPtrDiffs: {{.*}}
+; CHECK:       NumInstructionsSimplified: {{.*}}
+; CHECK:       NumInstructions: {{.*}}
+; CHECK:       SROACostSavings: {{.*}}
+; CHECK:       SROACostSavingsLost: {{.*}}
+; CHECK:       LoadEliminationCost: {{.*}}
+; CHECK:       ContainsNoDuplicateCall: {{.*}}
+; CHECK:       Cost: {{.*}}
+; CHECK:       Threshold: {{.*}}
+
+define i8 addrspace(1)** @foo() {
+  %1 = inttoptr i64 754974720 to i8 addrspace(1)**
+  ret i8 addrspace(1)** %1
+}
+
+define i8 addrspace(1)** @main() {
+  %1 = call i8 addrspace(1)** @foo()
+  ret i8 addrspace(1)** %1
+}

llvm/test/Transforms/Inline/print-instructions-deltas-unfinished.ll

-; Require asserts for -debug-only
-; REQUIRES: asserts
-
-; This test ensures that the hadling of instructions which were not analyzed by
-; '-print-instruction-deltas' flag due to the early exit was done correctly.
-
-; RUN: opt < %s -inline -debug-only=inline-cost -disable-output -print-instruction-comments -inline-threshold=0 2>&1 | FileCheck %s
-
-; CHECK: No analysis for the instruction
-; CHECK:   ret void
-
-declare void @callee1()
-
-define void @bar() {
-  call void @callee1()
-  ret void
-}
-
-define void @foo() {
-  call void @bar()
-  ret void
-}