llvm/lib/Analysis/ReplayInlineAdvisor.cpp

   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 }