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