Move SLEB/ULEB size calculation routines from AsmPrinter to TargetAsmInfo. This makes...

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

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index 457d37d1fa800f72f36ef23d7c5f2fa76f150437..04a73fe8cf2e74c9a977f61713a29971cf4a1c37 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -67,7 +67,7 @@ public:
   void dump() const { Type::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 DerivedType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->isDerivedType();
   }
@@ -104,7 +104,7 @@ public:
 
   /// getBitMask - Return a bitmask with ones set for all of the bits
   /// that can be set by an unsigned version of this type.  This is 0xFF for
-  /// sbyte/ubyte, 0xFFFF for shorts, etc.
+  /// i8, 0xFFFF for i16, etc.
   uint64_t getBitMask() const {
     return ~uint64_t(0UL) >> (64-getBitWidth());
   }
@@ -127,7 +127,7 @@ public:
   bool isPowerOf2ByteWidth() const;
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const IntegerType *T) { return true; }
+  static inline bool classof(const IntegerType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == IntegerTyID;
   }
@@ -154,6 +154,10 @@ public:
     const std::vector<const Type*> &Params, ///< The types of the parameters
     bool isVarArg  ///< Whether this is a variable argument length function
   );
+  
+  /// isValidReturnType - Return true if the specified type is valid as a return
+  /// type.
+  static bool isValidReturnType(const Type *RetTy);
 
   inline bool isVarArg() const { return isVarArgs; }
   inline const Type *getReturnType() const { return ContainedTys[0]; }
@@ -175,7 +179,7 @@ public:
   virtual void typeBecameConcrete(const DerivedType *AbsTy);
 
   // 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 FunctionType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == FunctionTyID;
   }
@@ -193,10 +197,12 @@ public:
   /// the element.
   ///
   virtual const Type *getTypeAtIndex(const Value *V) const = 0;
+  virtual const Type *getTypeAtIndex(unsigned Idx) const = 0;
   virtual bool indexValid(const Value *V) const = 0;
+  virtual bool indexValid(unsigned Idx) const = 0;
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const CompositeType *T) { return true; }
+  static inline bool classof(const CompositeType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == ArrayTyID ||
            T->getTypeID() == StructTyID ||
@@ -220,6 +226,12 @@ public:
   static StructType *get(const std::vector<const Type*> &Params, 
                          bool isPacked=false);
 
+  /// StructType::get - This static method is a convenience method for
+  /// creating structure types by specifying the elements as arguments.
+  /// Note that this method always returns a non-packed struct.  To get
+  /// an empty struct, pass NULL, NULL.
+  static StructType *get(const Type *type, ...) END_WITH_NULL;
+
   // Iterator access to the elements
   typedef Type::subtype_iterator element_iterator;
   element_iterator element_begin() const { return ContainedTys; }
@@ -235,15 +247,17 @@ public:
   /// getTypeAtIndex - Given an index value into the type, return the type of
   /// the element.  For a structure type, this must be a constant value...
   ///
-  virtual const Type *getTypeAtIndex(const Value *V) const ;
+  virtual const Type *getTypeAtIndex(const Value *V) const;
+  virtual const Type *getTypeAtIndex(unsigned Idx) const;
   virtual bool indexValid(const Value *V) const;
+  virtual bool indexValid(unsigned Idx) const;
 
   // Implement the AbstractTypeUser interface.
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
   virtual void typeBecameConcrete(const DerivedType *AbsTy);
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const StructType *T) { return true; }
+  static inline bool classof(const StructType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == StructTyID;
   }
@@ -278,16 +292,22 @@ public:
   inline const Type *getElementType() const { return ContainedTys[0]; }
 
   virtual bool indexValid(const Value *V) const;
+  virtual bool indexValid(unsigned) const {
+    return true;
+  }
 
   /// getTypeAtIndex - Given an index value into the type, return the type of
   /// the element.  For sequential types, there is only one subtype...
   ///
-  virtual const Type *getTypeAtIndex(const Value *V) const {
+  virtual const Type *getTypeAtIndex(const Value *) const {
+    return ContainedTys[0];
+  }
+  virtual const Type *getTypeAtIndex(unsigned) const {
     return ContainedTys[0];
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const SequentialType *T) { return true; }
+  static inline bool classof(const SequentialType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == ArrayTyID ||
            T->getTypeID() == PointerTyID ||
@@ -318,7 +338,7 @@ public:
   virtual void typeBecameConcrete(const DerivedType *AbsTy);
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const ArrayType *T) { return true; }
+  static inline bool classof(const ArrayType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == ArrayTyID;
   }
@@ -339,6 +359,16 @@ public:
   ///
   static VectorType *get(const Type *ElementType, unsigned NumElements);
 
+  /// VectorType::getInteger - This static method gets a VectorType with the
+  /// same number of elements as the input type, and the element type is an
+  /// integer type of the same width as the input element type.
+  ///
+  static VectorType *getInteger(const VectorType *VTy) {
+    unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
+    const Type *EltTy = IntegerType::get(EltBits);
+    return VectorType::get(EltTy, VTy->getNumElements());
+  }
+
   /// @brief Return the number of elements in the Vector type.
   inline unsigned getNumElements() const { return NumElements; }
 
@@ -352,7 +382,7 @@ public:
   virtual void typeBecameConcrete(const DerivedType *AbsTy);
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const VectorType *T) { return true; }
+  static inline bool classof(const VectorType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == VectorTyID;
   }
@@ -387,7 +417,7 @@ public:
   virtual void typeBecameConcrete(const DerivedType *AbsTy);
 
   // Implement support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const PointerType *T) { return true; }
+  static inline bool classof(const PointerType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == PointerTyID;
   }
@@ -408,7 +438,7 @@ public:
   }
 
   // Implement support for type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const OpaqueType *T) { return true; }
+  static inline bool classof(const OpaqueType *) { return true; }
   static inline bool classof(const Type *T) {
     return T->getTypeID() == OpaqueTyID;
   }