Coverage Report

Created: 2019-03-22 08:08

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h
Line
Count
Source (jump to first uncovered line)
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"
19
#include "clang/Analysis/AnalysisDeclContext.h"
20
#include "clang/Basic/LLVM.h"
21
#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
22
#include "clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h"
23
#include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.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:
45
  SymbolRegionValue(SymbolID sym, const TypedValueRegion *r)
46
8.54k
      : SymbolData(SymbolRegionValueKind, sym), R(r) {
47
8.54k
    assert(r);
48
8.54k
    assert(isValidTypeForSymbol(r->getValueType()));
49
8.54k
  }
50
51
1.07M
  const TypedValueRegion* getRegion() const { return R; }
52
53
157k
  static void Profile(llvm::FoldingSetNodeID& profile, const TypedValueRegion* R) {
54
157k
    profile.AddInteger((unsigned) SymbolRegionValueKind);
55
157k
    profile.AddPointer(R);
56
157k
  }
57
58
81.4k
  void Profile(llvm::FoldingSetNodeID& profile) override {
59
81.4k
    Profile(profile, R);
60
81.4k
  }
61
62
  void dumpToStream(raw_ostream &os) const override;
63
1.13k
  const MemRegion *getOriginRegion() const override { return getRegion(); }
64
65
  QualType getType() const override;
66
67
  // Implement isa<T> support.
68
22.8k
  static bool classof(const SymExpr *SE) {
69
22.8k
    return SE->getKind() == SymbolRegionValueKind;
70
22.8k
  }
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
44.2k
        LCtx(lctx), SymbolTag(symbolTag) {
87
44.2k
    // FIXME: 's' might be a nullptr if we're conducting invalidation
88
44.2k
    // that was caused by a destructor call on a temporary object,
89
44.2k
    // which has no statement associated with it.
90
44.2k
    // Due to this, we might be creating the same invalidation symbol for
91
44.2k
    // two different invalidation passes (for two different temporaries).
92
44.2k
    assert(lctx);
93
44.2k
    assert(isValidTypeForSymbol(t));
94
44.2k
  }
95
96
108
  const Stmt *getStmt() const { return S; }
97
0
  unsigned getCount() const { return Count; }
98
0
  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
185k
                      const void *SymbolTag) {
107
185k
    profile.AddInteger((unsigned) SymbolConjuredKind);
108
185k
    profile.AddPointer(S);
109
185k
    profile.AddPointer(LCtx);
110
185k
    profile.Add(T);
111
185k
    profile.AddInteger(Count);
112
185k
    profile.AddPointer(SymbolTag);
113
185k
  }
114
115
92.2k
  void Profile(llvm::FoldingSetNodeID& profile) override {
116
92.2k
    Profile(profile, S, T, Count, LCtx, SymbolTag);
117
92.2k
  }
118
119
  // Implement isa<T> support.
120
1.72k
  static bool classof(const SymExpr *SE) {
121
1.72k
    return SE->getKind() == SymbolConjuredKind;
122
1.72k
  }
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:
132
  SymbolDerived(SymbolID sym, SymbolRef parent, const TypedValueRegion *r)
133
1.31k
      : SymbolData(SymbolDerivedKind, sym), parentSymbol(parent), R(r) {
134
1.31k
    assert(parent);
135
1.31k
    assert(r);
136
1.31k
    assert(isValidTypeForSymbol(r->getValueType()));
137
1.31k
  }
138
139
110k
  SymbolRef getParentSymbol() const { return parentSymbol; }
140
216
  const TypedValueRegion *getRegion() const { return R; }
141
142
  QualType getType() const override;
143
144
  void dumpToStream(raw_ostream &os) const override;
145
109
  const MemRegion *getOriginRegion() const override { return getRegion(); }
146
147
  static void Profile(llvm::FoldingSetNodeID& profile, SymbolRef parent,
148
33.7k
                      const TypedValueRegion *r) {
149
33.7k
    profile.AddInteger((unsigned) SymbolDerivedKind);
150
33.7k
    profile.AddPointer(r);
151
33.7k
    profile.AddPointer(parent);
152
33.7k
  }
