static std::map<const Type*, std::string> ConcreteTypeDescriptions;
static std::map<const Type*, std::string> AbstractTypeDescriptions;
-Type::Type( const std::string& name, TypeID id )
- : RefCount(0), ForwardType(0) {
- if (!name.empty())
- ConcreteTypeDescriptions[this] = name;
- ID = id;
- Abstract = false;
+Type::Type(const char *Name, TypeID id)
+ : ID(id), Abstract(false), RefCount(0), ForwardType(0) {
+ assert(Name && Name[0] && "Should use other ctor if no name!");
+ ConcreteTypeDescriptions[this] = Name;
}
+
const Type *Type::getPrimitiveType(TypeID IDNumber) {
switch (IDNumber) {
case VoidTyID : return VoidTy;
return ForwardType;
}
+void Type::refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
+ abort();
+}
+void Type::typeBecameConcrete(const DerivedType *AbsTy) {
+ abort();
+}
+
+
// getTypeDescription - This is a recursive function that walks a type hierarchy
// calculating the description for a type.
//
// Derived Type Factory Functions
//===----------------------------------------------------------------------===//
-// TypeMap - Make sure that only one instance of a particular type may be
-// created on any given run of the compiler... note that this involves updating
-// our map if an abstract type gets refined somehow.
-//
namespace llvm {
-template<class ValType, class TypeClass>
-class TypeMap {
- std::map<ValType, PATypeHolder> Map;
-
+class TypeMapBase {
+protected:
/// TypesByHash - Keep track of types by their structure hash value. Note
/// that we only keep track of types that have cycles through themselves in
/// this map.
///
std::multimap<unsigned, PATypeHolder> TypesByHash;
- friend void Type::clearAllTypeMaps();
-
-private:
- void clear(std::vector<Type *> &DerivedTypes) {
- for (typename std::map<ValType, PATypeHolder>::iterator I = Map.begin(),
- E = Map.end(); I != E; ++I)
- DerivedTypes.push_back(I->second.get());
- TypesByHash.clear();
- Map.clear();
+public:
+ void RemoveFromTypesByHash(unsigned Hash, const Type *Ty) {
+ std::multimap<unsigned, PATypeHolder>::iterator I =
+ TypesByHash.lower_bound(Hash);
+ while (I->second != Ty) {
+ ++I;
+ assert(I != TypesByHash.end() && I->first == Hash);
+ }
+ TypesByHash.erase(I);
}
+
+ /// TypeBecameConcrete - When Ty gets a notification that TheType just became
+ /// concrete, drop uses and make Ty non-abstract if we should.
+ void TypeBecameConcrete(DerivedType *Ty, const DerivedType *TheType) {
+ // If the element just became concrete, remove 'ty' from the abstract
+ // type user list for the type. Do this for as many times as Ty uses
+ // OldType.
+ for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
+ I != E; ++I)
+ if (I->get() == TheType)
+ TheType->removeAbstractTypeUser(Ty);
+
+ // If the type is currently thought to be abstract, rescan all of our
+ // subtypes to see if the type has just become concrete! Note that this
+ // may send out notifications to AbstractTypeUsers that types become
+ // concrete.
+ if (Ty->isAbstract())
+ Ty->PromoteAbstractToConcrete();
+ }
+};
+}
+
+
+// TypeMap - Make sure that only one instance of a particular type may be
+// created on any given run of the compiler... note that this involves updating
+// our map if an abstract type gets refined somehow.
+//
+namespace llvm {
+template<class ValType, class TypeClass>
+class TypeMap : public TypeMapBase {
+ std::map<ValType, PATypeHolder> Map;
public:
typedef typename std::map<ValType, PATypeHolder>::iterator iterator;
~TypeMap() { print("ON EXIT"); }
TypesByHash.insert(std::make_pair(ValType::hashTypeStructure(Ty), Ty));
print("add");
}
-
- void RemoveFromTypesByHash(unsigned Hash, const Type *Ty) {
- std::multimap<unsigned, PATypeHolder>::iterator I =
- TypesByHash.lower_bound(Hash);
- while (I->second != Ty) {
- ++I;
- assert(I != TypesByHash.end() && I->first == Hash);
- }
- TypesByHash.erase(I);
+
+ void clear(std::vector<Type *> &DerivedTypes) {
+ for (typename std::map<ValType, PATypeHolder>::iterator I = Map.begin(),
+ E = Map.end(); I != E; ++I)
+ DerivedTypes.push_back(I->second.get());
+ TypesByHash.clear();
+ Map.clear();
}
- /// finishRefinement - This method is called after we have updated an existing
- /// type with its new components. We must now either merge the type away with
+ /// RefineAbstractType - This method is called after we have merged a type
+ /// with another one. We must now either merge the type away with
/// some other type or reinstall it in the map with it's new configuration.
- /// The specified iterator tells us what the type USED to look like.
- void finishRefinement(TypeClass *Ty, const DerivedType *OldType,
+ void RefineAbstractType(TypeClass *Ty, const DerivedType *OldType,
const Type *NewType) {
- assert((Ty->isAbstract() || !OldType->isAbstract()) &&
- "Refining a non-abstract type!");
#ifdef DEBUG_MERGE_TYPES
- std::cerr << "refineAbstractTy(" << (void*)OldType << "[" << *OldType
- << "], " << (void*)NewType << " [" << *NewType << "])\n";
+ std::cerr << "RefineAbstractType(" << (void*)OldType << "[" << *OldType
+ << "], " << (void*)NewType << " [" << *NewType << "])\n";
#endif
+
+ // Otherwise, we are changing one subelement type into another. Clearly the
+ // OldType must have been abstract, making us abstract.
+ assert(Ty->isAbstract() && "Refining a non-abstract type!");
+ assert(OldType != NewType);
// Make a temporary type holder for the type so that it doesn't disappear on
// us when we erase the entry from the map.
// Remember the structural hash for the type before we start hacking on it,
// in case we need it later.
unsigned OldTypeHash = ValType::hashTypeStructure(Ty);
- unsigned NewTypeHash;
// Find the type element we are refining... and change it now!
- if (OldType != NewType || !OldType->isAbstract()) {
- for (unsigned i = 0, e = Ty->ContainedTys.size(); i != e; ++i)
- if (Ty->ContainedTys[i] == OldType) {
- Ty->ContainedTys[i].removeUserFromConcrete();
- Ty->ContainedTys[i] = NewType;
- }
- NewTypeHash = ValType::hashTypeStructure(Ty);
- } else {
- NewTypeHash = OldTypeHash;
- }
-
+ for (unsigned i = 0, e = Ty->ContainedTys.size(); i != e; ++i)
+ if (Ty->ContainedTys[i] == OldType)
+ Ty->ContainedTys[i] = NewType;
+ unsigned NewTypeHash = ValType::hashTypeStructure(Ty);
+
// If there are no cycles going through this node, we can do a simple,
// efficient lookup in the map, instead of an inefficient nasty linear
// lookup.
- if (!Ty->isAbstract() || !TypeHasCycleThroughItself(Ty)) {
+ if (!TypeHasCycleThroughItself(Ty)) {
typename std::map<ValType, PATypeHolder>::iterator I;
bool Inserted;
tie(I, Inserted) = Map.insert(std::make_pair(ValType::get(Ty), Ty));
if (!Inserted) {
+ assert(OldType != NewType);
// Refined to a different type altogether?
- RemoveFromTypesByHash(NewTypeHash, Ty);
+ RemoveFromTypesByHash(OldTypeHash, Ty);
// We already have this type in the table. Get rid of the newly refined
// type.
return;
}
} else {
- assert(Ty->isAbstract() && "Potentially replacing a non-abstract type?");
-
// Now we check to see if there is an existing entry in the table which is
// structurally identical to the newly refined type. If so, this type
// gets refined to the pre-existing type.
}
Entry = I;
}
-
TypesByHash.erase(Entry);
Ty->refineAbstractTypeTo(NewTy);
return;
return PT;
}
-
//===----------------------------------------------------------------------===//
// Derived Type Refinement Functions
//===----------------------------------------------------------------------===//
// the PATypeHandle class. When there are no users of the abstract type, it
// is annihilated, because there is no way to get a reference to it ever again.
//
-void DerivedType::removeAbstractTypeUser(AbstractTypeUser *U) const {
+void Type::removeAbstractTypeUser(AbstractTypeUser *U) const {
// Search from back to front because we will notify users from back to
// front. Also, it is likely that there will be a stack like behavior to
// users that register and unregister users.
//
void FunctionType::refineAbstractType(const DerivedType *OldType,
const Type *NewType) {
- FunctionTypes.finishRefinement(this, OldType, NewType);
+ FunctionTypes.RefineAbstractType(this, OldType, NewType);
}
void FunctionType::typeBecameConcrete(const DerivedType *AbsTy) {
- refineAbstractType(AbsTy, AbsTy);
+ FunctionTypes.TypeBecameConcrete(this, AbsTy);
}
//
void ArrayType::refineAbstractType(const DerivedType *OldType,
const Type *NewType) {
- ArrayTypes.finishRefinement(this, OldType, NewType);
+ ArrayTypes.RefineAbstractType(this, OldType, NewType);
}
void ArrayType::typeBecameConcrete(const DerivedType *AbsTy) {
- refineAbstractType(AbsTy, AbsTy);
+ ArrayTypes.TypeBecameConcrete(this, AbsTy);
}
// refineAbstractType - Called when a contained type is found to be more
//
void PackedType::refineAbstractType(const DerivedType *OldType,
const Type *NewType) {
- PackedTypes.finishRefinement(this, OldType, NewType);
+ PackedTypes.RefineAbstractType(this, OldType, NewType);
}
void PackedType::typeBecameConcrete(const DerivedType *AbsTy) {
- refineAbstractType(AbsTy, AbsTy);
+ PackedTypes.TypeBecameConcrete(this, AbsTy);
}
// refineAbstractType - Called when a contained type is found to be more
//
void StructType::refineAbstractType(const DerivedType *OldType,
const Type *NewType) {
- StructTypes.finishRefinement(this, OldType, NewType);
+ StructTypes.RefineAbstractType(this, OldType, NewType);
}
void StructType::typeBecameConcrete(const DerivedType *AbsTy) {
- refineAbstractType(AbsTy, AbsTy);
+ StructTypes.TypeBecameConcrete(this, AbsTy);
}
// refineAbstractType - Called when a contained type is found to be more
//
void PointerType::refineAbstractType(const DerivedType *OldType,
const Type *NewType) {
- PointerTypes.finishRefinement(this, OldType, NewType);
+ PointerTypes.RefineAbstractType(this, OldType, NewType);
}
void PointerType::typeBecameConcrete(const DerivedType *AbsTy) {
- refineAbstractType(AbsTy, AbsTy);
+ PointerTypes.TypeBecameConcrete(this, AbsTy);
}
bool SequentialType::indexValid(const Value *V) const {
projects / oota-llvm.git / blobdiff