PGOInstrumentation.cpp [plain text]
#include "CFGMST.h"
#include "IndirectCallSiteVisitor.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/Analysis/BranchProbabilityInfo.h"
#include "llvm/Analysis/CFG.h"
#include "llvm/IR/CallSite.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/MDBuilder.h"
#include "llvm/IR/Module.h"
#include "llvm/Pass.h"
#include "llvm/ProfileData/InstrProfReader.h"
#include "llvm/Support/BranchProbability.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/JamCRC.h"
#include "llvm/Transforms/Instrumentation.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include <string>
#include <utility>
#include <vector>
using namespace llvm;
#define DEBUG_TYPE "pgo-instrumentation"
STATISTIC(NumOfPGOInstrument, "Number of edges instrumented.");
STATISTIC(NumOfPGOEdge, "Number of edges.");
STATISTIC(NumOfPGOBB, "Number of basic-blocks.");
STATISTIC(NumOfPGOSplit, "Number of critical edge splits.");
STATISTIC(NumOfPGOFunc, "Number of functions having valid profile counts.");
STATISTIC(NumOfPGOMismatch, "Number of functions having mismatch profile.");
STATISTIC(NumOfPGOMissing, "Number of functions without profile.");
STATISTIC(NumOfPGOICall, "Number of indirect call value instrumentations.");
static cl::opt<std::string>
PGOTestProfileFile("pgo-test-profile-file", cl::init(""), cl::Hidden,
cl::value_desc("filename"),
cl::desc("Specify the path of profile data file. This is"
"mainly for test purpose."));
static cl::opt<bool> DisableValueProfiling("disable-vp", cl::init(false),
cl::Hidden,
cl::desc("Disable Value Profiling"));
static cl::opt<unsigned>
MaxNumAnnotations("icp-max-annotations", cl::init(3), cl::Hidden,
cl::ZeroOrMore,
cl::desc("Max number of annotations for a single indirect "
"call callsite"));
namespace {
class PGOInstrumentationGen : public ModulePass {
public:
static char ID;
PGOInstrumentationGen() : ModulePass(ID) {
initializePGOInstrumentationGenPass(*PassRegistry::getPassRegistry());
}
const char *getPassName() const override {
return "PGOInstrumentationGenPass";
}
private:
bool runOnModule(Module &M) override;
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<BlockFrequencyInfoWrapperPass>();
}
};
class PGOInstrumentationUse : public ModulePass {
public:
static char ID;
PGOInstrumentationUse(std::string Filename = "")
: ModulePass(ID), ProfileFileName(Filename) {
if (!PGOTestProfileFile.empty())
ProfileFileName = PGOTestProfileFile;
initializePGOInstrumentationUsePass(*PassRegistry::getPassRegistry());
}
const char *getPassName() const override {
return "PGOInstrumentationUsePass";
}
private:
std::string ProfileFileName;
std::unique_ptr<IndexedInstrProfReader> PGOReader;
bool runOnModule(Module &M) override;
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<BlockFrequencyInfoWrapperPass>();
}
};
}
char PGOInstrumentationGen::ID = 0;
INITIALIZE_PASS_BEGIN(PGOInstrumentationGen, "pgo-instr-gen",
"PGO instrumentation.", false, false)
INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfoWrapperPass)
INITIALIZE_PASS_END(PGOInstrumentationGen, "pgo-instr-gen",
"PGO instrumentation.", false, false)
ModulePass *llvm::createPGOInstrumentationGenPass() {
return new PGOInstrumentationGen();
}
char PGOInstrumentationUse::ID = 0;
INITIALIZE_PASS_BEGIN(PGOInstrumentationUse, "pgo-instr-use",
"Read PGO instrumentation profile.", false, false)
INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfoWrapperPass)
INITIALIZE_PASS_END(PGOInstrumentationUse, "pgo-instr-use",
"Read PGO instrumentation profile.", false, false)
ModulePass *llvm::createPGOInstrumentationUsePass(StringRef Filename) {
return new PGOInstrumentationUse(Filename.str());
}
namespace {
struct PGOEdge {
const BasicBlock *SrcBB;
const BasicBlock *DestBB;
uint64_t Weight;
bool InMST;
bool Removed;
bool IsCritical;
PGOEdge(const BasicBlock *Src, const BasicBlock *Dest, unsigned W = 1)
: SrcBB(Src), DestBB(Dest), Weight(W), InMST(false), Removed(false),
IsCritical(false) {}
const std::string infoString() const {
return (Twine(Removed ? "-" : " ") + (InMST ? " " : "*") +
(IsCritical ? "c" : " ") + " W=" + Twine(Weight)).str();
}
};
struct BBInfo {
BBInfo *Group;
uint32_t Index;
uint32_t Rank;
BBInfo(unsigned IX) : Group(this), Index(IX), Rank(0) {}
const std::string infoString() const {
return (Twine("Index=") + Twine(Index)).str();
}
};
template <class Edge, class BBInfo> class FuncPGOInstrumentation {
private:
Function &F;
void computeCFGHash();
public:
std::string FuncName;
GlobalVariable *FuncNameVar;
uint64_t FunctionHash;
CFGMST<Edge, BBInfo> MST;
BasicBlock *getInstrBB(Edge *E);
BBInfo &getBBInfo(const BasicBlock *BB) const { return MST.getBBInfo(BB); }
void dumpInfo(std::string Str = "") const {
MST.dumpEdges(dbgs(), Twine("Dump Function ") + FuncName + " Hash: " +
Twine(FunctionHash) + "\t" + Str);
}
FuncPGOInstrumentation(Function &Func, bool CreateGlobalVar = false,
BranchProbabilityInfo *BPI = nullptr,
BlockFrequencyInfo *BFI = nullptr)
: F(Func), FunctionHash(0), MST(F, BPI, BFI) {
FuncName = getPGOFuncName(F);
computeCFGHash();
DEBUG(dumpInfo("after CFGMST"));
NumOfPGOBB += MST.BBInfos.size();
for (auto &E : MST.AllEdges) {
if (E->Removed)
continue;
NumOfPGOEdge++;
if (!E->InMST)
NumOfPGOInstrument++;
}
if (CreateGlobalVar)
FuncNameVar = createPGOFuncNameVar(F, FuncName);
};
};
template <class Edge, class BBInfo>
void FuncPGOInstrumentation<Edge, BBInfo>::computeCFGHash() {
std::vector<char> Indexes;
JamCRC JC;
for (auto &BB : F) {
const TerminatorInst *TI = BB.getTerminator();
for (unsigned I = 0, E = TI->getNumSuccessors(); I != E; ++I) {
BasicBlock *Succ = TI->getSuccessor(I);
uint32_t Index = getBBInfo(Succ).Index;
for (int J = 0; J < 4; J++)
Indexes.push_back((char)(Index >> (J * 8)));
}
}
JC.update(Indexes);
FunctionHash = (uint64_t)MST.AllEdges.size() << 32 | JC.getCRC();
}
template <class Edge, class BBInfo>
BasicBlock *FuncPGOInstrumentation<Edge, BBInfo>::getInstrBB(Edge *E) {
if (E->InMST || E->Removed)
return nullptr;
BasicBlock *SrcBB = const_cast<BasicBlock *>(E->SrcBB);
BasicBlock *DestBB = const_cast<BasicBlock *>(E->DestBB);
if (SrcBB == nullptr)
return DestBB;
if (DestBB == nullptr)
return SrcBB;
TerminatorInst *TI = SrcBB->getTerminator();
if (TI->getNumSuccessors() <= 1)
return SrcBB;
if (!E->IsCritical)
return DestBB;
NumOfPGOSplit++;
DEBUG(dbgs() << "Split critical edge: " << getBBInfo(SrcBB).Index << " --> "
<< getBBInfo(DestBB).Index << "\n");
unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
BasicBlock *InstrBB = SplitCriticalEdge(TI, SuccNum);
assert(InstrBB && "Critical edge is not split");
E->Removed = true;
return InstrBB;
}
static void instrumentOneFunc(Function &F, Module *M,
BranchProbabilityInfo *BPI,
BlockFrequencyInfo *BFI) {
unsigned NumCounters = 0;
FuncPGOInstrumentation<PGOEdge, BBInfo> FuncInfo(F, true, BPI, BFI);
for (auto &E : FuncInfo.MST.AllEdges) {
if (!E->InMST && !E->Removed)
NumCounters++;
}
uint32_t I = 0;
Type *I8PtrTy = Type::getInt8PtrTy(M->getContext());
for (auto &E : FuncInfo.MST.AllEdges) {
BasicBlock *InstrBB = FuncInfo.getInstrBB(E.get());
if (!InstrBB)
continue;
IRBuilder<> Builder(InstrBB, InstrBB->getFirstInsertionPt());
assert(Builder.GetInsertPoint() != InstrBB->end() &&
"Cannot get the Instrumentation point");
Builder.CreateCall(
Intrinsic::getDeclaration(M, Intrinsic::instrprof_increment),
{llvm::ConstantExpr::getBitCast(FuncInfo.FuncNameVar, I8PtrTy),
Builder.getInt64(FuncInfo.FunctionHash), Builder.getInt32(NumCounters),
Builder.getInt32(I++)});
}
if (DisableValueProfiling)
return;
unsigned NumIndirectCallSites = 0;
for (auto &I : findIndirectCallSites(F)) {
CallSite CS(I);
Value *Callee = CS.getCalledValue();
DEBUG(dbgs() << "Instrument one indirect call: CallSite Index = "
<< NumIndirectCallSites << "\n");
IRBuilder<> Builder(I);
assert(Builder.GetInsertPoint() != I->getParent()->end() &&
"Cannot get the Instrumentation point");
Builder.CreateCall(
Intrinsic::getDeclaration(M, Intrinsic::instrprof_value_profile),
{llvm::ConstantExpr::getBitCast(FuncInfo.FuncNameVar, I8PtrTy),
Builder.getInt64(FuncInfo.FunctionHash),
Builder.CreatePtrToInt(Callee, Builder.getInt64Ty()),
Builder.getInt32(llvm::InstrProfValueKind::IPVK_IndirectCallTarget),
Builder.getInt32(NumIndirectCallSites++)});
}
NumOfPGOICall += NumIndirectCallSites;
}
struct PGOUseEdge : public PGOEdge {
bool CountValid;
uint64_t CountValue;
PGOUseEdge(const BasicBlock *Src, const BasicBlock *Dest, unsigned W = 1)
: PGOEdge(Src, Dest, W), CountValid(false), CountValue(0) {}
void setEdgeCount(uint64_t Value) {
CountValue = Value;
CountValid = true;
}
const std::string infoString() const {
if (!CountValid)
return PGOEdge::infoString();
return (Twine(PGOEdge::infoString()) + " Count=" + Twine(CountValue))
.str();
}
};
typedef SmallVector<PGOUseEdge *, 2> DirectEdges;
struct UseBBInfo : public BBInfo {
uint64_t CountValue;
bool CountValid;
int32_t UnknownCountInEdge;
int32_t UnknownCountOutEdge;
DirectEdges InEdges;
DirectEdges OutEdges;
UseBBInfo(unsigned IX)
: BBInfo(IX), CountValue(0), CountValid(false), UnknownCountInEdge(0),
UnknownCountOutEdge(0) {}
UseBBInfo(unsigned IX, uint64_t C)
: BBInfo(IX), CountValue(C), CountValid(true), UnknownCountInEdge(0),
UnknownCountOutEdge(0) {}
void setBBInfoCount(uint64_t Value) {
CountValue = Value;
CountValid = true;
}
const std::string infoString() const {
if (!CountValid)
return BBInfo::infoString();
return (Twine(BBInfo::infoString()) + " Count=" + Twine(CountValue)).str();
}
};
static uint64_t sumEdgeCount(const ArrayRef<PGOUseEdge *> Edges) {
uint64_t Total = 0;
for (auto &E : Edges) {
if (E->Removed)
continue;
Total += E->CountValue;
}
return Total;
}
class PGOUseFunc {
public:
PGOUseFunc(Function &Func, Module *Modu, BranchProbabilityInfo *BPI = nullptr,
BlockFrequencyInfo *BFI = nullptr)
: F(Func), M(Modu), FuncInfo(Func, false, BPI, BFI),
FreqAttr(FFA_Normal) {}
bool readCounters(IndexedInstrProfReader *PGOReader);
void populateCounters();
void setBranchWeights();
void annotateIndirectCallSites();
enum FuncFreqAttr { FFA_Normal, FFA_Cold, FFA_Hot };
FuncFreqAttr getFuncFreqAttr() const {
return FreqAttr;
}
private:
Function &F;
Module *M;
FuncPGOInstrumentation<PGOUseEdge, UseBBInfo> FuncInfo;
UseBBInfo &getBBInfo(const BasicBlock *BB) const {
return FuncInfo.getBBInfo(BB);
}
uint64_t ProgramMaxCount;
InstrProfRecord ProfileRecord;
FuncFreqAttr FreqAttr;
void setInstrumentedCounts(const std::vector<uint64_t> &CountFromProfile);
void setEdgeCount(DirectEdges &Edges, uint64_t Value);
const std::string getFuncName() const { return FuncInfo.FuncName; }
void markFunctionAttributes(uint64_t EntryCount, uint64_t MaxCount) {
if (ProgramMaxCount == 0)
return;
const BranchProbability HotFunctionThreshold(1, 100);
const BranchProbability ColdFunctionThreshold(2, 10000);
if (EntryCount >= HotFunctionThreshold.scale(ProgramMaxCount))
FreqAttr = FFA_Hot;
else if (MaxCount <= ColdFunctionThreshold.scale(ProgramMaxCount))
FreqAttr = FFA_Cold;
}
};
void PGOUseFunc::setInstrumentedCounts(
const std::vector<uint64_t> &CountFromProfile) {
std::vector<PGOUseEdge *> WorkList;
for (auto &E : FuncInfo.MST.AllEdges)
WorkList.push_back(E.get());
uint32_t I = 0;
for (auto &E : WorkList) {
BasicBlock *InstrBB = FuncInfo.getInstrBB(E);
if (!InstrBB)
continue;
uint64_t CountValue = CountFromProfile[I++];
if (!E->Removed) {
getBBInfo(InstrBB).setBBInfoCount(CountValue);
E->setEdgeCount(CountValue);
continue;
}
BasicBlock *SrcBB = const_cast<BasicBlock *>(E->SrcBB);
BasicBlock *DestBB = const_cast<BasicBlock *>(E->DestBB);
PGOUseEdge &NewEdge = FuncInfo.MST.addEdge(SrcBB, InstrBB, 0);
NewEdge.setEdgeCount(CountValue);
PGOUseEdge &NewEdge1 = FuncInfo.MST.addEdge(InstrBB, DestBB, 0);
NewEdge1.setEdgeCount(CountValue);
NewEdge1.InMST = true;
getBBInfo(InstrBB).setBBInfoCount(CountValue);
}
}
void PGOUseFunc::setEdgeCount(DirectEdges &Edges, uint64_t Value) {
for (auto &E : Edges) {
if (E->CountValid)
continue;
E->setEdgeCount(Value);
getBBInfo(E->SrcBB).UnknownCountOutEdge--;
getBBInfo(E->DestBB).UnknownCountInEdge--;
return;
}
llvm_unreachable("Cannot find the unknown count edge");
}
bool PGOUseFunc::readCounters(IndexedInstrProfReader *PGOReader) {
auto &Ctx = M->getContext();
ErrorOr<InstrProfRecord> Result =
PGOReader->getInstrProfRecord(FuncInfo.FuncName, FuncInfo.FunctionHash);
if (std::error_code EC = Result.getError()) {
if (EC == instrprof_error::unknown_function)
NumOfPGOMissing++;
else if (EC == instrprof_error::hash_mismatch ||
EC == llvm::instrprof_error::malformed)
NumOfPGOMismatch++;
std::string Msg = EC.message() + std::string(" ") + F.getName().str();
Ctx.diagnose(
DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
return false;
}
ProfileRecord = std::move(Result.get());
std::vector<uint64_t> &CountFromProfile = ProfileRecord.Counts;
NumOfPGOFunc++;
DEBUG(dbgs() << CountFromProfile.size() << " counts\n");
uint64_t ValueSum = 0;
for (unsigned I = 0, S = CountFromProfile.size(); I < S; I++) {
DEBUG(dbgs() << " " << I << ": " << CountFromProfile[I] << "\n");
ValueSum += CountFromProfile[I];
}
DEBUG(dbgs() << "SUM = " << ValueSum << "\n");
getBBInfo(nullptr).UnknownCountOutEdge = 2;
getBBInfo(nullptr).UnknownCountInEdge = 2;
setInstrumentedCounts(CountFromProfile);
ProgramMaxCount = PGOReader->getMaximumFunctionCount();
return true;
}
void PGOUseFunc::populateCounters() {
for (auto &E : FuncInfo.MST.AllEdges) {
if (E->Removed)
continue;
const BasicBlock *SrcBB = E->SrcBB;
const BasicBlock *DestBB = E->DestBB;
UseBBInfo &SrcInfo = getBBInfo(SrcBB);
UseBBInfo &DestInfo = getBBInfo(DestBB);
SrcInfo.OutEdges.push_back(E.get());
DestInfo.InEdges.push_back(E.get());
SrcInfo.UnknownCountOutEdge++;
DestInfo.UnknownCountInEdge++;
if (!E->CountValid)
continue;
DestInfo.UnknownCountInEdge--;
SrcInfo.UnknownCountOutEdge--;
}
bool Changes = true;
unsigned NumPasses = 0;
while (Changes) {
NumPasses++;
Changes = false;
for (auto &BB : reverse(F)) {
UseBBInfo &Count = getBBInfo(&BB);
if (!Count.CountValid) {
if (Count.UnknownCountOutEdge == 0) {
Count.CountValue = sumEdgeCount(Count.OutEdges);
Count.CountValid = true;
Changes = true;
} else if (Count.UnknownCountInEdge == 0) {
Count.CountValue = sumEdgeCount(Count.InEdges);
Count.CountValid = true;
Changes = true;
}
}
if (Count.CountValid) {
if (Count.UnknownCountOutEdge == 1) {
uint64_t Total = Count.CountValue - sumEdgeCount(Count.OutEdges);
setEdgeCount(Count.OutEdges, Total);
Changes = true;
}
if (Count.UnknownCountInEdge == 1) {
uint64_t Total = Count.CountValue - sumEdgeCount(Count.InEdges);
setEdgeCount(Count.InEdges, Total);
Changes = true;
}
}
}
}
DEBUG(dbgs() << "Populate counts in " << NumPasses << " passes.\n");
uint64_t FuncEntryCount = getBBInfo(&*F.begin()).CountValue;
uint64_t FuncMaxCount = FuncEntryCount;
for (auto &BB : F) {
assert(getBBInfo(&BB).CountValid && "BB count is not valid");
uint64_t Count = getBBInfo(&BB).CountValue;
if (Count > FuncMaxCount)
FuncMaxCount = Count;
}
markFunctionAttributes(FuncEntryCount, FuncMaxCount);
DEBUG(FuncInfo.dumpInfo("after reading profile."));
}
void PGOUseFunc::setBranchWeights() {
DEBUG(dbgs() << "\nSetting branch weights.\n");
MDBuilder MDB(M->getContext());
for (auto &BB : F) {
TerminatorInst *TI = BB.getTerminator();
if (TI->getNumSuccessors() < 2)
continue;
if (!isa<BranchInst>(TI) && !isa<SwitchInst>(TI))
continue;
if (getBBInfo(&BB).CountValue == 0)
continue;
const UseBBInfo &BBCountInfo = getBBInfo(&BB);
unsigned Size = BBCountInfo.OutEdges.size();
SmallVector<unsigned, 2> EdgeCounts(Size, 0);
uint64_t MaxCount = 0;
for (unsigned s = 0; s < Size; s++) {
const PGOUseEdge *E = BBCountInfo.OutEdges[s];
const BasicBlock *SrcBB = E->SrcBB;
const BasicBlock *DestBB = E->DestBB;
if (DestBB == 0)
continue;
unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
uint64_t EdgeCount = E->CountValue;
if (EdgeCount > MaxCount)
MaxCount = EdgeCount;
EdgeCounts[SuccNum] = EdgeCount;
}
assert(MaxCount > 0 && "Bad max count");
uint64_t Scale = calculateCountScale(MaxCount);
SmallVector<unsigned, 4> Weights;
for (const auto &ECI : EdgeCounts)
Weights.push_back(scaleBranchCount(ECI, Scale));
TI->setMetadata(llvm::LLVMContext::MD_prof,
MDB.createBranchWeights(Weights));
DEBUG(dbgs() << "Weight is: ";
for (const auto &W : Weights) { dbgs() << W << " "; }
dbgs() << "\n";);
}
}
void PGOUseFunc::annotateIndirectCallSites() {
if (DisableValueProfiling)
return;
createPGOFuncNameMetadata(F, FuncInfo.FuncName);
unsigned IndirectCallSiteIndex = 0;
auto IndirectCallSites = findIndirectCallSites(F);
unsigned NumValueSites =
ProfileRecord.getNumValueSites(IPVK_IndirectCallTarget);
if (NumValueSites != IndirectCallSites.size()) {
std::string Msg =
std::string("Inconsistent number of indirect call sites: ") +
F.getName().str();
auto &Ctx = M->getContext();
Ctx.diagnose(
DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
return;
}
for (auto &I : IndirectCallSites) {
DEBUG(dbgs() << "Read one indirect call instrumentation: Index="
<< IndirectCallSiteIndex << " out of " << NumValueSites
<< "\n");
annotateValueSite(*M, *I, ProfileRecord, IPVK_IndirectCallTarget,
IndirectCallSiteIndex, MaxNumAnnotations);
IndirectCallSiteIndex++;
}
}
}
static void createIRLevelProfileFlagVariable(Module &M) {
Type *IntTy64 = Type::getInt64Ty(M.getContext());
uint64_t ProfileVersion = (INSTR_PROF_RAW_VERSION | VARIANT_MASK_IR_PROF);
auto IRLevelVersionVariable = new GlobalVariable(
M, IntTy64, true, GlobalVariable::ExternalLinkage,
Constant::getIntegerValue(IntTy64, APInt(64, ProfileVersion)),
INSTR_PROF_QUOTE(IR_LEVEL_PROF_VERSION_VAR));
IRLevelVersionVariable->setVisibility(GlobalValue::DefaultVisibility);
Triple TT(M.getTargetTriple());
if (TT.isOSBinFormatMachO())
IRLevelVersionVariable->setLinkage(GlobalValue::LinkOnceODRLinkage);
else
IRLevelVersionVariable->setComdat(M.getOrInsertComdat(
StringRef(INSTR_PROF_QUOTE(IR_LEVEL_PROF_VERSION_VAR))));
}
bool PGOInstrumentationGen::runOnModule(Module &M) {
createIRLevelProfileFlagVariable(M);
for (auto &F : M) {
if (F.isDeclaration())
continue;
BranchProbabilityInfo *BPI =
&(getAnalysis<BranchProbabilityInfoWrapperPass>(F).getBPI());
BlockFrequencyInfo *BFI =
&(getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI());
instrumentOneFunc(F, &M, BPI, BFI);
}
return true;
}
static void setPGOCountOnFunc(PGOUseFunc &Func,
IndexedInstrProfReader *PGOReader) {
if (Func.readCounters(PGOReader)) {
Func.populateCounters();
Func.setBranchWeights();
Func.annotateIndirectCallSites();
}
}
bool PGOInstrumentationUse::runOnModule(Module &M) {
DEBUG(dbgs() << "Read in profile counters: ");
auto &Ctx = M.getContext();
auto ReaderOrErr = IndexedInstrProfReader::create(ProfileFileName);
if (std::error_code EC = ReaderOrErr.getError()) {
Ctx.diagnose(
DiagnosticInfoPGOProfile(ProfileFileName.data(), EC.message()));
return false;
}
PGOReader = std::move(ReaderOrErr.get());
if (!PGOReader) {
Ctx.diagnose(DiagnosticInfoPGOProfile(ProfileFileName.data(),
"Cannot get PGOReader"));
return false;
}
if (!PGOReader->isIRLevelProfile()) {
Ctx.diagnose(DiagnosticInfoPGOProfile(
ProfileFileName.data(), "Not an IR level instrumentation profile"));
return false;
}
std::vector<Function *> HotFunctions;
std::vector<Function *> ColdFunctions;
for (auto &F : M) {
if (F.isDeclaration())
continue;
BranchProbabilityInfo *BPI =
&(getAnalysis<BranchProbabilityInfoWrapperPass>(F).getBPI());
BlockFrequencyInfo *BFI =
&(getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI());
PGOUseFunc Func(F, &M, BPI, BFI);
setPGOCountOnFunc(Func, PGOReader.get());
PGOUseFunc::FuncFreqAttr FreqAttr = Func.getFuncFreqAttr();
if (FreqAttr == PGOUseFunc::FFA_Cold)
ColdFunctions.push_back(&F);
else if (FreqAttr == PGOUseFunc::FFA_Hot)
HotFunctions.push_back(&F);
}
for (auto &F : HotFunctions) {
F->addFnAttr(llvm::Attribute::InlineHint);
DEBUG(dbgs() << "Set inline attribute to function: " << F->getName()
<< "\n");
}
for (auto &F : ColdFunctions) {
F->addFnAttr(llvm::Attribute::Cold);
DEBUG(dbgs() << "Set cold attribute to function: " << F->getName() << "\n");
}
return true;
}