Remove extranous #include

[oota-llvm.git] / include / llvm / Type.h

diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index cc682669ce51c939501d1c71d6bd00011e0e1e8d..1bbe02337bef7c557379221e1aa06ed201080739 100644 (file)
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -27,7 +27,7 @@
 #define LLVM_TYPE_H
 
 #include "llvm/Value.h"
-#include "llvm/Support/GraphTraits.h"
+#include "Support/GraphTraits.h"
 
 class DerivedType;
 class MethodType;
@@ -71,23 +71,23 @@ public:
 private:
   PrimitiveID ID;        // The current base type of this type...
   unsigned    UID;       // The unique ID number for this class
-  string      Desc;      // The printed name of the string...
+  std::string Desc;      // The printed name of the string...
   bool        Abstract;  // True if type contains an OpaqueType
   bool        Recursive; // True if the type is recursive
 
 protected:
   // ctor is protected, so only subclasses can create Type objects...
-  Type(const string &Name, PrimitiveID id);
+  Type(const std::string &Name, PrimitiveID id);
   virtual ~Type() {}
 
   // When types are refined, they update their description to be more concrete.
   //
-  inline void setDescription(const string &D) { Desc = D; }
+  inline void setDescription(const std::string &D) { Desc = D; }
   
   // setName - Associate the name with this type in the symbol table, but don't
   // set the local name to be equal specified name.
   //
-  virtual void setName(const string &Name, SymbolTable *ST = 0);
+  virtual void setName(const std::string &Name, SymbolTable *ST = 0);
 
   // Types can become nonabstract later, if they are refined.
   //
@@ -116,7 +116,7 @@ public:
   inline unsigned getUniqueID() const { return UID; }
 
   // getDescription - Return the string representation of the type...
-  inline const string &getDescription() const { return Desc; }
+  inline const std::string &getDescription() const { return Desc; }
 
   // isSigned - Return whether a numeric type is signed.
   virtual bool isSigned() const { return 0; }
@@ -141,6 +141,19 @@ public:
   //
   inline bool isRecursive() const { return Recursive; }
 
+  // isLosslesslyConvertableTo - Return true if this type can be converted to
+  // 'Ty' without any reinterpretation of bits.  For example, uint to int.
+  //
+  bool isLosslesslyConvertableTo(const Type *Ty) const;
+
+  // 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.
+  //
+  bool isSized() const {
+    return ID != TypeTyID && ID != MethodTyID && ID != OpaqueTyID;
+  }
+
   //===--------------------------------------------------------------------===//
   // Type Iteration support
   //
@@ -185,9 +198,13 @@ public:
   // Note that all other types can just compare to see if this == Type::xxxTy;
   //
   inline bool isPrimitiveType() const { return ID < FirstDerivedTyID;  }
-
   inline bool isDerivedType()   const { return ID >= FirstDerivedTyID; }
 
+  // isFirstClassType - Return true if the value is holdable in a register.
+  inline bool isFirstClassType() const {
+    return isPrimitiveType() || ID == PointerTyID;
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Type *T) { return true; }
   static inline bool classof(const Value *V) {