1#include "LifetimeModeling.h"
2#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
3#include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
4#include "clang/StaticAnalyzer/Core/Checker.h"
5
6using namespace clang;
7using namespace ento;
8
9namespace {
10class UseAfterLifetimeEnd : public Checker<check::EndFunction> {
11public:
12 void reportDanglingSource(const MemRegion *Source, SVal Val, ExplodedNode *N,
13 CheckerContext &C) const;
14 void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const;
15 const BugType BugMsg{this, "UseAfterLifetimeEnd", "LifetimeBound"};
16};
17
18class UseAfterLifetimeEndBRVisitor : public BugReporterVisitor {
19 SVal BoundVal;
20 const MemRegion *SourceRegion;
21
22public:
23 explicit UseAfterLifetimeEndBRVisitor(SVal Val, const MemRegion *Source)
24 : BoundVal(Val), SourceRegion(Source) {}
25
26 void Profile(llvm::FoldingSetNodeID &ID) const override {
27 static int X = 0;
28 ID.AddPointer(Ptr: &X);
29 BoundVal.Profile(ID);
30 SourceRegion->Profile(ID);
31 }
32
33 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
34 BugReporterContext &BRC,
35 PathSensitiveBugReport &BR) override;
36 PathDiagnosticPieceRef getEndPath(const ExplodedNode *N,
37 BugReporterContext &BRC,
38 PathSensitiveBugReport &BR) override;
39 PathDiagnosticPieceRef createSourcePiece(const ExplodedNode *N,
40 BugReporterContext &BRC,
41 StringRef Message) const;
42};
43
44} // namespace
45
46static const Expr *getLifetimeBoundArg(const Expr *RetExpr,
47 const MemRegion *Region,
48 const ExplodedNode *N) {
49 const CallExpr *Expr = dyn_cast_or_null<CallExpr>(Val: RetExpr);
50 if (!Expr)
51 return nullptr;
52
53 const FunctionDecl *FD = Expr->getDirectCallee();
54 if (!FD)
55 return nullptr;
56
57 const MemRegion *BaseReg = Region->getBaseRegion();
58
59 for (const ParmVarDecl *PVD : FD->parameters()) {
60 if (!PVD->hasAttr<LifetimeBoundAttr>())
61 continue;
62 unsigned Idx = PVD->getFunctionScopeIndex();
63
64 if (Idx >= Expr->getNumArgs())
65 continue;
66
67 const MemRegion *R = N->getSVal(E: Expr->getArg(Arg: Idx)).getAsRegion();
68 if (R && R->getBaseRegion() == BaseReg)
69 return Expr->getArg(Arg: Idx);
70 }
71 return nullptr;
72}
73
74void UseAfterLifetimeEnd::checkEndFunction(const ReturnStmt *RS,
75 CheckerContext &C) const {
76 if (!RS)
77 return;
78
79 ProgramStateRef State = C.getState();
80
81 const Expr *RetExpr = RS->getRetValue();
82 if (!RetExpr)
83 return;
84
85 RetExpr = RetExpr->IgnoreParens();
86 SVal RetVal = C.getSVal(E: RetExpr);
87
88 std::vector<const MemRegion *> RetValRegion =
89 lifetime_modeling::getDanglingRegionsAfterReturn(Source: RetVal, State, C);
90 if (RetValRegion.empty())
91 return;
92
93 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
94 for (const MemRegion *R : RetValRegion)
95 reportDanglingSource(Source: R, Val: RetVal, N, C);
96 }
97}
98
99static SourceRange getRegionDeclRange(const MemRegion *Source) {
100 if (const auto *VR = dyn_cast_or_null<VarRegion>(Val: Source)) {
101 const VarDecl *VD = VR->getDecl();
102 return SourceRange(VD->getLocation());
103 }
104 return SourceRange();
105}
106
107void UseAfterLifetimeEnd::reportDanglingSource(const MemRegion *Source,
108 SVal RetVal, ExplodedNode *N,
109 CheckerContext &C) const {
110 auto BR = std::make_unique<PathSensitiveBugReport>(
111 args: BugMsg,
112 args: (llvm::Twine("Returning value bound to ") +
113 lifetime_modeling::getRegionName(Reg: Source) + " that will go out of scope"),
114 args&: N);
115
116 if (SourceRange Range = getRegionDeclRange(Source); Range.isValid())
117 BR->addRange(R: Range);
118
119 BR->addVisitor<UseAfterLifetimeEndBRVisitor>(ConstructorArgs&: RetVal, ConstructorArgs&: Source);
120 bugreporter::trackStoredValue(V: RetVal, R: Source, Report&: *BR);
121 C.emitReport(R: std::move(BR));
122}
123
124PathDiagnosticPieceRef UseAfterLifetimeEndBRVisitor::createSourcePiece(
125 const ExplodedNode *N, BugReporterContext &BRC, StringRef Message) const {
126 const Stmt *S = N->getStmtForDiagnostics();
127 if (!S)
128 return nullptr;
129
130 const Expr *RetExpr = dyn_cast_or_null<Expr>(Val: S);
131 const Expr *Arg = getLifetimeBoundArg(RetExpr, Region: SourceRegion, N);
132
133 PathDiagnosticLocation Pos;
134
135 Pos = PathDiagnosticLocation(Arg ? Arg : S, BRC.getSourceManager(),
136 N->getStackFrame());
137
138 auto Note = std::make_shared<PathDiagnosticEventPiece>(args&: Pos, args&: Message, args: true);
139 if (SourceRange Range = getRegionDeclRange(Source: SourceRegion); Range.isValid())
140 Note->addRange(R: Range);
141
142 return Note;
143}
144
145PathDiagnosticPieceRef
146UseAfterLifetimeEndBRVisitor::VisitNode(const ExplodedNode *N,
147 BugReporterContext &BRC,
148 PathSensitiveBugReport &BR) {
149 const ExplodedNode *Pred = N->getFirstPred();
150 if (!Pred)
151 return nullptr;
152
153 if (!lifetime_modeling::isBoundToLifetimeSource(State: N->getState(), Val: BoundVal) ||
154 lifetime_modeling::isBoundToLifetimeSource(State: Pred->getState(), Val: BoundVal))
155 return nullptr;
156
157 auto Piece = createSourcePiece(
158 N, BRC,
159 Message: (llvm::Twine("Value's lifetime bound to the lifetime of ") +
160 lifetime_modeling::getRegionName(Reg: SourceRegion) + " here")
161 .str());
162 return Piece;
163}
164
165PathDiagnosticPieceRef
166UseAfterLifetimeEndBRVisitor::getEndPath(const ExplodedNode *N,
167 BugReporterContext &BRC,
168 PathSensitiveBugReport &BR) {
169 auto Piece = createSourcePiece(
170 N, BRC,
171 Message: (llvm::Twine("Lifetime of ") +
172 lifetime_modeling::getRegionName(Reg: SourceRegion) + " ended here")
173 .str());
174 return Piece;
175}
176
177void ento::registerUseAfterLifetimeEnd(CheckerManager &Mgr) {
178 Mgr.registerChecker<UseAfterLifetimeEnd>();
179}
180
181bool ento::shouldRegisterUseAfterLifetimeEnd(const CheckerManager &Mgr) {
182 return true;
183}
184