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.
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", 'x', 0)
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. */
DEFTREECODE (STRING_CST, "string_cst", 'c', 0)
/* 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.
The field can be either a signed or unsigned field;
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)
-
-/* 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)
+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)
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).
/* Declare local variables, including making RTL and allocating space.
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
+ 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.
BIND_EXPR_BLOCK is the BLOCK that corresponds to these bindings
for debugging purposes. If this BIND_EXPR is actually expanded,
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
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
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. The
- third operand is the "alternate RTL expression" for the result, if
- any; if the second argument is the DECL_RTL for a VAR_DECL, but
- with an invalid memory address replaced by a valid one, then the
- third operand will be the original DECL_RTL. 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', 3)
+ 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.
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", 'e', 2)
+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)
+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 (GOTO_EXPR, "goto_expr", 's', 1)
-/* 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", 's', 2)
-
/* RETURN. Evaluates operand 0, then returns from the current function.
Presumably that operand is an assignment that stores into the
RESULT_DECL that hold the value to be returned.
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
+/* 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)
nodes to implement SSA versioning. */
DEFTREECODE (SSA_NAME, "ssa_name", 'x', 0)
-/* Expression SSA real and phi operand occurrence node. */
-DEFTREECODE (EUSE_NODE, "euse_node", 'x', 0)
-
-/* Expression SSA kill occurrence node. */
-DEFTREECODE (EKILL_NODE, "ekill_node", 'x', 0)
-
-/* Expression SSA expression PHI. Like a regular SSA PHI operator,
- but for expressions*/
-DEFTREECODE (EPHI_NODE, "ephi_node", 'x', 0)
-
-/* Expression SSA exit occurrence node. */
-DEFTREECODE (EEXIT_NODE, "eexit_node", '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
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
OSDN Git Service
