1 | /* This file contains the definitions and documentation for the |
2 | tree codes used in GCC. |
3 | Copyright (C) 1987-2023 Free Software Foundation, Inc. |
4 | |
5 | This file is part of GCC. |
6 | |
7 | GCC is free software; you can redistribute it and/or modify it under |
8 | the terms of the GNU General Public License as published by the Free |
9 | Software Foundation; either version 3, or (at your option) any later |
10 | version. |
11 | |
12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
15 | for more details. |
16 | |
17 | You should have received a copy of the GNU General Public License |
18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ |
20 | |
21 | |
22 | /* For tcc_references, tcc_expression, tcc_comparison, tcc_unary, |
23 | tcc_binary, and tcc_statement nodes, which use struct tree_exp, the |
24 | 4th element is the number of argument slots to allocate. This |
25 | determines the size of the tree node object. Other nodes use |
26 | different structures, and the size is determined by the tree_union |
27 | member structure; the 4th element should be zero. Languages that |
28 | define language-specific tcc_exceptional or tcc_constant codes must |
29 | define the tree_size langhook to say how big they are. |
30 | |
31 | These tree codes have been sorted so that the macros in tree.h that |
32 | check for various tree codes are optimized into range checks. This |
33 | gives a measurable performance improvement. When adding a new |
34 | code, consider its placement in relation to the other codes. */ |
35 | |
36 | /* Any erroneous construct is parsed into a node of this type. |
37 | This type of node is accepted without complaint in all contexts |
38 | by later parsing activities, to avoid multiple error messages |
39 | for one error. |
40 | No fields in these nodes are used except the TREE_CODE. */ |
41 | DEFTREECODE (ERROR_MARK, "error_mark" , tcc_exceptional, 0) |
42 | |
43 | /* Used to represent a name (such as, in the DECL_NAME of a decl node). |
44 | Internally it looks like a STRING_CST node. |
45 | There is only one IDENTIFIER_NODE ever made for any particular name. |
46 | Use `get_identifier' to get it (or create it, the first time). */ |
47 | DEFTREECODE (IDENTIFIER_NODE, "identifier_node" , tcc_exceptional, 0) |
48 | |
49 | /* Has the TREE_VALUE and TREE_PURPOSE fields. */ |
50 | /* These nodes are made into lists by chaining through the |
51 | TREE_CHAIN field. The elements of the list live in the |
52 | TREE_VALUE fields, while TREE_PURPOSE fields are occasionally |
53 | used as well to get the effect of Lisp association lists. */ |
54 | DEFTREECODE (TREE_LIST, "tree_list" , tcc_exceptional, 0) |
55 | |
56 | /* These nodes contain an array of tree nodes. */ |
57 | DEFTREECODE (TREE_VEC, "tree_vec" , tcc_exceptional, 0) |
58 | |
59 | /* A symbol binding block. These are arranged in a tree, |
60 | where the BLOCK_SUBBLOCKS field contains a chain of subblocks |
61 | chained through the BLOCK_CHAIN field. |
62 | BLOCK_SUPERCONTEXT points to the parent block. |
63 | For a block which represents the outermost scope of a function, it |
64 | points to the FUNCTION_DECL node. |
65 | BLOCK_VARS points to a chain of decl nodes. |
66 | BLOCK_CHAIN points to the next BLOCK at the same level. |
67 | BLOCK_ABSTRACT_ORIGIN points to the original (abstract) tree node which |
68 | this block is an instance of, or else is NULL to indicate that this |
69 | block is not an instance of anything else. When non-NULL, the value |
70 | could either point to another BLOCK node or it could point to a |
71 | FUNCTION_DECL node (e.g. in the case of a block representing the |
72 | outermost scope of a particular inlining of a function). |
73 | TREE_ASM_WRITTEN is nonzero if the block was actually referenced |
74 | in the generated assembly. */ |
75 | DEFTREECODE (BLOCK, "block" , tcc_exceptional, 0) |
76 | |
77 | /* Each data type is represented by a tree node whose code is one of |
78 | the following: */ |
79 | /* Each node that represents a data type has a component TYPE_SIZE |
80 | that evaluates either to a tree that is a (potentially non-constant) |
81 | expression representing the type size in bits, or to a null pointer |
82 | when the size of the type is unknown (for example, for incomplete |
83 | types such as arrays of unspecified bound). |
84 | The TYPE_MODE contains the machine mode for values of this type. |
85 | The TYPE_POINTER_TO field contains a type for a pointer to this type, |
86 | or zero if no such has been created yet. |
87 | The TYPE_NEXT_VARIANT field is used to chain together types |
88 | that are variants made by type modifiers such as "const" and "volatile". |
89 | The TYPE_MAIN_VARIANT field, in any member of such a chain, |
90 | points to the start of the chain. |
91 | The TYPE_NAME field contains info on the name used in the program |
92 | for this type (for GDB symbol table output). It is either a |
93 | TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE |
94 | in the case of structs, unions or enums that are known with a tag, |
95 | or zero for types that have no special name. |
96 | The TYPE_CONTEXT for any sort of type which could have a name or |
97 | which could have named members (e.g. tagged types in C/C++) will |
98 | point to the node which represents the scope of the given type, or |
99 | will be NULL_TREE if the type has "file scope". For most types, this |
100 | will point to a BLOCK node or a FUNCTION_DECL node, but it could also |
101 | point to a FUNCTION_TYPE node (for types whose scope is limited to the |
102 | formal parameter list of some function type specification) or it |
103 | could point to a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE node |
104 | (for C++ "member" types). |
105 | For non-tagged-types, TYPE_CONTEXT need not be set to anything in |
106 | particular, since any type which is of some type category (e.g. |
107 | an array type or a function type) which cannot either have a name |
108 | itself or have named members doesn't really have a "scope" per se. |
109 | The TYPE_STUB_DECL field is used as a forward-references to names for |
110 | ENUMERAL_TYPE, RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE nodes; |
111 | see below. */ |
112 | |
113 | /* The ordering of the following codes is optimized for the checking |
114 | macros in tree.h. Changing the order will degrade the speed of the |
115 | compiler. OFFSET_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE, |
116 | BITINT_TYPE, REAL_TYPE, POINTER_TYPE. */ |
117 | |
118 | /* An offset is a pointer relative to an object. |
119 | The TREE_TYPE field is the type of the object at the offset. |
120 | The TYPE_OFFSET_BASETYPE points to the node for the type of object |
121 | that the offset is relative to. */ |
122 | DEFTREECODE (OFFSET_TYPE, "offset_type" , tcc_type, 0) |
123 | |
124 | /* C enums. The type node looks just like an INTEGER_TYPE node. |
125 | The symbols for the values of the enum type are defined by |
126 | CONST_DECL nodes, but the type does not point to them; |
127 | however, the TYPE_VALUES is a list in which each element's TREE_PURPOSE |
128 | is a name and the TREE_VALUE is the value (an INTEGER_CST node). */ |
129 | /* A forward reference `enum foo' when no enum named foo is defined yet |
130 | has zero (a null pointer) in its TYPE_SIZE. The tag name is in |
131 | the TYPE_NAME field. If the type is later defined, the normal |
132 | fields are filled in. |
133 | RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE forward refs are |
134 | treated similarly. */ |
135 | DEFTREECODE (ENUMERAL_TYPE, "enumeral_type" , tcc_type, 0) |
136 | |
137 | /* Boolean type (true or false are the only values). Looks like an |
138 | INTEGRAL_TYPE. */ |
139 | DEFTREECODE (BOOLEAN_TYPE, "boolean_type" , tcc_type, 0) |
140 | |
141 | /* Integer types in all languages, including char in C. |
142 | Also used for sub-ranges of other discrete types. |
143 | Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive) |
144 | and TYPE_PRECISION (number of bits used by this type). */ |
145 | DEFTREECODE (INTEGER_TYPE, "integer_type" , tcc_type, 0) |
146 | |
147 | /* Bit-precise integer type. These are similar to INTEGER_TYPEs, but |
148 | can have arbitrary user selected precisions and do or can have different |
149 | alignment, function argument and return value passing conventions. |
150 | Larger BITINT_TYPEs can have BLKmode TYPE_MODE and need to be lowered |
151 | by a special BITINT_TYPE lowering pass. */ |
152 | DEFTREECODE (BITINT_TYPE, "bitint_type" , tcc_type, 0) |
153 | |
154 | /* C's float and double. Different floating types are distinguished |
155 | by machine mode and by the TYPE_SIZE and the TYPE_PRECISION. */ |
156 | DEFTREECODE (REAL_TYPE, "real_type" , tcc_type, 0) |
157 | |
158 | /* The ordering of the following codes is optimized for the checking |
159 | macros in tree.h. Changing the order will degrade the speed of the |
160 | compiler. POINTER_TYPE, REFERENCE_TYPE. Note that this range |
161 | overlaps the previous range of ordered types. */ |
162 | |
163 | /* All pointer-to-x types have code POINTER_TYPE. |
164 | The TREE_TYPE points to the node for the type pointed to. */ |
165 | DEFTREECODE (POINTER_TYPE, "pointer_type" , tcc_type, 0) |
166 | |
167 | /* A reference is like a pointer except that it is coerced |
168 | automatically to the value it points to. Used in C++. */ |
169 | DEFTREECODE (REFERENCE_TYPE, "reference_type" , tcc_type, 0) |
170 | |
171 | /* The C++ decltype(nullptr) type. */ |
172 | DEFTREECODE (NULLPTR_TYPE, "nullptr_type" , tcc_type, 0) |
173 | |
174 | /* _Fract and _Accum types in Embedded-C. Different fixed-point types |
175 | are distinguished by machine mode and by the TYPE_SIZE and the |
176 | TYPE_PRECISION. */ |
177 | DEFTREECODE (FIXED_POINT_TYPE, "fixed_point_type" , tcc_type, 0) |
178 | |
179 | /* The ordering of the following codes is optimized for the checking |
180 | macros in tree.h. Changing the order will degrade the speed of the |
181 | compiler. COMPLEX_TYPE, VECTOR_TYPE, ARRAY_TYPE. */ |
182 | |
183 | /* Complex number types. The TREE_TYPE field is the data type |
184 | of the real and imaginary parts. It must be of scalar |
185 | arithmetic type, not including pointer type. */ |
186 | DEFTREECODE (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. */ |
191 | DEFTREECODE (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 */ |
207 | DEFTREECODE (ARRAY_TYPE, "array_type" , tcc_type, 0) |
208 | |
209 | /* Struct in C. */ |
210 | /* Special fields: |
211 | TYPE_FIELDS chain of FIELD_DECLs for the fields of the struct, |
212 | VAR_DECLs, TYPE_DECLs and CONST_DECLs for record-scope variables, |
213 | types and enumerators and FUNCTION_DECLs for methods associated |
214 | with the type. */ |
215 | /* See the comment above, before ENUMERAL_TYPE, for how |
216 | forward references to struct tags are handled in C. */ |
217 | DEFTREECODE (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. */ |
223 | DEFTREECODE (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. */ |
229 | DEFTREECODE (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 */ |
236 | DEFTREECODE (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 | In this list TREE_PURPOSE can be used to indicate the default |
243 | value of parameter (used by C++ frontend). |
244 | Types of "Procedures" in languages where they are different from functions |
245 | have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type. */ |
246 | DEFTREECODE (FUNCTION_TYPE, "function_type" , tcc_type, 0) |
247 | |
248 | /* METHOD_TYPE is the type of a function which takes an extra first |
249 | argument for "self", which is not present in the declared argument list. |
250 | The TREE_TYPE is the return type of the method. The TYPE_METHOD_BASETYPE |
251 | is the type of "self". TYPE_ARG_TYPES is the real argument list, which |
252 | includes the hidden argument for "self". */ |
253 | DEFTREECODE (METHOD_TYPE, "method_type" , tcc_type, 0) |
254 | |
255 | /* This is a language-specific kind of type. |
256 | Its meaning is defined by the language front end. |
257 | layout_type does not know how to lay this out, |
258 | so the front-end must do so manually. */ |
259 | DEFTREECODE (LANG_TYPE, "lang_type" , tcc_type, 0) |
260 | |
261 | /* This is for types that will use MODE_OPAQUE in the back end. They are meant |
262 | to be able to go in a register of some sort but are explicitly not to be |
263 | converted or operated on like INTEGER_TYPE. They will have size and |
264 | alignment information only. */ |
265 | DEFTREECODE (OPAQUE_TYPE, "opaque_type" , tcc_type, 0) |
266 | |
267 | /* Expressions */ |
268 | |
269 | /* First, the constants. */ |
270 | |
271 | DEFTREECODE (VOID_CST, "void_cst" , tcc_constant, 0) |
272 | |
273 | /* Contents are in an array of HOST_WIDE_INTs. |
274 | |
275 | We often access these constants both in their native precision and |
276 | in wider precisions (with the constant being implicitly extended |
277 | according to TYPE_SIGN). In each case, the useful part of the array |
278 | may be as wide as the precision requires but may be shorter when all |
279 | of the upper bits are sign bits. The length of the array when accessed |
280 | in the constant's native precision is given by TREE_INT_CST_NUNITS. |
281 | The length of the array when accessed in wider precisions is given |
282 | by TREE_INT_CST_EXT_NUNITS. Each element can be obtained using |
283 | TREE_INT_CST_ELT. |
284 | |
285 | INTEGER_CST nodes can be shared, and therefore should be considered |
286 | read only. They should be copied before setting a flag such as |
287 | TREE_OVERFLOW. If an INTEGER_CST has TREE_OVERFLOW already set, |
288 | it is known to be unique. INTEGER_CST nodes are created for the |
289 | integral types, for pointer types and for vector and float types in |
290 | some circumstances. */ |
291 | DEFTREECODE (INTEGER_CST, "integer_cst" , tcc_constant, 0) |
292 | |
293 | /* Contents are given by POLY_INT_CST_COEFF. */ |
294 | DEFTREECODE (POLY_INT_CST, "poly_int_cst" , tcc_constant, 0) |
295 | |
296 | /* Contents are in TREE_REAL_CST field. */ |
297 | DEFTREECODE (REAL_CST, "real_cst" , tcc_constant, 0) |
298 | |
299 | /* Contents are in TREE_FIXED_CST field. */ |
300 | DEFTREECODE (FIXED_CST, "fixed_cst" , tcc_constant, 0) |
301 | |
302 | /* Contents are in TREE_REALPART and TREE_IMAGPART fields, |
303 | whose contents are other constant nodes. */ |
304 | DEFTREECODE (COMPLEX_CST, "complex_cst" , tcc_constant, 0) |
305 | |
306 | /* See generic.texi for details. */ |
307 | DEFTREECODE (VECTOR_CST, "vector_cst" , tcc_constant, 0) |
308 | |
309 | /* Contents are TREE_STRING_LENGTH and the actual contents of the string. */ |
310 | DEFTREECODE (STRING_CST, "string_cst" , tcc_constant, 0) |
311 | |
312 | /* Declarations. All references to names are represented as ..._DECL |
313 | nodes. The decls in one binding context are chained through the |
314 | TREE_CHAIN field. Each DECL has a DECL_NAME field which contains |
315 | an IDENTIFIER_NODE. (Some decls, most often labels, may have zero |
316 | as the DECL_NAME). DECL_CONTEXT points to the node representing |
317 | the context in which this declaration has its scope. For |
318 | FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or |
319 | QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL, |
320 | PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this |
321 | points to either the FUNCTION_DECL for the containing function, the |
322 | RECORD_TYPE or UNION_TYPE for the containing type, or NULL_TREE or |
323 | a TRANSLATION_UNIT_DECL if the given decl has "file scope". |
324 | DECL_ABSTRACT_ORIGIN, if non-NULL, points to the original (abstract) |
325 | ..._DECL node of which this decl is an (inlined or template expanded) |
326 | instance. |
327 | The TREE_TYPE field holds the data type of the object, when relevant. |
328 | LABEL_DECLs have no data type. For TYPE_DECL, the TREE_TYPE field |
329 | contents are the type whose name is being declared. |
330 | The DECL_ALIGN, DECL_SIZE, |
331 | and DECL_MODE fields exist in decl nodes just as in type nodes. |
332 | They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes. |
333 | |
334 | DECL_FIELD_BIT_OFFSET holds an integer number of bits offset for |
335 | the location. DECL_VOFFSET holds an expression for a variable |
336 | offset; it is to be multiplied by DECL_VOFFSET_UNIT (an integer). |
337 | These fields are relevant only in FIELD_DECLs and PARM_DECLs. |
338 | |
339 | DECL_INITIAL holds the value to initialize a variable to, |
340 | or the value of a constant. For a function, it holds the body |
341 | (a node of type BLOCK representing the function's binding contour |
342 | and whose body contains the function's statements.) For a LABEL_DECL |
343 | in C, it is a flag, nonzero if the label's definition has been seen. |
344 | |
345 | PARM_DECLs use a special field: |
346 | DECL_ARG_TYPE is the type in which the argument is actually |
347 | passed, which may be different from its type within the function. |
348 | |
349 | FUNCTION_DECLs use four special fields: |
350 | DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments. |
351 | DECL_RESULT holds a RESULT_DECL node for the value of a function. |
352 | The DECL_RTL field is 0 for a function that returns no value. |
353 | (C functions returning void have zero here.) |
354 | The TREE_TYPE field is the type in which the result is actually |
355 | returned. This is usually the same as the return type of the |
356 | FUNCTION_DECL, but it may be a wider integer type because of |
357 | promotion. |
358 | DECL_FUNCTION_CODE is a code number that is nonzero for |
359 | built-in functions. Its value is an enum built_in_function |
360 | that says which built-in function it is. |
361 | |
362 | DECL_SOURCE_FILE holds a filename string and DECL_SOURCE_LINE |
363 | holds a line number. In some cases these can be the location of |
364 | a reference, if no definition has been seen. |
365 | |
366 | DECL_ABSTRACT is nonzero if the decl represents an abstract instance |
367 | of a decl (i.e. one which is nested within an abstract instance of a |
368 | inline function. */ |
369 | |
370 | DEFTREECODE (FUNCTION_DECL, "function_decl" , tcc_declaration, 0) |
371 | DEFTREECODE (LABEL_DECL, "label_decl" , tcc_declaration, 0) |
372 | /* The ordering of the following codes is optimized for the checking |
373 | macros in tree.h. Changing the order will degrade the speed of the |
374 | compiler. FIELD_DECL, VAR_DECL, CONST_DECL, PARM_DECL, |
375 | TYPE_DECL. */ |
376 | DEFTREECODE (FIELD_DECL, "field_decl" , tcc_declaration, 0) |
377 | DEFTREECODE (VAR_DECL, "var_decl" , tcc_declaration, 0) |
378 | DEFTREECODE (CONST_DECL, "const_decl" , tcc_declaration, 0) |
379 | DEFTREECODE (PARM_DECL, "parm_decl" , tcc_declaration, 0) |
380 | DEFTREECODE (TYPE_DECL, "type_decl" , tcc_declaration, 0) |
381 | DEFTREECODE (RESULT_DECL, "result_decl" , tcc_declaration, 0) |
382 | |
383 | /* A "declaration" of a debug temporary. It should only appear in |
384 | DEBUG stmts. */ |
385 | DEFTREECODE (DEBUG_EXPR_DECL, "debug_expr_decl" , tcc_declaration, 0) |
386 | |
387 | /* A stmt that marks the beginning of a source statement. */ |
388 | DEFTREECODE (DEBUG_BEGIN_STMT, "debug_begin_stmt" , tcc_statement, 0) |
389 | |
390 | /* A namespace declaration. Namespaces appear in DECL_CONTEXT of other |
391 | _DECLs, providing a hierarchy of names. */ |
392 | DEFTREECODE (NAMESPACE_DECL, "namespace_decl" , tcc_declaration, 0) |
393 | |
394 | /* A declaration import. |
395 | The C++ FE uses this to represent a using-directive; eg: |
396 | "using namespace foo". |
397 | But it could be used to represent any declaration import construct. |
398 | Whenever a declaration import appears in a lexical block, the BLOCK node |
399 | representing that lexical block in GIMPLE will contain an IMPORTED_DECL |
400 | node, linked via BLOCK_VARS accessor of the said BLOCK. |
401 | For a given NODE which code is IMPORTED_DECL, |
402 | IMPORTED_DECL_ASSOCIATED_DECL (NODE) accesses the imported declaration. */ |
403 | DEFTREECODE (IMPORTED_DECL, "imported_decl" , tcc_declaration, 0) |
404 | |
405 | /* A namelist declaration. |
406 | The Fortran FE uses this to represent a namelist statement, e.g.: |
407 | NAMELIST /namelist-group-name/ namelist-group-object-list. |
408 | Whenever a declaration import appears in a lexical block, the BLOCK node |
409 | representing that lexical block in GIMPLE will contain an NAMELIST_DECL |
410 | node, linked via BLOCK_VARS accessor of the said BLOCK. |
411 | For a given NODE which code is NAMELIST_DECL, |
412 | NAMELIST_DECL_ASSOCIATED_DECL (NODE) accesses the imported declaration. */ |
413 | DEFTREECODE (NAMELIST_DECL, "namelist_decl" , tcc_declaration, 0) |
414 | |
415 | /* A translation unit. This is not technically a declaration, since it |
416 | can't be looked up, but it's close enough. */ |
417 | DEFTREECODE (TRANSLATION_UNIT_DECL, "translation_unit_decl" ,\ |
418 | tcc_declaration, 0) |
419 | |
420 | /* References to storage. */ |
421 | |
422 | /* The ordering of the following codes is optimized for the classification |
423 | in handled_component_p. Keep them in a consecutive group. */ |
424 | |
425 | /* Value is structure or union component. |
426 | Operand 0 is the structure or union (an expression). |
427 | Operand 1 is the field (a node of type FIELD_DECL). |
428 | Operand 2, if present, is the value of DECL_FIELD_OFFSET, measured |
429 | in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. */ |
430 | DEFTREECODE (COMPONENT_REF, "component_ref" , tcc_reference, 3) |
431 | |
432 | /* Reference to a group of bits within an object. Similar to COMPONENT_REF |
433 | except the position is given explicitly rather than via a FIELD_DECL. |
434 | Operand 0 is the structure or union expression; |
435 | operand 1 is a tree giving the constant number of bits being referenced; |
436 | operand 2 is a tree giving the constant position of the first referenced bit. |
437 | The result type width has to match the number of bits referenced. |
438 | If the result type is integral, its signedness specifies how it is extended |
439 | to its mode width. */ |
440 | DEFTREECODE (BIT_FIELD_REF, "bit_field_ref" , tcc_reference, 3) |
441 | |
442 | /* Array indexing. |
443 | Operand 0 is the array; operand 1 is a (single) array index. |
444 | Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index. |
445 | Operand 3, if present, is the element size, measured in units of |
446 | the alignment of the element type. */ |
447 | DEFTREECODE (ARRAY_REF, "array_ref" , tcc_reference, 4) |
448 | |
449 | /* Likewise, except that the result is a range ("slice") of the array. The |
450 | starting index of the resulting array is taken from operand 1 and the size |
451 | of the range is taken from the type of the expression. */ |
452 | DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref" , tcc_reference, 4) |
453 | |
454 | /* Used only on an operand of complex type, these return |
455 | a value of the corresponding component type. */ |
456 | DEFTREECODE (REALPART_EXPR, "realpart_expr" , tcc_reference, 1) |
457 | DEFTREECODE (IMAGPART_EXPR, "imagpart_expr" , tcc_reference, 1) |
458 | |
459 | /* Represents viewing something of one type as being of a second type. |
460 | This corresponds to an "Unchecked Conversion" in Ada and roughly to |
461 | the idiom *(type2 *)&X in C. The only operand is the value to be |
462 | viewed as being of another type. It is undefined if the type of the |
463 | input and of the expression have different sizes. |
464 | |
465 | This code may also be used within the LHS of a MODIFY_EXPR, in which |
466 | case no actual data motion may occur. TREE_ADDRESSABLE will be set in |
467 | this case and GCC must abort if it could not do the operation without |
468 | generating insns. */ |
469 | DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr" , tcc_reference, 1) |
470 | |
471 | /* C unary `*'. One operand, an expression for a pointer. */ |
472 | DEFTREECODE (INDIRECT_REF, "indirect_ref" , tcc_reference, 1) |
473 | |
474 | /* Used to represent lookup in a virtual method table which is dependent on |
475 | the runtime type of an object. Operands are: |
476 | OBJ_TYPE_REF_EXPR: An expression that evaluates the value to use. |
477 | OBJ_TYPE_REF_OBJECT: Is the object on whose behalf the lookup is |
478 | being performed. Through this the optimizers may be able to statically |
479 | determine the dynamic type of the object. |
480 | OBJ_TYPE_REF_TOKEN: An integer index to the virtual method table. |
481 | The integer index should have as type the original type of |
482 | OBJ_TYPE_REF_OBJECT; as pointer type conversions are useless in GIMPLE, |
483 | the type of OBJ_TYPE_REF_OBJECT can change to an unrelated pointer |
484 | type during optimizations. */ |
485 | DEFTREECODE (OBJ_TYPE_REF, "obj_type_ref" , tcc_expression, 3) |
486 | |
487 | /* Used to represent the brace-enclosed initializers for a structure or an |
488 | array. It contains a sequence of component values made out of a VEC of |
489 | constructor_elt. |
490 | |
491 | For RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE: |
492 | The field INDEX of each constructor_elt is a FIELD_DECL. |
493 | |
494 | For ARRAY_TYPE: |
495 | The field INDEX of each constructor_elt is the corresponding index. |
496 | If the index is a RANGE_EXPR, it is a short-hand for many nodes, |
497 | one for each index in the range. (If the corresponding field VALUE |
498 | has side-effects, they are evaluated once for each element. Wrap the |
499 | value in a SAVE_EXPR if you want to evaluate side effects only once.) |
500 | |
501 | Components that aren't present are cleared as per the C semantics, |
502 | unless the CONSTRUCTOR_NO_CLEARING flag is set, in which case their |
503 | value becomes undefined. */ |
504 | DEFTREECODE (CONSTRUCTOR, "constructor" , tcc_exceptional, 0) |
505 | |
506 | /* The expression types are mostly straightforward, with the fourth argument |
507 | of DEFTREECODE saying how many operands there are. |
508 | Unless otherwise specified, the operands are expressions and the |
509 | types of all the operands and the expression must all be the same. */ |
510 | |
511 | /* Contains two expressions to compute, one followed by the other. |
512 | the first value is ignored. The second one's value is used. The |
513 | type of the first expression need not agree with the other types. */ |
514 | DEFTREECODE (COMPOUND_EXPR, "compound_expr" , tcc_expression, 2) |
515 | |
516 | /* Assignment expression. Operand 0 is the what to set; 1, the new value. */ |
517 | DEFTREECODE (MODIFY_EXPR, "modify_expr" , tcc_expression, 2) |
518 | |
519 | /* Initialization expression. Operand 0 is the variable to initialize; |
520 | Operand 1 is the initializer. This differs from MODIFY_EXPR in that any |
521 | reference to the referent of operand 0 within operand 1 is undefined. */ |
522 | DEFTREECODE (INIT_EXPR, "init_expr" , tcc_expression, 2) |
523 | |
524 | /* For TARGET_EXPR, operand 0 is the target of an initialization, |
525 | operand 1 is the initializer for the target, which may be void |
526 | if simply expanding it initializes the target. |
527 | operand 2 is the cleanup for this node, if any. |
528 | operand 3 is the saved initializer after this node has been |
529 | expanded once; this is so we can re-expand the tree later. */ |
530 | DEFTREECODE (TARGET_EXPR, "target_expr" , tcc_expression, 4) |
531 | |
532 | /* Conditional expression ( ... ? ... : ... in C). |
533 | Operand 0 is the condition. |
534 | Operand 1 is the then-value. |
535 | Operand 2 is the else-value. |
536 | Operand 0 may be of any type. |
537 | Operand 1 must have the same type as the entire expression, unless |
538 | it unconditionally throws an exception, in which case it should |
539 | have VOID_TYPE. The same constraints apply to operand 2. The |
540 | condition in operand 0 must be of integral type. |
541 | |
542 | In cfg gimple, if you do not have a selection expression, operands |
543 | 1 and 2 are NULL. The operands are then taken from the cfg edges. */ |
544 | DEFTREECODE (COND_EXPR, "cond_expr" , tcc_expression, 3) |
545 | |
546 | /* Represents a vector in which every element is equal to operand 0. */ |
547 | DEFTREECODE (VEC_DUPLICATE_EXPR, "vec_duplicate_expr" , tcc_unary, 1) |
548 | |
549 | /* Vector series created from a start (base) value and a step. |
550 | |
551 | A = VEC_SERIES_EXPR (B, C) |
552 | |
553 | means |
554 | |
555 | for (i = 0; i < N; i++) |
556 | A[i] = B + C * i; */ |
557 | DEFTREECODE (VEC_SERIES_EXPR, "vec_series_expr" , tcc_binary, 2) |
558 | |
559 | /* Vector conditional expression. It is like COND_EXPR, but with |
560 | vector operands. |
561 | |
562 | A = VEC_COND_EXPR ( X < Y, B, C) |
563 | |
564 | means |
565 | |
566 | for (i=0; i<N; i++) |
567 | A[i] = X[i] < Y[i] ? B[i] : C[i]; |
568 | */ |
569 | DEFTREECODE (VEC_COND_EXPR, "vec_cond_expr" , tcc_expression, 3) |
570 | |
571 | /* Vector permutation expression. A = VEC_PERM_EXPR<v0, v1, mask> means |
572 | |
573 | N = length(mask) |
574 | foreach i in N: |
575 | M = mask[i] % (length(v0) + length(v1)) |
576 | A[i] = M < length(v0) ? v0[M] : v1[M - length(v0)] |
577 | |
578 | V0 and V1 are vectors of the same type. |
579 | |
580 | When MASK is not constant: |
581 | MASK is an integer-typed vector. The number of MASK elements must |
582 | be the same as the number of elements in V0 and V1. The size of |
583 | the inner type of the MASK and of the V0 and V1 must be the same. |
584 | |
585 | When MASK is constant: |
586 | MASK is an integer-typed vector. |
587 | */ |
588 | DEFTREECODE (VEC_PERM_EXPR, "vec_perm_expr" , tcc_expression, 3) |
589 | |
590 | /* Declare local variables, including making RTL and allocating space. |
591 | BIND_EXPR_VARS is a chain of VAR_DECL nodes for the variables. |
592 | BIND_EXPR_BODY is the body, the expression to be computed using |
593 | the variables. The value of operand 1 becomes that of the BIND_EXPR. |
594 | BIND_EXPR_BLOCK is the BLOCK that corresponds to these bindings |
595 | for debugging purposes. If this BIND_EXPR is actually expanded, |
596 | that sets the TREE_USED flag in the BLOCK. |
597 | |
598 | The BIND_EXPR is not responsible for informing parsers |
599 | about these variables. If the body is coming from the input file, |
600 | then the code that creates the BIND_EXPR is also responsible for |
601 | informing the parser of the variables. |
602 | |
603 | If the BIND_EXPR is ever expanded, its TREE_USED flag is set. |
604 | This tells the code for debugging symbol tables not to ignore the BIND_EXPR. |
605 | If the BIND_EXPR should be output for debugging but will not be expanded, |
606 | set the TREE_USED flag by hand. |
607 | |
608 | In order for the BIND_EXPR to be known at all, the code that creates it |
609 | must also install it as a subblock in the tree of BLOCK |
610 | nodes for the function. */ |
611 | DEFTREECODE (BIND_EXPR, "bind_expr" , tcc_expression, 3) |
612 | |
613 | /* Function call. CALL_EXPRs are represented by variably-sized expression |
614 | nodes. There are at least three fixed operands. Operand 0 is an |
615 | INTEGER_CST node containing the total operand count, the number of |
616 | arguments plus 3. Operand 1 is the function or NULL, while operand 2 is |
617 | is static chain argument, or NULL. The remaining operands are the |
618 | arguments to the call. */ |
619 | DEFTREECODE (CALL_EXPR, "call_expr" , tcc_vl_exp, 3) |
620 | |
621 | /* Specify a value to compute along with its corresponding cleanup. |
622 | Operand 0 is the cleanup expression. |
623 | The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR, |
624 | which must exist. This differs from TRY_CATCH_EXPR in that operand 1 |
625 | is always evaluated when cleanups are run. */ |
626 | DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr" , tcc_expression, 1) |
627 | |
628 | /* Specify a cleanup point. |
629 | Operand 0 is an expression that may have cleanups. If it does, those |
630 | cleanups are executed after the expression is expanded. |
631 | |
632 | Note that if the expression is a reference to storage, it is forced out |
633 | of memory before the cleanups are run. This is necessary to handle |
634 | cases where the cleanups modify the storage referenced; in the |
635 | expression 't.i', if 't' is a struct with an integer member 'i' and a |
636 | cleanup which modifies 'i', the value of the expression depends on |
637 | whether the cleanup is run before or after 't.i' is evaluated. When |
638 | expand_expr is run on 't.i', it returns a MEM. This is not good enough; |
639 | the value of 't.i' must be forced out of memory. |
640 | |
641 | As a consequence, the operand of a CLEANUP_POINT_EXPR must not have |
642 | BLKmode, because it will not be forced out of memory. */ |
643 | DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr" , tcc_expression, 1) |
644 | |
645 | /* The following code is used in languages that have types where some |
646 | field in an object of the type contains a value that is used in the |
647 | computation of another field's offset or size and/or the size of the |
648 | type. The positions and/or sizes of fields can vary from object to |
649 | object of the same type or even for one and the same object within |
650 | its scope. |
651 | |
652 | Record types with discriminants in Ada are |
653 | examples of such types. This mechanism is also used to create "fat |
654 | pointers" for unconstrained array types in Ada; the fat pointer is a |
655 | structure one of whose fields is a pointer to the actual array type |
656 | and the other field is a pointer to a template, which is a structure |
657 | containing the bounds of the array. The bounds in the type pointed |
658 | to by the first field in the fat pointer refer to the values in the |
659 | template. |
660 | |
661 | When you wish to construct such a type you need "self-references" |
662 | that allow you to reference the object having this type from the |
663 | TYPE node, i.e. without having a variable instantiating this type. |
664 | |
665 | Such a "self-references" is done using a PLACEHOLDER_EXPR. This is |
666 | a node that will later be replaced with the object being referenced. |
667 | Its type is that of the object and selects which object to use from |
668 | a chain of references (see below). No other slots are used in the |
669 | PLACEHOLDER_EXPR. |
670 | |
671 | For example, if your type FOO is a RECORD_TYPE with a field BAR, |
672 | and you need the value of <variable>.BAR to calculate TYPE_SIZE |
673 | (FOO), just substitute <variable> above with a PLACEHOLDER_EXPR |
674 | whose TREE_TYPE is FOO. Then construct your COMPONENT_REF with |
675 | the PLACEHOLDER_EXPR as the first operand (which has the correct |
676 | type). Later, when the size is needed in the program, the back-end |
677 | will find this PLACEHOLDER_EXPR and generate code to calculate the |
678 | actual size at run-time. In the following, we describe how this |
679 | calculation is done. |
680 | |
681 | When we wish to evaluate a size or offset, we check whether it contains a |
682 | PLACEHOLDER_EXPR. If it does, we call substitute_placeholder_in_expr |
683 | passing both that tree and an expression within which the object may be |
684 | found. The latter expression is the object itself in the simple case of |
685 | an Ada record with discriminant, but it can be the array in the case of an |
686 | unconstrained array. |
687 | |
688 | In the latter case, we need the fat pointer, because the bounds of |
689 | the array can only be accessed from it. However, we rely here on the |
690 | fact that the expression for the array contains the dereference of |
691 | the fat pointer that obtained the array pointer. */ |
692 | |
693 | /* Denotes a record to later be substituted before evaluating this expression. |
694 | The type of this expression is used to find the record to replace it. */ |
695 | DEFTREECODE (PLACEHOLDER_EXPR, "placeholder_expr" , tcc_exceptional, 0) |
696 | |
697 | /* Simple arithmetic. */ |
698 | DEFTREECODE (PLUS_EXPR, "plus_expr" , tcc_binary, 2) |
699 | DEFTREECODE (MINUS_EXPR, "minus_expr" , tcc_binary, 2) |
700 | DEFTREECODE (MULT_EXPR, "mult_expr" , tcc_binary, 2) |
701 | |
702 | /* Pointer addition. The first operand is always a pointer and the |
703 | second operand is an integer of type sizetype. */ |
704 | DEFTREECODE (POINTER_PLUS_EXPR, "pointer_plus_expr" , tcc_binary, 2) |
705 | |
706 | /* Pointer subtraction. The two arguments are pointers, and the result |
707 | is a signed integer of the same precision. Pointers are interpreted |
708 | as unsigned, the difference is computed as if in infinite signed |
709 | precision. Behavior is undefined if the difference does not fit in |
710 | the result type. The result does not depend on the pointer type, |
711 | it is not divided by the size of the pointed-to type. */ |
712 | DEFTREECODE (POINTER_DIFF_EXPR, "pointer_diff_expr" , tcc_binary, 2) |
713 | |
714 | /* Highpart multiplication. For an integral type with precision B, |
715 | returns bits [2B-1, B] of the full 2*B product. Both operands |
716 | and the result should have integer types of the same precision |
717 | and signedness. */ |
718 | DEFTREECODE (MULT_HIGHPART_EXPR, "mult_highpart_expr" , tcc_binary, 2) |
719 | |
720 | /* Division for integer result that rounds the quotient toward zero. */ |
721 | DEFTREECODE (TRUNC_DIV_EXPR, "trunc_div_expr" , tcc_binary, 2) |
722 | |
723 | /* Division for integer result that rounds it toward plus infinity. */ |
724 | DEFTREECODE (CEIL_DIV_EXPR, "ceil_div_expr" , tcc_binary, 2) |
725 | |
726 | /* Division for integer result that rounds it toward minus infinity. */ |
727 | DEFTREECODE (FLOOR_DIV_EXPR, "floor_div_expr" , tcc_binary, 2) |
728 | |
729 | /* Division for integer result that rounds it toward nearest integer. */ |
730 | DEFTREECODE (ROUND_DIV_EXPR, "round_div_expr" , tcc_binary, 2) |
731 | |
732 | /* Four kinds of remainder that go with the four kinds of division: */ |
733 | |
734 | /* The sign of the remainder is that of the dividend. */ |
735 | DEFTREECODE (TRUNC_MOD_EXPR, "trunc_mod_expr" , tcc_binary, 2) |
736 | |
737 | /* The sign of the remainder is the opposite of that of the divisor. */ |
738 | DEFTREECODE (CEIL_MOD_EXPR, "ceil_mod_expr" , tcc_binary, 2) |
739 | |
740 | /* The sign of the remainder is that of the divisor. */ |
741 | DEFTREECODE (FLOOR_MOD_EXPR, "floor_mod_expr" , tcc_binary, 2) |
742 | |
743 | /* The sign of the remainder is not predictable. */ |
744 | DEFTREECODE (ROUND_MOD_EXPR, "round_mod_expr" , tcc_binary, 2) |
745 | |
746 | /* Division for real result. */ |
747 | DEFTREECODE (RDIV_EXPR, "rdiv_expr" , tcc_binary, 2) |
748 | |
749 | /* Division which is not supposed to need rounding. |
750 | Used for pointer subtraction in C. */ |
751 | DEFTREECODE (EXACT_DIV_EXPR, "exact_div_expr" , tcc_binary, 2) |
752 | |
753 | /* Conversion of real to fixed point by truncation. */ |
754 | DEFTREECODE (FIX_TRUNC_EXPR, "fix_trunc_expr" , tcc_unary, 1) |
755 | |
756 | /* Conversion of an integer to a real. */ |
757 | DEFTREECODE (FLOAT_EXPR, "float_expr" , tcc_unary, 1) |
758 | |
759 | /* Unary negation. */ |
760 | DEFTREECODE (NEGATE_EXPR, "negate_expr" , tcc_unary, 1) |
761 | |
762 | /* Minimum and maximum values. When used with floating point, if both |
763 | operands are zeros, or if either operand is NaN, then it is unspecified |
764 | which of the two operands is returned as the result. */ |
765 | DEFTREECODE (MIN_EXPR, "min_expr" , tcc_binary, 2) |
766 | DEFTREECODE (MAX_EXPR, "max_expr" , tcc_binary, 2) |
767 | |
768 | /* Represents the absolute value of the operand. |
769 | |
770 | An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE. The |
771 | operand of the ABS_EXPR must have the same type. */ |
772 | DEFTREECODE (ABS_EXPR, "abs_expr" , tcc_unary, 1) |
773 | |
774 | /* Represents the unsigned absolute value of the operand. |
775 | An ABSU_EXPR must have unsigned INTEGER_TYPE. The operand of the ABSU_EXPR |
776 | must have the corresponding signed type. */ |
777 | DEFTREECODE (ABSU_EXPR, "absu_expr" , tcc_unary, 1) |
778 | |
779 | /* Shift operations for shift and rotate. |
780 | Shift means logical shift if done on an |
781 | unsigned type, arithmetic shift if done on a signed type. |
782 | The second operand is the number of bits to |
783 | shift by; it need not be the same type as the first operand and result. |
784 | Note that the result is undefined if the second operand is larger |
785 | than or equal to the first operand's type size. |
786 | |
787 | The first operand of a shift can have either an integer or a |
788 | (non-integer) fixed-point type. We follow the ISO/IEC TR 18037:2004 |
789 | semantics for the latter. |
790 | |
791 | Rotates are defined for integer types only. */ |
792 | DEFTREECODE (LSHIFT_EXPR, "lshift_expr" , tcc_binary, 2) |
793 | DEFTREECODE (RSHIFT_EXPR, "rshift_expr" , tcc_binary, 2) |
794 | DEFTREECODE (LROTATE_EXPR, "lrotate_expr" , tcc_binary, 2) |
795 | DEFTREECODE (RROTATE_EXPR, "rrotate_expr" , tcc_binary, 2) |
796 | |
797 | /* Bitwise operations. Operands have same mode as result. */ |
798 | DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr" , tcc_binary, 2) |
799 | DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr" , tcc_binary, 2) |
800 | DEFTREECODE (BIT_AND_EXPR, "bit_and_expr" , tcc_binary, 2) |
801 | DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr" , tcc_unary, 1) |
802 | |
803 | /* ANDIF and ORIF allow the second operand not to be computed if the |
804 | value of the expression is determined from the first operand. AND, |
805 | OR, and XOR always compute the second operand whether its value is |
806 | needed or not (for side effects). The operand may have |
807 | BOOLEAN_TYPE or INTEGER_TYPE. In either case, the argument will be |
808 | either zero or one. For example, a TRUTH_NOT_EXPR will never have |
809 | an INTEGER_TYPE VAR_DECL as its argument; instead, a NE_EXPR will be |
810 | used to compare the VAR_DECL to zero, thereby obtaining a node with |
811 | value zero or one. */ |
812 | DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr" , tcc_expression, 2) |
813 | DEFTREECODE (TRUTH_ORIF_EXPR, "truth_orif_expr" , tcc_expression, 2) |
814 | DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr" , tcc_expression, 2) |
815 | DEFTREECODE (TRUTH_OR_EXPR, "truth_or_expr" , tcc_expression, 2) |
816 | DEFTREECODE (TRUTH_XOR_EXPR, "truth_xor_expr" , tcc_expression, 2) |
817 | DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr" , tcc_expression, 1) |
818 | |
819 | /* Relational operators. |
820 | EQ_EXPR and NE_EXPR are allowed for any types. The others, except for |
821 | LTGT_EXPR, are allowed only for integral, floating-point and vector types. |
822 | LTGT_EXPR is allowed only for floating-point types. |
823 | For floating-point operators, if either operand is a NaN, then NE_EXPR |
824 | returns true and the remaining operators return false. The operators |
825 | other than EQ_EXPR and NE_EXPR may generate an exception on quiet NaNs. |
826 | In all cases the operands will have the same type, |
827 | and the value is either the type used by the language for booleans |
828 | or an integer vector type of the same size and with the same number |
829 | of elements as the comparison operands. True for a vector of |
830 | comparison results has all bits set while false is equal to zero. */ |
831 | DEFTREECODE (LT_EXPR, "lt_expr" , tcc_comparison, 2) |
832 | DEFTREECODE (LE_EXPR, "le_expr" , tcc_comparison, 2) |
833 | DEFTREECODE (GT_EXPR, "gt_expr" , tcc_comparison, 2) |
834 | DEFTREECODE (GE_EXPR, "ge_expr" , tcc_comparison, 2) |
835 | DEFTREECODE (LTGT_EXPR, "ltgt_expr" , tcc_comparison, 2) |
836 | DEFTREECODE (EQ_EXPR, "eq_expr" , tcc_comparison, 2) |
837 | DEFTREECODE (NE_EXPR, "ne_expr" , tcc_comparison, 2) |
838 | |
839 | /* Additional relational operators for floating-point unordered. */ |
840 | DEFTREECODE (UNORDERED_EXPR, "unordered_expr" , tcc_comparison, 2) |
841 | DEFTREECODE (ORDERED_EXPR, "ordered_expr" , tcc_comparison, 2) |
842 | |
843 | /* These are equivalent to unordered or ... */ |
844 | DEFTREECODE (UNLT_EXPR, "unlt_expr" , tcc_comparison, 2) |
845 | DEFTREECODE (UNLE_EXPR, "unle_expr" , tcc_comparison, 2) |
846 | DEFTREECODE (UNGT_EXPR, "ungt_expr" , tcc_comparison, 2) |
847 | DEFTREECODE (UNGE_EXPR, "unge_expr" , tcc_comparison, 2) |
848 | DEFTREECODE (UNEQ_EXPR, "uneq_expr" , tcc_comparison, 2) |
849 | |
850 | DEFTREECODE (RANGE_EXPR, "range_expr" , tcc_binary, 2) |
851 | |
852 | /* Represents a re-association barrier for floating point expressions |
853 | like explicit parenthesis in fortran. */ |
854 | DEFTREECODE (PAREN_EXPR, "paren_expr" , tcc_unary, 1) |
855 | |
856 | /* Represents a conversion of type of a value. |
857 | All conversions, including implicit ones, must be |
858 | represented by CONVERT_EXPR or NOP_EXPR nodes. */ |
859 | DEFTREECODE (CONVERT_EXPR, "convert_expr" , tcc_unary, 1) |
860 | |
861 | /* Conversion of a pointer value to a pointer to a different |
862 | address space. */ |
863 | DEFTREECODE (ADDR_SPACE_CONVERT_EXPR, "addr_space_convert_expr" , tcc_unary, 1) |
864 | |
865 | /* Conversion of a fixed-point value to an integer, a real, or a fixed-point |
866 | value. Or conversion of a fixed-point value from an integer, a real, or |
867 | a fixed-point value. */ |
868 | DEFTREECODE (FIXED_CONVERT_EXPR, "fixed_convert_expr" , tcc_unary, 1) |
869 | |
870 | /* Represents a conversion expected to require no code to be generated. */ |
871 | DEFTREECODE (NOP_EXPR, "nop_expr" , tcc_unary, 1) |
872 | |
873 | /* Value is same as argument, but guaranteed not an lvalue. */ |
874 | DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr" , tcc_unary, 1) |
875 | |
876 | /* A COMPOUND_LITERAL_EXPR represents a literal that is placed in a DECL. The |
877 | COMPOUND_LITERAL_EXPR_DECL_EXPR is the a DECL_EXPR containing the decl |
878 | for the anonymous object represented by the COMPOUND_LITERAL; |
879 | the DECL_INITIAL of that decl is the CONSTRUCTOR that initializes |
880 | the compound literal. */ |
881 | DEFTREECODE (COMPOUND_LITERAL_EXPR, "compound_literal_expr" , tcc_expression, 1) |
882 | |
883 | /* Represents something we computed once and will use multiple times. |
884 | First operand is that expression. After it is evaluated once, it |
885 | will be replaced by the temporary variable that holds the value. */ |
886 | DEFTREECODE (SAVE_EXPR, "save_expr" , tcc_expression, 1) |
887 | |
888 | /* & in C. Value is the address at which the operand's value resides. |
889 | Operand may have any mode. Result mode is Pmode. */ |
890 | DEFTREECODE (ADDR_EXPR, "addr_expr" , tcc_expression, 1) |
891 | |
892 | /* Operand0 is a function constant; result is part N of a function |
893 | descriptor of type ptr_mode. */ |
894 | DEFTREECODE (FDESC_EXPR, "fdesc_expr" , tcc_expression, 2) |
895 | |
896 | /* Given a container value, a replacement value and a bit position within |
897 | the container, produce the value that results from replacing the part of |
898 | the container starting at the bit position with the replacement value. |
899 | Operand 0 is a tree for the container value of integral or vector type; |
900 | Operand 1 is a tree for the replacement value of another integral or |
901 | the vector element type; |
902 | Operand 2 is a tree giving the constant bit position; |
903 | The number of bits replaced is given by the precision of the type of the |
904 | replacement value if it is integral or by its size if it is non-integral. |
905 | ??? The reason to make the size of the replacement implicit is to avoid |
906 | introducing a quaternary operation. |
907 | The replaced bits shall be fully inside the container. If the container |
908 | is of vector type, then these bits shall be aligned with its elements. */ |
909 | DEFTREECODE (BIT_INSERT_EXPR, "bit_insert_expr" , tcc_expression, 3) |
910 | |
911 | /* Given two real or integer operands of the same type, |
912 | returns a complex value of the corresponding complex type. */ |
913 | DEFTREECODE (COMPLEX_EXPR, "complex_expr" , tcc_binary, 2) |
914 | |
915 | /* Complex conjugate of operand. Used only on complex types. */ |
916 | DEFTREECODE (CONJ_EXPR, "conj_expr" , tcc_unary, 1) |
917 | |
918 | /* Nodes for ++ and -- in C. |
919 | The second arg is how much to increment or decrement by. |
920 | For a pointer, it would be the size of the object pointed to. */ |
921 | DEFTREECODE (PREDECREMENT_EXPR, "predecrement_expr" , tcc_expression, 2) |
922 | DEFTREECODE (PREINCREMENT_EXPR, "preincrement_expr" , tcc_expression, 2) |
923 | DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr" , tcc_expression, 2) |
924 | DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr" , tcc_expression, 2) |
925 | |
926 | /* Used to implement `va_arg'. */ |
927 | DEFTREECODE (VA_ARG_EXPR, "va_arg_expr" , tcc_expression, 1) |
928 | |
929 | /* Evaluate operand 0. If and only if an exception is thrown during |
930 | the evaluation of operand 0, evaluate operand 1. |
931 | |
932 | This differs from TRY_FINALLY_EXPR in that operand 1 is not evaluated |
933 | on a normal or jump exit, only on an exception. */ |
934 | DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr" , tcc_statement, 2) |
935 | |
936 | /* Evaluate the first operand. |
937 | The second operand is a cleanup expression which is evaluated |
938 | on any exit (normal, exception, or jump out) from this expression. */ |
939 | DEFTREECODE (TRY_FINALLY_EXPR, "try_finally_expr" , tcc_statement, 2) |
940 | |
941 | /* Evaluate either the normal or the exceptional cleanup. This must |
942 | only be present as the cleanup expression in a TRY_FINALLY_EXPR. |
943 | If the TRY_FINALLY_EXPR completes normally, the first operand of |
944 | EH_ELSE_EXPR is used as a cleanup, otherwise the second operand is |
945 | used. */ |
946 | DEFTREECODE (EH_ELSE_EXPR, "eh_else_expr" , tcc_statement, 2) |
947 | |
948 | /* These types of expressions have no useful value, |
949 | and always have side effects. */ |
950 | |
951 | /* Used to represent a local declaration. The operand is DECL_EXPR_DECL. */ |
952 | DEFTREECODE (DECL_EXPR, "decl_expr" , tcc_statement, 1) |
953 | |
954 | /* A label definition, encapsulated as a statement. |
955 | Operand 0 is the LABEL_DECL node for the label that appears here. |
956 | The type should be void and the value should be ignored. */ |
957 | DEFTREECODE (LABEL_EXPR, "label_expr" , tcc_statement, 1) |
958 | |
959 | /* GOTO. Operand 0 is a LABEL_DECL node or an expression. |
960 | The type should be void and the value should be ignored. */ |
961 | DEFTREECODE (GOTO_EXPR, "goto_expr" , tcc_statement, 1) |
962 | |
963 | /* RETURN. Evaluates operand 0, then returns from the current function. |
964 | Presumably that operand is an assignment that stores into the |
965 | RESULT_DECL that hold the value to be returned. |
966 | The operand may be null. |
967 | The type should be void and the value should be ignored. */ |
968 | DEFTREECODE (RETURN_EXPR, "return_expr" , tcc_statement, 1) |
969 | |
970 | /* Exit the inner most loop conditionally. Operand 0 is the condition. |
971 | The type should be void and the value should be ignored. */ |
972 | DEFTREECODE (EXIT_EXPR, "exit_expr" , tcc_statement, 1) |
973 | |
974 | /* A loop. Operand 0 is the body of the loop. |
975 | It must contain an EXIT_EXPR or is an infinite loop. |
976 | The type should be void and the value should be ignored. */ |
977 | DEFTREECODE (LOOP_EXPR, "loop_expr" , tcc_statement, 1) |
978 | |
979 | /* Switch expression. |
980 | |
981 | TREE_TYPE is the original type of the condition, before any |
982 | language required type conversions. It may be NULL, in which case |
983 | the original type and final types are assumed to be the same. |
984 | |
985 | Operand 0 is the expression used to perform the branch, |
986 | Operand 1 is the body of the switch, which probably contains |
987 | CASE_LABEL_EXPRs. It may also be NULL, in which case operand 2 |
988 | must not be NULL. */ |
989 | DEFTREECODE (SWITCH_EXPR, "switch_expr" , tcc_statement, 2) |
990 | |
991 | /* Used to represent a case label. |
992 | |
993 | Operand 0 is CASE_LOW. It may be NULL_TREE, in which case the label |
994 | is a 'default' label. |
995 | Operand 1 is CASE_HIGH. If it is NULL_TREE, the label is a simple |
996 | (one-value) case label. If it is non-NULL_TREE, the case is a range. |
997 | Operand 2 is CASE_LABEL, which has the corresponding LABEL_DECL. |
998 | Operand 3 is CASE_CHAIN. This operand is only used in tree-cfg.cc to |
999 | speed up the lookup of case labels which use a particular edge in |
1000 | the control flow graph. */ |
1001 | DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr" , tcc_statement, 4) |
1002 | |
1003 | /* Used to represent an inline assembly statement. ASM_STRING returns a |
1004 | STRING_CST for the instruction (e.g., "mov x, y"). ASM_OUTPUTS, |
1005 | ASM_INPUTS, and ASM_CLOBBERS represent the outputs, inputs, and clobbers |
1006 | for the statement. ASM_LABELS, if present, indicates various destinations |
1007 | for the asm; labels cannot be combined with outputs. */ |
1008 | DEFTREECODE (ASM_EXPR, "asm_expr" , tcc_statement, 5) |
1009 | |
1010 | /* Variable references for SSA analysis. New SSA names are created every |
1011 | time a variable is assigned a new value. The SSA builder uses SSA_NAME |
1012 | nodes to implement SSA versioning. */ |
1013 | DEFTREECODE (SSA_NAME, "ssa_name" , tcc_exceptional, 0) |
1014 | |
1015 | /* Used to represent a typed exception handler. CATCH_TYPES is the type (or |
1016 | list of types) handled, and CATCH_BODY is the code for the handler. */ |
1017 | DEFTREECODE (CATCH_EXPR, "catch_expr" , tcc_statement, 2) |
1018 | |
1019 | /* Used to represent an exception specification. EH_FILTER_TYPES is a list |
1020 | of allowed types, and EH_FILTER_FAILURE is an expression to evaluate on |
1021 | failure. */ |
1022 | DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr" , tcc_statement, 2) |
1023 | |
1024 | /* Node used for describing a property that is known at compile |
1025 | time. */ |
1026 | DEFTREECODE (SCEV_KNOWN, "scev_known" , tcc_expression, 0) |
1027 | |
1028 | /* Node used for describing a property that is not known at compile |
1029 | time. */ |
1030 | DEFTREECODE (SCEV_NOT_KNOWN, "scev_not_known" , tcc_expression, 0) |
1031 | |
1032 | /* Polynomial chains of recurrences. |
1033 | cr = {CHREC_LEFT (cr), +, CHREC_RIGHT (cr)}_CHREC_VARIABLE (cr). */ |
1034 | DEFTREECODE (POLYNOMIAL_CHREC, "polynomial_chrec" , tcc_expression, 2) |
1035 | |
1036 | /* Used to chain children of container statements together. |
1037 | Use the interface in tree-iterator.h to access this node. */ |
1038 | DEFTREECODE (STATEMENT_LIST, "statement_list" , tcc_exceptional, 0) |
1039 | |
1040 | /* NOTE: This code is deprecated and should only be used internally by ipa* as |
1041 | temporary construct. |
1042 | |
1043 | Predicate assertion. Artificial expression generated by the optimizers |
1044 | to keep track of predicate values. This expression may only appear on |
1045 | the RHS of assignments. |
1046 | |
1047 | Given X = ASSERT_EXPR <Y, EXPR>, the optimizers can infer |
1048 | two things: |
1049 | |
1050 | 1- X is a copy of Y. |
1051 | 2- EXPR is a conditional expression and is known to be true. |
1052 | |
1053 | Valid and to be expected forms of conditional expressions are |
1054 | valid GIMPLE conditional expressions (as defined by is_gimple_condexpr) |
1055 | and conditional expressions with the first operand being a |
1056 | PLUS_EXPR with a variable possibly wrapped in a NOP_EXPR first |
1057 | operand and an integer constant second operand. |
1058 | |
1059 | The type of the expression is the same as Y. */ |
1060 | DEFTREECODE (ASSERT_EXPR, "assert_expr" , tcc_expression, 2) |
1061 | |
1062 | /* Base class information. Holds information about a class as a |
1063 | baseclass of itself or another class. */ |
1064 | DEFTREECODE (TREE_BINFO, "tree_binfo" , tcc_exceptional, 0) |
1065 | |
1066 | /* Records the size for an expression of variable size type. This is |
1067 | for use in contexts in which we are accessing the entire object, |
1068 | such as for a function call, or block copy. |
1069 | Operand 0 is the real expression. |
1070 | Operand 1 is the size of the type in the expression. */ |
1071 | DEFTREECODE (WITH_SIZE_EXPR, "with_size_expr" , tcc_expression, 2) |
1072 | |
1073 | /* Extract elements from two input vectors Operand 0 and Operand 1 |
1074 | size VS, according to the offset OFF defined by Operand 2 as |
1075 | follows: |
1076 | If OFF > 0, the last VS - OFF elements of vector OP0 are concatenated to |
1077 | the first OFF elements of the vector OP1. |
1078 | If OFF == 0, then the returned vector is OP1. |
1079 | On different targets OFF may take different forms; It can be an address, in |
1080 | which case its low log2(VS)-1 bits define the offset, or it can be a mask |
1081 | generated by the builtin targetm.vectorize.mask_for_load_builtin_decl. */ |
1082 | DEFTREECODE (REALIGN_LOAD_EXPR, "realign_load" , tcc_expression, 3) |
1083 | |
1084 | /* Low-level memory addressing. Operands are BASE (address of static or |
1085 | global variable or register), OFFSET (integer constant), |
1086 | INDEX (register), STEP (integer constant), INDEX2 (register), |
1087 | The corresponding address is BASE + STEP * INDEX + INDEX2 + OFFSET. |
1088 | Only variations and values valid on the target are allowed. |
1089 | |
1090 | The type of STEP, INDEX and INDEX2 is sizetype. |
1091 | |
1092 | The type of BASE is a pointer type. If BASE is not an address of |
1093 | a static or global variable INDEX2 will be NULL. |
1094 | |
1095 | The type of OFFSET is a pointer type and determines TBAA the same as |
1096 | the constant offset operand in MEM_REF. */ |
1097 | |
1098 | DEFTREECODE (TARGET_MEM_REF, "target_mem_ref" , tcc_reference, 5) |
1099 | |
1100 | /* Memory addressing. Operands are a pointer and a tree constant integer |
1101 | byte offset of the pointer type that when dereferenced yields the |
1102 | type of the base object the pointer points into and which is used for |
1103 | TBAA purposes. |
1104 | The type of the MEM_REF is the type the bytes at the memory location |
1105 | are interpreted as. |
1106 | MEM_REF <p, c> is equivalent to ((typeof(c))p)->x... where x... is a |
1107 | chain of component references offsetting p by c. */ |
1108 | DEFTREECODE (MEM_REF, "mem_ref" , tcc_reference, 2) |
1109 | |
1110 | /* OpenACC and OpenMP. As it is exposed in TREE_RANGE_CHECK invocations, do |
1111 | not change the ordering of these codes. */ |
1112 | |
1113 | /* OpenACC - #pragma acc parallel [clause1 ... clauseN] |
1114 | Operand 0: OMP_BODY: Code to be executed in parallel. |
1115 | Operand 1: OMP_CLAUSES: List of clauses. */ |
1116 | |
1117 | DEFTREECODE (OACC_PARALLEL, "oacc_parallel" , tcc_statement, 2) |
1118 | |
1119 | /* OpenACC - #pragma acc kernels [clause1 ... clauseN] |
1120 | Operand 0: OMP_BODY: Sequence of kernels. |
1121 | Operand 1: OMP_CLAUSES: List of clauses. */ |
1122 | |
1123 | DEFTREECODE (OACC_KERNELS, "oacc_kernels" , tcc_statement, 2) |
1124 | |
1125 | /* OpenACC - #pragma acc serial [clause1 ... clauseN] |
1126 | Operand 0: OMP_BODY: Code to be executed sequentially. |
1127 | Operand 1: OMP_CLAUSES: List of clauses. */ |
1128 | |
1129 | DEFTREECODE (OACC_SERIAL, "oacc_serial" , tcc_statement, 2) |
1130 | |
1131 | /* OpenACC - #pragma acc data [clause1 ... clauseN] |
1132 | Operand 0: OACC_DATA_BODY: Data construct body. |
1133 | Operand 1: OACC_DATA_CLAUSES: List of clauses. */ |
1134 | |
1135 | DEFTREECODE (OACC_DATA, "oacc_data" , tcc_statement, 2) |
1136 | |
1137 | /* OpenACC - #pragma acc host_data [clause1 ... clauseN] |
1138 | Operand 0: OACC_HOST_DATA_BODY: Host_data construct body. |
1139 | Operand 1: OACC_HOST_DATA_CLAUSES: List of clauses. */ |
1140 | |
1141 | DEFTREECODE (OACC_HOST_DATA, "oacc_host_data" , tcc_statement, 2) |
1142 | |
1143 | /* OpenMP - #pragma omp parallel [clause1 ... clauseN] |
1144 | Operand 0: OMP_PARALLEL_BODY: Code to be executed by all threads. |
1145 | Operand 1: OMP_PARALLEL_CLAUSES: List of clauses. */ |
1146 | |
1147 | DEFTREECODE (OMP_PARALLEL, "omp_parallel" , tcc_statement, 2) |
1148 | |
1149 | /* OpenMP - #pragma omp task [clause1 ... clauseN] |
1150 | Operand 0: OMP_TASK_BODY: Code to be executed by all threads. |
1151 | Operand 1: OMP_TASK_CLAUSES: List of clauses. */ |
1152 | |
1153 | DEFTREECODE (OMP_TASK, "omp_task" , tcc_statement, 2) |
1154 | |
1155 | /* OpenMP - #pragma omp for [clause1 ... clauseN] |
1156 | |
1157 | A single OMP_FOR node represents an entire nest of collapsed |
1158 | loops; as noted below, some of its arguments are vectors of length |
1159 | equal to the collapse depth, and the corresponding elements holding |
1160 | data specific to a particular loop in the nest. These vectors are |
1161 | numbered from the outside in so that the outermost loop is element 0. |
1162 | |
1163 | These constructs have seven operands: |
1164 | |
1165 | Operand 0: OMP_FOR_BODY contains the loop body. |
1166 | |
1167 | Operand 1: OMP_FOR_CLAUSES is the list of clauses |
1168 | associated with the directive. |
1169 | |
1170 | Operand 2: OMP_FOR_INIT is a vector containing iteration |
1171 | variable initializations of the form VAR = N1. |
1172 | |
1173 | Operand 3: OMP_FOR_COND is vector containing loop |
1174 | conditional expressions of the form VAR {<,>,<=,>=,!=} N2. |
1175 | |
1176 | Operand 4: OMP_FOR_INCR is a vector containing loop index |
1177 | increment expressions of the form VAR {+=,-=} INCR. |
1178 | |
1179 | Operand 5: OMP_FOR_PRE_BODY contains side effect code from |
1180 | operands OMP_FOR_INIT, OMP_FOR_COND and |
1181 | OMP_FOR_INCR. These side effects are part of the |
1182 | OMP_FOR block but must be evaluated before the start of |
1183 | loop body. OMP_FOR_PRE_BODY specifically |
1184 | includes DECL_EXPRs for iteration variables that are |
1185 | declared in the nested for loops. |
1186 | Note this field is not a vector; it may be null, but otherwise is |
1187 | usually a statement list collecting the side effect code from all |
1188 | the collapsed loops. |
1189 | |
1190 | Operand 6: OMP_FOR_ORIG_DECLS holds VAR_DECLS for the |
1191 | original user-specified iterator variables in the source code. |
1192 | In some cases, like C++ class iterators or range for with |
1193 | decomposition, the for loop is rewritten by the front end to |
1194 | use a temporary iteration variable. The purpose of this field is to |
1195 | make the original variables available to the gimplifier so it can |
1196 | adjust their data-sharing attributes and diagnose errors. |
1197 | OMP_FOR_ORIG_DECLS is a vector field, with each element holding |
1198 | a list of VAR_DECLS for the corresponding collapse level. |
1199 | |
1200 | The loop index variable VAR must be an integer variable, |
1201 | which is implicitly private to each thread. For rectangular loops, |
1202 | the bounds N1 and N2 and the increment expression |
1203 | INCR are required to be loop-invariant integer expressions |
1204 | that are evaluated without any synchronization. The evaluation order, |
1205 | frequency of evaluation and side effects are otherwise unspecified |
1206 | by the standard. |
1207 | |
1208 | For non-rectangular loops, in which the bounds of an inner loop depend |
1209 | on the index of an outer loop, the bit OMP_FOR_NON_RECTANGULAR |
1210 | must be set. In this case N1 and N2 are not ordinary |
1211 | expressions, but instead a TREE_VEC with three elements: |
1212 | the DECL for the outer loop variable, a multiplication |
1213 | factor, and an offset. */ |
1214 | |
1215 | DEFTREECODE (OMP_FOR, "omp_for" , tcc_statement, 7) |
1216 | |
1217 | /* OpenMP - #pragma omp simd [clause1 ... clauseN] |
1218 | Operands like for OMP_FOR. */ |
1219 | DEFTREECODE (OMP_SIMD, "omp_simd" , tcc_statement, 7) |
1220 | |
1221 | /* OpenMP - #pragma omp distribute [clause1 ... clauseN] |
1222 | Operands like for OMP_FOR. */ |
1223 | DEFTREECODE (OMP_DISTRIBUTE, "omp_distribute" , tcc_statement, 7) |
1224 | |
1225 | /* OpenMP - #pragma omp taskloop [clause1 ... clauseN] |
1226 | Operands like for OMP_FOR. */ |
1227 | DEFTREECODE (OMP_TASKLOOP, "omp_taskloop" , tcc_statement, 7) |
1228 | |
1229 | /* OpenMP - #pragma omp loop [clause1 ... clauseN] |
1230 | Operands like for OMP_FOR. */ |
1231 | DEFTREECODE (OMP_LOOP, "omp_loop" , tcc_statement, 7) |
1232 | |
1233 | /* OpenMP - #pragma acc loop [clause1 ... clauseN] |
1234 | Operands like for OMP_FOR. */ |
1235 | DEFTREECODE (OACC_LOOP, "oacc_loop" , tcc_statement, 7) |
1236 | |
1237 | /* OpenMP - #pragma omp teams [clause1 ... clauseN] |
1238 | Operand 0: OMP_TEAMS_BODY: Teams body. |
1239 | Operand 1: OMP_TEAMS_CLAUSES: List of clauses. */ |
1240 | DEFTREECODE (OMP_TEAMS, "omp_teams" , tcc_statement, 2) |
1241 | |
1242 | /* OpenMP - #pragma omp target data [clause1 ... clauseN] |
1243 | Operand 0: OMP_TARGET_DATA_BODY: Target data construct body. |
1244 | Operand 1: OMP_TARGET_DATA_CLAUSES: List of clauses. */ |
1245 | DEFTREECODE (OMP_TARGET_DATA, "omp_target_data" , tcc_statement, 2) |
1246 | |
1247 | /* OpenMP - #pragma omp target [clause1 ... clauseN] |
1248 | Operand 0: OMP_TARGET_BODY: Target construct body. |
1249 | Operand 1: OMP_TARGET_CLAUSES: List of clauses. */ |
1250 | DEFTREECODE (OMP_TARGET, "omp_target" , tcc_statement, 2) |
1251 | |
1252 | /* OpenMP - #pragma omp sections [clause1 ... clauseN] |
1253 | Operand 0: OMP_SECTIONS_BODY: Sections body. |
1254 | Operand 1: OMP_SECTIONS_CLAUSES: List of clauses. */ |
1255 | DEFTREECODE (OMP_SECTIONS, "omp_sections" , tcc_statement, 2) |
1256 | |
1257 | /* OpenMP - #pragma omp ordered |
1258 | Operand 0: OMP_ORDERED_BODY: Master section body. |
1259 | Operand 1: OMP_ORDERED_CLAUSES: List of clauses. */ |
1260 | DEFTREECODE (OMP_ORDERED, "omp_ordered" , tcc_statement, 2) |
1261 | |
1262 | /* OpenMP - #pragma omp critical [name] |
1263 | Operand 0: OMP_CRITICAL_BODY: Critical section body. |
1264 | Operand 1: OMP_CRITICAL_CLAUSES: List of clauses. |
1265 | Operand 2: OMP_CRITICAL_NAME: Identifier for critical section. */ |
1266 | DEFTREECODE (OMP_CRITICAL, "omp_critical" , tcc_statement, 3) |
1267 | |
1268 | /* OpenMP - #pragma omp single |
1269 | Operand 0: OMP_SINGLE_BODY: Single section body. |
1270 | Operand 1: OMP_SINGLE_CLAUSES: List of clauses. */ |
1271 | DEFTREECODE (OMP_SINGLE, "omp_single" , tcc_statement, 2) |
1272 | |
1273 | /* OpenMP - #pragma omp scope |
1274 | Operand 0: OMP_SCOPE_BODY: Masked section body. |
1275 | Operand 1: OMP_SCOPE_CLAUSES: List of clauses. */ |
1276 | DEFTREECODE (OMP_SCOPE, "omp_scope" , tcc_statement, 2) |
1277 | |
1278 | /* OpenMP - #pragma omp taskgroup |
1279 | Operand 0: OMP_TASKGROUP_BODY: Taskgroup body. |
1280 | Operand 1: OMP_SINGLE_CLAUSES: List of clauses. */ |
1281 | DEFTREECODE (OMP_TASKGROUP, "omp_taskgroup" , tcc_statement, 2) |
1282 | |
1283 | /* OpenMP - #pragma omp masked |
1284 | Operand 0: OMP_MASKED_BODY: Masked section body. |
1285 | Operand 1: OMP_MASKED_CLAUSES: List of clauses. */ |
1286 | DEFTREECODE (OMP_MASKED, "omp_masked" , tcc_statement, 2) |
1287 | |
1288 | /* OpenMP - #pragma omp scan |
1289 | Operand 0: OMP_SCAN_BODY: Scan body. |
1290 | Operand 1: OMP_SCAN_CLAUSES: List of clauses. */ |
1291 | DEFTREECODE (OMP_SCAN, "omp_scan" , tcc_statement, 2) |
1292 | |
1293 | /* OpenMP - #pragma omp section |
1294 | Operand 0: OMP_SECTION_BODY: Section body. */ |
1295 | DEFTREECODE (OMP_SECTION, "omp_section" , tcc_statement, 1) |
1296 | |
1297 | /* OpenMP structured block sequences that don't correspond to the body |
1298 | another directive. This is used for code fragments within the body |
1299 | of a directive that are separately required to be structured block |
1300 | sequence; in particular, for intervening code sequences in |
1301 | imperfectly-nested loops. |
1302 | Operand 0: BODY: contains the statement(s) within the structured block |
1303 | sequence. */ |
1304 | DEFTREECODE (OMP_STRUCTURED_BLOCK, "omp_structured_block" , tcc_statement, 1) |
1305 | |
1306 | /* OpenMP - #pragma omp master |
1307 | Operand 0: OMP_MASTER_BODY: Master section body. */ |
1308 | DEFTREECODE (OMP_MASTER, "omp_master" , tcc_statement, 1) |
1309 | |
1310 | /* OpenACC - #pragma acc cache (variable1 ... variableN) |
1311 | Operand 0: OACC_CACHE_CLAUSES: List of variables (transformed into |
1312 | OMP_CLAUSE__CACHE_ clauses). */ |
1313 | DEFTREECODE (OACC_CACHE, "oacc_cache" , tcc_statement, 1) |
1314 | |
1315 | /* OpenACC - #pragma acc declare [clause1 ... clauseN] |
1316 | Operand 0: OACC_DECLARE_CLAUSES: List of clauses. */ |
1317 | DEFTREECODE (OACC_DECLARE, "oacc_declare" , tcc_statement, 1) |
1318 | |
1319 | /* OpenACC - #pragma acc enter data [clause1 ... clauseN] |
1320 | Operand 0: OACC_ENTER_DATA_CLAUSES: List of clauses. */ |
1321 | DEFTREECODE (OACC_ENTER_DATA, "oacc_enter_data" , tcc_statement, 1) |
1322 | |
1323 | /* OpenACC - #pragma acc exit data [clause1 ... clauseN] |
1324 | Operand 0: OACC_EXIT_DATA_CLAUSES: List of clauses. */ |
1325 | DEFTREECODE (OACC_EXIT_DATA, "oacc_exit_data" , tcc_statement, 1) |
1326 | |
1327 | /* OpenACC - #pragma acc update [clause1 ... clauseN] |
1328 | Operand 0: OACC_UPDATE_CLAUSES: List of clauses. */ |
1329 | DEFTREECODE (OACC_UPDATE, "oacc_update" , tcc_statement, 1) |
1330 | |
1331 | /* OpenMP - #pragma omp target update [clause1 ... clauseN] |
1332 | Operand 0: OMP_TARGET_UPDATE_CLAUSES: List of clauses. */ |
1333 | DEFTREECODE (OMP_TARGET_UPDATE, "omp_target_update" , tcc_statement, 1) |
1334 | |
1335 | /* OpenMP - #pragma omp target enter data [clause1 ... clauseN] |
1336 | Operand 0: OMP_TARGET_ENTER_DATA_CLAUSES: List of clauses. */ |
1337 | DEFTREECODE (OMP_TARGET_ENTER_DATA, "omp_target_enter_data" , tcc_statement, 1) |
1338 | |
1339 | /* OpenMP - #pragma omp target exit data [clause1 ... clauseN] |
1340 | Operand 0: OMP_TARGET_EXIT_DATA_CLAUSES: List of clauses. */ |
1341 | DEFTREECODE (OMP_TARGET_EXIT_DATA, "omp_target_exit_data" , tcc_statement, 1) |
1342 | |
1343 | /* OMP_ATOMIC through OMP_ATOMIC_CAPTURE_NEW must be consecutive, |
1344 | or OMP_ATOMIC_SEQ_CST needs adjusting. */ |
1345 | |
1346 | /* OpenMP - #pragma omp atomic |
1347 | Operand 0: The address at which the atomic operation is to be performed. |
1348 | This address should be stabilized with save_expr. |
1349 | Operand 1: The expression to evaluate. When the old value of the object |
1350 | at the address is used in the expression, it should appear as if |
1351 | build_fold_indirect_ref of the address. */ |
1352 | DEFTREECODE (OMP_ATOMIC, "omp_atomic" , tcc_statement, 2) |
1353 | |
1354 | /* OpenMP - #pragma omp atomic read |
1355 | Operand 0: The address at which the atomic operation is to be performed. |
1356 | This address should be stabilized with save_expr. */ |
1357 | DEFTREECODE (OMP_ATOMIC_READ, "omp_atomic_read" , tcc_statement, 1) |
1358 | |
1359 | /* OpenMP - #pragma omp atomic capture |
1360 | Operand 0: The address at which the atomic operation is to be performed. |
1361 | This address should be stabilized with save_expr. |
1362 | Operand 1: The expression to evaluate. When the old value of the object |
1363 | at the address is used in the expression, it should appear as if |
1364 | build_fold_indirect_ref of the address. |
1365 | OMP_ATOMIC_CAPTURE_OLD returns the old memory content, |
1366 | OMP_ATOMIC_CAPTURE_NEW the new value. */ |
1367 | DEFTREECODE (OMP_ATOMIC_CAPTURE_OLD, "omp_atomic_capture_old" , tcc_statement, 2) |
1368 | DEFTREECODE (OMP_ATOMIC_CAPTURE_NEW, "omp_atomic_capture_new" , tcc_statement, 2) |
1369 | |
1370 | /* OpenMP clauses. */ |
1371 | DEFTREECODE (OMP_CLAUSE, "omp_clause" , tcc_exceptional, 0) |
1372 | |
1373 | /* TRANSACTION_EXPR tree code. |
1374 | Operand 0: BODY: contains body of the transaction. */ |
1375 | DEFTREECODE (TRANSACTION_EXPR, "transaction_expr" , tcc_expression, 1) |
1376 | |
1377 | /* Widening dot-product. |
1378 | The first two arguments are of type t1. |
1379 | The third argument and the result are of type t2, such that t2 is at least |
1380 | twice the size of t1. DOT_PROD_EXPR(arg1,arg2,arg3) is equivalent to: |
1381 | tmp = WIDEN_MULT_EXPR(arg1, arg2); |
1382 | arg3 = PLUS_EXPR (tmp, arg3); |
1383 | or: |
1384 | tmp = WIDEN_MULT_EXPR(arg1, arg2); |
1385 | arg3 = WIDEN_SUM_EXPR (tmp, arg3); */ |
1386 | DEFTREECODE (DOT_PROD_EXPR, "dot_prod_expr" , tcc_expression, 3) |
1387 | |
1388 | /* Widening summation. |
1389 | The first argument is of type t1. |
1390 | The second argument is of type t2, such that t2 is at least twice |
1391 | the size of t1. The type of the entire expression is also t2. |
1392 | WIDEN_SUM_EXPR is equivalent to first widening (promoting) |
1393 | the first argument from type t1 to type t2, and then summing it |
1394 | with the second argument. */ |
1395 | DEFTREECODE (WIDEN_SUM_EXPR, "widen_sum_expr" , tcc_binary, 2) |
1396 | |
1397 | /* Widening sad (sum of absolute differences). |
1398 | The first two arguments are of type t1 which should be a vector of integers. |
1399 | The third argument and the result are of type t2, such that the size of |
1400 | the elements of t2 is at least twice the size of the elements of t1. |
1401 | Like DOT_PROD_EXPR, SAD_EXPR (arg1,arg2,arg3) is |
1402 | equivalent to: |
1403 | tmp = IFN_VEC_WIDEN_MINUS_EXPR (arg1, arg2) |
1404 | tmp2 = ABS_EXPR (tmp) |
1405 | arg3 = PLUS_EXPR (tmp2, arg3) |
1406 | or: |
1407 | tmp = IFN_VEC_WIDEN_MINUS_EXPR (arg1, arg2) |
1408 | tmp2 = ABS_EXPR (tmp) |
1409 | arg3 = WIDEN_SUM_EXPR (tmp2, arg3) |
1410 | */ |
1411 | DEFTREECODE (SAD_EXPR, "sad_expr" , tcc_expression, 3) |
1412 | |
1413 | /* Widening multiplication. |
1414 | The two arguments are of type t1 and t2, both integral types that |
1415 | have the same precision, but possibly different signedness. |
1416 | The result is of integral type t3, such that t3 is at least twice |
1417 | the size of t1/t2. WIDEN_MULT_EXPR is equivalent to first widening |
1418 | (promoting) the arguments from type t1 to type t3, and from t2 to |
1419 | type t3 and then multiplying them. */ |
1420 | DEFTREECODE (WIDEN_MULT_EXPR, "widen_mult_expr" , tcc_binary, 2) |
1421 | |
1422 | /* Widening multiply-accumulate. |
1423 | The first two arguments are of type t1. |
1424 | The third argument and the result are of type t2, such as t2 is at least |
1425 | twice the size of t1. t1 and t2 must be integral or fixed-point types. |
1426 | The expression is equivalent to a WIDEN_MULT_EXPR operation |
1427 | of the first two operands followed by an add or subtract of the third |
1428 | operand. */ |
1429 | DEFTREECODE (WIDEN_MULT_PLUS_EXPR, "widen_mult_plus_expr" , tcc_expression, 3) |
1430 | /* This is like the above, except in the final expression the multiply result |
1431 | is subtracted from t3. */ |
1432 | DEFTREECODE (WIDEN_MULT_MINUS_EXPR, "widen_mult_minus_expr" , tcc_expression, 3) |
1433 | |
1434 | /* Widening shift left. |
1435 | The first operand is of type t1. |
1436 | The second operand is the number of bits to shift by; it need not be the |
1437 | same type as the first operand and result. |
1438 | Note that the result is undefined if the second operand is larger |
1439 | than or equal to the first operand's type size. |
1440 | The type of the entire expression is t2, such that t2 is at least twice |
1441 | the size of t1. |
1442 | WIDEN_LSHIFT_EXPR is equivalent to first widening (promoting) |
1443 | the first argument from type t1 to type t2, and then shifting it |
1444 | by the second argument. */ |
1445 | DEFTREECODE (WIDEN_LSHIFT_EXPR, "widen_lshift_expr" , tcc_binary, 2) |
1446 | |
1447 | /* Widening vector multiplication. |
1448 | The two operands are vectors with N elements of size S. Multiplying the |
1449 | elements of the two vectors will result in N products of size 2*S. |
1450 | VEC_WIDEN_MULT_HI_EXPR computes the N/2 high products. |
1451 | VEC_WIDEN_MULT_LO_EXPR computes the N/2 low products. */ |
1452 | DEFTREECODE (VEC_WIDEN_MULT_HI_EXPR, "widen_mult_hi_expr" , tcc_binary, 2) |
1453 | DEFTREECODE (VEC_WIDEN_MULT_LO_EXPR, "widen_mult_lo_expr" , tcc_binary, 2) |
1454 | |
1455 | /* Similarly, but return the even or odd N/2 products. */ |
1456 | DEFTREECODE (VEC_WIDEN_MULT_EVEN_EXPR, "widen_mult_even_expr" , tcc_binary, 2) |
1457 | DEFTREECODE (VEC_WIDEN_MULT_ODD_EXPR, "widen_mult_odd_expr" , tcc_binary, 2) |
1458 | |
1459 | /* Unpack (extract and promote/widen) the high/low elements of the input |
1460 | vector into the output vector. The input vector has twice as many |
1461 | elements as the output vector, that are half the size of the elements |
1462 | of the output vector. This is used to support type promotion. */ |
1463 | DEFTREECODE (VEC_UNPACK_HI_EXPR, "vec_unpack_hi_expr" , tcc_unary, 1) |
1464 | DEFTREECODE (VEC_UNPACK_LO_EXPR, "vec_unpack_lo_expr" , tcc_unary, 1) |
1465 | |
1466 | /* Unpack (extract) the high/low elements of the input vector, convert |
1467 | fixed point values to floating point and widen elements into the |
1468 | output vector. The input vector has twice as many elements as the output |
1469 | vector, that are half the size of the elements of the output vector. */ |
1470 | DEFTREECODE (VEC_UNPACK_FLOAT_HI_EXPR, "vec_unpack_float_hi_expr" , tcc_unary, 1) |
1471 | DEFTREECODE (VEC_UNPACK_FLOAT_LO_EXPR, "vec_unpack_float_lo_expr" , tcc_unary, 1) |
1472 | |
1473 | /* Unpack (extract) the high/low elements of the input vector, convert |
1474 | floating point values to integer and widen elements into the output |
1475 | vector. The input vector has twice as many elements as the output |
1476 | vector, that are half the size of the elements of the output vector. */ |
1477 | DEFTREECODE (VEC_UNPACK_FIX_TRUNC_HI_EXPR, "vec_unpack_fix_trunc_hi_expr" , |
1478 | tcc_unary, 1) |
1479 | DEFTREECODE (VEC_UNPACK_FIX_TRUNC_LO_EXPR, "vec_unpack_fix_trunc_lo_expr" , |
1480 | tcc_unary, 1) |
1481 | |
1482 | /* Pack (demote/narrow and merge) the elements of the two input vectors |
1483 | into the output vector using truncation/saturation. |
1484 | The elements of the input vectors are twice the size of the elements of the |
1485 | output vector. This is used to support type demotion. */ |
1486 | DEFTREECODE (VEC_PACK_TRUNC_EXPR, "vec_pack_trunc_expr" , tcc_binary, 2) |
1487 | DEFTREECODE (VEC_PACK_SAT_EXPR, "vec_pack_sat_expr" , tcc_binary, 2) |
1488 | |
1489 | /* Convert floating point values of the two input vectors to integer |
1490 | and pack (narrow and merge) the elements into the output vector. The |
1491 | elements of the input vector are twice the size of the elements of |
1492 | the output vector. */ |
1493 | DEFTREECODE (VEC_PACK_FIX_TRUNC_EXPR, "vec_pack_fix_trunc_expr" , tcc_binary, 2) |
1494 | |
1495 | /* Convert fixed point values of the two input vectors to floating point |
1496 | and pack (narrow and merge) the elements into the output vector. The |
1497 | elements of the input vector are twice the size of the elements of |
1498 | the output vector. */ |
1499 | DEFTREECODE (VEC_PACK_FLOAT_EXPR, "vec_pack_float_expr" , tcc_binary, 2) |
1500 | |
1501 | /* Widening vector shift left in bits. |
1502 | Operand 0 is a vector to be shifted with N elements of size S. |
1503 | Operand 1 is an integer shift amount in bits. |
1504 | The result of the operation is N elements of size 2*S. |
1505 | VEC_WIDEN_LSHIFT_HI_EXPR computes the N/2 high results. |
1506 | VEC_WIDEN_LSHIFT_LO_EXPR computes the N/2 low results. |
1507 | */ |
1508 | DEFTREECODE (VEC_WIDEN_LSHIFT_HI_EXPR, "widen_lshift_hi_expr" , tcc_binary, 2) |
1509 | DEFTREECODE (VEC_WIDEN_LSHIFT_LO_EXPR, "widen_lshift_lo_expr" , tcc_binary, 2) |
1510 | |
1511 | /* PREDICT_EXPR. Specify hint for branch prediction. The |
1512 | PREDICT_EXPR_PREDICTOR specify predictor and PREDICT_EXPR_OUTCOME the |
1513 | outcome (0 for not taken and 1 for taken). Once the profile is guessed |
1514 | all conditional branches leading to execution paths executing the |
1515 | PREDICT_EXPR will get predicted by the specified predictor. */ |
1516 | DEFTREECODE (PREDICT_EXPR, "predict_expr" , tcc_expression, 1) |
1517 | |
1518 | /* OPTIMIZATION_NODE. Node to store the optimization options. */ |
1519 | DEFTREECODE (OPTIMIZATION_NODE, "optimization_node" , tcc_exceptional, 0) |
1520 | |
1521 | /* TARGET_OPTION_NODE. Node to store the target specific options. */ |
1522 | DEFTREECODE (TARGET_OPTION_NODE, "target_option_node" , tcc_exceptional, 0) |
1523 | |
1524 | /* ANNOTATE_EXPR. |
1525 | Operand 0 is the expression to be annotated. |
1526 | Operand 1 is the annotation kind. |
1527 | Operand 2 is additional data. */ |
1528 | DEFTREECODE (ANNOTATE_EXPR, "annotate_expr" , tcc_expression, 3) |
1529 | |
1530 | /* |
1531 | Local variables: |
1532 | mode:c |
1533 | End: |
1534 | */ |
1535 | |