remove dead method

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

diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index 6cf3c8d04b583026fcca551ad314560af3ca14a4..1d776440522f22b2f6b9c3ef4d4f9ece97a91fb2 100644 (file)
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -35,9 +35,9 @@
 #define LLVM_TYPE_H
 
 #include "AbstractTypeUser.h"
-#include "Support/Casting.h"
-#include "Support/GraphTraits.h"
-#include "Support/iterator"
+#include "llvm/Support/Casting.h"
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/iterator"
 #include <vector>
 
 namespace llvm {
@@ -48,8 +48,10 @@ class FunctionType;
 class OpaqueType;
 class PointerType;
 class StructType;
+class PackedType;
 
-struct Type {
+class Type {
+public:
   ///===-------------------------------------------------------------------===//
   /// 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)
@@ -71,7 +73,7 @@ struct Type {
     FunctionTyID  , StructTyID,         // Functions... Structs...
     ArrayTyID     , PointerTyID,        // Array... pointer...
     OpaqueTyID,                         // Opaque type instances...
-    //PackedTyID  ,                     // SIMD 'packed' format... TODO
+    PackedTyID,                         // SIMD 'packed' format... 
     //...
 
     NumTypeIDs,                         // Must remain as last defined ID
@@ -99,9 +101,9 @@ protected:
   ///
   inline void setAbstract(bool Val) { Abstract = Val; }
 
-  /// isTypeAbstract - This method is used to calculate the Abstract bit.
-  ///
-  bool isTypeAbstract();
+  // PromoteAbstractToConcrete - This is an internal method used to calculate
+  // change "Abstract" from true to false when types are refined.
+  void PromoteAbstractToConcrete();
 
   unsigned getRefCount() const { return RefCount; }
 
@@ -188,8 +190,10 @@ public:
   inline bool isDerivedType()   const { return ID >= FirstDerivedTyID; }
 
   /// isFirstClassType - Return true if the value is holdable in a register.
+  ///
   inline bool isFirstClassType() const {
-    return (ID != VoidTyID && ID <= LastPrimitiveTyID) || ID == PointerTyID;
+    return (ID != VoidTyID && ID <= LastPrimitiveTyID) || 
+            ID == PointerTyID || ID == PackedTyID;
   }
 
   /// isSized - Return true if it makes sense to take the size of this type.  To
@@ -197,8 +201,16 @@ public:
   /// TargetData subsystem to do this.
   ///
   bool isSized() const {
-    return (ID >= BoolTyID && ID <= DoubleTyID) || ID == PointerTyID ||
-           isSizedDerivedType();
+    // If it's a primitive, it is always sized.
+    if (ID >= BoolTyID && ID <= DoubleTyID || ID == PointerTyID)
+      return true;
+    // If it is not something that can have a size (e.g. a function or label),
+    // it doesn't have a size.
+    if (ID != StructTyID && ID != ArrayTyID && ID != PackedTyID)
+      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();
   }
 
   /// getPrimitiveSize - Return the basic size of this type if it is a primitive
@@ -242,7 +254,8 @@ public:
 
   /// getNumContainedTypes - Return the number of types in the derived type.
   ///
-  unsigned getNumContainedTypes() const { return ContainedTys.size(); }
+  typedef std::vector<PATypeHandle>::size_type size_type;
+  size_type getNumContainedTypes() const { return ContainedTys.size(); }
 
   //===--------------------------------------------------------------------===//
   // Static members exported by the Type class itself.  Useful for getting
@@ -284,7 +297,7 @@ public:
   }
   
   void dropRef() const {
-    assert(isAbstract() && "Cannot drop a refernce to a non-abstract type!");
+    assert(isAbstract() && "Cannot drop a reference to a non-abstract type!");
     assert(RefCount && "No objects are currently referencing this object!");
 
     // If this is the last PATypeHolder using this object, and there are no
@@ -292,6 +305,12 @@ public:
     if (--RefCount == 0)
       RefCountIsZero();
   }
+
+  /// clearAllTypeMaps - This method frees all internal memory used by the
+  /// type subsystem, which can be used in environments where this memory is
+  /// otherwise reported as a leak.
+  static void clearAllTypeMaps();
+
 private:
   /// isSizedDerivedType - Derived types like structures and arrays are sized
   /// iff all of the members of the type are sized as well.  Since asking for
@@ -389,7 +408,6 @@ template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
   return Ty.getTypeID() == Type::PointerTyID;
 }
 
-std::ostream &operator<<(std::ostream &OS, const Type *T);
 std::ostream &operator<<(std::ostream &OS, const Type &T);
 
 } // End llvm namespace