A class type is represented by either a RECORD_TYPE or a
UNION_TYPE. A class declared with the union tag is
represented by a UNION_TYPE, while classes declared with either
the struct or the class tag are represented by
RECORD_TYPEs. You can use the CLASSTYPE_DECLARED_CLASS
macro to discern whether or not a particular type is a class as
opposed to a struct. This macro will be true only for classes
declared with the class tag.
Almost all non-function members are available on the TYPE_FIELDS
list. Given one member, the next can be found by following the
TREE_CHAIN. You should not depend in any way on the order in
which fields appear on this list. All nodes on this list will be
DECL nodes. A FIELD_DECL is used to represent a non-static
data member, a VAR_DECL is used to represent a static data
member, and a TYPE_DECL is used to represent a type. Note that
the CONST_DECL for an enumeration constant will appear on this
list, if the enumeration type was declared in the class. (Of course,
the TYPE_DECL for the enumeration type will appear here as well.)
There are no entries for base classes on this list. In particular,
there is no FIELD_DECL for the "base-class portion" of an
object.
The TYPE_VFIELD is a compiler-generated field used to point to
virtual function tables. It may or may not appear on the
TYPE_FIELDS list. However, back ends should handle the
TYPE_VFIELD just like all the entries on the TYPE_FIELDS
list.
The function members are available on the TYPE_METHODS list.
Again, subsequent members are found by following the TREE_CHAIN
field. If a function is overloaded, each of the overloaded functions
appears; no OVERLOAD nodes appear on the TYPE_METHODS
list. Implicitly declared functions (including default constructors,
copy constructors, assignment operators, and destructors) will appear on
this list as well.
Every class has an associated binfo, which can be obtained with
TYPE_BINFO. Binfos are used to represent base-classes. The
binfo given by TYPE_BINFO is the degenerate case, whereby every
class is considered to be its own base-class. The base classes for a
particular binfo can be obtained with BINFO_BASETYPES. These
base-classes are themselves binfos. The class type associated with a
binfo is given by BINFO_TYPE. It is always the case that
BINFO_TYPE (TYPE_BINFO (x)) is the same type as x, up to
qualifiers. However, it is not always the case that TYPE_BINFO
(BINFO_TYPE (y)) is always the same binfo as y. The reason is
that if y is a binfo representing a base-class B of a
derived class D, then BINFO_TYPE (y) will be B,
and TYPE_BINFO (BINFO_TYPE (y)) will be B as its own
base-class, rather than as a base-class of D.
The BINFO_BASETYPES is a TREE_VEC (see Containers).
Base types appear in left-to-right order in this vector. You can tell
whether or public, protected, or private
inheritance was used by using the TREE_VIA_PUBLIC,
TREE_VIA_PROTECTED, and TREE_VIA_PRIVATE macros. Each of
these macros takes a BINFO and is true if and only if the
indicated kind of inheritance was used. If TREE_VIA_VIRTUAL
holds of a binfo, then its BINFO_TYPE was inherited from
virtually.
The following macros can be used on a tree node representing a class-type.
LOCAL_CLASS_P
TYPE_POLYMORPHIC_P
TYPE_HAS_DEFAULT_CONSTRUCTOR
CLASSTYPE_HAS_MUTABLE
TYPE_HAS_MUTABLE_P
CLASSTYPE_NON_POD_P
TYPE_HAS_NEW_OPERATOR
operator new.
TYPE_HAS_ARRAY_NEW_OPERATOR
operator new[] is defined.
TYPE_OVERLOADS_CALL_EXPR
operator() is overloaded.
TYPE_OVERLOADS_ARRAY_REF
operator[]
TYPE_OVERLOADS_ARROW
operator-> is
overloaded.