/* This file contains the definitions and documentation for the
tree codes used in GCC.
- Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001, 2004
+ Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
You should have received a copy of the GNU General Public License
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. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
/* For tcc_references, tcc_expression, tcc_comparison, tcc_unary,
different structures, and the size is determined by the tree_union
member structure; the 4th element should be zero. Languages that
define language-specific tcc_exceptional or tcc_constant codes must
- define the tree_size langhook to say how big they are. */
+ define the tree_size langhook to say how big they are.
+
+ These tree codes have been sorted so that the macros in tree.h that
+ check for various tree codes are optimized into range checks. This
+ gives a measurable performance improvement. When adding a new
+ code, consider its placement in relation to the other codes. */
/* Any erroneous construct is parsed into a node of this type.
This type of node is accepted without complaint in all contexts
ENUMERAL_TYPE, RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE nodes;
see below. */
-DEFTREECODE (VOID_TYPE, "void_type", tcc_type, 0)
- /* The void type in C */
-
-/* Integer types in all languages, including char in C.
- Also used for sub-ranges of other discrete types.
- Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive)
- and TYPE_PRECISION (number of bits used by this type).
- In the case of a subrange type in Pascal, the TREE_TYPE
- of this will point at the supertype (another INTEGER_TYPE,
- or an ENUMERAL_TYPE, CHAR_TYPE, or BOOLEAN_TYPE).
- Otherwise, the TREE_TYPE is zero. */
-DEFTREECODE (INTEGER_TYPE, "integer_type", tcc_type, 0)
-
-/* C's float and double. Different floating types are distinguished
- by machine mode and by the TYPE_SIZE and the TYPE_PRECISION. */
-DEFTREECODE (REAL_TYPE, "real_type", tcc_type, 0)
-
-/* Complex number types. The TREE_TYPE field is the data type
- of the real and imaginary parts. */
-DEFTREECODE (COMPLEX_TYPE, "complex_type", tcc_type, 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", tcc_type, 0)
+/* The ordering of the following codes is optimized for the checking
+ macros in tree.h. Changing the order will degrade the speed of the
+ compiler. OFFSET_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, CHAR_TYPE,
+ INTEGER_TYPE, REAL_TYPE, POINTER_TYPE. */
+
+/* An offset is a pointer relative to an object.
+ The TREE_TYPE field is the type of the object at the offset.
+ The TYPE_OFFSET_BASETYPE points to the node for the type of object
+ that the offset is relative to. */
+DEFTREECODE (OFFSET_TYPE, "offset_type", tcc_type, 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
treated similarly. */
DEFTREECODE (ENUMERAL_TYPE, "enumeral_type", tcc_type, 0)
-/* Pascal's boolean type (true or false are the only values);
- no special fields needed. */
+/* Boolean type (true or false are the only values). Looks like an
+ INTEGRAL_TYPE. */
DEFTREECODE (BOOLEAN_TYPE, "boolean_type", tcc_type, 0)
-/* CHAR in Pascal; not used in C.
- No special fields needed. */
+/* CHAR in Java; not used in C. Looks like an INTEGRAL_TYPE. */
DEFTREECODE (CHAR_TYPE, "char_type", tcc_type, 0)
+/* Integer types in all languages, including char in C.
+ Also used for sub-ranges of other discrete types.
+ Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive)
+ and TYPE_PRECISION (number of bits used by this type).
+ In the case of a subrange type in Pascal, the TREE_TYPE
+ of this will point at the supertype (another INTEGER_TYPE,
+ or an ENUMERAL_TYPE, CHAR_TYPE, or BOOLEAN_TYPE).
+ Otherwise, the TREE_TYPE is zero. */
+DEFTREECODE (INTEGER_TYPE, "integer_type", tcc_type, 0)
+
+/* C's float and double. Different floating types are distinguished
+ by machine mode and by the TYPE_SIZE and the TYPE_PRECISION. */
+DEFTREECODE (REAL_TYPE, "real_type", tcc_type, 0)
+
+/* The ordering of the following codes is optimized for the checking
+ macros in tree.h. Changing the order will degrade the speed of the
+ compiler. POINTER_TYPE, REFERENCE_TYPE. Note that this range
+ overlaps the previous range of ordered types. */
+
/* All pointer-to-x types have code POINTER_TYPE.
The TREE_TYPE points to the node for the type pointed to. */
DEFTREECODE (POINTER_TYPE, "pointer_type", tcc_type, 0)
-/* An offset is a pointer relative to an object.
- The TREE_TYPE field is the type of the object at the offset.
- The TYPE_OFFSET_BASETYPE points to the node for the type of object
- that the offset is relative to. */
-DEFTREECODE (OFFSET_TYPE, "offset_type", tcc_type, 0)
-
/* A reference is like a pointer except that it is coerced
automatically to the value it points to. Used in C++. */
DEFTREECODE (REFERENCE_TYPE, "reference_type", tcc_type, 0)
-/* METHOD_TYPE is the type of a function which takes an extra first
- argument for "self", which is not present in the declared argument list.
- The TREE_TYPE is the return type of the method. The TYPE_METHOD_BASETYPE
- is the type of "self". TYPE_ARG_TYPES is the real argument list, which
- includes the hidden argument for "self". */
-DEFTREECODE (METHOD_TYPE, "method_type", tcc_type, 0)
+/* The ordering of the following codes is optimized for the checking
+ macros in tree.h. Changing the order will degrade the speed of the
+ compiler. COMPLEX_TYPE, VECTOR_TYPE, ARRAY_TYPE. */
+
+/* Complex number types. The TREE_TYPE field is the data type
+ of the real and imaginary parts. */
+DEFTREECODE (COMPLEX_TYPE, "complex_type", tcc_type, 0)
-/* Used for Pascal; details not determined right now. */
-DEFTREECODE (FILE_TYPE, "file_type", tcc_type, 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", tcc_type, 0)
+/* The ordering of the following codes is optimized for the checking
+ macros in tree.h. Changing the order will degrade the speed of the
+ compiler. ARRAY_TYPE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE.
+ Note that this range overlaps the previous range. */
+
/* Types of arrays. Special fields:
TREE_TYPE Type of an array element.
TYPE_DOMAIN Type to index by.
/* Array types in C or Pascal */
DEFTREECODE (ARRAY_TYPE, "array_type", tcc_type, 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. */
-DEFTREECODE (SET_TYPE, "set_type", tcc_type, 0)
-
/* Struct in C, or record in Pascal. */
/* Special fields:
TYPE_FIELDS chain of FIELD_DECLs for the fields of the struct,
the union. */
DEFTREECODE (QUAL_UNION_TYPE, "qual_union_type", tcc_type, 0)
+/* The ordering of the following codes is optimized for the checking
+ macros in tree.h. Changing the order will degrade the speed of the
+ compiler. VOID_TYPE, FUNCTION_TYPE, METHOD_TYPE. */
+
+/* The void type in C */
+DEFTREECODE (VOID_TYPE, "void_type", tcc_type, 0)
+
/* Type of functions. Special fields:
TREE_TYPE type of value returned.
TYPE_ARG_TYPES list of types of arguments expected.
have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type. */
DEFTREECODE (FUNCTION_TYPE, "function_type", tcc_type, 0)
+/* METHOD_TYPE is the type of a function which takes an extra first
+ argument for "self", which is not present in the declared argument list.
+ The TREE_TYPE is the return type of the method. The TYPE_METHOD_BASETYPE
+ is the type of "self". TYPE_ARG_TYPES is the real argument list, which
+ includes the hidden argument for "self". */
+DEFTREECODE (METHOD_TYPE, "method_type", tcc_type, 0)
+
/* This is a language-specific kind of type.
Its meaning is defined by the language front end.
layout_type does not know how to lay this out,
FUNCTION_DECLs use four special fields:
DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments.
- DECL_RESULT holds a RESULT_DECL node for the value of a function,
- or it is 0 for a function that returns no value.
+ DECL_RESULT holds a RESULT_DECL node for the value of a function.
+ The DECL_RTL field is 0 for a function that returns no value.
(C functions returning void have zero here.)
The TREE_TYPE field is the type in which the result is actually
returned. This is usually the same as the return type of the
DEFTREECODE (FUNCTION_DECL, "function_decl", tcc_declaration, 0)
DEFTREECODE (LABEL_DECL, "label_decl", tcc_declaration, 0)
-DEFTREECODE (CONST_DECL, "const_decl", tcc_declaration, 0)
-DEFTREECODE (TYPE_DECL, "type_decl", tcc_declaration, 0)
+/* The ordering of the following codes is optimized for the checking
+ macros in tree.h. Changing the order will degrade the speed of the
+ compiler. FIELD_DECL, VAR_DECL, CONST_DECL, PARM_DECL,
+ TYPE_DECL. */
+DEFTREECODE (FIELD_DECL, "field_decl", tcc_declaration, 0)
DEFTREECODE (VAR_DECL, "var_decl", tcc_declaration, 0)
+DEFTREECODE (CONST_DECL, "const_decl", tcc_declaration, 0)
DEFTREECODE (PARM_DECL, "parm_decl", tcc_declaration, 0)
+DEFTREECODE (TYPE_DECL, "type_decl", tcc_declaration, 0)
DEFTREECODE (RESULT_DECL, "result_decl", tcc_declaration, 0)
-DEFTREECODE (FIELD_DECL, "field_decl", tcc_declaration, 0)
/* A namespace declaration. Namespaces appear in DECL_CONTEXT of other
_DECLs, providing a hierarchy of names. */
BIT_FIELD_REF_UNSIGNED says which. */
DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", tcc_reference, 3)
+/* The ordering of the following codes is optimized for the checking
+ macros in tree.h. Changing the order will degrade the speed of the
+ compiler. INDIRECT_REF, ALIGN_INDIRECT_REF, MISALIGNED_INDIRECT_REF. */
+
/* C unary `*' or Pascal `^'. One operand, an expression for a pointer. */
DEFTREECODE (INDIRECT_REF, "indirect_ref", tcc_reference, 1)
+/* Like above, but aligns the referenced address (i.e, if the address
+ in P is not aligned on TYPE_ALIGN boundary, then &(*P) != P). */
+DEFTREECODE (ALIGN_INDIRECT_REF, "align_indirect_ref", tcc_reference, 1)
+
+/* Same as INDIRECT_REF, but also specifies the alignment of the referenced
+ address:
+ Operand 0 is the referenced address (a pointer);
+ Operand 1 is an INTEGER_CST which represents the alignment of the address,
+ or 0 if the alignment is unknown. */
+DEFTREECODE (MISALIGNED_INDIRECT_REF, "misaligned_indirect_ref", tcc_reference, 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.
/* 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 operand is a list of component values made out of a chain of
- TREE_LIST nodes.
+ The operand is a sequence of component values made out of a VEC of
+ struct constructor_elt.
For ARRAY_TYPE:
- The TREE_PURPOSE of each node is the corresponding index.
- If the TREE_PURPOSE is a RANGE_EXPR, it is a short-hand for many nodes,
- one for each index in the range. (If the corresponding TREE_VALUE
+ The field INDEX of each constructor_elt is the corresponding index.
+ If the index is a RANGE_EXPR, it is a short-hand for many nodes,
+ one for each index in the range. (If the corresponding field VALUE
has side-effects, they are evaluated once for each element. Wrap the
value in a SAVE_EXPR if you want to evaluate side effects only once.)
For RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE:
- The TREE_PURPOSE of each node is a FIELD_DECL.
-
- For SET_TYPE:
- 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", tcc_expression, 1)
+ The field INDEX of each node is a FIELD_DECL. */
+DEFTREECODE (CONSTRUCTOR, "constructor", tcc_exceptional, 0)
/* The expression types are mostly straightforward, with the fourth argument
of DEFTREECODE saying how many operands there are.
have VOID_TYPE. The same constraints apply to operand 2. */
DEFTREECODE (COND_EXPR, "cond_expr", tcc_expression, 3)
+/* Vector conditional expression. It is like COND_EXPR, but with
+ vector operands.
+
+ A = VEC_COND_EXPR ( X < Y, B, C)
+
+ means
+
+ for (i=0; i<N; i++)
+ A[i] = X[i] < Y[i] ? B[i] : C[i];
+*/
+DEFTREECODE (VEC_COND_EXPR, "vec_cond_expr", tcc_expression, 3)
+
/* 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
nodes for the function. */
DEFTREECODE (BIND_EXPR, "bind_expr", tcc_expression, 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", tcc_expression, 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.
/* Unary negation. */
DEFTREECODE (NEGATE_EXPR, "negate_expr", tcc_unary, 1)
+/* Minimum and maximum values. When used with floating point, if both
+ operands are zeros, or if either operand is NaN, then it is unspecified
+ which of the two operands is returned as the result. */
DEFTREECODE (MIN_EXPR, "min_expr", tcc_binary, 2)
DEFTREECODE (MAX_EXPR, "max_expr", tcc_binary, 2)
The second operand is the number of bits to
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. */
+ than or equal to the first operand's type size. */
DEFTREECODE (LSHIFT_EXPR, "lshift_expr", tcc_binary, 2)
DEFTREECODE (RSHIFT_EXPR, "rshift_expr", tcc_binary, 2)
DEFTREECODE (LROTATE_EXPR, "lrotate_expr", tcc_binary, 2)
The type should be void and the value should be ignored. */
DEFTREECODE (LOOP_EXPR, "loop_expr", tcc_statement, 1)
-/* 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", tcc_statement, 2)
-
/* Switch expression.
TREE_TYPE is the original type of the condition, before any
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. */
+ is coming through. */
DEFTREECODE (PHI_NODE, "phi_node", tcc_exceptional, 0)
/* Used to represent a typed exception handler. CATCH_TYPES is the type (or
the same value, they will be assigned the same value handle. */
DEFTREECODE (VALUE_HANDLE, "value_handle", tcc_exceptional, 0)
+/* Predicate assertion. Artificial expression generated by the optimizers
+ to keep track of predicate values. This expression may only appear on
+ the RHS of assignments.
+
+ Given X = ASSERT_EXPR <Y, EXPR>, the optimizers can infer
+ two things:
+
+ 1- X is a copy of Y.
+ 2- EXPR is a GIMPLE conditional expression (as defined by
+ is_gimple_condexpr) and is known to be true.
+
+ The type of the expression is the same as Y. */
+DEFTREECODE (ASSERT_EXPR, "assert_expr", tcc_expression, 2)
+
/* Base class information. Holds information about a class as a
baseclass of itself or another class. */
DEFTREECODE (TREE_BINFO, "tree_binfo", tcc_exceptional, 0)
Operand 1 is the size of the type in the expression. */
DEFTREECODE (WITH_SIZE_EXPR, "with_size_expr", tcc_expression, 2)
+/* Extract elements from two input vectors Operand 0 and Operand 1
+ size VS, according to the offset OFF defined by Operand 2 as
+ follows:
+ If OFF > 0, the last VS - OFF elements of vector OP0 are concatenated to
+ the first OFF elements of the vector OP1.
+ If OFF == 0, then the returned vector is OP1.
+ On different targets OFF may take different forms; It can be an address, in
+ which case its low log2(VS)-1 bits define the offset, or it can be a mask
+ generated by the builtin targetm.vectorize.mask_for_load_builtin_decl. */
+DEFTREECODE (REALIGN_LOAD_EXPR, "realign_load", tcc_expression, 3)
+
+/* Low-level memory addressing. Operands are SYMBOL (static or global
+ variable), BASE (register), INDEX (register), STEP (integer constant),
+ OFFSET (integer constant). Corresponding address is
+ SYMBOL + BASE + STEP * INDEX + OFFSET. Only variations and values valid on
+ the target are allowed.
+
+ The sixth argument is the reference to the original memory access, which
+ is preserved for the purposes of the RTL alias analysis. The seventh
+ argument is a tag representing results of the tree level alias analysis. */
+
+DEFTREECODE (TARGET_MEM_REF, "target_mem_ref", tcc_reference, 7)
+
+/* Reduction operations.
+ Operations that take a vector of elements and "reduce" it to a scalar
+ result (e.g. summing the elements of the vector, finding the minimum over
+ the vector elements, etc).
+ Operand 0 is a vector; the first element in the vector has the result.
+ Operand 1 is a vector. */
+DEFTREECODE (REDUC_MAX_EXPR, "reduc_max_expr", tcc_unary, 1)
+DEFTREECODE (REDUC_MIN_EXPR, "reduc_min_expr", tcc_unary, 1)
+DEFTREECODE (REDUC_PLUS_EXPR, "reduc_plus_expr", tcc_unary, 1)
+
+/* Whole vector left/right shift in bits.
+ Operand 0 is a vector to be shifted.
+ Operand 1 is an integer shift amount in bits. */
+DEFTREECODE (VEC_LSHIFT_EXPR, "vec_lshift_expr", tcc_binary, 2)
+DEFTREECODE (VEC_RSHIFT_EXPR, "vec_rshift_expr", tcc_binary, 2)
+
/*
Local variables:
mode:c