1 //===--- CodeGenPGO.h - PGO Instrumentation for LLVM CodeGen ----*- C++ -*-===// 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 // Instrumentation-based profile-guided optimization 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENPGO_H 14 #define LLVM_CLANG_LIB_CODEGEN_CODEGENPGO_H 15 16 #include "CGBuilder.h" 17 #include "CodeGenModule.h" 18 #include "CodeGenTypes.h" 19 #include "llvm/ProfileData/InstrProfReader.h" 20 #include <array> 21 #include <memory> 22 23 namespace clang { 24 namespace CodeGen { 25 26 /// Per-function PGO state. 27 class CodeGenPGO { 28 private: 29 CodeGenModule &CGM; 30 std::string FuncName; 31 llvm::GlobalVariable *FuncNameVar; 32 33 std::array <unsigned, llvm::IPVK_Last + 1> NumValueSites; 34 unsigned NumRegionCounters; 35 uint64_t FunctionHash; 36 std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionCounterMap; 37 std::unique_ptr<llvm::DenseMap<const Stmt *, uint64_t>> StmtCountMap; 38 std::unique_ptr<llvm::InstrProfRecord> ProfRecord; 39 std::vector<uint64_t> RegionCounts; 40 uint64_t CurrentRegionCount; 41 42 public: 43 CodeGenPGO(CodeGenModule &CGModule) 44 : CGM(CGModule), FuncNameVar(nullptr), NumValueSites({{0}}), 45 NumRegionCounters(0), FunctionHash(0), CurrentRegionCount(0) {} 46 47 /// Whether or not we have PGO region data for the current function. This is 48 /// false both when we have no data at all and when our data has been 49 /// discarded. 50 bool haveRegionCounts() const { return !RegionCounts.empty(); } 51 52 /// Return the counter value of the current region. 53 uint64_t getCurrentRegionCount() const { return CurrentRegionCount; } 54 55 /// Set the counter value for the current region. This is used to keep track 56 /// of changes to the most recent counter from control flow and non-local 57 /// exits. 58 void setCurrentRegionCount(uint64_t Count) { CurrentRegionCount = Count; } 59 60 /// Check if an execution count is known for a given statement. If so, return 61 /// true and put the value in Count; else return false. 62 Optional<uint64_t> getStmtCount(const Stmt *S) { 63 if (!StmtCountMap) 64 return None; 65 auto I = StmtCountMap->find(S); 66 if (I == StmtCountMap->end()) 67 return None; 68 return I->second; 69 } 70 71 /// If the execution count for the current statement is known, record that 72 /// as the current count. 73 void setCurrentStmt(const Stmt *S) { 74 if (auto Count = getStmtCount(S)) 75 setCurrentRegionCount(*Count); 76 } 77 78 /// Assign counters to regions and configure them for PGO of a given 79 /// function. Does nothing if instrumentation is not enabled and either 80 /// generates global variables or associates PGO data with each of the 81 /// counters depending on whether we are generating or using instrumentation. 82 void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn); 83 /// Emit a coverage mapping range with a counter zero 84 /// for an unused declaration. 85 void emitEmptyCounterMapping(const Decl *D, StringRef FuncName, 86 llvm::GlobalValue::LinkageTypes Linkage); 87 // Insert instrumentation or attach profile metadata at value sites 88 void valueProfile(CGBuilderTy &Builder, uint32_t ValueKind, 89 llvm::Instruction *ValueSite, llvm::Value *ValuePtr); 90 private: 91 void setFuncName(llvm::Function *Fn); 92 void setFuncName(StringRef Name, llvm::GlobalValue::LinkageTypes Linkage); 93 void mapRegionCounters(const Decl *D); 94 void computeRegionCounts(const Decl *D); 95 void applyFunctionAttributes(llvm::IndexedInstrProfReader *PGOReader, 96 llvm::Function *Fn); 97 void loadRegionCounts(llvm::IndexedInstrProfReader *PGOReader, 98 bool IsInMainFile); 99 bool skipRegionMappingForDecl(const Decl *D); 100 void emitCounterRegionMapping(const Decl *D); 101 102 public: 103 void emitCounterIncrement(CGBuilderTy &Builder, const Stmt *S, 104 llvm::Value *StepV); 105 106 /// Return the region count for the counter at the given index. 107 uint64_t getRegionCount(const Stmt *S) { 108 if (!RegionCounterMap) 109 return 0; 110 if (!haveRegionCounts()) 111 return 0; 112 return RegionCounts[(*RegionCounterMap)[S]]; 113 } 114 }; 115 116 } // end namespace CodeGen 117 } // end namespace clang 118 119 #endif 120