/* This file contains the definitions and documentation for the
- tree codes used in the GNU C compiler.
+ tree codes used in GCC.
Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001
Free Software Foundation, Inc.
'<' for codes for comparison expressions.
'1' for codes for unary arithmetic expressions.
'2' for codes for binary arithmetic expressions.
- 's' for codes for expressions with inherent side effects.
+ 's' for codes for "statement" expressions, which have side-effects,
+ but usually no interesting value.
'e' for codes for other kinds of expressions. */
-/* For `r', `e', `<', `1', `2', `s' and `x' nodes,
- the 4th element is the number of argument slots to allocate.
- This determines the size of the tree node object. */
+/* For `r', `e', `<', `1', `2', and `s' nodes, which use struct
+ tree_exp, the 4th element is the number of argument slots to
+ allocate. This determines the size of the tree node object.
+ Other nodes use different structures, and the size is determined
+ by the tree_union member structure; the 4th element should be
+ zero. Languages that define language-specific 'x' or 'c' codes
+ must define the tree_size langhook to say how big they are. */
/* Any erroneous construct is parsed into a node of this type.
This type of node is accepted without complaint in all contexts
Internally it looks like a STRING_CST node.
There is only one IDENTIFIER_NODE ever made for any particular name.
Use `get_identifier' to get it (or create it, the first time). */
-DEFTREECODE (IDENTIFIER_NODE, "identifier_node", 'x', -1)
-
-/* Used to hold information to identify an operator (or combination
- of two operators) considered as a `noun' rather than a `verb'.
- The first operand is encoded in the TREE_TYPE field. */
-DEFTREECODE (OP_IDENTIFIER, "op_identifier", 'x', 2)
+DEFTREECODE (IDENTIFIER_NODE, "identifier_node", 'x', 0)
/* Has the TREE_VALUE and TREE_PURPOSE fields. */
/* These nodes are made into lists by chaining through the
TREE_CHAIN field. The elements of the list live in the
TREE_VALUE fields, while TREE_PURPOSE fields are occasionally
used as well to get the effect of Lisp association lists. */
-DEFTREECODE (TREE_LIST, "tree_list", 'x', 2)
+DEFTREECODE (TREE_LIST, "tree_list", 'x', 0)
/* These nodes contain an array of tree nodes. */
-DEFTREECODE (TREE_VEC, "tree_vec", 'x', 2)
+DEFTREECODE (TREE_VEC, "tree_vec", 'x', 0)
/* A symbol binding block. These are arranged in a tree,
where the BLOCK_SUBBLOCKS field contains a chain of subblocks
could either point to another BLOCK node or it could point to a
FUNCTION_DECL node (e.g. in the case of a block representing the
outermost scope of a particular inlining of a function).
- BLOCK_ABSTRACT is non-zero if the block represents an abstract
+ BLOCK_ABSTRACT is nonzero if the block represents an abstract
instance of a block (i.e. one which is nested within an abstract
instance of an inline function).
- TREE_ASM_WRITTEN is non-zero if the block was actually referenced
+ TREE_ASM_WRITTEN is nonzero if the block was actually referenced
in the generated assembly. */
DEFTREECODE (BLOCK, "block", 'b', 0)
\f
TREE_TYPE Type of an array element.
TYPE_DOMAIN Type to index by.
Its range of values specifies the array length.
- TYPE_SEP Expression for units from one elt to the next.
- TYPE_SEP_UNIT Number of bits in a unit for previous.
The field TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero
and holds the type to coerce a value of that array type to in C.
TYPE_STRING_FLAG indicates a string (in contrast to an array of chars)
- in languages (such as Chill) that make a distinction. */
+ in languages (such as Chill) that make a distinction. */
/* Array types in C or Pascal */
DEFTREECODE (ARRAY_TYPE, "array_type", 't', 0)
/* Types of sets for Pascal. Special fields are the same as
in an array type. The target type is always a boolean type.
Used for both bitstrings and powersets in Chill;
- TYPE_STRING_FLAG indicates a bitstring. */
+ TYPE_STRING_FLAG indicates a bitstring. */
DEFTREECODE (SET_TYPE, "set_type", 't', 0)
/* Struct in C, or record in Pascal. */
Note: constants of type char in Pascal are INTEGER_CST,
and so are pointer constants such as nil in Pascal or NULL in C.
`(int *) 1' in C also results in an INTEGER_CST. */
-DEFTREECODE (INTEGER_CST, "integer_cst", 'c', 2)
+DEFTREECODE (INTEGER_CST, "integer_cst", 'c', 0)
-/* Contents are in TREE_REAL_CST field. Also there is TREE_CST_RTL. */
-DEFTREECODE (REAL_CST, "real_cst", 'c', 3)
+/* Contents are in TREE_REAL_CST field. */
+DEFTREECODE (REAL_CST, "real_cst", 'c', 0)
/* Contents are in TREE_REALPART and TREE_IMAGPART fields,
- whose contents are other constant nodes.
- Also there is TREE_CST_RTL. */
-DEFTREECODE (COMPLEX_CST, "complex_cst", 'c', 3)
-
-/* Contents are TREE_STRING_LENGTH and TREE_STRING_POINTER fields.
- Also there is TREE_CST_RTL. */
-DEFTREECODE (STRING_CST, "string_cst", 'c', 3)
-
-/* Declarations. All references to names are represented as ..._DECL nodes.
- The decls in one binding context are chained through the TREE_CHAIN field.
- Each DECL has a DECL_NAME field which contains an IDENTIFIER_NODE.
- (Some decls, most often labels, may have zero as the DECL_NAME).
- DECL_CONTEXT points to the node representing the context in which
- this declaration has its scope. For FIELD_DECLs, this is the
- RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field
- is a member of. For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL,
- and CONST_DECL nodes, this points to either the FUNCTION_DECL for the
- containing function, the RECORD_TYPE or UNION_TYPE for the containing
- type, or NULL_TREE if the given decl has "file scope".
+ whose contents are other constant nodes. */
+DEFTREECODE (COMPLEX_CST, "complex_cst", 'c', 0)
+
+/* Contents are in TREE_VECTOR_CST_ELTS field. */
+DEFTREECODE (VECTOR_CST, "vector_cst", 'c', 0)
+
+/* Contents are TREE_STRING_LENGTH and TREE_STRING_POINTER fields. */
+DEFTREECODE (STRING_CST, "string_cst", 'c', 0)
+
+/* Declarations. All references to names are represented as ..._DECL
+ nodes. The decls in one binding context are chained through the
+ TREE_CHAIN field. Each DECL has a DECL_NAME field which contains
+ an IDENTIFIER_NODE. (Some decls, most often labels, may have zero
+ as the DECL_NAME). DECL_CONTEXT points to the node representing
+ the context in which this declaration has its scope. For
+ FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
+ QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
+ PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
+ points to either the FUNCTION_DECL for the containing function, the
+ RECORD_TYPE or UNION_TYPE for the containing type, or NULL_TREE or
+ a TRANSLATION_UNIT_DECL if the given decl has "file scope".
DECL_ABSTRACT_ORIGIN, if non-NULL, points to the original (abstract)
..._DECL node of which this decl is an (inlined or template expanded)
instance.
and DECL_MODE fields exist in decl nodes just as in type nodes.
They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes.
- DECL_OFFSET holds an integer number of bits offset for the location.
- DECL_VOFFSET holds an expression for a variable offset; it is
- to be multiplied by DECL_VOFFSET_UNIT (an integer).
+ DECL_FIELD_BIT_OFFSET holds an integer number of bits offset for
+ the location. DECL_VOFFSET holds an expression for a variable
+ offset; it is to be multiplied by DECL_VOFFSET_UNIT (an integer).
These fields are relevant only in FIELD_DECLs and PARM_DECLs.
DECL_INITIAL holds the value to initialize a variable to,
holds a line number. In some cases these can be the location of
a reference, if no definition has been seen.
- DECL_ABSTRACT is non-zero if the decl represents an abstract instance
+ DECL_ABSTRACT is nonzero if the decl represents an abstract instance
of a decl (i.e. one which is nested within an abstract instance of a
inline function. */
/* A namespace declaration. Namespaces appear in DECL_CONTEXT of other
_DECLs, providing a hierarchy of names. */
DEFTREECODE (NAMESPACE_DECL, "namespace_decl", 'd', 0)
+
+/* A translation unit. This is not technically a declaration, since it
+ can't be looked up, but it's close enough. */
+DEFTREECODE (TRANSLATION_UNIT_DECL, "translation_unit_decl", 'd', 0)
\f
/* References to storage. */
DEFTREECODE (BUFFER_REF, "buffer_ref", 'r', 1)
/* Array indexing.
- Operand 0 is the array; operand 1 is a (single) array index. */
+ Operand 0 is the array; operand 1 is a (single) array index. */
DEFTREECODE (ARRAY_REF, "array_ref", 'r', 2)
/* Likewise, except that the result is a range ("slice") of the array. The
of the range is taken from the type of the expression. */
DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", 'r', 2)
+/* Vtable indexing. Carries data useful for emitting information
+ for vtable garbage collection.
+ Operand 0: an array_ref (or equivalent expression)
+ Operand 1: the vtable base (must be a var_decl)
+ Operand 2: index into vtable (must be an integer_cst). */
+DEFTREECODE (VTABLE_REF, "vtable_ref", 'r', 3)
+
/* Constructor: return an aggregate value made from specified components.
In C, this is used only for structure and array initializers.
Also used for SET_TYPE in Chill (and potentially Pascal).
- The first "operand" is really a pointer to the RTL,
- for constant constructors only.
- The second operand is a list of component values
- made out of a chain of TREE_LIST nodes.
+ The operand is a list of component values made out of a chain of
+ TREE_LIST nodes.
For ARRAY_TYPE:
The TREE_PURPOSE of each node is the corresponding index.
The TREE_VALUE specifies a value (index) in the set that is true.
If TREE_PURPOSE is non-NULL, it specifies the lower limit of a
range of true values. Elements not listed are false (not in the set). */
-DEFTREECODE (CONSTRUCTOR, "constructor", 'e', 2)
+DEFTREECODE (CONSTRUCTOR, "constructor", 'e', 1)
/* The expression types are mostly straightforward, with the fourth argument
of DEFTREECODE saying how many operands there are.
made out of a chain of TREE_LIST nodes. */
DEFTREECODE (CALL_EXPR, "call_expr", 'e', 2)
-/* Call a method. Operand 0 is the method, whose type is a METHOD_TYPE.
- Operand 1 is the expression for "self".
- Operand 2 is the list of explicit arguments. */
-DEFTREECODE (METHOD_CALL_EXPR, "method_call_expr", 'e', 4)
-
/* Specify a value to compute along with its corresponding cleanup.
Operand 0 argument is an expression whose value needs a cleanup.
Operand 1 is the cleanup expression for the object.
operand of the ABS_EXPR must have the same type. */
DEFTREECODE (ABS_EXPR, "abs_expr", '1', 1)
+/* Bit scanning and counting. */
DEFTREECODE (FFS_EXPR, "ffs_expr", '1', 1)
+DEFTREECODE (CLZ_EXPR, "clz_expr", '1', 1)
+DEFTREECODE (CTZ_EXPR, "ctz_expr", '1', 1)
+DEFTREECODE (POPCOUNT_EXPR, "popcount_expr", '1', 1)
+DEFTREECODE (PARITY_EXPR, "parity_expr", '1', 1)
/* Shift operations for shift and rotate.
Shift means logical shift if done on an
DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr", '2', 2)
DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr", '2', 2)
DEFTREECODE (BIT_AND_EXPR, "bit_and_expr", '2', 2)
-DEFTREECODE (BIT_ANDTC_EXPR, "bit_andtc_expr", '2', 2)
DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", '1', 1)
/* ANDIF and ORIF allow the second operand not to be computed if the
needed or not (for side effects). The operand may have
BOOLEAN_TYPE or INTEGER_TYPE. In either case, the argument will be
either zero or one. For example, a TRUTH_NOT_EXPR will never have
- a INTEGER_TYPE VAR_DECL as its argument; instead, a NE_EXPR will be
+ an INTEGER_TYPE VAR_DECL as its argument; instead, a NE_EXPR will be
used to compare the VAR_DECL to zero, thereby obtaining a node with
value zero or one. */
DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr", 'e', 2)
DEFTREECODE (UNORDERED_EXPR, "unordered_expr", '<', 2)
DEFTREECODE (ORDERED_EXPR, "ordered_expr", '<', 2)
-/* These are equivalent to unordered or ... */
+/* These are equivalent to unordered or ... */
DEFTREECODE (UNLT_EXPR, "unlt_expr", '<', 2)
DEFTREECODE (UNLE_EXPR, "unle_expr", '<', 2)
DEFTREECODE (UNGT_EXPR, "ungt_expr", '<', 2)
/* Value is same as argument, but guaranteed not an lvalue. */
DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr", '1', 1)
+/* Represents viewing something of one type as being of a second type.
+ This corresponds to an "Unchecked Conversion" in Ada and roughly to
+ the idiom *(type2 *)&X in C. The only operand is the value to be
+ viewed as being of another type. It is undefined if the type of the
+ input and of the expression have different sizes.
+
+ This code may also be used within the LHS of a MODIFY_EXPR, in which
+ case no actual data motion may occur. TREE_ADDRESSABLE will be set in
+ this case and GCC must abort if it could not do the operation without
+ generating insns. */
+DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr", '1', 1)
+
/* Represents something we computed once and will use multiple times.
First operand is that expression. Second is the function decl
in which the SAVE_EXPR was created. The third operand is the RTL,
DEFTREECODE (REFERENCE_EXPR, "reference_expr", 'e', 1)
/* Operand is a function constant; result is a function variable value
- of typeEPmode. Used only for languages that need static chains. */
+ of type EPmode. Used only for languages that need static chains. */
DEFTREECODE (ENTRY_VALUE_EXPR, "entry_value_expr", 'e', 1)
+/* Operand0 is a function constant; result is part N of a function
+ descriptor of type ptr_mode. */
+DEFTREECODE (FDESC_EXPR, "fdesc_expr", 'e', 2)
+
/* Given two real or integer operands of the same type,
returns a complex value of the corresponding complex type. */
DEFTREECODE (COMPLEX_EXPR, "complex_expr", '2', 2)
DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr", 'e', 2)
/* Evaluate the first operand.
- The second operand is a a cleanup expression which is evaluated
- before an exit (normal, exception, or jump out) from this expression.
-
- Like a CLEANUP_POINT_EXPR/WITH_CLEANUP_EXPR combination, but those
- always copy the cleanup expression where needed. In contrast,
- TRY_FINALLY_EXPR generates a jump to a cleanup subroutine.
- (At least conceptually; the optimizer could inline the cleanup
- subroutine in the same way it could inline normal subroutines.)
- TRY_FINALLY_EXPR should be used when the cleanup is actual statements
- in the source of the current function (which people might want to
- set breakpoints in). */
+ The second operand is a cleanup expression which is evaluated
+ on any exit (normal, exception, or jump out) from this expression. */
DEFTREECODE (TRY_FINALLY_EXPR, "try_finally", 'e', 2)
/* Used internally for cleanups in the implementation of TRY_FINALLY_EXPR.
/* Switch expression.
Operand 0 is the expression used to perform the branch,
Operand 1 contains the case values. The way they're organized is
- front-end implementation defined. */
+ front-end implementation defined. */
DEFTREECODE (SWITCH_EXPR, "switch_expr", 'e', 2)
/* The exception object from the runtime. */