/* 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, 2000, 2001
+ 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 GCC.
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.
outermost scope of a particular inlining of a function).
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).
+ instance of an inline function).
TREE_ASM_WRITTEN is nonzero if the block was actually referenced
in the generated assembly. */
-DEFTREECODE (BLOCK, "block", 'b', 0)
+DEFTREECODE (BLOCK, "block", 'x', 0)
\f
/* Each data type is represented by a tree node whose code is one of
the following: */
DEFTREECODE (COMPLEX_TYPE, "complex_type", 't', 0)
/* Vector types. The TREE_TYPE field is the data type of the vector
- elements. */
+ 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.
DEFTREECODE (COMPLEX_CST, "complex_cst", 'c', 0)
/* Contents are in TREE_VECTOR_CST_ELTS field. */
-DEFTREECODE (VECTOR_CST, "vector_cst", 'c', 0)
+DEFTREECODE (VECTOR_CST, "vector_cst", 'c', 0)
-/* Contents are TREE_STRING_LENGTH and TREE_STRING_POINTER fields. */
+/* 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 if the given decl has "file scope".
+/* 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,
/* 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.
- Operand 0 is the array; operand 1 is a (single) array index. */
-DEFTREECODE (ARRAY_REF, "array_ref", 'r', 2)
+ 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', 2)
+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)
-/* 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)
+/* 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.
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).
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. */
-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)
+ made out of a chain of TREE_LIST nodes.
+ Operand 2 is the static chain argument, or NULL. */
+DEFTREECODE (CALL_EXPR, "call_expr", 'e', 3)
/* 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 2 is an RTL_EXPR which will eventually represent that value.
- 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
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.
+ 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
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
- what 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.
+ 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.
-
- 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. */
+ the fat pointer that obtained the array pointer. */
-/* 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. */
+/* 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)
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
unsigned type, arithmetic shift if done on a signed type.
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
DEFTREECODE (UNGE_EXPR, "unge_expr", '<', 2)
DEFTREECODE (UNEQ_EXPR, "uneq_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)
+/* 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.
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)
+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. Any
- temporaries created during the building of the RTL_EXPR can be
- reused once the RTL_EXPR has been expanded, with the exception of
- the RTL_EXPR_RTL. */
-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 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
+/* Operand0 is a function constant; result is part N of a function
descriptor of type ptr_mode. */
DEFTREECODE (FDESC_EXPR, "fdesc_expr", 'e', 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.
/* 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 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.
- (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)
+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.
- The third operand is only used in the Java front-end, and will
- eventually be removed. */
-DEFTREECODE (EXPR_WITH_FILE_LOCATION, "expr_with_file_location", 'e', 3)
+DEFTREECODE (EXIT_BLOCK_EXPR, "exit_block_expr", 's', 2)
/* 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. */
-DEFTREECODE (SWITCH_EXPR, "switch_expr", 'e', 2)
-/* The exception object from the runtime. */
-DEFTREECODE (EXC_PTR_EXPR, "exc_ptr_expr", 'e', 0)
+ 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 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:
OSDN Git Service
