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

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

clang: lib/StaticAnalyzer/Core/BugReporter.cpp Source File

;

);

);

(NumTimesReportPassesZ3,

);

(NumTimesReportRefuted,

);

);

BugReporterContext::anchor() {}

std::pair<PathDiagnosticCallPiece *, const ExplodedNode *>;

VisitorsDiagnosticsTy =

llvm::DenseMap<const ExplodedNode *, std::vector<PathDiagnosticPieceRef>>;

LocationContextMap =

llvm::DenseMap<const PathPieces *, const LocationContext *>;

PathDiagnosticConstruct {

LocationContextMap LCM;

CallWithEntryStack CallStack;

std::unique_ptr<PathDiagnostic> PD;

*AnalysisEntryPoint);

assert(CurrentNode &&

);

LCM.find(&PD->getActivePath())->getSecond();

*getCurrentNode()

{

CurrentNode; }

ascendToPrevNode() {

(CurrentNode);

getCurrLocationContext()->getParentMap();

*getParent(

*S)

{

getParentMap().getParent(S);

assert(LCM.count(

) &&

);

LCM.find(

)->getSecond();

&getActivePath() {

PD->getActivePath(); }

&getMutablePieces() {

PD->getMutablePieces(); }

shouldAddControlNotes()

{

shouldGenerateDiagnostics()

{

supportsLogicalOpControlFlow()

{

std::unique_ptr<const ExplodedGraph> BugPath;

std::unique_ptr<const VisitorsDiagnosticsTy> VisitorsDiagnostics;

std::optional<PathDiagnosticBuilder>

PathDiagnosticBuilder(

std::unique_ptr<VisitorsDiagnosticsTy> VisitorsDiagnostics);

std::unique_ptr<PathDiagnostic>

CallWithEntryStack &CallStack)

;

generatePathDiagnosticsForNode(PathDiagnosticConstruct &

,

generateMinimalDiagForBlockEdge(PathDiagnosticConstruct &

,

generateDiagForGotoOP(

PathDiagnosticConstruct &

,

*S,

generateDiagForSwitchOP(

PathDiagnosticConstruct &

,

*Dst,

generateDiagForBinaryOP(

PathDiagnosticConstruct &

,

*

,

ExecutionContinues(

PathDiagnosticConstruct &

)

;

ExecutionContinues(llvm::raw_string_ostream &os,

PathDiagnosticConstruct &

)

;

*CE = dyn_cast_or_null<CallExpr>(CallSite);

(

[Idx, ArgExpr] : llvm::enumerate(CE->arguments())) {

(ArgExpr->getType()->isVoidPointerType())

(llvm::Twine(Msg) +

+ std::to_string(ArgIndex) +

llvm::getOrdinalSuffix(ArgIndex) +

).str();

(

->getTag() == tagPreferred && Y->

() == tagLesser)

(Y->

() == tagPreferred &&

->getTag() == tagLesser)

N = path.size();

(

i = 0; i < N; ++i) {

piece = std::move(path.front());

(piece->getKind()) {

(

*nextEvent =

dyn_cast<PathDiagnosticEventPiece>(path.front().get())) {

*

= cast<PathDiagnosticEventPiece>(piece.get());

(

*pieceToKeep =

piece = std::move(pieceToKeep == event ? piece : path.front());

path.push_back(std::move(piece));

IsInteresting =

) {

containsSomethingInteresting = IsInteresting;

N = pieces.size();

(

i = 0 ; i < N ; ++i) {

piece = std::move(pieces.front());

(piece->getKind()) {

&call = cast<PathDiagnosticCallPiece>(*piece);

containsSomethingInteresting =

;

&macro = cast<PathDiagnosticMacroPiece>(*piece);

containsSomethingInteresting =

;

&

= cast<PathDiagnosticEventPiece>(*piece);

containsSomethingInteresting |= !

.isPrunable();

pieces.push_back(std::move(piece));

containsSomethingInteresting;

(

i = 0; i <

.size(); ++i) {

Piece = std::move(

.front());

(!isa<PathDiagnosticPopUpPiece>(*Piece))

.push_back(std::move(Piece));

(

&I : Pieces) {

*

= dyn_cast<PathDiagnosticCallPiece>(I.get());

(LastCallLocation) {

(CallerIsImplicit || !

->callEnter.asLocation().isValid())

->callEnter = *LastCallLocation;

(CallerIsImplicit || !

->callReturn.asLocation().isValid())

->callReturn = *LastCallLocation;

(

->callEnterWithin.asLocation().isValid() &&

ThisCallLocation = &

->callEnterWithin;

ThisCallLocation = &

->callEnter;

assert(ThisCallLocation &&

);

(PathPieces::iterator I = Pieces.begin(),

= Pieces.end(); I !=

;) {

(

*

= dyn_cast<PathDiagnosticCallPiece>(I->get()))

(

*M = dyn_cast<PathDiagnosticMacroPiece>(I->get()))

(

*

= dyn_cast<PathDiagnosticControlFlowPiece>(I->get())) {

*Start =

->getStartLocation().asStmt();

*End =

->getEndLocation().asStmt();

(isa_and_nonnull<CXXDefaultInitExpr>(Start)) {

}

(isa_and_nonnull<CXXDefaultInitExpr>(End)) {

PathPieces::iterator Next = std::next(I);

dyn_cast<PathDiagnosticControlFlowPiece>(Next->get())) {

NextCF->setStartLocation(

->getStartLocation());

(PathPieces::iterator I = Pieces.begin(),

= Pieces.end(); I !=

;) {

(

*

= dyn_cast<PathDiagnosticCallPiece>(I->get()))

(

*M = dyn_cast<PathDiagnosticMacroPiece>(I->get()))

(!(*I)->getLocation().isValid() ||

!(*I)->getLocation().asLocation().isValid()) {

PathDiagnosticConstruct &

)

{

(

*S =

.getCurrentNode()->getNextStmtForDiagnostics())

.getCurrLocationContext());

llvm::raw_string_ostream &os,

PathDiagnosticConstruct &

)

{

(os.str().empty())

os <<

<< getSourceManager().getExpansionLineNumber(

.asLocation())

os <<

;

*

=

.getCurrLocationContext()->getDecl();

(isa<ObjCMethodDecl>(

))

(isa<FunctionDecl>(

))

assert(isa<BlockDecl>(

));

os <<

;

(

->getStmtClass()) {

Stmt::ForStmtClass:

Stmt::DoStmtClass:

Stmt::WhileStmtClass:

Stmt::ObjCForCollectionStmtClass:

Stmt::CXXForRangeStmtClass:

allowNestedContexts =

) {

(

->getStmtClass()) {

Stmt::BinaryOperatorClass: {

*B = cast<BinaryOperator>(

);

(B->isLogicalOp())

Stmt::CompoundStmtClass:

Stmt::StmtExprClass:

Stmt::ChooseExprClass:

(allowNestedContexts || cast<ChooseExpr>(

)->getCond() == S)

Stmt::BinaryConditionalOperatorClass:

Stmt::ConditionalOperatorClass:

(allowNestedContexts ||

cast<AbstractConditionalOperator>(

)->getCond() == S)

Stmt::CXXForRangeStmtClass:

(cast<CXXForRangeStmt>(

)->getBody() == S)

Stmt::DoStmtClass:

Stmt::ForStmtClass:

(cast<ForStmt>(

)->getBody() == S)

Stmt::IfStmtClass:

(cast<IfStmt>(

)->getCond() != S)

Stmt::ObjCForCollectionStmtClass:

(cast<ObjCForCollectionStmt>(

)->getBody() == S)

Stmt::WhileStmtClass:

(cast<WhileStmt>(

)->getCond() != S)

assert(S &&

);

PathDiagnosticBuilder::updateStackPiecesWithMessage(

(R->hasCallStackHint(

))

(

&I : CallStack) {

std::string stackMsg = R->getCallStackMessage(

, N);

PathDiagnosticConstruct &

,

*Dst,

llvm::raw_string_ostream os(sbuf);

(S->getStmtClass()) {

os <<

<< End.asLocation().getExpansionLineNumber();

Stmt::DefaultStmtClass:

os <<

<< End.asLocation().getExpansionLineNumber();

Stmt::CaseStmtClass: {

os <<

;

*Case = cast<CaseStmt>(S);

GetRawInt =

;

(

*DR = dyn_cast<DeclRefExpr>(LHS)) {

*

= dyn_cast<EnumConstantDecl>(DR->getDecl());

os <<

<< End.asLocation().getExpansionLineNumber();

os <<

;

End = ExecutionContinues(os,

);

std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, sbuf);

PathDiagnosticConstruct &

,

*S,

llvm::raw_string_ostream os(sbuf);

os <<

<< End.asLocation().getExpansionLineNumber();

std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, sbuf);

PathDiagnosticConstruct &

,

*

,

*Src,

*B = cast<BinaryOperator>(

);

llvm::raw_string_ostream os(sbuf);

os <<

;

(B->getOpcode() == BO_LAnd) {

End = ExecutionContinues(

);

assert(B->getOpcode() == BO_LOr);

End = ExecutionContinues(

);

std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, sbuf);

PathDiagnosticBuilder::generateMinimalDiagForBlockEdge(

PathDiagnosticConstruct &

,

BE)

{

(

->getStmtClass()) {

Stmt::GotoStmtClass:

Stmt::IndirectGotoStmtClass: {

(

*S =

.getCurrentNode()->getNextStmtForDiagnostics())

.getActivePath().push_front(generateDiagForGotoOP(

, S, Start));

Stmt::SwitchStmtClass: {

.getActivePath().push_front(generateDiagForSwitchOP(

, Dst, Start));

Stmt::BreakStmtClass:

Stmt::ContinueStmtClass: {

llvm::raw_string_ostream os(sbuf);

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, sbuf));

Stmt::BinaryConditionalOperatorClass:

Stmt::ConditionalOperatorClass: {

llvm::raw_string_ostream os(sbuf);

os <<

;

(

*S = End.asStmt())

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, sbuf));

Stmt::BinaryOperatorClass: {

(!

.supportsLogicalOpControlFlow())

.getActivePath().push_front(generateDiagForBinaryOP(

,

, Src, Dst));

Stmt::DoStmtClass:

llvm::raw_string_ostream os(sbuf);

os <<

;

(

*S = End.asStmt())

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, sbuf));

(

*S = End.asStmt())

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(

Start, End,

));

Stmt::WhileStmtClass:

Stmt::ForStmtClass:

llvm::raw_string_ostream os(sbuf);

os <<

;

(

*S = End.asStmt())

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, sbuf));

(

*S = End.asStmt())

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(

Start, End,

));

Stmt::IfStmtClass: {

(

*S = End.asStmt())

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(

Start, End,

));

.getActivePath().push_front(

std::make_shared<PathDiagnosticControlFlowPiece>(

Start, End,

));

Stmt::ForStmtClass:

Stmt::WhileStmtClass:

Stmt::ObjCForCollectionStmtClass:

Stmt::CXXForRangeStmtClass:

*S = SP->getStmt();

*LoopBody =

;

Stmt::CXXForRangeStmtClass: {

*FR = cast<CXXForRangeStmt>(Term);

LoopBody = FR->getBody();

Stmt::ForStmtClass: {

*FS = cast<ForStmt>(Term);

LoopBody = FS->getBody();

Stmt::ObjCForCollectionStmtClass: {

*FC = cast<ObjCForCollectionStmt>(Term);

LoopBody = FC->getBody();

Stmt::WhileStmtClass:

LoopBody = cast<WhileStmt>(Term)->getBody();

std::make_shared<PathDiagnosticControlFlowPiece>(NewLoc, PrevLoc));

(

*FS = dyn_cast_or_null<ObjCForCollectionStmt>(S))

FS->getElement();

;

;

std::unique_ptr<FilesToLineNumsMap>

PathDiagnosticBuilder::generatePathDiagnosticsForNode(

(

.shouldAddPathEdges()) {

VisitedEntireCall =

.PD->isWithinCall();

.PD->popActivePath();

(VisitedEntireCall) {

= cast<PathDiagnosticCallPiece>(

.getActivePath().front().get());

*Caller = CE->getLocationContext()->getDecl();

assert(

.getActivePath().size() == 1 &&

.getActivePath().front().get() ==

);

assert(

.isInLocCtxMap(&

.getActivePath()) &&

);

.updateLocCtxMap(&

.getActivePath(),

.getCurrLocationContext());

assert(!

.isInLocCtxMap(&

->path) &&

);

.updateLocCtxMap(&

->path, CE->getCalleeContext());

->setCallee(*CE,

);

PrevLoc =

->getLocation();

(!

.CallStack.empty()) {

assert(

.CallStack.back().first ==

);

.CallStack.pop_back();

assert(

.getCurrLocationContext() ==

.getLocationContextForActivePath() &&

);

(std::optional<CallExitEnd> CE =

.getAs<

>()) {

assert(!

.isInLocCtxMap(&

->path) &&

);

.updateLocCtxMap(&

->path, CE->getCalleeContext());

(

.shouldAddPathEdges()) {

*

=

.get();

.getActivePath().push_front(std::move(

));

.PD->pushActivePath(&

->path);

.CallStack.push_back(CallWithEntry(

,

.getCurrentNode()));

(

PS =

.getAs<

>()) {

(!

.shouldAddPathEdges())

(!isa<ObjCForCollectionStmt>(PS->getStmt())) {

}

(

BE =

.getAs<

>()) {

(

.shouldAddControlNotes()) {

generateMinimalDiagForBlockEdge(

, *BE);

(!

.shouldAddPathEdges()) {

*Body =

;

(

*FS = dyn_cast<ForStmt>(

))

Body = FS->getBody();

(

*WS = dyn_cast<WhileStmt>(

))

Body = WS->getBody();

(

*OFS = dyn_cast<ObjCForCollectionStmt>(

)) {

Body = OFS->getBody();

}

(

*FRS = dyn_cast<CXXForRangeStmt>(

)) {

Body = FRS->getBody();

p = std::make_shared<PathDiagnosticEventPiece>(

L,

);

p->setPrunable(

);

(!

.shouldAddControlNotes()) {

.getActivePath().push_front(std::move(p));

(

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

(!IsInLoopBody) {

(isa<ObjCForCollectionStmt>(Term)) {

}

(isa<CXXForRangeStmt>(Term)) {

.getCurrLocationContext());

PE = std::make_shared<PathDiagnosticEventPiece>(L, str);

PE->setPrunable(

);

(!

.shouldAddControlNotes()) {

.getActivePath().push_front(std::move(PE));

}

(isa<BreakStmt, ContinueStmt, GotoStmt>(Term)) {

std::unique_ptr<PathDiagnostic>

*AnalysisEntryPoint) {

std::make_unique<PathDiagnostic>(

AnalysisEntryPoint, std::make_unique<FilesToLineNumsMap>());

std::unique_ptr<PathDiagnostic>

*AnalysisEntryPoint) {

std::make_unique<PathDiagnostic>(

(isa<FullExpr, CXXBindTemporaryExpr, SubstNonTypeTemplateParmExpr>(S))

(S->getStmtClass()) {

Stmt::BinaryOperatorClass: {

*BO = cast<BinaryOperator>(S);

(!BO->isLogicalOp())

BO->getLHS() == Cond || BO->getRHS() == Cond;

Stmt::IfStmtClass:

cast<IfStmt>(S)->getCond() == Cond;

Stmt::ForStmtClass:

cast<ForStmt>(S)->getCond() == Cond;

Stmt::WhileStmtClass:

cast<WhileStmt>(S)->getCond() == Cond;

Stmt::DoStmtClass:

cast<DoStmt>(S)->getCond() == Cond;

Stmt::ChooseExprClass:

cast<ChooseExpr>(S)->getCond() == Cond;

Stmt::IndirectGotoStmtClass:

cast<IndirectGotoStmt>(S)->getTarget() == Cond;

Stmt::SwitchStmtClass:

cast<SwitchStmt>(S)->getCond() == Cond;

Stmt::BinaryConditionalOperatorClass:

cast<BinaryConditionalOperator>(S)->getCond() == Cond;

Stmt::ConditionalOperatorClass: {

*CO = cast<ConditionalOperator>(S);

CO->getCond() == Cond ||

CO->getLHS() == Cond ||

CO->getRHS() == Cond;

Stmt::ObjCForCollectionStmtClass:

cast<ObjCForCollectionStmt>(S)->getElement() == Cond;

Stmt::CXXForRangeStmtClass: {

*FRS = cast<CXXForRangeStmt>(S);

FRS->getCond() == Cond || FRS->getRangeInit() == Cond;

(

*FS = dyn_cast<ForStmt>(FL))

FS->getInc() == S || FS->getInit() == S;

(

*FRS = dyn_cast<CXXForRangeStmt>(FL))

FRS->getInc() == S || FRS->getRangeStmt() == S ||

FRS->getLoopVarStmt() || FRS->getRangeInit() == S;

PathPieces::iterator Prev = pieces.end();

(PathPieces::iterator I = pieces.begin(),

= Prev; I !=

;

*Piece = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());

*InnerStmt =

;

(NextSrcContext.

() && NextSrcContext.

() != InnerStmt) {

SrcContexts.push_back(NextSrcContext);

InnerStmt = NextSrcContext.

();

*Dst = Piece->getEndLocation().getStmtOrNull();

(!DstContext.

() || DstContext.

() == Dst)

(llvm::is_contained(SrcContexts, DstContext))

Piece->setStartLocation(DstContext);

*PrevPiece = dyn_cast<PathDiagnosticControlFlowPiece>(Prev->get());

(

*PrevSrc =

PrevPiece->getStartLocation().getStmtOrNull()) {

(PrevSrcParent ==

PrevPiece->setEndLocation(DstContext);

std::make_shared<PathDiagnosticControlFlowPiece>(SrcLoc, DstContext);

I = pieces.insert(I, std::move(

));

(PathPieces::iterator I = pieces.begin(),

= pieces.end(); I !=

; ++I) {

*PieceI = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());

*s1Start = PieceI->getStartLocation().getStmtOrNull();

*s1End = PieceI->getEndLocation().getStmtOrNull();

(!s1Start || !s1End)

PathPieces::iterator NextI = I; ++NextI;

*EV = dyn_cast<PathDiagnosticEventPiece>(NextI->get());

StringRef S = EV->getString();

PieceNextI = dyn_cast<PathDiagnosticControlFlowPiece>(NextI->get());

(!s2Start || !s2End || s1End != s2Start)

I = pieces.erase(I);

.getExpansionRange(

.getEnd()).getEnd());

(FID !=

.getFileID(ExpansionRange.

()))

std::nullopt;

std::optional<MemoryBufferRef> Buffer =

.getBufferOrNone(FID);

std::nullopt;

BeginOffset =

.getFileOffset(ExpansionRange.

());

EndOffset =

.getFileOffset(ExpansionRange.

());

StringRef Snippet = Buffer->getBuffer().slice(BeginOffset, EndOffset);

(Snippet.find_first_of(

) != StringRef::npos)

std::nullopt;

Snippet.size();

(PathPieces::iterator I =

.begin(),

=

.end(); I !=

; ) {

*PieceI = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());

*s1Start = PieceI->getStartLocation().getStmtOrNull();

*s1End = PieceI->getEndLocation().getStmtOrNull();

PathPieces::iterator NextI = I; ++NextI;

*PieceNextI =

dyn_cast<PathDiagnosticControlFlowPiece>(NextI->get());

(isa<PathDiagnosticEventPiece>(NextI->get())) {

PieceNextI = dyn_cast<PathDiagnosticControlFlowPiece>(NextI->get());

*s2Start = PieceNextI->getStartLocation().getStmtOrNull();

*s2End = PieceNextI->getEndLocation().getStmtOrNull();

(s1Start && s2Start && s1Start == s2End && s2Start == s1End) {

MAX_SHORT_LINE_LENGTH = 80;

(s1Length && *s1Length <= MAX_SHORT_LINE_LENGTH) {

(s2Length && *s2Length <= MAX_SHORT_LINE_LENGTH) {

I =

.erase(NextI);

erased =

;

(PathPieces::iterator I = path.begin(),

= path.end(); I !=

;

*PieceI = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());

*start = PieceI->getStartLocation().getStmtOrNull();

*end = PieceI->getEndLocation().getStmtOrNull();

(!

.isWrittenInSameFile(FirstLoc, SecondLoc))

(

.isBeforeInTranslationUnit(SecondLoc, FirstLoc))

std::swap(SecondLoc, FirstLoc);

MAX_PUNY_EDGE_LENGTH = 2;

(*ByteWidth <= MAX_PUNY_EDGE_LENGTH) {

(PathPieces::iterator I = path.begin(),

= path.end(); I !=

; ++I) {

*PieceI = dyn_cast<PathDiagnosticEventPiece>(I->get());

PathPieces::iterator NextI = I; ++NextI;

*PieceNextI = dyn_cast<PathDiagnosticEventPiece>(NextI->get());

(PieceI->getString() == PieceNextI->getString()) {

hasChanges =

;

(PathPieces::iterator I = path.begin(),

= path.end(); I !=

; ) {

(

*CallI = dyn_cast<PathDiagnosticCallPiece>(I->get())) {

(!OCS.count(CallI)) {

*PieceI = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());

*s1Start = PieceI->getStartLocation().getStmtOrNull();

*s1End = PieceI->getEndLocation().getStmtOrNull();

PathPieces::iterator NextI = I; ++NextI;

*PieceNextI = dyn_cast<PathDiagnosticControlFlowPiece>(NextI->get());

*s2Start = PieceNextI->getStartLocation().getStmtOrNull();

*s2End = PieceNextI->getEndLocation().getStmtOrNull();

(level1 && level1 == level2 && level1 == level3 && level1 == level4) {

PieceI->setEndLocation(PieceNextI->getEndLocation());

(s1End && s1End == s2Start && level2) {

removeEdge =

;

(isa<Expr>(s1End) && PM.

(cast<Expr>(s1End))) {

(s1Start && s2End &&

(s1Start && s2End &&

EdgeRange(PieceI->getEndLocation().asLocation(),

PieceI->getStartLocation().asLocation());

PieceI->setEndLocation(PieceNextI->getEndLocation());

(s1End == s2Start) {

*FS = dyn_cast_or_null<ObjCForCollectionStmt>(level3);

(FS && FS->getCollection()->IgnoreParens() == s2Start &&

s2End == FS->getElement()) {

PieceI->setEndLocation(PieceNextI->getEndLocation());

*FirstEdge =

dyn_cast<PathDiagnosticControlFlowPiece>(

.front().get());

*

=

.getLocationContextFor(&

)->getDecl();

(FirstEdge->getStartLocation() != EntryLoc)

(

&

: path) {

LineNo =

.getLineNumber();

ExecutedLines[FID].insert(LineNo);

PathDiagnosticConstruct::PathDiagnosticConstruct(

: Consumer(PDC), CurrentNode(ErrorNode),

(CurrentNode->getCodeDecl().getASTContext().getSourceManager()),

AnalysisEntryPoint)) {

PathDiagnosticBuilder::PathDiagnosticBuilder(

std::unique_ptr<VisitorsDiagnosticsTy> VisitorsDiagnostics)

ErrorNode(ErrorNode),

VisitorsDiagnostics(

::move(VisitorsDiagnostics)) {}

std::unique_ptr<PathDiagnostic>

*EntryPoint = getBugReporter().getAnalysisEntryPoint();

PathDiagnosticConstruct Construct(PDC, ErrorNode, R, EntryPoint);

EndNotes = VisitorsDiagnostics->find(ErrorNode);

(EndNotes != VisitorsDiagnostics->end()) {

assert(!EndNotes->second.empty());

LastPiece = EndNotes->second[0];

Construct.PD->setEndOfPath(LastPiece);

(Construct.ascendToPrevNode()) {

generatePathDiagnosticsForNode(Construct, PrevLoc);

VisitorNotes = VisitorsDiagnostics->find(Construct.getCurrentNode());

(VisitorNotes == VisitorsDiagnostics->end())

std::set<llvm::FoldingSetNodeID> DeduplicationSet;

llvm::FoldingSetNodeID

;

(!DeduplicationSet.insert(ID).second)

updateStackPiecesWithMessage(

, Construct.CallStack);

Construct.getActivePath().push_front(

);

Construct.getLocationContextForActivePath()->

();

(!Construct.PD->path.empty()) {

stillHasNotes =

assert(stillHasNotes);

(void)stillHasNotes;

(!Opts.ShouldAddPopUpNotes)

(

(Construct, Construct.getMutablePieces(), OCS)) {

(Opts.ShouldDisplayMacroExpansions)

std::move(Construct.PD);

BugType::anchor() {}

LLVM_ATTRIBUTE_USED

(

std::pair<StringRef, StringRef> &Pair : Registry.

) {

(Pair.second == CheckerName)

StringRef CheckerName) {

(

.FullName == CheckerName)

);

&bt, StringRef shortDesc, StringRef desc,

*DeclToUnique)

:

(

::PathSensitive, bt, shortDesc, desc), ErrorNode(errorNode),

ErrorNodeRange(getStmt() ? getStmt()->getSourceRange() :

()),

UniqueingLocation(LocationToUnique), UniqueingDecl(DeclToUnique) {

->getAnalysisManager()

.getCheckerManager()

->getCheckerRegistryData(),

);

->getAnalysisManager()

.getCheckerManager()

->getCheckerRegistryData(),

);

std::unique_ptr<BugReporterVisitor> visitor) {

llvm::FoldingSetNodeID ID;

visitor->Profile(ID);

*InsertPos =

;

(

.FindNodeOrInsertPos(ID, InsertPos)) {

.push_back(std::move(visitor));

hash.AddInteger(

(

()));

hash.AddPointer(&

);

(!range.isValid())

hash.Add(range.getBegin());

hash.Add(range.getEnd());

hash.AddInteger(

(

()));

hash.AddPointer(&

);

(!range.isValid())

hash.Add(range.getBegin());

hash.Add(range.getEnd());

llvm::DenseMap<T, bugreporter::TrackingKind> &InterestingnessMap,

Val,

= InterestingnessMap.insert({Val, TKind});

);

(

*meta = dyn_cast<SymbolMetadata>(sym))

(

*meta = dyn_cast<SymbolMetadata>(sym))

(

*SR = dyn_cast<SymbolicRegion>(R))

(

*SR = dyn_cast<SymbolicRegion>(R))

std::optional<bugreporter::TrackingKind>

);

std::nullopt;

std::optional<bugreporter::TrackingKind>

std::nullopt;

std::nullopt;

It->getSecond();

std::optional<bugreporter::TrackingKind>

std::nullopt;

It->getSecond();

(

*SR = dyn_cast<SymbolicRegion>(R))

std::nullopt;

*S =

;

(BE->getBlock() == &Exit)

assert(

&&

);

(

*AS = dyn_cast<AttributedStmt>(S))

S = AS->getSubStmt();

(

*ME = dyn_cast<MemberExpr>(S))

(

*B = dyn_cast<BinaryOperator>(S))

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

:

(

), UserSuppressions(

.getASTContext()) {}

assert(StrBugTypes.empty() &&

);

(

I : EQClassesVector)

(

EQ : EQClassesVector)

StrBugTypes.clear();

std::unique_ptr<ExplodedGraph> BugPath;

BugPathGetter {

std::unique_ptr<ExplodedGraph> TrimmedGraph;

PriorityMapTy = llvm::DenseMap<const ExplodedNode *, unsigned>;

PriorityMapTy PriorityMap;

ReportNewNodePair =

std::pair<PathSensitiveBugReport *, const ExplodedNode *>;

BugPathInfo CurrentBugPath;

<

Descending>

PriorityCompare {

PriorityMapTy &PriorityMap;

PriorityCompare(

PriorityMapTy &M) : PriorityMap(M) {}

PriorityMapTy::const_iterator LI = PriorityMap.find(LHS);

PriorityMapTy::const_iterator RI = PriorityMap.find(RHS);

PriorityMapTy::const_iterator

= PriorityMap.end();

Descending ? LI->second > RI->second

: LI->second < RI->second;

operator()(

ReportNewNodePair &LHS,

ReportNewNodePair &RHS)

{

(*

)(LHS.second, RHS.second);

BugPathInfo *getNextBugPath();

BugPathGetter::BugPathGetter(

*OriginalGraph,

(

I : bugReports) {

assert(I->isValid() &&

);

.emplace_back(I->getErrorNode());

TrimmedGraph = OriginalGraph->

(

, &ForwardMap);

ReportNodes.emplace_back(

, NewNode);

RemainingNodes.insert(NewNode);

assert(!RemainingNodes.empty() &&

);

std::queue<const ExplodedNode *> WS;

assert(TrimmedGraph->num_roots() == 1);

WS.push(*TrimmedGraph->roots_begin());

(!WS.empty()) {

PriorityMapTy::iterator PriorityEntry;

std::tie(PriorityEntry, IsNew) = PriorityMap.insert({

,

});

assert(PriorityEntry->second <= Priority);

(RemainingNodes.erase(

))

(RemainingNodes.empty())

llvm::sort(ReportNodes, PriorityCompare<true>(PriorityMap));

BugPathInfo *BugPathGetter::getNextBugPath() {

(ReportNodes.empty())

std::tie(CurrentBugPath.Report, OrigN) = ReportNodes.pop_back_val();

assert(PriorityMap.contains(OrigN) &&

);

GNew = std::make_unique<ExplodedGraph>();

CurrentBugPath.ErrorNode = NewN;

GNew->addRoot(NewN);

PriorityCompare<false>(PriorityMap));

CurrentBugPath.BugPath = std::move(GNew);

&CurrentBugPath;

MacroStackTy = std::vector<

std::pair<std::shared_ptr<PathDiagnosticMacroPiece>,

>>;

PiecesTy = std::vector<PathDiagnosticPieceRef>;

MacroStackTy MacroStack;

(PathPieces::const_iterator I = path.begin(),

= path.end();

&piece = *I;

(

*call = dyn_cast<PathDiagnosticCallPiece>(&*piece)) {

.getExpansionLoc(

) :

(

.isFileID()) {

Pieces.push_back(piece);

assert(

.isMacroID());

(!MacroStack.empty() && InstantiationLoc == MacroStack.back().second) {

MacroStack.back().first->subPieces.push_back(piece);

std::shared_ptr<PathDiagnosticMacroPiece> MacroGroup;

.getExpansionLoc(

) :

(!MacroStack.empty()) {

(InstantiationLoc == MacroStack.back().second) {

MacroGroup = MacroStack.back().first;

(ParentInstantiationLoc == MacroStack.back().second) {

MacroGroup = MacroStack.back().first;

MacroStack.pop_back();

(!MacroGroup || ParentInstantiationLoc == MacroStack.back().second) {

NewGroup = std::make_shared<PathDiagnosticMacroPiece>(

MacroGroup->subPieces.push_back(NewGroup);

assert(InstantiationLoc.

());

Pieces.push_back(NewGroup);

MacroGroup = NewGroup;

MacroStack.push_back(std::make_pair(MacroGroup, InstantiationLoc));

MacroGroup->subPieces.push_back(piece);

path.insert(path.end(), Pieces.begin(), Pieces.end());

std::unique_ptr<VisitorsDiagnosticsTy>

std::unique_ptr<VisitorsDiagnosticsTy> Notes =

std::make_unique<VisitorsDiagnosticsTy>();

(std::unique_ptr<BugReporterVisitor> &Visitor : R->

())

visitors.push_back(std::move(Visitor));

(

&

: visitors) {

->finalizeVisitor(BRC, ErrorNode, *R);

(

Piece =

->getEndPath(BRC, ErrorNode, *R)) {

assert(!LastPiece &&

);

);

LastPiece = std::move(Piece);

(*Notes)[ErrorNode].push_back(LastPiece);

(

&

: visitors) {

=

->VisitNode(NextNode, BRC, *R);

(*Notes)[NextNode].push_back(std::move(

));

std::optional<PathDiagnosticBuilder> PathDiagnosticBuilder::findValidReport(

BugPathGetter BugGraph(&Reporter.

(), bugReports);

(BugPathInfo *BugPath = BugGraph.getNextBugPath()) {

assert(R &&

);

assert(R->

() &&

);

std::unique_ptr<VisitorsDiagnosticsTy> visitorNotes =

(Z3Oracle.interpretQueryResult(CrosscheckResult)) {

++NumTimesReportRefuted;

R->

(

,

);

++NumTimesReportEQClassAborted;

++NumTimesReportPassesZ3;

PathDiagnosticBuilder(std::move(BRC), std::move(BugPath->BugPath),

BugPath->Report, BugPath->ErrorNode,

std::move(visitorNotes));

++NumTimesReportEQClassWasExhausted;

std::unique_ptr<DiagnosticForConsumerMapTy>

assert(!bugReports.empty());

Out = std::make_unique<DiagnosticForConsumerMapTy>();

std::optional<PathDiagnosticBuilder> PDB =

PathDiagnosticBuilder::findValidReport(bugReports, *

);

(std::unique_ptr<PathDiagnostic> PD = PDB->generate(PC)) {

(*Out)[PC] = std::move(PD);

ValidSourceLoc = R->getLocation().isValid();

assert(ValidSourceLoc);

(!ValidSourceLoc)

llvm::FoldingSetNodeID ID;

EQClasses.InsertNode(EQ, InsertPos);

EQClassesVector.push_back(EQ);

EQ->AddReport(std::move(R));

(

PR = dyn_cast<PathSensitiveBugReport>(R.get()))

assert((

->isSink() ||

->getLocation().getTag()) &&

);

->getLocationContext()->getAnalysisDeclContext();

FRIEC_WLItem {

: N(n), I(N->succ_begin()),

(N->succ_end()) {}

*PathSensitiveBugReporter::findReportInEquivalenceClass(

assert(

.getReports().size() > 0);

& BT =

.getReports()[0]->getBugType();

(

&J :

.getReports()) {

(

*PR = dyn_cast<PathSensitiveBugReport>(J.get())) {

bugReports.push_back(PR);

(

&I:

.getReports()) {

*R = dyn_cast<PathSensitiveBugReport>(I.get());

(errorNode->

()) {

);

bugReports.push_back(R);

(ErrorB->isInevitablySinking())

WLItem = FRIEC_WLItem;

llvm::DenseMap<const ExplodedNode *, unsigned>

;

WL.push_back(errorNode);

(!WL.empty()) {

WLItem &WI = WL.back();

assert(!WI.N->succ_empty());

(; WI.I != WI.E; ++WI.I) {

bugReports.push_back(R);

&mark =

[Succ];

(!WL.empty() && &WL.back() == &WI)

exampleReport;

*report = findReportInEquivalenceClass(EQ, bugReports);

(

std::string &CheckerOrPackage :

std::unique_ptr<DiagnosticForConsumerMapTy> Diagnostics =

(

&

: *Diagnostics) {

std::unique_ptr<PathDiagnostic> &PD =

.second;

(PD->path.empty()) {

piece = std::make_unique<PathDiagnosticEventPiece>(

piece->addRange(

);

PD->setEndOfPath(std::move(piece));

(

&I : llvm::reverse(report->

())) {

ConvertedPiece = std::make_shared<PathDiagnosticEventPiece>(

(

&R: Piece->

())

ConvertedPiece->addRange(R);

Pieces.push_front(std::move(ConvertedPiece));

(

&I : llvm::reverse(report->

()))

Pieces.push_front(I);

(

&I : report->

())

Pieces.back()->addFixit(I);

Pieces.push_front(std::make_shared<PathDiagnosticEventPiece>(

+

(

FD = dyn_cast<FunctionDecl>(Signature)) {

SignatureSourceRange = FD->getSourceRange();

}

(

OD = dyn_cast<ObjCMethodDecl>(Signature)) {

SignatureSourceRange = OD->getSourceRange();

: SignatureSourceRange.

();

(!Start.

() || !End.isValid())

StartLine =

.getExpansionLineNumber(Start);

EndLine =

.getExpansionLineNumber(End);

FID =

.getFileID(

.getExpansionLoc(Start));

(

= StartLine;

<= EndLine;

++)

ExecutedLines[FID].insert(

);

FID =

.getFileID(ExpansionLoc);

LineNo =

.getExpansionLineNumber(ExpansionLoc);

ExecutedLines[FID].insert(LineNo);

std::unique_ptr<FilesToLineNumsMap>

ExecutedLines = std::make_unique<FilesToLineNumsMap>();

*

= CE->getCalleeContext()->getDecl();

(

*RS = dyn_cast_or_null<ReturnStmt>(

)) {

(isa_and_nonnull<SwitchCase, LabelStmt>(

))

ExecutedLines;

std::unique_ptr<DiagnosticForConsumerMapTy>

*basicReport = cast<BasicBugReport>(exampleReport);

Out = std::make_unique<DiagnosticForConsumerMapTy>();

(

*Consumer : consumers)

);

(

*CPInner = dyn_cast<PathDiagnosticCallPiece>(

.back().get()))

(PD.

.empty())

(

*CP = dyn_cast<PathDiagnosticCallPiece>(LastP)) {

*ND = dyn_cast<NamedDecl>(CP->

());

llvm::raw_svector_ostream os(buf);

os <<

<< ND->getDeclName() <<

;

std::unique_ptr<DiagnosticForConsumerMapTy>

PathSensitiveBugReporter::generateDiagnosticForConsumerMap(

std::vector<BasicBugReport *> BasicBugReports;

std::vector<PathSensitiveBugReport *> PathSensitiveBugReports;

(isa<BasicBugReport>(exampleReport))

consumers, bugReports);

assert(!bugReports.empty());

MaxBugClassSize.updateMax(bugReports.size());

consumers, convertedArrayOfReports);

MaxValidBugClassSize.updateMax(bugReports.size());

(

&

: *Out)

(Opts.ShouldReportIssuesInMainSourceFile && !Opts.

)

StringRef

, StringRef Str,

, Ranges, Fixits);

StringRef name, StringRef category,

*BT = getBugTypeForName(CheckName, name, category);

R = std::make_unique<BasicBugReport>(*BT, str,

);

R->setDeclWithIssue(DeclWithIssue);

(

&SR : Ranges)

(

&FH : Fixits)

StringRef name, StringRef category) {

llvm::raw_svector_ostream(fullDesc) << CheckName.

() <<

<< name

std::unique_ptr<BugType> &BT = StrBugTypes[fullDesc];

BT = std::make_unique<BugType>(CheckName, name, category);

BoundNodesTreeBuilder Nodes

This file defines AnalysisDeclContext, a class that manages the analysis context data for context sen...

static void dropFunctionEntryEdge(const PathDiagnosticConstruct &C, PathPieces &Path)

Drop the very first edge in a path, which should be a function entry edge.

constexpr llvm::StringLiteral StrLoopRangeEmpty

static PathDiagnosticLocation getEnclosingStmtLocation(const Stmt *S, const LocationContext *LC, bool allowNestedContexts=false)

static std::unique_ptr< FilesToLineNumsMap > findExecutedLines(const SourceManager &SM, const ExplodedNode *N)

static bool isConditionForTerminator(const Stmt *S, const Stmt *Cond)

static void updateExecutedLinesWithDiagnosticPieces(PathDiagnostic &PD)

Populate executes lines with lines containing at least one diagnostics.

static void removeRedundantMsgs(PathPieces &path)

An optimization pass over PathPieces that removes redundant diagnostics generated by both ConditionBR...

constexpr llvm::StringLiteral StrLoopCollectionEmpty

static void adjustCallLocations(PathPieces &Pieces, PathDiagnosticLocation *LastCallLocation=nullptr)

Recursively scan through a path and make sure that all call pieces have valid locations.

static void removeIdenticalEvents(PathPieces &path)

static const Stmt * getTerminatorCondition(const CFGBlock *B)

A customized wrapper for CFGBlock::getTerminatorCondition() which returns the element for ObjCForColl...

static std::unique_ptr< VisitorsDiagnosticsTy > generateVisitorsDiagnostics(PathSensitiveBugReport *R, const ExplodedNode *ErrorNode, BugReporterContext &BRC)

Generate notes from all visitors.

static bool removeUnneededCalls(const PathDiagnosticConstruct &C, PathPieces &pieces, const PathSensitiveBugReport *R, bool IsInteresting=false)

Recursively scan through a path and prune out calls and macros pieces that aren't needed.

static const Stmt * findReasonableStmtCloseToFunctionExit(const ExplodedNode *N)

static void populateExecutedLinesWithStmt(const Stmt *S, const SourceManager &SM, FilesToLineNumsMap &ExecutedLines)

static bool isJumpToFalseBranch(const BlockEdge *BE)

static std::optional< size_t > getLengthOnSingleLine(const SourceManager &SM, SourceRange Range)

Returns the number of bytes in the given (character-based) SourceRange.

static bool isLoop(const Stmt *Term)

static bool isContainedByStmt(const ParentMap &PM, const Stmt *S, const Stmt *SubS)

constexpr llvm::StringLiteral StrEnteringLoop

static void addEdgeToPath(PathPieces &path, PathDiagnosticLocation &PrevLoc, PathDiagnosticLocation NewLoc)

Adds a sanitized control-flow diagnostic edge to a path.

static bool isIncrementOrInitInForLoop(const Stmt *S, const Stmt *FL)

static std::unique_ptr< PathDiagnostic > generateEmptyDiagnosticForReport(const PathSensitiveBugReport *R, const SourceManager &SM, const Decl *AnalysisEntryPoint)

static void removeContextCycles(PathPieces &Path, const SourceManager &SM)

Eliminate two-edge cycles created by addContextEdges().

static bool lexicalContains(const ParentMap &PM, const Stmt *X, const Stmt *Y)

Return true if X is contained by Y.

static std::unique_ptr< PathDiagnostic > generateDiagnosticForBasicReport(const BasicBugReport *R, const Decl *AnalysisEntryPoint)

static void removePopUpNotes(PathPieces &Path)

Same logic as above to remove extra pieces.

STATISTIC(MaxBugClassSize, "The maximum number of bug reports in the same equivalence class")

static void insertToInterestingnessMap(llvm::DenseMap< T, bugreporter::TrackingKind > &InterestingnessMap, T Val, bugreporter::TrackingKind TKind)

constexpr llvm::StringLiteral StrLoopBodyZero

static const Stmt * getEnclosingParent(const Stmt *S, const ParentMap &PM)

static void removePunyEdges(PathPieces &path, const SourceManager &SM, const ParentMap &PM)

static const Stmt * getStmtParent(const Stmt *S, const ParentMap &PM)

static bool exitingDestructor(const ExplodedNode *N)

static void CompactMacroExpandedPieces(PathPieces &path, const SourceManager &SM)

CompactMacroExpandedPieces - This function postprocesses a PathDiagnostic object and collapses PathDi...

static void simplifySimpleBranches(PathPieces &pieces)

Move edges from a branch condition to a branch target when the condition is simple.

static void populateExecutedLinesWithFunctionSignature(const Decl *Signature, const SourceManager &SM, FilesToLineNumsMap &ExecutedLines)

Insert all lines participating in the function signature Signature into ExecutedLines.

static void resetDiagnosticLocationToMainFile(PathDiagnostic &PD)

static bool optimizeEdges(const PathDiagnosticConstruct &C, PathPieces &path, OptimizedCallsSet &OCS)

static bool hasImplicitBody(const Decl *D)

Returns true if the given decl has been implicitly given a body, either by the analyzer or by the com...

static PathDiagnosticCallPiece * getFirstStackedCallToHeaderFile(PathDiagnosticCallPiece *CP, const SourceManager &SMgr)

llvm::DenseSet< const PathDiagnosticCallPiece * > OptimizedCallsSet

static void addContextEdges(PathPieces &pieces, const LocationContext *LC)

Adds synthetic edges from top-level statements to their subexpressions.

static LLVM_ATTRIBUTE_USED bool isDependency(const CheckerRegistryData &Registry, StringRef CheckerName)

static PathDiagnosticEventPiece * eventsDescribeSameCondition(PathDiagnosticEventPiece *X, PathDiagnosticEventPiece *Y)

static bool isInLoopBody(const ParentMap &PM, const Stmt *S, const Stmt *Term)

static void removeEdgesToDefaultInitializers(PathPieces &Pieces)

Remove edges in and out of C++ default initializer expressions.

static const Stmt * getStmtBeforeCond(const ParentMap &PM, const Stmt *Term, const ExplodedNode *N)

static void removePiecesWithInvalidLocations(PathPieces &Pieces)

Remove all pieces with invalid locations as these cannot be serialized.

static LLVM_ATTRIBUTE_USED bool isHidden(const CheckerRegistryData &Registry, StringRef CheckerName)

Defines the clang::Expr interface and subclasses for C++ expressions.

llvm::DenseSet< const void * > Visited

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

Defines the Objective-C statement AST node classes.

SourceManager & getSourceManager()

AnalysisDeclContext contains the context data for the function, method or block under analysis.

static std::string getFunctionName(const Decl *D)

bool isBodyAutosynthesized() const

bool isBodyAutosynthesizedFromModelFile() const

Stores options for the analyzer from the command line.

const CFGBlock * getSrc() const

const CFGBlock * getDst() const

Represents a single basic block in a source-level CFG.

succ_iterator succ_begin()

Stmt * getTerminatorStmt()

const Stmt * getLoopTarget() const

Stmt * getTerminatorCondition(bool StripParens=true)

unsigned succ_size() const

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

Represents a point when we begin processing an inlined call.

Represents a point when we finish the call exit sequence (for inlined call).

const StackFrameContext * getCalleeContext() const

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

ASTContext & getASTContext() const LLVM_READONLY

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

This represents one expression.

llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

Expr * IgnoreParenImpCasts() LLVM_READONLY

Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...

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.

A SourceLocation and its associated SourceManager.

IfStmt - This represents an if/then/else.

It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...

const Decl * getDecl() const

const ParentMap & getParentMap() const

const StackFrameContext * getStackFrame() const

Represents Objective-C's collection statement.

bool isConsumedExpr(Expr *E) const

Stmt * getParent(Stmt *) const

Stmt * getParentIgnoreParens(Stmt *) const

Represents a point after we ran remove dead bindings AFTER processing the given statement.

Represents a program point just before an implicit call event.

std::optional< T > getAs() const

Convert to the specified ProgramPoint type, returning std::nullopt if this ProgramPoint is not of the...

const LocationContext * getLocationContext() const

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.

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

It represents a stack frame of the call stack (based on CallEvent).

const Stmt * getCallSite() const

Stmt - This represents one statement.

StmtClass getStmtClass() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

SourceLocation getBeginLoc() const LLVM_READONLY

WhileStmt - This represents a 'while' stmt.

static bool isInCodeFile(SourceLocation SL, const SourceManager &SM)

const Decl * getDeclWithIssue() const override

The smallest declaration that contains the bug location.

PathDiagnosticLocation getUniqueingLocation() const override

Get the location on which the report should be uniqued.

void Profile(llvm::FoldingSetNodeID &hash) const override

Reports are uniqued to ensure that we do not emit multiple diagnostics for each bug.

const Decl * getUniqueingDecl() const override

Get the declaration that corresponds to (usually contains) the uniqueing location.

This class provides an interface through which checkers can create individual bug reports.

llvm::ArrayRef< FixItHint > getFixits() const

void addRange(SourceRange R)

Add a range to a bug report.

SmallVector< SourceRange, 4 > Ranges

virtual PathDiagnosticLocation getLocation() const =0

The primary location of the bug report that points at the undesirable behavior in the code.

ArrayRef< std::shared_ptr< PathDiagnosticNotePiece > > getNotes()

void addFixItHint(const FixItHint &F)

Add a fix-it hint to the bug report.

StringRef getDescription() const

A verbose warning message that is appropriate for displaying next to the source code that introduces ...

const BugType & getBugType() const

StringRef getShortDescription(bool UseFallback=true) const

A short general warning message that is appropriate for displaying in the list of all reported bugs.

virtual ArrayRef< SourceRange > getRanges() const

Get the SourceRanges associated with the report.

static PathDiagnosticPieceRef getDefaultEndPath(const BugReporterContext &BRC, const ExplodedNode *N, const PathSensitiveBugReport &BR)

Generates the default final diagnostic piece.

virtual ~BugReporterVisitor()

virtual std::unique_ptr< DiagnosticForConsumerMapTy > generateDiagnosticForConsumerMap(BugReport *exampleReport, ArrayRef< PathDiagnosticConsumer * > consumers, ArrayRef< BugReport * > bugReports)

Generate the diagnostics for the given bug report.

void FlushReports()

Generate and flush diagnostics for all bug reports.

BugReporter(BugReporterData &d)

const SourceManager & getSourceManager()

const Decl * getAnalysisEntryPoint() const

Get the top-level entry point for the issue to be reported.

const AnalyzerOptions & getAnalyzerOptions()

void EmitBasicReport(const Decl *DeclWithIssue, const CheckerBase *Checker, StringRef BugName, StringRef BugCategory, StringRef BugStr, PathDiagnosticLocation Loc, ArrayRef< SourceRange > Ranges={}, ArrayRef< FixItHint > Fixits={})

virtual void emitReport(std::unique_ptr< BugReport > R)

Add the given report to the set of reports tracked by BugReporter.

ArrayRef< PathDiagnosticConsumer * > getPathDiagnosticConsumers()

bool isSuppressed(const BugReport &)

Return true if the given bug report was explicitly suppressed by the user.

bool isSuppressOnSink() const

isSuppressOnSink - Returns true if bug reports associated with this bug type should be suppressed if ...

StringRef getCategory() const

StringRef getDescription() const

StringRef getCheckerName() const

CheckerNameRef getCheckerName() const

This wrapper is used to ensure that only StringRefs originating from the CheckerRegistry are used as ...

StringRef getName() const

Visitor that tries to report interesting diagnostics from conditions.

static bool isPieceMessageGeneric(const PathDiagnosticPiece *Piece)

static const char * getTag()

Return the tag associated with this visitor.

bool isValid() const =delete

std::unique_ptr< ExplodedGraph > trim(ArrayRef< const NodeTy * > Nodes, InterExplodedGraphMap *ForwardMap=nullptr, InterExplodedGraphMap *InverseMap=nullptr) const

Creates a trimmed version of the graph that only contains paths leading to the given nodes.

const CFGBlock * getCFGBlock() const

const ProgramStateRef & getState() const

pred_iterator pred_begin()

const Stmt * getStmtForDiagnostics() const

If the node's program point corresponds to a statement, retrieve that statement.

const Stmt * getPreviousStmtForDiagnostics() const

Find the statement that was executed immediately before this node.

ProgramPoint getLocation() const

getLocation - Returns the edge associated with the given node.

void addPredecessor(ExplodedNode *V, ExplodedGraph &G)

addPredeccessor - Adds a predecessor to the current node, and in tandem add this node as a successor ...

const Stmt * getNextStmtForDiagnostics() const

Find the next statement that was executed on this node's execution path.

const ParentMap & getParentMap() const

SVal getSVal(const Stmt *S) const

Get the value of an arbitrary expression at this node.

const LocationContext * getLocationContext() const

std::optional< T > getLocationAs() const &

const Stmt * getCurrentOrPreviousStmtForDiagnostics() const

Find the statement that was executed at or immediately before this node.

ExplodedNode * getFirstPred()

const ExplodedNode *const * const_succ_iterator

ProgramStateManager & getStateManager()

ExplodedGraph & getGraph()

Suppress reports that might lead to known false positives.

MemRegion - The root abstract class for all memory regions.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getBaseRegion() const

Prints path notes when a message is sent to a nil receiver.

PathDiagnosticLocation getLocation() const override

PathDiagnosticLocation callEnter

void setCallStackMessage(StringRef st)

bool hasCallStackMessage()

const Decl * getCallee() const

static std::shared_ptr< PathDiagnosticCallPiece > construct(const CallExitEnd &CE, const SourceManager &SM)

const Decl * getCaller() const

PathDiagnosticLocation callEnterWithin

virtual bool supportsLogicalOpControlFlow() const

bool shouldAddPathEdges() const

void HandlePathDiagnostic(std::unique_ptr< PathDiagnostic > D)

bool shouldAddControlNotes() const

bool shouldGenerateDiagnostics() const

PathDiagnosticLocation getStartLocation() const

void setStartLocation(const PathDiagnosticLocation &L)

PathDiagnosticLocation getEndLocation() const

static PathDiagnosticLocation createMemberLoc(const MemberExpr *ME, const SourceManager &SM)

For member expressions, return the location of the '.

const Stmt * asStmt() const

void Profile(llvm::FoldingSetNodeID &ID) const

const SourceManager & getManager() const

static PathDiagnosticLocation createOperatorLoc(const BinaryOperator *BO, const SourceManager &SM)

Create the location for the operator of the binary expression.

static PathDiagnosticLocation createEndBrace(const CompoundStmt *CS, const SourceManager &SM)

Create a location for the end of the compound statement.

static SourceLocation getValidSourceLocation(const Stmt *S, LocationOrAnalysisDeclContext LAC, bool UseEndOfStatement=false)

Construct a source location that corresponds to either the beginning or the end of the given statemen...

static PathDiagnosticLocation createEnd(const Stmt *S, const SourceManager &SM, const LocationOrAnalysisDeclContext LAC)

Create a location for the end of the statement.

static PathDiagnosticLocation createBegin(const Decl *D, const SourceManager &SM)

Create a location for the beginning of the declaration.

FullSourceLoc asLocation() const

static PathDiagnosticLocation createDeclEnd(const LocationContext *LC, const SourceManager &SM)

Constructs a location for the end of the enclosing declaration body.

const Stmt * getStmtOrNull() const

static PathDiagnosticLocation createSingleLocation(const PathDiagnosticLocation &PDL)

Convert the given location into a single kind location.

ArrayRef< SourceRange > getRanges() const

Return the SourceRanges associated with this PathDiagnosticPiece.

virtual PathDiagnosticLocation getLocation() const =0

void setAsLastInMainSourceFile()

const void * getTag() const

Return the opaque tag (if any) on the PathDiagnosticPiece.

StringRef getString() const

PathDiagnosticLocation getLocation() const override

PathDiagnostic - PathDiagnostic objects represent a single path-sensitive diagnostic.

void setDeclWithIssue(const Decl *D)

void appendToDesc(StringRef S)

void setLocation(PathDiagnosticLocation NewLoc)

const FilesToLineNumsMap & getExecutedLines() const

PathPieces flatten(bool ShouldFlattenMacros) const

llvm::SmallSet< const LocationContext *, 2 > InterestingLocationContexts

A set of location contexts that correspoind to call sites which should be considered "interesting".

void markInteresting(SymbolRef sym, bugreporter::TrackingKind TKind=bugreporter::TrackingKind::Thorough)

Marks a symbol as interesting.

PathDiagnosticLocation getUniqueingLocation() const override

Get the location on which the report should be uniqued.

VisitorList Callbacks

A set of custom visitors which generate "event" diagnostics at interesting points in the path.

const Stmt * getStmt() const

PathDiagnosticLocation getLocation() const override

The primary location of the bug report that points at the undesirable behavior in the code.

const Decl * getDeclWithIssue() const override

The smallest declaration that contains the bug location.

bool shouldPrunePath() const

Indicates whether or not any path pruning should take place when generating a PathDiagnostic from thi...

ArrayRef< SourceRange > getRanges() const override

Get the SourceRanges associated with the report.

llvm::DenseMap< SymbolRef, bugreporter::TrackingKind > InterestingSymbols

Profile to identify equivalent bug reports for error report coalescing.

const Decl * getUniqueingDecl() const override

Get the declaration containing the uniqueing location.

const ExplodedNode * getErrorNode() const

PathSensitiveBugReport(const BugType &bt, StringRef desc, const ExplodedNode *errorNode)

const ExplodedNode * ErrorNode

The ExplodedGraph node against which the report was thrown.

void markInvalid(const void *Tag, const void *Data)

Marks the current report as invalid, meaning that it is probably a false positive and should not be r...

void Profile(llvm::FoldingSetNodeID &hash) const override

Profile to identify equivalent bug reports for error report coalescing.

void clearVisitors()

Remove all visitors attached to this bug report.

void addVisitor(std::unique_ptr< BugReporterVisitor > visitor)

Add custom or predefined bug report visitors to this report.

bool isValid() const

Returns whether or not this report should be considered valid.

std::optional< bugreporter::TrackingKind > getInterestingnessKind(SymbolRef sym) const

void markNotInteresting(SymbolRef sym)

llvm::DenseMap< const MemRegion *, bugreporter::TrackingKind > InterestingRegions

A (stack of) set of regions that are registered with this report as being "interesting",...

bool isInteresting(SymbolRef sym) const

const SourceRange ErrorNodeRange

The range that corresponds to ErrorNode's program point.

llvm::FoldingSet< BugReporterVisitor > CallbacksSet

Used for ensuring the visitors are only added once.

GRBugReporter is used for generating path-sensitive reports.

const ExplodedGraph & getGraph() const

getGraph - Get the exploded graph created by the analysis engine for the analyzed method or function.

std::unique_ptr< DiagnosticForConsumerMapTy > generatePathDiagnostics(ArrayRef< PathDiagnosticConsumer * > consumers, ArrayRef< PathSensitiveBugReport * > &bugReports)

bugReports A set of bug reports within a single equivalence class

void emitReport(std::unique_ptr< BugReport > R) override

Add the given report to the set of reports tracked by BugReporter.

ProgramStateManager & getStateManager() const

getStateManager - Return the state manager used by the analysis engine.

A Range represents the closed range [from, to].

SVal - This represents a symbolic expression, which can be either an L-value or an R-value.

std::optional< T > getAs() const

Convert to the specified SVal type, returning std::nullopt if this SVal is not of the desired type.

SymbolRef getAsLocSymbol(bool IncludeBaseRegions=false) const

If this SVal is a location and wraps a symbol, return that SymbolRef.

std::string getMessage(const ExplodedNode *N) override

Search the call expression for the symbol Sym and dispatch the 'getMessageForX()' methods to construc...

virtual std::string getMessageForSymbolNotFound()

virtual std::string getMessageForReturn(const CallExpr *CallExpr)

virtual std::string getMessageForArg(const Expr *ArgE, unsigned ArgIndex)

Produces the message of the following form: 'Msg via Nth parameter'.

virtual ~StackHintGenerator()=0

The visitor detects NoteTags and displays the event notes they contain.

static const char * getTag()

Return the tag associated with this visitor.

The oracle will decide if a report should be accepted or rejected based on the results of the Z3 solv...

The bug visitor will walk all the nodes in a path and collect all the constraints.

TrackingKind

Specifies the type of tracking for an expression.

@ Thorough

Default tracking kind – specifies that as much information should be gathered about the tracked expre...

@ Condition

Specifies that a more moderate tracking should be used for the expression value.

llvm::DenseMap< const ExplodedNode *, const ExplodedNode * > InterExplodedGraphMap

std::map< FileID, std::set< unsigned > > FilesToLineNumsMap

File IDs mapped to sets of line numbers.

@ CF

Indicates that the tracked object is a CF object.

std::shared_ptr< PathDiagnosticPiece > PathDiagnosticPieceRef

bool EQ(InterpState &S, CodePtr OpPC)

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

bool isa(CodeGen::Address addr)

@ Result

The result type of a method or function.

const FunctionProtoType * T

Diagnostic wrappers for TextAPI types for error reporting.

llvm::SmallVector< std::pair< StringRef, StringRef >, 0 > Dependencies

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