153
154
22.4k
  void Profile(llvm::FoldingSetNodeID& profile) override {
155
22.4k
    Profile(profile, parentSymbol, R);
156
22.4k
  }
157
158
  // Implement isa<T> support.
159
23.0k
  static bool classof(const SymExpr *SE) {
160
23.0k
    return SE->getKind() == SymbolDerivedKind;
161
23.0k
  }
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:
171
  SymbolExtent(SymbolID sym, const SubRegion *r)
172
1.57k
      : SymbolData(SymbolExtentKind, sym), R(r) {
173
1.57k
    assert(r);
174
1.57k
  }
175
176
16.6k
  const SubRegion *getRegion() const { return R; }
177
178
  QualType getType() const override;
179
180
  void dumpToStream(raw_ostream &os) const override;
181
182
2.98k
  static void Profile(llvm::FoldingSetNodeID& profile, const SubRegion *R) {
183
2.98k
    profile.AddInteger((unsigned) SymbolExtentKind);
184
2.98k
    profile.AddPointer(R);
185
2.98k
  }
186
187
871
  void Profile(llvm::FoldingSetNodeID& profile) override {
188
871
    Profile(profile, R);
189
871
  }
190
191
  // Implement isa<T> support.
192
0
  static bool classof(const SymExpr *SE) {
193
0
    return SE->getKind() == SymbolExtentKind;
194
0
  }
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
456
        Count(count), Tag(tag) {
214
456
      assert(r);
215
456
      assert(s);
216
456
      assert(isValidTypeForSymbol(t));
217
456
      assert(LCtx);
218
456
      assert(tag);
219
456
    }
220
221
1.84k
  const MemRegion *getRegion() const { return R; }
222
0
  const Stmt *getStmt() const { return S; }
223
0
  const LocationContext *getLocationContext() const { return LCtx; }
224
0
  unsigned getCount() const { return Count; }
225
0
  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
587
                      unsigned Count, const void *Tag) {
234
587
    profile.AddInteger((unsigned) SymbolMetadataKind);
235
587
    profile.AddPointer(R);
236
587
    profile.AddPointer(S);
237
587
    profile.Add(T);
238
587
    profile.AddPointer(LCtx);
239
587
    profile.AddInteger(Count);
240
587
    profile.AddPointer(Tag);
241
587
  }
242
243
107
  void Profile(llvm::FoldingSetNodeID& profile) override {
244
107
    Profile(profile, R, S, T, LCtx, Count, Tag);
245
107
  }
246
247
  // Implement isa<T> support.
248
5.96k
  static bool classof(const SymExpr *SE) {
249
5.96k
    return SE->getKind() == SymbolMetadataKind;
250
5.96k
  }
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
29
      : SymExpr(SymbolCastKind), Operand(In), FromTy(From), ToTy(To) {
266
29
    assert(In);
267
29
    assert(isValidTypeForSymbol(From));
268
29
    // FIXME: GenericTaintChecker creates symbols of void type.
269
29
    // Otherwise, 'To' should also be a valid type.
270
29
  }
271
272
0
  unsigned computeComplexity() const override {
273
0
    if (Complexity == 0)
274
0
      Complexity = 1 + Operand->computeComplexity();
275
0
    return Complexity;
276
0
  }
277
278
106
  QualType getType() const override { return ToTy; }
279
280
124
  const SymExpr *getOperand() const { return Operand; }
281
282
  void dumpToStream(raw_ostream &os) const override;
283
284
  static void Profile(llvm::FoldingSetNodeID& ID,
285
40
                      const SymExpr *In, QualType From, QualType To) {
286
40
    ID.AddInteger((unsigned) SymbolCastKind);
287
40
    ID.AddPointer(In);
288
40
    ID.Add(From);
289
40
    ID.Add(To);
290
40
  }
291
292
6
  void Profile(llvm::FoldingSetNodeID& ID) override {
293
6
    Profile(ID, Operand, FromTy, ToTy);
294
6
  }
295
296
  // Implement isa<T> support.
297
22.7k
  static bool classof(const SymExpr *SE) {
298
22.7k
    return SE->getKind() == SymbolCastKind;
299
22.7k
  }
