clang 8.0.0

SVals.h
Go to the documentation of this file.
1 //===- SVals.h - Abstract Values for Static Analysis ------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines SVal, Loc, and NonLoc, classes that represent
11 // abstract r-values for use with path-sensitive value tracking.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H
16 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H
17
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/LLVM.h"
21 #include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
22 #include "llvm/ADT/FoldingSet.h"
23 #include "llvm/ADT/ImmutableList.h"
24 #include "llvm/ADT/None.h"
25 #include "llvm/ADT/Optional.h"
26 #include "llvm/ADT/PointerUnion.h"
27 #include "llvm/Support/Casting.h"
28 #include <cassert>
29 #include <cstdint>
30 #include <utility>
31
32 //==------------------------------------------------------------------------==//
33 // Base SVal types.
34 //==------------------------------------------------------------------------==//
35
36 namespace clang {
37
38 class CXXBaseSpecifier;
39 class DeclaratorDecl;
40 class FunctionDecl;
41 class LabelDecl;
42
43 namespace ento {
44
45 class BasicValueFactory;
46 class CompoundValData;
47 class LazyCompoundValData;
48 class MemRegion;
49 class PointerToMemberData;
50 class SValBuilder;
51 class TypedValueRegion;
52
53 namespace nonloc {
54
55 /// Sub-kinds for NonLoc values.
56 enum Kind {
57 #define NONLOC_SVAL(Id, Parent) Id ## Kind,
58 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.def"
59 };
60
61 } // namespace nonloc
62
63 namespace loc {
64
65 /// Sub-kinds for Loc values.
66 enum Kind {
67 #define LOC_SVAL(Id, Parent) Id ## Kind,
68 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.def"
69 };
70
71 } // namespace loc
72
73 /// SVal - This represents a symbolic expression, which can be either
74 /// an L-value or an R-value.
75 ///
76 class SVal {
77 public:
78 enum BaseKind {
79 // The enumerators must be representable using 2 bits.
80 #define BASIC_SVAL(Id, Parent) Id ## Kind,
81 #define ABSTRACT_SVAL_WITH_KIND(Id, Parent) Id ## Kind,
82 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.def"
83 };
84 enum { BaseBits = 2, BaseMask = 0x3 };
85
86 protected:
87 const void *Data = nullptr;
88
89 /// The lowest 2 bits are a BaseKind (0 -- 3).
90 /// The higher bits are an unsigned "kind" value.
91 unsigned Kind = 0;
92
93 explicit SVal(const void *d, bool isLoc, unsigned ValKind)
94 : Data(d), Kind((isLoc ? LocKind : NonLocKind) | (ValKind << BaseBits)) {}
95
96 explicit SVal(BaseKind k, const void *D = nullptr) : Data(D), Kind(k) {}
97
98 public:
99 explicit SVal() = default;
100
101 /// Convert to the specified SVal type, asserting that this SVal is of
102 /// the desired type.
103 template<typename T>
104 T castAs() const {
105 assert(T::isKind(*this));
106 return *static_cast<const T *>(this);
107 }
108
109 /// Convert to the specified SVal type, returning None if this SVal is
110 /// not of the desired type.
111 template<typename T>
112 Optional<T> getAs() const {
113 if (!T::isKind(*this))
114 return None;
115 return *static_cast<const T *>(this);
116 }
117
118 unsigned getRawKind() const { return Kind; }
119 BaseKind getBaseKind() const { return (BaseKind) (Kind & BaseMask); }
120 unsigned getSubKind() const { return (Kind & ~BaseMask) >> BaseBits; }
121
122 // This method is required for using SVal in a FoldingSetNode. It
123 // extracts a unique signature for this SVal object.
124 void Profile(llvm::FoldingSetNodeID &ID) const {
125 ID.AddInteger((unsigned) getRawKind());
126 ID.AddPointer(Data);
127 }
128
129 bool operator==(const SVal &R) const {
130 return getRawKind() == R.getRawKind() && Data == R.Data;
131 }
132
133 bool operator!=(const SVal &R) const {
134 return !(*this == R);
135 }
136
137 bool isUnknown() const {
138 return getRawKind() == UnknownValKind;
139 }
140
141 bool isUndef() const {
142 return getRawKind() == UndefinedValKind;
143 }
144
145 bool isUnknownOrUndef() const {
146 return getRawKind() <= UnknownValKind;
147 }
148
149 bool isValid() const {
150 return getRawKind() > UnknownValKind;
151 }
152
153 bool isConstant() const;
154
155 bool isConstant(int I) const;
156
157 bool isZeroConstant() const;
158
159 /// hasConjuredSymbol - If this SVal wraps a conjured symbol, return true;
160 bool hasConjuredSymbol() const;
161
162 /// getAsFunctionDecl - If this SVal is a MemRegionVal and wraps a
163 /// CodeTextRegion wrapping a FunctionDecl, return that FunctionDecl.
164 /// Otherwise return 0.
165 const FunctionDecl *getAsFunctionDecl() const;
166
167 /// If this SVal is a location and wraps a symbol, return that
168 /// SymbolRef. Otherwise return 0.
169 ///
170 /// Casts are ignored during lookup.
171 /// \param IncludeBaseRegions The boolean that controls whether the search
172 /// should continue to the base regions if the region is not symbolic.
173 SymbolRef getAsLocSymbol(bool IncludeBaseRegions = false) const;
174
175 /// Get the symbol in the SVal or its base region.
176 SymbolRef getLocSymbolInBase() const;
177
178 /// If this SVal wraps a symbol return that SymbolRef.
179 /// Otherwise, return 0.
180 ///
181 /// Casts are ignored during lookup.
182 /// \param IncludeBaseRegions The boolean that controls whether the search
183 /// should continue to the base regions if the region is not symbolic.
184 SymbolRef getAsSymbol(bool IncludeBaseRegions = false) const;
185
186 /// getAsSymbolicExpression - If this Sval wraps a symbolic expression then
187 /// return that expression. Otherwise return NULL.
188 const SymExpr *getAsSymbolicExpression() const;
189
190 const SymExpr *getAsSymExpr() const;
191
192 const MemRegion *getAsRegion() const;
193
194 void dumpToStream(raw_ostream &OS) const;
195 void dump() const;
196
197 SymExpr::symbol_iterator symbol_begin() const {
198 const SymExpr *SE = getAsSymbol(/*IncludeBaseRegions=*/true);
199 if (SE)
200 return SE->symbol_begin();
201 else
202 return SymExpr::symbol_iterator();
203 }
204
205 SymExpr::symbol_iterator symbol_end() const {
206 return SymExpr::symbol_end();
207 }
208 };
209
210 inline raw_ostream &operator<<(raw_ostream &os, clang::ento::SVal V) {
211 V.dumpToStream(os);
212 return os;
213 }
214
215 class UndefinedVal : public SVal {
216 public:
217 UndefinedVal() : SVal(UndefinedValKind) {}
218
219 private:
220 friend class SVal;
221
222 static bool isKind(const SVal& V) {
223 return V.getBaseKind() == UndefinedValKind;
224 }
225 };
226
227 class DefinedOrUnknownSVal : public SVal {
228 public:
229 // We want calling these methods to be a compiler error since they are
230 // tautologically false.
231 bool isUndef() const = delete;
232 bool isValid() const = delete;
233
234 protected:
235 DefinedOrUnknownSVal() = default;
236 explicit DefinedOrUnknownSVal(const void *d, bool isLoc, unsigned ValKind)
237 : SVal(d, isLoc, ValKind) {}
238 explicit DefinedOrUnknownSVal(BaseKind k, void *D = nullptr) : SVal(k, D) {}
239
240 private:
241 friend class SVal;
242
243 static bool isKind(const SVal& V) {
244 return !V.isUndef();
245 }
246 };
247
248 class UnknownVal : public DefinedOrUnknownSVal {
249 public:
250 explicit UnknownVal() : DefinedOrUnknownSVal(UnknownValKind) {}
251
252 private:
253 friend class SVal;
254
255 static bool isKind(const SVal &V) {
256 return V.getBaseKind() == UnknownValKind;
257 }
258 };
259
260 class DefinedSVal : public DefinedOrUnknownSVal {
261 public:
262 // We want calling these methods to be a compiler error since they are
263 // tautologically true/false.
264 bool isUnknown() const = delete;
265 bool isUnknownOrUndef() const = delete;
266 bool isValid() const = delete;
267
268 protected:
269 DefinedSVal() = default;
270 explicit DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
271 : DefinedOrUnknownSVal(d, isLoc, ValKind) {}
272
273 private:
274 friend class SVal;
275
276 static bool isKind(const SVal& V) {
277 return !V.isUnknownOrUndef();
278 }
279 };
280
281 /// Represents an SVal that is guaranteed to not be UnknownVal.
282 class KnownSVal : public SVal {
283 friend class SVal;
284
285 KnownSVal() = default;
286
287 static bool isKind(const SVal &V) {
288 return !V.isUnknown();
289 }
290
291 public:
292 KnownSVal(const DefinedSVal &V) : SVal(V) {}
293 KnownSVal(const UndefinedVal &V) : SVal(V) {}
294 };
295
296 class NonLoc : public DefinedSVal {
297 protected:
298 NonLoc() = default;
299 explicit NonLoc(unsigned SubKind, const void *d)
300 : DefinedSVal(d, false, SubKind) {}
301
302 public:
303 void dumpToStream(raw_ostream &Out) const;
304
305 static bool isCompoundType(QualType T) {
306 return T->isArrayType() || T->isRecordType() ||
307 T->isComplexType() || T->isVectorType();
308 }
309
310 private:
311 friend class SVal;
312
313 static bool isKind(const SVal& V) {
314 return V.getBaseKind() == NonLocKind;
315 }
316 };
317
318 class Loc : public DefinedSVal {
319 protected:
320 Loc() = default;
321 explicit Loc(unsigned SubKind, const void *D)
322 : DefinedSVal(const_cast<void *>(D), true, SubKind) {}
323
324 public:
325 void dumpToStream(raw_ostream &Out) const;
326
327 static bool isLocType(QualType T) {
328 return T->isAnyPointerType() || T->isBlockPointerType() ||
329 T->isReferenceType() || T->isNullPtrType();
330 }
331
332 private:
333 friend class SVal;
334
335 static bool isKind(const SVal& V) {
336 return V.getBaseKind() == LocKind;
337 }
338 };
339
340 //==------------------------------------------------------------------------==//
341 // Subclasses of NonLoc.
342 //==------------------------------------------------------------------------==//
343
344 namespace nonloc {
345
346 /// Represents symbolic expression that isn't a location.
347 class SymbolVal : public NonLoc {
348 public:
349 SymbolVal() = delete;
350 SymbolVal(SymbolRef sym) : NonLoc(SymbolValKind, sym) {
351 assert(sym);
352 assert(!Loc::isLocType(sym->getType()));
353 }
354
355 SymbolRef getSymbol() const {
356 return (const SymExpr *) Data;
357 }
358
359 bool isExpression() const {
360 return !isa<SymbolData>(getSymbol());
361 }
362
363 private:
364 friend class SVal;
365
366 static bool isKind(const SVal& V) {
367 return V.getBaseKind() == NonLocKind &&
368 V.getSubKind() == SymbolValKind;
369 }
370
371 static bool isKind(const NonLoc& V) {
372 return V.getSubKind() == SymbolValKind;
373 }
374 };
375
376 /// Value representing integer constant.
377 class ConcreteInt : public NonLoc {
378 public:
379 explicit ConcreteInt(const llvm::APSInt& V) : NonLoc(ConcreteIntKind, &V) {}
380
381 const llvm::APSInt& getValue() const {
382 return *static_cast<const llvm::APSInt *>(Data);
383 }
384
385 // Transfer functions for binary/unary operations on ConcreteInts.
386 SVal evalBinOp(SValBuilder &svalBuilder, BinaryOperator::Opcode Op,
387 const ConcreteInt& R) const;
388
389 ConcreteInt evalComplement(SValBuilder &svalBuilder) const;
390
391 ConcreteInt evalMinus(SValBuilder &svalBuilder) const;
392
393 private:
394 friend class SVal;
395
396 ConcreteInt() = default;
397
398 static bool isKind(const SVal& V) {
399 return V.getBaseKind() == NonLocKind &&
400 V.getSubKind() == ConcreteIntKind;
401 }
402
403 static bool isKind(const NonLoc& V) {
404 return V.getSubKind() == ConcreteIntKind;
405 }
406 };
407
408 class LocAsInteger : public NonLoc {
409 friend class ento::SValBuilder;
410
411 explicit LocAsInteger(const std::pair<SVal, uintptr_t> &data)
412 : NonLoc(LocAsIntegerKind, &data) {
413 // We do not need to represent loc::ConcreteInt as LocAsInteger,
414 // as it'd collapse into a nonloc::ConcreteInt instead.
415 assert(data.first.getBaseKind() == LocKind &&
416 (data.first.getSubKind() == loc::MemRegionValKind ||
417 data.first.getSubKind() == loc::GotoLabelKind));
418 }
419
420 public:
421 Loc getLoc() const {
422 const std::pair<SVal, uintptr_t> *D =
423 static_cast<const std::pair<SVal, uintptr_t> *>(Data);
424 return D->first.castAs<Loc>();
425 }
426
427 Loc getPersistentLoc() const {
428 const std::pair<SVal, uintptr_t> *D =
429 static_cast<const std::pair<SVal, uintptr_t> *>(Data);
430 const SVal& V = D->first;
431 return V.castAs<Loc>();
432 }
433
434 unsigned getNumBits() const {
435 const std::pair<SVal, uintptr_t> *D =
436 static_cast<const std::pair<SVal, uintptr_t> *>(Data);
437 return D->second;
438 }
439
440 private:
441 friend class SVal;
442
443 LocAsInteger() = default;
444
445 static bool isKind(const SVal& V) {
446 return V.getBaseKind() == NonLocKind &&
447 V.getSubKind() == LocAsIntegerKind;
448 }
449
450 static bool isKind(const NonLoc& V) {
451 return V.getSubKind() == LocAsIntegerKind;
452 }
453 };
454
455 class CompoundVal : public NonLoc {
456 friend class ento::SValBuilder;
457
458 explicit CompoundVal(const CompoundValData* D) : NonLoc(CompoundValKind, D) {}
459
460 public:
461 const CompoundValData* getValue() const {
462 return static_cast<const CompoundValData *>(Data);
463 }
464
465 using iterator = llvm::ImmutableList<SVal>::iterator;
466
467 iterator begin() const;
468 iterator end() const;
469
470 private:
471 friend class SVal;
472
473 CompoundVal() = default;
474
475 static bool isKind(const SVal& V) {
476 return V.getBaseKind() == NonLocKind && V.getSubKind() == CompoundValKind;
477 }
478
479 static bool isKind(const NonLoc& V) {
480 return V.getSubKind() == CompoundValKind;
481 }
482 };
483
484 class LazyCompoundVal : public NonLoc {
485 friend class ento::SValBuilder;
486
487 explicit LazyCompoundVal(const LazyCompoundValData *D)
488 : NonLoc(LazyCompoundValKind, D) {}
489
490 public:
491 const LazyCompoundValData *getCVData() const {
492 return static_cast<const LazyCompoundValData *>(Data);
493 }
494
495 const void *getStore() const;
496 const TypedValueRegion *getRegion() const;
497
498 private:
499 friend class SVal;
500
501 LazyCompoundVal() = default;
502
503 static bool isKind(const SVal& V) {
504 return V.getBaseKind() == NonLocKind &&
505 V.getSubKind() == LazyCompoundValKind;
506 }
507
508 static bool isKind(const NonLoc& V) {
509 return V.getSubKind() == LazyCompoundValKind;
510 }
511 };
512
513 /// Value representing pointer-to-member.
514 ///
515 /// This value is qualified as NonLoc because neither loading nor storing
516 /// operations are applied to it. Instead, the analyzer uses the L-value coming
517 /// from pointer-to-member applied to an object.
518 /// This SVal is represented by a DeclaratorDecl which can be a member function
519 /// pointer or a member data pointer and a list of CXXBaseSpecifiers. This list
520 /// is required to accumulate the pointer-to-member cast history to figure out
521 /// the correct subobject field.
522 class PointerToMember : public NonLoc {
523 friend class ento::SValBuilder;
524
525 public:
526 using PTMDataType =
527 llvm::PointerUnion<const DeclaratorDecl *, const PointerToMemberData *>;
528
529 const PTMDataType getPTMData() const {
530 return PTMDataType::getFromOpaqueValue(const_cast<void *>(Data));
531 }
532
533 bool isNullMemberPointer() const;
534
535 const DeclaratorDecl *getDecl() const;
536
537 template<typename AdjustedDecl>
538 const AdjustedDecl *getDeclAs() const {
539 return dyn_cast_or_null<AdjustedDecl>(getDecl());
540 }
541
542 using iterator = llvm::ImmutableList<const CXXBaseSpecifier *>::iterator;
543
544 iterator begin() const;
545 iterator end() const;
546
547 private:
548 friend class SVal;
549
550 PointerToMember() = default;
551 explicit PointerToMember(const PTMDataType D)
552 : NonLoc(PointerToMemberKind, D.getOpaqueValue()) {}
553
554 static bool isKind(const SVal& V) {
555 return V.getBaseKind() == NonLocKind &&
556 V.getSubKind() == PointerToMemberKind;
557 }
558
559 static bool isKind(const NonLoc& V) {
560 return V.getSubKind() == PointerToMemberKind;
561 }
562 };
563
564 } // namespace nonloc
565
566 //==------------------------------------------------------------------------==//
567 // Subclasses of Loc.
568 //==------------------------------------------------------------------------==//
569
570 namespace loc {
571
572 class GotoLabel : public Loc {
573 public:
574 explicit GotoLabel(const LabelDecl *Label) : Loc(GotoLabelKind, Label) {
575 assert(Label);
576 }
577
578 const LabelDecl *getLabel() const {
579 return static_cast<const LabelDecl *>(Data);
580 }
581
582 private:
583 friend class SVal;
584
585 GotoLabel() = default;
586
587 static bool isKind(const SVal& V) {
588 return V.getBaseKind() == LocKind && V.getSubKind() == GotoLabelKind;
589 }
590
591 static bool isKind(const Loc& V) {
592 return V.getSubKind() == GotoLabelKind;
593 }
594 };
595
596 class MemRegionVal : public Loc {
597 public:
598 explicit MemRegionVal(const MemRegion* r) : Loc(MemRegionValKind, r) {
599 assert(r);
600 }
601
602 /// Get the underlining region.
603 const MemRegion *getRegion() const {
604 return static_cast<const MemRegion *>(Data);
605 }
606
607 /// Get the underlining region and strip casts.
608 const MemRegion* stripCasts(bool StripBaseCasts = true) const;
609
610 template <typename REGION>
611 const REGION* getRegionAs() const {
612 return dyn_cast<REGION>(getRegion());
613 }
614
615 bool operator==(const MemRegionVal &R) const {
616 return getRegion() == R.getRegion();
617 }
618
619 bool operator!=(const MemRegionVal &R) const {
620 return getRegion() != R.getRegion();
621 }
622
623 private:
624 friend class SVal;
625
626 MemRegionVal() = default;
627
628 static bool isKind(const SVal& V) {
629 return V.getBaseKind() == LocKind &&
630 V.getSubKind() == MemRegionValKind;
631 }
632
633 static bool isKind(const Loc& V) {
634 return V.getSubKind() == MemRegionValKind;
635 }
636 };
637
638 class ConcreteInt : public Loc {
639 public:
640 explicit ConcreteInt(const llvm::APSInt& V) : Loc(ConcreteIntKind, &V) {}
641
642 const llvm::APSInt &getValue() const {
643 return *static_cast<const llvm::APSInt *>(Data);
644 }
645
646 // Transfer functions for binary/unary operations on ConcreteInts.
647 SVal evalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op,
648 const ConcreteInt& R) const;
649
650 private:
651 friend class SVal;
652
653 ConcreteInt() = default;
654
655 static bool isKind(const SVal& V) {
656 return V.getBaseKind() == LocKind &&
657 V.getSubKind() == ConcreteIntKind;
658 }
659
660 static bool isKind(const Loc& V) {
661 return V.getSubKind() == ConcreteIntKind;
662 }
663 };
664
665 } // namespace loc
666
667 } // namespace ento
668
669 } // namespace clang
670
671 namespace llvm {
672
673 template <typename T> struct isPodLike;
674 template <> struct isPodLike<clang::ento::SVal> {
675 static const bool value = true;
676 };
677
678 } // namespace llvm
679
680 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H
clang::ento::SVal::BaseKind
BaseKind
Definition: SVals.h:78
clang::ento::DefinedSVal
Definition: SVals.h:260
clang::ento::KnownSVal::KnownSVal
KnownSVal(const UndefinedVal &V)
Definition: SVals.h:293
clang::Builtin::ID
ID
Definition: Builtins.h:49
ento
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1738
clang::ento::TypedValueRegion
TypedValueRegion - An abstract class representing regions having a typed value.
Definition: MemRegion.h:530
clang::ento::loc::MemRegionVal::operator!=
bool operator!=(const MemRegionVal &R) const
Definition: SVals.h:619
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:638
clang::ento::MemRegion
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:95
clang::Type::isBlockPointerType
bool isBlockPointerType() const
Definition: Type.h:6304
clang::Type::isArrayType
bool isArrayType() const
Definition: Type.h:6345
clang::ento::LazyCompoundValData
Definition: BasicValueFactory.h:62
clang::ento::nonloc::CompoundVal
Definition: SVals.h:455
clang::ento::SVal::SVal
SVal(BaseKind k, const void *D=nullptr)
Definition: SVals.h:96
llvm
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
clang::ento::DefinedOrUnknownSVal::DefinedOrUnknownSVal
DefinedOrUnknownSVal(const void *d, bool isLoc, unsigned ValKind)
Definition: SVals.h:236
clang::ento::loc::MemRegionVal::getRegionAs
const REGION * getRegionAs() const
Definition: SVals.h:611
Type.h
C Language Family Type Representation.
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6369
clang::ento::SVal::SVal
SVal(const void *d, bool isLoc, unsigned ValKind)
Definition: SVals.h:93
clang::ento::nonloc::PointerToMember::iterator
llvm::ImmutableList< const CXXBaseSpecifier * >::iterator iterator
Definition: SVals.h:542
clang::ento::Loc::Loc
Loc(unsigned SubKind, const void *D)
Definition: SVals.h:321
clang::ento::nonloc::ConcreteInt
Value representing integer constant.
Definition: SVals.h:377
clang::ento::loc::GotoLabel::GotoLabel
GotoLabel(const LabelDecl *Label)
Definition: SVals.h:574
stripCasts
static const Expr * stripCasts(ASTContext &C, const Expr *Ex)
Definition: UninitializedValues.cpp:297
clang::ento::UndefinedVal
Definition: SVals.h:215
clang::ento::nonloc::Kind
Kind
Sub-kinds for NonLoc values.
Definition: SVals.h:56
clang::ento::BasicValueFactory
Definition: BasicValueFactory.h:107
clang::ento::UnknownVal::UnknownVal
UnknownVal()
Definition: SVals.h:250
clang::ento::SymExpr
Symbolic value.
Definition: SymExpr.h:30
clang::ento::nonloc::PointerToMember::getPTMData
const PTMDataType getPTMData() const
Definition: SVals.h:529
clang::ento::CompoundValData
Definition: BasicValueFactory.h:42
clang::ento::SVal::dumpToStream
void dumpToStream(raw_ostream &OS) const
Definition: SVals.cpp:287
llvm::Optional
Definition: LLVM.h:38
clang::ento::nonloc::PointerToMember
Value representing pointer-to-member.
Definition: SVals.h:522
clang::ento::nonloc::CompoundVal::iterator
llvm::ImmutableList< SVal >::iterator iterator
Definition: SVals.h:465
clang::ento::nonloc::LocAsInteger::getNumBits
unsigned getNumBits() const
Definition: SVals.h:434
clang::ento::nonloc::ConcreteInt::ConcreteInt
ConcreteInt(const llvm::APSInt &V)
Definition: SVals.h:379
clang::Type::isReferenceType
bool isReferenceType() const
Definition: Type.h:6308
clang::ento::SymExpr::symbol_begin
symbol_iterator symbol_begin() const
Definition: SymExpr.h:87
clang::ento::loc::GotoLabel::getLabel
const LabelDecl * getLabel() const
Definition: SVals.h:578
clang::ento::NonLoc::isCompoundType
static bool isCompoundType(QualType T)
Definition: SVals.h:305
clang::ento::Loc::isLocType
static bool isLocType(QualType T)
Definition: SVals.h:327
clang::BinaryOperatorKind
BinaryOperatorKind
Definition: OperationKinds.h:26
clang::ento::SVal::getRawKind
unsigned getRawKind() const
Definition: SVals.h:118
clang::ento::loc::MemRegionVal::operator==
bool operator==(const MemRegionVal &R) const
Definition: SVals.h:615
dump
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Definition: CoverageMappingGen.cpp:1291
LLVM.h
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
clang::ento::nonloc::SymbolVal::SymbolVal
SymbolVal(SymbolRef sym)
Definition: SVals.h:350
clang::ento::SVal::isUnknown
bool isUnknown() const
Definition: SVals.h:137
clang::ento::DefinedOrUnknownSVal
Definition: SVals.h:227
clang::ento::nonloc::LazyCompoundVal::getCVData
const LazyCompoundValData * getCVData() const
Definition: SVals.h:491
clang::ento::SVal::symbol_end
SymExpr::symbol_iterator symbol_end() const
Definition: SVals.h:205
REGION
#define REGION(Id, Parent)
Definition: MemRegion.h:98
clang::ento::loc::GotoLabel
Definition: SVals.h:572
clang::ento::nonloc::SymbolVal::isExpression
bool isExpression() const
Definition: SVals.h:359
clang::ento::SVal::Data
const void * Data
Definition: SVals.h:87
clang::ento::KnownSVal::KnownSVal
KnownSVal(const DefinedSVal &V)
Definition: SVals.h:292
clang::ento::SymExpr::getType
virtual QualType getType() const =0
clang::Type::isComplexType
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:481
clang::DeclaratorDecl
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:689
clang::ento::SVal::getSubKind
unsigned getSubKind() const
Definition: SVals.h:120
Label
std::string Label
Definition: UsingDeclarationsSorter.cpp:70
clang::Type::isNullPtrType
bool isNullPtrType() const
Definition: Type.h:6569
clang::ento::nonloc::LocAsInteger::getLoc
Loc getLoc() const
Definition: SVals.h:421
clang::ento::SVal::isValid
bool isValid() const
Definition: SVals.h:149
clang::ento::loc::MemRegionVal::MemRegionVal
MemRegionVal(const MemRegion *r)
Definition: SVals.h:598
clang::ento::NonLoc
Definition: SVals.h:296
clang::ento::SVal::getAs
Optional< T > getAs() const
Convert to the specified SVal type, returning None if this SVal is not of the desired type...
Definition: SVals.h:112
clang::ento::loc::MemRegionVal::getRegion
const MemRegion * getRegion() const
Get the underlining region.
Definition: SVals.h:603
clang::ento::SVal::Profile
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: SVals.h:124
clang::ento::loc::ConcreteInt
Definition: SVals.h:638
clang::prec::PointerToMember
Definition: OperatorPrecedence.h:43
false
#define false
Definition: stdbool.h:33
Kind
Kind
Definition: ChrootChecker.cpp:29
clang::ento::SVal::operator==
bool operator==(const SVal &R) const
Definition: SVals.h:129
clang::ento::Loc
Definition: SVals.h:318
clang::ento::NonLoc::NonLoc
NonLoc(unsigned SubKind, const void *d)
Definition: SVals.h:299
clang::LabelDecl
Represents the declaration of a label.
Definition: Decl.h:469
llvm::isPodLike
Definition: DeclAccessPair.h:66
clang::ento::SVal
SVal - This represents a symbolic expression, which can be either an L-value or an R-value...
Definition: SVals.h:76
clang::Type::isAnyPointerType
bool isAnyPointerType() const
Definition: Type.h:6300
clang::ento::UndefinedVal::UndefinedVal
UndefinedVal()
Definition: SVals.h:217
clang::Type::isVectorType
bool isVectorType() const
Definition: Type.h:6381
clang::ento::DefinedOrUnknownSVal::DefinedOrUnknownSVal
DefinedOrUnknownSVal(BaseKind k, void *D=nullptr)
Definition: SVals.h:238
clang::ento::SVal::getBaseKind
BaseKind getBaseKind() const
Definition: SVals.h:119
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::ento::loc::Kind
Kind
Sub-kinds for Loc values.
Definition: SVals.h:66
clang::ento::operator<<
raw_ostream & operator<<(raw_ostream &Out, const CheckerBase &Checker)
Dump checker name to stream.
Definition: Checker.cpp:36
clang::ento::SymExpr::symbol_end
static symbol_iterator symbol_end()
Definition: SymExpr.h:88
clang::ento::DefinedSVal::DefinedSVal
DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
Definition: SVals.h:270
clang::ento::SValBuilder
Definition: SValBuilder.h:53
clang::ento::nonloc::SymbolVal
Represents symbolic expression that isn&#39;t a location.
Definition: SVals.h:347
clang::ento::loc::ConcreteInt::getValue
const llvm::APSInt & getValue() const
Definition: SVals.h:642
clang::ento::nonloc::LocAsInteger::getPersistentLoc
Loc getPersistentLoc() const
Definition: SVals.h:427
clang::ento::KnownSVal
Represents an SVal that is guaranteed to not be UnknownVal.
Definition: SVals.h:282
clang::ento::ObjKind::OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject, used in the Darwin kernel.
clang::ento::SVal::castAs
T castAs() const
Convert to the specified SVal type, asserting that this SVal is of the desired type.
Definition: SVals.h:104
SymExpr.h
clang::ento::nonloc::SymbolVal::getSymbol
SymbolRef getSymbol() const
Definition: SVals.h:355
clang::ento::SVal::operator!=
bool operator!=(const SVal &R) const
Definition: SVals.h:133
clang::ento::nonloc::LazyCompoundVal
Definition: SVals.h:484
clang::ento::nonloc::PointerToMember::PTMDataType
llvm::PointerUnion< const DeclaratorDecl *, const PointerToMemberData * > PTMDataType
Definition: SVals.h:527
clang::ento::nonloc::LocAsInteger
Definition: SVals.h:408
Expr.h
clang::ento::UnknownVal
Definition: SVals.h:248
clang::ento::SVal::isUndef
bool isUndef() const
Definition: SVals.h:141
clang::ento::SVal::symbol_begin
SymExpr::symbol_iterator symbol_begin() const
Definition: SVals.h:197
true
#define true
Definition: stdbool.h:32
clang::ento::nonloc::ConcreteInt::getValue
const llvm::APSInt & getValue() const
Definition: SVals.h:381
clang::ento::nonloc::CompoundVal::getValue
const CompoundValData * getValue() const
Definition: SVals.h:461
clang::ento::loc::ConcreteInt::ConcreteInt
ConcreteInt(const llvm::APSInt &V)
Definition: SVals.h:640
clang::ento::loc::MemRegionVal
Definition: SVals.h:596
clang::ento::nonloc::PointerToMember::getDeclAs
const AdjustedDecl * getDeclAs() const
Definition: SVals.h:538
clang::ento::SVal::isUnknownOrUndef
bool isUnknownOrUndef() const
Definition: SVals.h:145
clang::ento::SymExpr::symbol_iterator
Iterator over symbols that the current symbol depends on.
Definition: SymExpr.h:71