| <!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> |