6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-10-20 09:24:58 +00:00
Code Issues Projects Releases Wiki Activity

There is no reason for Value to be an AbstractTypeUser. This just makes things

Browse Source 
significantly more complete.  Instead, just make DerivedType's AbstractTypeUser's,
and make Value contain a PATypeHolder.  This will also be more efficient in the
future.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8827 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-10-02 19:44:23 +00:00
parent df0c1a2189
commit 0dde36c4c7
2 changed files with 16 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
include/llvm/DerivedTypes.h
View File

@ -19,7 +19,7 @@ class ArrayValType;
class StructValType;
class PointerValType;
class DerivedType : public Type {
class DerivedType : public Type, public AbstractTypeUser {
char isRefining; // Used for recursive types
// AbstractTypeUsers - Implement a list of the users that need to be notified
@ -80,6 +80,8 @@ public:
refineAbstractTypeToInternal(NewType, true);
}
void dump() const { Value::dump(); }
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const DerivedType *T) { return true; }
static inline bool classof(const Type *T) {
@ -149,7 +151,6 @@ public:
const std::vector<const Type*> &Params,
bool isVarArg);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FunctionType *T) { return true; }
static inline bool classof(const Type *T) {
@ -410,6 +411,16 @@ public:
return new OpaqueType(); // All opaque types are distinct
}
// refineAbstractType - Called when a contained type is found to be more
// concrete - this could potentially change us from an abstract type to a
// concrete type.
//
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
// This class never uses other types!
abort();
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const OpaqueType *T) { return true; }
static inline bool classof(const Type *T) {

14
include/llvm/Value.h
View File

@ -34,9 +34,7 @@ class SymbolTable;
/// Value - The base class of all values computed by a program that may be used
/// as operands to other values.
///
class Value : public Annotable, // Values are annotable
public AbstractTypeUser { // Values use potentially abstract types
public:
struct Value : public Annotable { // Values are annotable
enum ValueTy {
TypeVal, // This is an instance of Type
ConstantVal, // This is an instance of Constant
@ -50,7 +48,7 @@ public:
private:
std::vector<User *> Uses;
std::string Name;
PATypeHandle Ty;
PATypeHolder Ty;
ValueTy VTy;
void operator=(const Value &); // Do not implement
@ -61,7 +59,7 @@ public:
/// dump - Support for debugging, callable in GDB: V->dump()
//
void dump() const;
virtual void dump() const;
/// print - Implement operator<< on Value...
///
@ -93,12 +91,6 @@ public:
// Only use when in type resolution situations!
void uncheckedReplaceAllUsesWith(Value *V);
/// refineAbstractType - This function is implemented because we use
/// potentially abstract types, and these types may be resolved to more
/// concrete types after we are constructed.
///
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
//----------------------------------------------------------------------
// Methods for handling the vector of uses of this Value.
//