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

Removal of explicit stack, which requires the method to be a member (so it can

Browse Source 
call setAbstract).  Now that we just compute abstractness we can also return
the computed value by value instead of as an argument.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8332 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-09-02 21:56:34 +00:00
parent 2a4a4b54ad
commit bc4846d76c
1 changed files with 28 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
lib/VMCore/Type.cpp
View File

@ -385,37 +385,38 @@ OpaqueType::OpaqueType() : DerivedType(OpaqueTyID) {
// Derived Type setDerivedTypeProperties Function
//===----------------------------------------------------------------------===//
// getTypeProps - This is a recursive function that walks a type hierarchy
// calculating the description for a type and whether or not it is abstract or
// recursive. Worst case it will have to do a lot of traversing if you have
// some whacko opaque types, but in most cases, it will do some simple stuff
// when it hits non-abstract types that aren't recursive.
// 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
// a lot of traversing if you have some whacko opaque types, but in most cases,
// it will do some simple stuff when it hits non-abstract types that aren't
// recursive.
//
static void getTypeProps(const Type *Ty, std::vector<const Type *> &TypeStack,
bool &isAbstract) {
if (!Ty->isAbstract()) // Base case for the recursion
return; // Primitive = leaf type
bool Type::isTypeAbstract() {
if (!isAbstract()) // Base case for the recursion
return false; // Primitive = leaf type
if (isa<OpaqueType>(Ty)) { // Base case for the recursion
isAbstract = true; // This whole type is abstract!
return; // Opaque = leaf type
}
if (isa<OpaqueType>(this)) // Base case for the recursion
return true; // This whole type is abstract!
// Check to see if the Type is already on the stack...
for (unsigned Slot = 0; Slot != TypeStack.size(); ++Slot)
if (TypeStack[Slot] == Ty) // Scan for type
return; // is a recursive check.
// We have to guard against recursion. To do this, we temporarily mark this
// type as concrete, so that if we get back to here recursively we will think
// it's not abstract, and thus not scan it again.
setAbstract(false);
// Recursive case: derived type...
TypeStack.push_back(Ty); // Add us to the stack..
// Scan all of the sub-types. If any of them are abstract, than so is this
// one!
for (Type::subtype_iterator I = subtype_begin(), E = subtype_end();
I != E; ++I)
if (const_cast<Type*>(*I)->isTypeAbstract()) {
setAbstract(true);
return true;
}
// Restore the abstract bit.
setAbstract(true);
for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
I != E; ++I) {
getTypeProps(*I, TypeStack, isAbstract);
if (isAbstract) break;
}
TypeStack.pop_back(); // Remove self from stack...
// Nothing looks abstract here...
return false;
}
@ -423,12 +424,8 @@ static void getTypeProps(const Type *Ty, std::vector<const Type *> &TypeStack,
// setting for a type. The getTypeProps function does all the dirty work.
//
void DerivedType::setDerivedTypeProperties() {
std::vector<const Type *> TypeStack;
bool isAbstract = false;
setAbstract(true);
getTypeProps(this, TypeStack, isAbstract);
setAbstract(isAbstract);
setAbstract(isTypeAbstract());
}