| 1 |
//===-- NullabilityChecker.cpp - Nullability 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 checker tries to find nullability violations. There are several kinds of |
| 10 |
// possible violations: |
| 11 |
// * Null pointer is passed to a pointer which has a _Nonnull type. |
| 12 |
// * Null pointer is returned from a function which has a _Nonnull return type. |
| 13 |
// * Nullable pointer is passed to a pointer which has a _Nonnull type. |
| 14 |
// * Nullable pointer is returned from a function which has a _Nonnull return |
| 15 |
// type. |
| 16 |
// * Nullable pointer is dereferenced. |
| 17 |
// |
| 18 |
// This checker propagates the nullability information of the pointers and looks |
| 19 |
// for the patterns that are described above. Explicit casts are trusted and are |
| 20 |
// considered a way to suppress false positives for this checker. The other way |
| 21 |
// to suppress warnings would be to add asserts or guarding if statements to the |
| 22 |
// code. In addition to the nullability propagation this checker also uses some |
| 23 |
// heuristics to suppress potential false positives. |
| 24 |
// |
| 25 |
//===----------------------------------------------------------------------===// |
| 26 |
|
| 27 |
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" |
| 28 |
|
| 29 |
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" |
| 30 |
#include "clang/StaticAnalyzer/Core/Checker.h" |
| 31 |
#include "clang/StaticAnalyzer/Core/CheckerManager.h" |
| 32 |
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h" |
| 33 |
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" |
| 34 |
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" |
| 35 |
|
| 36 |
#include "llvm/ADT/StringExtras.h" |
| 37 |
#include "llvm/Support/Path.h" |
| 38 |
|
| 39 |
using namespace clang; |
| 40 |
using namespace ento; |
| 41 |
|
| 42 |
namespace { |
| 43 |
|
| 44 |
/// Returns the most nullable nullability. This is used for message expressions |
| 45 |
/// like [receiver method], where the nullability of this expression is either |
| 46 |
/// the nullability of the receiver or the nullability of the return type of the |
| 47 |
/// method, depending on which is more nullable. Contradicted is considered to |
| 48 |
/// be the most nullable, to avoid false positive results. |
| 49 |
Nullability getMostNullable(Nullability Lhs, Nullability Rhs) { |
| 50 |
return static_cast<Nullability>( |
| 51 |
std::min(static_cast<char>(Lhs), static_cast<char>(Rhs))); |
| 52 |
} |
| 53 |
|
| 54 |
const char *getNullabilityString(Nullability Nullab) { |
| 55 |
switch (Nullab) { |
| 56 |
case Nullability::Contradicted: |
| 57 |
return "contradicted"; |
| 58 |
case Nullability::Nullable: |
| 59 |
return "nullable"; |
| 60 |
case Nullability::Unspecified: |
| 61 |
return "unspecified"; |
| 62 |
case Nullability::Nonnull: |
| 63 |
return "nonnull"; |
| 64 |
} |
| 65 |
llvm_unreachable("Unexpected enumeration."); |
| 66 |
return ""; |
| 67 |
} |
| 68 |
|
| 69 |
// These enums are used as an index to ErrorMessages array. |
| 70 |
enum class ErrorKind : int { |
| 71 |
NilAssignedToNonnull, |
| 72 |
NilPassedToNonnull, |
| 73 |
NilReturnedToNonnull, |
| 74 |
NullableAssignedToNonnull, |
| 75 |
NullableReturnedToNonnull, |
| 76 |
NullableDereferenced, |
| 77 |
NullablePassedToNonnull |
| 78 |
}; |
| 79 |
|
| 80 |
class NullabilityChecker |
| 81 |
: public Checker<check::Bind, check::PreCall, check::PreStmt<ReturnStmt>, |
| 82 |
check::PostCall, check::PostStmt<ExplicitCastExpr>, |
| 83 |
check::PostObjCMessage, check::DeadSymbols, eval::Assume, |
| 84 |
check::Location, check::Event<ImplicitNullDerefEvent>> { |
| 85 |
|
| 86 |
public: |
| 87 |
// If true, the checker will not diagnose nullabilility issues for calls |
| 88 |
// to system headers. This option is motivated by the observation that large |
| 89 |
// projects may have many nullability warnings. These projects may |
| 90 |
// find warnings about nullability annotations that they have explicitly |
| 91 |
// added themselves higher priority to fix than warnings on calls to system |
| 92 |
// libraries. |
| 93 |
bool NoDiagnoseCallsToSystemHeaders = false; |
| 94 |
|
| 95 |
void checkBind(SVal L, SVal V, const Stmt *S, CheckerContext &C) const; |
| 96 |
void checkPostStmt(const ExplicitCastExpr *CE, CheckerContext &C) const; |
| 97 |
void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const; |
| 98 |
void checkPostObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const; |
| 99 |
void checkPostCall(const CallEvent &Call, CheckerContext &C) const; |
| 100 |
void checkPreCall(const CallEvent &Call, CheckerContext &C) const; |
| 101 |
void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const; |
| 102 |
void checkEvent(ImplicitNullDerefEvent Event) const; |
| 103 |
void checkLocation(SVal Location, bool IsLoad, const Stmt *S, |
| 104 |
CheckerContext &C) const; |
| 105 |
ProgramStateRef evalAssume(ProgramStateRef State, SVal Cond, |
| 106 |
bool Assumption) const; |
| 107 |
|
| 108 |
void printState(raw_ostream &Out, ProgramStateRef State, const char *NL, |
| 109 |
const char *Sep) const override; |
| 110 |
|
| 111 |
enum CheckKind { |
| 112 |
CK_NullPassedToNonnull, |
| 113 |
CK_NullReturnedFromNonnull, |
| 114 |
CK_NullableDereferenced, |
| 115 |
CK_NullablePassedToNonnull, |
| 116 |
CK_NullableReturnedFromNonnull, |
| 117 |
CK_NumCheckKinds |
| 118 |
}; |
| 119 |
|
| 120 |
bool ChecksEnabled[CK_NumCheckKinds] = {false}; |
| 121 |
CheckerNameRef CheckNames[CK_NumCheckKinds]; |
| 122 |
mutable std::unique_ptr<BugType> BTs[CK_NumCheckKinds]; |
| 123 |
|
| 124 |
const std::unique_ptr<BugType> &getBugType(CheckKind Kind) const { |
| 125 |
if (!BTs[Kind]) |
| 126 |
BTs[Kind].reset(new BugType(CheckNames[Kind], "Nullability", |
| 127 |
categories::MemoryError)); |
| 128 |
return BTs[Kind]; |
| 129 |
} |
| 130 |
|
| 131 |
// When set to false no nullability information will be tracked in |
| 132 |
// NullabilityMap. It is possible to catch errors like passing a null pointer |
| 133 |
// to a callee that expects nonnull argument without the information that is |
| 134 |
// stored in the NullabilityMap. This is an optimization. |
| 135 |
bool NeedTracking = false; |
| 136 |
|
| 137 |
private: |
| 138 |
class NullabilityBugVisitor : public BugReporterVisitor { |
| 139 |
public: |
| 140 |
NullabilityBugVisitor(const MemRegion *M) : Region(M) {} |
| 141 |
|
| 142 |
void Profile(llvm::FoldingSetNodeID &ID) const override { |
| 143 |
static int X = 0; |
| 144 |
ID.AddPointer(&X); |
| 145 |
ID.AddPointer(Region); |
| 146 |
} |
| 147 |
|
| 148 |
PathDiagnosticPieceRef VisitNode(const ExplodedNode *N, |
| 149 |
BugReporterContext &BRC, |
| 150 |
PathSensitiveBugReport &BR) override; |
| 151 |
|
| 152 |
private: |
| 153 |
// The tracked region. |
| 154 |
const MemRegion *Region; |
| 155 |
}; |
| 156 |
|
| 157 |
/// When any of the nonnull arguments of the analyzed function is null, do not |
| 158 |
/// report anything and turn off the check. |
| 159 |
/// |
| 160 |
/// When \p SuppressPath is set to true, no more bugs will be reported on this |
| 161 |
/// path by this checker. |
| 162 |
void reportBugIfInvariantHolds(StringRef Msg, ErrorKind Error, CheckKind CK, |
| 163 |
ExplodedNode *N, const MemRegion *Region, |
| 164 |
CheckerContext &C, |
| 165 |
const Stmt *ValueExpr = nullptr, |
| 166 |
bool SuppressPath = false) const; |
| 167 |
|
| 168 |
void reportBug(StringRef Msg, ErrorKind Error, CheckKind CK, ExplodedNode *N, |
| 169 |
const MemRegion *Region, BugReporter &BR, |
| 170 |
const Stmt *ValueExpr = nullptr) const { |
| 171 |
const std::unique_ptr<BugType> &BT = getBugType(CK); |
| 172 |
auto R = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N); |
| 173 |
if (Region) { |
| 174 |
R->markInteresting(Region); |
| 175 |
R->addVisitor<NullabilityBugVisitor>(Region); |
| 176 |
} |
| 177 |
if (ValueExpr) { |
| 178 |
R->addRange(ValueExpr->getSourceRange()); |
| 179 |
if (Error == ErrorKind::NilAssignedToNonnull || |
| 180 |
Error == ErrorKind::NilPassedToNonnull || |
| 181 |
Error == ErrorKind::NilReturnedToNonnull) |
| 182 |
if (const auto *Ex = dyn_cast<Expr>(ValueExpr)) |
| 183 |
bugreporter::trackExpressionValue(N, Ex, *R); |
| 184 |
} |
| 185 |
BR.emitReport(std::move(R)); |
| 186 |
} |
| 187 |
|
| 188 |
/// If an SVal wraps a region that should be tracked, it will return a pointer |
| 189 |
/// to the wrapped region. Otherwise it will return a nullptr. |
| 190 |
const SymbolicRegion *getTrackRegion(SVal Val, |
| 191 |
bool CheckSuperRegion = false) const; |
| 192 |
|
| 193 |
/// Returns true if the call is diagnosable in the current analyzer |
| 194 |
/// configuration. |
| 195 |
bool isDiagnosableCall(const CallEvent &Call) const { |
| 196 |
if (NoDiagnoseCallsToSystemHeaders && Call.isInSystemHeader()) |
| 197 |
return false; |
| 198 |
|
| 199 |
return true; |
| 200 |
} |
| 201 |
}; |
| 202 |
|
| 203 |
class NullabilityState { |
| 204 |
public: |
| 205 |
NullabilityState(Nullability Nullab, const Stmt *Source = nullptr) |
| 206 |
: Nullab(Nullab), Source(Source) {} |
| 207 |
|
| 208 |
const Stmt *getNullabilitySource() const { return Source; } |
| 209 |
|
| 210 |
Nullability getValue() const { return Nullab; } |
| 211 |
|
| 212 |
void Profile(llvm::FoldingSetNodeID &ID) const { |
| 213 |
ID.AddInteger(static_cast<char>(Nullab)); |
| 214 |
ID.AddPointer(Source); |
| 215 |
} |
| 216 |
|
| 217 |
void print(raw_ostream &Out) const { |
| 218 |
Out << getNullabilityString(Nullab) << "\n"; |
| 219 |
} |
| 220 |
|
| 221 |
private: |
| 222 |
Nullability Nullab; |
| 223 |
// Source is the expression which determined the nullability. For example in a |
| 224 |
// message like [nullable nonnull_returning] has nullable nullability, because |
| 225 |
// the receiver is nullable. Here the receiver will be the source of the |
| 226 |
// nullability. This is useful information when the diagnostics are generated. |
| 227 |
const Stmt *Source; |
| 228 |
}; |
| 229 |
|
| 230 |
bool operator==(NullabilityState Lhs, NullabilityState Rhs) { |
| 231 |
return Lhs.getValue() == Rhs.getValue() && |
| 232 |
Lhs.getNullabilitySource() == Rhs.getNullabilitySource(); |
| 233 |
} |
| 234 |
|
| 235 |
// For the purpose of tracking historical property accesses, the key for lookup |
| 236 |
// is an object pointer (could be an instance or a class) paired with the unique |
| 237 |
// identifier for the property being invoked on that object. |
| 238 |
using ObjectPropPair = std::pair<const MemRegion *, const IdentifierInfo *>; |
| 239 |
|
| 240 |
// Metadata associated with the return value from a recorded property access. |
| 241 |
struct ConstrainedPropertyVal { |
| 242 |
// This will reference the conjured return SVal for some call |
| 243 |
// of the form [object property] |
| 244 |
DefinedOrUnknownSVal Value; |
| 245 |
|
| 246 |
// If the SVal has been determined to be nonnull, that is recorded here |
| 247 |
bool isConstrainedNonnull; |
| 248 |
|
| 249 |
ConstrainedPropertyVal(DefinedOrUnknownSVal SV) |
| 250 |
: Value(SV), isConstrainedNonnull(false) {} |
| 251 |
|
| 252 |
void Profile(llvm::FoldingSetNodeID &ID) const { |
| 253 |
Value.Profile(ID); |
| 254 |
ID.AddInteger(isConstrainedNonnull ? 1 : 0); |
| 255 |
} |
| 256 |
}; |
| 257 |
|
| 258 |
bool operator==(const ConstrainedPropertyVal &Lhs, |
| 259 |
const ConstrainedPropertyVal &Rhs) { |
| 260 |
return Lhs.Value == Rhs.Value && |
| 261 |
Lhs.isConstrainedNonnull == Rhs.isConstrainedNonnull; |
| 262 |
} |
| 263 |
|
| 264 |
} // end anonymous namespace |
| 265 |
|
| 266 |
REGISTER_MAP_WITH_PROGRAMSTATE(NullabilityMap, const MemRegion *, |
| 267 |
NullabilityState) |
| 268 |
REGISTER_MAP_WITH_PROGRAMSTATE(PropertyAccessesMap, ObjectPropPair, |
| 269 |
ConstrainedPropertyVal) |
| 270 |
|
| 271 |
// We say "the nullability type invariant is violated" when a location with a |
| 272 |
// non-null type contains NULL or a function with a non-null return type returns |
| 273 |
// NULL. Violations of the nullability type invariant can be detected either |
| 274 |
// directly (for example, when NULL is passed as an argument to a nonnull |
| 275 |
// parameter) or indirectly (for example, when, inside a function, the |
| 276 |
// programmer defensively checks whether a nonnull parameter contains NULL and |
| 277 |
// finds that it does). |
| 278 |
// |
| 279 |
// As a matter of policy, the nullability checker typically warns on direct |
| 280 |
// violations of the nullability invariant (although it uses various |
| 281 |
// heuristics to suppress warnings in some cases) but will not warn if the |
| 282 |
// invariant has already been violated along the path (either directly or |
| 283 |
// indirectly). As a practical matter, this prevents the analyzer from |
| 284 |
// (1) warning on defensive code paths where a nullability precondition is |
| 285 |
// determined to have been violated, (2) warning additional times after an |
| 286 |
// initial direct violation has been discovered, and (3) warning after a direct |
| 287 |
// violation that has been implicitly or explicitly suppressed (for |
| 288 |
// example, with a cast of NULL to _Nonnull). In essence, once an invariant |
| 289 |
// violation is detected on a path, this checker will be essentially turned off |
| 290 |
// for the rest of the analysis |
| 291 |
// |
| 292 |
// The analyzer takes this approach (rather than generating a sink node) to |
| 293 |
// ensure coverage of defensive paths, which may be important for backwards |
| 294 |
// compatibility in codebases that were developed without nullability in mind. |
| 295 |
REGISTER_TRAIT_WITH_PROGRAMSTATE(InvariantViolated, bool) |
| 296 |
|
| 297 |
enum class NullConstraint { IsNull, IsNotNull, Unknown }; |
| 298 |
|
| 299 |
static NullConstraint getNullConstraint(DefinedOrUnknownSVal Val, |
| 300 |
ProgramStateRef State) { |
| 301 |
ConditionTruthVal Nullness = State->isNull(Val); |
| 302 |
if (Nullness.isConstrainedFalse()) |
| 303 |
return NullConstraint::IsNotNull; |
| 304 |
if (Nullness.isConstrainedTrue()) |
| 305 |
return NullConstraint::IsNull; |
| 306 |
return NullConstraint::Unknown; |
| 307 |
} |
| 308 |
|
| 309 |
const SymbolicRegion * |
| 310 |
NullabilityChecker::getTrackRegion(SVal Val, bool CheckSuperRegion) const { |
| 311 |
if (!NeedTracking) |
| 312 |
return nullptr; |
| 313 |
|
| 314 |
auto RegionSVal = Val.getAs<loc::MemRegionVal>(); |
| 315 |
if (!RegionSVal) |
| 316 |
return nullptr; |
| 317 |
|
| 318 |
const MemRegion *Region = RegionSVal->getRegion(); |
| 319 |
|
| 320 |
if (CheckSuperRegion) { |
| 321 |
if (const SubRegion *FieldReg = Region->getAs<FieldRegion>()) { |
| 322 |
if (const auto *ER = dyn_cast<ElementRegion>(FieldReg->getSuperRegion())) |
| 323 |
FieldReg = ER; |
| 324 |
return dyn_cast<SymbolicRegion>(FieldReg->getSuperRegion()); |
| 325 |
} |
| 326 |
if (auto ElementReg = Region->getAs<ElementRegion>()) |
| 327 |
return dyn_cast<SymbolicRegion>(ElementReg->getSuperRegion()); |
| 328 |
} |
| 329 |
|
| 330 |
return dyn_cast<SymbolicRegion>(Region); |
| 331 |
} |
| 332 |
|
| 333 |
PathDiagnosticPieceRef NullabilityChecker::NullabilityBugVisitor::VisitNode( |
| 334 |
const ExplodedNode *N, BugReporterContext &BRC, |
| 335 |
PathSensitiveBugReport &BR) { |
| 336 |
ProgramStateRef State = N->getState(); |
| 337 |
ProgramStateRef StatePrev = N->getFirstPred()->getState(); |
| 338 |
|
| 339 |
const NullabilityState *TrackedNullab = State->get<NullabilityMap>(Region); |
| 340 |
const NullabilityState *TrackedNullabPrev = |
| 341 |
StatePrev->get<NullabilityMap>(Region); |
| 342 |
if (!TrackedNullab) |
| 343 |
return nullptr; |
| 344 |
|
| 345 |
if (TrackedNullabPrev && |
| 346 |
TrackedNullabPrev->getValue() == TrackedNullab->getValue()) |
| 347 |
return nullptr; |
| 348 |
|
| 349 |
// Retrieve the associated statement. |
| 350 |
const Stmt *S = TrackedNullab->getNullabilitySource(); |
| 351 |
if (!S || S->getBeginLoc().isInvalid()) { |
| 352 |
S = N->getStmtForDiagnostics(); |
| 353 |
} |
| 354 |
|
| 355 |
if (!S) |
| 356 |
return nullptr; |
| 357 |
|
| 358 |
std::string InfoText = |
| 359 |
(llvm::Twine("Nullability '") + |
| 360 |
getNullabilityString(TrackedNullab->getValue()) + "' is inferred") |
| 361 |
.str(); |
| 362 |
|
| 363 |
// Generate the extra diagnostic. |
| 364 |
PathDiagnosticLocation Pos(S, BRC.getSourceManager(), |
| 365 |
N->getLocationContext()); |
| 366 |
return std::make_shared<PathDiagnosticEventPiece>(Pos, InfoText, true); |
| 367 |
} |
| 368 |
|
| 369 |
/// Returns true when the value stored at the given location has been |
| 370 |
/// constrained to null after being passed through an object of nonnnull type. |
| 371 |
static bool checkValueAtLValForInvariantViolation(ProgramStateRef State, |
| 372 |
SVal LV, QualType T) { |
| 373 |
if (getNullabilityAnnotation(T) != Nullability::Nonnull) |
| 374 |
return false; |
| 375 |
|
| 376 |
auto RegionVal = LV.getAs<loc::MemRegionVal>(); |
| 377 |
if (!RegionVal) |
| 378 |
return false; |
| 379 |
|
| 380 |
// If the value was constrained to null *after* it was passed through that |
| 381 |
// location, it could not have been a concrete pointer *when* it was passed. |
| 382 |
// In that case we would have handled the situation when the value was |
| 383 |
// bound to that location, by emitting (or not emitting) a report. |
| 384 |
// Therefore we are only interested in symbolic regions that can be either |
| 385 |
// null or non-null depending on the value of their respective symbol. |
| 386 |
auto StoredVal = State->getSVal(*RegionVal).getAs<loc::MemRegionVal>(); |
| 387 |
if (!StoredVal || !isa<SymbolicRegion>(StoredVal->getRegion())) |
| 388 |
return false; |
| 389 |
|
| 390 |
if (getNullConstraint(*StoredVal, State) == NullConstraint::IsNull) |
| 391 |
return true; |
| 392 |
|
| 393 |
return false; |
| 394 |
} |
| 395 |
|
| 396 |
static bool |
| 397 |
checkParamsForPreconditionViolation(ArrayRef<ParmVarDecl *> Params, |
| 398 |
ProgramStateRef State, |
| 399 |
const LocationContext *LocCtxt) { |
| 400 |
for (const auto *ParamDecl : Params) { |
| 401 |
if (ParamDecl->isParameterPack()) |
| 402 |
break; |
| 403 |
|
| 404 |
SVal LV = State->getLValue(ParamDecl, LocCtxt); |
| 405 |
if (checkValueAtLValForInvariantViolation(State, LV, |
| 406 |
ParamDecl->getType())) { |
| 407 |
return true; |
| 408 |
} |
| 409 |
} |
| 410 |
return false; |
| 411 |
} |
| 412 |
|
| 413 |
static bool |
| 414 |
checkSelfIvarsForInvariantViolation(ProgramStateRef State, |
| 415 |
const LocationContext *LocCtxt) { |
| 416 |
auto *MD = dyn_cast<ObjCMethodDecl>(LocCtxt->getDecl()); |
| 417 |
if (!MD || !MD->isInstanceMethod()) |
| 418 |
return false; |
| 419 |
|
| 420 |
const ImplicitParamDecl *SelfDecl = LocCtxt->getSelfDecl(); |
| 421 |
if (!SelfDecl) |
| 422 |
return false; |
| 423 |
|
| 424 |
SVal SelfVal = State->getSVal(State->getRegion(SelfDecl, LocCtxt)); |
| 425 |
|
| 426 |
const ObjCObjectPointerType *SelfType = |
| 427 |
dyn_cast<ObjCObjectPointerType>(SelfDecl->getType()); |
| 428 |
if (!SelfType) |
| 429 |
return false; |
| 430 |
|
| 431 |
const ObjCInterfaceDecl *ID = SelfType->getInterfaceDecl(); |
| 432 |
if (!ID) |
| 433 |
return false; |
| 434 |
|
| 435 |
for (const auto *IvarDecl : ID->ivars()) { |
| 436 |
SVal LV = State->getLValue(IvarDecl, SelfVal); |
| 437 |
if (checkValueAtLValForInvariantViolation(State, LV, IvarDecl->getType())) { |
| 438 |
return true; |
| 439 |
} |
| 440 |
} |
| 441 |
return false; |
| 442 |
} |
| 443 |
|
| 444 |
static bool checkInvariantViolation(ProgramStateRef State, ExplodedNode *N, |
| 445 |
CheckerContext &C) { |
| 446 |
if (State->get<InvariantViolated>()) |
| 447 |
return true; |
| 448 |
|
| 449 |
const LocationContext *LocCtxt = C.getLocationContext(); |
| 450 |
const Decl *D = LocCtxt->getDecl(); |
| 451 |
if (!D) |
| 452 |
return false; |
| 453 |
|
| 454 |
ArrayRef<ParmVarDecl*> Params; |
| 455 |
if (const auto *BD = dyn_cast<BlockDecl>(D)) |
| 456 |
Params = BD->parameters(); |
| 457 |
else if (const auto *FD = dyn_cast<FunctionDecl>(D)) |
| 458 |
Params = FD->parameters(); |
| 459 |
else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) |
| 460 |
Params = MD->parameters(); |
| 461 |
else |
| 462 |
return false; |
| 463 |
|
| 464 |
if (checkParamsForPreconditionViolation(Params, State, LocCtxt) || |
| 465 |
checkSelfIvarsForInvariantViolation(State, LocCtxt)) { |
| 466 |
if (!N->isSink()) |
| 467 |
C.addTransition(State->set<InvariantViolated>(true), N); |
| 468 |
return true; |
| 469 |
} |
| 470 |
return false; |
| 471 |
} |
| 472 |
|
| 473 |
void NullabilityChecker::reportBugIfInvariantHolds( |
| 474 |
StringRef Msg, ErrorKind Error, CheckKind CK, ExplodedNode *N, |
| 475 |
const MemRegion *Region, CheckerContext &C, const Stmt *ValueExpr, |
| 476 |
bool SuppressPath) const { |
| 477 |
ProgramStateRef OriginalState = N->getState(); |
| 478 |
|
| 479 |
if (checkInvariantViolation(OriginalState, N, C)) |
| 480 |
return; |
| 481 |
if (SuppressPath) { |
| 482 |
OriginalState = OriginalState->set<InvariantViolated>(true); |
| 483 |
N = C.addTransition(OriginalState, N); |
| 484 |
} |
| 485 |
|
| 486 |
reportBug(Msg, Error, CK, N, Region, C.getBugReporter(), ValueExpr); |
| 487 |
} |
| 488 |
|
| 489 |
/// Cleaning up the program state. |
| 490 |
void NullabilityChecker::checkDeadSymbols(SymbolReaper &SR, |
| 491 |
CheckerContext &C) const { |
| 492 |
ProgramStateRef State = C.getState(); |
| 493 |
NullabilityMapTy Nullabilities = State->get<NullabilityMap>(); |
| 494 |
for (NullabilityMapTy::iterator I = Nullabilities.begin(), |
| 495 |
E = Nullabilities.end(); |
| 496 |
I != E; ++I) { |
| 497 |
const auto *Region = I->first->getAs<SymbolicRegion>(); |
| 498 |
assert(Region && "Non-symbolic region is tracked."); |
| 499 |
if (SR.isDead(Region->getSymbol())) { |
| 500 |
State = State->remove<NullabilityMap>(I->first); |
| 501 |
} |
| 502 |
} |
| 503 |
|
| 504 |
// When an object goes out of scope, we can free the history associated |
| 505 |
// with any property accesses on that object |
| 506 |
PropertyAccessesMapTy PropertyAccesses = State->get<PropertyAccessesMap>(); |
| 507 |
for (PropertyAccessesMapTy::iterator I = PropertyAccesses.begin(), |
| 508 |
E = PropertyAccesses.end(); |
| 509 |
I != E; ++I) { |
| 510 |
const MemRegion *ReceiverRegion = I->first.first; |
| 511 |
if (!SR.isLiveRegion(ReceiverRegion)) { |
| 512 |
State = State->remove<PropertyAccessesMap>(I->first); |
| 513 |
} |
| 514 |
} |
| 515 |
|
| 516 |
// When one of the nonnull arguments are constrained to be null, nullability |
| 517 |
// preconditions are violated. It is not enough to check this only when we |
| 518 |
// actually report an error, because at that time interesting symbols might be |
| 519 |
// reaped. |
| 520 |
if (checkInvariantViolation(State, C.getPredecessor(), C)) |
| 521 |
return; |
| 522 |
C.addTransition(State); |
| 523 |
} |
| 524 |
|
| 525 |
/// This callback triggers when a pointer is dereferenced and the analyzer does |
| 526 |
/// not know anything about the value of that pointer. When that pointer is |
| 527 |
/// nullable, this code emits a warning. |
| 528 |
void NullabilityChecker::checkEvent(ImplicitNullDerefEvent Event) const { |
| 529 |
if (Event.SinkNode->getState()->get<InvariantViolated>()) |
| 530 |
return; |
| 531 |
|
| 532 |
const MemRegion *Region = |
| 533 |
getTrackRegion(Event.Location, /*CheckSuperRegion=*/true); |
| 534 |
if (!Region) |
| 535 |
return; |
| 536 |
|
| 537 |
ProgramStateRef State = Event.SinkNode->getState(); |
| 538 |
const NullabilityState *TrackedNullability = |
| 539 |
State->get<NullabilityMap>(Region); |
| 540 |
|
| 541 |
if (!TrackedNullability) |
| 542 |
return; |
| 543 |
|
| 544 |
if (ChecksEnabled[CK_NullableDereferenced] && |
| 545 |
TrackedNullability->getValue() == Nullability::Nullable) { |
| 546 |
BugReporter &BR = *Event.BR; |
| 547 |
// Do not suppress errors on defensive code paths, because dereferencing |
| 548 |
// a nullable pointer is always an error. |
| 549 |
if (Event.IsDirectDereference) |
| 550 |
reportBug("Nullable pointer is dereferenced", |
| 551 |
ErrorKind::NullableDereferenced, CK_NullableDereferenced, |
| 552 |
Event.SinkNode, Region, BR); |
| 553 |
else { |
| 554 |
reportBug("Nullable pointer is passed to a callee that requires a " |
| 555 |
"non-null", |
| 556 |
ErrorKind::NullablePassedToNonnull, CK_NullableDereferenced, |
| 557 |
Event.SinkNode, Region, BR); |
| 558 |
} |
| 559 |
} |
| 560 |
} |
| 561 |
|
| 562 |
// Whenever we see a load from a typed memory region that's been annotated as |
| 563 |
// 'nonnull', we want to trust the user on that and assume that it is is indeed |
| 564 |
// non-null. |
| 565 |
// |
| 566 |
// We do so even if the value is known to have been assigned to null. |
| 567 |
// The user should be warned on assigning the null value to a non-null pointer |
| 568 |
// as opposed to warning on the later dereference of this pointer. |
| 569 |
// |
| 570 |
// \code |
| 571 |
// int * _Nonnull var = 0; // we want to warn the user here... |
| 572 |
// // . . . |
| 573 |
// *var = 42; // ...and not here |
| 574 |
// \endcode |
| 575 |
void NullabilityChecker::checkLocation(SVal Location, bool IsLoad, |
| 576 |
const Stmt *S, |
| 577 |
CheckerContext &Context) const { |
| 578 |
// We should care only about loads. |
| 579 |
// The main idea is to add a constraint whenever we're loading a value from |
| 580 |
// an annotated pointer type. |
| 581 |
if (!IsLoad) |
| 582 |
return; |
| 583 |
|
| 584 |
// Annotations that we want to consider make sense only for types. |
| 585 |
const auto *Region = |
| 586 |
dyn_cast_or_null<TypedValueRegion>(Location.getAsRegion()); |
| 587 |
if (!Region) |
| 588 |
return; |
| 589 |
|
| 590 |
ProgramStateRef State = Context.getState(); |
| 591 |
|
| 592 |
auto StoredVal = State->getSVal(Region).getAs<loc::MemRegionVal>(); |
| 593 |
if (!StoredVal) |
| 594 |
return; |
| 595 |
|
| 596 |
Nullability NullabilityOfTheLoadedValue = |
| 597 |
getNullabilityAnnotation(Region->getValueType()); |
| 598 |
|
| 599 |
if (NullabilityOfTheLoadedValue == Nullability::Nonnull) { |
| 600 |
// It doesn't matter what we think about this particular pointer, it should |
| 601 |
// be considered non-null as annotated by the developer. |
| 602 |
if (ProgramStateRef NewState = State->assume(*StoredVal, true)) { |
| 603 |
Context.addTransition(NewState); |
| 604 |
} |
| 605 |
} |
| 606 |
} |
| 607 |
|
| 608 |
/// Find the outermost subexpression of E that is not an implicit cast. |
| 609 |
/// This looks through the implicit casts to _Nonnull that ARC adds to |
| 610 |
/// return expressions of ObjC types when the return type of the function or |
| 611 |
/// method is non-null but the express is not. |
| 612 |
static const Expr *lookThroughImplicitCasts(const Expr *E) { |
| 613 |
return E->IgnoreImpCasts(); |
| 614 |
} |
| 615 |
|
| 616 |
/// This method check when nullable pointer or null value is returned from a |
| 617 |
/// function that has nonnull return type. |
| 618 |
void NullabilityChecker::checkPreStmt(const ReturnStmt *S, |
| 619 |
CheckerContext &C) const { |
| 620 |
auto RetExpr = S->getRetValue(); |
| 621 |
if (!RetExpr) |
| 622 |
return; |
| 623 |
|
| 624 |
if (!RetExpr->getType()->isAnyPointerType()) |
| 625 |
return; |
| 626 |
|
| 627 |
ProgramStateRef State = C.getState(); |
| 628 |
if (State->get<InvariantViolated>()) |
| 629 |
return; |
| 630 |
|
| 631 |
auto RetSVal = C.getSVal(S).getAs<DefinedOrUnknownSVal>(); |
| 632 |
if (!RetSVal) |
| 633 |
return; |
| 634 |
|
| 635 |
bool InSuppressedMethodFamily = false; |
| 636 |
|
| 637 |
QualType RequiredRetType; |
| 638 |
AnalysisDeclContext *DeclCtxt = |
| 639 |
C.getLocationContext()->getAnalysisDeclContext(); |
| 640 |
const Decl *D = DeclCtxt->getDecl(); |
| 641 |
if (auto *MD = dyn_cast<ObjCMethodDecl>(D)) { |
| 642 |
// HACK: This is a big hammer to avoid warning when there are defensive |
| 643 |
// nil checks in -init and -copy methods. We should add more sophisticated |
| 644 |
// logic here to suppress on common defensive idioms but still |
| 645 |
// warn when there is a likely problem. |
| 646 |
ObjCMethodFamily Family = MD->getMethodFamily(); |
| 647 |
if (OMF_init == Family || OMF_copy == Family || OMF_mutableCopy == Family) |
| 648 |
InSuppressedMethodFamily = true; |
| 649 |
|
| 650 |
RequiredRetType = MD->getReturnType(); |
| 651 |
} else if (auto *FD = dyn_cast<FunctionDecl>(D)) { |
| 652 |
RequiredRetType = FD->getReturnType(); |
| 653 |
} else { |
| 654 |
return; |
| 655 |
} |
| 656 |
|
| 657 |
NullConstraint Nullness = getNullConstraint(*RetSVal, State); |
| 658 |
|
| 659 |
Nullability RequiredNullability = getNullabilityAnnotation(RequiredRetType); |
| 660 |
|
| 661 |
// If the returned value is null but the type of the expression |
| 662 |
// generating it is nonnull then we will suppress the diagnostic. |
| 663 |
// This enables explicit suppression when returning a nil literal in a |
| 664 |
// function with a _Nonnull return type: |
| 665 |
// return (NSString * _Nonnull)0; |
| 666 |
Nullability RetExprTypeLevelNullability = |
| 667 |
getNullabilityAnnotation(lookThroughImplicitCasts(RetExpr)->getType()); |
| 668 |
|
| 669 |
bool NullReturnedFromNonNull = (RequiredNullability == Nullability::Nonnull && |
| 670 |
Nullness == NullConstraint::IsNull); |
| 671 |
if (ChecksEnabled[CK_NullReturnedFromNonnull] && NullReturnedFromNonNull && |
| 672 |
RetExprTypeLevelNullability != Nullability::Nonnull && |
| 673 |
!InSuppressedMethodFamily && C.getLocationContext()->inTopFrame()) { |
| 674 |
static CheckerProgramPointTag Tag(this, "NullReturnedFromNonnull"); |
| 675 |
ExplodedNode *N = C.generateErrorNode(State, &Tag); |
| 676 |
if (!N) |
| 677 |
return; |
| 678 |
|
| 679 |
SmallString<256> SBuf; |
| 680 |
llvm::raw_svector_ostream OS(SBuf); |
| 681 |
OS << (RetExpr->getType()->isObjCObjectPointerType() ? "nil" : "Null"); |
| 682 |
OS << " returned from a " << C.getDeclDescription(D) << |
| 683 |
" that is expected to return a non-null value"; |
| 684 |
reportBugIfInvariantHolds(OS.str(), ErrorKind::NilReturnedToNonnull, |
| 685 |
CK_NullReturnedFromNonnull, N, nullptr, C, |
| 686 |
RetExpr); |
| 687 |
return; |
| 688 |
} |
| 689 |
|
| 690 |
// If null was returned from a non-null function, mark the nullability |
| 691 |
// invariant as violated even if the diagnostic was suppressed. |
| 692 |
if (NullReturnedFromNonNull) { |
| 693 |
State = State->set<InvariantViolated>(true); |
| 694 |
C.addTransition(State); |
| 695 |
return; |
| 696 |
} |
| 697 |
|
| 698 |
const MemRegion *Region = getTrackRegion(*RetSVal); |
| 699 |
if (!Region) |
| 700 |
return; |
| 701 |
|
| 702 |
const NullabilityState *TrackedNullability = |
| 703 |
State->get<NullabilityMap>(Region); |
| 704 |
if (TrackedNullability) { |
| 705 |
Nullability TrackedNullabValue = TrackedNullability->getValue(); |
| 706 |
if (ChecksEnabled[CK_NullableReturnedFromNonnull] && |
| 707 |
Nullness != NullConstraint::IsNotNull && |
| 708 |
TrackedNullabValue == Nullability::Nullable && |
| 709 |
RequiredNullability == Nullability::Nonnull) { |
| 710 |
static CheckerProgramPointTag Tag(this, "NullableReturnedFromNonnull"); |
| 711 |
ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag); |
| 712 |
|
| 713 |
SmallString<256> SBuf; |
| 714 |
llvm::raw_svector_ostream OS(SBuf); |
| 715 |
OS << "Nullable pointer is returned from a " << C.getDeclDescription(D) << |
| 716 |
" that is expected to return a non-null value"; |
| 717 |
|
| 718 |
reportBugIfInvariantHolds(OS.str(), ErrorKind::NullableReturnedToNonnull, |
| 719 |
CK_NullableReturnedFromNonnull, N, Region, C); |
| 720 |
} |
| 721 |
return; |
| 722 |
} |
| 723 |
if (RequiredNullability == Nullability::Nullable) { |
| 724 |
State = State->set<NullabilityMap>(Region, |
| 725 |
NullabilityState(RequiredNullability, |
| 726 |
S)); |
| 727 |
C.addTransition(State); |
| 728 |
} |
| 729 |
} |
| 730 |
|
| 731 |
/// This callback warns when a nullable pointer or a null value is passed to a |
| 732 |
/// function that expects its argument to be nonnull. |
| 733 |
void NullabilityChecker::checkPreCall(const CallEvent &Call, |
| 734 |
CheckerContext &C) const { |
| 735 |
if (!Call.getDecl()) |
| 736 |
return; |
| 737 |
|
| 738 |
ProgramStateRef State = C.getState(); |
| 739 |
if (State->get<InvariantViolated>()) |
| 740 |
return; |
| 741 |
|
| 742 |
ProgramStateRef OrigState = State; |
| 743 |
|
| 744 |
unsigned Idx = 0; |
| 745 |
for (const ParmVarDecl *Param : Call.parameters()) { |
| 746 |
if (Param->isParameterPack()) |
| 747 |
break; |
| 748 |
|
| 749 |
if (Idx >= Call.getNumArgs()) |
| 750 |
break; |
| 751 |
|
| 752 |
const Expr *ArgExpr = Call.getArgExpr(Idx); |
| 753 |
auto ArgSVal = Call.getArgSVal(Idx++).getAs<DefinedOrUnknownSVal>(); |
| 754 |
if (!ArgSVal) |
| 755 |
continue; |
| 756 |
|
| 757 |
if (!Param->getType()->isAnyPointerType() && |
| 758 |
!Param->getType()->isReferenceType()) |
| 759 |
continue; |
| 760 |
|
| 761 |
NullConstraint Nullness = getNullConstraint(*ArgSVal, State); |
| 762 |
|
| 763 |
Nullability RequiredNullability = |
| 764 |
getNullabilityAnnotation(Param->getType()); |
| 765 |
Nullability ArgExprTypeLevelNullability = |
| 766 |
getNullabilityAnnotation(ArgExpr->getType()); |
| 767 |
|
| 768 |
unsigned ParamIdx = Param->getFunctionScopeIndex() + 1; |
| 769 |
|
| 770 |
if (ChecksEnabled[CK_NullPassedToNonnull] && |
| 771 |
Nullness == NullConstraint::IsNull && |
| 772 |
ArgExprTypeLevelNullability != Nullability::Nonnull && |
| 773 |
RequiredNullability == Nullability::Nonnull && |
| 774 |
isDiagnosableCall(Call)) { |
| 775 |
ExplodedNode *N = C.generateErrorNode(State); |
| 776 |
if (!N) |
| 777 |
return; |
| 778 |
|
| 779 |
SmallString<256> SBuf; |
| 780 |
llvm::raw_svector_ostream OS(SBuf); |
| 781 |
OS << (Param->getType()->isObjCObjectPointerType() ? "nil" : "Null"); |
| 782 |
OS << " passed to a callee that requires a non-null " << ParamIdx |
| 783 |
<< llvm::getOrdinalSuffix(ParamIdx) << " parameter"; |
| 784 |
reportBugIfInvariantHolds(OS.str(), ErrorKind::NilPassedToNonnull, |
| 785 |
CK_NullPassedToNonnull, N, nullptr, C, ArgExpr, |
| 786 |
/*SuppressPath=*/false); |
| 787 |
return; |
| 788 |
} |
| 789 |
|
| 790 |
const MemRegion *Region = getTrackRegion(*ArgSVal); |
| 791 |
if (!Region) |
| 792 |
continue; |
| 793 |
|
| 794 |
const NullabilityState *TrackedNullability = |
| 795 |
State->get<NullabilityMap>(Region); |
| 796 |
|
| 797 |
if (TrackedNullability) { |
| 798 |
if (Nullness == NullConstraint::IsNotNull || |
| 799 |
TrackedNullability->getValue() != Nullability::Nullable) |
| 800 |
continue; |
| 801 |
|
| 802 |
if (ChecksEnabled[CK_NullablePassedToNonnull] && |
| 803 |
RequiredNullability == Nullability::Nonnull && |
| 804 |
isDiagnosableCall(Call)) { |
| 805 |
ExplodedNode *N = C.addTransition(State); |
| 806 |
SmallString<256> SBuf; |
| 807 |
llvm::raw_svector_ostream OS(SBuf); |
| 808 |
OS << "Nullable pointer is passed to a callee that requires a non-null " |
| 809 |
<< ParamIdx << llvm::getOrdinalSuffix(ParamIdx) << " parameter"; |
| 810 |
reportBugIfInvariantHolds(OS.str(), ErrorKind::NullablePassedToNonnull, |
| 811 |
CK_NullablePassedToNonnull, N, Region, C, |
| 812 |
ArgExpr, /*SuppressPath=*/true); |
| 813 |
return; |
| 814 |
} |
| 815 |
if (ChecksEnabled[CK_NullableDereferenced] && |
| 816 |
Param->getType()->isReferenceType()) { |
| 817 |
ExplodedNode *N = C.addTransition(State); |
| 818 |
reportBugIfInvariantHolds("Nullable pointer is dereferenced", |
| 819 |
ErrorKind::NullableDereferenced, |
| 820 |
CK_NullableDereferenced, N, Region, C, |
| 821 |
ArgExpr, /*SuppressPath=*/true); |
| 822 |
return; |
| 823 |
} |
| 824 |
continue; |
| 825 |
} |
| 826 |
} |
| 827 |
if (State != OrigState) |
| 828 |
C.addTransition(State); |
| 829 |
} |
| 830 |
|
| 831 |
/// Suppress the nullability warnings for some functions. |
| 832 |
void NullabilityChecker::checkPostCall(const CallEvent &Call, |
| 833 |
CheckerContext &C) const { |
| 834 |
auto Decl = Call.getDecl(); |
| 835 |
if (!Decl) |
| 836 |
return; |
| 837 |
// ObjC Messages handles in a different callback. |
| 838 |
if (Call.getKind() == CE_ObjCMessage) |
| 839 |
return; |
| 840 |
const FunctionType *FuncType = Decl->getFunctionType(); |
| 841 |
if (!FuncType) |
| 842 |
return; |
| 843 |
QualType ReturnType = FuncType->getReturnType(); |
| 844 |
if (!ReturnType->isAnyPointerType()) |
| 845 |
return; |
| 846 |
ProgramStateRef State = C.getState(); |
| 847 |
if (State->get<InvariantViolated>()) |
| 848 |
return; |
| 849 |
|
| 850 |
const MemRegion *Region = getTrackRegion(Call.getReturnValue()); |
| 851 |
if (!Region) |
| 852 |
return; |
| 853 |
|
| 854 |
// CG headers are misannotated. Do not warn for symbols that are the results |
| 855 |
// of CG calls. |
| 856 |
const SourceManager &SM = C.getSourceManager(); |
| 857 |
StringRef FilePath = SM.getFilename(SM.getSpellingLoc(Decl->getBeginLoc())); |
| 858 |
if (llvm::sys::path::filename(FilePath).startswith("CG")) { |
| 859 |
State = State->set<NullabilityMap>(Region, Nullability::Contradicted); |
| 860 |
C.addTransition(State); |
| 861 |
return; |
| 862 |
} |
| 863 |
|
| 864 |
const NullabilityState *TrackedNullability = |
| 865 |
State->get<NullabilityMap>(Region); |
| 866 |
|
| 867 |
if (!TrackedNullability && |
| 868 |
getNullabilityAnnotation(ReturnType) == Nullability::Nullable) { |
| 869 |
State = State->set<NullabilityMap>(Region, Nullability::Nullable); |
| 870 |
C.addTransition(State); |
| 871 |
} |
| 872 |
} |
| 873 |
|
| 874 |
static Nullability getReceiverNullability(const ObjCMethodCall &M, |
| 875 |
ProgramStateRef State) { |
| 876 |
if (M.isReceiverSelfOrSuper()) { |
| 877 |
// For super and super class receivers we assume that the receiver is |
| 878 |
// nonnull. |
| 879 |
return Nullability::Nonnull; |
| 880 |
} |
| 881 |
// Otherwise look up nullability in the state. |
| 882 |
SVal Receiver = M.getReceiverSVal(); |
| 883 |
if (auto DefOrUnknown = Receiver.getAs<DefinedOrUnknownSVal>()) { |
| 884 |
// If the receiver is constrained to be nonnull, assume that it is nonnull |
| 885 |
// regardless of its type. |
| 886 |
NullConstraint Nullness = getNullConstraint(*DefOrUnknown, State); |
| 887 |
if (Nullness == NullConstraint::IsNotNull) |
| 888 |
return Nullability::Nonnull; |
| 889 |
} |
| 890 |
auto ValueRegionSVal = Receiver.getAs<loc::MemRegionVal>(); |
| 891 |
if (ValueRegionSVal) { |
| 892 |
const MemRegion *SelfRegion = ValueRegionSVal->getRegion(); |
| 893 |
assert(SelfRegion); |
| 894 |
|
| 895 |
const NullabilityState *TrackedSelfNullability = |
| 896 |
State->get<NullabilityMap>(SelfRegion); |
| 897 |
if (TrackedSelfNullability) |
| 898 |
return TrackedSelfNullability->getValue(); |
| 899 |
} |
| 900 |
return Nullability::Unspecified; |
| 901 |
} |
| 902 |
|
| 903 |
// The return value of a property access is typically a temporary value which |
| 904 |
// will not be tracked in a persistent manner by the analyzer. We use |
| 905 |
// evalAssume() in order to immediately record constraints on those temporaries |
| 906 |
// at the time they are imposed (e.g. by a nil-check conditional). |
| 907 |
ProgramStateRef NullabilityChecker::evalAssume(ProgramStateRef State, SVal Cond, |
| 908 |
bool Assumption) const { |
| 909 |
PropertyAccessesMapTy PropertyAccesses = State->get<PropertyAccessesMap>(); |
| 910 |
for (PropertyAccessesMapTy::iterator I = PropertyAccesses.begin(), |
| 911 |
E = PropertyAccesses.end(); |
| 912 |
I != E; ++I) { |
| 913 |
if (!I->second.isConstrainedNonnull) { |
| 914 |
ConditionTruthVal IsNonNull = State->isNonNull(I->second.Value); |
| 915 |
if (IsNonNull.isConstrainedTrue()) { |
| 916 |
ConstrainedPropertyVal Replacement = I->second; |
| 917 |
Replacement.isConstrainedNonnull = true; |
| 918 |
State = State->set<PropertyAccessesMap>(I->first, Replacement); |
| 919 |
} else if (IsNonNull.isConstrainedFalse()) { |
| 920 |
// Space optimization: no point in tracking constrained-null cases |
| 921 |
State = State->remove<PropertyAccessesMap>(I->first); |
| 922 |
} |
| 923 |
} |
| 924 |
} |
| 925 |
|
| 926 |
return State; |
| 927 |
} |
| 928 |
|
| 929 |
/// Calculate the nullability of the result of a message expr based on the |
| 930 |
/// nullability of the receiver, the nullability of the return value, and the |
| 931 |
/// constraints. |
| 932 |
void NullabilityChecker::checkPostObjCMessage(const ObjCMethodCall &M, |
| 933 |
CheckerContext &C) const { |
| 934 |
auto Decl = M.getDecl(); |
| 935 |
if (!Decl) |
| 936 |
return; |
| 937 |
QualType RetType = Decl->getReturnType(); |
| 938 |
if (!RetType->isAnyPointerType()) |
| 939 |
return; |
| 940 |
|
| 941 |
ProgramStateRef State = C.getState(); |
| 942 |
if (State->get<InvariantViolated>()) |
| 943 |
return; |
| 944 |
|
| 945 |
const MemRegion *ReturnRegion = getTrackRegion(M.getReturnValue()); |
| 946 |
if (!ReturnRegion) |
| 947 |
return; |
| 948 |
|
| 949 |
auto Interface = Decl->getClassInterface(); |
| 950 |
auto Name = Interface ? Interface->getName() : ""; |
| 951 |
// In order to reduce the noise in the diagnostics generated by this checker, |
| 952 |
// some framework and programming style based heuristics are used. These |
| 953 |
// heuristics are for Cocoa APIs which have NS prefix. |
| 954 |
if (Name.startswith("NS")) { |
| 955 |
// Developers rely on dynamic invariants such as an item should be available |
| 956 |
// in a collection, or a collection is not empty often. Those invariants can |
| 957 |
// not be inferred by any static analysis tool. To not to bother the users |
| 958 |
// with too many false positives, every item retrieval function should be |
| 959 |
// ignored for collections. The instance methods of dictionaries in Cocoa |
| 960 |
// are either item retrieval related or not interesting nullability wise. |
| 961 |
// Using this fact, to keep the code easier to read just ignore the return |
| 962 |
// value of every instance method of dictionaries. |
| 963 |
if (M.isInstanceMessage() && Name.contains("Dictionary")) { |
| 964 |
State = |
| 965 |
State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted); |
| 966 |
C.addTransition(State); |
| 967 |
return; |
| 968 |
} |
| 969 |
// For similar reasons ignore some methods of Cocoa arrays. |
| 970 |
StringRef FirstSelectorSlot = M.getSelector().getNameForSlot(0); |
| 971 |
if (Name.contains("Array") && |
| 972 |
(FirstSelectorSlot == "firstObject" || |
| 973 |
FirstSelectorSlot == "lastObject")) { |
| 974 |
State = |
| 975 |
State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted); |
| 976 |
C.addTransition(State); |
| 977 |
return; |
| 978 |
} |
| 979 |
|
| 980 |
// Encoding related methods of string should not fail when lossless |
| 981 |
// encodings are used. Using lossless encodings is so frequent that ignoring |
| 982 |
// this class of methods reduced the emitted diagnostics by about 30% on |
| 983 |
// some projects (and all of that was false positives). |
| 984 |
if (Name.contains("String")) { |
| 985 |
for (auto *Param : M.parameters()) { |
| 986 |
if (Param->getName() == "encoding") { |
| 987 |
State = State->set<NullabilityMap>(ReturnRegion, |
| 988 |
Nullability::Contradicted); |
| 989 |
C.addTransition(State); |
| 990 |
return; |
| 991 |
} |
| 992 |
} |
| 993 |
} |
| 994 |
} |
| 995 |
|
| 996 |
const ObjCMessageExpr *Message = M.getOriginExpr(); |
| 997 |
Nullability SelfNullability = getReceiverNullability(M, State); |
| 998 |
|
| 999 |
const NullabilityState *NullabilityOfReturn = |
| 1000 |
State->get<NullabilityMap>(ReturnRegion); |
| 1001 |
|
| 1002 |
if (NullabilityOfReturn) { |
| 1003 |
// When we have a nullability tracked for the return value, the nullability |
| 1004 |
// of the expression will be the most nullable of the receiver and the |
| 1005 |
// return value. |
| 1006 |
Nullability RetValTracked = NullabilityOfReturn->getValue(); |
| 1007 |
Nullability ComputedNullab = |
| 1008 |
getMostNullable(RetValTracked, SelfNullability); |
| 1009 |
if (ComputedNullab != RetValTracked && |
| 1010 |
ComputedNullab != Nullability::Unspecified) { |
| 1011 |
const Stmt *NullabilitySource = |
| 1012 |
ComputedNullab == RetValTracked |
| 1013 |
? NullabilityOfReturn->getNullabilitySource() |
| 1014 |
: Message->getInstanceReceiver(); |
| 1015 |
State = State->set<NullabilityMap>( |
| 1016 |
ReturnRegion, NullabilityState(ComputedNullab, NullabilitySource)); |
| 1017 |
C.addTransition(State); |
| 1018 |
} |
| 1019 |
return; |
| 1020 |
} |
| 1021 |
|
| 1022 |
// No tracked information. Use static type information for return value. |
| 1023 |
Nullability RetNullability = getNullabilityAnnotation(RetType); |
| 1024 |
|
| 1025 |
// Properties might be computed, which means the property value could |
| 1026 |
// theoretically change between calls even in commonly-observed cases like |
| 1027 |
// this: |
| 1028 |
// |
| 1029 |
// if (foo.prop) { // ok, it's nonnull here... |
| 1030 |
// [bar doStuffWithNonnullVal:foo.prop]; // ...but what about |
| 1031 |
// here? |
| 1032 |
// } |
| 1033 |
// |
| 1034 |
// If the property is nullable-annotated, a naive analysis would lead to many |
| 1035 |
// false positives despite the presence of probably-correct nil-checks. To |
| 1036 |
// reduce the false positive rate, we maintain a history of the most recently |
| 1037 |
// observed property value. For each property access, if the prior value has |
| 1038 |
// been constrained to be not nil then we will conservatively assume that the |
| 1039 |
// next access can be inferred as nonnull. |
| 1040 |
if (RetNullability != Nullability::Nonnull && |
| 1041 |
M.getMessageKind() == OCM_PropertyAccess && !C.wasInlined) { |
| 1042 |
bool LookupResolved = false; |
| 1043 |
if (const MemRegion *ReceiverRegion = getTrackRegion(M.getReceiverSVal())) { |
| 1044 |
if (IdentifierInfo *Ident = M.getSelector().getIdentifierInfoForSlot(0)) { |
| 1045 |
LookupResolved = true; |
| 1046 |
ObjectPropPair Key = std::make_pair(ReceiverRegion, Ident); |
| 1047 |
const ConstrainedPropertyVal *PrevPropVal = |
| 1048 |
State->get<PropertyAccessesMap>(Key); |
| 1049 |
if (PrevPropVal && PrevPropVal->isConstrainedNonnull) { |
| 1050 |
RetNullability = Nullability::Nonnull; |
| 1051 |
} else { |
| 1052 |
// If a previous property access was constrained as nonnull, we hold |
| 1053 |
// on to that constraint (effectively inferring that all subsequent |
| 1054 |
// accesses on that code path can be inferred as nonnull). If the |
| 1055 |
// previous property access was *not* constrained as nonnull, then |
| 1056 |
// let's throw it away in favor of keeping the SVal associated with |
| 1057 |
// this more recent access. |
| 1058 |
if (auto ReturnSVal = |
| 1059 |
M.getReturnValue().getAs<DefinedOrUnknownSVal>()) { |
| 1060 |
State = State->set<PropertyAccessesMap>( |
| 1061 |
Key, ConstrainedPropertyVal(*ReturnSVal)); |
| 1062 |
} |
| 1063 |
} |
| 1064 |
} |
| 1065 |
} |
| 1066 |
|
| 1067 |
if (!LookupResolved) { |
| 1068 |
// Fallback: err on the side of suppressing the false positive. |
| 1069 |
RetNullability = Nullability::Nonnull; |
| 1070 |
} |
| 1071 |
} |
| 1072 |
|
| 1073 |
Nullability ComputedNullab = getMostNullable(RetNullability, SelfNullability); |
| 1074 |
if (ComputedNullab == Nullability::Nullable) { |
| 1075 |
const Stmt *NullabilitySource = ComputedNullab == RetNullability |
| 1076 |
? Message |
| 1077 |
: Message->getInstanceReceiver(); |
| 1078 |
State = State->set<NullabilityMap>( |
| 1079 |
ReturnRegion, NullabilityState(ComputedNullab, NullabilitySource)); |
| 1080 |
C.addTransition(State); |
| 1081 |
} |
| 1082 |
} |
| 1083 |
|
| 1084 |
/// Explicit casts are trusted. If there is a disagreement in the nullability |
| 1085 |
/// annotations in the destination and the source or '0' is casted to nonnull |
| 1086 |
/// track the value as having contraditory nullability. This will allow users to |
| 1087 |
/// suppress warnings. |
| 1088 |
void NullabilityChecker::checkPostStmt(const ExplicitCastExpr *CE, |
| 1089 |
CheckerContext &C) const { |
| 1090 |
QualType OriginType = CE->getSubExpr()->getType(); |
| 1091 |
QualType DestType = CE->getType(); |
| 1092 |
if (!OriginType->isAnyPointerType()) |
| 1093 |
return; |
| 1094 |
if (!DestType->isAnyPointerType()) |
| 1095 |
return; |
| 1096 |
|
| 1097 |
ProgramStateRef State = C.getState(); |
| 1098 |
if (State->get<InvariantViolated>()) |
| 1099 |
return; |
| 1100 |
|
| 1101 |
Nullability DestNullability = getNullabilityAnnotation(DestType); |
| 1102 |
|
| 1103 |
// No explicit nullability in the destination type, so this cast does not |
| 1104 |
// change the nullability. |
| 1105 |
if (DestNullability == Nullability::Unspecified) |
| 1106 |
return; |
| 1107 |
|
| 1108 |
auto RegionSVal = C.getSVal(CE).getAs<DefinedOrUnknownSVal>(); |
| 1109 |
const MemRegion *Region = getTrackRegion(*RegionSVal); |
| 1110 |
if (!Region) |
| 1111 |
return; |
| 1112 |
|
| 1113 |
// When 0 is converted to nonnull mark it as contradicted. |
| 1114 |
if (DestNullability == Nullability::Nonnull) { |
| 1115 |
NullConstraint Nullness = getNullConstraint(*RegionSVal, State); |
| 1116 |
if (Nullness == NullConstraint::IsNull) { |
| 1117 |
State = State->set<NullabilityMap>(Region, Nullability::Contradicted); |
| 1118 |
C.addTransition(State); |
| 1119 |
return; |
| 1120 |
} |
| 1121 |
} |
| 1122 |
|
| 1123 |
const NullabilityState *TrackedNullability = |
| 1124 |
State->get<NullabilityMap>(Region); |
| 1125 |
|
| 1126 |
if (!TrackedNullability) { |
| 1127 |
if (DestNullability != Nullability::Nullable) |
| 1128 |
return; |
| 1129 |
State = State->set<NullabilityMap>(Region, |
| 1130 |
NullabilityState(DestNullability, CE)); |
| 1131 |
C.addTransition(State); |
| 1132 |
return; |
| 1133 |
} |
| 1134 |
|
| 1135 |
if (TrackedNullability->getValue() != DestNullability && |
| 1136 |
TrackedNullability->getValue() != Nullability::Contradicted) { |
| 1137 |
State = State->set<NullabilityMap>(Region, Nullability::Contradicted); |
| 1138 |
C.addTransition(State); |
| 1139 |
} |
| 1140 |
} |
| 1141 |
|
| 1142 |
/// For a given statement performing a bind, attempt to syntactically |
| 1143 |
/// match the expression resulting in the bound value. |
| 1144 |
static const Expr * matchValueExprForBind(const Stmt *S) { |
| 1145 |
// For `x = e` the value expression is the right-hand side. |
| 1146 |
if (auto *BinOp = dyn_cast<BinaryOperator>(S)) { |
| 1147 |
if (BinOp->getOpcode() == BO_Assign) |
| 1148 |
return BinOp->getRHS(); |
| 1149 |
} |
| 1150 |
|
| 1151 |
// For `int x = e` the value expression is the initializer. |
| 1152 |
if (auto *DS = dyn_cast<DeclStmt>(S)) { |
| 1153 |
if (DS->isSingleDecl()) { |
| 1154 |
auto *VD = dyn_cast<VarDecl>(DS->getSingleDecl()); |
| 1155 |
if (!VD) |
| 1156 |
return nullptr; |
| 1157 |
|
| 1158 |
if (const Expr *Init = VD->getInit()) |
| 1159 |
return Init; |
| 1160 |
} |
| 1161 |
} |
| 1162 |
|
| 1163 |
return nullptr; |
| 1164 |
} |
| 1165 |
|
| 1166 |
/// Returns true if \param S is a DeclStmt for a local variable that |
| 1167 |
/// ObjC automated reference counting initialized with zero. |
| 1168 |
static bool isARCNilInitializedLocal(CheckerContext &C, const Stmt *S) { |
| 1169 |
// We suppress diagnostics for ARC zero-initialized _Nonnull locals. This |
| 1170 |
// prevents false positives when a _Nonnull local variable cannot be |
| 1171 |
// initialized with an initialization expression: |
| 1172 |
// NSString * _Nonnull s; // no-warning |
| 1173 |
// @autoreleasepool { |
| 1174 |
// s = ... |
| 1175 |
// } |
| 1176 |
// |
| 1177 |
// FIXME: We should treat implicitly zero-initialized _Nonnull locals as |
| 1178 |
// uninitialized in Sema's UninitializedValues analysis to warn when a use of |
| 1179 |
// the zero-initialized definition will unexpectedly yield nil. |
| 1180 |
|
| 1181 |
// Locals are only zero-initialized when automated reference counting |
| 1182 |
// is turned on. |
| 1183 |
if (!C.getASTContext().getLangOpts().ObjCAutoRefCount) |
| 1184 |
return false; |
| 1185 |
|
| 1186 |
auto *DS = dyn_cast<DeclStmt>(S); |
| 1187 |
if (!DS || !DS->isSingleDecl()) |
| 1188 |
return false; |
| 1189 |
|
| 1190 |
auto *VD = dyn_cast<VarDecl>(DS->getSingleDecl()); |
| 1191 |
if (!VD) |
| 1192 |
return false; |
| 1193 |
|
| 1194 |
// Sema only zero-initializes locals with ObjCLifetimes. |
| 1195 |
if(!VD->getType().getQualifiers().hasObjCLifetime()) |
| 1196 |
return false; |
| 1197 |
|
| 1198 |
const Expr *Init = VD->getInit(); |
| 1199 |
assert(Init && "ObjC local under ARC without initializer"); |
| 1200 |
|
| 1201 |
// Return false if the local is explicitly initialized (e.g., with '= nil'). |
| 1202 |
if (!isa<ImplicitValueInitExpr>(Init)) |
| 1203 |
return false; |
| 1204 |
|
| 1205 |
return true; |
| 1206 |
} |
| 1207 |
|
| 1208 |
/// Propagate the nullability information through binds and warn when nullable |
| 1209 |
/// pointer or null symbol is assigned to a pointer with a nonnull type. |
| 1210 |
void NullabilityChecker::checkBind(SVal L, SVal V, const Stmt *S, |
| 1211 |
CheckerContext &C) const { |
| 1212 |
const TypedValueRegion *TVR = |
| 1213 |
dyn_cast_or_null<TypedValueRegion>(L.getAsRegion()); |
| 1214 |
if (!TVR) |
| 1215 |
return; |
| 1216 |
|
| 1217 |
QualType LocType = TVR->getValueType(); |
| 1218 |
if (!LocType->isAnyPointerType()) |
| 1219 |
return; |
| 1220 |
|
| 1221 |
ProgramStateRef State = C.getState(); |
| 1222 |
if (State->get<InvariantViolated>()) |
| 1223 |
return; |
| 1224 |
|
| 1225 |
auto ValDefOrUnknown = V.getAs<DefinedOrUnknownSVal>(); |
| 1226 |
if (!ValDefOrUnknown) |
| 1227 |
return; |
| 1228 |
|
| 1229 |
NullConstraint RhsNullness = getNullConstraint(*ValDefOrUnknown, State); |
| 1230 |
|
| 1231 |
Nullability ValNullability = Nullability::Unspecified; |
| 1232 |
if (SymbolRef Sym = ValDefOrUnknown->getAsSymbol()) |
| 1233 |
ValNullability = getNullabilityAnnotation(Sym->getType()); |
| 1234 |
|
| 1235 |
Nullability LocNullability = getNullabilityAnnotation(LocType); |
| 1236 |
|
| 1237 |
// If the type of the RHS expression is nonnull, don't warn. This |
| 1238 |
// enables explicit suppression with a cast to nonnull. |
| 1239 |
Nullability ValueExprTypeLevelNullability = Nullability::Unspecified; |
| 1240 |
const Expr *ValueExpr = matchValueExprForBind(S); |
| 1241 |
if (ValueExpr) { |
| 1242 |
ValueExprTypeLevelNullability = |
| 1243 |
getNullabilityAnnotation(lookThroughImplicitCasts(ValueExpr)->getType()); |
| 1244 |
} |
| 1245 |
|
| 1246 |
bool NullAssignedToNonNull = (LocNullability == Nullability::Nonnull && |
| 1247 |
RhsNullness == NullConstraint::IsNull); |
| 1248 |
if (ChecksEnabled[CK_NullPassedToNonnull] && NullAssignedToNonNull && |
| 1249 |
ValNullability != Nullability::Nonnull && |
| 1250 |
ValueExprTypeLevelNullability != Nullability::Nonnull && |
| 1251 |
!isARCNilInitializedLocal(C, S)) { |
| 1252 |
static CheckerProgramPointTag Tag(this, "NullPassedToNonnull"); |
| 1253 |
ExplodedNode *N = C.generateErrorNode(State, &Tag); |
| 1254 |
if (!N) |
| 1255 |
return; |
| 1256 |
|
| 1257 |
|
| 1258 |
const Stmt *ValueStmt = S; |
| 1259 |
if (ValueExpr) |
| 1260 |
ValueStmt = ValueExpr; |
| 1261 |
|
| 1262 |
SmallString<256> SBuf; |
| 1263 |
llvm::raw_svector_ostream OS(SBuf); |
| 1264 |
OS << (LocType->isObjCObjectPointerType() ? "nil" : "Null"); |
| 1265 |
OS << " assigned to a pointer which is expected to have non-null value"; |
| 1266 |
reportBugIfInvariantHolds(OS.str(), ErrorKind::NilAssignedToNonnull, |
| 1267 |
CK_NullPassedToNonnull, N, nullptr, C, ValueStmt); |
| 1268 |
return; |
| 1269 |
} |
| 1270 |
|
| 1271 |
// If null was returned from a non-null function, mark the nullability |
| 1272 |
// invariant as violated even if the diagnostic was suppressed. |
| 1273 |
if (NullAssignedToNonNull) { |
| 1274 |
State = State->set<InvariantViolated>(true); |
| 1275 |
C.addTransition(State); |
| 1276 |
return; |
| 1277 |
} |
| 1278 |
|
| 1279 |
// Intentionally missing case: '0' is bound to a reference. It is handled by |
| 1280 |
// the DereferenceChecker. |
| 1281 |
|
| 1282 |
const MemRegion *ValueRegion = getTrackRegion(*ValDefOrUnknown); |
| 1283 |
if (!ValueRegion) |
| 1284 |
return; |
| 1285 |
|
| 1286 |
const NullabilityState *TrackedNullability = |
| 1287 |
State->get<NullabilityMap>(ValueRegion); |
| 1288 |
|
| 1289 |
if (TrackedNullability) { |
| 1290 |
if (RhsNullness == NullConstraint::IsNotNull || |
| 1291 |
TrackedNullability->getValue() != Nullability::Nullable) |
| 1292 |
return; |
| 1293 |
if (ChecksEnabled[CK_NullablePassedToNonnull] && |
| 1294 |
LocNullability == Nullability::Nonnull) { |
| 1295 |
static CheckerProgramPointTag Tag(this, "NullablePassedToNonnull"); |
| 1296 |
ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag); |
| 1297 |
reportBugIfInvariantHolds("Nullable pointer is assigned to a pointer " |
| 1298 |
"which is expected to have non-null value", |
| 1299 |
ErrorKind::NullableAssignedToNonnull, |
| 1300 |
CK_NullablePassedToNonnull, N, ValueRegion, C); |
| 1301 |
} |
| 1302 |
return; |
| 1303 |
} |
| 1304 |
|
| 1305 |
const auto *BinOp = dyn_cast<BinaryOperator>(S); |
| 1306 |
|
| 1307 |
if (ValNullability == Nullability::Nullable) { |
| 1308 |
// Trust the static information of the value more than the static |
| 1309 |
// information on the location. |
| 1310 |
const Stmt *NullabilitySource = BinOp ? BinOp->getRHS() : S; |
| 1311 |
State = State->set<NullabilityMap>( |
| 1312 |
ValueRegion, NullabilityState(ValNullability, NullabilitySource)); |
| 1313 |
C.addTransition(State); |
| 1314 |
return; |
| 1315 |
} |
| 1316 |
|
| 1317 |
if (LocNullability == Nullability::Nullable) { |
| 1318 |
const Stmt *NullabilitySource = BinOp ? BinOp->getLHS() : S; |
| 1319 |
State = State->set<NullabilityMap>( |
| 1320 |
ValueRegion, NullabilityState(LocNullability, NullabilitySource)); |
| 1321 |
C.addTransition(State); |
| 1322 |
} |
| 1323 |
} |
| 1324 |
|
| 1325 |
void NullabilityChecker::printState(raw_ostream &Out, ProgramStateRef State, |
| 1326 |
const char *NL, const char *Sep) const { |
| 1327 |
|
| 1328 |
NullabilityMapTy B = State->get<NullabilityMap>(); |
| 1329 |
|
| 1330 |
if (State->get<InvariantViolated>()) |
| 1331 |
Out << Sep << NL |
| 1332 |
<< "Nullability invariant was violated, warnings suppressed." << NL; |
| 1333 |
|
| 1334 |
if (B.isEmpty()) |
| 1335 |
return; |
| 1336 |
|
| 1337 |
if (!State->get<InvariantViolated>()) |
| 1338 |
Out << Sep << NL; |
| 1339 |
|
| 1340 |
for (NullabilityMapTy::iterator I = B.begin(), E = B.end(); I != E; ++I) { |
| 1341 |
Out << I->first << " : "; |
| 1342 |
I->second.print(Out); |
| 1343 |
Out << NL; |
| 1344 |
} |
| 1345 |
} |
| 1346 |
|
| 1347 |
void ento::registerNullabilityBase(CheckerManager &mgr) { |
| 1348 |
mgr.registerChecker<NullabilityChecker>(); |
| 1349 |
} |
| 1350 |
|
| 1351 |
bool ento::shouldRegisterNullabilityBase(const CheckerManager &mgr) { |
| 1352 |
return true; |
| 1353 |
} |
| 1354 |
|
| 1355 |
#define REGISTER_CHECKER(name, trackingRequired) \ |
| 1356 |
void ento::register##name##Checker(CheckerManager &mgr) { \ |
| 1357 |
NullabilityChecker *checker = mgr.getChecker<NullabilityChecker>(); \ |
| 1358 |
checker->ChecksEnabled[NullabilityChecker::CK_##name] = true; \ |
| 1359 |
checker->CheckNames[NullabilityChecker::CK_##name] = \ |
| 1360 |
mgr.getCurrentCheckerName(); \ |
| 1361 |
checker->NeedTracking = checker->NeedTracking || trackingRequired; \ |
| 1362 |
checker->NoDiagnoseCallsToSystemHeaders = \ |
| 1363 |
checker->NoDiagnoseCallsToSystemHeaders || \ |
| 1364 |
mgr.getAnalyzerOptions().getCheckerBooleanOption( \ |
| 1365 |
checker, "NoDiagnoseCallsToSystemHeaders", true); \ |
| 1366 |
} \ |
| 1367 |
\ |
| 1368 |
bool ento::shouldRegister##name##Checker(const CheckerManager &mgr) { \ |
| 1369 |
return true; \ |
| 1370 |
} |
| 1371 |
|
| 1372 |
// The checks are likely to be turned on by default and it is possible to do |
| 1373 |
// them without tracking any nullability related information. As an optimization |
| 1374 |
// no nullability information will be tracked when only these two checks are |
| 1375 |
// enables. |
| 1376 |
REGISTER_CHECKER(NullPassedToNonnull, false) |
| 1377 |
REGISTER_CHECKER(NullReturnedFromNonnull, false) |
| 1378 |
|
| 1379 |
REGISTER_CHECKER(NullableDereferenced, true) |
| 1380 |
REGISTER_CHECKER(NullablePassedToNonnull, true) |
| 1381 |
REGISTER_CHECKER(NullableReturnedFromNonnull, true) |