tree.def source code [gcc/tree.def]

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

Provided by KDAB

Improve your Profiling and Debugging skills

Find out more

source code of gcc/tree.def