RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 11:13:28 +01:00
Code Issues Projects Releases Wiki Activity

eliminate unlockedRefineAbstractTypeTo, types are all per-llvmcontext,

Browse Source 
so there is no locking involved in type refinement.

llvm-svn: 108553
This commit is contained in:
Chris Lattner 2010-07-16 20:50:13 +00:00
parent 4121df768b
commit 663dd0eb36
4 changed files with 5 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/DerivedTypes.h
View File

@ -52,10 +52,6 @@ protected:
///
void dropAllTypeUses();
/// unlockedRefineAbstractTypeTo - Internal version of refineAbstractTypeTo
/// that performs no locking. Only used for internal recursion.
void unlockedRefineAbstractTypeTo(const Type *NewType);
public:
//===--------------------------------------------------------------------===//

2
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -1467,7 +1467,7 @@ static bool TryToOptimizeStoreOfMallocToGlobal(GlobalVariable *GV,
TargetData *TD) {
if (!TD)
return false;
// If this is a malloc of an abstract type, don't touch it.
if (!AllocTy->isSized())
return false;

13
lib/VMCore/Type.cpp
View File

@ -1128,13 +1128,13 @@ void Type::removeAbstractTypeUser(AbstractTypeUser *U) const {
}
// unlockedRefineAbstractTypeTo - This function is used when it is discovered
// refineAbstractTypeTo - This function is used when it is discovered
// that the 'this' abstract type is actually equivalent to the NewType
// specified. This causes all users of 'this' to switch to reference the more
// concrete type NewType and for 'this' to be deleted. Only used for internal
// callers.
//
void DerivedType::unlockedRefineAbstractTypeTo(const Type *NewType) {
void DerivedType::refineAbstractTypeTo(const Type *NewType) {
assert(isAbstract() && "refineAbstractTypeTo: Current type is not abstract!");
assert(this != NewType && "Can't refine to myself!");
assert(ForwardType == 0 && "This type has already been refined!");
@ -1199,15 +1199,6 @@ void DerivedType::unlockedRefineAbstractTypeTo(const Type *NewType) {
// destroyed.
}
// refineAbstractTypeTo - This function is used by external callers to notify
// us that this abstract type is equivalent to another type.
//
void DerivedType::refineAbstractTypeTo(const Type *NewType) {
// All recursive calls will go through unlockedRefineAbstractTypeTo,
// to avoid deadlock problems.
unlockedRefineAbstractTypeTo(NewType);
}
// notifyUsesThatTypeBecameConcrete - Notify AbstractTypeUsers of this type that
// the current type has transitioned from being abstract to being concrete.
//

4
lib/VMCore/TypesContext.h
View File

@ -370,7 +370,7 @@ public:
// We already have this type in the table. Get rid of the newly refined
// type.
TypeClass *NewTy = cast<TypeClass>((Type*)I->second.get());
Ty->unlockedRefineAbstractTypeTo(NewTy);
Ty->refineAbstractTypeTo(NewTy);
return;
}
} else {
@ -406,7 +406,7 @@ public:
}
TypesByHash.erase(Entry);
}
Ty->unlockedRefineAbstractTypeTo(NewTy);
Ty->refineAbstractTypeTo(NewTy);
return;
}
}