//===-- llvm/DerivedTypes.h - Classes for handling data types ---*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of classes that represent "derived
+// This file contains the declarations of classes that represent "derived
// types". These are things like "arrays of x" or "structure of x, y, z" or
// "method returning x taking (y,z) as parameters", etc...
//
delete this;
}
-
+
public:
//===--------------------------------------------------------------------===//
const FunctionType &operator=(const FunctionType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class FunctionType' only
+ /// from GCC to make them protected: warning: `class FunctionType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
///
- FunctionType(const Type *Result, const std::vector<const Type*> &Params,
+ FunctionType(const Type *Result, const std::vector<const Type*> &Params,
bool IsVarArgs);
public:
/// getNumParams - Return the number of fixed parameters this function type
/// requires. This does not consider varargs.
///
- unsigned getNumParams() const { return (unsigned)ContainedTys.size()-1; }
+ unsigned getNumParams() const { return unsigned(ContainedTys.size()-1); }
// 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 FunctionType *T) { return true; }
static inline bool classof(const Type *T) {
// 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 Type *T) {
- return T->getTypeID() == ArrayTyID ||
+ return T->getTypeID() == ArrayTyID ||
T->getTypeID() == StructTyID ||
T->getTypeID() == PointerTyID ||
T->getTypeID() == PackedTyID;
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class StructType' only
+ /// from GCC to make them protected: warning: `class StructType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
element_iterator element_end() const { return ContainedTys.end(); }
// Random access to the elements
- unsigned getNumElements() const { return (unsigned)ContainedTys.size(); }
+ unsigned getNumElements() const { return unsigned(ContainedTys.size()); }
const Type *getElementType(unsigned N) const {
assert(N < ContainedTys.size() && "Element number out of range!");
return ContainedTys[N];
};
-/// SequentialType - This is the superclass of the array, pointer and packed
+/// SequentialType - This is the superclass of the array, pointer and packed
/// type classes. All of these represent "arrays" in memory. The array type
/// represents a specifically sized array, pointer types are unsized/unknown
-/// size arrays, packed types represent specifically sized arrays that
-/// allow for use of SIMD instructions. SequentialType holds the common
-/// features of all, which stem from the fact that all three lay their
+/// size arrays, packed types represent specifically sized arrays that
+/// allow for use of SIMD instructions. SequentialType holds the common
+/// features of all, which stem from the fact that all three lay their
/// components out in memory identically.
///
class SequentialType : public CompositeType {
const ArrayType &operator=(const ArrayType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class ArrayType' only
+ /// from GCC to make them protected: warning: `class ArrayType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
const PackedType &operator=(const PackedType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class PackedType' only
+ /// from GCC to make them protected: warning: `class PackedType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
const PointerType &operator=(const PointerType &); // Do not implement
protected:
// This should really be private, but it squelches a bogus warning
- // from GCC to make them protected: warning: `class PointerType' only
+ // from GCC to make them protected: warning: `class PointerType' only
// defines private constructors and has no friends
// Private ctor - Only can be created by a static member...
const OpaqueType &operator=(const OpaqueType &); // DO NOT IMPLEMENT
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class OpaqueType' only
+ /// from GCC to make them protected: warning: `class OpaqueType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
projects / oota-llvm.git / blobdiff