2010-03-21 21:17:34 +00:00
|
|
|
//===-- LLVMContextImpl.h - The LLVMContextImpl opaque class ----*- C++ -*-===//
|
2009-06-30 00:48:55 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-06-30 17:06:46 +00:00
|
|
|
//
|
|
|
|
// This file declares LLVMContextImpl, the opaque implementation
|
|
|
|
// of LLVMContext.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-06-30 00:48:55 +00:00
|
|
|
|
|
|
|
#ifndef LLVM_LLVMCONTEXT_IMPL_H
|
|
|
|
#define LLVM_LLVMCONTEXT_IMPL_H
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
#include "llvm/LLVMContext.h"
|
2009-08-04 22:41:48 +00:00
|
|
|
#include "ConstantsContext.h"
|
2009-08-19 17:07:46 +00:00
|
|
|
#include "LeaksContext.h"
|
2009-07-24 23:12:02 +00:00
|
|
|
#include "llvm/Constants.h"
|
2009-07-21 02:47:59 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2010-03-21 22:08:41 +00:00
|
|
|
#include "llvm/Metadata.h"
|
2009-12-29 09:01:33 +00:00
|
|
|
#include "llvm/Support/ValueHandle.h"
|
2009-07-16 19:05:41 +00:00
|
|
|
#include "llvm/ADT/APFloat.h"
|
2009-07-16 18:04:31 +00:00
|
|
|
#include "llvm/ADT/APInt.h"
|
2011-06-22 08:50:06 +00:00
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
2009-07-16 18:04:31 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2009-07-16 23:44:30 +00:00
|
|
|
#include "llvm/ADT/FoldingSet.h"
|
2009-12-17 19:55:06 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2009-07-16 22:11:26 +00:00
|
|
|
#include "llvm/ADT/StringMap.h"
|
2012-02-23 09:17:40 +00:00
|
|
|
#include "llvm/ADT/Hashing.h"
|
2009-07-23 23:25:33 +00:00
|
|
|
#include <vector>
|
2009-07-21 20:13:12 +00:00
|
|
|
|
2009-06-30 00:48:55 +00:00
|
|
|
namespace llvm {
|
2009-07-24 23:12:02 +00:00
|
|
|
|
2009-07-16 18:04:31 +00:00
|
|
|
class ConstantInt;
|
2009-07-16 19:05:41 +00:00
|
|
|
class ConstantFP;
|
2009-08-11 17:45:13 +00:00
|
|
|
class LLVMContext;
|
2009-07-16 18:04:31 +00:00
|
|
|
class Type;
|
2009-07-16 23:44:30 +00:00
|
|
|
class Value;
|
2009-07-16 18:04:31 +00:00
|
|
|
|
|
|
|
struct DenseMapAPIntKeyInfo {
|
|
|
|
struct KeyTy {
|
|
|
|
APInt val;
|
2011-07-18 04:54:35 +00:00
|
|
|
Type* type;
|
|
|
|
KeyTy(const APInt& V, Type* Ty) : val(V), type(Ty) {}
|
2009-07-16 18:04:31 +00:00
|
|
|
KeyTy(const KeyTy& that) : val(that.val), type(that.type) {}
|
|
|
|
bool operator==(const KeyTy& that) const {
|
|
|
|
return type == that.type && this->val == that.val;
|
|
|
|
}
|
|
|
|
bool operator!=(const KeyTy& that) const {
|
|
|
|
return !this->operator==(that);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
static inline KeyTy getEmptyKey() { return KeyTy(APInt(1,0), 0); }
|
|
|
|
static inline KeyTy getTombstoneKey() { return KeyTy(APInt(1,1), 0); }
|
|
|
|
static unsigned getHashValue(const KeyTy &Key) {
|
|
|
|
return DenseMapInfo<void*>::getHashValue(Key.type) ^
|
|
|
|
Key.val.getHashValue();
|
|
|
|
}
|
|
|
|
static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
|
|
|
|
return LHS == RHS;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-07-16 19:05:41 +00:00
|
|
|
struct DenseMapAPFloatKeyInfo {
|
|
|
|
struct KeyTy {
|
|
|
|
APFloat val;
|
|
|
|
KeyTy(const APFloat& V) : val(V){}
|
|
|
|
KeyTy(const KeyTy& that) : val(that.val) {}
|
|
|
|
bool operator==(const KeyTy& that) const {
|
|
|
|
return this->val.bitwiseIsEqual(that.val);
|
|
|
|
}
|
|
|
|
bool operator!=(const KeyTy& that) const {
|
|
|
|
return !this->operator==(that);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
static inline KeyTy getEmptyKey() {
|
|
|
|
return KeyTy(APFloat(APFloat::Bogus,1));
|
|
|
|
}
|
|
|
|
static inline KeyTy getTombstoneKey() {
|
|
|
|
return KeyTy(APFloat(APFloat::Bogus,2));
|
|
|
|
}
|
|
|
|
static unsigned getHashValue(const KeyTy &Key) {
|
|
|
|
return Key.val.getHashValue();
|
|
|
|
}
|
|
|
|
static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
|
|
|
|
return LHS == RHS;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-02-23 09:17:40 +00:00
|
|
|
struct AnonStructTypeKeyInfo {
|
|
|
|
struct KeyTy {
|
|
|
|
ArrayRef<Type*> ETypes;
|
|
|
|
bool isPacked;
|
|
|
|
KeyTy(const ArrayRef<Type*>& E, bool P) :
|
|
|
|
ETypes(E), isPacked(P) {}
|
|
|
|
KeyTy(const KeyTy& that) :
|
|
|
|
ETypes(that.ETypes), isPacked(that.isPacked) {}
|
|
|
|
KeyTy(const StructType* ST) :
|
|
|
|
ETypes(ArrayRef<Type*>(ST->element_begin(), ST->element_end())),
|
|
|
|
isPacked(ST->isPacked()) {}
|
|
|
|
bool operator==(const KeyTy& that) const {
|
|
|
|
if (isPacked != that.isPacked)
|
|
|
|
return false;
|
|
|
|
if (ETypes != that.ETypes)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool operator!=(const KeyTy& that) const {
|
|
|
|
return !this->operator==(that);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
static inline StructType* getEmptyKey() {
|
|
|
|
return DenseMapInfo<StructType*>::getEmptyKey();
|
|
|
|
}
|
|
|
|
static inline StructType* getTombstoneKey() {
|
|
|
|
return DenseMapInfo<StructType*>::getTombstoneKey();
|
|
|
|
}
|
|
|
|
static unsigned getHashValue(const KeyTy& Key) {
|
|
|
|
GeneralHash Hash;
|
|
|
|
Hash.add(Key.ETypes);
|
|
|
|
Hash.add(Key.isPacked);
|
|
|
|
return Hash.finish();
|
|
|
|
}
|
|
|
|
static unsigned getHashValue(const StructType *ST) {
|
|
|
|
return getHashValue(KeyTy(ST));
|
|
|
|
}
|
|
|
|
static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
|
|
|
|
if (RHS == getEmptyKey() || RHS == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return LHS == KeyTy(RHS);
|
|
|
|
}
|
|
|
|
static bool isEqual(const StructType *LHS, const StructType *RHS) {
|
|
|
|
return LHS == RHS;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct FunctionTypeKeyInfo {
|
|
|
|
struct KeyTy {
|
|
|
|
const Type *ReturnType;
|
|
|
|
ArrayRef<Type*> Params;
|
|
|
|
bool isVarArg;
|
|
|
|
KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
|
|
|
|
ReturnType(R), Params(P), isVarArg(V) {}
|
|
|
|
KeyTy(const KeyTy& that) :
|
|
|
|
ReturnType(that.ReturnType),
|
|
|
|
Params(that.Params),
|
|
|
|
isVarArg(that.isVarArg) {}
|
|
|
|
KeyTy(const FunctionType* FT) :
|
|
|
|
ReturnType(FT->getReturnType()),
|
|
|
|
Params(ArrayRef<Type*>(FT->param_begin(), FT->param_end())),
|
|
|
|
isVarArg(FT->isVarArg()) {}
|
|
|
|
bool operator==(const KeyTy& that) const {
|
|
|
|
if (ReturnType != that.ReturnType)
|
|
|
|
return false;
|
|
|
|
if (isVarArg != that.isVarArg)
|
|
|
|
return false;
|
|
|
|
if (Params != that.Params)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool operator!=(const KeyTy& that) const {
|
|
|
|
return !this->operator==(that);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
static inline FunctionType* getEmptyKey() {
|
|
|
|
return DenseMapInfo<FunctionType*>::getEmptyKey();
|
|
|
|
}
|
|
|
|
static inline FunctionType* getTombstoneKey() {
|
|
|
|
return DenseMapInfo<FunctionType*>::getTombstoneKey();
|
|
|
|
}
|
|
|
|
static unsigned getHashValue(const KeyTy& Key) {
|
|
|
|
GeneralHash Hash;
|
|
|
|
Hash.add(Key.ReturnType);
|
|
|
|
Hash.add(Key.Params);
|
|
|
|
Hash.add(Key.isVarArg);
|
|
|
|
return Hash.finish();
|
|
|
|
}
|
|
|
|
static unsigned getHashValue(const FunctionType *FT) {
|
|
|
|
return getHashValue(KeyTy(FT));
|
|
|
|
}
|
|
|
|
static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
|
|
|
|
if (RHS == getEmptyKey() || RHS == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return LHS == KeyTy(RHS);
|
|
|
|
}
|
|
|
|
static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
|
|
|
|
return LHS == RHS;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-04-01 00:37:44 +00:00
|
|
|
/// 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<MDNode>(getValPtr());
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void deleted();
|
|
|
|
virtual void allUsesReplacedWith(Value *VNew);
|
|
|
|
};
|
|
|
|
|
2009-08-11 17:45:13 +00:00
|
|
|
class LLVMContextImpl {
|
|
|
|
public:
|
2010-09-08 18:03:32 +00:00
|
|
|
/// OwnedModules - The set of modules instantiated in this context, and which
|
|
|
|
/// will be automatically deleted if this context is deleted.
|
|
|
|
SmallPtrSet<Module*, 4> OwnedModules;
|
|
|
|
|
2010-11-17 08:13:01 +00:00
|
|
|
LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler;
|
|
|
|
void *InlineAsmDiagContext;
|
2010-04-06 00:44:45 +00:00
|
|
|
|
2009-07-16 18:04:31 +00:00
|
|
|
typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*,
|
2009-08-04 22:41:48 +00:00
|
|
|
DenseMapAPIntKeyInfo> IntMapTy;
|
2009-07-16 18:04:31 +00:00
|
|
|
IntMapTy IntConstants;
|
|
|
|
|
2009-07-16 19:05:41 +00:00
|
|
|
typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
|
2009-08-04 22:41:48 +00:00
|
|
|
DenseMapAPFloatKeyInfo> FPMapTy;
|
2009-07-16 19:05:41 +00:00
|
|
|
FPMapTy FPConstants;
|
|
|
|
|
2009-07-16 22:11:26 +00:00
|
|
|
StringMap<MDString*> MDStringCache;
|
|
|
|
|
2009-09-03 01:39:20 +00:00
|
|
|
FoldingSet<MDNode> MDNodeSet;
|
2010-03-13 01:26:15 +00:00
|
|
|
// 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<MDNode*, 1> NonUniquedMDNodes;
|
2009-09-03 01:39:20 +00:00
|
|
|
|
2012-01-23 15:20:12 +00:00
|
|
|
DenseMap<Type*, ConstantAggregateZero*> CAZConstants;
|
2009-08-10 18:16:08 +00:00
|
|
|
|
2012-02-05 20:54:10 +00:00
|
|
|
typedef ConstantAggrUniqueMap<ArrayType, ConstantArray> ArrayConstantsTy;
|
2009-07-24 23:12:02 +00:00
|
|
|
ArrayConstantsTy ArrayConstants;
|
2009-07-21 20:13:12 +00:00
|
|
|
|
2012-02-05 20:54:10 +00:00
|
|
|
typedef ConstantAggrUniqueMap<StructType, ConstantStruct> StructConstantsTy;
|
2009-07-24 23:12:02 +00:00
|
|
|
StructConstantsTy StructConstants;
|
2009-07-23 23:25:33 +00:00
|
|
|
|
2012-02-05 20:54:10 +00:00
|
|
|
typedef ConstantAggrUniqueMap<VectorType, ConstantVector> VectorConstantsTy;
|
2009-07-24 23:12:02 +00:00
|
|
|
VectorConstantsTy VectorConstants;
|
2009-07-24 00:36:24 +00:00
|
|
|
|
2012-01-23 15:20:12 +00:00
|
|
|
DenseMap<PointerType*, ConstantPointerNull*> CPNConstants;
|
|
|
|
|
|
|
|
DenseMap<Type*, UndefValue*> UVConstants;
|
2009-07-31 22:45:43 +00:00
|
|
|
|
2012-01-23 22:57:10 +00:00
|
|
|
StringMap<ConstantDataSequential*> CDSConstants;
|
|
|
|
|
|
|
|
|
2009-10-28 00:01:44 +00:00
|
|
|
DenseMap<std::pair<Function*, BasicBlock*> , BlockAddress*> BlockAddresses;
|
2011-06-22 08:50:06 +00:00
|
|
|
ConstantUniqueMap<ExprMapKeyType, const ExprMapKeyType&, Type, ConstantExpr>
|
|
|
|
ExprConstants;
|
2010-03-21 20:37:19 +00:00
|
|
|
|
2011-06-22 08:50:06 +00:00
|
|
|
ConstantUniqueMap<InlineAsmKeyType, const InlineAsmKeyType&, PointerType,
|
|
|
|
InlineAsm> InlineAsms;
|
2009-08-04 20:25:11 +00:00
|
|
|
|
2009-07-21 02:47:59 +00:00
|
|
|
ConstantInt *TheTrueVal;
|
|
|
|
ConstantInt *TheFalseVal;
|
|
|
|
|
2009-08-19 17:07:46 +00:00
|
|
|
LeakDetectorImpl<Value> LLVMObjects;
|
|
|
|
|
2009-08-25 16:00:35 +00:00
|
|
|
// Basic type instances.
|
2011-12-17 00:04:22 +00:00
|
|
|
Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy;
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
|
|
|
|
IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty;
|
2010-02-11 06:41:30 +00:00
|
|
|
|
2011-07-15 05:49:15 +00:00
|
|
|
|
|
|
|
/// TypeAllocator - All dynamically allocated types are allocated from this.
|
|
|
|
/// They live forever until the context is torn down.
|
|
|
|
BumpPtrAllocator TypeAllocator;
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
DenseMap<unsigned, IntegerType*> IntegerTypes;
|
|
|
|
|
2012-02-23 09:17:40 +00:00
|
|
|
typedef DenseMap<FunctionType*, bool, FunctionTypeKeyInfo> FunctionTypeMap;
|
|
|
|
FunctionTypeMap FunctionTypes;
|
|
|
|
typedef DenseMap<StructType*, bool, AnonStructTypeKeyInfo> StructTypeMap;
|
|
|
|
StructTypeMap AnonStructTypes;
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
StringMap<StructType*> NamedStructTypes;
|
|
|
|
unsigned NamedStructTypesUniqueID;
|
|
|
|
|
|
|
|
DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
|
|
|
|
DenseMap<std::pair<Type *, unsigned>, VectorType*> VectorTypes;
|
|
|
|
DenseMap<Type*, PointerType*> PointerTypes; // Pointers in AddrSpace = 0
|
|
|
|
DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
|
2010-02-11 06:41:30 +00:00
|
|
|
|
2009-12-17 19:55:06 +00:00
|
|
|
|
2009-08-18 18:28:58 +00:00
|
|
|
/// 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<Value*, ValueHandleBase*> ValueHandlesTy;
|
|
|
|
ValueHandlesTy ValueHandles;
|
|
|
|
|
2009-12-29 09:01:33 +00:00
|
|
|
/// CustomMDKindNames - Map to hold the metadata string to ID mapping.
|
|
|
|
StringMap<unsigned> CustomMDKindNames;
|
|
|
|
|
|
|
|
typedef std::pair<unsigned, TrackingVH<MDNode> > MDPairTy;
|
|
|
|
typedef SmallVector<MDPairTy, 2> MDMapTy;
|
|
|
|
|
|
|
|
/// MetadataStore - Collection of per-instruction metadata used in this
|
|
|
|
/// context.
|
|
|
|
DenseMap<const Instruction *, MDMapTy> MetadataStore;
|
|
|
|
|
2010-04-01 00:37:44 +00:00
|
|
|
/// ScopeRecordIdx - This is the index in ScopeRecords for an MDNode scope
|
|
|
|
/// entry with no "inlined at" element.
|
|
|
|
DenseMap<MDNode*, int> 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<DebugRecVH> ScopeRecords;
|
|
|
|
|
|
|
|
/// ScopeInlinedAtIdx - This is the index in ScopeInlinedAtRecords for an
|
|
|
|
/// scope/inlined-at pair.
|
|
|
|
DenseMap<std::pair<MDNode*, MDNode*>, 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<std::pair<DebugRecVH, DebugRecVH> > ScopeInlinedAtRecords;
|
|
|
|
|
|
|
|
int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
|
|
|
|
int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
|
|
|
|
|
2010-03-21 21:17:34 +00:00
|
|
|
LLVMContextImpl(LLVMContext &C);
|
|
|
|
~LLVMContextImpl();
|
2009-06-30 00:48:55 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-06-30 17:06:46 +00:00
|
|
|
#endif
|