Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
Line
Count
Source (jump to first uncovered line)
1
//==- MemRegion.h - Abstract memory regions for static analysis -*- 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 MemRegion and its subclasses.  MemRegion defines a
10
//  partially-typed abstraction of memory useful for path-sensitive dataflow
11
//  analyses.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_MEMREGION_H
16
#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_MEMREGION_H
17
18
#include "clang/AST/ASTContext.h"
19
#include "clang/AST/CharUnits.h"
20
#include "clang/AST/Decl.h"
21
#include "clang/AST/DeclObjC.h"
22
#include "clang/AST/DeclarationName.h"
23
#include "clang/AST/Expr.h"
24
#include "clang/AST/ExprObjC.h"
25
#include "clang/AST/Type.h"
26
#include "clang/Analysis/AnalysisDeclContext.h"
27
#include "clang/Basic/LLVM.h"
28
#include "clang/Basic/SourceLocation.h"
29
#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
30
#include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
31
#include "llvm/ADT/DenseMap.h"
32
#include "llvm/ADT/FoldingSet.h"
33
#include "llvm/ADT/Optional.h"
34
#include "llvm/ADT/PointerIntPair.h"
35
#include "llvm/Support/Allocator.h"
36
#include "llvm/Support/Casting.h"
37
#include <cassert>
38
#include <cstdint>
39
#include <limits>
40
#include <string>
41
#include <utility>
42
43
namespace clang {
44
45
class AnalysisDeclContext;
46
class CXXRecordDecl;
47
class Decl;
48
class LocationContext;
49
class StackFrameContext;
50
51
namespace ento {
52
53
class CodeTextRegion;
54
class MemRegion;
55
class MemRegionManager;
56
class MemSpaceRegion;
57
class SValBuilder;
58
class SymbolicRegion;
59
class VarRegion;
60
61
/// Represent a region's offset within the top level base region.
62
class RegionOffset {
63
  /// The base region.
64
  const MemRegion *R = nullptr;
65
66
  /// The bit offset within the base region. Can be negative.
67
  int64_t Offset;
68
69
public:
70
  // We're using a const instead of an enumeration due to the size required;
71
  // Visual Studio will only create enumerations of size int, not long long.
72
  static const int64_t Symbolic = std::numeric_limits<int64_t>::max();
73
74
  RegionOffset() = default;
75
121k
  RegionOffset(const MemRegion *r, int64_t off) : R(r), Offset(off) {}
76
77
  /// It might return null.
78
1.88M
  const MemRegion *getRegion() const { return R; }
79
80
3.65M
  bool hasSymbolicOffset() const { return Offset == Symbolic; }
81
82
1.77M
  int64_t getOffset() const {
83
1.77M
    assert(!hasSymbolicOffset());
84
0
    return Offset;
85
1.77M
  }
86
87
772
  bool isValid() const { return R; }
88
};
89
90
//===----------------------------------------------------------------------===//
91
// Base region classes.
92
//===----------------------------------------------------------------------===//
93
94
/// MemRegion - The root abstract class for all memory regions.
95
class MemRegion : public llvm::FoldingSetNode {
96
public:
97
  enum Kind {
98
#define REGION(Id, Parent) Id ## Kind,
99
#define REGION_RANGE(Id, First, Last) BEGIN_##Id = First, END_##Id = Last,
100
#include "clang/StaticAnalyzer/Core/PathSensitive/Regions.def"
101
  };
102
103
private:
104
  const Kind kind;
105
  mutable Optional<RegionOffset> cachedOffset;
106
107
protected:
108
241k
  MemRegion(Kind k) : kind(k) {}
109
  virtual ~MemRegion();
110
111
public:
112
  ASTContext &getContext() const;
113
114
  virtual void Profile(llvm::FoldingSetNodeID& ID) const = 0;
115
116
  virtual MemRegionManager &getMemRegionManager() const = 0;
117
118
  LLVM_ATTRIBUTE_RETURNS_NONNULL const MemSpaceRegion *getMemorySpace() const;
119
120
  LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion *getBaseRegion() const;
121
122
  /// Recursively retrieve the region of the most derived class instance of
123
  /// regions of C++ base class instances.
124
  LLVM_ATTRIBUTE_RETURNS_NONNULL
125
  const MemRegion *getMostDerivedObjectRegion() const;
126
127
  /// Check if the region is a subregion of the given region.
128
  /// Each region is a subregion of itself.
129
  virtual bool isSubRegionOf(const MemRegion *R) const;
130
131
  LLVM_ATTRIBUTE_RETURNS_NONNULL
132
  const MemRegion *StripCasts(bool StripBaseAndDerivedCasts = true) const;
133
134
  /// If this is a symbolic region, returns the region. Otherwise,
135
  /// goes up the base chain looking for the first symbolic base region.
136
  /// It might return null.
137
  const SymbolicRegion *getSymbolicBase() const;
138
139
  bool hasGlobalsOrParametersStorage() const;
140
141
  bool hasStackStorage() const;
142
143
  bool hasStackNonParametersStorage() const;
144
145
  bool hasStackParametersStorage() const;
146
147
  /// Compute the offset within the top level memory object.
148
  RegionOffset getAsOffset() const;
149
150
  /// Get a string representation of a region for debug use.
151
  std::string getString() const;
152
153
  virtual void dumpToStream(raw_ostream &os) const;
154
155
  void dump() const;
156
157
  /// Returns true if this region can be printed in a user-friendly way.
158
  virtual bool canPrintPretty() const;
159
160
  /// Print the region for use in diagnostics.
161
  virtual void printPretty(raw_ostream &os) const;
162
163
  /// Returns true if this region's textual representation can be used
164
  /// as part of a larger expression.
165
  virtual bool canPrintPrettyAsExpr() const;
166
167
  /// Print the region as expression.
168
  ///
169
  /// When this region represents a subexpression, the method is for printing
170
  /// an expression containing it.
171
  virtual void printPrettyAsExpr(raw_ostream &os) const;
172
173
69.6M
  Kind getKind() const { return kind; }
174
175
  template<typename RegionTy> const RegionTy* getAs() const;
176
  template <typename RegionTy>
177
  LLVM_ATTRIBUTE_RETURNS_NONNULL const RegionTy *castAs() const;
178
179
0
  virtual bool isBoundable() const { return false; }
180
181
  /// Get descriptive name for memory region. The name is obtained from
182
  /// the variable/field declaration retrieved from the memory region.
183
  /// Regions that point to an element of an array are returned as: "arr[0]".
184
  /// Regions that point to a struct are returned as: "st.var".
185
  //
186
  /// \param UseQuotes Set if the name should be quoted.
187
  ///
188
  /// \returns variable name for memory region
189
  std::string getDescriptiveName(bool UseQuotes = true) const;
190
191
  /// Retrieve source range from memory region. The range retrieval
192
  /// is based on the decl obtained from the memory region.
193
  /// For a VarRegion the range of the base region is returned.
194
  /// For a FieldRegion the range of the field is returned.
195
  /// If no declaration is found, an empty source range is returned.
196
  /// The client is responsible for checking if the returned range is valid.
197
  ///
198
  /// \returns source range for declaration retrieved from memory region
199
  SourceRange sourceRange() const;
200
};
201
202
/// MemSpaceRegion - A memory region that represents a "memory space";
203
///  for example, the set of global variables, the stack frame, etc.
204
class MemSpaceRegion : public MemRegion {
205
protected:
206
  MemRegionManager &Mgr;
207
208
81.6k
  MemSpaceRegion(MemRegionManager &mgr, Kind k) : MemRegion(k), Mgr(mgr) {
209
81.6k
    assert(classof(this));
210
81.6k
  }
211
212
2.05M
  MemRegionManager &getMemRegionManager() const override { return Mgr; }
213
214
public:
215
51.2k
  bool isBoundable() const override { return false; }
216
217
  void Profile(llvm::FoldingSetNodeID &ID) const override;
218
219
5.99M
  static bool classof(const MemRegion *R) {
220
5.99M
    Kind k = R->getKind();
221
5.99M
    return k >= BEGIN_MEMSPACES && k <= END_MEMSPACES;
222
5.99M
  }
223
};
224
225
/// CodeSpaceRegion - The memory space that holds the executable code of
226
/// functions and blocks.
227
class CodeSpaceRegion : public MemSpaceRegion {
228
  friend class MemRegionManager;
229
230
  CodeSpaceRegion(MemRegionManager &mgr)
231
10.6k
      : MemSpaceRegion(mgr, CodeSpaceRegionKind) {}
232
233
public:
234
  void dumpToStream(raw_ostream &os) const override;
235
236
0
  static bool classof(const MemRegion *R) {
237
0
    return R->getKind() == CodeSpaceRegionKind;
238
0
  }
239
};
240
241
class GlobalsSpaceRegion : public MemSpaceRegion {
242
  virtual void anchor();
243
244
protected:
245
16.5k
  GlobalsSpaceRegion(MemRegionManager &mgr, Kind k) : MemSpaceRegion(mgr, k) {
246
16.5k
    assert(classof(this));
247
16.5k
  }
248
249
public:
250
280k
  static bool classof(const MemRegion *R) {
251
280k
    Kind k = R->getKind();
252
280k
    return k >= BEGIN_GLOBAL_MEMSPACES && k <= END_GLOBAL_MEMSPACES;
253
280k
  }
254
};
255
256
/// The region of the static variables within the current CodeTextRegion
257
/// scope.
258
///
259
/// Currently, only the static locals are placed there, so we know that these
260
/// variables do not get invalidated by calls to other functions.
261
class StaticGlobalSpaceRegion : public GlobalsSpaceRegion {
262
  friend class MemRegionManager;
263
264
  const CodeTextRegion *CR;
265
266
  StaticGlobalSpaceRegion(MemRegionManager &mgr, const CodeTextRegion *cr)
267
174
      : GlobalsSpaceRegion(mgr, StaticGlobalSpaceRegionKind), CR(cr) {
268
174
    assert(cr);
269
174
  }
270
271
public:
272
  void Profile(llvm::FoldingSetNodeID &ID) const override;
273
274
  void dumpToStream(raw_ostream &os) const override;
275
276
  LLVM_ATTRIBUTE_RETURNS_NONNULL
277
0
  const CodeTextRegion *getCodeRegion() const { return CR; }
278
279
7.90k
  static bool classof(const MemRegion *R) {
280
7.90k
    return R->getKind() == StaticGlobalSpaceRegionKind;
281
7.90k
  }
282
};
283
284
/// The region for all the non-static global variables.
285
///
286
/// This class is further split into subclasses for efficient implementation of
287
/// invalidating a set of related global values as is done in
288
/// RegionStoreManager::invalidateRegions (instead of finding all the dependent
289
/// globals, we invalidate the whole parent region).
290
class NonStaticGlobalSpaceRegion : public GlobalsSpaceRegion {
291
  void anchor() override;
292
293
protected:
294
  NonStaticGlobalSpaceRegion(MemRegionManager &mgr, Kind k)
295
16.3k
      : GlobalsSpaceRegion(mgr, k) {
296
16.3k
    assert(classof(this));
297
16.3k
  }
298
299
public:
300
777k
  static bool classof(const MemRegion *R) {
301
777k
    Kind k = R->getKind();
302
777k
    return k >= BEGIN_NON_STATIC_GLOBAL_MEMSPACES &&
303
777k
           k <= END_NON_STATIC_GLOBAL_MEMSPACES;
304
777k
  }
305
};
306
307
/// The region containing globals which are defined in system/external
308
/// headers and are considered modifiable by system calls (ex: errno).
309
class GlobalSystemSpaceRegion : public NonStaticGlobalSpaceRegion {
310
  friend class MemRegionManager;
311
312
  GlobalSystemSpaceRegion(MemRegionManager &mgr)
313
7.95k
      : NonStaticGlobalSpaceRegion(mgr, GlobalSystemSpaceRegionKind) {}
314
315
public:
316
  void dumpToStream(raw_ostream &os) const override;
317
318
22.9k
  static bool classof(const MemRegion *R) {
319
22.9k
    return R->getKind() == GlobalSystemSpaceRegionKind;
320
22.9k
  }
321
};
322
323
/// The region containing globals which are considered not to be modified
324
/// or point to data which could be modified as a result of a function call
325
/// (system or internal). Ex: Const global scalars would be modeled as part of
326
/// this region. This region also includes most system globals since they have
327
/// low chance of being modified.
328
class GlobalImmutableSpaceRegion : public NonStaticGlobalSpaceRegion {
329
  friend class MemRegionManager;
330
331
  GlobalImmutableSpaceRegion(MemRegionManager &mgr)
332
453
      : NonStaticGlobalSpaceRegion(mgr, GlobalImmutableSpaceRegionKind) {}
333
334
public:
335
  void dumpToStream(raw_ostream &os) const override;
336
337
373
  static bool classof(const MemRegion *R) {
338
373
    return R->getKind() == GlobalImmutableSpaceRegionKind;
339
373
  }
340
};
341
342
/// The region containing globals which can be modified by calls to
343
/// "internally" defined functions - (for now just) functions other then system
344
/// calls.
345
class GlobalInternalSpaceRegion : public NonStaticGlobalSpaceRegion {
346
  friend class MemRegionManager;
347
348
  GlobalInternalSpaceRegion(MemRegionManager &mgr)
349
7.94k
      : NonStaticGlobalSpaceRegion(mgr, GlobalInternalSpaceRegionKind) {}
350
351
public:
352
  void dumpToStream(raw_ostream &os) const override;
353
354
12.0k
  static bool classof(const MemRegion *R) {
355
12.0k
    return R->getKind() == GlobalInternalSpaceRegionKind;
356
12.0k
  }
357
};
358
359
class HeapSpaceRegion : public MemSpaceRegion {
360
  friend class MemRegionManager;
361
362
  HeapSpaceRegion(MemRegionManager &mgr)
363
1.29k
      : MemSpaceRegion(mgr, HeapSpaceRegionKind) {}
364
365
public:
366
  void dumpToStream(raw_ostream &os) const override;
367
368
4.06k
  static bool classof(const MemRegion *R) {
369
4.06k
    return R->getKind() == HeapSpaceRegionKind;
370
4.06k
  }
371
};
372
373
class UnknownSpaceRegion : public MemSpaceRegion {
374
  friend class MemRegionManager;
375
376
  UnknownSpaceRegion(MemRegionManager &mgr)
377
9.55k
      : MemSpaceRegion(mgr, UnknownSpaceRegionKind) {}
378
379
public:
380
  void dumpToStream(raw_ostream &os) const override;
381
382
109k
  static bool classof(const MemRegion *R) {
383
109k
    return R->getKind() == UnknownSpaceRegionKind;
384
109k
  }
385
};
386
387
class StackSpaceRegion : public MemSpaceRegion {
388
  virtual void anchor();
389
390
  const StackFrameContext *SFC;
391
392
protected:
393
  StackSpaceRegion(MemRegionManager &mgr, Kind k, const StackFrameContext *sfc)
394
43.5k
      : MemSpaceRegion(mgr, k), SFC(sfc) {
395
43.5k
    assert(classof(this));
396
0
    assert(sfc);
397
43.5k
  }
398
399
public:
400
  LLVM_ATTRIBUTE_RETURNS_NONNULL
401
2.22M
  const StackFrameContext *getStackFrame() const { return SFC; }
402
403
  void Profile(llvm::FoldingSetNodeID &ID) const override;
404
405
2.46M
  static bool classof(const MemRegion *R) {
406
2.46M
    Kind k = R->getKind();
407
2.46M
    return k >= BEGIN_STACK_MEMSPACES && 
k <= END_STACK_MEMSPACES2.37M
;
408
2.46M
  }
409
};
410
411
class StackLocalsSpaceRegion : public StackSpaceRegion {
412
  friend class MemRegionManager;
413
414
  StackLocalsSpaceRegion(MemRegionManager &mgr, const StackFrameContext *sfc)
415
12.9k
      : StackSpaceRegion(mgr, StackLocalsSpaceRegionKind, sfc) {}
416
417
public:
418
  void dumpToStream(raw_ostream &os) const override;
419
420
76.3k
  static bool classof(const MemRegion *R) {
421
76.3k
    return R->getKind() == StackLocalsSpaceRegionKind;
422
76.3k
  }
423
};
424
425
class StackArgumentsSpaceRegion : public StackSpaceRegion {
426
private:
427
  friend class MemRegionManager;
428
429
  StackArgumentsSpaceRegion(MemRegionManager &mgr, const StackFrameContext *sfc)
430
30.5k
      : StackSpaceRegion(mgr, StackArgumentsSpaceRegionKind, sfc) {}
431
432
public:
433
  void dumpToStream(raw_ostream &os) const override;
434
435
404k
  static bool classof(const MemRegion *R) {
436
404k
    return R->getKind() == StackArgumentsSpaceRegionKind;
437
404k
  }
438
};
439
440
/// SubRegion - A region that subsets another larger region.  Most regions
441
///  are subclasses of SubRegion.
442
class SubRegion : public MemRegion {
443
  virtual void anchor();
444
445
protected:
446
  const MemRegion* superRegion;
447
448
159k
  SubRegion(const MemRegion *sReg, Kind k) : MemRegion(k), superRegion(sReg) {
449
159k
    assert(classof(this));
450
0
    assert(sReg);
451
159k
  }
452
453
public:
454
  LLVM_ATTRIBUTE_RETURNS_NONNULL
455
14.2M
  const MemRegion* getSuperRegion() const {
456
14.2M
    return superRegion;
457
14.2M
  }
458
459
  MemRegionManager &getMemRegionManager() const override;
460
461
  bool isSubRegionOf(const MemRegion* R) const override;
462
463
22.1M
  static bool classof(const MemRegion* R) {
464
22.1M
    return R->getKind() > END_MEMSPACES;
465
22.1M
  }
466
};
467
468
//===----------------------------------------------------------------------===//
469
// MemRegion subclasses.
470
//===----------------------------------------------------------------------===//
471
472
/// AllocaRegion - A region that represents an untyped blob of bytes created
473
///  by a call to 'alloca'.
474
class AllocaRegion : public SubRegion {
475
  friend class MemRegionManager;
476
477
  // Block counter. Used to distinguish different pieces of memory allocated by
478
  // alloca at the same call site.
479
  unsigned Cnt;
480
481
  const Expr *Ex;
482
483
  AllocaRegion(const Expr *ex, unsigned cnt, const MemSpaceRegion *superRegion)
484
91
      : SubRegion(superRegion, AllocaRegionKind), Cnt(cnt), Ex(ex) {
485
91
    assert(Ex);
486
91
  }
487
488
  static void ProfileRegion(llvm::FoldingSetNodeID& ID, const Expr *Ex,
489
                            unsigned Cnt, const MemRegion *superRegion);
490
491
public:
492
  LLVM_ATTRIBUTE_RETURNS_NONNULL
493
10
  const Expr *getExpr() const { return Ex; }
494
495
21
  bool isBoundable() const override { return true; }
496
497
  void Profile(llvm::FoldingSetNodeID& ID) const override;
498
499
  void dumpToStream(raw_ostream &os) const override;
500
501
88.8k
  static bool classof(const MemRegion* R) {
502
88.8k
    return R->getKind() == AllocaRegionKind;
503
88.8k
  }
504
};
505
506
/// TypedRegion - An abstract class representing regions that are typed.
507
class TypedRegion : public SubRegion {
508
  void anchor() override;
509
510
protected:
511
139k
  TypedRegion(const MemRegion *sReg, Kind k) : SubRegion(sReg, k) {
512
139k
    assert(classof(this));
513
139k
  }
514
515
public:
516
  virtual QualType getLocationType() const = 0;
517
518
0
  QualType getDesugaredLocationType(ASTContext &Context) const {
519
0
    return getLocationType().getDesugaredType(Context);
520
0
  }
521
522
80.9k
  bool isBoundable() const override { return true; }
523
524
916k
  static bool classof(const MemRegion* R) {
525
916k
    unsigned k = R->getKind();
526
916k
    return k >= BEGIN_TYPED_REGIONS && 
k <= END_TYPED_REGIONS872k
;
527
916k
  }
528
};
529
530
/// TypedValueRegion - An abstract class representing regions having a typed value.
531
class TypedValueRegion : public TypedRegion {
532
  void anchor() override;
533
534
protected:
535
110k
  TypedValueRegion(const MemRegion* sReg, Kind k) : TypedRegion(sReg, k) {
536
110k
    assert(classof(this));
537
110k
  }
538
539
public:
540
  virtual QualType getValueType() const = 0;
541
542
613k
  QualType getLocationType() const override {
543
    // FIXME: We can possibly optimize this later to cache this value.
544
613k
    QualType T = getValueType();
545
613k
    ASTContext &ctx = getContext();
546
613k
    if (T->getAs<ObjCObjectType>())
547
0
      return ctx.getObjCObjectPointerType(T);
548
613k
    return ctx.getPointerType(getValueType());
549
613k
  }
550
551
90.1k
  QualType getDesugaredValueType(ASTContext &Context) const {
552
90.1k
    QualType T = getValueType();
553
90.1k
    return T.getTypePtrOrNull() ? T.getDesugaredType(Context) : 
T0
;
554
90.1k
  }
555
556
2.74M
  static bool classof(const MemRegion* R) {
557
2.74M
    unsigned k = R->getKind();
558
2.74M
    return k >= BEGIN_TYPED_VALUE_REGIONS && 
k <= END_TYPED_VALUE_REGIONS2.64M
;
559
2.74M
  }
560
};
561
562
class CodeTextRegion : public TypedRegion {
563
  void anchor() override;
564
565
protected:
566
29.2k
  CodeTextRegion(const MemSpaceRegion *sreg, Kind k) : TypedRegion(sreg, k) {
567
29.2k
    assert(classof(this));
568
29.2k
  }
569
570
public:
571
45
  bool isBoundable() const override { return false; }
572
573
54.0k
  static bool classof(const MemRegion* R) {
574
54.0k
    Kind k = R->getKind();
575
54.0k
    return k >= BEGIN_CODE_TEXT_REGIONS && 
k <= END_CODE_TEXT_REGIONS37.8k
;
576
54.0k
  }
577
};
578
579
/// FunctionCodeRegion - A region that represents code texts of function.
580
class FunctionCodeRegion : public CodeTextRegion {
581
  friend class MemRegionManager;
582
583
  const NamedDecl *FD;
584
585
  FunctionCodeRegion(const NamedDecl *fd, const CodeSpaceRegion* sreg)
586
28.8k
      : CodeTextRegion(sreg, FunctionCodeRegionKind), FD(fd) {
587
28.8k
    assert(isa<ObjCMethodDecl>(fd) || isa<FunctionDecl>(fd));
588
28.8k
  }
589
590
  static void ProfileRegion(llvm::FoldingSetNodeID& ID, const NamedDecl *FD,
591
                            const MemRegion*);
592
593
public:
594
139k
  QualType getLocationType() const override {
595
139k
    const ASTContext &Ctx = getContext();
596
139k
    if (const auto *D = dyn_cast<FunctionDecl>(FD)) {
597
139k
      return Ctx.getPointerType(D->getType());
598
139k
    }
599
600
0
    assert(isa<ObjCMethodDecl>(FD));
601
0
    assert(false && "Getting the type of ObjCMethod is not supported yet");
602
603
    // TODO: We might want to return a different type here (ex: id (*ty)(...))
604
    //       depending on how it is used.
605
0
    return {};
606
139k
  }
607
608
163k
  const NamedDecl *getDecl() const {
609
163k
    return FD;
610
163k
  }
611
612
  void dumpToStream(raw_ostream &os) const override;
613
614
  void Profile(llvm::FoldingSetNodeID& ID) const override;
615
616
894k
  static bool classof(const MemRegion* R) {
617
894k
    return R->getKind() == FunctionCodeRegionKind;
618
894k
  }
619
};
620
621
/// BlockCodeRegion - A region that represents code texts of blocks (closures).
622
///  Blocks are represented with two kinds of regions.  BlockCodeRegions
623
///  represent the "code", while BlockDataRegions represent instances of blocks,
624
///  which correspond to "code+data".  The distinction is important, because
625
///  like a closure a block captures the values of externally referenced
626
///  variables.
627
class BlockCodeRegion : public CodeTextRegion {
628
  friend class MemRegionManager;
629
630
  const BlockDecl *BD;
631
  AnalysisDeclContext *AC;
632
  CanQualType locTy;
633
634
  BlockCodeRegion(const BlockDecl *bd, CanQualType lTy,
635
                  AnalysisDeclContext *ac, const CodeSpaceRegion* sreg)
636
366
      : CodeTextRegion(sreg, BlockCodeRegionKind), BD(bd), AC(ac), locTy(lTy) {
637
366
    assert(bd);
638
0
    assert(ac);
639
0
    assert(lTy->getTypePtr()->isBlockPointerType());
640
366
  }
641
642
  static void ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockDecl *BD,
643
                            CanQualType, const AnalysisDeclContext*,
644
                            const MemRegion*);
645
646
public:
647
418
  QualType getLocationType() const override {
648
418
    return locTy;
649
418
  }
650
651
  LLVM_ATTRIBUTE_RETURNS_NONNULL
652
4.04k
  const BlockDecl *getDecl() const {
653
4.04k
    return BD;
654
4.04k
  }
655
656
  LLVM_ATTRIBUTE_RETURNS_NONNULL
657
373
  AnalysisDeclContext *getAnalysisDeclContext() const { return AC; }
658
659
  void dumpToStream(raw_ostream &os) const override;
660
661
  void Profile(llvm::FoldingSetNodeID& ID) const override;
662
663
68
  static bool classof(const MemRegion* R) {
664
68
    return R->getKind() == BlockCodeRegionKind;
665
68
  }
666
};
667
668
/// BlockDataRegion - A region that represents a block instance.
669
///  Blocks are represented with two kinds of regions.  BlockCodeRegions
670
///  represent the "code", while BlockDataRegions represent instances of blocks,
671
///  which correspond to "code+data".  The distinction is important, because
672
///  like a closure a block captures the values of externally referenced
673
///  variables.
674
class BlockDataRegion : public TypedRegion {
675
  friend class MemRegionManager;
676
677
  const BlockCodeRegion *BC;
678
  const LocationContext *LC; // Can be null
679
  unsigned BlockCount;
680
  void *ReferencedVars = nullptr;
681
  void *OriginalVars = nullptr;
682
683
  BlockDataRegion(const BlockCodeRegion *bc, const LocationContext *lc,
684
                  unsigned count, const MemSpaceRegion *sreg)
685
      : TypedRegion(sreg, BlockDataRegionKind), BC(bc), LC(lc),
686
373
        BlockCount(count) {
687
373
    assert(bc);
688
0
    assert(bc->getDecl());
689
0
    assert(lc);
690
0
    assert(isa<GlobalImmutableSpaceRegion>(sreg) ||
691
373
           isa<StackLocalsSpaceRegion>(sreg) ||
692
373
           isa<UnknownSpaceRegion>(sreg));
693
373
  }
694
695
  static void ProfileRegion(llvm::FoldingSetNodeID&, const BlockCodeRegion *,
696
                            const LocationContext *, unsigned,
697
                            const MemRegion *);
698
699
public:
700
  LLVM_ATTRIBUTE_RETURNS_NONNULL
701
375
  const BlockCodeRegion *getCodeRegion() const { return BC; }
702
703
  LLVM_ATTRIBUTE_RETURNS_NONNULL
704
2.90k
  const BlockDecl *getDecl() const { return BC->getDecl(); }
705
706
418
  QualType getLocationType() const override { return BC->getLocationType(); }
707
708
  class referenced_vars_iterator {
709
    const MemRegion * const *R;
710
    const MemRegion * const *OriginalR;
711
712
  public:
713
    explicit referenced_vars_iterator(const MemRegion * const *r,
714
                                      const MemRegion * const *originalR)
715
6.05k
        : R(r), OriginalR(originalR) {}
716
717
    LLVM_ATTRIBUTE_RETURNS_NONNULL
718
2.96k
    const VarRegion *getCapturedRegion() const {
719
2.96k
      return cast<VarRegion>(*R);
720
2.96k
    }
721
722
    LLVM_ATTRIBUTE_RETURNS_NONNULL
723
725
    const VarRegion *getOriginalRegion() const {
724
725
      return cast<VarRegion>(*OriginalR);
725
725
    }
726
727
30
    bool operator==(const referenced_vars_iterator &I) const {
728
30
      assert((R == nullptr) == (I.R == nullptr));
729
0
      return I.R == R;
730
30
    }
731
732
5.85k
    bool operator!=(const referenced_vars_iterator &I) const {
733
5.85k
      assert((R == nullptr) == (I.R == nullptr));
734
0
      return I.R != R;
735
5.85k
    }
736
737
2.82k
    referenced_vars_iterator &operator++() {
738
2.82k
      ++R;
739
2.82k
      ++OriginalR;
740
2.82k
      return *this;
741
2.82k
    }
742
  };
743
744
  /// Return the original region for a captured region, if
745
  /// one exists. It might return null.
746
  const VarRegion *getOriginalRegion(const VarRegion *VR) const;
747
748
  referenced_vars_iterator referenced_vars_begin() const;
749
  referenced_vars_iterator referenced_vars_end() const;
750
751
  void dumpToStream(raw_ostream &os) const override;
752
753
  void Profile(llvm::FoldingSetNodeID& ID) const override;
754
755
2.11M
  static bool classof(const MemRegion* R) {
756
2.11M
    return R->getKind() == BlockDataRegionKind;
757
2.11M
  }
758
759
private:
760
  void LazyInitializeReferencedVars();
761
  std::pair<const VarRegion *, const VarRegion *>
762
  getCaptureRegions(const VarDecl *VD);
763
};
764
765
/// SymbolicRegion - A special, "non-concrete" region. Unlike other region
766
///  classes, SymbolicRegion represents a region that serves as an alias for
767
///  either a real region, a NULL pointer, etc.  It essentially is used to
768
///  map the concept of symbolic values into the domain of regions.  Symbolic
769
///  regions do not need to be typed.
770
class SymbolicRegion : public SubRegion {
771
  friend class MemRegionManager;
772
773
  const SymbolRef sym;
774
775
  SymbolicRegion(const SymbolRef s, const MemSpaceRegion *sreg)
776
19.7k
      : SubRegion(sreg, SymbolicRegionKind), sym(s) {
777
    // Because pointer arithmetic is represented by ElementRegion layers,
778
    // the base symbol here should not contain any arithmetic.
779
19.7k
    assert(s && isa<SymbolData>(s));
780
0
    assert(s->getType()->isAnyPointerType() ||
781
19.7k
           s->getType()->isReferenceType() ||
782
19.7k
           s->getType()->isBlockPointerType());
783
0
    assert(isa<UnknownSpaceRegion>(sreg) || isa<HeapSpaceRegion>(sreg) ||
784
19.7k
           isa<GlobalSystemSpaceRegion>(sreg));
785
19.7k
  }
786
787
public:
788
  /// It might return null.
789
1.81M
  SymbolRef getSymbol() const { return sym; }
790
791
5.75k
  bool isBoundable() const override { return true; }
792
793
  void Profile(llvm::FoldingSetNodeID& ID) const override;
794
795
  static void ProfileRegion(llvm::FoldingSetNodeID& ID,
796
                            SymbolRef sym,
797
                            const MemRegion* superRegion);
798
799
  void dumpToStream(raw_ostream &os) const override;
800
801
7.83M
  static bool classof(const MemRegion* R) {
802
7.83M
    return R->getKind() == SymbolicRegionKind;
803
7.83M
  }
804
};
805
806
/// StringRegion - Region associated with a StringLiteral.
807
class StringRegion : public TypedValueRegion {
808
  friend class MemRegionManager;
809
810
  const StringLiteral *Str;
811
812
  StringRegion(const StringLiteral *str, const GlobalInternalSpaceRegion *sreg)
813
4.77k
      : TypedValueRegion(sreg, StringRegionKind), Str(str) {
814
4.77k
    assert(str);
815
4.77k
  }
816
817
  static void ProfileRegion(llvm::FoldingSetNodeID &ID,
818
                            const StringLiteral *Str,
819
                            const MemRegion *superRegion);
820
821
public:
822
  LLVM_ATTRIBUTE_RETURNS_NONNULL
823
2.15k
  const StringLiteral *getStringLiteral() const { return Str; }
824
825
4.81k
  QualType getValueType() const override { return Str->getType(); }
826
827
72
  bool isBoundable() const override { return false; }
828
829
7.31k
  void Profile(llvm::FoldingSetNodeID& ID) const override {
830
7.31k
    ProfileRegion(ID, Str, superRegion);
831
7.31k
  }
832
833
  void dumpToStream(raw_ostream &os) const override;
834
835
38.9k
  static bool classof(const MemRegion* R) {
836
38.9k
    return R->getKind() == StringRegionKind;
837
38.9k
  }
838
};
839
840
/// The region associated with an ObjCStringLiteral.
841
class ObjCStringRegion : public TypedValueRegion {
842
  friend class MemRegionManager;
843
844
  const ObjCStringLiteral *Str;
845
846
  ObjCStringRegion(const ObjCStringLiteral *str,
847
                   const GlobalInternalSpaceRegion *sreg)
848
285
      : TypedValueRegion(sreg, ObjCStringRegionKind), Str(str) {
849
285
    assert(str);
850
285
  }
851
852
  static void ProfileRegion(llvm::FoldingSetNodeID &ID,
853
                            const ObjCStringLiteral *Str,
854
                            const MemRegion *superRegion);
855
856
public:
857
  LLVM_ATTRIBUTE_RETURNS_NONNULL
858
17
  const ObjCStringLiteral *getObjCStringLiteral() const { return Str; }
859
860
1.44k
  QualType getValueType() const override { return Str->getType(); }
861
862
299
  bool isBoundable() const override { return false; }
863
864
910
  void Profile(llvm::FoldingSetNodeID& ID) const override {
865
910
    ProfileRegion(ID, Str, superRegion);
866
910
  }
867
868
  void dumpToStream(raw_ostream &os) const override;
869
870
1.69k
  static bool classof(const MemRegion* R) {
871
1.69k
    return R->getKind() == ObjCStringRegionKind;
872
1.69k
  }
873
};
874
875
/// CompoundLiteralRegion - A memory region representing a compound literal.
876
///   Compound literals are essentially temporaries that are stack allocated
877
///   or in the global constant pool.
878
class CompoundLiteralRegion : public TypedValueRegion {
879
  friend class MemRegionManager;
880
881
  const CompoundLiteralExpr *CL;
882
883
  CompoundLiteralRegion(const CompoundLiteralExpr *cl,
884
                        const MemSpaceRegion *sReg)
885
53
      : TypedValueRegion(sReg, CompoundLiteralRegionKind), CL(cl) {
886
53
    assert(cl);
887
0
    assert(isa<GlobalInternalSpaceRegion>(sReg) ||
888
53
           isa<StackLocalsSpaceRegion>(sReg));
889
53
  }
890
891
  static void ProfileRegion(llvm::FoldingSetNodeID& ID,
892
                            const CompoundLiteralExpr *CL,
893
                            const MemRegion* superRegion);
894
895
public:
896
227
  QualType getValueType() const override { return CL->getType(); }
897
898
0
  bool isBoundable() const override { return !CL->isFileScope(); }
899
900
  void Profile(llvm::FoldingSetNodeID& ID) const override;
901
902
  void dumpToStream(raw_ostream &os) const override;
903
904
  LLVM_ATTRIBUTE_RETURNS_NONNULL
905
3
  const CompoundLiteralExpr *getLiteralExpr() const { return CL; }
906
907
119
  static bool classof(const MemRegion* R) {
908
119
    return R->getKind() == CompoundLiteralRegionKind;
909
119
  }
910
};
911
912
class DeclRegion : public TypedValueRegion {
913
protected:
914
70.2k
  DeclRegion(const MemRegion *sReg, Kind k) : TypedValueRegion(sReg, k) {
915
70.2k
    assert(classof(this));
916
70.2k
  }
917
918
public:
919
  // TODO what does this return?
920
  virtual const ValueDecl *getDecl() const = 0;
921
922
72.0k
  static bool classof(const MemRegion* R) {
923
72.0k
    unsigned k = R->getKind();
924
72.0k
    return k >= BEGIN_DECL_REGIONS && 
k <= END_DECL_REGIONS71.8k
;
925
72.0k
  }
926
};
927
928
class VarRegion : public DeclRegion {
929
  friend class MemRegionManager;
930
931
protected:
932
  // Constructors and protected methods.
933
52.1k
  VarRegion(const MemRegion *sReg, Kind k) : DeclRegion(sReg, k) {
934
    // VarRegion appears in unknown space when it's a block variable as seen
935
    // from a block using it, when this block is analyzed at top-level.
936
    // Other block variables appear within block data regions,
937
    // which, unlike everything else on this list, are not memory spaces.
938
52.1k
    assert(isa<GlobalsSpaceRegion>(sReg) || isa<StackSpaceRegion>(sReg) ||
939
52.1k
           isa<BlockDataRegion>(sReg) || isa<UnknownSpaceRegion>(sReg));
940
52.1k
  }
941
942
public:
943
  // TODO what does this return?
944
  const VarDecl *getDecl() const override = 0;
945
946
  /// It might return null.
947
  const StackFrameContext *getStackFrame() const;
948
949
0
  QualType getValueType() const override {
950
    // FIXME: We can cache this if needed.
951
0
    return getDecl()->getType();
952
0
  }
953
954
2.88M
  static bool classof(const MemRegion *R) {
955
2.88M
    unsigned k = R->getKind();
956
2.88M
    return k >= BEGIN_VAR_REGIONS && 
k <= END_VAR_REGIONS2.00M
;
957
2.88M
  }
958
};
959
960
class NonParamVarRegion : public VarRegion {
961
  friend class MemRegionManager;
962
963
  const VarDecl *VD;
964
965
  // Constructors and private methods.
966
  NonParamVarRegion(const VarDecl *vd, const MemRegion *sReg)
967
32.9k
      : VarRegion(sReg, NonParamVarRegionKind), VD(vd) {
968
    // VarRegion appears in unknown space when it's a block variable as seen
969
    // from a block using it, when this block is analyzed at top-level.
970
    // Other block variables appear within block data regions,
971
    // which, unlike everything else on this list, are not memory spaces.
972
32.9k
    assert(isa<GlobalsSpaceRegion>(sReg) || isa<StackSpaceRegion>(sReg) ||
973
32.9k
           isa<BlockDataRegion>(sReg) || isa<UnknownSpaceRegion>(sReg));
974
0
    assert(vd);
975
32.9k
  }
976
977
  static void ProfileRegion(llvm::FoldingSetNodeID &ID, const VarDecl *VD,
978
                            const MemRegion *superRegion);
979
980
public:
981
  void Profile(llvm::FoldingSetNodeID &ID) const override;
982
983
  LLVM_ATTRIBUTE_RETURNS_NONNULL
984
11.9M
  const VarDecl *getDecl() const override { return VD; }
985
986
10.7M
  QualType getValueType() const override {
987
    // FIXME: We can cache this if needed.
988
10.7M
    return getDecl()->getType();
989
10.7M
  }
990
991
  void dumpToStream(raw_ostream &os) const override;
992
993
  bool canPrintPrettyAsExpr() const override;
994
995
  void printPrettyAsExpr(raw_ostream &os) const override;
996
997
450k
  static bool classof(const MemRegion* R) {
998
450k
    return R->getKind() == NonParamVarRegionKind;
999
450k
  }
1000
};
1001
1002
/// ParamVarRegion - Represents a region for paremters. Only parameters of the
1003
/// function in the current stack frame are represented as `ParamVarRegion`s.
1004
/// Parameters of top-level analyzed functions as well as captured paremeters
1005
/// by lambdas and blocks are repesented as `VarRegion`s.
1006
1007
// FIXME: `ParamVarRegion` only supports parameters of functions, C++
1008
// constructors, blocks and Objective-C methods with existing `Decl`. Upon
1009
// implementing stack frame creations for functions without decl (functions
1010
// passed by unknown function pointer) methods of `ParamVarRegion` must be
1011
// updated.
1012
class ParamVarRegion : public VarRegion {
1013
  friend class MemRegionManager;
1014
1015
  const Expr *OriginExpr;
1016
  unsigned Index;
1017
1018
  ParamVarRegion(const Expr *OE, unsigned Idx, const MemRegion *SReg)
1019
19.1k
      : VarRegion(SReg, ParamVarRegionKind), OriginExpr(OE), Index(Idx) {
1020
19.1k
    assert(!cast<StackSpaceRegion>(SReg)->getStackFrame()->inTopFrame());
1021
0
    assert(OriginExpr);
1022
19.1k
  }
1023
1024
  static void ProfileRegion(llvm::FoldingSetNodeID &ID, const Expr *OE,
1025
                            unsigned Idx, const MemRegion *SReg);
1026
1027
public:
1028
  LLVM_ATTRIBUTE_RETURNS_NONNULL
1029
145k
  const Expr *getOriginExpr() const { return OriginExpr; }
1030
145k
  unsigned getIndex() const { return Index; }
1031
1032
  void Profile(llvm::FoldingSetNodeID& ID) const override;
1033
1034
  void dumpToStream(raw_ostream &os) const override;
1035
1036
  QualType getValueType() const override;
1037
1038
  /// TODO: What does this return?
1039
  const ParmVarDecl *getDecl() const override;
1040
1041
  bool canPrintPrettyAsExpr() const override;
1042
  void printPrettyAsExpr(raw_ostream &os) const override;
1043
1044
134k
  static bool classof(const MemRegion *R) {
1045
134k
    return R->getKind() == ParamVarRegionKind;
1046
134k
  }
1047
};
1048
1049
/// CXXThisRegion - Represents the region for the implicit 'this' parameter
1050
///  in a call to a C++ method.  This region doesn't represent the object
1051
///  referred to by 'this', but rather 'this' itself.
1052
class CXXThisRegion : public TypedValueRegion {
1053
  friend class MemRegionManager;
1054
1055
  CXXThisRegion(const PointerType *thisPointerTy,
1056
                const StackArgumentsSpaceRegion *sReg)
1057
      : TypedValueRegion(sReg, CXXThisRegionKind),
1058
14.4k
        ThisPointerTy(thisPointerTy) {
1059
14.4k
    assert(ThisPointerTy->getPointeeType()->getAsCXXRecordDecl() &&
1060
14.4k
           "Invalid region type!");
1061
14.4k
  }
1062
1063
  static void ProfileRegion(llvm::FoldingSetNodeID &ID,
1064
                            const PointerType *PT,
1065
                            const MemRegion *sReg);
1066
1067
public:
1068
  void Profile(llvm::FoldingSetNodeID &ID) const override;
1069
1070
187k
  QualType getValueType() const override {
1071
187k
    return QualType(ThisPointerTy, 0);
1072
187k
  }
1073
1074
  void dumpToStream(raw_ostream &os) const override;
1075
1076
505k
  static bool classof(const MemRegion* R) {
1077
505k
    return R->getKind() == CXXThisRegionKind;
1078
505k
  }
1079
1080
private:
1081
  const PointerType *ThisPointerTy;
1082
};
1083
1084
class FieldRegion : public DeclRegion {
1085
  friend class MemRegionManager;
1086
1087
  const FieldDecl *FD;
1088
1089
  FieldRegion(const FieldDecl *fd, const SubRegion *sReg)
1090
17.4k
      : DeclRegion(sReg, FieldRegionKind), FD(fd) {
1091
17.4k
    assert(FD);
1092
17.4k
  }
1093
1094
  static void ProfileRegion(llvm::FoldingSetNodeID &ID, const FieldDecl *FD,
1095
303k
                            const MemRegion* superRegion) {
1096
303k
    ID.AddInteger(static_cast<unsigned>(FieldRegionKind));
1097
303k
    ID.AddPointer(FD);
1098
303k
    ID.AddPointer(superRegion);
1099
303k
  }
1100
1101
public:
1102
  LLVM_ATTRIBUTE_RETURNS_NONNULL
1103
2.05M
  const FieldDecl *getDecl() const override { return FD; }
1104
1105
  void Profile(llvm::FoldingSetNodeID &ID) const override;
1106
1107
1.73M
  QualType getValueType() const override {
1108
    // FIXME: We can cache this if needed.
1109
1.73M
    return getDecl()->getType();
1110
1.73M
  }
1111
1112
  void dumpToStream(raw_ostream &os) const override;
1113
1114
  bool canPrintPretty() const override;
1115
  void printPretty(raw_ostream &os) const override;
1116
  bool canPrintPrettyAsExpr() const override;
1117
  void printPrettyAsExpr(raw_ostream &os) const override;
1118
1119
989k
  static bool classof(const MemRegion* R) {
1120
989k
    return R->getKind() == FieldRegionKind;
1121
989k
  }
1122
};
1123
1124
class ObjCIvarRegion : public DeclRegion {
1125
  friend class MemRegionManager;
1126
1127
  const ObjCIvarDecl *IVD;
1128
1129
  ObjCIvarRegion(const ObjCIvarDecl *ivd, const SubRegion *sReg);
1130
1131
  static void ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCIvarDecl *ivd,
1132
                            const MemRegion* superRegion);
1133
1134
public:
1135
  LLVM_ATTRIBUTE_RETURNS_NONNULL
1136
  const ObjCIvarDecl *getDecl() const override;
1137
1138
  void Profile(llvm::FoldingSetNodeID& ID) const override;
1139
1140
  QualType getValueType() const override;
1141
1142
  bool canPrintPrettyAsExpr() const override;
1143
  void printPrettyAsExpr(raw_ostream &os) const override;
1144
1145
  void dumpToStream(raw_ostream &os) const override;
1146
1147
512k
  static bool classof(const MemRegion* R) {
1148
512k
    return R->getKind() == ObjCIvarRegionKind;
1149
512k
  }
1150
};
1151
1152
//===----------------------------------------------------------------------===//
1153
// Auxiliary data classes for use with MemRegions.
1154
//===----------------------------------------------------------------------===//
1155
1156
class RegionRawOffset {
1157
  friend class ElementRegion;
1158
1159
  const MemRegion *Region;
1160
  CharUnits Offset;
1161
1162
  RegionRawOffset(const MemRegion* reg, CharUnits offset = CharUnits::Zero())
1163
23.8k
      : Region(reg), Offset(offset) {}
1164
1165
public:
1166
  // FIXME: Eventually support symbolic offsets.
1167
492
  CharUnits getOffset() const { return Offset; }
1168
1169
  // It might return null.
1170
38.1k
  const MemRegion *getRegion() const { return Region; }
1171
1172
  void dumpToStream(raw_ostream &os) const;
1173
  void dump() const;
1174
};
1175
1176
/// ElementRegion is used to represent both array elements and casts.
1177
class ElementRegion : public TypedValueRegion {
1178
  friend class MemRegionManager;
1179
1180
  QualType ElementType;
1181
  NonLoc Index;
1182
1183
  ElementRegion(QualType elementType, NonLoc Idx, const SubRegion *sReg)
1184
      : TypedValueRegion(sReg, ElementRegionKind), ElementType(elementType),
1185
16.5k
        Index(Idx) {
1186
16.5k
    assert((!isa<nonloc::ConcreteInt>(Idx) ||
1187
16.5k
            Idx.castAs<nonloc::ConcreteInt>().getValue().isSigned()) &&
1188
16.5k
           "The index must be signed");
1189
0
    assert(!elementType.isNull() && !elementType->isVoidType() &&
1190
16.5k
           "Invalid region type!");
1191
16.5k
  }
1192
1193
  static void ProfileRegion(llvm::FoldingSetNodeID& ID, QualType elementType,
1194
                            SVal Idx, const MemRegion* superRegion);
1195
1196
public:
1197
378k
  NonLoc getIndex() const { return Index; }
1198
1199
381k
  QualType getValueType() const override { return ElementType; }
1200
1201
46.3k
  QualType getElementType() const { return ElementType; }
1202
1203
  /// Compute the offset within the array. The array might also be a subobject.
1204
  RegionRawOffset getAsArrayOffset() const;
1205
1206
  void dumpToStream(raw_ostream &os) const override;
1207
1208
  void Profile(llvm::FoldingSetNodeID& ID) const override;
1209
1210
4.55M
  static bool classof(const MemRegion* R) {
1211
4.55M
    return R->getKind() == ElementRegionKind;
1212
4.55M
  }
1213
};
1214
1215
// C++ temporary object associated with an expression.
1216
class CXXTempObjectRegion : public TypedValueRegion {
1217
  friend class MemRegionManager;
1218
1219
  Expr const *Ex;
1220
1221
  CXXTempObjectRegion(Expr const *E, MemSpaceRegion const *sReg)
1222
2.91k
      : TypedValueRegion(sReg, CXXTempObjectRegionKind), Ex(E) {
1223
2.91k
    assert(E);
1224
0
    assert(isa<StackLocalsSpaceRegion>(sReg) ||
1225
2.91k
           isa<GlobalInternalSpaceRegion>(sReg));
1226
2.91k
  }
1227
1228
  static void ProfileRegion(llvm::FoldingSetNodeID &ID,
1229
                            Expr const *E, const MemRegion *sReg);
1230
1231
public:
1232
  LLVM_ATTRIBUTE_RETURNS_NONNULL
1233
50
  const Expr *getExpr() const { return Ex; }
1234
1235
47.2k
  QualType getValueType() const override { return Ex->getType(); }
1236
1237
  void dumpToStream(raw_ostream &os) const override;
1238
1239
  void Profile(llvm::FoldingSetNodeID &ID) const override;
1240
1241
7.81k
  static bool classof(const MemRegion* R) {
1242
7.81k
    return R->getKind() == CXXTempObjectRegionKind;
1243
7.81k
  }
1244
};
1245
1246
// CXXBaseObjectRegion represents a base object within a C++ object. It is
1247
// identified by the base class declaration and the region of its parent object.
1248
class CXXBaseObjectRegion : public TypedValueRegion {
1249
  friend class MemRegionManager;
1250
1251
  llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> Data;
1252
1253
  CXXBaseObjectRegion(const CXXRecordDecl *RD, bool IsVirtual,
1254
                      const SubRegion *SReg)
1255
1.08k
      : TypedValueRegion(SReg, CXXBaseObjectRegionKind), Data(RD, IsVirtual) {
1256
1.08k
    assert(RD);
1257
1.08k
  }
1258
1259
  static void ProfileRegion(llvm::FoldingSetNodeID &ID, const CXXRecordDecl *RD,
1260
                            bool IsVirtual, const MemRegion *SReg);
1261
1262
public:
1263
  LLVM_ATTRIBUTE_RETURNS_NONNULL
1264
10.2k
  const CXXRecordDecl *getDecl() const { return Data.getPointer(); }
1265
3.09k
  bool isVirtual() const { return Data.getInt(); }
1266
1267
  QualType getValueType() const override;
1268
1269
  void dumpToStream(raw_ostream &os) const override;
1270
1271
  void Profile(llvm::FoldingSetNodeID &ID) const override;
1272
1273
  bool canPrintPrettyAsExpr() const override;
1274
1275
  void printPrettyAsExpr(raw_ostream &os) const override;
1276
1277
131k
  static bool classof(const MemRegion *region) {
1278
131k
    return region->getKind() == CXXBaseObjectRegionKind;
1279
131k
  }
1280
};
1281
1282
// CXXDerivedObjectRegion represents a derived-class object that surrounds
1283
// a C++ object. It is identified by the derived class declaration and the
1284
// region of its parent object. It is a bit counter-intuitive (but not otherwise
1285
// unseen) that this region represents a larger segment of memory that its
1286
// super-region.
1287
class CXXDerivedObjectRegion : public TypedValueRegion {
1288
  friend class MemRegionManager;
1289
1290
  const CXXRecordDecl *DerivedD;
1291
1292
  CXXDerivedObjectRegion(const CXXRecordDecl *DerivedD, const SubRegion *SReg)
1293
24
      : TypedValueRegion(SReg, CXXDerivedObjectRegionKind), DerivedD(DerivedD) {
1294
24
    assert(DerivedD);
1295
    // In case of a concrete region, it should always be possible to model
1296
    // the base-to-derived cast by undoing a previous derived-to-base cast,
1297
    // otherwise the cast is most likely ill-formed.
1298
0
    assert(SReg->getSymbolicBase() &&
1299
24
           "Should have unwrapped a base region instead!");
1300
24
  }
1301
1302
  static void ProfileRegion(llvm::FoldingSetNodeID &ID, const CXXRecordDecl *RD,
1303
                            const MemRegion *SReg);
1304
1305
public:
1306
  LLVM_ATTRIBUTE_RETURNS_NONNULL
1307
563
  const CXXRecordDecl *getDecl() const { return DerivedD; }
1308
1309
  QualType getValueType() const override;
1310
1311
  void dumpToStream(raw_ostream &os) const override;
1312
1313
  void Profile(llvm::FoldingSetNodeID &ID) const override;
1314
1315
  bool canPrintPrettyAsExpr() const override;
1316
1317
  void printPrettyAsExpr(raw_ostream &os) const override;
1318
1319
2.09k
  static bool classof(const MemRegion *region) {
1320
2.09k
    return region->getKind() == CXXDerivedObjectRegionKind;
1321
2.09k
  }
1322
};
1323
1324
template<typename RegionTy>
1325
246k
const RegionTy* MemRegion::getAs() const {
1326
246k
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
189k
    return RT;
1328
1329
57.5k
  return nullptr;
1330
246k
}
clang::ento::TypedValueRegion const* clang::ento::MemRegion::getAs<clang::ento::TypedValueRegion>() const
Line
Count
Source
1325
919
const RegionTy* MemRegion::getAs() const {
1326
919
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
820
    return RT;
1328
1329
99
  return nullptr;
1330
919
}
clang::ento::VarRegion const* clang::ento::MemRegion::getAs<clang::ento::VarRegion>() const
Line
Count
Source
1325
756
const RegionTy* MemRegion::getAs() const {
1326
756
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
716
    return RT;
1328
1329
40
  return nullptr;
1330
756
}
clang::ento::CXXTempObjectRegion const* clang::ento::MemRegion::getAs<clang::ento::CXXTempObjectRegion>() const
Line
Count
Source
1325
3.42k
const RegionTy* MemRegion::getAs() const {
1326
3.42k
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
300
    return RT;
1328
1329
3.12k
  return nullptr;
1330
3.42k
}
clang::ento::MemRegion const* clang::ento::MemRegion::getAs<clang::ento::MemRegion>() const
Line
Count
Source
1325
18
const RegionTy* MemRegion::getAs() const {
1326
18
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
18
    return RT;
1328
1329
0
  return nullptr;
1330
18
}
clang::ento::FieldRegion const* clang::ento::MemRegion::getAs<clang::ento::FieldRegion>() const
Line
Count
Source
1325
54
const RegionTy* MemRegion::getAs() const {
1326
54
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
23
    return RT;
1328
1329
31
  return nullptr;
1330
54
}
clang::ento::StackSpaceRegion const* clang::ento::MemRegion::getAs<clang::ento::StackSpaceRegion>() const
Line
Count
Source
1325
179k
const RegionTy* MemRegion::getAs() const {
1326
179k
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
149k
    return RT;
1328
1329
30.0k
  return nullptr;
1330
179k
}
clang::ento::DeclRegion const* clang::ento::MemRegion::getAs<clang::ento::DeclRegion>() const
Line
Count
Source
1325
340
const RegionTy* MemRegion::getAs() const {
1326
340
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
137
    return RT;
1328
1329
203
  return nullptr;
1330
340
}
clang::ento::SubRegion const* clang::ento::MemRegion::getAs<clang::ento::SubRegion>() const
Line
Count
Source
1325
1.24k
const RegionTy* MemRegion::getAs() const {
1326
1.24k
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
1.24k
    return RT;
1328
1329
0
  return nullptr;
1330
1.24k
}
clang::ento::SymbolicRegion const* clang::ento::MemRegion::getAs<clang::ento::SymbolicRegion>() const
Line
Count
Source
1325
34.5k
const RegionTy* MemRegion::getAs() const {
1326
34.5k
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
12.2k
    return RT;
1328
1329
22.3k
  return nullptr;
1330
34.5k
}
clang::ento::ElementRegion const* clang::ento::MemRegion::getAs<clang::ento::ElementRegion>() const
Line
Count
Source
1325
671
const RegionTy* MemRegion::getAs() const {
1326
671
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
45
    return RT;
1328
1329
626
  return nullptr;
1330
671
}
clang::ento::FunctionCodeRegion const* clang::ento::MemRegion::getAs<clang::ento::FunctionCodeRegion>() const
Line
Count
Source
1325
25.0k
const RegionTy* MemRegion::getAs() const {
1326
25.0k
  if (const auto *RT = dyn_cast<RegionTy>(this))
1327
24.0k
    return RT;
1328
1329
1.03k
  return nullptr;
1330
25.0k
}
1331
1332
template <typename RegionTy>
1333
2
LLVM_ATTRIBUTE_RETURNS_NONNULL const RegionTy *MemRegion::castAs() const {
1334
2
  return cast<RegionTy>(this);
1335
2
}
1336
1337
//===----------------------------------------------------------------------===//
1338
// MemRegionManager - Factory object for creating regions.
1339
//===----------------------------------------------------------------------===//
1340
1341
class MemRegionManager {
1342
  ASTContext &Ctx;
1343
  llvm::BumpPtrAllocator& A;
1344
1345
  llvm::FoldingSet<MemRegion> Regions;
1346
1347
  GlobalInternalSpaceRegion *InternalGlobals = nullptr;
1348
  GlobalSystemSpaceRegion *SystemGlobals = nullptr;
1349
  GlobalImmutableSpaceRegion *ImmutableGlobals = nullptr;
1350
1351
  llvm::DenseMap<const StackFrameContext *, StackLocalsSpaceRegion *>
1352
    StackLocalsSpaceRegions;
1353
  llvm::DenseMap<const StackFrameContext *, StackArgumentsSpaceRegion *>
1354
    StackArgumentsSpaceRegions;
1355
  llvm::DenseMap<const CodeTextRegion *, StaticGlobalSpaceRegion *>
1356
    StaticsGlobalSpaceRegions;
1357
1358
  HeapSpaceRegion *heap = nullptr;
1359
  UnknownSpaceRegion *unknown = nullptr;
1360
  CodeSpaceRegion *code = nullptr;
1361
1362
public:
1363
15.6k
  MemRegionManager(ASTContext &c, llvm::BumpPtrAllocator &a) : Ctx(c), A(a) {}
1364
  ~MemRegionManager();
1365
1366
1.96M
  ASTContext &getContext() { return Ctx; }
1367
1368
236
  llvm::BumpPtrAllocator &getAllocator() { return A; }
1369
1370
  /// \returns The static size in bytes of the region \p MR.
1371
  /// \note The region \p MR must be a 'SubRegion'.
1372
  DefinedOrUnknownSVal getStaticSize(const MemRegion *MR,
1373
                                     SValBuilder &SVB) const;
1374
1375
  /// getStackLocalsRegion - Retrieve the memory region associated with the
1376
  ///  specified stack frame.
1377
  const StackLocalsSpaceRegion *
1378
  getStackLocalsRegion(const StackFrameContext *STC);
1379
1380
  /// getStackArgumentsRegion - Retrieve the memory region associated with
1381
  ///  function/method arguments of the specified stack frame.
1382
  const StackArgumentsSpaceRegion *
1383
  getStackArgumentsRegion(const StackFrameContext *STC);
1384
1385
  /// getGlobalsRegion - Retrieve the memory region associated with
1386
  ///  global variables.
1387
  const GlobalsSpaceRegion *getGlobalsRegion(
1388
      MemRegion::Kind K = MemRegion::GlobalInternalSpaceRegionKind,
1389
      const CodeTextRegion *R = nullptr);
1390
1391
  /// getHeapRegion - Retrieve the memory region associated with the
1392
  ///  generic "heap".
1393
  const HeapSpaceRegion *getHeapRegion();
1394
1395
  /// getUnknownRegion - Retrieve the memory region associated with unknown
1396
  /// memory space.
1397
  const UnknownSpaceRegion *getUnknownRegion();
1398
1399
  const CodeSpaceRegion *getCodeRegion();
1400
1401
  /// getAllocaRegion - Retrieve a region associated with a call to alloca().
1402
  const AllocaRegion *getAllocaRegion(const Expr *Ex, unsigned Cnt,
1403
                                      const LocationContext *LC);
1404
1405
  /// getCompoundLiteralRegion - Retrieve the region associated with a
1406
  ///  given CompoundLiteral.
1407
  const CompoundLiteralRegion*
1408
  getCompoundLiteralRegion(const CompoundLiteralExpr *CL,
1409
                           const LocationContext *LC);
1410
1411
  /// getCXXThisRegion - Retrieve the [artificial] region associated with the
1412
  ///  parameter 'this'.
1413
  const CXXThisRegion *getCXXThisRegion(QualType thisPointerTy,
1414
                                        const LocationContext *LC);
1415
1416
  /// Retrieve or create a "symbolic" memory region.
1417
  /// If no memory space is specified, `UnknownSpaceRegion` will be used.
1418
  const SymbolicRegion *
1419
  getSymbolicRegion(SymbolRef Sym, const MemSpaceRegion *MemSpace = nullptr);
1420
1421
  /// Return a unique symbolic region belonging to heap memory space.
1422
  const SymbolicRegion *getSymbolicHeapRegion(SymbolRef sym);
1423
1424
  const StringRegion *getStringRegion(const StringLiteral *Str);
1425
1426
  const ObjCStringRegion *getObjCStringRegion(const ObjCStringLiteral *Str);
1427
1428
  /// getVarRegion - Retrieve or create the memory region associated with
1429
  ///  a specified VarDecl and LocationContext.
1430
  const VarRegion *getVarRegion(const VarDecl *VD, const LocationContext *LC);
1431
1432
  /// getVarRegion - Retrieve or create the memory region associated with
1433
  ///  a specified VarDecl and LocationContext.
1434
  const NonParamVarRegion *getNonParamVarRegion(const VarDecl *VD,
1435
                                                const MemRegion *superR);
1436
1437
  /// getParamVarRegion - Retrieve or create the memory region
1438
  /// associated with a specified CallExpr, Index and LocationContext.
1439
  const ParamVarRegion *getParamVarRegion(const Expr *OriginExpr,
1440
                                          unsigned Index,
1441
                                          const LocationContext *LC);
1442
1443
  /// getElementRegion - Retrieve the memory region associated with the
1444
  ///  associated element type, index, and super region.
1445
  const ElementRegion *getElementRegion(QualType elementType, NonLoc Idx,
1446
                                        const SubRegion *superRegion,
1447
                                        ASTContext &Ctx);
1448
1449
  const ElementRegion *getElementRegionWithSuper(const ElementRegion *ER,
1450
288
                                                 const SubRegion *superRegion) {
1451
288
    return getElementRegion(ER->getElementType(), ER->getIndex(),
1452
288
                            superRegion, ER->getContext());
1453
288
  }
1454
1455
  /// getFieldRegion - Retrieve or create the memory region associated with
1456
  ///  a specified FieldDecl.  'superRegion' corresponds to the containing
1457
  ///  memory region (which typically represents the memory representing
1458
  ///  a structure or class).
1459
  const FieldRegion *getFieldRegion(const FieldDecl *fd,
1460
                                    const SubRegion* superRegion);
1461
1462
  const FieldRegion *getFieldRegionWithSuper(const FieldRegion *FR,
1463
501
                                             const SubRegion *superRegion) {
1464
501
    return getFieldRegion(FR->getDecl(), superRegion);
1465
501
  }
1466
1467
  /// getObjCIvarRegion - Retrieve or create the memory region associated with
1468
  ///   a specified Objective-c instance variable.  'superRegion' corresponds
1469
  ///   to the containing region (which typically represents the Objective-C
1470
  ///   object).
1471
  const ObjCIvarRegion *getObjCIvarRegion(const ObjCIvarDecl *ivd,
1472
                                          const SubRegion* superRegion);
1473
1474
  const CXXTempObjectRegion *getCXXTempObjectRegion(Expr const *Ex,
1475
                                                    LocationContext const *LC);
1476
1477
  /// Create a CXXBaseObjectRegion with the given base class for region
1478
  /// \p Super.
1479
  ///
1480
  /// The type of \p Super is assumed be a class deriving from \p BaseClass.
1481
  const CXXBaseObjectRegion *
1482
  getCXXBaseObjectRegion(const CXXRecordDecl *BaseClass, const SubRegion *Super,
1483
                         bool IsVirtual);
1484
1485
  /// Create a CXXBaseObjectRegion with the same CXXRecordDecl but a different
1486
  /// super region.
1487
  const CXXBaseObjectRegion *
1488
  getCXXBaseObjectRegionWithSuper(const CXXBaseObjectRegion *baseReg,
1489
46
                                  const SubRegion *superRegion) {
1490
46
    return getCXXBaseObjectRegion(baseReg->getDecl(), superRegion,
1491
46
                                  baseReg->isVirtual());
1492
46
  }
1493
1494
  /// Create a CXXDerivedObjectRegion with the given derived class for region
1495
  /// \p Super. This should not be used for casting an existing
1496
  /// CXXBaseObjectRegion back to the derived type; instead, CXXBaseObjectRegion
1497
  /// should be removed.
1498
  const CXXDerivedObjectRegion *
1499
  getCXXDerivedObjectRegion(const CXXRecordDecl *BaseClass,
1500
                            const SubRegion *Super);
1501
1502
  const FunctionCodeRegion *getFunctionCodeRegion(const NamedDecl *FD);
1503
  const BlockCodeRegion *getBlockCodeRegion(const BlockDecl *BD,
1504
                                            CanQualType locTy,
1505
                                            AnalysisDeclContext *AC);
1506
1507
  /// getBlockDataRegion - Get the memory region associated with an instance
1508
  ///  of a block.  Unlike many other MemRegions, the LocationContext*
1509
  ///  argument is allowed to be NULL for cases where we have no known
1510
  ///  context.
1511
  const BlockDataRegion *getBlockDataRegion(const BlockCodeRegion *bc,
1512
                                            const LocationContext *lc,
1513
                                            unsigned blockCount);
1514
1515
  /// Create a CXXTempObjectRegion for temporaries which are lifetime-extended
1516
  /// by static references. This differs from getCXXTempObjectRegion in the
1517
  /// super-region used.
1518
  const CXXTempObjectRegion *getCXXStaticTempObjectRegion(const Expr *Ex);
1519
1520
private:
1521
  template <typename RegionTy, typename SuperTy,
1522
            typename Arg1Ty>
1523
  RegionTy* getSubRegion(const Arg1Ty arg1,
1524
                         const SuperTy* superRegion);
1525
1526
  template <typename RegionTy, typename SuperTy,
1527
            typename Arg1Ty, typename Arg2Ty>
1528
  RegionTy* getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
1529
                         const SuperTy* superRegion);
