CGValue.h revision 6b73568bc3d44ac6e6d62437cba0e307cf8900d6 
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
15#ifndef CLANG_CODEGEN_CGVALUE_H
16#define CLANG_CODEGEN_CGVALUE_H
17
18#include "clang/AST/Type.h"
19
20namespace llvm {
21  class Constant;
22  class Value;
23}
24
25namespace clang {
26  class ObjCPropertyRefExpr;
27  class ObjCKVCRefExpr;
28
29namespace CodeGen {
30
31/// RValue - This trivial value class is used to represent the result of an
32/// expression that is evaluated.  It can be one of three things: either a
33/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the
34/// address of an aggregate value in memory.
35class RValue {
36  llvm::Value *V1, *V2;
37  // TODO: Encode this into the low bit of pointer for more efficient
38  // return-by-value.
39  enum { Scalar, Complex, Aggregate } Flavor;
40
41  bool Volatile:1;
42public:
43
44  bool isScalar() const { return Flavor == Scalar; }
45  bool isComplex() const { return Flavor == Complex; }
46  bool isAggregate() const { return Flavor == Aggregate; }
47
48  bool isVolatileQualified() const { return Volatile; }
49
50  /// getScalar() - Return the Value* of this scalar value.
51  llvm::Value *getScalarVal() const {
52    assert(isScalar() && "Not a scalar!");
53    return V1;
54  }
55
56  /// getComplexVal - Return the real/imag components of this complex value.
57  ///
58  std::pair<llvm::Value *, llvm::Value *> getComplexVal() const {
59    return std::pair<llvm::Value *, llvm::Value *>(V1, V2);
60  }
61
62  /// getAggregateAddr() - Return the Value* of the address of the aggregate.
63  llvm::Value *getAggregateAddr() const {
64    assert(isAggregate() && "Not an aggregate!");
65    return V1;
66  }
67
68  static RValue get(llvm::Value *V) {
69    RValue ER;
70    ER.V1 = V;
71    ER.Flavor = Scalar;
72    ER.Volatile = false;
73    return ER;
74  }
75  static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
76    RValue ER;
77    ER.V1 = V1;
78    ER.V2 = V2;
79    ER.Flavor = Complex;
80    ER.Volatile = false;
81    return ER;
82  }
83  static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
84    RValue ER;
85    ER.V1 = C.first;
86    ER.V2 = C.second;
87    ER.Flavor = Complex;
88    ER.Volatile = false;
89    return ER;
90  }
91  // FIXME: Aggregate rvalues need to retain information about whether they are
92  // volatile or not.  Remove default to find all places that probably get this
93  // wrong.
94  static RValue getAggregate(llvm::Value *V, bool Vol = false) {
95    RValue ER;
96    ER.V1 = V;
97    ER.Flavor = Aggregate;
98    ER.Volatile = Vol;
99    return ER;
100  }
101};
102
103
104/// LValue - This represents an lvalue references.  Because C/C++ allow
105/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a
106/// bitrange.
107class LValue {
108  // FIXME: alignment?
109
110  enum {
111    Simple,       // This is a normal l-value, use getAddress().
112    VectorElt,    // This is a vector element l-value (V[i]), use getVector*
113    BitField,     // This is a bitfield l-value, use getBitfield*.
114    ExtVectorElt, // This is an extended vector subset, use getExtVectorComp
115    PropertyRef,  // This is an Objective-C property reference, use
116                  // getPropertyRefExpr
117    KVCRef        // This is an objective-c 'implicit' property ref,
118                  // use getKVCRefExpr
119  } LVType;
120
121  enum ObjCType {
122    None = 0,     // object with no gc attribute.
123    Weak,         // __weak object expression
124    Strong        // __strong object expression
125  };
126
127  llvm::Value *V;
128
129  union {
130    // Index into a vector subscript: V[i]
131    llvm::Value *VectorIdx;
132
133    // ExtVector element subset: V.xyx
134    llvm::Constant *VectorElts;
135
136    // BitField start bit and size
137    struct {
138      unsigned short StartBit;
139      unsigned short Size;
140      bool IsSigned;
141    } BitfieldData;
142
143    // Obj-C property reference expression
144    const ObjCPropertyRefExpr *PropertyRefExpr;
145    // ObjC 'implicit' property reference expression
146    const ObjCKVCRefExpr *KVCRefExpr;
147  };
148
149  bool Volatile:1;
150  // FIXME: set but never used, what effect should it have?
151  bool Restrict:1;
152
153  // objective-c's ivar
154  bool Ivar:1;
155
156  // LValue is non-gc'able for any reason, including being a parameter or local
157  // variable.
158  bool NonGC: 1;
159
160  // Lvalue is a global reference of an objective-c object
161  bool GlobalObjCRef : 1;
162
163  // objective-c's gc attributes
164  unsigned ObjCType : 2;
165
166
167
168private:
169  static void SetQualifiers(unsigned Qualifiers, LValue& R) {
170    R.Volatile = (Qualifiers&QualType::Volatile)!=0;
171    R.Restrict = (Qualifiers&QualType::Restrict)!=0;
172    // FIXME: Convenient place to set objc flags to 0. This should really be
173    // done in a user-defined constructor instead.
174    R.ObjCType = None;
175    R.Ivar = R.NonGC = R.GlobalObjCRef = false;
176  }
177
178public:
179  bool isSimple() const { return LVType == Simple; }
180  bool isVectorElt() const { return LVType == VectorElt; }
181  bool isBitfield() const { return LVType == BitField; }
182  bool isExtVectorElt() const { return LVType == ExtVectorElt; }
183  bool isPropertyRef() const { return LVType == PropertyRef; }
184  bool isKVCRef() const { return LVType == KVCRef; }
185
186  bool isVolatileQualified() const { return Volatile; }
187  bool isRestrictQualified() const { return Restrict; }
188  unsigned getQualifiers() const {
189    return (Volatile ? QualType::Volatile : 0) |
190           (Restrict ? QualType::Restrict : 0);
191  }
192
193  bool isObjCIvar() const { return Ivar; }
194  bool isNonGC () const { return NonGC; }
195  bool isGlobalObjCRef() const { return GlobalObjCRef; }
196  bool isObjCWeak() const { return ObjCType == Weak; }
197  bool isObjCStrong() const { return ObjCType == Strong; }
198
199  static void SetObjCIvar(LValue& R, bool iValue) {
200    R.Ivar = iValue;
201  }
202
203  static void SetGlobalObjCRef(LValue& R, bool iValue) {
204    R.GlobalObjCRef = iValue;
205  }
206
207  static void SetObjCNonGC(LValue& R, bool iValue) {
208    R.NonGC = iValue;
209  }
210  static void SetObjCType(QualType::GCAttrTypes GCAttrs, LValue& R) {
211    if (GCAttrs == QualType::Weak)
212      R.ObjCType = Weak;
213    else if (GCAttrs == QualType::Strong)
214      R.ObjCType = Strong;
215    else
216     R.ObjCType = None;
217  }
218
219  // simple lvalue
220  llvm::Value *getAddress() const { assert(isSimple()); return V; }
221  // vector elt lvalue
222  llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; }
223  llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; }
224  // extended vector elements.
225  llvm::Value *getExtVectorAddr() const { assert(isExtVectorElt()); return V; }
226  llvm::Constant *getExtVectorElts() const {
227    assert(isExtVectorElt());
228    return VectorElts;
229  }
230  // bitfield lvalue
231  llvm::Value *getBitfieldAddr() const { assert(isBitfield()); return V; }
232  unsigned short getBitfieldStartBit() const {
233    assert(isBitfield());
234    return BitfieldData.StartBit;
235  }
236  unsigned short getBitfieldSize() const {
237    assert(isBitfield());
238    return BitfieldData.Size;
239  }
240  bool isBitfieldSigned() const {
241    assert(isBitfield());
242    return BitfieldData.IsSigned;
243  }
244  // property ref lvalue
245  const ObjCPropertyRefExpr *getPropertyRefExpr() const {
246    assert(isPropertyRef());
247    return PropertyRefExpr;
248  }
249
250  // 'implicit' property ref lvalue
251  const ObjCKVCRefExpr *getKVCRefExpr() const {
252    assert(isKVCRef());
253    return KVCRefExpr;
254  }
255
256  static LValue MakeAddr(llvm::Value *V, unsigned Qualifiers,
257                         QualType::GCAttrTypes GCAttrs = QualType::GCNone) {
258    LValue R;
259    R.LVType = Simple;
260    R.V = V;
261    SetQualifiers(Qualifiers,R);
262    SetObjCType(GCAttrs, R);
263    return R;
264  }
265
266  static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx,
267                              unsigned Qualifiers) {
268    LValue R;
269    R.LVType = VectorElt;
270    R.V = Vec;
271    R.VectorIdx = Idx;
272    SetQualifiers(Qualifiers,R);
273    return R;
274  }
275
276  static LValue MakeExtVectorElt(llvm::Value *Vec, llvm::Constant *Elts,
277                                 unsigned Qualifiers) {
278    LValue R;
279    R.LVType = ExtVectorElt;
280    R.V = Vec;
281    R.VectorElts = Elts;
282    SetQualifiers(Qualifiers,R);
283    return R;
284  }
285
286  static LValue MakeBitfield(llvm::Value *V, unsigned short StartBit,
287                             unsigned short Size, bool IsSigned,
288                             unsigned Qualifiers) {
289    LValue R;
290    R.LVType = BitField;
291    R.V = V;
292    R.BitfieldData.StartBit = StartBit;
293    R.BitfieldData.Size = Size;
294    R.BitfieldData.IsSigned = IsSigned;
295    SetQualifiers(Qualifiers,R);
296    return R;
297  }
298
299  // FIXME: It is probably bad that we aren't emitting the target when we build
300  // the lvalue. However, this complicates the code a bit, and I haven't figured
301  // out how to make it go wrong yet.
302  static LValue MakePropertyRef(const ObjCPropertyRefExpr *E,
303                                unsigned Qualifiers) {
304    LValue R;
305    R.LVType = PropertyRef;
306    R.PropertyRefExpr = E;
307    SetQualifiers(Qualifiers,R);
308    return R;
309  }
310
311  static LValue MakeKVCRef(const ObjCKVCRefExpr *E, unsigned Qualifiers) {
312    LValue R;
313    R.LVType = KVCRef;
314    R.KVCRefExpr = E;
315    SetQualifiers(Qualifiers,R);
316    return R;
317  }
318};
319
320}  // end namespace CodeGen
321}  // end namespace clang
322
323#endif
324