aarch64-linux-gnu-4.9/share/doc/gccint/Types.html - toolchains/linux-x86/gcc - Git at Google

 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <!-- Copyright (C) 1988-2015 Free Software Foundation, Inc.

 Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.3 or
 any later version published by the Free Software Foundation; with the
 Invariant Sections being "Funding Free Software", the Front-Cover
 Texts being (a) (see below), and with the Back-Cover Texts being (b)
 (see below).  A copy of the license is included in the section entitled
 "GNU Free Documentation License".

 (a) The FSF's Front-Cover Text is:

 A GNU Manual

 (b) The FSF's Back-Cover Text is:

 You have freedom to copy and modify this GNU Manual, like GNU
      software.  Copies published by the Free Software Foundation raise
      funds for GNU development. -->
 <!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
 <head>
 <title>GNU Compiler Collection (GCC) Internals: Types</title>

 <meta name="description" content="GNU Compiler Collection (GCC) Internals: Types">
 <meta name="keywords" content="GNU Compiler Collection (GCC) Internals: Types">
 <meta name="resource-type" content="document">
 <meta name="distribution" content="global">
 <meta name="Generator" content="makeinfo">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <link href="index.html#Top" rel="start" title="Top">
 <link href="Option-Index.html#Option-Index" rel="index" title="Option Index">
 <link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
 <link href="GENERIC.html#GENERIC" rel="up" title="GENERIC">
 <link href="Declarations.html#Declarations" rel="next" title="Declarations">
 <link href="Containers.html#Containers" rel="prev" title="Containers">
 <style type="text/css">
 <!--
 a.summary-letter {text-decoration: none}
 blockquote.smallquotation {font-size: smaller}
 div.display {margin-left: 3.2em}
 div.example {margin-left: 3.2em}
 div.indentedblock {margin-left: 3.2em}
 div.lisp {margin-left: 3.2em}
 div.smalldisplay {margin-left: 3.2em}
 div.smallexample {margin-left: 3.2em}
 div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
 div.smalllisp {margin-left: 3.2em}
 kbd {font-style:oblique}
 pre.display {font-family: inherit}
 pre.format {font-family: inherit}
 pre.menu-comment {font-family: serif}
 pre.menu-preformatted {font-family: serif}
 pre.smalldisplay {font-family: inherit; font-size: smaller}
 pre.smallexample {font-size: smaller}
 pre.smallformat {font-family: inherit; font-size: smaller}
 pre.smalllisp {font-size: smaller}
 span.nocodebreak {white-space:nowrap}
 span.nolinebreak {white-space:nowrap}
 span.roman {font-family:serif; font-weight:normal}
 span.sansserif {font-family:sans-serif; font-weight:normal}
 ul.no-bullet {list-style: none}
 -->
 </style>


 </head>

 <body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
 <a name="Types"></a>
 <div class="header">
 <p>
 Next: <a href="Declarations.html#Declarations" accesskey="n" rel="next">Declarations</a>, Previous: <a href="Tree-overview.html#Tree-overview" accesskey="p" rel="prev">Tree overview</a>, Up: <a href="GENERIC.html#GENERIC" accesskey="u" rel="up">GENERIC</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
 </div>
 <hr>
 <a name="Types-1"></a>
 <h3 class="section">10.3 Types</h3>
 <a name="index-type"></a>
 <a name="index-pointer"></a>
 <a name="index-reference"></a>
 <a name="index-fundamental-type"></a>
 <a name="index-array"></a>
 <a name="index-VOID_005fTYPE"></a>
 <a name="index-INTEGER_005fTYPE"></a>
 <a name="index-TYPE_005fMIN_005fVALUE"></a>
 <a name="index-TYPE_005fMAX_005fVALUE"></a>
 <a name="index-REAL_005fTYPE"></a>
 <a name="index-FIXED_005fPOINT_005fTYPE"></a>
 <a name="index-COMPLEX_005fTYPE"></a>
 <a name="index-ENUMERAL_005fTYPE"></a>
 <a name="index-BOOLEAN_005fTYPE"></a>
 <a name="index-POINTER_005fTYPE"></a>
 <a name="index-REFERENCE_005fTYPE"></a>
 <a name="index-FUNCTION_005fTYPE"></a>
 <a name="index-METHOD_005fTYPE"></a>
 <a name="index-ARRAY_005fTYPE"></a>
 <a name="index-RECORD_005fTYPE"></a>
 <a name="index-UNION_005fTYPE"></a>
 <a name="index-UNKNOWN_005fTYPE"></a>
 <a name="index-OFFSET_005fTYPE"></a>
 <a name="index-TYPE_005fUNQUALIFIED"></a>
 <a name="index-TYPE_005fQUAL_005fCONST"></a>
 <a name="index-TYPE_005fQUAL_005fVOLATILE"></a>
 <a name="index-TYPE_005fQUAL_005fRESTRICT"></a>
 <a name="index-TYPE_005fMAIN_005fVARIANT"></a>
 <a name="index-qualified-type"></a>
 <a name="index-TYPE_005fSIZE"></a>
 <a name="index-TYPE_005fALIGN"></a>
 <a name="index-TYPE_005fPRECISION"></a>
 <a name="index-TYPE_005fARG_005fTYPES"></a>
 <a name="index-TYPE_005fMETHOD_005fBASETYPE"></a>
 <a name="index-TYPE_005fOFFSET_005fBASETYPE"></a>
 <a name="index-TREE_005fTYPE-1"></a>
 <a name="index-TYPE_005fCONTEXT"></a>
 <a name="index-TYPE_005fNAME"></a>
 <a name="index-TYPENAME_005fTYPE_005fFULLNAME"></a>
 <a name="index-TYPE_005fFIELDS"></a>
 <a name="index-TYPE_005fCANONICAL"></a>
 <a name="index-TYPE_005fSTRUCTURAL_005fEQUALITY_005fP"></a>
 <a name="index-SET_005fTYPE_005fSTRUCTURAL_005fEQUALITY"></a>

 <p>All types have corresponding tree nodes.  However, you should not assume
 that there is exactly one tree node corresponding to each type.  There
 are often multiple nodes corresponding to the same type.
 </p>
 <p>For the most part, different kinds of types have different tree codes.
 (For example, pointer types use a <code>POINTER_TYPE</code> code while arrays
 use an <code>ARRAY_TYPE</code> code.)  However, pointers to member functions
 use the <code>RECORD_TYPE</code> code.  Therefore, when writing a
 <code>switch</code> statement that depends on the code associated with a
 particular type, you should take care to handle pointers to member
 functions under the <code>RECORD_TYPE</code> case label.
 </p>
 <p>The following functions and macros deal with cv-qualification of types:
 </p><dl compact="compact">
 <dt><code>TYPE_MAIN_VARIANT</code>
 <a name="index-TYPE_005fMAIN_005fVARIANT-1"></a>
 </dt>
 <dd><p>This macro returns the unqualified version of a type.  It may be applied
 to an unqualified type, but it is not always the identity function in
 that case.
 </p></dd>
 </dl>

 <p>A few other macros and functions are usable with all types:
 </p><dl compact="compact">
 <dt><code>TYPE_SIZE</code>
 <a name="index-TYPE_005fSIZE-1"></a>
 </dt>
 <dd><p>The number of bits required to represent the type, represented as an
 <code>INTEGER_CST</code>.  For an incomplete type, <code>TYPE_SIZE</code> will be
 <code>NULL_TREE</code>.
 </p>
 </dd>
 <dt><code>TYPE_ALIGN</code>
 <a name="index-TYPE_005fALIGN-1"></a>
 </dt>
 <dd><p>The alignment of the type, in bits, represented as an <code>int</code>.
 </p>
 </dd>
 <dt><code>TYPE_NAME</code>
 <a name="index-TYPE_005fNAME-1"></a>
 </dt>
 <dd><p>This macro returns a declaration (in the form of a <code>TYPE_DECL</code>) for
 the type.  (Note this macro does <em>not</em> return an
 <code>IDENTIFIER_NODE</code>, as you might expect, given its name!)  You can
 look at the <code>DECL_NAME</code> of the <code>TYPE_DECL</code> to obtain the
 actual name of the type.  The <code>TYPE_NAME</code> will be <code>NULL_TREE</code>
 for a type that is not a built-in type, the result of a typedef, or a
 named class type.
 </p>
 </dd>
 <dt><code>TYPE_CANONICAL</code>
 <a name="index-TYPE_005fCANONICAL-1"></a>
 </dt>
 <dd><p>This macro returns the &ldquo;canonical&rdquo; type for the given type
 node. Canonical types are used to improve performance in the C++ and
 Objective-C++ front ends by allowing efficient comparison between two
 type nodes in <code>same_type_p</code>: if the <code>TYPE_CANONICAL</code> values
 of the types are equal, the types are equivalent; otherwise, the types
 are not equivalent. The notion of equivalence for canonical types is
 the same as the notion of type equivalence in the language itself. For
 instance,
 </p>
 <p>When <code>TYPE_CANONICAL</code> is <code>NULL_TREE</code>, there is no canonical
 type for the given type node. In this case, comparison between this
 type and any other type requires the compiler to perform a deep,
 &ldquo;structural&rdquo; comparison to see if the two type nodes have the same
 form and properties.
 </p>
 <p>The canonical type for a node is always the most fundamental type in
 the equivalence class of types. For instance, <code>int</code> is its own
 canonical type. A typedef <code>I</code> of <code>int</code> will have <code>int</code>
 as its canonical type. Similarly, <code>I*</code>&nbsp;and a typedef <code>IP</code>&nbsp;(defined to <code>I*</code>) will has <code>int*</code> as their canonical
 type. When building a new type node, be sure to set
 <code>TYPE_CANONICAL</code> to the appropriate canonical type. If the new
 type is a compound type (built from other types), and any of those
 other types require structural equality, use
 <code>SET_TYPE_STRUCTURAL_EQUALITY</code> to ensure that the new type also
 requires structural equality. Finally, if for some reason you cannot
 guarantee that <code>TYPE_CANONICAL</code> will point to the canonical type,
 use <code>SET_TYPE_STRUCTURAL_EQUALITY</code> to make sure that the new
 type&ndash;and any type constructed based on it&ndash;requires structural
 equality. If you suspect that the canonical type system is
 miscomparing types, pass <code>--param verify-canonical-types=1</code> to
 the compiler or configure with <code>--enable-checking</code> to force the
 compiler to verify its canonical-type comparisons against the
 structural comparisons; the compiler will then print any warnings if
 the canonical types miscompare.
 </p>
 </dd>
 <dt><code>TYPE_STRUCTURAL_EQUALITY_P</code>
 <a name="index-TYPE_005fSTRUCTURAL_005fEQUALITY_005fP-1"></a>
 </dt>
 <dd><p>This predicate holds when the node requires structural equality
 checks, e.g., when <code>TYPE_CANONICAL</code> is <code>NULL_TREE</code>.
 </p>
 </dd>
 <dt><code>SET_TYPE_STRUCTURAL_EQUALITY</code>
 <a name="index-SET_005fTYPE_005fSTRUCTURAL_005fEQUALITY-1"></a>
 </dt>
 <dd><p>This macro states that the type node it is given requires structural
 equality checks, e.g., it sets <code>TYPE_CANONICAL</code> to
 <code>NULL_TREE</code>.
 </p>
 </dd>
 <dt><code>same_type_p</code>
 <a name="index-same_005ftype_005fp"></a>
 </dt>
 <dd><p>This predicate takes two types as input, and holds if they are the same
 type.  For example, if one type is a <code>typedef</code> for the other, or
 both are <code>typedef</code>s for the same type.  This predicate also holds if
 the two trees given as input are simply copies of one another; i.e.,
 there is no difference between them at the source level, but, for
 whatever reason, a duplicate has been made in the representation.  You
 should never use <code>==</code> (pointer equality) to compare types; always
 use <code>same_type_p</code> instead.
 </p></dd>
 </dl>

 <p>Detailed below are the various kinds of types, and the macros that can
 be used to access them.  Although other kinds of types are used
 elsewhere in G++, the types described here are the only ones that you
 will encounter while examining the intermediate representation.
 </p>
 <dl compact="compact">
 <dt><code>VOID_TYPE</code></dt>
 <dd><p>Used to represent the <code>void</code> type.
 </p>
 </dd>
 <dt><code>INTEGER_TYPE</code></dt>
 <dd><p>Used to represent the various integral types, including <code>char</code>,
 <code>short</code>, <code>int</code>, <code>long</code>, and <code>long long</code>.  This code
 is not used for enumeration types, nor for the <code>bool</code> type.
 The <code>TYPE_PRECISION</code> is the number of bits used in
 the representation, represented as an <code>unsigned int</code>.  (Note that
 in the general case this is not the same value as <code>TYPE_SIZE</code>;
 suppose that there were a 24-bit integer type, but that alignment
 requirements for the ABI required 32-bit alignment.  Then,
 <code>TYPE_SIZE</code> would be an <code>INTEGER_CST</code> for 32, while
 <code>TYPE_PRECISION</code> would be 24.)  The integer type is unsigned if
 <code>TYPE_UNSIGNED</code> holds; otherwise, it is signed.
 </p>
 <p>The <code>TYPE_MIN_VALUE</code> is an <code>INTEGER_CST</code> for the smallest
 integer that may be represented by this type.  Similarly, the
 <code>TYPE_MAX_VALUE</code> is an <code>INTEGER_CST</code> for the largest integer
 that may be represented by this type.
 </p>
 </dd>
 <dt><code>REAL_TYPE</code></dt>
 <dd><p>Used to represent the <code>float</code>, <code>double</code>, and <code>long
 double</code> types.  The number of bits in the floating-point representation
 is given by <code>TYPE_PRECISION</code>, as in the <code>INTEGER_TYPE</code> case.
 </p>
 </dd>
 <dt><code>FIXED_POINT_TYPE</code></dt>
 <dd><p>Used to represent the <code>short _Fract</code>, <code>_Fract</code>, <code>long
 _Fract</code>, <code>long long _Fract</code>, <code>short _Accum</code>, <code>_Accum</code>,
 <code>long _Accum</code>, and <code>long long _Accum</code> types.  The number of bits
 in the fixed-point representation is given by <code>TYPE_PRECISION</code>,
 as in the <code>INTEGER_TYPE</code> case.  There may be padding bits, fractional
 bits and integral bits.  The number of fractional bits is given by
 <code>TYPE_FBIT</code>, and the number of integral bits is given by <code>TYPE_IBIT</code>.
 The fixed-point type is unsigned if <code>TYPE_UNSIGNED</code> holds; otherwise,
 it is signed.
 The fixed-point type is saturating if <code>TYPE_SATURATING</code> holds; otherwise,
 it is not saturating.
 </p>
 </dd>
 <dt><code>COMPLEX_TYPE</code></dt>
 <dd><p>Used to represent GCC built-in <code>__complex__</code> data types.  The
 <code>TREE_TYPE</code> is the type of the real and imaginary parts.
 </p>
 </dd>
 <dt><code>ENUMERAL_TYPE</code></dt>
 <dd><p>Used to represent an enumeration type.  The <code>TYPE_PRECISION</code> gives
 (as an <code>int</code>), the number of bits used to represent the type.  If
 there are no negative enumeration constants, <code>TYPE_UNSIGNED</code> will
 hold.  The minimum and maximum enumeration constants may be obtained
 with <code>TYPE_MIN_VALUE</code> and <code>TYPE_MAX_VALUE</code>, respectively; each
 of these macros returns an <code>INTEGER_CST</code>.
 </p>
 <p>The actual enumeration constants themselves may be obtained by looking
 at the <code>TYPE_VALUES</code>.  This macro will return a <code>TREE_LIST</code>,
 containing the constants.  The <code>TREE_PURPOSE</code> of each node will be
 an <code>IDENTIFIER_NODE</code> giving the name of the constant; the
 <code>TREE_VALUE</code> will be an <code>INTEGER_CST</code> giving the value
 assigned to that constant.  These constants will appear in the order in
 which they were declared.  The <code>TREE_TYPE</code> of each of these
 constants will be the type of enumeration type itself.
 </p>
 </dd>
 <dt><code>BOOLEAN_TYPE</code></dt>
 <dd><p>Used to represent the <code>bool</code> type.
 </p>
 </dd>
 <dt><code>POINTER_TYPE</code></dt>
 <dd><p>Used to represent pointer types, and pointer to data member types.  The
 <code>TREE_TYPE</code> gives the type to which this type points.
 </p>
 </dd>
 <dt><code>REFERENCE_TYPE</code></dt>
 <dd><p>Used to represent reference types.  The <code>TREE_TYPE</code> gives the type
 to which this type refers.
 </p>
 </dd>
 <dt><code>FUNCTION_TYPE</code></dt>
 <dd><p>Used to represent the type of non-member functions and of static member
 functions.  The <code>TREE_TYPE</code> gives the return type of the function.
 The <code>TYPE_ARG_TYPES</code> are a <code>TREE_LIST</code> of the argument types.
 The <code>TREE_VALUE</code> of each node in this list is the type of the
 corresponding argument; the <code>TREE_PURPOSE</code> is an expression for the
 default argument value, if any.  If the last node in the list is
 <code>void_list_node</code> (a <code>TREE_LIST</code> node whose <code>TREE_VALUE</code>
 is the <code>void_type_node</code>), then functions of this type do not take
 variable arguments.  Otherwise, they do take a variable number of
 arguments.
 </p>
 <p>Note that in C (but not in C++) a function declared like <code>void f()</code>
 is an unprototyped function taking a variable number of arguments; the
 <code>TYPE_ARG_TYPES</code> of such a function will be <code>NULL</code>.
 </p>
 </dd>
 <dt><code>METHOD_TYPE</code></dt>
 <dd><p>Used to represent the type of a non-static member function.  Like a
 <code>FUNCTION_TYPE</code>, the return type is given by the <code>TREE_TYPE</code>.
 The type of <code>*this</code>, i.e., the class of which functions of this
 type are a member, is given by the <code>TYPE_METHOD_BASETYPE</code>.  The
 <code>TYPE_ARG_TYPES</code> is the parameter list, as for a
 <code>FUNCTION_TYPE</code>, and includes the <code>this</code> argument.
 </p>
 </dd>
 <dt><code>ARRAY_TYPE</code></dt>
 <dd><p>Used to represent array types.  The <code>TREE_TYPE</code> gives the type of
 the elements in the array.  If the array-bound is present in the type,
 the <code>TYPE_DOMAIN</code> is an <code>INTEGER_TYPE</code> whose
 <code>TYPE_MIN_VALUE</code> and <code>TYPE_MAX_VALUE</code> will be the lower and
 upper bounds of the array, respectively.  The <code>TYPE_MIN_VALUE</code> will
 always be an <code>INTEGER_CST</code> for zero, while the
 <code>TYPE_MAX_VALUE</code> will be one less than the number of elements in
 the array, i.e., the highest value which may be used to index an element
 in the array.
 </p>
 </dd>
 <dt><code>RECORD_TYPE</code></dt>
 <dd><p>Used to represent <code>struct</code> and <code>class</code> types, as well as
 pointers to member functions and similar constructs in other languages.
 <code>TYPE_FIELDS</code> contains the items contained in this type, each of
 which can be a <code>FIELD_DECL</code>, <code>VAR_DECL</code>, <code>CONST_DECL</code>, or
 <code>TYPE_DECL</code>.  You may not make any assumptions about the ordering
 of the fields in the type or whether one or more of them overlap.
 </p>
 </dd>
 <dt><code>UNION_TYPE</code></dt>
 <dd><p>Used to represent <code>union</code> types.  Similar to <code>RECORD_TYPE</code>
 except that all <code>FIELD_DECL</code> nodes in <code>TYPE_FIELD</code> start at
 bit position zero.
 </p>
 </dd>
 <dt><code>QUAL_UNION_TYPE</code></dt>
 <dd><p>Used to represent part of a variant record in Ada.  Similar to
 <code>UNION_TYPE</code> except that each <code>FIELD_DECL</code> has a
 <code>DECL_QUALIFIER</code> field, which contains a boolean expression that
 indicates whether the field is present in the object.  The type will only
 have one field, so each field&rsquo;s <code>DECL_QUALIFIER</code> is only evaluated
 if none of the expressions in the previous fields in <code>TYPE_FIELDS</code>
 are nonzero.  Normally these expressions will reference a field in the
 outer object using a <code>PLACEHOLDER_EXPR</code>.
 </p>
 </dd>
 <dt><code>LANG_TYPE</code></dt>
 <dd><p>This node is used to represent a language-specific type.  The front
 end must handle it.
 </p>
 </dd>
 <dt><code>OFFSET_TYPE</code></dt>
 <dd><p>This node is used to represent a pointer-to-data member.  For a data
 member <code>X::m</code> the <code>TYPE_OFFSET_BASETYPE</code> is <code>X</code> and the
 <code>TREE_TYPE</code> is the type of <code>m</code>.
 </p>
 </dd>
 </dl>

 <p>There are variables whose values represent some of the basic types.
 These include:
 </p><dl compact="compact">
 <dt><code>void_type_node</code></dt>
 <dd><p>A node for <code>void</code>.
 </p>
 </dd>
 <dt><code>integer_type_node</code></dt>
 <dd><p>A node for <code>int</code>.
 </p>
 </dd>
 <dt><code>unsigned_type_node.</code></dt>
 <dd><p>A node for <code>unsigned int</code>.
 </p>
 </dd>
 <dt><code>char_type_node.</code></dt>
 <dd><p>A node for <code>char</code>.
 </p></dd>
 </dl>
 <p>It may sometimes be useful to compare one of these variables with a type
 in hand, using <code>same_type_p</code>.
 </p>

 <hr>
 <div class="header">
 <p>
 Next: <a href="Declarations.html#Declarations" accesskey="n" rel="next">Declarations</a>, Previous: <a href="Tree-overview.html#Tree-overview" accesskey="p" rel="prev">Tree overview</a>, Up: <a href="GENERIC.html#GENERIC" accesskey="u" rel="up">GENERIC</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
 </div>


 </body>
 </html>
	<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
	<html>
	<!-- Copyright (C) 1988-2015 Free Software Foundation, Inc.

	Permission is granted to copy, distribute and/or modify this document
	under the terms of the GNU Free Documentation License, Version 1.3 or
	any later version published by the Free Software Foundation; with the
	Invariant Sections being "Funding Free Software", the Front-Cover
	Texts being (a) (see below), and with the Back-Cover Texts being (b)
	(see below). A copy of the license is included in the section entitled
	"GNU Free Documentation License".

	(a) The FSF's Front-Cover Text is:

	A GNU Manual

	(b) The FSF's Back-Cover Text is:

	You have freedom to copy and modify this GNU Manual, like GNU
	software. Copies published by the Free Software Foundation raise
	funds for GNU development. -->
	<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
	<head>
	<title>GNU Compiler Collection (GCC) Internals: Types</title>

	<meta name="description" content="GNU Compiler Collection (GCC) Internals: Types">
	<meta name="keywords" content="GNU Compiler Collection (GCC) Internals: Types">
	<meta name="resource-type" content="document">
	<meta name="distribution" content="global">
	<meta name="Generator" content="makeinfo">
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<link href="index.html#Top" rel="start" title="Top">
	<link href="Option-Index.html#Option-Index" rel="index" title="Option Index">
	<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
	<link href="GENERIC.html#GENERIC" rel="up" title="GENERIC">
	<link href="Declarations.html#Declarations" rel="next" title="Declarations">
	<link href="Containers.html#Containers" rel="prev" title="Containers">
	<style type="text/css">
	<!--
	a.summary-letter {text-decoration: none}
	blockquote.smallquotation {font-size: smaller}
	div.display {margin-left: 3.2em}
	div.example {margin-left: 3.2em}
	div.indentedblock {margin-left: 3.2em}
	div.lisp {margin-left: 3.2em}
	div.smalldisplay {margin-left: 3.2em}
	div.smallexample {margin-left: 3.2em}
	div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
	div.smalllisp {margin-left: 3.2em}
	kbd {font-style:oblique}
	pre.display {font-family: inherit}
	pre.format {font-family: inherit}
	pre.menu-comment {font-family: serif}
	pre.menu-preformatted {font-family: serif}
	pre.smalldisplay {font-family: inherit; font-size: smaller}
	pre.smallexample {font-size: smaller}
	pre.smallformat {font-family: inherit; font-size: smaller}
	pre.smalllisp {font-size: smaller}
	span.nocodebreak {white-space:nowrap}
	span.nolinebreak {white-space:nowrap}
	span.roman {font-family:serif; font-weight:normal}
	span.sansserif {font-family:sans-serif; font-weight:normal}
	ul.no-bullet {list-style: none}
	-->
	</style>


	</head>

	<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
	<a name="Types"></a>
	<div class="header">
	<p>
	Next: <a href="Declarations.html#Declarations" accesskey="n" rel="next">Declarations</a>, Previous: <a href="Tree-overview.html#Tree-overview" accesskey="p" rel="prev">Tree overview</a>, Up: <a href="GENERIC.html#GENERIC" accesskey="u" rel="up">GENERIC</a>   [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
	</div>
	<hr>
	<a name="Types-1"></a>
	<h3 class="section">10.3 Types</h3>
	<a name="index-type"></a>
	<a name="index-pointer"></a>
	<a name="index-reference"></a>
	<a name="index-fundamental-type"></a>
	<a name="index-array"></a>
	<a name="index-VOID_005fTYPE"></a>
	<a name="index-INTEGER_005fTYPE"></a>
	<a name="index-TYPE_005fMIN_005fVALUE"></a>
	<a name="index-TYPE_005fMAX_005fVALUE"></a>
	<a name="index-REAL_005fTYPE"></a>
	<a name="index-FIXED_005fPOINT_005fTYPE"></a>
	<a name="index-COMPLEX_005fTYPE"></a>
	<a name="index-ENUMERAL_005fTYPE"></a>
	<a name="index-BOOLEAN_005fTYPE"></a>
	<a name="index-POINTER_005fTYPE"></a>
	<a name="index-REFERENCE_005fTYPE"></a>
	<a name="index-FUNCTION_005fTYPE"></a>
	<a name="index-METHOD_005fTYPE"></a>
	<a name="index-ARRAY_005fTYPE"></a>
	<a name="index-RECORD_005fTYPE"></a>
	<a name="index-UNION_005fTYPE"></a>
	<a name="index-UNKNOWN_005fTYPE"></a>
	<a name="index-OFFSET_005fTYPE"></a>
	<a name="index-TYPE_005fUNQUALIFIED"></a>
	<a name="index-TYPE_005fQUAL_005fCONST"></a>
	<a name="index-TYPE_005fQUAL_005fVOLATILE"></a>
	<a name="index-TYPE_005fQUAL_005fRESTRICT"></a>
	<a name="index-TYPE_005fMAIN_005fVARIANT"></a>
	<a name="index-qualified-type"></a>
	<a name="index-TYPE_005fSIZE"></a>
	<a name="index-TYPE_005fALIGN"></a>
	<a name="index-TYPE_005fPRECISION"></a>
	<a name="index-TYPE_005fARG_005fTYPES"></a>
	<a name="index-TYPE_005fMETHOD_005fBASETYPE"></a>
	<a name="index-TYPE_005fOFFSET_005fBASETYPE"></a>
	<a name="index-TREE_005fTYPE-1"></a>
	<a name="index-TYPE_005fCONTEXT"></a>
	<a name="index-TYPE_005fNAME"></a>
	<a name="index-TYPENAME_005fTYPE_005fFULLNAME"></a>
	<a name="index-TYPE_005fFIELDS"></a>
	<a name="index-TYPE_005fCANONICAL"></a>
	<a name="index-TYPE_005fSTRUCTURAL_005fEQUALITY_005fP"></a>
	<a name="index-SET_005fTYPE_005fSTRUCTURAL_005fEQUALITY"></a>

	<p>All types have corresponding tree nodes. However, you should not assume
	that there is exactly one tree node corresponding to each type. There
	are often multiple nodes corresponding to the same type.
	</p>
	<p>For the most part, different kinds of types have different tree codes.
	(For example, pointer types use a <code>POINTER_TYPE</code> code while arrays
	use an <code>ARRAY_TYPE</code> code.) However, pointers to member functions
	use the <code>RECORD_TYPE</code> code. Therefore, when writing a
	<code>switch</code> statement that depends on the code associated with a
	particular type, you should take care to handle pointers to member
	functions under the <code>RECORD_TYPE</code> case label.
	</p>
	<p>The following functions and macros deal with cv-qualification of types:
	</p><dl compact="compact">
	<dt><code>TYPE_MAIN_VARIANT</code>
	<a name="index-TYPE_005fMAIN_005fVARIANT-1"></a>
	</dt>
	<dd><p>This macro returns the unqualified version of a type. It may be applied
	to an unqualified type, but it is not always the identity function in
	that case.
	</p></dd>
	</dl>

	<p>A few other macros and functions are usable with all types:
	</p><dl compact="compact">
	<dt><code>TYPE_SIZE</code>
	<a name="index-TYPE_005fSIZE-1"></a>
	</dt>
	<dd><p>The number of bits required to represent the type, represented as an
	<code>INTEGER_CST</code>. For an incomplete type, <code>TYPE_SIZE</code> will be
	<code>NULL_TREE</code>.
	</p>
	</dd>
	<dt><code>TYPE_ALIGN</code>
	<a name="index-TYPE_005fALIGN-1"></a>
	</dt>
	<dd><p>The alignment of the type, in bits, represented as an <code>int</code>.
	</p>
	</dd>
	<dt><code>TYPE_NAME</code>
	<a name="index-TYPE_005fNAME-1"></a>
	</dt>
	<dd><p>This macro returns a declaration (in the form of a <code>TYPE_DECL</code>) for
	the type. (Note this macro does <em>not</em> return an
	<code>IDENTIFIER_NODE</code>, as you might expect, given its name!) You can
	look at the <code>DECL_NAME</code> of the <code>TYPE_DECL</code> to obtain the
	actual name of the type. The <code>TYPE_NAME</code> will be <code>NULL_TREE</code>
	for a type that is not a built-in type, the result of a typedef, or a
	named class type.
	</p>
	</dd>
	<dt><code>TYPE_CANONICAL</code>
	<a name="index-TYPE_005fCANONICAL-1"></a>
	</dt>
	<dd><p>This macro returns the “canonical” type for the given type
	node. Canonical types are used to improve performance in the C++ and
	Objective-C++ front ends by allowing efficient comparison between two
	type nodes in <code>same_type_p</code>: if the <code>TYPE_CANONICAL</code> values
	of the types are equal, the types are equivalent; otherwise, the types
	are not equivalent. The notion of equivalence for canonical types is
	the same as the notion of type equivalence in the language itself. For
	instance,
	</p>
	<p>When <code>TYPE_CANONICAL</code> is <code>NULL_TREE</code>, there is no canonical
	type for the given type node. In this case, comparison between this
	type and any other type requires the compiler to perform a deep,
	“structural” comparison to see if the two type nodes have the same
	form and properties.
	</p>
	<p>The canonical type for a node is always the most fundamental type in
	the equivalence class of types. For instance, <code>int</code> is its own
	canonical type. A typedef <code>I</code> of <code>int</code> will have <code>int</code>
	as its canonical type. Similarly, <code>I</code> and a typedef <code>IP</code> (defined to <code>I</code>) will has <code>int*</code> as their canonical
	type. When building a new type node, be sure to set
	<code>TYPE_CANONICAL</code> to the appropriate canonical type. If the new
	type is a compound type (built from other types), and any of those
	other types require structural equality, use
	<code>SET_TYPE_STRUCTURAL_EQUALITY</code> to ensure that the new type also
	requires structural equality. Finally, if for some reason you cannot
	guarantee that <code>TYPE_CANONICAL</code> will point to the canonical type,
	use <code>SET_TYPE_STRUCTURAL_EQUALITY</code> to make sure that the new
	type–and any type constructed based on it–requires structural
	equality. If you suspect that the canonical type system is
	miscomparing types, pass <code>--param verify-canonical-types=1</code> to
	the compiler or configure with <code>--enable-checking</code> to force the
	compiler to verify its canonical-type comparisons against the
	structural comparisons; the compiler will then print any warnings if
	the canonical types miscompare.
	</p>
	</dd>
	<dt><code>TYPE_STRUCTURAL_EQUALITY_P</code>
	<a name="index-TYPE_005fSTRUCTURAL_005fEQUALITY_005fP-1"></a>
	</dt>
	<dd><p>This predicate holds when the node requires structural equality
	checks, e.g., when <code>TYPE_CANONICAL</code> is <code>NULL_TREE</code>.
	</p>
	</dd>
	<dt><code>SET_TYPE_STRUCTURAL_EQUALITY</code>
	<a name="index-SET_005fTYPE_005fSTRUCTURAL_005fEQUALITY-1"></a>
	</dt>
	<dd><p>This macro states that the type node it is given requires structural
	equality checks, e.g., it sets <code>TYPE_CANONICAL</code> to
	<code>NULL_TREE</code>.
	</p>
	</dd>
	<dt><code>same_type_p</code>
	<a name="index-same_005ftype_005fp"></a>
	</dt>
	<dd><p>This predicate takes two types as input, and holds if they are the same
	type. For example, if one type is a <code>typedef</code> for the other, or
	both are <code>typedef</code>s for the same type. This predicate also holds if
	the two trees given as input are simply copies of one another; i.e.,
	there is no difference between them at the source level, but, for
	whatever reason, a duplicate has been made in the representation. You
	should never use <code>==</code> (pointer equality) to compare types; always
	use <code>same_type_p</code> instead.
	</p></dd>
	</dl>

	<p>Detailed below are the various kinds of types, and the macros that can
	be used to access them. Although other kinds of types are used
	elsewhere in G++, the types described here are the only ones that you
	will encounter while examining the intermediate representation.
	</p>
	<dl compact="compact">
	<dt><code>VOID_TYPE</code></dt>
	<dd><p>Used to represent the <code>void</code> type.
	</p>
	</dd>
	<dt><code>INTEGER_TYPE</code></dt>
	<dd><p>Used to represent the various integral types, including <code>char</code>,
	<code>short</code>, <code>int</code>, <code>long</code>, and <code>long long</code>. This code
	is not used for enumeration types, nor for the <code>bool</code> type.
	The <code>TYPE_PRECISION</code> is the number of bits used in
	the representation, represented as an <code>unsigned int</code>. (Note that
	in the general case this is not the same value as <code>TYPE_SIZE</code>;
	suppose that there were a 24-bit integer type, but that alignment
	requirements for the ABI required 32-bit alignment. Then,
	<code>TYPE_SIZE</code> would be an <code>INTEGER_CST</code> for 32, while
	<code>TYPE_PRECISION</code> would be 24.) The integer type is unsigned if
	<code>TYPE_UNSIGNED</code> holds; otherwise, it is signed.
	</p>
	<p>The <code>TYPE_MIN_VALUE</code> is an <code>INTEGER_CST</code> for the smallest
	integer that may be represented by this type. Similarly, the
	<code>TYPE_MAX_VALUE</code> is an <code>INTEGER_CST</code> for the largest integer
	that may be represented by this type.
	</p>
	</dd>
	<dt><code>REAL_TYPE</code></dt>
	<dd><p>Used to represent the <code>float</code>, <code>double</code>, and <code>long
	double</code> types. The number of bits in the floating-point representation
	is given by <code>TYPE_PRECISION</code>, as in the <code>INTEGER_TYPE</code> case.
	</p>
	</dd>
	<dt><code>FIXED_POINT_TYPE</code></dt>
	<dd><p>Used to represent the <code>short _Fract</code>, <code>_Fract</code>, <code>long
	_Fract</code>, <code>long long _Fract</code>, <code>short _Accum</code>, <code>_Accum</code>,
	<code>long _Accum</code>, and <code>long long _Accum</code> types. The number of bits
	in the fixed-point representation is given by <code>TYPE_PRECISION</code>,
	as in the <code>INTEGER_TYPE</code> case. There may be padding bits, fractional
	bits and integral bits. The number of fractional bits is given by
	<code>TYPE_FBIT</code>, and the number of integral bits is given by <code>TYPE_IBIT</code>.
	The fixed-point type is unsigned if <code>TYPE_UNSIGNED</code> holds; otherwise,
	it is signed.
	The fixed-point type is saturating if <code>TYPE_SATURATING</code> holds; otherwise,
	it is not saturating.
	</p>
	</dd>
	<dt><code>COMPLEX_TYPE</code></dt>
	<dd><p>Used to represent GCC built-in <code>__complex__</code> data types. The
	<code>TREE_TYPE</code> is the type of the real and imaginary parts.
	</p>
	</dd>
	<dt><code>ENUMERAL_TYPE</code></dt>
	<dd><p>Used to represent an enumeration type. The <code>TYPE_PRECISION</code> gives
	(as an <code>int</code>), the number of bits used to represent the type. If
	there are no negative enumeration constants, <code>TYPE_UNSIGNED</code> will
	hold. The minimum and maximum enumeration constants may be obtained
	with <code>TYPE_MIN_VALUE</code> and <code>TYPE_MAX_VALUE</code>, respectively; each
	of these macros returns an <code>INTEGER_CST</code>.
	</p>
	<p>The actual enumeration constants themselves may be obtained by looking
	at the <code>TYPE_VALUES</code>. This macro will return a <code>TREE_LIST</code>,
	containing the constants. The <code>TREE_PURPOSE</code> of each node will be
	an <code>IDENTIFIER_NODE</code> giving the name of the constant; the
	<code>TREE_VALUE</code> will be an <code>INTEGER_CST</code> giving the value
	assigned to that constant. These constants will appear in the order in
	which they were declared. The <code>TREE_TYPE</code> of each of these
	constants will be the type of enumeration type itself.
	</p>
	</dd>
	<dt><code>BOOLEAN_TYPE</code></dt>
	<dd><p>Used to represent the <code>bool</code> type.
	</p>
	</dd>
	<dt><code>POINTER_TYPE</code></dt>
	<dd><p>Used to represent pointer types, and pointer to data member types. The
	<code>TREE_TYPE</code> gives the type to which this type points.
	</p>
	</dd>
	<dt><code>REFERENCE_TYPE</code></dt>
	<dd><p>Used to represent reference types. The <code>TREE_TYPE</code> gives the type
	to which this type refers.
	</p>
	</dd>
	<dt><code>FUNCTION_TYPE</code></dt>
	<dd><p>Used to represent the type of non-member functions and of static member
	functions. The <code>TREE_TYPE</code> gives the return type of the function.
	The <code>TYPE_ARG_TYPES</code> are a <code>TREE_LIST</code> of the argument types.
	The <code>TREE_VALUE</code> of each node in this list is the type of the
	corresponding argument; the <code>TREE_PURPOSE</code> is an expression for the
	default argument value, if any. If the last node in the list is
	<code>void_list_node</code> (a <code>TREE_LIST</code> node whose <code>TREE_VALUE</code>
	is the <code>void_type_node</code>), then functions of this type do not take
	variable arguments. Otherwise, they do take a variable number of
	arguments.
	</p>
	<p>Note that in C (but not in C++) a function declared like <code>void f()</code>
	is an unprototyped function taking a variable number of arguments; the
	<code>TYPE_ARG_TYPES</code> of such a function will be <code>NULL</code>.
	</p>
	</dd>
	<dt><code>METHOD_TYPE</code></dt>
	<dd><p>Used to represent the type of a non-static member function. Like a
	<code>FUNCTION_TYPE</code>, the return type is given by the <code>TREE_TYPE</code>.
	The type of <code>*this</code>, i.e., the class of which functions of this
	type are a member, is given by the <code>TYPE_METHOD_BASETYPE</code>. The
	<code>TYPE_ARG_TYPES</code> is the parameter list, as for a
	<code>FUNCTION_TYPE</code>, and includes the <code>this</code> argument.
	</p>
	</dd>
	<dt><code>ARRAY_TYPE</code></dt>
	<dd><p>Used to represent array types. The <code>TREE_TYPE</code> gives the type of
	the elements in the array. If the array-bound is present in the type,
	the <code>TYPE_DOMAIN</code> is an <code>INTEGER_TYPE</code> whose
	<code>TYPE_MIN_VALUE</code> and <code>TYPE_MAX_VALUE</code> will be the lower and
	upper bounds of the array, respectively. The <code>TYPE_MIN_VALUE</code> will
	always be an <code>INTEGER_CST</code> for zero, while the
	<code>TYPE_MAX_VALUE</code> will be one less than the number of elements in
	the array, i.e., the highest value which may be used to index an element
	in the array.
	</p>
	</dd>
	<dt><code>RECORD_TYPE</code></dt>
	<dd><p>Used to represent <code>struct</code> and <code>class</code> types, as well as
	pointers to member functions and similar constructs in other languages.
	<code>TYPE_FIELDS</code> contains the items contained in this type, each of
	which can be a <code>FIELD_DECL</code>, <code>VAR_DECL</code>, <code>CONST_DECL</code>, or
	<code>TYPE_DECL</code>. You may not make any assumptions about the ordering
	of the fields in the type or whether one or more of them overlap.
	</p>
	</dd>
	<dt><code>UNION_TYPE</code></dt>
	<dd><p>Used to represent <code>union</code> types. Similar to <code>RECORD_TYPE</code>
	except that all <code>FIELD_DECL</code> nodes in <code>TYPE_FIELD</code> start at
	bit position zero.
	</p>
	</dd>
	<dt><code>QUAL_UNION_TYPE</code></dt>
	<dd><p>Used to represent part of a variant record in Ada. Similar to
	<code>UNION_TYPE</code> except that each <code>FIELD_DECL</code> has a
	<code>DECL_QUALIFIER</code> field, which contains a boolean expression that
	indicates whether the field is present in the object. The type will only
	have one field, so each field’s <code>DECL_QUALIFIER</code> is only evaluated
	if none of the expressions in the previous fields in <code>TYPE_FIELDS</code>
	are nonzero. Normally these expressions will reference a field in the
	outer object using a <code>PLACEHOLDER_EXPR</code>.
	</p>
	</dd>
	<dt><code>LANG_TYPE</code></dt>
	<dd><p>This node is used to represent a language-specific type. The front
	end must handle it.
	</p>
	</dd>
	<dt><code>OFFSET_TYPE</code></dt>
	<dd><p>This node is used to represent a pointer-to-data member. For a data
	member <code>X::m</code> the <code>TYPE_OFFSET_BASETYPE</code> is <code>X</code> and the
	<code>TREE_TYPE</code> is the type of <code>m</code>.
	</p>
	</dd>
	</dl>

	<p>There are variables whose values represent some of the basic types.
	These include:
	</p><dl compact="compact">
	<dt><code>void_type_node</code></dt>
	<dd><p>A node for <code>void</code>.
	</p>
	</dd>
	<dt><code>integer_type_node</code></dt>
	<dd><p>A node for <code>int</code>.
	</p>
	</dd>
	<dt><code>unsigned_type_node.</code></dt>
	<dd><p>A node for <code>unsigned int</code>.
	</p>
	</dd>
	<dt><code>char_type_node.</code></dt>
	<dd><p>A node for <code>char</code>.
	</p></dd>
	</dl>
	<p>It may sometimes be useful to compare one of these variables with a type
	in hand, using <code>same_type_p</code>.
	</p>

	<hr>
	<div class="header">
	<p>
	Next: <a href="Declarations.html#Declarations" accesskey="n" rel="next">Declarations</a>, Previous: <a href="Tree-overview.html#Tree-overview" accesskey="p" rel="prev">Tree overview</a>, Up: <a href="GENERIC.html#GENERIC" accesskey="u" rel="up">GENERIC</a>   [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
	</div>



	</body>
	</html>