Author: Donát Nagy Date: 2026-06-22T14:06:32+02:00 New Revision: 8b723503336f094afb92f00cb73378321914f6cf
URL: https://github.com/llvm/llvm-project/commit/8b723503336f094afb92f00cb73378321914f6cf DIFF: https://github.com/llvm/llvm-project/commit/8b723503336f094afb92f00cb73378321914f6cf.diff LOG: [NFC][analyzer] Eliminate some simple node builders (#204187) Replace four `NodeBuilder`s with direct use of the `makeNode` method family. This is part of my commit series that simplifies the engine by gradually eliminating the class `NodeBuilder`. Added: Modified: clang/lib/StaticAnalyzer/Core/ExprEngine.cpp Removed: ################################################################################ diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp index 32da5e097c76e..77faa675b90b8 100644 --- a/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp +++ b/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp @@ -1148,10 +1148,8 @@ void ExprEngine::ProcessLifetimeEnd(const Stmt *S, const VarDecl *D, PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(), S->getBeginLoc(), "Error evaluating end of a lifetime"); - ExplodedNodeSet Src; - NodeBuilder Bldr(Pred, Src, *currBldrCtx); LifetimeEnd PP(S, D, Pred->getStackFrame()); - Bldr.generateNode(PP, Pred->getState(), Pred); + ExplodedNode *Src = Engine.makeNode(PP, Pred->getState(), Pred); ExplodedNodeSet Dst; getCheckerManager().runCheckersForLifetimeEnd(Dst, Src, D, *this); @@ -1639,7 +1637,6 @@ void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE, Dst = PreVisit; return; } - NodeBuilder Builder(PreVisit, Dst, *currBldrCtx); for (ExplodedNode *Node : PreVisit) { ProgramStateRef State = Node->getState(); const StackFrame *SF = Node->getStackFrame(); @@ -1650,7 +1647,7 @@ void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE, // temporary destructor nodes. State = addObjectUnderConstruction(State, BTE, SF, UnknownVal()); } - Builder.generateNode(BTE, Node, State); + Dst.insert(Engine.makePostStmtNode(BTE, State, Node)); } } @@ -3352,7 +3349,6 @@ void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred, for (const auto I : CheckedSet) VisitCommonDeclRefExpr(M, Member, I, EvalSet); } else { - NodeBuilder Bldr(CheckedSet, EvalSet, *currBldrCtx); ExplodedNodeSet Tmp; for (const auto I : CheckedSet) { @@ -3366,9 +3362,8 @@ void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred, state = createTemporaryRegionIfNeeded(state, SF, BaseExpr); SVal MDVal = svalBuilder.getFunctionPointer(MD); - state = state->BindExpr(M, SF, MDVal); - Bldr.generateNode(M, I, state); + EvalSet.insert(Engine.makeNodeWithBinding(I, M, MDVal, state)); continue; } @@ -3412,12 +3407,13 @@ void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred, L = UnknownVal(); } - Bldr.generateNode(M, I, state->BindExpr(M, SF, L), nullptr, - ProgramPoint::PostLValueKind); + EvalSet.insert(Engine.makeNodeWithBinding( + I, M, L, state, ProgramPoint::PostLValueKind)); } else { - Bldr.takeNodes(I); + // FIXME: When evalLoad no longer uses NodeBuilders, eliminate Tmp and + // pass EvalSet as the first argument of evalLoad. evalLoad(Tmp, M, M, I, state, L); - Bldr.addNodes(Tmp); + EvalSet.insert(Tmp); } } } @@ -3434,16 +3430,14 @@ void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred, // FIXME: Ideally we should model the behavior of the atomics precisely here. ExplodedNodeSet AfterInvalidateSet; - NodeBuilder Bldr(AfterPreSet, AfterInvalidateSet, *currBldrCtx); for (const auto I : AfterPreSet) { ProgramStateRef State = I->getState(); const StackFrame *SF = I->getStackFrame(); SmallVector<SVal, 8> ValuesToInvalidate; - for (unsigned SI = 0, Count = AE->getNumSubExprs(); SI != Count; SI++) { - const Expr *SubExpr = AE->getSubExprs()[SI]; - SVal SubExprVal = State->getSVal(SubExpr, SF); + for (const Stmt *SubExpr : AE->children()) { + SVal SubExprVal = State->getSVal(cast<Expr>(SubExpr), SF); ValuesToInvalidate.push_back(SubExprVal); } @@ -3452,10 +3446,8 @@ void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred, /*CausedByPointerEscape*/ true, /*Symbols=*/nullptr); - SVal ResultVal = UnknownVal(); - State = State->BindExpr(AE, SF, ResultVal); - Bldr.generateNode(AE, I, State, nullptr, - ProgramPoint::PostStmtKind); + AfterInvalidateSet.insert( + Engine.makeNodeWithBinding(I, AE, UnknownVal(), State)); } getCheckerManager().runCheckersForPostStmt(Dst, AfterInvalidateSet, AE, *this); @@ -3768,7 +3760,6 @@ bool ExprEngine::didEagerlyAssumeBifurcateAt(ProgramStateRef State, void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred, ExplodedNodeSet &Dst) { - NodeBuilder Bldr(Pred, Dst, *currBldrCtx); // We have processed both the inputs and the outputs. All of the outputs // should evaluate to Locs. Nuke all of their values. @@ -3800,13 +3791,12 @@ void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred, /*CausedByPointerEscape=*/true); } - Bldr.generateNode(A, Pred, state); + Dst.insert(Engine.makePostStmtNode(A, state, Pred)); } void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred, ExplodedNodeSet &Dst) { - NodeBuilder Bldr(Pred, Dst, *currBldrCtx); - Bldr.generateNode(A, Pred, Pred->getState()); + Dst.insert(Engine.makePostStmtNode(A, Pred->getState(), Pred)); } //===----------------------------------------------------------------------===// @@ -3972,25 +3962,23 @@ void ExprEngine::ConstructInitList(const Expr *E, ArrayRef<Expr *> Args, const StackFrame *SF = Pred->getStackFrame(); - NodeBuilder B(Pred, Dst, *currBldrCtx); ProgramStateRef S = Pred->getState(); QualType T = E->getType().getCanonicalType(); bool IsCompound = T->isArrayType() || T->isRecordType() || T->isAnyComplexType() || T->isVectorType(); + SVal Val; if (Args.size() > 1 || (E->isPRValue() && IsCompound && !IsTransparent)) { llvm::ImmutableList<SVal> ArgList = getBasicVals().getEmptySValList(); for (Expr *E : llvm::reverse(Args)) ArgList = getBasicVals().prependSVal(S->getSVal(E, SF), ArgList); - B.generateNode(E, Pred, - S->BindExpr(E, SF, svalBuilder.makeCompoundVal(T, ArgList))); + Val = getSValBuilder().makeCompoundVal(T, ArgList); + } else if (Args.size() == 0) { + Val = getSValBuilder().makeZeroVal(T); } else { - B.generateNode(E, Pred, - S->BindExpr(E, SF, - Args.size() == 0 - ? getSValBuilder().makeZeroVal(T) - : S->getSVal(Args.front(), SF))); + Val = S->getSVal(Args.front(), SF); } + Dst.insert(Engine.makeNodeWithBinding(Pred, E, Val)); } _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
