contrib/llvm/tools/clang/include/clang/AST/APValue.h

   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/APSInt.h"
  19 #include "llvm/ADT/APFloat.h"
  20
  21 namespace clang {
  22   class CharUnits;
  23   class DiagnosticBuilder;
  24   class Expr;
  25
  26 /// APValue - This class implements a discriminated union of [uninitialized]
  27 /// [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset].
  28 class APValue {
  29   typedef llvm::APSInt APSInt;
  30   typedef llvm::APFloat APFloat;
  31 public:
  32   enum ValueKind {
  33     Uninitialized,
  34     Int,
  35     Float,
  36     ComplexInt,
  37     ComplexFloat,
  38     LValue,
  39     Vector
  40   };
  41 private:
  42   ValueKind Kind;
  43
  44   struct ComplexAPSInt {
  45     APSInt Real, Imag;
  46     ComplexAPSInt() : Real(1), Imag(1) {}
  47   };
  48   struct ComplexAPFloat {
  49     APFloat Real, Imag;
  50     ComplexAPFloat() : Real(0.0), Imag(0.0) {}
  51   };
  52
  53   struct Vec {
  54     APValue *Elts;
  55     unsigned NumElts;
  56     Vec() : Elts(0), NumElts(0) {}
  57     ~Vec() { delete[] Elts; }
  58   };
  59
  60   enum {
  61     MaxSize = (sizeof(ComplexAPSInt) > sizeof(ComplexAPFloat) ?
  62                sizeof(ComplexAPSInt) : sizeof(ComplexAPFloat))
  63   };
  64
  65   union {
  66     void *Aligner;
  67     char Data[MaxSize];
  68   };
  69
  70 public:
  71   APValue() : Kind(Uninitialized) {}
  72   explicit APValue(const APSInt &I) : Kind(Uninitialized) {
  73     MakeInt(); setInt(I);
  74   }
  75   explicit APValue(const APFloat &F) : Kind(Uninitialized) {
  76     MakeFloat(); setFloat(F);
  77   }
  78   explicit APValue(const APValue *E, unsigned N) : Kind(Uninitialized) {
  79     MakeVector(); setVector(E, N);
  80   }
  81   APValue(const APSInt &R, const APSInt &I) : Kind(Uninitialized) {
  82     MakeComplexInt(); setComplexInt(R, I);
  83   }
  84   APValue(const APFloat &R, const APFloat &I) : Kind(Uninitialized) {
  85     MakeComplexFloat(); setComplexFloat(R, I);
  86   }
  87   APValue(const APValue &RHS) : Kind(Uninitialized) {
  88     *this = RHS;
  89   }
  90   APValue(const Expr* B, const CharUnits &O) : Kind(Uninitialized) {
  91     MakeLValue(); setLValue(B, O);
  92   }
  93   APValue(const Expr* B);
  94
  95   ~APValue() {
  96     MakeUninit();
  97   }
  98
  99   ValueKind getKind() const { return Kind; }
 100   bool isUninit() const { return Kind == Uninitialized; }
 101   bool isInt() const { return Kind == Int; }
 102   bool isFloat() const { return Kind == Float; }
 103   bool isComplexInt() const { return Kind == ComplexInt; }
 104   bool isComplexFloat() const { return Kind == ComplexFloat; }
 105   bool isLValue() const { return Kind == LValue; }
 106   bool isVector() const { return Kind == Vector; }
 107
 108   void print(raw_ostream &OS) const;
 109   void dump() const;
 110
 111   APSInt &getInt() {
 112     assert(isInt() && "Invalid accessor");
 113     return *(APSInt*)(char*)Data;
 114   }
 115   const APSInt &getInt() const {
 116     return const_cast<APValue*>(this)->getInt();
 117   }
 118
 119   APFloat &getFloat() {
 120     assert(isFloat() && "Invalid accessor");
 121     return *(APFloat*)(char*)Data;
 122   }
 123   const APFloat &getFloat() const {
 124     return const_cast<APValue*>(this)->getFloat();
 125   }
 126
 127   APValue &getVectorElt(unsigned i) {
 128     assert(isVector() && "Invalid accessor");
 129     return ((Vec*)(char*)Data)->Elts[i];
 130   }
 131   const APValue &getVectorElt(unsigned i) const {
 132     assert(isVector() && "Invalid accessor");
 133     return ((const Vec*)(const char*)Data)->Elts[i];
 134   }
 135   unsigned getVectorLength() const {
 136     assert(isVector() && "Invalid accessor");
 137     return ((const Vec*)(const void *)Data)->NumElts;
 138   }
 139
 140   APSInt &getComplexIntReal() {
 141     assert(isComplexInt() && "Invalid accessor");
 142     return ((ComplexAPSInt*)(char*)Data)->Real;
 143   }
 144   const APSInt &getComplexIntReal() const {
 145     return const_cast<APValue*>(this)->getComplexIntReal();
 146   }
 147
 148   APSInt &getComplexIntImag() {
 149     assert(isComplexInt() && "Invalid accessor");
 150     return ((ComplexAPSInt*)(char*)Data)->Imag;
 151   }
 152   const APSInt &getComplexIntImag() const {
 153     return const_cast<APValue*>(this)->getComplexIntImag();
 154   }
 155
 156   APFloat &getComplexFloatReal() {
 157     assert(isComplexFloat() && "Invalid accessor");
 158     return ((ComplexAPFloat*)(char*)Data)->Real;
 159   }
 160   const APFloat &getComplexFloatReal() const {
 161     return const_cast<APValue*>(this)->getComplexFloatReal();
 162   }
 163
 164   APFloat &getComplexFloatImag() {
 165     assert(isComplexFloat() && "Invalid accessor");
 166     return ((ComplexAPFloat*)(char*)Data)->Imag;
 167   }
 168   const APFloat &getComplexFloatImag() const {
 169     return const_cast<APValue*>(this)->getComplexFloatImag();
 170   }
 171
 172   const Expr* getLValueBase() const;
 173   CharUnits getLValueOffset() const;
 174
 175   void setInt(const APSInt &I) {
 176     assert(isInt() && "Invalid accessor");
 177     *(APSInt*)(char*)Data = I;
 178   }
 179   void setFloat(const APFloat &F) {
 180     assert(isFloat() && "Invalid accessor");
 181     *(APFloat*)(char*)Data = F;
 182   }
 183   void setVector(const APValue *E, unsigned N) {
 184     assert(isVector() && "Invalid accessor");
 185     ((Vec*)(char*)Data)->Elts = new APValue[N];
 186     ((Vec*)(char*)Data)->NumElts = N;
 187     for (unsigned i = 0; i != N; ++i)
 188       ((Vec*)(char*)Data)->Elts[i] = E[i];
 189   }
 190   void setComplexInt(const APSInt &R, const APSInt &I) {
 191     assert(R.getBitWidth() == I.getBitWidth() &&
 192            "Invalid complex int (type mismatch).");
 193     assert(isComplexInt() && "Invalid accessor");
 194     ((ComplexAPSInt*)(char*)Data)->Real = R;
 195     ((ComplexAPSInt*)(char*)Data)->Imag = I;
 196   }
 197   void setComplexFloat(const APFloat &R, const APFloat &I) {
 198     assert(&R.getSemantics() == &I.getSemantics() &&
 199            "Invalid complex float (type mismatch).");
 200     assert(isComplexFloat() && "Invalid accessor");
 201     ((ComplexAPFloat*)(char*)Data)->Real = R;
 202     ((ComplexAPFloat*)(char*)Data)->Imag = I;
 203   }
 204   void setLValue(const Expr *B, const CharUnits &O);
 205
 206   const APValue &operator=(const APValue &RHS);
 207
 208 private:
 209   void MakeUninit();
 210   void MakeInt() {
 211     assert(isUninit() && "Bad state change");
 212     new ((void*)Data) APSInt(1);
 213     Kind = Int;
 214   }
 215   void MakeFloat() {
 216     assert(isUninit() && "Bad state change");
 217     new ((void*)(char*)Data) APFloat(0.0);
 218     Kind = Float;
 219   }
 220   void MakeVector() {
 221     assert(isUninit() && "Bad state change");
 222     new ((void*)(char*)Data) Vec();
 223     Kind = Vector;
 224   }
 225   void MakeComplexInt() {
 226     assert(isUninit() && "Bad state change");
 227     new ((void*)(char*)Data) ComplexAPSInt();
 228     Kind = ComplexInt;
 229   }
 230   void MakeComplexFloat() {
 231     assert(isUninit() && "Bad state change");
 232     new ((void*)(char*)Data) ComplexAPFloat();
 233     Kind = ComplexFloat;
 234   }
 235   void MakeLValue();
 236 };
 237
 238 inline raw_ostream &operator<<(raw_ostream &OS, const APValue &V) {
 239   V.print(OS);
 240   return OS;
 241 }
 242
 243 // Writes a concise representation of V to DB, in a single << operation.
 244 const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 245                                     const APValue &V);
 246
 247 } // end namespace clang.
 248
 249 #endif