RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-27 21:50:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Avoid creating lots of pointless opaque types, with short lifetimes

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9076 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-10-13 14:03:36 +00:00
parent 236f646371
commit 1825009ba8
1 changed files with 37 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
lib/VMCore/Type.cpp
View File

@ -401,6 +401,43 @@ OpaqueType::OpaqueType() : DerivedType(OpaqueTyID) {
} }
// getAlwaysOpaqueTy - This function returns an opaque type. It doesn't matter
// _which_ opaque type it is, but the opaque type must never get resolved.
//
static Type *getAlwaysOpaqueTy() {
static Type *AlwaysOpaqueTy = OpaqueType::get();
static PATypeHolder Holder(AlwaysOpaqueTy);
return AlwaysOpaqueTy;
}
//===----------------------------------------------------------------------===//
// dropAllTypeUses methods - These methods eliminate any possibly recursive type
// references from a derived type. The type must remain abstract, so we make
// sure to use an always opaque type as an argument.
//
void FunctionType::dropAllTypeUses() {
ResultType = getAlwaysOpaqueTy();
ParamTys.clear();
}
void ArrayType::dropAllTypeUses() {
ElementType = getAlwaysOpaqueTy();
}
void StructType::dropAllTypeUses() {
ETypes.clear();
ETypes.push_back(PATypeHandle(getAlwaysOpaqueTy(), this));
}
void PointerType::dropAllTypeUses() {
ElementType = getAlwaysOpaqueTy();
}
// isTypeAbstract - This is a recursive function that walks a type hierarchy // isTypeAbstract - This is a recursive function that walks a type hierarchy
// calculating whether or not a type is abstract. Worst case it will have to do // calculating whether or not a type is abstract. Worst case it will have to do
// a lot of traversing if you have some whacko opaque types, but in most cases, // a lot of traversing if you have some whacko opaque types, but in most cases,
@ -651,12 +688,6 @@ FunctionType *FunctionType::get(const Type *ReturnType,
return MT; return MT;
} }
void FunctionType::dropAllTypeUses() {
ResultType = OpaqueType::get();
ParamTys.clear();
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Array Type Factory... // Array Type Factory...
// //
@ -701,13 +732,6 @@ ArrayType *ArrayType::get(const Type *ElementType, unsigned NumElements) {
return AT; return AT;
} }
void ArrayType::dropAllTypeUses() {
ElementType = OpaqueType::get();
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Struct Type Factory... // Struct Type Factory...
// //
@ -755,11 +779,6 @@ StructType *StructType::get(const std::vector<const Type*> &ETypes) {
return ST; return ST;
} }
void StructType::dropAllTypeUses() {
ETypes.clear();
ETypes.push_back(PATypeHandle(OpaqueType::get(), this));
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -806,10 +825,6 @@ PointerType *PointerType::get(const Type *ValueType) {
return PT; return PT;
} }
void PointerType::dropAllTypeUses() {
ElementType = OpaqueType::get();
}
void debug_type_tables() { void debug_type_tables() {
FunctionTypes.dump(); FunctionTypes.dump();
ArrayTypes.dump(); ArrayTypes.dump();