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"
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 
198  const SymExpr *SE = getAsSymbol(/*IncludeBaseRegions=*/true);
199  if (SE)
200  return SE->symbol_begin();
201  else
202  return SymExpr::symbol_iterator();
203  }
204 
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 
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 
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 
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 
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:
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
KnownSVal(const UndefinedVal &V)
Definition: SVals.h:293
Represents a function declaration or definition.
Definition: Decl.h:1738
TypedValueRegion - An abstract class representing regions having a typed value.
Definition: MemRegion.h:530
bool operator!=(const MemRegionVal &R) const
Definition: SVals.h:619
A (possibly-)qualified type.
Definition: Type.h:638
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:95
bool isBlockPointerType() const
Definition: Type.h:6304
bool isArrayType() const
Definition: Type.h:6345
SVal(BaseKind k, const void *D=nullptr)
Definition: SVals.h:96
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
DefinedOrUnknownSVal(const void *d, bool isLoc, unsigned ValKind)
Definition: SVals.h:236
const REGION * getRegionAs() const
Definition: SVals.h:611
C Language Family Type Representation.
bool isRecordType() const
Definition: Type.h:6369
SVal(const void *d, bool isLoc, unsigned ValKind)
Definition: SVals.h:93
llvm::ImmutableList< const CXXBaseSpecifier * >::iterator iterator
Definition: SVals.h:542
Loc(unsigned SubKind, const void *D)
Definition: SVals.h:321
Value representing integer constant.
Definition: SVals.h:377
GotoLabel(const LabelDecl *Label)
Definition: SVals.h:574
static const Expr * stripCasts(ASTContext &C, const Expr *Ex)
Kind
Sub-kinds for NonLoc values.
Definition: SVals.h:56
Symbolic value.
Definition: SymExpr.h:30
const PTMDataType getPTMData() const
Definition: SVals.h:529
void dumpToStream(raw_ostream &OS) const
Definition: SVals.cpp:287
Value representing pointer-to-member.
Definition: SVals.h:522
llvm::ImmutableList< SVal >::iterator iterator
Definition: SVals.h:465
unsigned getNumBits() const
Definition: SVals.h:434
ConcreteInt(const llvm::APSInt &V)
Definition: SVals.h:379
bool isReferenceType() const
Definition: Type.h:6308
symbol_iterator symbol_begin() const
Definition: SymExpr.h:87
const LabelDecl * getLabel() const
Definition: SVals.h:578
static bool isCompoundType(QualType T)
Definition: SVals.h:305
static bool isLocType(QualType T)
Definition: SVals.h:327
BinaryOperatorKind
unsigned getRawKind() const
Definition: SVals.h:118
bool operator==(const MemRegionVal &R) const
Definition: SVals.h:615
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
SymbolVal(SymbolRef sym)
Definition: SVals.h:350
bool isUnknown() const
Definition: SVals.h:137
const LazyCompoundValData * getCVData() const
Definition: SVals.h:491
SymExpr::symbol_iterator symbol_end() const
Definition: SVals.h:205
#define REGION(Id, Parent)
Definition: MemRegion.h:98
bool isExpression() const
Definition: SVals.h:359
const void * Data
Definition: SVals.h:87
KnownSVal(const DefinedSVal &V)
Definition: SVals.h:292
virtual QualType getType() const =0
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:481
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:689
unsigned getSubKind() const
Definition: SVals.h:120
std::string Label
bool isNullPtrType() const
Definition: Type.h:6569
bool isValid() const
Definition: SVals.h:149
MemRegionVal(const MemRegion *r)
Definition: SVals.h:598
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
const MemRegion * getRegion() const
Get the underlining region.
Definition: SVals.h:603
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: SVals.h:124
#define false
Definition: stdbool.h:33
Kind
bool operator==(const SVal &R) const
Definition: SVals.h:129
NonLoc(unsigned SubKind, const void *d)
Definition: SVals.h:299
Represents the declaration of a label.
Definition: Decl.h:469
SVal - This represents a symbolic expression, which can be either an L-value or an R-value...
Definition: SVals.h:76
bool isAnyPointerType() const
Definition: Type.h:6300
bool isVectorType() const
Definition: Type.h:6381
DefinedOrUnknownSVal(BaseKind k, void *D=nullptr)
Definition: SVals.h:238
BaseKind getBaseKind() const
Definition: SVals.h:119
Dataflow Directional Tag Classes.
Kind
Sub-kinds for Loc values.
Definition: SVals.h:66
raw_ostream & operator<<(raw_ostream &Out, const CheckerBase &Checker)
Dump checker name to stream.
Definition: Checker.cpp:36
static symbol_iterator symbol_end()
Definition: SymExpr.h:88
DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
Definition: SVals.h:270
Represents symbolic expression that isn&#39;t a location.
Definition: SVals.h:347
const llvm::APSInt & getValue() const
Definition: SVals.h:642
Represents an SVal that is guaranteed to not be UnknownVal.
Definition: SVals.h:282
Indicates that the tracking object is a descendant of a referenced-counted OSObject, used in the Darwin kernel.
T castAs() const
Convert to the specified SVal type, asserting that this SVal is of the desired type.
Definition: SVals.h:104
SymbolRef getSymbol() const
Definition: SVals.h:355
bool operator!=(const SVal &R) const
Definition: SVals.h:133
llvm::PointerUnion< const DeclaratorDecl *, const PointerToMemberData * > PTMDataType
Definition: SVals.h:527
bool isUndef() const
Definition: SVals.h:141
SymExpr::symbol_iterator symbol_begin() const
Definition: SVals.h:197
#define true
Definition: stdbool.h:32
const llvm::APSInt & getValue() const
Definition: SVals.h:381
const CompoundValData * getValue() const
Definition: SVals.h:461
ConcreteInt(const llvm::APSInt &V)
Definition: SVals.h:640
const AdjustedDecl * getDeclAs() const
Definition: SVals.h:538
bool isUnknownOrUndef() const
Definition: SVals.h:145
Iterator over symbols that the current symbol depends on.
Definition: SymExpr.h:71