llvm/lib/Transforms/Instrumentation/CGProfile.cpp

   1 //===-- CGProfile.cpp -----------------------------------------------------===//
   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 #include "llvm/Transforms/Instrumentation/CGProfile.h"
  10
  11 #include "llvm/ADT/MapVector.h"
  12 #include "llvm/Analysis/BlockFrequencyInfo.h"
  13 #include "llvm/Analysis/LazyBlockFrequencyInfo.h"
  14 #include "llvm/Analysis/TargetTransformInfo.h"
  15 #include "llvm/IR/Constants.h"
  16 #include "llvm/IR/Instructions.h"
  17 #include "llvm/IR/MDBuilder.h"
  18 #include "llvm/IR/PassManager.h"
  19 #include "llvm/InitializePasses.h"
  20 #include "llvm/ProfileData/InstrProf.h"
  21 #include "llvm/Transforms/Instrumentation.h"
  22
  23 #include <array>
  24
  25 using namespace llvm;
  26
  27 static bool
  28 addModuleFlags(Module &M,
  29                MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) {
  30   if (Counts.empty())
  31     return false;
  32
  33   LLVMContext &Context = M.getContext();
  34   MDBuilder MDB(Context);
  35   std::vector<Metadata *> Nodes;
  36
  37   for (auto E : Counts) {
  38     Metadata *Vals[] = {ValueAsMetadata::get(E.first.first),
  39                         ValueAsMetadata::get(E.first.second),
  40                         MDB.createConstant(ConstantInt::get(
  41                             Type::getInt64Ty(Context), E.second))};
  42     Nodes.push_back(MDNode::get(Context, Vals));
  43   }
  44
  45   M.addModuleFlag(Module::Append, "CG Profile", MDNode::get(Context, Nodes));
  46   return true;
  47 }
  48
  49 static bool runCGProfilePass(
  50     Module &M, function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
  51     function_ref<TargetTransformInfo &(Function &)> GetTTI, bool LazyBFI) {
  52   MapVector<std::pair<Function *, Function *>, uint64_t> Counts;
  53   InstrProfSymtab Symtab;
  54   auto UpdateCounts = [&](TargetTransformInfo &TTI, Function *F,
  55                           Function *CalledF, uint64_t NewCount) {
  56     if (!CalledF || !TTI.isLoweredToCall(CalledF) ||
  57         CalledF->hasDLLImportStorageClass())
  58       return;
  59     uint64_t &Count = Counts[std::make_pair(F, CalledF)];
  60     Count = SaturatingAdd(Count, NewCount);
  61   };
  62   // Ignore error here.  Indirect calls are ignored if this fails.
  63   (void)(bool) Symtab.create(M);
  64   for (auto &F : M) {
  65     // Avoid extra cost of running passes for BFI when the function doesn't have
  66     // entry count. Since LazyBlockFrequencyInfoPass only exists in LPM, check
  67     // if using LazyBlockFrequencyInfoPass.
  68     // TODO: Remove LazyBFI when LazyBlockFrequencyInfoPass is available in NPM.
  69     if (F.isDeclaration() || (LazyBFI && !F.getEntryCount()))
  70       continue;
  71     auto &BFI = GetBFI(F);
  72     if (BFI.getEntryFreq() == 0)
  73       continue;
  74     TargetTransformInfo &TTI = GetTTI(F);
  75     for (auto &BB : F) {
  76       Optional<uint64_t> BBCount = BFI.getBlockProfileCount(&BB);
  77       if (!BBCount)
  78         continue;
  79       for (auto &I : BB) {
  80         CallBase *CB = dyn_cast<CallBase>(&I);
  81         if (!CB)
  82           continue;
  83         if (CB->isIndirectCall()) {
  84           InstrProfValueData ValueData[8];
  85           uint32_t ActualNumValueData;
  86           uint64_t TotalC;
  87           if (!getValueProfDataFromInst(*CB, IPVK_IndirectCallTarget, 8,
  88                                         ValueData, ActualNumValueData, TotalC))
  89             continue;
  90           for (const auto &VD :
  91                ArrayRef<InstrProfValueData>(ValueData, ActualNumValueData)) {
  92             UpdateCounts(TTI, &F, Symtab.getFunction(VD.Value), VD.Count);
  93           }
  94           continue;
  95         }
  96         UpdateCounts(TTI, &F, CB->getCalledFunction(), *BBCount);
  97       }
  98     }
  99   }
 100
 101   return addModuleFlags(M, Counts);
 102 }
 103
 104 namespace {
 105 struct CGProfileLegacyPass final : public ModulePass {
 106   static char ID;
 107   CGProfileLegacyPass() : ModulePass(ID) {
 108     initializeCGProfileLegacyPassPass(*PassRegistry::getPassRegistry());
 109   }
 110
 111   void getAnalysisUsage(AnalysisUsage &AU) const override {
 112     AU.setPreservesCFG();
 113     AU.addRequired<LazyBlockFrequencyInfoPass>();
 114     AU.addRequired<TargetTransformInfoWrapperPass>();
 115   }
 116
 117   bool runOnModule(Module &M) override {
 118     auto GetBFI = [this](Function &F) -> BlockFrequencyInfo & {
 119       return this->getAnalysis<LazyBlockFrequencyInfoPass>(F).getBFI();
 120     };
 121     auto GetTTI = [this](Function &F) -> TargetTransformInfo & {
 122       return this->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
 123     };
 124
 125     return runCGProfilePass(M, GetBFI, GetTTI, true);
 126   }
 127 };
 128
 129 } // namespace
 130
 131 char CGProfileLegacyPass::ID = 0;
 132
 133 INITIALIZE_PASS(CGProfileLegacyPass, "cg-profile", "Call Graph Profile", false,
 134                 false)
 135
 136 ModulePass *llvm::createCGProfileLegacyPass() {
 137   return new CGProfileLegacyPass();
 138 }
 139
 140 PreservedAnalyses CGProfilePass::run(Module &M, ModuleAnalysisManager &MAM) {
 141   FunctionAnalysisManager &FAM =
 142       MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
 143   auto GetBFI = [&FAM](Function &F) -> BlockFrequencyInfo & {
 144     return FAM.getResult<BlockFrequencyAnalysis>(F);
 145   };
 146   auto GetTTI = [&FAM](Function &F) -> TargetTransformInfo & {
 147     return FAM.getResult<TargetIRAnalysis>(F);
 148   };
 149
 150   runCGProfilePass(M, GetBFI, GetTTI, false);
 151
 152   return PreservedAnalyses::all();
 153 }