X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FLLVMContextImpl.h;h=a27afc08b9f82d095e5fb1b278e2bff20f57ee05;hb=e6bd7a805808a05e9869fbf067581855a8b2a2c2;hp=20d410eaf87840812d9ff054ec4747c902f1709c;hpb=ba43a385a817d7f59e528a744dc40e44317ec739;p=oota-llvm.git diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h index 20d410eaf87..a27afc08b9f 100644 --- a/lib/VMCore/LLVMContextImpl.h +++ b/lib/VMCore/LLVMContextImpl.h @@ -1,4 +1,4 @@ -//===----------------- LLVMContextImpl.h - Implementation ------*- C++ -*--===// +//===-- LLVMContextImpl.h - The LLVMContextImpl opaque class ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -15,19 +15,19 @@ #ifndef LLVM_LLVMCONTEXT_IMPL_H #define LLVM_LLVMCONTEXT_IMPL_H +#include "llvm/LLVMContext.h" #include "ConstantsContext.h" #include "LeaksContext.h" -#include "TypesContext.h" -#include "llvm/LLVMContext.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" -#include "llvm/System/Mutex.h" -#include "llvm/System/RWMutex.h" -#include "llvm/Assembly/Writer.h" +#include "llvm/Metadata.h" +#include "llvm/Support/ValueHandle.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APInt.h" +#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" +#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/StringMap.h" #include @@ -35,8 +35,6 @@ namespace llvm { class ConstantInt; class ConstantFP; -class MDString; -class MDNode; class LLVMContext; class Type; class Value; @@ -44,8 +42,8 @@ class Value; struct DenseMapAPIntKeyInfo { struct KeyTy { APInt val; - const Type* type; - KeyTy(const APInt& V, const Type* Ty) : val(V), type(Ty) {} + Type* type; + KeyTy(const APInt& V, Type* Ty) : val(V), type(Ty) {} KeyTy(const KeyTy& that) : val(that.val), type(that.type) {} bool operator==(const KeyTy& that) const { return type == that.type && this->val == that.val; @@ -63,7 +61,6 @@ struct DenseMapAPIntKeyInfo { static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) { return LHS == RHS; } - static bool isPod() { return false; } }; struct DenseMapAPFloatKeyInfo { @@ -90,12 +87,39 @@ struct DenseMapAPFloatKeyInfo { static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) { return LHS == RHS; } - static bool isPod() { return false; } }; +/// DebugRecVH - This is a CallbackVH used to keep the Scope -> index maps +/// up to date as MDNodes mutate. This class is implemented in DebugLoc.cpp. +class DebugRecVH : public CallbackVH { + /// Ctx - This is the LLVM Context being referenced. + LLVMContextImpl *Ctx; + + /// Idx - The index into either ScopeRecordIdx or ScopeInlinedAtRecords that + /// this reference lives in. If this is zero, then it represents a + /// non-canonical entry that has no DenseMap value. This can happen due to + /// RAUW. + int Idx; +public: + DebugRecVH(MDNode *n, LLVMContextImpl *ctx, int idx) + : CallbackVH(n), Ctx(ctx), Idx(idx) {} + + MDNode *get() const { + return cast_or_null(getValPtr()); + } + + virtual void deleted(); + virtual void allUsesReplacedWith(Value *VNew); +}; + class LLVMContextImpl { public: - sys::SmartRWMutex ConstantsLock; + /// OwnedModules - The set of modules instantiated in this context, and which + /// will be automatically deleted if this context is deleted. + SmallPtrSet OwnedModules; + + LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler; + void *InlineAsmDiagContext; typedef DenseMap IntMapTy; @@ -107,118 +131,106 @@ public: StringMap MDStringCache; - ValueMap AggZeroConstants; - - typedef ValueMap, Type, MDNode, true /*largekey*/> - MDNodeMapTy; - - MDNodeMapTy MDNodes; + FoldingSet MDNodeSet; + // MDNodes may be uniqued or not uniqued. When they're not uniqued, they + // aren't in the MDNodeSet, but they're still shared between objects, so no + // one object can destroy them. This set allows us to at least destroy them + // on Context destruction. + SmallPtrSet NonUniquedMDNodes; - typedef ValueMap, ArrayType, - ConstantArray, true /*largekey*/> ArrayConstantsTy; + DenseMap CAZConstants; + + typedef ConstantAggrUniqueMap ArrayConstantsTy; ArrayConstantsTy ArrayConstants; - typedef ValueMap, StructType, - ConstantStruct, true /*largekey*/> StructConstantsTy; + typedef ConstantAggrUniqueMap StructConstantsTy; StructConstantsTy StructConstants; - typedef ValueMap, VectorType, - ConstantVector> VectorConstantsTy; + typedef ConstantAggrUniqueMap VectorConstantsTy; VectorConstantsTy VectorConstants; - ValueMap NullPtrConstants; + DenseMap CPNConstants; + + DenseMap UVConstants; - ValueMap UndefValueConstants; + StringMap CDSConstants; + - ValueMap ExprConstants; + DenseMap , BlockAddress*> BlockAddresses; + ConstantUniqueMap + ExprConstants; + + ConstantUniqueMap InlineAsms; ConstantInt *TheTrueVal; ConstantInt *TheFalseVal; - // Lock used for guarding access to the leak detector - sys::SmartMutex LLVMObjectsLock; LeakDetectorImpl LLVMObjects; - // Lock used for guarding access to the type maps. - sys::SmartMutex TypeMapLock; - - // Recursive lock used for guarding access to AbstractTypeUsers. - // NOTE: The true template parameter means this will no-op when we're not in - // multithreaded mode. - sys::SmartMutex AbstractTypeUsersLock; - - // Concrete/Abstract TypeDescriptions - We lazily calculate type descriptions - // for types as they are needed. Because resolution of types must invalidate - // all of the abstract type descriptions, we keep them in a seperate map to - // make this easy. - TypePrinting ConcreteTypeDescriptions; - TypePrinting AbstractTypeDescriptions; - - TypeMap ArrayTypes; - TypeMap VectorTypes; - TypeMap PointerTypes; - TypeMap FunctionTypes; - TypeMap StructTypes; - TypeMap IntegerTypes; - - const Type *VoidTy; - const Type *LabelTy; - const Type *FloatTy; - const Type *DoubleTy; - const Type *MetadataTy; - const Type *X86_FP80Ty; - const Type *FP128Ty; - const Type *PPC_FP128Ty; - - const IntegerType *Int1Ty; - const IntegerType *Int8Ty; - const IntegerType *Int16Ty; - const IntegerType *Int32Ty; - const IntegerType *Int64Ty; + // Basic type instances. + Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy; + Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy; + IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty; + + + /// TypeAllocator - All dynamically allocated types are allocated from this. + /// They live forever until the context is torn down. + BumpPtrAllocator TypeAllocator; + + DenseMap IntegerTypes; + // TODO: Optimize FunctionTypes/AnonStructTypes! + std::map, FunctionType*> FunctionTypes; + std::map, StructType*> AnonStructTypes; + StringMap NamedStructTypes; + unsigned NamedStructTypesUniqueID; + + DenseMap, ArrayType*> ArrayTypes; + DenseMap, VectorType*> VectorTypes; + DenseMap PointerTypes; // Pointers in AddrSpace = 0 + DenseMap, PointerType*> ASPointerTypes; + + /// ValueHandles - This map keeps track of all of the value handles that are /// watching a Value*. The Value::HasValueHandle bit is used to know // whether or not a value has an entry in this map. typedef DenseMap ValueHandlesTy; ValueHandlesTy ValueHandles; - LLVMContextImpl(LLVMContext &C) : TheTrueVal(0), TheFalseVal(0), - VoidTy(new Type(C, Type::VoidTyID)), - LabelTy(new Type(C, Type::LabelTyID)), - FloatTy(new Type(C, Type::FloatTyID)), - DoubleTy(new Type(C, Type::DoubleTyID)), - MetadataTy(new Type(C, Type::MetadataTyID)), - X86_FP80Ty(new Type(C, Type::X86_FP80TyID)), - FP128Ty(new Type(C, Type::FP128TyID)), - PPC_FP128Ty(new Type(C, Type::PPC_FP128TyID)), - Int1Ty(new IntegerType(C, 1)), - Int8Ty(new IntegerType(C, 8)), - Int16Ty(new IntegerType(C, 16)), - Int32Ty(new IntegerType(C, 32)), - Int64Ty(new IntegerType(C, 64)) { } - - ~LLVMContextImpl() { - // In principle, we should delete the member types here. However, - // this causes destruction order issues with the types in the TypeMaps. - // For now, just leak this, which is at least not a regression from the - // previous behavior, though still undesirable. -#if 0 - delete VoidTy; - delete LabelTy; - delete FloatTy; - delete DoubleTy; - delete MetadataTy; - delete X86_FP80Ty; - delete FP128Ty; - delete PPC_FP128Ty; - - delete Int1Ty; - delete Int8Ty; - delete Int16Ty; - delete Int32Ty; - delete Int64Ty; -#endif - } + /// CustomMDKindNames - Map to hold the metadata string to ID mapping. + StringMap CustomMDKindNames; + + typedef std::pair > MDPairTy; + typedef SmallVector MDMapTy; + + /// MetadataStore - Collection of per-instruction metadata used in this + /// context. + DenseMap MetadataStore; + + /// ScopeRecordIdx - This is the index in ScopeRecords for an MDNode scope + /// entry with no "inlined at" element. + DenseMap ScopeRecordIdx; + + /// ScopeRecords - These are the actual mdnodes (in a value handle) for an + /// index. The ValueHandle ensures that ScopeRecordIdx stays up to date if + /// the MDNode is RAUW'd. + std::vector ScopeRecords; + + /// ScopeInlinedAtIdx - This is the index in ScopeInlinedAtRecords for an + /// scope/inlined-at pair. + DenseMap, int> ScopeInlinedAtIdx; + + /// ScopeInlinedAtRecords - These are the actual mdnodes (in value handles) + /// for an index. The ValueHandle ensures that ScopeINlinedAtIdx stays up + /// to date. + std::vector > ScopeInlinedAtRecords; + + int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx); + int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx); + + LLVMContextImpl(LLVMContext &C); + ~LLVMContextImpl(); }; }