2003-09-30 18:37:50 +00:00
|
|
|
//===-- llvm/Type.h - Classes for handling data types -----------*- C++ -*-===//
|
2005-04-21 20:19:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 19:59:42 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 20:19:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-05-30 15:49:30 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
#ifndef LLVM_TYPE_H
|
|
|
|
#define LLVM_TYPE_H
|
|
|
|
|
2006-04-04 19:05:42 +00:00
|
|
|
#include "llvm/AbstractTypeUser.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/Casting.h"
|
2006-02-07 06:17:10 +00:00
|
|
|
#include "llvm/Support/DataTypes.h"
|
2009-06-17 00:28:49 +00:00
|
|
|
#include "llvm/System/Atomic.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/GraphTraits.h"
|
2008-05-29 17:41:17 +00:00
|
|
|
#include "llvm/ADT/iterator.h"
|
2005-12-26 08:36:53 +00:00
|
|
|
#include <string>
|
2004-02-09 05:40:24 +00:00
|
|
|
#include <vector>
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
namespace llvm {
|
|
|
|
|
2001-09-07 16:23:59 +00:00
|
|
|
class DerivedType;
|
2001-07-20 19:12:34 +00:00
|
|
|
class PointerType;
|
2007-01-19 21:13:56 +00:00
|
|
|
class IntegerType;
|
2005-11-13 03:13:26 +00:00
|
|
|
class TypeMapBase;
|
2008-08-23 22:23:09 +00:00
|
|
|
class raw_ostream;
|
2008-10-01 20:16:19 +00:00
|
|
|
class Module;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2006-05-30 15:49:30 +00:00
|
|
|
/// This file contains the declaration of the Type class. For more "Type" type
|
|
|
|
/// stuff, look in DerivedTypes.h.
|
|
|
|
///
|
|
|
|
/// The instances of the Type class are immutable: once they are created,
|
|
|
|
/// they are never changed. Also note that only one instance of a particular
|
|
|
|
/// type is ever created. Thus seeing if two types are equal is a matter of
|
|
|
|
/// doing a trivial pointer comparison. To enforce that no two equal instances
|
|
|
|
/// are created, Type instances can only be created via static factory methods
|
|
|
|
/// in class Type and in derived classes.
|
|
|
|
///
|
|
|
|
/// Once allocated, Types are never free'd, unless they are an abstract type
|
|
|
|
/// that is resolved to a more concrete type.
|
2006-05-31 16:03:20 +00:00
|
|
|
///
|
|
|
|
/// Types themself don't have a name, and can be named either by:
|
|
|
|
/// - using SymbolTable instance, typically from some Module,
|
|
|
|
/// - using convenience methods in the Module class (which uses module's
|
|
|
|
/// SymbolTable too).
|
2006-05-30 15:49:30 +00:00
|
|
|
///
|
|
|
|
/// Opaque types are simple derived types with no state. There may be many
|
|
|
|
/// different Opaque type objects floating around, but two are only considered
|
|
|
|
/// identical if they are pointer equals of each other. This allows us to have
|
|
|
|
/// two opaque types that end up resolving to different concrete types later.
|
|
|
|
///
|
|
|
|
/// Opaque types are also kinda weird and scary and different because they have
|
|
|
|
/// to keep a list of uses of the type. When, through linking, parsing, or
|
2007-07-05 17:07:56 +00:00
|
|
|
/// bitcode reading, they become resolved, they need to find and update all
|
2006-05-30 15:49:30 +00:00
|
|
|
/// users of the unknown type, causing them to reference a new, more concrete
|
|
|
|
/// type. Opaque types are deleted when their use list dwindles to zero users.
|
|
|
|
///
|
|
|
|
/// @brief Root of type hierarchy
|
2005-11-13 03:26:12 +00:00
|
|
|
class Type : public AbstractTypeUser {
|
2004-09-28 01:59:17 +00:00
|
|
|
public:
|
2007-01-29 00:09:00 +00:00
|
|
|
//===-------------------------------------------------------------------===//
|
2002-08-25 22:54:55 +00:00
|
|
|
/// Definitions of all of the base types for the Type system. Based on this
|
|
|
|
/// value, you can cast to a "DerivedType" subclass (see DerivedTypes.h)
|
2005-04-21 20:19:05 +00:00
|
|
|
/// Note: If you add an element to this, you need to add an element to the
|
2002-08-25 22:54:55 +00:00
|
|
|
/// Type::getPrimitiveType function, or else things will break!
|
|
|
|
///
|
2004-06-17 18:19:28 +00:00
|
|
|
enum TypeID {
|
2004-07-04 10:46:49 +00:00
|
|
|
// PrimitiveTypes .. make sure LastPrimitiveTyID stays up to date
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
VoidTyID = 0, ///< 0: type with no size
|
|
|
|
FloatTyID, ///< 1: 32 bit floating point type
|
|
|
|
DoubleTyID, ///< 2: 64 bit floating point type
|
2007-08-03 01:03:46 +00:00
|
|
|
X86_FP80TyID, ///< 3: 80 bit floating point type (X87)
|
|
|
|
FP128TyID, ///< 4: 128 bit floating point type (112-bit mantissa)
|
|
|
|
PPC_FP128TyID, ///< 5: 128 bit floating point type (two 64-bits)
|
|
|
|
LabelTyID, ///< 6: Labels
|
2009-05-30 05:06:04 +00:00
|
|
|
MetadataTyID, ///< 7: Metadata
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
// Derived types... see DerivedTypes.h file...
|
|
|
|
// Make sure FirstDerivedTyID stays up to date!!!
|
2009-05-30 05:06:04 +00:00
|
|
|
IntegerTyID, ///< 8: Arbitrary bit width integers
|
|
|
|
FunctionTyID, ///< 9: Functions
|
|
|
|
StructTyID, ///< 10: Structures
|
|
|
|
ArrayTyID, ///< 11: Arrays
|
|
|
|
PointerTyID, ///< 12: Pointers
|
|
|
|
OpaqueTyID, ///< 13: Opaque: type with unknown structure
|
|
|
|
VectorTyID, ///< 14: SIMD 'packed' format, or other vector type
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-06-17 18:19:28 +00:00
|
|
|
NumTypeIDs, // Must remain as last defined ID
|
2004-07-04 10:46:49 +00:00
|
|
|
LastPrimitiveTyID = LabelTyID,
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
FirstDerivedTyID = IntegerTyID
|
2001-06-06 20:29:01 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2004-07-08 16:09:38 +00:00
|
|
|
TypeID ID : 8; // The current base type of this type.
|
2005-11-12 10:07:47 +00:00
|
|
|
bool Abstract : 1; // True if type contains an OpaqueType
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
unsigned SubclassData : 23; //Space for subclasses to store data
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-02-17 02:58:36 +00:00
|
|
|
/// RefCount - This counts the number of PATypeHolders that are pointing to
|
|
|
|
/// this type. When this number falls to zero, if the type is abstract and
|
|
|
|
/// has no AbstractTypeUsers, the type is deleted. This is only sensical for
|
|
|
|
/// derived types.
|
|
|
|
///
|
2009-06-23 20:17:22 +00:00
|
|
|
mutable sys::cas_flag RefCount;
|
2004-02-17 02:58:36 +00:00
|
|
|
|
2003-10-02 23:35:57 +00:00
|
|
|
const Type *getForwardedTypeInternal() const;
|
2007-04-06 02:02:20 +00:00
|
|
|
|
|
|
|
// Some Type instances are allocated as arrays, some aren't. So we provide
|
|
|
|
// this method to get the right kind of destruction for the type of Type.
|
|
|
|
void destroy() const; // const is a lie, this does "delete this"!
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
protected:
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit Type(TypeID id) : ID(id), Abstract(false), SubclassData(0),
|
2007-04-06 02:02:20 +00:00
|
|
|
RefCount(0), ForwardType(0), NumContainedTys(0),
|
|
|
|
ContainedTys(0) {}
|
2005-11-13 03:13:26 +00:00
|
|
|
virtual ~Type() {
|
2007-04-06 02:02:20 +00:00
|
|
|
assert(AbstractTypeUsers.empty() && "Abstract types remain");
|
2005-11-13 03:13:26 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// Types can become nonabstract later, if they are refined.
|
|
|
|
///
|
2001-09-07 16:23:59 +00:00
|
|
|
inline void setAbstract(bool Val) { Abstract = Val; }
|
|
|
|
|
2004-02-17 03:03:36 +00:00
|
|
|
unsigned getRefCount() const { return RefCount; }
|
|
|
|
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
unsigned getSubclassData() const { return SubclassData; }
|
|
|
|
void setSubclassData(unsigned val) { SubclassData = val; }
|
2006-12-08 18:06:16 +00:00
|
|
|
|
2003-10-02 23:35:57 +00:00
|
|
|
/// ForwardType - This field is used to implement the union find scheme for
|
|
|
|
/// abstract types. When types are refined to other types, this field is set
|
|
|
|
/// to the more refined type. Only abstract types can be forwarded.
|
|
|
|
mutable const Type *ForwardType;
|
|
|
|
|
2004-02-09 05:40:24 +00:00
|
|
|
|
2005-11-13 03:13:26 +00:00
|
|
|
/// AbstractTypeUsers - Implement a list of the users that need to be notified
|
|
|
|
/// if I am a type, and I get resolved into a more concrete type.
|
|
|
|
///
|
|
|
|
mutable std::vector<AbstractTypeUser *> AbstractTypeUsers;
|
2007-04-06 02:02:20 +00:00
|
|
|
|
|
|
|
/// NumContainedTys - Keeps track of how many PATypeHandle instances there
|
|
|
|
/// are at the end of this type instance for the list of contained types. It
|
|
|
|
/// is the subclasses responsibility to set this up. Set to 0 if there are no
|
|
|
|
/// contained types in this type.
|
|
|
|
unsigned NumContainedTys;
|
|
|
|
|
|
|
|
/// ContainedTys - A pointer to the array of Types (PATypeHandle) contained
|
|
|
|
/// by this Type. For example, this includes the arguments of a function
|
|
|
|
/// type, the elements of a structure, the pointee of a pointer, the element
|
|
|
|
/// type of an array, etc. This pointer may be 0 for types that don't
|
|
|
|
/// contain other types (Integer, Double, Float). In general, the subclass
|
|
|
|
/// should arrange for space for the PATypeHandles to be included in the
|
|
|
|
/// allocation of the type object and set this pointer to the address of the
|
|
|
|
/// first element. This allows the Type class to manipulate the ContainedTys
|
|
|
|
/// without understanding the subclass's placement for this array. keeping
|
|
|
|
/// it here also allows the subtype_* members to be implemented MUCH more
|
|
|
|
/// efficiently, and dynamically very few types do not contain any elements.
|
|
|
|
PATypeHandle *ContainedTys;
|
|
|
|
|
2001-09-07 16:23:59 +00:00
|
|
|
public:
|
2008-08-23 22:23:09 +00:00
|
|
|
void print(raw_ostream &O) const;
|
2005-03-02 03:43:55 +00:00
|
|
|
void print(std::ostream &O) const;
|
2001-09-07 16:23:59 +00:00
|
|
|
|
2004-05-25 08:46:04 +00:00
|
|
|
/// @brief Debugging support: print to stderr
|
2005-03-02 03:43:55 +00:00
|
|
|
void dump() const;
|
2004-05-25 08:46:04 +00:00
|
|
|
|
2008-10-01 20:16:19 +00:00
|
|
|
/// @brief Debugging support: print to stderr (use type names from context
|
|
|
|
/// module).
|
|
|
|
void dump(const Module *Context) const;
|
|
|
|
|
2001-09-07 16:23:59 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2002-08-25 22:54:55 +00:00
|
|
|
// Property accessors for dealing with types... Some of these virtual methods
|
|
|
|
// are defined in private classes defined in Type.cpp for primitive types.
|
2001-09-07 16:23:59 +00:00
|
|
|
//
|
|
|
|
|
2004-06-17 18:19:28 +00:00
|
|
|
/// getTypeID - Return the type id for the type. This will return one
|
|
|
|
/// of the TypeID enum elements defined above.
|
2002-08-25 22:54:55 +00:00
|
|
|
///
|
2004-06-17 18:19:28 +00:00
|
|
|
inline TypeID getTypeID() const { return ID; }
|
2001-09-07 16:23:59 +00:00
|
|
|
|
2009-02-28 23:01:57 +00:00
|
|
|
/// getDescription - Return the string representation of the type.
|
|
|
|
std::string getDescription() const;
|
2001-09-07 16:23:59 +00:00
|
|
|
|
2007-01-15 02:27:26 +00:00
|
|
|
/// isInteger - True if this is an instance of IntegerType.
|
2002-08-25 22:54:55 +00:00
|
|
|
///
|
2007-01-15 02:27:26 +00:00
|
|
|
bool isInteger() const { return ID == IntegerTyID; }
|
2001-09-07 16:23:59 +00:00
|
|
|
|
2007-08-20 19:25:59 +00:00
|
|
|
/// isIntOrIntVector - Return true if this is an integer type or a vector of
|
|
|
|
/// integer types.
|
|
|
|
///
|
|
|
|
bool isIntOrIntVector() const;
|
|
|
|
|
2009-07-05 22:35:49 +00:00
|
|
|
/// isFloatingPoint - Return true if this is one of the five floating point
|
2002-08-25 22:54:55 +00:00
|
|
|
/// types
|
2007-08-03 01:03:46 +00:00
|
|
|
bool isFloatingPoint() const { return ID == FloatTyID || ID == DoubleTyID ||
|
|
|
|
ID == X86_FP80TyID || ID == FP128TyID || ID == PPC_FP128TyID; }
|
2002-04-08 21:50:15 +00:00
|
|
|
|
2006-10-26 18:22:45 +00:00
|
|
|
/// isFPOrFPVector - Return true if this is a FP type or a vector of FP types.
|
|
|
|
///
|
|
|
|
bool isFPOrFPVector() const;
|
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// isAbstract - True if the type is either an Opaque type, or is a derived
|
2005-04-21 20:19:05 +00:00
|
|
|
/// type that includes an opaque type somewhere in it.
|
2002-08-25 22:54:55 +00:00
|
|
|
///
|
2001-09-07 16:23:59 +00:00
|
|
|
inline bool isAbstract() const { return Abstract; }
|
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
/// canLosslesslyBitCastTo - Return true if this type could be converted
|
2009-06-07 07:26:46 +00:00
|
|
|
/// with a lossless BitCast to type 'Ty'. For example, i8* to i32*. BitCasts
|
2006-11-27 01:05:10 +00:00
|
|
|
/// are valid for types of the same size only where no re-interpretation of
|
|
|
|
/// the bits is done.
|
|
|
|
/// @brief Determine if this type could be losslessly bitcast to Ty
|
|
|
|
bool canLosslesslyBitCastTo(const Type *Ty) const;
|
2001-11-26 16:47:10 +00:00
|
|
|
|
2002-05-06 16:12:53 +00:00
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// Here are some useful little methods to query what type derived types are
|
|
|
|
/// Note that all other types can just compare to see if this == Type::xxxTy;
|
|
|
|
///
|
2004-07-04 10:46:49 +00:00
|
|
|
inline bool isPrimitiveType() const { return ID <= LastPrimitiveTyID; }
|
2002-05-06 16:12:53 +00:00
|
|
|
inline bool isDerivedType() const { return ID >= FirstDerivedTyID; }
|
|
|
|
|
2008-05-21 23:35:53 +00:00
|
|
|
/// isFirstClassType - Return true if the type is "first class", meaning it
|
|
|
|
/// is a valid type for a Value.
|
2004-10-12 20:35:04 +00:00
|
|
|
///
|
2002-05-06 16:12:53 +00:00
|
|
|
inline bool isFirstClassType() const {
|
2008-05-23 22:47:52 +00:00
|
|
|
// There are more first-class kinds than non-first-class kinds, so a
|
|
|
|
// negative test is simpler than a positive one.
|
|
|
|
return ID != FunctionTyID && ID != VoidTyID && ID != OpaqueTyID;
|
2008-05-21 23:35:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// isSingleValueType - Return true if the type is a valid type for a
|
|
|
|
/// virtual register in codegen. This includes all first-class types
|
|
|
|
/// except struct and array types.
|
|
|
|
///
|
|
|
|
inline bool isSingleValueType() const {
|
2005-04-21 20:19:05 +00:00
|
|
|
return (ID != VoidTyID && ID <= LastPrimitiveTyID) ||
|
2007-02-15 02:26:10 +00:00
|
|
|
ID == IntegerTyID || ID == PointerTyID || ID == VectorTyID;
|
2002-05-06 16:12:53 +00:00
|
|
|
}
|
|
|
|
|
2008-05-30 22:40:06 +00:00
|
|
|
/// isAggregateType - Return true if the type is an aggregate type. This
|
|
|
|
/// means it is valid as the first operand of an insertvalue or
|
|
|
|
/// extractvalue instruction. This includes struct and array types, but
|
|
|
|
/// does not include vector types.
|
|
|
|
///
|
|
|
|
inline bool isAggregateType() const {
|
|
|
|
return ID == StructTyID || ID == ArrayTyID;
|
|
|
|
}
|
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// isSized - Return true if it makes sense to take the size of this type. To
|
|
|
|
/// get the actual size for a particular target, it is reasonable to use the
|
|
|
|
/// TargetData subsystem to do this.
|
|
|
|
///
|
2001-12-13 00:40:16 +00:00
|
|
|
bool isSized() const {
|
2005-01-24 16:28:03 +00:00
|
|
|
// If it's a primitive, it is always sized.
|
2007-01-15 02:27:26 +00:00
|
|
|
if (ID == IntegerTyID || isFloatingPoint() || ID == PointerTyID)
|
2005-01-24 16:00:52 +00:00
|
|
|
return true;
|
|
|
|
// If it is not something that can have a size (e.g. a function or label),
|
|
|
|
// it doesn't have a size.
|
2007-09-13 06:18:04 +00:00
|
|
|
if (ID != StructTyID && ID != ArrayTyID && ID != VectorTyID)
|
2005-01-24 16:00:52 +00:00
|
|
|
return false;
|
|
|
|
// If it is something that can have a size and it's concrete, it definitely
|
|
|
|
// has a size, otherwise we have to try harder to decide.
|
|
|
|
return !isAbstract() || isSizedDerivedType();
|
2001-12-13 00:40:16 +00:00
|
|
|
}
|
|
|
|
|
2007-05-17 21:30:39 +00:00
|
|
|
/// getPrimitiveSizeInBits - Return the basic size of this type if it is a
|
|
|
|
/// primitive type. These are fixed by LLVM and are not target dependent.
|
|
|
|
/// This will return zero if the type does not have a size or is not a
|
|
|
|
/// primitive type.
|
2002-08-25 22:54:55 +00:00
|
|
|
///
|
2005-04-23 21:59:42 +00:00
|
|
|
unsigned getPrimitiveSizeInBits() const;
|
2009-06-15 22:12:54 +00:00
|
|
|
|
|
|
|
/// getScalarSizeInBits - If this is a vector type, return the
|
|
|
|
/// getPrimitiveSizeInBits value for the element type. Otherwise return the
|
|
|
|
/// getPrimitiveSizeInBits value for this type.
|
|
|
|
unsigned getScalarSizeInBits() const;
|
|
|
|
|
2008-05-19 21:17:01 +00:00
|
|
|
/// getFPMantissaWidth - Return the width of the mantissa of this type. This
|
2009-06-15 22:12:54 +00:00
|
|
|
/// is only valid on floating point types. If the FP type does not
|
2008-05-19 21:17:01 +00:00
|
|
|
/// have a stable mantissa (e.g. ppc long double), this method returns -1.
|
2009-06-15 22:12:54 +00:00
|
|
|
int getFPMantissaWidth() const;
|
2002-05-06 16:12:53 +00:00
|
|
|
|
2007-09-25 13:53:22 +00:00
|
|
|
/// getForwardedType - Return the type that this type has been resolved to if
|
2003-10-02 23:35:57 +00:00
|
|
|
/// it has been resolved to anything. This is used to implement the
|
2004-03-26 21:43:22 +00:00
|
|
|
/// union-find algorithm for type resolution, and shouldn't be used by general
|
|
|
|
/// purpose clients.
|
2003-10-02 23:35:57 +00:00
|
|
|
const Type *getForwardedType() const {
|
|
|
|
if (!ForwardType) return 0;
|
|
|
|
return getForwardedTypeInternal();
|
|
|
|
}
|
2002-05-06 16:12:53 +00:00
|
|
|
|
2005-04-23 00:11:21 +00:00
|
|
|
/// getVAArgsPromotedType - Return the type an argument of this type
|
|
|
|
/// will be promoted to if passed through a variable argument
|
|
|
|
/// function.
|
2007-01-19 21:13:56 +00:00
|
|
|
const Type *getVAArgsPromotedType() const;
|
2005-04-23 00:11:21 +00:00
|
|
|
|
2009-06-15 22:12:54 +00:00
|
|
|
/// getScalarType - If this is a vector type, return the element type,
|
|
|
|
/// otherwise return this.
|
|
|
|
const Type *getScalarType() const;
|
|
|
|
|
2001-09-07 16:23:59 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Type Iteration support
|
|
|
|
//
|
2007-04-06 02:02:20 +00:00
|
|
|
typedef PATypeHandle *subtype_iterator;
|
|
|
|
subtype_iterator subtype_begin() const { return ContainedTys; }
|
|
|
|
subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
|
2001-09-07 16:23:59 +00:00
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// getContainedType - This method is used to implement the type iterator
|
|
|
|
/// (defined a the end of the file). For derived types, this returns the
|
2003-10-09 20:35:15 +00:00
|
|
|
/// types 'contained' in the derived type.
|
2002-08-25 22:54:55 +00:00
|
|
|
///
|
2004-02-09 05:40:24 +00:00
|
|
|
const Type *getContainedType(unsigned i) const {
|
2007-04-06 02:02:20 +00:00
|
|
|
assert(i < NumContainedTys && "Index out of range!");
|
|
|
|
return ContainedTys[i].get();
|
2003-10-09 20:35:15 +00:00
|
|
|
}
|
2001-09-07 16:23:59 +00:00
|
|
|
|
2004-02-09 05:40:24 +00:00
|
|
|
/// getNumContainedTypes - Return the number of types in the derived type.
|
|
|
|
///
|
2007-04-06 02:02:20 +00:00
|
|
|
unsigned getNumContainedTypes() const { return NumContainedTys; }
|
2001-09-07 16:23:59 +00:00
|
|
|
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Static members exported by the Type class itself. Useful for getting
|
|
|
|
// instances of Type.
|
|
|
|
//
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-07-08 22:31:37 +00:00
|
|
|
/// getPrimitiveType - Return a type based on an identifier.
|
2004-06-17 18:19:28 +00:00
|
|
|
static const Type *getPrimitiveType(TypeID IDNumber);
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2001-09-07 16:23:59 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// These are the builtin types that are always available...
|
|
|
|
//
|
2009-05-30 05:06:04 +00:00
|
|
|
static const Type *VoidTy, *LabelTy, *FloatTy, *DoubleTy, *MetadataTy;
|
2007-08-03 01:03:46 +00:00
|
|
|
static const Type *X86_FP80Ty, *FP128Ty, *PPC_FP128Ty;
|
2007-01-19 21:13:56 +00:00
|
|
|
static const IntegerType *Int1Ty, *Int8Ty, *Int16Ty, *Int32Ty, *Int64Ty;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-08-25 22:54:55 +00:00
|
|
|
/// Methods for support type inquiry through isa, cast, and dyn_cast:
|
2008-05-19 20:15:12 +00:00
|
|
|
static inline bool classof(const Type *) { return true; }
|
2001-10-01 13:58:13 +00:00
|
|
|
|
2004-02-17 02:58:36 +00:00
|
|
|
void addRef() const {
|
|
|
|
assert(isAbstract() && "Cannot add a reference to a non-abstract type!");
|
2009-06-23 20:17:22 +00:00
|
|
|
sys::AtomicIncrement(&RefCount);
|
2004-02-17 02:58:36 +00:00
|
|
|
}
|
2005-04-21 20:19:05 +00:00
|
|
|
|
2004-02-17 02:58:36 +00:00
|
|
|
void dropRef() const {
|
2004-11-19 16:39:04 +00:00
|
|
|
assert(isAbstract() && "Cannot drop a reference to a non-abstract type!");
|
2004-02-17 02:58:36 +00:00
|
|
|
assert(RefCount && "No objects are currently referencing this object!");
|
|
|
|
|
|
|
|
// If this is the last PATypeHolder using this object, and there are no
|
|
|
|
// PATypeHandles using it, the type is dead, delete it now.
|
2009-06-23 20:17:22 +00:00
|
|
|
sys::cas_flag OldCount = sys::AtomicDecrement(&RefCount);
|
|
|
|
if (OldCount == 0 && AbstractTypeUsers.empty())
|
2007-04-06 02:02:20 +00:00
|
|
|
this->destroy();
|
2004-02-17 02:58:36 +00:00
|
|
|
}
|
2005-11-13 03:13:26 +00:00
|
|
|
|
|
|
|
/// addAbstractTypeUser - Notify an abstract type that there is a new user of
|
|
|
|
/// it. This function is called primarily by the PATypeHandle class.
|
|
|
|
///
|
2009-06-17 00:13:00 +00:00
|
|
|
void addAbstractTypeUser(AbstractTypeUser *U) const;
|
2005-11-13 03:13:26 +00:00
|
|
|
|
|
|
|
/// removeAbstractTypeUser - Notify an abstract type that a user of the class
|
|
|
|
/// no longer has a handle to the type. This function is called primarily by
|
|
|
|
/// the PATypeHandle class. When there are no users of the abstract type, it
|
|
|
|
/// is annihilated, because there is no way to get a reference to it ever
|
|
|
|
/// again.
|
|
|
|
///
|
|
|
|
void removeAbstractTypeUser(AbstractTypeUser *U) const;
|
2004-11-19 16:39:04 +00:00
|
|
|
|
2009-04-10 06:42:02 +00:00
|
|
|
/// getPointerTo - Return a pointer to the current type. This is equivalent
|
|
|
|
/// to PointerType::get(Foo, AddrSpace).
|
|
|
|
PointerType *getPointerTo(unsigned AddrSpace = 0) const;
|
|
|
|
|
2004-02-17 02:58:36 +00:00
|
|
|
private:
|
2004-07-02 23:20:17 +00:00
|
|
|
/// isSizedDerivedType - Derived types like structures and arrays are sized
|
|
|
|
/// iff all of the members of the type are sized as well. Since asking for
|
|
|
|
/// their size is relatively uncommon, move this operation out of line.
|
|
|
|
bool isSizedDerivedType() const;
|
|
|
|
|
2005-11-13 03:26:12 +00:00
|
|
|
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
|
|
|
|
virtual void typeBecameConcrete(const DerivedType *AbsTy);
|
|
|
|
|
2005-11-13 03:13:26 +00:00
|
|
|
protected:
|
|
|
|
// PromoteAbstractToConcrete - This is an internal method used to calculate
|
|
|
|
// change "Abstract" from true to false when types are refined.
|
|
|
|
void PromoteAbstractToConcrete();
|
|
|
|
friend class TypeMapBase;
|
2001-06-06 20:29:01 +00:00
|
|
|
};
|
|
|
|
|
2004-02-17 02:58:36 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Define some inline methods for the AbstractTypeUser.h:PATypeHandle class.
|
2005-04-21 20:19:05 +00:00
|
|
|
// These are defined here because they MUST be inlined, yet are dependent on
|
2006-09-23 06:09:45 +00:00
|
|
|
// the definition of the Type class.
|
2004-02-17 02:58:36 +00:00
|
|
|
//
|
|
|
|
inline void PATypeHandle::addUser() {
|
|
|
|
assert(Ty && "Type Handle has a null type!");
|
|
|
|
if (Ty->isAbstract())
|
|
|
|
Ty->addAbstractTypeUser(User);
|
|
|
|
}
|
|
|
|
inline void PATypeHandle::removeUser() {
|
|
|
|
if (Ty->isAbstract())
|
|
|
|
Ty->removeAbstractTypeUser(User);
|
|
|
|
}
|
|
|
|
|
2008-02-25 21:28:46 +00:00
|
|
|
// Define inline methods for PATypeHolder.
|
2004-02-17 02:58:36 +00:00
|
|
|
|
2008-08-15 15:16:50 +00:00
|
|
|
/// get - This implements the forwarding part of the union-find algorithm for
|
|
|
|
/// abstract types. Before every access to the Type*, we check to see if the
|
|
|
|
/// type we are pointing to is forwarding to a new type. If so, we drop our
|
|
|
|
/// reference to the type.
|
|
|
|
///
|
|
|
|
inline Type* PATypeHolder::get() const {
|
|
|
|
const Type *NewTy = Ty->getForwardedType();
|
|
|
|
if (!NewTy) return const_cast<Type*>(Ty);
|
|
|
|
return *const_cast<PATypeHolder*>(this) = NewTy;
|
|
|
|
}
|
|
|
|
|
2004-02-17 02:58:36 +00:00
|
|
|
inline void PATypeHolder::addRef() {
|
2008-02-25 21:28:46 +00:00
|
|
|
assert(Ty && "Type Holder has a null type!");
|
2004-02-17 02:58:36 +00:00
|
|
|
if (Ty->isAbstract())
|
|
|
|
Ty->addRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void PATypeHolder::dropRef() {
|
|
|
|
if (Ty->isAbstract())
|
|
|
|
Ty->dropRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2005-04-21 20:19:05 +00:00
|
|
|
// Provide specializations of GraphTraits to be able to treat a type as a
|
2001-09-28 22:56:31 +00:00
|
|
|
// graph of sub types...
|
|
|
|
|
|
|
|
template <> struct GraphTraits<Type*> {
|
|
|
|
typedef Type NodeType;
|
|
|
|
typedef Type::subtype_iterator ChildIteratorType;
|
|
|
|
|
|
|
|
static inline NodeType *getEntryNode(Type *T) { return T; }
|
2005-04-21 20:19:05 +00:00
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
|
|
|
return N->subtype_begin();
|
2001-09-28 22:56:31 +00:00
|
|
|
}
|
2005-04-21 20:19:05 +00:00
|
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
2001-09-28 22:56:31 +00:00
|
|
|
return N->subtype_end();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct GraphTraits<const Type*> {
|
|
|
|
typedef const Type NodeType;
|
|
|
|
typedef Type::subtype_iterator ChildIteratorType;
|
|
|
|
|
|
|
|
static inline NodeType *getEntryNode(const Type *T) { return T; }
|
2005-04-21 20:19:05 +00:00
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
|
|
|
return N->subtype_begin();
|
2001-09-28 22:56:31 +00:00
|
|
|
}
|
2005-04-21 20:19:05 +00:00
|
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
2001-09-28 22:56:31 +00:00
|
|
|
return N->subtype_end();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-04-21 20:19:05 +00:00
|
|
|
template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
|
2004-06-17 18:19:28 +00:00
|
|
|
return Ty.getTypeID() == Type::PointerTyID;
|
2002-05-06 16:12:53 +00:00
|
|
|
}
|
|
|
|
|
2004-07-04 10:46:49 +00:00
|
|
|
std::ostream &operator<<(std::ostream &OS, const Type &T);
|
2008-08-23 22:23:09 +00:00
|
|
|
raw_ostream &operator<<(raw_ostream &OS, const Type &T);
|
2004-07-04 10:46:49 +00:00
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
} // End llvm namespace
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
#endif
|