#include "Support/DepthFirstIterator.h"
#include "Support/StringExtras.h"
#include "Support/STLExtras.h"
-#include "Support/Statistic.h"
#include <algorithm>
-
using namespace llvm;
-static Statistic<> NumSlowTypes("type", "numslowtypes");
-static Statistic<> NumTypeEquals("type", "numtypeequals");
-
// DEBUG_MERGE_TYPES - Enable this #define to see how and when derived types are
// created and later destroyed, all in an effort to make sure that there is only
// a single canonical version of a type.
return TypesEqual(Ty, Ty2, EqTypes);
}
+// TypeHasCycleThrough - Return true there is a path from CurTy to TargetTy in
+// the type graph. We know that Ty is an abstract type, so if we ever reach a
+// non-abstract type, we know that we don't need to search the subgraph.
+static bool TypeHasCycleThrough(const Type *TargetTy, const Type *CurTy,
+ std::set<const Type*> &VisitedTypes) {
+ if (TargetTy == CurTy) return true;
+ if (!CurTy->isAbstract()) return false;
+
+ std::set<const Type*>::iterator VTI = VisitedTypes.lower_bound(CurTy);
+ if (VTI != VisitedTypes.end() && *VTI == CurTy)
+ return false;
+ VisitedTypes.insert(VTI, CurTy);
+
+ for (Type::subtype_iterator I = CurTy->subtype_begin(),
+ E = CurTy->subtype_end(); I != E; ++I)
+ if (TypeHasCycleThrough(TargetTy, *I, VisitedTypes))
+ return true;
+ return false;
+}
+
+
/// TypeHasCycleThroughItself - Return true if the specified type has a cycle
/// back to itself.
static bool TypeHasCycleThroughItself(const Type *Ty) {
+ assert(Ty->isAbstract() && "This code assumes that Ty was abstract!");
std::set<const Type*> VisitedTypes;
- for (Type::subtype_iterator I = Ty->subtype_begin(),
- E = Ty->subtype_end(); I != E; ++I)
- for (df_ext_iterator<const Type *, std::set<const Type*> >
- DFI = df_ext_begin(I->get(), VisitedTypes),
- E = df_ext_end(I->get(), VisitedTypes); DFI != E; ++DFI)
- if (*DFI == Ty)
- return true; // Found a cycle through ty!
+ for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
+ I != E; ++I)
+ if (TypeHasCycleThrough(Ty, *I, VisitedTypes))
+ return true;
return false;
}
class TypeMap {
std::map<ValType, PATypeHolder> Map;
+ /// TypesByHash - Keep track of each type by its structure hash value.
+ ///
+ std::multimap<unsigned, PATypeHolder> TypesByHash;
public:
typedef typename std::map<ValType, PATypeHolder>::iterator iterator;
~TypeMap() { print("ON EXIT"); }
return I != Map.end() ? cast<TypeClass>((Type*)I->second.get()) : 0;
}
- inline void add(const ValType &V, TypeClass *T) {
- Map.insert(std::make_pair(V, T));
+ inline void add(const ValType &V, TypeClass *Ty) {
+ Map.insert(std::make_pair(V, Ty));
+
+ // If this type has a cycle, remember it.
+ TypesByHash.insert(std::make_pair(ValType::hashTypeStructure(Ty), Ty));
print("add");
}
- iterator getEntryForType(TypeClass *Ty) {
- iterator I = Map.find(ValType::get(Ty));
- if (I == Map.end()) print("ERROR!");
- assert(I != Map.end() && "Didn't find type entry!");
- assert(I->second.get() == (const Type*)Ty && "Type entry wrong?");
- return I;
+ 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);
}
/// finishRefinement - This method is called after we have updated an existing
// us when we erase the entry from the map.
PATypeHolder TyHolder = Ty;
- // Look up our current type map entry..
- iterator TyIt = getEntryForType(Ty);
-
// 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(TyIt);
+ Map.erase(ValType::get(Ty));
+
+ // Remember the structural hash for the type before we start hacking on it,
+ // in case we need it later. Also, check to see if the type HAD a cycle
+ // through it, if so, we know it will when we hack on it.
+ unsigned OldTypeHash = ValType::hashTypeStructure(Ty);
- // Find the type element we are refining...
+ // 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();
Ty->ContainedTys[i] = NewType;
}
+
+ unsigned TypeHash = 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.
- bool TypeHasCycle = TypeHasCycleThroughItself(Ty);
+ bool TypeHasCycle = Ty->isAbstract() && TypeHasCycleThroughItself(Ty);
if (!TypeHasCycle) {
iterator I = Map.find(ValType::get(Ty));
if (I != Map.end()) {
TypeClass *NewTy = cast<TypeClass>((Type*)I->second.get());
// Refined to a different type altogether?
+ RemoveFromTypesByHash(TypeHash, Ty);
Ty->refineAbstractTypeTo(NewTy);
return;
}
} else {
- ++NumSlowTypes;
-
- unsigned TypeHash = ValType::hashTypeStructure(Ty);
-
-
-
// 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.
//
- for (iterator I = Map.begin(), E = Map.end(); I != E; ++I) {
- ++NumTypeEquals;
- if (TypesEqual(Ty, I->second)) {
- assert(Ty->isAbstract() && "Replacing a non-abstract type?");
- TypeClass *NewTy = cast<TypeClass>((Type*)I->second.get());
-
- // Refined to a different type altogether?
- Ty->refineAbstractTypeTo(NewTy);
- return;
+ std::multimap<unsigned, PATypeHolder>::iterator I,E, Entry;
+ tie(I, E) = TypesByHash.equal_range(TypeHash);
+ Entry = E;
+ for (; I != E; ++I) {
+ if (I->second != Ty) {
+ 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.
+ 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 we succeeded, we need to insert the type into the cycletypes table.
+ // There are several cases here, depending on whether the original type
+ // had the same hash code and was itself cyclic.
+ if (TypeHash != OldTypeHash) {
+ RemoveFromTypesByHash(OldTypeHash, Ty);
+ TypesByHash.insert(std::make_pair(TypeHash, Ty));
+ }
+
// 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));
}
}
- void remove(const ValType &OldVal) {
- iterator I = Map.find(OldVal);
- assert(I != Map.end() && "TypeMap::remove, element not found!");
- Map.erase(I);
- }
-
- void remove(iterator I) {
- assert(I != Map.end() && "Cannot remove invalid iterator pointer!");
- Map.erase(I);
- }
-
void print(const char *Arg) const {
#ifdef DEBUG_MERGE_TYPES
std::cerr << "TypeMap<>::" << Arg << " table contents:\n";
static FunctionValType get(const FunctionType *FT);
static unsigned hashTypeStructure(const FunctionType *FT) {
- return 0;
+ return FT->getNumParams()*2+FT->isVarArg();
}
// Subclass should override this... to update self as usual
}
static unsigned hashTypeStructure(const ArrayType *AT) {
- return 0;
+ return AT->getNumElements();
}
// Subclass should override this... to update self as usual
}
static unsigned hashTypeStructure(const StructType *ST) {
- return 0;
+ return ST->getNumElements();
}
// Subclass should override this... to update self as usual
return PT;
}
-namespace llvm {
-void debug_type_tables() {
- FunctionTypes.dump();
- ArrayTypes.dump();
- StructTypes.dump();
- PointerTypes.dump();
-}
-}
//===----------------------------------------------------------------------===//
// Derived Type Refinement Functions
projects / oota-llvm.git / blobdiff