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

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

clang: lib/CodeGen/CoverageMappingGen.cpp Source File

llvm::cl::desc(

),

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

));

,

llvm::cl::desc(

),

llvm::cl::init(

), llvm::cl::Hidden);

,

cl::desc(

), cl::init(

),

;

CodeGen;

(Tok.

() != clang::tok::eod)

PrevTokLoc == SkippedRanges.back().PrevTokLoc &&

SourceMgr.isWrittenInSameFile(SkippedRanges.back().Range.getEnd(),

SkippedRanges.back().Range.setEnd(

.

());

SkippedRanges.push_back({

, RangeKind, PrevTokLoc});

(!SkippedRanges.empty() && SkippedRanges.back().NextTokLoc.isInvalid())

SkippedRanges.back().NextTokLoc =

;

SourceMappingRegion {

std::optional<Counter> FalseCount;

mcdc::Parameters MCDCParams;

std::optional<SourceLocation> LocStart;

std::optional<SourceLocation> LocEnd;

SourceMappingRegion(Counter Count, std::optional<SourceLocation> LocStart,

std::optional<SourceLocation> LocEnd,

GapRegion =

)

: Count(Count), LocStart(LocStart), LocEnd(LocEnd), GapRegion(GapRegion),

SkippedRegion(

) {}

SourceMappingRegion(Counter Count, std::optional<Counter> FalseCount,

mcdc::Parameters MCDCParams,

std::optional<SourceLocation> LocStart,

std::optional<SourceLocation> LocEnd,

GapRegion =

)

: Count(Count), FalseCount(FalseCount), MCDCParams(MCDCParams),

LocStart(LocStart), LocEnd(LocEnd), GapRegion(GapRegion),

SkippedRegion(

) {}

SourceMappingRegion(mcdc::Parameters MCDCParams,

std::optional<SourceLocation> LocStart,

std::optional<SourceLocation> LocEnd)

: MCDCParams(MCDCParams), LocStart(LocStart), LocEnd(LocEnd),

Counter &getCounter()

{

Count; }

Counter &getFalseCounter()

{

assert(FalseCount &&

);

setCounter(Counter

) { Count =

; }

hasStartLoc()

{

LocStart.has_value(); }

assert(LocStart &&

);

hasEndLoc()

{

LocEnd.has_value(); }

assert(

.

() &&

);

assert(LocEnd &&

);

isGap()

{

GapRegion; }

setGap(

Gap) { GapRegion = Gap; }

isSkipped()

{

SkippedRegion; }

setSkipped(

Skipped) { SkippedRegion = Skipped; }

isBranch()

{

FalseCount.has_value(); }

isMCDCBranch()

{

std::holds_alternative<mcdc::BranchParameters>(MCDCParams);

&getMCDCBranchParams()

{

mcdc::getParams<const mcdc::BranchParameters>(MCDCParams);

isMCDCDecision()

{

std::holds_alternative<mcdc::DecisionParameters>(MCDCParams);

&getMCDCDecisionParams()

{

mcdc::getParams<const mcdc::DecisionParameters>(MCDCParams);

mcdc::Parameters &getMCDCParams()

{

MCDCParams; }

resetMCDCParams() { MCDCParams = mcdc::Parameters(); }

SpellingRegion {

ColumnStart;

LineStart =

.getSpellingLineNumber(LocStart);

ColumnStart =

.getSpellingColumnNumber(LocStart);

LineEnd =

.getSpellingLineNumber(LocEnd);

ColumnEnd =

.getSpellingColumnNumber(LocEnd);

: SpellingRegion(

, R.getBeginLoc(), R.getEndLoc()) {}

isInSourceOrder()

{

(LineStart < LineEnd) ||

(LineStart == LineEnd && ColumnStart <= ColumnEnd);

CoverageMappingBuilder {

llvm::SmallDenseMap<FileID, std::pair<unsigned, SourceLocation>, 8>

std::vector<SourceMappingRegion> SourceRegions;

llvm::SmallSet<std::pair<SourceLocation, SourceLocation>, 8>

: CVM(CVM),

(

), LangOpts(LangOpts) {}

.getLocForStartOfFile(

.getFileID(

));

.getFileOffset(

));

.getLocForEndOfFile(

.getFileID(

));

std::pair<SourceLocation, std::optional<SourceLocation>>

std::optional<SourceLocation> EndLoc = std::nullopt;

.isWrittenInScratchSpace(

.getSpellingLoc(

))) {

ExpansionRange =

.getImmediateExpansionRange(

);

= ExpansionRange.getBegin();

EndLoc = ExpansionRange.getEnd();

std::make_pair(

, EndLoc);

AcceptScratch =

) {

.getIncludeLoc(

.getFileID(

));

=

.getImmediateExpansionRange(

).getBegin();

getNonScratchExpansionLoc(

).first;

.getBufferName(

.getSpellingLoc(

)) ==

;

= getIncludeOrExpansionLoc(

);

(

.isMacroArgExpansion(

) || isInBuiltin(

))

=

.getImmediateExpansionRange(

).getBegin();

(

.isMacroArgExpansion(

) || isInBuiltin(

))

=

.getImmediateExpansionRange(

).getBegin();

getPreciseTokenLocEnd(

);

FileIDMapping.clear();

llvm::SmallSet<FileID, 8>

;

(

&Region : SourceRegions) {

NonScratchExpansionLoc = getNonScratchExpansionLoc(

);

EndLoc = NonScratchExpansionLoc.second;

(EndLoc.has_value()) {

= NonScratchExpansionLoc.first;

Region.setStartLoc(

);

Region.setEndLoc(EndLoc.value());

BeginLoc =

.getSpellingLoc(

);

EndLoc =

.getSpellingLoc(Region.getEndLoc());

(

.isWrittenInSameFile(BeginLoc, EndLoc)) {

Region.setStartLoc(

);

Region.setEndLoc(

.getFileLoc(Region.getEndLoc()));

!

.isInSystemHeader(

.getSpellingLoc(

)));

FileLocs.push_back(std::make_pair(

, Depth));

llvm::stable_sort(FileLocs, llvm::less_second());

(

&FL : FileLocs) {

SpellingFile =

.getDecomposedSpellingLoc(

).first;

Entry =

.getFileEntryRefForID(SpellingFile);

FileIDMapping[

.getFileID(

)] = std::make_pair(Mapping.size(),

);

Mapping.push_back(CVM.

(*Entry));

Mapping = FileIDMapping.find(

.getFileID(

));

(Mapping != FileIDMapping.end())

Mapping->second.first;

SpellingRegion SR{

, LocStart, LocEnd};

(PrevTokLoc.

() &&

.isWrittenInSameFile(LocStart, PrevTokLoc) &&

SR.LineStart ==

.getSpellingLineNumber(PrevTokLoc))

(NextTokLoc.

() &&

.isWrittenInSameFile(LocEnd, NextTokLoc) &&

SR.LineEnd ==

.getSpellingLineNumber(NextTokLoc)) {

(SR.isInSourceOrder())

gatherSkippedRegions() {

FileLineRanges.resize(

FileIDMapping.size(),

std::make_pair(std::numeric_limits<unsigned>::max(), 0));

(

&R : MappingRegions) {

FileLineRanges[R.FileID].first =

std::min(FileLineRanges[R.FileID].first, R.LineStart);

FileLineRanges[R.FileID].second =

std::max(FileLineRanges[R.FileID].second, R.LineEnd);

(

&I : SkippedRanges) {

assert(

.isWrittenInSameFile(LocStart, LocEnd) &&

);

CovFileID = getCoverageFileID(LocStart);

std::optional<SpellingRegion> SR;

SR = adjustSkippedRange(

, LocStart, LocEnd, I.PrevTokLoc,

(I.isPPIfElse() || I.isEmptyLine())

SR = {

, LocStart, LocEnd};

Region = CounterMappingRegion::makeSkipped(

*CovFileID, SR->LineStart, SR->ColumnStart, SR->LineEnd,

(Region.LineStart >= FileLineRanges[*CovFileID].first &&

Region.LineEnd <= FileLineRanges[*CovFileID].second)

MappingRegions.push_back(Region);

emitSourceRegions(

SourceRegionFilter &Filter) {

(

&Region : SourceRegions) {

assert(Region.hasEndLoc() &&

);

assert(

.getFileID(LocStart).isValid() &&

);

.isInSystemHeader(

.getSpellingLoc(LocStart))) {

assert(!Region.isMCDCBranch() && !Region.isMCDCDecision() &&

);

CovFileID = getCoverageFileID(LocStart);

assert(!Region.isMCDCBranch() && !Region.isMCDCDecision() &&

);

assert(

.isWrittenInSameFile(LocStart, LocEnd) &&

);

(

.count(std::make_pair(LocStart, LocEnd))) {

assert(!Region.isMCDCBranch() && !Region.isMCDCDecision() &&

);

SpellingRegion SR{

, LocStart, LocEnd};

assert(SR.isInSourceOrder() &&

);

(Region.isGap()) {

MappingRegions.push_back(CounterMappingRegion::makeGapRegion(

Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,

SR.LineEnd, SR.ColumnEnd));

}

(Region.isSkipped()) {

MappingRegions.push_back(CounterMappingRegion::makeSkipped(

*CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd,

}

(Region.isBranch()) {

MappingRegions.push_back(CounterMappingRegion::makeBranchRegion(

Region.getCounter(), Region.getFalseCounter(), *CovFileID,

SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd,

Region.getMCDCParams()));

}

(Region.isMCDCDecision()) {

MappingRegions.push_back(CounterMappingRegion::makeDecisionRegion(

Region.getMCDCDecisionParams(), *CovFileID, SR.LineStart,

SR.ColumnStart, SR.LineEnd, SR.ColumnEnd));

MappingRegions.push_back(CounterMappingRegion::makeRegion(

Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,

SR.LineEnd, SR.ColumnEnd));

SourceRegionFilter emitExpansionRegions() {

SourceRegionFilter

;

(

&FM : FileIDMapping) {

ParentLoc = getIncludeOrExpansionLoc(ExpandedLoc,

);

ParentFileID = getCoverageFileID(ParentLoc);

ExpandedFileID = getCoverageFileID(ExpandedLoc);

assert(ExpandedFileID &&

);

assert(

.isWrittenInSameFile(ParentLoc, LocEnd) &&

);

.insert(std::make_pair(ParentLoc, LocEnd));

SpellingRegion SR{

, ParentLoc, LocEnd};

assert(SR.isInSourceOrder() &&

);

MappingRegions.push_back(CounterMappingRegion::makeExpansion(

*ParentFileID, *ExpandedFileID, SR.LineStart, SR.ColumnStart,

SR.LineEnd, SR.ColumnEnd));

EmptyCoverageMappingBuilder :

CoverageMappingBuilder {

: CoverageMappingBuilder(CVM,

, LangOpts) {}

VisitDecl(

*

) {

(!

.isWrittenInSameFile(Start, End)) {

StartFileID =

.getFileID(Start);

EndFileID =

.getFileID(End);

(StartFileID != EndFileID && !isNestedIn(End, StartFileID)) {

Start = getIncludeOrExpansionLoc(Start);

);

StartFileID =

.getFileID(Start);

(StartFileID != EndFileID) {

End = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(End));

assert(End.isValid() &&

);

EndFileID =

.getFileID(End);

SourceRegions.emplace_back(Counter(), Start, End);

write(llvm::raw_ostream &OS) {

gatherFileIDs(FileIDMapping);

emitSourceRegions(SourceRegionFilter());

(MappingRegions.empty())

CoverageMappingWriter Writer(FileIDMapping, {}, MappingRegions);

MCDCCoverageBuilder {

*DecisionStmt =

;

mcdc::ConditionID NextID = 0;

NotMapped =

;

mcdc::ConditionIDs DecisionStackSentinel{-1, -1};

->getOpcode() == BO_LAnd;

: CGM(CGM), DecisionStack(1, DecisionStackSentinel),

MCDCState(MCDCState) {}

isIdle()

{

(NextID == 0 && !NotMapped); }

isBuilding()

{

(NextID > 0); }

setCondID(

*Cond, mcdc::ConditionID

) {

MCDCState.

[CodeGenFunction::stripCond(Cond)] = {

,

mcdc::ConditionID getCondID(

*Cond)

{

I = MCDCState.

.find(CodeGenFunction::stripCond(Cond));

mcdc::ConditionIDs &back()

{

DecisionStack.back(); }

mcdc::ConditionIDs &ParentDecision = DecisionStack.back();

(MCDCState.

.contains(CodeGenFunction::stripCond(

)))

setCondID(

->getLHS(), getCondID(

));

setCondID(

->getLHS(), NextID++);

mcdc::ConditionID RHSid = NextID++;

setCondID(

->getRHS(), RHSid);

DecisionStack.push_back({ParentDecision[

], RHSid});

DecisionStack.push_back({RHSid, ParentDecision[

]});

mcdc::ConditionIDs pop() {

DecisionStackSentinel;

assert(DecisionStack.size() > 1);

DecisionStack.pop_back_val();

assert(DecisionStack.size() == 1);

TotalConds = NextID;

CounterCoverageMappingBuilder

:

CoverageMappingBuilder,

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

llvm::DenseSet<const Stmt *> LeafExprSet;

MCDCCoverageBuilder MCDCBuilder;

CounterExpressionBuilder Builder;

HasTerminateStmt =

;

Counter GapRegionCounter;

Counter subtractCounters(Counter LHS, Counter RHS,

Simplify =

) {

);

Builder.subtract(LHS, RHS, Simplify);

Counter addCounters(Counter LHS, Counter RHS,

Simplify =

) {

Builder.add(LHS, RHS, Simplify);

Counter addCounters(Counter C1, Counter C2, Counter C3,

Simplify =

) {

addCounters(addCounters(C1, C2, Simplify), C3, Simplify);

Counter getRegionCounter(

*S) {

Counter::getCounter(CounterMap[S].Executed);

BranchCounterPair {

getBranchCounterPair(

*S, Counter ParentCnt,

std::optional<Counter> SkipCntForOld = std::nullopt) {

Counter ExecCnt = getRegionCounter(S);

assert(SkipCntForOld &&

);

{ExecCnt, *SkipCntForOld};

{ExecCnt, Builder.subtract(ParentCnt, ExecCnt)};

IsCounterEqual(Counter OutCount, Counter ParentCount) {

(OutCount == ParentCount)

pushRegion(Counter Count,

std::optional<SourceLocation> StartLoc = std::nullopt,

std::optional<SourceLocation> EndLoc = std::nullopt,

std::optional<Counter> FalseCount = std::nullopt,

mcdc::Parameters &BranchParams = std::monostate()) {

(StartLoc && !FalseCount) {

MostRecentLocation = *StartLoc;

assert((!StartLoc || StartLoc->isValid()) &&

);

assert((!EndLoc || EndLoc->isValid()) &&

);

(StartLoc && StartLoc->isInvalid())

StartLoc = std::nullopt;

(EndLoc && EndLoc->isInvalid())

EndLoc = std::nullopt;

RegionStack.emplace_back(Count, FalseCount, BranchParams, StartLoc, EndLoc);

RegionStack.size() - 1;

pushRegion(

mcdc::DecisionParameters &DecisionParams,

std::optional<SourceLocation> StartLoc = std::nullopt,

std::optional<SourceLocation> EndLoc = std::nullopt) {

RegionStack.emplace_back(DecisionParams, StartLoc, EndLoc);

RegionStack.size() - 1;

= getIncludeOrExpansionLoc(

);

popRegions(

ParentIndex) {

assert(RegionStack.size() >= ParentIndex &&

);

(RegionStack.size() > ParentIndex) {

SourceMappingRegion &Region = RegionStack.back();

(Region.hasStartLoc() &&

(Region.hasEndLoc() || RegionStack[ParentIndex].hasEndLoc())) {

? Region.getEndLoc()

: RegionStack[ParentIndex].getEndLoc();

isBranch = Region.isBranch();

StartDepth = locationDepth(StartLoc);

EndDepth = locationDepth(EndLoc);

(!

.isWrittenInSameFile(StartLoc, EndLoc)) {

UnnestStart = StartDepth >= EndDepth;

UnnestEnd = EndDepth >= StartDepth;

assert(

.isWrittenInSameFile(NestedLoc, EndLoc));

(!isBranch && !isRegionAlreadyAdded(NestedLoc, EndLoc))

SourceRegions.emplace_back(Region.getCounter(), NestedLoc,

EndLoc = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(EndLoc));

llvm::report_fatal_error(

);

assert(

.isWrittenInSameFile(StartLoc, NestedLoc));

(!isBranch && !isRegionAlreadyAdded(StartLoc, NestedLoc))

SourceRegions.emplace_back(Region.getCounter(), StartLoc,

StartLoc = getIncludeOrExpansionLoc(StartLoc);

llvm::report_fatal_error(

);

Region.setStartLoc(StartLoc);

Region.setEndLoc(EndLoc);

MostRecentLocation = EndLoc;

(StartLoc == getStartOfFileOrMacro(StartLoc) &&

EndLoc == getEndOfFileOrMacro(EndLoc))

MostRecentLocation = getIncludeOrExpansionLoc(EndLoc);

assert(

.isWrittenInSameFile(Region.getBeginLoc(), EndLoc));

assert(SpellingRegion(

, Region).isInSourceOrder());

SourceRegions.push_back(Region);

RegionStack.pop_back();

assert(!RegionStack.empty() &&

);

RegionStack.back();

Counter propagateCounts(Counter TopCount,

*S,

VisitChildren =

) {

Index = pushRegion(TopCount, StartLoc, EndLoc);

Counter ExitCount =

().getCounter();

(

.isBeforeInTranslationUnit(StartLoc, S->getBeginLoc()))

MostRecentLocation = EndLoc;

createBranchRegion(

*

, Counter TrueCnt, Counter FalseCnt,

mcdc::ConditionIDs &Conds = {}) {

(CodeGenFunction::isInstrumentedCondition(

) ||

LeafExprSet.count(CodeGenFunction::stripCond(

))) {

mcdc::Parameters BranchParams;

mcdc::ConditionID

= MCDCBuilder.getCondID(

);

BranchParams = mcdc::BranchParameters{

, Conds};

(Result.Val.getInt().getBoolValue())

FalseCnt = Counter::getZero();

TrueCnt = Counter::getZero();

pushRegion(TrueCnt, getStart(

), getEnd(

), FalseCnt, BranchParams));

createDecisionRegion(

*

,

mcdc::DecisionParameters &DecisionParams) {

popRegions(pushRegion(DecisionParams, getStart(

), getEnd(

)));

Counter createSwitchCaseRegion(

*SC, Counter ParentCount) {

Counter TrueCnt = getRegionCounter(SC);

popRegions(pushRegion(TrueCnt, getStart(SC), SC->

(),

subtractCounters(ParentCount, TrueCnt)));

isBranch =

) {

llvm::any_of(

llvm::reverse(SourceRegions), [&](

SourceMappingRegion &Region) {

Region.getBeginLoc() == StartLoc &&

Region.getEndLoc() == EndLoc && Region.isBranch() == isBranch;

MostRecentLocation = EndLoc;

MostRecentLocation == getEndOfFileOrMacro(MostRecentLocation) &&

isRegionAlreadyAdded(getStartOfFileOrMacro(MostRecentLocation),

MostRecentLocation,

().isBranch()))

MostRecentLocation = getIncludeOrExpansionLoc(MostRecentLocation);

.isWrittenInSameFile(MostRecentLocation, NewLoc))

ParentFile =

.getFileID(LCA);

(!isNestedIn(MostRecentLocation, ParentFile)) {

LCA = getIncludeOrExpansionLoc(LCA);

(LCA.

() ||

.isWrittenInSameFile(LCA, MostRecentLocation)) {

MostRecentLocation = NewLoc;

ParentFile =

.getFileID(LCA);

llvm::SmallSet<SourceLocation, 8> StartLocs;

std::optional<Counter> ParentCounter;

(SourceMappingRegion &I : llvm::reverse(RegionStack)) {

(!I.hasStartLoc())

(!isNestedIn(

, ParentFile)) {

ParentCounter = I.getCounter();

(!

.isInFileID(

, ParentFile)) {

(StartLocs.insert(

).second) {

SourceRegions.emplace_back(I.getCounter(), I.getFalseCounter(),

I.getMCDCParams(),

,

getEndOfFileOrMacro(

), I.isBranch());

SourceRegions.emplace_back(I.getCounter(),

,

getEndOfFileOrMacro(

));

= getIncludeOrExpansionLoc(

);

I.setStartLoc(getPreciseTokenLocEnd(

));

(ParentCounter) {

(isNestedIn(

, ParentFile)) {

(StartLocs.insert(FileStart).second) {

SourceRegions.emplace_back(*ParentCounter, FileStart,

getEndOfFileOrMacro(

));

assert(SpellingRegion(

, SourceRegions.back()).isInSourceOrder());

= getIncludeOrExpansionLoc(

);

MostRecentLocation = NewLoc;

extendRegion(

*S) {

SourceMappingRegion &Region =

();

handleFileExit(StartLoc);

(!Region.hasStartLoc())

Region.setStartLoc(StartLoc);

terminateRegion(

*S) {

SourceMappingRegion &Region =

();

(!Region.hasEndLoc())

Region.setEndLoc(EndLoc);

pushRegion(Counter::getZero());

HasTerminateStmt =

;

std::optional<SourceRange> findGapAreaBetween(

AfterLoc,

std::nullopt;

FID =

.getFileID(AfterLoc);

StartDepth = locationDepth(AfterLoc);

EndDepth = locationDepth(BeforeLoc);

(!

.isWrittenInSameFile(AfterLoc, BeforeLoc)) {

UnnestStart = StartDepth >= EndDepth;

UnnestEnd = EndDepth >= StartDepth;

assert(

.isWrittenInSameFile(getStartOfFileOrMacro(BeforeLoc),

BeforeLoc = getIncludeOrExpansionLoc(BeforeLoc);

assert(BeforeLoc.

());

assert(

.isWrittenInSameFile(AfterLoc,

getEndOfFileOrMacro(AfterLoc)));

AfterLoc = getIncludeOrExpansionLoc(AfterLoc);

AfterLoc = getPreciseTokenLocEnd(AfterLoc);

AfterLoc = getPreciseTokenLocEnd(AfterLoc);

std::nullopt;

(!

.isWrittenInSameFile(AfterLoc, BeforeLoc) ||

!SpellingRegion(

, AfterLoc, BeforeLoc).isInSourceOrder())

std::nullopt;

{{AfterLoc, BeforeLoc}};

(StartLoc == EndLoc)

assert(SpellingRegion(

, StartLoc, EndLoc).isInSourceOrder());

handleFileExit(StartLoc);

Index = pushRegion(Count, StartLoc, EndLoc);

handleFileExit(EndLoc);

std::optional<SourceRange> findAreaStartingFromTo(

StartingLoc,

FID =

.getFileID(StartingLoc);

StartDepth = locationDepth(StartingLoc);

EndDepth = locationDepth(BeforeLoc);

(!

.isWrittenInSameFile(StartingLoc, BeforeLoc)) {

UnnestStart = StartDepth >= EndDepth;

UnnestEnd = EndDepth >= StartDepth;

assert(

.isWrittenInSameFile(getStartOfFileOrMacro(BeforeLoc),

BeforeLoc = getIncludeOrExpansionLoc(BeforeLoc);

assert(BeforeLoc.

());

assert(

.isWrittenInSameFile(StartingLoc,

getStartOfFileOrMacro(StartingLoc)));

StartingLoc = getIncludeOrExpansionLoc(StartingLoc);

assert(StartingLoc.

());

std::nullopt;

(!

.isWrittenInSameFile(StartingLoc, BeforeLoc) ||

!SpellingRegion(

, StartingLoc, BeforeLoc).isInSourceOrder())

std::nullopt;

{{StartingLoc, BeforeLoc}};

Skipped = findAreaStartingFromTo(StartLoc, BeforeLoc);

NewStartLoc = Skipped->getBegin();

EndLoc = Skipped->getEnd();

(NewStartLoc == EndLoc)

assert(SpellingRegion(

, NewStartLoc, EndLoc).isInSourceOrder());

handleFileExit(NewStartLoc);

Index = pushRegion(Counter{}, NewStartLoc, EndLoc);

handleFileExit(EndLoc);

BreakContinue {

Counter ContinueCount;

CounterCoverageMappingBuilder(

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

: CoverageMappingBuilder(CVM,

, LangOpts), CounterMap(CounterMap),

MCDCState(MCDCState), MCDCBuilder(CVM.getCodeGenModule(), MCDCState) {}

write(llvm::raw_ostream &OS) {

gatherFileIDs(VirtualFileMapping);

SourceRegionFilter

= emitExpansionRegions();

emitSourceRegions(Filter);

gatherSkippedRegions();

(MappingRegions.empty())

CoverageMappingWriter Writer(VirtualFileMapping, Builder.getExpressions(),

VisitStmt(

*S) {

(S->getBeginLoc().isValid())

*LastStmt =

;

SaveTerminateStmt = HasTerminateStmt;

HasTerminateStmt =

;

GapRegionCounter = Counter::getZero();

(

*Child : S->children())

(LastStmt && HasTerminateStmt) {

Gap = findGapAreaBetween(getEnd(LastStmt), getStart(Child));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(),

SaveTerminateStmt =

;

HasTerminateStmt =

;

(SaveTerminateStmt)

HasTerminateStmt =

;

handleFileExit(getEnd(S));

VisitDecl(

*

) {

.isInSystemHeader(

.getSpellingLoc(getStart(Body))))

Counter BodyCounter = getRegionCounter(Body);

(

*Method = dyn_cast<CXXMethodDecl>(

))

(

*Ctor = dyn_cast<CXXConstructorDecl>(

)) {

(getStart(

).isValid() && getEnd(

).isValid())

propagateCounts(BodyCounter,

);

propagateCounts(BodyCounter, Body,

assert(RegionStack.empty() &&

);

(S->getRetValue())

Visit(S->getRetValue());

Visit(S->getBody());

(S->getOperand())

Visit(S->getOperand());

Visit(

->getOperand());

(

->getSubExpr())

Visit(

->getSubExpr());

terminateRegion(

);

VisitGotoStmt(

*S) { terminateRegion(S); }

VisitLabelStmt(

*S) {

Counter LabelCount = getRegionCounter(S);

handleFileExit(Start);

pushRegion(LabelCount, Start);

Visit(S->getSubStmt());

VisitBreakStmt(

*S) {

assert(!BreakContinueStack.empty() &&

);

BreakContinueStack.back().BreakCount = addCounters(

BreakContinueStack.back().BreakCount,

().getCounter());

assert(!BreakContinueStack.empty() &&

);

BreakContinueStack.back().ContinueCount = addCounters(

BreakContinueStack.back().ContinueCount,

().getCounter());

VisitCallExpr(

*

) {

terminateRegion(

);

VisitWhileStmt(

*S) {

Counter ParentCount =

().getCounter();

? getRegionCounter(S->getBody())

: getRegionCounter(S);

BreakContinueStack.push_back(BreakContinue());

extendRegion(S->getBody());

Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());

BreakContinue BC = BreakContinueStack.pop_back_val();

BodyHasTerminateStmt = HasTerminateStmt;

HasTerminateStmt =

;

? getRegionCounter(S->getCond())

: addCounters(ParentCount, BackedgeCount, BC.ContinueCount);

BranchCount = getBranchCounterPair(S, CondCount, getRegionCounter(S));

assert(BranchCount.Executed.isZero() || BranchCount.Executed == BodyCount ||

propagateCounts(CondCount, S->getCond());

adjustForOutOfOrderTraversal(getEnd(S));

Gap = findGapAreaBetween(S->getRParenLoc(), getStart(S->getBody()));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);

(BC.BreakCount.isZero() && BranchCount.Skipped == getRegionCounter(S)));

Counter OutCount = addCounters(BC.BreakCount, BranchCount.Skipped);

(!IsCounterEqual(OutCount, ParentCount)) {

pushRegion(OutCount);

GapRegionCounter = OutCount;

(BodyHasTerminateStmt)

HasTerminateStmt =

;

createBranchRegion(S->getCond(), BodyCount, BranchCount.Skipped);

VisitDoStmt(

*S) {

Counter ParentCount =

().getCounter();

? getRegionCounter(S->getBody())

: getRegionCounter(S);

BreakContinueStack.push_back(BreakContinue());

extendRegion(S->getBody());

Counter BackedgeCount;

propagateCounts(BodyCount, S->getBody());

propagateCounts(addCounters(ParentCount, BodyCount), S->getBody());

BreakContinue BC = BreakContinueStack.pop_back_val();

BodyHasTerminateStmt = HasTerminateStmt;

HasTerminateStmt =

;

? getRegionCounter(S->getCond())

: addCounters(BackedgeCount, BC.ContinueCount);

BranchCount = getBranchCounterPair(S, CondCount, getRegionCounter(S));

assert(BranchCount.Executed.isZero() || BranchCount.Executed == BodyCount ||

propagateCounts(CondCount, S->getCond());

(BC.BreakCount.isZero() && BranchCount.Skipped == getRegionCounter(S)));

Counter OutCount = addCounters(BC.BreakCount, BranchCount.Skipped);

(!IsCounterEqual(OutCount, ParentCount)) {

pushRegion(OutCount);

GapRegionCounter = OutCount;

createBranchRegion(S->getCond(), BodyCount, BranchCount.Skipped);

(BodyHasTerminateStmt)

HasTerminateStmt =

;

VisitForStmt(

*S) {

Visit(S->getInit());

Counter ParentCount =

().getCounter();

? getRegionCounter(S->getBody())

: getRegionCounter(S);

BreakContinueStack.emplace_back();

BreakContinueStack.emplace_back();

extendRegion(S->getBody());

Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());

BreakContinue BodyBC = BreakContinueStack.pop_back_val();

BodyHasTerminateStmt = HasTerminateStmt;

HasTerminateStmt =

;

BreakContinue IncrementBC;

(

*Inc = S->getInc()) {

IncCount = getRegionCounter(S->getInc());

IncCount = addCounters(BackedgeCount, BodyBC.ContinueCount);

propagateCounts(IncCount, Inc);

IncrementBC = BreakContinueStack.pop_back_val();

? getRegionCounter(S->getCond())

addCounters(ParentCount, BackedgeCount, BodyBC.ContinueCount),

IncrementBC.ContinueCount);

BranchCount = getBranchCounterPair(S, CondCount, getRegionCounter(S));

assert(BranchCount.Executed.isZero() || BranchCount.Executed == BodyCount ||

(

*Cond = S->getCond()) {

propagateCounts(CondCount, Cond);

adjustForOutOfOrderTraversal(getEnd(S));

Gap = findGapAreaBetween(S->getRParenLoc(), getStart(S->getBody()));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);

(BodyBC.BreakCount.isZero() && IncrementBC.BreakCount.isZero()));

Counter OutCount = addCounters(BodyBC.BreakCount, IncrementBC.BreakCount,

BranchCount.Skipped);

(!IsCounterEqual(OutCount, ParentCount)) {

pushRegion(OutCount);

GapRegionCounter = OutCount;

(BodyHasTerminateStmt)

HasTerminateStmt =

;

createBranchRegion(S->getCond(), BodyCount, BranchCount.Skipped);

Visit(S->getInit());

Visit(S->getLoopVarStmt());

Visit(S->getRangeStmt());

Counter ParentCount =

().getCounter();

? getRegionCounter(S->getBody())

: getRegionCounter(S);

BreakContinueStack.push_back(BreakContinue());

extendRegion(S->getBody());

Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());

BreakContinue BC = BreakContinueStack.pop_back_val();

BodyHasTerminateStmt = HasTerminateStmt;

HasTerminateStmt =

;

Gap = findGapAreaBetween(S->getRParenLoc(), getStart(S->getBody()));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);

addCounters(ParentCount, BackedgeCount, BC.ContinueCount);

BranchCount = getBranchCounterPair(S, LoopCount, getRegionCounter(S));

assert(BranchCount.Executed.isZero() || BranchCount.Executed == BodyCount ||

(BC.BreakCount.isZero() && BranchCount.Skipped == getRegionCounter(S)));

Counter OutCount = addCounters(BC.BreakCount, BranchCount.Skipped);

(!IsCounterEqual(OutCount, ParentCount)) {

pushRegion(OutCount);

GapRegionCounter = OutCount;

(BodyHasTerminateStmt)

HasTerminateStmt =

;

createBranchRegion(S->getCond(), BodyCount, BranchCount.Skipped);

Visit(S->getElement());

Counter ParentCount =

().getCounter();

Counter BodyCount = getRegionCounter(S);

BreakContinueStack.push_back(BreakContinue());

extendRegion(S->getBody());

Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());

BreakContinue BC = BreakContinueStack.pop_back_val();

Gap = findGapAreaBetween(S->getRParenLoc(), getStart(S->getBody()));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);

addCounters(ParentCount, BackedgeCount, BC.ContinueCount);

BranchCount = getBranchCounterPair(S, LoopCount);

assert(BranchCount.Executed.isZero() || BranchCount.Executed == BodyCount);

Counter OutCount = addCounters(BC.BreakCount, BranchCount.Skipped);

(!IsCounterEqual(OutCount, ParentCount)) {

pushRegion(OutCount);

GapRegionCounter = OutCount;

Visit(S->getInit());

Visit(S->getCond());

BreakContinueStack.push_back(BreakContinue());

*Body = S->getBody();

(

*CS = dyn_cast<CompoundStmt>(Body)) {

(!CS->body_empty()) {

Index = pushRegion(Counter::getZero(), getStart(CS));

(

i = RegionStack.size(); i != Index; --i) {

(!RegionStack[i - 1].hasEndLoc())

RegionStack[i - 1].setEndLoc(getEnd(CS->body_back()));

propagateCounts(Counter::getZero(), Body);

BreakContinue BC = BreakContinueStack.pop_back_val();

BreakContinueStack.back().ContinueCount = addCounters(

BreakContinueStack.back().ContinueCount, BC.ContinueCount);

Counter ParentCount =

().getCounter();

Counter ExitCount = getRegionCounter(S);

pushRegion(ExitCount);

GapRegionCounter = ExitCount;

MostRecentLocation = getStart(S);

handleFileExit(ExitLoc);

Counter CaseCountSum;

HasDefaultCase =

;

*Case = S->getSwitchCaseList();

HasDefaultCase = HasDefaultCase || isa<DefaultStmt>(Case);

CaseCount = createSwitchCaseRegion(Case, ParentCount);

CaseCountSum = addCounters(CaseCountSum, CaseCount,

);

(!HasDefaultCase) {

addCounters(CaseCountSum, Counter::getZero(),

);

Counter SwitchFalse = subtractCounters(ParentCount, CaseCountSum);

createBranchRegion(S->getCond(), CaseCountSum, SwitchFalse);

? getRegionCounter(S)

: addCounters(

.getCounter(), getRegionCounter(S));

(

.hasStartLoc() &&

.getBeginLoc() == getStart(S))

.setCounter(Count);

pushRegion(Count, getStart(S));

GapRegionCounter = Count;

(

*CS = dyn_cast<CaseStmt>(S)) {

Visit(CS->getLHS());

(

*RHS = CS->getRHS())

Visit(S->getSubStmt());

coverIfConsteval(

*S) {

assert(S->isConsteval());

*Then = S->getThen();

*Else = S->getElse();

Counter ParentCount =

().getCounter();

(S->isNegatedConsteval()) {

markSkipped(S->getIfLoc(), getStart(Then));

propagateCounts(ParentCount, Then);

markSkipped(getEnd(Then), getEnd(Else));

assert(S->isNonNegatedConsteval());

markSkipped(S->getIfLoc(), Else ? getStart(Else) : getEnd(Then));

propagateCounts(ParentCount, Else);

coverIfConstexpr(

*S) {

assert(S->isConstexpr());

Counter ParentCount =

().getCounter();

(

*

= S->getInit()) {

start = getStart(

);

end = getEnd(

);

(start.isValid() && end.isValid()) {

markSkipped(startOfSkipped, start);

propagateCounts(ParentCount,

);

startOfSkipped = getEnd(

);

*Then = S->getThen();

*Else = S->getElse();

markSkipped(startOfSkipped, getStart(Then));

propagateCounts(ParentCount, Then);

markSkipped(getEnd(Then), getEnd(Else));

markSkipped(startOfSkipped, Else ? getStart(Else) : getEnd(Then));

propagateCounts(ParentCount, Else);

VisitIfStmt(

*S) {

(S->isConsteval())

coverIfConsteval(S);

(S->isConstexpr())

coverIfConstexpr(S);

Visit(S->getInit());

extendRegion(S->getCond());

Counter ParentCount =

().getCounter();

[ThenCount, ElseCount] =

? BranchCounterPair{getRegionCounter(S->getThen()),

(S->getElse() ? getRegionCounter(S->getElse())

: Counter::getZero())}

: getBranchCounterPair(S, ParentCount));

propagateCounts(ParentCount, S->getCond());

std::optional<SourceRange> Gap =

findGapAreaBetween(S->getRParenLoc(), getStart(S->getThen()));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ThenCount);

extendRegion(S->getThen());

Counter OutCount = propagateCounts(ThenCount, S->getThen());

(

*Else = S->getElse()) {

ThenHasTerminateStmt = HasTerminateStmt;

HasTerminateStmt =

;

std::optional<SourceRange> Gap =

findGapAreaBetween(getEnd(S->getThen()), getStart(Else));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ElseCount);

Counter ElseOutCount = propagateCounts(ElseCount, Else);

OutCount = addCounters(OutCount, ElseOutCount);

(ThenHasTerminateStmt)

HasTerminateStmt =

;

OutCount = addCounters(OutCount, ElseCount);

OutCount = getRegionCounter(S);

(!IsCounterEqual(OutCount, ParentCount)) {

pushRegion(OutCount);

GapRegionCounter = OutCount;

createBranchRegion(S->getCond(), ThenCount, ElseCount);

extendRegion(S->getTryBlock());

Counter ParentCount =

().getCounter();

propagateCounts(ParentCount, S->getTryBlock());

(

I = 0,

= S->getNumHandlers(); I <

; ++I)

Visit(S->getHandler(I));

Counter ExitCount = getRegionCounter(S);

pushRegion(ExitCount);

propagateCounts(getRegionCounter(S), S->getHandlerBlock());

Counter ParentCount =

().getCounter();

[TrueCount, FalseCount] =

? BranchCounterPair{getRegionCounter(

->getTrueExpr()),

getRegionCounter(

->getFalseExpr())}

: getBranchCounterPair(

, ParentCount));

(

*BCO = dyn_cast<BinaryConditionalOperator>(

)) {

propagateCounts(ParentCount, BCO->getCommon());

OutCount = TrueCount;

propagateCounts(ParentCount,

->getCond());

findGapAreaBetween(

->getQuestionLoc(), getStart(

->getTrueExpr()));

fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), TrueCount);

extendRegion(

->getTrueExpr());

OutCount = propagateCounts(TrueCount,

->getTrueExpr());

extendRegion(

->getFalseExpr());

Counter FalseOutCount = propagateCounts(FalseCount,

->getFalseExpr());

OutCount = getRegionCounter(

);

OutCount = addCounters(OutCount, FalseOutCount);

(!IsCounterEqual(OutCount, ParentCount)) {

pushRegion(OutCount);

GapRegionCounter = OutCount;

createBranchRegion(

->getCond(), TrueCount, FalseCount);

createOrCancelDecision(

*

,

Since) {

NumConds = MCDCBuilder.getTotalConditionsAndReset(

);

(

&SR :

(SourceRegions).slice(Since)) {

(SR.isMCDCBranch()) {

[

, Conds] = SR.getMCDCBranchParams();

CondIDs[

] = Conds;

mcdc::TVIdxBuilder Builder(CondIDs);

NumTVs = Builder.NumTestVectors;

assert(MaxTVs < mcdc::TVIdxBuilder::HardMaxTVs);

(NumTVs > MaxTVs) {

cancelDecision(

, Since, NumTVs, MaxTVs);

std::move(Builder.Indices),

DecisionParams = mcdc::DecisionParameters{

createDecisionRegion(

, DecisionParams);

cancelDecision(

*

,

Since,

NumTVs,

);

assert(!SR.isMCDCDecision() &&

);

(SR.isMCDCBranch())

SR.resetMCDCParams();

.isInSystemHeader(

.getSpellingLoc(

->getOperatorLoc())) &&

(isExprInSystemHeader(

)) {

LeafExprSet.insert(

);

IsRootNode = MCDCBuilder.isIdle();

SourceRegionsSince = SourceRegions.size();

MCDCBuilder.pushAndAssignIDs(

);

extendRegion(

->getLHS());

propagateCounts(

().getCounter(),

->getLHS());

handleFileExit(getEnd(

->getLHS()));

DecisionLHS = MCDCBuilder.pop();

extendRegion(

->getRHS());

propagateCounts(getRegionCounter(

),

->getRHS());

DecisionRHS = MCDCBuilder.back();

Counter ParentCnt =

().getCounter();

[RHSExecCnt, LHSExitCnt] = getBranchCounterPair(

, ParentCnt);

[RHSTrueCnt, RHSExitCnt] =

getBranchCounterPair(

->getRHS(), RHSExecCnt);

createBranchRegion(

->getLHS(), RHSExecCnt, LHSExitCnt, DecisionLHS);

createBranchRegion(

->getRHS(), RHSTrueCnt, RHSExitCnt, DecisionRHS);

createOrCancelDecision(

, SourceRegionsSince);

shouldVisitRHS(

*LHS) {

LHSIsTrue =

;

LHSIsConst =

;

!LHSIsConst || (LHSIsConst && !LHSIsTrue);

(isExprInSystemHeader(

)) {

LeafExprSet.insert(

);

IsRootNode = MCDCBuilder.isIdle();

SourceRegionsSince = SourceRegions.size();

MCDCBuilder.pushAndAssignIDs(

);

extendRegion(

->getLHS());

Counter OutCount = propagateCounts(

().getCounter(),

->getLHS());

handleFileExit(getEnd(

->getLHS()));

DecisionLHS = MCDCBuilder.pop();

extendRegion(

->getRHS());

propagateCounts(getRegionCounter(

),

->getRHS());

DecisionRHS = MCDCBuilder.back();

Counter ParentCnt =

().getCounter();

[RHSExecCnt, LHSExitCnt] = getBranchCounterPair(

, ParentCnt);

[RHSFalseCnt, RHSExitCnt] =

getBranchCounterPair(

->getRHS(), RHSExecCnt);

(!shouldVisitRHS(

->getLHS())) {

GapRegionCounter = OutCount;

createBranchRegion(

->getLHS(), LHSExitCnt, RHSExecCnt, DecisionLHS);

createBranchRegion(

->getRHS(), RHSExitCnt, RHSFalseCnt, DecisionRHS);

createOrCancelDecision(

, SourceRegionsSince);

VisitLambdaExpr(

*LE) {

(llvm::raw_ostream &OS, StringRef FunctionName,

OS << FunctionName <<

;

CounterMappingContext Ctx(Expressions);

(

&R : Regions) {

CounterMappingRegion::CodeRegion:

CounterMappingRegion::ExpansionRegion:

OS <<

;

CounterMappingRegion::SkippedRegion:

CounterMappingRegion::GapRegion:

CounterMappingRegion::BranchRegion:

CounterMappingRegion::MCDCBranchRegion:

CounterMappingRegion::MCDCDecisionRegion:

OS <<

<< R.FileID <<

<< R.LineStart <<

<< R.ColumnStart

<<

<< R.LineEnd <<

<< R.ColumnEnd <<

;

(

*DecisionParams =

std::get_if<mcdc::DecisionParameters>(&R.MCDCParams)) {

OS <<

<< DecisionParams->BitmapIdx;

OS <<

<< DecisionParams->NumConditions;

Ctx.dump(R.Count, OS);

Ctx.dump(R.FalseCount, OS);

(

*BranchParams =

std::get_if<mcdc::BranchParameters>(&R.MCDCParams)) {

OS <<

<< BranchParams->ID + 1 <<

<< BranchParams->Conds[

] + 1;

OS <<

<< BranchParams->Conds[

] + 1 <<

;

(R.Kind == CounterMappingRegion::ExpansionRegion)

OS <<

<< R.ExpandedFileID <<

;

: CGM(CGM), SourceInfo(SourceInfo) {}

std::string CoverageMappingModuleGen::getCurrentDirname() {

llvm::sys::fs::current_path(CWD);

CWD.str().str();

std::string CoverageMappingModuleGen::normalizeFilename(StringRef

) {

llvm::sys::path::remove_dots(

,

);

(

&[From, To] :

(llvm::sys::path::replace_path_prefix(

, From, To))

.str().str();

llvm::InstrProfSectKind SK) {

llvm::getInstrProfSectionName(

CoverageMappingModuleGen::emitFunctionMappingRecord(

FunctionInfo &Info, uint64_t FilenamesRef) {

std::string FuncRecordName =

+ llvm::utohexstr(Info.NameHash);

FuncRecordName +=

;

NameHash = Info.NameHash;

FuncHash = Info.FuncHash;

std::string &CoverageMapping = Info.CoverageMapping;

llvm::Type *FunctionRecordTypes[] = {

*FunctionRecordTy =

llvm::StructType::get(Ctx,

(FunctionRecordTypes),

llvm::Constant *FunctionRecordVals[] = {

*FuncRecordConstant =

llvm::ConstantStruct::get(FunctionRecordTy,

(FunctionRecordVals));

*FuncRecord =

llvm::GlobalVariable(

CGM.

(), FunctionRecordTy,

,

llvm::GlobalValue::LinkOnceODRLinkage, FuncRecordConstant,

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

FuncRecord->setAlignment(llvm::Align(8));

FuncRecord->setComdat(CGM.

().getOrInsertComdat(FuncRecordName));

llvm::GlobalVariable *NamePtr, StringRef NameValue, uint64_t FuncHash,

std::string &CoverageMapping,

IsUsed) {

uint64_t NameHash = llvm::IndexedInstrProf::ComputeHash(NameValue);

FunctionRecords.push_back({NameHash, FuncHash, CoverageMapping, IsUsed});

FunctionNames.push_back(NamePtr);

std::vector<StringRef> Filenames;

std::vector<CounterExpression> Expressions;

std::vector<CounterMappingRegion> Regions;

FilenameStrs.resize(FileEntries.size() + 1);

FilenameStrs[0] = normalizeFilename(getCurrentDirname());

(

&Entry : FileEntries) {

I = Entry.second;

FilenameStrs[I] = normalizeFilename(Entry.first.getName());

RawCoverageMappingReader Reader(CoverageMapping, FilenameRefs, Filenames,

Expressions, Regions);

(llvm::outs(), NameValue, Expressions, Regions);

(FunctionRecords.empty())

*Int32Ty = llvm::Type::getInt32Ty(Ctx);

FilenameStrs.resize(FileEntries.size() + 1);

FilenameStrs[0] = normalizeFilename(getCurrentDirname());

(

&Entry : FileEntries) {

I = Entry.second;

FilenameStrs[I] = normalizeFilename(Entry.first.getName());

std::string Filenames;

llvm::raw_string_ostream OS(Filenames);

CoverageFilenamesSectionWriter(FilenameStrs).write(OS);

*FilenamesVal =

llvm::ConstantDataArray::getString(Ctx, Filenames,

);

int64_t FilenamesRef = llvm::IndexedInstrProf::ComputeHash(Filenames);

(

FunctionInfo &Info : FunctionRecords)

emitFunctionMappingRecord(Info, FilenamesRef);

NRecords = 0;

FilenamesSize = Filenames.size();

CoverageMappingSize = 0;

llvm::Type *CovDataHeaderTypes[] = {

CovDataHeaderTy =

llvm::StructType::get(Ctx,

(CovDataHeaderTypes));

llvm::Constant *CovDataHeaderVals[] = {

CovDataHeaderVal =

llvm::ConstantStruct::get(CovDataHeaderTy,

(CovDataHeaderVals));

llvm::Type *CovDataTypes[] = {CovDataHeaderTy, FilenamesVal->getType()};

CovDataTy = llvm::StructType::get(Ctx,

(CovDataTypes));

llvm::Constant *TUDataVals[] = {CovDataHeaderVal, FilenamesVal};

CovDataVal = llvm::ConstantStruct::get(CovDataTy,

(TUDataVals));

CovData =

llvm::GlobalVariable(

CGM.

(), CovDataTy,

, llvm::GlobalValue::PrivateLinkage,

CovDataVal, llvm::getCoverageMappingVarName());

CovData->setAlignment(llvm::Align(8));

(!FunctionNames.empty()) {

NamesArrTy = llvm::ArrayType::get(llvm::PointerType::getUnqual(Ctx),

FunctionNames.size());

NamesArrVal = llvm::ConstantArray::get(NamesArrTy, FunctionNames);

llvm::GlobalVariable(CGM.

(), NamesArrTy,

,

llvm::GlobalValue::InternalLinkage, NamesArrVal,

llvm::getCoverageUnusedNamesVarName());

FileEntries.try_emplace(

, FileEntries.size() + 1).first->second;

llvm::raw_ostream &OS) {

assert(CounterMap && MCDCState);

CounterCoverageMappingBuilder Walker(CVM, *CounterMap, *MCDCState,

,

Walker.VisitDecl(

);

llvm::raw_ostream &OS) {

EmptyCoverageMappingBuilder Walker(CVM,

, LangOpts);

Walker.VisitDecl(

);

Defines the Diagnostic-related interfaces.

static const MemRegion * getRegion(const CallEvent &Call, const MutexDescriptor &Descriptor, bool IsLock)

static std::string getInstrProfSection(const CodeGenModule &CGM, llvm::InstrProfSectKind SK)

static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)

static llvm::cl::opt< bool > EmptyLineCommentCoverage("emptyline-comment-coverage", llvm::cl::desc("Emit emptylines and comment lines as skipped regions (only " "disable it on test)"), llvm::cl::init(true), llvm::cl::Hidden)

llvm::DenseSet< const void * > Visited

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.

const TargetInfo & getTargetInfo() const

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

Represents a loop initializing the elements of an array.

OpaqueValueExpr * getCommonExpr() const

Get the common subexpression shared by all initializations (the source array).

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

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.

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

llvm::SmallVector< std::pair< std::string, std::string >, 0 > CoveragePrefixMap

Prefix replacement map for source-based code coverage to remap source file paths in coverage mapping.

std::string CoverageCompilationDir

The string to embed in coverage mapping as the current working directory.

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

llvm::Module & getModule() const

DiagnosticsEngine & getDiags() const

void addUsedGlobal(llvm::GlobalValue *GV)

Add a global to a list to be added to the llvm.used metadata.

ASTContext & getContext() const

bool supportsCOMDAT() const

const CodeGenOptions & getCodeGenOpts() const

llvm::LLVMContext & getLLVMContext()

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

Emit the coverage mapping data for an unused function.

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

Emit the coverage mapping data which maps the regions of code to counters that will be used to find t...

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

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.

CoverageSourceInfo & getSourceInfo() const

static CoverageSourceInfo * setUpCoverageCallbacks(Preprocessor &PP)

CoverageMappingModuleGen(CodeGenModule &CGM, CoverageSourceInfo &SourceInfo)

void emit()

Emit the coverage mapping data for a translation unit.

CodeGenModule & getCodeGenModule()

Return an interface into CodeGenModule.

unsigned getFileID(FileEntryRef File)

Return the coverage mapping translation unit file id for the given file.

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

ContinueStmt - This represents a continue.

Represents a 'co_return' statement in the C++ Coroutines TS.

Represents the body of a coroutine.

Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...

Stores additional source code information like skipped ranges which is required by the coverage mappi...

void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override

Hook called when a source range is skipped.

void updateNextTokLoc(SourceLocation Loc)

void AddSkippedRange(SourceRange Range, SkippedRange::Kind RangeKind)

std::vector< SkippedRange > & getSkippedRanges()

bool HandleComment(Preprocessor &PP, SourceRange Range) override

SourceLocation PrevTokLoc

void HandleEmptyline(SourceRange Range) override

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

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...

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

This represents one expression.

bool isValueDependent() const

Determines whether the value of this expression depends on.

bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const

EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

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

GotoStmt - This represents a direct goto.

IfStmt - This represents an if/then/else.

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...

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)

MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...

Represents Objective-C's collection statement.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

Expr * getSourceExpr() const

The source expression of an opaque value expression is the expression which originally generated the ...

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

void addCommentHandler(CommentHandler *Handler)

Add the specified comment handler to the preprocessor.

void addPPCallbacks(std::unique_ptr< PPCallbacks > C)

SourceManager & getSourceManager() const

void setPreprocessToken(bool Preprocess)

void setTokenWatcher(llvm::unique_function< void(const clang::Token &)> F)

Register a function that would be called on each token in the final expanded token stream.

void setEmptylineHandler(EmptylineHandler *Handler)

Set empty line handler.

PseudoObjectExpr - An expression which accesses a pseudo-object l-value.

Expr * getSyntacticForm()

Return the syntactic form of this expression, i.e.

A (possibly-)qualified type.

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

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

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

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded,...

SourceLocation getExpansionLocStart() const

bool isFunctionMacroExpansion() const

SourceLocation getExpansionLocEnd() const

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getColonLoc() const

const SwitchCase * getNextSwitchCase() const

SwitchStmt - This represents a 'switch' stmt.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

Token - This structure provides full information about a lexed token.

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

tok::TokenKind getKind() const

WhileStmt - This represents a 'while' stmt.

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

FunctionType::ExtInfo getFunctionExtInfo(const Type &t)

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 *, Branch > BranchByStmt

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

EvalResult is a struct with detailed info about an evaluated expression.

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