300
};
301
302
/// Represents a symbolic expression involving a binary operator
303
class BinarySymExpr : public SymExpr {
304
  BinaryOperator::Opcode Op;
305
  QualType T;
306
307
protected:
308
  BinarySymExpr(Kind k, BinaryOperator::Opcode op, QualType t)
309
19.8k
      : SymExpr(k), Op(op), T(t) {
310
19.8k
    assert(classof(this));
311
19.8k
    // Binary expressions are results of arithmetic. Pointer arithmetic is not
312
19.8k
    // handled by binary expressions, but it is instead handled by applying
313
19.8k
    // sub-regions to regions.
314
19.8k
    assert(isValidTypeForSymbol(t) && !Loc::isLocType(t));
315
19.8k
  }
316
317
public:
318
  // FIXME: We probably need to make this out-of-line to avoid redundant
319
  // generation of virtual functions.
320
446k
  QualType getType() const override { return T; }
321
322
656k
  BinaryOperator::Opcode getOpcode() const { return Op; }
323
324
  // Implement isa<T> support.
325
142k
  static bool classof(const SymExpr *SE) {
326
142k
    Kind k = SE->getKind();
327
142k
    return k >= BEGIN_BINARYSYMEXPRS && k <= END_BINARYSYMEXPRS;
328
142k
  }
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:
337
  SymIntExpr(const SymExpr *lhs, BinaryOperator::Opcode op,
338
             const llvm::APSInt &rhs, QualType t)
339
18.1k
      : BinarySymExpr(SymIntExprKind, op, t), LHS(lhs), RHS(rhs) {
340
18.1k
    assert(lhs);
341
18.1k
  }
342
343
  void dumpToStream(raw_ostream &os) const override;
344
345
1.80M
  const SymExpr *getLHS() const { return LHS; }
346
199k
  const llvm::APSInt &getRHS() const { return RHS; }
347
348
4.06k
  unsigned computeComplexity() const override {
349
4.06k
    if (Complexity == 0)
350
378
      Complexity = 1 + LHS->computeComplexity();
351
4.06k
    return Complexity;
352
4.06k
  }
353
354
  static void Profile(llvm::FoldingSetNodeID& ID, const SymExpr *lhs,
355
                      BinaryOperator::Opcode op, const llvm::APSInt& rhs,
356
341k
                      QualType t) {
357
341k
    ID.AddInteger((unsigned) SymIntExprKind);
358
341k
    ID.AddPointer(lhs);
359
341k
    ID.AddInteger(op);
360
341k
    ID.AddPointer(&rhs);
361
341k
    ID.Add(t);
362
341k
  }
363
364
192k
  void Profile(llvm::FoldingSetNodeID& ID) override {
365
192k
    Profile(ID, LHS, getOpcode(), RHS, getType());
366
192k
  }
367
368
  // Implement isa<T> support.
369
617k
  static bool classof(const SymExpr *SE) {
370
617k
    return SE->getKind() == SymIntExprKind;
371
617k
  }
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:
380
  IntSymExpr(const llvm::APSInt &lhs, BinaryOperator::Opcode op,
381
             const SymExpr *rhs, QualType t)
382
124
      : BinarySymExpr(IntSymExprKind, op, t), LHS(lhs), RHS(rhs) {
383
124
    assert(rhs);
384
124
  }
385
386
  void dumpToStream(raw_ostream &os) const override;
387
388
3.60k
  const SymExpr *getRHS() const { return RHS; }
389
0
  const llvm::APSInt &getLHS() const { return LHS; }
390
391
28
  unsigned computeComplexity() const override {
392
28
    if (Complexity == 0)
393
20
      Complexity = 1 + RHS->computeComplexity();
394
28
    return Complexity;
395
28
  }
396
397
  static void Profile(llvm::FoldingSetNodeID& ID, const llvm::APSInt& lhs,
398
                      BinaryOperator::Opcode op, const SymExpr *rhs,
399
199
                      QualType t) {
400
199
    ID.AddInteger((unsigned) IntSymExprKind);
401
199
    ID.AddPointer(&lhs);
402
199
    ID.AddInteger(op);
403
199
    ID.AddPointer(rhs);
404
199
    ID.Add(t);
405
199
  }
406
407
58
  void Profile(llvm::FoldingSetNodeID& ID) override {
408
58
    Profile(ID, LHS, getOpcode(), RHS, getType());
409
58
  }
410
411
  // Implement isa<T> support.
412
0
  static bool classof(const SymExpr *SE) {
413
0
    return SE->getKind() == IntSymExprKind;
414
0
  }
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
1.50k
      : BinarySymExpr(SymSymExprKind, op, t), LHS(lhs), RHS(rhs) {
426
1.50k
    assert(lhs);
427
1.50k
    assert(rhs);
428
1.50k
  }
429
430
694k
  const SymExpr *getLHS() const { return LHS; }
431
662k
  const SymExpr *getRHS() const { return RHS; }
432
433
  void dumpToStream(raw_ostream &os) const override;
434
435
6.58k
  unsigned computeComplexity() const override {
436
6.58k
    if (Complexity == 0)
437
325
      Complexity = RHS->computeComplexity() + LHS->computeComplexity();
438
6.58k
    return Complexity;
439
6.58k
  }
440
441
  static void Profile(llvm::FoldingSetNodeID& ID, const SymExpr *lhs,
442
32.9k
                    BinaryOperator::Opcode op, const SymExpr *rhs, QualType t) {
443
32.9k
    ID.AddInteger((unsigned) SymSymExprKind);
444
32.9k
    ID.AddPointer(lhs);
445
32.9k
    ID.AddInteger(op);
446
32.9k
    ID.AddPointer(rhs);
447
32.9k
    ID.Add(t);
448
32.9k
  }
449
450
21.7k
  void Profile(llvm::FoldingSetNodeID& ID) override {
451
21.7k
    Profile(ID, LHS, getOpcode(), RHS, getType());
452
21.7k
  }
453
454
  // Implement isa<T> support.
455
89.8k
  static bool classof(const SymExpr *SE) {
456
89.8k
    return SE->getKind() == SymSymExprKind;
457
89.8k
  }
458
};
459
460
class SymbolManager {
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:
476
  SymbolManager(ASTContext &ctx, BasicValueFactory &bv,
477
                llvm::BumpPtrAllocator& bpalloc)
478
10.5k
      : 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
492
  const SymbolConjured* conjureSymbol(const Expr *E,
493
                                      const LocationContext *LCtx,
494
                                      unsigned VisitCount,
495
0
                                      const void *SymbolTag = nullptr) {
496
0
    return conjureSymbol(E, LCtx, E->getType(), VisitCount, SymbolTag);
497
0
  }
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
520
  const SymIntExpr *getSymIntExpr(const SymExpr &lhs, BinaryOperator::Opcode op,
521
0
                                  const llvm::APSInt& rhs, QualType t) {
522
0
    return getSymIntExpr(&lhs, op, rhs, t);
523
0
  }
524
525
  const IntSymExpr *getIntSymExpr(const llvm::APSInt& lhs,
526
                                  BinaryOperator::Opcode op,
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
470
  QualType getType(const SymExpr *SE) const {
533
470
    return SE->getType();
534
470
  }
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
593
  ASTContext &getContext() { return Ctx; }
544
298
  BasicValueFactory &getBasicVals() { return BV; }
545
};
546
547
/// A class responsible for cleaning up unused symbols.
548
class SymbolReaper {
549
  enum SymbolStatus {
550
    NotProcessed,
551
    HaveMarkedDependents
552
  };
553
554
  using SymbolSetTy = llvm::DenseSet<SymbolRef>;
555
  using SymbolMapTy = llvm::DenseMap<SymbolRef, SymbolStatus>;
556
  using RegionSetTy = llvm::DenseSet<const MemRegion *>;
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
300k
      : 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
300k
  region_iterator region_begin() const { return RegionRoots.begin(); }
607
300k
  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
3.78M
  bool isDead(SymbolRef sym) {
614
3.78M
    return !isLive(sym);
615
3.78M
  }
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
300k
  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
629
class SymbolVisitor {
630
protected:
631
  ~SymbolVisitor() = default;
632
633
public:
634
304k
  SymbolVisitor() = default;
635
  SymbolVisitor(const SymbolVisitor &) = default;
636
  SymbolVisitor(SymbolVisitor &&) {}
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
917
  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