1/* This file contains the definitions and documentation for the 2 tree codes used in GCC. 3 Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001, 2004, 2005, 4 2006 Free Software Foundation, Inc. 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to the Free 20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2102110-1301, USA. */ 22 23 24/* For tcc_references, tcc_expression, tcc_comparison, tcc_unary, 25 tcc_binary, and tcc_statement nodes, which use struct tree_exp, the 26 4th element is the number of argument slots to allocate. This 27 determines the size of the tree node object. Other nodes use 28 different structures, and the size is determined by the tree_union 29 member structure; the 4th element should be zero. Languages that 30 define language-specific tcc_exceptional or tcc_constant codes must 31 define the tree_size langhook to say how big they are. 32 33 These tree codes have been sorted so that the macros in tree.h that 34 check for various tree codes are optimized into range checks. This 35 gives a measurable performance improvement. When adding a new 36 code, consider its placement in relation to the other codes. */ 37 38/* Any erroneous construct is parsed into a node of this type. 39 This type of node is accepted without complaint in all contexts 40 by later parsing activities, to avoid multiple error messages 41 for one error. 42 No fields in these nodes are used except the TREE_CODE. */ 43DEFTREECODE (ERROR_MARK, "error_mark", tcc_exceptional, 0) 44 45/* Used to represent a name (such as, in the DECL_NAME of a decl node). 46 Internally it looks like a STRING_CST node. 47 There is only one IDENTIFIER_NODE ever made for any particular name. 48 Use `get_identifier' to get it (or create it, the first time). */ 49DEFTREECODE (IDENTIFIER_NODE, "identifier_node", tcc_exceptional, 0) 50 51/* Has the TREE_VALUE and TREE_PURPOSE fields. */ 52/* These nodes are made into lists by chaining through the 53 TREE_CHAIN field. The elements of the list live in the 54 TREE_VALUE fields, while TREE_PURPOSE fields are occasionally 55 used as well to get the effect of Lisp association lists. */ 56DEFTREECODE (TREE_LIST, "tree_list", tcc_exceptional, 0) 57 58/* These nodes contain an array of tree nodes. */ 59DEFTREECODE (TREE_VEC, "tree_vec", tcc_exceptional, 0) 60 61/* A symbol binding block. These are arranged in a tree, 62 where the BLOCK_SUBBLOCKS field contains a chain of subblocks 63 chained through the BLOCK_CHAIN field. 64 BLOCK_SUPERCONTEXT points to the parent block. 65 For a block which represents the outermost scope of a function, it 66 points to the FUNCTION_DECL node. 67 BLOCK_VARS points to a chain of decl nodes. 68 BLOCK_CHAIN points to the next BLOCK at the same level. 69 BLOCK_ABSTRACT_ORIGIN points to the original (abstract) tree node which 70 this block is an instance of, or else is NULL to indicate that this 71 block is not an instance of anything else. When non-NULL, the value 72 could either point to another BLOCK node or it could point to a 73 FUNCTION_DECL node (e.g. in the case of a block representing the 74 outermost scope of a particular inlining of a function). 75 BLOCK_ABSTRACT is nonzero if the block represents an abstract 76 instance of a block (i.e. one which is nested within an abstract 77 instance of an inline function). 78 TREE_ASM_WRITTEN is nonzero if the block was actually referenced 79 in the generated assembly. */ 80DEFTREECODE (BLOCK, "block", tcc_exceptional, 0) 81 82/* Each data type is represented by a tree node whose code is one of 83 the following: */ 84/* Each node that represents a data type has a component TYPE_SIZE 85 containing a tree that is an expression for the size in bits. 86 The TYPE_MODE contains the machine mode for values of this type. 87 The TYPE_POINTER_TO field contains a type for a pointer to this type, 88 or zero if no such has been created yet. 89 The TYPE_NEXT_VARIANT field is used to chain together types 90 that are variants made by type modifiers such as "const" and "volatile". 91 The TYPE_MAIN_VARIANT field, in any member of such a chain, 92 points to the start of the chain. 93 The TYPE_NONCOPIED_PARTS field is a list specifying which parts 94 of an object of this type should *not* be copied by assignment. 95 The TREE_VALUE of each is a FIELD_DECL that should not be 96 copied. The TREE_PURPOSE is an initial value for that field when 97 an object of this type is initialized via an INIT_EXPR. It may 98 be NULL if no special value is required. Even the things in this 99 list are copied if the right-hand side of an assignment is known 100 to be a complete object (rather than being, perhaps, a subobject 101 of some other object.) The determination of what constitutes a 102 complete object is done by fixed_type_p. 103 The TYPE_NAME field contains info on the name used in the program 104 for this type (for GDB symbol table output). It is either a 105 TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE 106 in the case of structs, unions or enums that are known with a tag, 107 or zero for types that have no special name. 108 The TYPE_CONTEXT for any sort of type which could have a name or 109 which could have named members (e.g. tagged types in C/C++) will 110 point to the node which represents the scope of the given type, or 111 will be NULL_TREE if the type has "file scope". For most types, this 112 will point to a BLOCK node or a FUNCTION_DECL node, but it could also 113 point to a FUNCTION_TYPE node (for types whose scope is limited to the 114 formal parameter list of some function type specification) or it 115 could point to a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE node 116 (for C++ "member" types). 117 For non-tagged-types, TYPE_CONTEXT need not be set to anything in 118 particular, since any type which is of some type category (e.g. 119 an array type or a function type) which cannot either have a name 120 itself or have named members doesn't really have a "scope" per se. 121 The TREE_CHAIN field is used as a forward-references to names for 122 ENUMERAL_TYPE, RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE nodes; 123 see below. */ 124 125/* The ordering of the following codes is optimized for the checking 126 macros in tree.h. Changing the order will degrade the speed of the 127 compiler. OFFSET_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE, 128 REAL_TYPE, POINTER_TYPE. */ 129 130/* An offset is a pointer relative to an object. 131 The TREE_TYPE field is the type of the object at the offset. 132 The TYPE_OFFSET_BASETYPE points to the node for the type of object 133 that the offset is relative to. */ 134DEFTREECODE (OFFSET_TYPE, "offset_type", tcc_type, 0) 135 136/* C enums. The type node looks just like an INTEGER_TYPE node. 137 The symbols for the values of the enum type are defined by 138 CONST_DECL nodes, but the type does not point to them; 139 however, the TYPE_VALUES is a list in which each element's TREE_PURPOSE 140 is a name and the TREE_VALUE is the value (an INTEGER_CST node). */ 141/* A forward reference `enum foo' when no enum named foo is defined yet 142 has zero (a null pointer) in its TYPE_SIZE. The tag name is in 143 the TYPE_NAME field. If the type is later defined, the normal 144 fields are filled in. 145 RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE forward refs are 146 treated similarly. */ 147DEFTREECODE (ENUMERAL_TYPE, "enumeral_type", tcc_type, 0) 148 149/* Boolean type (true or false are the only values). Looks like an 150 INTEGRAL_TYPE. */ 151DEFTREECODE (BOOLEAN_TYPE, "boolean_type", tcc_type, 0) 152 153/* Integer types in all languages, including char in C. 154 Also used for sub-ranges of other discrete types. 155 Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive) 156 and TYPE_PRECISION (number of bits used by this type). 157 In the case of a subrange type in Pascal, the TREE_TYPE 158 of this will point at the supertype (another INTEGER_TYPE, 159 or an ENUMERAL_TYPE or BOOLEAN_TYPE). 160 Otherwise, the TREE_TYPE is zero. */ 161DEFTREECODE (INTEGER_TYPE, "integer_type", tcc_type, 0) 162 163/* C's float and double. Different floating types are distinguished 164 by machine mode and by the TYPE_SIZE and the TYPE_PRECISION. */ 165DEFTREECODE (REAL_TYPE, "real_type", tcc_type, 0) 166 167/* The ordering of the following codes is optimized for the checking 168 macros in tree.h. Changing the order will degrade the speed of the 169 compiler. POINTER_TYPE, REFERENCE_TYPE. Note that this range 170 overlaps the previous range of ordered types. */ 171 172/* All pointer-to-x types have code POINTER_TYPE. 173 The TREE_TYPE points to the node for the type pointed to. */ 174DEFTREECODE (POINTER_TYPE, "pointer_type", tcc_type, 0) 175 176/* A reference is like a pointer except that it is coerced 177 automatically to the value it points to. Used in C++. */ 178DEFTREECODE (REFERENCE_TYPE, "reference_type", tcc_type, 0) 179 180/* The ordering of the following codes is optimized for the checking 181 macros in tree.h. Changing the order will degrade the speed of the 182 compiler. COMPLEX_TYPE, VECTOR_TYPE, ARRAY_TYPE. */ 183 184/* Complex number types. The TREE_TYPE field is the data type 185 of the real and imaginary parts. */ 186DEFTREECODE (COMPLEX_TYPE, "complex_type", tcc_type, 0) 187 188/* Vector types. The TREE_TYPE field is the data type of the vector 189 elements. The TYPE_PRECISION field is the number of subparts of 190 the vector. */ 191DEFTREECODE (VECTOR_TYPE, "vector_type", tcc_type, 0) 192 193/* The ordering of the following codes is optimized for the checking 194 macros in tree.h. Changing the order will degrade the speed of the 195 compiler. ARRAY_TYPE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE. 196 Note that this range overlaps the previous range. */ 197 198/* Types of arrays. Special fields: 199 TREE_TYPE Type of an array element. 200 TYPE_DOMAIN Type to index by. 201 Its range of values specifies the array length. 202 The field TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero 203 and holds the type to coerce a value of that array type to in C. 204 TYPE_STRING_FLAG indicates a string (in contrast to an array of chars) 205 in languages (such as Chill) that make a distinction. */ 206/* Array types in C or Pascal */ 207DEFTREECODE (ARRAY_TYPE, "array_type", tcc_type, 0) 208 209/* Struct in C, or record in Pascal. */ 210/* Special fields: 211 TYPE_FIELDS chain of FIELD_DECLs for the fields of the struct, 212 and VAR_DECLs, TYPE_DECLs and CONST_DECLs for record-scope variables, 213 types and enumerators. 214 A few may need to be added for Pascal. */ 215/* See the comment above, before ENUMERAL_TYPE, for how 216 forward references to struct tags are handled in C. */ 217DEFTREECODE (RECORD_TYPE, "record_type", tcc_type, 0) 218 219/* Union in C. Like a struct, except that the offsets of the fields 220 will all be zero. */ 221/* See the comment above, before ENUMERAL_TYPE, for how 222 forward references to union tags are handled in C. */ 223DEFTREECODE (UNION_TYPE, "union_type", tcc_type, 0) /* C union type */ 224 225/* Similar to UNION_TYPE, except that the expressions in DECL_QUALIFIER 226 in each FIELD_DECL determine what the union contains. The first 227 field whose DECL_QUALIFIER expression is true is deemed to occupy 228 the union. */ 229DEFTREECODE (QUAL_UNION_TYPE, "qual_union_type", tcc_type, 0) 230 231/* The ordering of the following codes is optimized for the checking 232 macros in tree.h. Changing the order will degrade the speed of the 233 compiler. VOID_TYPE, FUNCTION_TYPE, METHOD_TYPE. */ 234 235/* The void type in C */ 236DEFTREECODE (VOID_TYPE, "void_type", tcc_type, 0) 237 238/* Type of functions. Special fields: 239 TREE_TYPE type of value returned. 240 TYPE_ARG_TYPES list of types of arguments expected. 241 this list is made of TREE_LIST nodes. 242 Types of "Procedures" in languages where they are different from functions 243 have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type. */ 244DEFTREECODE (FUNCTION_TYPE, "function_type", tcc_type, 0) 245 246/* METHOD_TYPE is the type of a function which takes an extra first 247 argument for "self", which is not present in the declared argument list. 248 The TREE_TYPE is the return type of the method. The TYPE_METHOD_BASETYPE 249 is the type of "self". TYPE_ARG_TYPES is the real argument list, which 250 includes the hidden argument for "self". */ 251DEFTREECODE (METHOD_TYPE, "method_type", tcc_type, 0) 252 253/* This is a language-specific kind of type. 254 Its meaning is defined by the language front end. 255 layout_type does not know how to lay this out, 256 so the front-end must do so manually. */ 257DEFTREECODE (LANG_TYPE, "lang_type", tcc_type, 0) 258 259/* Expressions */ 260 261/* First, the constants. */ 262 263/* Contents are in TREE_INT_CST_LOW and TREE_INT_CST_HIGH fields, 264 32 bits each, giving us a 64 bit constant capability. INTEGER_CST 265 nodes can be shared, and therefore should be considered read only. 266 They should be copied, before setting a flag such as 267 TREE_OVERFLOW. If an INTEGER_CST has TREE_OVERFLOW or 268 TREE_CONSTANT_OVERFLOW already set, it is known to be unique. 269 INTEGER_CST nodes are created for the integral types, for pointer 270 types and for vector and float types in some circumstances. */ 271DEFTREECODE (INTEGER_CST, "integer_cst", tcc_constant, 0) 272 273/* Contents are in TREE_REAL_CST field. */ 274DEFTREECODE (REAL_CST, "real_cst", tcc_constant, 0) 275 276/* Contents are in TREE_REALPART and TREE_IMAGPART fields, 277 whose contents are other constant nodes. */ 278DEFTREECODE (COMPLEX_CST, "complex_cst", tcc_constant, 0) 279 280/* Contents are in TREE_VECTOR_CST_ELTS field. */ 281DEFTREECODE (VECTOR_CST, "vector_cst", tcc_constant, 0) 282 283/* Contents are TREE_STRING_LENGTH and the actual contents of the string. */ 284DEFTREECODE (STRING_CST, "string_cst", tcc_constant, 0) 285 286/* Declarations. All references to names are represented as ..._DECL 287 nodes. The decls in one binding context are chained through the 288 TREE_CHAIN field. Each DECL has a DECL_NAME field which contains 289 an IDENTIFIER_NODE. (Some decls, most often labels, may have zero 290 as the DECL_NAME). DECL_CONTEXT points to the node representing 291 the context in which this declaration has its scope. For 292 FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or 293 QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL, 294 PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this 295 points to either the FUNCTION_DECL for the containing function, the 296 RECORD_TYPE or UNION_TYPE for the containing type, or NULL_TREE or 297 a TRANSLATION_UNIT_DECL if the given decl has "file scope". 298 DECL_ABSTRACT_ORIGIN, if non-NULL, points to the original (abstract) 299 ..._DECL node of which this decl is an (inlined or template expanded) 300 instance. 301 The TREE_TYPE field holds the data type of the object, when relevant. 302 LABEL_DECLs have no data type. For TYPE_DECL, the TREE_TYPE field 303 contents are the type whose name is being declared. 304 The DECL_ALIGN, DECL_SIZE, 305 and DECL_MODE fields exist in decl nodes just as in type nodes. 306 They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes. 307 308 DECL_FIELD_BIT_OFFSET holds an integer number of bits offset for 309 the location. DECL_VOFFSET holds an expression for a variable 310 offset; it is to be multiplied by DECL_VOFFSET_UNIT (an integer). 311 These fields are relevant only in FIELD_DECLs and PARM_DECLs. 312 313 DECL_INITIAL holds the value to initialize a variable to, 314 or the value of a constant. For a function, it holds the body 315 (a node of type BLOCK representing the function's binding contour 316 and whose body contains the function's statements.) For a LABEL_DECL 317 in C, it is a flag, nonzero if the label's definition has been seen. 318 319 PARM_DECLs use a special field: 320 DECL_ARG_TYPE is the type in which the argument is actually 321 passed, which may be different from its type within the function. 322 323 FUNCTION_DECLs use four special fields: 324 DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments. 325 DECL_RESULT holds a RESULT_DECL node for the value of a function. 326 The DECL_RTL field is 0 for a function that returns no value. 327 (C functions returning void have zero here.) 328 The TREE_TYPE field is the type in which the result is actually 329 returned. This is usually the same as the return type of the 330 FUNCTION_DECL, but it may be a wider integer type because of 331 promotion. 332 DECL_FUNCTION_CODE is a code number that is nonzero for 333 built-in functions. Its value is an enum built_in_function 334 that says which built-in function it is. 335 336 DECL_SOURCE_FILE holds a filename string and DECL_SOURCE_LINE 337 holds a line number. In some cases these can be the location of 338 a reference, if no definition has been seen. 339 340 DECL_ABSTRACT is nonzero if the decl represents an abstract instance 341 of a decl (i.e. one which is nested within an abstract instance of a 342 inline function. */ 343 344DEFTREECODE (FUNCTION_DECL, "function_decl", tcc_declaration, 0) 345DEFTREECODE (LABEL_DECL, "label_decl", tcc_declaration, 0) 346/* The ordering of the following codes is optimized for the checking 347 macros in tree.h. Changing the order will degrade the speed of the 348 compiler. FIELD_DECL, VAR_DECL, CONST_DECL, PARM_DECL, 349 TYPE_DECL. */ 350DEFTREECODE (FIELD_DECL, "field_decl", tcc_declaration, 0) 351DEFTREECODE (VAR_DECL, "var_decl", tcc_declaration, 0) 352DEFTREECODE (CONST_DECL, "const_decl", tcc_declaration, 0) 353DEFTREECODE (PARM_DECL, "parm_decl", tcc_declaration, 0) 354DEFTREECODE (TYPE_DECL, "type_decl", tcc_declaration, 0) 355DEFTREECODE (RESULT_DECL, "result_decl", tcc_declaration, 0) 356 357/* Memory tags used in tree-ssa to represent memory locations in 358 virtual SSA. */ 359DEFTREECODE (STRUCT_FIELD_TAG, "struct_field_tag", tcc_declaration, 0) 360DEFTREECODE (NAME_MEMORY_TAG, "name_memory_tag", tcc_declaration, 0) 361DEFTREECODE (SYMBOL_MEMORY_TAG, "symbol_memory_tag", tcc_declaration, 0) 362 363/* A namespace declaration. Namespaces appear in DECL_CONTEXT of other 364 _DECLs, providing a hierarchy of names. */ 365DEFTREECODE (NAMESPACE_DECL, "namespace_decl", tcc_declaration, 0) 366 367/* A translation unit. This is not technically a declaration, since it 368 can't be looked up, but it's close enough. */ 369DEFTREECODE (TRANSLATION_UNIT_DECL, "translation_unit_decl",\ 370 tcc_declaration, 0) 371 372/* References to storage. */ 373 374/* Value is structure or union component. 375 Operand 0 is the structure or union (an expression). 376 Operand 1 is the field (a node of type FIELD_DECL). 377 Operand 2, if present, is the value of DECL_FIELD_OFFSET, measured 378 in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. */ 379DEFTREECODE (COMPONENT_REF, "component_ref", tcc_reference, 3) 380 381/* Reference to a group of bits within an object. Similar to COMPONENT_REF 382 except the position is given explicitly rather than via a FIELD_DECL. 383 Operand 0 is the structure or union expression; 384 operand 1 is a tree giving the number of bits being referenced; 385 operand 2 is a tree giving the position of the first referenced bit. 386 The field can be either a signed or unsigned field; 387 BIT_FIELD_REF_UNSIGNED says which. */ 388DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", tcc_reference, 3) 389 390/* The ordering of the following codes is optimized for the checking 391 macros in tree.h. Changing the order will degrade the speed of the 392 compiler. INDIRECT_REF, ALIGN_INDIRECT_REF, MISALIGNED_INDIRECT_REF. */ 393 394/* C unary `*' or Pascal `^'. One operand, an expression for a pointer. */ 395DEFTREECODE (INDIRECT_REF, "indirect_ref", tcc_reference, 1) 396 397/* Like above, but aligns the referenced address (i.e, if the address 398 in P is not aligned on TYPE_ALIGN boundary, then &(*P) != P). */ 399DEFTREECODE (ALIGN_INDIRECT_REF, "align_indirect_ref", tcc_reference, 1) 400 401/* Same as INDIRECT_REF, but also specifies the alignment of the referenced 402 address: 403 Operand 0 is the referenced address (a pointer); 404 Operand 1 is an INTEGER_CST which represents the alignment of the address, 405 or 0 if the alignment is unknown. */ 406DEFTREECODE (MISALIGNED_INDIRECT_REF, "misaligned_indirect_ref", tcc_reference, 2) 407 408/* Array indexing. 409 Operand 0 is the array; operand 1 is a (single) array index. 410 Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index. 411 Operand 3, if present, is the element size, measured in units of 412 the alignment of the element type. */ 413DEFTREECODE (ARRAY_REF, "array_ref", tcc_reference, 4) 414 415/* Likewise, except that the result is a range ("slice") of the array. The 416 starting index of the resulting array is taken from operand 1 and the size 417 of the range is taken from the type of the expression. */ 418DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", tcc_reference, 4) 419 420/* Used to represent lookup of runtime type dependent data. Often this is 421 a reference to a vtable, but it needn't be. Operands are: 422 OBJ_TYPE_REF_EXPR: An expression that evaluates the value to use. 423 OBJ_TYPE_REF_OBJECT: Is the object on whose behalf the lookup is 424 being performed. Through this the optimizers may be able to statically 425 determine the dynamic type of the object. 426 OBJ_TYPE_REF_TOKEN: Something front-end specific used to resolve the 427 reference to something simpler, usually to the address of a DECL. 428 Never touched by the middle-end. Good choices would be either an 429 identifier or a vtable index. */ 430DEFTREECODE (OBJ_TYPE_REF, "obj_type_ref", tcc_expression, 3) 431 432/* The exception object from the runtime. */ 433DEFTREECODE (EXC_PTR_EXPR, "exc_ptr_expr", tcc_expression, 0) 434 435/* The filter object from the runtime. */ 436DEFTREECODE (FILTER_EXPR, "filter_expr", tcc_expression, 0) 437 438/* Constructor: return an aggregate value made from specified components. 439 In C, this is used only for structure and array initializers. 440 The operand is a sequence of component values made out of a VEC of 441 struct constructor_elt. 442 443 For ARRAY_TYPE: 444 The field INDEX of each constructor_elt is the corresponding index. 445 If the index is a RANGE_EXPR, it is a short-hand for many nodes, 446 one for each index in the range. (If the corresponding field VALUE 447 has side-effects, they are evaluated once for each element. Wrap the 448 value in a SAVE_EXPR if you want to evaluate side effects only once.) 449 450 For RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE: 451 The field INDEX of each node is a FIELD_DECL. */ 452DEFTREECODE (CONSTRUCTOR, "constructor", tcc_exceptional, 0) 453 454/* The expression types are mostly straightforward, with the fourth argument 455 of DEFTREECODE saying how many operands there are. 456 Unless otherwise specified, the operands are expressions and the 457 types of all the operands and the expression must all be the same. */ 458 459/* Contains two expressions to compute, one followed by the other. 460 the first value is ignored. The second one's value is used. The 461 type of the first expression need not agree with the other types. */ 462DEFTREECODE (COMPOUND_EXPR, "compound_expr", tcc_expression, 2) 463 464/* Assignment expression. Operand 0 is the what to set; 1, the new value. */ 465DEFTREECODE (MODIFY_EXPR, "modify_expr", tcc_expression, 2) 466 467/* Initialization expression. Operand 0 is the variable to initialize; 468 Operand 1 is the initializer. This differs from MODIFY_EXPR in that any 469 reference to the referent of operand 0 within operand 1 is undefined. */ 470DEFTREECODE (INIT_EXPR, "init_expr", tcc_expression, 2) 471 472/* For TARGET_EXPR, operand 0 is the target of an initialization, 473 operand 1 is the initializer for the target, which may be void 474 if simply expanding it initializes the target. 475 operand 2 is the cleanup for this node, if any. 476 operand 3 is the saved initializer after this node has been 477 expanded once; this is so we can re-expand the tree later. */ 478DEFTREECODE (TARGET_EXPR, "target_expr", tcc_expression, 4) 479 480/* Conditional expression ( ... ? ... : ... in C). 481 Operand 0 is the condition. 482 Operand 1 is the then-value. 483 Operand 2 is the else-value. 484 Operand 0 may be of any type. 485 Operand 1 must have the same type as the entire expression, unless 486 it unconditionally throws an exception, in which case it should 487 have VOID_TYPE. The same constraints apply to operand 2. */ 488DEFTREECODE (COND_EXPR, "cond_expr", tcc_expression, 3) 489 490/* Vector conditional expression. It is like COND_EXPR, but with 491 vector operands. 492 493 A = VEC_COND_EXPR ( X < Y, B, C) 494 495 means 496 497 for (i=0; i<N; i++) 498 A[i] = X[i] < Y[i] ? B[i] : C[i]; 499*/ 500DEFTREECODE (VEC_COND_EXPR, "vec_cond_expr", tcc_expression, 3) 501 502/* Declare local variables, including making RTL and allocating space. 503 BIND_EXPR_VARS is a chain of VAR_DECL nodes for the variables. 504 BIND_EXPR_BODY is the body, the expression to be computed using 505 the variables. The value of operand 1 becomes that of the BIND_EXPR. 506 BIND_EXPR_BLOCK is the BLOCK that corresponds to these bindings 507 for debugging purposes. If this BIND_EXPR is actually expanded, 508 that sets the TREE_USED flag in the BLOCK. 509 510 The BIND_EXPR is not responsible for informing parsers 511 about these variables. If the body is coming from the input file, 512 then the code that creates the BIND_EXPR is also responsible for 513 informing the parser of the variables. 514 515 If the BIND_EXPR is ever expanded, its TREE_USED flag is set. 516 This tells the code for debugging symbol tables not to ignore the BIND_EXPR. 517 If the BIND_EXPR should be output for debugging but will not be expanded, 518 set the TREE_USED flag by hand. 519 520 In order for the BIND_EXPR to be known at all, the code that creates it 521 must also install it as a subblock in the tree of BLOCK 522 nodes for the function. */ 523DEFTREECODE (BIND_EXPR, "bind_expr", tcc_expression, 3) 524 525/* Function call. Operand 0 is the function. 526 Operand 1 is the argument list, a list of expressions 527 made out of a chain of TREE_LIST nodes. 528 Operand 2 is the static chain argument, or NULL. */ 529DEFTREECODE (CALL_EXPR, "call_expr", tcc_expression, 3) 530 531/* Specify a value to compute along with its corresponding cleanup. 532 Operand 0 is the cleanup expression. 533 The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR, 534 which must exist. This differs from TRY_CATCH_EXPR in that operand 1 535 is always evaluated when cleanups are run. */ 536DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", tcc_expression, 1) 537 538/* Specify a cleanup point. 539 Operand 0 is an expression that may have cleanups. If it does, those 540 cleanups are executed after the expression is expanded. 541 542 Note that if the expression is a reference to storage, it is forced out 543 of memory before the cleanups are run. This is necessary to handle 544 cases where the cleanups modify the storage referenced; in the 545 expression 't.i', if 't' is a struct with an integer member 'i' and a 546 cleanup which modifies 'i', the value of the expression depends on 547 whether the cleanup is run before or after 't.i' is evaluated. When 548 expand_expr is run on 't.i', it returns a MEM. This is not good enough; 549 the value of 't.i' must be forced out of memory. 550 551 As a consequence, the operand of a CLEANUP_POINT_EXPR must not have 552 BLKmode, because it will not be forced out of memory. */ 553DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", tcc_expression, 1) 554 555/* The following two codes are used in languages that have types where 556 some field in an object of the type contains a value that is used in 557 the computation of another field's offset or size and/or the size of 558 the type. The positions and/or sizes of fields can vary from object 559 to object of the same type or even for one and the same object within 560 its scope. 561 562 Record types with discriminants in Ada or schema types in Pascal are 563 examples of such types. This mechanism is also used to create "fat 564 pointers" for unconstrained array types in Ada; the fat pointer is a 565 structure one of whose fields is a pointer to the actual array type 566 and the other field is a pointer to a template, which is a structure 567 containing the bounds of the array. The bounds in the type pointed 568 to by the first field in the fat pointer refer to the values in the 569 template. 570 571 When you wish to construct such a type you need "self-references" 572 that allow you to reference the object having this type from the 573 TYPE node, i.e. without having a variable instantiating this type. 574 575 Such a "self-references" is done using a PLACEHOLDER_EXPR. This is 576 a node that will later be replaced with the object being referenced. 577 Its type is that of the object and selects which object to use from 578 a chain of references (see below). No other slots are used in the 579 PLACEHOLDER_EXPR. 580 581 For example, if your type FOO is a RECORD_TYPE with a field BAR, 582 and you need the value of <variable>.BAR to calculate TYPE_SIZE 583 (FOO), just substitute <variable> above with a PLACEHOLDER_EXPR 584 whose TREE_TYPE is FOO. Then construct your COMPONENT_REF with 585 the PLACEHOLDER_EXPR as the first operand (which has the correct 586 type). Later, when the size is needed in the program, the back-end 587 will find this PLACEHOLDER_EXPR and generate code to calculate the 588 actual size at run-time. In the following, we describe how this 589 calculation is done. 590 591 When we wish to evaluate a size or offset, we check whether it contains a 592 PLACEHOLDER_EXPR. If it does, we call substitute_placeholder_in_expr 593 passing both that tree and an expression within which the object may be 594 found. The latter expression is the object itself in the simple case of 595 an Ada record with discriminant, but it can be the array in the case of an 596 unconstrained array. 597 598 In the latter case, we need the fat pointer, because the bounds of 599 the array can only be accessed from it. However, we rely here on the 600 fact that the expression for the array contains the dereference of 601 the fat pointer that obtained the array pointer. */ 602 603/* Denotes a record to later be substituted before evaluating this expression. 604 The type of this expression is used to find the record to replace it. */ 605DEFTREECODE (PLACEHOLDER_EXPR, "placeholder_expr", tcc_exceptional, 0) 606 607/* Simple arithmetic. */ 608DEFTREECODE (PLUS_EXPR, "plus_expr", tcc_binary, 2) 609DEFTREECODE (MINUS_EXPR, "minus_expr", tcc_binary, 2) 610DEFTREECODE (MULT_EXPR, "mult_expr", tcc_binary, 2) 611 612/* Division for integer result that rounds the quotient toward zero. */ 613DEFTREECODE (TRUNC_DIV_EXPR, "trunc_div_expr", tcc_binary, 2) 614 615/* Division for integer result that rounds the quotient toward infinity. */ 616DEFTREECODE (CEIL_DIV_EXPR, "ceil_div_expr", tcc_binary, 2) 617 618/* Division for integer result that rounds toward minus infinity. */ 619DEFTREECODE (FLOOR_DIV_EXPR, "floor_div_expr", tcc_binary, 2) 620 621/* Division for integer result that rounds toward nearest integer. */ 622DEFTREECODE (ROUND_DIV_EXPR, "round_div_expr", tcc_binary, 2) 623 624/* Four kinds of remainder that go with the four kinds of division. */ 625DEFTREECODE (TRUNC_MOD_EXPR, "trunc_mod_expr", tcc_binary, 2) 626DEFTREECODE (CEIL_MOD_EXPR, "ceil_mod_expr", tcc_binary, 2) 627DEFTREECODE (FLOOR_MOD_EXPR, "floor_mod_expr", tcc_binary, 2) 628DEFTREECODE (ROUND_MOD_EXPR, "round_mod_expr", tcc_binary, 2) 629 630/* Division for real result. */ 631DEFTREECODE (RDIV_EXPR, "rdiv_expr", tcc_binary, 2) 632 633/* Division which is not supposed to need rounding. 634 Used for pointer subtraction in C. */ 635DEFTREECODE (EXACT_DIV_EXPR, "exact_div_expr", tcc_binary, 2) 636 637/* Conversion of real to fixed point: four ways to round, 638 like the four ways to divide. 639 CONVERT_EXPR can also be used to convert a real to an integer, 640 and that is what is used in languages that do not have ways of 641 specifying which of these is wanted. Maybe these are not needed. */ 642DEFTREECODE (FIX_TRUNC_EXPR, "fix_trunc_expr", tcc_unary, 1) 643DEFTREECODE (FIX_CEIL_EXPR, "fix_ceil_expr", tcc_unary, 1) 644DEFTREECODE (FIX_FLOOR_EXPR, "fix_floor_expr", tcc_unary, 1) 645DEFTREECODE (FIX_ROUND_EXPR, "fix_round_expr", tcc_unary, 1) 646 647/* Conversion of an integer to a real. */ 648DEFTREECODE (FLOAT_EXPR, "float_expr", tcc_unary, 1) 649 650/* Unary negation. */ 651DEFTREECODE (NEGATE_EXPR, "negate_expr", tcc_unary, 1) 652 653/* Minimum and maximum values. When used with floating point, if both 654 operands are zeros, or if either operand is NaN, then it is unspecified 655 which of the two operands is returned as the result. */ 656DEFTREECODE (MIN_EXPR, "min_expr", tcc_binary, 2) 657DEFTREECODE (MAX_EXPR, "max_expr", tcc_binary, 2) 658 659/* Represents the absolute value of the operand. 660 661 An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE. The 662 operand of the ABS_EXPR must have the same type. */ 663DEFTREECODE (ABS_EXPR, "abs_expr", tcc_unary, 1) 664 665/* Shift operations for shift and rotate. 666 Shift means logical shift if done on an 667 unsigned type, arithmetic shift if done on a signed type. 668 The second operand is the number of bits to 669 shift by; it need not be the same type as the first operand and result. 670 Note that the result is undefined if the second operand is larger 671 than or equal to the first operand's type size. */ 672DEFTREECODE (LSHIFT_EXPR, "lshift_expr", tcc_binary, 2) 673DEFTREECODE (RSHIFT_EXPR, "rshift_expr", tcc_binary, 2) 674DEFTREECODE (LROTATE_EXPR, "lrotate_expr", tcc_binary, 2) 675DEFTREECODE (RROTATE_EXPR, "rrotate_expr", tcc_binary, 2) 676 677/* Bitwise operations. Operands have same mode as result. */ 678DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr", tcc_binary, 2) 679DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr", tcc_binary, 2) 680DEFTREECODE (BIT_AND_EXPR, "bit_and_expr", tcc_binary, 2) 681DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", tcc_unary, 1) 682 683/* ANDIF and ORIF allow the second operand not to be computed if the 684 value of the expression is determined from the first operand. AND, 685 OR, and XOR always compute the second operand whether its value is 686 needed or not (for side effects). The operand may have 687 BOOLEAN_TYPE or INTEGER_TYPE. In either case, the argument will be 688 either zero or one. For example, a TRUTH_NOT_EXPR will never have 689 an INTEGER_TYPE VAR_DECL as its argument; instead, a NE_EXPR will be 690 used to compare the VAR_DECL to zero, thereby obtaining a node with 691 value zero or one. */ 692DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr", tcc_expression, 2) 693DEFTREECODE (TRUTH_ORIF_EXPR, "truth_orif_expr", tcc_expression, 2) 694DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr", tcc_expression, 2) 695DEFTREECODE (TRUTH_OR_EXPR, "truth_or_expr", tcc_expression, 2) 696DEFTREECODE (TRUTH_XOR_EXPR, "truth_xor_expr", tcc_expression, 2) 697DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr", tcc_expression, 1) 698 699/* Relational operators. 700 `EQ_EXPR' and `NE_EXPR' are allowed for any types. 701 The others are allowed only for integer (or pointer or enumeral) 702 or real types. 703 In all cases the operands will have the same type, 704 and the value is always the type used by the language for booleans. */ 705DEFTREECODE (LT_EXPR, "lt_expr", tcc_comparison, 2) 706DEFTREECODE (LE_EXPR, "le_expr", tcc_comparison, 2) 707DEFTREECODE (GT_EXPR, "gt_expr", tcc_comparison, 2) 708DEFTREECODE (GE_EXPR, "ge_expr", tcc_comparison, 2) 709DEFTREECODE (EQ_EXPR, "eq_expr", tcc_comparison, 2) 710DEFTREECODE (NE_EXPR, "ne_expr", tcc_comparison, 2) 711 712/* Additional relational operators for floating point unordered. */ 713DEFTREECODE (UNORDERED_EXPR, "unordered_expr", tcc_comparison, 2) 714DEFTREECODE (ORDERED_EXPR, "ordered_expr", tcc_comparison, 2) 715 716/* These are equivalent to unordered or ... */ 717DEFTREECODE (UNLT_EXPR, "unlt_expr", tcc_comparison, 2) 718DEFTREECODE (UNLE_EXPR, "unle_expr", tcc_comparison, 2) 719DEFTREECODE (UNGT_EXPR, "ungt_expr", tcc_comparison, 2) 720DEFTREECODE (UNGE_EXPR, "unge_expr", tcc_comparison, 2) 721DEFTREECODE (UNEQ_EXPR, "uneq_expr", tcc_comparison, 2) 722 723/* This is the reverse of uneq_expr. */ 724DEFTREECODE (LTGT_EXPR, "ltgt_expr", tcc_comparison, 2) 725 726DEFTREECODE (RANGE_EXPR, "range_expr", tcc_binary, 2) 727 728/* Represents a conversion of type of a value. 729 All conversions, including implicit ones, must be 730 represented by CONVERT_EXPR or NOP_EXPR nodes. */ 731DEFTREECODE (CONVERT_EXPR, "convert_expr", tcc_unary, 1) 732 733/* Represents a conversion expected to require no code to be generated. */ 734DEFTREECODE (NOP_EXPR, "nop_expr", tcc_unary, 1) 735 736/* Value is same as argument, but guaranteed not an lvalue. */ 737DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr", tcc_unary, 1) 738 739/* Represents viewing something of one type as being of a second type. 740 This corresponds to an "Unchecked Conversion" in Ada and roughly to 741 the idiom *(type2 *)&X in C. The only operand is the value to be 742 viewed as being of another type. It is undefined if the type of the 743 input and of the expression have different sizes. 744 745 This code may also be used within the LHS of a MODIFY_EXPR, in which 746 case no actual data motion may occur. TREE_ADDRESSABLE will be set in 747 this case and GCC must abort if it could not do the operation without 748 generating insns. */ 749DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr", tcc_reference, 1) 750 751/* Represents something we computed once and will use multiple times. 752 First operand is that expression. After it is evaluated once, it 753 will be replaced by the temporary variable that holds the value. */ 754DEFTREECODE (SAVE_EXPR, "save_expr", tcc_expression, 1) 755 756/* & in C. Value is the address at which the operand's value resides. 757 Operand may have any mode. Result mode is Pmode. */ 758DEFTREECODE (ADDR_EXPR, "addr_expr", tcc_expression, 1) 759 760/* Operand0 is a function constant; result is part N of a function 761 descriptor of type ptr_mode. */ 762DEFTREECODE (FDESC_EXPR, "fdesc_expr", tcc_expression, 2) 763 764/* Given two real or integer operands of the same type, 765 returns a complex value of the corresponding complex type. */ 766DEFTREECODE (COMPLEX_EXPR, "complex_expr", tcc_binary, 2) 767 768/* Complex conjugate of operand. Used only on complex types. */ 769DEFTREECODE (CONJ_EXPR, "conj_expr", tcc_unary, 1) 770 771/* Used only on an operand of complex type, these return 772 a value of the corresponding component type. */ 773DEFTREECODE (REALPART_EXPR, "realpart_expr", tcc_reference, 1) 774DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", tcc_reference, 1) 775 776/* Nodes for ++ and -- in C. 777 The second arg is how much to increment or decrement by. 778 For a pointer, it would be the size of the object pointed to. */ 779DEFTREECODE (PREDECREMENT_EXPR, "predecrement_expr", tcc_expression, 2) 780DEFTREECODE (PREINCREMENT_EXPR, "preincrement_expr", tcc_expression, 2) 781DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr", tcc_expression, 2) 782DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr", tcc_expression, 2) 783 784/* Used to implement `va_arg'. */ 785DEFTREECODE (VA_ARG_EXPR, "va_arg_expr", tcc_expression, 1) 786 787/* Evaluate operand 1. If and only if an exception is thrown during 788 the evaluation of operand 1, evaluate operand 2. 789 790 This differs from TRY_FINALLY_EXPR in that operand 2 is not evaluated 791 on a normal or jump exit, only on an exception. */ 792DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr", tcc_statement, 2) 793 794/* Evaluate the first operand. 795 The second operand is a cleanup expression which is evaluated 796 on any exit (normal, exception, or jump out) from this expression. */ 797DEFTREECODE (TRY_FINALLY_EXPR, "try_finally", tcc_statement, 2) 798 799/* These types of expressions have no useful value, 800 and always have side effects. */ 801 802/* Used to represent a local declaration. The operand is DECL_EXPR_DECL. */ 803DEFTREECODE (DECL_EXPR, "decl_expr", tcc_statement, 1) 804 805/* A label definition, encapsulated as a statement. 806 Operand 0 is the LABEL_DECL node for the label that appears here. 807 The type should be void and the value should be ignored. */ 808DEFTREECODE (LABEL_EXPR, "label_expr", tcc_statement, 1) 809 810/* GOTO. Operand 0 is a LABEL_DECL node or an expression. 811 The type should be void and the value should be ignored. */ 812DEFTREECODE (GOTO_EXPR, "goto_expr", tcc_statement, 1) 813 814/* RETURN. Evaluates operand 0, then returns from the current function. 815 Presumably that operand is an assignment that stores into the 816 RESULT_DECL that hold the value to be returned. 817 The operand may be null. 818 The type should be void and the value should be ignored. */ 819DEFTREECODE (RETURN_EXPR, "return_expr", tcc_statement, 1) 820 821/* Exit the inner most loop conditionally. Operand 0 is the condition. 822 The type should be void and the value should be ignored. */ 823DEFTREECODE (EXIT_EXPR, "exit_expr", tcc_statement, 1) 824 825/* A loop. Operand 0 is the body of the loop. 826 It must contain an EXIT_EXPR or is an infinite loop. 827 The type should be void and the value should be ignored. */ 828DEFTREECODE (LOOP_EXPR, "loop_expr", tcc_statement, 1) 829 830/* Switch expression. 831 832 TREE_TYPE is the original type of the condition, before any 833 language required type conversions. It may be NULL, in which case 834 the original type and final types are assumed to be the same. 835 836 Operand 0 is the expression used to perform the branch, 837 Operand 1 is the body of the switch, which probably contains 838 CASE_LABEL_EXPRs. It may also be NULL, in which case operand 2 839 must not be NULL. 840 Operand 2 is either NULL_TREE or a TREE_VEC of the CASE_LABEL_EXPRs 841 of all the cases. */ 842DEFTREECODE (SWITCH_EXPR, "switch_expr", tcc_statement, 3) 843 844/* Used to represent a case label. The operands are CASE_LOW and 845 CASE_HIGH, respectively. If CASE_LOW is NULL_TREE, the label is a 846 'default' label. If CASE_HIGH is NULL_TREE, the label is a normal case 847 label. CASE_LABEL is the corresponding LABEL_DECL. */ 848DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr", tcc_statement, 3) 849 850/* RESX. Resume execution after an exception. Operand 0 is a 851 number indicating the exception region that is being left. */ 852DEFTREECODE (RESX_EXPR, "resx_expr", tcc_statement, 1) 853 854/* Used to represent an inline assembly statement. ASM_STRING returns a 855 STRING_CST for the instruction (e.g., "mov x, y"). ASM_OUTPUTS, 856 ASM_INPUTS, and ASM_CLOBBERS represent the outputs, inputs, and clobbers 857 for the statement. */ 858DEFTREECODE (ASM_EXPR, "asm_expr", tcc_statement, 4) 859 860/* Variable references for SSA analysis. New SSA names are created every 861 time a variable is assigned a new value. The SSA builder uses SSA_NAME 862 nodes to implement SSA versioning. */ 863DEFTREECODE (SSA_NAME, "ssa_name", tcc_exceptional, 0) 864 865/* SSA PHI operator. PHI_RESULT is the new SSA_NAME node created by 866 the PHI node. PHI_ARG_LENGTH is the number of arguments. 867 PHI_ARG_ELT returns the Ith tuple <ssa_name, edge> from the 868 argument list. Each tuple contains the incoming reaching 869 definition (SSA_NAME node) and the edge via which that definition 870 is coming through. */ 871DEFTREECODE (PHI_NODE, "phi_node", tcc_exceptional, 0) 872 873/* Used to represent a typed exception handler. CATCH_TYPES is the type (or 874 list of types) handled, and CATCH_BODY is the code for the handler. */ 875DEFTREECODE (CATCH_EXPR, "catch_expr", tcc_statement, 2) 876 877/* Used to represent an exception specification. EH_FILTER_TYPES is a list 878 of allowed types, and EH_FILTER_FAILURE is an expression to evaluate on 879 failure. EH_FILTER_MUST_NOT_THROW controls which range type to use when 880 expanding. */ 881DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr", tcc_statement, 2) 882 883/* Node used for describing a property that is known at compile 884 time. */ 885DEFTREECODE (SCEV_KNOWN, "scev_known", tcc_expression, 0) 886 887/* Node used for describing a property that is not known at compile 888 time. */ 889DEFTREECODE (SCEV_NOT_KNOWN, "scev_not_known", tcc_expression, 0) 890 891/* Polynomial chains of recurrences. 892 Under the form: cr = {CHREC_LEFT (cr), +, CHREC_RIGHT (cr)}. */ 893DEFTREECODE (POLYNOMIAL_CHREC, "polynomial_chrec", tcc_expression, 3) 894 895/* Used to chain children of container statements together. 896 Use the interface in tree-iterator.h to access this node. */ 897DEFTREECODE (STATEMENT_LIST, "statement_list", tcc_exceptional, 0) 898 899/* Value handles. Artificial nodes to represent expressions in 900 partial redundancy elimination (tree-ssa-pre.c). These nodes are 901 used for expression canonicalization. If two expressions compute 902 the same value, they will be assigned the same value handle. */ 903DEFTREECODE (VALUE_HANDLE, "value_handle", tcc_exceptional, 0) 904 905/* Predicate assertion. Artificial expression generated by the optimizers 906 to keep track of predicate values. This expression may only appear on 907 the RHS of assignments. 908 909 Given X = ASSERT_EXPR <Y, EXPR>, the optimizers can infer 910 two things: 911 912 1- X is a copy of Y. 913 2- EXPR is a GIMPLE conditional expression (as defined by 914 is_gimple_condexpr) and is known to be true. 915 916 The type of the expression is the same as Y. */ 917DEFTREECODE (ASSERT_EXPR, "assert_expr", tcc_expression, 2) 918 919/* Base class information. Holds information about a class as a 920 baseclass of itself or another class. */ 921DEFTREECODE (TREE_BINFO, "tree_binfo", tcc_exceptional, 0) 922 923/* Records the size for an expression of variable size type. This is 924 for use in contexts in which we are accessing the entire object, 925 such as for a function call, or block copy. 926 Operand 0 is the real expression. 927 Operand 1 is the size of the type in the expression. */ 928DEFTREECODE (WITH_SIZE_EXPR, "with_size_expr", tcc_expression, 2) 929 930/* Extract elements from two input vectors Operand 0 and Operand 1 931 size VS, according to the offset OFF defined by Operand 2 as 932 follows: 933 If OFF > 0, the last VS - OFF elements of vector OP0 are concatenated to 934 the first OFF elements of the vector OP1. 935 If OFF == 0, then the returned vector is OP1. 936 On different targets OFF may take different forms; It can be an address, in 937 which case its low log2(VS)-1 bits define the offset, or it can be a mask 938 generated by the builtin targetm.vectorize.mask_for_load_builtin_decl. */ 939DEFTREECODE (REALIGN_LOAD_EXPR, "realign_load", tcc_expression, 3) 940 941/* Low-level memory addressing. Operands are SYMBOL (static or global 942 variable), BASE (register), INDEX (register), STEP (integer constant), 943 OFFSET (integer constant). Corresponding address is 944 SYMBOL + BASE + STEP * INDEX + OFFSET. Only variations and values valid on 945 the target are allowed. 946 947 The type of STEP, INDEX and OFFSET is sizetype. The type of BASE is 948 sizetype or a pointer type (if SYMBOL is NULL). 949 950 The sixth argument is the reference to the original memory access, which 951 is preserved for the purposes of the RTL alias analysis. The seventh 952 argument is a tag representing results of the tree level alias analysis. */ 953 954DEFTREECODE (TARGET_MEM_REF, "target_mem_ref", tcc_reference, 7) 955 956/* The ordering of the codes between OMP_PARALLEL and OMP_CRITICAL is 957 exposed to TREE_RANGE_CHECK. */ 958/* OpenMP - #pragma omp parallel [clause1 ... clauseN] 959 Operand 0: OMP_PARALLEL_BODY: Code to be executed by all threads. 960 Operand 1: OMP_PARALLEL_CLAUSES: List of clauses. 961 Operand 2: OMP_PARALLEL_FN: FUNCTION_DECL used when outlining the 962 body of the parallel region. Only valid after 963 pass_lower_omp. 964 Operand 3: OMP_PARALLEL_DATA_ARG: Local variable in the parent 965 function containing data to be shared with the child 966 function. */ 967 968DEFTREECODE (OMP_PARALLEL, "omp_parallel", tcc_statement, 4) 969 970/* OpenMP - #pragma omp for [clause1 ... clauseN] 971 Operand 0: OMP_FOR_BODY: Loop body. 972 Operand 1: OMP_FOR_CLAUSES: List of clauses. 973 Operand 2: OMP_FOR_INIT: Initialization code of the form 974 VAR = N1. 975 Operand 3: OMP_FOR_COND: Loop conditional expression of the form 976 VAR { <, >, <=, >= } N2. 977 Operand 4: OMP_FOR_INCR: Loop index increment of the form 978 VAR { +=, -= } INCR. 979 Operand 5: OMP_FOR_PRE_BODY: Filled by the gimplifier with things 980 from INIT, COND, and INCR that are technically part of the 981 OMP_FOR structured block, but are evaluated before the loop 982 body begins. 983 984 VAR must be a signed integer variable, which is implicitly thread 985 private. N1, N2 and INCR are required to be loop invariant integer 986 expressions that are evaluated without any synchronization. 987 The evaluation order, frequency of evaluation and side-effects are 988 unspecified by the standard. */ 989DEFTREECODE (OMP_FOR, "omp_for", tcc_statement, 6) 990 991/* OpenMP - #pragma omp sections [clause1 ... clauseN] 992 Operand 0: OMP_SECTIONS_BODY: Sections body. 993 Operand 1: OMP_SECTIONS_CLAUSES: List of clauses. */ 994DEFTREECODE (OMP_SECTIONS, "omp_sections", tcc_statement, 2) 995 996/* OpenMP - #pragma omp single 997 Operand 0: OMP_SINGLE_BODY: Single section body. 998 Operand 1: OMP_SINGLE_CLAUSES: List of clauses. */ 999DEFTREECODE (OMP_SINGLE, "omp_single", tcc_statement, 2) 1000 1001/* OpenMP - #pragma omp section 1002 Operand 0: OMP_SECTION_BODY: Section body. */ 1003DEFTREECODE (OMP_SECTION, "omp_section", tcc_statement, 1) 1004 1005/* OpenMP - #pragma omp master 1006 Operand 0: OMP_MASTER_BODY: Master section body. */ 1007DEFTREECODE (OMP_MASTER, "omp_master", tcc_statement, 1) 1008 1009/* OpenMP - #pragma omp ordered 1010 Operand 0: OMP_ORDERED_BODY: Master section body. */ 1011DEFTREECODE (OMP_ORDERED, "omp_ordered", tcc_statement, 1) 1012 1013/* OpenMP - #pragma omp critical [name] 1014 Operand 0: OMP_CRITICAL_BODY: Critical section body. 1015 Operand 1: OMP_CRITICAL_NAME: Identifier for critical section. */ 1016DEFTREECODE (OMP_CRITICAL, "omp_critical", tcc_statement, 2) 1017 1018/* Return from an OpenMP directive. */ 1019DEFTREECODE (OMP_RETURN, "omp_return", tcc_statement, 0) 1020 1021/* OpenMP - An intermediate tree code to mark the location of the 1022 loop or sections iteration in the partially lowered code. */ 1023DEFTREECODE (OMP_CONTINUE, "omp_continue", tcc_statement, 0) 1024 1025/* OpenMP - #pragma omp atomic 1026 Operand 0: The address at which the atomic operation is to be performed. 1027 This address should be stabilized with save_expr. 1028 Operand 1: The expression to evaluate. When the old value of the object 1029 at the address is used in the expression, it should appear as if 1030 build_fold_indirect_ref of the address. */ 1031DEFTREECODE (OMP_ATOMIC, "omp_atomic", tcc_statement, 2) 1032 1033/* OpenMP clauses. */ 1034DEFTREECODE (OMP_CLAUSE, "omp_clause", tcc_exceptional, 0) 1035 1036/* Reduction operations. 1037 Operations that take a vector of elements and "reduce" it to a scalar 1038 result (e.g. summing the elements of the vector, finding the minimum over 1039 the vector elements, etc). 1040 Operand 0 is a vector; the first element in the vector has the result. 1041 Operand 1 is a vector. */ 1042DEFTREECODE (REDUC_MAX_EXPR, "reduc_max_expr", tcc_unary, 1) 1043DEFTREECODE (REDUC_MIN_EXPR, "reduc_min_expr", tcc_unary, 1) 1044DEFTREECODE (REDUC_PLUS_EXPR, "reduc_plus_expr", tcc_unary, 1) 1045 1046/* Widenning dot-product. 1047 The first two arguments are of type t1. 1048 The third argument and the result are of type t2, such that t2 is at least 1049 twice the size of t1. DOT_PROD_EXPR(arg1,arg2,arg3) is equivalent to: 1050 tmp = WIDEN_MULT_EXPR(arg1, arg2); 1051 arg3 = PLUS_EXPR (tmp, arg3); 1052 or: 1053 tmp = WIDEN_MULT_EXPR(arg1, arg2); 1054 arg3 = WIDEN_SUM_EXPR (tmp, arg3); */ 1055DEFTREECODE (DOT_PROD_EXPR, "dot_prod_expr", tcc_expression, 3) 1056 1057/* Widenning summation. 1058 The first argument is of type t1. 1059 The second argument is of type t2, such that t2 is at least twice 1060 the size of t1. The type of the entire expression is also t2. 1061 WIDEN_SUM_EXPR is equivalent to first widening (promoting) 1062 the first argument from type t1 to type t2, and then summing it 1063 with the second argument. */ 1064DEFTREECODE (WIDEN_SUM_EXPR, "widen_sum_expr", tcc_binary, 2) 1065 1066/* Widenning multiplication. 1067 The two arguments are of type t1. 1068 The result is of type t2, such that t2 is at least twice 1069 the size of t1. WIDEN_MULT_EXPR is equivalent to first widening (promoting) 1070 the arguments from type t1 to type t2, and then multiplying them. */ 1071DEFTREECODE (WIDEN_MULT_EXPR, "widen_mult_expr", tcc_binary, 2) 1072 1073/* Whole vector left/right shift in bits. 1074 Operand 0 is a vector to be shifted. 1075 Operand 1 is an integer shift amount in bits. */ 1076DEFTREECODE (VEC_LSHIFT_EXPR, "vec_lshift_expr", tcc_binary, 2) 1077DEFTREECODE (VEC_RSHIFT_EXPR, "vec_rshift_expr", tcc_binary, 2) 1078 1079/* 1080Local variables: 1081mode:c 1082End: 1083*/ 1084