6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-21 18:29:46 +00:00
Code Issues Projects Releases Wiki Activity

Privatize the ConstantStruct table.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76912 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2009-07-23 23:25:33 +00:00
parent ed0e2adc70
commit 006c77df8c
6 changed files with 133 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/Constants.h
View File

@ -344,13 +344,10 @@ class ConstantStruct : public Constant {
friend struct ConstantCreator<ConstantStruct, StructType,
std::vector<Constant*> >;
ConstantStruct(const ConstantStruct &); // DO NOT IMPLEMENT
friend class LLVMContextImpl;
protected:
ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
public:
/// get() - Static factory methods - Return objects of the specified value
///
static Constant *get(const StructType *T, const std::vector<Constant*> &V);
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);

3
include/llvm/LLVMContext.h
View File

@ -275,10 +275,13 @@ public:
void erase(MDNode *M);
void erase(ConstantAggregateZero *Z);
void erase(ConstantArray *Z);
void erase(ConstantStruct *S);
// RAUW helpers
Constant *replaceUsesOfWithOnConstant(ConstantArray *CA,
Value *From, Value *To, Use *U);
Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
Value *To, Use *U);
};
/// FOR BACKWARDS COMPATIBILITY - Returns a global context.

96
lib/VMCore/Constants.cpp
View File

