1 //===- ReplayInlineAdvisor.cpp - Replay InlineAdvisor ---------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements ReplayInlineAdvisor that replays inline decisions based
10 // on previous inline remarks from optimization remark log. This is a best
11 // effort approach useful for testing compiler/source changes while holding
12 // inlining steady.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "llvm/Analysis/ReplayInlineAdvisor.h"
17 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
18 #include "llvm/Support/LineIterator.h"
19 #include "llvm/Support/MemoryBuffer.h"
20 #include <memory>
21 
22 using namespace llvm;
23 
24 #define DEBUG_TYPE "replay-inline"
25 
26 ReplayInlineAdvisor::ReplayInlineAdvisor(
27     Module &M, FunctionAnalysisManager &FAM, LLVMContext &Context,
28     std::unique_ptr<InlineAdvisor> OriginalAdvisor,
29     const ReplayInlinerSettings &ReplaySettings, bool EmitRemarks,
30     InlineContext IC)
31     : InlineAdvisor(M, FAM, IC), OriginalAdvisor(std::move(OriginalAdvisor)),
32       ReplaySettings(ReplaySettings), EmitRemarks(EmitRemarks) {
33 
34   auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(ReplaySettings.ReplayFile);
35   std::error_code EC = BufferOrErr.getError();
36   if (EC) {
37     Context.emitError("Could not open remarks file: " + EC.message());
38     return;
39   }
40 
41   // Example for inline remarks to parse:
42   //   main:3:1.1: '_Z3subii' inlined into 'main' at callsite sum:1 @
43   //   main:3:1.1;
44   // We use the callsite string after `at callsite` to replay inlining.
45   line_iterator LineIt(*BufferOrErr.get(), /*SkipBlanks=*/true);
46   const std::string PositiveRemark = "' inlined into '";
47   const std::string NegativeRemark = "' will not be inlined into '";
48 
49   for (; !LineIt.is_at_eof(); ++LineIt) {
50     StringRef Line = *LineIt;
51     auto Pair = Line.split(" at callsite ");
52 
53     bool IsPositiveRemark = true;
54     if (Pair.first.contains(NegativeRemark))
55       IsPositiveRemark = false;
56 
57     auto CalleeCaller =
58         Pair.first.split(IsPositiveRemark ? PositiveRemark : NegativeRemark);
59 
60     StringRef Callee = CalleeCaller.first.rsplit(": '").second;
61     StringRef Caller = CalleeCaller.second.rsplit("'").first;
62 
63     auto CallSite = Pair.second.split(";").first;
64 
65     if (Callee.empty() || Caller.empty() || CallSite.empty()) {
66       Context.emitError("Invalid remark format: " + Line);
67       return;
68     }
69 
70     std::string Combined = (Callee + CallSite).str();
71     InlineSitesFromRemarks[Combined] = IsPositiveRemark;
72     if (ReplaySettings.ReplayScope == ReplayInlinerSettings::Scope::Function)
73       CallersToReplay.insert(Caller);
74   }
75 
76   HasReplayRemarks = true;
77 }
78 
79 std::unique_ptr<InlineAdvisor>
80 llvm::getReplayInlineAdvisor(Module &M, FunctionAnalysisManager &FAM,
81                              LLVMContext &Context,
82                              std::unique_ptr<InlineAdvisor> OriginalAdvisor,
83                              const ReplayInlinerSettings &ReplaySettings,
84                              bool EmitRemarks, InlineContext IC) {
85   auto Advisor = std::make_unique<ReplayInlineAdvisor>(
86       M, FAM, Context, std::move(OriginalAdvisor), ReplaySettings, EmitRemarks,
87       IC);
88   if (!Advisor->areReplayRemarksLoaded())
89     Advisor.reset();
90   return Advisor;
91 }
92 
93 std::unique_ptr<InlineAdvice> ReplayInlineAdvisor::getAdviceImpl(CallBase &CB) {
94   assert(HasReplayRemarks);
95 
96   Function &Caller = *CB.getCaller();
97   auto &ORE = FAM.getResult<OptimizationRemarkEmitterAnalysis>(Caller);
98 
99   // Decision not made by replay system
100   if (!hasInlineAdvice(*CB.getFunction())) {
101     // If there's a registered original advisor, return its decision
102     if (OriginalAdvisor)
103       return OriginalAdvisor->getAdvice(CB);
104 
105     // If no decision is made above, return non-decision
106     return {};
107   }
108 
109   std::string CallSiteLoc =
110       formatCallSiteLocation(CB.getDebugLoc(), ReplaySettings.ReplayFormat);
111   StringRef Callee = CB.getCalledFunction()->getName();
112   std::string Combined = (Callee + CallSiteLoc).str();
113 
114   // Replay decision, if it has one
115   auto Iter = InlineSitesFromRemarks.find(Combined);
116   if (Iter != InlineSitesFromRemarks.end()) {
117     if (InlineSitesFromRemarks[Combined]) {
118       LLVM_DEBUG(dbgs() << "Replay Inliner: Inlined " << Callee << " @ "
119                         << CallSiteLoc << "\n");
120       return std::make_unique<DefaultInlineAdvice>(
121           this, CB, llvm::InlineCost::getAlways("previously inlined"), ORE,
122           EmitRemarks);
123     } else {
124       LLVM_DEBUG(dbgs() << "Replay Inliner: Not Inlined " << Callee << " @ "
125                         << CallSiteLoc << "\n");
126       // A negative inline is conveyed by "None" std::optional<InlineCost>
127       return std::make_unique<DefaultInlineAdvice>(this, CB, std::nullopt, ORE,
128                                                    EmitRemarks);
129     }
130   }
131 
132   // Fallback decisions
133   if (ReplaySettings.ReplayFallback ==
134       ReplayInlinerSettings::Fallback::AlwaysInline)
135     return std::make_unique<DefaultInlineAdvice>(
136         this, CB, llvm::InlineCost::getAlways("AlwaysInline Fallback"), ORE,
137         EmitRemarks);
138   else if (ReplaySettings.ReplayFallback ==
139            ReplayInlinerSettings::Fallback::NeverInline)
140     // A negative inline is conveyed by "None" std::optional<InlineCost>
141     return std::make_unique<DefaultInlineAdvice>(this, CB, std::nullopt, ORE,
142                                                  EmitRemarks);
143   else {
144     assert(ReplaySettings.ReplayFallback ==
145            ReplayInlinerSettings::Fallback::Original);
146     // If there's a registered original advisor, return its decision
147     if (OriginalAdvisor)
148       return OriginalAdvisor->getAdvice(CB);
149   }
150 
151   // If no decision is made above, return non-decision
152   return {};
153 }
154