clang  7.0.0svn
APValue.h
Go to the documentation of this file.
1 //===--- APValue.h - Union class for APFloat/APSInt/Complex -----*- 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 the APValue class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_APVALUE_H
15 #define LLVM_CLANG_AST_APVALUE_H
16 
17 #include "clang/Basic/LLVM.h"
18 #include "llvm/ADT/APFloat.h"
19 #include "llvm/ADT/APSInt.h"
20 #include "llvm/ADT/PointerIntPair.h"
21 #include "llvm/ADT/PointerUnion.h"
22 
23 namespace clang {
24  class AddrLabelExpr;
25  class ASTContext;
26  class CharUnits;
27  class DiagnosticBuilder;
28  class Expr;
29  class FieldDecl;
30  class Decl;
31  class ValueDecl;
32  class CXXRecordDecl;
33  class QualType;
34 
35 /// APValue - This class implements a discriminated union of [uninitialized]
36 /// [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset],
37 /// [Vector: N * APValue], [Array: N * APValue]
38 class APValue {
39  typedef llvm::APSInt APSInt;
40  typedef llvm::APFloat APFloat;
41 public:
42  enum ValueKind {
44  Int,
55  };
56 
57  class LValueBase {
58  public:
59  typedef llvm::PointerUnion<const ValueDecl *, const Expr *> PtrTy;
60 
61  LValueBase() : CallIndex(0), Version(0) {}
62 
63  template <class T>
64  LValueBase(T P, unsigned I = 0, unsigned V = 0)
65  : Ptr(P), CallIndex(I), Version(V) {}
66 
67  template <class T>
68  bool is() const { return Ptr.is<T>(); }
69 
70  template <class T>
71  T get() const { return Ptr.get<T>(); }
72 
73  template <class T>
74  T dyn_cast() const { return Ptr.dyn_cast<T>(); }
75 
76  void *getOpaqueValue() const;
77 
78  bool isNull() const;
79 
80  explicit operator bool () const;
81 
82  PtrTy getPointer() const {
83  return Ptr;
84  }
85 
86  unsigned getCallIndex() const {
87  return CallIndex;
88  }
89 
90  void setCallIndex(unsigned Index) {
91  CallIndex = Index;
92  }
93 
94  unsigned getVersion() const {
95  return Version;
96  }
97 
98  bool operator==(const LValueBase &Other) const {
99  return Ptr == Other.Ptr && CallIndex == Other.CallIndex &&
100  Version == Other.Version;
101  }
102 
103  private:
104  PtrTy Ptr;
105  unsigned CallIndex, Version;
106  };
107 
108  typedef llvm::PointerIntPair<const Decl *, 1, bool> BaseOrMemberType;
110  /// BaseOrMember - The FieldDecl or CXXRecordDecl indicating the next item
111  /// in the path. An opaque value of type BaseOrMemberType.
113  /// ArrayIndex - The array index of the next item in the path.
114  uint64_t ArrayIndex;
115  };
116  struct NoLValuePath {};
117  struct UninitArray {};
118  struct UninitStruct {};
119 private:
120  ValueKind Kind;
121 
122  struct ComplexAPSInt {
123  APSInt Real, Imag;
124  ComplexAPSInt() : Real(1), Imag(1) {}
125  };
126  struct ComplexAPFloat {
127  APFloat Real, Imag;
128  ComplexAPFloat() : Real(0.0), Imag(0.0) {}
129  };
130  struct LV;
131  struct Vec {
132  APValue *Elts;
133  unsigned NumElts;
134  Vec() : Elts(nullptr), NumElts(0) {}
135  ~Vec() { delete[] Elts; }
136  };
137  struct Arr {
138  APValue *Elts;
139  unsigned NumElts, ArrSize;
140  Arr(unsigned NumElts, unsigned ArrSize);
141  ~Arr();
142  };
143  struct StructData {
144  APValue *Elts;
145  unsigned NumBases;
146  unsigned NumFields;
147  StructData(unsigned NumBases, unsigned NumFields);
148  ~StructData();
149  };
150  struct UnionData {
151  const FieldDecl *Field;
152  APValue *Value;
153  UnionData();
154  ~UnionData();
155  };
156  struct AddrLabelDiffData {
157  const AddrLabelExpr* LHSExpr;
158  const AddrLabelExpr* RHSExpr;
159  };
160  struct MemberPointerData;
161 
162  // We ensure elsewhere that Data is big enough for LV and MemberPointerData.
163  typedef llvm::AlignedCharArrayUnion<void *, APSInt, APFloat, ComplexAPSInt,
164  ComplexAPFloat, Vec, Arr, StructData,
165  UnionData, AddrLabelDiffData> DataType;
166  static const size_t DataSize = sizeof(DataType);
167 
168  DataType Data;
169 
170 public:
171  APValue() : Kind(Uninitialized) {}
172  explicit APValue(APSInt I) : Kind(Uninitialized) {
173  MakeInt(); setInt(std::move(I));
174  }
175  explicit APValue(APFloat F) : Kind(Uninitialized) {
176  MakeFloat(); setFloat(std::move(F));
177  }
178  explicit APValue(const APValue *E, unsigned N) : Kind(Uninitialized) {
179  MakeVector(); setVector(E, N);
180  }
181  APValue(APSInt R, APSInt I) : Kind(Uninitialized) {
182  MakeComplexInt(); setComplexInt(std::move(R), std::move(I));
183  }
184  APValue(APFloat R, APFloat I) : Kind(Uninitialized) {
185  MakeComplexFloat(); setComplexFloat(std::move(R), std::move(I));
186  }
187  APValue(const APValue &RHS);
188  APValue(APValue &&RHS) : Kind(Uninitialized) { swap(RHS); }
190  bool IsNullPtr = false)
191  : Kind(Uninitialized) {
192  MakeLValue(); setLValue(B, O, N, IsNullPtr);
193  }
195  bool OnePastTheEnd, bool IsNullPtr = false)
196  : Kind(Uninitialized) {
197  MakeLValue(); setLValue(B, O, Path, OnePastTheEnd, IsNullPtr);
198  }
199  APValue(UninitArray, unsigned InitElts, unsigned Size) : Kind(Uninitialized) {
200  MakeArray(InitElts, Size);
201  }
202  APValue(UninitStruct, unsigned B, unsigned M) : Kind(Uninitialized) {
203  MakeStruct(B, M);
204  }
205  explicit APValue(const FieldDecl *D, const APValue &V = APValue())
206  : Kind(Uninitialized) {
207  MakeUnion(); setUnion(D, V);
208  }
209  APValue(const ValueDecl *Member, bool IsDerivedMember,
211  MakeMemberPointer(Member, IsDerivedMember, Path);
212  }
213  APValue(const AddrLabelExpr* LHSExpr, const AddrLabelExpr* RHSExpr)
214  : Kind(Uninitialized) {
215  MakeAddrLabelDiff(); setAddrLabelDiff(LHSExpr, RHSExpr);
216  }
217 
219  MakeUninit();
220  }
221 
222  /// Returns whether the object performed allocations.
223  ///
224  /// If APValues are constructed via placement new, \c needsCleanup()
225  /// indicates whether the destructor must be called in order to correctly
226  /// free all allocated memory.
227  bool needsCleanup() const;
228 
229  /// Swaps the contents of this and the given APValue.
230  void swap(APValue &RHS);
231 
232  ValueKind getKind() const { return Kind; }
233  bool isUninit() const { return Kind == Uninitialized; }
234  bool isInt() const { return Kind == Int; }
235  bool isFloat() const { return Kind == Float; }
236  bool isComplexInt() const { return Kind == ComplexInt; }
237  bool isComplexFloat() const { return Kind == ComplexFloat; }
238  bool isLValue() const { return Kind == LValue; }
239  bool isVector() const { return Kind == Vector; }
240  bool isArray() const { return Kind == Array; }
241  bool isStruct() const { return Kind == Struct; }
242  bool isUnion() const { return Kind == Union; }
243  bool isMemberPointer() const { return Kind == MemberPointer; }
244  bool isAddrLabelDiff() const { return Kind == AddrLabelDiff; }
245 
246  void dump() const;
247  void dump(raw_ostream &OS) const;
248 
249  void printPretty(raw_ostream &OS, ASTContext &Ctx, QualType Ty) const;
250  std::string getAsString(ASTContext &Ctx, QualType Ty) const;
251 
252  APSInt &getInt() {
253  assert(isInt() && "Invalid accessor");
254  return *(APSInt*)(char*)Data.buffer;
255  }
256  const APSInt &getInt() const {
257  return const_cast<APValue*>(this)->getInt();
258  }
259 
260  APFloat &getFloat() {
261  assert(isFloat() && "Invalid accessor");
262  return *(APFloat*)(char*)Data.buffer;
263  }
264  const APFloat &getFloat() const {
265  return const_cast<APValue*>(this)->getFloat();
266  }
267 
268  APSInt &getComplexIntReal() {
269  assert(isComplexInt() && "Invalid accessor");
270  return ((ComplexAPSInt*)(char*)Data.buffer)->Real;
271  }
272  const APSInt &getComplexIntReal() const {
273  return const_cast<APValue*>(this)->getComplexIntReal();
274  }
275 
276  APSInt &getComplexIntImag() {
277  assert(isComplexInt() && "Invalid accessor");
278  return ((ComplexAPSInt*)(char*)Data.buffer)->Imag;
279  }
280  const APSInt &getComplexIntImag() const {
281  return const_cast<APValue*>(this)->getComplexIntImag();
282  }
283 
284  APFloat &getComplexFloatReal() {
285  assert(isComplexFloat() && "Invalid accessor");
286  return ((ComplexAPFloat*)(char*)Data.buffer)->Real;
287  }
288  const APFloat &getComplexFloatReal() const {
289  return const_cast<APValue*>(this)->getComplexFloatReal();
290  }
291 
292  APFloat &getComplexFloatImag() {
293  assert(isComplexFloat() && "Invalid accessor");
294  return ((ComplexAPFloat*)(char*)Data.buffer)->Imag;
295  }
296  const APFloat &getComplexFloatImag() const {
297  return const_cast<APValue*>(this)->getComplexFloatImag();
298  }
299 
300  const LValueBase getLValueBase() const;
302  const CharUnits &getLValueOffset() const {
303  return const_cast<APValue*>(this)->getLValueOffset();
304  }
305  bool isLValueOnePastTheEnd() const;
306  bool hasLValuePath() const;
308  unsigned getLValueCallIndex() const;
309  unsigned getLValueVersion() const;
310  bool isNullPointer() const;
311 
312  APValue &getVectorElt(unsigned I) {
313  assert(isVector() && "Invalid accessor");
314  assert(I < getVectorLength() && "Index out of range");
315  return ((Vec*)(char*)Data.buffer)->Elts[I];
316  }
317  const APValue &getVectorElt(unsigned I) const {
318  return const_cast<APValue*>(this)->getVectorElt(I);
319  }
320  unsigned getVectorLength() const {
321  assert(isVector() && "Invalid accessor");
322  return ((const Vec*)(const void *)Data.buffer)->NumElts;
323  }
324 
326  assert(isArray() && "Invalid accessor");
327  assert(I < getArrayInitializedElts() && "Index out of range");
328  return ((Arr*)(char*)Data.buffer)->Elts[I];
329  }
330  const APValue &getArrayInitializedElt(unsigned I) const {
331  return const_cast<APValue*>(this)->getArrayInitializedElt(I);
332  }
333  bool hasArrayFiller() const {
335  }
337  assert(isArray() && "Invalid accessor");
338  assert(hasArrayFiller() && "No array filler");
339  return ((Arr*)(char*)Data.buffer)->Elts[getArrayInitializedElts()];
340  }
341  const APValue &getArrayFiller() const {
342  return const_cast<APValue*>(this)->getArrayFiller();
343  }
344  unsigned getArrayInitializedElts() const {
345  assert(isArray() && "Invalid accessor");
346  return ((const Arr*)(const void *)Data.buffer)->NumElts;
347  }
348  unsigned getArraySize() const {
349  assert(isArray() && "Invalid accessor");
350  return ((const Arr*)(const void *)Data.buffer)->ArrSize;
351  }
352 
353  unsigned getStructNumBases() const {
354  assert(isStruct() && "Invalid accessor");
355  return ((const StructData*)(const char*)Data.buffer)->NumBases;
356  }
357  unsigned getStructNumFields() const {
358  assert(isStruct() && "Invalid accessor");
359  return ((const StructData*)(const char*)Data.buffer)->NumFields;
360  }
361  APValue &getStructBase(unsigned i) {
362  assert(isStruct() && "Invalid accessor");
363  return ((StructData*)(char*)Data.buffer)->Elts[i];
364  }
365  APValue &getStructField(unsigned i) {
366  assert(isStruct() && "Invalid accessor");
367  return ((StructData*)(char*)Data.buffer)->Elts[getStructNumBases() + i];
368  }
369  const APValue &getStructBase(unsigned i) const {
370  return const_cast<APValue*>(this)->getStructBase(i);
371  }
372  const APValue &getStructField(unsigned i) const {
373  return const_cast<APValue*>(this)->getStructField(i);
374  }
375 
376  const FieldDecl *getUnionField() const {
377  assert(isUnion() && "Invalid accessor");
378  return ((const UnionData*)(const char*)Data.buffer)->Field;
379  }
381  assert(isUnion() && "Invalid accessor");
382  return *((UnionData*)(char*)Data.buffer)->Value;
383  }
384  const APValue &getUnionValue() const {
385  return const_cast<APValue*>(this)->getUnionValue();
386  }
387 
388  const ValueDecl *getMemberPointerDecl() const;
389  bool isMemberPointerToDerivedMember() const;
391 
393  assert(isAddrLabelDiff() && "Invalid accessor");
394  return ((const AddrLabelDiffData*)(const char*)Data.buffer)->LHSExpr;
395  }
397  assert(isAddrLabelDiff() && "Invalid accessor");
398  return ((const AddrLabelDiffData*)(const char*)Data.buffer)->RHSExpr;
399  }
400 
401  void setInt(APSInt I) {
402  assert(isInt() && "Invalid accessor");
403  *(APSInt *)(char *)Data.buffer = std::move(I);
404  }
405  void setFloat(APFloat F) {
406  assert(isFloat() && "Invalid accessor");
407  *(APFloat *)(char *)Data.buffer = std::move(F);
408  }
409  void setVector(const APValue *E, unsigned N) {
410  assert(isVector() && "Invalid accessor");
411  ((Vec*)(char*)Data.buffer)->Elts = new APValue[N];
412  ((Vec*)(char*)Data.buffer)->NumElts = N;
413  for (unsigned i = 0; i != N; ++i)
414  ((Vec*)(char*)Data.buffer)->Elts[i] = E[i];
415  }
416  void setComplexInt(APSInt R, APSInt I) {
417  assert(R.getBitWidth() == I.getBitWidth() &&
418  "Invalid complex int (type mismatch).");
419  assert(isComplexInt() && "Invalid accessor");
420  ((ComplexAPSInt *)(char *)Data.buffer)->Real = std::move(R);
421  ((ComplexAPSInt *)(char *)Data.buffer)->Imag = std::move(I);
422  }
423  void setComplexFloat(APFloat R, APFloat I) {
424  assert(&R.getSemantics() == &I.getSemantics() &&
425  "Invalid complex float (type mismatch).");
426  assert(isComplexFloat() && "Invalid accessor");
427  ((ComplexAPFloat *)(char *)Data.buffer)->Real = std::move(R);
428  ((ComplexAPFloat *)(char *)Data.buffer)->Imag = std::move(I);
429  }
430  void setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
431  bool IsNullPtr);
432  void setLValue(LValueBase B, const CharUnits &O,
433  ArrayRef<LValuePathEntry> Path, bool OnePastTheEnd,
434  bool IsNullPtr);
435  void setUnion(const FieldDecl *Field, const APValue &Value) {
436  assert(isUnion() && "Invalid accessor");
437  ((UnionData*)(char*)Data.buffer)->Field = Field;
438  *((UnionData*)(char*)Data.buffer)->Value = Value;
439  }
440  void setAddrLabelDiff(const AddrLabelExpr* LHSExpr,
441  const AddrLabelExpr* RHSExpr) {
442  ((AddrLabelDiffData*)(char*)Data.buffer)->LHSExpr = LHSExpr;
443  ((AddrLabelDiffData*)(char*)Data.buffer)->RHSExpr = RHSExpr;
444  }
445 
446  /// Assign by swapping from a copy of the RHS.
448  swap(RHS);
449  return *this;
450  }
451 
452 private:
453  void DestroyDataAndMakeUninit();
454  void MakeUninit() {
455  if (Kind != Uninitialized)
456  DestroyDataAndMakeUninit();
457  }
458  void MakeInt() {
459  assert(isUninit() && "Bad state change");
460  new ((void*)Data.buffer) APSInt(1);
461  Kind = Int;
462  }
463  void MakeFloat() {
464  assert(isUninit() && "Bad state change");
465  new ((void*)(char*)Data.buffer) APFloat(0.0);
466  Kind = Float;
467  }
468  void MakeVector() {
469  assert(isUninit() && "Bad state change");
470  new ((void*)(char*)Data.buffer) Vec();
471  Kind = Vector;
472  }
473  void MakeComplexInt() {
474  assert(isUninit() && "Bad state change");
475  new ((void*)(char*)Data.buffer) ComplexAPSInt();
476  Kind = ComplexInt;
477  }
478  void MakeComplexFloat() {
479  assert(isUninit() && "Bad state change");
480  new ((void*)(char*)Data.buffer) ComplexAPFloat();
481  Kind = ComplexFloat;
482  }
483  void MakeLValue();
484  void MakeArray(unsigned InitElts, unsigned Size);
485  void MakeStruct(unsigned B, unsigned M) {
486  assert(isUninit() && "Bad state change");
487  new ((void*)(char*)Data.buffer) StructData(B, M);
488  Kind = Struct;
489  }
490  void MakeUnion() {
491  assert(isUninit() && "Bad state change");
492  new ((void*)(char*)Data.buffer) UnionData();
493  Kind = Union;
494  }
495  void MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
497  void MakeAddrLabelDiff() {
498  assert(isUninit() && "Bad state change");
499  new ((void*)(char*)Data.buffer) AddrLabelDiffData();
500  Kind = AddrLabelDiff;
501  }
502 };
503 
504 } // end namespace clang.
505 
506 namespace llvm {
507 template<> struct DenseMapInfo<clang::APValue::LValueBase> {
508  static clang::APValue::LValueBase getEmptyKey();
509  static clang::APValue::LValueBase getTombstoneKey();
510  static unsigned getHashValue(const clang::APValue::LValueBase &Base);
511  static bool isEqual(const clang::APValue::LValueBase &LHS,
512  const clang::APValue::LValueBase &RHS);
513 };
514 }
515 
516 #endif
unsigned getStructNumFields() const
Definition: APValue.h:357
A (possibly-)qualified type.
Definition: Type.h:654
APValue(const AddrLabelExpr *LHSExpr, const AddrLabelExpr *RHSExpr)
Definition: APValue.h:213
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
llvm::PointerUnion< const ValueDecl *, const Expr * > PtrTy
Definition: APValue.h:59
StringRef P
bool isUninit() const
Definition: APValue.h:233
APValue(UninitStruct, unsigned B, unsigned M)
Definition: APValue.h:202
bool isVector() const
Definition: APValue.h:239
void * BaseOrMember
BaseOrMember - The FieldDecl or CXXRecordDecl indicating the next item in the path.
Definition: APValue.h:112
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
const APValue & getStructField(unsigned i) const
Definition: APValue.h:372
const AddrLabelExpr * getAddrLabelDiffLHS() const
Definition: APValue.h:392
PtrTy getPointer() const
Definition: APValue.h:82
APFloat & getComplexFloatReal()
Definition: APValue.h:284
void dump() const
Definition: APValue.cpp:300
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:615
const APFloat & getComplexFloatReal() const
Definition: APValue.h:288
bool isAddrLabelDiff() const
Definition: APValue.h:244
const APValue & getArrayFiller() const
Definition: APValue.h:341
const APSInt & getComplexIntReal() const
Definition: APValue.h:272
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:600
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:660
unsigned getVersion() const
Definition: APValue.h:94
APValue & operator=(APValue RHS)
Assign by swapping from a copy of the RHS.
Definition: APValue.h:447
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
APValue(const APValue *E, unsigned N)
Definition: APValue.h:178
Represents a member of a struct/union/class.
Definition: Decl.h:2521
const APValue & getUnionValue() const
Definition: APValue.h:384
unsigned getCallIndex() const
Definition: APValue.h:86
unsigned getArraySize() const
Definition: APValue.h:348
unsigned getLValueCallIndex() const
Definition: APValue.cpp:621
bool isFloat() const
Definition: APValue.h:235
bool operator==(const LValueBase &Other) const
Definition: APValue.h:98
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:587
void setCallIndex(unsigned Index)
Definition: APValue.h:90
bool isComplexFloat() const
Definition: APValue.h:237
bool isComplexInt() const
Definition: APValue.h:236
void printPretty(raw_ostream &OS, ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:386
bool isInt() const
Definition: APValue.h:234
APValue(APSInt I)
Definition: APValue.h:172
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:257
APSInt & getComplexIntReal()
Definition: APValue.h:268
APValue(UninitArray, unsigned InitElts, unsigned Size)
Definition: APValue.h:199
APValue & getVectorElt(unsigned I)
Definition: APValue.h:312
unsigned getLValueVersion() const
Definition: APValue.cpp:626
bool isUnion() const
Definition: APValue.h:242
bool hasLValuePath() const
Definition: APValue.cpp:610
const APFloat & getComplexFloatImag() const
Definition: APValue.h:296
APValue(APFloat F)
Definition: APValue.h:175
APValue & getArrayFiller()
Definition: APValue.h:336
uint64_t ArrayIndex
ArrayIndex - The array index of the next item in the path.
Definition: APValue.h:114
bool hasArrayFiller() const
Definition: APValue.h:333
const APValue & getVectorElt(unsigned I) const
Definition: APValue.h:317
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
const FunctionProtoType * T
const APSInt & getInt() const
Definition: APValue.h:256
#define bool
Definition: stdbool.h:31
APValue(const FieldDecl *D, const APValue &V=APValue())
Definition: APValue.h:205
APValue(APFloat R, APFloat I)
Definition: APValue.h:184
APValue & getStructField(unsigned i)
Definition: APValue.h:365
bool isNullPointer() const
Definition: APValue.cpp:631
APSInt & getComplexIntImag()
Definition: APValue.h:276
const APValue & getArrayInitializedElt(unsigned I) const
Definition: APValue.h:330
APValue(const ValueDecl *Member, bool IsDerivedMember, ArrayRef< const CXXRecordDecl *> Path)
Definition: APValue.h:209
const FieldDecl * getUnionField() const
Definition: APValue.h:376
void setVector(const APValue *E, unsigned N)
Definition: APValue.h:409
APValue & getStructBase(unsigned i)
Definition: APValue.h:361
unsigned getStructNumBases() const
Definition: APValue.h:353
LValueBase(T P, unsigned I=0, unsigned V=0)
Definition: APValue.h:64
APValue & getArrayInitializedElt(unsigned I)
Definition: APValue.h:325
Kind
const LValueBase getLValueBase() const
Definition: APValue.cpp:595
void * getOpaqueValue() const
Definition: APValue.cpp:34
const APSInt & getComplexIntImag() const
Definition: APValue.h:280
void setInt(APSInt I)
Definition: APValue.h:401
void setLValue(LValueBase B, const CharUnits &O, NoLValuePath, bool IsNullPtr)
Definition: APValue.cpp:636
const AddrLabelExpr * getAddrLabelDiffRHS() const
Definition: APValue.h:396
APValue & getUnionValue()
Definition: APValue.h:380
APFloat & getFloat()
Definition: APValue.h:260
bool isMemberPointer() const
Definition: APValue.h:243
void setAddrLabelDiff(const AddrLabelExpr *LHSExpr, const AddrLabelExpr *RHSExpr)
Definition: APValue.h:440
bool isLValue() const
Definition: APValue.h:238
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:667
const APValue & getStructBase(unsigned i) const
Definition: APValue.h:369
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3475
Dataflow Directional Tag Classes.
void swap(APValue &RHS)
Swaps the contents of this and the given APValue.
Definition: APValue.cpp:292
unsigned getArrayInitializedElts() const
Definition: APValue.h:344
APValue(APSInt R, APSInt I)
Definition: APValue.h:181
APValue(LValueBase B, const CharUnits &O, NoLValuePath N, bool IsNullPtr=false)
Definition: APValue.h:189
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:674
const APFloat & getFloat() const
Definition: APValue.h:264
bool isArray() const
Definition: APValue.h:240
bool isStruct() const
Definition: APValue.h:241
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
ValueKind getKind() const
Definition: APValue.h:232
APFloat & getComplexFloatImag()
Definition: APValue.h:292
const CharUnits & getLValueOffset() const
Definition: APValue.h:302
APValue(LValueBase B, const CharUnits &O, ArrayRef< LValuePathEntry > Path, bool OnePastTheEnd, bool IsNullPtr=false)
Definition: APValue.h:194
llvm::PointerIntPair< const Decl *, 1, bool > BaseOrMemberType
Definition: APValue.h:108
void setFloat(APFloat F)
Definition: APValue.h:405
void setComplexInt(APSInt R, APSInt I)
Definition: APValue.h:416
void setUnion(const FieldDecl *Field, const APValue &Value)
Definition: APValue.h:435
APSInt & getInt()
Definition: APValue.h:252
void setComplexFloat(APFloat R, APFloat I)
Definition: APValue.h:423
CharUnits & getLValueOffset()
Definition: APValue.cpp:605
APValue(APValue &&RHS)
Definition: APValue.h:188
unsigned getVectorLength() const
Definition: APValue.h:320