/* This file contains the definitions and documentation for the
- tree codes used in the GNU C compiler.
- Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998 Free Software Foundation, Inc.
+ tree codes used in GCC.
+ Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001, 2004
+ Free Software Foundation, Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
+
-
/* The third argument can be:
'x' for an exceptional code (fits no category).
't' for a type object code.
- 'b' for a lexical block.
'c' for codes for constants.
'd' for codes for declarations (also serving as variable refs).
'r' for codes for references to storage.
'<' 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). */
-DEFTREECODE (BLOCK, "block", 'b', 0)
+ instance of an inline function).
+ TREE_ASM_WRITTEN is nonzero if the block was actually referenced
+ in the generated assembly. */
+DEFTREECODE (BLOCK, "block", 'x', 0)
\f
/* Each data type is represented by a tree node whose code is one of
the following: */
of the real and imaginary parts. */
DEFTREECODE (COMPLEX_TYPE, "complex_type", 't', 0)
+/* Vector types. The TREE_TYPE field is the data type of the vector
+ elements. The TYPE_PRECISION field is the number of subparts of
+ the vector. */
+DEFTREECODE (VECTOR_TYPE, "vector_type", 't', 0)
+
/* C enums. The type node looks just like an INTEGER_TYPE node.
The symbols for the values of the enum type are defined by
CONST_DECL nodes, but the type does not point to them;
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. */
/* Value is structure or union component.
- Operand 0 is the structure or union (an expression);
- operand 1 is the field (a node of type FIELD_DECL). */
-DEFTREECODE (COMPONENT_REF, "component_ref", 'r', 2)
+ Operand 0 is the structure or union (an expression).
+ Operand 1 is the field (a node of type FIELD_DECL).
+ Operand 2, if present, is the value of DECL_FIELD_OFFSET, measured
+ in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. */
+DEFTREECODE (COMPONENT_REF, "component_ref", 'r', 3)
/* Reference to a group of bits within an object. Similar to COMPONENT_REF
except the position is given explicitly rather than via a FIELD_DECL.
operand 1 is a tree giving the number of bits being referenced;
operand 2 is a tree giving the position of the first referenced bit.
The field can be either a signed or unsigned field;
- TREE_UNSIGNED says which. */
+ BIT_FIELD_REF_UNSIGNED says which. */
DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", 'r', 3)
-
+
/* C unary `*' or Pascal `^'. One operand, an expression for a pointer. */
DEFTREECODE (INDIRECT_REF, "indirect_ref", 'r', 1)
-/* Pascal `^` on a file. One operand, an expression for the file. */
-DEFTREECODE (BUFFER_REF, "buffer_ref", 'r', 1)
-
-/* Array indexing in languages other than C.
- Operand 0 is the array; operand 1 is a (single) array index. */
-DEFTREECODE (ARRAY_REF, "array_ref", 'r', 2)
+/* Array indexing.
+ Operand 0 is the array; operand 1 is a (single) array index.
+ Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index.
+ Operand 3, if present, is the element size, measured in units of
+ the alignment of the element type. */
+DEFTREECODE (ARRAY_REF, "array_ref", 'r', 4)
+
+/* Likewise, except that the result is a range ("slice") of the array. The
+ starting index of the resulting array is taken from operand 1 and the size
+ of the range is taken from the type of the expression. */
+DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", 'r', 4)
+
+/* Used to represent lookup of runtime type dependent data. Often this is
+ a reference to a vtable, but it needn't be. Operands are:
+ OBJ_TYPE_REF_EXPR: An expression that evaluates the value to use.
+ OBJ_TYPE_REF_OBJECT: Is the object on whose behalf the lookup is
+ being performed. Through this the optimizers may be able to statically
+ determine the dynamic type of the object.
+ OBJ_TYPE_REF_TOKEN: Something front-end specific used to resolve the
+ reference to something simpler, usually to the address of a DECL.
+ Never touched by the middle-end. Good choices would be either an
+ identifier or a vtable index. */
+DEFTREECODE (OBJ_TYPE_REF, "obj_type_ref", 'e', 3)
+
+/* The exception object from the runtime. */
+DEFTREECODE (EXC_PTR_EXPR, "exc_ptr_expr", 'e', 0)
+
+/* The filter object from the runtime. */
+DEFTREECODE (FILTER_EXPR, "filter_expr", 'e', 0)
/* 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.
DEFTREECODE (INIT_EXPR, "init_expr", 'e', 2)
/* For TARGET_EXPR, operand 0 is the target of an initialization,
- operand 1 is the initializer for the target,
- and operand 2 is the cleanup for this node, if any.
- and operand 3 is the saved initializer after this node has been
- expanded once, this is so we can re-expand the tree later. */
+ operand 1 is the initializer for the target, which may be void
+ if simply expanding it initializes the target.
+ operand 2 is the cleanup for this node, if any.
+ operand 3 is the saved initializer after this node has been
+ expanded once; this is so we can re-expand the tree later. */
DEFTREECODE (TARGET_EXPR, "target_expr", 'e', 4)
/* Conditional expression ( ... ? ... : ... in C).
Operand 0 is the condition.
Operand 1 is the then-value.
Operand 2 is the else-value.
- Operand 0 may be of any type, but the types of operands 1 and 2
- must be the same and the same as the type of this expression. */
+ Operand 0 may be of any type.
+ Operand 1 must have the same type as the entire expression, unless
+ it unconditionally throws an exception, in which case it should
+ have VOID_TYPE. The same constraints apply to operand 2. */
DEFTREECODE (COND_EXPR, "cond_expr", 'e', 3)
/* Declare local variables, including making RTL and allocating space.
- Operand 0 is a chain of VAR_DECL nodes for the variables.
- Operand 1 is the body, the expression to be computed using
+ BIND_EXPR_VARS is a chain of VAR_DECL nodes for the variables.
+ BIND_EXPR_BODY is the body, the expression to be computed using
the variables. The value of operand 1 becomes that of the BIND_EXPR.
- Operand 2 is the BLOCK that corresponds to these bindings
+ BIND_EXPR_BLOCK is the BLOCK that corresponds to these bindings
for debugging purposes. If this BIND_EXPR is actually expanded,
that sets the TREE_USED flag in the BLOCK.
The BIND_EXPR is not responsible for informing parsers
about these variables. If the body is coming from the input file,
- then the code that creates the BIND_EXPR is also responsible for
+ then the code that creates the BIND_EXPR is also responsible for
informing the parser of the variables.
If the BIND_EXPR is ever expanded, its TREE_USED flag is set.
This tells the code for debugging symbol tables not to ignore the BIND_EXPR.
- If the BIND_EXPR should be output for debugging but will not be expanded,
+ If the BIND_EXPR should be output for debugging but will not be expanded,
set the TREE_USED flag by hand.
In order for the BIND_EXPR to be known at all, the code that creates it
nodes for the function. */
DEFTREECODE (BIND_EXPR, "bind_expr", 'e', 3)
+/* A labeled block. Operand 0 is the label that will be generated to
+ mark the end of the block.
+ Operand 1 is the labeled block body. */
+DEFTREECODE (LABELED_BLOCK_EXPR, "labeled_block_expr", 'e', 2)
+
/* Function call. Operand 0 is the function.
Operand 1 is the argument list, a list of expressions
made out of a chain of TREE_LIST nodes.
- There is no operand 2. That slot is used for the
- CALL_EXPR_RTL macro (see preexpand_calls). */
+ Operand 2 is the static chain argument, or NULL. */
DEFTREECODE (CALL_EXPR, "call_expr", 'e', 3)
-/* 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 an RTL_EXPR which will eventually represent that value.
- Operand 2 is the cleanup expression for the object.
- The RTL_EXPR is used in this expression, which is how the expression
- manages to act on the proper value.
- The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR, if
- it exists, otherwise it is the responsibility of the caller to manually
- call expand_start_target_temps/expand_end_target_temps, as needed.
-
- This differs from TRY_CATCH_EXPR in that operand 2 is always
- evaluated when an exception isn't thrown when cleanups are run. */
-DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", 'e', 3)
+ Operand 0 is the cleanup expression.
+ The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR,
+ which must exist. This differs from TRY_CATCH_EXPR in that operand 1
+ is always evaluated when cleanups are run. */
+DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", 'e', 1)
/* Specify a cleanup point.
Operand 0 is an expression that may have cleanups. If it does, those
DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1)
/* The following two codes are used in languages that have types where
- the position and/or sizes of fields vary from object to object of the
- same type, i.e., where some other field in the object contains a value
- that is used in the computation of another field's offset or size.
-
- For example, a record type with a discriminant in Ada is such a type.
- This mechanism is also used to create "fat pointers" for unconstrained
- array types in Ada; the fat pointer is a structure one of whose fields is
- a pointer to the actual array type and the other field is a pointer to a
- template, which is a structure containing the bounds of the array. The
- bounds in the type pointed to by the first field in the fat pointer refer
- to the values in the template.
-
- These "self-references" are doing using a PLACEHOLDER_EXPR. This is a
- node that will later be replaced with the object being referenced. Its type
- is that of the object and selects which object to use from a chain of
- references (see below).
-
- When we wish to evaluate a size or offset, we check it is contains a
- placeholder. If it does, we construct a WITH_RECORD_EXPR that contains
- both the expression we wish to evaluate and an expression within which the
- object may be found. The latter expression is the object itself in
- the simple case of an Ada record with discriminant, but it can be the
- array in the case of an unconstrained array.
-
- In the latter case, we need the fat pointer, because the bounds of the
- array can only be accessed from it. However, we rely here on the fact that
- the expression for the array contains the dereference of the fat pointer
- that obtained the array pointer.
-
- Accordingly, when looking for the object to substitute in place of
- a PLACEHOLDER_EXPR, we look down the first operand of the expression
- passed as the second operand to WITH_RECORD_EXPR until we find something
- of the desired type or reach a constant. */
-
-/* Denotes a record to later be supplied with a WITH_RECORD_EXPR when
- evaluating this expression. The type of this expression is used to
- find the record to replace it. */
+ some field in an object of the type contains a value that is used in
+ the computation of another field's offset or size and/or the size of
+ the type. The positions and/or sizes of fields can vary from object
+ to object of the same type or even for one and the same object within
+ its scope.
+
+ Record types with discriminants in Ada or schema types in Pascal are
+ examples of such types. This mechanism is also used to create "fat
+ pointers" for unconstrained array types in Ada; the fat pointer is a
+ structure one of whose fields is a pointer to the actual array type
+ and the other field is a pointer to a template, which is a structure
+ containing the bounds of the array. The bounds in the type pointed
+ to by the first field in the fat pointer refer to the values in the
+ template.
+
+ When you wish to construct such a type you need "self-references"
+ that allow you to reference the object having this type from the
+ TYPE node, i.e. without having a variable instantiating this type.
+
+ Such a "self-references" is done using a PLACEHOLDER_EXPR. This is
+ a node that will later be replaced with the object being referenced.
+ Its type is that of the object and selects which object to use from
+ a chain of references (see below). No other slots are used in the
+ PLACEHOLDER_EXPR.
+
+ For example, if your type FOO is a RECORD_TYPE with a field BAR,
+ and you need the value of <variable>.BAR to calculate TYPE_SIZE
+ (FOO), just substitute <variable> above with a PLACEHOLDER_EXPR
+ whose TREE_TYPE is FOO. Then construct your COMPONENT_REF with
+ the PLACEHOLDER_EXPR as the first operand (which has the correct
+ type). Later, when the size is needed in the program, the back-end
+ will find this PLACEHOLDER_EXPR and generate code to calculate the
+ actual size at run-time. In the following, we describe how this
+ calculation is done.
+
+ When we wish to evaluate a size or offset, we check whether it contains a
+ PLACEHOLDER_EXPR. If it does, we call substitute_placeholder_in_expr
+ passing both that tree and an expression within which the object may be
+ found. The latter expression is the object itself in the simple case of
+ an Ada record with discriminant, but it can be the array in the case of an
+ unconstrained array.
+
+ In the latter case, we need the fat pointer, because the bounds of
+ the array can only be accessed from it. However, we rely here on the
+ fact that the expression for the array contains the dereference of
+ the fat pointer that obtained the array pointer. */
+
+/* Denotes a record to later be substituted before evaluating this expression.
+ The type of this expression is used to find the record to replace it. */
DEFTREECODE (PLACEHOLDER_EXPR, "placeholder_expr", 'x', 0)
-/* Provide an expression that references a record to be used in place
- of a PLACEHOLDER_EXPR. The record to be used is the record within
- operand 1 that has the same type as the PLACEHOLDER_EXPR in
- operand 0. */
-DEFTREECODE (WITH_RECORD_EXPR, "with_record_expr", 'e', 2)
-
/* Simple arithmetic. */
DEFTREECODE (PLUS_EXPR, "plus_expr", '2', 2)
DEFTREECODE (MINUS_EXPR, "minus_expr", '2', 2)
/* Conversion of an integer to a real. */
DEFTREECODE (FLOAT_EXPR, "float_expr", '1', 1)
-/* Exponentiation. Operands may have any types;
- constraints on value type are not known yet. */
-DEFTREECODE (EXPON_EXPR, "expon_expr", '2', 2)
-
/* Unary negation. */
DEFTREECODE (NEGATE_EXPR, "negate_expr", '1', 1)
DEFTREECODE (MIN_EXPR, "min_expr", '2', 2)
DEFTREECODE (MAX_EXPR, "max_expr", '2', 2)
+
+/* Represents the absolute value of the operand.
+
+ An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE. The
+ operand of the ABS_EXPR must have the same type. */
DEFTREECODE (ABS_EXPR, "abs_expr", '1', 1)
-DEFTREECODE (FFS_EXPR, "ffs_expr", '1', 1)
/* Shift operations for shift and rotate.
- Shift is supposed to mean logical shift if done on an
- unsigned type, arithmetic shift on a signed type.
+ Shift means logical shift if done on an
+ unsigned type, arithmetic shift if done on a signed type.
The second operand is the number of bits to
- shift by; it need not be the same type as the first operand and result. */
+ shift by; it need not be the same type as the first operand and result.
+ Note that the result is undefined if the second operand is larger
+ than the first operand's type size. */
DEFTREECODE (LSHIFT_EXPR, "lshift_expr", '2', 2)
DEFTREECODE (RSHIFT_EXPR, "rshift_expr", '2', 2)
DEFTREECODE (LROTATE_EXPR, "lrotate_expr", '2', 2)
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)
-/* Combination of boolean values or of integers considered only
- as zero or nonzero. ANDIF and ORIF allow the second operand
- not to be computed if the value of the expression is determined
- from the first operand. AND, OR, and XOR always compute the second
- operand whether its value is needed or not (for side effects). */
+/* ANDIF and ORIF allow the second operand not to be computed if the
+ value of the expression is determined from the first operand. AND,
+ OR, and XOR always compute the second operand whether its value is
+ 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
+ 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 (TRUTH_ORIF_EXPR, "truth_orif_expr", 'e', 2)
DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr", 'e', 2)
DEFTREECODE (EQ_EXPR, "eq_expr", '<', 2)
DEFTREECODE (NE_EXPR, "ne_expr", '<', 2)
-/* Operations for Pascal sets. Not used now. */
-DEFTREECODE (IN_EXPR, "in_expr", '2', 2)
-DEFTREECODE (SET_LE_EXPR, "set_le_expr", '<', 2)
-DEFTREECODE (CARD_EXPR, "card_expr", '1', 1)
+/* Additional relational operators for floating point unordered. */
+DEFTREECODE (UNORDERED_EXPR, "unordered_expr", '<', 2)
+DEFTREECODE (ORDERED_EXPR, "ordered_expr", '<', 2)
+
+/* These are equivalent to unordered or ... */
+DEFTREECODE (UNLT_EXPR, "unlt_expr", '<', 2)
+DEFTREECODE (UNLE_EXPR, "unle_expr", '<', 2)
+DEFTREECODE (UNGT_EXPR, "ungt_expr", '<', 2)
+DEFTREECODE (UNGE_EXPR, "unge_expr", '<', 2)
+DEFTREECODE (UNEQ_EXPR, "uneq_expr", '<', 2)
+
+/* This is the reverse of uneq_expr. */
+DEFTREECODE (LTGT_EXPR, "ltgt_expr", '<', 2)
+
DEFTREECODE (RANGE_EXPR, "range_expr", '2', 2)
/* Represents a conversion of type of a value.
/* 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", 'r', 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,
- nonzero only after the expression has been computed. */
-DEFTREECODE (SAVE_EXPR, "save_expr", 'e', 3)
-
-/* For a UNSAVE_EXPR, operand 0 is the value to unsave. By unsave, we
- mean that all _EXPRs such as TARGET_EXPRs, SAVE_EXPRs,
- CALL_EXPRs and RTL_EXPRs, that are protected
- from being evaluated more than once should be reset so that a new
- expand_expr call of this expr will cause those to be re-evaluated.
- This is useful when we want to reuse a tree in different places,
- but where we must re-expand. */
-DEFTREECODE (UNSAVE_EXPR, "unsave_expr", 'e', 1)
-
-/* Represents something whose RTL has already been expanded
- as a sequence which should be emitted when this expression is expanded.
- The first operand is the RTL to emit. It is the first of a chain of insns.
- The second is the RTL expression for the result. */
-DEFTREECODE (RTL_EXPR, "rtl_expr", 'e', 2)
+ First operand is that expression. After it is evaluated once, it
+ will be replaced by the temporary variable that holds the value. */
+DEFTREECODE (SAVE_EXPR, "save_expr", 'e', 1)
/* & in C. Value is the address at which the operand's value resides.
Operand may have any mode. Result mode is Pmode. */
DEFTREECODE (ADDR_EXPR, "addr_expr", 'e', 1)
-/* Non-lvalue reference or pointer to an object. */
-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)
/* Used only on an operand of complex type, these return
a value of the corresponding component type. */
-DEFTREECODE (REALPART_EXPR, "realpart_expr", '1', 1)
-DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", '1', 1)
+DEFTREECODE (REALPART_EXPR, "realpart_expr", 'r', 1)
+DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", 'r', 1)
/* Nodes for ++ and -- in C.
The second arg is how much to increment or decrement by.
DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr", 'e', 2)
DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr", 'e', 2)
+/* Used to implement `va_arg'. */
+DEFTREECODE (VA_ARG_EXPR, "va_arg_expr", 'e', 1)
+
/* Evaluate operand 1. If and only if an exception is thrown during
the evaluation of operand 1, evaluate operand 2.
- This differs from WITH_CLEANUP_EXPR, in that operand 2 is never
- evaluated unless an exception is throw. */
-DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr", 'e', 2)
+ This differs from TRY_FINALLY_EXPR in that operand 2 is not evaluated
+ on a normal or jump exit, only on an exception. */
+DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr", 's', 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). */
-DEFTREECODE (TRY_FINALLY_EXPR, "try_finally", 'e', 2)
-
-/* Used internally for cleanups in the implementation of TRY_FINALLY_EXPR.
- (Specifically, it is created by expand_expr, not front-ends.)
- Operand 0 is the rtx for the start of the subroutine we need to call.
- Operand 1 is the rtx for a variable in which to store the address
- of where the subroutine should return to. */
-DEFTREECODE (GOTO_SUBROUTINE_EXPR, "goto_subroutine", 'e', 2)
-
-/* Pop the top element off the dynamic handler chain. Used in
- conjunction with setjmp/longjmp based exception handling, see
- except.c for more details. This is meant to be used only by the
- exception handling backend, expand_dhc_cleanup specifically. */
-DEFTREECODE (POPDHC_EXPR, "popdhc_expr", 's', 0)
-
-/* Pop the top element off the dynamic cleanup chain. Used in
- conjunction with the exception handling. This is meant to be used
- only by the exception handling backend. */
-DEFTREECODE (POPDCC_EXPR, "popdcc_expr", 's', 0)
+ 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", 's', 2)
\f
/* These types of expressions have no useful value,
and always have side effects. */
+/* Used to represent a local declaration. The operand is DECL_EXPR_DECL. */
+DEFTREECODE (DECL_EXPR, "decl_expr", 's', 1)
+
/* A label definition, encapsulated as a statement.
Operand 0 is the LABEL_DECL node for the label that appears here.
The type should be void and the value should be ignored. */
The type should be void and the value should be ignored. */
DEFTREECODE (LOOP_EXPR, "loop_expr", 's', 1)
-/* A labeled block. Operand 0 is the label that will be generated to
- mark the end of the block.
- Operand 1 is the labeled block body. */
-DEFTREECODE (LABELED_BLOCK_EXPR, "labeled_block_expr", 'e', 2)
-
/* Exit a labeled block, possibly returning a value. Operand 0 is a
LABELED_BLOCK_EXPR to exit. Operand 1 is the value to return. It
may be left null. */
-DEFTREECODE (EXIT_BLOCK_EXPR, "exit_block_expr", 'e', 2)
-
-/* Annotates a tree node (usually an expression) with source location
- information: a file name (EXPR_WFL_FILENAME); a line number
- (EXPR_WFL_LINENO); and column number (EXPR_WFL_COLNO). It is
- expanded as the contained node (EXPR_WFL_NODE); a line note should
- be emitted first if EXPR_WFL_EMIT_LINE_NOTE. */
-DEFTREECODE (EXPR_WITH_FILE_LOCATION, "expr_with_file_location", 'e', 2)
+DEFTREECODE (EXIT_BLOCK_EXPR, "exit_block_expr", 's', 2)
/* Switch expression.
+
+ TREE_TYPE is the original type of the condition, before any
+ language required type conversions. It may be NULL, in which case
+ the original type and final types are assumed to be the same.
+
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. */
-DEFTREECODE (SWITCH_EXPR, "switch_expr", 'e', 2)
+ Operand 1 is the body of the switch, which probably contains
+ CASE_LABEL_EXPRs. It may also be NULL, in which case operand 2
+ must not be NULL.
+ Operand 2 is either NULL_TREE or a TREE_VEC of the CASE_LABEL_EXPRs
+ of all the cases. */
+DEFTREECODE (SWITCH_EXPR, "switch_expr", 's', 3)
+
+/* Used to represent a case label. The operands are CASE_LOW and
+ CASE_HIGH, respectively. If CASE_LOW is NULL_TREE, the label is a
+ 'default' label. If CASE_HIGH is NULL_TREE, the label is a normal case
+ label. CASE_LABEL is the corresponding LABEL_DECL. */
+DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr", 's', 3)
+
+/* RESX. Resume execution after an exception. Operand 0 is a
+ number indicating the exception region that is being left. */
+DEFTREECODE (RESX_EXPR, "resx_expr", 's', 1)
+
+/* Used to represent an inline assembly statement. ASM_STRING returns a
+ STRING_CST for the instruction (e.g., "mov x, y"). ASM_OUTPUTS,
+ ASM_INPUTS, and ASM_CLOBBERS represent the outputs, inputs, and clobbers
+ for the statement. */
+DEFTREECODE (ASM_EXPR, "asm_expr", 's', 4)
+
+/* Variable references for SSA analysis. New SSA names are created every
+ time a variable is assigned a new value. The SSA builder uses SSA_NAME
+ nodes to implement SSA versioning. */
+DEFTREECODE (SSA_NAME, "ssa_name", 'x', 0)
+
+/* SSA PHI operator. PHI_RESULT is the new SSA_NAME node created by
+ the PHI node. PHI_ARG_LENGTH is the number of arguments.
+ PHI_ARG_ELT returns the Ith tuple <ssa_name, edge> from the
+ argument list. Each tuple contains the incoming reaching
+ definition (SSA_NAME node) and the edge via which that definition
+ is coming through. */
+DEFTREECODE (PHI_NODE, "phi_node", 'x', 0)
+
+/* Used to represent a typed exception handler. CATCH_TYPES is the type (or
+ list of types) handled, and CATCH_BODY is the code for the handler. */
+DEFTREECODE (CATCH_EXPR, "catch_expr", 's', 2)
+
+/* Used to represent an exception specification. EH_FILTER_TYPES is a list
+ of allowed types, and EH_FILTER_FAILURE is an expression to evaluate on
+ failure. EH_FILTER_MUST_NOT_THROW controls which range type to use when
+ expanding. */
+DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr", 's', 2)
+
+/* Node used for describing a property that is known at compile
+ time. */
+DEFTREECODE (SCEV_KNOWN, "scev_known", 'e', 0)
+
+/* Node used for describing a property that is not known at compile
+ time. */
+DEFTREECODE (SCEV_NOT_KNOWN, "scev_not_known", 'e', 0)
+
+/* Polynomial chains of recurrences.
+ Under the form: cr = {CHREC_LEFT (cr), +, CHREC_RIGHT (cr)}. */
+DEFTREECODE (POLYNOMIAL_CHREC, "polynomial_chrec", 'e', 3)
+
+/* Used to chain children of container statements together.
+ Use the interface in tree-iterator.h to access this node. */
+DEFTREECODE (STATEMENT_LIST, "statement_list", 'x', 0)
+
+/* Value handles. Artificial nodes to represent expressions in
+ partial redundancy elimination (tree-ssa-pre.c). These nodes are
+ used for expression canonicalization. If two expressions compute
+ the same value, they will be assigned the same value handle. */
+DEFTREECODE (VALUE_HANDLE, "value_handle", 'x', 0)
+
+/* Base class information. Holds information about a class as a
+ baseclass of itself or another class. */
+DEFTREECODE (TREE_BINFO, "tree_binfo", 'x', 0)
+
+/* Records the size for an expression of variable size type. This is
+ for use in contexts in which we are accessing the entire object,
+ such as for a function call, or block copy.
+ Operand 0 is the real expression.
+ Operand 1 is the size of the type in the expression. */
+DEFTREECODE (WITH_SIZE_EXPR, "with_size_expr", 'e', 2)
+
/*
Local variables:
mode:c