RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 11:13:28 +01:00
Code Issues Projects Releases Wiki Activity

Detemplatize the PATypeHandle class, which was only really instantiated on 'Type'.

Browse Source 
llvm-svn: 6774
This commit is contained in:
Chris Lattner 2003-06-18 19:22:36 +00:00
parent 9798527411
commit 75e1e892a6
7 changed files with 45 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
include/llvm/AbstractTypeUser.h
View File

@ -58,9 +58,8 @@ public:
// example. This class is a simple class used to keep the use list of abstract
// types up-to-date.
//
template <class TypeSubClass>
class PATypeHandle {
const TypeSubClass *Ty;
const Type *Ty;
AbstractTypeUser * const User;
// These functions are defined at the bottom of Type.h. See the comment there
@ -69,7 +68,7 @@ class PATypeHandle {
inline void removeUser();
public:
// ctor - Add use to type if abstract. Note that Ty must not be null
inline PATypeHandle(const TypeSubClass *ty, AbstractTypeUser *user)
inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
: Ty(ty), User(user) {
addUser();
}
@ -83,11 +82,11 @@ public:
inline ~PATypeHandle() { removeUser(); }
// Automatic casting operator so that the handle may be used naturally
inline operator const TypeSubClass *() const { return Ty; }
inline const TypeSubClass *get() const { return Ty; }
inline operator const Type *() const { return Ty; }
inline const Type *get() const { return Ty; }
// operator= - Allow assignment to handle
inline const TypeSubClass *operator=(const TypeSubClass *ty) {
inline const Type *operator=(const Type *ty) {
if (Ty != ty) { // Ensure we don't accidentally drop last ref to Ty
removeUser();
Ty = ty;
@ -97,16 +96,16 @@ public:
}
// operator= - Allow assignment to handle
inline const TypeSubClass *operator=(const PATypeHandle &T) {
inline const Type *operator=(const PATypeHandle &T) {
return operator=(T.Ty);
}
inline bool operator==(const TypeSubClass *ty) {
inline bool operator==(const Type *ty) {
return Ty == ty;
}
// operator-> - Allow user to dereference handle naturally...
inline const TypeSubClass *operator->() const { return Ty; }
inline const Type *operator->() const { return Ty; }
// removeUserFromConcrete - This function should be called when the User is
// notified that our type is refined... and the type is being refined to
@ -122,10 +121,10 @@ public:
// as both a handle (as above) and an AbstractTypeUser. It uses the callback to
// keep its pointer member updated to the current version of the type.
//
struct PATypeHolder : public AbstractTypeUser, public PATypeHandle<Type> {
inline PATypeHolder(const Type *ty) : PATypeHandle<Type>(ty, this) {}
struct PATypeHolder : public AbstractTypeUser, public PATypeHandle {
inline PATypeHolder(const Type *ty) : PATypeHandle(ty, this) {}
inline PATypeHolder(const PATypeHolder &T)
: AbstractTypeUser(T), PATypeHandle<Type>(T, this) {}
: AbstractTypeUser(T), PATypeHandle(T, this) {}
// refineAbstractType - All we do is update our PATypeHandle member to point
// to the new type.
@ -138,20 +137,20 @@ struct PATypeHolder : public AbstractTypeUser, public PATypeHandle<Type> {
removeUserFromConcrete();
if ((const Type*)OldTy != NewTy)
PATypeHandle<Type>::operator=(NewTy);
PATypeHandle::operator=(NewTy);
}
// operator= - Allow assignment to handle
inline const Type *operator=(const Type *ty) {
return PATypeHandle<Type>::operator=(ty);
return PATypeHandle::operator=(ty);
}
// operator= - Allow assignment to handle
inline const Type *operator=(const PATypeHandle<Type> &T) {
return PATypeHandle<Type>::operator=(T);
inline const Type *operator=(const PATypeHandle &T) {
return PATypeHandle::operator=(T);
}
inline const Type *operator=(const PATypeHolder &H) {
return PATypeHandle<Type>::operator=(H);
return PATypeHandle::operator=(H);
}
void dump() const;

17
include/llvm/DerivedTypes.h
View File

@ -86,9 +86,9 @@ public:
class FunctionType : public DerivedType {
public:
typedef std::vector<PATypeHandle<Type> > ParamTypes;
typedef std::vector<PATypeHandle> ParamTypes;
private:
PATypeHandle<Type> ResultType;
PATypeHandle ResultType;
ParamTypes ParamTys;
bool isVarArgs;
@ -181,7 +181,7 @@ public:
class StructType : public CompositeType {
public:
typedef std::vector<PATypeHandle<Type> > ElementTypes;
typedef std::vector<PATypeHandle> ElementTypes;
private:
ElementTypes ETypes; // Element types of struct
@ -245,10 +245,10 @@ class SequentialType : public CompositeType {
SequentialType(const SequentialType &); // Do not implement!
const SequentialType &operator=(const SequentialType &); // Do not implement!
protected:
PATypeHandle<Type> ElementType;
PATypeHandle ElementType;
SequentialType(PrimitiveID TID, const Type *ElType)
: CompositeType(TID), ElementType(PATypeHandle<Type>(ElType, this)) {
: CompositeType(TID), ElementType(PATypeHandle(ElType, this)) {
}
public:
@ -390,18 +390,17 @@ public:
// contains an AbstractTypeUser instance, so there is no good way to factor out
// the code. Hence this bit of uglyness.
//
template <class TypeSubClass> void PATypeHandle<TypeSubClass>::addUser() {
inline void PATypeHandle::addUser() {
assert(Ty && "Type Handle has a null type!");
if (Ty->isAbstract())
cast<DerivedType>(Ty)->addAbstractTypeUser(User);
}
template <class TypeSubClass> void PATypeHandle<TypeSubClass>::removeUser() {
inline void PATypeHandle::removeUser() {
if (Ty->isAbstract())
cast<DerivedType>(Ty)->removeAbstractTypeUser(User);
}
template <class TypeSubClass>
void PATypeHandle<TypeSubClass>::removeUserFromConcrete() {
inline void PATypeHandle::removeUserFromConcrete() {
if (!Ty->isAbstract())
cast<DerivedType>(Ty)->removeAbstractTypeUser(User);
}

2
include/llvm/Value.h
View File

@ -50,7 +50,7 @@ public:
private:
std::vector<User *> Uses;
std::string Name;
PATypeHandle<Type> Ty;
PATypeHandle Ty;
ValueTy VTy;
void operator=(const Value &); // Do not implement

4
lib/AsmParser/llvmAsmParser.y
View File

@ -816,7 +816,7 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference
| UpRTypesV '(' ArgTypeListI ')' { // Function derived type?
std::vector<const Type*> Params;
mapto($3->begin(), $3->end(), std::back_inserter(Params),
std::mem_fun_ref(&PATypeHandle<Type>::get));
std::mem_fun_ref(&PATypeHandle::get));
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
if (isVarArg) Params.pop_back();
@ -831,7 +831,7 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference
| '{' TypeListI '}' { // Structure type?
std::vector<const Type*> Elements;
mapto($2->begin(), $2->end(), std::back_inserter(Elements),
std::mem_fun_ref(&PATypeHandle<Type>::get));
std::mem_fun_ref(&PATypeHandle::get));
$$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
delete $2;

2
lib/Bytecode/Reader/ConstantReader.cpp
View File

@ -139,7 +139,7 @@ bool BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
// Insert a bunch of opaque types to be resolved later...
for (unsigned i = 0; i < NumEntries; ++i)
Tab.push_back(PATypeHandle<Type>(OpaqueType::get(), this));
Tab.push_back(PATypeHandle(OpaqueType::get(), this));
// Loop through reading all of the types. Forward types will make use of the
// opaque types just inserted.

2
lib/Bytecode/Reader/ReaderInternals.h
View File

@ -104,7 +104,7 @@ private: // All of this data is transient across calls to ParseBytecode
// TypesLoaded - This vector mirrors the Values[TypeTyID] plane. It is used
// to deal with forward references to types.
//
typedef std::vector<PATypeHandle<Type> > TypeValuesListTy;
typedef std::vector<PATypeHandle> TypeValuesListTy;
TypeValuesListTy ModuleTypeValues;
TypeValuesListTy FunctionTypeValues;

32
lib/VMCore/Type.cpp
View File

@ -216,11 +216,11 @@ Type *Type::LabelTy = &TheLabelTy;
FunctionType::FunctionType(const Type *Result,
const std::vector<const Type*> &Params,
bool IsVarArgs) : DerivedType(FunctionTyID),
ResultType(PATypeHandle<Type>(Result, this)),
ResultType(PATypeHandle(Result, this)),
isVarArgs(IsVarArgs) {
ParamTys.reserve(Params.size());
for (unsigned i = 0; i < Params.size(); ++i)
ParamTys.push_back(PATypeHandle<Type>(Params[i], this));
ParamTys.push_back(PATypeHandle(Params[i], this));
setDerivedTypeProperties();
}
@ -230,7 +230,7 @@ StructType::StructType(const std::vector<const Type*> &Types)
ETypes.reserve(Types.size());
for (unsigned i = 0; i < Types.size(); ++i) {
assert(Types[i] != Type::VoidTy && "Void type in method prototype!!");
ETypes.push_back(PATypeHandle<Type>(Types[i], this));
ETypes.push_back(PATypeHandle(Types[i], this));
}
setDerivedTypeProperties();
}
@ -427,20 +427,20 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2) {
//
template<class ValType, class TypeClass>
class TypeMap : public AbstractTypeUser {
typedef std::map<ValType, PATypeHandle<TypeClass> > MapTy;
typedef std::map<ValType, PATypeHandle> MapTy;
MapTy Map;
public:
~TypeMap() { print("ON EXIT"); }
inline TypeClass *get(const ValType &V) {
typename std::map<ValType, PATypeHandle<TypeClass> >::iterator I
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;
}
inline void add(const ValType &V, TypeClass *T) {
Map.insert(std::make_pair(V, PATypeHandle<TypeClass>(T, this)));
Map.insert(std::make_pair(V, PATypeHandle(T, this)));
print("add");
}
@ -521,7 +521,7 @@ protected:
TypeMap<ValType, TypeClass> &Table = MyTable; // Copy MyTable reference
ValType Tmp(*(ValType*)this); // Copy this.
PATypeHandle<TypeClass> OldType(Table.get(*(ValType*)this), this);
PATypeHandle OldType(Table.get(*(ValType*)this), this);
Table.remove(*(ValType*)this); // Destroy's this!
// Refine temporary to new state...
@ -546,8 +546,8 @@ protected:
// FunctionValType - Define a class to hold the key that goes into the TypeMap
//
class FunctionValType : public ValTypeBase<FunctionValType, FunctionType> {
PATypeHandle<Type> RetTy;
std::vector<PATypeHandle<Type> > ArgTypes;
PATypeHandle RetTy;
std::vector<PATypeHandle> ArgTypes;
bool isVarArg;
public:
FunctionValType(const Type *ret, const std::vector<const Type*> &args,
@ -555,7 +555,7 @@ public:
: ValTypeBase<FunctionValType, FunctionType>(Tab), RetTy(ret, this),
isVarArg(IVA) {
for (unsigned i = 0; i < args.size(); ++i)
ArgTypes.push_back(PATypeHandle<Type>(args[i], this));
ArgTypes.push_back(PATypeHandle(args[i], this));
}
// We *MUST* have an explicit copy ctor so that the TypeHandles think that
@ -566,7 +566,7 @@ public:
isVarArg(MVT.isVarArg) {
ArgTypes.reserve(MVT.ArgTypes.size());
for (unsigned i = 0; i < MVT.ArgTypes.size(); ++i)
ArgTypes.push_back(PATypeHandle<Type>(MVT.ArgTypes[i], this));
ArgTypes.push_back(PATypeHandle(MVT.ArgTypes[i], this));
}
// Subclass should override this... to update self as usual
@ -615,7 +615,7 @@ FunctionType *FunctionType::get(const Type *ReturnType,
// Array Type Factory...
//
class ArrayValType : public ValTypeBase<ArrayValType, ArrayType> {
PATypeHandle<Type> ValTy;
PATypeHandle ValTy;
unsigned Size;
public:
ArrayValType(const Type *val, int sz, TypeMap<ArrayValType, ArrayType> &Tab)
@ -671,14 +671,14 @@ ArrayType *ArrayType::get(const Type *ElementType, unsigned NumElements) {
// StructValType - Define a class to hold the key that goes into the TypeMap
//
class StructValType : public ValTypeBase<StructValType, StructType> {
std::vector<PATypeHandle<Type> > ElTypes;
std::vector<PATypeHandle> ElTypes;
public:
StructValType(const std::vector<const Type*> &args,
TypeMap<StructValType, StructType> &Tab)
: ValTypeBase<StructValType, StructType>(Tab) {
ElTypes.reserve(args.size());
for (unsigned i = 0, e = args.size(); i != e; ++i)
ElTypes.push_back(PATypeHandle<Type>(args[i], this));
ElTypes.push_back(PATypeHandle(args[i], this));
}
// We *MUST* have an explicit copy ctor so that the TypeHandles think that
@ -688,7 +688,7 @@ public:
: ValTypeBase<StructValType, StructType>(SVT){
ElTypes.reserve(SVT.ElTypes.size());
for (unsigned i = 0, e = SVT.ElTypes.size(); i != e; ++i)
ElTypes.push_back(PATypeHandle<Type>(SVT.ElTypes[i], this));
ElTypes.push_back(PATypeHandle(SVT.ElTypes[i], this));
}
// Subclass should override this... to update self as usual
@ -731,7 +731,7 @@ StructType *StructType::get(const std::vector<const Type*> &ETypes) {
// PointerValType - Define a class to hold the key that goes into the TypeMap
//
class PointerValType : public ValTypeBase<PointerValType, PointerType> {
PATypeHandle<Type> ValTy;
PATypeHandle ValTy;
public:
PointerValType(const Type *val, TypeMap<PointerValType, PointerType> &Tab)
: ValTypeBase<PointerValType, PointerType>(Tab), ValTy(val, this) {}