clang  10.0.0svn
SymbolManager.h
Go to the documentation of this file.
1 //===- SymbolManager.h - Management of Symbolic Values ----------*- C++ -*-===//
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 file defines SymbolManager, a class that manages symbolic values
10 // created for use by ExprEngine and related classes.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SYMBOLMANAGER_H
15 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SYMBOLMANAGER_H
16 
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/Type.h"
20 #include "clang/Basic/LLVM.h"
24 #include "llvm/ADT/DenseMap.h"
25 #include "llvm/ADT/DenseSet.h"
26 #include "llvm/ADT/FoldingSet.h"
27 #include "llvm/Support/Allocator.h"
28 #include <cassert>
29 
30 namespace clang {
31 
32 class ASTContext;
33 class Stmt;
34 
35 namespace ento {
36 
37 class BasicValueFactory;
38 class StoreManager;
39 
40 ///A symbol representing the value stored at a MemRegion.
41 class SymbolRegionValue : public SymbolData {
42  const TypedValueRegion *R;
43 
44 public:
46  : SymbolData(SymbolRegionValueKind, sym), R(r) {
47  assert(r);
48  assert(isValidTypeForSymbol(r->getValueType()));
49  }
50 
51  const TypedValueRegion* getRegion() const { return R; }
52 
53  static void Profile(llvm::FoldingSetNodeID& profile, const TypedValueRegion* R) {
54  profile.AddInteger((unsigned) SymbolRegionValueKind);
55  profile.AddPointer(R);
56  }
57 
58  void Profile(llvm::FoldingSetNodeID& profile) override {
59  Profile(profile, R);
60  }
61 
62  void dumpToStream(raw_ostream &os) const override;
63  const MemRegion *getOriginRegion() const override { return getRegion(); }
64 
65  QualType getType() const override;
66 
67  // Implement isa<T> support.
68  static bool classof(const SymExpr *SE) {
69  return SE->getKind() == SymbolRegionValueKind;
70  }
71 };
72 
73 /// A symbol representing the result of an expression in the case when we do
74 /// not know anything about what the expression is.
75 class SymbolConjured : public SymbolData {
76  const Stmt *S;
77  QualType T;
78  unsigned Count;
79  const LocationContext *LCtx;
80  const void *SymbolTag;
81 
82 public:
83  SymbolConjured(SymbolID sym, const Stmt *s, const LocationContext *lctx,
84  QualType t, unsigned count, const void *symbolTag)
85  : SymbolData(SymbolConjuredKind, sym), S(s), T(t), Count(count),
86  LCtx(lctx), SymbolTag(symbolTag) {
87  // FIXME: 's' might be a nullptr if we're conducting invalidation
88  // that was caused by a destructor call on a temporary object,
89  // which has no statement associated with it.
90  // Due to this, we might be creating the same invalidation symbol for
91  // two different invalidation passes (for two different temporaries).
92  assert(lctx);
93  assert(isValidTypeForSymbol(t));
94  }
95 
96  const Stmt *getStmt() const { return S; }
97  unsigned getCount() const { return Count; }
98  const void *getTag() const { return SymbolTag; }
99 
100  QualType getType() const override;
101 
102  void dumpToStream(raw_ostream &os) const override;
103 
104  static void Profile(llvm::FoldingSetNodeID& profile, const Stmt *S,
105  QualType T, unsigned Count, const LocationContext *LCtx,
106  const void *SymbolTag) {
107  profile.AddInteger((unsigned) SymbolConjuredKind);
108  profile.AddPointer(S);
109  profile.AddPointer(LCtx);
110  profile.Add(T);
111  profile.AddInteger(Count);
112  profile.AddPointer(SymbolTag);
113  }
114 
115  void Profile(llvm::FoldingSetNodeID& profile) override {
116  Profile(profile, S, T, Count, LCtx, SymbolTag);
117  }
118 
119  // Implement isa<T> support.
120  static bool classof(const SymExpr *SE) {
121  return SE->getKind() == SymbolConjuredKind;
122  }
123 };
124 
125 /// A symbol representing the value of a MemRegion whose parent region has
126 /// symbolic value.
127 class SymbolDerived : public SymbolData {
128  SymbolRef parentSymbol;
129  const TypedValueRegion *R;
130 
131 public:
133  : SymbolData(SymbolDerivedKind, sym), parentSymbol(parent), R(r) {
134  assert(parent);
135  assert(r);
136  assert(isValidTypeForSymbol(r->getValueType()));
137  }
138 
139  SymbolRef getParentSymbol() const { return parentSymbol; }
140  const TypedValueRegion *getRegion() const { return R; }
141 
142  QualType getType() const override;
143 
144  void dumpToStream(raw_ostream &os) const override;
145  const MemRegion *getOriginRegion() const override { return getRegion(); }
146 
147  static void Profile(llvm::FoldingSetNodeID& profile, SymbolRef parent,
148  const TypedValueRegion *r) {
149  profile.AddInteger((unsigned) SymbolDerivedKind);
150  profile.AddPointer(r);
151  profile.AddPointer(parent);
152  }
153 
154  void Profile(llvm::FoldingSetNodeID& profile) override {
155  Profile(profile, parentSymbol, R);
156  }
157 
158  // Implement isa<T> support.
159  static bool classof(const SymExpr *SE) {
160  return SE->getKind() == SymbolDerivedKind;
161  }
162 };
163 
164 /// SymbolExtent - Represents the extent (size in bytes) of a bounded region.
165 /// Clients should not ask the SymbolManager for a region's extent. Always use
166 /// SubRegion::getExtent instead -- the value returned may not be a symbol.
167 class SymbolExtent : public SymbolData {
168  const SubRegion *R;
169 
170 public:
172  : SymbolData(SymbolExtentKind, sym), R(r) {
173  assert(r);
174  }
175 
176  const SubRegion *getRegion() const { return R; }
177 
178  QualType getType() const override;
179 
180  void dumpToStream(raw_ostream &os) const override;
181 
182  static void Profile(llvm::FoldingSetNodeID& profile, const SubRegion *R) {
183  profile.AddInteger((unsigned) SymbolExtentKind);
184  profile.AddPointer(R);
185  }
186 
187  void Profile(llvm::FoldingSetNodeID& profile) override {
188  Profile(profile, R);
189  }
190 
191  // Implement isa<T> support.
192  static bool classof(const SymExpr *SE) {
193  return SE->getKind() == SymbolExtentKind;
194  }
195 };
196 
197 /// SymbolMetadata - Represents path-dependent metadata about a specific region.
198 /// Metadata symbols remain live as long as they are marked as in use before
199 /// dead-symbol sweeping AND their associated regions are still alive.
200 /// Intended for use by checkers.
201 class SymbolMetadata : public SymbolData {
202  const MemRegion* R;
203  const Stmt *S;
204  QualType T;
205  const LocationContext *LCtx;
206  unsigned Count;
207  const void *Tag;
208 
209 public:
210  SymbolMetadata(SymbolID sym, const MemRegion* r, const Stmt *s, QualType t,
211  const LocationContext *LCtx, unsigned count, const void *tag)
212  : SymbolData(SymbolMetadataKind, sym), R(r), S(s), T(t), LCtx(LCtx),
213  Count(count), Tag(tag) {
214  assert(r);
215  assert(s);
216  assert(isValidTypeForSymbol(t));
217  assert(LCtx);
218  assert(tag);
219  }
220 
221  const MemRegion *getRegion() const { return R; }
222  const Stmt *getStmt() const { return S; }
223  const LocationContext *getLocationContext() const { return LCtx; }
224  unsigned getCount() const { return Count; }
225  const void *getTag() const { return Tag; }
226 
227  QualType getType() const override;
228 
229  void dumpToStream(raw_ostream &os) const override;
230 
231  static void Profile(llvm::FoldingSetNodeID& profile, const MemRegion *R,
232  const Stmt *S, QualType T, const LocationContext *LCtx,
233  unsigned Count, const void *Tag) {
234  profile.AddInteger((unsigned) SymbolMetadataKind);
235  profile.AddPointer(R);
236  profile.AddPointer(S);
237  profile.Add(T);
238  profile.AddPointer(LCtx);
239  profile.AddInteger(Count);
240  profile.AddPointer(Tag);
241  }
242 
243  void Profile(llvm::FoldingSetNodeID& profile) override {
244  Profile(profile, R, S, T, LCtx, Count, Tag);
245  }
246 
247  // Implement isa<T> support.
248  static bool classof(const SymExpr *SE) {
249  return SE->getKind() == SymbolMetadataKind;
250  }
251 };
252 
253 /// Represents a cast expression.
254 class SymbolCast : public SymExpr {
255  const SymExpr *Operand;
256 
257  /// Type of the operand.
258  QualType FromTy;
259 
260  /// The type of the result.
261  QualType ToTy;
262 
263 public:
264  SymbolCast(const SymExpr *In, QualType From, QualType To)
265  : SymExpr(SymbolCastKind), Operand(In), FromTy(From), ToTy(To) {
266  assert(In);
267  assert(isValidTypeForSymbol(From));
268  // FIXME: GenericTaintChecker creates symbols of void type.
269  // Otherwise, 'To' should also be a valid type.
270  }
271 
272  unsigned computeComplexity() const override {
273  if (Complexity == 0)
274  Complexity = 1 + Operand->computeComplexity();
275  return Complexity;
276  }
277 
278  QualType getType() const override { return ToTy; }
279 
280  const SymExpr *getOperand() const { return Operand; }
281 
282  void dumpToStream(raw_ostream &os) const override;
283 
284  static void Profile(llvm::FoldingSetNodeID& ID,
285  const SymExpr *In, QualType From, QualType To) {
286  ID.AddInteger((unsigned) SymbolCastKind);
287  ID.AddPointer(In);
288  ID.Add(From);
289  ID.Add(To);
290  }
291 
292  void Profile(llvm::FoldingSetNodeID& ID) override {
293  Profile(ID, Operand, FromTy, ToTy);
294  }
295 
296  // Implement isa<T> support.
297  static bool classof(const SymExpr *SE) {
298  return SE->getKind() == SymbolCastKind;
299  }
300 };
301 
302 /// Represents a symbolic expression involving a binary operator
303 class BinarySymExpr : public SymExpr {
305  QualType T;
306 
307 protected:
309  : SymExpr(k), Op(op), T(t) {
310  assert(classof(this));
311  // Binary expressions are results of arithmetic. Pointer arithmetic is not
312  // handled by binary expressions, but it is instead handled by applying
313  // sub-regions to regions.
314  assert(isValidTypeForSymbol(t) && !Loc::isLocType(t));
315  }
316 
317 public:
318  // FIXME: We probably need to make this out-of-line to avoid redundant
319  // generation of virtual functions.
320  QualType getType() const override { return T; }
321 
322  BinaryOperator::Opcode getOpcode() const { return Op; }
323 
324  // Implement isa<T> support.
325  static bool classof(const SymExpr *SE) {
326  Kind k = SE->getKind();
327  return k >= BEGIN_BINARYSYMEXPRS && k <= END_BINARYSYMEXPRS;
328  }
329 };
330 
331 /// Represents a symbolic expression like 'x' + 3.
332 class SymIntExpr : public BinarySymExpr {
333  const SymExpr *LHS;
334  const llvm::APSInt& RHS;
335 
336 public:
338  const llvm::APSInt &rhs, QualType t)
339  : BinarySymExpr(SymIntExprKind, op, t), LHS(lhs), RHS(rhs) {
340  assert(lhs);
341  }
342 
343  void dumpToStream(raw_ostream &os) const override;
344 
345  const SymExpr *getLHS() const { return LHS; }
346  const llvm::APSInt &getRHS() const { return RHS; }
347 
348  unsigned computeComplexity() const override {
349  if (Complexity == 0)
350  Complexity = 1 + LHS->computeComplexity();
351  return Complexity;
352  }
353 
354  static void Profile(llvm::FoldingSetNodeID& ID, const SymExpr *lhs,
355  BinaryOperator::Opcode op, const llvm::APSInt& rhs,
356  QualType t) {
357  ID.AddInteger((unsigned) SymIntExprKind);
358  ID.AddPointer(lhs);
359  ID.AddInteger(op);
360  ID.AddPointer(&rhs);
361  ID.Add(t);
362  }
363 
364  void Profile(llvm::FoldingSetNodeID& ID) override {
365  Profile(ID, LHS, getOpcode(), RHS, getType());
366  }
367 
368  // Implement isa<T> support.
369  static bool classof(const SymExpr *SE) {
370  return SE->getKind() == SymIntExprKind;
371  }
372 };
373 
374 /// Represents a symbolic expression like 3 - 'x'.
375 class IntSymExpr : public BinarySymExpr {
376  const llvm::APSInt& LHS;
377  const SymExpr *RHS;
378 
379 public:
381  const SymExpr *rhs, QualType t)
382  : BinarySymExpr(IntSymExprKind, op, t), LHS(lhs), RHS(rhs) {
383  assert(rhs);
384  }
385 
386  void dumpToStream(raw_ostream &os) const override;
387 
388  const SymExpr *getRHS() const { return RHS; }
389  const llvm::APSInt &getLHS() const { return LHS; }
390 
391  unsigned computeComplexity() const override {
392  if (Complexity == 0)
393  Complexity = 1 + RHS->computeComplexity();
394  return Complexity;
395  }
396 
397  static void Profile(llvm::FoldingSetNodeID& ID, const llvm::APSInt& lhs,
398  BinaryOperator::Opcode op, const SymExpr *rhs,
399  QualType t) {
400  ID.AddInteger((unsigned) IntSymExprKind);
401  ID.AddPointer(&lhs);
402  ID.AddInteger(op);
403  ID.AddPointer(rhs);
404  ID.Add(t);
405  }
406 
407  void Profile(llvm::FoldingSetNodeID& ID) override {
408  Profile(ID, LHS, getOpcode(), RHS, getType());
409  }
410 
411  // Implement isa<T> support.
412  static bool classof(const SymExpr *SE) {
413  return SE->getKind() == IntSymExprKind;
414  }
415 };
416 
417 /// Represents a symbolic expression like 'x' + 'y'.
418 class SymSymExpr : public BinarySymExpr {
419  const SymExpr *LHS;
420  const SymExpr *RHS;
421 
422 public:
423  SymSymExpr(const SymExpr *lhs, BinaryOperator::Opcode op, const SymExpr *rhs,
424  QualType t)
425  : BinarySymExpr(SymSymExprKind, op, t), LHS(lhs), RHS(rhs) {
426  assert(lhs);
427  assert(rhs);
428  }
429 
430  const SymExpr *getLHS() const { return LHS; }
431  const SymExpr *getRHS() const { return RHS; }
432 
433  void dumpToStream(raw_ostream &os) const override;
434 
435  unsigned computeComplexity() const override {
436  if (Complexity == 0)
438  return Complexity;
439  }
440 
441  static void Profile(llvm::FoldingSetNodeID& ID, const SymExpr *lhs,
442  BinaryOperator::Opcode op, const SymExpr *rhs, QualType t) {
443  ID.AddInteger((unsigned) SymSymExprKind);
444  ID.AddPointer(lhs);
445  ID.AddInteger(op);
446  ID.AddPointer(rhs);
447  ID.Add(t);
448  }
449 
450  void Profile(llvm::FoldingSetNodeID& ID) override {
451  Profile(ID, LHS, getOpcode(), RHS, getType());
452  }
453 
454  // Implement isa<T> support.
455  static bool classof(const SymExpr *SE) {
456  return SE->getKind() == SymSymExprKind;
457  }
458 };
459 
461  using DataSetTy = llvm::FoldingSet<SymExpr>;
462  using SymbolDependTy = llvm::DenseMap<SymbolRef, SymbolRefSmallVectorTy *>;
463 
464  DataSetTy DataSet;
465 
466  /// Stores the extra dependencies between symbols: the data should be kept
467  /// alive as long as the key is live.
468  SymbolDependTy SymbolDependencies;
469 
470  unsigned SymbolCounter = 0;
471  llvm::BumpPtrAllocator& BPAlloc;
472  BasicValueFactory &BV;
473  ASTContext &Ctx;
474 
475 public:
477  llvm::BumpPtrAllocator& bpalloc)
478  : SymbolDependencies(16), BPAlloc(bpalloc), BV(bv), Ctx(ctx) {}
479  ~SymbolManager();
480 
481  static bool canSymbolicate(QualType T);
482 
483  /// Make a unique symbol for MemRegion R according to its kind.
484  const SymbolRegionValue* getRegionValueSymbol(const TypedValueRegion* R);
485 
486  const SymbolConjured* conjureSymbol(const Stmt *E,
487  const LocationContext *LCtx,
488  QualType T,
489  unsigned VisitCount,
490  const void *SymbolTag = nullptr);
491 
493  const LocationContext *LCtx,
494  unsigned VisitCount,
495  const void *SymbolTag = nullptr) {
496  return conjureSymbol(E, LCtx, E->getType(), VisitCount, SymbolTag);
497  }
498 
499  const SymbolDerived *getDerivedSymbol(SymbolRef parentSymbol,
500  const TypedValueRegion *R);
501 
502  const SymbolExtent *getExtentSymbol(const SubRegion *R);
503 
504  /// Creates a metadata symbol associated with a specific region.
505  ///
506  /// VisitCount can be used to differentiate regions corresponding to
507  /// different loop iterations, thus, making the symbol path-dependent.
508  const SymbolMetadata *getMetadataSymbol(const MemRegion *R, const Stmt *S,
509  QualType T,
510  const LocationContext *LCtx,
511  unsigned VisitCount,
512  const void *SymbolTag = nullptr);
513 
514  const SymbolCast* getCastSymbol(const SymExpr *Operand,
515  QualType From, QualType To);
516 
517  const SymIntExpr *getSymIntExpr(const SymExpr *lhs, BinaryOperator::Opcode op,
518  const llvm::APSInt& rhs, QualType t);
519 
521  const llvm::APSInt& rhs, QualType t) {
522  return getSymIntExpr(&lhs, op, rhs, t);
523  }
524 
525  const IntSymExpr *getIntSymExpr(const llvm::APSInt& lhs,
527  const SymExpr *rhs, QualType t);
528 
529  const SymSymExpr *getSymSymExpr(const SymExpr *lhs, BinaryOperator::Opcode op,
530  const SymExpr *rhs, QualType t);
531 
532  QualType getType(const SymExpr *SE) const {
533  return SE->getType();
534  }
535 
536  /// Add artificial symbol dependency.
537  ///
538  /// The dependent symbol should stay alive as long as the primary is alive.
539  void addSymbolDependency(const SymbolRef Primary, const SymbolRef Dependent);
540 
541  const SymbolRefSmallVectorTy *getDependentSymbols(const SymbolRef Primary);
542 
543  ASTContext &getContext() { return Ctx; }
544  BasicValueFactory &getBasicVals() { return BV; }
545 };
546 
547 /// A class responsible for cleaning up unused symbols.
549  enum SymbolStatus {
550  NotProcessed,
551  HaveMarkedDependents
552  };
553 
555  using SymbolMapTy = llvm::DenseMap<SymbolRef, SymbolStatus>;
557 
558  SymbolMapTy TheLiving;
559  SymbolSetTy MetadataInUse;
560 
561  RegionSetTy RegionRoots;
562 
563  const StackFrameContext *LCtx;
564  const Stmt *Loc;
565  SymbolManager& SymMgr;
566  StoreRef reapedStore;
567  llvm::DenseMap<const MemRegion *, unsigned> includedRegionCache;
568 
569 public:
570  /// Construct a reaper object, which removes everything which is not
571  /// live before we execute statement s in the given location context.
572  ///
573  /// If the statement is NULL, everything is this and parent contexts is
574  /// considered live.
575  /// If the stack frame context is NULL, everything on stack is considered
576  /// dead.
577  SymbolReaper(const StackFrameContext *Ctx, const Stmt *s,
578  SymbolManager &symmgr, StoreManager &storeMgr)
579  : LCtx(Ctx), Loc(s), SymMgr(symmgr), reapedStore(nullptr, storeMgr) {}
580 
581  const LocationContext *getLocationContext() const { return LCtx; }
582 
583  bool isLive(SymbolRef sym);
584  bool isLiveRegion(const MemRegion *region);
585  bool isLive(const Stmt *ExprVal, const LocationContext *LCtx) const;
586  bool isLive(const VarRegion *VR, bool includeStoreBindings = false) const;
587 
588  /// Unconditionally marks a symbol as live.
589  ///
590  /// This should never be
591  /// used by checkers, only by the state infrastructure such as the store and
592  /// environment. Checkers should instead use metadata symbols and markInUse.
593  void markLive(SymbolRef sym);
594 
595  /// Marks a symbol as important to a checker.
596  ///
597  /// For metadata symbols,
598  /// this will keep the symbol alive as long as its associated region is also
599  /// live. For other symbols, this has no effect; checkers are not permitted
600  /// to influence the life of other symbols. This should be used before any
601  /// symbol marking has occurred, i.e. in the MarkLiveSymbols callback.
602  void markInUse(SymbolRef sym);
603 
604  using region_iterator = RegionSetTy::const_iterator;
605 
606  region_iterator region_begin() const { return RegionRoots.begin(); }
607  region_iterator region_end() const { return RegionRoots.end(); }
608 
609  /// Returns whether or not a symbol has been confirmed dead.
610  ///
611  /// This should only be called once all marking of dead symbols has completed.
612  /// (For checkers, this means only in the checkDeadSymbols callback.)
613  bool isDead(SymbolRef sym) {
614  return !isLive(sym);
615  }
616 
617  void markLive(const MemRegion *region);
618  void markElementIndicesLive(const MemRegion *region);
619 
620  /// Set to the value of the symbolic store after
621  /// StoreManager::removeDeadBindings has been called.
622  void setReapedStore(StoreRef st) { reapedStore = st; }
623 
624 private:
625  /// Mark the symbols dependent on the input symbol as live.
626  void markDependentsLive(SymbolRef sym);
627 };
628 
630 protected:
631  ~SymbolVisitor() = default;
632 
633 public:
634  SymbolVisitor() = default;
635  SymbolVisitor(const SymbolVisitor &) = default;
637 
638  /// A visitor method invoked by ProgramStateManager::scanReachableSymbols.
639  ///
640  /// The method returns \c true if symbols should continue be scanned and \c
641  /// false otherwise.
642  virtual bool VisitSymbol(SymbolRef sym) = 0;
643  virtual bool VisitMemRegion(const MemRegion *) { return true; }
644 };
645 
646 } // namespace ento
647 
648 } // namespace clang
649 
650 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SYMBOLMANAGER_H
static bool classof(const SymExpr *SE)
TypedValueRegion - An abstract class representing regions having a typed value.
Definition: MemRegion.h:530
A (possibly-)qualified type.
Definition: Type.h:643
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:94
SymbolDerived(SymbolID sym, SymbolRef parent, const TypedValueRegion *r)
bool isDead(SymbolRef sym)
Returns whether or not a symbol has been confirmed dead.
unsigned computeComplexity() const override
Stmt - This represents one statement.
Definition: Stmt.h:66
C Language Family Type Representation.
static void Profile(llvm::FoldingSetNodeID &profile, const TypedValueRegion *R)
Definition: SymbolManager.h:53
static bool classof(const SymExpr *SE)
virtual QualType getValueType() const =0
const SymExpr * getOperand() const
void Profile(llvm::FoldingSetNodeID &profile) override
virtual unsigned computeComplexity() const =0
BasicValueFactory & getBasicVals()
SymbolManager(ASTContext &ctx, BasicValueFactory &bv, llvm::BumpPtrAllocator &bpalloc)
Symbolic value.
Definition: SymExpr.h:29
SymbolCast(const SymExpr *In, QualType From, QualType To)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:160
static void Profile(llvm::FoldingSetNodeID &profile, SymbolRef parent, const TypedValueRegion *r)
void Profile(llvm::FoldingSetNodeID &profile) override
SymbolReaper(const StackFrameContext *Ctx, const Stmt *s, SymbolManager &symmgr, StoreManager &storeMgr)
Construct a reaper object, which removes everything which is not live before we execute statement s i...
unsigned getCount() const
Definition: SymbolManager.h:97
unsigned Complexity
Definition: SymExpr.h:51
void setReapedStore(StoreRef st)
Set to the value of the symbolic store after StoreManager::removeDeadBindings has been called...
static void Profile(llvm::FoldingSetNodeID &ID, const SymExpr *lhs, BinaryOperator::Opcode op, const llvm::APSInt &rhs, QualType t)
SymbolConjured(SymbolID sym, const Stmt *s, const LocationContext *lctx, QualType t, unsigned count, const void *symbolTag)
Definition: SymbolManager.h:83
static bool isLocType(QualType T)
Definition: SVals.h:329
SymbolExtent(SymbolID sym, const SubRegion *r)
BinaryOperatorKind
static bool classof(const SymExpr *SE)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
QualType getType(const SymExpr *SE) const
RegionSetTy::const_iterator region_iterator
Represents a symbolic expression like &#39;x&#39; + 3.
A symbol representing the value of a MemRegion whose parent region has symbolic value.
void Profile(llvm::FoldingSetNodeID &ID) override
const MemRegion * getRegion() const
virtual QualType getType() const =0
static void Profile(llvm::FoldingSetNodeID &ID, const llvm::APSInt &lhs, BinaryOperator::Opcode op, const SymExpr *rhs, QualType t)
const void * getTag() const
const LocationContext * getLocationContext() const
static bool classof(const SymExpr *SE)
static void Profile(llvm::FoldingSetNodeID &profile, const Stmt *S, QualType T, unsigned Count, const LocationContext *LCtx, const void *SymbolTag)
const SymIntExpr * getSymIntExpr(const SymExpr &lhs, BinaryOperator::Opcode op, const llvm::APSInt &rhs, QualType t)
This represents one expression.
Definition: Expr.h:108
const TypedValueRegion * getRegion() const
void Profile(llvm::FoldingSetNodeID &profile) override
const SubRegion * getRegion() const
Represents a cast expression.
const LocationContext * getLocationContext() const
QualType getType() const
Definition: Expr.h:137
static void Profile(llvm::FoldingSetNodeID &profile, const MemRegion *R, const Stmt *S, QualType T, const LocationContext *LCtx, unsigned Count, const void *Tag)
static bool classof(const SymExpr *SE)
virtual bool VisitMemRegion(const MemRegion *)
IntSymExpr(const llvm::APSInt &lhs, BinaryOperator::Opcode op, const SymExpr *rhs, QualType t)
const SymExpr * getRHS() const
static bool classof(const SymExpr *SE)
Definition: SymbolManager.h:68
const TypedValueRegion * getRegion() const
Definition: SymbolManager.h:51
const SymExpr * getLHS() const
llvm::APSInt APSInt
const void * getTag() const
Definition: SymbolManager.h:98
Represents a symbolic expression like 3 - &#39;x&#39;.
const SymbolConjured * conjureSymbol(const Expr *E, const LocationContext *LCtx, unsigned VisitCount, const void *SymbolTag=nullptr)
void dumpToStream(raw_ostream &os) const override
QualType getType() const override
const llvm::APSInt & getLHS() const
A class responsible for cleaning up unused symbols.
SymIntExpr(const SymExpr *lhs, BinaryOperator::Opcode op, const llvm::APSInt &rhs, QualType t)
unsigned computeComplexity() const override
region_iterator region_end() const
QualType getType() const override
A symbol representing the result of an expression in the case when we do not know anything about what...
Definition: SymbolManager.h:75
static bool isValidTypeForSymbol(QualType T)
Definition: SymExpr.h:45
A symbol representing the value stored at a MemRegion.
Definition: SymbolManager.h:41
Dataflow Directional Tag Classes.
static void Profile(llvm::FoldingSetNodeID &ID, const SymExpr *In, QualType From, QualType To)
SymbolRegionValue(SymbolID sym, const TypedValueRegion *r)
Definition: SymbolManager.h:45
Represents a symbolic expression involving a binary operator.
const llvm::APSInt & getRHS() const
region_iterator region_begin() const
const MemRegion * getOriginRegion() const override
Find the region from which this symbol originates.
const Stmt * getStmt() const
QualType getType() const override
static bool classof(const SymExpr *SE)
SymbolMetadata(SymbolID sym, const MemRegion *r, const Stmt *s, QualType t, const LocationContext *LCtx, unsigned count, const void *tag)
void Profile(llvm::FoldingSetNodeID &ID) override
unsigned computeComplexity() const override
const SymExpr * getRHS() const
SymbolVisitor(SymbolVisitor &&)
static bool classof(const SymExpr *SE)
SubRegion - A region that subsets another larger region.
Definition: MemRegion.h:436
void Profile(llvm::FoldingSetNodeID &ID) override
const Stmt * getStmt() const
Definition: SymbolManager.h:96
SymbolMetadata - Represents path-dependent metadata about a specific region.
static void Profile(llvm::FoldingSetNodeID &profile, const SubRegion *R)
Kind getKind() const
Definition: SymExpr.h:56
unsigned SymbolID
Definition: SymExpr.h:112
const MemRegion * getOriginRegion() const override
Find the region from which this symbol originates.
Definition: SymbolManager.h:63
BinaryOperator::Opcode getOpcode() const
SymbolRef getParentSymbol() const
SymSymExpr(const SymExpr *lhs, BinaryOperator::Opcode op, const SymExpr *rhs, QualType t)
void Profile(llvm::FoldingSetNodeID &profile) override
Definition: SymbolManager.h:58
static bool classof(const SymExpr *SE)
static bool classof(const SymExpr *SE)
BinarySymExpr(Kind k, BinaryOperator::Opcode op, QualType t)
SymbolExtent - Represents the extent (size in bytes) of a bounded region.
void Profile(llvm::FoldingSetNodeID &profile) override
void Profile(llvm::FoldingSetNodeID &ID) override
unsigned computeComplexity() const override
Represents a symbolic expression like &#39;x&#39; + &#39;y&#39;.
A symbol representing data which can be stored in a memory location (region).
Definition: SymExpr.h:116
const SymExpr * getLHS() const
static void Profile(llvm::FoldingSetNodeID &ID, const SymExpr *lhs, BinaryOperator::Opcode op, const SymExpr *rhs, QualType t)