GCC Middle and Back End API Reference
tree.h
Go to the documentation of this file.
1/* Definitions for the ubiquitous 'tree' type for GNU compilers.
2 Copyright (C) 1989-2025 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#ifndef GCC_TREE_H
21#define GCC_TREE_H
22
23#include "tree-core.h"
24#include "options.h"
25#include "vec.h"
26
27/* Convert a target-independent built-in function code to a combined_fn. */
28
29inline combined_fn
31{
32 return combined_fn (int (fn));
33}
34
35/* Convert an internal function code to a combined_fn. */
36
37inline combined_fn
39{
40 return combined_fn (int (fn) + int (END_BUILTINS));
41}
42
43/* Return true if CODE is a target-independent built-in function. */
44
45inline bool
47{
48 return int (code) < int (END_BUILTINS);
49}
50
51/* Return the target-independent built-in function represented by CODE.
52 Only valid if builtin_fn_p (CODE). */
53
56{
58 return built_in_function (int (code));
59}
60
61/* Return true if CODE is an internal function. */
62
63inline bool
65{
66 return int (code) >= int (END_BUILTINS);
67}
68
69/* Return the internal function represented by CODE. Only valid if
70 internal_fn_p (CODE). */
71
72inline internal_fn
74{
76 return internal_fn (int (code) - int (END_BUILTINS));
77}
78
79/* Helper to transparently allow tree codes and builtin function codes
80 exist in one storage entity. */
82{
83public:
85 code_helper (tree_code code) : rep ((int) code) {}
86 code_helper (combined_fn fn) : rep (-(int) fn) {}
87 code_helper (internal_fn fn) : rep (-(int) as_combined_fn (fn)) {}
88 explicit operator tree_code () const { return (tree_code) rep; }
89 explicit operator combined_fn () const { return (combined_fn) -rep; }
90 explicit operator internal_fn () const;
91 explicit operator built_in_function () const;
92 bool is_tree_code () const { return rep > 0; }
93 bool is_fn_code () const { return rep < 0; }
94 bool is_internal_fn () const;
95 bool is_builtin_fn () const;
96 int get_rep () const { return rep; }
99 bool operator== (const code_helper &other) { return rep == other.rep; }
100 bool operator!= (const code_helper &other) { return rep != other.rep; }
101 bool operator== (tree_code c) { return rep == code_helper (c).rep; }
102 bool operator!= (tree_code c) { return rep != code_helper (c).rep; }
103
104private:
105 int rep;
106};
107
108/* Helper function that returns the tree_code representation of THIS
109 code_helper if it is a tree_code and MAX_TREE_CODES otherwise. This is
110 useful when passing a code_helper to a tree_code only check. */
111
112inline tree_code
114{
115 return is_tree_code () ? (tree_code) *this : MAX_TREE_CODES;
116}
117
118/* Helper function that returns the combined_fn representation of THIS
119 code_helper if it is a fn_code and CFN_LAST otherwise. This is useful when
120 passing a code_helper to a combined_fn only check. */
121
122inline combined_fn
124 return is_fn_code () ? (combined_fn) *this : CFN_LAST;
125}
126
127inline code_helper::operator internal_fn () const
128{
129 return as_internal_fn (combined_fn (*this));
130}
131
132inline code_helper::operator built_in_function () const
133{
134 return as_builtin_fn (combined_fn (*this));
135}
136
137inline bool
139{
140 return is_fn_code () && internal_fn_p (combined_fn (*this));
141}
142
143inline bool
145{
146 return is_fn_code () && builtin_fn_p (combined_fn (*this));
147}
148
149/* Macros for initializing `tree_contains_struct'. */
150#define MARK_TS_BASE(C) \
151 (tree_contains_struct[C][TS_BASE] = true)
152
153#define MARK_TS_TYPED(C) \
154 (MARK_TS_BASE (C), \
155 tree_contains_struct[C][TS_TYPED] = true)
156
157#define MARK_TS_COMMON(C) \
158 (MARK_TS_TYPED (C), \
159 tree_contains_struct[C][TS_COMMON] = true)
160
161#define MARK_TS_TYPE_COMMON(C) \
162 (MARK_TS_COMMON (C), \
163 tree_contains_struct[C][TS_TYPE_COMMON] = true)
164
165#define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C) \
166 (MARK_TS_TYPE_COMMON (C), \
167 tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
168
169#define MARK_TS_TYPE_NON_COMMON(C) \
170 (MARK_TS_TYPE_WITH_LANG_SPECIFIC (C), \
171 tree_contains_struct[C][TS_TYPE_NON_COMMON] = true) \
172
173#define MARK_TS_DECL_MINIMAL(C) \
174 (MARK_TS_COMMON (C), \
175 tree_contains_struct[C][TS_DECL_MINIMAL] = true)
176
177#define MARK_TS_DECL_COMMON(C) \
178 (MARK_TS_DECL_MINIMAL (C), \
179 tree_contains_struct[C][TS_DECL_COMMON] = true)
180
181#define MARK_TS_DECL_WRTL(C) \
182 (MARK_TS_DECL_COMMON (C), \
183 tree_contains_struct[C][TS_DECL_WRTL] = true)
184
185#define MARK_TS_DECL_WITH_VIS(C) \
186 (MARK_TS_DECL_WRTL (C), \
187 tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
188
189#define MARK_TS_DECL_NON_COMMON(C) \
190 (MARK_TS_DECL_WITH_VIS (C), \
191 tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
192
193#define MARK_TS_EXP(C) \
194 (MARK_TS_TYPED (C), \
195 tree_contains_struct[C][TS_EXP] = true)
196
197/* Returns the string representing CLASS. */
198
199#define TREE_CODE_CLASS_STRING(CLASS)\
200 tree_code_class_strings[(int) (CLASS)]
201
202#if __cpp_inline_variables < 201606L
203#define TREE_CODE_CLASS(CODE) \
204 tree_code_type_tmpl <0>::tree_code_type[(int) (CODE)]
205#else
206#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
207#endif
208
209/* Nonzero if NODE represents an exceptional code. */
210
211#define EXCEPTIONAL_CLASS_P(NODE)\
212 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_exceptional)
213
214/* Nonzero if NODE represents a constant. */
215
216#define CONSTANT_CLASS_P(NODE)\
217 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_constant)
218
219/* Nonzero if NODE represents a constant, or is a location wrapper
220 around such a node. */
221
222#define CONSTANT_CLASS_OR_WRAPPER_P(NODE)\
223 (CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE)))
224
225/* Nonzero if NODE represents a type. */
226
227#define TYPE_P(NODE)\
228 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_type)
229
230/* Nonzero if NODE represents a declaration. */
231
232#define DECL_P(NODE)\
233 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_declaration)
234
235/* True if NODE designates a variable declaration. */
236#define VAR_P(NODE) \
237 (TREE_CODE (NODE) == VAR_DECL)
238
239/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */
240
241#define VAR_OR_FUNCTION_DECL_P(DECL)\
242 (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)
243
244/* Nonzero if NODE represents a INDIRECT_REF. Keep these checks in
245 ascending code order. */
246
247#define INDIRECT_REF_P(NODE)\
248 (TREE_CODE (NODE) == INDIRECT_REF)
249
250/* Nonzero if NODE represents a reference. */
251
252#define REFERENCE_CLASS_P(NODE)\
253 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_reference)
254
255/* Nonzero if NODE represents a comparison. */
256
257#define COMPARISON_CLASS_P(NODE)\
258 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_comparison)
259
260/* Nonzero if NODE represents a unary arithmetic expression. */
261
262#define UNARY_CLASS_P(NODE)\
263 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_unary)
264
265/* Nonzero if NODE represents a binary arithmetic expression. */
266
267#define BINARY_CLASS_P(NODE)\
268 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_binary)
269
270/* Nonzero if NODE represents a statement expression. */
271
272#define STATEMENT_CLASS_P(NODE)\
273 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_statement)
274
275/* Nonzero if NODE represents a function call-like expression with a
276 variable-length operand vector. */
277
278#define VL_EXP_CLASS_P(NODE)\
279 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_vl_exp)
280
281/* Nonzero if NODE represents any other expression. */
282
283#define EXPRESSION_CLASS_P(NODE)\
284 (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_expression)
285
286/* Returns nonzero iff NODE represents a type or declaration. */
287
288#define IS_TYPE_OR_DECL_P(NODE)\
289 (TYPE_P (NODE) || DECL_P (NODE))
290
291/* Returns nonzero iff CLASS is the tree-code class of an
292 expression. */
293
294#define IS_EXPR_CODE_CLASS(CLASS)\
295 ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
296
297/* Returns nonzero iff NODE is an expression of some kind. */
298
299#define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
300
301#if __cpp_inline_variables < 201606L
302#define TREE_CODE_LENGTH(CODE) \
303 tree_code_length_tmpl <0>::tree_code_length[(int) (CODE)]
304#else
305#define TREE_CODE_LENGTH(CODE) tree_code_length[(int) (CODE)]
306#endif
307
308
309/* Helper macros for math builtins. */
310
311#define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
312#define CASE_FLT_FN_FLOATN_NX(FN) \
313 case FN##F16: case FN##F32: case FN##F64: case FN##F128: \
314 case FN##F32X: case FN##F64X: case FN##F128X
315#define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R
316#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL: case FN##IMAX
317
318#define NULL_TREE (tree) NULL
319
320/* Define accessors for the fields that all tree nodes have
321 (though some fields are not used for all kinds of nodes). */
322
323/* The tree-code says what kind of node it is.
324 Codes are defined in tree.def. */
325#define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
326#define TREE_SET_CODE(NODE, VALUE) ((NODE)->base.code = (VALUE))
327
328/* When checking is enabled, errors will be generated if a tree node
329 is accessed incorrectly. The macros die with a fatal error. */
330#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
331
332#define TREE_CHECK(T, CODE) \
333(tree_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
334
335#define TREE_NOT_CHECK(T, CODE) \
336(tree_not_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
337
338#define TREE_CHECK2(T, CODE1, CODE2) \
339(tree_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
340
341#define TREE_NOT_CHECK2(T, CODE1, CODE2) \
342(tree_not_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
343
344#define TREE_CHECK3(T, CODE1, CODE2, CODE3) \
345(tree_check3 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
346
347#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) \
348(tree_not_check3 ((T), __FILE__, __LINE__, __FUNCTION__, \
349 (CODE1), (CODE2), (CODE3)))
350
351#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
352(tree_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
353 (CODE1), (CODE2), (CODE3), (CODE4)))
354
355#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
356(tree_not_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
357 (CODE1), (CODE2), (CODE3), (CODE4)))
358
359#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
360(tree_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
361 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
362
363#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
364(tree_not_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
365 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
366
367#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) \
368(tree_check6 ((T), __FILE__, __LINE__, __FUNCTION__, \
369 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), (CODE6)))
370
371#define TREE_NOT_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) \
372(tree_not_check6 ((T), __FILE__, __LINE__, __FUNCTION__, \
373 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), (CODE6)))
374
375#define CONTAINS_STRUCT_CHECK(T, STRUCT) \
376(contains_struct_check ((T), (STRUCT), __FILE__, __LINE__, __FUNCTION__))
377
378#define TREE_CLASS_CHECK(T, CLASS) \
379(tree_class_check ((T), (CLASS), __FILE__, __LINE__, __FUNCTION__))
380
381#define TREE_RANGE_CHECK(T, CODE1, CODE2) \
382(tree_range_check ((T), (CODE1), (CODE2), __FILE__, __LINE__, __FUNCTION__))
383
384#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) \
385(omp_clause_subcode_check ((T), (CODE), __FILE__, __LINE__, __FUNCTION__))
386
387#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) \
388(omp_clause_range_check ((T), (CODE1), (CODE2), \
389 __FILE__, __LINE__, __FUNCTION__))
390
391/* These checks have to be special cased. */
392#define EXPR_CHECK(T) \
393(expr_check ((T), __FILE__, __LINE__, __FUNCTION__))
394
395/* These checks have to be special cased. */
396#define NON_TYPE_CHECK(T) \
397(non_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
398
399/* These checks have to be special cased. */
400#define ANY_INTEGRAL_TYPE_CHECK(T) \
401(any_integral_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
402
403#define TREE_INT_CST_ELT_CHECK(T, I) \
404(*tree_int_cst_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))
405
406#define TREE_VEC_ELT_CHECK(T, I) \
407(*(CONST_CAST2 (tree *, typeof (T)*, \
408 tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
409
410#define OMP_CLAUSE_ELT_CHECK(T, I) \
411(*(omp_clause_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)))
412
413/* Special checks for TREE_OPERANDs. */
414#define TREE_OPERAND_CHECK(T, I) \
415(*(CONST_CAST2 (tree*, typeof (T)*, \
416 tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
417
418#define TREE_OPERAND_CHECK_CODE(T, CODE, I) \
419(*(tree_operand_check_code ((T), (CODE), (I), \
420 __FILE__, __LINE__, __FUNCTION__)))
421
422/* Nodes are chained together for many purposes.
423 Types are chained together to record them for being output to the debugger
424 (see the function `chain_type').
425 Decls in the same scope are chained together to record the contents
426 of the scope.
427 Statement nodes for successive statements used to be chained together.
428 Often lists of things are represented by TREE_LIST nodes that
429 are chained together. */
430
431#define TREE_CHAIN(NODE) \
432(CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)->common.chain)
433
434/* In all nodes that are expressions, this is the data type of the expression.
435 In POINTER_TYPE nodes, this is the type that the pointer points to.
436 In ARRAY_TYPE nodes, this is the type of the elements.
437 In VECTOR_TYPE nodes, this is the type of the elements. */
438#define TREE_TYPE(NODE) \
439(CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)->typed.type)
440
441extern void tree_contains_struct_check_failed (const_tree,
442 const enum tree_node_structure_enum,
443 const char *, int, const char *)
444 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
445
446extern void tree_check_failed (const_tree, const char *, int, const char *,
447 ...) ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
448extern void tree_not_check_failed (const_tree, const char *, int, const char *,
449 ...) ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
450extern void tree_class_check_failed (const_tree, const enum tree_code_class,
451 const char *, int, const char *)
452 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
453extern void tree_range_check_failed (const_tree, const char *, int,
454 const char *, enum tree_code,
455 enum tree_code)
456 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
457extern void tree_not_class_check_failed (const_tree,
458 const enum tree_code_class,
459 const char *, int, const char *)
460 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
461extern void tree_int_cst_elt_check_failed (int, int, const char *,
462 int, const char *)
463 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
464extern void tree_vec_elt_check_failed (int, int, const char *,
465 int, const char *)
466 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
467extern void phi_node_elt_check_failed (int, int, const char *,
468 int, const char *)
469 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
470extern void tree_operand_check_failed (int, const_tree,
471 const char *, int, const char *)
472 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
473extern void omp_clause_check_failed (const_tree, const char *, int,
474 const char *, enum omp_clause_code)
475 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
476extern void omp_clause_operand_check_failed (int, const_tree, const char *,
477 int, const char *)
478 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
479extern void omp_clause_range_check_failed (const_tree, const char *, int,
480 const char *, enum omp_clause_code,
481 enum omp_clause_code)
482 ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
483
484#else /* not ENABLE_TREE_CHECKING, or not gcc */
485
486#define CONTAINS_STRUCT_CHECK(T, ENUM) (T)
487#define TREE_CHECK(T, CODE) (T)
488#define TREE_NOT_CHECK(T, CODE) (T)
489#define TREE_CHECK2(T, CODE1, CODE2) (T)
490#define TREE_NOT_CHECK2(T, CODE1, CODE2) (T)
491#define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T)
492#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T)
493#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
494#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
495#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
496#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
497#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) (T)
498#define TREE_NOT_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) (T)
499#define TREE_CLASS_CHECK(T, CODE) (T)
500#define TREE_RANGE_CHECK(T, CODE1, CODE2) (T)
501#define EXPR_CHECK(T) (T)
502#define NON_TYPE_CHECK(T) (T)
503#define TREE_INT_CST_ELT_CHECK(T, I) ((T)->int_cst.val[I])
504#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I])
505#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I])
506#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I])
507#define OMP_CLAUSE_ELT_CHECK(T, i) ((T)->omp_clause.ops[i])
508#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T)
509#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) (T)
510#define ANY_INTEGRAL_TYPE_CHECK(T) (T)
511
512#define TREE_CHAIN(NODE) ((NODE)->common.chain)
513#define TREE_TYPE(NODE) ((NODE)->typed.type)
514
515#endif
516
517#define TREE_BLOCK(NODE) (tree_block (NODE))
518#define TREE_SET_BLOCK(T, B) (tree_set_block ((T), (B)))
519
520#include "tree-check.h"
521
522#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type)
523#define DECL_MINIMAL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
524#define DECL_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
525#define DECL_WRTL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
526#define DECL_WITH_VIS_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
527#define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)
528#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant)
529#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement)
530#define VL_EXP_CHECK(T) TREE_CLASS_CHECK (T, tcc_vl_exp)
531#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
532#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
533
534#define RECORD_OR_UNION_CHECK(T) \
535 TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
536#define NOT_RECORD_OR_UNION_CHECK(T) \
537 TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
538#define ARRAY_OR_INTEGER_TYPE_CHECK(T) \
539 TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)
540
541#define NUMERICAL_TYPE_CHECK(T) \
542 TREE_CHECK6 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \
543 FIXED_POINT_TYPE, BITINT_TYPE)
544
545/* Here is how primitive or already-canonicalized types' hash codes
546 are made. */
547#define TYPE_HASH(TYPE) (TYPE_UID (TYPE))
548
549/* A simple hash function for an arbitrary tree node. This must not be
550 used in hash tables which are saved to a PCH. */
551#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)
552
553/* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR). */
554#define CONVERT_EXPR_CODE_P(CODE) \
555 ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
556
557/* Similarly, but accept an expression instead of a tree code. */
558#define CONVERT_EXPR_P(EXP) CONVERT_EXPR_CODE_P (TREE_CODE (EXP))
559
560/* Generate case for NOP_EXPR, CONVERT_EXPR. */
561
562#define CASE_CONVERT \
563 case NOP_EXPR: \
564 case CONVERT_EXPR
565
566/* Given an expression as a tree, strip any conversion that generates
567 no instruction. Accepts both tree and const_tree arguments since
568 we are not modifying the tree itself. */
569
570#define STRIP_NOPS(EXP) \
571 (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP))
572
573/* Like STRIP_NOPS, but don't let the signedness change either. */
574
575#define STRIP_SIGN_NOPS(EXP) \
576 (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP))
577
578/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
579
580#define STRIP_TYPE_NOPS(EXP) \
581 while ((CONVERT_EXPR_P (EXP) \
582 || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
583 && TREE_OPERAND (EXP, 0) != error_mark_node \
584 && (TREE_TYPE (EXP) \
585 == TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
586 (EXP) = TREE_OPERAND (EXP, 0)
587
588/* Remove unnecessary type conversions according to
589 tree_ssa_useless_type_conversion. */
590
591#define STRIP_USELESS_TYPE_CONVERSION(EXP) \
592 (EXP) = tree_ssa_strip_useless_type_conversions (EXP)
593
594/* Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely
595 in use to provide a location_t. */
596
597#define STRIP_ANY_LOCATION_WRAPPER(EXP) \
598 (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP))
599
600/* Nonzero if TYPE represents a vector type. */
601
602#define VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE)
603
604/* Nonzero if TYPE represents a vector of booleans. */
605
606#define VECTOR_BOOLEAN_TYPE_P(TYPE) \
607 (TREE_CODE (TYPE) == VECTOR_TYPE \
608 && TREE_CODE (TREE_TYPE (TYPE)) == BOOLEAN_TYPE)
609
610/* Nonzero if TYPE represents an integral type. Note that we do not
611 include COMPLEX types here. Keep these checks in ascending code
612 order. */
613
614#define INTEGRAL_TYPE_P(TYPE) \
615 (TREE_CODE (TYPE) == ENUMERAL_TYPE \
616 || TREE_CODE (TYPE) == BOOLEAN_TYPE \
617 || TREE_CODE (TYPE) == INTEGER_TYPE \
618 || TREE_CODE (TYPE) == BITINT_TYPE)
619
620/* Nonzero if TYPE represents an integral type, including complex
621 and vector integer types. */
622
623#define ANY_INTEGRAL_TYPE_P(TYPE) \
624 (INTEGRAL_TYPE_P (TYPE) \
625 || ((TREE_CODE (TYPE) == COMPLEX_TYPE \
626 || VECTOR_TYPE_P (TYPE)) \
627 && INTEGRAL_TYPE_P (TREE_TYPE (TYPE))))
628
629/* Nonzero if TYPE is bit-precise integer type. */
630
631#define BITINT_TYPE_P(TYPE) (TREE_CODE (TYPE) == BITINT_TYPE)
632
633/* Nonzero if TYPE represents a non-saturating fixed-point type. */
634
635#define NON_SAT_FIXED_POINT_TYPE_P(TYPE) \
636 (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE))
637
638/* Nonzero if TYPE represents a saturating fixed-point type. */
639
640#define SAT_FIXED_POINT_TYPE_P(TYPE) \
641 (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE))
642
643/* Nonzero if TYPE represents a fixed-point type. */
644
645#define FIXED_POINT_TYPE_P(TYPE) (TREE_CODE (TYPE) == FIXED_POINT_TYPE)
646
647/* Nonzero if TYPE represents a scalar floating-point type. */
648
649#define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE)
650
651/* Nonzero if TYPE represents a complex floating-point type. */
652
653#define COMPLEX_FLOAT_TYPE_P(TYPE) \
654 (TREE_CODE (TYPE) == COMPLEX_TYPE \
655 && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
656
657/* Nonzero if TYPE represents a vector integer type. */
658
659#define VECTOR_INTEGER_TYPE_P(TYPE) \
660 (VECTOR_TYPE_P (TYPE) \
661 && TREE_CODE (TREE_TYPE (TYPE)) == INTEGER_TYPE)
662
663
664/* Nonzero if TYPE represents a vector floating-point type. */
665
666#define VECTOR_FLOAT_TYPE_P(TYPE) \
667 (VECTOR_TYPE_P (TYPE) \
668 && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
669
670/* Nonzero if TYPE represents a floating-point type, including complex
671 and vector floating-point types. The vector and complex check does
672 not use the previous two macros to enable early folding. */
673
674#define FLOAT_TYPE_P(TYPE) \
675 (SCALAR_FLOAT_TYPE_P (TYPE) \
676 || ((TREE_CODE (TYPE) == COMPLEX_TYPE \
677 || VECTOR_TYPE_P (TYPE)) \
678 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))
679
680/* Nonzero if TYPE represents a decimal floating-point type. */
681#define DECIMAL_FLOAT_TYPE_P(TYPE) \
682 (SCALAR_FLOAT_TYPE_P (TYPE) \
683 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))
684
685/* Nonzero if TYPE is a record or union type. */
686#define RECORD_OR_UNION_TYPE_P(TYPE) \
687 (TREE_CODE (TYPE) == RECORD_TYPE \
688 || TREE_CODE (TYPE) == UNION_TYPE \
689 || TREE_CODE (TYPE) == QUAL_UNION_TYPE)
690
691/* Nonzero if TYPE represents an aggregate (multi-component) type.
692 Keep these checks in ascending code order. */
693
694#define AGGREGATE_TYPE_P(TYPE) \
695 (TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE))
696
697/* Nonzero if TYPE represents a pointer or reference type.
698 (It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
699 ascending code order. */
700
701#define POINTER_TYPE_P(TYPE) \
702 (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
703
704/* Nonzero if TYPE represents a pointer to function. */
705#define FUNCTION_POINTER_TYPE_P(TYPE) \
706 (POINTER_TYPE_P (TYPE) && TREE_CODE (TREE_TYPE (TYPE)) == FUNCTION_TYPE)
707
708/* Nonzero if this type is a complete type. */
709#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
710
711/* Nonzero if this type is the (possibly qualified) void type. */
712#define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE)
713
714/* Nonzero if this type is complete or is cv void. */
715#define COMPLETE_OR_VOID_TYPE_P(NODE) \
716 (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
717
718/* Nonzero if this type is complete or is an array with unspecified bound. */
719#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
720 (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
721
722#define FUNC_OR_METHOD_TYPE_P(NODE) \
723 (TREE_CODE (NODE) == FUNCTION_TYPE || TREE_CODE (NODE) == METHOD_TYPE)
724
725#define OPAQUE_TYPE_P(NODE) \
726 (TREE_CODE (NODE) == OPAQUE_TYPE)
727
728/* Define many boolean fields that all tree nodes have. */
729
730/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
731 of this is needed. So it cannot be in a register.
732 In a FUNCTION_DECL it has no meaning.
733 In LABEL_DECL nodes, it means a goto for this label has been seen
734 from a place outside all binding contours that restore stack levels.
735 In an artificial SSA_NAME that points to a stack partition with at least
736 two variables, it means that at least one variable has TREE_ADDRESSABLE.
737 In ..._TYPE nodes, it means that objects of this type must be fully
738 addressable. This means that pieces of this object cannot go into
739 register parameters, for example. If this a function type, this
740 means that the value must be returned in memory.
741 In CONSTRUCTOR nodes, it means object constructed must be in memory.
742 In IDENTIFIER_NODEs, this means that some extern decl for this name
743 had its address taken. That matters for inline functions.
744 In a STMT_EXPR, it means we want the result of the enclosed expression. */
745#define TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag)
746
747/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
748 exit of a function. Calls for which this is true are candidates for tail
749 call optimizations. */
750#define CALL_EXPR_TAILCALL(NODE) \
751 (CALL_EXPR_CHECK (NODE)->base.addressable_flag)
752
753/* Set on a CALL_EXPR if the call has been marked as requiring tail call
754 optimization for correctness. */
755#define CALL_EXPR_MUST_TAIL_CALL(NODE) \
756 (CALL_EXPR_CHECK (NODE)->base.static_flag)
757
758/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
759 CASE_LOW operand has been processed. */
760#define CASE_LOW_SEEN(NODE) \
761 (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
762
763#define PREDICT_EXPR_OUTCOME(NODE) \
764 ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag))
765#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \
766 (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME)
767#define PREDICT_EXPR_PREDICTOR(NODE) \
768 ((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0)))
769
770/* In a VAR_DECL, nonzero means allocate static storage.
771 In a FUNCTION_DECL, nonzero if function has been defined.
772 In a CONSTRUCTOR, nonzero means allocate static storage. */
773#define TREE_STATIC(NODE) ((NODE)->base.static_flag)
774
775/* In an ADDR_EXPR, nonzero means do not use a trampoline. */
776#define TREE_NO_TRAMPOLINE(NODE) (ADDR_EXPR_CHECK (NODE)->base.static_flag)
777
778/* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
779 should only be executed if an exception is thrown, not on normal exit
780 of its scope. */
781#define CLEANUP_EH_ONLY(NODE) ((NODE)->base.static_flag)
782
783/* In a TRY_CATCH_EXPR, means that the handler should be considered a
784 separate cleanup in honor_protect_cleanup_actions. */
785#define TRY_CATCH_IS_CLEANUP(NODE) \
786 (TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag)
787
788/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
789 CASE_HIGH operand has been processed. */
790#define CASE_HIGH_SEEN(NODE) \
791 (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag)
792
793/* Used to mark scoped enums. */
794#define ENUM_IS_SCOPED(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag)
795
796/* Determines whether an ENUMERAL_TYPE has defined the list of constants. */
797#define ENUM_IS_OPAQUE(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.private_flag)
798
799/* In an expr node (usually a conversion) this means the node was made
800 implicitly and should not lead to any sort of warning. In a decl node,
801 warnings concerning the decl should be suppressed. This is used at
802 least for used-before-set warnings, and it set after one warning is
803 emitted. */
804#define TREE_NO_WARNING(NODE) ((NODE)->base.nowarning_flag)
805
806/* Nonzero if we should warn about the change in empty class parameter
807 passing ABI in this TU. */
808#define TRANSLATION_UNIT_WARN_EMPTY_P(NODE) \
809 (TRANSLATION_UNIT_DECL_CHECK (NODE)->decl_common.decl_flag_0)
810
811/* Nonzero if this type is "empty" according to the particular psABI. */
812#define TYPE_EMPTY_P(NODE) (TYPE_CHECK (NODE)->type_common.empty_flag)
813
814/* Used to indicate that this TYPE represents a compiler-generated entity. */
815#define TYPE_ARTIFICIAL(NODE) (TYPE_CHECK (NODE)->base.nowarning_flag)
816
817/* True if the type is indivisible at the source level, i.e. if its
818 component parts cannot be accessed directly. This is used to suppress
819 normal GNU extensions for target-specific vector types. */
820#define TYPE_INDIVISIBLE_P(NODE) (TYPE_CHECK (NODE)->type_common.indivisible_p)
821
822/* True if this is a stdarg function with no named arguments (C23
823 (...) prototype, where arguments can be accessed with va_start and
824 va_arg), as opposed to an unprototyped function. */
825#define TYPE_NO_NAMED_ARGS_STDARG_P(NODE) \
826 (FUNC_OR_METHOD_CHECK (NODE)->type_common.no_named_args_stdarg_p)
827
828/* True if this RECORD_TYPE or UNION_TYPE includes a flexible array member
829 as the last field recursively. */
830#define TYPE_INCLUDES_FLEXARRAY(NODE) \
831 (RECORD_OR_UNION_CHECK (NODE)->type_common.no_named_args_stdarg_p)
832
833/* In an IDENTIFIER_NODE, this means that assemble_name was called with
834 this string as an argument. */
835#define TREE_SYMBOL_REFERENCED(NODE) \
836 (IDENTIFIER_NODE_CHECK (NODE)->base.static_flag)
837
838/* Nonzero in a pointer or reference type means the data pointed to
839 by this type can alias anything. */
840#define TYPE_REF_CAN_ALIAS_ALL(NODE) \
841 (PTR_OR_REF_CHECK (NODE)->base.static_flag)
842
843/* In an INTEGER_CST, REAL_CST, or COMPLEX_CST, this means
844 there was an overflow in folding. */
845
846#define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag)
847
848/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */
849
850#define TREE_OVERFLOW_P(EXPR) \
851 (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR))
852
853/* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
854 nonzero means name is to be accessible from outside this translation unit.
855 In an IDENTIFIER_NODE, nonzero means an external declaration
856 accessible from outside this translation unit was previously seen
857 for this name in an inner scope. */
858#define TREE_PUBLIC(NODE) ((NODE)->base.public_flag)
859
860/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
861 of cached values, or is something else. */
862#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK (NODE)->base.public_flag)
863
864/* In a SAVE_EXPR, indicates that the original expression has already
865 been substituted with a VAR_DECL that contains the value. */
866#define SAVE_EXPR_RESOLVED_P(NODE) \
867 (SAVE_EXPR_CHECK (NODE)->base.public_flag)
868
869/* Set on a CALL_EXPR if this stdarg call should be passed the argument
870 pack. */
871#define CALL_EXPR_VA_ARG_PACK(NODE) \
872 (CALL_EXPR_CHECK (NODE)->base.public_flag)
873
874/* In any expression, decl, or constant, nonzero means it has side effects or
875 reevaluation of the whole expression could produce a different value.
876 This is set if any subexpression is a function call, a side effect or a
877 reference to a volatile variable. In a ..._DECL, this is set only if the
878 declaration said `volatile'. This will never be set for a constant. */
879#define TREE_SIDE_EFFECTS(NODE) \
880 (NON_TYPE_CHECK (NODE)->base.side_effects_flag)
881
882/* In a LABEL_DECL, nonzero means this label had its address taken
883 and therefore can never be deleted and is a jump target for
884 computed gotos. */
885#define FORCED_LABEL(NODE) (LABEL_DECL_CHECK (NODE)->base.side_effects_flag)
886
887/* Whether a case or a user-defined label is allowed to fall through to.
888 This is used to implement -Wimplicit-fallthrough. */
889#define FALLTHROUGH_LABEL_P(NODE) \
890 (LABEL_DECL_CHECK (NODE)->base.private_flag)
891
892/* Set on the artificial label created for break; stmt from a switch.
893 This is used to implement -Wimplicit-fallthrough. */
894#define SWITCH_BREAK_LABEL_P(NODE) \
895 (LABEL_DECL_CHECK (NODE)->base.protected_flag)
896
897/* Set on label that is known not to be jumped to, it can be only
898 reached by falling through from previous statements.
899 This is used to implement -Wimplicit-fallthrough. */
900#define UNUSED_LABEL_P(NODE) \
901 (LABEL_DECL_CHECK (NODE)->base.default_def_flag)
902
903/* Label used to goto around artificial .DEFERRED_INIT code for
904 C++ -ftrivial-auto-var-init= purposes with a goto around it.
905 VACUOUS_INIT_LABEL_P flag is used on the lab LABEL_DECL in:
906 goto lab;
907 lab1:
908 v1 = .DEFERRED_INIT (...);
909 v2 = .DEFERRED_INIT (...);
910 lab2:
911 v3 = .DEFERRED_INIT (...);
912 lab: */
913#define VACUOUS_INIT_LABEL_P(NODE) \
914 (LABEL_DECL_CHECK (NODE)->base.nothrow_flag)
915
916/* Nonzero means this expression is volatile in the C sense:
917 its address should be of type `volatile WHATEVER *'.
918 In other words, the declared item is volatile qualified.
919 This is used in _DECL nodes and _REF nodes.
920 On a FUNCTION_DECL node, this means the function does not
921 return normally. This is the same effect as setting
922 the attribute noreturn on the function in C.
923
924 In a ..._TYPE node, means this type is volatile-qualified.
925 But use TYPE_VOLATILE instead of this macro when the node is a type,
926 because eventually we may make that a different bit.
927
928 If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
929#define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag)
930
931/* Nonzero means this node will not trap. In an INDIRECT_REF, means
932 accessing the memory pointed to won't generate a trap. However,
933 this only applies to an object when used appropriately: it doesn't
934 mean that writing a READONLY mem won't trap.
935
936 In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
937 (or slice of the array) always belongs to the range of the array.
938 I.e. that the access will not trap, provided that the access to
939 the base to the array will not trap. */
940#define TREE_THIS_NOTRAP(NODE) \
941 (TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \
942 ARRAY_RANGE_REF)->base.nothrow_flag)
943
944/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
945 nonzero means it may not be the lhs of an assignment.
946 Nonzero in a FUNCTION_DECL means this function should be treated
947 as "const" function (can only read its arguments). */
948#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag)
949
950/* Value of expression is constant. Always on in all ..._CST nodes. May
951 also appear in an expression or decl where the value is constant. */
952#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->base.constant_flag)
953
954/* Nonzero if NODE, a type, has had its sizes gimplified. */
955#define TYPE_SIZES_GIMPLIFIED(NODE) \
956 (TYPE_CHECK (NODE)->base.constant_flag)
957
958/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
959#define DECL_UNSIGNED(NODE) \
960 (DECL_COMMON_CHECK (NODE)->base.u.bits.unsigned_flag)
961
962/* In integral and pointer types, means an unsigned type. */
963#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)
964
965/* Same as TYPE_UNSIGNED but converted to SIGNOP. */
966#define TYPE_SIGN(NODE) ((signop) TYPE_UNSIGNED (NODE))
967
968/* True if overflow wraps around for the given integral or pointer type. That
969 is, TYPE_MAX + 1 == TYPE_MIN. */
970#define TYPE_OVERFLOW_WRAPS(TYPE) \
971 (POINTER_TYPE_P (TYPE) \
972 ? flag_wrapv_pointer \
973 : (ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag \
974 || flag_wrapv))
975
976/* True if overflow is undefined for the given integral or pointer type.
977 We may optimize on the assumption that values in the type never overflow.
978
979 IMPORTANT NOTE: Any optimization based on TYPE_OVERFLOW_UNDEFINED
980 must issue a warning based on warn_strict_overflow. In some cases
981 it will be appropriate to issue the warning immediately, and in
982 other cases it will be appropriate to simply set a flag and let the
983 caller decide whether a warning is appropriate or not. */
984#define TYPE_OVERFLOW_UNDEFINED(TYPE) \
985 (POINTER_TYPE_P (TYPE) \
986 ? !flag_wrapv_pointer \
987 : (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag \
988 && !flag_wrapv && !flag_trapv))
989
990/* True if overflow for the given integral type should issue a
991 trap. */
992#define TYPE_OVERFLOW_TRAPS(TYPE) \
993 (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag && flag_trapv)
994
995/* True if an overflow is to be preserved for sanitization. */
996#define TYPE_OVERFLOW_SANITIZED(TYPE) \
997 (INTEGRAL_TYPE_P (TYPE) \
998 && !TYPE_OVERFLOW_WRAPS (TYPE) \
999 && (flag_sanitize & SANITIZE_SI_OVERFLOW))
1000
1001/* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
1002 Nonzero in a FUNCTION_DECL means that the function has been compiled.
1003 This is interesting in an inline function, since it might not need
1004 to be compiled separately.
1005 Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ENUMERAL_TYPE
1006 or TYPE_DECL if the debugging info for the type has been written.
1007 In a BLOCK node, nonzero if reorder_blocks has already seen this block.
1008 In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
1009 PHI node. */
1010#define TREE_ASM_WRITTEN(NODE) ((NODE)->base.asm_written_flag)
1011
1012/* Nonzero in a _DECL if the name is used in its scope.
1013 Nonzero in an expr node means inhibit warning if value is unused.
1014 In IDENTIFIER_NODEs, this means that some extern decl for this name
1015 was used.
1016 In a BLOCK, this means that the block contains variables that are used. */
1017#define TREE_USED(NODE) ((NODE)->base.used_flag)
1018
1019/* In a FUNCTION_DECL, nonzero means a call to the function cannot
1020 throw an exception. In a CALL_EXPR, nonzero means the call cannot
1021 throw. We can't easily check the node type here as the C++
1022 frontend also uses this flag (for AGGR_INIT_EXPR). */
1023#define TREE_NOTHROW(NODE) ((NODE)->base.nothrow_flag)
1024
1025/* In a CALL_EXPR, means that it's safe to use the target of the call
1026 expansion as the return slot for a call that returns in memory. */
1027#define CALL_EXPR_RETURN_SLOT_OPT(NODE) \
1028 (CALL_EXPR_CHECK (NODE)->base.private_flag)
1029
1030/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
1031 passed by invisible reference (and the TREE_TYPE is a pointer to the true
1032 type). */
1033#define DECL_BY_REFERENCE(NODE) \
1034 (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \
1035 RESULT_DECL)->decl_common.decl_by_reference_flag)
1036
1037/* In VAR_DECL and PARM_DECL, set when the decl has been used except for
1038 being set. */
1039#define DECL_READ_P(NODE) \
1040 (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_flag)
1041
1042/* In VAR_DECL or RESULT_DECL, set when significant code movement precludes
1043 attempting to share the stack slot with some other variable. */
1044#define DECL_NONSHAREABLE(NODE) \
1045 (TREE_CHECK2 (NODE, VAR_DECL, \
1046 RESULT_DECL)->decl_common.decl_nonshareable_flag)
1047
1048/* In a PARM_DECL, set for Fortran hidden string length arguments that some
1049 buggy callers don't pass to the callee. */
1050#define DECL_HIDDEN_STRING_LENGTH(NODE) \
1051 (TREE_CHECK (NODE, PARM_DECL)->decl_common.decl_nonshareable_flag)
1052
1053/* In a CALL_EXPR, means that the call is the jump from a thunk to the
1054 thunked-to function. Be careful to avoid using this macro when one of the
1055 next two applies instead. */
1056#define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag)
1057
1058/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
1059 it has been built for the declaration of a variable-sized object and, if the
1060 function being called is BUILT_IN_MEMCPY, means that it has been built for
1061 the assignment of a variable-sized object. */
1062#define CALL_ALLOCA_FOR_VAR_P(NODE) \
1063 (CALL_EXPR_CHECK (NODE)->base.protected_flag)
1064
1065/* In a CALL_EXPR, if the function being called is DECL_IS_OPERATOR_NEW_P or
1066 DECL_IS_OPERATOR_DELETE_P, true for allocator calls from C++ new or delete
1067 expressions. Not set for C++20 destroying delete operators. */
1068#define CALL_FROM_NEW_OR_DELETE_P(NODE) \
1069 (CALL_EXPR_CHECK (NODE)->base.protected_flag)
1070
1071/* Used in classes in C++. */
1072#define TREE_PRIVATE(NODE) ((NODE)->base.private_flag)
1073/* Used in classes in C++. */
1074#define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag)
1075
1076/* True if reference type NODE is a C++ rvalue reference. */
1077#define TYPE_REF_IS_RVALUE(NODE) \
1078 (REFERENCE_TYPE_CHECK (NODE)->base.private_flag)
1079
1080/* Nonzero in a _DECL if the use of the name is defined as a
1081 deprecated feature by __attribute__((deprecated)). */
1082#define TREE_DEPRECATED(NODE) \
1083 ((NODE)->base.deprecated_flag)
1084
1085/* Nonzero in a _DECL if the use of the name is defined as an
1086 unavailable feature by __attribute__((unavailable)). */
1087#define TREE_UNAVAILABLE(NODE) \
1088 ((NODE)->base.u.bits.unavailable_flag)
1089
1090/* Nonzero indicates an IDENTIFIER_NODE that names an anonymous
1091 aggregate, (as created by anon_aggr_name_format). */
1092#define IDENTIFIER_ANON_P(NODE) \
1093 (IDENTIFIER_NODE_CHECK (NODE)->base.private_flag)
1094
1095/* Nonzero indicates an IDENTIFIER_NODE that names an internal label.
1096 The prefix used to generate the label can be found on the TREE_CHAIN. */
1097#define IDENTIFIER_INTERNAL_P(NODE) \
1098 (IDENTIFIER_NODE_CHECK (NODE)->base.volatile_flag)
1099
1100/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
1101 uses are to be substituted for uses of the TREE_CHAINed identifier. */
1102#define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \
1103 (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag)
1104
1105/* In an aggregate type, indicates that the scalar fields of the type are
1106 stored in reverse order from the target order. This effectively
1107 toggles BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN within the type. */
1108#define TYPE_REVERSE_STORAGE_ORDER(NODE) \
1109 (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
1110
1111/* In a non-aggregate type, indicates a saturating type. */
1112#define TYPE_SATURATING(NODE) \
1113 (TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
1114
1115/* In a BIT_FIELD_REF and MEM_REF, indicates that the reference is to a group
1116 of bits stored in reverse order from the target order. This effectively
1117 toggles both BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN for the reference.
1118
1119 The overall strategy is to preserve the invariant that every scalar in
1120 memory is associated with a single storage order, i.e. all accesses to
1121 this scalar are done with the same storage order. This invariant makes
1122 it possible to factor out the storage order in most transformations, as
1123 only the address and/or the value (in target order) matter for them.
1124 But, of course, the storage order must be preserved when the accesses
1125 themselves are rewritten or transformed. */
1126#define REF_REVERSE_STORAGE_ORDER(NODE) \
1127 (TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)->base.default_def_flag)
1128
1129 /* In an ADDR_EXPR, indicates that this is a pointer to nested function
1130 represented by a descriptor instead of a trampoline. */
1131#define FUNC_ADDR_BY_DESCRIPTOR(NODE) \
1132 (TREE_CHECK (NODE, ADDR_EXPR)->base.default_def_flag)
1133
1134/* In a CALL_EXPR, indicates that this is an indirect call for which
1135 pointers to nested function are descriptors instead of trampolines. */
1136#define CALL_EXPR_BY_DESCRIPTOR(NODE) \
1137 (TREE_CHECK (NODE, CALL_EXPR)->base.default_def_flag)
1138
1139/* These flags are available for each language front end to use internally. */
1140#define TREE_LANG_FLAG_0(NODE) \
1141 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0)
1142#define TREE_LANG_FLAG_1(NODE) \
1143 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)
1144#define TREE_LANG_FLAG_2(NODE) \
1145 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)
1146#define TREE_LANG_FLAG_3(NODE) \
1147 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)
1148#define TREE_LANG_FLAG_4(NODE) \
1149 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)
1150#define TREE_LANG_FLAG_5(NODE) \
1151 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)
1152#define TREE_LANG_FLAG_6(NODE) \
1153 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)
1154
1155/* Define additional fields and accessors for nodes representing constants. */
1156
1157#define TREE_INT_CST_NUNITS(NODE) \
1158 (INTEGER_CST_CHECK (NODE)->base.u.int_length.unextended)
1159#define TREE_INT_CST_EXT_NUNITS(NODE) \
1160 (INTEGER_CST_CHECK (NODE)->base.u.int_length.extended)
1161#define TREE_INT_CST_ELT(NODE, I) TREE_INT_CST_ELT_CHECK (NODE, I)
1162#define TREE_INT_CST_LOW(NODE) \
1163 ((unsigned HOST_WIDE_INT) TREE_INT_CST_ELT (NODE, 0))
1164
1165/* Return true if NODE is a POLY_INT_CST. This is only ever true on
1166 targets with variable-sized modes. */
1167#define POLY_INT_CST_P(NODE) \
1168 (NUM_POLY_INT_COEFFS > 1 && TREE_CODE (NODE) == POLY_INT_CST)
1169
1170/* In a POLY_INT_CST node. */
1171#define POLY_INT_CST_COEFF(NODE, I) \
1172 (POLY_INT_CST_CHECK (NODE)->poly_int_cst.coeffs[I])
1173
1174#define TREE_REAL_CST_PTR(NODE) (&REAL_CST_CHECK (NODE)->real_cst.value)
1175#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
1176
1177#define TREE_FIXED_CST_PTR(NODE) \
1178 (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)
1179#define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE))
1180
1181/* In a STRING_CST */
1182/* In C terms, this is sizeof, not strlen. */
1183#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
1184#define TREE_STRING_POINTER(NODE) \
1185 ((const char *)(STRING_CST_CHECK (NODE)->string.str))
1186
1187/* In a RAW_DATA_CST */
1188#define RAW_DATA_LENGTH(NODE) \
1189 (RAW_DATA_CST_CHECK (NODE)->raw_data_cst.length)
1190#define RAW_DATA_POINTER(NODE) \
1191 (RAW_DATA_CST_CHECK (NODE)->raw_data_cst.str)
1192#define RAW_DATA_OWNER(NODE) \
1193 (RAW_DATA_CST_CHECK (NODE)->raw_data_cst.owner)
1194#define RAW_DATA_UCHAR_ELT(NODE, I) \
1195 (((const unsigned char *) RAW_DATA_POINTER (NODE))[I])
1196#define RAW_DATA_SCHAR_ELT(NODE, I) \
1197 (((const signed char *) RAW_DATA_POINTER (NODE))[I])
1198
1199/* In a COMPLEX_CST node. */
1200#define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
1201#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
1202
1203/* In a VECTOR_CST node. See generic.texi for details. */
1204#define VECTOR_CST_NELTS(NODE) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)))
1205#define VECTOR_CST_ELT(NODE,IDX) vector_cst_elt (NODE, IDX)
1206
1207#define VECTOR_CST_LOG2_NPATTERNS(NODE) \
1208 (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.log2_npatterns)
1209#define VECTOR_CST_NPATTERNS(NODE) \
1210 (1U << VECTOR_CST_LOG2_NPATTERNS (NODE))
1211#define VECTOR_CST_NELTS_PER_PATTERN(NODE) \
1212 (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.nelts_per_pattern)
1213#define VECTOR_CST_DUPLICATE_P(NODE) \
1214 (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 1)
1215#define VECTOR_CST_STEPPED_P(NODE) \
1216 (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 3)
1217#define VECTOR_CST_ENCODED_ELTS(NODE) \
1218 (VECTOR_CST_CHECK (NODE)->vector.elts)
1219#define VECTOR_CST_ENCODED_ELT(NODE, ELT) \
1220 (VECTOR_CST_CHECK (NODE)->vector.elts[ELT])
1221
1222/* Define fields and accessors for some special-purpose tree nodes. */
1223
1224/* Unlike STRING_CST, in C terms this is strlen, not sizeof. */
1225#define IDENTIFIER_LENGTH(NODE) \
1226 (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
1227#define IDENTIFIER_POINTER(NODE) \
1228 ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
1229#define IDENTIFIER_HASH_VALUE(NODE) \
1230 (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
1231
1232/* Translate a hash table identifier pointer to a tree_identifier
1233 pointer, and vice versa. */
1234
1235#define HT_IDENT_TO_GCC_IDENT(NODE) \
1236 ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
1237#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
1238
1239/* In a TREE_LIST node. */
1240#define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
1241#define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
1242
1243/* In a TREE_VEC node. */
1244#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->base.u.length)
1245#define TREE_VEC_BEGIN(NODE) (&TREE_VEC_CHECK (NODE)->vec.a[0])
1246#define TREE_VEC_END(NODE) \
1247 ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->base.u.length]))
1248
1249#define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
1250
1251/* In a CONSTRUCTOR node. */
1252#define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
1253#define CONSTRUCTOR_ELT(NODE,IDX) \
1254 (&(*CONSTRUCTOR_ELTS (NODE))[IDX])
1255#define CONSTRUCTOR_NELTS(NODE) \
1256 (vec_safe_length (CONSTRUCTOR_ELTS (NODE)))
1257#define CONSTRUCTOR_NO_CLEARING(NODE) \
1258 (CONSTRUCTOR_CHECK (NODE)->base.public_flag)
1259/* True if even padding bits should be zeroed during initialization. */
1260#define CONSTRUCTOR_ZERO_PADDING_BITS(NODE) \
1261 (CONSTRUCTOR_CHECK (NODE)->base.default_def_flag)
1262
1263/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
1264 value of each element (stored within VAL). IX must be a scratch variable
1265 of unsigned integer type. */
1266#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \
1267 for (IX = 0; (IX >= vec_safe_length (V)) \
1268 ? false \
1269 : ((VAL = (*(V))[IX].value), \
1270 true); \
1271 (IX)++)
1272
1273/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
1274 the value of each element (stored within VAL) and its index (stored
1275 within INDEX). IX must be a scratch variable of unsigned integer type. */
1276#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \
1277 for (IX = 0; (IX >= vec_safe_length (V)) \
1278 ? false \
1279 : (((void) (VAL = (*V)[IX].value)), \
1280 (INDEX = (*V)[IX].index), \
1281 true); \
1282 (IX)++)
1283
1284/* Append a new constructor element to V, with the specified INDEX and VAL. */
1285#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
1286 do { \
1287 constructor_elt _ce___ = {INDEX, VALUE}; \
1288 vec_safe_push ((V), _ce___); \
1289 } while (0)
1290
1291/* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
1292 constructor output purposes. */
1293#define CONSTRUCTOR_BITFIELD_P(NODE) \
1294 (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) \
1295 && (DECL_MODE (NODE) != BLKmode \
1296 || TREE_CODE (TREE_TYPE (NODE)) == BITINT_TYPE))
1297
1298/* True if NODE is a clobber right hand side, an expression of indeterminate
1299 value that clobbers the LHS in a copy instruction. We use a volatile
1300 empty CONSTRUCTOR for this, as it matches most of the necessary semantic.
1301 In particular the volatile flag causes us to not prematurely remove
1302 such clobber instructions. */
1303#define TREE_CLOBBER_P(NODE) \
1304 (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE))
1305
1306/* Return the clobber_kind of a CLOBBER CONSTRUCTOR. */
1307#define CLOBBER_KIND(NODE) \
1308 (CONSTRUCTOR_CHECK (NODE)->base.u.bits.address_space)
1309
1310/* Define fields and accessors for some nodes that represent expressions. */
1311
1312/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */
1313#define IS_EMPTY_STMT(NODE) (TREE_CODE (NODE) == NOP_EXPR \
1314 && VOID_TYPE_P (TREE_TYPE (NODE)) \
1315 && integer_zerop (TREE_OPERAND (NODE, 0)))
1316
1317/* In ordinary expression nodes. */
1318#define TREE_OPERAND_LENGTH(NODE) tree_operand_length (NODE)
1319#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
1320
1321/* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand
1322 length. Its value includes the length operand itself; that is,
1323 the minimum valid length is 1.
1324 Note that we have to bypass the use of TREE_OPERAND to access
1325 that field to avoid infinite recursion in expanding the macros. */
1326#define VL_EXP_OPERAND_LENGTH(NODE) \
1327 ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0]))
1328
1329/* Nonzero if gimple_debug_nonbind_marker_p() may possibly hold. */
1330#define MAY_HAVE_DEBUG_MARKER_STMTS debug_nonbind_markers_p
1331/* Nonzero if gimple_debug_bind_p() (and thus
1332 gimple_debug_source_bind_p()) may possibly hold. */
1333#define MAY_HAVE_DEBUG_BIND_STMTS flag_var_tracking_assignments
1334/* Nonzero if is_gimple_debug() may possibly hold. */
1335#define MAY_HAVE_DEBUG_STMTS \
1336 (MAY_HAVE_DEBUG_MARKER_STMTS || MAY_HAVE_DEBUG_BIND_STMTS)
1337
1338/* In a LOOP_EXPR node. */
1339#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
1340
1341/* The source location of this expression. Non-tree_exp nodes such as
1342 decls and constants can be shared among multiple locations, so
1343 return nothing. */
1344#define EXPR_LOCATION(NODE) \
1345 (CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
1346#define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS)
1347#define EXPR_HAS_LOCATION(NODE) (LOCATION_LOCUS (EXPR_LOCATION (NODE)) \
1348 != UNKNOWN_LOCATION)
1349/* The location to be used in a diagnostic about this expression. Do not
1350 use this macro if the location will be assigned to other expressions. */
1351#define EXPR_LOC_OR_LOC(NODE, LOCUS) (EXPR_HAS_LOCATION (NODE) \
1352 ? (NODE)->exp.locus : (LOCUS))
1353#define EXPR_FILENAME(NODE) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)
1354#define EXPR_LINENO(NODE) LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)
1355
1356#define CAN_HAVE_RANGE_P(NODE) (CAN_HAVE_LOCATION_P (NODE))
1357#define EXPR_LOCATION_RANGE(NODE) (get_expr_source_range (EXPR_CHECK ((NODE))))
1358
1359#define EXPR_HAS_RANGE(NODE) \
1360 (CAN_HAVE_RANGE_P (NODE) \
1361 ? EXPR_LOCATION_RANGE (NODE).m_start != UNKNOWN_LOCATION \
1362 : false)
1363
1364/* True if a tree is an expression or statement that can have a
1365 location. */
1366#define CAN_HAVE_LOCATION_P(NODE) ((NODE) && EXPR_P (NODE))
1367
1368inline source_range
1370{
1371 location_t loc = EXPR_LOCATION (expr);
1372 return get_range_from_loc (line_table, loc);
1373}
1374
1375extern void protected_set_expr_location (tree, location_t);
1376extern void protected_set_expr_location_if_unset (tree, location_t);
1377ATTRIBUTE_WARN_UNUSED_RESULT
1378extern tree protected_set_expr_location_unshare (tree, location_t);
1379
1381
1383
1384/* A class for suppressing the creation of location wrappers.
1385 Location wrappers will not be created during the lifetime
1386 of an instance of this class. */
1387
1394
1395/* In a TARGET_EXPR node. */
1396#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
1397#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
1398#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
1399/* Don't elide the initialization of TARGET_EXPR_SLOT for this TARGET_EXPR
1400 on rhs of MODIFY_EXPR. */
1401#define TARGET_EXPR_NO_ELIDE(NODE) (TARGET_EXPR_CHECK (NODE)->base.private_flag)
1402
1403/* DECL_EXPR accessor. This gives access to the DECL associated with
1404 the given declaration statement. */
1405#define DECL_EXPR_DECL(NODE) TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)
1406
1407#define EXIT_EXPR_COND(NODE) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
1408
1409/* COMPOUND_LITERAL_EXPR accessors. */
1410#define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE) \
1411 TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)
1412#define COMPOUND_LITERAL_EXPR_DECL(NODE) \
1413 DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE))
1414
1415/* SWITCH_EXPR accessors. These give access to the condition and body. */
1416#define SWITCH_COND(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
1417#define SWITCH_BODY(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
1418/* True if there are case labels for all possible values of SWITCH_COND, either
1419 because there is a default: case label or because the case label ranges cover
1420 all values. */
1421#define SWITCH_ALL_CASES_P(NODE) (SWITCH_EXPR_CHECK (NODE)->base.private_flag)
1422
1423/* CASE_LABEL_EXPR accessors. These give access to the high and low values
1424 of a case label, respectively. */
1425#define CASE_LOW(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
1426#define CASE_HIGH(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
1427#define CASE_LABEL(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
1428#define CASE_CHAIN(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 3)
1429
1430/* The operands of a TARGET_MEM_REF. Operands 0 and 1 have to match
1431 corresponding MEM_REF operands. */
1432#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
1433#define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
1434#define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
1435#define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
1436#define TMR_INDEX2(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
1437
1438#define MR_DEPENDENCE_CLIQUE(NODE) \
1439 (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.clique)
1440#define MR_DEPENDENCE_BASE(NODE) \
1441 (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.base)
1442
1443/* The operands of a BIND_EXPR. */
1444#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
1445#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
1446#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))
1447
1448/* GOTO_EXPR accessor. This gives access to the label associated with
1449 a goto statement. */
1450#define GOTO_DESTINATION(NODE) TREE_OPERAND (GOTO_EXPR_CHECK (NODE), 0)
1451
1452/* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
1453 instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
1454 ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
1455 statement. */
1456#define ASM_STRING(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
1457#define ASM_OUTPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
1458#define ASM_INPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
1459#define ASM_CLOBBERS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
1460#define ASM_LABELS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4)
1461/* Nonzero if the asm is a basic asm, zero if it is an extended asm.
1462 Basic asms use a plain ASM_INPUT insn pattern whereas extended asms
1463 use an ASM_OPERANDS insn pattern. */
1464#define ASM_BASIC_P(NODE) (ASM_EXPR_CHECK (NODE)->base.static_flag)
1465#define ASM_VOLATILE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.public_flag)
1466/* Nonzero if we want to consider this asm as minimum length and cost
1467 for inlining decisions. */
1468#define ASM_INLINE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.protected_flag)
1469
1470/* COND_EXPR accessors. */
1471#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
1472#define COND_EXPR_THEN(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
1473#define COND_EXPR_ELSE(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))
1474
1475/* Accessors for the chains of recurrences. */
1476#define CHREC_LEFT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)
1477#define CHREC_RIGHT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)
1478#define CHREC_VARIABLE(NODE) POLYNOMIAL_CHREC_CHECK (NODE)->base.u.chrec_var
1479/* Nonzero if this chrec doesn't overflow (i.e., nonwrapping). */
1480#define CHREC_NOWRAP(NODE) POLYNOMIAL_CHREC_CHECK (NODE)->base.nothrow_flag
1481
1482/* LABEL_EXPR accessor. This gives access to the label associated with
1483 the given label expression. */
1484#define LABEL_EXPR_LABEL(NODE) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)
1485
1486/* CATCH_EXPR accessors. */
1487#define CATCH_TYPES(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
1488#define CATCH_BODY(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)
1489
1490/* EH_FILTER_EXPR accessors. */
1491#define EH_FILTER_TYPES(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
1492#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
1493
1494/* OBJ_TYPE_REF accessors. */
1495#define OBJ_TYPE_REF_EXPR(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)
1496#define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)
1497#define OBJ_TYPE_REF_TOKEN(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)
1498
1499/* CALL_EXPR accessors. */
1500#define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)
1501#define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)
1502#define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)
1503#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH (NODE) - 3)
1504#define CALL_EXPR_IFN(NODE) (CALL_EXPR_CHECK (NODE)->base.u.ifn)
1505
1506/* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
1507 We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
1508 the argument count is zero when checking is enabled. Instead, do
1509 the pointer arithmetic to advance past the 3 fixed operands in a
1510 CALL_EXPR. That produces a valid pointer to just past the end of the
1511 operand array, even if it's not valid to dereference it. */
1512#define CALL_EXPR_ARGP(NODE) \
1513 (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3)
1514
1515/* TM directives and accessors. */
1516#define TRANSACTION_EXPR_BODY(NODE) \
1517 TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0)
1518#define TRANSACTION_EXPR_OUTER(NODE) \
1519 (TRANSACTION_EXPR_CHECK (NODE)->base.static_flag)
1520#define TRANSACTION_EXPR_RELAXED(NODE) \
1521 (TRANSACTION_EXPR_CHECK (NODE)->base.public_flag)
1522
1523/* OpenMP and OpenACC directive and clause accessors. */
1524
1525/* Generic accessors for OMP nodes that keep the body as operand 0, and clauses
1526 as operand 1. */
1527#define OMP_BODY(NODE) \
1528 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_MASTER), 0)
1529#define OMP_CLAUSES(NODE) \
1530 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_SCAN), 1)
1531
1532/* Generic accessors for OMP nodes that keep clauses as operand 0. */
1533#define OMP_STANDALONE_CLAUSES(NODE) \
1534 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_CACHE, OMP_TARGET_EXIT_DATA), 0)
1535
1536#define OACC_DATA_BODY(NODE) \
1537 TREE_OPERAND (OACC_DATA_CHECK (NODE), 0)
1538#define OACC_DATA_CLAUSES(NODE) \
1539 TREE_OPERAND (OACC_DATA_CHECK (NODE), 1)
1540
1541#define OACC_HOST_DATA_BODY(NODE) \
1542 TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 0)
1543#define OACC_HOST_DATA_CLAUSES(NODE) \
1544 TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 1)
1545
1546#define OACC_CACHE_CLAUSES(NODE) \
1547 TREE_OPERAND (OACC_CACHE_CHECK (NODE), 0)
1548
1549#define OACC_DECLARE_CLAUSES(NODE) \
1550 TREE_OPERAND (OACC_DECLARE_CHECK (NODE), 0)
1551
1552#define OACC_ENTER_DATA_CLAUSES(NODE) \
1553 TREE_OPERAND (OACC_ENTER_DATA_CHECK (NODE), 0)
1554
1555#define OACC_EXIT_DATA_CLAUSES(NODE) \
1556 TREE_OPERAND (OACC_EXIT_DATA_CHECK (NODE), 0)
1557
1558#define OACC_UPDATE_CLAUSES(NODE) \
1559 TREE_OPERAND (OACC_UPDATE_CHECK (NODE), 0)
1560
1561#define OMP_PARALLEL_BODY(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
1562#define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
1563
1564#define OMP_TASK_BODY(NODE) TREE_OPERAND (OMP_TASK_CHECK (NODE), 0)
1565#define OMP_TASK_CLAUSES(NODE) TREE_OPERAND (OMP_TASK_CHECK (NODE), 1)
1566
1567#define OMP_TASKREG_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK)
1568#define OMP_TASKREG_BODY(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0)
1569#define OMP_TASKREG_CLAUSES(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1)
1570
1571#define OMP_LOOPING_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_FOR, OACC_LOOP)
1572#define OMP_FOR_BODY(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 0)
1573#define OMP_FOR_CLAUSES(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 1)
1574#define OMP_FOR_INIT(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 2)
1575#define OMP_FOR_COND(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 3)
1576#define OMP_FOR_INCR(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 4)
1577#define OMP_FOR_PRE_BODY(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 5)
1578#define OMP_FOR_ORIG_DECLS(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 6)
1579
1580#define OMP_INTEROP_CLAUSES(NODE)\
1581 TREE_OPERAND (OMP_INTEROP_CHECK (NODE), 0)
1582
1583#define OMP_LOOPXFORM_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_TILE, OMP_UNROLL)
1584#define OMP_LOOPXFORM_LOWERED(NODE) \
1585 (OMP_LOOPXFORM_CHECK (NODE)->base.public_flag)
1586
1587#define OMP_SECTIONS_BODY(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
1588#define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
1589
1590#define OMP_SECTION_BODY(NODE) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)
1591
1592#define OMP_STRUCTURED_BLOCK_BODY(NODE) \
1593 TREE_OPERAND (OMP_STRUCTURED_BLOCK_CHECK (NODE), 0)
1594
1595#define OMP_SINGLE_BODY(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
1596#define OMP_SINGLE_CLAUSES(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)
1597
1598#define OMP_SCOPE_BODY(NODE) TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 0)
1599#define OMP_SCOPE_CLAUSES(NODE) TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 1)
1600
1601#define OMP_MASTER_BODY(NODE) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)
1602
1603#define OMP_MASKED_BODY(NODE) TREE_OPERAND (OMP_MASKED_CHECK (NODE), 0)
1604#define OMP_MASKED_CLAUSES(NODE) TREE_OPERAND (OMP_MASKED_CHECK (NODE), 1)
1605
1606#define OMP_TASKGROUP_BODY(NODE) TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0)
1607#define OMP_TASKGROUP_CLAUSES(NODE) \
1608 TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 1)
1609
1610#define OMP_ORDERED_BODY(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)
1611#define OMP_ORDERED_CLAUSES(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 1)
1612
1613#define OMP_CRITICAL_BODY(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
1614#define OMP_CRITICAL_CLAUSES(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)
1615#define OMP_CRITICAL_NAME(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 2)
1616
1617#define OMP_TEAMS_BODY(NODE) TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 0)
1618#define OMP_TEAMS_CLAUSES(NODE) TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 1)
1619
1620#define OMP_TARGET_DATA_BODY(NODE) \
1621 TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 0)
1622#define OMP_TARGET_DATA_CLAUSES(NODE)\
1623 TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 1)
1624
1625#define OMP_TARGET_BODY(NODE) TREE_OPERAND (OMP_TARGET_CHECK (NODE), 0)
1626#define OMP_TARGET_CLAUSES(NODE) TREE_OPERAND (OMP_TARGET_CHECK (NODE), 1)
1627
1628#define OMP_TARGET_UPDATE_CLAUSES(NODE)\
1629 TREE_OPERAND (OMP_TARGET_UPDATE_CHECK (NODE), 0)
1630
1631#define OMP_TARGET_ENTER_DATA_CLAUSES(NODE)\
1632 TREE_OPERAND (OMP_TARGET_ENTER_DATA_CHECK (NODE), 0)
1633
1634#define OMP_TARGET_EXIT_DATA_CLAUSES(NODE)\
1635 TREE_OPERAND (OMP_TARGET_EXIT_DATA_CHECK (NODE), 0)
1636
1637#define OMP_METADIRECTIVE_VARIANTS(NODE) \
1638 TREE_OPERAND (OMP_METADIRECTIVE_CHECK (NODE), 0)
1639
1640#define OMP_METADIRECTIVE_VARIANT_SELECTOR(v) \
1641 TREE_PURPOSE (v)
1642#define OMP_METADIRECTIVE_VARIANT_DIRECTIVE(v) \
1643 TREE_PURPOSE (TREE_VALUE (v))
1644#define OMP_METADIRECTIVE_VARIANT_BODY(v) \
1645 TREE_VALUE (TREE_VALUE (v))
1646
1647#define OMP_DECLARE_MAPPER_ID(NODE) \
1648 TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 0)
1649#define OMP_DECLARE_MAPPER_DECL(NODE) \
1650 TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 1)
1651#define OMP_DECLARE_MAPPER_CLAUSES(NODE) \
1652 TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 2)
1653
1654#define OMP_SCAN_BODY(NODE) TREE_OPERAND (OMP_SCAN_CHECK (NODE), 0)
1655#define OMP_SCAN_CLAUSES(NODE) TREE_OPERAND (OMP_SCAN_CHECK (NODE), 1)
1656
1657#define OMP_DISPATCH_BODY(NODE) TREE_OPERAND (OMP_DISPATCH_CHECK (NODE), 0)
1658#define OMP_DISPATCH_CLAUSES(NODE) TREE_OPERAND (OMP_DISPATCH_CHECK (NODE), 1)
1659
1660#define OMP_CLAUSE_SIZE(NODE) \
1661 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1662 OMP_CLAUSE_FROM, \
1663 OMP_CLAUSE__CACHE_), 1)
1664
1665#define OMP_CLAUSE_CHAIN(NODE) TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
1666#define OMP_CLAUSE_DECL(NODE) \
1667 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1668 OMP_CLAUSE_PRIVATE, \
1669 OMP_CLAUSE__SCANTEMP_), 0)
1670#define OMP_CLAUSE_HAS_LOCATION(NODE) \
1671 (LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus) \
1672 != UNKNOWN_LOCATION)
1673#define OMP_CLAUSE_LOCATION(NODE) (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus
1674
1675#define OMP_CLAUSE_HAS_ITERATORS(NODE) \
1676 ((OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_FROM \
1677 || OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_TO \
1678 || OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_MAP) \
1679 && OMP_CLAUSE_ITERATORS (NODE))
1680#define OMP_CLAUSE_ITERATORS(NODE) \
1681 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1682 OMP_CLAUSE_FROM, \
1683 OMP_CLAUSE_MAP), 2)
1684
1685/* True on OMP_FOR and other OpenMP/OpenACC looping constructs if the loop nest
1686 is non-rectangular. */
1687#define OMP_FOR_NON_RECTANGULAR(NODE) \
1688 (OMP_LOOPING_CHECK (NODE)->base.private_flag)
1689
1690/* True on an OMP_SECTION statement that was the last lexical member.
1691 This status is meaningful in the implementation of lastprivate. */
1692#define OMP_SECTION_LAST(NODE) \
1693 (OMP_SECTION_CHECK (NODE)->base.private_flag)
1694
1695/* True on an OMP_PARALLEL statement if it represents an explicit
1696 combined parallel work-sharing constructs. */
1697#define OMP_PARALLEL_COMBINED(NODE) \
1698 (OMP_PARALLEL_CHECK (NODE)->base.private_flag)
1699
1700/* True on an OMP_TEAMS statement if it represents an explicit
1701 combined teams distribute constructs. */
1702#define OMP_TEAMS_COMBINED(NODE) \
1703 (OMP_TEAMS_CHECK (NODE)->base.private_flag)
1704
1705/* True on an OMP_TARGET statement if it represents explicit
1706 combined target teams, target parallel or target simd constructs. */
1707#define OMP_TARGET_COMBINED(NODE) \
1708 (OMP_TARGET_CHECK (NODE)->base.private_flag)
1709
1710/* True on an OMP_MASTER statement if it represents an explicit
1711 combined master constructs. */
1712#define OMP_MASTER_COMBINED(NODE) \
1713 (OMP_MASTER_CHECK (NODE)->base.private_flag)
1714
1715/* True on an OMP_MASKED statement if it represents an explicit
1716 combined masked constructs. */
1717#define OMP_MASKED_COMBINED(NODE) \
1718 (OMP_MASKED_CHECK (NODE)->base.private_flag)
1719
1720/* Memory order for OMP_ATOMIC*. */
1721#define OMP_ATOMIC_MEMORY_ORDER(NODE) \
1722 (TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \
1723 OMP_ATOMIC_CAPTURE_NEW)->base.u.omp_atomic_memory_order)
1724
1725/* Weak clause on OMP_ATOMIC*. */
1726#define OMP_ATOMIC_WEAK(NODE) \
1727 (TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \
1728 OMP_ATOMIC_CAPTURE_NEW)->base.public_flag)
1729
1730/* True on a PRIVATE clause if its decl is kept around for debugging
1731 information only and its DECL_VALUE_EXPR is supposed to point
1732 to what it has been remapped to. */
1733#define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \
1734 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)->base.public_flag)
1735
1736/* True on a PRIVATE clause if ctor needs access to outer region's
1737 variable. */
1738#define OMP_CLAUSE_PRIVATE_OUTER_REF(NODE) \
1739 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
1740
1741/* True if a PRIVATE clause is for a C++ class IV on taskloop construct
1742 (thus should be private on the outer taskloop and firstprivate on
1743 task). */
1744#define OMP_CLAUSE_PRIVATE_TASKLOOP_IV(NODE) \
1745 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
1746
1747/* True on a FIRSTPRIVATE clause if it has been added implicitly. */
1748#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT(NODE) \
1749 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)->base.public_flag)
1750
1751/* True on a FIRSTPRIVATE clause if only the reference and not what it refers
1752 to should be firstprivatized. */
1753#define OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE(NODE) \
1754 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))
1755
1756/* True on a FIRSTPRIVATE clause with OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT also
1757 set if target construct is the only one that accepts the clause. */
1758#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT_TARGET(NODE) \
1759 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))
1760
1761/* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
1762 decl is present in the chain. */
1763#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \
1764 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)->base.public_flag)
1765#define OMP_CLAUSE_LASTPRIVATE_STMT(NODE) \
1766 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
1767 OMP_CLAUSE_LASTPRIVATE),\
1768 1)
1769#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ(NODE) \
1770 (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
1771
1772/* True if a LASTPRIVATE clause is for a C++ class IV on taskloop or
1773 loop construct (thus should be lastprivate on the outer taskloop and
1774 firstprivate on task for the taskloop construct and carefully handled
1775 for loop construct). */
1776#define OMP_CLAUSE_LASTPRIVATE_LOOP_IV(NODE) \
1777 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
1778
1779/* True if a LASTPRIVATE clause has CONDITIONAL: modifier. */
1780#define OMP_CLAUSE_LASTPRIVATE_CONDITIONAL(NODE) \
1781 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
1782
1783/* True on a SHARED clause if a FIRSTPRIVATE clause for the same
1784 decl is present in the chain (this can happen only for taskloop
1785 with FIRSTPRIVATE/LASTPRIVATE on it originally. */
1786#define OMP_CLAUSE_SHARED_FIRSTPRIVATE(NODE) \
1787 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)->base.public_flag)
1788
1789/* True on a SHARED clause if a scalar is not modified in the body and
1790 thus could be optimized as firstprivate. */
1791#define OMP_CLAUSE_SHARED_READONLY(NODE) \
1792 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED))
1793
1794#define OMP_CLAUSE_IF_MODIFIER(NODE) \
1795 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF)->omp_clause.subcode.if_modifier)
1796
1797#define OMP_CLAUSE_FINAL_EXPR(NODE) \
1798 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0)
1799#define OMP_CLAUSE_IF_EXPR(NODE) \
1800 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)
1801#define OMP_CLAUSE_SELF_EXPR(NODE) \
1802 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SELF), 0)
1803#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \
1804 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)
1805#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \
1806 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)
1807#define OMP_CLAUSE_NUM_TASKS_EXPR(NODE) \
1808 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS), 0)
1809#define OMP_CLAUSE_HINT_EXPR(NODE) \
1810 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_HINT), 0)
1811#define OMP_CLAUSE_FILTER_EXPR(NODE) \
1812 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FILTER), 0)
1813#define OMP_CLAUSE_PARTIAL_EXPR(NODE) \
1814 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PARTIAL), 0)
1815#define OMP_CLAUSE_SIZES_LIST(NODE) \
1816 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIZES), 0)
1817#define OMP_CLAUSE_NOVARIANTS_EXPR(NODE) \
1818 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NOVARIANTS), 0)
1819#define OMP_CLAUSE_NOCONTEXT_EXPR(NODE) \
1820 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NOCONTEXT), 0)
1821
1822#define OMP_CLAUSE_GRAINSIZE_EXPR(NODE) \
1823 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE),0)
1824
1825#define OMP_CLAUSE_PRIORITY_EXPR(NODE) \
1826 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIORITY),0)
1827
1828#define OMP_CLAUSE_GRAINSIZE_STRICT(NODE) \
1829 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE))
1830#define OMP_CLAUSE_NUM_TASKS_STRICT(NODE) \
1831 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS))
1832
1833/* OpenACC clause expressions */
1834#define OMP_CLAUSE_EXPR(NODE, CLAUSE) \
1835 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, CLAUSE), 0)
1836#define OMP_CLAUSE_GANG_EXPR(NODE) \
1837 OMP_CLAUSE_OPERAND ( \
1838 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 0)
1839#define OMP_CLAUSE_GANG_STATIC_EXPR(NODE) \
1840 OMP_CLAUSE_OPERAND ( \
1841 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 1)
1842#define OMP_CLAUSE_ASYNC_EXPR(NODE) \
1843 OMP_CLAUSE_OPERAND ( \
1844 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ASYNC), 0)
1845#define OMP_CLAUSE_WAIT_EXPR(NODE) \
1846 OMP_CLAUSE_OPERAND ( \
1847 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WAIT), 0)
1848#define OMP_CLAUSE_VECTOR_EXPR(NODE) \
1849 OMP_CLAUSE_OPERAND ( \
1850 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR), 0)
1851#define OMP_CLAUSE_WORKER_EXPR(NODE) \
1852 OMP_CLAUSE_OPERAND ( \
1853 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WORKER), 0)
1854#define OMP_CLAUSE_NUM_GANGS_EXPR(NODE) \
1855 OMP_CLAUSE_OPERAND ( \
1856 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_GANGS), 0)
1857#define OMP_CLAUSE_NUM_WORKERS_EXPR(NODE) \
1858 OMP_CLAUSE_OPERAND ( \
1859 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_WORKERS), 0)
1860#define OMP_CLAUSE_VECTOR_LENGTH_EXPR(NODE) \
1861 OMP_CLAUSE_OPERAND ( \
1862 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR_LENGTH), 0)
1863
1864#define OMP_CLAUSE_DEPEND_KIND(NODE) \
1865 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind)
1866
1867#define OMP_CLAUSE_DOACROSS_KIND(NODE) \
1868 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS)->omp_clause.subcode.doacross_kind)
1869
1870#define OMP_CLAUSE_DOACROSS_SINK_NEGATIVE(NODE) \
1871 TREE_PUBLIC (TREE_LIST_CHECK (NODE))
1872
1873/* True if DOACROSS clause is spelled as DEPEND. */
1874#define OMP_CLAUSE_DOACROSS_DEPEND(NODE) \
1875 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS))
1876
1877#define OMP_CLAUSE_MAP_KIND(NODE) \
1878 ((enum gomp_map_kind) OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind)
1879#define OMP_CLAUSE_SET_MAP_KIND(NODE, MAP_KIND) \
1880 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind \
1881 = (unsigned int) (MAP_KIND))
1882
1883#define OMP_CLAUSE_MOTION_PRESENT(NODE) \
1884 (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_FROM, OMP_CLAUSE_TO)->base.deprecated_flag)
1885
1886#define OMP_CLAUSE_INIT_TARGET(NODE) \
1887 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INIT)->base.public_flag)
1888#define OMP_CLAUSE_INIT_TARGETSYNC(NODE) \
1889 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INIT)->base.deprecated_flag)
1890#define OMP_CLAUSE_INIT_PREFER_TYPE(NODE) \
1891 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1892 OMP_CLAUSE_INIT, \
1893 OMP_CLAUSE_INIT), 1)
1894
1895/* Nonzero if this map clause is for array (rather than pointer) based array
1896 section with zero bias. Both the non-decl OMP_CLAUSE_MAP and corresponding
1897 OMP_CLAUSE_MAP with GOMP_MAP_POINTER are marked with this flag. */
1898#define OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION(NODE) \
1899 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.public_flag)
1900/* Nonzero if this is a mapped array section, that might need special
1901 treatment if OMP_CLAUSE_SIZE is zero. */
1902#define OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION(NODE) \
1903 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1904/* Nonzero if this map clause is for an OpenACC compute construct's reduction
1905 variable or OpenMP map clause mentioned also in in_reduction clause on the
1906 same construct. */
1907#define OMP_CLAUSE_MAP_IN_REDUCTION(NODE) \
1908 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1909/* Nonzero on map clauses added implicitly for reduction clauses on combined
1910 or composite constructs. They shall be removed if there is an explicit
1911 map clause. */
1912#define OMP_CLAUSE_MAP_IMPLICIT(NODE) \
1913 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.default_def_flag)
1914/* Nonzero if this map clause is to be indicated to the runtime as 'implicit',
1915 due to being created through implicit data-mapping rules in the middle-end.
1916 NOTE: this is different than OMP_CLAUSE_MAP_IMPLICIT. */
1917#define OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P(NODE) \
1918 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.deprecated_flag)
1919/* Nonzero for an attach/detach node whose decl was explicitly mapped on the
1920 same directive. */
1921#define OMP_CLAUSE_ATTACHMENT_MAPPING_ERASED(NODE) \
1922 TREE_STATIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1923/* Nonzero if this is a release/delete node which refers to a (Fortran) array
1924 descriptor. */
1925#define OMP_CLAUSE_RELEASE_DESCRIPTOR(NODE) \
1926 TREE_NOTHROW (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1927
1928/* Flag that 'OMP_CLAUSE_DECL (NODE)' is to be made addressable during OMP
1929 lowering. */
1930#define OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE(NODE) \
1931 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.addressable_flag)
1932
1933/* Nonzero if OpenACC 'readonly' modifier set, used for 'copyin'. */
1934#define OMP_CLAUSE_MAP_READONLY(NODE) \
1935 TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1936
1937/* Same as above, for use in OpenACC cache directives. */
1938#define OMP_CLAUSE__CACHE__READONLY(NODE) \
1939 TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CACHE_))
1940
1941/* True on an OMP_CLAUSE_USE_DEVICE_PTR with an OpenACC 'if_present'
1942 clause. */
1943#define OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT(NODE) \
1944 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USE_DEVICE_PTR)->base.public_flag)
1945
1946#define OMP_CLAUSE_PROC_BIND_KIND(NODE) \
1947 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)->omp_clause.subcode.proc_bind_kind)
1948
1949#define OMP_CLAUSE_DEVICE_TYPE_KIND(NODE) \
1950 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE_TYPE)->omp_clause.subcode.device_type_kind)
1951
1952#define OMP_CLAUSE_INDIRECT_EXPR(NODE) \
1953 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INDIRECT), 0)
1954
1955
1956/* True if there is a device clause with a device-modifier 'ancestor'. */
1957#define OMP_CLAUSE_DEVICE_ANCESTOR(NODE) \
1958 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE)->base.public_flag)
1959
1960#define OMP_CLAUSE_COLLAPSE_EXPR(NODE) \
1961 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0)
1962#define OMP_CLAUSE_COLLAPSE_ITERVAR(NODE) \
1963 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1)
1964#define OMP_CLAUSE_COLLAPSE_COUNT(NODE) \
1965 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2)
1966
1967#define OMP_CLAUSE_ORDERED_EXPR(NODE) \
1968 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED), 0)
1969
1970/* True on an OMP_CLAUSE_ORDERED if stand-alone ordered construct is nested
1971 inside of work-sharing loop the clause is on. */
1972#define OMP_CLAUSE_ORDERED_DOACROSS(NODE) \
1973 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED)->base.public_flag)
1974
1975/* True for unconstrained modifier on order(concurrent) clause. */
1976#define OMP_CLAUSE_ORDER_UNCONSTRAINED(NODE) \
1977 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)->base.public_flag)
1978/* True for reproducible modifier on order(concurrent) clause. */
1979#define OMP_CLAUSE_ORDER_REPRODUCIBLE(NODE) \
1980 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER))
1981
1982#define OMP_CLAUSE_REDUCTION_CODE(NODE) \
1983 (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
1984 OMP_CLAUSE_IN_REDUCTION)->omp_clause.subcode.reduction_code)
1985#define OMP_CLAUSE_REDUCTION_INIT(NODE) \
1986 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
1987 OMP_CLAUSE_IN_REDUCTION), 1)
1988#define OMP_CLAUSE_REDUCTION_MERGE(NODE) \
1989 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
1990 OMP_CLAUSE_IN_REDUCTION), 2)
1991#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT(NODE) \
1992 (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
1993#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE(NODE) \
1994 (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge
1995#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
1996 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
1997 OMP_CLAUSE_IN_REDUCTION), 3)
1998#define OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER(NODE) \
1999 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
2000 OMP_CLAUSE_IN_REDUCTION), 4)
2001
2002/* True if a REDUCTION clause may reference the original list item (omp_orig)
2003 in its OMP_CLAUSE_REDUCTION_{,GIMPLE_}INIT. */
2004#define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF(NODE) \
2005 (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
2006 OMP_CLAUSE_IN_REDUCTION)->base.public_flag)
2007
2008/* True if a REDUCTION clause has task reduction-modifier. */
2009#define OMP_CLAUSE_REDUCTION_TASK(NODE) \
2010 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
2011
2012/* True if a REDUCTION clause has inscan reduction-modifier. */
2013#define OMP_CLAUSE_REDUCTION_INSCAN(NODE) \
2014 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
2015
2016/* True if a LINEAR clause doesn't need copy in. True for iterator vars which
2017 are always initialized inside of the loop construct, false otherwise. */
2018#define OMP_CLAUSE_LINEAR_NO_COPYIN(NODE) \
2019 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.public_flag)
2020
2021/* True if a LINEAR clause doesn't need copy out. True for iterator vars which
2022 are declared inside of the simd construct. */
2023#define OMP_CLAUSE_LINEAR_NO_COPYOUT(NODE) \
2024 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
2025
2026/* True if a LINEAR clause has a stride that is variable. */
2027#define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE(NODE) \
2028 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
2029
2030/* True for a LINEAR clause with old style modifier syntax
2031 linear(modifier(list)) or linear(modifier(list):step). */
2032#define OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER(NODE) \
2033 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.addressable_flag)
2034
2035/* True if a LINEAR clause is for an array or allocatable variable that
2036 needs special handling by the frontend. */
2037#define OMP_CLAUSE_LINEAR_ARRAY(NODE) \
2038 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.deprecated_flag)
2039
2040#define OMP_CLAUSE_LINEAR_STEP(NODE) \
2041 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)
2042
2043#define OMP_CLAUSE_LINEAR_STMT(NODE) \
2044 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 2)
2045
2046#define OMP_CLAUSE_LINEAR_GIMPLE_SEQ(NODE) \
2047 (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
2048
2049#define OMP_CLAUSE_LINEAR_KIND(NODE) \
2050 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->omp_clause.subcode.linear_kind)
2051
2052#define OMP_CLAUSE_ALIGNED_ALIGNMENT(NODE) \
2053 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1)
2054
2055#define OMP_CLAUSE_ALLOCATE_ALLOCATOR(NODE) \
2056 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 1)
2057
2058#define OMP_CLAUSE_ALLOCATE_ALIGN(NODE) \
2059 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 2)
2060
2061/* True if an ALLOCATE clause was present on a combined or composite
2062 construct and the code for splitting the clauses has already performed
2063 checking if the listed variable has explicit privatization on the
2064 construct. */
2065#define OMP_CLAUSE_ALLOCATE_COMBINED(NODE) \
2066 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE)->base.public_flag)
2067
2068#define OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR(NODE) \
2069 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)
2070
2071#define OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR(NODE) \
2072 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 1)
2073
2074#define OMP_CLAUSE_THREAD_LIMIT_EXPR(NODE) \
2075 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2076 OMP_CLAUSE_THREAD_LIMIT), 0)
2077
2078#define OMP_CLAUSE_DEVICE_ID(NODE) \
2079 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0)
2080
2081#define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR(NODE) \
2082 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2083 OMP_CLAUSE_DIST_SCHEDULE), 0)
2084
2085#define OMP_CLAUSE_SAFELEN_EXPR(NODE) \
2086 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0)
2087
2088#define OMP_CLAUSE_SIMDLEN_EXPR(NODE) \
2089 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0)
2090
2091#define OMP_CLAUSE__SIMDUID__DECL(NODE) \
2092 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0)
2093
2094#define OMP_CLAUSE_SCHEDULE_KIND(NODE) \
2095 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)
2096
2097/* True if a SCHEDULE clause has the simd modifier on it. */
2098#define OMP_CLAUSE_SCHEDULE_SIMD(NODE) \
2099 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->base.public_flag)
2100
2101#define OMP_CLAUSE_DEFAULT_KIND(NODE) \
2102 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
2103
2104#define OMP_CLAUSE_DEFAULTMAP_KIND(NODE) \
2105 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULTMAP)->omp_clause.subcode.defaultmap_kind)
2106#define OMP_CLAUSE_DEFAULTMAP_CATEGORY(NODE) \
2107 ((enum omp_clause_defaultmap_kind) \
2108 (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK))
2109#define OMP_CLAUSE_DEFAULTMAP_BEHAVIOR(NODE) \
2110 ((enum omp_clause_defaultmap_kind) \
2111 (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_MASK))
2112#define OMP_CLAUSE_DEFAULTMAP_SET_KIND(NODE, BEHAVIOR, CATEGORY) \
2113 (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) \
2114 = (enum omp_clause_defaultmap_kind) (CATEGORY | BEHAVIOR))
2115
2116#define OMP_CLAUSE_BIND_KIND(NODE) \
2117 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_BIND)->omp_clause.subcode.bind_kind)
2118
2119/* True if ENTER clause is spelled as TO. */
2120#define OMP_CLAUSE_ENTER_TO(NODE) \
2121 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ENTER)->base.public_flag)
2122
2123#define OMP_CLAUSE_TILE_LIST(NODE) \
2124 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 0)
2125#define OMP_CLAUSE_TILE_ITERVAR(NODE) \
2126 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 1)
2127#define OMP_CLAUSE_TILE_COUNT(NODE) \
2128 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 2)
2129
2130/* _CONDTEMP_ holding temporary with iteration count. */
2131#define OMP_CLAUSE__CONDTEMP__ITER(NODE) \
2132 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CONDTEMP_)->base.public_flag)
2133
2134/* _SCANTEMP_ holding temporary with pointer to thread's local array;
2135 allocation. */
2136#define OMP_CLAUSE__SCANTEMP__ALLOC(NODE) \
2137 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)->base.public_flag)
2138
2139/* _SCANTEMP_ holding temporary with a control variable for deallocation;
2140 one boolean_type_node for test whether alloca was used, another one
2141 to pass to __builtin_stack_restore or free. */
2142#define OMP_CLAUSE__SCANTEMP__CONTROL(NODE) \
2143 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_))
2144
2145/* OpenMP OMP_NEXT_VARIANT accessors. */
2146#define OMP_NEXT_VARIANT_INDEX(NODE) \
2147 TREE_OPERAND (OMP_NEXT_VARIANT_CHECK (NODE), 0)
2148#define OMP_NEXT_VARIANT_STATE(NODE) \
2149 TREE_OPERAND (OMP_NEXT_VARIANT_CHECK (NODE), 1)
2150
2151/* OpenMP OMP_TARGET_DEVICE_MATCHES accessors. */
2152#define OMP_TARGET_DEVICE_MATCHES_SELECTOR(NODE) \
2153 TREE_OPERAND (OMP_TARGET_DEVICE_MATCHES_CHECK (NODE), 0)
2154#define OMP_TARGET_DEVICE_MATCHES_PROPERTIES(NODE) \
2155 TREE_OPERAND (OMP_TARGET_DEVICE_MATCHES_CHECK (NODE), 1)
2156
2157#define OMP_CLAUSE__MAPPER_BINDING__ID(NODE) \
2158 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2159 OMP_CLAUSE__MAPPER_BINDING_), 0)
2160
2161#define OMP_CLAUSE__MAPPER_BINDING__DECL(NODE) \
2162 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2163 OMP_CLAUSE__MAPPER_BINDING_), 1)
2164
2165#define OMP_CLAUSE__MAPPER_BINDING__MAPPER(NODE) \
2166 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2167 OMP_CLAUSE__MAPPER_BINDING_), 2)
2168
2169/* SSA_NAME accessors. */
2170
2171/* Whether SSA_NAME NODE is a virtual operand. This simply caches the
2172 information in the underlying SSA_NAME_VAR for efficiency. */
2173#define SSA_NAME_IS_VIRTUAL_OPERAND(NODE) \
2174 SSA_NAME_CHECK (NODE)->base.public_flag
2175
2176/* Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE
2177 if there is no name associated with it. */
2178#define SSA_NAME_IDENTIFIER(NODE) \
2179 (SSA_NAME_CHECK (NODE)->ssa_name.var != NULL_TREE \
2180 ? (TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE \
2181 ? (NODE)->ssa_name.var \
2182 : DECL_NAME ((NODE)->ssa_name.var)) \
2183 : NULL_TREE)
2184
2185/* Returns the variable being referenced. This can be NULL_TREE for
2186 temporaries not associated with any user variable.
2187 Once released, this is the only field that can be relied upon. */
2188#define SSA_NAME_VAR(NODE) \
2189 (SSA_NAME_CHECK (NODE)->ssa_name.var == NULL_TREE \
2190 || TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE \
2191 ? NULL_TREE : (NODE)->ssa_name.var)
2192
2193#define SET_SSA_NAME_VAR_OR_IDENTIFIER(NODE,VAR) \
2194 do \
2195 { \
2196 tree var_ = (VAR); \
2197 SSA_NAME_CHECK (NODE)->ssa_name.var = var_; \
2198 SSA_NAME_IS_VIRTUAL_OPERAND (NODE) \
2199 = (var_ \
2200 && TREE_CODE (var_) == VAR_DECL \
2201 && VAR_DECL_IS_VIRTUAL_OPERAND (var_)); \
2202 } \
2203 while (0)
2204
2205/* Returns the statement which defines this SSA name. */
2206#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->ssa_name.def_stmt
2207
2208/* Returns the SSA version number of this SSA name. Note that in
2209 tree SSA, version numbers are not per variable and may be recycled. */
2210#define SSA_NAME_VERSION(NODE) SSA_NAME_CHECK (NODE)->base.u.version
2211
2212/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are
2213 never output, so we can safely use the ASM_WRITTEN_FLAG for this
2214 status bit. */
2215#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \
2216 SSA_NAME_CHECK (NODE)->base.asm_written_flag
2217
2218/* Nonzero if this SSA_NAME expression is currently on the free list of
2219 SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing
2220 has no meaning for an SSA_NAME. */
2221#define SSA_NAME_IN_FREE_LIST(NODE) \
2222 SSA_NAME_CHECK (NODE)->base.nothrow_flag
2223
2224/* Nonzero if this SSA_NAME is the default definition for the
2225 underlying symbol. A default SSA name is created for symbol S if
2226 the very first reference to S in the function is a read operation.
2227 Default definitions are always created by an empty statement and
2228 belong to no basic block. */
2229#define SSA_NAME_IS_DEFAULT_DEF(NODE) \
2230 SSA_NAME_CHECK (NODE)->base.default_def_flag
2231
2232/* Nonzero if this SSA_NAME is known to point to memory that may not
2233 be written to. This is set for default defs of function parameters
2234 that have a corresponding r or R specification in the functions
2235 fn spec attribute. This is used by alias analysis. */
2236#define SSA_NAME_POINTS_TO_READONLY_MEMORY(NODE) \
2237 SSA_NAME_CHECK (NODE)->base.deprecated_flag
2238
2239/* Attributes for SSA_NAMEs for pointer-type variables. */
2240#define SSA_NAME_PTR_INFO(N) \
2241 SSA_NAME_CHECK (N)->ssa_name.info.ptr_info
2242
2243/* Value range info attributes for SSA_NAMEs of non pointer-type variables. */
2244#define SSA_NAME_RANGE_INFO(N) \
2245 SSA_NAME_CHECK (N)->ssa_name.info.range_info
2246
2247/* Return the immediate_use information for an SSA_NAME. */
2248#define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
2249
2250#define OMP_CLAUSE_CODE(NODE) \
2251 (OMP_CLAUSE_CHECK (NODE))->omp_clause.code
2252
2253#define OMP_CLAUSE_SET_CODE(NODE, CODE) \
2254 ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))
2255
2256#define OMP_CLAUSE_OPERAND(NODE, I) \
2257 OMP_CLAUSE_ELT_CHECK (NODE, I)
2258
2259/* True if the clause decl NODE contains an OpenMP iterator. */
2260#define OMP_ITERATOR_DECL_P(NODE) \
2261 (TREE_CODE (NODE) == TREE_LIST \
2262 && TREE_PURPOSE (NODE) \
2263 && TREE_CODE (TREE_PURPOSE (NODE)) == TREE_VEC)
2264
2265/* In a BLOCK (scope) node:
2266 Variables declared in the scope NODE. */
2267#define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
2268#define BLOCK_NONLOCALIZED_VARS(NODE) \
2269 (BLOCK_CHECK (NODE)->block.nonlocalized_vars)
2270#define BLOCK_NUM_NONLOCALIZED_VARS(NODE) \
2271 vec_safe_length (BLOCK_NONLOCALIZED_VARS (NODE))
2272#define BLOCK_NONLOCALIZED_VAR(NODE,N) (*BLOCK_NONLOCALIZED_VARS (NODE))[N]
2273/* A chain of BLOCKs (scopes) nested within the scope NODE. */
2274#define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
2275/* The scope enclosing the scope NODE, or FUNCTION_DECL for the "outermost"
2276 function scope. Inlined functions are chained by this so that given
2277 expression E and its TREE_BLOCK(E) B, BLOCK_SUPERCONTEXT(B) is the scope
2278 in which E has been made or into which E has been inlined. */
2279#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
2280/* Points to the next scope at the same level of nesting as scope NODE. */
2281#define BLOCK_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.chain)
2282/* A BLOCK, or FUNCTION_DECL of the function from which a block has been
2283 inlined. In a scope immediately enclosing an inlined leaf expression,
2284 points to the outermost scope into which it has been inlined (thus
2285 bypassing all intermediate BLOCK_SUPERCONTEXTs). */
2286#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
2287#define BLOCK_ORIGIN(NODE) \
2288 (BLOCK_ABSTRACT_ORIGIN(NODE) ? BLOCK_ABSTRACT_ORIGIN(NODE) : (NODE))
2289#define BLOCK_DIE(NODE) (BLOCK_CHECK (NODE)->block.die)
2290
2291/* True if BLOCK has the same ranges as its BLOCK_SUPERCONTEXT. */
2292#define BLOCK_SAME_RANGE(NODE) (BLOCK_CHECK (NODE)->base.u.bits.nameless_flag)
2293
2294/* True if BLOCK appears in cold section. */
2295#define BLOCK_IN_COLD_SECTION_P(NODE) \
2296 (BLOCK_CHECK (NODE)->base.u.bits.atomic_flag)
2297
2298/* An index number for this block. These values are not guaranteed to
2299 be unique across functions -- whether or not they are depends on
2300 the debugging output format in use. */
2301#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
2302
2303/* If block reordering splits a lexical block into discontiguous
2304 address ranges, we'll make a copy of the original block.
2305
2306 Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
2307 In that case, we have one source block that has been replicated
2308 (through inlining or unrolling) into many logical blocks, and that
2309 these logical blocks have different physical variables in them.
2310
2311 In this case, we have one logical block split into several
2312 non-contiguous address ranges. Most debug formats can't actually
2313 represent this idea directly, so we fake it by creating multiple
2314 logical blocks with the same variables in them. However, for those
2315 that do support non-contiguous regions, these allow the original
2316 logical block to be reconstructed, along with the set of address
2317 ranges.
2318
2319 One of the logical block fragments is arbitrarily chosen to be
2320 the ORIGIN. The other fragments will point to the origin via
2321 BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
2322 be null. The list of fragments will be chained through
2323 BLOCK_FRAGMENT_CHAIN from the origin. */
2324
2325#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
2326#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
2327
2328/* For an inlined function, this gives the location where it was called
2329 from. This is only set in the top level block, which corresponds to the
2330 inlined function scope. This is used in the debug output routines. */
2331
2332#define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)
2333
2334/* This gives the location of the end of the block, useful to attach
2335 code implicitly generated for outgoing paths. */
2336
2337#define BLOCK_SOURCE_END_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.end_locus)
2338
2339/* Define fields and accessors for nodes representing data types. */
2340
2341/* See tree.def for documentation of the use of these fields.
2342 Look at the documentation of the various ..._TYPE tree codes.
2343
2344 Note that the type.values, type.minval, and type.maxval fields are
2345 overloaded and used for different macros in different kinds of types.
2346 Each macro must check to ensure the tree node is of the proper kind of
2347 type. Note also that some of the front-ends also overload these fields,
2348 so they must be checked as well. */
2349
2350#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type_common.uid)
2351/* Type size in bits as a tree expression. Need not be constant and may
2352 be greater than TYPE_SIZE for a C++ FIELD_DECL representing a base
2353 class subobject with its own virtual base classes (which are laid out
2354 separately). */
2355#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type_common.size)
2356/* Likewise, type size in bytes. */
2357#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type_common.size_unit)
2358#define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type_common.pointer_to)
2359#define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type_common.reference_to)
2360#define TYPE_PRECISION(NODE) \
2361 (TREE_NOT_CHECK (TYPE_CHECK (NODE), VECTOR_TYPE)->type_common.precision)
2362#define TYPE_PRECISION_RAW(NODE) (TYPE_CHECK (NODE)->type_common.precision)
2363#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type_common.name)
2364#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.next_variant)
2365#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.main_variant)
2366#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type_common.context)
2367
2368#define TYPE_MODE_RAW(NODE) (TYPE_CHECK (NODE)->type_common.mode)
2369#define TYPE_MODE(NODE) \
2370 (VECTOR_TYPE_P (TYPE_CHECK (NODE)) \
2371 ? vector_type_mode (NODE) : (NODE)->type_common.mode)
2372#define SCALAR_TYPE_MODE(NODE) \
2373 (as_a <scalar_mode> (TYPE_CHECK (NODE)->type_common.mode))
2374#define SCALAR_INT_TYPE_MODE(NODE) \
2375 (as_a <scalar_int_mode> (TYPE_CHECK (NODE)->type_common.mode))
2376#define SCALAR_FLOAT_TYPE_MODE(NODE) \
2377 (as_a <scalar_float_mode> (TYPE_CHECK (NODE)->type_common.mode))
2378#define SET_TYPE_MODE(NODE, MODE) \
2379 (TYPE_CHECK (NODE)->type_common.mode = (MODE))
2380
2381extern unsigned int element_precision (const_tree);
2382extern machine_mode element_mode (const_tree);
2383extern machine_mode vector_type_mode (const_tree);
2384extern unsigned int vector_element_bits (const_tree);
2386
2387/* The "canonical" type for this type node, which is used by frontends to
2388 compare the type for equality with another type. If two types are
2389 equal (based on the semantics of the language), then they will have
2390 equivalent TYPE_CANONICAL entries.
2391
2392 As a special case, if TYPE_CANONICAL is NULL_TREE, and thus
2393 TYPE_STRUCTURAL_EQUALITY_P is true, then it cannot
2394 be used for comparison against other types. Instead, the type is
2395 said to require structural equality checks, described in
2396 TYPE_STRUCTURAL_EQUALITY_P.
2397
2398 For unqualified aggregate and function types the middle-end relies on
2399 TYPE_CANONICAL to tell whether two variables can be assigned
2400 to each other without a conversion. The middle-end also makes sure
2401 to assign the same alias-sets to the type partition with equal
2402 TYPE_CANONICAL of their unqualified variants. */
2403#define TYPE_CANONICAL(NODE) (TYPE_CHECK (NODE)->type_common.canonical)
2404/* Indicates that the type node requires structural equality
2405 checks. The compiler will need to look at the composition of the
2406 type to determine whether it is equal to another type, rather than
2407 just comparing canonical type pointers. For instance, we would need
2408 to look at the return and parameter types of a FUNCTION_TYPE
2409 node. */
2410#define TYPE_STRUCTURAL_EQUALITY_P(NODE) (TYPE_CANONICAL (NODE) == NULL_TREE)
2411/* Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the
2412 type node requires structural equality. */
2413#define SET_TYPE_STRUCTURAL_EQUALITY(NODE) (TYPE_CANONICAL (NODE) = NULL_TREE)
2414
2415#define TYPE_IBIT(NODE) (GET_MODE_IBIT (TYPE_MODE (NODE)))
2416#define TYPE_FBIT(NODE) (GET_MODE_FBIT (TYPE_MODE (NODE)))
2417
2418/* The (language-specific) typed-based alias set for this type.
2419 Objects whose TYPE_ALIAS_SETs are different cannot alias each
2420 other. If the TYPE_ALIAS_SET is -1, no alias set has yet been
2421 assigned to this type. If the TYPE_ALIAS_SET is 0, objects of this
2422 type can alias objects of any type. */
2423#define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type_common.alias_set)
2424
2425/* Nonzero iff the typed-based alias set for this type has been
2426 calculated. */
2427#define TYPE_ALIAS_SET_KNOWN_P(NODE) \
2428 (TYPE_CHECK (NODE)->type_common.alias_set != -1)
2429
2430/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
2431 to this type. */
2432#define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type_common.attributes)
2433
2434/* Raw access to the alignment field. */
2435#define TYPE_ALIGN_RAW(NODE) \
2436 (TYPE_CHECK (NODE)->type_common.align)
2437
2438/* The alignment necessary for objects of this type.
2439 The value is an int, measured in bits and must be a power of two.
2440 We support also an "alignment" of zero. */
2441#define TYPE_ALIGN(NODE) \
2442 (TYPE_ALIGN_RAW (NODE) \
2443 ? ((unsigned)1) << (TYPE_ALIGN_RAW(NODE) - 1) : 0)
2444
2445/* Specify that TYPE_ALIGN(NODE) is X. */
2446#define SET_TYPE_ALIGN(NODE, X) \
2447 (TYPE_CHECK (NODE)->type_common.align = ffs_hwi (X))
2448
2449/* 1 if the alignment for this type was requested by "aligned" attribute,
2450 0 if it is the default for this type. */
2451#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->base.u.bits.user_align)
2452
2453/* The alignment for NODE, in bytes. */
2454#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
2455
2456/* The minimum alignment necessary for objects of this type without
2457 warning. The value is an int, measured in bits. */
2458#define TYPE_WARN_IF_NOT_ALIGN_RAW(NODE) \
2459 (TYPE_CHECK (NODE)->type_common.warn_if_not_align)
2460#define TYPE_WARN_IF_NOT_ALIGN(NODE) \
2461 (TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) \
2462 ? ((unsigned)1) << (TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) - 1) : 0)
2463
2464/* Specify that TYPE_WARN_IF_NOT_ALIGN(NODE) is X. */
2465#define SET_TYPE_WARN_IF_NOT_ALIGN(NODE, X) \
2466 (TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X))
2467
2468/* If your language allows you to declare types, and you want debug info
2469 for them, then you need to generate corresponding TYPE_DECL nodes.
2470 These "stub" TYPE_DECL nodes have no name, and simply point at the
2471 type node. You then set the TYPE_STUB_DECL field of the type node
2472 to point back at the TYPE_DECL node. This allows the debug routines
2473 to know that the two nodes represent the same type, so that we only
2474 get one debug info record for them. */
2475#define TYPE_STUB_DECL(NODE) (TREE_CHAIN (TYPE_CHECK (NODE)))
2476
2477/* In a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ARRAY_TYPE, it means
2478 the type has BLKmode only because it lacks the alignment required for
2479 its size. */
2480#define TYPE_NO_FORCE_BLK(NODE) \
2481 (TYPE_CHECK (NODE)->type_common.no_force_blk_flag)
2482
2483/* Nonzero in a type considered volatile as a whole. */
2484#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->base.volatile_flag)
2485
2486/* Nonzero in a type considered atomic as a whole. */
2487#define TYPE_ATOMIC(NODE) (TYPE_CHECK (NODE)->base.u.bits.atomic_flag)
2488
2489/* Means this type is const-qualified. */
2490#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->base.readonly_flag)
2491
2492/* If nonzero, this type is `restrict'-qualified, in the C sense of
2493 the term. */
2494#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type_common.restrict_flag)
2495
2496/* If nonzero, type's name shouldn't be emitted into debug info. */
2497#define TYPE_NAMELESS(NODE) (TYPE_CHECK (NODE)->base.u.bits.nameless_flag)
2498
2499/* The address space the type is in. */
2500#define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.u.bits.address_space)
2501
2502/* Encode/decode the named memory support as part of the qualifier. If more
2503 than 8 qualifiers are added, these macros need to be adjusted. */
2504#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
2505#define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
2506
2507/* Return all qualifiers except for the address space qualifiers. */
2508#define CLEAR_QUAL_ADDR_SPACE(X) ((X) & ~0xFF00)
2509
2510/* Only keep the address space out of the qualifiers and discard the other
2511 qualifiers. */
2512#define KEEP_QUAL_ADDR_SPACE(X) ((X) & 0xFF00)
2513
2514/* The set of type qualifiers for this type. */
2515#define TYPE_QUALS(NODE) \
2516 ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
2517 | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
2518 | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC) \
2519 | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT) \
2520 | (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE)))))
2521
2522/* The same as TYPE_QUALS without the address space qualifications. */
2523#define TYPE_QUALS_NO_ADDR_SPACE(NODE) \
2524 ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
2525 | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
2526 | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC) \
2527 | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))
2528
2529/* The same as TYPE_QUALS without the address space and atomic
2530 qualifications. */
2531#define TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC(NODE) \
2532 ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
2533 | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
2534 | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))
2535
2536/* These flags are available for each language front end to use internally. */
2537#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_0)
2538#define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_1)
2539#define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_2)
2540#define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_3)
2541#define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_4)
2542#define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_5)
2543#define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_6)
2544#define TYPE_LANG_FLAG_7(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_7)
2545
2546/* Used to keep track of visited nodes in tree traversals. This is set to
2547 0 by copy_node and make_node. */
2548#define TREE_VISITED(NODE) ((NODE)->base.visited)
2549
2550/* If set in an ARRAY_TYPE, indicates a string type (for languages
2551 that distinguish string from array of char).
2552 If set in a INTEGER_TYPE, indicates a character type. */
2553#define TYPE_STRING_FLAG(NODE) \
2554 (ARRAY_OR_INTEGER_TYPE_CHECK (NODE)->type_common.string_flag)
2555
2556/* If set for RECORD_TYPE or UNION_TYPE it indicates that the type conforms
2557 to the C++ one definition rule. This is used for LTO canonical type
2558 computation. */
2559#define TYPE_CXX_ODR_P(NODE) \
2560 (RECORD_OR_UNION_CHECK (NODE)->type_common.string_flag)
2561
2562/* Nonzero in a VECTOR_TYPE if the frontends should not emit warnings
2563 about missing conversions to other vector types of the same size. */
2564#define TYPE_VECTOR_OPAQUE(NODE) \
2565 (VECTOR_TYPE_CHECK (NODE)->base.default_def_flag)
2566
2567/* Indicates that objects of this type must be initialized by calling a
2568 function when they are created. */
2569#define TYPE_NEEDS_CONSTRUCTING(NODE) \
2570 (TYPE_CHECK (NODE)->type_common.needs_constructing_flag)
2571
2572/* Indicates that a UNION_TYPE object should be passed the same way that
2573 the first union alternative would be passed, or that a RECORD_TYPE
2574 object should be passed the same way that the first (and only) member
2575 would be passed. */
2576#define TYPE_TRANSPARENT_AGGR(NODE) \
2577 (RECORD_OR_UNION_CHECK (NODE)->type_common.transparent_aggr_flag)
2578
2579/* For an ARRAY_TYPE, indicates that it is not permitted to take the
2580 address of a component of the type. This is the counterpart of
2581 DECL_NONADDRESSABLE_P for arrays, see the definition of this flag. */
2582#define TYPE_NONALIASED_COMPONENT(NODE) \
2583 (ARRAY_TYPE_CHECK (NODE)->type_common.transparent_aggr_flag)
2584
2585/* For an ARRAY_TYPE, a RECORD_TYPE, a UNION_TYPE or a QUAL_UNION_TYPE
2586 whether the array is typeless storage or the type contains a member
2587 with this flag set. Such types are exempt from type-based alias
2588 analysis. For ARRAY_TYPEs with AGGREGATE_TYPE_P element types
2589 the flag should be inherited from the element type, can change
2590 when type is finalized and because of that should not be used in
2591 type hashing. For ARRAY_TYPEs with non-AGGREGATE_TYPE_P element types
2592 the flag should not be changed after the array is created and should
2593 be used in type hashing. */
2594#define TYPE_TYPELESS_STORAGE(NODE) \
2595 (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, \
2596 ARRAY_TYPE)->type_common.typeless_storage)
2597
2598/* Indicated that objects of this type should be laid out in as
2599 compact a way as possible. */
2600#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->base.u.bits.packed_flag)
2601
2602/* Used by type_contains_placeholder_p to avoid recomputation.
2603 Values are: 0 (unknown), 1 (false), 2 (true). Never access
2604 this field directly. */
2605#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
2606 (TYPE_CHECK (NODE)->type_common.contains_placeholder_bits)
2607
2608/* Nonzero if RECORD_TYPE represents a final derivation of class. */
2609#define TYPE_FINAL_P(NODE) \
2610 (RECORD_OR_UNION_CHECK (NODE)->base.default_def_flag)
2611
2612/* The debug output functions use the symtab union field to store
2613 information specific to the debugging format. The different debug
2614 output hooks store different types in the union field. These three
2615 macros are used to access different fields in the union. The debug
2616 hooks are responsible for consistently using only a specific
2617 macro. */
2618
2619/* Symtab field as an integer. Used by stabs generator in dbxout.cc to
2620 hold the type's number in the generated stabs. */
2621#define TYPE_SYMTAB_ADDRESS(NODE) \
2622 (TYPE_CHECK (NODE)->type_common.symtab.address)
2623
2624/* Symtab field as a pointer to a DWARF DIE. Used by DWARF generator
2625 in dwarf2out.cc to point to the DIE generated for the type. */
2626#define TYPE_SYMTAB_DIE(NODE) \
2627 (TYPE_CHECK (NODE)->type_common.symtab.die)
2628
2629/* The garbage collector needs to know the interpretation of the
2630 symtab field. These constants represent the different types in the
2631 union. */
2632
2633#define TYPE_SYMTAB_IS_ADDRESS (0)
2634#define TYPE_SYMTAB_IS_DIE (1)
2635
2636#define TYPE_LANG_SPECIFIC(NODE) \
2637 (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific)
2638
2639#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)
2640#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)
2641#define TYPE_FIELDS(NODE) \
2642 (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)
2643#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
2644#define TYPE_ARG_TYPES(NODE) \
2645 (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)
2646#define TYPE_VALUES_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
2647
2648#define TYPE_MIN_VALUE(NODE) \
2649 (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)
2650#define TYPE_NEXT_PTR_TO(NODE) \
2651 (POINTER_TYPE_CHECK (NODE)->type_non_common.minval)
2652#define TYPE_NEXT_REF_TO(NODE) \
2653 (REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval)
2654#define TYPE_VFIELD(NODE) \
2655 (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)
2656#define TYPE_MIN_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.minval)
2657
2658#define TYPE_MAX_VALUE(NODE) \
2659 (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval)
2660#define TYPE_METHOD_BASETYPE(NODE) \
2661 (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval)
2662#define TYPE_OFFSET_BASETYPE(NODE) \
2663 (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)
2664/* If non-NULL, this is an upper bound of the size (in bytes) of an
2665 object of the given ARRAY_TYPE_NON_COMMON. This allows temporaries to be
2666 allocated. */
2667#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
2668 (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type_non_common.maxval)
2669#define TYPE_MAX_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.maxval)
2670/* For record and union types, information about this type, as a base type
2671 for itself. */
2672#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
2673
2674/* For types, used in a language-dependent way. */
2675#define TYPE_LANG_SLOT_1(NODE) \
2676 (TYPE_CHECK (NODE)->type_non_common.lang_1)
2677
2678/* Define accessor macros for information about type inheritance
2679 and basetypes.
2680
2681 A "basetype" means a particular usage of a data type for inheritance
2682 in another type. Each such basetype usage has its own "binfo"
2683 object to describe it. The binfo object is a TREE_VEC node.
2684
2685 Inheritance is represented by the binfo nodes allocated for a
2686 given type. For example, given types C and D, such that D is
2687 inherited by C, 3 binfo nodes will be allocated: one for describing
2688 the binfo properties of C, similarly one for D, and one for
2689 describing the binfo properties of D as a base type for C.
2690 Thus, given a pointer to class C, one can get a pointer to the binfo
2691 of D acting as a basetype for C by looking at C's binfo's basetypes. */
2692
2693/* BINFO specific flags. */
2694
2695/* Nonzero means that the derivation chain is via a `virtual' declaration. */
2696#define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag)
2697
2698/* Flags for language dependent use. */
2699#define BINFO_FLAG_0(NODE) TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE))
2700#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE))
2701#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE))
2702#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE))
2703#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE))
2704#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE))
2705#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE))
2706
2707/* The actual data type node being inherited in this basetype. */
2708#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK (NODE))
2709
2710/* The offset where this basetype appears in its containing type.
2711 BINFO_OFFSET slot holds the offset (in bytes)
2712 from the base of the complete object to the base of the part of the
2713 object that is allocated on behalf of this `type'.
2714 This is always 0 except when there is multiple inheritance. */
2715
2716#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK (NODE)->binfo.offset)
2717#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
2718
2719/* The virtual function table belonging to this basetype. Virtual
2720 function tables provide a mechanism for run-time method dispatching.
2721 The entries of a virtual function table are language-dependent. */
2722
2723#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtable)
2724
2725/* The virtual functions in the virtual function table. This is
2726 a TREE_LIST that is used as an initial approximation for building
2727 a virtual function table for this basetype. */
2728#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK (NODE)->binfo.virtuals)
2729
2730/* A vector of binfos for the direct basetypes inherited by this
2731 basetype.
2732
2733 If this basetype describes type D as inherited in C, and if the
2734 basetypes of D are E and F, then this vector contains binfos for
2735 inheritance of E and F by C. */
2736#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos)
2737
2738/* The number of basetypes for NODE. */
2739#define BINFO_N_BASE_BINFOS(NODE) (BINFO_BASE_BINFOS (NODE)->length ())
2740
2741/* Accessor macro to get to the Nth base binfo of this binfo. */
2742#define BINFO_BASE_BINFO(NODE,N) \
2743 ((*BINFO_BASE_BINFOS (NODE))[(N)])
2744#define BINFO_BASE_ITERATE(NODE,N,B) \
2745 (BINFO_BASE_BINFOS (NODE)->iterate ((N), &(B)))
2746#define BINFO_BASE_APPEND(NODE,T) \
2747 (BINFO_BASE_BINFOS (NODE)->quick_push ((T)))
2748
2749/* For a BINFO record describing a virtual base class, i.e., one where
2750 TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
2751 base. The actual contents are language-dependent. In the C++
2752 front-end this field is an INTEGER_CST giving an offset into the
2753 vtable where the offset to the virtual base can be found. */
2754#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vptr_field)
2755
2756/* Indicates the accesses this binfo has to its bases. The values are
2757 access_public_node, access_protected_node or access_private_node.
2758 If this array is not present, public access is implied. */
2759#define BINFO_BASE_ACCESSES(NODE) \
2760 (TREE_BINFO_CHECK (NODE)->binfo.base_accesses)
2761
2762#define BINFO_BASE_ACCESS(NODE,N) \
2763 (*BINFO_BASE_ACCESSES (NODE))[(N)]
2764#define BINFO_BASE_ACCESS_APPEND(NODE,T) \
2765 BINFO_BASE_ACCESSES (NODE)->quick_push ((T))
2766
2767/* The index in the VTT where this subobject's sub-VTT can be found.
2768 NULL_TREE if there is no sub-VTT. */
2769#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt)
2770
2771/* The index in the VTT where the vptr for this subobject can be
2772 found. NULL_TREE if there is no secondary vptr in the VTT. */
2773#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr)
2774
2775/* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
2776 inheriting this base for non-virtual bases. For virtual bases it
2777 points either to the binfo for which this is a primary binfo, or to
2778 the binfo of the most derived type. */
2779#define BINFO_INHERITANCE_CHAIN(NODE) \
2780 (TREE_BINFO_CHECK (NODE)->binfo.inheritance)
2781
2782
2783/* Define fields and accessors for nodes representing declared names. */
2784
2785/* Nonzero if DECL represents an SSA name or a variable that can possibly
2786 have an associated SSA name. */
2787#define SSA_VAR_P(DECL) \
2788 (TREE_CODE (DECL) == VAR_DECL \
2789 || TREE_CODE (DECL) == PARM_DECL \
2790 || TREE_CODE (DECL) == RESULT_DECL \
2791 || TREE_CODE (DECL) == SSA_NAME)
2792
2793
2794#define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE)))
2795
2796/* This is the name of the object as written by the user.
2797 It is an IDENTIFIER_NODE. */
2798#define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
2799
2800/* The IDENTIFIER_NODE associated with the TYPE_NAME field. */
2801#define TYPE_IDENTIFIER(NODE) \
2802 (TYPE_NAME (NODE) && DECL_P (TYPE_NAME (NODE)) \
2803 ? DECL_NAME (TYPE_NAME (NODE)) : TYPE_NAME (NODE))
2804
2805/* Every ..._DECL node gets a unique number. */
2806#define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)
2807
2808/* DEBUG_EXPR_DECLs get negative UID numbers, to catch erroneous
2809 uses. */
2810#define DEBUG_TEMP_UID(NODE) (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL)))
2811
2812/* Every ..._DECL node gets a unique number that stays the same even
2813 when the decl is copied by the inliner once it is set. */
2814#define DECL_PT_UID(NODE) \
2815 (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid == -1u \
2816 ? (NODE)->decl_minimal.uid : (NODE)->decl_common.pt_uid)
2817/* Initialize the ..._DECL node pt-uid to the decls uid. */
2818#define SET_DECL_PT_UID(NODE, UID) \
2819 (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID))
2820/* Whether the ..._DECL node pt-uid has been initialized and thus needs to
2821 be preserved when copyin the decl. */
2822#define DECL_PT_UID_SET_P(NODE) \
2823 (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u)
2824
2825/* These two fields describe where in the source code the declaration
2826 was. If the declaration appears in several places (as for a C
2827 function that is declared first and then defined later), this
2828 information should refer to the definition. */
2829#define DECL_SOURCE_LOCATION(NODE) \
2830 (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
2831#define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
2832#define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
2833#define DECL_SOURCE_COLUMN(NODE) LOCATION_COLUMN (DECL_SOURCE_LOCATION (NODE))
2834/* This decl was created by a front-end or back-end rather than by
2835 user code, and has not been explicitly declared by the user -- when
2836 that happens the source location is updated to the user's
2837 source. This includes decls with no location (!). */
2838#define DECL_IS_UNDECLARED_BUILTIN(DECL) \
2839 (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
2840
2841/* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
2842 QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
2843 PARM_DECL, FUNCTION_DECL, LABEL_DECL, RESULT_DECL, and CONST_DECL
2844 nodes, this points to either the FUNCTION_DECL for the containing
2845 function, the RECORD_TYPE or UNION_TYPE for the containing type, or
2846 NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
2847 scope". In particular, for VAR_DECLs which are virtual table pointers
2848 (they have DECL_VIRTUAL set), we use DECL_CONTEXT to determine the type
2849 they belong to. */
2850#define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
2851#define DECL_FIELD_CONTEXT(NODE) \
2852 (FIELD_DECL_CHECK (NODE)->decl_minimal.context)
2853
2854/* If nonzero, decl's name shouldn't be emitted into debug info. */
2855#define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag)
2856
2857/* For any sort of a ..._DECL node, this points to the original (abstract)
2858 decl node which this decl is an inlined/cloned instance of, or else it
2859 is NULL indicating that this decl is not an instance of some other decl.
2860
2861 The C front-end also uses this in a nested declaration of an inline
2862 function, to point back to the definition. */
2863#define DECL_ABSTRACT_ORIGIN(NODE) \
2864 (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)
2865
2866/* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
2867 origin. This is useful when setting the DECL_ABSTRACT_ORIGIN. */
2868#define DECL_ORIGIN(NODE) \
2869 (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
2870
2871/* Nonzero for any sort of ..._DECL node means this decl node represents an
2872 inline instance of some original (abstract) decl from an inline function;
2873 suppress any warnings about shadowing some other variable. FUNCTION_DECL
2874 nodes can also have their abstract origin set to themselves. */
2875#define DECL_FROM_INLINE(NODE) \
2876 (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
2877 && DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
2878
2879/* In a DECL this is the field where attributes are stored. */
2880#define DECL_ATTRIBUTES(NODE) \
2881 (DECL_COMMON_CHECK (NODE)->decl_common.attributes)
2882
2883/* For a FUNCTION_DECL, holds the tree of BINDINGs.
2884 For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
2885 For a VAR_DECL, holds the initial value.
2886 For a PARM_DECL, used for DECL_ARG_TYPE--default
2887 values for parameters are encoded in the type of the function,
2888 not in the PARM_DECL slot.
2889 For a FIELD_DECL, this is used for enumeration values and the C
2890 frontend uses it for temporarily storing bitwidth of bitfields.
2891
2892 ??? Need to figure out some way to check this isn't a PARM_DECL. */
2893#define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial)
2894
2895/* Holds the size of the datum, in bits, as a tree expression.
2896 Need not be constant and may be null. May be less than TYPE_SIZE
2897 for a C++ FIELD_DECL representing a base class subobject with its
2898 own virtual base classes (which are laid out separately). */
2899#define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size)
2900/* Likewise for the size in bytes. */
2901#define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)
2902#define DECL_ALIGN_RAW(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align)
2903/* Returns the alignment required for the datum, in bits. It must
2904 be a power of two, but an "alignment" of zero is supported
2905 (e.g. as "uninitialized" sentinel). */
2906#define DECL_ALIGN(NODE) \
2907 (DECL_ALIGN_RAW (NODE) \
2908 ? ((unsigned)1) << (DECL_ALIGN_RAW (NODE) - 1) : 0)
2909/* Specify that DECL_ALIGN(NODE) is X. */
2910#define SET_DECL_ALIGN(NODE, X) \
2911 (DECL_ALIGN_RAW (NODE) = ffs_hwi (X))
2912
2913/* The minimum alignment necessary for the datum, in bits, without
2914 warning. */
2915#define DECL_WARN_IF_NOT_ALIGN_RAW(NODE) \
2916 (DECL_COMMON_CHECK (NODE)->decl_common.warn_if_not_align)
2917#define DECL_WARN_IF_NOT_ALIGN(NODE) \
2918 (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) \
2919 ? ((unsigned)1) << (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) - 1) : 0)
2920
2921/* Specify that DECL_WARN_IF_NOT_ALIGN(NODE) is X. */
2922#define SET_DECL_WARN_IF_NOT_ALIGN(NODE, X) \
2923 (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X))
2924
2925/* The alignment of NODE, in bytes. */
2926#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
2927/* Set if the alignment of this DECL has been set by the user, for
2928 example with an 'aligned' attribute. */
2929#define DECL_USER_ALIGN(NODE) \
2930 (DECL_COMMON_CHECK (NODE)->base.u.bits.user_align)
2931/* Holds the machine mode corresponding to the declaration of a variable or
2932 field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
2933 FIELD_DECL. */
2934#define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode)
2935#define SET_DECL_MODE(NODE, MODE) \
2936 (DECL_COMMON_CHECK (NODE)->decl_common.mode = (MODE))
2937
2938/* For FUNCTION_DECL, if it is built-in, this identifies which built-in
2939 operation it is. This is only intended for low-level accesses;
2940 normally DECL_FUNCTION_CODE, DECL_FE_FUNCTION_CODE or DECL_MD_FUNCTION
2941 should be used instead. */
2942#define DECL_UNCHECKED_FUNCTION_CODE(NODE) \
2943 (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
2944
2945/* Test if FCODE is a function code for an alloca operation. */
2946#define ALLOCA_FUNCTION_CODE_P(FCODE) \
2947 ((FCODE) == BUILT_IN_ALLOCA \
2948 || (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN \
2949 || (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX)
2950
2951/* Generate case for an alloca operation. */
2952#define CASE_BUILT_IN_ALLOCA \
2953 case BUILT_IN_ALLOCA: \
2954 case BUILT_IN_ALLOCA_WITH_ALIGN: \
2955 case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
2956
2957#define DECL_FUNCTION_PERSONALITY(NODE) \
2958 (FUNCTION_DECL_CHECK (NODE)->function_decl.personality)
2959
2960/* Nonzero for a given ..._DECL node means that the name of this node should
2961 be ignored for symbolic debug purposes. For a TYPE_DECL, this means that
2962 the associated type should be ignored. For a FUNCTION_DECL, the body of
2963 the function should also be ignored. */
2964#define DECL_IGNORED_P(NODE) \
2965 (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
2966
2967/* Nonzero for a given ..._DECL node means that this node represents an
2968 "abstract instance" of the given declaration (e.g. in the original
2969 declaration of an inline function). When generating symbolic debugging
2970 information, we mustn't try to generate any address information for nodes
2971 marked as "abstract instances" because we don't actually generate
2972 any code or allocate any data space for such instances. */
2973#define DECL_ABSTRACT_P(NODE) \
2974 (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
2975
2976/* Language-specific decl information. */
2977#define DECL_LANG_SPECIFIC(NODE) \
2978 (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
2979
2980/* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
2981 do not allocate storage, and refer to a definition elsewhere. Note that
2982 this does not necessarily imply the entity represented by NODE
2983 has no program source-level definition in this translation unit. For
2984 example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
2985 DECL_EXTERNAL may be true simultaneously; that can be the case for
2986 a C99 "extern inline" function. */
2987#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1)
2988
2989/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
2990 For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
2991
2992 For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
2993
2994 Also set in some languages for variables, etc., outside the normal
2995 lexical scope, such as class instance variables. */
2996#define DECL_NONLOCAL(NODE) \
2997 (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
2998
2999/* Used in VAR_DECLs to indicate that the variable is a vtable.
3000 Used in FIELD_DECLs for vtable pointers.
3001 Used in FUNCTION_DECLs to indicate that the function is virtual. */
3002#define DECL_VIRTUAL_P(NODE) \
3003 (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
3004
3005/* Used to indicate that this DECL represents a compiler-generated entity. */
3006#define DECL_ARTIFICIAL(NODE) \
3007 (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
3008
3009/* Additional flags for language-specific uses. */
3010#define DECL_LANG_FLAG_0(NODE) \
3011 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
3012#define DECL_LANG_FLAG_1(NODE) \
3013 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
3014#define DECL_LANG_FLAG_2(NODE) \
3015 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
3016#define DECL_LANG_FLAG_3(NODE) \
3017 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
3018#define DECL_LANG_FLAG_4(NODE) \
3019 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
3020#define DECL_LANG_FLAG_5(NODE) \
3021 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
3022#define DECL_LANG_FLAG_6(NODE) \
3023 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
3024#define DECL_LANG_FLAG_7(NODE) \
3025 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
3026#define DECL_LANG_FLAG_8(NODE) \
3027 (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8)
3028
3029/* Nonzero for a scope which is equal to file scope. */
3030#define SCOPE_FILE_SCOPE_P(EXP) \
3031 (! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL)
3032/* Nonzero for a decl which is at file scope. */
3033#define DECL_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP))
3034/* Nonzero for a type which is at file scope. */
3035#define TYPE_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP))
3036
3037/* Nonzero for a decl that is decorated using attribute used.
3038 This indicates to compiler tools that this decl needs to be preserved. */
3039#define DECL_PRESERVE_P(DECL) \
3040 DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag
3041
3042/* Nonzero for a decl that is decorated with the "noinit" attribute.
3043 decls with this attribute are placed into the ".noinit" section, so they are
3044 not initialized by the target's startup code. */
3045#define DECL_NOINIT_P(DECL) \
3046 (DECL_P (DECL) \
3047 && (lookup_attribute ("noinit", DECL_ATTRIBUTES (DECL)) != NULL_TREE))
3048
3049/* Nonzero for a decl that is decorated with the "persistent" attribute.
3050 decls with this attribute are placed into the ".persistent" section, so they
3051 are not initialized by the target's startup code. */
3052#define DECL_PERSISTENT_P(DECL) \
3053 (DECL_P (DECL) \
3054 && (lookup_attribute ("persistent", DECL_ATTRIBUTES (DECL)) != NULL_TREE))
3055
3056/* For function local variables indicates that the variable
3057 should not be treated as a GIMPLE register. In particular
3058 this means that partial definitions can appear and the
3059 variable cannot be written into SSA form and instead uses
3060 virtual operands to represent the use-def dataflow. */
3061#define DECL_NOT_GIMPLE_REG_P(DECL) \
3062 DECL_COMMON_CHECK (DECL)->decl_common.not_gimple_reg_flag
3063
3065extern void decl_value_expr_insert (tree, tree);
3066
3067/* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
3068 if transformations have made this more complicated than evaluating the
3069 decl itself. */
3070#define DECL_HAS_VALUE_EXPR_P(NODE) \
3071 (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_DECL) \
3072 ->decl_common.decl_flag_2)
3073#define DECL_VALUE_EXPR(NODE) \
3074 (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
3075#define SET_DECL_VALUE_EXPR(NODE, VAL) \
3076 (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
3077
3078/* Holds the RTL expression for the value of a variable or function.
3079 This value can be evaluated lazily for functions, variables with
3080 static storage duration, and labels. */
3081#define DECL_RTL(NODE) \
3082 (DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl \
3083 ? (NODE)->decl_with_rtl.rtl \
3084 : (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl))
3085
3086/* Set the DECL_RTL for NODE to RTL. */
3087#define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)
3088
3089/* Returns nonzero if NODE is a tree node that can contain RTL. */
3090#define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))
3091
3092/* Returns nonzero if the DECL_RTL for NODE has already been set. */
3093#define DECL_RTL_SET_P(NODE) \
3094 (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
3095
3096/* Copy the RTL from SRC_DECL to DST_DECL. If the RTL was not set for
3097 SRC_DECL, it will not be set for DST_DECL; this is a lazy copy. */
3098#define COPY_DECL_RTL(SRC_DECL, DST_DECL) \
3099 (DECL_WRTL_CHECK (DST_DECL)->decl_with_rtl.rtl \
3100 = DECL_WRTL_CHECK (SRC_DECL)->decl_with_rtl.rtl)
3101
3102/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
3103#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
3104
3105#if (GCC_VERSION >= 2007)
3106#define DECL_RTL_KNOWN_SET(decl) __extension__ \
3107({ tree const __d = (decl); \
3108 gcc_checking_assert (DECL_RTL_SET_P (__d)); \
3109 /* Dereference it so the compiler knows it can't be NULL even \
3110 without assertion checking. */ \
3111 &*DECL_RTL_IF_SET (__d); })
3112#else
3113#define DECL_RTL_KNOWN_SET(decl) (&*DECL_RTL_IF_SET (decl))
3114#endif
3115
3116/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
3117#define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)
3118
3119/* In a FIELD_DECL, this is the field position, counting in bytes, of the
3120 DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
3121 of the structure. */
3122#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset)
3123
3124/* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
3125 field from DECL_FIELD_OFFSET. This field may be nonzero even for fields
3126 that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the
3127 natural alignment of the field's type). */
3128#define DECL_FIELD_BIT_OFFSET(NODE) \
3129 (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
3130
3131/* In a FIELD_DECL, this indicates whether the field was a bit-field and
3132 if so, the type that was originally specified for it.
3133 TREE_TYPE may have been modified (in finish_struct). */
3134#define DECL_BIT_FIELD_TYPE(NODE) \
3135 (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
3136
3137/* In a FIELD_DECL of a RECORD_TYPE, this is a pointer to the storage
3138 representative FIELD_DECL. */
3139#define DECL_BIT_FIELD_REPRESENTATIVE(NODE) \
3140 (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
3141
3142/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
3143 if nonzero, indicates that the field occupies the type. */
3144#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
3145
3146/* For FIELD_DECLs, off_align holds the number of low-order bits of
3147 DECL_FIELD_OFFSET which are known to be always zero.
3148 DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
3149 has. */
3150#define DECL_OFFSET_ALIGN(NODE) \
3151 (HOST_WIDE_INT_1U << FIELD_DECL_CHECK (NODE)->decl_common.off_align)
3152
3153/* Specify that DECL_OFFSET_ALIGN(NODE) is X. */
3154#define SET_DECL_OFFSET_ALIGN(NODE, X) \
3155 (FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1)
3156
3157/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
3158 which this FIELD_DECL is defined. This information is needed when
3159 writing debugging information about vfield and vbase decls for C++. */
3160#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
3161
3162/* In a FIELD_DECL, indicates this field should be bit-packed. */
3163#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->base.u.bits.packed_flag)
3164
3165/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
3166 specially. */
3167#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
3168
3169/* In a FIELD_DECL, indicates this field should be ignored for ABI decisions
3170 like passing/returning containing struct by value.
3171 Set for C++17 empty base artificial FIELD_DECLs as well as
3172 empty [[no_unique_address]] non-static data members. */
3173#define DECL_FIELD_ABI_IGNORED(NODE) \
3174 (!DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)
3175#define SET_DECL_FIELD_ABI_IGNORED(NODE, VAL) \
3176 do { \
3177 gcc_checking_assert (!DECL_BIT_FIELD (NODE)); \
3178 FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL); \
3179 } while (0)
3180
3181/* In a FIELD_DECL, indicates C++ zero-width bitfield that used to be
3182 removed from the IL since PR42217 until PR101539 and by that changed
3183 the ABI on several targets. This flag is provided so that the backends
3184 can decide on the ABI with zero-width bitfields and emit -Wpsabi
3185 warnings. */
3186#define DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE) \
3187 (DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)
3188#define SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE, VAL) \
3189 do { \
3190 gcc_checking_assert (DECL_BIT_FIELD (NODE)); \
3191 FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL); \
3192 } while (0)
3193
3194/* Used in a FIELD_DECL to indicate that we cannot form the address of
3195 this component. This makes it possible for Type-Based Alias Analysis
3196 to disambiguate accesses to this field with indirect accesses using
3197 the field's type:
3198
3199 struct S { int i; } s;
3200 int *p;
3201
3202 If the flag is set on 'i', TBAA computes that s.i and *p never conflict.
3203
3204 From the implementation's viewpoint, the alias set of the type of the
3205 field 'i' (int) will not be recorded as a subset of that of the type of
3206 's' (struct S) in record_component_aliases. The counterpart is that
3207 accesses to s.i must not be given the alias set of the type of 'i'
3208 (int) but instead directly that of the type of 's' (struct S). */
3209#define DECL_NONADDRESSABLE_P(NODE) \
3210 (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
3211
3212/* Used in a FIELD_DECL to indicate that this field is padding. */
3213#define DECL_PADDING_P(NODE) \
3214 (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
3215
3216/* Used in a FIELD_DECL to indicate whether this field is not a flexible
3217 array member. This is only valid for the last array type field of a
3218 structure. */
3219#define DECL_NOT_FLEXARRAY(NODE) \
3220 (FIELD_DECL_CHECK (NODE)->decl_common.decl_not_flexarray)
3221
3222/* A numeric unique identifier for a LABEL_DECL. The UID allocation is
3223 dense, unique within any one function, and may be used to index arrays.
3224 If the value is -1, then no UID has been assigned. */
3225#define LABEL_DECL_UID(NODE) \
3226 (LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid)
3227
3228/* In a LABEL_DECL, the EH region number for which the label is the
3229 post_landing_pad. */
3230#define EH_LANDING_PAD_NR(NODE) \
3231 (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr)
3232
3233/* For a PARM_DECL, records the data type used to pass the argument,
3234 which may be different from the type seen in the program. */
3235#define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)
3236
3237/* For PARM_DECL, holds an RTL for the stack slot or register
3238 where the data was actually passed. */
3239#define DECL_INCOMING_RTL(NODE) \
3240 (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
3241
3242/* Nonzero for a given ..._DECL node means that no warnings should be
3243 generated just because this node is unused. */
3244#define DECL_IN_SYSTEM_HEADER(NODE) \
3245 (in_system_header_at (DECL_SOURCE_LOCATION (NODE)))
3246
3247/* Used to indicate that the linkage status of this DECL is not yet known,
3248 so it should not be output now. */
3249#define DECL_DEFER_OUTPUT(NODE) \
3250 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
3251
3252/* In a VAR_DECL that's static,
3253 nonzero if the space is in the text section. */
3254#define DECL_IN_TEXT_SECTION(NODE) \
3255 (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)
3256
3257/* In a VAR_DECL that's static,
3258 nonzero if it belongs to the global constant pool. */
3259#define DECL_IN_CONSTANT_POOL(NODE) \
3260 (VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool)
3261
3262/* Nonzero for a given ..._DECL node means that this node should be
3263 put in .common, if possible. If a DECL_INITIAL is given, and it
3264 is not error_mark_node, then the decl cannot be put in .common. */
3265#define DECL_COMMON(NODE) \
3266 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
3267
3268/* In a VAR_DECL, nonzero if the decl is a register variable with
3269 an explicit asm specification. */
3270#define DECL_HARD_REGISTER(NODE) \
3271 (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
3272
3273 /* Used to indicate that this DECL has weak linkage. */
3274#define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
3275
3276/* Used to indicate that the DECL is a dllimport. */
3277#define DECL_DLLIMPORT_P(NODE) \
3278 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
3279
3280/* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
3281 not be put out unless it is needed in this translation unit.
3282 Entities like this are shared across translation units (like weak
3283 entities), but are guaranteed to be generated by any translation
3284 unit that needs them, and therefore need not be put out anywhere
3285 where they are not needed. DECL_COMDAT is just a hint to the
3286 back-end; it is up to front-ends which set this flag to ensure
3287 that there will never be any harm, other than bloat, in putting out
3288 something which is DECL_COMDAT. */
3289#define DECL_COMDAT(NODE) \
3290 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)
3291
3292#define DECL_COMDAT_GROUP(NODE) \
3293 decl_comdat_group (NODE)
3294
3295/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
3296 multiple translation units should be merged. */
3297#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE \
3298 && (TREE_PUBLIC (NODE) || DECL_EXTERNAL (NODE)))
3299
3300/* The name of the object as the assembler will see it (but before any
3301 translations made by ASM_OUTPUT_LABELREF). Often this is the same
3302 as DECL_NAME. It is an IDENTIFIER_NODE.
3303
3304 ASSEMBLER_NAME of TYPE_DECLS may store global name of type used for
3305 One Definition Rule based type merging at LTO. It is computed only for
3306 LTO compilation and C++. */
3307#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
3308
3309/* Raw accessor for DECL_ASSEMBLE_NAME. */
3310#define DECL_ASSEMBLER_NAME_RAW(NODE) \
3311 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name)
3312
3313/* Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME.
3314 This is true of all DECL nodes except FIELD_DECL. */
3315#define HAS_DECL_ASSEMBLER_NAME_P(NODE) \
3316 (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))
3317
3318/* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
3319 the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
3320 yet. */
3321#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
3322 (DECL_ASSEMBLER_NAME_RAW (NODE) != NULL_TREE)
3323
3324/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
3325#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
3326 overwrite_decl_assembler_name (NODE, NAME)
3327
3328/* Copy the DECL_ASSEMBLER_NAME from SRC_DECL to DST_DECL. Note that
3329 if SRC_DECL's DECL_ASSEMBLER_NAME has not yet been set, using this
3330 macro will not cause the DECL_ASSEMBLER_NAME to be set, but will
3331 clear DECL_ASSEMBLER_NAME of DST_DECL, if it was already set. In
3332 other words, the semantics of using this macro, are different than
3333 saying:
3334
3335 SET_DECL_ASSEMBLER_NAME(DST_DECL, DECL_ASSEMBLER_NAME (SRC_DECL))
3336
3337 which will try to set the DECL_ASSEMBLER_NAME for SRC_DECL. */
3338
3339#define COPY_DECL_ASSEMBLER_NAME(SRC_DECL, DST_DECL) \
3340 SET_DECL_ASSEMBLER_NAME (DST_DECL, DECL_ASSEMBLER_NAME_RAW (SRC_DECL))
3341
3342/* Records the section name in a section attribute. Used to pass
3343 the name from decl_attributes to make_function_rtl and make_decl_rtl. */
3344#define DECL_SECTION_NAME(NODE) decl_section_name (NODE)
3345
3346/* Nonzero in a decl means that the gimplifier has seen (or placed)
3347 this variable in a BIND_EXPR. */
3348#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
3349 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
3350
3351/* Value of the decls's visibility attribute */
3352#define DECL_VISIBILITY(NODE) \
3353 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
3354
3355/* Nonzero means that the decl (or an enclosing scope) had its
3356 visibility specified rather than being inferred. */
3357#define DECL_VISIBILITY_SPECIFIED(NODE) \
3358 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
3359
3360/* In a VAR_DECL, the model to use if the data should be allocated from
3361 thread-local storage. */
3362#define DECL_TLS_MODEL(NODE) decl_tls_model (NODE)
3363
3364/* In a VAR_DECL, nonzero if the data should be allocated from
3365 thread-local storage. */
3366#define DECL_THREAD_LOCAL_P(NODE) \
3367 ((TREE_STATIC (NODE) || DECL_EXTERNAL (NODE)) && decl_tls_model (NODE) >= TLS_MODEL_REAL)
3368
3369/* In a non-local VAR_DECL with static storage duration, true if the
3370 variable has an initialization priority. If false, the variable
3371 will be initialized at the DEFAULT_INIT_PRIORITY. */
3372#define DECL_HAS_INIT_PRIORITY_P(NODE) \
3373 (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
3374
3376extern void decl_debug_expr_insert (tree, tree);
3377
3378/* For VAR_DECL, this is set to an expression that it was split from. */
3379#define DECL_HAS_DEBUG_EXPR_P(NODE) \
3380 (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from)
3381#define DECL_DEBUG_EXPR(NODE) \
3382 (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))
3383
3384#define SET_DECL_DEBUG_EXPR(NODE, VAL) \
3385 (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))
3386
3391
3392/* For a VAR_DECL or FUNCTION_DECL the initialization priority of
3393 NODE. */
3394#define DECL_INIT_PRIORITY(NODE) \
3395 (decl_init_priority_lookup (NODE))
3396/* Set the initialization priority for NODE to VAL. */
3397#define SET_DECL_INIT_PRIORITY(NODE, VAL) \
3398 (decl_init_priority_insert (NODE, VAL))
3399
3400/* For a FUNCTION_DECL the finalization priority of NODE. */
3401#define DECL_FINI_PRIORITY(NODE) \
3402 (decl_fini_priority_lookup (NODE))
3403/* Set the finalization priority for NODE to VAL. */
3404#define SET_DECL_FINI_PRIORITY(NODE, VAL) \
3405 (decl_fini_priority_insert (NODE, VAL))
3406
3407/* The initialization priority for entities for which no explicit
3408 initialization priority has been specified. */
3409#define DEFAULT_INIT_PRIORITY 65535
3410
3411/* The maximum allowed initialization priority. */
3412#define MAX_INIT_PRIORITY 65535
3413
3414/* The largest priority value reserved for use by system runtime
3415 libraries. */
3416#define MAX_RESERVED_INIT_PRIORITY 100
3417
3418/* In a VAR_DECL, nonzero if this is a global variable for VOPs. */
3419#define VAR_DECL_IS_VIRTUAL_OPERAND(NODE) \
3420 (VAR_DECL_CHECK (NODE)->base.u.bits.saturating_flag)
3421
3422/* In a VAR_DECL, nonzero if this is a non-local frame structure. */
3423#define DECL_NONLOCAL_FRAME(NODE) \
3424 (VAR_DECL_CHECK (NODE)->base.default_def_flag)
3425
3426/* In a VAR_DECL, nonzero if this variable is not aliased by any pointer. */
3427#define DECL_NONALIASED(NODE) \
3428 (VAR_DECL_CHECK (NODE)->base.nothrow_flag)
3429
3430/* In a VAR_DECL, nonzero if this variable is not required to have a distinct
3431 address from other variables with the same constant value. In other words,
3432 consider -fmerge-all-constants to be on for this VAR_DECL. */
3433#define DECL_MERGEABLE(NODE) \
3434 (VAR_DECL_CHECK (NODE)->decl_common.decl_flag_3)
3435
3436/* This field is used to reference anything in decl.result and is meant only
3437 for use by the garbage collector. */
3438#define DECL_RESULT_FLD(NODE) \
3439 (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
3440
3441/* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
3442 Before the struct containing the FUNCTION_DECL is laid out,
3443 DECL_VINDEX may point to a FUNCTION_DECL in a base class which
3444 is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
3445 function. When the class is laid out, this pointer is changed
3446 to an INTEGER_CST node which is suitable for use as an index
3447 into the virtual function table. */
3448#define DECL_VINDEX(NODE) \
3449 (FUNCTION_DECL_CHECK (NODE)->function_decl.vindex)
3450
3451/* In FUNCTION_DECL, holds the decl for the return value. */
3452#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
3453
3454/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
3455#define DECL_UNINLINABLE(NODE) \
3456 (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
3457
3458/* In a FUNCTION_DECL, the saved representation of the body of the
3459 entire function. */
3460#define DECL_SAVED_TREE(NODE) \
3461 (FUNCTION_DECL_CHECK (NODE)->function_decl.saved_tree)
3462
3463/* Nonzero in a FUNCTION_DECL means this function should be treated
3464 as if it were a malloc, meaning it returns a pointer that is
3465 not an alias. */
3466#define DECL_IS_MALLOC(NODE) \
3467 (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
3468
3469/* Macro for direct set and get of function_decl.decl_type. */
3470#define FUNCTION_DECL_DECL_TYPE(NODE) \
3471 (NODE->function_decl.decl_type)
3472
3473/* Set decl_type of a DECL. Set it to T when SET is true, or reset
3474 it to NONE. */
3475
3476inline void
3477set_function_decl_type (tree decl, function_decl_type t, bool set)
3478{
3479 if (set)
3480 {
3481 gcc_assert (FUNCTION_DECL_DECL_TYPE (decl) == function_decl_type::NONE
3482 || FUNCTION_DECL_DECL_TYPE (decl) == t);
3484 }
3485 else if (FUNCTION_DECL_DECL_TYPE (decl) == t)
3486 FUNCTION_DECL_DECL_TYPE (decl) = function_decl_type::NONE;
3487}
3488
3489/* Nonzero in a FUNCTION_DECL means this function is a replaceable
3490 function (like replaceable operators new or delete). */
3491#define DECL_IS_REPLACEABLE_OPERATOR(NODE)\
3492 (FUNCTION_DECL_CHECK (NODE)->function_decl.replaceable_operator)
3493
3494/* Nonzero in a FUNCTION_DECL means this function should be treated as
3495 C++ operator new, meaning that it returns a pointer for which we
3496 should not use type based aliasing. */
3497#define DECL_IS_OPERATOR_NEW_P(NODE) \
3498 (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \
3499 == function_decl_type::OPERATOR_NEW)
3500
3501#define DECL_IS_REPLACEABLE_OPERATOR_NEW_P(NODE) \
3502 (DECL_IS_OPERATOR_NEW_P (NODE) && DECL_IS_REPLACEABLE_OPERATOR (NODE))
3503
3504#define DECL_SET_IS_OPERATOR_NEW(NODE, VAL) \
3505 set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \
3506 function_decl_type::OPERATOR_NEW, VAL)
3507
3508/* Nonzero in a FUNCTION_DECL means this function should be treated as
3509 C++ operator delete. */
3510#define DECL_IS_OPERATOR_DELETE_P(NODE) \
3511 (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \
3512 == function_decl_type::OPERATOR_DELETE)
3513
3514#define DECL_SET_IS_OPERATOR_DELETE(NODE, VAL) \
3515 set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \
3516 function_decl_type::OPERATOR_DELETE, VAL)
3517
3518/* Nonzero in a FUNCTION_DECL means this function may return more
3519 than once. */
3520#define DECL_IS_RETURNS_TWICE(NODE) \
3521 (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)
3522
3523/* Nonzero in a FUNCTION_DECL means this function should be treated
3524 as "pure" function (like const function, but may read global memory).
3525 Note that being pure or const for a function is orthogonal to being
3526 nothrow, i.e. it is valid to have DECL_PURE_P set and TREE_NOTHROW
3527 cleared. */
3528#define DECL_PURE_P(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)
3529
3530/* Nonzero only if one of TREE_READONLY or DECL_PURE_P is nonzero AND
3531 the const or pure function may not terminate. When this is nonzero
3532 for a const or pure function, it can be dealt with by cse passes
3533 but cannot be removed by dce passes since you are not allowed to
3534 change an infinite looping program into one that terminates without
3535 error. */
3536#define DECL_LOOPING_CONST_OR_PURE_P(NODE) \
3537 (FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag)
3538
3539/* Nonzero in a FUNCTION_DECL means this function should be treated
3540 as "novops" function (function that does not read global memory,
3541 but may have arbitrary side effects). */
3542#define DECL_IS_NOVOPS(NODE) \
3543 (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
3544
3545/* Used in FUNCTION_DECLs to indicate that they should be run automatically
3546 at the beginning or end of execution. */
3547#define DECL_STATIC_CONSTRUCTOR(NODE) \
3548 (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)
3549
3550#define DECL_STATIC_DESTRUCTOR(NODE) \
3551(FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)
3552
3553/* Used in FUNCTION_DECLs to indicate that function entry and exit should
3554 be instrumented with calls to support routines. */
3555#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
3556 (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)
3557
3558/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
3559 disabled in this function. */
3560#define DECL_NO_LIMIT_STACK(NODE) \
3561 (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)
3562
3563/* In a FUNCTION_DECL indicates that a static chain is needed. */
3564#define DECL_STATIC_CHAIN(NODE) \
3565 (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.regdecl_flag)
3566
3567/* Nonzero for a decl that cgraph has decided should be inlined into
3568 at least one call site. It is not meaningful to look at this
3569 directly; always use cgraph_function_possibly_inlined_p. */
3570#define DECL_POSSIBLY_INLINED(DECL) \
3571 FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined
3572
3573/* Nonzero in a FUNCTION_DECL means that this function was declared inline,
3574 such as via the `inline' keyword in C/C++. This flag controls the linkage
3575 semantics of 'inline' */
3576#define DECL_DECLARED_INLINE_P(NODE) \
3577 (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
3578
3579/* Nonzero in a FUNCTION_DECL means this function should not get
3580 -Winline warnings. */
3581#define DECL_NO_INLINE_WARNING_P(NODE) \
3582 (FUNCTION_DECL_CHECK (NODE)->function_decl.no_inline_warning_flag)
3583
3584/* Nonzero if a FUNCTION_CODE is a TM load/store. */
3585#define BUILTIN_TM_LOAD_STORE_P(FN) \
3586 ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
3587
3588/* Nonzero if a FUNCTION_CODE is a TM load. */
3589#define BUILTIN_TM_LOAD_P(FN) \
3590 ((FN) >= BUILT_IN_TM_LOAD_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
3591
3592/* Nonzero if a FUNCTION_CODE is a TM store. */
3593#define BUILTIN_TM_STORE_P(FN) \
3594 ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_STORE_WAW_LDOUBLE)
3595
3596#define CASE_BUILT_IN_TM_LOAD(FN) \
3597 case BUILT_IN_TM_LOAD_##FN: \
3598 case BUILT_IN_TM_LOAD_RAR_##FN: \
3599 case BUILT_IN_TM_LOAD_RAW_##FN: \
3600 case BUILT_IN_TM_LOAD_RFW_##FN
3601
3602#define CASE_BUILT_IN_TM_STORE(FN) \
3603 case BUILT_IN_TM_STORE_##FN: \
3604 case BUILT_IN_TM_STORE_WAR_##FN: \
3605 case BUILT_IN_TM_STORE_WAW_##FN
3606
3607/* Nonzero in a FUNCTION_DECL that should be always inlined by the inliner
3608 disregarding size and cost heuristics. This is equivalent to using
3609 the always_inline attribute without the required diagnostics if the
3610 function cannot be inlined. */
3611#define DECL_DISREGARD_INLINE_LIMITS(NODE) \
3612 (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits)
3613
3616
3617/* Nonzero if a FUNCTION_DECL has DEBUG arguments attached to it. */
3618#define DECL_HAS_DEBUG_ARGS_P(NODE) \
3619 (FUNCTION_DECL_CHECK (NODE)->function_decl.has_debug_args_flag)
3620
3621/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
3622 that describes the status of this function. */
3623#define DECL_STRUCT_FUNCTION(NODE) \
3624 (FUNCTION_DECL_CHECK (NODE)->function_decl.f)
3625
3626/* For a builtin function, identify which part of the compiler defined it. */
3627#define DECL_BUILT_IN_CLASS(NODE) \
3628 ((built_in_class) FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
3629
3630/* In FUNCTION_DECL, a chain of ..._DECL nodes. */
3631#define DECL_ARGUMENTS(NODE) \
3632 (FUNCTION_DECL_CHECK (NODE)->function_decl.arguments)
3633
3634/* In FUNCTION_DECL, the function specific target options to use when compiling
3635 this function. */
3636#define DECL_FUNCTION_SPECIFIC_TARGET(NODE) \
3637 (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target)
3638
3639/* In FUNCTION_DECL, the function specific optimization options to use when
3640 compiling this function. */
3641#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE) \
3642 (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_optimization)
3643
3644/* In FUNCTION_DECL, this is set if this function has other versions generated
3645 to support different architecture feature sets, e.g. using "target" or
3646 "target_version" attributes. */
3647#define DECL_FUNCTION_VERSIONED(NODE)\
3648 (FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function)
3649
3650/* In FUNCTION_DECL, this is set if this function is a C++ constructor.
3651 Devirtualization machinery uses this knowledge for determing type of the
3652 object constructed. Also we assume that constructor address is not
3653 important. */
3654#define DECL_CXX_CONSTRUCTOR_P(NODE)\
3655 (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_constructor)
3656
3657/* In FUNCTION_DECL, this is set if this function is a C++ destructor.
3658 Devirtualization machinery uses this to track types in destruction. */
3659#define DECL_CXX_DESTRUCTOR_P(NODE)\
3660 (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_destructor)
3661
3662/* In FUNCTION_DECL, this is set if this function is a lambda function. */
3663#define DECL_LAMBDA_FUNCTION_P(NODE) \
3664 (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \
3665 == function_decl_type::LAMBDA_FUNCTION)
3666
3667#define DECL_SET_LAMBDA_FUNCTION(NODE, VAL) \
3668 set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \
3669 function_decl_type::LAMBDA_FUNCTION, VAL)
3670
3671/* In FUNCTION_DECL that represent an virtual method this is set when
3672 the method is final. */
3673#define DECL_FINAL_P(NODE)\
3674 (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.final)
3675
3676/* The source language of the translation-unit. */
3677#define TRANSLATION_UNIT_LANGUAGE(NODE) \
3678 (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language)
3679
3680/* TRANSLATION_UNIT_DECL inherits from DECL_MINIMAL. */
3681
3682/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
3683#define DECL_ORIGINAL_TYPE(NODE) \
3684 (TYPE_DECL_CHECK (NODE)->decl_non_common.result)
3685
3686/* In a TYPE_DECL nonzero means the detail info about this type is not dumped
3687 into stabs. Instead it will generate cross reference ('x') of names.
3688 This uses the same flag as DECL_EXTERNAL. */
3689#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
3690 (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1)
3691
3692/* Getter of the imported declaration associated to the
3693 IMPORTED_DECL node. */
3694#define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \
3695(DECL_INITIAL (IMPORTED_DECL_CHECK (NODE)))
3696
3697/* Getter of the symbol declaration associated with the
3698 NAMELIST_DECL node. */
3699#define NAMELIST_DECL_ASSOCIATED_DECL(NODE) \
3700 (DECL_INITIAL (NODE))
3701
3702/* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
3703 To reduce overhead, the nodes containing the statements are not trees.
3704 This avoids the overhead of tree_common on all linked list elements.
3705
3706 Use the interface in tree-iterator.h to access this node. */
3707
3708#define STATEMENT_LIST_HEAD(NODE) \
3709 (STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
3710#define STATEMENT_LIST_TAIL(NODE) \
3711 (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
3712
3713#define TREE_OPTIMIZATION(NODE) \
3714 (OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)
3715
3716#define TREE_OPTIMIZATION_OPTABS(NODE) \
3717 (OPTIMIZATION_NODE_CHECK (NODE)->optimization.optabs)
3718
3719#define TREE_OPTIMIZATION_BASE_OPTABS(NODE) \
3720 (OPTIMIZATION_NODE_CHECK (NODE)->optimization.base_optabs)
3721
3722/* Return a tree node that encapsulates the optimization options in OPTS
3723 and OPTS_SET. */
3724extern tree build_optimization_node (struct gcc_options *opts,
3725 struct gcc_options *opts_set);
3726
3727#define TREE_TARGET_OPTION(NODE) \
3728 (TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts)
3729
3730#define TREE_TARGET_GLOBALS(NODE) \
3731 (TARGET_OPTION_NODE_CHECK (NODE)->target_option.globals)
3732
3733/* Return a tree node that encapsulates the target options in OPTS and
3734 OPTS_SET. */
3735extern tree build_target_option_node (struct gcc_options *opts,
3736 struct gcc_options *opts_set);
3737
3738extern void prepare_target_option_nodes_for_pch (void);
3739
3740#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3741
3742inline tree
3743tree_check (tree __t, const char *__f, int __l, const char *__g, tree_code __c)
3744{
3745 if (TREE_CODE (__t) != __c)
3746 tree_check_failed (__t, __f, __l, __g, __c, 0);
3747 return __t;
3748}
3749
3750inline tree
3751tree_not_check (tree __t, const char *__f, int __l, const char *__g,
3752 enum tree_code __c)
3753{
3754 if (TREE_CODE (__t) == __c)
3755 tree_not_check_failed (__t, __f, __l, __g, __c, 0);
3756 return __t;
3757}
3758
3759inline tree
3760tree_check2 (tree __t, const char *__f, int __l, const char *__g,
3761 enum tree_code __c1, enum tree_code __c2)
3762{
3763 if (TREE_CODE (__t) != __c1
3764 && TREE_CODE (__t) != __c2)
3765 tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
3766 return __t;
3767}
3768
3769inline tree
3770tree_not_check2 (tree __t, const char *__f, int __l, const char *__g,
3771 enum tree_code __c1, enum tree_code __c2)
3772{
3773 if (TREE_CODE (__t) == __c1
3774 || TREE_CODE (__t) == __c2)
3775 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
3776 return __t;
3777}
3778
3779inline tree
3780tree_check3 (tree __t, const char *__f, int __l, const char *__g,
3781 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
3782{
3783 if (TREE_CODE (__t) != __c1
3784 && TREE_CODE (__t) != __c2
3785 && TREE_CODE (__t) != __c3)
3786 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
3787 return __t;
3788}
3789
3790inline tree
3791tree_not_check3 (tree __t, const char *__f, int __l, const char *__g,
3792 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
3793{
3794 if (TREE_CODE (__t) == __c1
3795 || TREE_CODE (__t) == __c2
3796 || TREE_CODE (__t) == __c3)
3797 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
3798 return __t;
3799}
3800
3801inline tree
3802tree_check4 (tree __t, const char *__f, int __l, const char *__g,
3803 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3804 enum tree_code __c4)
3805{
3806 if (TREE_CODE (__t) != __c1
3807 && TREE_CODE (__t) != __c2
3808 && TREE_CODE (__t) != __c3
3809 && TREE_CODE (__t) != __c4)
3810 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
3811 return __t;
3812}
3813
3814inline tree
3815tree_not_check4 (tree __t, const char *__f, int __l, const char *__g,
3816 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3817 enum tree_code __c4)
3818{
3819 if (TREE_CODE (__t) == __c1
3820 || TREE_CODE (__t) == __c2
3821 || TREE_CODE (__t) == __c3
3822 || TREE_CODE (__t) == __c4)
3823 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
3824 return __t;
3825}
3826
3827inline tree
3828tree_check5 (tree __t, const char *__f, int __l, const char *__g,
3829 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3830 enum tree_code __c4, enum tree_code __c5)
3831{
3832 if (TREE_CODE (__t) != __c1
3833 && TREE_CODE (__t) != __c2
3834 && TREE_CODE (__t) != __c3
3835 && TREE_CODE (__t) != __c4
3836 && TREE_CODE (__t) != __c5)
3837 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
3838 return __t;
3839}
3840
3841inline tree
3842tree_not_check5 (tree __t, const char *__f, int __l, const char *__g,
3843 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3844 enum tree_code __c4, enum tree_code __c5)
3845{
3846 if (TREE_CODE (__t) == __c1
3847 || TREE_CODE (__t) == __c2
3848 || TREE_CODE (__t) == __c3
3849 || TREE_CODE (__t) == __c4
3850 || TREE_CODE (__t) == __c5)
3851 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
3852 return __t;
3853}
3854
3855inline tree
3856tree_check6 (tree __t, const char *__f, int __l, const char *__g,
3857 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3858 enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
3859{
3860 if (TREE_CODE (__t) != __c1
3861 && TREE_CODE (__t) != __c2
3862 && TREE_CODE (__t) != __c3
3863 && TREE_CODE (__t) != __c4
3864 && TREE_CODE (__t) != __c5
3865 && TREE_CODE (__t) != __c6)
3866 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, __c6,
3867 0);
3868 return __t;
3869}
3870
3871inline tree
3872tree_not_check6 (tree __t, const char *__f, int __l, const char *__g,
3873 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3874 enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
3875{
3876 if (TREE_CODE (__t) == __c1
3877 || TREE_CODE (__t) == __c2
3878 || TREE_CODE (__t) == __c3
3879 || TREE_CODE (__t) == __c4
3880 || TREE_CODE (__t) == __c5
3881 || TREE_CODE (__t) == __c6)
3882 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
3883 __c6, 0);
3884 return __t;
3885}
3886
3887inline tree
3888contains_struct_check (tree __t, const enum tree_node_structure_enum __s,
3889 const char *__f, int __l, const char *__g)
3890{
3891 if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
3892 tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
3893 return __t;
3894}
3895
3896inline tree
3897tree_class_check (tree __t, const enum tree_code_class __class,
3898 const char *__f, int __l, const char *__g)
3899{
3900 if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
3901 tree_class_check_failed (__t, __class, __f, __l, __g);
3902 return __t;
3903}
3904
3905inline tree
3906tree_range_check (tree __t,
3907 enum tree_code __code1, enum tree_code __code2,
3908 const char *__f, int __l, const char *__g)
3909{
3910 if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
3911 tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
3912 return __t;
3913}
3914
3915inline tree
3916omp_clause_subcode_check (tree __t, enum omp_clause_code __code,
3917 const char *__f, int __l, const char *__g)
3918{
3919 if (TREE_CODE (__t) != OMP_CLAUSE)
3920 tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
3921 if (__t->omp_clause.code != __code)
3922 omp_clause_check_failed (__t, __f, __l, __g, __code);
3923 return __t;
3924}
3925
3926inline tree
3927omp_clause_range_check (tree __t,
3928 enum omp_clause_code __code1,
3929 enum omp_clause_code __code2,
3930 const char *__f, int __l, const char *__g)
3931{
3932 if (TREE_CODE (__t) != OMP_CLAUSE)
3933 tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
3934 if ((int) __t->omp_clause.code < (int) __code1
3935 || (int) __t->omp_clause.code > (int) __code2)
3936 omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
3937 return __t;
3938}
3939
3940/* These checks have to be special cased. */
3941
3942inline tree
3943expr_check (tree __t, const char *__f, int __l, const char *__g)
3944{
3945 char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
3946 if (!IS_EXPR_CODE_CLASS (__c))
3947 tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
3948 return __t;
3949}
3950
3951/* These checks have to be special cased. */
3952
3953inline tree
3954non_type_check (tree __t, const char *__f, int __l, const char *__g)
3955{
3956 if (TYPE_P (__t))
3957 tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
3958 return __t;
3959}
3960
3961inline const HOST_WIDE_INT *
3962tree_int_cst_elt_check (const_tree __t, int __i,
3963 const char *__f, int __l, const char *__g)
3964{
3965 if (TREE_CODE (__t) != INTEGER_CST)
3966 tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
3967 if (__i < 0 || __i >= __t->base.u.int_length.extended)
3968 tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
3969 __f, __l, __g);
3970 return &CONST_CAST_TREE (__t)->int_cst.val[__i];
3971}
3972
3973inline HOST_WIDE_INT *
3974tree_int_cst_elt_check (tree __t, int __i,
3975 const char *__f, int __l, const char *__g)
3976{
3977 if (TREE_CODE (__t) != INTEGER_CST)
3978 tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
3979 if (__i < 0 || __i >= __t->base.u.int_length.extended)
3980 tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
3981 __f, __l, __g);
3982 return &CONST_CAST_TREE (__t)->int_cst.val[__i];
3983}
3984
3985/* Workaround -Wstrict-overflow false positive during profiledbootstrap. */
3986
3987# if GCC_VERSION >= 4006
3988#pragma GCC diagnostic push
3989#pragma GCC diagnostic ignored "-Wstrict-overflow"
3990#endif
3991
3992inline tree *
3993tree_vec_elt_check (tree __t, int __i,
3994 const char *__f, int __l, const char *__g)
3995{
3996 if (TREE_CODE (__t) != TREE_VEC)
3997 tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
3998 if (__i < 0 || __i >= __t->base.u.length)
3999 tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
4000 return &CONST_CAST_TREE (__t)->vec.a[__i];
4001}
4002
4003# if GCC_VERSION >= 4006
4004#pragma GCC diagnostic pop
4005#endif
4006
4007inline tree *
4008omp_clause_elt_check (tree __t, int __i,
4009 const char *__f, int __l, const char *__g)
4010{
4011 if (TREE_CODE (__t) != OMP_CLAUSE)
4012 tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4013 if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
4014 omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
4015 return &__t->omp_clause.ops[__i];
4016}
4017
4018/* These checks have to be special cased. */
4019
4020inline tree
4021any_integral_type_check (tree __t, const char *__f, int __l, const char *__g)
4022{
4023 if (!ANY_INTEGRAL_TYPE_P (__t))
4024 tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
4025 INTEGER_TYPE, BITINT_TYPE, 0);
4026 return __t;
4027}
4028
4029inline const_tree
4030tree_check (const_tree __t, const char *__f, int __l, const char *__g,
4031 tree_code __c)
4032{
4033 if (TREE_CODE (__t) != __c)
4034 tree_check_failed (__t, __f, __l, __g, __c, 0);
4035 return __t;
4036}
4037
4038inline const_tree
4039tree_not_check (const_tree __t, const char *__f, int __l, const char *__g,
4040 enum tree_code __c)
4041{
4042 if (TREE_CODE (__t) == __c)
4043 tree_not_check_failed (__t, __f, __l, __g, __c, 0);
4044 return __t;
4045}
4046
4047inline const_tree
4048tree_check2 (const_tree __t, const char *__f, int __l, const char *__g,
4049 enum tree_code __c1, enum tree_code __c2)
4050{
4051 if (TREE_CODE (__t) != __c1
4052 && TREE_CODE (__t) != __c2)
4053 tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
4054 return __t;
4055}
4056
4057inline const_tree
4058tree_not_check2 (const_tree __t, const char *__f, int __l, const char *__g,
4059 enum tree_code __c1, enum tree_code __c2)
4060{
4061 if (TREE_CODE (__t) == __c1
4062 || TREE_CODE (__t) == __c2)
4063 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
4064 return __t;
4065}
4066
4067inline const_tree
4068tree_check3 (const_tree __t, const char *__f, int __l, const char *__g,
4069 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
4070{
4071 if (TREE_CODE (__t) != __c1
4072 && TREE_CODE (__t) != __c2
4073 && TREE_CODE (__t) != __c3)
4074 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
4075 return __t;
4076}
4077
4078inline const_tree
4079tree_not_check3 (const_tree __t, const char *__f, int __l, const char *__g,
4080 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
4081{
4082 if (TREE_CODE (__t) == __c1
4083 || TREE_CODE (__t) == __c2
4084 || TREE_CODE (__t) == __c3)
4085 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
4086 return __t;
4087}
4088
4089inline const_tree
4090tree_check4 (const_tree __t, const char *__f, int __l, const char *__g,
4091 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4092 enum tree_code __c4)
4093{
4094 if (TREE_CODE (__t) != __c1
4095 && TREE_CODE (__t) != __c2
4096 && TREE_CODE (__t) != __c3
4097 && TREE_CODE (__t) != __c4)
4098 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
4099 return __t;
4100}
4101
4102inline const_tree
4103tree_not_check4 (const_tree __t, const char *__f, int __l, const char *__g,
4104 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4105 enum tree_code __c4)
4106{
4107 if (TREE_CODE (__t) == __c1
4108 || TREE_CODE (__t) == __c2
4109 || TREE_CODE (__t) == __c3
4110 || TREE_CODE (__t) == __c4)
4111 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
4112 return __t;
4113}
4114
4115inline const_tree
4116tree_check5 (const_tree __t, const char *__f, int __l, const char *__g,
4117 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4118 enum tree_code __c4, enum tree_code __c5)
4119{
4120 if (TREE_CODE (__t) != __c1
4121 && TREE_CODE (__t) != __c2
4122 && TREE_CODE (__t) != __c3
4123 && TREE_CODE (__t) != __c4
4124 && TREE_CODE (__t) != __c5)
4125 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
4126 return __t;
4127}
4128
4129inline const_tree
4130tree_not_check5 (const_tree __t, const char *__f, int __l, const char *__g,
4131 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4132 enum tree_code __c4, enum tree_code __c5)
4133{
4134 if (TREE_CODE (__t) == __c1
4135 || TREE_CODE (__t) == __c2
4136 || TREE_CODE (__t) == __c3
4137 || TREE_CODE (__t) == __c4
4138 || TREE_CODE (__t) == __c5)
4139 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
4140 return __t;
4141}
4142
4143inline const_tree
4144tree_check6 (const_tree __t, const char *__f, int __l, const char *__g,
4145 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4146 enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
4147{
4148 if (TREE_CODE (__t) != __c1
4149 && TREE_CODE (__t) != __c2
4150 && TREE_CODE (__t) != __c3
4151 && TREE_CODE (__t) != __c4
4152 && TREE_CODE (__t) != __c5
4153 && TREE_CODE (__t) != __c6)
4154 tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, __c6,
4155 0);
4156 return __t;
4157}
4158
4159inline const_tree
4160tree_not_check6 (const_tree __t, const char *__f, int __l, const char *__g,
4161 enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4162 enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
4163{
4164 if (TREE_CODE (__t) == __c1
4165 || TREE_CODE (__t) == __c2
4166 || TREE_CODE (__t) == __c3
4167 || TREE_CODE (__t) == __c4
4168 || TREE_CODE (__t) == __c5
4169 || TREE_CODE (__t) == __c6)
4170 tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
4171 __c6, 0);
4172 return __t;
4173}
4174
4175inline const_tree
4176contains_struct_check (const_tree __t, const enum tree_node_structure_enum __s,
4177 const char *__f, int __l, const char *__g)
4178{
4179 if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
4180 tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
4181 return __t;
4182}
4183
4184inline const_tree
4185tree_class_check (const_tree __t, const enum tree_code_class __class,
4186 const char *__f, int __l, const char *__g)
4187{
4188 if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
4189 tree_class_check_failed (__t, __class, __f, __l, __g);
4190 return __t;
4191}
4192
4193inline const_tree
4194tree_range_check (const_tree __t,
4195 enum tree_code __code1, enum tree_code __code2,
4196 const char *__f, int __l, const char *__g)
4197{
4198 if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
4199 tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
4200 return __t;
4201}
4202
4203inline const_tree
4204omp_clause_subcode_check (const_tree __t, enum omp_clause_code __code,
4205 const char *__f, int __l, const char *__g)
4206{
4207 if (TREE_CODE (__t) != OMP_CLAUSE)
4208 tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4209 if (__t->omp_clause.code != __code)
4210 omp_clause_check_failed (__t, __f, __l, __g, __code);
4211 return __t;
4212}
4213
4214inline const_tree
4215omp_clause_range_check (const_tree __t,
4216 enum omp_clause_code __code1,
4217 enum omp_clause_code __code2,
4218 const char *__f, int __l, const char *__g)
4219{
4220 if (TREE_CODE (__t) != OMP_CLAUSE)
4221 tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4222 if ((int) __t->omp_clause.code < (int) __code1
4223 || (int) __t->omp_clause.code > (int) __code2)
4224 omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
4225 return __t;
4226}
4227
4228inline const_tree
4229expr_check (const_tree __t, const char *__f, int __l, const char *__g)
4230{
4231 char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
4232 if (!IS_EXPR_CODE_CLASS (__c))
4233 tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
4234 return __t;
4235}
4236
4237inline const_tree
4238non_type_check (const_tree __t, const char *__f, int __l, const char *__g)
4239{
4240 if (TYPE_P (__t))
4241 tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
4242 return __t;
4243}
4244
4245# if GCC_VERSION >= 4006
4246#pragma GCC diagnostic push
4247#pragma GCC diagnostic ignored "-Wstrict-overflow"
4248#endif
4249
4250inline const_tree *
4251tree_vec_elt_check (const_tree __t, int __i,
4252 const char *__f, int __l, const char *__g)
4253{
4254 if (TREE_CODE (__t) != TREE_VEC)
4255 tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
4256 if (__i < 0 || __i >= __t->base.u.length)
4257 tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
4258 return CONST_CAST (const_tree *, &__t->vec.a[__i]);
4259 //return &__t->vec.a[__i];
4260}
4261
4262# if GCC_VERSION >= 4006
4263#pragma GCC diagnostic pop
4264#endif
4265
4266inline const_tree *
4267omp_clause_elt_check (const_tree __t, int __i,
4268 const char *__f, int __l, const char *__g)
4269{
4270 if (TREE_CODE (__t) != OMP_CLAUSE)
4271 tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4272 if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
4273 omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
4274 return CONST_CAST (const_tree *, &__t->omp_clause.ops[__i]);
4275}
4276
4277inline const_tree
4278any_integral_type_check (const_tree __t, const char *__f, int __l,
4279 const char *__g)
4280{
4281 if (!ANY_INTEGRAL_TYPE_P (__t))
4282 tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
4283 INTEGER_TYPE, BITINT_TYPE, 0);
4284 return __t;
4285}
4286
4287#endif
4288
4289/* Compute the number of operands in an expression node NODE. For
4290 tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
4291 otherwise it is looked up from the node's code. */
4292inline int
4294{
4295 if (VL_EXP_CLASS_P (node))
4296 return VL_EXP_OPERAND_LENGTH (node);
4297 else
4298 return TREE_CODE_LENGTH (TREE_CODE (node));
4299}
4300
4301#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4302
4303/* Special checks for TREE_OPERANDs. */
4304inline tree *
4305tree_operand_check (tree __t, int __i,
4306 const char *__f, int __l, const char *__g)
4307{
4308 const_tree __u = EXPR_CHECK (__t);
4309 if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
4310 tree_operand_check_failed (__i, __u, __f, __l, __g);
4311 return &CONST_CAST_TREE (__u)->exp.operands[__i];
4312}
4313
4314inline tree *
4315tree_operand_check_code (tree __t, enum tree_code __code, int __i,
4316 const char *__f, int __l, const char *__g)
4317{
4318 if (TREE_CODE (__t) != __code)
4319 tree_check_failed (__t, __f, __l, __g, __code, 0);
4320 if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
4321 tree_operand_check_failed (__i, __t, __f, __l, __g);
4322 return &__t->exp.operands[__i];
4323}
4324
4325inline const_tree *
4326tree_operand_check (const_tree __t, int __i,
4327 const char *__f, int __l, const char *__g)
4328{
4329 const_tree __u = EXPR_CHECK (__t);
4330 if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
4331 tree_operand_check_failed (__i, __u, __f, __l, __g);
4332 return CONST_CAST (const_tree *, &__u->exp.operands[__i]);
4333}
4334
4335inline const_tree *
4336tree_operand_check_code (const_tree __t, enum tree_code __code, int __i,
4337 const char *__f, int __l, const char *__g)
4338{
4339 if (TREE_CODE (__t) != __code)
4340 tree_check_failed (__t, __f, __l, __g, __code, 0);
4341 if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
4342 tree_operand_check_failed (__i, __t, __f, __l, __g);
4343 return CONST_CAST (const_tree *, &__t->exp.operands[__i]);
4344}
4345
4346#endif
4347
4348/* True iff an identifier matches a C string. */
4349
4350inline bool
4351id_equal (const_tree id, const char *str)
4352{
4353 return !strcmp (IDENTIFIER_POINTER (id), str);
4354}
4355
4356inline bool
4357id_equal (const char *str, const_tree id)
4358{
4359 return id_equal (id, str);
4360}
4361
4362/* Return the number of elements in the VECTOR_TYPE given by NODE. */
4363
4364inline poly_uint64
4366{
4368 unsigned int precision = VECTOR_TYPE_CHECK (node)->type_common.precision;
4369 if (NUM_POLY_INT_COEFFS == 2)
4370 {
4371 /* See the corresponding code in SET_TYPE_VECTOR_SUBPARTS for a
4372 description of the encoding. */
4373 poly_uint64 res = 0;
4374 res.coeffs[0] = HOST_WIDE_INT_1U << (precision & 0xff);
4375 if (precision & 0x100)
4376 res.coeffs[1] = HOST_WIDE_INT_1U << (precision & 0xff);
4377 return res;
4378 }
4379 else
4380 return HOST_WIDE_INT_1U << precision;
4381}
4382
4383/* Set the number of elements in VECTOR_TYPE NODE to SUBPARTS, which must
4384 satisfy valid_vector_subparts_p. */
4385
4386inline void
4388{
4390 unsigned HOST_WIDE_INT coeff0 = subparts.coeffs[0];
4391 int index = exact_log2 (coeff0);
4392 gcc_assert (index >= 0);
4393 if (NUM_POLY_INT_COEFFS == 2)
4394 {
4395 /* We have two coefficients that are each in the range 1 << [0, 63],
4396 so supporting all combinations would require 6 bits per coefficient
4397 and 12 bits in total. Since the precision field is only 10 bits
4398 in size, we need to be more restrictive than that.
4399
4400 At present, coeff[1] is always either 0 (meaning that the number
4401 of units is constant) or equal to coeff[0] (meaning that the number
4402 of units is N + X * N for some target-dependent zero-based runtime
4403 parameter X). We can therefore encode coeff[1] in a single bit.
4404
4405 The most compact encoding would be to use mask 0x3f for coeff[0]
4406 and 0x40 for coeff[1], leaving 0x380 unused. It's possible to
4407 get slightly more efficient code on some hosts if we instead
4408 treat the shift amount as an independent byte, so here we use
4409 0xff for coeff[0] and 0x100 for coeff[1]. */
4410 unsigned HOST_WIDE_INT coeff1 = subparts.coeffs[1];
4411 gcc_assert (coeff1 == 0 || coeff1 == coeff0);
4412 VECTOR_TYPE_CHECK (node)->type_common.precision
4413 = index + (coeff1 != 0 ? 0x100 : 0);
4414 }
4415 else
4416 VECTOR_TYPE_CHECK (node)->type_common.precision = index;
4417}
4418
4419/* Return true if we can construct vector types with the given number
4420 of subparts. */
4421
4422inline bool
4424{
4425 unsigned HOST_WIDE_INT coeff0 = subparts.coeffs[0];
4426 if (!pow2p_hwi (coeff0))
4427 return false;
4428 if (NUM_POLY_INT_COEFFS == 2)
4429 {
4430 unsigned HOST_WIDE_INT coeff1 = subparts.coeffs[1];
4431 if (coeff1 != 0 && coeff1 != coeff0)
4432 return false;
4433 }
4434 return true;
4435}
4436
4437/* Return the built-in function that DECL represents, given that it is known
4438 to be a FUNCTION_DECL with built-in class BUILT_IN_NORMAL. */
4439inline built_in_function
4441{
4442 const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4443 gcc_checking_assert (fndecl.built_in_class == BUILT_IN_NORMAL);
4444 return (built_in_function) fndecl.function_code;
4445}
4446
4447/* Return the target-specific built-in function that DECL represents,
4448 given that it is known to be a FUNCTION_DECL with built-in class
4449 BUILT_IN_MD. */
4450inline int
4452{
4453 const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4454 gcc_checking_assert (fndecl.built_in_class == BUILT_IN_MD);
4455 return fndecl.function_code;
4456}
4457
4458/* Return the frontend-specific built-in function that DECL represents,
4459 given that it is known to be a FUNCTION_DECL with built-in class
4460 BUILT_IN_FRONTEND. */
4461inline int
4463{
4464 const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4465 gcc_checking_assert (fndecl.built_in_class == BUILT_IN_FRONTEND);
4466 return fndecl.function_code;
4467}
4468
4469/* Record that FUNCTION_DECL DECL represents built-in function FCODE of
4470 class FCLASS. */
4471inline void
4473 unsigned int fcode)
4474{
4475 tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4476 fndecl.built_in_class = fclass;
4477 fndecl.function_code = fcode;
4478}
4479
4480/* Record that FUNCTION_DECL NEWDECL represents the same built-in function
4481 as OLDDECL (or none, if OLDDECL doesn't represent a built-in function). */
4482inline void
4484{
4485 tree_function_decl &newfndecl = FUNCTION_DECL_CHECK (newdecl)->function_decl;
4486 const tree_function_decl &oldfndecl
4487 = FUNCTION_DECL_CHECK (olddecl)->function_decl;
4488 newfndecl.built_in_class = oldfndecl.built_in_class;
4489 newfndecl.function_code = oldfndecl.function_code;
4490}
4491
4492/* In NON_LVALUE_EXPR and VIEW_CONVERT_EXPR, set when this node is merely a
4493 wrapper added to express a location_t on behalf of the node's child
4494 (e.g. by maybe_wrap_with_location). */
4495
4496#define EXPR_LOCATION_WRAPPER_P(NODE) \
4497 (TREE_CHECK2(NODE, NON_LVALUE_EXPR, VIEW_CONVERT_EXPR)->base.public_flag)
4498
4499/* Test if EXP is merely a wrapper node, added to express a location_t
4500 on behalf of the node's child (e.g. by maybe_wrap_with_location). */
4501
4502inline bool
4504{
4505 /* A wrapper node has code NON_LVALUE_EXPR or VIEW_CONVERT_EXPR, and
4506 the flag EXPR_LOCATION_WRAPPER_P is set.
4507 It normally has the same type as its operand, but it can have a
4508 different one if the type of the operand has changed (e.g. when
4509 merging duplicate decls).
4510
4511 NON_LVALUE_EXPR is used for wrapping constants, apart from STRING_CST.
4512 VIEW_CONVERT_EXPR is used for wrapping non-constants and STRING_CST. */
4513 if ((TREE_CODE (exp) == NON_LVALUE_EXPR
4514 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
4516 return true;
4517 return false;
4518}
4519
4520/* Implementation of STRIP_ANY_LOCATION_WRAPPER. */
4521
4522inline tree
4524{
4525 if (location_wrapper_p (exp))
4526 return TREE_OPERAND (exp, 0);
4527 else
4528 return exp;
4529}
4530
4531#define error_mark_node global_trees[TI_ERROR_MARK]
4532
4533#define intQI_type_node global_trees[TI_INTQI_TYPE]
4534#define intHI_type_node global_trees[TI_INTHI_TYPE]
4535#define intSI_type_node global_trees[TI_INTSI_TYPE]
4536#define intDI_type_node global_trees[TI_INTDI_TYPE]
4537#define intTI_type_node global_trees[TI_INTTI_TYPE]
4538
4539#define unsigned_intQI_type_node global_trees[TI_UINTQI_TYPE]
4540#define unsigned_intHI_type_node global_trees[TI_UINTHI_TYPE]
4541#define unsigned_intSI_type_node global_trees[TI_UINTSI_TYPE]
4542#define unsigned_intDI_type_node global_trees[TI_UINTDI_TYPE]
4543#define unsigned_intTI_type_node global_trees[TI_UINTTI_TYPE]
4544
4545#define atomicQI_type_node global_trees[TI_ATOMICQI_TYPE]
4546#define atomicHI_type_node global_trees[TI_ATOMICHI_TYPE]
4547#define atomicSI_type_node global_trees[TI_ATOMICSI_TYPE]
4548#define atomicDI_type_node global_trees[TI_ATOMICDI_TYPE]
4549#define atomicTI_type_node global_trees[TI_ATOMICTI_TYPE]
4550
4551#define uint16_type_node global_trees[TI_UINT16_TYPE]
4552#define uint32_type_node global_trees[TI_UINT32_TYPE]
4553#define uint64_type_node global_trees[TI_UINT64_TYPE]
4554#define uint128_type_node global_trees[TI_UINT128_TYPE]
4555
4556#define void_node global_trees[TI_VOID]
4557
4558#define integer_zero_node global_trees[TI_INTEGER_ZERO]
4559#define integer_one_node global_trees[TI_INTEGER_ONE]
4560#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]
4561#define size_zero_node global_trees[TI_SIZE_ZERO]
4562#define size_one_node global_trees[TI_SIZE_ONE]
4563#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]
4564#define bitsize_one_node global_trees[TI_BITSIZE_ONE]
4565#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT]
4566
4567/* Base access nodes. */
4568#define access_public_node global_trees[TI_PUBLIC]
4569#define access_protected_node global_trees[TI_PROTECTED]
4570#define access_private_node global_trees[TI_PRIVATE]
4571
4572#define null_pointer_node global_trees[TI_NULL_POINTER]
4573
4574#define float_type_node global_trees[TI_FLOAT_TYPE]
4575#define double_type_node global_trees[TI_DOUBLE_TYPE]
4576#define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE]
4577#define bfloat16_type_node global_trees[TI_BFLOAT16_TYPE]
4578
4579/* Nodes for particular _FloatN and _FloatNx types in sequence. */
4580#define FLOATN_TYPE_NODE(IDX) global_trees[TI_FLOATN_TYPE_FIRST + (IDX)]
4581#define FLOATN_NX_TYPE_NODE(IDX) global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)]
4582#define FLOATNX_TYPE_NODE(IDX) global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)]
4583
4584/* Names for individual types (code should normally iterate over all
4585 such types; these are only for back-end use, or in contexts such as
4586 *.def where iteration is not possible). */
4587#define float16_type_node global_trees[TI_FLOAT16_TYPE]
4588#define float32_type_node global_trees[TI_FLOAT32_TYPE]
4589#define float64_type_node global_trees[TI_FLOAT64_TYPE]
4590#define float128_type_node global_trees[TI_FLOAT128_TYPE]
4591#define float32x_type_node global_trees[TI_FLOAT32X_TYPE]
4592#define float64x_type_node global_trees[TI_FLOAT64X_TYPE]
4593#define float128x_type_node global_trees[TI_FLOAT128X_TYPE]
4594
4595/* Type used by certain backends for __float128, which in C++ should be
4596 distinct type from _Float128 for backwards compatibility reasons. */
4597#define float128t_type_node global_trees[TI_FLOAT128T_TYPE]
4598
4599#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE]
4600#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE]
4601#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE]
4602#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE]
4603
4604#define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE]
4605#define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE]
4606#define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE]
4607#define complex_long_double_type_node global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
4608
4609#define COMPLEX_FLOATN_NX_TYPE_NODE(IDX) global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)]
4610
4611#define void_type_node global_trees[TI_VOID_TYPE]
4612/* The C type `void *'. */
4613#define ptr_type_node global_trees[TI_PTR_TYPE]
4614/* The C type `const void *'. */
4615#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE]
4616/* The C type `size_t'. */
4617#define size_type_node global_trees[TI_SIZE_TYPE]
4618#define pid_type_node global_trees[TI_PID_TYPE]
4619#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
4620#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
4621#define va_list_gpr_counter_field global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]
4622#define va_list_fpr_counter_field global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]
4623/* The C type `FILE *'. */
4624#define fileptr_type_node global_trees[TI_FILEPTR_TYPE]
4625/* The C type `const struct tm *'. */
4626#define const_tm_ptr_type_node global_trees[TI_CONST_TM_PTR_TYPE]
4627/* The C type `fenv_t *'. */
4628#define fenv_t_ptr_type_node global_trees[TI_FENV_T_PTR_TYPE]
4629#define const_fenv_t_ptr_type_node global_trees[TI_CONST_FENV_T_PTR_TYPE]
4630/* The C type `fexcept_t *'. */
4631#define fexcept_t_ptr_type_node global_trees[TI_FEXCEPT_T_PTR_TYPE]
4632#define const_fexcept_t_ptr_type_node global_trees[TI_CONST_FEXCEPT_T_PTR_TYPE]
4633#define pointer_sized_int_node global_trees[TI_POINTER_SIZED_TYPE]
4634
4635#define boolean_type_node global_trees[TI_BOOLEAN_TYPE]
4636#define boolean_false_node global_trees[TI_BOOLEAN_FALSE]
4637#define boolean_true_node global_trees[TI_BOOLEAN_TRUE]
4638
4639/* The decimal floating point types. */
4640#define dfloat32_type_node global_trees[TI_DFLOAT32_TYPE]
4641#define dfloat64_type_node global_trees[TI_DFLOAT64_TYPE]
4642#define dfloat128_type_node global_trees[TI_DFLOAT128_TYPE]
4643#define dfloat64x_type_node global_trees[TI_DFLOAT64X_TYPE]
4644
4645/* The fixed-point types. */
4646#define sat_short_fract_type_node global_trees[TI_SAT_SFRACT_TYPE]
4647#define sat_fract_type_node global_trees[TI_SAT_FRACT_TYPE]
4648#define sat_long_fract_type_node global_trees[TI_SAT_LFRACT_TYPE]
4649#define sat_long_long_fract_type_node global_trees[TI_SAT_LLFRACT_TYPE]
4650#define sat_unsigned_short_fract_type_node \
4651 global_trees[TI_SAT_USFRACT_TYPE]
4652#define sat_unsigned_fract_type_node global_trees[TI_SAT_UFRACT_TYPE]
4653#define sat_unsigned_long_fract_type_node \
4654 global_trees[TI_SAT_ULFRACT_TYPE]
4655#define sat_unsigned_long_long_fract_type_node \
4656 global_trees[TI_SAT_ULLFRACT_TYPE]
4657#define short_fract_type_node global_trees[TI_SFRACT_TYPE]
4658#define fract_type_node global_trees[TI_FRACT_TYPE]
4659#define long_fract_type_node global_trees[TI_LFRACT_TYPE]
4660#define long_long_fract_type_node global_trees[TI_LLFRACT_TYPE]
4661#define unsigned_short_fract_type_node global_trees[TI_USFRACT_TYPE]
4662#define unsigned_fract_type_node global_trees[TI_UFRACT_TYPE]
4663#define unsigned_long_fract_type_node global_trees[TI_ULFRACT_TYPE]
4664#define unsigned_long_long_fract_type_node \
4665 global_trees[TI_ULLFRACT_TYPE]
4666#define sat_short_accum_type_node global_trees[TI_SAT_SACCUM_TYPE]
4667#define sat_accum_type_node global_trees[TI_SAT_ACCUM_TYPE]
4668#define sat_long_accum_type_node global_trees[TI_SAT_LACCUM_TYPE]
4669#define sat_long_long_accum_type_node global_trees[TI_SAT_LLACCUM_TYPE]
4670#define sat_unsigned_short_accum_type_node \
4671 global_trees[TI_SAT_USACCUM_TYPE]
4672#define sat_unsigned_accum_type_node global_trees[TI_SAT_UACCUM_TYPE]
4673#define sat_unsigned_long_accum_type_node \
4674 global_trees[TI_SAT_ULACCUM_TYPE]
4675#define sat_unsigned_long_long_accum_type_node \
4676 global_trees[TI_SAT_ULLACCUM_TYPE]
4677#define short_accum_type_node global_trees[TI_SACCUM_TYPE]
4678#define accum_type_node global_trees[TI_ACCUM_TYPE]
4679#define long_accum_type_node global_trees[TI_LACCUM_TYPE]
4680#define long_long_accum_type_node global_trees[TI_LLACCUM_TYPE]
4681#define unsigned_short_accum_type_node global_trees[TI_USACCUM_TYPE]
4682#define unsigned_accum_type_node global_trees[TI_UACCUM_TYPE]
4683#define unsigned_long_accum_type_node global_trees[TI_ULACCUM_TYPE]
4684#define unsigned_long_long_accum_type_node \
4685 global_trees[TI_ULLACCUM_TYPE]
4686#define qq_type_node global_trees[TI_QQ_TYPE]
4687#define hq_type_node global_trees[TI_HQ_TYPE]
4688#define sq_type_node global_trees[TI_SQ_TYPE]
4689#define dq_type_node global_trees[TI_DQ_TYPE]
4690#define tq_type_node global_trees[TI_TQ_TYPE]
4691#define uqq_type_node global_trees[TI_UQQ_TYPE]
4692#define uhq_type_node global_trees[TI_UHQ_TYPE]
4693#define usq_type_node global_trees[TI_USQ_TYPE]
4694#define udq_type_node global_trees[TI_UDQ_TYPE]
4695#define utq_type_node global_trees[TI_UTQ_TYPE]
4696#define sat_qq_type_node global_trees[TI_SAT_QQ_TYPE]
4697#define sat_hq_type_node global_trees[TI_SAT_HQ_TYPE]
4698#define sat_sq_type_node global_trees[TI_SAT_SQ_TYPE]
4699#define sat_dq_type_node global_trees[TI_SAT_DQ_TYPE]
4700#define sat_tq_type_node global_trees[TI_SAT_TQ_TYPE]
4701#define sat_uqq_type_node global_trees[TI_SAT_UQQ_TYPE]
4702#define sat_uhq_type_node global_trees[TI_SAT_UHQ_TYPE]
4703#define sat_usq_type_node global_trees[TI_SAT_USQ_TYPE]
4704#define sat_udq_type_node global_trees[TI_SAT_UDQ_TYPE]
4705#define sat_utq_type_node global_trees[TI_SAT_UTQ_TYPE]
4706#define ha_type_node global_trees[TI_HA_TYPE]
4707#define sa_type_node global_trees[TI_SA_TYPE]
4708#define da_type_node global_trees[TI_DA_TYPE]
4709#define ta_type_node global_trees[TI_TA_TYPE]
4710#define uha_type_node global_trees[TI_UHA_TYPE]
4711#define usa_type_node global_trees[TI_USA_TYPE]
4712#define uda_type_node global_trees[TI_UDA_TYPE]
4713#define uta_type_node global_trees[TI_UTA_TYPE]
4714#define sat_ha_type_node global_trees[TI_SAT_HA_TYPE]
4715#define sat_sa_type_node global_trees[TI_SAT_SA_TYPE]
4716#define sat_da_type_node global_trees[TI_SAT_DA_TYPE]
4717#define sat_ta_type_node global_trees[TI_SAT_TA_TYPE]
4718#define sat_uha_type_node global_trees[TI_SAT_UHA_TYPE]
4719#define sat_usa_type_node global_trees[TI_SAT_USA_TYPE]
4720#define sat_uda_type_node global_trees[TI_SAT_UDA_TYPE]
4721#define sat_uta_type_node global_trees[TI_SAT_UTA_TYPE]
4722
4723/* The node that should be placed at the end of a parameter list to
4724 indicate that the function does not take a variable number of
4725 arguments. The TREE_VALUE will be void_type_node and there will be
4726 no TREE_CHAIN. Language-independent code should not assume
4727 anything else about this node. */
4728#define void_list_node global_trees[TI_VOID_LIST_NODE]
4729
4730#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
4731#define MAIN_NAME_P(NODE) \
4732 (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
4733
4734/* Optimization options (OPTIMIZATION_NODE) to use for default and current
4735 functions. */
4736#define optimization_default_node global_trees[TI_OPTIMIZATION_DEFAULT]
4737#define optimization_current_node global_trees[TI_OPTIMIZATION_CURRENT]
4738
4739/* Default/current target options (TARGET_OPTION_NODE). */
4740#define target_option_default_node global_trees[TI_TARGET_OPTION_DEFAULT]
4741#define target_option_current_node global_trees[TI_TARGET_OPTION_CURRENT]
4742
4743/* Default tree list option(), optimize() pragmas to be linked into the
4744 attribute list. */
4745#define current_target_pragma global_trees[TI_CURRENT_TARGET_PRAGMA]
4746#define current_optimize_pragma global_trees[TI_CURRENT_OPTIMIZE_PRAGMA]
4747
4748/* SCEV analyzer global shared trees. */
4749#define chrec_not_analyzed_yet NULL_TREE
4750#define chrec_dont_know global_trees[TI_CHREC_DONT_KNOW]
4751#define chrec_known global_trees[TI_CHREC_KNOWN]
4752
4753#define char_type_node integer_types[itk_char]
4754#define signed_char_type_node integer_types[itk_signed_char]
4755#define unsigned_char_type_node integer_types[itk_unsigned_char]
4756#define short_integer_type_node integer_types[itk_short]
4757#define short_unsigned_type_node integer_types[itk_unsigned_short]
4758#define integer_type_node integer_types[itk_int]
4759#define unsigned_type_node integer_types[itk_unsigned_int]
4760#define long_integer_type_node integer_types[itk_long]
4761#define long_unsigned_type_node integer_types[itk_unsigned_long]
4762#define long_long_integer_type_node integer_types[itk_long_long]
4763#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]
4764
4765/* True if T is an erroneous expression. */
4766
4767inline bool
4769{
4770 return (t == error_mark_node
4771 || (t && TREE_TYPE (t) == error_mark_node));
4772}
4773
4774/* Return the number of elements encoded directly in a VECTOR_CST. */
4775
4776inline unsigned int
4781
4782extern tree generate_internal_label (const char *);
4783extern const char *prefix_for_internal_label (tree label);
4785extern void overwrite_decl_assembler_name (tree decl, tree name);
4788extern const char *decl_section_name (const_tree);
4789extern void set_decl_section_name (tree, const char *);
4791extern enum tls_model decl_tls_model (const_tree);
4792extern void set_decl_tls_model (tree, enum tls_model);
4793
4794/* Compute the number of bytes occupied by 'node'. This routine only
4795 looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
4796
4797extern size_t tree_size (const_tree);
4798
4799/* Compute the number of bytes occupied by a tree with code CODE.
4800 This function cannot be used for TREE_VEC or INTEGER_CST nodes,
4801 which are of variable length. */
4802extern size_t tree_code_size (enum tree_code);
4803
4804/* Allocate and return a new UID from the DECL_UID namespace. */
4805extern int allocate_decl_uid (void);
4806
4807/* Lowest level primitive for allocating a node.
4808 The TREE_CODE is the only argument. Contents are initialized
4809 to zero except for a few of the common fields. */
4810
4812
4813/* Free tree node. */
4814
4815extern void free_node (tree);
4816
4817/* Make a copy of a node, with all the same contents. */
4818
4820
4821/* Make a copy of a chain of TREE_LIST nodes. */
4822
4823extern tree copy_list (tree);
4824
4825/* Make a CASE_LABEL_EXPR. */
4826
4828
4829/* Make a BINFO. */
4831
4832/* Make an INTEGER_CST. */
4833
4835
4836/* Make a TREE_VEC. */
4837
4839
4840/* Grow a TREE_VEC. */
4841
4843
4844/* Treat a TREE_VEC as a range of trees, e.g.
4845 for (tree e : tree_vec_range (v)) { ... } */
4846
4848{
4850public:
4852 tree *begin() { return TREE_VEC_BEGIN (v); }
4853 tree *end() { return TREE_VEC_END (v); }
4854};
4855
4856/* Construct various types of nodes. */
4857
4858extern tree build_nt (enum tree_code, ...);
4860
4869
4870/* _loc versions of build[1-5]. */
4871
4872inline tree
4873build1_loc (location_t loc, enum tree_code code, tree type,
4875{
4876 tree t = build1 (code, type, arg1 PASS_MEM_STAT);
4877 if (CAN_HAVE_LOCATION_P (t))
4878 SET_EXPR_LOCATION (t, loc);
4879 return t;
4880}
4881
4882inline tree
4883build2_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4885{
4886 tree t = build2 (code, type, arg0, arg1 PASS_MEM_STAT);
4887 if (CAN_HAVE_LOCATION_P (t))
4888 SET_EXPR_LOCATION (t, loc);
4889 return t;
4890}
4891
4892inline tree
4893build3_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4894 tree arg1, tree arg2 CXX_MEM_STAT_INFO)
4895{
4896 tree t = build3 (code, type, arg0, arg1, arg2 PASS_MEM_STAT);
4897 if (CAN_HAVE_LOCATION_P (t))
4898 SET_EXPR_LOCATION (t, loc);
4899 return t;
4900}
4901
4902inline tree
4903build4_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4904 tree arg1, tree arg2, tree arg3 CXX_MEM_STAT_INFO)
4905{
4906 tree t = build4 (code, type, arg0, arg1, arg2, arg3 PASS_MEM_STAT);
4907 if (CAN_HAVE_LOCATION_P (t))
4908 SET_EXPR_LOCATION (t, loc);
4909 return t;
4910}
4911
4912inline tree
4913build5_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4914 tree arg1, tree arg2, tree arg3, tree arg4 CXX_MEM_STAT_INFO)
4915{
4916 tree t = build5 (code, type, arg0, arg1, arg2, arg3,
4917 arg4 PASS_MEM_STAT);
4918 if (CAN_HAVE_LOCATION_P (t))
4919 SET_EXPR_LOCATION (t, loc);
4920 return t;
4921}
4922
4923/* Constructs double_int from tree CST. */
4924
4926
4927extern tree wide_int_to_tree (tree type, const poly_wide_int_ref &cst);
4928extern tree force_fit_type (tree, const poly_wide_int_ref &, int, bool);
4929
4930/* Create an INT_CST node with a CST value zero extended. */
4931
4932/* static inline */
4936extern tree make_vector (unsigned, unsigned CXX_MEM_STAT_INFO);
4942extern tree build_vector_a_then_b (tree, unsigned int, tree, tree);
4943extern void recompute_constructor_flags (tree);
4944extern void verify_constructor_flags (tree);
4949extern tree build_constructor_va (tree, int, ...);
4953extern tree build_complex (tree, tree, tree);
4954extern tree build_complex_inf (tree, bool);
4956extern tree build_one_cst (tree);
4959extern tree build_zero_cst (tree);
4960extern tree build_replicated_int_cst (tree, unsigned, HOST_WIDE_INT);
4961extern tree sign_mask_for (tree);
4962extern tree build_string (unsigned, const char * = NULL);
4966extern tree build_decl (location_t, enum tree_code,
4969extern tree build_fn_decl (const char *, tree);
4971extern tree build_block (tree, tree, tree, tree);
4972extern tree build_empty_stmt (location_t);
4973extern tree build_omp_clause (location_t, enum omp_clause_code);
4974
4976
4977extern tree build_call_nary (tree, tree, int, ...);
4978extern tree build_call_valist (tree, tree, int, va_list);
4979#define build_call_array(T1,T2,N,T3)\
4980 build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3)
4981extern tree build_call_array_loc (location_t, tree, tree, int, const tree *);
4982extern tree build_call_vec (tree, tree, const vec<tree, va_gc> *);
4983extern tree build_call_expr_loc_array (location_t, tree, int, tree *);
4984extern tree build_call_expr_loc_vec (location_t, tree, vec<tree, va_gc> *);
4985extern tree build_call_expr_loc (location_t, tree, int, ...);
4986extern tree build_call_expr (tree, int, ...);
4987extern tree build_call_expr_internal_loc (location_t, enum internal_fn,
4988 tree, int, ...);
4990 tree, int, const tree *);
4991extern tree maybe_build_call_expr_loc (location_t, combined_fn, tree,
4992 int, ...);
4993extern tree build_alloca_call_expr (tree, unsigned int, HOST_WIDE_INT);
4994extern tree build_string_literal (unsigned, const char * = NULL,
4996 unsigned HOST_WIDE_INT = HOST_WIDE_INT_M1U);
4997inline tree build_string_literal (const char *p)
4998{ return build_string_literal (strlen (p) + 1, p); }
5000{
5002 IDENTIFIER_POINTER (t));
5003}
5004
5005/* Construct various nodes representing data types. */
5006
5008extern tree signed_type_for (tree);
5009extern tree unsigned_type_for (tree);
5010extern bool is_truth_type_for (tree, tree);
5012extern tree truth_type_for (tree);
5013extern tree build_pointer_type_for_mode (tree, machine_mode, bool);
5015extern tree build_reference_type_for_mode (tree, machine_mode, bool);
5017extern tree build_vector_type_for_mode (tree, machine_mode);
5021extern tree build_index_type (tree);
5022extern tree build_array_type_1 (tree, tree, bool, bool, bool);
5023extern tree build_array_type (tree, tree, bool = false);
5026extern tree build_function_type (tree, tree, bool = false);
5027extern tree build_function_type_list (tree, ...);
5029extern tree build_function_type_array (tree, int, tree *);
5031#define build_function_type_vec(RET, V) \
5032 build_function_type_array (RET, vec_safe_length (V), vec_safe_address (V))
5033#define build_varargs_function_type_vec(RET, V) \
5034 build_varargs_function_type_array (RET, vec_safe_length (V), \
5035 vec_safe_address (V))
5039extern tree build_complex_type (tree, bool named = false);
5042
5043extern tree value_member (tree, tree);
5045extern bool vec_member (const_tree, vec<tree, va_gc> *);
5046extern tree chain_index (int, tree);
5047
5048/* Arguments may be null. */
5050
5051/* The following predicates are safe to call with a null argument. */
5052extern bool tree_fits_shwi_p (const_tree) ATTRIBUTE_PURE;
5053extern bool tree_fits_poly_int64_p (const_tree) ATTRIBUTE_PURE;
5054extern bool tree_fits_uhwi_p (const_tree) ATTRIBUTE_PURE;
5055extern bool tree_fits_poly_uint64_p (const_tree) ATTRIBUTE_PURE;
5056extern bool tree_fits_sanitize_code_type_p (const_tree) ATTRIBUTE_PURE;
5057
5058
5059extern HOST_WIDE_INT tree_to_shwi (const_tree)
5060 ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5062 ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5063extern unsigned HOST_WIDE_INT tree_to_uhwi (const_tree)
5064 ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5066 ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5068 ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5069#if !defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 4003)
5070extern inline __attribute__ ((__gnu_inline__)) HOST_WIDE_INT
5072{
5074 return TREE_INT_CST_LOW (t);
5075}
5076
5077extern inline __attribute__ ((__gnu_inline__)) unsigned HOST_WIDE_INT
5079{
5081 return TREE_INT_CST_LOW (t);
5082}
5083#if NUM_POLY_INT_COEFFS == 1
5084extern inline __attribute__ ((__gnu_inline__)) poly_int64
5086{
5088 return TREE_INT_CST_LOW (t);
5089}
5090
5091extern inline __attribute__ ((__gnu_inline__)) poly_uint64
5093{
5095 return TREE_INT_CST_LOW (t);
5096}
5097#endif
5098#endif
5099extern int tree_int_cst_sgn (const_tree);
5101extern unsigned int tree_int_cst_min_precision (tree, signop);
5103
5104/* Recursively examines the array elements of TYPE, until a non-array
5105 element type is found. */
5106
5107inline tree
5109{
5110 while (TREE_CODE (type) == ARRAY_TYPE)
5111 type = TREE_TYPE (type);
5112
5113 return type;
5114}
5115
5116/* Recursively traverse down pointer type layers to pointee type. */
5117
5118inline const_tree
5120{
5121 while (POINTER_TYPE_P (type))
5122 type = TREE_TYPE (type);
5123
5124 return type;
5125}
5126
5127/* Desription of the reason why the argument of valid_constant_size_p
5128 is not a valid size. */
5136
5138extern tree max_object_size ();
5139
5140/* Return true if T holds a value that can be represented as a poly_int64
5141 without loss of precision. Store the value in *VALUE if so. */
5142
5143inline bool
5145{
5146 if (tree_fits_poly_int64_p (t))
5147 {
5148 *value = tree_to_poly_int64 (t);
5149 return true;
5150 }
5151 return false;
5152}
5153
5154/* Return true if T holds a value that can be represented as a poly_uint64
5155 without loss of precision. Store the value in *VALUE if so. */
5156
5157inline bool
5159{
5161 {
5162 *value = tree_to_poly_uint64 (t);
5163 return true;
5164 }
5165 return false;
5166}
5167
5168/* From expmed.cc. Since rtl.h is included after tree.h, we can't
5169 put the prototype here. Rtl.h does declare the prototype if
5170 tree.h had been included. */
5171
5172extern tree make_tree (tree, rtx);
5173
5174/* Returns true iff CAND and BASE have equivalent language-specific
5175 qualifiers. */
5176
5177extern bool check_lang_type (const_tree cand, const_tree base);
5178
5179/* Returns true iff unqualified CAND and BASE are equivalent. */
5180
5181extern bool check_base_type (const_tree cand, const_tree base);
5182
5183/* Check whether CAND is suitable to be returned from get_qualified_type
5184 (BASE, TYPE_QUALS). */
5185
5186extern bool check_qualified_type (const_tree, const_tree, int);
5187
5188/* Return a version of the TYPE, qualified as indicated by the
5189 TYPE_QUALS, if one exists. If no qualified version exists yet,
5190 return NULL_TREE. */
5191
5192extern tree get_qualified_type (tree, int);
5193
5194/* Like get_qualified_type, but creates the type if it does not
5195 exist. This function never returns NULL_TREE. */
5196
5198
5199/* Create a variant of type T with alignment ALIGN. */
5200
5201extern tree build_aligned_type (tree, unsigned int);
5202
5203/* Like build_qualified_type, but only deals with the `const' and
5204 `volatile' qualifiers. This interface is retained for backwards
5205 compatibility with the various front-ends; new code should use
5206 build_qualified_type instead. */
5207
5208#define build_type_variant(TYPE, CONST_P, VOLATILE_P) \
5209 build_qualified_type ((TYPE), \
5210 ((CONST_P) ? TYPE_QUAL_CONST : 0) \
5211 | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))
5212
5213/* Make a copy of a type node. */
5214
5217
5218/* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
5219 return a canonicalized ..._TYPE node, so that duplicates are not made.
5220 How the hash code is computed is up to the caller, as long as any two
5221 callers that could hash identical-looking type nodes agree. */
5222
5223extern hashval_t type_hash_canon_hash (tree);
5224extern tree type_hash_canon (unsigned int, tree);
5225
5227extern tree size_in_bytes_loc (location_t, const_tree);
5228inline tree
5233
5234extern HOST_WIDE_INT int_size_in_bytes (const_tree);
5235extern HOST_WIDE_INT max_int_size_in_bytes (const_tree);
5238extern HOST_WIDE_INT int_byte_position (const_tree);
5239
5240/* Type for sizes of data-type. */
5241
5242#define sizetype sizetype_tab[(int) stk_sizetype]
5243#define bitsizetype sizetype_tab[(int) stk_bitsizetype]
5244#define ssizetype sizetype_tab[(int) stk_ssizetype]
5245#define sbitsizetype sizetype_tab[(int) stk_sbitsizetype]
5246#define size_int(L) size_int_kind (L, stk_sizetype)
5247#define ssize_int(L) size_int_kind (L, stk_ssizetype)
5248#define bitsize_int(L) size_int_kind (L, stk_bitsizetype)
5249#define sbitsize_int(L) size_int_kind (L, stk_sbitsizetype)
5250
5251/* Log2 of BITS_PER_UNIT. */
5252
5253#if BITS_PER_UNIT == 8
5254#define LOG2_BITS_PER_UNIT 3
5255#elif BITS_PER_UNIT == 16
5256#define LOG2_BITS_PER_UNIT 4
5257#else
5258#error Unknown BITS_PER_UNIT
5259#endif
5260
5261/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
5262 by making the last node in X point to Y.
5263 Returns X, except if X is 0 returns Y. */
5264
5265extern tree chainon (tree, tree);
5266
5267/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
5268
5270
5271/* Return the last tree node in a chain. */
5272
5273extern tree tree_last (tree);
5274
5275/* Reverse the order of elements in a chain, and return the new head. */
5276
5277extern tree nreverse (tree);
5278
5279/* Returns the length of a chain of nodes
5280 (number of chain pointers to follow before reaching a null pointer). */
5281
5282extern int list_length (const_tree);
5283
5284/* Returns the first/last FIELD_DECL in a RECORD_TYPE. */
5285
5286extern tree first_field (const_tree) ATTRIBUTE_NONNULL (1);
5287extern tree last_field (const_tree) ATTRIBUTE_NONNULL (1);
5288
5289/* Given an initializer INIT, return TRUE if INIT is zero or some
5290 aggregate of zeros. Otherwise return FALSE. If NONZERO is not
5291 null, set *NONZERO if and only if INIT is known not to be all
5292 zeros. The combination of return value of false and *NONZERO
5293 false implies that INIT may but need not be all zeros. Other
5294 combinations indicate definitive answers. */
5295
5296extern bool initializer_zerop (const_tree, bool * = NULL);
5298
5299extern tree vector_cst_elt (const_tree, unsigned int);
5300
5301/* Given a vector VEC, return its first element if all elements are
5302 the same. Otherwise return NULL_TREE. */
5303
5305
5306/* If the argument is INTEGER_CST, return it. If the argument is vector
5307 with all elements the same INTEGER_CST, return that INTEGER_CST. Otherwise
5308 return NULL_TREE. */
5309
5311
5313
5314/* Given a CONSTRUCTOR CTOR, return the element values as a vector. */
5315
5317
5318/* zerop (tree x) is nonzero if X is a constant of value 0. */
5319
5320extern bool zerop (const_tree);
5321
5322/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0. */
5323
5324extern bool integer_zerop (const_tree);
5325
5326/* integer_onep (tree x) is nonzero if X is an integer constant of value 1. */
5327
5328extern bool integer_onep (const_tree);
5329
5330/* integer_onep (tree x) is nonzero if X is an integer constant of value 1, or
5331 a vector or complex where each part is 1. */
5332
5333extern bool integer_each_onep (const_tree);
5334
5335/* integer_all_onesp (tree x) is nonzero if X is an integer constant
5336 all of whose significant bits are 1. */
5337
5338extern bool integer_all_onesp (const_tree);
5339
5340/* integer_minus_onep (tree x) is nonzero if X is an integer constant of
5341 value -1. */
5342
5343extern bool integer_minus_onep (const_tree);
5344
5345/* integer_pow2p (tree x) is nonzero is X is an integer constant with
5346 exactly one bit 1. */
5347
5348extern bool integer_pow2p (const_tree);
5349
5350/* Checks to see if T is a constant or a constant vector and if each element E
5351 adheres to ~E + 1 == pow2 then return ~E otherwise NULL_TREE. */
5352
5354
5355/* integer_nonzerop (tree x) is nonzero if X is an integer constant
5356 with a nonzero value. */
5357
5358extern bool integer_nonzerop (const_tree);
5359
5360/* integer_truep (tree x) is nonzero if X is an integer constant of value 1 or
5361 a vector where each element is an integer constant of value -1. */
5362
5363extern bool integer_truep (const_tree);
5364
5365extern bool cst_and_fits_in_hwi (const_tree);
5367
5368/* fixed_zerop (tree x) is nonzero if X is a fixed-point constant of
5369 value 0. */
5370
5371extern bool fixed_zerop (const_tree);
5372
5373/* staticp (tree x) is nonzero if X is a reference to data allocated
5374 at a fixed address in memory. Returns the outermost data. */
5375
5376extern tree staticp (tree);
5377
5378/* save_expr (EXP) returns an expression equivalent to EXP
5379 but it can be used multiple times within context CTX
5380 and only evaluate EXP once. */
5381
5382extern tree save_expr (tree);
5383
5384/* Return true if T is an object with invariant address. */
5385
5386extern bool address_invariant_p (tree);
5387
5388/* Return true if T is function-invariant. */
5389
5390extern bool tree_invariant_p (tree);
5391
5392/* Look inside EXPR into any simple arithmetic operations. Return the
5393 outermost non-arithmetic or non-invariant node. */
5394
5396
5397/* Look inside EXPR into simple arithmetic operations involving constants.
5398 Return the outermost non-arithmetic or non-constant node. */
5399
5401
5402/* Return which tree structure is used by T. */
5403
5405
5406/* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
5407 size or offset that depends on a field within a record. */
5408
5410
5411/* This macro calls the above function but short-circuits the common
5412 case of a constant to save time. Also check for null. */
5413
5414#define CONTAINS_PLACEHOLDER_P(EXP) \
5415 ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
5416
5417/* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
5418 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
5419 field positions. */
5420
5421extern bool type_contains_placeholder_p (tree);
5422
5423/* Given a tree EXP, find all occurrences of references to fields
5424 in a PLACEHOLDER_EXPR and place them in vector REFS without
5425 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
5426 we assume here that EXP contains only arithmetic expressions
5427 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
5428 argument list. */
5429
5430extern void find_placeholder_in_expr (tree, vec<tree> *);
5431
5432/* This macro calls the above function but short-circuits the common
5433 case of a constant to save time and also checks for NULL. */
5434
5435#define FIND_PLACEHOLDER_IN_EXPR(EXP, V) \
5436do { \
5437 if((EXP) && !TREE_CONSTANT (EXP)) \
5438 find_placeholder_in_expr (EXP, V); \
5439} while (0)
5440
5441/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
5442 return a tree with all occurrences of references to F in a
5443 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
5444 CONST_DECLs. Note that we assume here that EXP contains only
5445 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
5446 occurring only in their argument list. */
5447
5449
5450/* This macro calls the above function but short-circuits the common
5451 case of a constant to save time and also checks for NULL. */
5452
5453#define SUBSTITUTE_IN_EXPR(EXP, F, R) \
5454 ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
5455
5456/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
5457 for it within OBJ, a tree that is an object or a chain of references. */
5458
5460
5461/* This macro calls the above function but short-circuits the common
5462 case of a constant to save time and also checks for NULL. */
5463
5464#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
5465 ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \
5466 : substitute_placeholder_in_expr (EXP, OBJ))
5467
5468
5469/* stabilize_reference (EXP) returns a reference equivalent to EXP
5470 but it can be used multiple times
5471 and only evaluate the subexpressions once. */
5472
5474
5475/* Return EXP, stripped of any conversions to wider types
5476 in such a way that the result of converting to type FOR_TYPE
5477 is the same as if EXP were converted to FOR_TYPE.
5478 If FOR_TYPE is 0, it signifies EXP's type. */
5479
5480extern tree get_unwidened (tree, tree);
5481
5482/* Return OP or a simpler expression for a narrower value
5483 which can be sign-extended or zero-extended to give back OP.
5484 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
5485 or 0 if the value should be sign-extended. */
5486
5487extern tree get_narrower (tree, int *);
5488
5489/* Return true if T is an expression that get_inner_reference handles. */
5490
5491inline bool
5493{
5494 switch (TREE_CODE (t))
5495 {
5496 case COMPONENT_REF:
5497 case BIT_FIELD_REF:
5498 case ARRAY_REF:
5499 case ARRAY_RANGE_REF:
5500 case REALPART_EXPR:
5501 case IMAGPART_EXPR:
5502 case VIEW_CONVERT_EXPR:
5503 return true;
5504
5505 default:
5506 return false;
5507 }
5508}
5509
5510/* Return true T is a component with reverse storage order. */
5511
5512inline bool
5514{
5515 /* The storage order only applies to scalar components. */
5516 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
5517 || POINTER_TYPE_P (TREE_TYPE (t))
5518 || VECTOR_TYPE_P (TREE_TYPE (t)))
5519 return false;
5520
5521 if (TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR)
5522 t = TREE_OPERAND (t, 0);
5523
5524 switch (TREE_CODE (t))
5525 {
5526 case ARRAY_REF:
5527 case COMPONENT_REF:
5528 /* ??? Fortran can take COMPONENT_REF of a VOID_TYPE. */
5529 /* ??? UBSan can take COMPONENT_REF of a REFERENCE_TYPE. */
5530 return AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0)))
5532
5533 case BIT_FIELD_REF:
5534 case MEM_REF:
5535 return REF_REVERSE_STORAGE_ORDER (t);
5536
5537 case ARRAY_RANGE_REF:
5538 case VIEW_CONVERT_EXPR:
5539 default:
5540 return false;
5541 }
5542}
5543
5544/* Return true if T is a storage order barrier, i.e. a VIEW_CONVERT_EXPR
5545 that can modify the storage order of objects. Note that, even if the
5546 TYPE_REVERSE_STORAGE_ORDER flag is set on both the inner type and the
5547 outer type, a VIEW_CONVERT_EXPR can modify the storage order because
5548 it can change the partition of the aggregate object into scalars. */
5549
5550inline bool
5552{
5553 if (TREE_CODE (t) != VIEW_CONVERT_EXPR)
5554 return false;
5555
5556 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
5558 return true;
5559
5560 tree op = TREE_OPERAND (t, 0);
5561
5562 if (AGGREGATE_TYPE_P (TREE_TYPE (op))
5564 return true;
5565
5567}
5568
5569/* Given a DECL or TYPE, return the scope in which it was declared, or
5570 NUL_TREE if there is no containing scope. */
5571
5573
5574/* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL. */
5575
5577
5578/* Return the FUNCTION_DECL which provides this _DECL with its context,
5579 or zero if none. */
5581
5582/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
5583 this _DECL with its context, or zero if none. */
5585
5586/* Return true if EXPR is the real constant zero. */
5587extern bool real_zerop (const_tree);
5588
5589/* Initialize the iterator I with arguments from function FNDECL */
5590
5591inline void
5592function_args_iter_init (function_args_iterator *i, const_tree fntype)
5593{
5594 i->next = TYPE_ARG_TYPES (fntype);
5595}
5596
5597/* Return a pointer that holds the next argument if there are more arguments to
5598 handle, otherwise return NULL. */
5599
5600inline tree *
5601function_args_iter_cond_ptr (function_args_iterator *i)
5602{
5603 return (i->next) ? &TREE_VALUE (i->next) : NULL;
5604}
5605
5606/* Return the next argument if there are more arguments to handle, otherwise
5607 return NULL. */
5608
5609inline tree
5610function_args_iter_cond (function_args_iterator *i)
5611{
5612 return (i->next) ? TREE_VALUE (i->next) : NULL_TREE;
5613}
5614
5615/* Advance to the next argument. */
5616inline void
5617function_args_iter_next (function_args_iterator *i)
5618{
5619 gcc_assert (i->next != NULL_TREE);
5620 i->next = TREE_CHAIN (i->next);
5621}
5622
5623/* Returns true if a BLOCK has a source location.
5624 BLOCK_SOURCE_LOCATION is set only to inlined function entry points,
5625 so the function returns true for all but the innermost and outermost
5626 blocks into which an expression has been inlined. */
5627
5628inline bool
5633
5634/* Loop over all function arguments of FNTYPE. In each iteration, PTR is set
5635 to point to the next tree element. ITER is an instance of
5636 function_args_iterator used to iterate the arguments. */
5637#define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER) \
5638 for (function_args_iter_init (&(ITER), (FNTYPE)); \
5639 (PTR = function_args_iter_cond_ptr (&(ITER))) != NULL; \
5640 function_args_iter_next (&(ITER)))
5641
5642/* Loop over all function arguments of FNTYPE. In each iteration, TREE is set
5643 to the next tree element. ITER is an instance of function_args_iterator
5644 used to iterate the arguments. */
5645#define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER) \
5646 for (function_args_iter_init (&(ITER), (FNTYPE)); \
5647 (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE; \
5648 function_args_iter_next (&(ITER)))
5649
5650/* In tree.cc */
5651extern unsigned crc32_unsigned_n (unsigned, unsigned, unsigned);
5652extern unsigned crc32_string (unsigned, const char *);
5653inline unsigned
5654crc32_unsigned (unsigned chksum, unsigned value)
5655{
5656 return crc32_unsigned_n (chksum, value, 4);
5657}
5658inline unsigned
5659crc32_byte (unsigned chksum, char byte)
5660{
5661 return crc32_unsigned_n (chksum, byte, 1);
5662}
5663extern void clean_symbol_name (char *);
5664extern tree get_file_function_name (const char *);
5667extern int type_num_arguments (const_tree);
5668extern tree type_argument_type (const_tree, unsigned) ATTRIBUTE_NONNULL (1);
5669extern bool associative_tree_code (enum tree_code);
5670extern bool commutative_tree_code (enum tree_code);
5671extern bool commutative_ternary_tree_code (enum tree_code);
5672extern bool operation_can_overflow (enum tree_code);
5677extern tree create_artificial_label (location_t);
5678extern const char *get_name (tree);
5679extern bool stdarg_p (const_tree);
5680extern bool prototype_p (const_tree);
5681extern bool auto_var_p (const_tree);
5683extern tree build_low_bits_mask (tree, unsigned);
5689extern tree lhd_gcc_personality (void);
5691extern bool warn_deprecated_use (tree, tree);
5692extern void error_unavailable_use (tree, tree);
5693extern tree cache_integer_cst (tree, bool might_duplicate = false);
5694extern const char *combined_fn_name (combined_fn);
5695
5696/* Returns true if X is a typedef decl. */
5697
5698inline bool
5700{
5701 return (x && TREE_CODE (x) == TYPE_DECL
5702 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
5703}
5704
5705/* Returns true iff TYPE is a type variant created for a typedef. */
5706
5707inline bool
5712
5713/* Compare and hash for any structure which begins with a canonical
5714 pointer. Assumes all pointers are interchangeable, which is sort
5715 of already assumed by gcc elsewhere IIRC. */
5716
5717inline int
5718struct_ptr_eq (const void *a, const void *b)
5719{
5720 const void * const * x = (const void * const *) a;
5721 const void * const * y = (const void * const *) b;
5722 return *x == *y;
5723}
5724
5725inline hashval_t
5726struct_ptr_hash (const void *a)
5727{
5728 const void * const * x = (const void * const *) a;
5729 return (intptr_t)*x >> 4;
5730}
5731
5732/* Return true if CODE can be treated as a truncating division.
5733
5734 EXACT_DIV_EXPR can be treated as a truncating division in which the
5735 remainder is known to be zero. However, if trunc_div_p gates the
5736 generation of new IL, the conservative choice for that new IL is
5737 TRUNC_DIV_EXPR rather than CODE. Using CODE (EXACT_DIV_EXPR) would
5738 only be correct if the transformation preserves exactness. */
5739inline bool
5741{
5742 return code == TRUNC_DIV_EXPR || code == EXACT_DIV_EXPR;
5743}
5744
5745/* Return nonzero if CODE is a tree code that represents a truth value. */
5746inline bool
5748{
5749 return (TREE_CODE_CLASS (code) == tcc_comparison
5750 || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
5751 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
5752 || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
5753}
5754
5755/* Return whether TYPE is a type suitable for an offset for
5756 a POINTER_PLUS_EXPR. */
5757inline bool
5764
5765/* Return true if the argument is a complete type or an array
5766 of unknown bound (whose type is incomplete but) whose elements
5767 have complete type. */
5768inline bool
5770{
5771 return COMPLETE_TYPE_P (type)
5772 || (TREE_CODE (type) == ARRAY_TYPE
5774}
5775
5776/* Return true if the value of T could be represented as a poly_widest_int. */
5777
5778inline bool
5780{
5781 return (TREE_CODE (t) == INTEGER_CST || POLY_INT_CST_P (t));
5782}
5783
5784/* Return the bit size of BIT_FIELD_REF T, in cases where it is known
5785 to be a poly_uint64. (This is always true at the gimple level.) */
5786
5787inline poly_uint64
5789{
5790 return tree_to_poly_uint64 (TREE_OPERAND (t, 1));
5791}
5792
5793/* Return the starting bit offset of BIT_FIELD_REF T, in cases where it is
5794 known to be a poly_uint64. (This is always true at the gimple level.) */
5795
5796inline poly_uint64
5798{
5799 return tree_to_poly_uint64 (TREE_OPERAND (t, 2));
5800}
5801
5803extern bool really_constant_p (const_tree);
5804extern bool ptrdiff_tree_p (const_tree, poly_int64 *);
5808 ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2) ATTRIBUTE_PURE;
5809#ifndef GENERATOR_FILE
5810extern void get_type_static_bounds (const_tree, mpz_t, mpz_t);
5811#endif
5812extern bool variably_modified_type_p (tree, tree);
5813extern int tree_log2 (const_tree);
5814extern int tree_floor_log2 (const_tree);
5815extern unsigned int tree_ctz (const_tree);
5817
5818namespace inchash
5819{
5820
5821extern void add_expr (const_tree, hash &, unsigned int = 0);
5822
5823}
5824
5825/* Compat version until all callers are converted. Return hash for
5826 TREE with SEED. */
5827inline hashval_t iterative_hash_expr(const_tree tree, hashval_t seed)
5828{
5829 inchash::hash hstate (seed);
5830 inchash::add_expr (tree, hstate);
5831 return hstate.end ();
5832}
5833
5834extern int compare_tree_int (const_tree, unsigned HOST_WIDE_INT);
5836extern bool chain_member (const_tree, const_tree);
5837extern void dump_tree_statistics (void);
5841extern bool real_onep (const_tree);
5842extern bool real_minus_onep (const_tree);
5843extern bool real_maybe_zerop (const_tree);
5844extern void init_ttree (void);
5845extern void build_common_tree_nodes (bool);
5846extern void build_common_builtin_nodes (void);
5847extern void tree_cc_finalize (void);
5848extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int);
5849extern tree build_nonstandard_boolean_type (unsigned HOST_WIDE_INT);
5850extern tree build_bitint_type (unsigned HOST_WIDE_INT, int);
5853extern bool subrange_type_for_debug_p (const_tree, tree *, tree *);
5854extern HOST_WIDE_INT int_cst_value (const_tree);
5855extern tree tree_block (tree);
5856extern void tree_set_block (tree, tree);
5857extern location_t *block_nonartificial_location (tree);
5858extern location_t tree_nonartificial_location (tree);
5859extern location_t tree_inlined_location (tree, bool = true);
5862extern bool virtual_method_call_p (const_tree, bool = false);
5863extern tree obj_type_ref_class (const_tree ref, bool = false);
5864extern bool types_same_for_odr (const_tree type1, const_tree type2);
5866extern bool block_may_fallthru (const_tree);
5867extern void using_eh_for_cleanups (void);
5868extern bool using_eh_for_cleanups_p (void);
5869extern const char *get_tree_code_name (enum tree_code);
5870extern void set_call_expr_flags (tree, int);
5872 walk_tree_lh);
5874 walk_tree_lh);
5875#define walk_tree(a,b,c,d) \
5876 walk_tree_1 (a, b, c, d, NULL)
5877#define walk_tree_without_duplicates(a,b,c) \
5878 walk_tree_without_duplicates_1 (a, b, c, NULL)
5879
5881
5882/* Given a memory reference expression T, return its base address.
5883 The base address of a memory reference expression is the main
5884 object being referenced. */
5885extern tree get_base_address (tree t);
5886
5887/* Return a tree of sizetype representing the size, in bytes, of the element
5888 of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
5890
5891/* Return a typenode for the "standard" C type with a given name. */
5892extern tree get_typenode_from_name (const char *);
5893
5894/* Return a tree representing the upper bound of the array mentioned in
5895 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
5897
5898/* Return a tree representing the lower bound of the array mentioned in
5899 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
5901
5902/* Returns true if REF is an array reference, a component reference,
5903 or a memory reference to an array whose actual size might be larger
5904 than its upper bound implies. */
5905extern bool array_ref_flexible_size_p (tree, bool * = NULL);
5906
5907/* Return a tree representing the offset, in bytes, of the field referenced
5908 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
5910
5911/* Describes a "special" array member for a COMPONENT_REF. */
5913 {
5914 none, /* Not a special array member. */
5915 int_0, /* Interior array member with zero elements. */
5916 trail_0, /* Trailing array member with zero elements. */
5917 trail_1, /* Trailing array member with one element. */
5918 trail_n, /* Trailing array member with two or more elements. */
5919 int_n /* Interior array member with one or more elements. */
5920 };
5921
5922/* Determines the special array member type for a COMPONENT_REF. */
5924
5925/* Return the size of the member referenced by the COMPONENT_REF, using
5926 its initializer expression if necessary in order to determine the size
5927 of an initialized flexible array member. The size might be zero for
5928 an object with an uninitialized flexible array member or null if it
5929 cannot be determined. */
5931
5932/* Return true if the given node is a call to a .ACCESS_WITH_SIZE
5933 function. */
5934extern bool is_access_with_size_p (const_tree);
5935
5936/* Get the corresponding reference from the call to a .ACCESS_WITH_SIZE,
5937 * i.e. the first argument of this call. Return NULL_TREE otherwise. */
5939
5940extern int tree_map_base_eq (const void *, const void *);
5941extern unsigned int tree_map_base_hash (const void *);
5942extern bool tree_map_base_marked_p (const void *);
5943extern void DEBUG_FUNCTION verify_type (const_tree t);
5945 bool trust_type_canonical = true);
5948extern int get_range_pos_neg (tree, gimple * = NULL);
5949
5950/* Return true for a valid pair of new and delete operators. */
5951extern bool valid_new_delete_pair_p (tree, tree, bool * = NULL);
5952
5953/* Return simplified tree code of type that is used for canonical type
5954 merging. */
5955inline enum tree_code
5957{
5958 /* By C standard, each enumerated type shall be compatible with char,
5959 a signed integer, or an unsigned integer. The choice of type is
5960 implementation defined (in our case it depends on -fshort-enum).
5961
5962 For this reason we make no distinction between ENUMERAL_TYPE and INTEGER
5963 type and compare only by their signedness and precision. */
5964 if (code == ENUMERAL_TYPE)
5965 return INTEGER_TYPE;
5966 /* To allow inter-operability between languages having references and
5967 C, we consider reference types and pointers alike. Note that this is
5968 not strictly necessary for C-Fortran 2008 interoperability because
5969 Fortran define C_PTR type that needs to be compatible with C pointers
5970 and we handle this one as ptr_type_node. */
5971 if (code == REFERENCE_TYPE)
5972 return POINTER_TYPE;
5973 return code;
5974}
5975
5976/* Return true if get_alias_set care about TYPE_CANONICAL of given type.
5977 We don't define the types for pointers, arrays and vectors. The reason is
5978 that pointers are handled specially: ptr_type_node accesses conflict with
5979 accesses to all other pointers. This is done by alias.cc.
5980 Because alias sets of arrays and vectors are the same as types of their
5981 elements, we can't compute canonical type either. Otherwise we could go
5982 form void *[10] to int *[10] (because they are equivalent for canonical type
5983 machinery) and get wrong TBAA. */
5984
5985inline bool
5987{
5988 return !(POINTER_TYPE_P (t)
5989 || TREE_CODE (t) == ARRAY_TYPE
5990 || TREE_CODE (t) == VECTOR_TYPE);
5991}
5992
5993/* Kinds of access to pass-by-reference arguments to functions. */
6002
6003#define tree_map_eq tree_map_base_eq
6004extern unsigned int tree_map_hash (const void *);
6005#define tree_map_marked_p tree_map_base_marked_p
6006
6007#define tree_decl_map_eq tree_map_base_eq
6008extern unsigned int tree_decl_map_hash (const void *);
6009#define tree_decl_map_marked_p tree_map_base_marked_p
6010
6012{
6013 static hashval_t hash (tree_decl_map *m) { return tree_decl_map_hash (m); }
6014 static bool
6015 equal (tree_decl_map *a, tree_decl_map *b)
6016 {
6017 return tree_decl_map_eq (a, b);
6018 }
6019
6020 static int
6021 keep_cache_entry (tree_decl_map *&m)
6022 {
6023 return ggc_marked_p (m->base.from);
6024 }
6025};
6026
6027#define tree_int_map_eq tree_map_base_eq
6028#define tree_int_map_hash tree_map_base_hash
6029#define tree_int_map_marked_p tree_map_base_marked_p
6030
6031#define tree_vec_map_eq tree_map_base_eq
6032#define tree_vec_map_hash tree_decl_map_hash
6033#define tree_vec_map_marked_p tree_map_base_marked_p
6034
6036{
6037 static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
6038
6039 static bool
6040 equal (tree_vec_map *a, tree_vec_map *b)
6041 {
6042 return a->base.from == b->base.from;
6043 }
6044
6045 static int
6046 keep_cache_entry (tree_vec_map *&m)
6047 {
6048 return ggc_marked_p (m->base.from);
6049 }
6050};
6051
6052/* Hasher for tree decls. Pointer equality is enough here, but the DECL_UID
6053 is a better hash than the pointer value and gives a predictable traversal
6054 order. Additionally it can be used across PCH save/restore. */
6055struct tree_decl_hash : ggc_ptr_hash <tree_node>
6056{
6057 static inline hashval_t hash (tree);
6058};
6059
6060inline hashval_t
6062{
6063 return DECL_UID (t);
6064}
6065
6066/* Similarly for types. Uses TYPE_UID as hash function. */
6067struct tree_type_hash : ggc_ptr_hash <tree_node>
6068{
6069 static inline hashval_t hash (tree);
6070};
6071
6072inline hashval_t
6074{
6075 return TYPE_UID (t);
6076}
6077
6078/* Hash for SSA_NAMEs in the same function. Pointer equality is enough
6079 here, but the SSA_NAME_VERSION is a better hash than the pointer
6080 value and gives a predictable traversal order. */
6082{
6083 static inline hashval_t hash (tree);
6084};
6085
6086inline hashval_t
6088{
6089 return SSA_NAME_VERSION (t);
6090}
6091
6092/* Hasher for general trees, based on their TREE_HASH. */
6093struct tree_hash : ggc_ptr_hash <tree_node>
6094{
6095 static hashval_t hash (tree);
6096};
6097
6098inline hashval_t
6100{
6101 return TREE_HASH (t);
6102}
6103
6104/* A hash_map of two trees for use with GTY((cache)). Garbage collection for
6105 such a map will not mark keys, and will mark values if the key is already
6106 marked. */
6107struct tree_cache_traits
6108 : simple_cache_map_traits<default_hash_traits<tree>, tree> { };
6109typedef hash_map<tree,tree,tree_cache_traits> tree_cache_map;
6110
6111/* Similarly, but use DECL_UID as hash function rather than pointer hashing.
6112 This is for hash_maps from decls to trees that need to work across PCH. */
6113struct decl_tree_cache_traits
6114 : simple_cache_map_traits<tree_decl_hash, tree> { };
6115typedef hash_map<tree,tree,decl_tree_cache_traits> decl_tree_cache_map;
6116
6117/* Similarly, but use TYPE_UID as hash function rather than pointer hashing.
6118 This is for hash_maps from types to trees that need to work across PCH. */
6119struct type_tree_cache_traits
6120 : simple_cache_map_traits<tree_type_hash, tree> { };
6121typedef hash_map<tree,tree,type_tree_cache_traits> type_tree_cache_map;
6123/* Similarly to decl_tree_cache_map, but without caching. */
6124struct decl_tree_traits
6125 : simple_hashmap_traits<tree_decl_hash, tree> { };
6126typedef hash_map<tree,tree,decl_tree_traits> decl_tree_map;
6127
6128/* Initialize the abstract argument list iterator object ITER with the
6129 arguments from CALL_EXPR node EXP. */
6130inline void
6131init_call_expr_arg_iterator (tree exp, call_expr_arg_iterator *iter)
6132{
6133 iter->t = exp;
6134 iter->n = call_expr_nargs (exp);
6135 iter->i = 0;
6136}
6137
6138inline void
6139init_const_call_expr_arg_iterator (const_tree exp, const_call_expr_arg_iterator *iter)
6140{
6141 iter->t = exp;
6142 iter->n = call_expr_nargs (exp);
6143 iter->i = 0;
6144}
6146/* Return the next argument from abstract argument list iterator object ITER,
6147 and advance its state. Return NULL_TREE if there are no more arguments. */
6148inline tree
6149next_call_expr_arg (call_expr_arg_iterator *iter)
6150{
6151 tree result;
6152 if (iter->i >= iter->n)
6153 return NULL_TREE;
6154 result = CALL_EXPR_ARG (iter->t, iter->i);
6155 iter->i++;
6156 return result;
6158
6159inline const_tree
6160next_const_call_expr_arg (const_call_expr_arg_iterator *iter)
6161{
6162 const_tree result;
6163 if (iter->i >= iter->n)
6164 return NULL_TREE;
6165 result = CALL_EXPR_ARG (iter->t, iter->i);
6166 iter->i++;
6167 return result;
6168}
6169
6170/* Initialize the abstract argument list iterator object ITER, then advance
6171 past and return the first argument. Useful in for expressions, e.g.
6172 for (arg = first_call_expr_arg (exp, &iter); arg;
6173 arg = next_call_expr_arg (&iter)) */
6174inline tree
6175first_call_expr_arg (tree exp, call_expr_arg_iterator *iter)
6176{
6177 init_call_expr_arg_iterator (exp, iter);
6178 return next_call_expr_arg (iter);
6179}
6180
6181inline const_tree
6182first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter)
6183{
6184 init_const_call_expr_arg_iterator (exp, iter);
6185 return next_const_call_expr_arg (iter);
6187
6188/* Test whether there are more arguments in abstract argument list iterator
6189 ITER, without changing its state. */
6190inline bool
6191more_call_expr_args_p (const call_expr_arg_iterator *iter)
6192{
6193 return (iter->i < iter->n);
6194}
6195
6196/* Iterate through each argument ARG of CALL_EXPR CALL, using variable ITER
6197 (of type call_expr_arg_iterator) to hold the iteration state. */
6198#define FOR_EACH_CALL_EXPR_ARG(arg, iter, call) \
6199 for ((arg) = first_call_expr_arg ((call), &(iter)); (arg); \
6200 (arg) = next_call_expr_arg (&(iter)))
6202#define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call) \
6203 for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg); \
6204 (arg) = next_const_call_expr_arg (&(iter)))
6205
6206/* Return true if tree node T is a language-specific node. */
6207inline bool
6209{
6210 return TREE_CODE (t) == LANG_TYPE || TREE_CODE (t) >= NUM_TREE_CODES;
6211}
6212
6213/* Valid builtin number. */
6214#define BUILTIN_VALID_P(FNCODE) \
6215 (IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1))
6216
6217/* Obtain a pointer to the identifier string holding the asm name for
6218 BUILTIN, a BUILT_IN code. This is handy if the target
6219 mangles/overrides the function name that implements the
6220 builtin. */
6221#define BUILTIN_ASM_NAME_PTR(BUILTIN) \
6222 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (builtin_decl_explicit (BUILTIN))))
6223
6224/* Return the tree node for an explicit standard builtin function or NULL. */
6225inline tree
6227{
6229
6230 return builtin_info[(size_t)fncode].decl;
6231}
6232
6233/* Return the tree node for an implicit builtin function or NULL. */
6234inline tree
6236{
6237 size_t uns_fncode = (size_t)fncode;
6239
6240 if (!builtin_info[uns_fncode].implicit_p)
6241 return NULL_TREE;
6242
6243 return builtin_info[uns_fncode].decl;
6244}
6245
6246/* For BUILTIN_UNREACHABLE, use one of these or
6247 gimple_build_builtin_unreachable instead of one of the above. */
6250
6251/* Set explicit builtin function nodes and whether it is an implicit
6252 function. */
6253
6254inline void
6255set_builtin_decl (enum built_in_function fncode, tree decl, bool implicit_p)
6256{
6257 size_t ufncode = (size_t)fncode;
6258
6260 && (decl != NULL_TREE || !implicit_p));
6261
6262 builtin_info[ufncode].decl = decl;
6263 builtin_info[ufncode].implicit_p = implicit_p;
6264 builtin_info[ufncode].declared_p = false;
6265}
6266
6267/* Set the implicit flag for a builtin function. */
6268
6269inline void
6270set_builtin_decl_implicit_p (enum built_in_function fncode, bool implicit_p)
6271{
6272 size_t uns_fncode = (size_t)fncode;
6273
6275 && builtin_info[uns_fncode].decl != NULL_TREE);
6276
6277 builtin_info[uns_fncode].implicit_p = implicit_p;
6278}
6279
6280/* Set the declared flag for a builtin function. */
6281
6282inline void
6283set_builtin_decl_declared_p (enum built_in_function fncode, bool declared_p)
6284{
6285 size_t uns_fncode = (size_t)fncode;
6286
6288 && builtin_info[uns_fncode].decl != NULL_TREE);
6289
6290 builtin_info[uns_fncode].declared_p = declared_p;
6291}
6292
6293/* Return whether the standard builtin function can be used as an explicit
6294 function. */
6295
6296inline bool
6298{
6300 return (builtin_info[(size_t)fncode].decl != NULL_TREE);
6301}
6302
6303/* Return whether the standard builtin function can be used implicitly. */
6304
6305inline bool
6307{
6308 size_t uns_fncode = (size_t)fncode;
6309
6311 return (builtin_info[uns_fncode].decl != NULL_TREE
6312 && builtin_info[uns_fncode].implicit_p);
6313}
6314
6315/* Return whether the standard builtin function was declared. */
6316
6317inline bool
6319{
6320 size_t uns_fncode = (size_t)fncode;
6323 return (builtin_info[uns_fncode].decl != NULL_TREE
6324 && builtin_info[uns_fncode].declared_p);
6325}
6326
6327/* Determine if the function identified by FNDECL is one that
6328 makes sense to match by name, for those places where we detect
6329 "magic" functions by name.
6330
6331 Return true if FNDECL has a name and is an extern fndecl at file scope.
6332 FNDECL must be a non-NULL decl.
6333
6334 Avoid using this, as it's generally better to use attributes rather
6335 than to check for functions by name. */
6336
6337inline bool
6339{
6340 tree name_decl = DECL_NAME (fndecl);
6341 if (name_decl
6342 /* Exclude functions not at the file scope, or not `extern',
6343 since they are not the magic functions we would otherwise
6344 think they are. */
6345 && (DECL_CONTEXT (fndecl) == NULL_TREE
6346 || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
6347 && TREE_PUBLIC (fndecl))
6348 return true;
6349 return false;
6350}
6351
6352/* Return true if T (assumed to be a DECL) is a global variable.
6353 A variable is considered global if its storage is not automatic. */
6355inline bool
6357{
6358 return (TREE_STATIC (t) || DECL_EXTERNAL (t));
6359}
6361/* Return true if VAR may be aliased. A variable is considered as
6362 maybe aliased if it has its address taken by the local TU
6363 or possibly by another TU and might be modified through a pointer. */
6364
6365inline bool
6368 return (TREE_CODE (var) != CONST_DECL
6369 && (TREE_PUBLIC (var)
6371 || TREE_ADDRESSABLE (var))
6372 && !((TREE_STATIC (var) || TREE_PUBLIC (var) || DECL_EXTERNAL (var))
6374 || (TREE_CODE (var) == VAR_DECL
6375 && DECL_NONALIASED (var)))));
6378/* Return pointer to optimization flags of FNDECL. */
6379inline struct cl_optimization *
6380opts_for_fn (const_tree fndecl)
6381{
6382 tree fn_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
6383 if (fn_opts == NULL_TREE)
6384 fn_opts = optimization_default_node;
6385 return TREE_OPTIMIZATION (fn_opts);
6386}
6388/* Return pointer to target flags of FNDECL. */
6389inline cl_target_option *
6391{
6392 tree fn_opts = DECL_FUNCTION_SPECIFIC_TARGET (fndecl);
6393 if (fn_opts == NULL_TREE)
6395 return fn_opts == NULL_TREE ? NULL : TREE_TARGET_OPTION (fn_opts);
6398/* opt flag for function FNDECL, e.g. opts_for_fn (fndecl, optimize) is
6399 the optimization level of function fndecl. */
6400#define opt_for_fn(fndecl, opt) (opts_for_fn (fndecl)->x_##opt)
6401
6402/* For anonymous aggregate types, we need some sort of name to
6403 hold on to. In practice, this should not appear, but it should
6404 not be harmful if it does. Identifiers returned will be
6405 IDENTIFIER_ANON_P. */
6406extern tree make_anon_name ();
6407
6408/* The tree and const_tree overload templates. */
6409namespace wi
6410{
6412 {
6413 private:
6415
6416 public:
6417 unextended_tree () {}
6418 unextended_tree (const_tree t) : m_t (t) {}
6419
6420 unsigned int get_precision () const;
6421 const HOST_WIDE_INT *get_val () const;
6422 unsigned int get_len () const;
6423 const_tree get_tree () const { return m_t; }
6425
6426 template <>
6429 static const enum precision_type precision_type = VAR_PRECISION;
6430 static const bool host_dependent_precision = false;
6431 static const bool is_sign_extended = false;
6432 static const bool needs_write_val_arg = false;
6433 };
6434
6435 template <int N>
6436 class extended_tree
6438 private:
6440
6441 public:
6442 extended_tree () {}
6444
6445 unsigned int get_precision () const;
6446 const HOST_WIDE_INT *get_val () const;
6447 unsigned int get_len () const;
6448 const_tree get_tree () const { return m_t; }
6449 };
6450
6451 template <int N>
6452 struct int_traits <extended_tree <N> >
6453 {
6454 static const enum precision_type precision_type
6456 static const bool host_dependent_precision = false;
6457 static const bool is_sign_extended = true;
6458 static const bool needs_write_val_arg = false;
6459 static const unsigned int precision = N;
6460 };
6461
6462 typedef extended_tree <WIDEST_INT_MAX_PRECISION> widest_extended_tree;
6463 typedef extended_tree <ADDR_MAX_PRECISION> offset_extended_tree;
6464
6465 typedef const generic_wide_int <widest_extended_tree> tree_to_widest_ref;
6466 typedef const generic_wide_int <offset_extended_tree> tree_to_offset_ref;
6467 typedef const generic_wide_int<wide_int_ref_storage<false, false> >
6469
6473 wide_int to_wide (const_tree, unsigned int);
6474
6475 typedef const poly_int <NUM_POLY_INT_COEFFS,
6476 generic_wide_int <widest_extended_tree> >
6478 typedef const poly_int <NUM_POLY_INT_COEFFS,
6479 generic_wide_int <offset_extended_tree> >
6481 typedef const poly_int <NUM_POLY_INT_COEFFS,
6482 generic_wide_int <unextended_tree> >
6484
6488
6489 template <int N>
6491 {
6492 typedef generic_wide_int <extended_tree <N> > extended;
6493 static extended zero (const extended &);
6494 };
6495
6496 template <int N>
6497 struct ints_for <generic_wide_int <extended_tree <N> >, CONST_PRECISION>
6498 {
6499 typedef generic_wide_int <extended_tree <N> > extended;
6500 static extended zero (const extended &);
6501 };
6502
6503 template <>
6504 struct ints_for <generic_wide_int <unextended_tree>, VAR_PRECISION>
6505 {
6506 typedef generic_wide_int <unextended_tree> unextended;
6507 static unextended zero (const unextended &);
6508 };
6509}
6510
6511/* Used to convert a tree to a widest2_int like this:
6512 widest2_int foo = widest2_int_cst (some_tree). */
6513typedef generic_wide_int <wi::extended_tree <WIDEST_INT_MAX_PRECISION * 2> >
6515
6516/* Refer to INTEGER_CST T as though it were a widest_int.
6517
6518 This function gives T's actual numerical value, influenced by the
6519 signedness of its type. For example, a signed byte with just the
6520 top bit set would be -128 while an unsigned byte with the same
6521 bit pattern would be 128.
6522
6523 This is the right choice when operating on groups of INTEGER_CSTs
6524 that might have different signedness or precision. It is also the
6525 right choice in code that specifically needs an approximation of
6526 infinite-precision arithmetic instead of normal modulo arithmetic.
6527
6528 The approximation of infinite precision is good enough for realistic
6529 numbers of additions and subtractions of INTEGER_CSTs (where
6530 "realistic" includes any number less than 1 << 31) but it cannot
6531 represent the result of multiplying the two largest supported
6532 INTEGER_CSTs. The overflow-checking form of wi::mul provides a way
6533 of multiplying two arbitrary INTEGER_CSTs and checking that the
6534 result is representable as a widest_int.
6535
6536 Note that any overflow checking done on these values is relative to
6537 the range of widest_int rather than the range of a TREE_TYPE.
6538
6539 Calling this function should have no overhead in release builds,
6540 so it is OK to call it several times for the same tree. If it is
6541 useful for readability reasons to reduce the number of calls,
6542 it is more efficient to use:
6543
6544 wi::tree_to_widest_ref wt = wi::to_widest (t);
6545
6546 instead of:
6547
6548 widest_int wt = wi::to_widest (t). */
6549
6552{
6553 return t;
6555
6556/* Refer to INTEGER_CST T as though it were an offset_int.
6557
6558 This function is an optimisation of wi::to_widest for cases
6559 in which T is known to be a bit or byte count in the range
6560 (-(2 ^ (N + BITS_PER_UNIT)), 2 ^ (N + BITS_PER_UNIT)), where N is
6561 the target's address size in bits.
6563 This is the right choice when operating on bit or byte counts as
6564 untyped numbers rather than M-bit values. The wi::to_widest comments
6565 about addition, subtraction and multiplication apply here: sequences
6566 of 1 << 31 additions and subtractions do not induce overflow, but
6567 multiplying the largest sizes might. Again,
6568
6569 wi::tree_to_offset_ref wt = wi::to_offset (t);
6570
6571 is more efficient than:
6572
6573 offset_int wt = wi::to_offset (t). */
6574
6577{
6578 return t;
6579}
6580
6581/* Refer to INTEGER_CST T as though it were a wide_int.
6582
6583 In contrast to the approximation of infinite-precision numbers given
6584 by wi::to_widest and wi::to_offset, this function treats T as a
6585 signless collection of N bits, where N is the precision of T's type.
6586 As with machine registers, signedness is determined by the operation
6587 rather than the operands; for example, there is a distinction between
6588 signed and unsigned division.
6589
6590 This is the right choice when operating on values with the same type
6591 using normal modulo arithmetic. The overflow-checking forms of things
6592 like wi::add check whether the result can be represented in T's type.
6593
6594 Calling this function should have no overhead in release builds,
6595 so it is OK to call it several times for the same tree. If it is
6596 useful for readability reasons to reduce the number of calls,
6597 it is more efficient to use:
6599 wi::tree_to_wide_ref wt = wi::to_wide (t);
6600
6601 instead of:
6602
6603 wide_int wt = wi::to_wide (t). */
6611
6612/* Convert INTEGER_CST T to a wide_int of precision PREC, extending or
6613 truncating as necessary. When extending, use sign extension if T's
6614 type is signed and zero extension if T's type is unsigned. */
6615
6616inline wide_int
6617wi::to_wide (const_tree t, unsigned int prec)
6619 return wide_int::from (wi::to_wide (t), prec, TYPE_SIGN (TREE_TYPE (t)));
6620}
6621
6622template <int N>
6624 : m_t (t)
6625{
6627}
6628
6629template <int N>
6630inline unsigned int
6632{
6633 return N;
6634}
6635
6636template <int N>
6637inline const HOST_WIDE_INT *
6639{
6640 return &TREE_INT_CST_ELT (m_t, 0);
6641}
6642
6643template <int N>
6644inline unsigned int
6646{
6648 {
6649 /* to_offset can only be applied to trees that are offset_int-sized
6650 or smaller. EXT_LEN is correct if it fits, otherwise the constant
6651 must be exactly the precision of offset_int and so LEN is correct. */
6652 unsigned int ext_len = TREE_INT_CST_EXT_NUNITS (m_t);
6653 if (ext_len <= OFFSET_INT_ELTS)
6654 return ext_len;
6655 return TREE_INT_CST_NUNITS (m_t);
6656 }
6657 else if (N >= WIDEST_INT_MAX_PRECISION)
6658 return TREE_INT_CST_EXT_NUNITS (m_t);
6659 else
6660 /* This class is designed to be used for specific output precisions
6661 and needs to be as fast as possible, so there is no fallback for
6662 other casees. */
6663 gcc_unreachable ();
6665
6666inline unsigned int
6668{
6669 return TYPE_PRECISION (TREE_TYPE (m_t));
6670}
6671
6672inline const HOST_WIDE_INT *
6674{
6675 return &TREE_INT_CST_ELT (m_t, 0);
6676}
6677
6678inline unsigned int
6680{
6681 return TREE_INT_CST_NUNITS (m_t);
6682}
6683
6684/* Return the value of a POLY_INT_CST in its native precision. */
6685
6688{
6689 poly_int <NUM_POLY_INT_COEFFS, generic_wide_int <wi::unextended_tree> > res;
6690 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
6691 res.coeffs[i] = POLY_INT_CST_COEFF (x, i);
6692 return res;
6693}
6694
6695/* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
6696 poly_widest_int. See wi::to_widest for more details. */
6697
6700{
6701 if (POLY_INT_CST_P (t))
6702 {
6703 poly_int <NUM_POLY_INT_COEFFS,
6704 generic_wide_int <widest_extended_tree> > res;
6705 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
6706 res.coeffs[i] = POLY_INT_CST_COEFF (t, i);
6707 return res;
6708 }
6709 return t;
6710}
6712/* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
6713 poly_offset_int. See wi::to_offset for more details. */
6714
6717{
6718 if (POLY_INT_CST_P (t))
6719 {
6721 generic_wide_int <offset_extended_tree> > res;
6722 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
6723 res.coeffs[i] = POLY_INT_CST_COEFF (t, i);
6724 return res;
6725 }
6726 return t;
6727}
6728
6729/* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
6730 poly_wide_int. See wi::to_wide for more details. */
6731
6734{
6735 if (POLY_INT_CST_P (t))
6737 return t;
6738}
6739
6740template <int N>
6741inline generic_wide_int <wi::extended_tree <N> >
6742wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
6743 wi::INL_CONST_PRECISION>::zero (const extended &x)
6745 return build_zero_cst (TREE_TYPE (x.get_tree ()));
6746}
6747
6748template <int N>
6749inline generic_wide_int <wi::extended_tree <N> >
6750wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
6751 wi::CONST_PRECISION>::zero (const extended &x)
6752{
6753 return build_zero_cst (TREE_TYPE (x.get_tree ()));
6754}
6755
6756inline generic_wide_int <wi::unextended_tree>
6757wi::ints_for <generic_wide_int <wi::unextended_tree>,
6758 wi::VAR_PRECISION>::zero (const unextended &x)
6759{
6760 return build_zero_cst (TREE_TYPE (x.get_tree ()));
6761}
6763namespace wi
6764{
6765 template <typename T>
6766 bool fits_to_boolean_p (const T &x, const_tree);
6767
6768 template <typename T>
6769 bool fits_to_tree_p (const T &x, const_tree);
6770
6773#ifndef GENERATOR_FILE
6774 wide_int from_mpz (const_tree, mpz_t, bool);
6775#endif
6776}
6777
6778template <typename T>
6779bool
6781{
6782 typedef typename poly_int_traits<T>::int_type int_type;
6783 return (known_eq (x, int_type (0))
6784 || known_eq (x, int_type (TYPE_UNSIGNED (type) ? 1 : -1)));
6785}
6786
6787template <typename T>
6788bool
6790{
6791 /* Non-standard boolean types can have arbitrary precision but various
6792 transformations assume that they can only take values 0 and +/-1. */
6793 if (TREE_CODE (type) == BOOLEAN_TYPE)
6795
6797 return known_eq (x, zext (x, TYPE_PRECISION (type)));
6798 else
6799 return known_eq (x, sext (x, TYPE_PRECISION (type)));
6800}
6801
6802/* Produce the smallest number that is represented in TYPE. The precision
6803 and sign are taken from TYPE. */
6804inline wide_int
6806{
6808}
6810/* Produce the largest number that is represented in TYPE. The precision
6811 and sign are taken from TYPE. */
6812inline wide_int
6814{
6816}
6817
6818/* Return true if INTEGER_CST T1 is less than INTEGER_CST T2,
6819 extending both according to their respective TYPE_SIGNs. */
6820
6821inline bool
6823{
6824 return wi::to_widest (t1) < wi::to_widest (t2);
6825}
6826
6827/* Return true if INTEGER_CST T1 is less than or equal to INTEGER_CST T2,
6828 extending both according to their respective TYPE_SIGNs. */
6829
6830inline bool
6832{
6833 return wi::to_widest (t1) <= wi::to_widest (t2);
6834}
6835
6836/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. T1 and T2
6837 are both INTEGER_CSTs and their values are extended according to their
6838 respective TYPE_SIGNs. */
6840inline int
6842{
6843 return wi::cmps (wi::to_widest (t1), wi::to_widest (t2));
6844}
6845
6846/* FIXME - These declarations belong in builtins.h, expr.h and emit-rtl.h,
6847 but none of these files are allowed to be included from front ends.
6848 They should be split in two. One suitable for the FEs, the other suitable
6849 for the BE. */
6850
6851/* Assign the RTX to declaration. */
6852extern void set_decl_rtl (tree, rtx);
6853extern bool complete_ctor_at_level_p (const_tree, HOST_WIDE_INT, const_tree);
6854
6855/* Given an expression EXP that is a handled_component_p,
6856 look for the ultimate containing object, which is returned and specify
6857 the access position and size. */
6859 tree *, machine_mode *, int *, int *, int *);
6861extern tree build_personality_function (const char *);
6862
6863struct GTY(()) int_n_trees_t {
6864 /* These parts are initialized at runtime */
6865 tree signed_type;
6866 tree unsigned_type;
6867};
6868
6869/* This is also in machmode.h */
6870extern bool int_n_enabled_p[NUM_INT_N_ENTS];
6871extern GTY(()) struct int_n_trees_t int_n_trees[NUM_INT_N_ENTS];
6872
6873/* Like bit_position, but return as an integer. It must be representable in
6874 that way (since it could be a signed value, we don't have the
6875 option of returning -1 like int_size_in_byte can. */
6876
6877inline HOST_WIDE_INT
6880 return ((wi::to_offset (DECL_FIELD_OFFSET (field)) << LOG2_BITS_PER_UNIT)
6881 + wi::to_offset (DECL_FIELD_BIT_OFFSET (field))).to_shwi ();
6882}
6883
6884/* Return true if it makes sense to consider alias set for a type T. */
6885
6886inline bool
6888{
6889 /* Function and method types are never accessed as memory locations. */
6890 if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
6891 return false;
6892
6893 if (COMPLETE_TYPE_P (t))
6894 return true;
6895
6896 /* Incomplete types cannot be accessed in general except for arrays
6897 where we can fetch its element despite we have no array bounds. */
6898 if (TREE_CODE (t) == ARRAY_TYPE && COMPLETE_TYPE_P (TREE_TYPE (t)))
6899 return true;
6900
6901 return false;
6902}
6904extern location_t set_block (location_t loc, tree block);
6905
6906extern void gt_ggc_mx (tree &);
6907extern void gt_pch_nx (tree &);
6908extern void gt_pch_nx (tree &, gt_pointer_operator, void *);
6909extern void gt_ggc_mx (tree_raw_data *);
6910extern void gt_pch_nx (tree_raw_data *);
6911extern void gt_pch_nx (tree_raw_data *, gt_pointer_operator, void *);
6912
6913extern bool nonnull_arg_p (const_tree);
6914extern bool is_empty_type (const_tree);
6920
6921extern location_t
6922set_source_range (tree expr, location_t start, location_t finish);
6923
6924extern location_t
6925set_source_range (tree expr, source_range src_range);
6926
6927/* Return true if it makes sense to promote/demote from_type to to_type. */
6928inline bool
6930{
6931 unsigned int to_type_precision = TYPE_PRECISION (to_type);
6932
6933 /* OK to promote if to_type is no bigger than word_mode. */
6934 if (to_type_precision <= GET_MODE_PRECISION (word_mode))
6935 return true;
6936
6937 /* Otherwise, allow only if narrowing or same precision conversions. */
6938 return to_type_precision <= TYPE_PRECISION (from_type);
6939}
6940
6941/* Pointer type used to declare builtins before we have seen its real
6942 declaration. */
6943class builtin_structptr_type
6944{
6945public:
6946 tree& node;
6947 tree& base;
6948 const char *str;
6949};
6950extern const builtin_structptr_type builtin_structptr_types[6];
6951
6952/* Return true if type T has the same precision as its underlying mode. */
6953
6954inline bool
6956{
6958}
6959
6960/* Helper functions for fndecl_built_in_p. */
6961
6962inline bool
6964{
6965 return name0 == name1;
6966}
6967
6968/* Recursive case for two or more names. */
6969
6970template <typename... F>
6971inline bool
6973 built_in_function name2, F... names)
6974{
6975 return name0 == name1 || built_in_function_equal_p (name0, name2, names...);
6976}
6977
6978/* Return true if a FUNCTION_DECL NODE is a GCC built-in function.
6979
6980 Note that it is different from the DECL_IS_UNDECLARED_BUILTIN
6981 accessor, as this is impervious to user declaration. */
6982
6983inline bool
6985{
6986 return DECL_BUILT_IN_CLASS (node) != NOT_BUILT_IN;
6987}
6988
6989/* Return true if a FUNCTION_DECL NODE is a GCC built-in function
6990 of class KLASS. */
6991
6992inline bool
6995 return fndecl_built_in_p (node) && DECL_BUILT_IN_CLASS (node) == klass;
6996}
6998/* Return true if a FUNCTION_DECL NODE is a GCC built-in function
6999 of class KLASS with name equal to NAME. */
7000
7001inline bool
7002fndecl_built_in_p (const_tree node, unsigned int name, built_in_class klass)
7004 return (fndecl_built_in_p (node, klass)
7005 && DECL_UNCHECKED_FUNCTION_CODE (node) == name);
7006}
7007
7008/* Return true if a FUNCTION_DECL NODE is a GCC built-in function
7009 of BUILT_IN_NORMAL class with name equal to NAME1 (or other mentioned
7010 NAMES). */
7011
7012template <typename... F>
7013inline bool
7016 return (fndecl_built_in_p (node, BUILT_IN_NORMAL)
7018 name1, names...));
7019}
7020
7021/* Returns true if the function decl NODE is an alloca. */
7022inline bool
7024{
7026 return false;
7028}
7029
7030/* A struct for encapsulating location information about an operator
7031 and the operation built from it.
7032
7033 m_operator_loc is the location of the operator
7034 m_combined_loc is the location of the compound expression.
7035
7036 For example, given "a && b" the, operator location is:
7037 a && b
7038 ^~
7039 and the combined location is:
7040 a && b
7041 ~~^~~~
7042 Capturing this information allows for class binary_op_rich_location
7043 to provide detailed information about e.g. type mismatches in binary
7044 operations where enough location information is available:
7045
7046 arg_0 op arg_1
7047 ~~~~~ ^~ ~~~~~
7048 | |
7049 | arg1 type
7050 arg0 type
7051
7052 falling back to just showing the combined location:
7053
7054 arg_0 op arg_1
7055 ~~~~~~^~~~~~~~
7056
7057 where it is not. */
7058
7059class op_location_t
7060{
7061public:
7062 location_t m_operator_loc;
7063 location_t m_combined_loc;
7064
7065 /* 1-argument ctor, for constructing from a combined location. */
7066 op_location_t (location_t combined_loc)
7067 : m_operator_loc (UNKNOWN_LOCATION), m_combined_loc (combined_loc)
7068 {}
7069
7070 /* 2-argument ctor, for distinguishing between the operator's location
7071 and the combined location. */
7072 op_location_t (location_t operator_loc, location_t combined_loc)
7073 : m_operator_loc (operator_loc), m_combined_loc (combined_loc)
7074 {}
7075
7076 /* Implicitly convert back to a location_t, using the combined location. */
7077 operator location_t () const { return m_combined_loc; }
7078};
7079
7080/* Code that doesn't refer to any warning. Has no effect on suppression
7081 functions. */
7082constexpr opt_code no_warning = opt_code ();
7083/* Wildcard code that refers to all warnings. */
7084constexpr opt_code all_warnings = N_OPTS;
7085
7086/* Return the disposition for a warning (or all warnings by default)
7087 at a location. */
7088extern bool warning_suppressed_at (location_t, opt_code = all_warnings);
7089/* Set the disposition for a warning (or all warnings by default)
7090 at a location to disabled by default. */
7091extern bool suppress_warning_at (location_t, opt_code = all_warnings,
7092 bool = true);
7093/* Overwrite warning disposition bitmap for a location with given spec. */
7094extern void put_warning_spec_at (location_t loc, unsigned);
7095/* Copy warning disposition from one location to another. */
7096extern void copy_warning (location_t, location_t);
7097
7098/* Return the disposition for a warning (or all warnings by default)
7099 for an expression. */
7100extern bool warning_suppressed_p (const_tree, opt_code = all_warnings);
7101/* Set the disposition for a warning (or all warnings by default)
7102 at a location to disabled by default. */
7103extern void suppress_warning (tree, opt_code = all_warnings, bool = true)
7104 ATTRIBUTE_NONNULL (1);
7105/* Copy warning disposition from one expression to another. */
7106extern void copy_warning (tree, const_tree);
7107
7108/* Whether the tree might have a warning spec. */
7109extern bool has_warning_spec (const_tree);
7110/* Retrieve warning spec bitmap for tree streaming. */
7111extern unsigned get_warning_spec (const_tree);
7112/* Overwrite warning spec bitmap for a tree with given spec. */
7113extern void put_warning_spec (tree, unsigned);
7114
7115/* Return the zero-based number corresponding to the argument being
7116 deallocated if FNDECL is a deallocation function or an out-of-bounds
7117 value if it isn't. */
7118extern unsigned fndecl_dealloc_argno (tree);
7119
7120/* If an expression refers to a character array or pointer declared
7121 attribute nonstring, return a decl for that array or pointer and
7122 if nonnull, set the second argument to the referenced enclosing
7123 object or pointer. Otherwise return null. */
7125
7126/* Returns the version string for a decl with target_version attribute.
7127 Returns an invalid string_slice if no attribute is present. */
7128extern string_slice get_target_version (const tree);
7129/* Returns a vector of the version strings from a target_clones attribute on
7130 a decl. Can also record the number of default versions found.
7131 Use bool to control whether or not the results should
7132 be filtered with TARGET_CHECK_TARGET_CLONE_VERSION. */
7133extern auto_vec<string_slice> get_clone_versions
7134 (const tree,int * = NULL, bool = true);
7135/* Returns a vector of the version strings from a target_clones attribute
7136 directly. Additionally takes a bool to control whether or not the results
7137 should be filtered with TARGET_CHECK_TARGET_CLONE_VERSION. */
7138extern auto_vec<string_slice> get_clone_attr_versions
7139 (const tree, int *, bool = true);
7140
7141/* Checks if two decls define any overlapping versions. */
7142extern bool disjoint_version_decls (tree, tree);
7143/* Checks if two overlapping decls are not mergeable. */
7144extern bool diagnose_versioned_decls (tree, tree);
7145
7146#endif /* GCC_TREE_H */
void gt_pch_nx(bbitmap< N > *)
Definition bbitmap.h:226
void gt_ggc_mx(bbitmap< N > *)
Definition bbitmap.h:220
auto_suppress_location_wrappers()
Definition tree.h:1391
~auto_suppress_location_wrappers()
Definition tree.h:1392
Definition vec.h:1667
Definition tree.h:6875
tree & base
Definition tree.h:6878
const char * str
Definition tree.h:6879
tree & node
Definition tree.h:6877
code_helper(tree_code code)
Definition tree.h:85
tree_code safe_as_tree_code() const
Definition tree.h:113
bool is_internal_fn() const
Definition tree.h:138
code_helper()
Definition tree.h:84
bool operator!=(const code_helper &other)
Definition tree.h:100
code_helper(internal_fn fn)
Definition tree.h:87
bool is_fn_code() const
Definition tree.h:93
bool operator==(const code_helper &other)
Definition tree.h:99
int rep
Definition tree.h:105
code_helper(combined_fn fn)
Definition tree.h:86
int get_rep() const
Definition tree.h:96
bool is_tree_code() const
Definition tree.h:92
bool is_builtin_fn() const
Definition tree.h:144
combined_fn safe_as_fn_code() const
Definition tree.h:123
Definition genmatch.cc:1506
Definition wide-int.h:776
Definition hash-map.h:40
Definition hash-set.h:37
Definition inchash.h:38
hashval_t end() const
Definition inchash.h:49
op_location_t(location_t operator_loc, location_t combined_loc)
Definition tree.h:7003
op_location_t(location_t combined_loc)
Definition tree.h:6997
location_t m_operator_loc
Definition tree.h:6993
location_t m_combined_loc
Definition tree.h:6994
Definition poly-int.h:378
C coeffs[N]
Definition poly-int.h:433
Definition vec.h:2502
tree * end()
Definition tree.h:4853
tree v
Definition tree.h:4849
tree_vec_range(tree v)
Definition tree.h:4851
tree * begin()
Definition tree.h:4852
Definition tree.h:6368
unsigned int get_precision() const
Definition tree.h:6562
const_tree m_t
Definition tree.h:6370
extended_tree(const_tree)
Definition tree.h:6554
const_tree get_tree() const
Definition tree.h:6379
extended_tree()
Definition tree.h:6373
const HOST_WIDE_INT * get_val() const
Definition tree.h:6569
unsigned int get_len() const
Definition tree.h:6576
Definition wide-int.h:707
Definition tree.h:6343
const_tree get_tree() const
Definition tree.h:6354
unextended_tree()
Definition tree.h:6348
unsigned int get_len() const
Definition tree.h:6610
unextended_tree(const_tree t)
Definition tree.h:6349
unsigned int get_precision() const
Definition tree.h:6598
const HOST_WIDE_INT * get_val() const
Definition tree.h:6604
const_tree m_t
Definition tree.h:6345
static wide_int from(const wide_int_ref &, unsigned int, signop)
Definition wide-int.h:1289
struct rtx_def * rtx
Definition coretypes.h:57
tls_model
Definition coretypes.h:210
excess_precision_type
Definition coretypes.h:452
const union tree_node * const_tree
Definition coretypes.h:98
#define GTY(x)
Definition coretypes.h:41
void(* gt_pointer_operator)(void *, void *, void *)
Definition coretypes.h:475
class bitmap_head * bitmap
Definition coretypes.h:51
union tree_node * tree
Definition coretypes.h:97
void ATTRIBUTE_NORETURN
Definition diagnostic-core.h:76
scalar_int_mode word_mode
Definition emit-rtl.cc:79
void set_decl_rtl(tree t, rtx x)
Definition emit-rtl.cc:1463
tree get_inner_reference(tree exp, poly_int64 *pbitsize, poly_int64 *pbitpos, tree *poffset, machine_mode *pmode, int *punsignedp, int *preversep, int *pvolatilep)
Definition expr.cc:8468
bool complete_ctor_at_level_p(const_tree type, HOST_WIDE_INT num_elts, const_tree last_type)
Definition expr.cc:7347
tree build_personality_function(const char *lang)
Definition expr.cc:14247
uint64_t sanitize_code_type
Definition flag-types.h:355
double exp(double)
void copy_warning(location_t to, location_t from)
Definition gcc-diagnostic-spec.cc:206
bool warning_suppressed_at(location_t loc, opt_code opt)
Definition gcc-diagnostic-spec.cc:126
bool suppress_warning_at(location_t loc, opt_code opt, bool supp)
Definition gcc-diagnostic-spec.cc:149
void put_warning_spec_at(location_t loc, unsigned bits)
Definition gcc-diagnostic-spec.cc:185
static vector< name_map > names
Definition gcov.cc:594
static type_p type(options_p *optsp, bool nested)
Definition gengtype-parse.cc:883
static struct token T
Definition gengtype-parse.cc:45
static class line_maps * line_table
Definition genmatch.cc:65
built_in_function
Definition genmatch.cc:1009
combined_fn
Definition genmatch.cc:1020
internal_fn
Definition genmatch.cc:1015
tree_code
Definition genmatch.cc:1002
#define NUM_POLY_INT_COEFFS
Definition genmodes.cc:859
#define N
Definition gensupport.cc:202
bool ggc_marked_p(const void *p)
Definition ggc-page.cc:1681
void suppress_warning(gimple *, opt_code=all_warnings, bool=true) ATTRIBUTE_NONNULL(1)
Definition warning-control.cc:173
bool warning_suppressed_p(const gimple *, opt_code=all_warnings) ATTRIBUTE_NONNULL(1)
Definition warning-control.cc:138
int exact_log2(unsigned HOST_WIDE_INT x)
Definition hwint.cc:75
bool pow2p_hwi(unsigned HOST_WIDE_INT x)
Definition hwint.h:179
#define HOST_WIDE_INT_M1U
Definition hwint.h:72
#define HOST_WIDE_INT_1U
Definition hwint.h:70
location_t input_location
Definition input.cc:41
#define LOCATION_LOCUS(LOC)
Definition input.h:95
#define UNKNOWN_LOCATION
Definition input.h:32
bool int_n_enabled_p[NUM_INT_N_ENTS]
Definition tree.cc:290
ALWAYS_INLINE poly_uint16 GET_MODE_PRECISION(machine_mode mode)
Definition machmode.h:710
Definition fold-const.cc:4346
void add_expr(const_tree t, inchash::hash &hstate, unsigned int flags)
Definition fold-const.cc:4354
Definition double-int.h:439
precision_type
Definition wide-int.h:387
@ INL_CONST_PRECISION
Definition wide-int.h:398
@ VAR_PRECISION
Definition wide-int.h:394
@ CONST_PRECISION
Definition wide-int.h:402
wide_int min_value(machine_mode, signop)
Definition rtl.h:2364
const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< unextended_tree > > tree_to_poly_wide_ref
Definition tree.h:6414
tree_to_offset_ref to_offset(const_tree)
Definition tree.h:6507
tree_to_poly_offset_ref to_poly_offset(const_tree)
Definition tree.h:6647
int cmps(const T1 &, const T2 &)
Definition wide-int.h:2444
const generic_wide_int< widest_extended_tree > tree_to_widest_ref
Definition tree.h:6396
UNARY_FUNCTION zext(const T &, unsigned int)
extended_tree< ADDR_MAX_PRECISION > offset_extended_tree
Definition tree.h:6394
tree_to_poly_widest_ref to_poly_widest(const_tree)
Definition tree.h:6630
bool fits_to_tree_p(const T &x, const_tree)
Definition tree.h:6720
const generic_wide_int< wide_int_ref_storage< false, false > > tree_to_wide_ref
Definition tree.h:6399
const generic_wide_int< offset_extended_tree > tree_to_offset_ref
Definition tree.h:6397
hwi_with_prec zero(unsigned int)
Definition wide-int.h:2018
const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< offset_extended_tree > > tree_to_poly_offset_ref
Definition tree.h:6411
tree_to_widest_ref to_widest(const_tree)
Definition tree.h:6482
rtx_to_poly_wide_ref to_poly_wide(const_rtx, machine_mode)
Definition rtl.h:2409
Ca unsigned int precision
Definition poly-int.h:746
wide_int from_mpz(const_tree, mpz_t, bool)
Definition wide-int.cc:253
bool fits_to_boolean_p(const T &x, const_tree)
Definition tree.h:6711
wide_int max_value(machine_mode, signop)
Definition rtl.h:2372
extended_tree< WIDEST_INT_MAX_PRECISION > widest_extended_tree
Definition tree.h:6393
tree_to_wide_ref to_wide(const_tree)
Definition tree.h:6537
UNARY_FUNCTION sext(const T &, unsigned int)
const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< widest_extended_tree > > tree_to_poly_widest_ref
Definition tree.h:6408
i
Definition poly-int.h:750
poly_int< NUM_POLY_INT_COEFFS, unsigned HOST_WIDE_INT > poly_uint64
Definition poly-int-types.h:25
poly_int< NUM_POLY_INT_COEFFS, wide_int_ref > poly_wide_int_ref
Definition poly-int-types.h:28
poly_int< NUM_POLY_INT_COEFFS, HOST_WIDE_INT > poly_int64
Definition poly-int-types.h:24
#define known_eq(A, B)
i
Definition poly-int.h:776
Ca const poly_int< N, Cb > & b
Definition poly-int.h:771
Ca & a
Definition poly-int.h:770
signop
Definition signop.h:28
#define PASS_MEM_STAT
Definition statistics.h:54
#define CXX_MEM_STAT_INFO
Definition statistics.h:58
Definition tree-loop-distribution.cc:240
Definition lra-remat.cc:89
Definition genautomata.cc:499
Definition double-int.h:50
Definition hash-traits.h:328
Definition hash-traits.h:321
Definition gimple.h:221
Definition tree.h:6794
tree signed_type
Definition tree.h:6796
tree unsigned_type
Definition tree.h:6797
poly_coeff_traits< T >::int_type int_type
Definition poly-int.h:198
Definition cse.cc:4127
Definition hash-map-traits.h:104
Definition hash-map-traits.h:33
Definition tree.h:6056
static hashval_t hash(tree)
Definition tree.h:6061
Definition tree.h:6012
static bool equal(tree_decl_map *a, tree_decl_map *b)
Definition tree.h:6015
static hashval_t hash(tree_decl_map *m)
Definition tree.h:6013
static int keep_cache_entry(tree_decl_map *&m)
Definition tree.h:6021
Definition tree.h:6094
static hashval_t hash(tree)
Definition tree.h:6099
Definition tree-core.h:1575
Definition tree.h:6082
static hashval_t hash(tree)
Definition tree.h:6087
Definition tree.h:6068
static hashval_t hash(tree)
Definition tree.h:6073
Definition tree.h:6036
static hashval_t hash(tree_vec_map *m)
Definition tree.h:6037
static bool equal(tree_vec_map *a, tree_vec_map *b)
Definition tree.h:6040
static int keep_cache_entry(tree_vec_map *&m)
Definition tree.h:6046
Definition gengtype.h:252
Definition vec.h:450
static const bool is_sign_extended
Definition tree.h:6388
static const unsigned int precision
Definition tree.h:6390
static const bool needs_write_val_arg
Definition tree.h:6389
static const bool host_dependent_precision
Definition tree.h:6387
static enum precision_type precision_type
Definition tree.h:6386
static enum precision_type precision_type
Definition tree.h:6360
static const bool is_sign_extended
Definition tree.h:6362
static const bool needs_write_val_arg
Definition tree.h:6363
static const bool host_dependent_precision
Definition tree.h:6361
Definition wide-int.h:427
generic_wide_int< extended_tree< N > > extended
Definition tree.h:6430
generic_wide_int< extended_tree< N > > extended
Definition tree.h:6423
generic_wide_int< unextended_tree > unextended
Definition tree.h:6437
Definition wide-int.h:2043
static int zero(const T &)
Definition wide-int.h:2044
#define NULL
Definition system.h:50
#define gcc_assert(EXPR)
Definition system.h:814
#define gcc_unreachable()
Definition system.h:841
#define true
Definition system.h:887
#define WARN_UNUSED_RESULT
Definition system.h:833
#define CONST_CAST_TREE(X)
Definition system.h:1194
#define CONST_CAST(TYPE, X)
Definition system.h:1193
#define STATIC_ASSERT(X)
Definition system.h:864
#define DEBUG_FUNCTION
Definition system.h:1236
#define gcc_checking_assert(EXPR)
Definition system.h:821
tree(* walk_tree_fn)(tree *, int *, void *)
Definition tree-core.h:1089
@ END_BUILTINS
Definition tree-core.h:3541
omp_clause_code
Definition tree-core.h:250
built_in_class
Definition tree-core.h:165
@ NOT_BUILT_IN
Definition tree-core.h:166
@ BUILT_IN_FRONTEND
Definition tree-core.h:167
@ BUILT_IN_NORMAL
Definition tree-core.h:169
@ BUILT_IN_MD
Definition tree-core.h:168
tree_code_class
Definition tree-core.h:226
@ tcc_comparison
Definition tree-core.h:233
@ tcc_expression
Definition tree-core.h:240
@ tcc_type
Definition tree-core.h:230
tree_node_structure_enum
Definition tree-core.h:598
unsigned short priority_type
Definition tree-core.h:1086
clobber_kind
Definition tree-core.h:1058
@ CLOBBER_UNDEF
Definition tree-core.h:1060
#define NUM_TREE_CODES
Definition tree-core.h:156
@ MAX_TREE_CODES
Definition tree-core.h:149
tree(* walk_tree_lh)(tree *, int *, tree(*)(tree *, int *, void *), void *, hash_set< tree > *)
Definition tree-core.h:1092
int suppress_location_wrappers
Definition tree.cc:14933
bool disjoint_version_decls(tree fn1, tree fn2)
Definition tree.cc:15499
string_slice get_target_version(const tree decl)
Definition tree.cc:15477
tree arg_size_in_bytes(const_tree type)
Definition tree.cc:15092
poly_int64 tree_to_poly_int64(const_tree t)
Definition tree.cc:3448
bool tree_fits_poly_int64_p(const_tree t)
Definition tree.cc:6598
bool flexible_array_type_p(const_tree type)
Definition tree.cc:15050
tree get_attr_nonstring_decl(tree expr, tree *ref)
Definition tree.cc:15374
bool tree_fits_uhwi_p(const_tree t)
Definition tree.cc:6617
unsigned const char omp_clause_num_ops[]
Definition tree.cc:296
tree build_zero_cst(tree type)
Definition tree.cc:2777
bool default_is_empty_record(const_tree type)
Definition tree.cc:15032
bool tree_fits_shwi_p(const_tree t)
Definition tree.cc:6587
bool nonnull_arg_p(const_tree arg)
Definition tree.cc:14788
auto_vec< string_slice > get_clone_attr_versions(const tree arglist, int *default_count, bool filter)
Definition tree.cc:15429
location_t set_block(location_t loc, tree block)
Definition tree.cc:14851
bool expr_type_first_operand_type_p(tree_code code)
Definition tree.cc:15101
const builtin_structptr_type builtin_structptr_types[6]
Definition tree.cc:15182
auto_vec< string_slice > get_clone_versions(const tree decl, int *default_count, bool filter)
Definition tree.cc:15463
HOST_WIDE_INT arg_int_size_in_bytes(const_tree type)
Definition tree.cc:15084
bool diagnose_versioned_decls(tree old_decl, tree new_decl)
Definition tree.cc:15621
bool is_empty_type(const_tree type)
Definition tree.cc:15010
bool tree_fits_poly_uint64_p(const_tree t)
Definition tree.cc:6628
location_t set_source_range(tree expr, location_t start, location_t finish)
Definition tree.cc:14861
unsigned HOST_WIDE_INT tree_to_uhwi(const_tree t)
Definition tree.cc:6671
struct int_n_trees_t int_n_trees[NUM_INT_N_ENTS]
Definition tree.cc:291
bool tree_contains_struct[MAX_TREE_CODES][64]
Definition tree.cc:293
poly_uint64 tree_to_poly_uint64(const_tree t)
Definition tree.cc:3457
sanitize_code_type tree_to_sanitize_code_type(const_tree t)
Definition tree.cc:6682
unsigned fndecl_dealloc_argno(tree fndecl)
Definition tree.cc:15312
HOST_WIDE_INT int_size_in_bytes(const_tree)
Definition tree.cc:3749
void decl_value_expr_insert(tree, tree)
Definition tree.cc:6122
int suppress_location_wrappers
Definition tree.cc:14933
void overwrite_decl_assembler_name(tree decl, tree name)
Definition tree.cc:857
void get_type_static_bounds(const_tree, mpz_t, mpz_t)
Definition tree.cc:8486
bool check_lang_type(const_tree cand, const_tree base)
Definition tree.cc:5675
special_array_member component_ref_sam_type(tree)
Definition tree.cc:13375
bool type_list_equal(const_tree, const_tree)
Definition tree.cc:6491
void build_common_tree_nodes(bool)
Definition tree.cc:9605
#define TYPE_NAME(NODE)
Definition tree.h:2363
bool is_lang_specific(const_tree t)
Definition tree.h:6139
tree strip_array_types(tree type)
Definition tree.h:5108
tree build_pointer_type(tree)
Definition tree.cc:7228
tree function_args_iter_cond(function_args_iterator *i)
Definition tree.h:5610
tree wide_int_to_tree(tree type, const poly_wide_int_ref &cst)
Definition tree.cc:2000
#define TREE_VALUE(NODE)
Definition tree.h:1241
poly_uint64 bit_field_offset(const_tree t)
Definition tree.h:5797
tree build4(enum tree_code, tree, tree, tree, tree, tree CXX_MEM_STAT_INFO)
tree build_vl_exp(enum tree_code, int CXX_MEM_STAT_INFO)
tree make_anon_name()
Definition tree.cc:9045
tree build3(enum tree_code, tree, tree, tree, tree CXX_MEM_STAT_INFO)
tree build_bitint_type(unsigned HOST_WIDE_INT, int)
Definition tree.cc:7386
tree build_constructor_from_vec(tree, const vec< tree, va_gc > *)
Definition tree.cc:2440
#define COMPLETE_TYPE_P(NODE)
Definition tree.h:709
unsigned int element_precision(const_tree)
Definition tree.cc:6996
const char * get_name(tree)
Definition tree.cc:11986
#define DECL_CONTEXT(NODE)
Definition tree.h:2850
bool operation_can_overflow(enum tree_code)
Definition tree.cc:7087
int allocate_decl_uid(void)
Definition tree.cc:1304
enum tree_code tree_code_for_canonical_type_merging(enum tree_code code)
Definition tree.h:5956
tree build_pointer_type_for_mode(tree, machine_mode, bool)
Definition tree.cc:7164
#define target_option_default_node
Definition tree.h:4740
tree unsigned_type_for(tree)
Definition tree.cc:11385
#define DECL_ORIGINAL_TYPE(NODE)
Definition tree.h:3683
tree num_ending_zeros(const_tree)
Definition tree.cc:11548
tree signed_type_for(tree)
Definition tree.cc:11396
int tree_floor_log2(const_tree)
Definition tree.cc:3171
const char * prefix_for_internal_label(tree label)
Definition tree.cc:832
tree build_int_cst_type(tree, poly_int64)
Definition tree.cc:1657
bool operation_no_trapping_overflow(tree, enum tree_code)
Definition tree.cc:7117
tree make_tree(tree, rtx)
Definition expmed.cc:5385
tree build_block(tree, tree, tree, tree)
Definition tree.cc:5618
unsigned int tree_decl_map_hash(const void *)
Definition tree.cc:5985
tree max_object_size()
Definition tree.cc:15195
poly_uint64 TYPE_VECTOR_SUBPARTS(const_tree node)
Definition tree.h:4365
tree build_vector_type(tree, poly_int64)
Definition tree.cc:10450
#define optimization_default_node
Definition tree.h:4736
#define TREE_READONLY(NODE)
Definition tree.h:948
tree build_function_type_list(tree,...)
Definition tree.cc:7796
tree build_omp_clause(location_t, enum omp_clause_code)
Definition tree.cc:10932
#define DECL_FUNCTION_SPECIFIC_TARGET(NODE)
Definition tree.h:3636
tree build_minus_one_cst(tree)
Definition tree.cc:2736
tree size_in_bytes_loc(location_t, const_tree)
Definition tree.cc:3726
cst_size_error
Definition tree.h:5129
@ cst_size_too_big
Definition tree.h:5133
@ cst_size_not_constant
Definition tree.h:5131
@ cst_size_ok
Definition tree.h:5130
@ cst_size_overflow
Definition tree.h:5134
@ cst_size_negative
Definition tree.h:5132
tree get_containing_scope(const_tree)
Definition tree.cc:8683
tree build_vec_series(tree, tree, tree)
Definition tree.cc:2279
#define call_expr_nargs(NODE)
Definition tree.h:1503
tree build_nonstandard_integer_type(unsigned HOST_WIDE_INT, int)
Definition tree.cc:7322
tree get_narrower(tree, int *)
Definition tree.cc:8276
#define DECL_FIELD_BIT_OFFSET(NODE)
Definition tree.h:3128
tree obj_type_ref_class(const_tree ref, bool=false)
Definition ipa-devirt.cc:1918
bool tree_int_cst_lt(const_tree t1, const_tree t2)
Definition tree.h:6753
tree build1(enum tree_code, tree, tree CXX_MEM_STAT_INFO)
bool real_zerop(const_tree)
Definition tree.cc:3295
built_in_function as_builtin_fn(combined_fn code)
Definition tree.h:55
bool really_constant_p(const_tree)
Definition tree.cc:3407
bool needs_to_live_in_memory(const_tree)
Definition tree.cc:11293
tree convert(tree, tree)
#define TYPE_PRECISION(NODE)
Definition tree.h:2360
tree build_method_type_directly(tree, tree, tree)
Definition tree.cc:7869
bool zerop(const_tree)
Definition tree.cc:2981
#define TREE_INT_CST_NUNITS(NODE)
Definition tree.h:1157
unsigned int vector_cst_encoded_nelts(const_tree t)
Definition tree.h:4777
built_in_function DECL_FUNCTION_CODE(const_tree decl)
Definition tree.h:4440
tree drop_tree_overflow(tree)
Definition tree.cc:13005
#define EXPR_CHECK(T)
Definition tree.h:501
tree build_offset_type(tree, tree)
Definition tree.cc:7945
tree build_alloca_call_expr(tree, unsigned int, HOST_WIDE_INT)
Definition tree.cc:11203
bool integer_all_onesp(const_tree)
Definition tree.cc:3057
#define TREE_OPERAND(NODE, I)
Definition tree.h:1319
tree maybe_build_call_expr_loc(location_t, combined_fn, tree, int,...)
Definition tree.cc:11164
unsigned crc32_unsigned_n(unsigned, unsigned, unsigned)
Definition tree.cc:8983
tree build_varargs_function_type_list(tree,...)
Definition tree.cc:7813
tree build_call_expr_loc_vec(location_t, tree, vec< tree, va_gc > *)
Definition tree.cc:11079
int tree_int_cst_sgn(const_tree)
Definition tree.cc:6703
poly_uint64 bit_field_size(const_tree t)
Definition tree.h:5788
bool poly_int_tree_p(const_tree t, poly_int64 *value)
Definition tree.h:5144
void free_node(tree)
Definition tree.cc:1428
#define DECL_NAME(NODE)
Definition tree.h:2798
bool canonical_type_used_p(const_tree t)
Definition tree.h:5986
tree build_optimization_node(struct gcc_options *opts, struct gcc_options *opts_set)
Definition tree.cc:12178
tree save_expr(tree)
Definition tree.cc:4112
tree build_constructor_from_list(tree, tree)
Definition tree.cc:2420
void protected_set_expr_location(tree, location_t)
Definition tree.cc:5635
const char * get_tree_code_name(enum tree_code)
Definition tree.cc:12986
tree decl_function_context(const_tree)
Definition tree.cc:8707
priority_type decl_init_priority_lookup(tree)
Definition tree.cc:5993
void decl_init_priority_insert(tree, priority_type)
Definition tree.cc:6019
#define IS_EXPR_CODE_CLASS(CLASS)
Definition tree.h:294
void put_warning_spec(tree, unsigned)
Definition warning-control.cc:280
HOST_WIDE_INT max_int_size_in_bytes(const_tree)
Definition tree.cc:3769
tree build_reference_type(tree)
Definition tree.cc:7300
bool tree_invariant_p(tree)
Definition tree.cc:4083
tree tree_last(tree)
Definition tree.cc:3624
void recompute_constructor_flags(tree)
Definition tree.cc:2342
tree byte_position(const_tree)
Definition tree.cc:3812
tree build_vector_from_ctor(tree, const vec< constructor_elt, va_gc > *)
Definition tree.cc:2191
tree signed_or_unsigned_type_for(int, tree)
Definition tree.cc:11333
tree build4_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3 CXX_MEM_STAT_INFO)
Definition tree.h:4903
void decl_fini_priority_insert(tree, priority_type)
Definition tree.cc:6039
bool type_with_interoperable_signedness(const_tree)
Definition tree.cc:13972
tree build_call_valist(tree, tree, int, va_list)
Definition tree.cc:11015
tree build_replicated_int_cst(tree, unsigned, HOST_WIDE_INT)
tree build_truth_vector_type_for_mode(poly_uint64, machine_mode)
Definition tree.cc:10458
void DEBUG_FUNCTION verify_type(const_tree t)
Definition tree.cc:14345
tree build_debug_expr_decl(tree type)
Definition tree.cc:5572
bool block_may_fallthru(const_tree)
Definition tree.cc:12893
int struct_ptr_eq(const void *a, const void *b)
Definition tree.h:5718
bool contains_placeholder_p(const_tree)
Definition tree.cc:4268
#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE)
Definition tree.h:3641
#define AGGREGATE_TYPE_P(TYPE)
Definition tree.h:694
int tree_map_base_eq(const void *, const void *)
Definition tree.cc:5949
#define sizetype
Definition tree.h:5242
bool maybe_special_function_p(const_tree fndecl)
Definition tree.h:6269
tree * function_args_iter_cond_ptr(function_args_iterator *i)
Definition tree.h:5601
#define TREE_VEC_BEGIN(NODE)
Definition tree.h:1245
tree build_array_type_nelts(tree, poly_uint64)
Definition tree.cc:7616
bool ptrofftype_p(tree type)
Definition tree.h:5758
tree first_call_expr_arg(tree exp, call_expr_arg_iterator *iter)
Definition tree.h:6106
bool address_invariant_p(tree)
Definition tree.cc:4024
void tree_set_block(tree, tree)
Definition tree.cc:11953
combined_fn get_call_combined_fn(const_tree)
Definition tree.cc:8870
enum tree_node_structure_enum tree_node_structure(const_tree)
Definition tree.cc:4228
tree build_case_label(tree, tree, tree)
Definition tree.cc:2898
tree build2_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1 CXX_MEM_STAT_INFO)
Definition tree.h:4883
#define TREE_INT_CST_LOW(NODE)
Definition tree.h:1162
tree build_vector_type_for_mode(tree, machine_mode)
Definition tree.cc:10415
tree builtin_decl_unreachable()
Definition tree.cc:11231
int simple_cst_equal(const_tree, const_tree)
Definition tree.cc:6747
bitmap get_nonnull_args(const_tree)
Definition tree.cc:14955
enum tls_model decl_tls_model(const_tree)
Definition tree.cc:1052
tree array_type_nelts_top(tree)
Definition tree.cc:3869
bool tree_map_base_marked_p(const void *)
Definition tree.cc:5969
bool tree_zero_one_valued_p(tree)
unsigned int tree_int_cst_min_precision(tree, signop)
Definition tree.cc:6719
tree block_ultimate_origin(const_tree)
Definition tree.cc:12246
tree build3_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2 CXX_MEM_STAT_INFO)
Definition tree.h:4893
tree build_variant_type_copy(tree CXX_MEM_STAT_INFO)
#define TREE_OPTIMIZATION(NODE)
Definition tree.h:3713
tree build_nonshared_array_type(tree, tree)
Definition tree.cc:7607
bool warn_deprecated_use(tree, tree)
Definition tree.cc:12647
tree build_empty_stmt(location_t)
Definition tree.cc:10920
bool inlined_function_outer_scope_p(const_tree block)
Definition tree.h:5629
tree build_array_type_1(tree, tree, bool, bool, bool)
Definition tree.cc:7542
poly_int64 tree_to_poly_int64(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:3448
void function_args_iter_init(function_args_iterator *i, const_tree fntype)
Definition tree.h:5592
#define tree_decl_map_eq
Definition tree.h:6007
bool tree_fits_uhwi_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6617
bool builtin_fn_p(combined_fn code)
Definition tree.h:46
bool commutative_ternary_tree_code(enum tree_code)
Definition genmatch.cc:1074
tree build_function_type_array(tree, int, tree *)
Definition tree.cc:7848
location_t * block_nonartificial_location(tree)
Definition tree.cc:12055
bool type_has_mode_precision_p(const_tree t)
Definition tree.h:6886
bool typedef_variant_p(const_tree type)
Definition tree.h:5708
ATTRIBUTE_WARN_UNUSED_RESULT tree protected_set_expr_location_unshare(tree, location_t)
Definition fold-const.cc:238
bool commutative_tree_code(enum tree_code)
Definition genmatch.cc:1037
bool integer_truep(const_tree)
Definition tree.cc:3134
tree create_artificial_label(location_t)
Definition tree.cc:11970
void assign_assembler_name_if_needed(tree)
Definition tree.cc:946
tree decl_value_expr_lookup(tree)
Definition tree.cc:6108
void function_args_iter_next(function_args_iterator *i)
Definition tree.h:5617
#define TREE_CODE_CLASS(CODE)
Definition tree.h:203
HOST_WIDE_INT int_bit_position(const_tree field)
Definition tree.h:6809
hashval_t struct_ptr_hash(const void *a)
Definition tree.h:5726
bool desired_pro_or_demotion_p(const_tree to_type, const_tree from_type)
Definition tree.h:6860
tree bit_position(const_tree)
Definition tree.cc:3802
bool decl_address_invariant_p(const_tree)
Definition tree.cc:3953
tree build_poly_int_cst(tree, const poly_wide_int_ref &)
Definition tree.cc:1974
unsigned crc32_string(unsigned, const char *)
Definition tree.cc:9013
tree build_tree_list(tree, tree CXX_MEM_STAT_INFO)
#define BLOCK_SOURCE_LOCATION(NODE)
Definition tree.h:2332
constexpr opt_code all_warnings
Definition tree.h:7015
bool real_minus_onep(const_tree)
Definition tree.cc:3354
unsigned HOST_WIDE_INT tree_to_uhwi(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:6671
vec< tree, va_gc > ** decl_debug_args_lookup(tree)
Definition tree.cc:6139
tree skip_simple_constant_arithmetic(tree)
Definition tree.cc:4200
void set_decl_tls_model(tree, enum tls_model)
Definition tree.cc:1062
bool valid_constant_size_p(const_tree, cst_size_error *=NULL)
Definition tree.cc:6948
#define DECL_UNCHECKED_FUNCTION_CODE(NODE)
Definition tree.h:2942
tree first_field(const_tree) ATTRIBUTE_NONNULL(1)
Definition tree.cc:3565
bool tree_fits_shwi_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6587
void clean_symbol_name(char *)
Definition tree.cc:9025
void SET_TYPE_VECTOR_SUBPARTS(tree node, poly_uint64 subparts)
Definition tree.h:4387
const_tree get_ultimate_context(const_tree)
Definition tree.cc:8691
bool auto_var_p(const_tree)
Definition tree.cc:8515
tree stabilize_reference(tree)
Definition tree.cc:4999
void using_eh_for_cleanups(void)
Definition tree.cc:12972
tree tree_strip_any_location_wrapper(tree exp)
Definition tree.h:4523
tree build_fn_decl(const char *, tree)
Definition tree.cc:5584
bool error_operand_p(const_tree t)
Definition tree.h:4768
tree sign_mask_for(tree)
Definition tree.cc:2848
tree build5_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3, tree arg4 CXX_MEM_STAT_INFO)
Definition tree.h:4913
unsigned int tree_map_hash(const void *)
Definition tree.cc:5977
size_t tree_size(const_tree)
Definition tree.cc:1194
tree lhd_gcc_personality(void)
Definition tree.cc:12456
void set_decl_built_in_function(tree decl, built_in_class fclass, unsigned int fcode)
Definition tree.h:4472
tree vector_cst_elt(const_tree, unsigned int)
Definition tree.cc:10557
bool more_call_expr_args_p(const call_expr_arg_iterator *iter)
Definition tree.h:6122
bool integer_minus_onep(const_tree)
Definition tree.cc:3082
#define IDENTIFIER_LENGTH(NODE)
Definition tree.h:1225
bool tree_fits_sanitize_code_type_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6647
bool built_in_function_equal_p(built_in_function name0, built_in_function name1)
Definition tree.h:6894
bool is_truth_type_for(tree, tree)
Definition tree.cc:11409
tree type_argument_type(const_tree, unsigned) ATTRIBUTE_NONNULL(1)
Definition tree.cc:6532
#define TYPE_UNSIGNED(NODE)
Definition tree.h:963
size_t tree_code_size(enum tree_code)
Definition tree.cc:1081
tree build_complex_type(tree, bool named=false)
Definition tree.cc:7991
#define TREE_CODE(NODE)
Definition tree.h:325
tree build_aligned_type(tree, unsigned int)
Definition tree.cc:5869
bool integer_each_onep(const_tree)
Definition tree.cc:3041
tree build_vector_from_val(tree, tree)
Definition tree.cc:2228
bool handled_component_p(const_tree t)
Definition tree.h:5492
#define TYPE_MODE(NODE)
Definition tree.h:2369
tree cache_integer_cst(tree, bool might_duplicate=false)
Definition tree.cc:2015
tree build_function_type(tree, tree, bool=false)
Definition tree.cc:7703
tree build_real_from_int_cst(tree, const_tree)
Definition tree.cc:2575
tree skip_simple_arithmetic(tree)
Definition tree.cc:4153
tree build_each_one_cst(tree)
Definition tree.cc:2668
tree uniform_vector_p(const_tree)
Definition tree.cc:10761
tree array_ref_up_bound(tree)
Definition tree.cc:13128
unsigned crc32_byte(unsigned chksum, char byte)
Definition tree.h:5659
bool integer_zerop(const_tree)
Definition tree.cc:2992
tree build_complex_inf(tree, bool)
Definition tree.cc:2655
tree tree_strip_sign_nop_conversions(tree)
Definition tree.cc:12355
tree decl_comdat_group_id(const_tree)
Definition tree.cc:984
tree build_clobber(tree, enum clobber_kind=CLOBBER_UNDEF)
Definition tree.cc:2474
tree build_string(unsigned, const char *=NULL)
Definition tree.cc:2608
#define TYPE_SIGN(NODE)
Definition tree.h:966
tree build_call_nary(tree, tree, int,...)
Definition tree.cc:11000
bool builtin_decl_declared_p(enum built_in_function fncode)
Definition tree.h:6249
generic_wide_int< wi::extended_tree< WIDEST_INT_MAX_PRECISION *2 > > widest2_int_cst
Definition tree.h:6445
tree component_ref_size(tree, special_array_member *=NULL)
Definition tree.cc:13448
tree make_node(enum tree_code CXX_MEM_STAT_INFO)
void build_common_builtin_nodes(void)
Definition tree.cc:10028
tree build_builtin_unreachable(location_t)
Definition tree.cc:11249
bool array_ref_flexible_size_p(tree, bool *=NULL)
Definition tree.cc:13162
const char * combined_fn_name(combined_fn)
Definition tree.cc:14938
bool truth_value_p(enum tree_code code)
Definition tree.h:5747
int DECL_FE_FUNCTION_CODE(const_tree decl)
Definition tree.h:4462
#define FUNCTION_DECL_DECL_TYPE(NODE)
Definition tree.h:3470
unsigned int tree_ctz(const_tree)
Definition tree.cc:3183
#define EXPR_LOCATION(NODE)
Definition tree.h:1344
int tree_int_cst_sign_bit(const_tree)
Definition tree.cc:6691
source_range get_expr_source_range(tree expr)
Definition tree.h:1369
#define POINTER_TYPE_P(TYPE)
Definition tree.h:701
tree build_vector_a_then_b(tree, unsigned int, tree, tree)
Definition tree.cc:2325
unsigned int tree_map_base_hash(const void *)
Definition tree.cc:5959
bool decl_address_ip_invariant_p(const_tree)
Definition tree.cc:3990
tree get_typenode_from_name(const char *)
Definition tree.cc:15143
#define CAN_HAVE_LOCATION_P(NODE)
Definition tree.h:1366
#define TREE_TARGET_OPTION(NODE)
Definition tree.h:3727
void find_placeholder_in_expr(tree, vec< tree > *)
Definition tree.cc:4470
#define SSA_NAME_VERSION(NODE)
Definition tree.h:2210
tree decl_type_context(const_tree)
Definition tree.cc:8743
#define TYPE_P(NODE)
Definition tree.h:227
location_t tree_inlined_location(tree, bool=true)
Definition tree.cc:12104
bool operand_equal_for_phi_arg_p(const_tree, const_tree)
Definition tree.cc:11536
tree component_ref_field_offset(tree)
Definition tree.cc:13320
hashval_t iterative_hash_expr(const_tree tree, hashval_t seed)
Definition tree.h:5827
tree upper_bound_in_type(tree, tree)
Definition tree.cc:11450
tree generate_internal_label(const char *)
Definition tree.cc:810
tree uniform_integer_cst_p(tree)
Definition tree.cc:10813
void set_decl_section_name(tree, const char *)
Definition tree.cc:1006
const_tree first_const_call_expr_arg(const_tree exp, const_call_expr_arg_iterator *iter)
Definition tree.h:6113
void set_builtin_decl_implicit_p(enum built_in_function fncode, bool implicit_p)
Definition tree.h:6201
tree decl_comdat_group(const_tree)
Definition tree.cc:974
void recompute_tree_invariant_for_addr_expr(tree)
Definition tree.cc:5080
tree strip_float_extensions(tree)
Definition tree.cc:12364
unsigned get_warning_spec(const_tree)
Definition warning-control.cc:271
tree reconstruct_complex_type(tree, tree)
Definition tree.cc:10362
tree staticp(tree)
Definition tree.cc:3882
tree build_range_type(tree, tree, tree)
Definition tree.cc:7467
void tree_cc_finalize(void)
Definition tree.cc:15734
vec< tree, va_gc > ** decl_debug_args_insert(tree)
Definition tree.cc:6157
#define TREE_CHAIN(NODE)
Definition tree.h:512
bool variably_modified_type_p(tree, tree)
Definition tree.cc:8568
bool builtin_decl_implicit_p(enum built_in_function fncode)
Definition tree.h:6237
tree build_all_ones_cst(tree)
Definition tree.cc:2721
bool fndecl_built_in_p(const_tree node)
Definition tree.h:6915
tree build_call_expr_internal_loc_array(location_t, enum internal_fn, tree, int, const tree *)
bool initializer_zerop(const_tree, bool *=NULL)
Definition tree.cc:10588
tree builtin_decl_explicit(enum built_in_function fncode)
Definition tree.h:6157
bool vec_member(const_tree, vec< tree, va_gc > *)
Definition tree.cc:3498
tree strip_zero_offset_components(tree)
Definition tree.cc:12442
#define VL_EXP_CLASS_P(NODE)
Definition tree.h:278
bool stdarg_p(const_tree)
Definition tree.cc:12016
tree build_complex(tree, tree, tree)
Definition tree.cc:2636
location_t tree_nonartificial_location(tree)
Definition tree.cc:12088
tree build_constructor_va(tree, int,...)
Definition tree.cc:2454
bool tree_nop_conversion_p(const_tree, const_tree)
Definition tree.cc:12265
#define IDENTIFIER_POINTER(NODE)
Definition tree.h:1227
tree walk_tree_without_duplicates_1(tree *, walk_tree_fn, void *, walk_tree_lh)
Definition tree.cc:11930
tree value_member(tree, tree)
Definition tree.cc:3469
#define BUILTIN_VALID_P(FNCODE)
Definition tree.h:6145
tree grow_tree_vec(tree v, int CXX_MEM_STAT_INFO)
int type_num_arguments(const_tree)
Definition tree.cc:6511
bool valid_new_delete_pair_p(tree, tree, bool *=NULL)
Definition tree.cc:15222
constexpr opt_code no_warning
Definition tree.h:7013
#define POLY_INT_CST_P(NODE)
Definition tree.h:1167
void dump_tree_statistics(void)
Definition tree.cc:8915
#define TYPE_REVERSE_STORAGE_ORDER(NODE)
Definition tree.h:1108
tree vector_element_bits_tree(const_tree)
Definition tree.cc:13707
tree build_reference_type_for_mode(tree, machine_mode, bool)
Definition tree.cc:7236
#define TREE_STATIC(NODE)
Definition tree.h:773
int tree_int_cst_compare(const_tree t1, const_tree t2)
Definition tree.h:6772
tree builtin_decl_implicit(enum built_in_function fncode)
Definition tree.h:6166
bool integer_nonzerop(const_tree)
Definition tree.cc:3117
void set_call_expr_flags(tree, int)
Definition tree.cc:9965
#define CALL_EXPR_ARG(NODE, I)
Definition tree.h:1502
int DECL_MD_FUNCTION_CODE(const_tree decl)
Definition tree.h:4451
#define ANY_INTEGRAL_TYPE_P(TYPE)
Definition tree.h:623
tree build_opaque_vector_type(tree, poly_int64)
Definition tree.cc:10502
void set_builtin_decl(enum built_in_function fncode, tree decl, bool implicit_p)
Definition tree.h:6186
tree get_binfo_at_offset(tree, poly_int64, tree)
Definition tree.cc:12512
bool ptrdiff_tree_p(const_tree, poly_int64 *)
Definition tree.cc:3424
tree decl_assembler_name(tree)
Definition tree.cc:845
tree build_constructor_single(tree, tree, tree)
Definition tree.cc:2405
tree force_fit_type(tree, const poly_wide_int_ref &, int, bool)
Definition tree.cc:1688
#define TREE_INT_CST_ELT(NODE, I)
Definition tree.h:1161
tree tree_cons(tree, tree, tree CXX_MEM_STAT_INFO)
bool real_onep(const_tree)
Definition tree.cc:3328
bool initializer_each_zero_or_onep(const_tree)
Definition tree.cc:10722
#define DECL_EXTERNAL(NODE)
Definition tree.h:2987
bool builtin_decl_explicit_p(enum built_in_function fncode)
Definition tree.h:6228
tree size_in_bytes(const_tree t)
Definition tree.h:5229
tree build_nonstandard_boolean_type(unsigned HOST_WIDE_INT)
Definition tree.cc:7361
cl_target_option * target_opts_for_fn(const_tree fndecl)
Definition tree.h:6321
bool location_wrapper_p(const_tree exp)
Definition tree.h:4503
machine_mode element_mode(const_tree)
Definition tree.cc:13643
bool real_maybe_zerop(const_tree)
Definition tree.cc:3378
tree last_field(const_tree) ATTRIBUTE_NONNULL(1)
Definition tree.cc:3577
#define TREE_TYPE(NODE)
Definition tree.h:513
tree bitmask_inv_cst_vector_p(tree)
Definition tree.cc:10834
#define VL_EXP_OPERAND_LENGTH(NODE)
Definition tree.h:1326
#define INTEGRAL_TYPE_P(TYPE)
Definition tree.h:614
machine_mode vector_type_mode(const_tree)
Definition tree.cc:13662
bool fndecl_builtin_alloc_p(const_tree node)
Definition tree.h:6954
tree type_hash_canon(unsigned int, tree)
Definition tree.cc:6413
tree build0(enum tree_code, tree CXX_MEM_STAT_INFO)
void copy_decl_built_in_function(tree newdecl, const_tree olddecl)
Definition tree.h:4483
tree build_uniform_cst(tree, tree)
Definition tree.cc:2266
#define DECL_BUILT_IN_CLASS(NODE)
Definition tree.h:3627
tree nreverse(tree)
Definition tree.cc:3637
tree build_call_array_loc(location_t, tree, tree, int, const tree *)
Definition tree.cc:11032
tree array_type_nelts_minus_one(const_tree)
Definition tree.cc:3832
bool reverse_storage_order_for_component_p(tree t)
Definition tree.h:5513
#define TREE_CODE_LENGTH(CODE)
Definition tree.h:302
tree build_zero_cst(tree)
Definition tree.cc:2777
tree purpose_member(const_tree, tree)
Definition tree.cc:3484
bool cst_and_fits_in_hwi(const_tree)
Definition tree.cc:2155
bool int_fits_type_p(const_tree, const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_PURE
Definition tree.cc:8387
bool tree_fits_poly_uint64_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6628
tree build_int_cst(tree, poly_int64)
Definition tree.cc:1637
unsigned int vector_element_bits(const_tree)
Definition tree.cc:13695
tree build_int_cstu(tree type, poly_uint64)
Definition tree.cc:1649
#define TREE_PUBLIC(NODE)
Definition tree.h:858
bool check_base_type(const_tree cand, const_tree base)
Definition tree.cc:5730
bool storage_order_barrier_p(const_tree t)
Definition tree.h:5551
tree chain_index(int, tree)
Definition tree.cc:3512
bool auto_var_in_fn_p(const_tree, const_tree)
Definition tree.cc:8526
int get_range_pos_neg(tree, gimple *=NULL)
Definition tree.cc:14706
tree build_index_type(tree)
Definition tree.cc:7490
bool associative_tree_code(enum tree_code)
Definition tree.cc:7010
tree build_call_expr_internal_loc(location_t, enum internal_fn, tree, int,...)
Definition tree.cc:11143
tree build_low_bits_mask(tree, unsigned)
Definition tree.cc:2143
tree build_call_expr_loc_array(location_t, tree, int, tree *)
Definition tree.cc:11066
#define TYPE_ARG_TYPES(NODE)
Definition tree.h:2644
bool integer_onep(const_tree)
Definition tree.cc:3016
HOST_WIDE_INT int_cst_value(const_tree)
Definition tree.cc:11305
bool complete_or_array_type_p(const_tree type)
Definition tree.h:5769
tree build_string_literal(unsigned, const char *=NULL, tree=char_type_node, unsigned HOST_WIDE_INT=HOST_WIDE_INT_M1U)
Definition tree.cc:11263
access_mode
Definition tree.h:5995
@ access_deferred
Definition tree.h:6000
@ access_none
Definition tree.h:5996
@ access_read_write
Definition tree.h:5999
@ access_write_only
Definition tree.h:5998
@ access_read_only
Definition tree.h:5997
tree get_qualified_type(tree, int)
Definition tree.cc:5788
wi::tree_to_poly_wide_ref poly_int_cst_value(const_tree x)
Definition tree.h:6618
bool is_access_with_size_p(const_tree)
Definition tree.cc:13619
#define EXPR_LOCATION_WRAPPER_P(NODE)
Definition tree.h:4496
bool internal_fn_p(combined_fn code)
Definition tree.h:64
#define DECL_UID(NODE)
Definition tree.h:2806
HOST_WIDE_INT tree_to_shwi(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:6660
unsigned crc32_unsigned(unsigned chksum, unsigned value)
Definition tree.h:5654
tree build_call_vec(tree, tree, const vec< tree, va_gc > *)
Definition tree.cc:11049
void init_ttree(void)
Definition tree.cc:761
tree tree_block(tree)
Definition tree.cc:11942
tree array_ref_low_bound(tree)
Definition tree.cc:13105
void decl_debug_expr_insert(tree, tree)
Definition tree.cc:6095
bool valid_vector_subparts_p(poly_uint64 subparts)
Definition tree.h:4423
tree tree_strip_nop_conversions(tree)
Definition tree.cc:12344
tree build1_loc(location_t loc, enum tree_code code, tree type, tree arg1 CXX_MEM_STAT_INFO)
Definition tree.h:4873
int tree_operand_length(const_tree node)
Definition tree.h:4293
hashval_t type_hash_canon_hash(tree)
Definition tree.cc:6182
bool type_with_alias_set_p(const_tree t)
Definition tree.h:6818
bool check_qualified_type(const_tree, const_tree, int)
Definition tree.cc:5757
tree make_int_cst(int, int CXX_MEM_STAT_INFO)
tree build_call_expr(tree, int,...)
Definition tree.cc:11108
#define REF_REVERSE_STORAGE_ORDER(NODE)
Definition tree.h:1126
bool tree_int_cst_le(const_tree t1, const_tree t2)
Definition tree.h:6762
tree build_distinct_type_copy(tree CXX_MEM_STAT_INFO)
bool types_same_for_odr(const_tree type1, const_tree type2)
Definition ipa-devirt.cc:361
tree build_varargs_function_type_array(tree, int, tree *)
Definition tree.cc:7858
tree build2(enum tree_code, tree, tree, tree CXX_MEM_STAT_INFO)
poly_uint64 tree_to_poly_uint64(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:3457
bool prototype_p(const_tree)
Definition tree.cc:12038
#define TREE_HASH(NODE)
Definition tree.h:551
tree copy_list(tree)
Definition tree.cc:1549
tree substitute_placeholder_in_expr(tree, tree)
Definition tree.cc:4736
#define ALLOCA_FUNCTION_CODE_P(FCODE)
Definition tree.h:2946
tree build_call_expr_loc(location_t, tree, int,...)
Definition tree.cc:11091
#define DECL_NONALIASED(NODE)
Definition tree.h:3427
bool trunc_or_exact_div_p(tree_code code)
Definition tree.h:5740
tree build5(enum tree_code, tree, tree, tree, tree, tree, tree CXX_MEM_STAT_INFO)
void prepare_target_option_nodes_for_pch(void)
Definition tree.cc:12235
struct cl_optimization * opts_for_fn(const_tree fndecl)
Definition tree.h:6311
bool type_contains_placeholder_p(tree)
Definition tree.cc:4424
#define VECTOR_CST_NPATTERNS(NODE)
Definition tree.h:1209
bool id_equal(const_tree id, const char *str)
Definition tree.h:4351
special_array_member
Definition tree.h:5913
@ none
Definition tree.h:5914
@ int_0
Definition tree.h:5915
@ trail_0
Definition tree.h:5916
@ trail_n
Definition tree.h:5918
@ trail_1
Definition tree.h:5917
@ int_n
Definition tree.h:5919
#define error_mark_node
Definition tree.h:4531
tree build_nt_call_vec(tree, vec< tree, va_gc > *)
Definition tree.cc:5524
bool fixed_zerop(const_tree)
Definition tree.cc:3147
tree decl_debug_expr_lookup(tree)
Definition tree.cc:6081
const_tree strip_pointer_types(const_tree type)
Definition tree.h:5119
tree build_array_type(tree, tree, bool=false)
Definition tree.cc:7598
#define TREE_VEC_END(NODE)
Definition tree.h:1246
void protected_set_expr_location_if_unset(tree, location_t)
Definition tree.cc:5651
tree build_real_from_wide(tree, const wide_int_ref &, signop)
Definition tree.cc:2590
tree build_decl(location_t, enum tree_code, tree, tree CXX_MEM_STAT_INFO)
tree truth_type_for(tree)
Definition tree.cc:11434
tree substitute_in_expr(tree, tree, tree)
Definition tree.cc:4544
tree get_unwidened(tree, tree)
Definition tree.cc:8192
bool tree_fits_poly_int64_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6598
tree build_nt(enum tree_code,...)
Definition tree.cc:5499
tree make_tree_vec(int CXX_MEM_STAT_INFO)
#define TREE_ADDRESSABLE(NODE)
Definition tree.h:745
bool is_typedef_decl(const_tree x)
Definition tree.h:5699
bool subrange_type_for_debug_p(const_tree, tree *, tree *)
Definition tree.cc:7501
#define SET_EXPR_LOCATION(NODE, LOCUS)
Definition tree.h:1346
tree build_method_type(tree, tree)
Definition tree.cc:7931
tree make_vector(unsigned, unsigned CXX_MEM_STAT_INFO)
internal_fn as_internal_fn(combined_fn code)
Definition tree.h:73
WARN_UNUSED_RESULT tree maybe_wrap_with_location(tree, location_t)
Definition tree.cc:14895
int single_nonzero_element(const_tree)
Definition tree.cc:10889
HOST_WIDE_INT int_byte_position(const_tree)
Definition tree.cc:3823
void verify_constructor_flags(tree)
Definition tree.cc:2370
tree copy_node(tree CXX_MEM_STAT_INFO)
void error_unavailable_use(tree, tree)
Definition tree.cc:12734
bool chain_member(const_tree, const_tree)
Definition tree.cc:3522
bool using_eh_for_cleanups_p(void)
Definition tree.cc:12979
#define DECL_FIELD_OFFSET(NODE)
Definition tree.h:3122
#define VECTOR_CST_NELTS_PER_PATTERN(NODE)
Definition tree.h:1211
bool integer_pow2p(const_tree)
Definition tree.cc:3097
combined_fn as_combined_fn(built_in_function fn)
Definition tree.h:30
void set_function_decl_type(tree decl, function_decl_type t, bool set)
Definition tree.h:3477
vec< tree, va_gc > * ctor_to_vec(tree)
Definition tree.cc:3706
#define NULL_TREE
Definition tree.h:318
bool gimple_canonical_types_compatible_p(const_tree, const_tree, bool trust_type_canonical=true)
Definition tree.cc:13993
tree make_tree_binfo(unsigned CXX_MEM_STAT_INFO)
tree lower_bound_in_type(tree, tree)
Definition tree.cc:11503
tree get_base_address(tree t)
Definition tree.cc:13058
tree get_file_function_name(const char *)
Definition tree.cc:9080
priority_type decl_fini_priority_lookup(tree)
Definition tree.cc:6006
tree get_callee_fndecl(const_tree)
Definition tree.cc:8780
const_tree strip_invariant_refs(const_tree)
Definition tree.cc:12412
int list_length(const_tree)
Definition tree.cc:3539
tree build_translation_unit_decl(tree)
Definition tree.cc:5603
tree build_nonshared_range_type(tree, tree, tree)
Definition tree.cc:7475
tree double_int_to_tree(tree, double_int)
Definition tree.cc:1667
tree build_tree_list_vec(const vec< tree, va_gc > *CXX_MEM_STAT_INFO)
#define POLY_INT_CST_COEFF(NODE, I)
Definition tree.h:1171
#define VECTOR_TYPE_P(TYPE)
Definition tree.h:602
int tree_log2(const_tree)
Definition tree.cc:3159
int compare_tree_int(const_tree, unsigned HOST_WIDE_INT)
Definition tree.cc:6927
tree build_index_vector(tree, poly_uint64, poly_uint64)
Definition tree.cc:2303
tree get_ref_from_access_with_size(tree)
Definition tree.cc:13631
void set_builtin_decl_declared_p(enum built_in_function fncode, bool declared_p)
Definition tree.h:6214
tree build_target_option_node(struct gcc_options *opts, struct gcc_options *opts_set)
Definition tree.cc:12206
tree build_qualified_type(tree, int CXX_MEM_STAT_INFO)
bool is_global_var(const_tree t)
Definition tree.h:6287
#define TREE_INT_CST_EXT_NUNITS(NODE)
Definition tree.h:1159
tree build_constructor(tree, vec< constructor_elt, va_gc > *CXX_MEM_STAT_INFO)
tree array_ref_element_size(tree)
Definition tree.cc:13077
#define TYPE_UID(NODE)
Definition tree.h:2350
#define char_type_node
Definition tree.h:4753
#define TREE_OPERAND_LENGTH(NODE)
Definition tree.h:1318
tree chainon(tree, tree)
Definition tree.cc:3597
const char * decl_section_name(const_tree)
Definition tree.cc:995
tree build_one_cst(tree)
Definition tree.cc:2683
tree walk_tree_1(tree *, walk_tree_fn, void *, hash_set< tree > *, walk_tree_lh)
Definition tree.cc:11650
bool virtual_method_call_p(const_tree, bool=false)
Definition tree.cc:12472
bool has_warning_spec(const_tree)
Definition warning-control.cc:262
bool tree_int_cst_equal(const_tree, const_tree)
Definition tree.cc:6564
bool contains_bitfld_component_ref_p(const_tree)
Definition tree.cc:12808
bool may_be_aliased(const_tree var)
Definition tree.h:6297
#define WIDEST_INT_MAX_PRECISION
Definition wide-int.h:257
generic_wide_int< wide_int_ref_storage< false > > wide_int_ref
Definition wide-int.h:353
#define OFFSET_INT_ELTS
Definition wide-int.h:281
#define ADDR_MAX_PRECISION
Definition wide-int.h:276
generic_wide_int< wide_int_storage > wide_int
Definition wide-int.h:343
const T2 & y
Definition wide-int.h:3870