Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1 | //== MemRegion.h - Abstract memory regions for static analysis --*- C++ -*--==// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file defines MemRegion and its subclasses. MemRegion defines a |
| 11 | // partially-typed abstraction of memory useful for path-sensitive dataflow |
| 12 | // analyses. |
| 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
Argyrios Kyrtzidis | 5a4f98f | 2010-12-22 18:53:20 +0000 | [diff] [blame] | 16 | #ifndef LLVM_CLANG_GR_MEMREGION_H |
| 17 | #define LLVM_CLANG_GR_MEMREGION_H |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 18 | |
Benjamin Kramer | 478851c | 2012-07-04 17:04:04 +0000 | [diff] [blame] | 19 | #include "clang/AST/ASTContext.h" |
Ken Dyck | 9ff2b13 | 2011-01-24 01:55:39 +0000 | [diff] [blame] | 20 | #include "clang/AST/CharUnits.h" |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 21 | #include "clang/AST/Decl.h" |
Ted Kremenek | 4c62b55 | 2012-02-28 00:56:05 +0000 | [diff] [blame] | 22 | #include "clang/AST/ExprObjC.h" |
Chris Lattner | d47d3b0 | 2011-07-23 10:35:09 +0000 | [diff] [blame] | 23 | #include "clang/Basic/LLVM.h" |
Ted Kremenek | 9b66371 | 2011-02-10 01:03:03 +0000 | [diff] [blame] | 24 | #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h" |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 25 | #include "llvm/ADT/FoldingSet.h" |
Chandler Carruth | 30a2e16 | 2012-12-04 09:18:49 +0000 | [diff] [blame] | 26 | #include "llvm/Support/ErrorHandling.h" |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 27 | #include <string> |
| 28 | |
Benjamin Kramer | 5e2d2c2 | 2010-03-27 21:19:47 +0000 | [diff] [blame] | 29 | namespace llvm { |
| 30 | class BumpPtrAllocator; |
Benjamin Kramer | 5e2d2c2 | 2010-03-27 21:19:47 +0000 | [diff] [blame] | 31 | } |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 32 | |
| 33 | namespace clang { |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 34 | |
Ted Kremenek | d17da2b | 2009-08-21 22:28:32 +0000 | [diff] [blame] | 35 | class LocationContext; |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 36 | class StackFrameContext; |
Argyrios Kyrtzidis | 5a4f98f | 2010-12-22 18:53:20 +0000 | [diff] [blame] | 37 | |
Ted Kremenek | 9ef6537 | 2010-12-23 07:20:52 +0000 | [diff] [blame] | 38 | namespace ento { |
Argyrios Kyrtzidis | 5a4f98f | 2010-12-22 18:53:20 +0000 | [diff] [blame] | 39 | |
| 40 | class MemRegionManager; |
| 41 | class MemSpaceRegion; |
Ted Kremenek | c8413fd | 2010-12-02 07:49:45 +0000 | [diff] [blame] | 42 | class SValBuilder; |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 43 | class VarRegion; |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 44 | class CodeTextRegion; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 45 | |
Zhongxing Xu | e888233 | 2010-08-03 04:52:05 +0000 | [diff] [blame] | 46 | /// Represent a region's offset within the top level base region. |
| 47 | class RegionOffset { |
| 48 | /// The base region. |
| 49 | const MemRegion *R; |
| 50 | |
| 51 | /// The bit offset within the base region. It shouldn't be negative. |
Zhongxing Xu | e3273e7 | 2010-08-03 06:34:25 +0000 | [diff] [blame] | 52 | int64_t Offset; |
Zhongxing Xu | e888233 | 2010-08-03 04:52:05 +0000 | [diff] [blame] | 53 | |
| 54 | public: |
Aaron Ballman | 5375d82 | 2012-08-14 16:46:35 +0000 | [diff] [blame] | 55 | // We're using a const instead of an enumeration due to the size required; |
| 56 | // Visual Studio will only create enumerations of size int, not long long. |
| 57 | static const int64_t Symbolic = INT64_MAX; |
Jordan Rose | 824e07a | 2012-08-09 22:55:37 +0000 | [diff] [blame] | 58 | |
Jordan Rose | e0d24eb | 2012-08-08 18:23:27 +0000 | [diff] [blame] | 59 | RegionOffset() : R(0) {} |
Zhongxing Xu | e3273e7 | 2010-08-03 06:34:25 +0000 | [diff] [blame] | 60 | RegionOffset(const MemRegion *r, int64_t off) : R(r), Offset(off) {} |
Zhongxing Xu | e888233 | 2010-08-03 04:52:05 +0000 | [diff] [blame] | 61 | |
| 62 | const MemRegion *getRegion() const { return R; } |
Jordan Rose | 824e07a | 2012-08-09 22:55:37 +0000 | [diff] [blame] | 63 | |
| 64 | bool hasSymbolicOffset() const { return Offset == Symbolic; } |
| 65 | |
| 66 | int64_t getOffset() const { |
| 67 | assert(!hasSymbolicOffset()); |
| 68 | return Offset; |
| 69 | } |
Jordan Rose | e0d24eb | 2012-08-08 18:23:27 +0000 | [diff] [blame] | 70 | |
| 71 | bool isValid() const { return R; } |
Zhongxing Xu | e888233 | 2010-08-03 04:52:05 +0000 | [diff] [blame] | 72 | }; |
| 73 | |
Ted Kremenek | 19e1f0b | 2009-08-01 06:17:29 +0000 | [diff] [blame] | 74 | //===----------------------------------------------------------------------===// |
| 75 | // Base region classes. |
| 76 | //===----------------------------------------------------------------------===// |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 77 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 78 | /// MemRegion - The root abstract class for all memory regions. |
| 79 | class MemRegion : public llvm::FoldingSetNode { |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 80 | friend class MemRegionManager; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 81 | public: |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 82 | enum Kind { |
| 83 | // Memory spaces. |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 84 | GenericMemSpaceRegionKind, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 85 | StackLocalsSpaceRegionKind, |
| 86 | StackArgumentsSpaceRegionKind, |
| 87 | HeapSpaceRegionKind, |
Ted Kremenek | 2b87ae4 | 2009-12-11 06:43:27 +0000 | [diff] [blame] | 88 | UnknownSpaceRegionKind, |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 89 | StaticGlobalSpaceRegionKind, |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 90 | GlobalInternalSpaceRegionKind, |
| 91 | GlobalSystemSpaceRegionKind, |
| 92 | GlobalImmutableSpaceRegionKind, |
| 93 | BEG_NON_STATIC_GLOBAL_MEMSPACES = GlobalInternalSpaceRegionKind, |
| 94 | END_NON_STATIC_GLOBAL_MEMSPACES = GlobalImmutableSpaceRegionKind, |
| 95 | BEG_GLOBAL_MEMSPACES = StaticGlobalSpaceRegionKind, |
| 96 | END_GLOBAL_MEMSPACES = GlobalImmutableSpaceRegionKind, |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 97 | BEG_MEMSPACES = GenericMemSpaceRegionKind, |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 98 | END_MEMSPACES = GlobalImmutableSpaceRegionKind, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 99 | // Untyped regions. |
| 100 | SymbolicRegionKind, |
| 101 | AllocaRegionKind, |
| 102 | // Typed regions. |
| 103 | BEG_TYPED_REGIONS, |
| 104 | FunctionTextRegionKind = BEG_TYPED_REGIONS, |
| 105 | BlockTextRegionKind, |
Jordan Rose | 8ecf59a | 2012-08-17 20:16:34 +0000 | [diff] [blame] | 106 | BlockDataRegionKind, |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 107 | BEG_TYPED_VALUE_REGIONS, |
| 108 | CompoundLiteralRegionKind = BEG_TYPED_VALUE_REGIONS, |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 109 | CXXThisRegionKind, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 110 | StringRegionKind, |
Ted Kremenek | 4c62b55 | 2012-02-28 00:56:05 +0000 | [diff] [blame] | 111 | ObjCStringRegionKind, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 112 | ElementRegionKind, |
| 113 | // Decl Regions. |
| 114 | BEG_DECL_REGIONS, |
| 115 | VarRegionKind = BEG_DECL_REGIONS, |
| 116 | FieldRegionKind, |
| 117 | ObjCIvarRegionKind, |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 118 | END_DECL_REGIONS = ObjCIvarRegionKind, |
Zhongxing Xu | 02fe28c | 2010-11-26 08:52:48 +0000 | [diff] [blame] | 119 | CXXTempObjectRegionKind, |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 120 | CXXBaseObjectRegionKind, |
Jordy Rose | 096aef9 | 2011-08-12 21:41:07 +0000 | [diff] [blame] | 121 | END_TYPED_VALUE_REGIONS = CXXBaseObjectRegionKind, |
| 122 | END_TYPED_REGIONS = CXXBaseObjectRegionKind |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 123 | }; |
| 124 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 125 | private: |
| 126 | const Kind kind; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 127 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 128 | protected: |
| 129 | MemRegion(Kind k) : kind(k) {} |
| 130 | virtual ~MemRegion(); |
| 131 | |
| 132 | public: |
Ted Kremenek | a6275a5 | 2009-07-15 02:31:43 +0000 | [diff] [blame] | 133 | ASTContext &getContext() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 134 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 135 | virtual void Profile(llvm::FoldingSetNodeID& ID) const = 0; |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 136 | |
| 137 | virtual MemRegionManager* getMemRegionManager() const = 0; |
| 138 | |
Ted Kremenek | bb7c96f | 2009-06-23 18:17:08 +0000 | [diff] [blame] | 139 | const MemSpaceRegion *getMemorySpace() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 140 | |
Zhongxing Xu | adca271 | 2009-11-10 02:37:53 +0000 | [diff] [blame] | 141 | const MemRegion *getBaseRegion() const; |
| 142 | |
Anna Zaks | 522fc21 | 2012-09-12 22:57:30 +0000 | [diff] [blame] | 143 | /// Check if the region is a subregion of the given region. |
Anna Zaks | 5f7c0ad | 2012-09-13 00:37:12 +0000 | [diff] [blame] | 144 | virtual bool isSubRegionOf(const MemRegion *R) const; |
Anna Zaks | 522fc21 | 2012-09-12 22:57:30 +0000 | [diff] [blame] | 145 | |
Jordan Rose | b11a3ad | 2012-08-13 22:11:34 +0000 | [diff] [blame] | 146 | const MemRegion *StripCasts(bool StripBaseCasts = true) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 147 | |
Ted Kremenek | 1508636 | 2009-07-02 18:25:09 +0000 | [diff] [blame] | 148 | bool hasGlobalsOrParametersStorage() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 149 | |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 150 | bool hasStackStorage() const; |
| 151 | |
| 152 | bool hasStackNonParametersStorage() const; |
| 153 | |
| 154 | bool hasStackParametersStorage() const; |
Zhongxing Xu | b21ff77 | 2008-10-24 06:30:07 +0000 | [diff] [blame] | 155 | |
Zhongxing Xu | e888233 | 2010-08-03 04:52:05 +0000 | [diff] [blame] | 156 | /// Compute the offset within the top level memory object. |
| 157 | RegionOffset getAsOffset() const; |
| 158 | |
Anna Zaks | 3d7c44e | 2012-03-21 19:45:08 +0000 | [diff] [blame] | 159 | /// \brief Get a string representation of a region for debug use. |
| 160 | std::string getString() const; |
| 161 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 162 | virtual void dumpToStream(raw_ostream &os) const; |
Ted Kremenek | 7f39d29 | 2009-07-02 17:24:10 +0000 | [diff] [blame] | 163 | |
Ted Kremenek | 8800ad4 | 2009-07-13 23:31:04 +0000 | [diff] [blame] | 164 | void dump() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 165 | |
Jordan Rose | 919e8a1 | 2012-08-08 18:23:36 +0000 | [diff] [blame] | 166 | /// \brief Returns true if this region can be printed in a user-friendly way. |
| 167 | virtual bool canPrintPretty() const; |
| 168 | |
Anna Zaks | 3d7c44e | 2012-03-21 19:45:08 +0000 | [diff] [blame] | 169 | /// \brief Print the region for use in diagnostics. |
Jordan Rose | 919e8a1 | 2012-08-08 18:23:36 +0000 | [diff] [blame] | 170 | virtual void printPretty(raw_ostream &os) const; |
Anna Zaks | 3d7c44e | 2012-03-21 19:45:08 +0000 | [diff] [blame] | 171 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 172 | Kind getKind() const { return kind; } |
| 173 | |
Ted Kremenek | ed65d3d | 2009-03-09 20:28:08 +0000 | [diff] [blame] | 174 | template<typename RegionTy> const RegionTy* getAs() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 175 | |
Zhongxing Xu | f0f0605 | 2009-06-29 05:44:14 +0000 | [diff] [blame] | 176 | virtual bool isBoundable() const { return false; } |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 177 | }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 178 | |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 179 | /// MemSpaceRegion - A memory region that represents a "memory space"; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 180 | /// for example, the set of global variables, the stack frame, etc. |
| 181 | class MemSpaceRegion : public MemRegion { |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 182 | protected: |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 183 | friend class MemRegionManager; |
| 184 | |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 185 | MemRegionManager *Mgr; |
| 186 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 187 | MemSpaceRegion(MemRegionManager *mgr, Kind k = GenericMemSpaceRegionKind) |
| 188 | : MemRegion(k), Mgr(mgr) { |
| 189 | assert(classof(this)); |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 190 | } |
| 191 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 192 | MemRegionManager* getMemRegionManager() const { return Mgr; } |
| 193 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 194 | public: |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 195 | bool isBoundable() const { return false; } |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 196 | |
| 197 | void Profile(llvm::FoldingSetNodeID &ID) const; |
Ted Kremenek | 41168ea | 2009-03-04 02:43:08 +0000 | [diff] [blame] | 198 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 199 | static bool classof(const MemRegion *R) { |
| 200 | Kind k = R->getKind(); |
| 201 | return k >= BEG_MEMSPACES && k <= END_MEMSPACES; |
| 202 | } |
| 203 | }; |
| 204 | |
| 205 | class GlobalsSpaceRegion : public MemSpaceRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 206 | virtual void anchor(); |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 207 | protected: |
| 208 | GlobalsSpaceRegion(MemRegionManager *mgr, Kind k) |
| 209 | : MemSpaceRegion(mgr, k) {} |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 210 | public: |
| 211 | static bool classof(const MemRegion *R) { |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 212 | Kind k = R->getKind(); |
| 213 | return k >= BEG_GLOBAL_MEMSPACES && k <= END_GLOBAL_MEMSPACES; |
| 214 | } |
| 215 | }; |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 216 | |
David Blaikie | 914edfb | 2012-05-02 21:58:03 +0000 | [diff] [blame] | 217 | /// \brief The region of the static variables within the current CodeTextRegion |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 218 | /// scope. |
David Blaikie | 914edfb | 2012-05-02 21:58:03 +0000 | [diff] [blame] | 219 | /// |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 220 | /// Currently, only the static locals are placed there, so we know that these |
| 221 | /// variables do not get invalidated by calls to other functions. |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 222 | class StaticGlobalSpaceRegion : public GlobalsSpaceRegion { |
| 223 | friend class MemRegionManager; |
| 224 | |
| 225 | const CodeTextRegion *CR; |
| 226 | |
| 227 | StaticGlobalSpaceRegion(MemRegionManager *mgr, const CodeTextRegion *cr) |
| 228 | : GlobalsSpaceRegion(mgr, StaticGlobalSpaceRegionKind), CR(cr) {} |
| 229 | |
| 230 | public: |
| 231 | void Profile(llvm::FoldingSetNodeID &ID) const; |
| 232 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 233 | void dumpToStream(raw_ostream &os) const; |
Ted Kremenek | fa87d81 | 2010-07-06 23:37:21 +0000 | [diff] [blame] | 234 | |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 235 | const CodeTextRegion *getCodeRegion() const { return CR; } |
| 236 | |
| 237 | static bool classof(const MemRegion *R) { |
| 238 | return R->getKind() == StaticGlobalSpaceRegionKind; |
| 239 | } |
| 240 | }; |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 241 | |
David Blaikie | 914edfb | 2012-05-02 21:58:03 +0000 | [diff] [blame] | 242 | /// \brief The region for all the non-static global variables. |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 243 | /// |
| 244 | /// This class is further split into subclasses for efficient implementation of |
| 245 | /// invalidating a set of related global values as is done in |
| 246 | /// RegionStoreManager::invalidateRegions (instead of finding all the dependent |
| 247 | /// globals, we invalidate the whole parent region). |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 248 | class NonStaticGlobalSpaceRegion : public GlobalsSpaceRegion { |
| 249 | friend class MemRegionManager; |
| 250 | |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 251 | protected: |
| 252 | NonStaticGlobalSpaceRegion(MemRegionManager *mgr, Kind k) |
| 253 | : GlobalsSpaceRegion(mgr, k) {} |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 254 | |
| 255 | public: |
Ted Kremenek | fa87d81 | 2010-07-06 23:37:21 +0000 | [diff] [blame] | 256 | |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 257 | static bool classof(const MemRegion *R) { |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 258 | Kind k = R->getKind(); |
| 259 | return k >= BEG_NON_STATIC_GLOBAL_MEMSPACES && |
| 260 | k <= END_NON_STATIC_GLOBAL_MEMSPACES; |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 261 | } |
| 262 | }; |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 263 | |
David Blaikie | 914edfb | 2012-05-02 21:58:03 +0000 | [diff] [blame] | 264 | /// \brief The region containing globals which are defined in system/external |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 265 | /// headers and are considered modifiable by system calls (ex: errno). |
| 266 | class GlobalSystemSpaceRegion : public NonStaticGlobalSpaceRegion { |
| 267 | friend class MemRegionManager; |
| 268 | |
| 269 | GlobalSystemSpaceRegion(MemRegionManager *mgr) |
| 270 | : NonStaticGlobalSpaceRegion(mgr, GlobalSystemSpaceRegionKind) {} |
| 271 | |
| 272 | public: |
| 273 | |
| 274 | void dumpToStream(raw_ostream &os) const; |
| 275 | |
| 276 | static bool classof(const MemRegion *R) { |
| 277 | return R->getKind() == GlobalSystemSpaceRegionKind; |
| 278 | } |
| 279 | }; |
| 280 | |
David Blaikie | 914edfb | 2012-05-02 21:58:03 +0000 | [diff] [blame] | 281 | /// \brief The region containing globals which are considered not to be modified |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 282 | /// or point to data which could be modified as a result of a function call |
| 283 | /// (system or internal). Ex: Const global scalars would be modeled as part of |
| 284 | /// this region. This region also includes most system globals since they have |
| 285 | /// low chance of being modified. |
| 286 | class GlobalImmutableSpaceRegion : public NonStaticGlobalSpaceRegion { |
| 287 | friend class MemRegionManager; |
| 288 | |
| 289 | GlobalImmutableSpaceRegion(MemRegionManager *mgr) |
| 290 | : NonStaticGlobalSpaceRegion(mgr, GlobalImmutableSpaceRegionKind) {} |
| 291 | |
| 292 | public: |
| 293 | |
| 294 | void dumpToStream(raw_ostream &os) const; |
| 295 | |
| 296 | static bool classof(const MemRegion *R) { |
| 297 | return R->getKind() == GlobalImmutableSpaceRegionKind; |
| 298 | } |
| 299 | }; |
| 300 | |
David Blaikie | 914edfb | 2012-05-02 21:58:03 +0000 | [diff] [blame] | 301 | /// \brief The region containing globals which can be modified by calls to |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 302 | /// "internally" defined functions - (for now just) functions other then system |
| 303 | /// calls. |
| 304 | class GlobalInternalSpaceRegion : public NonStaticGlobalSpaceRegion { |
| 305 | friend class MemRegionManager; |
| 306 | |
| 307 | GlobalInternalSpaceRegion(MemRegionManager *mgr) |
| 308 | : NonStaticGlobalSpaceRegion(mgr, GlobalInternalSpaceRegionKind) {} |
| 309 | |
| 310 | public: |
| 311 | |
| 312 | void dumpToStream(raw_ostream &os) const; |
| 313 | |
| 314 | static bool classof(const MemRegion *R) { |
| 315 | return R->getKind() == GlobalInternalSpaceRegionKind; |
| 316 | } |
| 317 | }; |
| 318 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 319 | class HeapSpaceRegion : public MemSpaceRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 320 | virtual void anchor(); |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 321 | friend class MemRegionManager; |
| 322 | |
| 323 | HeapSpaceRegion(MemRegionManager *mgr) |
| 324 | : MemSpaceRegion(mgr, HeapSpaceRegionKind) {} |
| 325 | public: |
Jordan Rose | 36397dc | 2012-06-06 20:47:00 +0000 | [diff] [blame] | 326 | |
| 327 | void dumpToStream(raw_ostream &os) const; |
| 328 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 329 | static bool classof(const MemRegion *R) { |
| 330 | return R->getKind() == HeapSpaceRegionKind; |
| 331 | } |
| 332 | }; |
| 333 | |
Ted Kremenek | 2b87ae4 | 2009-12-11 06:43:27 +0000 | [diff] [blame] | 334 | class UnknownSpaceRegion : public MemSpaceRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 335 | virtual void anchor(); |
Ted Kremenek | 2b87ae4 | 2009-12-11 06:43:27 +0000 | [diff] [blame] | 336 | friend class MemRegionManager; |
| 337 | UnknownSpaceRegion(MemRegionManager *mgr) |
| 338 | : MemSpaceRegion(mgr, UnknownSpaceRegionKind) {} |
| 339 | public: |
Jordan Rose | 36397dc | 2012-06-06 20:47:00 +0000 | [diff] [blame] | 340 | |
| 341 | void dumpToStream(raw_ostream &os) const; |
| 342 | |
Ted Kremenek | 2b87ae4 | 2009-12-11 06:43:27 +0000 | [diff] [blame] | 343 | static bool classof(const MemRegion *R) { |
| 344 | return R->getKind() == UnknownSpaceRegionKind; |
| 345 | } |
| 346 | }; |
| 347 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 348 | class StackSpaceRegion : public MemSpaceRegion { |
| 349 | private: |
| 350 | const StackFrameContext *SFC; |
| 351 | |
| 352 | protected: |
| 353 | StackSpaceRegion(MemRegionManager *mgr, Kind k, const StackFrameContext *sfc) |
| 354 | : MemSpaceRegion(mgr, k), SFC(sfc) { |
| 355 | assert(classof(this)); |
| 356 | } |
| 357 | |
| 358 | public: |
| 359 | const StackFrameContext *getStackFrame() const { return SFC; } |
| 360 | |
| 361 | void Profile(llvm::FoldingSetNodeID &ID) const; |
| 362 | |
| 363 | static bool classof(const MemRegion *R) { |
| 364 | Kind k = R->getKind(); |
| 365 | return k >= StackLocalsSpaceRegionKind && |
| 366 | k <= StackArgumentsSpaceRegionKind; |
| 367 | } |
| 368 | }; |
| 369 | |
| 370 | class StackLocalsSpaceRegion : public StackSpaceRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 371 | virtual void anchor(); |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 372 | friend class MemRegionManager; |
| 373 | StackLocalsSpaceRegion(MemRegionManager *mgr, const StackFrameContext *sfc) |
| 374 | : StackSpaceRegion(mgr, StackLocalsSpaceRegionKind, sfc) {} |
| 375 | public: |
Jordan Rose | 36397dc | 2012-06-06 20:47:00 +0000 | [diff] [blame] | 376 | |
| 377 | void dumpToStream(raw_ostream &os) const; |
| 378 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 379 | static bool classof(const MemRegion *R) { |
| 380 | return R->getKind() == StackLocalsSpaceRegionKind; |
| 381 | } |
| 382 | }; |
| 383 | |
| 384 | class StackArgumentsSpaceRegion : public StackSpaceRegion { |
| 385 | private: |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 386 | virtual void anchor(); |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 387 | friend class MemRegionManager; |
| 388 | StackArgumentsSpaceRegion(MemRegionManager *mgr, const StackFrameContext *sfc) |
| 389 | : StackSpaceRegion(mgr, StackArgumentsSpaceRegionKind, sfc) {} |
| 390 | public: |
Jordan Rose | 36397dc | 2012-06-06 20:47:00 +0000 | [diff] [blame] | 391 | |
| 392 | void dumpToStream(raw_ostream &os) const; |
| 393 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 394 | static bool classof(const MemRegion *R) { |
| 395 | return R->getKind() == StackArgumentsSpaceRegionKind; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 396 | } |
| 397 | }; |
| 398 | |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 399 | |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 400 | /// SubRegion - A region that subsets another larger region. Most regions |
| 401 | /// are subclasses of SubRegion. |
| 402 | class SubRegion : public MemRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 403 | private: |
| 404 | virtual void anchor(); |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 405 | protected: |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 406 | const MemRegion* superRegion; |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 407 | SubRegion(const MemRegion* sReg, Kind k) : MemRegion(k), superRegion(sReg) {} |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 408 | public: |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 409 | const MemRegion* getSuperRegion() const { |
| 410 | return superRegion; |
| 411 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 412 | |
Jordy Rose | 32f2656 | 2010-07-04 00:00:41 +0000 | [diff] [blame] | 413 | /// getExtent - Returns the size of the region in bytes. |
Ted Kremenek | c8413fd | 2010-12-02 07:49:45 +0000 | [diff] [blame] | 414 | virtual DefinedOrUnknownSVal getExtent(SValBuilder &svalBuilder) const { |
Jordy Rose | 32f2656 | 2010-07-04 00:00:41 +0000 | [diff] [blame] | 415 | return UnknownVal(); |
| 416 | } |
| 417 | |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 418 | MemRegionManager* getMemRegionManager() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 419 | |
Anna Zaks | 5f7c0ad | 2012-09-13 00:37:12 +0000 | [diff] [blame] | 420 | virtual bool isSubRegionOf(const MemRegion* R) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 421 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 422 | static bool classof(const MemRegion* R) { |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 423 | return R->getKind() > END_MEMSPACES; |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 424 | } |
| 425 | }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 426 | |
Ted Kremenek | 19e1f0b | 2009-08-01 06:17:29 +0000 | [diff] [blame] | 427 | //===----------------------------------------------------------------------===// |
Ted Kremenek | 19e1f0b | 2009-08-01 06:17:29 +0000 | [diff] [blame] | 428 | // MemRegion subclasses. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 429 | //===----------------------------------------------------------------------===// |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 430 | |
Ted Kremenek | 82bd99f | 2008-11-13 15:42:31 +0000 | [diff] [blame] | 431 | /// AllocaRegion - A region that represents an untyped blob of bytes created |
| 432 | /// by a call to 'alloca'. |
| 433 | class AllocaRegion : public SubRegion { |
| 434 | friend class MemRegionManager; |
| 435 | protected: |
| 436 | unsigned Cnt; // Block counter. Used to distinguish different pieces of |
| 437 | // memory allocated by alloca at the same call site. |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 438 | const Expr *Ex; |
Ted Kremenek | 82bd99f | 2008-11-13 15:42:31 +0000 | [diff] [blame] | 439 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 440 | AllocaRegion(const Expr *ex, unsigned cnt, const MemRegion *superRegion) |
Ted Kremenek | 82bd99f | 2008-11-13 15:42:31 +0000 | [diff] [blame] | 441 | : SubRegion(superRegion, AllocaRegionKind), Cnt(cnt), Ex(ex) {} |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 442 | |
Ted Kremenek | 82bd99f | 2008-11-13 15:42:31 +0000 | [diff] [blame] | 443 | public: |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 444 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 445 | const Expr *getExpr() const { return Ex; } |
Zhongxing Xu | 9852b5b | 2009-07-06 05:34:56 +0000 | [diff] [blame] | 446 | |
| 447 | bool isBoundable() const { return true; } |
| 448 | |
Ted Kremenek | c8413fd | 2010-12-02 07:49:45 +0000 | [diff] [blame] | 449 | DefinedOrUnknownSVal getExtent(SValBuilder &svalBuilder) const; |
Jordy Rose | 32f2656 | 2010-07-04 00:00:41 +0000 | [diff] [blame] | 450 | |
Ted Kremenek | 82bd99f | 2008-11-13 15:42:31 +0000 | [diff] [blame] | 451 | void Profile(llvm::FoldingSetNodeID& ID) const; |
| 452 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 453 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, const Expr *Ex, |
Ted Kremenek | 7ae7ad9 | 2009-06-23 00:15:41 +0000 | [diff] [blame] | 454 | unsigned Cnt, const MemRegion *superRegion); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 455 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 456 | void dumpToStream(raw_ostream &os) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 457 | |
Ted Kremenek | 82bd99f | 2008-11-13 15:42:31 +0000 | [diff] [blame] | 458 | static bool classof(const MemRegion* R) { |
| 459 | return R->getKind() == AllocaRegionKind; |
| 460 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 461 | }; |
| 462 | |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 463 | /// TypedRegion - An abstract class representing regions that are typed. |
| 464 | class TypedRegion : public SubRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 465 | public: |
| 466 | virtual void anchor(); |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 467 | protected: |
| 468 | TypedRegion(const MemRegion* sReg, Kind k) : SubRegion(sReg, k) {} |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 469 | |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 470 | public: |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 471 | virtual QualType getLocationType() const = 0; |
| 472 | |
| 473 | QualType getDesugaredLocationType(ASTContext &Context) const { |
| 474 | return getLocationType().getDesugaredType(Context); |
| 475 | } |
| 476 | |
| 477 | bool isBoundable() const { return true; } |
| 478 | |
| 479 | static bool classof(const MemRegion* R) { |
| 480 | unsigned k = R->getKind(); |
| 481 | return k >= BEG_TYPED_REGIONS && k <= END_TYPED_REGIONS; |
| 482 | } |
| 483 | }; |
| 484 | |
| 485 | /// TypedValueRegion - An abstract class representing regions having a typed value. |
| 486 | class TypedValueRegion : public TypedRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 487 | public: |
| 488 | virtual void anchor(); |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 489 | protected: |
| 490 | TypedValueRegion(const MemRegion* sReg, Kind k) : TypedRegion(sReg, k) {} |
| 491 | |
| 492 | public: |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 493 | virtual QualType getValueType() const = 0; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 494 | |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 495 | virtual QualType getLocationType() const { |
Ted Kremenek | 6eddeb1 | 2008-12-13 21:49:13 +0000 | [diff] [blame] | 496 | // FIXME: We can possibly optimize this later to cache this value. |
Ted Kremenek | a6b0b96 | 2010-12-24 08:39:33 +0000 | [diff] [blame] | 497 | QualType T = getValueType(); |
| 498 | ASTContext &ctx = getContext(); |
| 499 | if (T->getAs<ObjCObjectType>()) |
| 500 | return ctx.getObjCObjectPointerType(T); |
| 501 | return ctx.getPointerType(getValueType()); |
Ted Kremenek | 6eddeb1 | 2008-12-13 21:49:13 +0000 | [diff] [blame] | 502 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 503 | |
John McCall | 49f4e1c | 2010-12-10 11:01:00 +0000 | [diff] [blame] | 504 | QualType getDesugaredValueType(ASTContext &Context) const { |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 505 | QualType T = getValueType(); |
Douglas Gregor | 1ab55e9 | 2010-12-10 17:03:06 +0000 | [diff] [blame] | 506 | return T.getTypePtrOrNull() ? T.getDesugaredType(Context) : T; |
Ted Kremenek | 14553ab | 2009-01-30 00:08:43 +0000 | [diff] [blame] | 507 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 508 | |
Jordan Rose | e0d24eb | 2012-08-08 18:23:27 +0000 | [diff] [blame] | 509 | DefinedOrUnknownSVal getExtent(SValBuilder &svalBuilder) const; |
| 510 | |
Ted Kremenek | 993f1c7 | 2008-10-17 20:28:54 +0000 | [diff] [blame] | 511 | static bool classof(const MemRegion* R) { |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 512 | unsigned k = R->getKind(); |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 513 | return k >= BEG_TYPED_VALUE_REGIONS && k <= END_TYPED_VALUE_REGIONS; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 514 | } |
| 515 | }; |
| 516 | |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 517 | |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 518 | class CodeTextRegion : public TypedRegion { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 519 | public: |
| 520 | virtual void anchor(); |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 521 | protected: |
| 522 | CodeTextRegion(const MemRegion *sreg, Kind k) : TypedRegion(sreg, k) {} |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 523 | public: |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 524 | bool isBoundable() const { return false; } |
| 525 | |
| 526 | static bool classof(const MemRegion* R) { |
| 527 | Kind k = R->getKind(); |
| 528 | return k >= FunctionTextRegionKind && k <= BlockTextRegionKind; |
| 529 | } |
| 530 | }; |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 531 | |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 532 | /// FunctionTextRegion - A region that represents code texts of function. |
| 533 | class FunctionTextRegion : public CodeTextRegion { |
Anna Zaks | 5fc1d0c | 2012-09-17 19:13:56 +0000 | [diff] [blame] | 534 | const NamedDecl *FD; |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 535 | public: |
Anna Zaks | 5fc1d0c | 2012-09-17 19:13:56 +0000 | [diff] [blame] | 536 | FunctionTextRegion(const NamedDecl *fd, const MemRegion* sreg) |
| 537 | : CodeTextRegion(sreg, FunctionTextRegionKind), FD(fd) { |
| 538 | assert(isa<ObjCMethodDecl>(fd) || isa<FunctionDecl>(fd)); |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 539 | } |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 540 | |
Anna Zaks | 5fc1d0c | 2012-09-17 19:13:56 +0000 | [diff] [blame] | 541 | QualType getLocationType() const { |
| 542 | const ASTContext &Ctx = getContext(); |
| 543 | if (const FunctionDecl *D = dyn_cast<FunctionDecl>(FD)) { |
| 544 | return Ctx.getPointerType(D->getType()); |
| 545 | } |
| 546 | |
| 547 | assert(isa<ObjCMethodDecl>(FD)); |
| 548 | assert(false && "Getting the type of ObjCMethod is not supported yet"); |
| 549 | |
| 550 | // TODO: We might want to return a different type here (ex: id (*ty)(...)) |
| 551 | // depending on how it is used. |
| 552 | return QualType(); |
| 553 | } |
| 554 | |
| 555 | const NamedDecl *getDecl() const { |
Ted Kremenek | abd46e1 | 2009-08-28 04:49:15 +0000 | [diff] [blame] | 556 | return FD; |
Zhongxing Xu | 369f447 | 2009-04-20 05:24:46 +0000 | [diff] [blame] | 557 | } |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 558 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 559 | virtual void dumpToStream(raw_ostream &os) const; |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 560 | |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 561 | void Profile(llvm::FoldingSetNodeID& ID) const; |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 562 | |
Anna Zaks | 5fc1d0c | 2012-09-17 19:13:56 +0000 | [diff] [blame] | 563 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, const NamedDecl *FD, |
Ted Kremenek | abd46e1 | 2009-08-28 04:49:15 +0000 | [diff] [blame] | 564 | const MemRegion*); |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 565 | |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 566 | static bool classof(const MemRegion* R) { |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 567 | return R->getKind() == FunctionTextRegionKind; |
| 568 | } |
| 569 | }; |
| 570 | |
| 571 | |
| 572 | /// BlockTextRegion - A region that represents code texts of blocks (closures). |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 573 | /// Blocks are represented with two kinds of regions. BlockTextRegions |
| 574 | /// represent the "code", while BlockDataRegions represent instances of blocks, |
| 575 | /// which correspond to "code+data". The distinction is important, because |
| 576 | /// like a closure a block captures the values of externally referenced |
| 577 | /// variables. |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 578 | class BlockTextRegion : public CodeTextRegion { |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 579 | friend class MemRegionManager; |
| 580 | |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 581 | const BlockDecl *BD; |
Ted Kremenek | 1d26f48 | 2011-10-24 01:32:45 +0000 | [diff] [blame] | 582 | AnalysisDeclContext *AC; |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 583 | CanQualType locTy; |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 584 | |
| 585 | BlockTextRegion(const BlockDecl *bd, CanQualType lTy, |
Ted Kremenek | 1d26f48 | 2011-10-24 01:32:45 +0000 | [diff] [blame] | 586 | AnalysisDeclContext *ac, const MemRegion* sreg) |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 587 | : CodeTextRegion(sreg, BlockTextRegionKind), BD(bd), AC(ac), locTy(lTy) {} |
| 588 | |
| 589 | public: |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 590 | QualType getLocationType() const { |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 591 | return locTy; |
| 592 | } |
| 593 | |
| 594 | const BlockDecl *getDecl() const { |
| 595 | return BD; |
| 596 | } |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 597 | |
Ted Kremenek | 1d26f48 | 2011-10-24 01:32:45 +0000 | [diff] [blame] | 598 | AnalysisDeclContext *getAnalysisDeclContext() const { return AC; } |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 599 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 600 | virtual void dumpToStream(raw_ostream &os) const; |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 601 | |
| 602 | void Profile(llvm::FoldingSetNodeID& ID) const; |
| 603 | |
| 604 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockDecl *BD, |
Ted Kremenek | 1d26f48 | 2011-10-24 01:32:45 +0000 | [diff] [blame] | 605 | CanQualType, const AnalysisDeclContext*, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 606 | const MemRegion*); |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 607 | |
| 608 | static bool classof(const MemRegion* R) { |
| 609 | return R->getKind() == BlockTextRegionKind; |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 610 | } |
| 611 | }; |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 612 | |
| 613 | /// BlockDataRegion - A region that represents a block instance. |
| 614 | /// Blocks are represented with two kinds of regions. BlockTextRegions |
| 615 | /// represent the "code", while BlockDataRegions represent instances of blocks, |
| 616 | /// which correspond to "code+data". The distinction is important, because |
| 617 | /// like a closure a block captures the values of externally referenced |
| 618 | /// variables. |
Jordan Rose | 8ecf59a | 2012-08-17 20:16:34 +0000 | [diff] [blame] | 619 | class BlockDataRegion : public TypedRegion { |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 620 | friend class MemRegionManager; |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 621 | const BlockTextRegion *BC; |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 622 | const LocationContext *LC; // Can be null */ |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 623 | void *ReferencedVars; |
Ted Kremenek | 85d87df | 2012-05-04 21:48:42 +0000 | [diff] [blame] | 624 | void *OriginalVars; |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 625 | |
| 626 | BlockDataRegion(const BlockTextRegion *bc, const LocationContext *lc, |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 627 | const MemRegion *sreg) |
Jordan Rose | 8ecf59a | 2012-08-17 20:16:34 +0000 | [diff] [blame] | 628 | : TypedRegion(sreg, BlockDataRegionKind), BC(bc), LC(lc), |
Ted Kremenek | 85d87df | 2012-05-04 21:48:42 +0000 | [diff] [blame] | 629 | ReferencedVars(0), OriginalVars(0) {} |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 630 | |
Ted Kremenek | 85d87df | 2012-05-04 21:48:42 +0000 | [diff] [blame] | 631 | public: |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 632 | const BlockTextRegion *getCodeRegion() const { return BC; } |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 633 | |
Ted Kremenek | d02e83a | 2009-12-04 02:03:51 +0000 | [diff] [blame] | 634 | const BlockDecl *getDecl() const { return BC->getDecl(); } |
Jordan Rose | 8ecf59a | 2012-08-17 20:16:34 +0000 | [diff] [blame] | 635 | |
| 636 | QualType getLocationType() const { return BC->getLocationType(); } |
Ted Kremenek | d02e83a | 2009-12-04 02:03:51 +0000 | [diff] [blame] | 637 | |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 638 | class referenced_vars_iterator { |
| 639 | const MemRegion * const *R; |
Ted Kremenek | 85d87df | 2012-05-04 21:48:42 +0000 | [diff] [blame] | 640 | const MemRegion * const *OriginalR; |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 641 | public: |
Ted Kremenek | 85d87df | 2012-05-04 21:48:42 +0000 | [diff] [blame] | 642 | explicit referenced_vars_iterator(const MemRegion * const *r, |
| 643 | const MemRegion * const *originalR) |
| 644 | : R(r), OriginalR(originalR) {} |
Ted Kremenek | 85d87df | 2012-05-04 21:48:42 +0000 | [diff] [blame] | 645 | |
Ted Kremenek | e3ce2c1 | 2012-12-06 07:17:20 +0000 | [diff] [blame] | 646 | const VarRegion *getCapturedRegion() const { |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 647 | return cast<VarRegion>(*R); |
| 648 | } |
Ted Kremenek | e3ce2c1 | 2012-12-06 07:17:20 +0000 | [diff] [blame] | 649 | const VarRegion *getOriginalRegion() const { |
| 650 | return cast<VarRegion>(*OriginalR); |
| 651 | } |
| 652 | |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 653 | bool operator==(const referenced_vars_iterator &I) const { |
Jordan Rose | 41f3f3a | 2013-03-05 01:27:54 +0000 | [diff] [blame^] | 654 | assert((R == 0) == (I.R == 0)); |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 655 | return I.R == R; |
| 656 | } |
| 657 | bool operator!=(const referenced_vars_iterator &I) const { |
Jordan Rose | 41f3f3a | 2013-03-05 01:27:54 +0000 | [diff] [blame^] | 658 | assert((R == 0) == (I.R == 0)); |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 659 | return I.R != R; |
| 660 | } |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 661 | referenced_vars_iterator &operator++() { |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 662 | ++R; |
Ted Kremenek | 85d87df | 2012-05-04 21:48:42 +0000 | [diff] [blame] | 663 | ++OriginalR; |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 664 | return *this; |
| 665 | } |
| 666 | }; |
Ted Kremenek | 5846720 | 2013-02-05 22:00:19 +0000 | [diff] [blame] | 667 | |
| 668 | /// Return the original region for a captured region, if |
| 669 | /// one exists. |
| 670 | const VarRegion *getOriginalRegion(const VarRegion *VR) const; |
Ted Kremenek | 81cef58 | 2009-12-03 08:09:21 +0000 | [diff] [blame] | 671 | |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 672 | referenced_vars_iterator referenced_vars_begin() const; |
| 673 | referenced_vars_iterator referenced_vars_end() const; |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 674 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 675 | virtual void dumpToStream(raw_ostream &os) const; |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 676 | |
| 677 | void Profile(llvm::FoldingSetNodeID& ID) const; |
| 678 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 679 | static void ProfileRegion(llvm::FoldingSetNodeID&, const BlockTextRegion *, |
| 680 | const LocationContext *, const MemRegion *); |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 681 | |
| 682 | static bool classof(const MemRegion* R) { |
| 683 | return R->getKind() == BlockDataRegionKind; |
| 684 | } |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 685 | private: |
| 686 | void LazyInitializeReferencedVars(); |
Ted Kremenek | 24570c4 | 2012-12-06 07:17:13 +0000 | [diff] [blame] | 687 | std::pair<const VarRegion *, const VarRegion *> |
| 688 | getCaptureRegions(const VarDecl *VD); |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 689 | }; |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 690 | |
Zhongxing Xu | 026c663 | 2009-02-05 06:57:29 +0000 | [diff] [blame] | 691 | /// SymbolicRegion - A special, "non-concrete" region. Unlike other region |
| 692 | /// clases, SymbolicRegion represents a region that serves as an alias for |
| 693 | /// either a real region, a NULL pointer, etc. It essentially is used to |
| 694 | /// map the concept of symbolic values into the domain of regions. Symbolic |
| 695 | /// regions do not need to be typed. |
Ted Kremenek | e8e8648 | 2009-03-30 22:20:54 +0000 | [diff] [blame] | 696 | class SymbolicRegion : public SubRegion { |
Zhongxing Xu | 026c663 | 2009-02-05 06:57:29 +0000 | [diff] [blame] | 697 | protected: |
| 698 | const SymbolRef sym; |
Zhongxing Xu | 026c663 | 2009-02-05 06:57:29 +0000 | [diff] [blame] | 699 | |
| 700 | public: |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 701 | SymbolicRegion(const SymbolRef s, const MemRegion* sreg) |
Ted Kremenek | e8e8648 | 2009-03-30 22:20:54 +0000 | [diff] [blame] | 702 | : SubRegion(sreg, SymbolicRegionKind), sym(s) {} |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 703 | |
Zhongxing Xu | 026c663 | 2009-02-05 06:57:29 +0000 | [diff] [blame] | 704 | SymbolRef getSymbol() const { |
| 705 | return sym; |
| 706 | } |
| 707 | |
Zhongxing Xu | 9852b5b | 2009-07-06 05:34:56 +0000 | [diff] [blame] | 708 | bool isBoundable() const { return true; } |
| 709 | |
Ted Kremenek | c8413fd | 2010-12-02 07:49:45 +0000 | [diff] [blame] | 710 | DefinedOrUnknownSVal getExtent(SValBuilder &svalBuilder) const; |
Jordy Rose | 32f2656 | 2010-07-04 00:00:41 +0000 | [diff] [blame] | 711 | |
Zhongxing Xu | 026c663 | 2009-02-05 06:57:29 +0000 | [diff] [blame] | 712 | void Profile(llvm::FoldingSetNodeID& ID) const; |
| 713 | |
Ted Kremenek | 2501013 | 2009-06-22 23:13:13 +0000 | [diff] [blame] | 714 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, |
| 715 | SymbolRef sym, |
| 716 | const MemRegion* superRegion); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 717 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 718 | void dumpToStream(raw_ostream &os) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 719 | |
Zhongxing Xu | 026c663 | 2009-02-05 06:57:29 +0000 | [diff] [blame] | 720 | static bool classof(const MemRegion* R) { |
| 721 | return R->getKind() == SymbolicRegionKind; |
| 722 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 723 | }; |
Zhongxing Xu | 026c663 | 2009-02-05 06:57:29 +0000 | [diff] [blame] | 724 | |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 725 | /// StringRegion - Region associated with a StringLiteral. |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 726 | class StringRegion : public TypedValueRegion { |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 727 | friend class MemRegionManager; |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 728 | const StringLiteral* Str; |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 729 | protected: |
| 730 | |
Ted Kremenek | 2501013 | 2009-06-22 23:13:13 +0000 | [diff] [blame] | 731 | StringRegion(const StringLiteral* str, const MemRegion* sreg) |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 732 | : TypedValueRegion(sreg, StringRegionKind), Str(str) {} |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 733 | |
| 734 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, |
| 735 | const StringLiteral* Str, |
| 736 | const MemRegion* superRegion); |
| 737 | |
| 738 | public: |
Zhongxing Xu | 6613d08 | 2008-11-24 02:18:56 +0000 | [diff] [blame] | 739 | |
| 740 | const StringLiteral* getStringLiteral() const { return Str; } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 741 | |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 742 | QualType getValueType() const { |
Zhongxing Xu | ff69782 | 2009-05-09 00:50:33 +0000 | [diff] [blame] | 743 | return Str->getType(); |
| 744 | } |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 745 | |
Ted Kremenek | c8413fd | 2010-12-02 07:49:45 +0000 | [diff] [blame] | 746 | DefinedOrUnknownSVal getExtent(SValBuilder &svalBuilder) const; |
Jordy Rose | 32f2656 | 2010-07-04 00:00:41 +0000 | [diff] [blame] | 747 | |
Zhongxing Xu | 0a51f1c | 2009-07-04 11:31:53 +0000 | [diff] [blame] | 748 | bool isBoundable() const { return false; } |
| 749 | |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 750 | void Profile(llvm::FoldingSetNodeID& ID) const { |
| 751 | ProfileRegion(ID, Str, superRegion); |
| 752 | } |
| 753 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 754 | void dumpToStream(raw_ostream &os) const; |
Zhongxing Xu | cc128b3 | 2008-11-10 13:05:26 +0000 | [diff] [blame] | 755 | |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 756 | static bool classof(const MemRegion* R) { |
| 757 | return R->getKind() == StringRegionKind; |
| 758 | } |
| 759 | }; |
Ted Kremenek | 4c62b55 | 2012-02-28 00:56:05 +0000 | [diff] [blame] | 760 | |
| 761 | /// The region associated with an ObjCStringLiteral. |
| 762 | class ObjCStringRegion : public TypedValueRegion { |
| 763 | friend class MemRegionManager; |
| 764 | const ObjCStringLiteral* Str; |
| 765 | protected: |
| 766 | |
| 767 | ObjCStringRegion(const ObjCStringLiteral* str, const MemRegion* sreg) |
| 768 | : TypedValueRegion(sreg, ObjCStringRegionKind), Str(str) {} |
| 769 | |
| 770 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, |
| 771 | const ObjCStringLiteral* Str, |
| 772 | const MemRegion* superRegion); |
| 773 | |
| 774 | public: |
| 775 | |
| 776 | const ObjCStringLiteral* getObjCStringLiteral() const { return Str; } |
| 777 | |
| 778 | QualType getValueType() const { |
| 779 | return Str->getType(); |
| 780 | } |
| 781 | |
| 782 | bool isBoundable() const { return false; } |
| 783 | |
| 784 | void Profile(llvm::FoldingSetNodeID& ID) const { |
| 785 | ProfileRegion(ID, Str, superRegion); |
| 786 | } |
| 787 | |
| 788 | void dumpToStream(raw_ostream &os) const; |
| 789 | |
| 790 | static bool classof(const MemRegion* R) { |
| 791 | return R->getKind() == ObjCStringRegionKind; |
| 792 | } |
| 793 | }; |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 794 | |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 795 | /// CompoundLiteralRegion - A memory region representing a compound literal. |
| 796 | /// Compound literals are essentially temporaries that are stack allocated |
| 797 | /// or in the global constant pool. |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 798 | class CompoundLiteralRegion : public TypedValueRegion { |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 799 | private: |
| 800 | friend class MemRegionManager; |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 801 | const CompoundLiteralExpr *CL; |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 802 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 803 | CompoundLiteralRegion(const CompoundLiteralExpr *cl, const MemRegion* sReg) |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 804 | : TypedValueRegion(sReg, CompoundLiteralRegionKind), CL(cl) {} |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 805 | |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 806 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 807 | const CompoundLiteralExpr *CL, |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 808 | const MemRegion* superRegion); |
| 809 | public: |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 810 | QualType getValueType() const { |
| 811 | return CL->getType(); |
Zhongxing Xu | 77cfac6 | 2008-10-31 06:30:35 +0000 | [diff] [blame] | 812 | } |
Zhongxing Xu | 0a51f1c | 2009-07-04 11:31:53 +0000 | [diff] [blame] | 813 | |
Zhongxing Xu | 9a08fee | 2009-07-04 11:43:03 +0000 | [diff] [blame] | 814 | bool isBoundable() const { return !CL->isFileScope(); } |
| 815 | |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 816 | void Profile(llvm::FoldingSetNodeID& ID) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 817 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 818 | void dumpToStream(raw_ostream &os) const; |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 819 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 820 | const CompoundLiteralExpr *getLiteralExpr() const { return CL; } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 821 | |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 822 | static bool classof(const MemRegion* R) { |
| 823 | return R->getKind() == CompoundLiteralRegionKind; |
| 824 | } |
| 825 | }; |
Zhongxing Xu | 1789275 | 2008-10-08 02:50:44 +0000 | [diff] [blame] | 826 | |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 827 | class DeclRegion : public TypedValueRegion { |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 828 | protected: |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 829 | const Decl *D; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 830 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 831 | DeclRegion(const Decl *d, const MemRegion* sReg, Kind k) |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 832 | : TypedValueRegion(sReg, k), D(d) {} |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 833 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 834 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, const Decl *D, |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 835 | const MemRegion* superRegion, Kind k); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 836 | |
Zhongxing Xu | bfb6582 | 2008-10-24 09:06:51 +0000 | [diff] [blame] | 837 | public: |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 838 | const Decl *getDecl() const { return D; } |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 839 | void Profile(llvm::FoldingSetNodeID& ID) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 840 | |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 841 | static bool classof(const MemRegion* R) { |
| 842 | unsigned k = R->getKind(); |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 843 | return k >= BEG_DECL_REGIONS && k <= END_DECL_REGIONS; |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 844 | } |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 845 | }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 846 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 847 | class VarRegion : public DeclRegion { |
| 848 | friend class MemRegionManager; |
Ted Kremenek | d17da2b | 2009-08-21 22:28:32 +0000 | [diff] [blame] | 849 | |
Ted Kremenek | d17da2b | 2009-08-21 22:28:32 +0000 | [diff] [blame] | 850 | // Constructors and private methods. |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 851 | VarRegion(const VarDecl *vd, const MemRegion* sReg) |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 852 | : DeclRegion(vd, sReg, VarRegionKind) {} |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 853 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 854 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, const VarDecl *VD, |
Ted Kremenek | d17da2b | 2009-08-21 22:28:32 +0000 | [diff] [blame] | 855 | const MemRegion *superRegion) { |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 856 | DeclRegion::ProfileRegion(ID, VD, superRegion, VarRegionKind); |
| 857 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 858 | |
Ted Kremenek | d17da2b | 2009-08-21 22:28:32 +0000 | [diff] [blame] | 859 | void Profile(llvm::FoldingSetNodeID& ID) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 860 | |
| 861 | public: |
Ted Kremenek | d17da2b | 2009-08-21 22:28:32 +0000 | [diff] [blame] | 862 | const VarDecl *getDecl() const { return cast<VarDecl>(D); } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 863 | |
Ted Kremenek | 5348f94 | 2009-12-14 22:15:06 +0000 | [diff] [blame] | 864 | const StackFrameContext *getStackFrame() const; |
| 865 | |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 866 | QualType getValueType() const { |
Ted Kremenek | 6eddeb1 | 2008-12-13 21:49:13 +0000 | [diff] [blame] | 867 | // FIXME: We can cache this if needed. |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 868 | return getDecl()->getType(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 869 | } |
| 870 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 871 | void dumpToStream(raw_ostream &os) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 872 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 873 | static bool classof(const MemRegion* R) { |
| 874 | return R->getKind() == VarRegionKind; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 875 | } |
Anna Zaks | 3d7c44e | 2012-03-21 19:45:08 +0000 | [diff] [blame] | 876 | |
Jordan Rose | 919e8a1 | 2012-08-08 18:23:36 +0000 | [diff] [blame] | 877 | bool canPrintPretty() const; |
| 878 | void printPretty(raw_ostream &os) const; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 879 | }; |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 880 | |
| 881 | /// CXXThisRegion - Represents the region for the implicit 'this' parameter |
| 882 | /// in a call to a C++ method. This region doesn't represent the object |
| 883 | /// referred to by 'this', but rather 'this' itself. |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 884 | class CXXThisRegion : public TypedValueRegion { |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 885 | friend class MemRegionManager; |
| 886 | CXXThisRegion(const PointerType *thisPointerTy, |
| 887 | const MemRegion *sReg) |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 888 | : TypedValueRegion(sReg, CXXThisRegionKind), ThisPointerTy(thisPointerTy) {} |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 889 | |
| 890 | static void ProfileRegion(llvm::FoldingSetNodeID &ID, |
| 891 | const PointerType *PT, |
| 892 | const MemRegion *sReg); |
| 893 | |
| 894 | void Profile(llvm::FoldingSetNodeID &ID) const; |
| 895 | |
| 896 | public: |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 897 | QualType getValueType() const { |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 898 | return QualType(ThisPointerTy, 0); |
| 899 | } |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 900 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 901 | void dumpToStream(raw_ostream &os) const; |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 902 | |
| 903 | static bool classof(const MemRegion* R) { |
| 904 | return R->getKind() == CXXThisRegionKind; |
| 905 | } |
| 906 | |
| 907 | private: |
| 908 | const PointerType *ThisPointerTy; |
| 909 | }; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 910 | |
| 911 | class FieldRegion : public DeclRegion { |
| 912 | friend class MemRegionManager; |
| 913 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 914 | FieldRegion(const FieldDecl *fd, const MemRegion* sReg) |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 915 | : DeclRegion(fd, sReg, FieldRegionKind) {} |
| 916 | |
Ted Kremenek | 4bd1eef | 2008-10-17 21:05:44 +0000 | [diff] [blame] | 917 | public: |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 918 | const FieldDecl *getDecl() const { return cast<FieldDecl>(D); } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 919 | |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 920 | QualType getValueType() const { |
Ted Kremenek | 6eddeb1 | 2008-12-13 21:49:13 +0000 | [diff] [blame] | 921 | // FIXME: We can cache this if needed. |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 922 | return getDecl()->getType(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 923 | } |
Ted Kremenek | 4bd1eef | 2008-10-17 21:05:44 +0000 | [diff] [blame] | 924 | |
Ted Kremenek | c8413fd | 2010-12-02 07:49:45 +0000 | [diff] [blame] | 925 | DefinedOrUnknownSVal getExtent(SValBuilder &svalBuilder) const; |
Jordy Rose | 32f2656 | 2010-07-04 00:00:41 +0000 | [diff] [blame] | 926 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 927 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, const FieldDecl *FD, |
Ted Kremenek | 6304b08 | 2009-06-22 23:34:21 +0000 | [diff] [blame] | 928 | const MemRegion* superRegion) { |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 929 | DeclRegion::ProfileRegion(ID, FD, superRegion, FieldRegionKind); |
| 930 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 931 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 932 | static bool classof(const MemRegion* R) { |
| 933 | return R->getKind() == FieldRegionKind; |
| 934 | } |
Anna Zaks | 3d7c44e | 2012-03-21 19:45:08 +0000 | [diff] [blame] | 935 | |
| 936 | void dumpToStream(raw_ostream &os) const; |
Jordan Rose | 919e8a1 | 2012-08-08 18:23:36 +0000 | [diff] [blame] | 937 | |
| 938 | bool canPrintPretty() const; |
| 939 | void printPretty(raw_ostream &os) const; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 940 | }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 941 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 942 | class ObjCIvarRegion : public DeclRegion { |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 943 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 944 | friend class MemRegionManager; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 945 | |
Benjamin Kramer | c35fb7d | 2012-01-28 12:06:22 +0000 | [diff] [blame] | 946 | ObjCIvarRegion(const ObjCIvarDecl *ivd, const MemRegion* sReg); |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 947 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 948 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCIvarDecl *ivd, |
Benjamin Kramer | c35fb7d | 2012-01-28 12:06:22 +0000 | [diff] [blame] | 949 | const MemRegion* superRegion); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 950 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 951 | public: |
Benjamin Kramer | c35fb7d | 2012-01-28 12:06:22 +0000 | [diff] [blame] | 952 | const ObjCIvarDecl *getDecl() const; |
| 953 | QualType getValueType() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 954 | |
Ted Kremenek | 43b82b8 | 2013-02-24 07:21:01 +0000 | [diff] [blame] | 955 | bool canPrintPretty() const; |
| 956 | void printPretty(raw_ostream &os) const; |
| 957 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 958 | void dumpToStream(raw_ostream &os) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 959 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 960 | static bool classof(const MemRegion* R) { |
| 961 | return R->getKind() == ObjCIvarRegionKind; |
| 962 | } |
| 963 | }; |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 964 | //===----------------------------------------------------------------------===// |
Chris Lattner | fc8f0e1 | 2011-04-15 05:22:18 +0000 | [diff] [blame] | 965 | // Auxiliary data classes for use with MemRegions. |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 966 | //===----------------------------------------------------------------------===// |
| 967 | |
| 968 | class ElementRegion; |
| 969 | |
| 970 | class RegionRawOffset { |
| 971 | private: |
| 972 | friend class ElementRegion; |
| 973 | |
| 974 | const MemRegion *Region; |
Ken Dyck | 9ff2b13 | 2011-01-24 01:55:39 +0000 | [diff] [blame] | 975 | CharUnits Offset; |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 976 | |
Ken Dyck | 9ff2b13 | 2011-01-24 01:55:39 +0000 | [diff] [blame] | 977 | RegionRawOffset(const MemRegion* reg, CharUnits offset = CharUnits::Zero()) |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 978 | : Region(reg), Offset(offset) {} |
| 979 | |
| 980 | public: |
| 981 | // FIXME: Eventually support symbolic offsets. |
Ken Dyck | 9ff2b13 | 2011-01-24 01:55:39 +0000 | [diff] [blame] | 982 | CharUnits getOffset() const { return Offset; } |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 983 | const MemRegion *getRegion() const { return Region; } |
| 984 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 985 | void dumpToStream(raw_ostream &os) const; |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 986 | void dump() const; |
| 987 | }; |
Zhongxing Xu | 511191c | 2008-10-21 05:27:10 +0000 | [diff] [blame] | 988 | |
Anna Zaks | 1437425 | 2012-01-12 02:22:40 +0000 | [diff] [blame] | 989 | /// \brief ElementRegin is used to represent both array elements and casts. |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 990 | class ElementRegion : public TypedValueRegion { |
Zhongxing Xu | 511191c | 2008-10-21 05:27:10 +0000 | [diff] [blame] | 991 | friend class MemRegionManager; |
| 992 | |
Ted Kremenek | f936f45 | 2009-05-04 06:18:28 +0000 | [diff] [blame] | 993 | QualType ElementType; |
Ted Kremenek | 02282ac | 2010-09-15 03:13:30 +0000 | [diff] [blame] | 994 | NonLoc Index; |
Zhongxing Xu | 511191c | 2008-10-21 05:27:10 +0000 | [diff] [blame] | 995 | |
Ted Kremenek | 02282ac | 2010-09-15 03:13:30 +0000 | [diff] [blame] | 996 | ElementRegion(QualType elementType, NonLoc Idx, const MemRegion* sReg) |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 997 | : TypedValueRegion(sReg, ElementRegionKind), |
Ted Kremenek | f936f45 | 2009-05-04 06:18:28 +0000 | [diff] [blame] | 998 | ElementType(elementType), Index(Idx) { |
David Blaikie | 5251abe | 2013-02-20 05:52:05 +0000 | [diff] [blame] | 999 | assert((!Idx.getAs<nonloc::ConcreteInt>() || |
| 1000 | Idx.castAs<nonloc::ConcreteInt>().getValue().isSigned()) && |
Chris Lattner | 43b28d0 | 2008-12-12 07:16:09 +0000 | [diff] [blame] | 1001 | "The index must be signed"); |
Zhongxing Xu | 0395b5d | 2008-11-29 12:05:04 +0000 | [diff] [blame] | 1002 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1003 | |
Ted Kremenek | f936f45 | 2009-05-04 06:18:28 +0000 | [diff] [blame] | 1004 | static void ProfileRegion(llvm::FoldingSetNodeID& ID, QualType elementType, |
| 1005 | SVal Idx, const MemRegion* superRegion); |
Zhongxing Xu | 511191c | 2008-10-21 05:27:10 +0000 | [diff] [blame] | 1006 | |
| 1007 | public: |
| 1008 | |
Ted Kremenek | 02282ac | 2010-09-15 03:13:30 +0000 | [diff] [blame] | 1009 | NonLoc getIndex() const { return Index; } |
Zhongxing Xu | 6e78e1b | 2008-10-23 01:35:34 +0000 | [diff] [blame] | 1010 | |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 1011 | QualType getValueType() const { |
Ted Kremenek | f936f45 | 2009-05-04 06:18:28 +0000 | [diff] [blame] | 1012 | return ElementType; |
| 1013 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1014 | |
Ted Kremenek | f936f45 | 2009-05-04 06:18:28 +0000 | [diff] [blame] | 1015 | QualType getElementType() const { |
| 1016 | return ElementType; |
Ted Kremenek | abb042f | 2008-12-13 19:24:37 +0000 | [diff] [blame] | 1017 | } |
Zhongxing Xu | 7caf9b3 | 2010-08-02 04:56:14 +0000 | [diff] [blame] | 1018 | /// Compute the offset within the array. The array might also be a subobject. |
| 1019 | RegionRawOffset getAsArrayOffset() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1020 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1021 | void dumpToStream(raw_ostream &os) const; |
Zhongxing Xu | b21ff77 | 2008-10-24 06:30:07 +0000 | [diff] [blame] | 1022 | |
Zhongxing Xu | 511191c | 2008-10-21 05:27:10 +0000 | [diff] [blame] | 1023 | void Profile(llvm::FoldingSetNodeID& ID) const; |
| 1024 | |
| 1025 | static bool classof(const MemRegion* R) { |
| 1026 | return R->getKind() == ElementRegionKind; |
| 1027 | } |
| 1028 | }; |
Ted Kremenek | 19e1f0b | 2009-08-01 06:17:29 +0000 | [diff] [blame] | 1029 | |
Zhongxing Xu | bc37b8d | 2010-01-09 09:16:47 +0000 | [diff] [blame] | 1030 | // C++ temporary object associated with an expression. |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 1031 | class CXXTempObjectRegion : public TypedValueRegion { |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1032 | friend class MemRegionManager; |
| 1033 | |
Zhongxing Xu | bc37b8d | 2010-01-09 09:16:47 +0000 | [diff] [blame] | 1034 | Expr const *Ex; |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1035 | |
Zhongxing Xu | 02fe28c | 2010-11-26 08:52:48 +0000 | [diff] [blame] | 1036 | CXXTempObjectRegion(Expr const *E, MemRegion const *sReg) |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 1037 | : TypedValueRegion(sReg, CXXTempObjectRegionKind), Ex(E) {} |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1038 | |
| 1039 | static void ProfileRegion(llvm::FoldingSetNodeID &ID, |
Zhongxing Xu | bc37b8d | 2010-01-09 09:16:47 +0000 | [diff] [blame] | 1040 | Expr const *E, const MemRegion *sReg); |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1041 | |
| 1042 | public: |
Jeffrey Yasskin | 782f63e | 2011-08-26 00:41:31 +0000 | [diff] [blame] | 1043 | const Expr *getExpr() const { return Ex; } |
| 1044 | |
Zhongxing Xu | 018220c | 2010-08-11 06:10:55 +0000 | [diff] [blame] | 1045 | QualType getValueType() const { |
Zhongxing Xu | bc37b8d | 2010-01-09 09:16:47 +0000 | [diff] [blame] | 1046 | return Ex->getType(); |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1047 | } |
| 1048 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1049 | void dumpToStream(raw_ostream &os) const; |
Zhongxing Xu | e1aeb13 | 2010-11-25 02:07:24 +0000 | [diff] [blame] | 1050 | |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1051 | void Profile(llvm::FoldingSetNodeID &ID) const; |
| 1052 | |
| 1053 | static bool classof(const MemRegion* R) { |
Zhongxing Xu | 02fe28c | 2010-11-26 08:52:48 +0000 | [diff] [blame] | 1054 | return R->getKind() == CXXTempObjectRegionKind; |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1055 | } |
| 1056 | }; |
| 1057 | |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1058 | // CXXBaseObjectRegion represents a base object within a C++ object. It is |
| 1059 | // identified by the base class declaration and the region of its parent object. |
Ted Kremenek | 9697934 | 2011-08-12 20:02:48 +0000 | [diff] [blame] | 1060 | class CXXBaseObjectRegion : public TypedValueRegion { |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1061 | friend class MemRegionManager; |
| 1062 | |
Jordan Rose | 4411b42 | 2013-02-21 03:12:32 +0000 | [diff] [blame] | 1063 | llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> Data; |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1064 | |
Jordan Rose | 4411b42 | 2013-02-21 03:12:32 +0000 | [diff] [blame] | 1065 | CXXBaseObjectRegion(const CXXRecordDecl *RD, bool IsVirtual, |
| 1066 | const MemRegion *SReg) |
| 1067 | : TypedValueRegion(SReg, CXXBaseObjectRegionKind), Data(RD, IsVirtual) {} |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1068 | |
Jordan Rose | 4411b42 | 2013-02-21 03:12:32 +0000 | [diff] [blame] | 1069 | static void ProfileRegion(llvm::FoldingSetNodeID &ID, const CXXRecordDecl *RD, |
| 1070 | bool IsVirtual, const MemRegion *SReg); |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1071 | |
| 1072 | public: |
Jordan Rose | 4411b42 | 2013-02-21 03:12:32 +0000 | [diff] [blame] | 1073 | const CXXRecordDecl *getDecl() const { return Data.getPointer(); } |
| 1074 | bool isVirtual() const { return Data.getInt(); } |
Zhongxing Xu | d074441 | 2011-01-13 12:30:12 +0000 | [diff] [blame] | 1075 | |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1076 | QualType getValueType() const; |
| 1077 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1078 | void dumpToStream(raw_ostream &os) const; |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1079 | |
| 1080 | void Profile(llvm::FoldingSetNodeID &ID) const; |
| 1081 | |
| 1082 | static bool classof(const MemRegion *region) { |
| 1083 | return region->getKind() == CXXBaseObjectRegionKind; |
| 1084 | } |
| 1085 | }; |
| 1086 | |
Ted Kremenek | ed65d3d | 2009-03-09 20:28:08 +0000 | [diff] [blame] | 1087 | template<typename RegionTy> |
| 1088 | const RegionTy* MemRegion::getAs() const { |
Ted Kremenek | f7a0cf4 | 2009-07-29 21:43:22 +0000 | [diff] [blame] | 1089 | if (const RegionTy* RT = dyn_cast<RegionTy>(this)) |
| 1090 | return RT; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1091 | |
Ted Kremenek | f7a0cf4 | 2009-07-29 21:43:22 +0000 | [diff] [blame] | 1092 | return NULL; |
Ted Kremenek | ed65d3d | 2009-03-09 20:28:08 +0000 | [diff] [blame] | 1093 | } |
Zhongxing Xu | 511191c | 2008-10-21 05:27:10 +0000 | [diff] [blame] | 1094 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1095 | //===----------------------------------------------------------------------===// |
| 1096 | // MemRegionManager - Factory object for creating regions. |
| 1097 | //===----------------------------------------------------------------------===// |
| 1098 | |
| 1099 | class MemRegionManager { |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 1100 | ASTContext &C; |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1101 | llvm::BumpPtrAllocator& A; |
| 1102 | llvm::FoldingSet<MemRegion> Regions; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1103 | |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 1104 | GlobalInternalSpaceRegion *InternalGlobals; |
| 1105 | GlobalSystemSpaceRegion *SystemGlobals; |
| 1106 | GlobalImmutableSpaceRegion *ImmutableGlobals; |
| 1107 | |
Ted Kremenek | 2b87ae4 | 2009-12-11 06:43:27 +0000 | [diff] [blame] | 1108 | |
Zhongxing Xu | c30470d | 2010-02-17 08:46:50 +0000 | [diff] [blame] | 1109 | llvm::DenseMap<const StackFrameContext *, StackLocalsSpaceRegion *> |
| 1110 | StackLocalsSpaceRegions; |
| 1111 | llvm::DenseMap<const StackFrameContext *, StackArgumentsSpaceRegion *> |
| 1112 | StackArgumentsSpaceRegions; |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 1113 | llvm::DenseMap<const CodeTextRegion *, StaticGlobalSpaceRegion *> |
| 1114 | StaticsGlobalSpaceRegions; |
Ted Kremenek | 2b87ae4 | 2009-12-11 06:43:27 +0000 | [diff] [blame] | 1115 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1116 | HeapSpaceRegion *heap; |
Ted Kremenek | 2b87ae4 | 2009-12-11 06:43:27 +0000 | [diff] [blame] | 1117 | UnknownSpaceRegion *unknown; |
Ted Kremenek | d05552a | 2009-07-02 18:14:59 +0000 | [diff] [blame] | 1118 | MemSpaceRegion *code; |
Zhongxing Xu | dc0a25d | 2008-11-16 04:07:26 +0000 | [diff] [blame] | 1119 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1120 | public: |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 1121 | MemRegionManager(ASTContext &c, llvm::BumpPtrAllocator& a) |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 1122 | : C(c), A(a), InternalGlobals(0), SystemGlobals(0), ImmutableGlobals(0), |
| 1123 | heap(0), unknown(0), code(0) {} |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1124 | |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 1125 | ~MemRegionManager(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1126 | |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 1127 | ASTContext &getContext() { return C; } |
Ted Kremenek | 4240096 | 2009-11-26 02:34:36 +0000 | [diff] [blame] | 1128 | |
| 1129 | llvm::BumpPtrAllocator &getAllocator() { return A; } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1130 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1131 | /// getStackLocalsRegion - Retrieve the memory region associated with the |
| 1132 | /// specified stack frame. |
| 1133 | const StackLocalsSpaceRegion * |
| 1134 | getStackLocalsRegion(const StackFrameContext *STC); |
Ted Kremenek | d05552a | 2009-07-02 18:14:59 +0000 | [diff] [blame] | 1135 | |
| 1136 | /// getStackArgumentsRegion - Retrieve the memory region associated with |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1137 | /// function/method arguments of the specified stack frame. |
| 1138 | const StackArgumentsSpaceRegion * |
| 1139 | getStackArgumentsRegion(const StackFrameContext *STC); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1140 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1141 | /// getGlobalsRegion - Retrieve the memory region associated with |
Ted Kremenek | dcee3ce | 2010-07-01 20:16:50 +0000 | [diff] [blame] | 1142 | /// global variables. |
Anna Zaks | eb31a76 | 2012-01-04 23:54:01 +0000 | [diff] [blame] | 1143 | const GlobalsSpaceRegion *getGlobalsRegion( |
| 1144 | MemRegion::Kind K = MemRegion::GlobalInternalSpaceRegionKind, |
| 1145 | const CodeTextRegion *R = 0); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1146 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1147 | /// getHeapRegion - Retrieve the memory region associated with the |
| 1148 | /// generic "heap". |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1149 | const HeapSpaceRegion *getHeapRegion(); |
Zhongxing Xu | 1789275 | 2008-10-08 02:50:44 +0000 | [diff] [blame] | 1150 | |
| 1151 | /// getUnknownRegion - Retrieve the memory region associated with unknown |
| 1152 | /// memory space. |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1153 | const MemSpaceRegion *getUnknownRegion(); |
Zhongxing Xu | c540b26 | 2008-10-28 05:15:23 +0000 | [diff] [blame] | 1154 | |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1155 | const MemSpaceRegion *getCodeRegion(); |
Zhongxing Xu | ec13d92 | 2009-04-10 08:45:10 +0000 | [diff] [blame] | 1156 | |
Ted Kremenek | 7090ae1 | 2008-11-02 00:34:33 +0000 | [diff] [blame] | 1157 | /// getAllocaRegion - Retrieve a region associated with a call to alloca(). |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1158 | const AllocaRegion *getAllocaRegion(const Expr *Ex, unsigned Cnt, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1159 | const LocationContext *LC); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1160 | |
Ted Kremenek | 329d6fd | 2008-10-27 20:57:58 +0000 | [diff] [blame] | 1161 | /// getCompoundLiteralRegion - Retrieve the region associated with a |
| 1162 | /// given CompoundLiteral. |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1163 | const CompoundLiteralRegion* |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1164 | getCompoundLiteralRegion(const CompoundLiteralExpr *CL, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1165 | const LocationContext *LC); |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 1166 | |
Chris Lattner | fc8f0e1 | 2011-04-15 05:22:18 +0000 | [diff] [blame] | 1167 | /// getCXXThisRegion - Retrieve the [artificial] region associated with the |
Ted Kremenek | de0d263 | 2010-01-05 02:18:06 +0000 | [diff] [blame] | 1168 | /// parameter 'this'. |
| 1169 | const CXXThisRegion *getCXXThisRegion(QualType thisPointerTy, |
| 1170 | const LocationContext *LC); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1171 | |
Anna Zaks | e17fdb2 | 2012-06-07 03:57:32 +0000 | [diff] [blame] | 1172 | /// \brief Retrieve or create a "symbolic" memory region. |
| 1173 | const SymbolicRegion* getSymbolicRegion(SymbolRef Sym); |
| 1174 | |
| 1175 | /// \brief Return a unique symbolic region belonging to heap memory space. |
| 1176 | const SymbolicRegion *getSymbolicHeapRegion(SymbolRef sym); |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 1177 | |
Ted Kremenek | 4c62b55 | 2012-02-28 00:56:05 +0000 | [diff] [blame] | 1178 | const StringRegion *getStringRegion(const StringLiteral* Str); |
| 1179 | |
| 1180 | const ObjCStringRegion *getObjCStringRegion(const ObjCStringLiteral *Str); |
Zhongxing Xu | e9f4e54 | 2008-10-25 14:13:41 +0000 | [diff] [blame] | 1181 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1182 | /// getVarRegion - Retrieve or create the memory region associated with |
Ted Kremenek | d17da2b | 2009-08-21 22:28:32 +0000 | [diff] [blame] | 1183 | /// a specified VarDecl and LocationContext. |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1184 | const VarRegion* getVarRegion(const VarDecl *D, const LocationContext *LC); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1185 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1186 | /// getVarRegion - Retrieve or create the memory region associated with |
| 1187 | /// a specified VarDecl and super region. |
| 1188 | const VarRegion* getVarRegion(const VarDecl *D, const MemRegion *superR); |
| 1189 | |
Ted Kremenek | f936f45 | 2009-05-04 06:18:28 +0000 | [diff] [blame] | 1190 | /// getElementRegion - Retrieve the memory region associated with the |
| 1191 | /// associated element type, index, and super region. |
Ted Kremenek | 02282ac | 2010-09-15 03:13:30 +0000 | [diff] [blame] | 1192 | const ElementRegion *getElementRegion(QualType elementType, NonLoc Idx, |
Zhongxing Xu | 856c6bc | 2010-04-19 11:47:28 +0000 | [diff] [blame] | 1193 | const MemRegion *superRegion, |
| 1194 | ASTContext &Ctx); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1195 | |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1196 | const ElementRegion *getElementRegionWithSuper(const ElementRegion *ER, |
Zhongxing Xu | 856c6bc | 2010-04-19 11:47:28 +0000 | [diff] [blame] | 1197 | const MemRegion *superRegion) { |
Ted Kremenek | a5e81f1 | 2009-08-06 01:20:57 +0000 | [diff] [blame] | 1198 | return getElementRegion(ER->getElementType(), ER->getIndex(), |
| 1199 | superRegion, ER->getContext()); |
| 1200 | } |
Zhongxing Xu | 511191c | 2008-10-21 05:27:10 +0000 | [diff] [blame] | 1201 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1202 | /// getFieldRegion - Retrieve or create the memory region associated with |
| 1203 | /// a specified FieldDecl. 'superRegion' corresponds to the containing |
| 1204 | /// memory region (which typically represents the memory representing |
| 1205 | /// a structure or class). |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1206 | const FieldRegion *getFieldRegion(const FieldDecl *fd, |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1207 | const MemRegion* superRegion); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1208 | |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1209 | const FieldRegion *getFieldRegionWithSuper(const FieldRegion *FR, |
| 1210 | const MemRegion *superRegion) { |
Ted Kremenek | a5e81f1 | 2009-08-06 01:20:57 +0000 | [diff] [blame] | 1211 | return getFieldRegion(FR->getDecl(), superRegion); |
| 1212 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1213 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1214 | /// getObjCIvarRegion - Retrieve or create the memory region associated with |
| 1215 | /// a specified Objective-c instance variable. 'superRegion' corresponds |
| 1216 | /// to the containing region (which typically represents the Objective-C |
| 1217 | /// object). |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1218 | const ObjCIvarRegion *getObjCIvarRegion(const ObjCIvarDecl *ivd, |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1219 | const MemRegion* superRegion); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1220 | |
Zhongxing Xu | 02fe28c | 2010-11-26 08:52:48 +0000 | [diff] [blame] | 1221 | const CXXTempObjectRegion *getCXXTempObjectRegion(Expr const *Ex, |
| 1222 | LocationContext const *LC); |
Zhongxing Xu | bb14121 | 2009-12-16 11:27:52 +0000 | [diff] [blame] | 1223 | |
Jordan Rose | 4411b42 | 2013-02-21 03:12:32 +0000 | [diff] [blame] | 1224 | /// Create a CXXBaseObjectRegion with the given base class for region |
| 1225 | /// \p Super. |
| 1226 | /// |
| 1227 | /// The type of \p Super is assumed be a class deriving from \p BaseClass. |
| 1228 | const CXXBaseObjectRegion * |
| 1229 | getCXXBaseObjectRegion(const CXXRecordDecl *BaseClass, const MemRegion *Super, |
| 1230 | bool IsVirtual); |
Zhongxing Xu | 4fd5681 | 2010-11-26 08:21:53 +0000 | [diff] [blame] | 1231 | |
Zhongxing Xu | d074441 | 2011-01-13 12:30:12 +0000 | [diff] [blame] | 1232 | /// Create a CXXBaseObjectRegion with the same CXXRecordDecl but a different |
| 1233 | /// super region. |
| 1234 | const CXXBaseObjectRegion * |
| 1235 | getCXXBaseObjectRegionWithSuper(const CXXBaseObjectRegion *baseReg, |
| 1236 | const MemRegion *superRegion) { |
Jordan Rose | 4411b42 | 2013-02-21 03:12:32 +0000 | [diff] [blame] | 1237 | return getCXXBaseObjectRegion(baseReg->getDecl(), superRegion, |
| 1238 | baseReg->isVirtual()); |
Zhongxing Xu | d074441 | 2011-01-13 12:30:12 +0000 | [diff] [blame] | 1239 | } |
| 1240 | |
Anna Zaks | 5fc1d0c | 2012-09-17 19:13:56 +0000 | [diff] [blame] | 1241 | const FunctionTextRegion *getFunctionTextRegion(const NamedDecl *FD); |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1242 | const BlockTextRegion *getBlockTextRegion(const BlockDecl *BD, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1243 | CanQualType locTy, |
Ted Kremenek | 1d26f48 | 2011-10-24 01:32:45 +0000 | [diff] [blame] | 1244 | AnalysisDeclContext *AC); |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1245 | |
| 1246 | /// getBlockDataRegion - Get the memory region associated with an instance |
| 1247 | /// of a block. Unlike many other MemRegions, the LocationContext* |
| 1248 | /// argument is allowed to be NULL for cases where we have no known |
| 1249 | /// context. |
Ted Kremenek | b48ad64 | 2009-12-04 00:26:31 +0000 | [diff] [blame] | 1250 | const BlockDataRegion *getBlockDataRegion(const BlockTextRegion *bc, |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1251 | const LocationContext *lc = NULL); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1252 | |
Ted Kremenek | bcd7f9f | 2009-12-04 00:05:57 +0000 | [diff] [blame] | 1253 | private: |
Ted Kremenek | 2501013 | 2009-06-22 23:13:13 +0000 | [diff] [blame] | 1254 | template <typename RegionTy, typename A1> |
| 1255 | RegionTy* getRegion(const A1 a1); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1256 | |
Ted Kremenek | 6304b08 | 2009-06-22 23:34:21 +0000 | [diff] [blame] | 1257 | template <typename RegionTy, typename A1> |
Ted Kremenek | eeea456 | 2009-07-10 16:51:45 +0000 | [diff] [blame] | 1258 | RegionTy* getSubRegion(const A1 a1, const MemRegion* superRegion); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1259 | |
Ted Kremenek | 7ae7ad9 | 2009-06-23 00:15:41 +0000 | [diff] [blame] | 1260 | template <typename RegionTy, typename A1, typename A2> |
| 1261 | RegionTy* getRegion(const A1 a1, const A2 a2); |
Zhongxing Xu | dc0a25d | 2008-11-16 04:07:26 +0000 | [diff] [blame] | 1262 | |
Ted Kremenek | 0a8112a | 2009-11-25 23:53:07 +0000 | [diff] [blame] | 1263 | template <typename RegionTy, typename A1, typename A2> |
| 1264 | RegionTy* getSubRegion(const A1 a1, const A2 a2, |
| 1265 | const MemRegion* superRegion); |
| 1266 | |
Ted Kremenek | 67d1287 | 2009-12-07 22:05:27 +0000 | [diff] [blame] | 1267 | template <typename RegionTy, typename A1, typename A2, typename A3> |
| 1268 | RegionTy* getSubRegion(const A1 a1, const A2 a2, const A3 a3, |
| 1269 | const MemRegion* superRegion); |
| 1270 | |
| 1271 | template <typename REG> |
| 1272 | const REG* LazyAllocate(REG*& region); |
| 1273 | |
| 1274 | template <typename REG, typename ARG> |
| 1275 | const REG* LazyAllocate(REG*& region, ARG a); |
Ted Kremenek | ed65d3d | 2009-03-09 20:28:08 +0000 | [diff] [blame] | 1276 | }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1277 | |
Ted Kremenek | 2501013 | 2009-06-22 23:13:13 +0000 | [diff] [blame] | 1278 | //===----------------------------------------------------------------------===// |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 1279 | // Out-of-line member definitions. |
Ted Kremenek | 2501013 | 2009-06-22 23:13:13 +0000 | [diff] [blame] | 1280 | //===----------------------------------------------------------------------===// |
| 1281 | |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1282 | inline ASTContext &MemRegion::getContext() const { |
Ted Kremenek | a43484a | 2009-06-23 00:46:41 +0000 | [diff] [blame] | 1283 | return getMemRegionManager()->getContext(); |
| 1284 | } |
Ted Kremenek | eb1c7a0 | 2009-11-25 01:32:22 +0000 | [diff] [blame] | 1285 | |
Argyrios Kyrtzidis | 5a4f98f | 2010-12-22 18:53:20 +0000 | [diff] [blame] | 1286 | } // end GR namespace |
| 1287 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1288 | } // end clang namespace |
Ted Kremenek | be91224 | 2009-03-05 16:31:07 +0000 | [diff] [blame] | 1289 | |
Ted Kremenek | 2501013 | 2009-06-22 23:13:13 +0000 | [diff] [blame] | 1290 | //===----------------------------------------------------------------------===// |
| 1291 | // Pretty-printing regions. |
| 1292 | //===----------------------------------------------------------------------===// |
| 1293 | |
Ted Kremenek | be91224 | 2009-03-05 16:31:07 +0000 | [diff] [blame] | 1294 | namespace llvm { |
Ted Kremenek | 9c378f7 | 2011-08-12 23:37:29 +0000 | [diff] [blame] | 1295 | static inline raw_ostream &operator<<(raw_ostream &os, |
Ted Kremenek | 9ef6537 | 2010-12-23 07:20:52 +0000 | [diff] [blame] | 1296 | const clang::ento::MemRegion* R) { |
Ted Kremenek | 8800ad4 | 2009-07-13 23:31:04 +0000 | [diff] [blame] | 1297 | R->dumpToStream(os); |
| 1298 | return os; |
Ted Kremenek | be91224 | 2009-03-05 16:31:07 +0000 | [diff] [blame] | 1299 | } |
| 1300 | } // end llvm namespace |
| 1301 | |
Ted Kremenek | 9e24049 | 2008-10-04 05:50:14 +0000 | [diff] [blame] | 1302 | #endif |