[clang] [analyzer] Don't keep a reclaimable node in TrackControlDependencyCondBRVisitor (PR #242711)
via cfe-commits
cfe-commits at lists.llvm.org
Sat Nov 14 13:59:46 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-static-analyzer-1
Author: mark-zilber
<details>
<summary>Changes</summary>
`trackExpressionValue()` may run when a checker emits a report, while the exploded graph is still being built. The `ControlDependencyHandler` then creates a `TrackControlDependencyCondBRVisitor`, which stored a pointer to an `ExplodedNode` of that graph. Node reclamation (`ExplodedGraph::reclaimRecentlyAllocatedNodes`) can free such a node before the report is processed and reuse its memory for a node of another function. The visitor then took the CFG block of the wrong function and hit in `ControlDependencyCalculator::getControlDependencies` and without assertions this is a use-after-free
```
GenericDomTree.h:400: Assertion `(!BB || Parent == NodeTrait::getParent(const_cast<NodeT *>(BB))) && "cannot get DomTreeNode of block with different parent"' failed.
```
The visitor only needs the stack frame and the CFG block of the origin node, so it now stores them when it is created. `ExplodedNode::getCFGBlock()` depends only on the node's own program point and stack frame, so the result is the same as before
Found while analyzing `llvm/lib/Target/X86/X86InterleavedAccess.cpp` with an extra checker enabled, which changed which nodes got reclaimed; the report there comes from `core.CallAndMessage`. With `-analyzer-config graph-trim-interval=0` the crash goes away
### Testing
- `clang/test/Analysis/track-control-dependency-reclaimed-node.cpp` crashes without the fix for each of its `graph-trim-interval` values (10, 15, 19). Whether the freed node is reused by a node of another function depends on the exploration order, so the test may stop reproducing the crash after unrelated engine changes
---
Full diff: https://github.com/llvm/llvm-project/pull/242711.diff
2 Files Affected:
- (modified) clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (+9-7)
- (added) clang/test/Analysis/track-control-dependency-reclaimed-node.cpp (+27)
``````````diff
diff --git a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
index 38d1cab8ff71e9..c9543965b80b94 100644
--- a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
+++ b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
@@ -1934,14 +1934,18 @@ namespace {
/// trackExpressionValue().
class TrackControlDependencyCondBRVisitor final
: public TrackingBugReporterVisitor {
- const ExplodedNode *Origin;
+ // The origin node itself may be reclaimed before the visitor runs.
+ const StackFrame *OriginFrame;
+ CFGBlock *OriginBlock;
ControlDependencyCalculator ControlDeps;
llvm::SmallPtrSet<const CFGBlock *, 32> VisitedBlocks;
public:
TrackControlDependencyCondBRVisitor(TrackerRef ParentTracker,
const ExplodedNode *O)
- : TrackingBugReporterVisitor(ParentTracker), Origin(O),
+ : TrackingBugReporterVisitor(ParentTracker),
+ OriginFrame(O->getStackFrame()),
+ OriginBlock(const_cast<CFGBlock *>(O->getCFGBlock())),
ControlDeps(&O->getCFG()) {}
void Profile(llvm::FoldingSetNodeID &ID) const override {
@@ -2011,7 +2015,7 @@ TrackControlDependencyCondBRVisitor::VisitNode(const ExplodedNode *N,
BugReporterContext &BRC,
PathSensitiveBugReport &BR) {
// We can only reason about control dependencies within the same stack frame.
- if (Origin->getStackFrame() != N->getStackFrame())
+ if (OriginFrame != N->getStackFrame())
return nullptr;
CFGBlock *NB = const_cast<CFGBlock *>(N->getCFGBlock());
@@ -2020,16 +2024,14 @@ TrackControlDependencyCondBRVisitor::VisitNode(const ExplodedNode *N,
if (!VisitedBlocks.insert(NB).second)
return nullptr;
- CFGBlock *OriginB = const_cast<CFGBlock *>(Origin->getCFGBlock());
-
// TODO: Cache CFGBlocks for each ExplodedNode.
- if (!OriginB || !NB)
+ if (!OriginBlock || !NB)
return nullptr;
if (isAssertlikeBlock(NB, BRC.getASTContext()))
return nullptr;
- if (ControlDeps.isControlDependent(OriginB, NB)) {
+ if (ControlDeps.isControlDependent(OriginBlock, NB)) {
// We don't really want to explain for range loops. Evidence suggests that
// the only thing that leads to is the addition of calls to operator!=.
if (llvm::isa_and_nonnull<CXXForRangeStmt>(NB->getTerminatorStmt()))
diff --git a/clang/test/Analysis/track-control-dependency-reclaimed-node.cpp b/clang/test/Analysis/track-control-dependency-reclaimed-node.cpp
new file mode 100644
index 00000000000000..6e737bd18baaa1
--- /dev/null
+++ b/clang/test/Analysis/track-control-dependency-reclaimed-node.cpp
@@ -0,0 +1,27 @@
+// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-config graph-trim-interval=10 -verify %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-config graph-trim-interval=15 -verify %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-config graph-trim-interval=19 -verify %s
+
+// Condition tracking must not use a node reclaimed before the report is built.
+
+void use(int *);
+
+static unsigned elems(unsigned k) {
+ switch (k) {
+ case 0: return 2;
+ case 1: return 4;
+ default: return 16;
+ }
+}
+
+static void reorder(int **in, unsigned n, unsigned s) {
+ int *t[8];
+ for (unsigned i = 0; i < (n / 16) * s; i += 2)
+ t[i / 2] = in[i];
+ for (unsigned i = 0; i < s; i++)
+ use(t[2 * i]); // expected-warning{{1st function call argument is an uninitialized value}}
+}
+
+void top(int **in, unsigned k, unsigned s) {
+ reorder(in, elems(k) * 16, s);
+}
``````````
</details>
https://github.com/llvm/llvm-project/pull/242711
More information about the cfe-commits
mailing list