[llvm-commits] CVS: llvm/lib/VMCore/Type.cpp
Chris Lattner
lattner at cs.uiuc.edu
Thu Sep 4 21:22:02 PDT 2003
Changes in directory llvm/lib/VMCore:
Type.cpp updated: 1.64 -> 1.65
---
Log message:
Check in a bunch of minor fixes, plus a whole lot of #if 0'd out code, which will hopefully be enabled in the near future
This does not make any functionality changes
---
Diffs of the changes:
Index: llvm/lib/VMCore/Type.cpp
diff -u llvm/lib/VMCore/Type.cpp:1.64 llvm/lib/VMCore/Type.cpp:1.65
--- llvm/lib/VMCore/Type.cpp:1.64 Thu Sep 4 18:49:53 2003
+++ llvm/lib/VMCore/Type.cpp Thu Sep 4 21:21:39 2003
@@ -1,4 +1,4 @@
-//===-- Type.cpp - Implement the Type class ----------------------*- C++ -*--=//
+//===-- Type.cpp - Implement the Type class -------------------------------===//
//
// This file implements the Type class for the VMCore library.
//
@@ -451,7 +451,7 @@
// Two really annoying special cases that breaks an otherwise nice simple
// algorithm is the fact that arraytypes have sizes that differentiates types,
- // and that method types can be varargs or not. Consider this now.
+ // and that function types can be varargs or not. Consider this now.
if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
if (ATy->getNumElements() != cast<ArrayType>(Ty2)->getNumElements())
return false;
@@ -483,13 +483,12 @@
typedef std::map<ValType, PATypeHandle> MapTy;
MapTy Map;
public:
+ typedef typename MapTy::iterator iterator;
~TypeMap() { print("ON EXIT"); }
inline TypeClass *get(const ValType &V) {
- typename std::map<ValType, PATypeHandle>::iterator I
- = Map.find(V);
- // TODO: FIXME: When Types are not CONST.
- return (I != Map.end()) ? (TypeClass*)I->second.get() : 0;
+ iterator I = Map.find(V);
+ return I != Map.end() ? (TypeClass*)I->second.get() : 0;
}
inline void add(const ValType &V, TypeClass *T) {
@@ -497,13 +496,26 @@
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!");
+ return I;
+ }
+
// containsEquivalent - Return true if the typemap contains a type that is
// structurally equivalent to the specified type.
//
- inline const TypeClass *containsEquivalent(const TypeClass *Ty) {
- for (typename MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I)
- if (I->second.get() != Ty && TypesEqual(Ty, I->second.get()))
- return (TypeClass*)I->second.get();
+ inline TypeClass *containsEquivalent(TypeClass *Ty) { //iterator TyIt) {
+ //const TypeClass *Ty = (const TypeClass*)TyIt->second.get();
+ for (iterator I = Map.begin(), E = Map.end(); I != E; ++I)
+ if (I->second.get() != Ty && TypesEqual(Ty, I->second.get())) {
+ TypeClass *New = (TypeClass*)I->second.get();
+#if 0
+ Map.erase(TyIt); // The old entry is now dead!
+#endif
+ return New;
+ }
return 0;
}
@@ -518,8 +530,8 @@
<< *OldTy << " replacement == " << (void*)NewTy
<< ", " << *NewTy << "\n";
#endif
- for (typename MapTy::iterator I = Map.begin(), E = Map.end(); I != E; ++I)
- if (I->second == OldTy) {
+ for (iterator I = Map.begin(), E = Map.end(); I != E; ++I)
+ if (I->second.get() == OldTy) {
// Check to see if the type just became concrete. If so, remove self
// from user list.
I->second.removeUserFromConcrete();
@@ -528,18 +540,24 @@
}
void remove(const ValType &OldVal) {
- typename MapTy::iterator I = Map.find(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";
unsigned i = 0;
- for (MapTy::const_iterator I = Map.begin(), E = Map.end(); I != E; ++I)
- std::cerr << " " << (++i) << ". " << I->second << " "
- << *I->second << "\n";
+ for (typename MapTy::const_iterator I = Map.begin(), E = Map.end();
+ I != E; ++I)
+ std::cerr << " " << (++i) << ". " << (void*)I->second.get() << " "
+ << *I->second.get() << "\n";
#endif
}
@@ -622,6 +640,8 @@
ArgTypes.push_back(PATypeHandle(MVT.ArgTypes[i], this));
}
+ static FunctionValType get(const FunctionType *FT);
+
// Subclass should override this... to update self as usual
virtual void doRefinement(const DerivedType *OldType, const Type *NewType) {
if (RetTy == OldType) RetTy = NewType;
@@ -648,6 +668,17 @@
// Define the actual map itself now...
static TypeMap<FunctionValType, FunctionType> FunctionTypes;
+FunctionValType FunctionValType::get(const FunctionType *FT) {
+ // Build up a FunctionValType
+ std::vector<const Type *> ParamTypes;
+ ParamTypes.reserve(FT->getParamTypes().size());
+ for (unsigned i = 0, e = FT->getParamTypes().size(); i != e; ++i)
+ ParamTypes.push_back(FT->getParamType(i));
+ return FunctionValType(FT->getReturnType(), ParamTypes, FT->isVarArg(),
+ FunctionTypes);
+}
+
+
// FunctionType::get - The factory function for the FunctionType class...
FunctionType *FunctionType::get(const Type *ReturnType,
const std::vector<const Type*> &Params,
@@ -664,6 +695,17 @@
return MT;
}
+void FunctionType::dropAllTypeUses(bool inMap) {
+#if 0
+ //if (inMap) FunctionTypes.remove(FunctionTypes.getEntryForType(this));
+
+ // Drop all uses of other types, which might be recursive.
+ ResultType = Type::VoidTy;
+ ParamTys.clear();
+#endif
+}
+
+
//===----------------------------------------------------------------------===//
// Array Type Factory...
//
@@ -681,6 +723,9 @@
: ValTypeBase<ArrayValType, ArrayType>(AVT), ValTy(AVT.ValTy, this),
Size(AVT.Size) {}
+ static ArrayValType get(const ArrayType *AT);
+
+
// Subclass should override this... to update self as usual
virtual void doRefinement(const DerivedType *OldType, const Type *NewType) {
assert(ValTy == OldType);
@@ -701,6 +746,11 @@
static TypeMap<ArrayValType, ArrayType> ArrayTypes;
+ArrayValType ArrayValType::get(const ArrayType *AT) {
+ return ArrayValType(AT->getElementType(), AT->getNumElements(), ArrayTypes);
+}
+
+
ArrayType *ArrayType::get(const Type *ElementType, unsigned NumElements) {
assert(ElementType && "Can't get array of null types!");
@@ -717,6 +767,16 @@
return AT;
}
+void ArrayType::dropAllTypeUses(bool inMap) {
+#if 0
+ //if (inMap) ArrayTypes.remove(ArrayTypes.getEntryForType(this));
+ ElementType = Type::IntTy;
+#endif
+}
+
+
+
+
//===----------------------------------------------------------------------===//
// Struct Type Factory...
//
@@ -744,6 +804,8 @@
ElTypes.push_back(PATypeHandle(SVT.ElTypes[i], this));
}
+ static StructValType get(const StructType *ST);
+
// Subclass should override this... to update self as usual
virtual void doRefinement(const DerivedType *OldType, const Type *NewType) {
for (unsigned i = 0; i < ElTypes.size(); ++i)
@@ -763,6 +825,17 @@
static TypeMap<StructValType, StructType> StructTypes;
+StructValType StructValType::get(const StructType *ST) {
+ std::vector<const Type *> ElTypes;
+ ElTypes.reserve(ST->getElementTypes().size());
+ for (unsigned i = 0, e = ST->getElementTypes().size(); i != e; ++i)
+ ElTypes.push_back(ST->getElementTypes()[i]);
+
+ return StructValType(ElTypes, StructTypes);
+}
+
+
+
StructType *StructType::get(const std::vector<const Type*> &ETypes) {
StructValType STV(ETypes, StructTypes);
StructType *ST = StructTypes.get(STV);
@@ -777,6 +850,15 @@
return ST;
}
+void StructType::dropAllTypeUses(bool inMap) {
+#if 0
+ //if (inMap) StructTypes.remove(StructTypes.getEntryForType(this));
+ ETypes.clear();
+#endif
+}
+
+
+
//===----------------------------------------------------------------------===//
// Pointer Type Factory...
//
@@ -795,6 +877,8 @@
PointerValType(const PointerValType &PVT)
: ValTypeBase<PointerValType, PointerType>(PVT), ValTy(PVT.ValTy, this) {}
+ static PointerValType get(const PointerType *PT);
+
// Subclass should override this... to update self as usual
virtual void doRefinement(const DerivedType *OldType, const Type *NewType) {
assert(ValTy == OldType);
@@ -814,6 +898,11 @@
static TypeMap<PointerValType, PointerType> PointerTypes;
+PointerValType PointerValType::get(const PointerType *PT) {
+ return PointerValType(PT->getElementType(), PointerTypes);
+}
+
+
PointerType *PointerType::get(const Type *ValueType) {
assert(ValueType && "Can't get a pointer to <null> type!");
PointerValType PVT(ValueType, PointerTypes);
@@ -830,6 +919,13 @@
return PT;
}
+void PointerType::dropAllTypeUses(bool inMap) {
+#if 0
+ //if (inMap) PointerTypes.remove(PointerTypes.getEntryForType(this));
+ ElementType = Type::IntTy;
+#endif
+}
+
void debug_type_tables() {
FunctionTypes.dump();
ArrayTypes.dump();
@@ -891,12 +987,12 @@
}
-// refineAbstractTypeTo - This function is used to when it is discovered that
-// the 'this' abstract type is actually equivalent to the NewType specified.
-// This causes all users of 'this' to switch to reference the more concrete
-// type NewType and for 'this' to be deleted.
+// refineAbstractTypeToInternal - This function is used to when it is discovered
+// that the 'this' abstract type is actually equivalent to the NewType
+// specified. This causes all users of 'this' to switch to reference the more
+// concrete type NewType and for 'this' to be deleted.
//
-void DerivedType::refineAbstractTypeTo(const Type *NewType) {
+void DerivedType::refineAbstractTypeToInternal(const Type *NewType, bool inMap){
assert(isAbstract() && "refineAbstractTypeTo: Current type is not abstract!");
assert(this != NewType && "Can't refine to myself!");
@@ -924,6 +1020,14 @@
//
addAbstractTypeUser(this);
+#if 0
+ // To make the situation simpler, we ask the subclass to remove this type from
+ // the type map, and to replace any type uses with uses of non-abstract types.
+ // This dramatically limits the amount of recursive type trouble we can find
+ // ourselves in.
+ dropAllTypeUses(inMap);
+#endif
+
// Count the number of self uses. Stop looping when sizeof(list) == NSU.
unsigned NumSelfUses = 0;
@@ -972,6 +1076,10 @@
//
assert((NewTy == this || AbstractTypeUsers.back() == this) &&
"Only self uses should be left!");
+
+#if 0
+ assert(AbstractTypeUsers.size() == 1 && "This type should get deleted!");
+#endif
removeAbstractTypeUser(this);
}
@@ -1054,6 +1162,14 @@
<< *OldType << "], " << (void*)NewType << " ["
<< *NewType << "])\n";
#endif
+
+ // Look up our current type map entry..
+#if 0
+ TypeMap<FunctionValType, FunctionType>::iterator TMI =
+ FunctionTypes.getEntryForType(this);
+ assert(TMI->second == this);
+#endif
+
// Find the type element we are refining...
if (ResultType == OldType) {
ResultType.removeUserFromConcrete();
@@ -1066,7 +1182,7 @@
}
if (const FunctionType *MT = FunctionTypes.containsEquivalent(this)) {
- refineAbstractTypeTo(MT); // Different type altogether...
+ refineAbstractTypeToInternal(MT, false); // Different type altogether...
} else {
// If the type is currently thought to be abstract, rescan all of our
// subtypes to see if the type has just become concrete!
@@ -1088,12 +1204,19 @@
<< *NewType << "])\n";
#endif
+#if 0
+ // Look up our current type map entry..
+ TypeMap<ArrayValType, ArrayType>::iterator TMI =
+ ArrayTypes.getEntryForType(this);
+ assert(TMI->second == this);
+#endif
+
assert(getElementType() == OldType);
ElementType.removeUserFromConcrete();
ElementType = NewType;
if (const ArrayType *AT = ArrayTypes.containsEquivalent(this)) {
- refineAbstractTypeTo(AT); // Different type altogether...
+ refineAbstractTypeToInternal(AT, false); // Different type altogether...
} else {
// If the type is currently thought to be abstract, rescan all of our
// subtypes to see if the type has just become concrete!
@@ -1114,6 +1237,14 @@
<< *OldType << "], " << (void*)NewType << " ["
<< *NewType << "])\n";
#endif
+
+#if 0
+ // Look up our current type map entry..
+ TypeMap<StructValType, StructType>::iterator TMI =
+ StructTypes.getEntryForType(this);
+ assert(TMI->second == this);
+#endif
+
for (int i = ETypes.size()-1; i >= 0; --i)
if (ETypes[i] == OldType) {
ETypes[i].removeUserFromConcrete();
@@ -1123,7 +1254,7 @@
}
if (const StructType *ST = StructTypes.containsEquivalent(this)) {
- refineAbstractTypeTo(ST); // Different type altogether...
+ refineAbstractTypeToInternal(ST, false); // Different type altogether...
} else {
// If the type is currently thought to be abstract, rescan all of our
// subtypes to see if the type has just become concrete!
@@ -1144,12 +1275,19 @@
<< *NewType << "])\n";
#endif
+#if 0
+ // Look up our current type map entry..
+ TypeMap<PointerValType, PointerType>::iterator TMI =
+ PointerTypes.getEntryForType(this);
+ assert(TMI->second == this);
+#endif
+
assert(ElementType == OldType);
ElementType.removeUserFromConcrete();
ElementType = NewType;
if (const PointerType *PT = PointerTypes.containsEquivalent(this)) {
- refineAbstractTypeTo(PT); // Different type altogether...
+ refineAbstractTypeToInternal(PT, false); // Different type altogether...
} else {
// If the type is currently thought to be abstract, rescan all of our
// subtypes to see if the type has just become concrete!
More information about the llvm-commits
mailing list