blob: 4d19a3c865deba6406499d84eccfd71e9f61e9e3 [file] [log] [blame]
Daniel Dunbar2eecaab2008-08-23 03:10:25 +00001//===-- 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
15#ifndef CLANG_CODEGEN_CGVALUE_H
16#define CLANG_CODEGEN_CGVALUE_H
17
Daniel Dunbar5cf8bfe2010-08-21 02:53:44 +000018#include "clang/AST/ASTContext.h"
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000019#include "clang/AST/Type.h"
20
Daniel Dunbar46f45b92008-09-09 01:06:48 +000021namespace llvm {
22 class Constant;
23 class Value;
24}
25
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000026namespace clang {
Daniel Dunbar85c59ed2008-08-29 08:11:39 +000027 class ObjCPropertyRefExpr;
Fariborz Jahanian09105f52009-08-20 17:02:02 +000028 class ObjCImplicitSetterGetterRefExpr;
Daniel Dunbar85c59ed2008-08-29 08:11:39 +000029
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000030namespace CodeGen {
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +000031 class CGBitFieldInfo;
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000032
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.
37class RValue {
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000038 enum Flavor { Scalar, Complex, Aggregate };
Mike Stump1eb44332009-09-09 15:08:12 +000039
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000040 // 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 Dunbar2eecaab2008-08-23 03:10:25 +000045public:
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000046 bool isScalar() const { return V1.getInt() == Scalar; }
47 bool isComplex() const { return V1.getInt() == Complex; }
48 bool isAggregate() const { return V1.getInt() == Aggregate; }
Mike Stump1eb44332009-09-09 15:08:12 +000049
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000050 bool isVolatileQualified() const { return V2.getInt(); }
Mike Stump8b3d93a2009-05-23 20:21:36 +000051
Mike Stump519202d2009-11-03 16:11:57 +000052 /// getScalarVal() - Return the Value* of this scalar value.
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000053 llvm::Value *getScalarVal() const {
54 assert(isScalar() && "Not a scalar!");
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000055 return V1.getPointer();
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000056 }
57
58 /// getComplexVal - Return the real/imag components of this complex value.
59 ///
60 std::pair<llvm::Value *, llvm::Value *> getComplexVal() const {
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000061 return std::make_pair(V1.getPointer(), V2.getPointer());
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000062 }
Mike Stump1eb44332009-09-09 15:08:12 +000063
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000064 /// getAggregateAddr() - Return the Value* of the address of the aggregate.
65 llvm::Value *getAggregateAddr() const {
66 assert(isAggregate() && "Not an aggregate!");
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000067 return V1.getPointer();
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000068 }
Mike Stump1eb44332009-09-09 15:08:12 +000069
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000070 static RValue get(llvm::Value *V) {
71 RValue ER;
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000072 ER.V1.setPointer(V);
73 ER.V1.setInt(Scalar);
74 ER.V2.setInt(false);
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000075 return ER;
76 }
77 static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
78 RValue ER;
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000079 ER.V1.setPointer(V1);
80 ER.V2.setPointer(V2);
81 ER.V1.setInt(Complex);
82 ER.V2.setInt(false);
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000083 return ER;
84 }
85 static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000086 return getComplex(C.first, C.second);
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000087 }
Mike Stump8b3d93a2009-05-23 20:21:36 +000088 // 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 Kramer81bf3b32010-05-02 14:59:10 +000091 static RValue getAggregate(llvm::Value *V, bool Volatile = false) {
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000092 RValue ER;
Benjamin Kramer81bf3b32010-05-02 14:59:10 +000093 ER.V1.setPointer(V);
94 ER.V1.setInt(Aggregate);
95 ER.V2.setInt(Volatile);
Daniel Dunbar2eecaab2008-08-23 03:10:25 +000096 return ER;
97 }
98};
99
100
101/// LValue - This represents an lvalue references. Because C/C++ allow
102/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a
103/// bitrange.
104class LValue {
105 // FIXME: alignment?
Mike Stump1eb44332009-09-09 15:08:12 +0000106
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000107 enum {
108 Simple, // This is a normal l-value, use getAddress().
109 VectorElt, // This is a vector element l-value (V[i]), use getVector*
110 BitField, // This is a bitfield l-value, use getBitfield*.
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000111 ExtVectorElt, // This is an extended vector subset, use getExtVectorComp
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000112 PropertyRef, // This is an Objective-C property reference, use
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000113 // getPropertyRefExpr
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000114 KVCRef // This is an objective-c 'implicit' property ref,
115 // use getKVCRefExpr
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000116 } LVType;
Fariborz Jahanian58626502008-11-19 00:59:10 +0000117
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000118 llvm::Value *V;
Mike Stump1eb44332009-09-09 15:08:12 +0000119
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000120 union {
121 // Index into a vector subscript: V[i]
122 llvm::Value *VectorIdx;
123
124 // ExtVector element subset: V.xyx
125 llvm::Constant *VectorElts;
Mike Stump1eb44332009-09-09 15:08:12 +0000126
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000127 // BitField start bit and size
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000128 const CGBitFieldInfo *BitFieldInfo;
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000129
130 // Obj-C property reference expression
131 const ObjCPropertyRefExpr *PropertyRefExpr;
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000132
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000133 // ObjC 'implicit' property reference expression
Fariborz Jahanian09105f52009-08-20 17:02:02 +0000134 const ObjCImplicitSetterGetterRefExpr *KVCRefExpr;
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000135 };
136
John McCall0953e762009-09-24 19:53:00 +0000137 // 'const' is unused here
138 Qualifiers Quals;
Fariborz Jahanian58626502008-11-19 00:59:10 +0000139
Daniel Dunbar9f4f7cf2010-08-21 02:39:23 +0000140 /// The alignment to use when accessing this lvalue.
141 unsigned char Alignment;
142
Fariborz Jahaniand1cc8042008-11-20 20:53:20 +0000143 // objective-c's ivar
144 bool Ivar:1;
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +0000145
146 // objective-c's ivar is an array
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +0000147 bool ObjIsArray:1;
Mike Stump1eb44332009-09-09 15:08:12 +0000148
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000149 // LValue is non-gc'able for any reason, including being a parameter or local
150 // variable.
151 bool NonGC: 1;
Fariborz Jahaniand1cc8042008-11-20 20:53:20 +0000152
Fariborz Jahanianbf63b872009-05-04 23:27:20 +0000153 // Lvalue is a global reference of an objective-c object
154 bool GlobalObjCRef : 1;
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000155
156 // Lvalue is a thread local reference
157 bool ThreadLocalRef : 1;
Fariborz Jahanianbf63b872009-05-04 23:27:20 +0000158
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000159 Expr *BaseIvarExp;
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000160private:
Daniel Dunbar9f4f7cf2010-08-21 02:39:23 +0000161 void Initialize(Qualifiers Quals, unsigned Alignment = 0) {
John McCall0953e762009-09-24 19:53:00 +0000162 this->Quals = Quals;
Daniel Dunbar9f4f7cf2010-08-21 02:39:23 +0000163 this->Alignment = Alignment;
164 assert(this->Alignment == Alignment && "Alignment exceeds allowed max!");
165
166 // Initialize Objective-C flags.
John McCall0953e762009-09-24 19:53:00 +0000167 this->Ivar = this->ObjIsArray = this->NonGC = this->GlobalObjCRef = false;
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000168 this->ThreadLocalRef = false;
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000169 this->BaseIvarExp = 0;
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000170 }
Mike Stump1eb44332009-09-09 15:08:12 +0000171
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000172public:
173 bool isSimple() const { return LVType == Simple; }
174 bool isVectorElt() const { return LVType == VectorElt; }
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000175 bool isBitField() const { return LVType == BitField; }
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000176 bool isExtVectorElt() const { return LVType == ExtVectorElt; }
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000177 bool isPropertyRef() const { return LVType == PropertyRef; }
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000178 bool isKVCRef() const { return LVType == KVCRef; }
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000179
John McCall0953e762009-09-24 19:53:00 +0000180 bool isVolatileQualified() const { return Quals.hasVolatile(); }
181 bool isRestrictQualified() const { return Quals.hasRestrict(); }
182 unsigned getVRQualifiers() const {
183 return Quals.getCVRQualifiers() & ~Qualifiers::Const;
Chris Lattner1bd885e2009-02-16 22:25:49 +0000184 }
Mike Stump1eb44332009-09-09 15:08:12 +0000185
Fariborz Jahaniand1cc8042008-11-20 20:53:20 +0000186 bool isObjCIvar() const { return Ivar; }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +0000187 void setObjCIvar(bool Value) { Ivar = Value; }
188
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +0000189 bool isObjCArray() const { return ObjIsArray; }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +0000190 void setObjCArray(bool Value) { ObjIsArray = Value; }
Daniel Dunbarea619172010-08-21 03:22:38 +0000191
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000192 bool isNonGC () const { return NonGC; }
Daniel Dunbarea619172010-08-21 03:22:38 +0000193 void setNonGC(bool Value) { NonGC = Value; }
194
Fariborz Jahanianbf63b872009-05-04 23:27:20 +0000195 bool isGlobalObjCRef() const { return GlobalObjCRef; }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +0000196 void setGlobalObjCRef(bool Value) { GlobalObjCRef = Value; }
197
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000198 bool isThreadLocalRef() const { return ThreadLocalRef; }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +0000199 void setThreadLocalRef(bool Value) { ThreadLocalRef = Value;}
200
201 bool isObjCWeak() const {
202 return Quals.getObjCGCAttr() == Qualifiers::Weak;
203 }
204 bool isObjCStrong() const {
205 return Quals.getObjCGCAttr() == Qualifiers::Strong;
206 }
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000207
208 Expr *getBaseIvarExp() const { return BaseIvarExp; }
209 void setBaseIvarExp(Expr *V) { BaseIvarExp = V; }
Mon P Wangc6a38a42009-07-22 03:08:17 +0000210
Daniel Dunbar99ad7df2010-08-21 03:29:54 +0000211 const Qualifiers &getQuals() const { return Quals; }
212 Qualifiers &getQuals() { return Quals; }
213
John McCall0953e762009-09-24 19:53:00 +0000214 unsigned getAddressSpace() const { return Quals.getAddressSpace(); }
Mon P Wangc6a38a42009-07-22 03:08:17 +0000215
Daniel Dunbar9f4f7cf2010-08-21 02:39:23 +0000216 unsigned getAlignment() const { return Alignment; }
217
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000218 // simple lvalue
219 llvm::Value *getAddress() const { assert(isSimple()); return V; }
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000220
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000221 // vector elt lvalue
222 llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; }
223 llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; }
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000224
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000225 // extended vector elements.
226 llvm::Value *getExtVectorAddr() const { assert(isExtVectorElt()); return V; }
227 llvm::Constant *getExtVectorElts() const {
228 assert(isExtVectorElt());
229 return VectorElts;
230 }
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000231
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000232 // bitfield lvalue
Daniel Dunbar7f289642010-04-08 02:59:45 +0000233 llvm::Value *getBitFieldBaseAddr() const {
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000234 assert(isBitField());
235 return V;
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000236 }
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000237 const CGBitFieldInfo &getBitFieldInfo() const {
238 assert(isBitField());
239 return *BitFieldInfo;
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000240 }
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000241
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000242 // property ref lvalue
243 const ObjCPropertyRefExpr *getPropertyRefExpr() const {
244 assert(isPropertyRef());
245 return PropertyRefExpr;
246 }
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000247
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000248 // 'implicit' property ref lvalue
Fariborz Jahanian09105f52009-08-20 17:02:02 +0000249 const ObjCImplicitSetterGetterRefExpr *getKVCRefExpr() const {
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000250 assert(isKVCRef());
251 return KVCRefExpr;
252 }
253
Daniel Dunbarf1fbda32010-08-21 03:58:45 +0000254 static LValue MakeAddr(llvm::Value *V, QualType T, unsigned Alignment,
255 ASTContext &Context) {
256 Qualifiers Quals = Context.getCanonicalType(T).getQualifiers();
257 Quals.setObjCGCAttr(Context.getObjCGCAttrKind(T));
258
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000259 LValue R;
260 R.LVType = Simple;
261 R.V = V;
Daniel Dunbar9f4f7cf2010-08-21 02:39:23 +0000262 R.Initialize(Quals, Alignment);
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000263 return R;
264 }
Mike Stump1eb44332009-09-09 15:08:12 +0000265
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000266 static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx,
John McCall0953e762009-09-24 19:53:00 +0000267 unsigned CVR) {
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000268 LValue R;
269 R.LVType = VectorElt;
270 R.V = Vec;
271 R.VectorIdx = Idx;
Daniel Dunbarde988812010-08-21 02:31:58 +0000272 R.Initialize(Qualifiers::fromCVRMask(CVR));
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000273 return R;
274 }
Mike Stump1eb44332009-09-09 15:08:12 +0000275
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000276 static LValue MakeExtVectorElt(llvm::Value *Vec, llvm::Constant *Elts,
John McCall0953e762009-09-24 19:53:00 +0000277 unsigned CVR) {
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000278 LValue R;
279 R.LVType = ExtVectorElt;
280 R.V = Vec;
281 R.VectorElts = Elts;
Daniel Dunbarde988812010-08-21 02:31:58 +0000282 R.Initialize(Qualifiers::fromCVRMask(CVR));
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000283 return R;
284 }
285
Daniel Dunbar7f289642010-04-08 02:59:45 +0000286 /// \brief Create a new object to represent a bit-field access.
287 ///
288 /// \param BaseValue - The base address of the structure containing the
289 /// bit-field.
290 /// \param Info - The information describing how to perform the bit-field
291 /// access.
292 static LValue MakeBitfield(llvm::Value *BaseValue, const CGBitFieldInfo &Info,
Daniel Dunbarefbf4872010-04-06 01:07:44 +0000293 unsigned CVR) {
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000294 LValue R;
295 R.LVType = BitField;
Daniel Dunbar7f289642010-04-08 02:59:45 +0000296 R.V = BaseValue;
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000297 R.BitFieldInfo = &Info;
Daniel Dunbarde988812010-08-21 02:31:58 +0000298 R.Initialize(Qualifiers::fromCVRMask(CVR));
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000299 return R;
300 }
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000301
Mike Stumpf5408fe2009-05-16 07:57:57 +0000302 // FIXME: It is probably bad that we aren't emitting the target when we build
303 // the lvalue. However, this complicates the code a bit, and I haven't figured
304 // out how to make it go wrong yet.
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000305 static LValue MakePropertyRef(const ObjCPropertyRefExpr *E,
John McCall0953e762009-09-24 19:53:00 +0000306 unsigned CVR) {
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000307 LValue R;
308 R.LVType = PropertyRef;
309 R.PropertyRefExpr = E;
Daniel Dunbarde988812010-08-21 02:31:58 +0000310 R.Initialize(Qualifiers::fromCVRMask(CVR));
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000311 return R;
312 }
Mike Stump1eb44332009-09-09 15:08:12 +0000313
314 static LValue MakeKVCRef(const ObjCImplicitSetterGetterRefExpr *E,
John McCall0953e762009-09-24 19:53:00 +0000315 unsigned CVR) {
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000316 LValue R;
317 R.LVType = KVCRef;
318 R.KVCRefExpr = E;
Daniel Dunbarde988812010-08-21 02:31:58 +0000319 R.Initialize(Qualifiers::fromCVRMask(CVR));
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000320 return R;
321 }
Daniel Dunbar2eecaab2008-08-23 03:10:25 +0000322};
323
324} // end namespace CodeGen
325} // end namespace clang
326
327#endif