1530
1531
  template <typename RegionTy, typename SuperTy,
1532
            typename Arg1Ty, typename Arg2Ty, typename Arg3Ty>
1533
  RegionTy* getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
1534
                         const Arg3Ty arg3,
1535
                         const SuperTy* superRegion);
1536
1537
  template <typename REG>
1538
  const REG* LazyAllocate(REG*& region);
1539
1540
  template <typename REG, typename ARG>
1541
  const REG* LazyAllocate(REG*& region, ARG a);
1542
};
1543
1544
//===----------------------------------------------------------------------===//
1545
// Out-of-line member definitions.
1546
//===----------------------------------------------------------------------===//
1547
1548
808k
inline ASTContext &MemRegion::getContext() const {
1549
808k
  return getMemRegionManager().getContext();
1550
808k
}
1551
1552
//===----------------------------------------------------------------------===//
1553
// Means for storing region/symbol handling traits.
1554
//===----------------------------------------------------------------------===//
1555
1556
/// Information about invalidation for a particular region/symbol.
1557
class RegionAndSymbolInvalidationTraits {
1558
  using StorageTypeForKinds = unsigned char;
1559
1560
  llvm::DenseMap<const MemRegion *, StorageTypeForKinds> MRTraitsMap;
1561
  llvm::DenseMap<SymbolRef, StorageTypeForKinds> SymTraitsMap;
1562
1563
  using const_region_iterator =
1564
      llvm::DenseMap<const MemRegion *, StorageTypeForKinds>::const_iterator;
1565
  using const_symbol_iterator =
1566
      llvm::DenseMap<SymbolRef, StorageTypeForKinds>::const_iterator;
1567
1568
public:
1569
  /// Describes different invalidation traits.
1570
  enum InvalidationKinds {
1571
    /// Tells that a region's contents is not changed.
1572
    TK_PreserveContents = 0x1,
1573
1574
    /// Suppress pointer-escaping of a region.
1575
    TK_SuppressEscape = 0x2,
1576
1577
    // Do not invalidate super region.
1578
    TK_DoNotInvalidateSuperRegion = 0x4,
1579
1580
    /// When applied to a MemSpaceRegion, indicates the entire memory space
1581
    /// should be invalidated.
1582
    TK_EntireMemSpace = 0x8
1583
1584
    // Do not forget to extend StorageTypeForKinds if number of traits exceed
1585
    // the number of bits StorageTypeForKinds can store.
1586
  };
1587
1588
  void setTrait(SymbolRef Sym, InvalidationKinds IK);
1589
  void setTrait(const MemRegion *MR, InvalidationKinds IK);
1590
  bool hasTrait(SymbolRef Sym, InvalidationKinds IK) const;
1591
  bool hasTrait(const MemRegion *MR, InvalidationKinds IK) const;
1592
};
1593
1594
//===----------------------------------------------------------------------===//
1595
// Pretty-printing regions.
1596
//===----------------------------------------------------------------------===//
1597
3.60k
inline raw_ostream &operator<<(raw_ostream &os, const MemRegion *R) {
1598
3.60k
  R->dumpToStream(os);
1599
3.60k
  return os;
1600
3.60k
}
1601
1602
} // namespace ento
1603
1604
} // namespace clang
1605
1606
#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_MEMREGION_H