aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/llvm/AbstractTypeUser.h33
-rw-r--r--include/llvm/DerivedTypes.h17
-rw-r--r--include/llvm/Value.h2
-rw-r--r--lib/AsmParser/llvmAsmParser.y4
-rw-r--r--lib/Bytecode/Reader/ConstantReader.cpp2
-rw-r--r--lib/Bytecode/Reader/ReaderInternals.h2
-rw-r--r--lib/VMCore/Type.cpp32
7 files changed, 45 insertions, 47 deletions
diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index 272560f..751c5ac 100644
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -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;
diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index ed1856f..bd44bd2 100644
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -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);
}
diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index f6bd144..aef3434 100644
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -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
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 8fd88ac..ca5b48d 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -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;
diff --git a/lib/Bytecode/Reader/ConstantReader.cpp b/lib/Bytecode/Reader/ConstantReader.cpp
index 80c6fc3..32874e2 100644
--- a/lib/Bytecode/Reader/ConstantReader.cpp
+++ b/lib/Bytecode/Reader/ConstantReader.cpp
@@ -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.
diff --git a/lib/Bytecode/Reader/ReaderInternals.h b/lib/Bytecode/Reader/ReaderInternals.h
index a8ee6fc..e09e5e5 100644
--- a/lib/Bytecode/Reader/ReaderInternals.h
+++ b/lib/Bytecode/Reader/ReaderInternals.h
@@ -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;
diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp
index 6865273..28ed4f3 100644
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -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) {}
generated by cgit v1.1 at 2025-01-12 08:50:01 +0000