RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-02-22 03:31:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Privatize all but one of the remaining constant tables.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77748 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2009-07-31 22:45:43 +00:00
parent 8d91955d2b
commit 7e3142b012
3 changed files with 58 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/llvm/LLVMContext.h
View File

@ -63,6 +63,9 @@ class LLVMContext {
friend class ConstantAggregateZero;
friend class MDNode;
friend class MDString;
friend class ConstantPointerNull;
friend class UndefValue;
friend class ConstantExpr;
public:
LLVMContext();
~LLVMContext();

59
lib/VMCore/Constants.cpp
View File

@ -40,9 +40,6 @@ using namespace llvm;
// Constant Class
//===----------------------------------------------------------------------===//
// Becomes a no-op when multithreading is disabled.
ManagedStatic<sys::SmartRWMutex<true> > ConstantsLock;
// Constructor to create a '0' constant of arbitrary type...
static const uint64_t zero[2] = {0, 0};
Constant* Constant::getNullValue(const Type* Ty) {
@ -1208,30 +1205,6 @@ Constant *ConstantVector::getSplatValue() {
//---- ConstantPointerNull::get() implementation...
//
namespace llvm {
// ConstantPointerNull does not take extra "value" argument...
template<class ValType>
struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){
return new ConstantPointerNull(Ty);
}
};
template<>
struct ConvertConstantType<ConstantPointerNull, PointerType> {
static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
// Make everyone now use a constant of the new type...
Constant *New = ConstantPointerNull::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
static ManagedStatic<ValueMap<char, PointerType,
ConstantPointerNull> > NullPtrConstants;
static char getValType(ConstantPointerNull *) {
return 0;
}
@ -1239,14 +1212,14 @@ static char getValType(ConstantPointerNull *) {
ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) {
// Implicitly locked.
return NullPtrConstants->getOrCreate(Ty, 0);
return Ty->getContext().pImpl->NullPtrConstants.getOrCreate(Ty, 0);
}
// destroyConstant - Remove the constant from the constant table...
//
void ConstantPointerNull::destroyConstant() {
// Implicitly locked.
NullPtrConstants->remove(this);
getType()->getContext().pImpl->NullPtrConstants.remove(this);
destroyConstantImpl();
}
@ -1254,44 +1227,20 @@ void ConstantPointerNull::destroyConstant() {
//---- UndefValue::get() implementation...
//
namespace llvm {
// UndefValue does not take extra "value" argument...
template<class ValType>
struct ConstantCreator<UndefValue, Type, ValType> {
static UndefValue *create(const Type *Ty, const ValType &V) {
return new UndefValue(Ty);
}
};
template<>
struct ConvertConstantType<UndefValue, Type> {
static void convert(UndefValue *OldC, const Type *NewTy) {
// Make everyone now use a constant of the new type.
Constant *New = UndefValue::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
static ManagedStatic<ValueMap<char, Type, UndefValue> > UndefValueConstants;
static char getValType(UndefValue *) {
return 0;
}
UndefValue *UndefValue::get(const Type *Ty) {
// Implicitly locked.
return UndefValueConstants->getOrCreate(Ty, 0);
return Ty->getContext().pImpl->UndefValueConstants.getOrCreate(Ty, 0);
}
// destroyConstant - Remove the constant from the constant table.
//
void UndefValue::destroyConstant() {
// Implicitly locked.
UndefValueConstants->remove(this);
getType()->getContext().pImpl->UndefValueConstants.remove(this);
destroyConstantImpl();
}

58
lib/VMCore/LLVMContextImpl.h
View File

@ -70,6 +70,20 @@ struct ConstantCreator<ConstantAggregateZero, Type, ValType> {
}
};
template<>
struct ConvertConstantType<ConstantVector, VectorType> {
static void convert(ConstantVector *OldC, const VectorType *NewTy) {
// Make everyone now use a constant of the new type...
std::vector<Constant*> C;
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
C.push_back(cast<Constant>(OldC->getOperand(i)));
Constant *New = ConstantVector::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
template<>
struct ConvertConstantType<ConstantAggregateZero, Type> {
static void convert(ConstantAggregateZero *OldC, const Type *NewTy) {
@ -110,17 +124,41 @@ struct ConvertConstantType<ConstantStruct, StructType> {
}
};
// ConstantPointerNull does not take extra "value" argument...
template<class ValType>
struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){
return new ConstantPointerNull(Ty);
}
};
template<>
struct ConvertConstantType<ConstantVector, VectorType> {
static void convert(ConstantVector *OldC, const VectorType *NewTy) {
struct ConvertConstantType<ConstantPointerNull, PointerType> {
static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
// Make everyone now use a constant of the new type...
std::vector<Constant*> C;
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
C.push_back(cast<Constant>(OldC->getOperand(i)));
Constant *New = ConstantVector::get(NewTy, C);
Constant *New = ConstantPointerNull::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
// UndefValue does not take extra "value" argument...
template<class ValType>
struct ConstantCreator<UndefValue, Type, ValType> {
static UndefValue *create(const Type *Ty, const ValType &V) {
return new UndefValue(Ty);
}
};
template<>
struct ConvertConstantType<UndefValue, Type> {
static void convert(UndefValue *OldC, const Type *NewTy) {
// Make everyone now use a constant of the new type.
Constant *New = UndefValue::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
@ -449,6 +487,10 @@ class LLVMContextImpl {
ConstantVector> VectorConstantsTy;
VectorConstantsTy VectorConstants;
ValueMap<char, PointerType, ConstantPointerNull> NullPtrConstants;
ValueMap<char, Type, UndefValue> UndefValueConstants;
LLVMContext &Context;
ConstantInt *TheTrueVal;
ConstantInt *TheFalseVal;
@ -464,6 +506,8 @@ class LLVMContextImpl {
friend class ConstantAggregateZero;
friend class MDNode;
friend class MDString;
friend class ConstantPointerNull;
friend class UndefValue;
public:
LLVMContextImpl(LLVMContext &C);
};