#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/SCCIterator.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
#include <algorithm>
#include <iostream>
using namespace llvm;
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;
//
unsigned Type::getPrimitiveSize() const {
switch (getTypeID()) {
- case Type::BoolTy:
- case Type::SByteTy:
- case Type::UByteTy: return 1;
- case Type::UShortTy:
- case Type::ShortTy: return 2;
- case Type::FloatTy:
- case Type::IntTy:
- case Type::UIntTy: return 4;
- case Type::LongTy:
- case Type::ULongTy:
- case Type::DoubleTy: return 8;
+ case Type::BoolTyID:
+ case Type::SByteTyID:
+ case Type::UByteTyID: return 1;
+ case Type::UShortTyID:
+ case Type::ShortTyID: return 2;
+ case Type::FloatTyID:
+ case Type::IntTyID:
+ case Type::UIntTyID: return 4;
+ case Type::LongTyID:
+ case Type::ULongTyID:
+ case Type::DoubleTyID: return 8;
default: return 0;
}
}
unsigned Type::getPrimitiveSizeInBits() const {
switch (getTypeID()) {
- case Type::BoolTy: return 1;
- case Type::SByteTy:
- case Type::UByteTy: return 8;
- case Type::UShortTy:
- case Type::ShortTy: return 16;
- case Type::FloatTy:
- case Type::IntTy:
- case Type::UIntTy: return 32;
- case Type::LongTy:
- case Type::ULongTy:
- case Type::DoubleTy: return 64;
+ case Type::BoolTyID: return 1;
+ case Type::SByteTyID:
+ case Type::UByteTyID: return 8;
+ case Type::UShortTyID:
+ case Type::ShortTyID: return 16;
+ case Type::FloatTyID:
+ case Type::IntTyID:
+ case Type::UIntTyID: return 32;
+ case Type::LongTyID:
+ case Type::ULongTyID:
+ case Type::DoubleTyID: return 64;
default: return 0;
}
}
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.
// The old record is now out-of-date, because one of the children has been
// updated. Remove the obsolete entry from the map.
- Map.erase(ValType::get(Ty));
+ unsigned NumErased = Map.erase(ValType::get(Ty));
+ assert(NumErased && "Element not found!");
// Remember the structural hash for the type before we start hacking on it,
// in case we need it later.
// Find the type element we are refining... and change it now!
for (unsigned i = 0, e = Ty->ContainedTys.size(); i != e; ++i)
- if (Ty->ContainedTys[i] == OldType) {
- Ty->ContainedTys[i].removeUserFromConcrete();
+ if (Ty->ContainedTys[i] == OldType)
Ty->ContainedTys[i] = NewType;
- }
-
- unsigned TypeHash = ValType::hashTypeStructure(Ty);
-
+ 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;
- ValType V = ValType::get(Ty);
- tie(I, Inserted) = Map.insert(std::make_pair(V, Ty));
+ tie(I, Inserted) = Map.insert(std::make_pair(ValType::get(Ty), Ty));
if (!Inserted) {
+ assert(OldType != NewType);
// Refined to a different type altogether?
- RemoveFromTypesByHash(TypeHash, Ty);
+ RemoveFromTypesByHash(OldTypeHash, Ty);
// We already have this type in the table. Get rid of the newly refined
// type.
Ty->refineAbstractTypeTo(NewTy);
return;
}
-
} else {
// 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
tie(I, E) = TypesByHash.equal_range(OldTypeHash);
Entry = E;
for (; I != E; ++I) {
- if (I->second != Ty) {
+ if (I->second == Ty) {
+ // Remember the position of the old type if we see it in our scan.
+ Entry = I;
+ } else {
if (TypesEqual(Ty, I->second)) {
- assert(Ty->isAbstract() && "Replacing a non-abstract type?");
TypeClass *NewTy = cast<TypeClass>((Type*)I->second.get());
if (Entry == E) {
- // Find the location of Ty in the TypesByHash structure.
+ // Find the location of Ty in the TypesByHash structure if we
+ // haven't seen it already.
while (I->second != Ty) {
++I;
assert(I != E && "Structure doesn't contain type??");
}
Entry = I;
}
-
TypesByHash.erase(Entry);
Ty->refineAbstractTypeTo(NewTy);
return;
}
- } else {
- // Remember the position of
- Entry = I;
}
}
-
// If there is no existing type of the same structure, we reinsert an
// updated record into the map.
Map.insert(std::make_pair(ValType::get(Ty), Ty));
}
// If the hash codes differ, update TypesByHash
- if (TypeHash != OldTypeHash) {
+ if (NewTypeHash != OldTypeHash) {
RemoveFromTypesByHash(OldTypeHash, Ty);
- TypesByHash.insert(std::make_pair(TypeHash, Ty));
+ TypesByHash.insert(std::make_pair(NewTypeHash, Ty));
}
-
+
// If the type is currently thought to be abstract, rescan all of our
- // subtypes to see if the type has just become concrete!
+ // 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();
}
PackedType *PackedType::get(const Type *ElementType, unsigned NumElements) {
assert(ElementType && "Can't get packed of null types!");
+ assert(isPowerOf2_32(NumElements) && "Vector length should be a power of 2!");
PackedValType PVT(ElementType, NumElements);
PackedType *PT = PackedTypes.get(PVT);
PointerType *PointerType::get(const Type *ValueType) {
assert(ValueType && "Can't get a pointer to <null> type!");
+ // FIXME: The sparc backend makes void pointers, which is horribly broken.
+ // "Fix" it, then reenable this assertion.
+ //assert(ValueType != Type::VoidTy &&
+ // "Pointer to void is not valid, use sbyte* instead!");
PointerValType PVT(ValueType);
PointerType *PT = PointerTypes.get(PVT);
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