Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CodeGenPGO_8cpp_source.html below:

clang: lib/CodeGen/CodeGenPGO.cpp Source File

llvm::cl::opt<bool>

llvm::cl::desc(

),

llvm::cl::Hidden, llvm::cl::init(

));

;

CodeGen;

CodeGenPGO::setFuncName(StringRef Name,

llvm::GlobalValue::LinkageTypes

) {

llvm::IndexedInstrProfReader *PGOReader = CGM.

();

FuncName = llvm::getPGOFuncName(

PGOReader ? PGOReader->getVersion() : llvm::IndexedInstrProf::Version);

FuncNameVar = llvm::createPGOFuncNameVar(CGM.

(),

, FuncName);

CodeGenPGO::setFuncName(llvm::Function *Fn) {

setFuncName(

->getName(),

->getLinkage());

llvm::createPGOFuncNameMetadata(*Fn, FuncName);

NumBitsPerType = 6;

NumTypesPerWord =

(

) * 8 / NumBitsPerType;

TooBig = 1u << NumBitsPerType;

HashType :

{

(LastHashType <= TooBig,

);

: Working(0), Count(0), HashVersion(HashVersion) {}

combine(HashType

);

PGOHash::NumBitsPerType;

PGOHash::NumTypesPerWord;

PGOHash::TooBig;

getPGOHashVersion(llvm::IndexedInstrProfReader *PGOReader,

(PGOReader->getVersion() <= 4)

(PGOReader->getVersion() <= 5)

NextCounter;

llvm::DenseMap<const Stmt *, CounterPair> &CounterMap;

MCDCMaxCond;

MapRegionCounters(

HashVersion, uint64_t ProfileVersion,

llvm::DenseMap<const Stmt *, CounterPair> &CounterMap,

: NextCounter(0), Hash(HashVersion), CounterMap(CounterMap),

MCDCState(MCDCState), MCDCMaxCond(MCDCMaxCond),

ProfileVersion(ProfileVersion),

(

) {}

TraverseBlockExpr(

*BE) {

; }

(

: zip(

->captures(),

->capture_inits()))

TraverseLambdaCapture(LE, &std::get<0>(

), std::get<1>(

));

TraverseCapturedStmt(

*CS) {

; }

VisitDecl(

*

) {

Decl::CXXMethod:

Decl::CXXConstructor:

Decl::CXXDestructor:

Decl::CXXConversion:

Decl::ObjCMethod:

CounterMap[

->

()] = NextCounter++;

PGOHash::HashType updateCounterMappings(

*S) {

(

!= PGOHash::None)

CounterMap[S] = NextCounter++;

NumCond = 0;

SplitNestedLogicalOp =

;

dataTraverseStmtPre(

*S) {

(MCDCMaxCond == 0)

(LogOpStack.empty()) {

SplitNestedLogicalOp =

;

(

*

= dyn_cast<Expr>(S)) {

SplitNestedLogicalOp = SplitNestedLogicalOp || !NonLogOpStack.empty();

LogOpStack.push_back(BinOp);

(!LogOpStack.empty())

NonLogOpStack.push_back(S);

dataTraverseStmtPost(

*S) {

(MCDCMaxCond == 0)

(

*

= dyn_cast<Expr>(S)) {

assert(LogOpStack.back() == BinOp);

LogOpStack.pop_back();

(LogOpStack.empty()) {

(SplitNestedLogicalOp) {

DiagID =

.getCustomDiagID(

);

.Report(S->getBeginLoc(), DiagID);

(NumCond > MCDCMaxCond) {

DiagID =

.getCustomDiagID(

);

.Report(S->getBeginLoc(), DiagID) << NumCond << MCDCMaxCond;

(!LogOpStack.empty())

NonLogOpStack.pop_back();

(S->isLogicalOp()) {

(CodeGenFunction::isInstrumentedCondition(S->getLHS()))

(CodeGenFunction::isInstrumentedCondition(S->getRHS())) {

(ProfileVersion >= llvm::IndexedInstrProf::Version7)

CounterMap[S->getRHS()] = NextCounter++;

Base::VisitBinaryOperator(S);

CounterMap[S->getTrueExpr()] = NextCounter++;

CounterMap[S->getFalseExpr()] = NextCounter++;

Base::VisitConditionalOperator(S);

VisitStmt(

*S) {

= updateCounterMappings(S);

= getHashType(Hash.getHashVersion(), S);

(

!= PGOHash::None)

Hash.combine(

);

TraverseIfStmt(

*

) {

Base::TraverseIfStmt(

);

(

*CS :

->children()) {

(!CS || NoSingleByteCoverage)

(CS ==

->getThen())

CounterMap[

->getThen()] = NextCounter++;

(CS ==

->getElse())

CounterMap[

->getElse()] = NextCounter++;

(

*CS :

->children()) {

(CS ==

->getThen())

Hash.combine(PGOHash::IfThenBranch);

(CS ==

->getElse())

Hash.combine(PGOHash::IfElseBranch);

Hash.combine(PGOHash::EndOfScope);

TraverseWhileStmt(

*While) {

(!CS || NoSingleByteCoverage)

CounterMap[While->

()] = NextCounter++;

(CS == While->

())

CounterMap[While->

()] = NextCounter++;

Base::TraverseWhileStmt(While);

Hash.combine(PGOHash::EndOfScope);

TraverseDoStmt(

*Do) {

(!CS || NoSingleByteCoverage)

CounterMap[Do->

()] = NextCounter++;

(CS == Do->

())

CounterMap[Do->

()] = NextCounter++;

Base::TraverseDoStmt(Do);

Hash.combine(PGOHash::EndOfScope);

TraverseForStmt(

*For) {

(!CS || NoSingleByteCoverage)

CounterMap[For->

()] = NextCounter++;

(CS == For->

())

CounterMap[For->

()] = NextCounter++;

(CS == For->

())

CounterMap[For->

()] = NextCounter++;

Base::TraverseForStmt(For);

Hash.combine(PGOHash::EndOfScope);

(!CS || NoSingleByteCoverage)

(CS == ForRange->

())

CounterMap[ForRange->

()] = NextCounter++;

Base::TraverseCXXForRangeStmt(ForRange);

Hash.combine(PGOHash::EndOfScope);

(S->getStmtClass()) {

Stmt::LabelStmtClass:

PGOHash::LabelStmt;

Stmt::WhileStmtClass:

PGOHash::WhileStmt;

Stmt::DoStmtClass:

PGOHash::DoStmt;

Stmt::ForStmtClass:

PGOHash::ForStmt;

Stmt::CXXForRangeStmtClass:

PGOHash::CXXForRangeStmt;

Stmt::ObjCForCollectionStmtClass:

PGOHash::ObjCForCollectionStmt;

Stmt::SwitchStmtClass:

PGOHash::SwitchStmt;

Stmt::CaseStmtClass:

PGOHash::CaseStmt;

Stmt::DefaultStmtClass:

PGOHash::DefaultStmt;

Stmt::IfStmtClass:

PGOHash::IfStmt;

Stmt::CXXTryStmtClass:

PGOHash::CXXTryStmt;

Stmt::CXXCatchStmtClass:

PGOHash::CXXCatchStmt;

Stmt::ConditionalOperatorClass:

PGOHash::ConditionalOperator;

Stmt::BinaryConditionalOperatorClass:

PGOHash::BinaryConditionalOperator;

Stmt::BinaryOperatorClass: {

PGOHash::BinaryOperatorLAnd;

PGOHash::BinaryOperatorLOr;

PGOHash::BinaryOperatorLT;

PGOHash::BinaryOperatorGT;

PGOHash::BinaryOperatorLE;

PGOHash::BinaryOperatorGE;

PGOHash::BinaryOperatorEQ;

PGOHash::BinaryOperatorNE;

(S->getStmtClass()) {

Stmt::GotoStmtClass:

PGOHash::GotoStmt;

Stmt::IndirectGotoStmtClass:

PGOHash::IndirectGotoStmt;

Stmt::BreakStmtClass:

PGOHash::BreakStmt;

Stmt::ContinueStmtClass:

PGOHash::ContinueStmt;

Stmt::ReturnStmtClass:

PGOHash::ReturnStmt;

Stmt::CXXThrowExprClass:

PGOHash::ThrowExpr;

Stmt::UnaryOperatorClass: {

PGOHash::UnaryOperatorLNot;

PGOHash::None;

RecordNextStmtCount;

llvm::DenseMap<const Stmt *, uint64_t> &

;

BreakContinue {

BreakContinue() =

;

ComputeRegionCounts(llvm::DenseMap<const Stmt *, uint64_t> &

,

RecordStmtCount(

*S) {

(RecordNextStmtCount) {

RecordNextStmtCount =

;

CurrentCount = Count;

VisitStmt(

*S) {

(

*Child : S->children())

VisitLambdaExpr(

*LE) {}

(S->getRetValue())

Visit(S->getRetValue());

RecordNextStmtCount =

;

RecordStmtCount(

);

(

->getSubExpr())

Visit(

->getSubExpr());

RecordNextStmtCount =

;

VisitGotoStmt(

*S) {

RecordNextStmtCount =

;

VisitLabelStmt(

*S) {

RecordNextStmtCount =

;

Visit(S->getSubStmt());

VisitBreakStmt(

*S) {

assert(!BreakContinueStack.empty() &&

);

BreakContinueStack.back().BreakCount += CurrentCount;

RecordNextStmtCount =

;

assert(!BreakContinueStack.empty() &&

);

BreakContinueStack.back().ContinueCount += CurrentCount;

RecordNextStmtCount =

;

VisitWhileStmt(

*S) {

ParentCount = CurrentCount;

BreakContinueStack.push_back(BreakContinue());

[S->getBody()] = CurrentCount;

BackedgeCount = CurrentCount;

BreakContinue BC = BreakContinueStack.pop_back_val();

setCount(ParentCount + BackedgeCount + BC.ContinueCount);

[S->getCond()] = CondCount;

setCount(BC.BreakCount + CondCount - BodyCount);

RecordNextStmtCount =

;

VisitDoStmt(

*S) {

BreakContinueStack.push_back(BreakContinue());

BodyCount = setCount(LoopCount + CurrentCount);

[S->getBody()] = BodyCount;

BackedgeCount = CurrentCount;

BreakContinue BC = BreakContinueStack.pop_back_val();

CondCount = setCount(BackedgeCount + BC.ContinueCount);

[S->getCond()] = CondCount;

setCount(BC.BreakCount + CondCount - LoopCount);

RecordNextStmtCount =

;

VisitForStmt(

*S) {

ParentCount = CurrentCount;

BreakContinueStack.push_back(BreakContinue());

[S->getBody()] = BodyCount;

BackedgeCount = CurrentCount;

BreakContinue BC = BreakContinueStack.pop_back_val();

IncCount = setCount(BackedgeCount + BC.ContinueCount);

setCount(ParentCount + BackedgeCount + BC.ContinueCount);

[S->getCond()] = CondCount;

setCount(BC.BreakCount + CondCount - BodyCount);

RecordNextStmtCount =

;

Visit(S->getLoopVarStmt());

Visit(S->getRangeStmt());

Visit(S->getBeginStmt());

Visit(S->getEndStmt());

ParentCount = CurrentCount;

BreakContinueStack.push_back(BreakContinue());

[S->getBody()] = BodyCount;

BackedgeCount = CurrentCount;

BreakContinue BC = BreakContinueStack.pop_back_val();

IncCount = setCount(BackedgeCount + BC.ContinueCount);

setCount(ParentCount + BackedgeCount + BC.ContinueCount);

[S->getCond()] = CondCount;

setCount(BC.BreakCount + CondCount - BodyCount);

RecordNextStmtCount =

;

Visit(S->getElement());

ParentCount = CurrentCount;

BreakContinueStack.push_back(BreakContinue());

[S->getBody()] = BodyCount;

BackedgeCount = CurrentCount;

BreakContinue BC = BreakContinueStack.pop_back_val();

setCount(BC.BreakCount + ParentCount + BackedgeCount + BC.ContinueCount -

RecordNextStmtCount =

;

BreakContinueStack.push_back(BreakContinue());

BreakContinue BC = BreakContinueStack.pop_back_val();

(!BreakContinueStack.empty())

BreakContinueStack.back().ContinueCount += BC.ContinueCount;

RecordNextStmtCount =

;

RecordNextStmtCount =

;

setCount(CurrentCount + CaseCount);

RecordNextStmtCount =

;

Visit(S->getSubStmt());

VisitIfStmt(

*S) {

(S->isConsteval()) {

*Stm = S->isNegatedConsteval() ? S->getThen() : S->getElse();

ParentCount = CurrentCount;

[S->getThen()] = ThenCount;

ElseCount = ParentCount - ThenCount;

[S->getElse()] = ElseCount;

OutCount += CurrentCount;

OutCount += ElseCount;

RecordNextStmtCount =

;

Visit(S->getTryBlock());

(

I = 0,

= S->getNumHandlers(); I <

; ++I)

Visit(S->getHandler(I));

RecordNextStmtCount =

;

RecordNextStmtCount =

;

Visit(S->getHandlerBlock());

RecordStmtCount(

);

ParentCount = CurrentCount;

Visit(

->getCond());

[

->getTrueExpr()] = TrueCount;

Visit(

->getTrueExpr());

FalseCount = setCount(ParentCount - TrueCount);

[

->getFalseExpr()] = FalseCount;

Visit(

->getFalseExpr());

OutCount += CurrentCount;

RecordNextStmtCount =

;

RecordStmtCount(

);

ParentCount = CurrentCount;

Visit(

->getLHS());

Visit(

->getRHS());

setCount(ParentCount + RHSCount - CurrentCount);

RecordNextStmtCount =

;

RecordStmtCount(

);

ParentCount = CurrentCount;

Visit(

->getLHS());

Visit(

->getRHS());

setCount(ParentCount + RHSCount - CurrentCount);

RecordNextStmtCount =

;

PGOHash::combine(HashType

) {

assert(

&&

);

assert(

(

) < TooBig &&

);

(Count && Count % NumTypesPerWord == 0) {

llvm::support;

endian::byte_swap<uint64_t, llvm::endianness::little>(Working);

MD5.update(

((uint8_t *)&Swapped,

(Swapped)));

Working = Working << NumBitsPerType |

;

(Count <= NumTypesPerWord)

MD5.update({(uint8_t)Working});

llvm::support;

endian::byte_swap<uint64_t, llvm::endianness::little>(Working);

MD5.update(

((uint8_t *)&Swapped,

(Swapped)));

llvm::MD5::MD5Result

;

llvm::IndexedInstrProfReader *PGOReader = CGM.

();

(!InstrumentRegions && !PGOReader)

(

*CCD = dyn_cast<CXXConstructorDecl>(

))

(Fn->hasFnAttribute(llvm::Attribute::NoProfile))

(Fn->hasFnAttribute(llvm::Attribute::SkipProfile))

mapRegionCounters(

);

emitCounterRegionMapping(

);

loadRegionCounts(PGOReader,

.isInMainFile(

->

()));

computeRegionCounts(

);

applyFunctionAttributes(PGOReader, Fn);

CodeGenPGO::mapRegionCounters(

*

) {

uint64_t ProfileVersion = llvm::IndexedInstrProf::Version;

HashVersion = getPGOHashVersion(PGOReader, CGM);

ProfileVersion = PGOReader->getVersion();

MCDCMaxConditions =

RegionCounterMap.reset(

llvm::DenseMap<const Stmt *, CounterPair>);

MapRegionCounters Walker(HashVersion, ProfileVersion, *RegionCounterMap,

*RegionMCDCState, MCDCMaxConditions, CGM.

());

(

*FD = dyn_cast_or_null<FunctionDecl>(

))

Walker.TraverseDecl(

*

(FD));

(

*MD = dyn_cast_or_null<ObjCMethodDecl>(

))

(

*BD = dyn_cast_or_null<BlockDecl>(

))

Walker.TraverseDecl(

*

(BD));

(

*CD = dyn_cast_or_null<CapturedDecl>(

))

Walker.TraverseDecl(

*

(CD));

assert(Walker.NextCounter > 0 &&

);

NumRegionCounters = Walker.NextCounter;

FunctionHash = Walker.Hash.finalize();

CodeGenPGO::skipRegionMappingForDecl(

*

) {

!

->

<CUDAGlobalAttr>()) ||

(

->

<CUDAGlobalAttr>() ||

CodeGenPGO::emitCounterRegionMapping(

*

) {

(skipRegionMappingForDecl(

))

std::string CoverageMapping;

llvm::raw_string_ostream OS(CoverageMapping);

RegionMCDCState->BranchByStmt.clear();

CGM.

(), RegionCounterMap.get(), RegionMCDCState.get());

MappingGen.emitCounterMapping(

, OS);

(CoverageMapping.empty())

FuncNameVar, FuncName, FunctionHash, CoverageMapping);

llvm::GlobalValue::LinkageTypes

) {

(skipRegionMappingForDecl(

))

std::string CoverageMapping;

llvm::raw_string_ostream OS(CoverageMapping);

(CoverageMapping.empty())

FuncNameVar, FuncName, FunctionHash, CoverageMapping,

);

CodeGenPGO::computeRegionCounts(

*

) {

StmtCountMap.reset(

llvm::DenseMap<const Stmt *, uint64_t>);

ComputeRegionCounts Walker(*StmtCountMap, *

);

(

*FD = dyn_cast_or_null<FunctionDecl>(

))

Walker.VisitFunctionDecl(FD);

(

*MD = dyn_cast_or_null<ObjCMethodDecl>(

))

Walker.VisitObjCMethodDecl(MD);

(

*BD = dyn_cast_or_null<BlockDecl>(

))

Walker.VisitBlockDecl(BD);

(

*CD = dyn_cast_or_null<CapturedDecl>(

))

Walker.VisitCapturedDecl(

*

(CD));

CodeGenPGO::applyFunctionAttributes(llvm::IndexedInstrProfReader *PGOReader,

llvm::Function *Fn) {

Fn->setEntryCount(FunctionCount);

(!RegionCounterMap)

{

,

};

I = RegionCounterMap->find(S);

(I == RegionCounterMap->end())

{

,

};

{I->second.Executed.hasValue(), I->second.Skipped.hasValue()};

llvm::Value *StepV) {

(!RegionCounterMap || !Builder.GetInsertBlock())

Counter = (*RegionCounterMap)[S].Executed;

*NormalizedFuncNameVarPtr =

llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(

llvm::Value *Args[] = {

NormalizedFuncNameVarPtr, Builder.getInt64(FunctionHash),

Builder.getInt32(NumRegionCounters), Builder.getInt32(Counter), StepV};

Builder.CreateCall(CGM.

(llvm::Intrinsic::instrprof_cover),

Builder.CreateCall(CGM.

(llvm::Intrinsic::instrprof_increment),

CGM.

(llvm::Intrinsic::instrprof_increment_step), Args);

CodeGenPGO::canEmitMCDCCoverage(

&Builder) {

CGM.

().MCDCCoverage && Builder.GetInsertBlock());

(!canEmitMCDCCoverage(Builder) || !RegionMCDCState)

*I8PtrTy = llvm::PointerType::getUnqual(CGM.

());

llvm::Value *Args[3] = {llvm::ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),

Builder.getInt64(FunctionHash),

Builder.getInt32(RegionMCDCState->BitmapBits)};

CGM.

(llvm::Intrinsic::instrprof_mcdc_parameters), Args);

(!canEmitMCDCCoverage(Builder) || !RegionMCDCState)

S = S->IgnoreParens();

DecisionStateIter = RegionMCDCState->DecisionByStmt.find(S);

(DecisionStateIter == RegionMCDCState->DecisionByStmt.end())

(DecisionStateIter->second.Indices.size() == 0)

MCDCTestVectorBitmapOffset = DecisionStateIter->second.BitmapIdx;

*I8PtrTy = llvm::PointerType::getUnqual(CGM.

());

llvm::Value *Args[4] = {llvm::ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),

Builder.getInt64(FunctionHash),

Builder.getInt32(MCDCTestVectorBitmapOffset),

CGM.

(llvm::Intrinsic::instrprof_mcdc_tvbitmap_update), Args);

(!canEmitMCDCCoverage(Builder) || !RegionMCDCState)

S = S->IgnoreParens();

(!RegionMCDCState->DecisionByStmt.contains(S))

Builder.CreateStore(Builder.getInt32(0), MCDCCondBitmapAddr);

(!canEmitMCDCCoverage(Builder) || !RegionMCDCState)

BranchStateIter = RegionMCDCState->BranchByStmt.find(S);

(BranchStateIter == RegionMCDCState->BranchByStmt.end())

&Branch = BranchStateIter->second;

assert(Branch.ID >= 0 &&

);

assert(Branch.DecisionStmt);

DecisionIter =

RegionMCDCState->DecisionByStmt.find(Branch.DecisionStmt);

(DecisionIter == RegionMCDCState->DecisionByStmt.end())

&TVIdxs = DecisionIter->second.Indices[Branch.ID];

*CurTV = Builder.CreateLoad(MCDCCondBitmapAddr,

+ Twine(Branch.ID + 1) +

);

*NewTV = Builder.CreateAdd(CurTV, Builder.getInt32(TVIdxs[

]));

NewTV = Builder.CreateSelect(

Val, NewTV, Builder.CreateAdd(CurTV, Builder.getInt32(TVIdxs[

])));

Builder.CreateStore(NewTV, MCDCCondBitmapAddr);

M.addModuleFlag(llvm::Module::Warning,

,

StringRef VarName(INSTR_PROF_QUOTE(INSTR_PROF_RAW_VERSION_VAR));

llvm::Type *IntTy64 = llvm::Type::getInt64Ty(M.getContext());

uint64_t ProfileVersion =

(INSTR_PROF_RAW_VERSION | VARIANT_MASK_BYTE_COVERAGE);

IRLevelVersionVariable =

llvm::GlobalVariable(

M, IntTy64,

, llvm::GlobalValue::WeakAnyLinkage,

llvm::Constant::getIntegerValue(IntTy64,

llvm::APInt(64, ProfileVersion)),

IRLevelVersionVariable->setVisibility(llvm::GlobalValue::HiddenVisibility);

llvm::Triple TT(M.getTargetTriple());

(TT.supportsCOMDAT()) {

IRLevelVersionVariable->setLinkage(llvm::GlobalValue::ExternalLinkage);

IRLevelVersionVariable->setComdat(M.getOrInsertComdat(VarName));

IRLevelVersionVariable->setDSOLocal(

);

llvm::Instruction *ValueSite, llvm::Value *ValuePtr) {

(!ValuePtr || !ValueSite || !Builder.GetInsertBlock())

(isa<llvm::Constant>(ValuePtr))

(InstrumentValueSites && RegionCounterMap) {

BuilderInsertPoint = Builder.saveIP();

Builder.SetInsertPoint(ValueSite);

llvm::Value *Args[5] = {

Builder.getInt64(FunctionHash),

Builder.CreatePtrToInt(ValuePtr, Builder.getInt64Ty()),

Builder.getInt32(ValueKind),

Builder.getInt32(NumValueSites[ValueKind]++)

CGM.

(llvm::Intrinsic::instrprof_value_profile), Args);

Builder.restoreIP(BuilderInsertPoint);

llvm::IndexedInstrProfReader *PGOReader = CGM.

();

(NumValueSites[ValueKind] >= ProfRecord->getNumValueSites(ValueKind))

llvm::annotateValueSite(CGM.

(), *ValueSite, *ProfRecord,

(llvm::InstrProfValueKind)ValueKind,

NumValueSites[ValueKind]);

NumValueSites[ValueKind]++;

CodeGenPGO::loadRegionCounts(llvm::IndexedInstrProfReader *PGOReader,

IsInMainFile) {

RegionCounts.clear();

PGOReader->getInstrProfRecord(FuncName, FunctionHash);

(

= RecordExpected.takeError()) {

IPE = std::get<0>(llvm::InstrProfError::take(std::move(

)));

(IPE == llvm::instrprof_error::unknown_function)

(IPE == llvm::instrprof_error::hash_mismatch)

(IPE == llvm::instrprof_error::malformed)

std::make_unique<llvm::InstrProfRecord>(std::move(RecordExpected.get()));

RegionCounts = ProfRecord->Counts;

MaxWeight < UINT32_MAX ? 1 : MaxWeight / UINT32_MAX + 1;

assert(Scale &&

);

uint64_t Scaled = Weight / Scale + 1;

assert(Scaled <= UINT32_MAX &&

);

llvm::MDNode *CodeGenFunction::createProfileWeights(uint64_t TrueCount,

uint64_t FalseCount)

{

(!TrueCount && !FalseCount)

(Weights.size() < 2)

MaxWeight = *std::max_element(Weights.begin(), Weights.end());

ScaledWeights.reserve(Weights.size());

(uint64_t W : Weights)

MDHelper.createBranchWeights(ScaledWeights);

CodeGenFunction::createProfileWeightsForLoop(

*Cond,

uint64_t LoopCount)

{

std::optional<uint64_t> CondCount = PGO.

(Cond);

(!CondCount || *CondCount == 0)

createProfileWeights(LoopCount,

std::max(*CondCount, LoopCount) - LoopCount);

llvm::ImmutableMap< CountKey, unsigned > CountMap

#define DEFINE_NESTABLE_TRAVERSAL(N)

static llvm::cl::opt< bool > EnableValueProfiling("enable-value-profiling", llvm::cl::desc("Enable value profiling"), llvm::cl::Hidden, llvm::cl::init(false))

PGOHashVersion

The version of the PGO hash algorithm.

static uint64_t calculateWeightScale(uint64_t MaxWeight)

Calculate what to divide by to scale weights.

static uint32_t scaleBranchWeight(uint64_t Weight, uint64_t Scale)

Scale an individual branch weight (and add 1).

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

SourceManager & getSourceManager()

AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...

BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...

A builtin binary operation expression such as "x + y" or "x <= y".

static bool isLogicalOp(Opcode Opc)

Represents a block literal declaration, which is like an unnamed FunctionDecl.

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

BreakStmt - This represents a break.

CXXCatchStmt - This represents a C++ catch block.

CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...

A C++ throw-expression (C++ [except.throw]).

CXXTryStmt - A C++ try block, including all handlers.

Represents the body of a CapturedStmt, and serves as its DeclContext.

This captures a statement into a function.

CaseStmt - Represent a case statement.

bool hasProfileClangInstr() const

Check if Clang profile instrumenation is on.

std::string MainFileName

The user provided name for the "main file", if non-empty.

Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...

llvm::Value * emitRawPointer(CodeGenFunction &CGF) const

Return the pointer contained in this class after authenticating it and adding offset to it if necessa...

CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...

static const Expr * stripCond(const Expr *C)

Ignore parentheses and logical-NOT to track conditions consistently.

static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor)

This class organizes the cross-function state that is used while generating LLVM code.

llvm::Module & getModule() const

DiagnosticsEngine & getDiags() const

const LangOptions & getLangOpts() const

const TargetInfo & getTarget() const

llvm::IndexedInstrProfReader * getPGOReader() const

CoverageMappingModuleGen * getCoverageMapping() const

InstrProfStats & getPGOStats()

ASTContext & getContext() const

const CodeGenOptions & getCodeGenOpts() const

llvm::LLVMContext & getLLVMContext()

llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})

void ClearUnusedCoverageMapping(const Decl *D)

Remove the deferred empty coverage mapping as this declaration is actually instrumented.

void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)

Assign counters to regions and configure them for PGO of a given function.

std::pair< bool, bool > getIsCounterPair(const Stmt *S) const

std::optional< uint64_t > getStmtCount(const Stmt *S) const

Check if an execution count is known for a given statement.

void emitMCDCTestVectorBitmapUpdate(CGBuilderTy &Builder, const Expr *S, Address MCDCCondBitmapAddr, CodeGenFunction &CGF)

uint64_t getRegionCount(const Stmt *S)

Return the region count for the counter at the given index.

void setValueProfilingFlag(llvm::Module &M)

void valueProfile(CGBuilderTy &Builder, uint32_t ValueKind, llvm::Instruction *ValueSite, llvm::Value *ValuePtr)

void emitMCDCCondBitmapUpdate(CGBuilderTy &Builder, const Expr *S, Address MCDCCondBitmapAddr, llvm::Value *Val, CodeGenFunction &CGF)

void emitMCDCCondBitmapReset(CGBuilderTy &Builder, const Expr *S, Address MCDCCondBitmapAddr)

void setProfileVersion(llvm::Module &M)

void emitEmptyCounterMapping(const Decl *D, StringRef FuncName, llvm::GlobalValue::LinkageTypes Linkage)

Emit a coverage mapping range with a counter zero for an unused declaration.

void emitMCDCParameters(CGBuilderTy &Builder)

bool haveRegionCounts() const

Whether or not we have PGO region data for the current function.

void emitCounterSetOrIncrement(CGBuilderTy &Builder, const Stmt *S, llvm::Value *StepV)

Organizes the per-function state that is used while generating code coverage mapping data.

void emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS)

Emit the coverage mapping data for an unused function.

void addFunctionMappingRecord(llvm::GlobalVariable *FunctionName, StringRef FunctionNameValue, uint64_t FunctionHash, const std::string &CoverageMapping, bool IsUsed=true)

Add a function's coverage mapping record to the collection of the function mapping records.

void addMissing(bool MainFile)

Record that a function we've visited has no profile data.

void addMismatched(bool MainFile)

Record that a function we've visited has mismatched profile data.

void addVisited(bool MainFile)

Record that we've visited a function and whether or not that function was in the main source file.

ConditionalOperator - The ?: ternary operator.

ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.

ContinueStmt - This represents a continue.

Decl - This represents one declaration (or definition), e.g.

bool isImplicit() const

isImplicit - Indicates whether the declaration was implicitly generated by the implementation.

virtual Stmt * getBody() const

getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...

virtual bool hasBody() const

Returns true if this Decl represents a declaration for a body of code, such as a function or method d...

SourceLocation getLocation() const

Concrete class used by the front-end to report problems and issues.

DoStmt - This represents a 'do/while' stmt.

This represents one expression.

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

ForStmt - This represents a 'for (init;cond;inc)' stmt.

Represents a function declaration or definition.

GlobalDecl - represents a global declaration.

CXXCtorType getCtorType() const

CXXDtorType getDtorType() const

const Decl * getDecl() const

GotoStmt - This represents a direct goto.

IfStmt - This represents an if/then/else.

IndirectGotoStmt - This represents an indirect goto.

LabelStmt - Represents a label, which has a substatement.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

Represents Objective-C's collection statement.

ObjCMethodDecl - Represents an instance or class method declaration.

A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

This class handles loading and caching of source files into memory.

Stmt - This represents one statement.

SourceLocation getBeginLoc() const LLVM_READONLY

SwitchStmt - This represents a 'switch' stmt.

bool hasConstructorVariants() const

Does this ABI have different entrypoints for complete-object and base-subobject constructors?

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

The base class of the type hierarchy.

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

WhileStmt - This represents a 'while' stmt.

@ Type

The l-value was considered opaque, so the alignment was determined from a type.

bool LE(InterpState &S, CodePtr OpPC)

The JSON file list parser is used to communicate input to InstallAPI.

@ Ctor_Base

Base object ctor.

@ If

'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...

Linkage

Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.

@ Result

The result type of a method or function.

@ Dtor_Base

Base object dtor.

void finalize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)

@ None

The alignment was not explicit in code.

cl::opt< bool > SystemHeadersCoverage

Diagnostic wrappers for TextAPI types for error reporting.

cl::opt< bool > EnableSingleByteCoverage

Per-Function MC/DC state.

llvm::DenseMap< const Stmt *, Decision > DecisionByStmt

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4