Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 1 | //===-- CGValue.h - LLVM CodeGen wrappers for llvm::Value* ------*- 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 | // These classes implement wrappers around llvm::Value in order to |
| 11 | // fully represent the range of values for C L- and R- values. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 15 | #ifndef LLVM_CLANG_LIB_CODEGEN_CGVALUE_H |
| 16 | #define LLVM_CLANG_LIB_CODEGEN_CGVALUE_H |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 17 | |
Daniel Dunbar | 5cf8bfe | 2010-08-21 02:53:44 +0000 | [diff] [blame] | 18 | #include "clang/AST/ASTContext.h" |
Eli Friedman | d7722d9 | 2011-12-03 02:13:40 +0000 | [diff] [blame] | 19 | #include "clang/AST/CharUnits.h" |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 20 | #include "clang/AST/Type.h" |
John McCall | 9d232c8 | 2013-03-07 21:37:08 +0000 | [diff] [blame] | 21 | #include "llvm/IR/Value.h" |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 22 | |
Daniel Dunbar | 46f45b9 | 2008-09-09 01:06:48 +0000 | [diff] [blame] | 23 | namespace llvm { |
| 24 | class Constant; |
John McCall | 9d232c8 | 2013-03-07 21:37:08 +0000 | [diff] [blame] | 25 | class MDNode; |
Daniel Dunbar | 46f45b9 | 2008-09-09 01:06:48 +0000 | [diff] [blame] | 26 | } |
| 27 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 28 | namespace clang { |
| 29 | namespace CodeGen { |
John McCall | 4b9c2d2 | 2011-11-06 09:01:30 +0000 | [diff] [blame] | 30 | class AggValueSlot; |
Chandler Carruth | 72d2dab | 2012-12-06 11:14:44 +0000 | [diff] [blame] | 31 | struct CGBitFieldInfo; |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 32 | |
| 33 | /// RValue - This trivial value class is used to represent the result of an |
| 34 | /// expression that is evaluated. It can be one of three things: either a |
| 35 | /// simple LLVM SSA value, a pair of SSA values for complex numbers, or the |
| 36 | /// address of an aggregate value in memory. |
| 37 | class RValue { |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 38 | enum Flavor { Scalar, Complex, Aggregate }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 39 | |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 40 | // Stores first value and flavor. |
| 41 | llvm::PointerIntPair<llvm::Value *, 2, Flavor> V1; |
| 42 | // Stores second value and volatility. |
| 43 | llvm::PointerIntPair<llvm::Value *, 1, bool> V2; |
| 44 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 45 | public: |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 46 | bool isScalar() const { return V1.getInt() == Scalar; } |
| 47 | bool isComplex() const { return V1.getInt() == Complex; } |
| 48 | bool isAggregate() const { return V1.getInt() == Aggregate; } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 49 | |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 50 | bool isVolatileQualified() const { return V2.getInt(); } |
Mike Stump | 8b3d93a | 2009-05-23 20:21:36 +0000 | [diff] [blame] | 51 | |
Mike Stump | 519202d | 2009-11-03 16:11:57 +0000 | [diff] [blame] | 52 | /// getScalarVal() - Return the Value* of this scalar value. |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 53 | llvm::Value *getScalarVal() const { |
| 54 | assert(isScalar() && "Not a scalar!"); |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 55 | return V1.getPointer(); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | /// getComplexVal - Return the real/imag components of this complex value. |
| 59 | /// |
| 60 | std::pair<llvm::Value *, llvm::Value *> getComplexVal() const { |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 61 | return std::make_pair(V1.getPointer(), V2.getPointer()); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 62 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 63 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 64 | /// getAggregateAddr() - Return the Value* of the address of the aggregate. |
| 65 | llvm::Value *getAggregateAddr() const { |
| 66 | assert(isAggregate() && "Not an aggregate!"); |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 67 | return V1.getPointer(); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 68 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 69 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 70 | static RValue get(llvm::Value *V) { |
| 71 | RValue ER; |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 72 | ER.V1.setPointer(V); |
| 73 | ER.V1.setInt(Scalar); |
| 74 | ER.V2.setInt(false); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 75 | return ER; |
| 76 | } |
| 77 | static RValue getComplex(llvm::Value *V1, llvm::Value *V2) { |
| 78 | RValue ER; |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 79 | ER.V1.setPointer(V1); |
| 80 | ER.V2.setPointer(V2); |
| 81 | ER.V1.setInt(Complex); |
| 82 | ER.V2.setInt(false); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 83 | return ER; |
| 84 | } |
| 85 | static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) { |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 86 | return getComplex(C.first, C.second); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 87 | } |
Mike Stump | 8b3d93a | 2009-05-23 20:21:36 +0000 | [diff] [blame] | 88 | // FIXME: Aggregate rvalues need to retain information about whether they are |
| 89 | // volatile or not. Remove default to find all places that probably get this |
| 90 | // wrong. |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 91 | static RValue getAggregate(llvm::Value *V, bool Volatile = false) { |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 92 | RValue ER; |
Benjamin Kramer | 81bf3b3 | 2010-05-02 14:59:10 +0000 | [diff] [blame] | 93 | ER.V1.setPointer(V); |
| 94 | ER.V1.setInt(Aggregate); |
| 95 | ER.V2.setInt(Volatile); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 96 | return ER; |
| 97 | } |
| 98 | }; |
| 99 | |
John McCall | 5b07e80 | 2013-03-13 03:10:54 +0000 | [diff] [blame] | 100 | /// Does an ARC strong l-value have precise lifetime? |
| 101 | enum ARCPreciseLifetime_t { |
John McCall | 99c6418 | 2013-03-13 05:02:21 +0000 | [diff] [blame] | 102 | ARCImpreciseLifetime, ARCPreciseLifetime |
John McCall | 5b07e80 | 2013-03-13 03:10:54 +0000 | [diff] [blame] | 103 | }; |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 104 | |
| 105 | /// LValue - This represents an lvalue references. Because C/C++ allow |
| 106 | /// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a |
| 107 | /// bitrange. |
| 108 | class LValue { |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 109 | enum { |
| 110 | Simple, // This is a normal l-value, use getAddress(). |
| 111 | VectorElt, // This is a vector element l-value (V[i]), use getVector* |
| 112 | BitField, // This is a bitfield l-value, use getBitfield*. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 113 | ExtVectorElt, // This is an extended vector subset, use getExtVectorComp |
| 114 | GlobalReg // This is a register l-value, use getGlobalReg() |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 115 | } LVType; |
Fariborz Jahanian | 5862650 | 2008-11-19 00:59:10 +0000 | [diff] [blame] | 116 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 117 | llvm::Value *V; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 118 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 119 | union { |
| 120 | // Index into a vector subscript: V[i] |
| 121 | llvm::Value *VectorIdx; |
| 122 | |
| 123 | // ExtVector element subset: V.xyx |
| 124 | llvm::Constant *VectorElts; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 125 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 126 | // BitField start bit and size |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 127 | const CGBitFieldInfo *BitFieldInfo; |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 128 | }; |
| 129 | |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 130 | QualType Type; |
| 131 | |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 132 | // 'const' is unused here |
| 133 | Qualifiers Quals; |
Fariborz Jahanian | 5862650 | 2008-11-19 00:59:10 +0000 | [diff] [blame] | 134 | |
Eli Friedman | e5a8aeb | 2012-03-22 22:36:39 +0000 | [diff] [blame] | 135 | // The alignment to use when accessing this lvalue. (For vector elements, |
| 136 | // this is the alignment of the whole vector.) |
John Criswell | 9e4abb4 | 2012-08-15 18:40:30 +0000 | [diff] [blame] | 137 | int64_t Alignment; |
Daniel Dunbar | 9f4f7cf | 2010-08-21 02:39:23 +0000 | [diff] [blame] | 138 | |
Fariborz Jahanian | d1cc804 | 2008-11-20 20:53:20 +0000 | [diff] [blame] | 139 | // objective-c's ivar |
| 140 | bool Ivar:1; |
Fariborz Jahanian | 1c1afc4 | 2009-09-18 00:04:00 +0000 | [diff] [blame] | 141 | |
| 142 | // objective-c's ivar is an array |
Fariborz Jahanian | fd02ed7 | 2009-09-21 18:54:29 +0000 | [diff] [blame] | 143 | bool ObjIsArray:1; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 144 | |
Fariborz Jahanian | 4f676ed | 2009-02-21 00:30:43 +0000 | [diff] [blame] | 145 | // LValue is non-gc'able for any reason, including being a parameter or local |
| 146 | // variable. |
| 147 | bool NonGC: 1; |
Fariborz Jahanian | d1cc804 | 2008-11-20 20:53:20 +0000 | [diff] [blame] | 148 | |
Fariborz Jahanian | bf63b87 | 2009-05-04 23:27:20 +0000 | [diff] [blame] | 149 | // Lvalue is a global reference of an objective-c object |
| 150 | bool GlobalObjCRef : 1; |
Fariborz Jahanian | 021a7a6 | 2010-07-20 20:30:03 +0000 | [diff] [blame] | 151 | |
| 152 | // Lvalue is a thread local reference |
| 153 | bool ThreadLocalRef : 1; |
Fariborz Jahanian | bf63b87 | 2009-05-04 23:27:20 +0000 | [diff] [blame] | 154 | |
John McCall | 5b07e80 | 2013-03-13 03:10:54 +0000 | [diff] [blame] | 155 | // Lvalue has ARC imprecise lifetime. We store this inverted to try |
| 156 | // to make the default bitfield pattern all-zeroes. |
| 157 | bool ImpreciseLifetime : 1; |
| 158 | |
Fariborz Jahanian | 6c7a1f3 | 2009-09-24 22:25:38 +0000 | [diff] [blame] | 159 | Expr *BaseIvarExp; |
Dan Gohman | 3d5aff5 | 2010-10-14 23:06:10 +0000 | [diff] [blame] | 160 | |
Manman Ren | b37a73d | 2013-04-04 21:53:22 +0000 | [diff] [blame] | 161 | /// Used by struct-path-aware TBAA. |
| 162 | QualType TBAABaseType; |
| 163 | /// Offset relative to the base type. |
| 164 | uint64_t TBAAOffset; |
| 165 | |
Dan Gohman | 3d5aff5 | 2010-10-14 23:06:10 +0000 | [diff] [blame] | 166 | /// TBAAInfo - TBAA information to attach to dereferences of this LValue. |
| 167 | llvm::MDNode *TBAAInfo; |
| 168 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 169 | private: |
Eli Friedman | 6da2c71 | 2011-12-03 04:14:32 +0000 | [diff] [blame] | 170 | void Initialize(QualType Type, Qualifiers Quals, |
Eli Friedman | f4bcfa1 | 2012-06-27 21:19:48 +0000 | [diff] [blame] | 171 | CharUnits Alignment, |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 172 | llvm::MDNode *TBAAInfo = nullptr) { |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 173 | this->Type = Type; |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 174 | this->Quals = Quals; |
Eli Friedman | 6da2c71 | 2011-12-03 04:14:32 +0000 | [diff] [blame] | 175 | this->Alignment = Alignment.getQuantity(); |
| 176 | assert(this->Alignment == Alignment.getQuantity() && |
| 177 | "Alignment exceeds allowed max!"); |
Daniel Dunbar | 9f4f7cf | 2010-08-21 02:39:23 +0000 | [diff] [blame] | 178 | |
| 179 | // Initialize Objective-C flags. |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 180 | this->Ivar = this->ObjIsArray = this->NonGC = this->GlobalObjCRef = false; |
John McCall | 5b07e80 | 2013-03-13 03:10:54 +0000 | [diff] [blame] | 181 | this->ImpreciseLifetime = false; |
Fariborz Jahanian | 021a7a6 | 2010-07-20 20:30:03 +0000 | [diff] [blame] | 182 | this->ThreadLocalRef = false; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 183 | this->BaseIvarExp = nullptr; |
Manman Ren | b37a73d | 2013-04-04 21:53:22 +0000 | [diff] [blame] | 184 | |
| 185 | // Initialize fields for TBAA. |
| 186 | this->TBAABaseType = Type; |
| 187 | this->TBAAOffset = 0; |
Dan Gohman | 3d5aff5 | 2010-10-14 23:06:10 +0000 | [diff] [blame] | 188 | this->TBAAInfo = TBAAInfo; |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 189 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 190 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 191 | public: |
| 192 | bool isSimple() const { return LVType == Simple; } |
| 193 | bool isVectorElt() const { return LVType == VectorElt; } |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 194 | bool isBitField() const { return LVType == BitField; } |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 195 | bool isExtVectorElt() const { return LVType == ExtVectorElt; } |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 196 | bool isGlobalReg() const { return LVType == GlobalReg; } |
Daniel Dunbar | 85c59ed | 2008-08-29 08:11:39 +0000 | [diff] [blame] | 197 | |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 198 | bool isVolatileQualified() const { return Quals.hasVolatile(); } |
| 199 | bool isRestrictQualified() const { return Quals.hasRestrict(); } |
| 200 | unsigned getVRQualifiers() const { |
| 201 | return Quals.getCVRQualifiers() & ~Qualifiers::Const; |
Chris Lattner | 1bd885e | 2009-02-16 22:25:49 +0000 | [diff] [blame] | 202 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 203 | |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 204 | QualType getType() const { return Type; } |
| 205 | |
| 206 | Qualifiers::ObjCLifetime getObjCLifetime() const { |
| 207 | return Quals.getObjCLifetime(); |
| 208 | } |
| 209 | |
Fariborz Jahanian | d1cc804 | 2008-11-20 20:53:20 +0000 | [diff] [blame] | 210 | bool isObjCIvar() const { return Ivar; } |
Daniel Dunbar | 3491b3d | 2010-08-21 03:51:29 +0000 | [diff] [blame] | 211 | void setObjCIvar(bool Value) { Ivar = Value; } |
| 212 | |
Fariborz Jahanian | fd02ed7 | 2009-09-21 18:54:29 +0000 | [diff] [blame] | 213 | bool isObjCArray() const { return ObjIsArray; } |
Daniel Dunbar | 3491b3d | 2010-08-21 03:51:29 +0000 | [diff] [blame] | 214 | void setObjCArray(bool Value) { ObjIsArray = Value; } |
Daniel Dunbar | ea61917 | 2010-08-21 03:22:38 +0000 | [diff] [blame] | 215 | |
Fariborz Jahanian | 4f676ed | 2009-02-21 00:30:43 +0000 | [diff] [blame] | 216 | bool isNonGC () const { return NonGC; } |
Daniel Dunbar | ea61917 | 2010-08-21 03:22:38 +0000 | [diff] [blame] | 217 | void setNonGC(bool Value) { NonGC = Value; } |
| 218 | |
Fariborz Jahanian | bf63b87 | 2009-05-04 23:27:20 +0000 | [diff] [blame] | 219 | bool isGlobalObjCRef() const { return GlobalObjCRef; } |
Daniel Dunbar | 3491b3d | 2010-08-21 03:51:29 +0000 | [diff] [blame] | 220 | void setGlobalObjCRef(bool Value) { GlobalObjCRef = Value; } |
| 221 | |
Fariborz Jahanian | 021a7a6 | 2010-07-20 20:30:03 +0000 | [diff] [blame] | 222 | bool isThreadLocalRef() const { return ThreadLocalRef; } |
Daniel Dunbar | 3491b3d | 2010-08-21 03:51:29 +0000 | [diff] [blame] | 223 | void setThreadLocalRef(bool Value) { ThreadLocalRef = Value;} |
| 224 | |
John McCall | 5b07e80 | 2013-03-13 03:10:54 +0000 | [diff] [blame] | 225 | ARCPreciseLifetime_t isARCPreciseLifetime() const { |
| 226 | return ARCPreciseLifetime_t(!ImpreciseLifetime); |
| 227 | } |
| 228 | void setARCPreciseLifetime(ARCPreciseLifetime_t value) { |
| 229 | ImpreciseLifetime = (value == ARCImpreciseLifetime); |
| 230 | } |
| 231 | |
Daniel Dunbar | 3491b3d | 2010-08-21 03:51:29 +0000 | [diff] [blame] | 232 | bool isObjCWeak() const { |
| 233 | return Quals.getObjCGCAttr() == Qualifiers::Weak; |
| 234 | } |
| 235 | bool isObjCStrong() const { |
| 236 | return Quals.getObjCGCAttr() == Qualifiers::Strong; |
| 237 | } |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 238 | |
| 239 | bool isVolatile() const { |
| 240 | return Quals.hasVolatile(); |
| 241 | } |
Fariborz Jahanian | 6c7a1f3 | 2009-09-24 22:25:38 +0000 | [diff] [blame] | 242 | |
| 243 | Expr *getBaseIvarExp() const { return BaseIvarExp; } |
| 244 | void setBaseIvarExp(Expr *V) { BaseIvarExp = V; } |
Mon P Wang | c6a38a4 | 2009-07-22 03:08:17 +0000 | [diff] [blame] | 245 | |
Manman Ren | b37a73d | 2013-04-04 21:53:22 +0000 | [diff] [blame] | 246 | QualType getTBAABaseType() const { return TBAABaseType; } |
| 247 | void setTBAABaseType(QualType T) { TBAABaseType = T; } |
| 248 | |
| 249 | uint64_t getTBAAOffset() const { return TBAAOffset; } |
| 250 | void setTBAAOffset(uint64_t O) { TBAAOffset = O; } |
| 251 | |
Dan Gohman | 3d5aff5 | 2010-10-14 23:06:10 +0000 | [diff] [blame] | 252 | llvm::MDNode *getTBAAInfo() const { return TBAAInfo; } |
| 253 | void setTBAAInfo(llvm::MDNode *N) { TBAAInfo = N; } |
| 254 | |
Daniel Dunbar | 99ad7df | 2010-08-21 03:29:54 +0000 | [diff] [blame] | 255 | const Qualifiers &getQuals() const { return Quals; } |
| 256 | Qualifiers &getQuals() { return Quals; } |
| 257 | |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 258 | unsigned getAddressSpace() const { return Quals.getAddressSpace(); } |
Mon P Wang | c6a38a4 | 2009-07-22 03:08:17 +0000 | [diff] [blame] | 259 | |
Eli Friedman | 6da2c71 | 2011-12-03 04:14:32 +0000 | [diff] [blame] | 260 | CharUnits getAlignment() const { return CharUnits::fromQuantity(Alignment); } |
| 261 | void setAlignment(CharUnits A) { Alignment = A.getQuantity(); } |
Daniel Dunbar | 9f4f7cf | 2010-08-21 02:39:23 +0000 | [diff] [blame] | 262 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 263 | // simple lvalue |
| 264 | llvm::Value *getAddress() const { assert(isSimple()); return V; } |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 265 | void setAddress(llvm::Value *address) { |
| 266 | assert(isSimple()); |
| 267 | V = address; |
| 268 | } |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 269 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 270 | // vector elt lvalue |
| 271 | llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; } |
| 272 | llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; } |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 273 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 274 | // extended vector elements. |
| 275 | llvm::Value *getExtVectorAddr() const { assert(isExtVectorElt()); return V; } |
| 276 | llvm::Constant *getExtVectorElts() const { |
| 277 | assert(isExtVectorElt()); |
| 278 | return VectorElts; |
| 279 | } |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 280 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 281 | // bitfield lvalue |
Chandler Carruth | 72d2dab | 2012-12-06 11:14:44 +0000 | [diff] [blame] | 282 | llvm::Value *getBitFieldAddr() const { |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 283 | assert(isBitField()); |
| 284 | return V; |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 285 | } |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 286 | const CGBitFieldInfo &getBitFieldInfo() const { |
| 287 | assert(isBitField()); |
| 288 | return *BitFieldInfo; |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 289 | } |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 290 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 291 | // global register lvalue |
| 292 | llvm::Value *getGlobalReg() const { assert(isGlobalReg()); return V; } |
| 293 | |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 294 | static LValue MakeAddr(llvm::Value *address, QualType type, |
Eli Friedman | 6da2c71 | 2011-12-03 04:14:32 +0000 | [diff] [blame] | 295 | CharUnits alignment, ASTContext &Context, |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 296 | llvm::MDNode *TBAAInfo = nullptr) { |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 297 | Qualifiers qs = type.getQualifiers(); |
| 298 | qs.setObjCGCAttr(Context.getObjCGCAttrKind(type)); |
Daniel Dunbar | f1fbda3 | 2010-08-21 03:58:45 +0000 | [diff] [blame] | 299 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 300 | LValue R; |
| 301 | R.LVType = Simple; |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 302 | R.V = address; |
| 303 | R.Initialize(type, qs, alignment, TBAAInfo); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 304 | return R; |
| 305 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 306 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 307 | static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx, |
Eli Friedman | e5a8aeb | 2012-03-22 22:36:39 +0000 | [diff] [blame] | 308 | QualType type, CharUnits Alignment) { |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 309 | LValue R; |
| 310 | R.LVType = VectorElt; |
| 311 | R.V = Vec; |
| 312 | R.VectorIdx = Idx; |
Eli Friedman | e5a8aeb | 2012-03-22 22:36:39 +0000 | [diff] [blame] | 313 | R.Initialize(type, type.getQualifiers(), Alignment); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 314 | return R; |
| 315 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 316 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 317 | static LValue MakeExtVectorElt(llvm::Value *Vec, llvm::Constant *Elts, |
Eli Friedman | e5a8aeb | 2012-03-22 22:36:39 +0000 | [diff] [blame] | 318 | QualType type, CharUnits Alignment) { |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 319 | LValue R; |
| 320 | R.LVType = ExtVectorElt; |
| 321 | R.V = Vec; |
| 322 | R.VectorElts = Elts; |
Eli Friedman | e5a8aeb | 2012-03-22 22:36:39 +0000 | [diff] [blame] | 323 | R.Initialize(type, type.getQualifiers(), Alignment); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 324 | return R; |
| 325 | } |
| 326 | |
Daniel Dunbar | 7f28964 | 2010-04-08 02:59:45 +0000 | [diff] [blame] | 327 | /// \brief Create a new object to represent a bit-field access. |
| 328 | /// |
NAKAMURA Takumi | 0481e54 | 2012-12-24 01:48:48 +0000 | [diff] [blame] | 329 | /// \param Addr - The base address of the bit-field sequence this |
Chandler Carruth | 72d2dab | 2012-12-06 11:14:44 +0000 | [diff] [blame] | 330 | /// bit-field refers to. |
Daniel Dunbar | 7f28964 | 2010-04-08 02:59:45 +0000 | [diff] [blame] | 331 | /// \param Info - The information describing how to perform the bit-field |
| 332 | /// access. |
Chandler Carruth | 72d2dab | 2012-12-06 11:14:44 +0000 | [diff] [blame] | 333 | static LValue MakeBitfield(llvm::Value *Addr, |
John McCall | a07398e | 2011-06-16 04:16:24 +0000 | [diff] [blame] | 334 | const CGBitFieldInfo &Info, |
Eli Friedman | f4bcfa1 | 2012-06-27 21:19:48 +0000 | [diff] [blame] | 335 | QualType type, CharUnits Alignment) { |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 336 | LValue R; |
| 337 | R.LVType = BitField; |
Chandler Carruth | 72d2dab | 2012-12-06 11:14:44 +0000 | [diff] [blame] | 338 | R.V = Addr; |
Daniel Dunbar | f0fe5bc | 2010-04-05 21:36:35 +0000 | [diff] [blame] | 339 | R.BitFieldInfo = &Info; |
Eli Friedman | f4bcfa1 | 2012-06-27 21:19:48 +0000 | [diff] [blame] | 340 | R.Initialize(type, type.getQualifiers(), Alignment); |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 341 | return R; |
| 342 | } |
Eli Friedman | 51f5120 | 2011-12-03 03:08:40 +0000 | [diff] [blame] | 343 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 344 | static LValue MakeGlobalReg(llvm::Value *Reg, |
| 345 | QualType type, |
| 346 | CharUnits Alignment) { |
| 347 | LValue R; |
| 348 | R.LVType = GlobalReg; |
| 349 | R.V = Reg; |
| 350 | R.Initialize(type, type.getQualifiers(), Alignment); |
| 351 | return R; |
| 352 | } |
| 353 | |
Eli Friedman | 51f5120 | 2011-12-03 03:08:40 +0000 | [diff] [blame] | 354 | RValue asAggregateRValue() const { |
| 355 | // FIMXE: Alignment |
| 356 | return RValue::getAggregate(getAddress(), isVolatileQualified()); |
| 357 | } |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 358 | }; |
| 359 | |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 360 | /// An aggregate value slot. |
| 361 | class AggValueSlot { |
Fariborz Jahanian | 474e2fe | 2010-09-16 00:20:07 +0000 | [diff] [blame] | 362 | /// The address. |
John McCall | 6fa2916 | 2010-09-16 03:16:41 +0000 | [diff] [blame] | 363 | llvm::Value *Addr; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 364 | |
| 365 | // Qualifiers |
| 366 | Qualifiers Quals; |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 367 | |
Chad Rosier | 649b4a1 | 2012-03-29 17:37:10 +0000 | [diff] [blame] | 368 | unsigned short Alignment; |
Eli Friedman | f394078 | 2011-12-03 00:54:26 +0000 | [diff] [blame] | 369 | |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 370 | /// DestructedFlag - This is set to true if some external code is |
| 371 | /// responsible for setting up a destructor for the slot. Otherwise |
| 372 | /// the code which constructs it should push the appropriate cleanup. |
Chad Rosier | 649b4a1 | 2012-03-29 17:37:10 +0000 | [diff] [blame] | 373 | bool DestructedFlag : 1; |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 374 | |
| 375 | /// ObjCGCFlag - This is set to true if writing to the memory in the |
| 376 | /// slot might require calling an appropriate Objective-C GC |
| 377 | /// barrier. The exact interaction here is unnecessarily mysterious. |
Chad Rosier | 649b4a1 | 2012-03-29 17:37:10 +0000 | [diff] [blame] | 378 | bool ObjCGCFlag : 1; |
Chris Lattner | 1b72677 | 2010-12-02 07:07:26 +0000 | [diff] [blame] | 379 | |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 380 | /// ZeroedFlag - This is set to true if the memory in the slot is |
| 381 | /// known to be zero before the assignment into it. This means that |
| 382 | /// zero fields don't need to be set. |
Chad Rosier | 649b4a1 | 2012-03-29 17:37:10 +0000 | [diff] [blame] | 383 | bool ZeroedFlag : 1; |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 384 | |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 385 | /// AliasedFlag - This is set to true if the slot might be aliased |
| 386 | /// and it's not undefined behavior to access it through such an |
| 387 | /// alias. Note that it's always undefined behavior to access a C++ |
| 388 | /// object that's under construction through an alias derived from |
| 389 | /// outside the construction process. |
| 390 | /// |
| 391 | /// This flag controls whether calls that produce the aggregate |
| 392 | /// value may be evaluated directly into the slot, or whether they |
| 393 | /// must be evaluated into an unaliased temporary and then memcpy'ed |
| 394 | /// over. Since it's invalid in general to memcpy a non-POD C++ |
| 395 | /// object, it's important that this flag never be set when |
| 396 | /// evaluating an expression which constructs such an object. |
Chad Rosier | 649b4a1 | 2012-03-29 17:37:10 +0000 | [diff] [blame] | 397 | bool AliasedFlag : 1; |
John McCall | 410ffb2 | 2011-08-25 23:04:34 +0000 | [diff] [blame] | 398 | |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 399 | public: |
John McCall | 410ffb2 | 2011-08-25 23:04:34 +0000 | [diff] [blame] | 400 | enum IsAliased_t { IsNotAliased, IsAliased }; |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 401 | enum IsDestructed_t { IsNotDestructed, IsDestructed }; |
John McCall | 410ffb2 | 2011-08-25 23:04:34 +0000 | [diff] [blame] | 402 | enum IsZeroed_t { IsNotZeroed, IsZeroed }; |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 403 | enum NeedsGCBarriers_t { DoesNotNeedGCBarriers, NeedsGCBarriers }; |
| 404 | |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 405 | /// ignored - Returns an aggregate value slot indicating that the |
| 406 | /// aggregate value is being ignored. |
| 407 | static AggValueSlot ignored() { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 408 | return forAddr(nullptr, CharUnits(), Qualifiers(), IsNotDestructed, |
Chad Rosier | 649b4a1 | 2012-03-29 17:37:10 +0000 | [diff] [blame] | 409 | DoesNotNeedGCBarriers, IsNotAliased); |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 410 | } |
| 411 | |
| 412 | /// forAddr - Make a slot for an aggregate value. |
| 413 | /// |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 414 | /// \param quals - The qualifiers that dictate how the slot should |
| 415 | /// be initialied. Only 'volatile' and the Objective-C lifetime |
| 416 | /// qualifiers matter. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 417 | /// |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 418 | /// \param isDestructed - true if something else is responsible |
| 419 | /// for calling destructors on this object |
| 420 | /// \param needsGC - true if the slot is potentially located |
John McCall | d1a5f13 | 2010-09-16 03:13:23 +0000 | [diff] [blame] | 421 | /// somewhere that ObjC GC calls should be emitted for |
Eli Friedman | d7722d9 | 2011-12-03 02:13:40 +0000 | [diff] [blame] | 422 | static AggValueSlot forAddr(llvm::Value *addr, CharUnits align, |
Eli Friedman | f394078 | 2011-12-03 00:54:26 +0000 | [diff] [blame] | 423 | Qualifiers quals, |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 424 | IsDestructed_t isDestructed, |
| 425 | NeedsGCBarriers_t needsGC, |
John McCall | 4418439 | 2011-08-26 07:31:35 +0000 | [diff] [blame] | 426 | IsAliased_t isAliased, |
Eli Friedman | 336d9df | 2013-07-11 01:32:21 +0000 | [diff] [blame] | 427 | IsZeroed_t isZeroed = IsNotZeroed) { |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 428 | AggValueSlot AV; |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 429 | AV.Addr = addr; |
Eli Friedman | d7722d9 | 2011-12-03 02:13:40 +0000 | [diff] [blame] | 430 | AV.Alignment = align.getQuantity(); |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 431 | AV.Quals = quals; |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 432 | AV.DestructedFlag = isDestructed; |
| 433 | AV.ObjCGCFlag = needsGC; |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 434 | AV.ZeroedFlag = isZeroed; |
John McCall | 410ffb2 | 2011-08-25 23:04:34 +0000 | [diff] [blame] | 435 | AV.AliasedFlag = isAliased; |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 436 | return AV; |
| 437 | } |
| 438 | |
John McCall | e0c1168 | 2012-07-02 23:58:38 +0000 | [diff] [blame] | 439 | static AggValueSlot forLValue(const LValue &LV, |
| 440 | IsDestructed_t isDestructed, |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 441 | NeedsGCBarriers_t needsGC, |
John McCall | 4418439 | 2011-08-26 07:31:35 +0000 | [diff] [blame] | 442 | IsAliased_t isAliased, |
Eli Friedman | 336d9df | 2013-07-11 01:32:21 +0000 | [diff] [blame] | 443 | IsZeroed_t isZeroed = IsNotZeroed) { |
Eli Friedman | 6da2c71 | 2011-12-03 04:14:32 +0000 | [diff] [blame] | 444 | return forAddr(LV.getAddress(), LV.getAlignment(), |
Eli Friedman | 336d9df | 2013-07-11 01:32:21 +0000 | [diff] [blame] | 445 | LV.getQuals(), isDestructed, needsGC, isAliased, isZeroed); |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 446 | } |
Fariborz Jahanian | 8a97005 | 2010-10-22 22:05:03 +0000 | [diff] [blame] | 447 | |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 448 | IsDestructed_t isExternallyDestructed() const { |
| 449 | return IsDestructed_t(DestructedFlag); |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 450 | } |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 451 | void setExternallyDestructed(bool destructed = true) { |
| 452 | DestructedFlag = destructed; |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 453 | } |
| 454 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 455 | Qualifiers getQualifiers() const { return Quals; } |
| 456 | |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 457 | bool isVolatile() const { |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 458 | return Quals.hasVolatile(); |
| 459 | } |
| 460 | |
Fariborz Jahanian | 3ac83d6 | 2013-01-25 23:57:05 +0000 | [diff] [blame] | 461 | void setVolatile(bool flag) { |
| 462 | Quals.setVolatile(flag); |
| 463 | } |
| 464 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 465 | Qualifiers::ObjCLifetime getObjCLifetime() const { |
| 466 | return Quals.getObjCLifetime(); |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 467 | } |
| 468 | |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 469 | NeedsGCBarriers_t requiresGCollection() const { |
John McCall | fd71fb8 | 2011-08-26 08:02:37 +0000 | [diff] [blame] | 470 | return NeedsGCBarriers_t(ObjCGCFlag); |
Fariborz Jahanian | 474e2fe | 2010-09-16 00:20:07 +0000 | [diff] [blame] | 471 | } |
Fariborz Jahanian | 474e2fe | 2010-09-16 00:20:07 +0000 | [diff] [blame] | 472 | |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 473 | llvm::Value *getAddr() const { |
John McCall | 6fa2916 | 2010-09-16 03:16:41 +0000 | [diff] [blame] | 474 | return Addr; |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 475 | } |
| 476 | |
| 477 | bool isIgnored() const { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 478 | return Addr == nullptr; |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 479 | } |
| 480 | |
Eli Friedman | d7722d9 | 2011-12-03 02:13:40 +0000 | [diff] [blame] | 481 | CharUnits getAlignment() const { |
| 482 | return CharUnits::fromQuantity(Alignment); |
Eli Friedman | f394078 | 2011-12-03 00:54:26 +0000 | [diff] [blame] | 483 | } |
| 484 | |
John McCall | 410ffb2 | 2011-08-25 23:04:34 +0000 | [diff] [blame] | 485 | IsAliased_t isPotentiallyAliased() const { |
| 486 | return IsAliased_t(AliasedFlag); |
| 487 | } |
| 488 | |
Eli Friedman | f394078 | 2011-12-03 00:54:26 +0000 | [diff] [blame] | 489 | // FIXME: Alignment? |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 490 | RValue asRValue() const { |
| 491 | return RValue::getAggregate(getAddr(), isVolatile()); |
| 492 | } |
John McCall | 4b9c2d2 | 2011-11-06 09:01:30 +0000 | [diff] [blame] | 493 | |
John McCall | 7c2349b | 2011-08-25 20:40:09 +0000 | [diff] [blame] | 494 | void setZeroed(bool V = true) { ZeroedFlag = V; } |
| 495 | IsZeroed_t isZeroed() const { |
| 496 | return IsZeroed_t(ZeroedFlag); |
Chris Lattner | 1b72677 | 2010-12-02 07:07:26 +0000 | [diff] [blame] | 497 | } |
John McCall | 558d2ab | 2010-09-15 10:14:12 +0000 | [diff] [blame] | 498 | }; |
| 499 | |
Daniel Dunbar | 2eecaab | 2008-08-23 03:10:25 +0000 | [diff] [blame] | 500 | } // end namespace CodeGen |
| 501 | } // end namespace clang |
| 502 | |
| 503 | #endif |