@ -1096,50 +1096,14 @@ std::string ConstantArray::getAsString() const {
//
namespace llvm {
template<>
struct ConvertConstantType<ConstantStruct, StructType> {
static void convert(ConstantStruct *OldC, const StructType *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 = ConstantStruct::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
typedef ValueMap<std::vector<Constant*>, StructType,
ConstantStruct, true /*largekey*/> StructConstantsTy;
static ManagedStatic<StructConstantsTy> StructConstants;
static std::vector<Constant*> getValType(ConstantStruct *CS) {
std::vector<Constant*> Elements;
Elements.reserve(CS->getNumOperands());
for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
Elements.push_back(cast<Constant>(CS->getOperand(i)));
return Elements;
}
Constant *ConstantStruct::get(const StructType *Ty,
const std::vector<Constant*> &V) {
// Create a ConstantAggregateZero value if all elements are zeros...
for (unsigned i = 0, e = V.size(); i != e; ++i)
if (!V[i]->isNullValue())
// Implicitly locked.
return StructConstants->getOrCreate(Ty, V);
return Ty->getContext().getConstantAggregateZero(Ty);
}
// destroyConstant - Remove the constant from the constant table...
//
void ConstantStruct::destroyConstant() {
// Implicitly locked.
StructConstants->remove(this);
getType()->getContext().erase(this);
destroyConstantImpl();
}
@ -2112,61 +2076,9 @@ void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To,
Use *U) {
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
Constant *ToC = cast<Constant>(To);
unsigned OperandToUpdate = U-OperandList;
assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
std::pair<StructConstantsTy::MapKey, Constant*> Lookup;
Lookup.first.first = getType();
Lookup.second = this;
std::vector<Constant*> &Values = Lookup.first.second;
Values.reserve(getNumOperands()); // Build replacement struct.
// Fill values with the modified operands of the constant struct. Also,
// compute whether this turns into an all-zeros struct.
bool isAllZeros = false;
if (!ToC->isNullValue()) {
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O)
Values.push_back(cast<Constant>(O->get()));
} else {
isAllZeros = true;
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
Constant *Val = cast<Constant>(O->get());
Values.push_back(Val);
if (isAllZeros) isAllZeros = Val->isNullValue();
}
}
Values[OperandToUpdate] = ToC;
Constant *Replacement = 0;
if (isAllZeros) {
Replacement = getType()->getContext().getConstantAggregateZero(getType());
} else {
// Check to see if we have this array type already.
sys::SmartScopedWriter<true> Writer(*ConstantsLock);
bool Exists;
StructConstantsTy::MapTy::iterator I =
StructConstants->InsertOrGetItem(Lookup, Exists);
if (Exists) {
Replacement = I->second;
} else {
// Okay, the new shape doesn't exist in the system yet. Instead of
// creating a new constant struct, inserting it, replaceallusesof'ing the
// old with the new, then deleting the old... just update the current one
// in place!
StructConstants->MoveConstantToNewSlot(this, I);
// Update to the new value.
setOperand(OperandToUpdate, ToC);
return;
}
}
assert(Replacement != this && "I didn't contain From!");
Constant* Replacement =
getType()->getContext().replaceUsesOfWithOnConstant(this, From, To, U);
if (!Replacement) return;
// Everyone using this now uses the replacement.
uncheckedReplaceAllUsesWith(Replacement);

11
lib/VMCore/LLVMContext.cpp
View File

@ -146,7 +146,7 @@ ConstantPointerNull* LLVMContext::getConstantPointerNull(const PointerType* T) {
// ConstantStruct accessors.
Constant* LLVMContext::getConstantStruct(const StructType* T,
const std::vector<Constant*>& V) {
return ConstantStruct::get(T, V);
return pImpl->getConstantStruct(T, V);
}
Constant* LLVMContext::getConstantStruct(const std::vector<Constant*>& V,
@ -658,7 +658,16 @@ void LLVMContext::erase(ConstantArray *C) {
pImpl->erase(C);
}
void LLVMContext::erase(ConstantStruct *S) {
pImpl->erase(S);
}
Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantArray *CA,
Value *From, Value *To, Use *U) {
return pImpl->replaceUsesOfWithOnConstant(CA, From, To, U);
}
Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantStruct *CS,
Value *From, Value *To, Use *U) {
return pImpl->replaceUsesOfWithOnConstant(CS, From, To, U);
}

104
lib/VMCore/LLVMContextImpl.cpp
View File

@ -29,6 +29,14 @@ static std::vector<Constant*> getValType(ConstantArray *CA) {
return Elements;
}
static std::vector<Constant*> getValType(ConstantStruct *CS) {
std::vector<Constant*> Elements;
Elements.reserve(CS->getNumOperands());
for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
Elements.push_back(cast<Constant>(CS->getOperand(i)));
return Elements;
}
namespace llvm {
template<typename T, typename Alloc>
struct VISIBILITY_HIDDEN ConstantTraits< std::vector<T, Alloc> > {
@ -83,6 +91,21 @@ struct ConvertConstantType<ConstantArray, ArrayType> {
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
template<>
struct ConvertConstantType<ConstantStruct, StructType> {
static void convert(ConstantStruct *OldC, const StructType *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 = NewTy->getContext().getConstantStruct(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
template<class ValType, class TypeClass, class ConstantClass,
@ -324,11 +347,13 @@ LLVMContextImpl::LLVMContextImpl(LLVMContext &C) :
Context(C), TheTrueVal(0), TheFalseVal(0) {
AggZeroConstants = new ValueMap<char, Type, ConstantAggregateZero>();
ArrayConstants = new ArrayConstantsTy();
StructConstants = new StructConstantsTy();
}
LLVMContextImpl::~LLVMContextImpl() {
delete AggZeroConstants;
delete ArrayConstants;
delete StructConstants;
}
// Get a ConstantInt from an APInt. Note that the value stored in the DenseMap
@ -456,6 +481,17 @@ Constant *LLVMContextImpl::getConstantArray(const ArrayType *Ty,
return Context.getConstantAggregateZero(Ty);
}
Constant *LLVMContextImpl::getConstantStruct(const StructType *Ty,
const std::vector<Constant*> &V) {
// Create a ConstantAggregateZero value if all elements are zeros...
for (unsigned i = 0, e = V.size(); i != e; ++i)
if (!V[i]->isNullValue())
// Implicitly locked.
return StructConstants->getOrCreate(Ty, V);
return Context.getConstantAggregateZero(Ty);
}
// *** erase methods ***
void LLVMContextImpl::erase(MDString *M) {
@ -477,7 +513,12 @@ void LLVMContextImpl::erase(ConstantArray *C) {
ArrayConstants->remove(C);
}
void LLVMContextImpl::erase(ConstantStruct *S) {
StructConstants->remove(S);
}
// *** RAUW helpers ***
Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantArray *CA,
Value *From, Value *To, Use *U) {
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
@ -556,3 +597,66 @@ Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantArray *CA,
return Replacement;
}
Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantStruct *CS,
Value *From, Value *To, Use *U) {
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
Constant *ToC = cast<Constant>(To);
unsigned OperandToUpdate = U - CS->OperandList;
assert(CS->getOperand(OperandToUpdate) == From &&
"ReplaceAllUsesWith broken!");
std::pair<StructConstantsTy::MapKey, Constant*> Lookup;
Lookup.first.first = CS->getType();
Lookup.second = CS;
std::vector<Constant*> &Values = Lookup.first.second;
Values.reserve(CS->getNumOperands()); // Build replacement struct.
// Fill values with the modified operands of the constant struct. Also,
// compute whether this turns into an all-zeros struct.
bool isAllZeros = false;
if (!ToC->isNullValue()) {
for (Use *O = CS->OperandList, *E = CS->OperandList + CS->getNumOperands();
O != E; ++O)
Values.push_back(cast<Constant>(O->get()));
} else {
isAllZeros = true;
for (Use *O = CS->OperandList, *E = CS->OperandList + CS->getNumOperands();
O != E; ++O) {
Constant *Val = cast<Constant>(O->get());
Values.push_back(Val);
if (isAllZeros) isAllZeros = Val->isNullValue();
}
}
Values[OperandToUpdate] = ToC;
Constant *Replacement = 0;
if (isAllZeros) {
Replacement = Context.getConstantAggregateZero(CS->getType());
} else {
// Check to see if we have this array type already.
sys::SmartScopedWriter<true> Writer(ConstantsLock);
bool Exists;
StructConstantsTy::MapTy::iterator I =
StructConstants->InsertOrGetItem(Lookup, Exists);
if (Exists) {
Replacement = I->second;
} else {
// Okay, the new shape doesn't exist in the system yet. Instead of
// creating a new constant struct, inserting it, replaceallusesof'ing the
// old with the new, then deleting the old... just update the current one
// in place!
StructConstants->MoveConstantToNewSlot(CS, I);
// Update to the new value.
CS->setOperand(OperandToUpdate, ToC);
return 0;
}
}
assert(Replacement != CS && "I didn't contain From!");
return Replacement;
}

11
lib/VMCore/LLVMContextImpl.h
View File

@ -27,6 +27,7 @@
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/StringMap.h"
#include <map>
#include <vector>
template<class ValType, class TypeClass, class ConstantClass,
bool HasLargeKey = false /*true for arrays and structs*/ >
@ -117,6 +118,10 @@ class LLVMContextImpl {
ConstantArray, true /*largekey*/> ArrayConstantsTy;
ArrayConstantsTy *ArrayConstants;
typedef ValueMap<std::vector<Constant*>, StructType,
ConstantStruct, true /*largekey*/> StructConstantsTy;
StructConstantsTy *StructConstants;
LLVMContext &Context;
ConstantInt *TheTrueVal;
ConstantInt *TheFalseVal;
@ -142,6 +147,9 @@ public:
Constant *getConstantArray(const ArrayType *Ty,
const std::vector<Constant*> &V);
Constant *getConstantStruct(const StructType *Ty,
const std::vector<Constant*> &V);
ConstantInt *getTrue() {
if (TheTrueVal)
return TheTrueVal;
@ -160,11 +168,14 @@ public:
void erase(MDNode *M);
void erase(ConstantAggregateZero *Z);
void erase(ConstantArray *C);
void erase(ConstantStruct *S);
// RAUW helpers
Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, Value *From,
Value *To, Use *U);
Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
Value *To, Use *U);
};
}