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

source code of gcc/tree.def