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