1//== TestAfterDivZeroChecker.cpp - Test after division by zero checker --*--==//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This defines TestAfterDivZeroChecker, a builtin check that performs checks
10// for division by zero where the division occurs before comparison with zero.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
15#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
16#include "clang/StaticAnalyzer/Core/Checker.h"
17#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
18#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
19#include "llvm/ADT/FoldingSet.h"
20#include <optional>
21
22using namespace clang;
23using namespace ento;
24
25namespace {
26
27class ZeroState {
28private:
29 SymbolRef ZeroSymbol;
30 unsigned BlockID;
31 const StackFrameContext *SFC;
32
33public:
34 ZeroState(SymbolRef S, unsigned B, const StackFrameContext *SFC)
35 : ZeroSymbol(S), BlockID(B), SFC(SFC) {}
36
37 const StackFrameContext *getStackFrameContext() const { return SFC; }
38
39 bool operator==(const ZeroState &X) const {
40 return BlockID == X.BlockID && SFC == X.SFC && ZeroSymbol == X.ZeroSymbol;
41 }
42
43 bool operator<(const ZeroState &X) const {
44 if (BlockID != X.BlockID)
45 return BlockID < X.BlockID;
46 if (SFC != X.SFC)
47 return SFC < X.SFC;
48 return ZeroSymbol < X.ZeroSymbol;
49 }
50
51 void Profile(llvm::FoldingSetNodeID &ID) const {
52 ID.AddInteger(I: BlockID);
53 ID.AddPointer(Ptr: SFC);
54 ID.AddPointer(Ptr: ZeroSymbol);
55 }
56};
57
58class DivisionBRVisitor : public BugReporterVisitor {
59private:
60 SymbolRef ZeroSymbol;
61 const StackFrameContext *SFC;
62 bool Satisfied;
63
64public:
65 DivisionBRVisitor(SymbolRef ZeroSymbol, const StackFrameContext *SFC)
66 : ZeroSymbol(ZeroSymbol), SFC(SFC), Satisfied(false) {}
67
68 void Profile(llvm::FoldingSetNodeID &ID) const override {
69 ID.Add(x: ZeroSymbol);
70 ID.Add(x: SFC);
71 }
72
73 PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
74 BugReporterContext &BRC,
75 PathSensitiveBugReport &BR) override;
76};
77
78class TestAfterDivZeroChecker
79 : public Checker<check::PreStmt<BinaryOperator>, check::BranchCondition,
80 check::EndFunction> {
81 const BugType DivZeroBug{this, "Division by zero"};
82 void reportBug(SVal Val, CheckerContext &C) const;
83
84public:
85 void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
86 void checkBranchCondition(const Stmt *Condition, CheckerContext &C) const;
87 void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const;
88 void setDivZeroMap(SVal Var, CheckerContext &C) const;
89 bool hasDivZeroMap(SVal Var, const CheckerContext &C) const;
90 bool isZero(SVal S, CheckerContext &C) const;
91};
92} // end anonymous namespace
93
94REGISTER_SET_WITH_PROGRAMSTATE(DivZeroMap, ZeroState)
95
96PathDiagnosticPieceRef
97DivisionBRVisitor::VisitNode(const ExplodedNode *Succ, BugReporterContext &BRC,
98 PathSensitiveBugReport &BR) {
99 if (Satisfied)
100 return nullptr;
101
102 const Expr *E = nullptr;
103
104 if (std::optional<PostStmt> P = Succ->getLocationAs<PostStmt>())
105 if (const BinaryOperator *BO = P->getStmtAs<BinaryOperator>()) {
106 BinaryOperator::Opcode Op = BO->getOpcode();
107 if (Op == BO_Div || Op == BO_Rem || Op == BO_DivAssign ||
108 Op == BO_RemAssign) {
109 E = BO->getRHS();
110 }
111 }
112
113 if (!E)
114 return nullptr;
115
116 SVal S = Succ->getSVal(S: E);
117 if (ZeroSymbol == S.getAsSymbol() && SFC == Succ->getStackFrame()) {
118 Satisfied = true;
119
120 // Construct a new PathDiagnosticPiece.
121 ProgramPoint P = Succ->getLocation();
122 PathDiagnosticLocation L =
123 PathDiagnosticLocation::create(P, SMng: BRC.getSourceManager());
124
125 if (!L.isValid() || !L.asLocation().isValid())
126 return nullptr;
127
128 return std::make_shared<PathDiagnosticEventPiece>(
129 args&: L, args: "Division with compared value made here");
130 }
131
132 return nullptr;
133}
134
135bool TestAfterDivZeroChecker::isZero(SVal S, CheckerContext &C) const {
136 std::optional<DefinedSVal> DSV = S.getAs<DefinedSVal>();
137
138 if (!DSV)
139 return false;
140
141 ConstraintManager &CM = C.getConstraintManager();
142 return !CM.assume(state: C.getState(), Cond: *DSV, Assumption: true);
143}
144
145void TestAfterDivZeroChecker::setDivZeroMap(SVal Var, CheckerContext &C) const {
146 SymbolRef SR = Var.getAsSymbol();
147 if (!SR)
148 return;
149
150 ProgramStateRef State = C.getState();
151 State =
152 State->add<DivZeroMap>(K: ZeroState(SR, C.getBlockID(), C.getStackFrame()));
153 C.addTransition(State);
154}
155
156bool TestAfterDivZeroChecker::hasDivZeroMap(SVal Var,
157 const CheckerContext &C) const {
158 SymbolRef SR = Var.getAsSymbol();
159 if (!SR)
160 return false;
161
162 ZeroState ZS(SR, C.getBlockID(), C.getStackFrame());
163 return C.getState()->contains<DivZeroMap>(key: ZS);
164}
165
166void TestAfterDivZeroChecker::reportBug(SVal Val, CheckerContext &C) const {
167 if (ExplodedNode *N = C.generateErrorNode(State: C.getState())) {
168 auto R = std::make_unique<PathSensitiveBugReport>(
169 args: DivZeroBug,
170 args: "Value being compared against zero has already been used "
171 "for division",
172 args&: N);
173
174 R->addVisitor(visitor: std::make_unique<DivisionBRVisitor>(args: Val.getAsSymbol(),
175 args: C.getStackFrame()));
176 C.emitReport(R: std::move(R));
177 }
178}
179
180void TestAfterDivZeroChecker::checkEndFunction(const ReturnStmt *,
181 CheckerContext &C) const {
182 ProgramStateRef State = C.getState();
183
184 DivZeroMapTy DivZeroes = State->get<DivZeroMap>();
185 if (DivZeroes.isEmpty())
186 return;
187
188 DivZeroMapTy::Factory &F = State->get_context<DivZeroMap>();
189 for (const ZeroState &ZS : DivZeroes) {
190 if (ZS.getStackFrameContext() == C.getStackFrame())
191 DivZeroes = F.remove(Old: DivZeroes, V: ZS);
192 }
193 C.addTransition(State: State->set<DivZeroMap>(DivZeroes));
194}
195
196void TestAfterDivZeroChecker::checkPreStmt(const BinaryOperator *B,
197 CheckerContext &C) const {
198 BinaryOperator::Opcode Op = B->getOpcode();
199 if (Op == BO_Div || Op == BO_Rem || Op == BO_DivAssign ||
200 Op == BO_RemAssign) {
201 SVal S = C.getSVal(S: B->getRHS());
202
203 if (!isZero(S, C))
204 setDivZeroMap(Var: S, C);
205 }
206}
207
208void TestAfterDivZeroChecker::checkBranchCondition(const Stmt *Condition,
209 CheckerContext &C) const {
210 if (const BinaryOperator *B = dyn_cast<BinaryOperator>(Val: Condition)) {
211 if (B->isComparisonOp()) {
212 const IntegerLiteral *IntLiteral = dyn_cast<IntegerLiteral>(Val: B->getRHS());
213 bool LRHS = true;
214 if (!IntLiteral) {
215 IntLiteral = dyn_cast<IntegerLiteral>(Val: B->getLHS());
216 LRHS = false;
217 }
218
219 if (!IntLiteral || IntLiteral->getValue() != 0)
220 return;
221
222 SVal Val = C.getSVal(S: LRHS ? B->getLHS() : B->getRHS());
223 if (hasDivZeroMap(Var: Val, C))
224 reportBug(Val, C);
225 }
226 } else if (const UnaryOperator *U = dyn_cast<UnaryOperator>(Val: Condition)) {
227 if (U->getOpcode() == UO_LNot) {
228 SVal Val;
229 if (const ImplicitCastExpr *I =
230 dyn_cast<ImplicitCastExpr>(Val: U->getSubExpr()))
231 Val = C.getSVal(S: I->getSubExpr());
232
233 if (hasDivZeroMap(Var: Val, C))
234 reportBug(Val, C);
235 else {
236 Val = C.getSVal(S: U->getSubExpr());
237 if (hasDivZeroMap(Var: Val, C))
238 reportBug(Val, C);
239 }
240 }
241 } else if (const ImplicitCastExpr *IE =
242 dyn_cast<ImplicitCastExpr>(Val: Condition)) {
243 SVal Val = C.getSVal(S: IE->getSubExpr());
244
245 if (hasDivZeroMap(Var: Val, C))
246 reportBug(Val, C);
247 else {
248 SVal Val = C.getSVal(S: Condition);
249
250 if (hasDivZeroMap(Var: Val, C))
251 reportBug(Val, C);
252 }
253 }
254}
255
256void ento::registerTestAfterDivZeroChecker(CheckerManager &mgr) {
257 mgr.registerChecker<TestAfterDivZeroChecker>();
258}
259
260bool ento::shouldRegisterTestAfterDivZeroChecker(const CheckerManager &mgr) {
261 return true;
262}
263