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 22 using namespace clang; 23 using namespace ento; 24 25 namespace { 26 27 class ZeroState { 28 private: 29 SymbolRef ZeroSymbol; 30 unsigned BlockID; 31 const StackFrameContext *SFC; 32 33 public: 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(BlockID); 53 ID.AddPointer(SFC); 54 ID.AddPointer(ZeroSymbol); 55 } 56 }; 57 58 class DivisionBRVisitor : public BugReporterVisitor { 59 private: 60 SymbolRef ZeroSymbol; 61 const StackFrameContext *SFC; 62 bool Satisfied; 63 64 public: 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(ZeroSymbol); 70 ID.Add(SFC); 71 } 72 73 PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ, 74 BugReporterContext &BRC, 75 PathSensitiveBugReport &BR) override; 76 }; 77 78 class TestAfterDivZeroChecker 79 : public Checker<check::PreStmt<BinaryOperator>, check::BranchCondition, 80 check::EndFunction> { 81 mutable std::unique_ptr<BuiltinBug> DivZeroBug; 82 void reportBug(SVal Val, CheckerContext &C) const; 83 84 public: 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 94 REGISTER_SET_WITH_PROGRAMSTATE(DivZeroMap, ZeroState) 95 96 PathDiagnosticPieceRef 97 DivisionBRVisitor::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(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, BRC.getSourceManager()); 124 125 if (!L.isValid() || !L.asLocation().isValid()) 126 return nullptr; 127 128 return std::make_shared<PathDiagnosticEventPiece>( 129 L, "Division with compared value made here"); 130 } 131 132 return nullptr; 133 } 134 135 bool 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(C.getState(), *DSV, true); 143 } 144 145 void 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>(ZeroState(SR, C.getBlockID(), C.getStackFrame())); 153 C.addTransition(State); 154 } 155 156 bool 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>(ZS); 164 } 165 166 void TestAfterDivZeroChecker::reportBug(SVal Val, CheckerContext &C) const { 167 if (ExplodedNode *N = C.generateErrorNode(C.getState())) { 168 if (!DivZeroBug) 169 DivZeroBug.reset(new BuiltinBug(this, "Division by zero")); 170 171 auto R = std::make_unique<PathSensitiveBugReport>( 172 *DivZeroBug, "Value being compared against zero has already been used " 173 "for division", 174 N); 175 176 R->addVisitor(std::make_unique<DivisionBRVisitor>(Val.getAsSymbol(), 177 C.getStackFrame())); 178 C.emitReport(std::move(R)); 179 } 180 } 181 182 void TestAfterDivZeroChecker::checkEndFunction(const ReturnStmt *, 183 CheckerContext &C) const { 184 ProgramStateRef State = C.getState(); 185 186 DivZeroMapTy DivZeroes = State->get<DivZeroMap>(); 187 if (DivZeroes.isEmpty()) 188 return; 189 190 DivZeroMapTy::Factory &F = State->get_context<DivZeroMap>(); 191 for (const ZeroState &ZS : DivZeroes) { 192 if (ZS.getStackFrameContext() == C.getStackFrame()) 193 DivZeroes = F.remove(DivZeroes, ZS); 194 } 195 C.addTransition(State->set<DivZeroMap>(DivZeroes)); 196 } 197 198 void TestAfterDivZeroChecker::checkPreStmt(const BinaryOperator *B, 199 CheckerContext &C) const { 200 BinaryOperator::Opcode Op = B->getOpcode(); 201 if (Op == BO_Div || Op == BO_Rem || Op == BO_DivAssign || 202 Op == BO_RemAssign) { 203 SVal S = C.getSVal(B->getRHS()); 204 205 if (!isZero(S, C)) 206 setDivZeroMap(S, C); 207 } 208 } 209 210 void TestAfterDivZeroChecker::checkBranchCondition(const Stmt *Condition, 211 CheckerContext &C) const { 212 if (const BinaryOperator *B = dyn_cast<BinaryOperator>(Condition)) { 213 if (B->isComparisonOp()) { 214 const IntegerLiteral *IntLiteral = dyn_cast<IntegerLiteral>(B->getRHS()); 215 bool LRHS = true; 216 if (!IntLiteral) { 217 IntLiteral = dyn_cast<IntegerLiteral>(B->getLHS()); 218 LRHS = false; 219 } 220 221 if (!IntLiteral || IntLiteral->getValue() != 0) 222 return; 223 224 SVal Val = C.getSVal(LRHS ? B->getLHS() : B->getRHS()); 225 if (hasDivZeroMap(Val, C)) 226 reportBug(Val, C); 227 } 228 } else if (const UnaryOperator *U = dyn_cast<UnaryOperator>(Condition)) { 229 if (U->getOpcode() == UO_LNot) { 230 SVal Val; 231 if (const ImplicitCastExpr *I = 232 dyn_cast<ImplicitCastExpr>(U->getSubExpr())) 233 Val = C.getSVal(I->getSubExpr()); 234 235 if (hasDivZeroMap(Val, C)) 236 reportBug(Val, C); 237 else { 238 Val = C.getSVal(U->getSubExpr()); 239 if (hasDivZeroMap(Val, C)) 240 reportBug(Val, C); 241 } 242 } 243 } else if (const ImplicitCastExpr *IE = 244 dyn_cast<ImplicitCastExpr>(Condition)) { 245 SVal Val = C.getSVal(IE->getSubExpr()); 246 247 if (hasDivZeroMap(Val, C)) 248 reportBug(Val, C); 249 else { 250 SVal Val = C.getSVal(Condition); 251 252 if (hasDivZeroMap(Val, C)) 253 reportBug(Val, C); 254 } 255 } 256 } 257 258 void ento::registerTestAfterDivZeroChecker(CheckerManager &mgr) { 259 mgr.registerChecker<TestAfterDivZeroChecker>(); 260 } 261 262 bool ento::shouldRegisterTestAfterDivZeroChecker(const CheckerManager &mgr) { 263 return true; 264 } 265