lib/VMCore/LLVMContextImpl.h

   1 //===----------------- LLVMContextImpl.h - Implementation ------*- 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 declares LLVMContextImpl, the opaque implementation
  11 //  of LLVMContext.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_LLVMCONTEXT_IMPL_H
  16 #define LLVM_LLVMCONTEXT_IMPL_H
  17
  18 #include "ConstantsContext.h"
  19 #include "TypesContext.h"
  20 #include "llvm/LLVMContext.h"
  21 #include "llvm/Constants.h"
  22 #include "llvm/DerivedTypes.h"
  23 #include "llvm/System/Mutex.h"
  24 #include "llvm/System/RWMutex.h"
  25 #include "llvm/Assembly/Writer.h"
  26 #include "llvm/ADT/APFloat.h"
  27 #include "llvm/ADT/APInt.h"
  28 #include "llvm/ADT/DenseMap.h"
  29 #include "llvm/ADT/FoldingSet.h"
  30 #include "llvm/ADT/StringMap.h"
  31 #include <vector>
  32
  33 namespace llvm {
  34
  35 class ConstantInt;
  36 class ConstantFP;
  37 class MDString;
  38 class MDNode;
  39 class LLVMContext;
  40 class Type;
  41 class Value;
  42
  43 struct DenseMapAPIntKeyInfo {
  44   struct KeyTy {
  45     APInt val;
  46     const Type* type;
  47     KeyTy(const APInt& V, const Type* Ty) : val(V), type(Ty) {}
  48     KeyTy(const KeyTy& that) : val(that.val), type(that.type) {}
  49     bool operator==(const KeyTy& that) const {
  50       return type == that.type && this->val == that.val;
  51     }
  52     bool operator!=(const KeyTy& that) const {
  53       return !this->operator==(that);
  54     }
  55   };
  56   static inline KeyTy getEmptyKey() { return KeyTy(APInt(1,0), 0); }
  57   static inline KeyTy getTombstoneKey() { return KeyTy(APInt(1,1), 0); }
  58   static unsigned getHashValue(const KeyTy &Key) {
  59     return DenseMapInfo<void*>::getHashValue(Key.type) ^
  60       Key.val.getHashValue();
  61   }
  62   static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
  63     return LHS == RHS;
  64   }
  65   static bool isPod() { return false; }
  66 };
  67
  68 struct DenseMapAPFloatKeyInfo {
  69   struct KeyTy {
  70     APFloat val;
  71     KeyTy(const APFloat& V) : val(V){}
  72     KeyTy(const KeyTy& that) : val(that.val) {}
  73     bool operator==(const KeyTy& that) const {
  74       return this->val.bitwiseIsEqual(that.val);
  75     }
  76     bool operator!=(const KeyTy& that) const {
  77       return !this->operator==(that);
  78     }
  79   };
  80   static inline KeyTy getEmptyKey() {
  81     return KeyTy(APFloat(APFloat::Bogus,1));
  82   }
  83   static inline KeyTy getTombstoneKey() {
  84     return KeyTy(APFloat(APFloat::Bogus,2));
  85   }
  86   static unsigned getHashValue(const KeyTy &Key) {
  87     return Key.val.getHashValue();
  88   }
  89   static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
  90     return LHS == RHS;
  91   }
  92   static bool isPod() { return false; }
  93 };
  94
  95 class LLVMContextImpl {
  96 public:
  97   sys::SmartRWMutex<true> ConstantsLock;
  98
  99   typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*,
 100                          DenseMapAPIntKeyInfo> IntMapTy;
 101   IntMapTy IntConstants;
 102
 103   typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
 104                          DenseMapAPFloatKeyInfo> FPMapTy;
 105   FPMapTy FPConstants;
 106
 107   StringMap<MDString*> MDStringCache;
 108
 109   ValueMap<char, Type, ConstantAggregateZero> AggZeroConstants;
 110
 111   typedef ValueMap<std::vector<Value*>, Type, MDNode, true /*largekey*/>
 112   MDNodeMapTy;
 113
 114   MDNodeMapTy MDNodes;
 115
 116   typedef ValueMap<std::vector<Constant*>, ArrayType,
 117     ConstantArray, true /*largekey*/> ArrayConstantsTy;
 118   ArrayConstantsTy ArrayConstants;
 119
 120   typedef ValueMap<std::vector<Constant*>, StructType,
 121                    ConstantStruct, true /*largekey*/> StructConstantsTy;
 122   StructConstantsTy StructConstants;
 123
 124   typedef ValueMap<std::vector<Constant*>, VectorType,
 125                    ConstantVector> VectorConstantsTy;
 126   VectorConstantsTy VectorConstants;
 127
 128   ValueMap<char, PointerType, ConstantPointerNull> NullPtrConstants;
 129
 130   ValueMap<char, Type, UndefValue> UndefValueConstants;
 131
 132   ValueMap<ExprMapKeyType, Type, ConstantExpr> ExprConstants;
 133
 134   ConstantInt *TheTrueVal;
 135   ConstantInt *TheFalseVal;
 136
 137   // Lock used for guarding access to the type maps.
 138   sys::SmartMutex<true> TypeMapLock;
 139
 140   // Recursive lock used for guarding access to AbstractTypeUsers.
 141   // NOTE: The true template parameter means this will no-op when we're not in
 142   // multithreaded mode.
 143   sys::SmartMutex<true> AbstractTypeUsersLock;
 144
 145   // Concrete/Abstract TypeDescriptions - We lazily calculate type descriptions
 146   // for types as they are needed.  Because resolution of types must invalidate
 147   // all of the abstract type descriptions, we keep them in a seperate map to
 148   // make this easy.
 149   TypePrinting ConcreteTypeDescriptions;
 150   TypePrinting AbstractTypeDescriptions;
 151
 152   TypeMap<ArrayValType, ArrayType> ArrayTypes;
 153   TypeMap<VectorValType, VectorType> VectorTypes;
 154   TypeMap<PointerValType, PointerType> PointerTypes;
 155   TypeMap<FunctionValType, FunctionType> FunctionTypes;
 156   TypeMap<StructValType, StructType> StructTypes;
 157   TypeMap<IntegerValType, IntegerType> IntegerTypes;
 158
 159   const Type *VoidTy;
 160   const Type *LabelTy;
 161   const Type *FloatTy;
 162   const Type *DoubleTy;
 163   const Type *MetadataTy;
 164   const Type *X86_FP80Ty;
 165   const Type *FP128Ty;
 166   const Type *PPC_FP128Ty;
 167
 168   const IntegerType *Int1Ty;
 169   const IntegerType *Int8Ty;
 170   const IntegerType *Int16Ty;
 171   const IntegerType *Int32Ty;
 172   const IntegerType *Int64Ty;
 173
 174   LLVMContextImpl(LLVMContext &C) : TheTrueVal(0), TheFalseVal(0),
 175     VoidTy(new Type(C, Type::VoidTyID)),
 176     LabelTy(new Type(C, Type::LabelTyID)),
 177     FloatTy(new Type(C, Type::FloatTyID)),
 178     DoubleTy(new Type(C, Type::DoubleTyID)),
 179     MetadataTy(new Type(C, Type::MetadataTyID)),
 180     X86_FP80Ty(new Type(C, Type::X86_FP80TyID)),
 181     FP128Ty(new Type(C, Type::FP128TyID)),
 182     PPC_FP128Ty(new Type(C, Type::PPC_FP128TyID)),
 183     Int1Ty(new IntegerType(C, 1)),
 184     Int8Ty(new IntegerType(C, 8)),
 185     Int16Ty(new IntegerType(C, 16)),
 186     Int32Ty(new IntegerType(C, 32)),
 187     Int64Ty(new IntegerType(C, 64)) { }
 188
 189   ~LLVMContextImpl() {
 190     // In principle, we should delete the member types here.  However,
 191     // this causes destruction order issues with the types in the TypeMaps.
 192     // For now, just leak this, which is at least not a regression from the
 193     // previous behavior, though still undesirable.
 194 #if 0
 195     delete VoidTy;
 196     delete LabelTy;
 197     delete FloatTy;
 198     delete DoubleTy;
 199     delete MetadataTy;
 200     delete X86_FP80Ty;
 201     delete FP128Ty;
 202     delete PPC_FP128Ty;
 203
 204     delete Int1Ty;
 205     delete Int8Ty;
 206     delete Int16Ty;
 207     delete Int32Ty;
 208     delete Int64Ty;
 209 #endif
 210   }
 211 };
 212
 213 }
 214
 215 #endif