mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-12 14:26:07 +00:00
502bbfafca
2nd attempt: the first was in r296231, but it had a use after lifetime
bug.
Clang has logic to lower certain conditional expressions directly into llvm
select instructions. However, it does not emit the correct profile counter
increment as it does this: it emits an unconditional increment of the counter
for the 'then branch', even if the value selected is from the 'else branch'
(this is PR32019).
That means, given the following snippet, we would report that "0" is selected
twice, and that "1" is never selected:
int f1(int x) {
return x ? 0 : 1;
^2 ^0
}
f1(0);
f1(1);
Fix the problem by using the instrprof_increment_step intrinsic to do the
proper increment.
llvm-svn: 296245
125 lines
4.5 KiB
C++
125 lines
4.5 KiB
C++
//===--- CodeGenPGO.h - PGO Instrumentation for LLVM CodeGen ----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Instrumentation-based profile-guided optimization
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENPGO_H
|
|
#define LLVM_CLANG_LIB_CODEGEN_CODEGENPGO_H
|
|
|
|
#include "CGBuilder.h"
|
|
#include "CodeGenModule.h"
|
|
#include "CodeGenTypes.h"
|
|
#include "clang/Frontend/CodeGenOptions.h"
|
|
#include "llvm/ProfileData/InstrProfReader.h"
|
|
#include <array>
|
|
#include <memory>
|
|
|
|
namespace clang {
|
|
namespace CodeGen {
|
|
|
|
/// Per-function PGO state.
|
|
class CodeGenPGO {
|
|
private:
|
|
CodeGenModule &CGM;
|
|
std::string FuncName;
|
|
llvm::GlobalVariable *FuncNameVar;
|
|
|
|
std::array <unsigned, llvm::IPVK_Last + 1> NumValueSites;
|
|
unsigned NumRegionCounters;
|
|
uint64_t FunctionHash;
|
|
std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionCounterMap;
|
|
std::unique_ptr<llvm::DenseMap<const Stmt *, uint64_t>> StmtCountMap;
|
|
std::unique_ptr<llvm::InstrProfRecord> ProfRecord;
|
|
std::vector<uint64_t> RegionCounts;
|
|
uint64_t CurrentRegionCount;
|
|
/// \brief A flag that is set to true when this function doesn't need
|
|
/// to have coverage mapping data.
|
|
bool SkipCoverageMapping;
|
|
|
|
public:
|
|
CodeGenPGO(CodeGenModule &CGM)
|
|
: CGM(CGM), NumValueSites({{0}}), NumRegionCounters(0),
|
|
FunctionHash(0), CurrentRegionCount(0), SkipCoverageMapping(false) {}
|
|
|
|
/// Whether or not we have PGO region data for the current function. This is
|
|
/// false both when we have no data at all and when our data has been
|
|
/// discarded.
|
|
bool haveRegionCounts() const { return !RegionCounts.empty(); }
|
|
|
|
/// Return the counter value of the current region.
|
|
uint64_t getCurrentRegionCount() const { return CurrentRegionCount; }
|
|
|
|
/// Set the counter value for the current region. This is used to keep track
|
|
/// of changes to the most recent counter from control flow and non-local
|
|
/// exits.
|
|
void setCurrentRegionCount(uint64_t Count) { CurrentRegionCount = Count; }
|
|
|
|
/// Check if an execution count is known for a given statement. If so, return
|
|
/// true and put the value in Count; else return false.
|
|
Optional<uint64_t> getStmtCount(const Stmt *S) {
|
|
if (!StmtCountMap)
|
|
return None;
|
|
auto I = StmtCountMap->find(S);
|
|
if (I == StmtCountMap->end())
|
|
return None;
|
|
return I->second;
|
|
}
|
|
|
|
/// If the execution count for the current statement is known, record that
|
|
/// as the current count.
|
|
void setCurrentStmt(const Stmt *S) {
|
|
if (auto Count = getStmtCount(S))
|
|
setCurrentRegionCount(*Count);
|
|
}
|
|
|
|
/// Assign counters to regions and configure them for PGO of a given
|
|
/// function. Does nothing if instrumentation is not enabled and either
|
|
/// generates global variables or associates PGO data with each of the
|
|
/// counters depending on whether we are generating or using instrumentation.
|
|
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn);
|
|
/// Emit a coverage mapping range with a counter zero
|
|
/// for an unused declaration.
|
|
void emitEmptyCounterMapping(const Decl *D, StringRef FuncName,
|
|
llvm::GlobalValue::LinkageTypes Linkage);
|
|
// Insert instrumentation or attach profile metadata at value sites
|
|
void valueProfile(CGBuilderTy &Builder, uint32_t ValueKind,
|
|
llvm::Instruction *ValueSite, llvm::Value *ValuePtr);
|
|
private:
|
|
void setFuncName(llvm::Function *Fn);
|
|
void setFuncName(StringRef Name, llvm::GlobalValue::LinkageTypes Linkage);
|
|
void mapRegionCounters(const Decl *D);
|
|
void computeRegionCounts(const Decl *D);
|
|
void applyFunctionAttributes(llvm::IndexedInstrProfReader *PGOReader,
|
|
llvm::Function *Fn);
|
|
void loadRegionCounts(llvm::IndexedInstrProfReader *PGOReader,
|
|
bool IsInMainFile);
|
|
bool skipRegionMappingForDecl(const Decl *D);
|
|
void emitCounterRegionMapping(const Decl *D);
|
|
|
|
public:
|
|
void emitCounterIncrement(CGBuilderTy &Builder, const Stmt *S,
|
|
llvm::Value *StepV);
|
|
|
|
/// Return the region count for the counter at the given index.
|
|
uint64_t getRegionCount(const Stmt *S) {
|
|
if (!RegionCounterMap)
|
|
return 0;
|
|
if (!haveRegionCounts())
|
|
return 0;
|
|
return RegionCounts[(*RegionCounterMap)[S]];
|
|
}
|
|
};
|
|
|
|
} // end namespace CodeGen
|
|
} // end namespace clang
|
|
|
|
#endif
|