]> gcc.gnu.org Git - gcc.git/blame - gcc/tree.h
git://gcc.gnu.org / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
trans-io.c (set_string): Use fold_build2 and build_int_cst instead of build2 and...
[gcc.git] / gcc / tree.h
CommitLineData
8da1b058 1/* Front-end tree definitions for GNU compiler.
1574ef13 2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
71d59383 3 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
8da1b058 4
1322177d 5This file is part of GCC.
8da1b058 6
1322177d
LB		 7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
8da1b058 11
1322177d
LB		 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
8da1b058
RS		 16
17You should have received a copy of the GNU General Public License
1322177d 18along with GCC; see the file COPYING. If not, write to the Free
366ccddb
KC		 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
2002110-1301, USA. */
8da1b058 21
df89f8e7
GDR		 22#ifndef GCC_TREE_H
23#define GCC_TREE_H
24
8da1b058 25#include "machmode.h"
6060edcb 26#include "input.h"
b9dcdee4 27#include "statistics.h"
fa743e8c 28#include "vec.h"
8da1b058 29
d6b12657 30/* Codes of tree nodes */
8da1b058
RS		 31
32#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM,
33
34enum tree_code {
35#include "tree.def"
36
6dc42e49 37 LAST_AND_UNUSED_TREE_CODE /* A convenient way to get a value for
cdc9d803 38 NUM_TREE_CODES. */
8da1b058
RS		 39};
40
41#undef DEFTREECODE
42
820cc88f
DB		 43extern unsigned char tree_contains_struct[256][64];
44#define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)])
45
8d5e6e25
RK		 46/* Number of language-independent tree codes. */
47#define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)
8da1b058 48
6615c446
JO		 49/* Tree code classes. */
50
51/* Each tree_code has an associated code class represented by a
52 TREE_CODE_CLASS. */
53
54enum tree_code_class {
55 tcc_exceptional, /* An exceptional code (fits no category). */
56 tcc_constant, /* A constant. */
38b3627d 57 /* Order of tcc_type and tcc_declaration is important. */
6615c446
JO		 58 tcc_type, /* A type object code. */
59 tcc_declaration, /* A declaration (also serving as variable refs). */
60 tcc_reference, /* A reference to storage. */
61 tcc_comparison, /* A comparison expression. */
62 tcc_unary, /* A unary arithmetic expression. */
63 tcc_binary, /* A binary arithmetic expression. */
64 tcc_statement, /* A statement expression, which have side effects
65 but usually no interesting value. */
66 tcc_expression /* Any other expression. */
67};
68
69/* Each tree code class has an associated string representation.
70 These must correspond to the tree_code_class entries. */
71
b85e3643 72extern const char *const tree_code_class_strings[];
6615c446
JO		 73
74/* Returns the string representing CLASS. */
75
76#define TREE_CODE_CLASS_STRING(CLASS)\
77 tree_code_class_strings[(int) (CLASS)]
8da1b058 78
0a6969ad 79#define MAX_TREE_CODES 256
6615c446 80extern const enum tree_code_class tree_code_type[];
0a6969ad 81#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
8da1b058 82
6615c446
JO		 83/* Nonzero if CODE represents an exceptional code. */
84
85#define EXCEPTIONAL_CLASS_P(CODE)\
86 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional)
87
88/* Nonzero if CODE represents a constant. */
89
90#define CONSTANT_CLASS_P(CODE)\
91 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant)
92
93/* Nonzero if CODE represents a type. */
94
95#define TYPE_P(CODE)\
96 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type)
97
98/* Nonzero if CODE represents a declaration. */
99
100#define DECL_P(CODE)\
101 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration)
102
326eda4b
DB		 103/* Nonzero if CODE represents a memory tag. */
104
105#define MTAG_P(CODE) \
106 (TREE_CODE (CODE) == STRUCT_FIELD_TAG \
107 || TREE_CODE (CODE) == NAME_MEMORY_TAG \
18cd8a03 108 || TREE_CODE (CODE) == SYMBOL_MEMORY_TAG)
326eda4b
DB		 109
110
820cc88f
DB		 111/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */
112
113#define VAR_OR_FUNCTION_DECL_P(DECL)\
114 (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)
115
38b3627d
NS		 116/* Nonzero if CODE represents a INDIRECT_REF. Keep these checks in
117 ascending code order. */
820cc88f 118
1b096a0a
DB		 119#define INDIRECT_REF_P(CODE)\
120 (TREE_CODE (CODE) == INDIRECT_REF \
38b3627d
NS		 121 || TREE_CODE (CODE) == ALIGN_INDIRECT_REF \
122 || TREE_CODE (CODE) == MISALIGNED_INDIRECT_REF)
1b096a0a 123
6615c446
JO		 124/* Nonzero if CODE represents a reference. */
125
126#define REFERENCE_CLASS_P(CODE)\
127 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_reference)
128
129/* Nonzero if CODE represents a comparison. */
130
131#define COMPARISON_CLASS_P(CODE)\
132 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison)
133
134/* Nonzero if CODE represents a unary arithmetic expression. */
135
136#define UNARY_CLASS_P(CODE)\
137 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary)
138
139/* Nonzero if CODE represents a binary arithmetic expression. */
140
141#define BINARY_CLASS_P(CODE)\
142 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary)
143
144/* Nonzero if CODE represents a statement expression. */
145
146#define STATEMENT_CLASS_P(CODE)\
147 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement)
148
149/* Nonzero if CODE represents any other expression. */
150
151#define EXPRESSION_CLASS_P(CODE)\
152 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression)
153
6615c446
JO		 154/* Returns nonzero iff CODE represents a type or declaration. */
155
156#define IS_TYPE_OR_DECL_P(CODE)\
157 (TYPE_P (CODE) || DECL_P (CODE))
4f976745 158
0e9e1e0a 159/* Returns nonzero iff CLASS is the tree-code class of an
4da05956
MM		 160 expression. */
161
6615c446 162#define IS_EXPR_CODE_CLASS(CLASS)\
4600cc14 163 ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
c25d44dd
JM		 164
165/* Returns nonzero iff NODE is an expression of some kind. */
166
167#define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
4da05956 168
50674e96
DN		 169/* Returns nonzero iff NODE is an OpenMP directive. */
170
171#define OMP_DIRECTIVE_P(NODE) \
172 (TREE_CODE (NODE) == OMP_PARALLEL \
50674e96 173 || TREE_CODE (NODE) == OMP_FOR \
777f7f9a 174 || TREE_CODE (NODE) == OMP_SECTIONS \
50674e96 175 || TREE_CODE (NODE) == OMP_SINGLE \
777f7f9a 176 || TREE_CODE (NODE) == OMP_SECTION \
50674e96
DN		 177 || TREE_CODE (NODE) == OMP_MASTER \
178 || TREE_CODE (NODE) == OMP_ORDERED \
777f7f9a
RH		 179 || TREE_CODE (NODE) == OMP_CRITICAL \
180 || TREE_CODE (NODE) == OMP_RETURN \
181 || TREE_CODE (NODE) == OMP_CONTINUE)
50674e96 182
8da1b058
RS		 183/* Number of argument-words in each kind of tree-node. */
184
2f9834e8 185extern const unsigned char tree_code_length[];
8d5e6e25 186#define TREE_CODE_LENGTH(CODE) tree_code_length[(int) (CODE)]
8da1b058
RS		 187
188/* Names of tree components. */
189
2f9834e8 190extern const char *const tree_code_name[];
fa743e8c 191
d4e6fecb
NS		 192/* A vectors of trees. */
193DEF_VEC_P(tree);
194DEF_VEC_ALLOC_P(tree,gc);
195DEF_VEC_ALLOC_P(tree,heap);
fa743e8c 196
8da1b058 197\f
9df2c88c
RK		 198/* Classify which part of the compiler has defined a given builtin function.
199 Note that we assume below that this is no more than two bits. */
26db82d8
BS		 200enum built_in_class
201{
202 NOT_BUILT_IN = 0,
203 BUILT_IN_FRONTEND,
204 BUILT_IN_MD,
205 BUILT_IN_NORMAL
206};
9df2c88c
RK		 207
208/* Names for the above. */
fd05eb80 209extern const char *const built_in_class_names[4];
9df2c88c 210
8da1b058
RS		 211/* Codes that identify the various built in functions
212 so that expand_call can identify them quickly. */
213
c6a912da 214#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM,
8da1b058
RS		 215enum built_in_function
216{
cb1072f4 217#include "builtins.def"
972ded9c 218
7e7e470f
RH		 219 /* Complex division routines in libgcc. These are done via builtins
220 because emit_library_call_value can't handle complex values. */
221 BUILT_IN_COMPLEX_MUL_MIN,
222 BUILT_IN_COMPLEX_MUL_MAX
223 = BUILT_IN_COMPLEX_MUL_MIN
224 + MAX_MODE_COMPLEX_FLOAT
225 - MIN_MODE_COMPLEX_FLOAT,
226
227 BUILT_IN_COMPLEX_DIV_MIN,
228 BUILT_IN_COMPLEX_DIV_MAX
229 = BUILT_IN_COMPLEX_DIV_MIN
230 + MAX_MODE_COMPLEX_FLOAT
231 - MIN_MODE_COMPLEX_FLOAT,
232
2ba84f36 233 /* Upper bound on non-language-specific builtins. */
972ded9c 234 END_BUILTINS
8da1b058 235};
cb1072f4 236#undef DEF_BUILTIN
9df2c88c
RK		 237
238/* Names for the above. */
7e7e470f 239extern const char * built_in_names[(int) END_BUILTINS];
3ff5f682 240
82b4201f
KG		 241/* Helper macros for math builtins. */
242
243#define BUILTIN_EXP10_P(FN) \
244 ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \
245 || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L)
246
247#define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \
248 || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \
249 || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L)
250
251#define BUILTIN_SQRT_P(FN) \
252 ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL)
253
254#define BUILTIN_CBRT_P(FN) \
255 ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL)
256
257#define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN))
258
ea6a6627
VR		 259#define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
260#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL
261
3ff5f682 262/* An array of _DECL trees for the above. */
17211ab5 263extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
272f51a3 264extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];
8da1b058 265\f
aaf46ef9
DN		 266/* In an OMP_CLAUSE node. */
267
268/* Number of operands and names for each clause. */
269extern unsigned const char omp_clause_num_ops[];
270extern const char * const omp_clause_code_name[];
271
272/* Clause codes. Do not reorder, as this is used to index into the tables
273 omp_clause_num_ops and omp_clause_code_name. */
274enum omp_clause_code
275{
276 /* Clause zero is special-cased inside the parser
277 (c_parser_omp_variable_list). */
278 OMP_CLAUSE_ERROR = 0,
279
280 /* OpenMP clause: private (variable_list). */
281 OMP_CLAUSE_PRIVATE,
282
283 /* OpenMP clause: shared (variable_list). */
284 OMP_CLAUSE_SHARED,
285
286 /* OpenMP clause: firstprivate (variable_list). */
287 OMP_CLAUSE_FIRSTPRIVATE,
288
289 /* OpenMP clause: lastprivate (variable_list). */
290 OMP_CLAUSE_LASTPRIVATE,
291
292 /* OpenMP clause: reduction (operator:variable_list).
293 OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator.
294 Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var.
295 Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var
296 into the shared one.
297 Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL
298 placeholder used in OMP_CLAUSE_REDUCTION_MERGE. */
299 OMP_CLAUSE_REDUCTION,
300
301 /* OpenMP clause: copyin (variable_list). */
302 OMP_CLAUSE_COPYIN,
303
304 /* OpenMP clause: copyprivate (variable_list). */
305 OMP_CLAUSE_COPYPRIVATE,
306
307 /* OpenMP clause: if (scalar-expression). */
308 OMP_CLAUSE_IF,
309
310 /* OpenMP clause: num_threads (integer-expression). */
311 OMP_CLAUSE_NUM_THREADS,
312
313 /* OpenMP clause: schedule. */
314 OMP_CLAUSE_SCHEDULE,
315
316 /* OpenMP clause: nowait. */
317 OMP_CLAUSE_NOWAIT,
318
319 /* OpenMP clause: ordered. */
320 OMP_CLAUSE_ORDERED,
321
322 /* OpenMP clause: default. */
323 OMP_CLAUSE_DEFAULT
324};
325\f
8da1b058
RS		 326/* The definition of tree nodes fills the next several pages. */
327
328/* A tree node can represent a data type, a variable, an expression
329 or a statement. Each node has a TREE_CODE which says what kind of
330 thing it represents. Some common codes are:
331 INTEGER_TYPE -- represents a type of integers.
332 ARRAY_TYPE -- represents a type of pointer.
333 VAR_DECL -- represents a declared variable.
334 INTEGER_CST -- represents a constant integer value.
335 PLUS_EXPR -- represents a sum (an expression).
336
337 As for the contents of a tree node: there are some fields
338 that all nodes share. Each TREE_CODE has various special-purpose
339 fields as well. The fields of a node are never accessed directly,
340 always through accessor macros. */
341
8da1b058
RS		 342/* Every kind of tree node starts with this structure,
343 so all nodes have these fields.
344
76c9d226 345 See the accessor macros, defined below, for documentation of the
eebedaa5 346 fields. */
6de9cd9a 347union tree_ann_d;
8da1b058 348
e2500fed 349struct tree_common GTY(())
8da1b058 350{
2f78c311
ZW		 351 tree chain;
352 tree type;
6de9cd9a 353 union tree_ann_d *ann;
ae34ac46 354
c149cc37 355 ENUM_BITFIELD(tree_code) code : 8;
ae34ac46 356
8da1b058
RS		 357 unsigned side_effects_flag : 1;
358 unsigned constant_flag : 1;
8da1b058
RS		 359 unsigned addressable_flag : 1;
360 unsigned volatile_flag : 1;
361 unsigned readonly_flag : 1;
362 unsigned unsigned_flag : 1;
363 unsigned asm_written_flag: 1;
6de9cd9a 364 unsigned nowarning_flag : 1;
4f976745 365
6de9cd9a 366 unsigned used_flag : 1;
12a22e76 367 unsigned nothrow_flag : 1;
8da1b058
RS		 368 unsigned static_flag : 1;
369 unsigned public_flag : 1;
370 unsigned private_flag : 1;
371 unsigned protected_flag : 1;
e23bd218 372 unsigned deprecated_flag : 1;
6de9cd9a 373 unsigned invariant_flag : 1;
8da1b058
RS		 374
375 unsigned lang_flag_0 : 1;
376 unsigned lang_flag_1 : 1;
377 unsigned lang_flag_2 : 1;
378 unsigned lang_flag_3 : 1;
379 unsigned lang_flag_4 : 1;
380 unsigned lang_flag_5 : 1;
381 unsigned lang_flag_6 : 1;
6de9cd9a 382 unsigned visited : 1;
8da1b058
RS		 383};
384
a5f99f01
RK		 385/* The following table lists the uses of each of the above flags and
386 for which types of nodes they are defined. Note that expressions
387 include decls.
388
389 addressable_flag:
390
391 TREE_ADDRESSABLE in
46c5ad27 392 VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
1574ef13
AO		 393 ..._TYPE, IDENTIFIER_NODE.
394 In a STMT_EXPR, it means we want the result of the enclosed
395 expression.
6de9cd9a 396 CALL_EXPR_TAILCALL in CALL_EXPR
a5f99f01
RK		 397
398 static_flag:
399
400 TREE_STATIC in
e5e809f4 401 VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR
604a3205 402 BINFO_VIRTUAL_P in
809e3e7f 403 TREE_BINFO
a5f99f01 404 TREE_CONSTANT_OVERFLOW in
69ef87e2 405 INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
a5f99f01
RK		 406 TREE_SYMBOL_REFERENCED in
407 IDENTIFIER_NODE
659e5a7a 408 CLEANUP_EH_ONLY in
5a508662 409 TARGET_EXPR, WITH_CLEANUP_EXPR
6de9cd9a
DN		 410 ASM_INPUT_P in
411 ASM_EXPR
412 EH_FILTER_MUST_NOT_THROW in EH_FILTER_EXPR
22421b79
RK		 413 TYPE_REF_CAN_ALIAS_ALL in
414 POINTER_TYPE, REFERENCE_TYPE
a5f99f01
RK		 415
416 public_flag:
417
418 TREE_OVERFLOW in
69ef87e2 419 INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
a5f99f01 420 TREE_PUBLIC in
4c521bad 421 VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
6de9cd9a
DN		 422 ASM_VOLATILE_P in
423 ASM_EXPR
89b0433e
NS		 424 TYPE_CACHED_VALUES_P in
425 ..._TYPE
7f5e6307
RH		 426 SAVE_EXPR_RESOLVED_P in
427 SAVE_EXPR
953ff289
DN		 428 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
429 OMP_CLAUSE_LASTPRIVATE
430 OMP_CLAUSE_PRIVATE_DEBUG in
431 OMP_CLAUSE_PRIVATE
a5f99f01
RK		 432
433 private_flag:
434
a5f99f01 435 TREE_PRIVATE in
659e5a7a 436 ..._DECL
fa47911c 437 CALL_EXPR_RETURN_SLOT_OPT in
4977bab6 438 CALL_EXPR
d8472c75
JM		 439 DECL_BY_REFERENCE in
440 PARM_DECL, RESULT_DECL
777f7f9a
RH		 441 OMP_RETURN_NOWAIT in
442 OMP_RETURN
443 OMP_SECTION_LAST in
444 OMP_SECTION
a5f99f01
RK		 445
446 protected_flag:
447
a5f99f01
RK		 448 TREE_PROTECTED in
449 BLOCK
659e5a7a 450 ..._DECL
dd292d0a 451 CALL_FROM_THUNK_P in
caf93cb0 452 CALL_EXPR
a5f99f01
RK		 453
454 side_effects_flag:
455
456 TREE_SIDE_EFFECTS in
457 all expressions
4f976745
RK		 458 all decls
459 all constants
a5f99f01 460
6de9cd9a
DN		 461 FORCED_LABEL in
462 LABEL_DECL
463
a5f99f01
RK		 464 volatile_flag:
465
466 TREE_THIS_VOLATILE in
467 all expressions
468 TYPE_VOLATILE in
469 ..._TYPE
470
471 readonly_flag:
472
473 TREE_READONLY in
e5e809f4 474 all expressions
a5f99f01
RK		 475 TYPE_READONLY in
476 ..._TYPE
477
478 constant_flag:
479
480 TREE_CONSTANT in
481 all expressions
4f976745
RK		 482 all decls
483 all constants
ad50bc8d
RH		 484 TYPE_SIZES_GIMPLIFIED
485 ..._TYPE
a5f99f01 486
a5f99f01
RK		 487 unsigned_flag:
488
8df83eae
RK		 489 TYPE_UNSIGNED in
490 all types
a150de29
RK		 491 DECL_UNSIGNED in
492 all decls
493 BIT_FIELD_REF_UNSIGNED in
494 BIT_FIELD_REF
a5f99f01
RK		 495
496 asm_written_flag:
497
498 TREE_ASM_WRITTEN in
499 VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
6de9cd9a 500 BLOCK, SSA_NAME
a5f99f01
RK		 501
502 used_flag:
503
504 TREE_USED in
505 expressions, IDENTIFIER_NODE
506
12a22e76 507 nothrow_flag:
a5f99f01 508
12a22e76
JM		 509 TREE_NOTHROW in
510 CALL_EXPR, FUNCTION_DECL
a5f99f01 511
1e2d4dc1
RK		 512 TYPE_ALIGN_OK in
513 ..._TYPE
514
5cb2183e 515 TREE_THIS_NOTRAP in
7ccf35ed 516 (ALIGN/MISALIGNED_)INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF
5cb2183e 517
e23bd218
IR		 518 deprecated_flag:
519
520 TREE_DEPRECATED in
521 ..._DECL
dd292d0a 522
a0203ca7
AO		 523 IDENTIFIER_TRANSPARENT_ALIAS in
524 IDENTIFIER_NODE
525
6de9cd9a
DN		 526 visited:
527
528 Used in tree traversals to mark visited nodes.
529
530 invariant_flag:
531
532 TREE_INVARIANT in
533 all expressions.
534
535 nowarning_flag:
536
537 TREE_NO_WARNING in
73022c2a 538 ... any expr or decl node
e23bd218 539*/
820cc88f
DB		 540#undef DEFTREESTRUCT
541#define DEFTREESTRUCT(ENUM, NAME) ENUM,
542enum tree_node_structure_enum {
543#include "treestruct.def"
544 LAST_TS_ENUM
545};
546#undef DEFTREESTRUCT
a6d7adfd 547
8da1b058
RS		 548/* Define accessors for the fields that all tree nodes have
549 (though some fields are not used for all kinds of nodes). */
550
551/* The tree-code says what kind of node it is.
552 Codes are defined in tree.def. */
553#define TREE_CODE(NODE) ((enum tree_code) (NODE)->common.code)
7e7c843f 554#define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (VALUE))
8da1b058 555
12b195d9 556/* When checking is enabled, errors will be generated if a tree node
0e61db61 557 is accessed incorrectly. The macros die with a fatal error. */
f4524c9e 558#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
12b195d9 559
7f42b6d7
RK		 560#define TREE_CHECK(T, CODE) __extension__ \
561({ const tree __t = (T); \
562 if (TREE_CODE (__t) != (CODE)) \
086e3095
NS		 563 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
564 (CODE), 0); \
565 __t; })
566
567#define TREE_NOT_CHECK(T, CODE) __extension__ \
568({ const tree __t = (T); \
569 if (TREE_CODE (__t) == (CODE)) \
570 tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
571 (CODE), 0); \
8f985ec4 572 __t; })
7f42b6d7 573
eb34af89
RK		 574#define TREE_CHECK2(T, CODE1, CODE2) __extension__ \
575({ const tree __t = (T); \
576 if (TREE_CODE (__t) != (CODE1) \
577 && TREE_CODE (__t) != (CODE2)) \
086e3095
NS		 578 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
579 (CODE1), (CODE2), 0); \
580 __t; })
581
582#define TREE_NOT_CHECK2(T, CODE1, CODE2) __extension__ \
583({ const tree __t = (T); \
584 if (TREE_CODE (__t) == (CODE1) \
585 || TREE_CODE (__t) == (CODE2)) \
586 tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
587 (CODE1), (CODE2), 0); \
eb34af89
RK		 588 __t; })
589
590#define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \
591({ const tree __t = (T); \
592 if (TREE_CODE (__t) != (CODE1) \
593 && TREE_CODE (__t) != (CODE2) \
594 && TREE_CODE (__t) != (CODE3)) \
086e3095
NS		 595 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
596 (CODE1), (CODE2), (CODE3), 0); \
597 __t; })
598
599#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \
600({ const tree __t = (T); \
601 if (TREE_CODE (__t) == (CODE1) \
602 || TREE_CODE (__t) == (CODE2) \
603 || TREE_CODE (__t) == (CODE3)) \
604 tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
605 (CODE1), (CODE2), (CODE3), 0); \
eb34af89
RK		 606 __t; })
607
22421b79
RK		 608#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \
609({ const tree __t = (T); \
610 if (TREE_CODE (__t) != (CODE1) \
611 && TREE_CODE (__t) != (CODE2) \
612 && TREE_CODE (__t) != (CODE3) \
613 && TREE_CODE (__t) != (CODE4)) \
086e3095
NS		 614 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
615 (CODE1), (CODE2), (CODE3), (CODE4), 0); \
616 __t; })
617
618#define NON_TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \
619({ const tree __t = (T); \
620 if (TREE_CODE (__t) == (CODE1) \
621 || TREE_CODE (__t) == (CODE2) \
622 || TREE_CODE (__t) == (CODE3) \
623 || TREE_CODE (__t) == (CODE4)) \
624 tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
625 (CODE1), (CODE2), (CODE3), (CODE4), 0); \
22421b79
RK		 626 __t; })
627
eb34af89
RK		 628#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
629({ const tree __t = (T); \
630 if (TREE_CODE (__t) != (CODE1) \
631 && TREE_CODE (__t) != (CODE2) \
632 && TREE_CODE (__t) != (CODE3) \
633 && TREE_CODE (__t) != (CODE4) \
634 && TREE_CODE (__t) != (CODE5)) \
086e3095
NS		 635 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
636 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
637 __t; })
638
639#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
640({ const tree __t = (T); \
641 if (TREE_CODE (__t) == (CODE1) \
642 || TREE_CODE (__t) == (CODE2) \
643 || TREE_CODE (__t) == (CODE3) \
644 || TREE_CODE (__t) == (CODE4) \
645 || TREE_CODE (__t) == (CODE5)) \
646 tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
647 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
eb34af89
RK		 648 __t; })
649
820cc88f
DB		 650#define CONTAINS_STRUCT_CHECK(T, STRUCT) __extension__ \
651({ const tree __t = (T); \
652 if (tree_contains_struct[TREE_CODE(__t)][(STRUCT)] != 1) \
653 tree_contains_struct_check_failed (__t, (STRUCT), __FILE__, __LINE__, \
654 __FUNCTION__); \
655 __t; })
656
7f42b6d7
RK		 657#define TREE_CLASS_CHECK(T, CLASS) __extension__ \
658({ const tree __t = (T); \
659 if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \
660 tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__, \
b9daac31 661 __FUNCTION__); \
8f985ec4
ZW		 662 __t; })
663
953ff289
DN		 664#define TREE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \
665({ const tree __t = (T); \
aaf46ef9 666 if (TREE_CODE (__t) < (CODE1) || TREE_CODE (__t) > (CODE2)) \
953ff289
DN		 667 tree_range_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
668 (CODE1), (CODE2)); \
669 __t; })
670
aaf46ef9
DN		 671#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) __extension__ \
672({ const tree __t = (T); \
673 if (TREE_CODE (__t) != OMP_CLAUSE) \
674 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
675 OMP_CLAUSE, 0); \
676 if (__t->omp_clause.code != (CODE)) \
677 omp_clause_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
678 (CODE)); \
679 __t; })
680
681#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \
682({ const tree __t = (T); \
683 if (TREE_CODE (__t) != OMP_CLAUSE) \
684 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
685 OMP_CLAUSE, 0); \
686 if ((int) __t->omp_clause.code < (int) (CODE1) \
687 || (int) __t->omp_clause.code > (int) (CODE2)) \
688 omp_clause_range_check_failed (__t, __FILE__, __LINE__, \
689 __FUNCTION__, (CODE1), (CODE2)); \
690 __t; })
691
8f985ec4 692/* These checks have to be special cased. */
7f42b6d7
RK		 693#define EXPR_CHECK(T) __extension__ \
694({ const tree __t = (T); \
695 char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
68ad9159 696 if (!IS_EXPR_CODE_CLASS (__c)) \
6615c446 697 tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__, \
4f976745
RK		 698 __FUNCTION__); \
699 __t; })
700
701/* These checks have to be special cased. */
702#define NON_TYPE_CHECK(T) __extension__ \
703({ const tree __t = (T); \
3f724eb8 704 if (TYPE_P (__t)) \
dd5827cb
ILT		 705 tree_not_class_check_failed (__t, tcc_type, __FILE__, __LINE__, \
706 __FUNCTION__); \
8f985ec4
ZW		 707 __t; })
708
7f42b6d7
RK		 709#define TREE_VEC_ELT_CHECK(T, I) __extension__ \
710(*({const tree __t = (T); \
711 const int __i = (I); \
fa7b533b 712 if (TREE_CODE (__t) != TREE_VEC) \
086e3095
NS		 713 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
714 TREE_VEC, 0); \
fa7b533b
ZW		 715 if (__i < 0 || __i >= __t->vec.length) \
716 tree_vec_elt_check_failed (__i, __t->vec.length, \
717 __FILE__, __LINE__, __FUNCTION__); \
718 &__t->vec.a[__i]; }))
719
6de9cd9a
DN		 720#define PHI_NODE_ELT_CHECK(t, i) __extension__ \
721(*({const tree __t = t; \
722 const int __i = (i); \
723 if (TREE_CODE (__t) != PHI_NODE) \
086e3095
NS		 724 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
725 PHI_NODE, 0); \
6de9cd9a
DN		 726 if (__i < 0 || __i >= __t->phi.capacity) \
727 phi_node_elt_check_failed (__i, __t->phi.num_args, \
728 __FILE__, __LINE__, __FUNCTION__); \
729 &__t->phi.a[__i]; }))
730
aaf46ef9
DN		 731#define OMP_CLAUSE_ELT_CHECK(t, i) __extension__ \
732(*({const tree __t = t; \
733 const int __i = (i); \
734 if (TREE_CODE (__t) != OMP_CLAUSE) \
735 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \
736 OMP_CLAUSE, 0); \
737 if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code]) \
738 omp_clause_operand_check_failed (__i, __t, __FILE__, __LINE__, \
739 __FUNCTION__); \
740 &__t->omp_clause.ops[__i]; }))
741
06790e5f 742/* Special checks for TREE_OPERANDs. */
7f42b6d7 743#define TREE_OPERAND_CHECK(T, I) __extension__ \
55448d12 744(*({const tree __t = EXPR_CHECK (T); \
7f42b6d7 745 const int __i = (I); \
06790e5f
ZW		 746 if (__i < 0 || __i >= TREE_CODE_LENGTH (TREE_CODE (__t))) \
747 tree_operand_check_failed (__i, TREE_CODE (__t), \
748 __FILE__, __LINE__, __FUNCTION__); \
749 &__t->exp.operands[__i]; }))
750
7f42b6d7
RK		 751#define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__ \
752(*({const tree __t = (T); \
753 const int __i = (I); \
754 if (TREE_CODE (__t) != CODE) \
086e3095 755 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0);\
7f42b6d7
RK		 756 if (__i < 0 || __i >= TREE_CODE_LENGTH (CODE)) \
757 tree_operand_check_failed (__i, (CODE), \
06790e5f
ZW		 758 __FILE__, __LINE__, __FUNCTION__); \
759 &__t->exp.operands[__i]; }))
760
7f42b6d7 761#define TREE_RTL_OPERAND_CHECK(T, CODE, I) __extension__ \
06790e5f 762(*(rtx *) \
7f42b6d7
RK		 763 ({const tree __t = (T); \
764 const int __i = (I); \
765 if (TREE_CODE (__t) != (CODE)) \
086e3095 766 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0); \
7f42b6d7
RK		 767 if (__i < 0 || __i >= TREE_CODE_LENGTH ((CODE))) \
768 tree_operand_check_failed (__i, (CODE), \
06790e5f
ZW		 769 __FILE__, __LINE__, __FUNCTION__); \
770 &__t->exp.operands[__i]; }))
771
820cc88f
DB		 772extern void tree_contains_struct_check_failed (const tree,
773 const enum tree_node_structure_enum,
774 const char *, int, const char *)
775 ATTRIBUTE_NORETURN;
776
086e3095
NS		 777extern void tree_check_failed (const tree, const char *, int, const char *,
778 ...) ATTRIBUTE_NORETURN;
779extern void tree_not_check_failed (const tree, const char *, int, const char *,
780 ...) ATTRIBUTE_NORETURN;
6615c446 781extern void tree_class_check_failed (const tree, const enum tree_code_class,
46c5ad27 782 const char *, int, const char *)
8f985ec4 783 ATTRIBUTE_NORETURN;
953ff289
DN		 784extern void tree_range_check_failed (const tree, const char *, int,
785 const char *, enum tree_code,
786 enum tree_code);
dd5827cb
ILT		 787extern void tree_not_class_check_failed (const tree,
788 const enum tree_code_class,
789 const char *, int, const char *)
790 ATTRIBUTE_NORETURN;
46c5ad27
AJ		 791extern void tree_vec_elt_check_failed (int, int, const char *,
792 int, const char *)
fa7b533b 793 ATTRIBUTE_NORETURN;
6de9cd9a
DN		 794extern void phi_node_elt_check_failed (int, int, const char *,
795 int, const char *)
796 ATTRIBUTE_NORETURN;
46c5ad27
AJ		 797extern void tree_operand_check_failed (int, enum tree_code,
798 const char *, int, const char *)
06790e5f 799 ATTRIBUTE_NORETURN;
aaf46ef9
DN		 800extern void omp_clause_check_failed (const tree, const char *, int,
801 const char *, enum omp_clause_code)
802 ATTRIBUTE_NORETURN;
803extern void omp_clause_operand_check_failed (int, tree, const char *,
804 int, const char *)
805 ATTRIBUTE_NORETURN;
806extern void omp_clause_range_check_failed (const tree, const char *, int,
807 const char *, enum omp_clause_code,
808 enum omp_clause_code)
809 ATTRIBUTE_NORETURN;
46c5ad27 810
f4524c9e 811#else /* not ENABLE_TREE_CHECKING, or not gcc */
12b195d9 812
820cc88f 813#define CONTAINS_STRUCT_CHECK(T, ENUM) (T)
eb34af89 814#define TREE_CHECK(T, CODE) (T)
086e3095 815#define TREE_NOT_CHECK(T, CODE) (T)
eb34af89 816#define TREE_CHECK2(T, CODE1, CODE2) (T)
086e3095 817#define TREE_NOT_CHECK2(T, CODE1, CODE2) (T)
eb34af89 818#define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T)
086e3095 819#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T)
22421b79 820#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
086e3095 821#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
eb34af89 822#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
086e3095 823#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
eb34af89 824#define TREE_CLASS_CHECK(T, CODE) (T)
953ff289 825#define TREE_RANGE_CHECK(T, CODE1, CODE2) (T)
eb34af89 826#define EXPR_CHECK(T) (T)
4f976745 827#define NON_TYPE_CHECK(T) (T)
eb34af89
RK		 828#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I])
829#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I])
830#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I])
7f42b6d7 831#define TREE_RTL_OPERAND_CHECK(T, CODE, I) (*(rtx *) &((T)->exp.operands[I]))
6de9cd9a 832#define PHI_NODE_ELT_CHECK(T, i) ((T)->phi.a[i])
aaf46ef9
DN		 833#define OMP_CLAUSE_ELT_CHECK(T, i) ((T)->omp_clause.ops[i])
834#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T)
62f3e894 835#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) (T)
8f985ec4
ZW		 836
837#endif
838
aaf46ef9 839#define TREE_BLOCK(NODE) (EXPR_CHECK (NODE)->exp.block)
6de9cd9a 840
8f985ec4
ZW		 841#include "tree-check.h"
842
6615c446 843#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type)
820cc88f 844#define DECL_MINIMAL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
326eda4b 845#define TREE_MEMORY_TAG_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_MEMORY_TAG)
820cc88f
DB		 846#define DECL_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
847#define DECL_WRTL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
848#define DECL_WITH_VIS_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
849#define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)
6615c446
JO		 850#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant)
851#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement)
eb34af89 852#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
22421b79 853#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
eb34af89 854
95b4aca6 855#define RECORD_OR_UNION_CHECK(T) \
eb34af89 856 TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
95b4aca6
NS		 857#define NOT_RECORD_OR_UNION_CHECK(T) \
858 TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
caf93cb0 859
eb34af89 860#define NUMERICAL_TYPE_CHECK(T) \
71d59383 861 TREE_CHECK4 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE)
12b195d9 862
8da1b058
RS		 863/* In all nodes that are expressions, this is the data type of the expression.
864 In POINTER_TYPE nodes, this is the type that the pointer points to.
0b4565c9
BS		 865 In ARRAY_TYPE nodes, this is the type of the elements.
866 In VECTOR_TYPE nodes, this is the type of the elements. */
8da1b058
RS		 867#define TREE_TYPE(NODE) ((NODE)->common.type)
868
1c0cc57e
KG		 869/* Here is how primitive or already-canonicalized types' hash codes
870 are made. */
fd917e0d
JM		 871#define TYPE_HASH(TYPE) (TYPE_UID (TYPE))
872
873/* A simple hash function for an arbitrary tree node. This must not be
874 used in hash tables which are saved to a PCH. */
875#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)
1c0cc57e 876
8da1b058
RS		 877/* Nodes are chained together for many purposes.
878 Types are chained together to record them for being output to the debugger
879 (see the function `chain_type').
880 Decls in the same scope are chained together to record the contents
881 of the scope.
882 Statement nodes for successive statements used to be chained together.
883 Often lists of things are represented by TREE_LIST nodes that
884 are chained together. */
885
886#define TREE_CHAIN(NODE) ((NODE)->common.chain)
887
888/* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs
889 that don't change the machine mode. */
890
9a6bb3f7 891#define STRIP_NOPS(EXP) \
8da1b058
RS		 892 while ((TREE_CODE (EXP) == NOP_EXPR \
893 || TREE_CODE (EXP) == CONVERT_EXPR \
894 || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
9a6bb3f7 895 && TREE_OPERAND (EXP, 0) != error_mark_node \
8da1b058
RS		 896 && (TYPE_MODE (TREE_TYPE (EXP)) \
897 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
713cc17b 898 (EXP) = TREE_OPERAND (EXP, 0)
0fafb45e 899
14a774a9
RK		 900/* Like STRIP_NOPS, but don't let the signedness change either. */
901
902#define STRIP_SIGN_NOPS(EXP) \
903 while ((TREE_CODE (EXP) == NOP_EXPR \
904 || TREE_CODE (EXP) == CONVERT_EXPR \
905 || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
9a6bb3f7 906 && TREE_OPERAND (EXP, 0) != error_mark_node \
14a774a9
RK		 907 && (TYPE_MODE (TREE_TYPE (EXP)) \
908 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
8df83eae
RK		 909 && (TYPE_UNSIGNED (TREE_TYPE (EXP)) \
910 == TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
713cc17b 911 (EXP) = TREE_OPERAND (EXP, 0)
14a774a9 912
0fafb45e
RS		 913/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
914
915#define STRIP_TYPE_NOPS(EXP) \
916 while ((TREE_CODE (EXP) == NOP_EXPR \
917 || TREE_CODE (EXP) == CONVERT_EXPR \
918 || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
9a6bb3f7 919 && TREE_OPERAND (EXP, 0) != error_mark_node \
0fafb45e
RS		 920 && (TREE_TYPE (EXP) \
921 == TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
713cc17b 922 (EXP) = TREE_OPERAND (EXP, 0)
87291138 923
6de9cd9a
DN		 924/* Remove unnecessary type conversions according to
925 tree_ssa_useless_type_conversion. */
926
927#define STRIP_USELESS_TYPE_CONVERSION(EXP) \
928 while (tree_ssa_useless_type_conversion (EXP)) \
929 EXP = TREE_OPERAND (EXP, 0)
930
87291138 931/* Nonzero if TYPE represents an integral type. Note that we do not
38b3627d 932 include COMPLEX types here. Keep these checks in ascending code
6c6cfbfd 933 order. */
87291138
RK		 934
935#define INTEGRAL_TYPE_P(TYPE) \
38b3627d
NS		 936 (TREE_CODE (TYPE) == ENUMERAL_TYPE \
937 || TREE_CODE (TYPE) == BOOLEAN_TYPE \
38b3627d 938 || TREE_CODE (TYPE) == INTEGER_TYPE)
87291138 939
00229de4
RS		 940/* Nonzero if TYPE represents a scalar floating-point type. */
941
942#define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE)
943
944/* Nonzero if TYPE represents a complex floating-point type. */
945
946#define COMPLEX_FLOAT_TYPE_P(TYPE) \
947 (TREE_CODE (TYPE) == COMPLEX_TYPE \
948 && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
949
d97c6333
JW		 950/* Nonzero if TYPE represents a vector floating-point type. */
951
952#define VECTOR_FLOAT_TYPE_P(TYPE) \
953 (TREE_CODE (TYPE) == VECTOR_TYPE \
954 && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
955
87291138 956/* Nonzero if TYPE represents a floating-point type, including complex
38b3627d
NS		 957 and vector floating-point types. The vector and complex check does
958 not use the previous two macros to enable early folding. */
87291138 959
38b3627d
NS		 960#define FLOAT_TYPE_P(TYPE) \
961 (SCALAR_FLOAT_TYPE_P (TYPE) \
962 || ((TREE_CODE (TYPE) == COMPLEX_TYPE \
963 || TREE_CODE (TYPE) == VECTOR_TYPE) \
964 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))
947765f9 965
38b3627d
NS		 966/* Nonzero if TYPE represents an aggregate (multi-component) type.
967 Keep these checks in ascending code order. */
947765f9
PB		 968
969#define AGGREGATE_TYPE_P(TYPE) \
970 (TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \
08f2586c 971 || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE)
9e6cfc43 972
66804d9e 973/* Nonzero if TYPE represents a pointer or reference type.
38b3627d
NS		 974 (It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
975 ascending code order. */
9e6cfc43
JM		 976
977#define POINTER_TYPE_P(TYPE) \
978 (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
555f90c5 979
d0f062fb
NS		 980/* Nonzero if this type is a complete type. */
981#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
982
71653180 983/* Nonzero if this type is the (possibly qualified) void type. */
e7cd085f 984#define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE)
71653180 985
d0f062fb
NS		 986/* Nonzero if this type is complete or is cv void. */
987#define COMPLETE_OR_VOID_TYPE_P(NODE) \
c46080ab 988 (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
d0f062fb
NS		 989
990/* Nonzero if this type is complete or is an array with unspecified bound. */
991#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
713cc17b 992 (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
d0f062fb 993
8da1b058
RS		 994\f
995/* Define many boolean fields that all tree nodes have. */
996
997/* In VAR_DECL nodes, nonzero means address of this is needed.
998 So it cannot be in a register.
999 In a FUNCTION_DECL, nonzero means its address is needed.
1000 So it must be compiled even if it is an inline function.
1febe16b
RK		 1001 In a FIELD_DECL node, it means that the programmer is permitted to
1002 construct the address of this field. This is used for aliasing
1003 purposes: see record_component_aliases.
8da1b058 1004 In CONSTRUCTOR nodes, it means object constructed must be in memory.
41077ce4 1005 In LABEL_DECL nodes, it means a goto for this label has been seen
8da1b058
RS		 1006 from a place outside all binding contours that restore stack levels.
1007 In ..._TYPE nodes, it means that objects of this type must
1008 be fully addressable. This means that pieces of this
1009 object cannot go into register parameters, for example.
1010 In IDENTIFIER_NODEs, this means that some extern decl for this name
1011 had its address taken. That matters for inline functions. */
1012#define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag)
1013
ead553a1
SB		 1014/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
1015 exit of a function. Calls for which this is true are candidates for tail
1016 call optimizations. */
6de9cd9a
DN		 1017#define CALL_EXPR_TAILCALL(NODE) (CALL_EXPR_CHECK(NODE)->common.addressable_flag)
1018
8da1b058 1019/* In a VAR_DECL, nonzero means allocate static storage.
9f86614b 1020 In a FUNCTION_DECL, nonzero if function has been defined.
22421b79
RK		 1021 In a CONSTRUCTOR, nonzero means allocate static storage.
1022
1023 ??? This is also used in lots of other nodes in unclear ways which
1024 should be cleaned up some day. */
8da1b058
RS		 1025#define TREE_STATIC(NODE) ((NODE)->common.static_flag)
1026
5a508662
RH		 1027/* In a TARGET_EXPR, WITH_CLEANUP_EXPR, means that the pertinent cleanup
1028 should only be executed if an exception is thrown, not on normal exit
1029 of its scope. */
659e5a7a
JM		 1030#define CLEANUP_EH_ONLY(NODE) ((NODE)->common.static_flag)
1031
6de9cd9a 1032/* In an expr node (usually a conversion) this means the node was made
73022c2a
RH		 1033 implicitly and should not lead to any sort of warning. In a decl node,
1034 warnings concerning the decl should be suppressed. This is used at
1035 least for used-before-set warnings, and it set after one warning is
1036 emitted. */
6de9cd9a 1037#define TREE_NO_WARNING(NODE) ((NODE)->common.nowarning_flag)
8da1b058 1038
69ef87e2
AH		 1039/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means
1040 there was an overflow in folding. This is distinct from
1041 TREE_OVERFLOW because ANSI C requires a diagnostic when overflows
1042 occur in constant expressions. */
22421b79 1043#define TREE_CONSTANT_OVERFLOW(NODE) (CST_CHECK (NODE)->common.static_flag)
261450e8 1044
d3568529
JM		 1045/* In an IDENTIFIER_NODE, this means that assemble_name was called with
1046 this string as an argument. */
c46080ab 1047#define TREE_SYMBOL_REFERENCED(NODE) \
b9daac31 1048 (IDENTIFIER_NODE_CHECK (NODE)->common.static_flag)
d3568529 1049
22421b79
RK		 1050/* Nonzero in a pointer or reference type means the data pointed to
1051 by this type can alias anything. */
1052#define TYPE_REF_CAN_ALIAS_ALL(NODE) \
1053 (PTR_OR_REF_CHECK (NODE)->common.static_flag)
1054
69ef87e2
AH		 1055/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
1056 there was an overflow in folding, and no warning has been issued
22421b79 1057 for this subexpression. TREE_OVERFLOW implies TREE_CONSTANT_OVERFLOW,
87f2a9f5 1058 but not vice versa. */
22421b79 1059
87f2a9f5 1060#define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->common.public_flag)
261450e8 1061
8da1b058
RS		 1062/* In a VAR_DECL or FUNCTION_DECL,
1063 nonzero means name is to be accessible from outside this module.
4c521bad 1064 In an IDENTIFIER_NODE, nonzero means an external declaration
6dc42e49 1065 accessible from outside this module was previously seen
8da1b058
RS		 1066 for this name in an inner scope. */
1067#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
1068
89b0433e
NS		 1069/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
1070 of cached values, or is something else. */
1071#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK(NODE)->common.public_flag)
7f5e6307
RH		 1072
1073/* In a SAVE_EXPR, indicates that the original expression has already
1074 been substituted with a VAR_DECL that contains the value. */
1075#define SAVE_EXPR_RESOLVED_P(NODE) \
1076 (TREE_CHECK (NODE, SAVE_EXPR)->common.public_flag)
89b0433e 1077
4f976745
RK		 1078/* In any expression, decl, or constant, nonzero means it has side effects or
1079 reevaluation of the whole expression could produce a different value.
1080 This is set if any subexpression is a function call, a side effect or a
1081 reference to a volatile variable. In a ..._DECL, this is set only if the
1082 declaration said `volatile'. This will never be set for a constant. */
1083#define TREE_SIDE_EFFECTS(NODE) \
1084 (NON_TYPE_CHECK (NODE)->common.side_effects_flag)
8da1b058 1085
6de9cd9a
DN		 1086/* In a LABEL_DECL, nonzero means this label had its address taken
1087 and therefore can never be deleted and is a jump target for
1088 computed gotos. */
1089#define FORCED_LABEL(NODE) ((NODE)->common.side_effects_flag)
1090
8da1b058
RS		 1091/* Nonzero means this expression is volatile in the C sense:
1092 its address should be of type `volatile WHATEVER *'.
1093 In other words, the declared item is volatile qualified.
1094 This is used in _DECL nodes and _REF nodes.
d29f81b6
AP		 1095 On a FUNCTION_DECL node, this means the function does not
1096 return normally. This is the same effect as setting
1097 the attribute noreturn on the function in C.
8da1b058
RS		 1098
1099 In a ..._TYPE node, means this type is volatile-qualified.
1100 But use TYPE_VOLATILE instead of this macro when the node is a type,
1101 because eventually we may make that a different bit.
1102
1103 If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
1104#define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag)
1105
5cb2183e
AH		 1106/* Nonzero means this node will not trap. In an INDIRECT_REF, means
1107 accessing the memory pointed to won't generate a trap. However,
1108 this only applies to an object when used appropriately: it doesn't
7ccf35ed
DN		 1109 mean that writing a READONLY mem won't trap. Similarly for
1110 ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF.
caf93cb0 1111
a7e5372d
ZD		 1112 In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
1113 (or slice of the array) always belongs to the range of the array.
1114 I.e. that the access will not trap, provided that the access to
1115 the base to the array will not trap. */
5cb2183e
AH		 1116#define TREE_THIS_NOTRAP(NODE) ((NODE)->common.nothrow_flag)
1117
8da1b058 1118/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
4f976745
RK		 1119 nonzero means it may not be the lhs of an assignment. */
1120#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->common.readonly_flag)
8da1b058 1121
272d0bee 1122/* Nonzero if NODE is a _DECL with TREE_READONLY set. */
6615c446
JO		 1123#define TREE_READONLY_DECL_P(NODE)\
1124 (DECL_P (NODE) && TREE_READONLY (NODE))
588d3ade 1125
4f976745
RK		 1126/* Value of expression is constant. Always on in all ..._CST nodes. May
1127 also appear in an expression or decl where the value is constant. */
1128#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->common.constant_flag)
8da1b058 1129
ad50bc8d
RH		 1130/* Nonzero if NODE, a type, has had its sizes gimplified. */
1131#define TYPE_SIZES_GIMPLIFIED(NODE) (TYPE_CHECK (NODE)->common.constant_flag)
1132
a150de29 1133/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
820cc88f 1134#define DECL_UNSIGNED(NODE) (DECL_COMMON_CHECK (NODE)->common.unsigned_flag)
a150de29
RK		 1135
1136/* In a BIT_FIELD_REF, means the bitfield is to be interpreted as unsigned. */
1137#define BIT_FIELD_REF_UNSIGNED(NODE) \
1138 (BIT_FIELD_REF_CHECK (NODE)->common.unsigned_flag)
8da1b058 1139
8df83eae
RK		 1140/* In integral and pointer types, means an unsigned type. */
1141#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->common.unsigned_flag)
1142
c46080ab 1143#define TYPE_TRAP_SIGNED(NODE) \
8df83eae 1144 (flag_trapv && ! TYPE_UNSIGNED (NODE))
91ce572a 1145
8da1b058
RS		 1146/* Nonzero in a VAR_DECL means assembler code has been written.
1147 Nonzero in a FUNCTION_DECL means that the function has been compiled.
1148 This is interesting in an inline function, since it might not need
1149 to be compiled separately.
3635a54b 1150 Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
9f86614b 1151 if the sdb debugging info for the type has been written.
caf93cb0 1152 In a BLOCK node, nonzero if reorder_blocks has already seen this block.
6de9cd9a
DN		 1153 In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
1154 PHI node. */
8da1b058
RS		 1155#define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag)
1156
1157/* Nonzero in a _DECL if the name is used in its scope.
1158 Nonzero in an expr node means inhibit warning if value is unused.
1159 In IDENTIFIER_NODEs, this means that some extern decl for this name
9acf766f
DB		 1160 was used.
1161 In a BLOCK, this means that the block contains variables that are used. */
8da1b058
RS		 1162#define TREE_USED(NODE) ((NODE)->common.used_flag)
1163
12a22e76
JM		 1164/* In a FUNCTION_DECL, nonzero means a call to the function cannot throw
1165 an exception. In a CALL_EXPR, nonzero means the call cannot throw. */
1166#define TREE_NOTHROW(NODE) ((NODE)->common.nothrow_flag)
c3d32120 1167
fa47911c
JM		 1168/* In a CALL_EXPR, means that it's safe to use the target of the call
1169 expansion as the return slot for a call that returns in memory. */
1170#define CALL_EXPR_RETURN_SLOT_OPT(NODE) ((NODE)->common.private_flag)
4977bab6 1171
d8472c75
JM		 1172/* In a RESULT_DECL or PARM_DECL, means that it is passed by invisible
1173 reference (and the TREE_TYPE is a pointer to the true type). */
820cc88f 1174#define DECL_BY_REFERENCE(NODE) (DECL_COMMON_CHECK (NODE)->common.private_flag)
d8472c75 1175
dd292d0a
MM		 1176/* In a CALL_EXPR, means that the call is the jump from a thunk to the
1177 thunked-to function. */
831d8bd7 1178#define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->common.protected_flag)
dd292d0a 1179
c3d32120
RK		 1180/* In a type, nonzero means that all objects of the type are guaranteed by the
1181 language or front-end to be properly aligned, so we can indicate that a MEM
1182 of this type is aligned at least to the alignment of the type, even if it
1183 doesn't appear that it is. We see this, for example, in object-oriented
1184 languages where a tag field may show this is an object of a more-aligned
6de9cd9a
DN		 1185 variant of the more generic type.
1186
1187 In an SSA_NAME node, nonzero if the SSA_NAME node is on the SSA_NAME
1188 freelist. */
c3d32120 1189#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag)
8da1b058 1190
9f86614b 1191/* Used in classes in C++. */
8da1b058 1192#define TREE_PRIVATE(NODE) ((NODE)->common.private_flag)
9f86614b
RS		 1193/* Used in classes in C++.
1194 In a BLOCK node, this is BLOCK_HANDLER_BLOCK. */
8da1b058
RS		 1195#define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)
1196
a0203ca7 1197/* Nonzero in a _DECL if the use of the name is defined as a
e23bd218 1198 deprecated feature by __attribute__((deprecated)). */
a0203ca7
AO		 1199#define TREE_DEPRECATED(NODE) \
1200 ((NODE)->common.deprecated_flag)
1201
1202/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
1203 uses are to be substituted for uses of the TREE_CHAINed identifier. */
1204#define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \
1205 (IDENTIFIER_NODE_CHECK (NODE)->common.deprecated_flag)
e23bd218 1206
6de9cd9a
DN		 1207/* Value of expression is function invariant. A strict subset of
1208 TREE_CONSTANT, such an expression is constant over any one function
1209 invocation, though not across different invocations. May appear in
1210 any expression node. */
1211#define TREE_INVARIANT(NODE) ((NODE)->common.invariant_flag)
1212
9f86614b 1213/* These flags are available for each language front end to use internally. */
8da1b058
RS		 1214#define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0)
1215#define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1)
1216#define TREE_LANG_FLAG_2(NODE) ((NODE)->common.lang_flag_2)
1217#define TREE_LANG_FLAG_3(NODE) ((NODE)->common.lang_flag_3)
1218#define TREE_LANG_FLAG_4(NODE) ((NODE)->common.lang_flag_4)
1219#define TREE_LANG_FLAG_5(NODE) ((NODE)->common.lang_flag_5)
1220#define TREE_LANG_FLAG_6(NODE) ((NODE)->common.lang_flag_6)
1221\f
1222/* Define additional fields and accessors for nodes representing constants. */
1223
e5d70561
RK		 1224/* In an INTEGER_CST node. These two together make a 2-word integer.
1225 If the data type is signed, the value is sign-extended to 2 words
8da1b058 1226 even though not all of them may really be in use.
e5d70561 1227 In an unsigned constant shorter than 2 words, the extra bits are 0. */
2afaa41c
GM		 1228#define TREE_INT_CST(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst)
1229#define TREE_INT_CST_LOW(NODE) (TREE_INT_CST (NODE).low)
1230#define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high)
8da1b058 1231
b9daac31
GS		 1232#define INT_CST_LT(A, B) \
1233 (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
1234 || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
c46080ab 1235 && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
8da1b058 1236
b9daac31
GS		 1237#define INT_CST_LT_UNSIGNED(A, B) \
1238 (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
1239 < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
1240 || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
41077ce4 1241 == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
c46080ab 1242 && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
46c5ad27 1243
e2500fed 1244struct tree_int_cst GTY(())
8da1b058 1245{
2bf105ab 1246 struct tree_common common;
f82783bd 1247 double_int int_cst;
8da1b058
RS		 1248};
1249
0ee6fdb5 1250/* In a REAL_CST node. struct real_value is an opaque entity, with
11ad4784
ZW		 1251 manipulators defined in real.h. We don't want tree.h depending on
1252 real.h and transitively on tm.h. */
0ee6fdb5 1253struct real_value;
c46080ab 1254
11ad4784
ZW		 1255#define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
1256#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
8da1b058 1257
e2500fed 1258struct tree_real_cst GTY(())
8da1b058 1259{
2bf105ab 1260 struct tree_common common;
0ee6fdb5 1261 struct real_value * real_cst_ptr;
8da1b058
RS		 1262};
1263
1264/* In a STRING_CST */
12b195d9 1265#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
7238c5ec
RM		 1266#define TREE_STRING_POINTER(NODE) \
1267 ((const char *)(STRING_CST_CHECK (NODE)->string.str))
8da1b058 1268
e2500fed 1269struct tree_string GTY(())
8da1b058 1270{
2bf105ab 1271 struct tree_common common;
8da1b058 1272 int length;
7238c5ec 1273 char str[1];
8da1b058
RS		 1274};
1275
1276/* In a COMPLEX_CST node. */
12b195d9
ML		 1277#define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
1278#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
8da1b058 1279
e2500fed 1280struct tree_complex GTY(())
8da1b058 1281{
2bf105ab 1282 struct tree_common common;
2f78c311
ZW		 1283 tree real;
1284 tree imag;
8da1b058 1285};
69ef87e2
AH		 1286
1287/* In a VECTOR_CST node. */
1288#define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements)
1289
e2500fed 1290struct tree_vector GTY(())
69ef87e2
AH		 1291{
1292 struct tree_common common;
69ef87e2
AH		 1293 tree elements;
1294};
8da1b058 1295\f
4f4e53dd 1296#include "symtab.h"
2a967f3d 1297
8da1b058
RS		 1298/* Define fields and accessors for some special-purpose tree nodes. */
1299
2a967f3d 1300#define IDENTIFIER_LENGTH(NODE) \
c46080ab 1301 (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
2a967f3d 1302#define IDENTIFIER_POINTER(NODE) \
b9daac31 1303 ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
5e0c54e5
GDR		 1304#define IDENTIFIER_HASH_VALUE(NODE) \
1305 (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
2a967f3d
NB		 1306
1307/* Translate a hash table identifier pointer to a tree_identifier
1308 pointer, and vice versa. */
1309
1310#define HT_IDENT_TO_GCC_IDENT(NODE) \
c46080ab
RK		 1311 ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
1312#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
8da1b058 1313
e2500fed 1314struct tree_identifier GTY(())
8da1b058 1315{
2bf105ab 1316 struct tree_common common;
2a967f3d 1317 struct ht_identifier id;
8da1b058
RS		 1318};
1319
1320/* In a TREE_LIST node. */
12b195d9
ML		 1321#define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
1322#define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
8da1b058 1323
e2500fed 1324struct tree_list GTY(())
8da1b058 1325{
2bf105ab 1326 struct tree_common common;
2f78c311
ZW		 1327 tree purpose;
1328 tree value;
8da1b058
RS		 1329};
1330
1331/* In a TREE_VEC node. */
12b195d9 1332#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length)
c46080ab
RK		 1333#define TREE_VEC_END(NODE) \
1334 ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))
8da1b058 1335
fa7b533b
ZW		 1336#define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
1337
e2500fed 1338struct tree_vec GTY(())
8da1b058 1339{
2bf105ab 1340 struct tree_common common;
8da1b058 1341 int length;
e2500fed 1342 tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
8da1b058
RS		 1343};
1344
4038c495
GB		 1345/* In a CONSTRUCTOR node. */
1346#define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
1347
1348/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
1349 value of each element (stored within VAL). IX must be a scratch variable
1350 of unsigned integer type. */
1351#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \
1352 for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \
1353 ? false \
1354 : ((VAL = VEC_index (constructor_elt, V, IX)->value), \
1355 true); \
1356 (IX)++)
1357
1358/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
1359 the value of each element (stored within VAL) and its index (stored
1360 within INDEX). IX must be a scratch variable of unsigned integer type. */
1361#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \
1362 for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \
1363 ? false \
1364 : ((VAL = VEC_index (constructor_elt, V, IX)->value), \
1365 (INDEX = VEC_index (constructor_elt, V, IX)->index), \
1366 true); \
1367 (IX)++)
1368
1369/* Append a new constructor element to V, with the specified INDEX and VAL. */
1370#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
1371 do { \
1372 constructor_elt *_ce___ = VEC_safe_push (constructor_elt, gc, V, NULL); \
1373 _ce___->index = INDEX; \
1374 _ce___->value = VALUE; \
1375 } while (0)
1376
1377/* A single element of a CONSTRUCTOR. VALUE holds the actual value of the
1378 element. INDEX can optionally design the position of VALUE: in arrays,
1379 it is the index where VALUE has to be placed; in structures, it is the
1380 FIELD_DECL of the member. */
1381typedef struct constructor_elt_d GTY(())
1382{
1383 tree index;
1384 tree value;
1385} constructor_elt;
1386
1387DEF_VEC_O(constructor_elt);
1388DEF_VEC_ALLOC_O(constructor_elt,gc);
1389
1390struct tree_constructor GTY(())
1391{
1392 struct tree_common common;
1393 VEC(constructor_elt,gc) *elts;
1394};
1395
8da1b058
RS		 1396/* Define fields and accessors for some nodes that represent expressions. */
1397
1ea7e6ad 1398/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */
6de9cd9a
DN		 1399#define IS_EMPTY_STMT(NODE) (TREE_CODE (NODE) == NOP_EXPR \
1400 && VOID_TYPE_P (TREE_TYPE (NODE)) \
1401 && integer_zerop (TREE_OPERAND (NODE, 0)))
1402
61131fa2 1403/* In ordinary expression nodes. */
06790e5f 1404#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
12b195d9 1405#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)
61131fa2 1406
40edd0bd 1407/* In a LOOP_EXPR node. */
06790e5f 1408#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
40edd0bd 1409
c1667470
PB		 1410#ifdef USE_MAPPED_LOCATION
1411/* The source location of this expression. Non-tree_exp nodes such as
1412 decls and constants can be shared among multiple locations, so
1413 return nothing. */
1414#define EXPR_LOCATION(NODE) \
6615c446 1415 (EXPR_P (NODE) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
c1667470
PB		 1416#define SET_EXPR_LOCATION(NODE, FROM) \
1417 (EXPR_CHECK (NODE)->exp.locus = (FROM))
1418#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION)
8c27b7d4 1419/* EXPR_LOCUS and SET_EXPR_LOCUS are deprecated. */
c1667470 1420#define EXPR_LOCUS(NODE) \
6615c446 1421 (EXPR_P (NODE) ? &(NODE)->exp.locus : (location_t *)NULL)
c1667470
PB		 1422#define SET_EXPR_LOCUS(NODE, FROM) \
1423 do { source_location *loc_tmp = FROM; \
1424 EXPR_CHECK (NODE)->exp.locus \
1425 = loc_tmp == NULL ? UNKNOWN_LOCATION : *loc_tmp; } while (0)
1426#define EXPR_FILENAME(NODE) \
1427 LOCATION_FILE (EXPR_CHECK (NODE)->exp.locus)
1428#define EXPR_LINENO(NODE) \
1429 LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)
1430#else
6de9cd9a
DN		 1431/* The source location of this expression. Non-tree_exp nodes such as
1432 decls and constants can be shared among multiple locations, so
1433 return nothing. */
1434#define EXPR_LOCUS(NODE) \
6615c446 1435 (EXPR_P (NODE) ? (NODE)->exp.locus : (location_t *)NULL)
6de9cd9a
DN		 1436#define SET_EXPR_LOCUS(NODE, FROM) \
1437 (EXPR_CHECK (NODE)->exp.locus = (FROM))
c1667470 1438#define SET_EXPR_LOCATION(NODE, FROM) annotate_with_locus (NODE, FROM)
6de9cd9a
DN		 1439#define EXPR_FILENAME(NODE) \
1440 (EXPR_CHECK (NODE)->exp.locus->file)
1441#define EXPR_LINENO(NODE) \
1442 (EXPR_CHECK (NODE)->exp.locus->line)
6de9cd9a 1443#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCUS (NODE) != NULL)
c1667470
PB		 1444#define EXPR_LOCATION(NODE) \
1445 (EXPR_HAS_LOCATION(NODE) ? *(NODE)->exp.locus : UNKNOWN_LOCATION)
6de9cd9a 1446#endif
bf1e5319 1447
6f30f1f1 1448/* In a TARGET_EXPR node. */
06790e5f
ZW		 1449#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
1450#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
1451#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
6f30f1f1 1452
350fae66
RK		 1453/* DECL_EXPR accessor. This gives access to the DECL associated with
1454 the given declaration statement. */
1455#define DECL_EXPR_DECL(NODE) TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)
1456
6de9cd9a
DN		 1457#define EXIT_EXPR_COND(NODE) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
1458
1459/* SWITCH_EXPR accessors. These give access to the condition, body and
1460 original condition type (before any compiler conversions)
1461 of the switch statement, respectively. */
ebaae582
SB		 1462#define SWITCH_COND(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
1463#define SWITCH_BODY(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
1464#define SWITCH_LABELS(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 2)
6de9cd9a 1465
8c161995 1466/* CASE_LABEL_EXPR accessors. These give access to the high and low values
6de9cd9a 1467 of a case label, respectively. */
ebaae582
SB		 1468#define CASE_LOW(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
1469#define CASE_HIGH(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
1470#define CASE_LABEL(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
6de9cd9a 1471
ac182688
ZD		 1472/* The operands of a TARGET_MEM_REF. */
1473#define TMR_SYMBOL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
1474#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
1475#define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
1476#define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
1477#define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
1478#define TMR_ORIGINAL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 5))
1479#define TMR_TAG(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 6))
1480
6de9cd9a
DN		 1481/* The operands of a BIND_EXPR. */
1482#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
1483#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
1484#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))
1485
1486/* GOTO_EXPR accessor. This gives access to the label associated with
1487 a goto statement. */
1488#define GOTO_DESTINATION(NODE) TREE_OPERAND ((NODE), 0)
1489
e130a54b 1490/* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
6de9cd9a
DN		 1491 instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
1492 ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
1493 statement. */
ebaae582
SB		 1494#define ASM_STRING(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
1495#define ASM_OUTPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
1496#define ASM_INPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
1497#define ASM_CLOBBERS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
6de9cd9a
DN		 1498/* Nonzero if we want to create an ASM_INPUT instead of an
1499 ASM_OPERAND with no operands. */
1500#define ASM_INPUT_P(NODE) (TREE_STATIC (NODE))
1501#define ASM_VOLATILE_P(NODE) (TREE_PUBLIC (NODE))
1502
1503/* COND_EXPR accessors. */
1504#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
1505#define COND_EXPR_THEN(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
1506#define COND_EXPR_ELSE(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))
1507
1508/* LABEL_EXPR accessor. This gives access to the label associated with
1509 the given label expression. */
1510#define LABEL_EXPR_LABEL(NODE) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)
1511
1512/* VDEF_EXPR accessors are specified in tree-flow.h, along with the other
1513 accessors for SSA operands. */
caf93cb0 1514
6de9cd9a
DN		 1515/* CATCH_EXPR accessors. */
1516#define CATCH_TYPES(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
1517#define CATCH_BODY(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)
1518
1519/* EH_FILTER_EXPR accessors. */
1520#define EH_FILTER_TYPES(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
1521#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
1522#define EH_FILTER_MUST_NOT_THROW(NODE) TREE_STATIC (EH_FILTER_EXPR_CHECK (NODE))
1523
0f59171d
RH		 1524/* OBJ_TYPE_REF accessors. */
1525#define OBJ_TYPE_REF_EXPR(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)
1526#define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)
1527#define OBJ_TYPE_REF_TOKEN(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)
1528
0bca51f0
DN		 1529/* ASSERT_EXPR accessors. */
1530#define ASSERT_EXPR_VAR(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0)
1531#define ASSERT_EXPR_COND(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)
1532
953ff289
DN		 1533/* OpenMP directive and clause accessors. */
1534
1535#define OMP_BODY(NODE) \
1536 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_CRITICAL), 0)
1537#define OMP_CLAUSES(NODE) \
1538 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_SINGLE), 1)
1539
1540#define OMP_PARALLEL_BODY(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
1541#define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
50674e96
DN		 1542#define OMP_PARALLEL_FN(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 2)
1543#define OMP_PARALLEL_DATA_ARG(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 3)
953ff289
DN		 1544
1545#define OMP_FOR_BODY(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 0)
1546#define OMP_FOR_CLAUSES(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 1)
1547#define OMP_FOR_INIT(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 2)
1548#define OMP_FOR_COND(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 3)
1549#define OMP_FOR_INCR(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 4)
1550#define OMP_FOR_PRE_BODY(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 5)
1551
1552#define OMP_SECTIONS_BODY(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
1553#define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
1554
1555#define OMP_SECTION_BODY(NODE) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)
1556
1557#define OMP_SINGLE_BODY(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
1558#define OMP_SINGLE_CLAUSES(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)
1559
1560#define OMP_MASTER_BODY(NODE) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)
1561
1562#define OMP_ORDERED_BODY(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)
1563
1564#define OMP_CRITICAL_BODY(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
1565#define OMP_CRITICAL_NAME(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)
1566
aaf46ef9
DN		 1567#define OMP_CLAUSE_CHAIN(NODE) TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
1568#define OMP_CLAUSE_DECL(NODE) \
1569 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1570 OMP_CLAUSE_PRIVATE, \
1571 OMP_CLAUSE_COPYPRIVATE), 0)
953ff289 1572
777f7f9a
RH		 1573/* True on an OMP_SECTION statement that was the last lexical member.
1574 This status is meaningful in the implementation of lastprivate. */
1575#define OMP_SECTION_LAST(NODE) \
1576 TREE_PRIVATE (OMP_SECTION_CHECK (NODE))
1577
1578/* True on an OMP_RETURN statement if the return does not require a
1579 thread synchronization via some sort of barrier. The exact barrier
1580 that would otherwise be emitted is dependent on the OMP statement
1581 with which this return is associated. */
1582#define OMP_RETURN_NOWAIT(NODE) \
1583 TREE_PRIVATE (OMP_RETURN_CHECK (NODE))
1584
953ff289
DN		 1585/* True on a PRIVATE clause if its decl is kept around for debugging
1586 information only and its DECL_VALUE_EXPR is supposed to point
1587 to what it has been remapped to. */
1588#define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \
aaf46ef9 1589 TREE_PUBLIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
953ff289
DN		 1590
1591/* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
1592 decl is present in the chain. */
1593#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \
aaf46ef9 1594 TREE_PUBLIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
953ff289
DN		 1595
1596#define OMP_CLAUSE_IF_EXPR(NODE) \
aaf46ef9 1597 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)
953ff289 1598#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \
aaf46ef9 1599 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)
953ff289 1600#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \
aaf46ef9 1601 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)
953ff289
DN		 1602
1603#define OMP_CLAUSE_REDUCTION_CODE(NODE) \
aaf46ef9 1604 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)->omp_clause.subcode.reduction_code)
953ff289 1605#define OMP_CLAUSE_REDUCTION_INIT(NODE) \
aaf46ef9 1606 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 1)
953ff289 1607#define OMP_CLAUSE_REDUCTION_MERGE(NODE) \
aaf46ef9 1608 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 2)
953ff289 1609#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
aaf46ef9 1610 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 3)
953ff289
DN		 1611
1612enum omp_clause_schedule_kind
1613{
1614 OMP_CLAUSE_SCHEDULE_STATIC,
1615 OMP_CLAUSE_SCHEDULE_DYNAMIC,
1616 OMP_CLAUSE_SCHEDULE_GUIDED,
1617 OMP_CLAUSE_SCHEDULE_RUNTIME
1618};
1619
1620#define OMP_CLAUSE_SCHEDULE_KIND(NODE) \
aaf46ef9 1621 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)
953ff289
DN		 1622
1623enum omp_clause_default_kind
1624{
1625 OMP_CLAUSE_DEFAULT_UNSPECIFIED,
1626 OMP_CLAUSE_DEFAULT_SHARED,
1627 OMP_CLAUSE_DEFAULT_NONE,
1628 OMP_CLAUSE_DEFAULT_PRIVATE
1629};
1630
1631#define OMP_CLAUSE_DEFAULT_KIND(NODE) \
aaf46ef9 1632 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
953ff289 1633
e2500fed 1634struct tree_exp GTY(())
61131fa2 1635{
2bf105ab 1636 struct tree_common common;
c1667470 1637 source_locus locus;
61131fa2 1638 int complexity;
6de9cd9a 1639 tree block;
46c5ad27
AJ		 1640 tree GTY ((special ("tree_exp"),
1641 desc ("TREE_CODE ((tree) &%0)")))
e2500fed 1642 operands[1];
61131fa2
RS		 1643};
1644\f
6de9cd9a
DN		 1645/* SSA_NAME accessors. */
1646
1647/* Returns the variable being referenced. Once released, this is the
1648 only field that can be relied upon. */
1649#define SSA_NAME_VAR(NODE) SSA_NAME_CHECK (NODE)->ssa_name.var
1650
1651/* Returns the statement which defines this reference. Note that
1652 we use the same field when chaining SSA_NAME nodes together on
1653 the SSA_NAME freelist. */
1654#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->common.chain
1655
1656/* Returns the SSA version number of this SSA name. Note that in
1657 tree SSA, version numbers are not per variable and may be recycled. */
1658#define SSA_NAME_VERSION(NODE) SSA_NAME_CHECK (NODE)->ssa_name.version
1659
1660/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are
1661 never output, so we can safely use the ASM_WRITTEN_FLAG for this
1662 status bit. */
1663#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \
1664 SSA_NAME_CHECK (NODE)->common.asm_written_flag
1665
313679b0 1666/* Nonzero if this SSA_NAME expression is currently on the free list of
6de9cd9a
DN		 1667 SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing
1668 has no meaning for an SSA_NAME. */
1669#define SSA_NAME_IN_FREE_LIST(NODE) \
1670 SSA_NAME_CHECK (NODE)->common.nothrow_flag
1671
313679b0
DN		 1672/* Attributes for SSA_NAMEs for pointer-type variables. */
1673#define SSA_NAME_PTR_INFO(N) \
1674 SSA_NAME_CHECK (N)->ssa_name.ptr_info
1675
7e6eb623
DB		 1676/* Get the value of this SSA_NAME, if available. */
1677#define SSA_NAME_VALUE(N) \
1678 SSA_NAME_CHECK (N)->ssa_name.value_handle
1679
5f240ec4
ZD		 1680/* Auxiliary pass-specific data. */
1681#define SSA_NAME_AUX(N) \
1682 SSA_NAME_CHECK (N)->ssa_name.aux
caf93cb0 1683
ff2ad0f7
DN		 1684#ifndef _TREE_FLOW_H
1685struct ptr_info_def;
313679b0
DN		 1686#endif
1687
f430bae8
AM		 1688
1689
f652d14b 1690/* Immediate use linking structure. This structure is used for maintaining
f430bae8 1691 a doubly linked list of uses of an SSA_NAME. */
f47c96aa 1692typedef struct ssa_use_operand_d GTY(())
f430bae8 1693{
f47c96aa
AM		 1694 struct ssa_use_operand_d* GTY((skip(""))) prev;
1695 struct ssa_use_operand_d* GTY((skip(""))) next;
f430bae8
AM		 1696 tree GTY((skip(""))) stmt;
1697 tree *GTY((skip(""))) use;
f47c96aa 1698} ssa_use_operand_t;
f430bae8
AM		 1699
1700/* Return the immediate_use information for an SSA_NAME. */
1701#define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
1702
6de9cd9a
DN		 1703struct tree_ssa_name GTY(())
1704{
1705 struct tree_common common;
1706
1707 /* _DECL wrapped by this SSA name. */
1708 tree var;
1709
1710 /* SSA version number. */
1711 unsigned int version;
313679b0
DN		 1712
1713 /* Pointer attributes used for alias analysis. */
1714 struct ptr_info_def *ptr_info;
7e6eb623 1715
3aecd08b
JL		 1716 /* Value for SSA name used by various passes.
1717
1718 Right now only invariants are allowed to persist beyond a pass in
1719 this field; in the future we will allow VALUE_HANDLEs to persist
1720 as well. */
1721 tree value_handle;
5f240ec4
ZD		 1722
1723 /* Auxiliary information stored with the ssa name. */
1724 PTR GTY((skip)) aux;
f430bae8
AM		 1725
1726 /* Immediate uses list for this SSA_NAME. */
f47c96aa 1727 struct ssa_use_operand_d imm_uses;
6de9cd9a
DN		 1728};
1729\f
1730/* In a PHI_NODE node. */
f430bae8
AM		 1731
1732/* These 2 macros should be considered off limits for use by developers. If
1733 you wish to access the use or def fields of a PHI_NODE in the SSA
1734 optimizers, use the accessor macros found in tree-ssa-operands.h.
1735 These two macros are to be used only by those accessor macros, and other
f652d14b 1736 select places where we *absolutely* must take the address of the tree. */
f430bae8 1737
d00ad49b
AM		 1738#define PHI_RESULT_TREE(NODE) PHI_NODE_CHECK (NODE)->phi.result
1739#define PHI_ARG_DEF_TREE(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).def
6de9cd9a 1740
17192884
SB		 1741/* PHI_NODEs for each basic block are chained together in a single linked
1742 list. The head of the list is linked from the block annotation, and
1743 the link to the next PHI is in PHI_CHAIN. */
1744#define PHI_CHAIN(NODE) TREE_CHAIN (PHI_NODE_CHECK (NODE))
1745
d00ad49b
AM		 1746#define PHI_NUM_ARGS(NODE) PHI_NODE_CHECK (NODE)->phi.num_args
1747#define PHI_ARG_CAPACITY(NODE) PHI_NODE_CHECK (NODE)->phi.capacity
1748#define PHI_ARG_ELT(NODE, I) PHI_NODE_ELT_CHECK (NODE, I)
6b66c718 1749#define PHI_ARG_EDGE(NODE, I) (EDGE_PRED (PHI_BB ((NODE)), (I)))
30d396e3 1750#define PHI_BB(NODE) PHI_NODE_CHECK (NODE)->phi.bb
f430bae8 1751#define PHI_ARG_IMM_USE_NODE(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).imm_use
6de9cd9a 1752
6de9cd9a
DN		 1753struct phi_arg_d GTY(())
1754{
5dbc71f8
KH		 1755 /* imm_use MUST be the first element in struct because we do some
1756 pointer arithmetic with it. See phi_arg_index_from_use. */
f47c96aa 1757 struct ssa_use_operand_d imm_use;
6de9cd9a 1758 tree def;
6de9cd9a
DN		 1759};
1760
1761struct tree_phi_node GTY(())
1762{
1763 struct tree_common common;
1764 tree result;
1765 int num_args;
1766 int capacity;
1767
30d396e3
ZD		 1768 /* Basic block to that the phi node belongs. */
1769 struct basic_block_def *bb;
1770
4b0ec99a
KH		 1771 /* Arguments of the PHI node. These are maintained in the same
1772 order as predecessor edge vector BB->PREDS. */
c24a4dcf 1773 struct phi_arg_d GTY ((length ("((tree)&%h)->phi.num_args"))) a[1];
6de9cd9a
DN		 1774};
1775\f
aaf46ef9
DN		 1776#define OMP_CLAUSE_CODE(NODE) \
1777 (OMP_CLAUSE_CHECK (NODE))->omp_clause.code
1778
1779#define OMP_CLAUSE_SET_CODE(NODE, CODE) \
1780 ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))
1781
1782#define OMP_CLAUSE_CODE(NODE) \
1783 (OMP_CLAUSE_CHECK (NODE))->omp_clause.code
1784
1785#define OMP_CLAUSE_OPERAND(NODE, I) \
1786 OMP_CLAUSE_ELT_CHECK (NODE, I)
1787
1788struct tree_omp_clause GTY(())
1789{
1790 struct tree_common common;
1791 enum omp_clause_code code;
1792 union omp_clause_subcode {
1793 enum omp_clause_default_kind default_kind;
1794 enum omp_clause_schedule_kind schedule_kind;
1795 enum tree_code reduction_code;
1796 } GTY ((skip)) subcode;
fb57dc0b 1797 tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
aaf46ef9
DN		 1798};
1799\f
6de9cd9a
DN		 1800
1801struct varray_head_tag;
1802
8da1b058 1803/* In a BLOCK node. */
12b195d9 1804#define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
12b195d9
ML		 1805#define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
1806#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
8da1b058
RS		 1807/* Note: when changing this, make sure to find the places
1808 that use chainon or nreverse. */
a901fa64 1809#define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE))
12b195d9
ML		 1810#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
1811#define BLOCK_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag)
8da1b058
RS		 1812
1813/* Nonzero means that this block is prepared to handle exceptions
1814 listed in the BLOCK_VARS slot. */
c46080ab
RK		 1815#define BLOCK_HANDLER_BLOCK(NODE) \
1816 (BLOCK_CHECK (NODE)->block.handler_block_flag)
8da1b058 1817
18c038b9
MM		 1818/* An index number for this block. These values are not guaranteed to
1819 be unique across functions -- whether or not they are depends on
1820 the debugging output format in use. */
1821#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
1822
a20612aa
RH		 1823/* If block reordering splits a lexical block into discontiguous
1824 address ranges, we'll make a copy of the original block.
1825
1826 Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
1827 In that case, we have one source block that has been replicated
1828 (through inlining or unrolling) into many logical blocks, and that
1829 these logical blocks have different physical variables in them.
1830
1831 In this case, we have one logical block split into several
1832 non-contiguous address ranges. Most debug formats can't actually
1833 represent this idea directly, so we fake it by creating multiple
1834 logical blocks with the same variables in them. However, for those
1835 that do support non-contiguous regions, these allow the original
1836 logical block to be reconstructed, along with the set of address
1837 ranges.
1838
1839 One of the logical block fragments is arbitrarily chosen to be
1840 the ORIGIN. The other fragments will point to the origin via
1841 BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
41077ce4 1842 be null. The list of fragments will be chained through
a20612aa
RH		 1843 BLOCK_FRAGMENT_CHAIN from the origin. */
1844
c46080ab
RK		 1845#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
1846#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
a20612aa 1847
3e2844cb
JW		 1848/* For an inlined function, this gives the location where it was called
1849 from. This is only set in the top level block, which corresponds to the
1850 inlined function scope. This is used in the debug output routines. */
1851
1852#define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)
1853
e2500fed 1854struct tree_block GTY(())
8da1b058 1855{
2bf105ab 1856 struct tree_common common;
61131fa2
RS		 1857
1858 unsigned handler_block_flag : 1;
1859 unsigned abstract_flag : 1;
a84efb51 1860 unsigned block_num : 30;
61131fa2 1861
2f78c311
ZW		 1862 tree vars;
1863 tree subblocks;
1864 tree supercontext;
1865 tree abstract_origin;
1866 tree fragment_origin;
1867 tree fragment_chain;
3e2844cb 1868 location_t locus;
8da1b058
RS		 1869};
1870\f
1871/* Define fields and accessors for nodes representing data types. */
1872
1873/* See tree.def for documentation of the use of these fields.
eb34af89
RK		 1874 Look at the documentation of the various ..._TYPE tree codes.
1875
d1a6adeb 1876 Note that the type.values, type.minval, and type.maxval fields are
eb34af89
RK		 1877 overloaded and used for different macros in different kinds of types.
1878 Each macro must check to ensure the tree node is of the proper kind of
1879 type. Note also that some of the front-ends also overload these fields,
1880 so they must be checked as well. */
8da1b058 1881
12b195d9
ML		 1882#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid)
1883#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size)
1884#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
1885#define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
eb34af89 1886#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
08f2586c 1887#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type.values)
95b4aca6 1888#define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values)
89b0433e
NS		 1889#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type.values)
1890#define TYPE_ORIG_SIZE_TYPE(NODE) \
1891 (INTEGER_TYPE_CHECK (NODE)->type.values \
1892 ? TREE_TYPE ((NODE)->type.values) : NULL_TREE)
95b4aca6
NS		 1893#define TYPE_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.maxval)
1894#define TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.minval)
eb34af89
RK		 1895#define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values)
1896#define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval)
1897#define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval)
12b195d9
ML		 1898#define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type.pointer_to)
1899#define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type.reference_to)
22421b79
RK		 1900#define TYPE_NEXT_PTR_TO(NODE) (POINTER_TYPE_CHECK (NODE)->type.minval)
1901#define TYPE_NEXT_REF_TO(NODE) (REFERENCE_TYPE_CHECK (NODE)->type.minval)
eb34af89
RK		 1902#define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
1903#define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
12b195d9
ML		 1904#define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
1905#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
1906#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
e2500fed 1907#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
12b195d9
ML		 1908#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
1909#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
1910#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
12b195d9 1911#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
12b195d9 1912#define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific)
8da1b058 1913
4061f623
BS		 1914/* For a VECTOR_TYPE node, this describes a different type which is emitted
1915 in the debugging output. We use this to describe a vector as a
1916 structure containing an array. */
5c5214a9 1917#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values)
4061f623 1918
95b4aca6 1919/* For record and union types, information about this type, as a base type
8c27b7d4 1920 for itself. */
95b4aca6
NS		 1921#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type.binfo)
1922
1923/* For non record and union types, used in a language-dependent way. */
1924#define TYPE_LANG_SLOT_1(NODE) (NOT_RECORD_OR_UNION_CHECK(NODE)->type.binfo)
8ff0c1af 1925
41472af8
MM		 1926/* The (language-specific) typed-based alias set for this type.
1927 Objects whose TYPE_ALIAS_SETs are different cannot alias each
1928 other. If the TYPE_ALIAS_SET is -1, no alias set has yet been
1929 assigned to this type. If the TYPE_ALIAS_SET is 0, objects of this
1930 type can alias objects of any type. */
1931#define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type.alias_set)
1932
1933/* Nonzero iff the typed-based alias set for this type has been
1934 calculated. */
c46080ab 1935#define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1)
41472af8 1936
bad1b4ba
RK		 1937/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
1938 to this type. */
12b195d9 1939#define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type.attributes)
bad1b4ba 1940
869637e6
RS		 1941/* The alignment necessary for objects of this type.
1942 The value is an int, measured in bits. */
12b195d9 1943#define TYPE_ALIGN(NODE) (TYPE_CHECK (NODE)->type.align)
869637e6 1944
11cf4d18
JJ		 1945/* 1 if the alignment for this type was requested by "aligned" attribute,
1946 0 if it is the default for this type. */
1947#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align)
1948
834c6dff 1949/* The alignment for NODE, in bytes. */
c46080ab 1950#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
834c6dff 1951
2b5f2501
RH		 1952/* If your language allows you to declare types, and you want debug info
1953 for them, then you need to generate corresponding TYPE_DECL nodes.
1954 These "stub" TYPE_DECL nodes have no name, and simply point at the
1955 type node. You then set the TYPE_STUB_DECL field of the type node
1956 to point back at the TYPE_DECL node. This allows the debug routines
1957 to know that the two nodes represent the same type, so that we only
2ba84f36 1958 get one debug info record for them. */
c46080ab 1959#define TYPE_STUB_DECL(NODE) TREE_CHAIN (NODE)
8da1b058 1960
3635a54b
RK		 1961/* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
1962 has BLKmode only because it lacks the alignment requirement for
1963 its size. */
12b195d9 1964#define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
8da1b058 1965
e36308b0
MM		 1966/* In an INTEGER_TYPE, it means the type represents a size. We use
1967 this both for validity checking and to permit optimizations that
1968 are unsafe for other types. Note that the C `size_t' type should
1969 *not* have this flag set. The `size_t' type is simply a typedef
1970 for an ordinary integer type that happens to be the type of an
1971 expression returned by `sizeof'; `size_t' has no special
1972 properties. Expressions whose type have TYPE_IS_SIZETYPE set are
1973 always actual sizes. */
7393c642
RK		 1974#define TYPE_IS_SIZETYPE(NODE) \
1975 (INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag)
1976
1977/* In a FUNCTION_TYPE, indicates that the function returns with the stack
1978 pointer depressed. */
1979#define TYPE_RETURNS_STACK_DEPRESSED(NODE) \
199acebb 1980 (FUNCTION_TYPE_CHECK (NODE)->type.no_force_blk_flag)
fed3cef0 1981
8da1b058 1982/* Nonzero in a type considered volatile as a whole. */
50e9f73a 1983#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->common.volatile_flag)
8da1b058
RS		 1984
1985/* Means this type is const-qualified. */
50e9f73a 1986#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->common.readonly_flag)
8da1b058 1987
3932261a
MM		 1988/* If nonzero, this type is `restrict'-qualified, in the C sense of
1989 the term. */
1990#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
1991
1992/* There is a TYPE_QUAL value for each type qualifier. They can be
1993 combined by bitwise-or to form the complete set of qualifiers for a
1994 type. */
1995
1996#define TYPE_UNQUALIFIED 0x0
1997#define TYPE_QUAL_CONST 0x1
1998#define TYPE_QUAL_VOLATILE 0x2
1999#define TYPE_QUAL_RESTRICT 0x4
2000
2001/* The set of type qualifiers for this type. */
a6d7adfd
GM		 2002#define TYPE_QUALS(NODE) \
2003 ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
2004 | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
66804d9e 2005 | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
3932261a 2006
9f86614b 2007/* These flags are available for each language front end to use internally. */
12b195d9
ML		 2008#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
2009#define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type.lang_flag_1)
2010#define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type.lang_flag_2)
2011#define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type.lang_flag_3)
2012#define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type.lang_flag_4)
2013#define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type.lang_flag_5)
2014#define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type.lang_flag_6)
8da1b058 2015
6de9cd9a
DN		 2016/* Used to keep track of visited nodes in tree traversals. This is set to
2017 0 by copy_node and make_node. */
2018#define TREE_VISITED(NODE) ((NODE)->common.visited)
2019
74a3fd26
PB		 2020/* If set in an ARRAY_TYPE, indicates a string type (for languages
2021 that distinguish string from array of char).
05fa7d54 2022 If set in a INTEGER_TYPE, indicates a character type. */
12b195d9 2023#define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type.string_flag)
74a3fd26 2024
4fe9b91c 2025/* If non-NULL, this is an upper bound of the size (in bytes) of an
c46080ab
RK		 2026 object of the given ARRAY_TYPE. This allows temporaries to be
2027 allocated. */
2028#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
a6002f8d 2029 (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type.maxval)
2fb2b21c 2030
0b4565c9 2031/* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */
c46080ab 2032#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \
a4e8ea7f
SE		 2033 (((unsigned HOST_WIDE_INT) 1) \
2034 << VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision)
2035
2036/* Set precision to n when we have 2^n sub-parts of the vector. */
2037#define SET_TYPE_VECTOR_SUBPARTS(VECTOR_TYPE, X) \
2038 (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision = exact_log2 (X))
0b4565c9 2039
cd3ce9b4 2040/* Indicates that objects of this type must be initialized by calling a
4ac3d994 2041 function when they are created. */
2bf105ab
RK		 2042#define TYPE_NEEDS_CONSTRUCTING(NODE) \
2043 (TYPE_CHECK (NODE)->type.needs_constructing_flag)
4ac3d994 2044
adb23061
RK		 2045/* Indicates that objects of this type (a UNION_TYPE), should be passed
2046 the same way that the first union alternative would be passed. */
2bf105ab
RK		 2047#define TYPE_TRANSPARENT_UNION(NODE) \
2048 (UNION_TYPE_CHECK (NODE)->type.transparent_union_flag)
2049
2050/* For an ARRAY_TYPE, indicates that it is not permitted to
2051 take the address of a component of the type. */
2052#define TYPE_NONALIASED_COMPONENT(NODE) \
2053 (ARRAY_TYPE_CHECK (NODE)->type.transparent_union_flag)
adb23061 2054
956d6950 2055/* Indicated that objects of this type should be laid out in as
9e357cd8 2056 compact a way as possible. */
12b195d9 2057#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
9e357cd8 2058
a5bfe141
RH		 2059/* Used by type_contains_placeholder_p to avoid recomputation.
2060 Values are: 0 (unknown), 1 (false), 2 (true). Never access
2061 this field directly. */
2062#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
2063 (TYPE_CHECK (NODE)->type.contains_placeholder_bits)
2064
e2500fed
GK		 2065struct die_struct;
2066
2067struct tree_type GTY(())
8da1b058 2068{
2bf105ab 2069 struct tree_common common;
2f78c311
ZW		 2070 tree values;
2071 tree size;
2072 tree size_unit;
2073 tree attributes;
b3ddc3ab 2074 unsigned int uid;
8da1b058 2075
b3ddc3ab 2076 unsigned int precision : 9;
c149cc37 2077 ENUM_BITFIELD(machine_mode) mode : 7;
bad1b4ba 2078
74a3fd26 2079 unsigned string_flag : 1;
8da1b058 2080 unsigned no_force_blk_flag : 1;
4ac3d994 2081 unsigned needs_constructing_flag : 1;
adb23061 2082 unsigned transparent_union_flag : 1;
9e357cd8 2083 unsigned packed_flag : 1;
3932261a 2084 unsigned restrict_flag : 1;
a5bfe141 2085 unsigned contains_placeholder_bits : 2;
3932261a 2086
8da1b058
RS		 2087 unsigned lang_flag_0 : 1;
2088 unsigned lang_flag_1 : 1;
2089 unsigned lang_flag_2 : 1;
2090 unsigned lang_flag_3 : 1;
2091 unsigned lang_flag_4 : 1;
2092 unsigned lang_flag_5 : 1;
2093 unsigned lang_flag_6 : 1;
11cf4d18 2094 unsigned user_align : 1;
8da1b058 2095
69b78d8d 2096 unsigned int align;
2f78c311
ZW		 2097 tree pointer_to;
2098 tree reference_to;
e2500fed 2099 union tree_type_symtab {
46c5ad27
AJ		 2100 int GTY ((tag ("0"))) address;
2101 char * GTY ((tag ("1"))) pointer;
17211ab5 2102 struct die_struct * GTY ((tag ("2"))) die;
46c5ad27 2103 } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
e2500fed 2104 descbits ("2"))) symtab;
2f78c311
ZW		 2105 tree name;
2106 tree minval;
2107 tree maxval;
2108 tree next_variant;
2109 tree main_variant;
2110 tree binfo;
2f78c311 2111 tree context;
3bdf5ad1 2112 HOST_WIDE_INT alias_set;
8da1b058
RS		 2113 /* Points to a structure whose details depend on the language in use. */
2114 struct lang_type *lang_specific;
2115};
2116\f
2117/* Define accessor macros for information about type inheritance
2118 and basetypes.
2119
2120 A "basetype" means a particular usage of a data type for inheritance
2121 in another type. Each such basetype usage has its own "binfo"
2122 object to describe it. The binfo object is a TREE_VEC node.
2123
2124 Inheritance is represented by the binfo nodes allocated for a
2125 given type. For example, given types C and D, such that D is
2126 inherited by C, 3 binfo nodes will be allocated: one for describing
2127 the binfo properties of C, similarly one for D, and one for
2128 describing the binfo properties of D as a base type for C.
2129 Thus, given a pointer to class C, one can get a pointer to the binfo
2130 of D acting as a basetype for C by looking at C's binfo's basetypes. */
2131
809e3e7f
NS		 2132/* BINFO specific flags. */
2133
2134/* Nonzero means that the derivation chain is via a `virtual' declaration. */
2135#define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->common.static_flag)
2136
2137/* Flags for language dependent use. */
2138#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0(TREE_BINFO_CHECK(NODE))
2139#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1(TREE_BINFO_CHECK(NODE))
2140#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2(TREE_BINFO_CHECK(NODE))
2141#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3(TREE_BINFO_CHECK(NODE))
2142#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4(TREE_BINFO_CHECK(NODE))
2143#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5(TREE_BINFO_CHECK(NODE))
2144#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6(TREE_BINFO_CHECK(NODE))
2145
8da1b058 2146/* The actual data type node being inherited in this basetype. */
95b4aca6 2147#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK(NODE))
8da1b058
RS		 2148
2149/* The offset where this basetype appears in its containing type.
2150 BINFO_OFFSET slot holds the offset (in bytes)
2151 from the base of the complete object to the base of the part of the
2152 object that is allocated on behalf of this `type'.
2153 This is always 0 except when there is multiple inheritance. */
41077ce4 2154
95b4aca6 2155#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK(NODE)->binfo.offset)
7d02bbef 2156#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
8da1b058
RS		 2157
2158/* The virtual function table belonging to this basetype. Virtual
2159 function tables provide a mechanism for run-time method dispatching.
2160 The entries of a virtual function table are language-dependent. */
2161
95b4aca6 2162#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtable)
8da1b058
RS		 2163
2164/* The virtual functions in the virtual function table. This is
2165 a TREE_LIST that is used as an initial approximation for building
2166 a virtual function table for this basetype. */
95b4aca6 2167#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK(NODE)->binfo.virtuals)
8da1b058 2168
0430641b
MM		 2169/* A vector of binfos for the direct basetypes inherited by this
2170 basetype.
8da1b058 2171
0430641b
MM		 2172 If this basetype describes type D as inherited in C, and if the
2173 basetypes of D are E and F, then this vector contains binfos for
fa743e8c
NS		 2174 inheritance of E and F by C. */
2175#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK(NODE)->binfo.base_binfos)
8da1b058 2176
5e1677bc 2177/* The number of basetypes for NODE. */
fa743e8c 2178#define BINFO_N_BASE_BINFOS(NODE) (VEC_length (tree, BINFO_BASE_BINFOS (NODE)))
5e1677bc 2179
604a3205 2180/* Accessor macro to get to the Nth base binfo of this binfo. */
fa743e8c
NS		 2181#define BINFO_BASE_BINFO(NODE,N) \
2182 (VEC_index (tree, BINFO_BASE_BINFOS (NODE), (N)))
2183#define BINFO_BASE_ITERATE(NODE,N,B) \
2184 (VEC_iterate (tree, BINFO_BASE_BINFOS (NODE), (N), (B)))
2185#define BINFO_BASE_APPEND(NODE,T) \
2186 (VEC_quick_push (tree, BINFO_BASE_BINFOS (NODE), (T)))
7d02bbef 2187
39ac3e4f
MM		 2188/* For a BINFO record describing a virtual base class, i.e., one where
2189 TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
1824b90d
NS		 2190 base. The actual contents are language-dependent. In the C++
2191 front-end this field is an INTEGER_CST giving an offset into the
2192 vtable where the offset to the virtual base can be found. */
95b4aca6 2193#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vptr_field)
2cc3ac7a 2194
dbbf88d1
NS		 2195/* Indicates the accesses this binfo has to its bases. The values are
2196 access_public_node, access_protected_node or access_private_node.
2197 If this array is not present, public access is implied. */
604a3205 2198#define BINFO_BASE_ACCESSES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_accesses)
63d1c7b3
NS		 2199
2200#define BINFO_BASE_ACCESS(NODE,N) \
2201 VEC_index (tree, BINFO_BASE_ACCESSES (NODE), (N))
2202#define BINFO_BASE_ACCESS_APPEND(NODE,T) \
2203 VEC_quick_push (tree, BINFO_BASE_ACCESSES (NODE), (T))
dbbf88d1 2204
fa743e8c
NS		 2205/* The index in the VTT where this subobject's sub-VTT can be found.
2206 NULL_TREE if there is no sub-VTT. */
2207#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_subvtt)
dbbf88d1 2208
fa743e8c
NS		 2209/* The index in the VTT where the vptr for this subobject can be
2210 found. NULL_TREE if there is no secondary vptr in the VTT. */
2211#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_vptr)
2212
604a3205
NS		 2213/* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
2214 inheriting this base for non-virtual bases. For virtual bases it
fc6633e0
NS		 2215 points either to the binfo for which this is a primary binfo, or to
2216 the binfo of the most derived type. */
95b4aca6
NS		 2217#define BINFO_INHERITANCE_CHAIN(NODE) \
2218 (TREE_BINFO_CHECK(NODE)->binfo.inheritance)
2219
2220struct tree_binfo GTY (())
2221{
2222 struct tree_common common;
2223
2224 tree offset;
2225 tree vtable;
2226 tree virtuals;
95b4aca6 2227 tree vptr_field;
d4e6fecb 2228 VEC(tree,gc) *base_accesses;
95b4aca6
NS		 2229 tree inheritance;
2230
fa743e8c
NS		 2231 tree vtt_subvtt;
2232 tree vtt_vptr;
fa743e8c 2233
d4e6fecb 2234 VEC(tree,none) base_binfos;
95b4aca6 2235};
95b4aca6 2236
8da1b058
RS		 2237\f
2238/* Define fields and accessors for nodes representing declared names. */
2239
6de9cd9a 2240/* Nonzero if DECL represents a variable for the SSA passes. */
326eda4b
DB		 2241#define SSA_VAR_P(DECL) \
2242 (TREE_CODE (DECL) == VAR_DECL \
2243 || TREE_CODE (DECL) == PARM_DECL \
2244 || TREE_CODE (DECL) == RESULT_DECL \
2245 || MTAG_P (DECL) \
2246 || (TREE_CODE (DECL) == SSA_NAME \
2247 && (TREE_CODE (SSA_NAME_VAR (DECL)) == VAR_DECL \
2248 || TREE_CODE (SSA_NAME_VAR (DECL)) == PARM_DECL \
2249 || TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL \
2250 || MTAG_P (SSA_NAME_VAR (DECL)))))
6de9cd9a 2251
c46080ab 2252
c46080ab 2253
c46080ab 2254
820cc88f
DB		 2255/* Enumerate visibility settings. */
2256#ifndef SYMBOL_VISIBILITY_DEFINED
2257#define SYMBOL_VISIBILITY_DEFINED
2258enum symbol_visibility
2259{
2260 VISIBILITY_DEFAULT,
2261 VISIBILITY_INTERNAL,
2262 VISIBILITY_HIDDEN,
2263 VISIBILITY_PROTECTED
2264};
2265#endif
c46080ab 2266
820cc88f 2267struct function;
41077ce4 2268
92643fea 2269
820cc88f
DB		 2270/* This is the name of the object as written by the user.
2271 It is an IDENTIFIER_NODE. */
2272#define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
c46080ab 2273
820cc88f
DB		 2274/* Every ..._DECL node gets a unique number. */
2275#define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)
92643fea 2276
820cc88f
DB		 2277/* These two fields describe where in the source code the declaration
2278 was. If the declaration appears in several places (as for a C
2279 function that is declared first and then defined later), this
2280 information should refer to the definition. */
2281#define DECL_SOURCE_LOCATION(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
2282#define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
2283#define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
2284#ifdef USE_MAPPED_LOCATION
2285#define DECL_IS_BUILTIN(DECL) \
2286 (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
2287#else
2288#define DECL_IS_BUILTIN(DECL) (DECL_SOURCE_LINE(DECL) == 0)
2289#endif
c46080ab 2290
d1bd0ded
GK		 2291/* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
2292 QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
2293 PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
2294 points to either the FUNCTION_DECL for the containing function,
2295 the RECORD_TYPE or UNION_TYPE for the containing type, or
2296 NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
2297 scope". */
820cc88f
DB		 2298#define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
2299#define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl_minimal.context)
2300struct tree_decl_minimal GTY(())
2301{
2302 struct tree_common common;
2303 location_t locus;
2304 unsigned int uid;
2305 tree name;
2306 tree context;
2307};
2308
326eda4b
DB		 2309/* When computing aliasing information, we represent the memory pointed-to
2310 by pointers with artificial variables called "memory tags" (MT). There
18cd8a03
DN		 2311 are two kinds of tags, namely symbol and name:
2312
2313 Symbol tags (SMT) are used in flow-insensitive alias analysis, they
2314 represent all the pointed-to locations and variables pointed-to by
2315 the same pointer symbol. Usually, this set is computed using
2316 type-based analysis (i.e., alias set classes), but this may not
2317 always be the case.
2318
2319 Name tags (NMT) are used in flow-sensitive points-to alias
2320 analysis, they represent the variables and memory locations
2321 pointed-to by a specific SSA_NAME pointer.
2322
2323 In general, given a pointer P with a symbol tag SMT, the alias set
2324 of SMT should be the union of all the alias sets of the NMTs of
2325 every SSA_NAME for P. */
326eda4b
DB		 2326struct tree_memory_tag GTY(())
2327{
2328 struct tree_decl_minimal common;
326eda4b 2329 unsigned int is_global:1;
a6c550f9 2330 unsigned int is_used_alone:1;
9ccfe0cd 2331 unsigned int old_used_alone:1;
326eda4b
DB		 2332};
2333
2334#define MTAG_GLOBAL(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.is_global)
3c0b6c43 2335
18cd8a03
DN		 2336/* This flag is true if a SMT is used as the V_MAY_DEF or VUSE operand
2337 directly, because the access had all of the SMT's aliases pruned
2338 from it. */
2339#define SMT_USED_ALONE(NODE) (SYMBOL_MEMORY_TAG_CHECK (NODE)->mtag.is_used_alone)
a6c550f9 2340
9ccfe0cd
DB		 2341/* This flag is used to temporarily store the old value of the used alone
2342 flag when updating so we know whether to mark the symbol for
2343 renaming. */
2344#define SMT_OLD_USED_ALONE(NODE) (SYMBOL_MEMORY_TAG_CHECK (NODE)->mtag.old_used_alone)
2345
3c0b6c43
DB		 2346struct tree_struct_field_tag GTY(())
2347{
2348 struct tree_memory_tag common;
2349
2350 /* Parent variable. */
2351 tree parent_var;
2352
2353 /* Offset inside structure. */
2354 unsigned HOST_WIDE_INT offset;
2355
2356 /* Size of the field. */
2357 unsigned HOST_WIDE_INT size;
2358
2359};
2360#define SFT_PARENT_VAR(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.parent_var)
2361#define SFT_OFFSET(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.offset)
2362#define SFT_SIZE(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.size)
326eda4b 2363
820cc88f
DB		 2364/* For any sort of a ..._DECL node, this points to the original (abstract)
2365 decl node which this decl is an instance of, or else it is NULL indicating
2366 that this decl is not an instance of some other decl. For example,
2367 in a nested declaration of an inline function, this points back to the
2368 definition. */
2369#define DECL_ABSTRACT_ORIGIN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)
2370
2371/* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
2372 origin. This is useful when setting the DECL_ABSTRACT_ORIGIN. */
2373#define DECL_ORIGIN(NODE) \
2374 (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
2375
2376/* Nonzero for any sort of ..._DECL node means this decl node represents an
2377 inline instance of some original (abstract) decl from an inline function;
2378 suppress any warnings about shadowing some other variable. FUNCTION_DECL
2379 nodes can also have their abstract origin set to themselves. */
2380#define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
2381 && DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
2382
91d231cb 2383/* In a DECL this is the field where attributes are stored. */
820cc88f
DB		 2384#define DECL_ATTRIBUTES(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.attributes)
2385
8da1b058 2386/* For a FUNCTION_DECL, holds the tree of BINDINGs.
d1bd0ded 2387 For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
8da1b058
RS		 2388 For a VAR_DECL, holds the initial value.
2389 For a PARM_DECL, not used--default
2390 values for parameters are encoded in the type of the function,
4f976745 2391 not in the PARM_DECL slot.
820cc88f
DB		 2392 For a FIELD_DECL, this is used for enumeration values and the C
2393 frontend uses it for temporarily storing bitwidth of bitfields.
4f976745
RK		 2394
2395 ??? Need to figure out some way to check this isn't a PARM_DECL. */
820cc88f
DB		 2396#define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial)
2397
06ceef4e 2398/* Holds the size of the datum, in bits, as a tree expression.
8da1b058 2399 Need not be constant. */
820cc88f 2400#define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size)
06ceef4e 2401/* Likewise for the size in bytes. */
820cc88f 2402#define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)
971774bb 2403/* Holds the alignment required for the datum, in bits. */
820cc88f 2404#define DECL_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.u1.a.align)
971774bb
MM		 2405/* The alignment of NODE, in bytes. */
2406#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
2f5c7f45
GK		 2407/* For FIELD_DECLs, off_align holds the number of low-order bits of
2408 DECL_FIELD_OFFSET which are known to be always zero.
2409 DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
2410 has. */
820cc88f 2411#define DECL_USER_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.user_align)
17c73321
RK		 2412/* Holds the machine mode corresponding to the declaration of a variable or
2413 field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
2414 FIELD_DECL. */
820cc88f 2415#define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode)
c46080ab 2416
9c0a30c3
EB		 2417/* For FUNCTION_DECL, if it is built-in, this identifies which built-in
2418 operation it is. Note, however, that this field is overloaded, with
2419 DECL_BUILT_IN_CLASS as the discriminant, so the latter must always be
2420 checked before any access to the former. */
820cc88f 2421#define DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_common.u1.f)
dad2a933 2422#define DECL_DEBUG_EXPR_IS_FROM(NODE) \
820cc88f 2423 (DECL_COMMON_CHECK (NODE)->decl_common.debug_expr_is_from)
8da1b058 2424
4aa708ba
TS		 2425/* Nonzero for a given ..._DECL node means that the name of this node should
2426 be ignored for symbolic debug purposes. */
820cc88f 2427#define DECL_IGNORED_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
8da1b058 2428
c5caa350
CH		 2429/* Nonzero for a given ..._DECL node means that this node represents an
2430 "abstract instance" of the given declaration (e.g. in the original
2431 declaration of an inline function). When generating symbolic debugging
9faa82d8 2432 information, we mustn't try to generate any address information for nodes
c5caa350
CH		 2433 marked as "abstract instances" because we don't actually generate
2434 any code or allocate any data space for such instances. */
820cc88f 2435#define DECL_ABSTRACT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
2c0d84d6 2436
3110a56e 2437/* Language-specific decl information. */
820cc88f 2438#define DECL_LANG_SPECIFIC(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
8da1b058 2439
820cc88f 2440/* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
9783dd38
GDR		 2441 do not allocate storage, and refer to a definition elsewhere. Note that
2442 this does not necessarily imply the entity represented by NODE
2443 has no program source-level definition in this translation unit. For
2444 example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
2445 DECL_EXTERNAL may be true simultaneously; that can be the case for
2446 a C99 "extern inline" function. */
820cc88f 2447#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_2)
8da1b058 2448
2ce3c6c6 2449/* In a VAR_DECL for a RECORD_TYPE, sets number for non-init_priority
14b493d6 2450 initializations. */
2ce3c6c6
JM		 2451#define DEFAULT_INIT_PRIORITY 65535
2452#define MAX_INIT_PRIORITY 65535
9a6e70c9 2453#define MAX_RESERVED_INIT_PRIORITY 100
2ce3c6c6 2454
8da1b058
RS		 2455
2456/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
2457 For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
2458
2459 For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
2460
2461 Also set in some languages for variables, etc., outside the normal
2462 lexical scope, such as class instance variables. */
820cc88f 2463#define DECL_NONLOCAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
8da1b058 2464
820cc88f
DB		 2465/* Used in VAR_DECLs to indicate that the variable is a vtable.
2466 Used in FIELD_DECLs for vtable pointers.
2467 Used in FUNCTION_DECLs to indicate that the function is virtual. */
2468#define DECL_VIRTUAL_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
8da1b058 2469
820cc88f
DB		 2470/* Used to indicate that this DECL represents a compiler-generated entity. */
2471#define DECL_ARTIFICIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
bc522472 2472
820cc88f
DB		 2473/* Additional flags for language-specific uses. */
2474#define DECL_LANG_FLAG_0(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
2475#define DECL_LANG_FLAG_1(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
2476#define DECL_LANG_FLAG_2(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
2477#define DECL_LANG_FLAG_3(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
2478#define DECL_LANG_FLAG_4(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
2479#define DECL_LANG_FLAG_5(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
2480#define DECL_LANG_FLAG_6(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
2481#define DECL_LANG_FLAG_7(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
48eb4e53 2482
820cc88f
DB		 2483/* Used to indicate an alias set for the memory pointed to by this
2484 particular FIELD_DECL, PARM_DECL, or VAR_DECL, which must have
2485 pointer (or reference) type. */
2486#define DECL_POINTER_ALIAS_SET(NODE) \
2487 (DECL_COMMON_CHECK (NODE)->decl_common.pointer_alias_set)
6de9cd9a 2488
820cc88f
DB		 2489/* Nonzero if an alias set has been assigned to this declaration. */
2490#define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \
2491 (DECL_POINTER_ALIAS_SET (NODE) != - 1)
968b41a1 2492
820cc88f
DB		 2493/* Nonzero for a decl which is at file scope. */
2494#define DECL_FILE_SCOPE_P(EXP) \
2495 (! DECL_CONTEXT (EXP) \
2496 || TREE_CODE (DECL_CONTEXT (EXP)) == TRANSLATION_UNIT_DECL)
d7afec4b 2497
820cc88f
DB		 2498/* Nonzero for a decl that is decorated using attribute used.
2499 This indicates compiler tools that this decl needs to be preserved. */
2500#define DECL_PRESERVE_P(DECL) \
2501 DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag
2502
2503/* For function local variables of COMPLEX type, indicates that the
2504 variable is not aliased, and that all modifications to the variable
2505 have been adjusted so that they are killing assignments. Thus the
2506 variable may now be treated as a GIMPLE register, and use real
2507 instead of virtual ops in SSA form. */
2508#define DECL_COMPLEX_GIMPLE_REG_P(DECL) \
2509 DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag
5daf7c0a 2510
fe1f8f44
DB		 2511/* This is true if DECL is call clobbered in the current function.
2512 The result of this flag should always be the same as
2513 bitmap_bit_p (call_clobbered_vars, DECL_UID (decl)). */
2514#define DECL_CALL_CLOBBERED(DECL) \
2515 DECL_COMMON_CHECK (DECL)->decl_common.call_clobbered_flag
2516
820cc88f
DB		 2517struct tree_decl_common GTY(())
2518{
2519 struct tree_decl_minimal common;
2520 tree size;
c2f7fa15 2521
820cc88f 2522 ENUM_BITFIELD(machine_mode) mode : 8;
3d78f2e9 2523
820cc88f
DB		 2524 unsigned nonlocal_flag : 1;
2525 unsigned virtual_flag : 1;
2526 unsigned ignored_flag : 1;
2527 unsigned abstract_flag : 1;
2528 unsigned artificial_flag : 1;
2529 unsigned user_align : 1;
2530 unsigned preserve_flag: 1;
2531 unsigned debug_expr_is_from : 1;
2532
2533 unsigned lang_flag_0 : 1;
2534 unsigned lang_flag_1 : 1;
2535 unsigned lang_flag_2 : 1;
2536 unsigned lang_flag_3 : 1;
2537 unsigned lang_flag_4 : 1;
2538 unsigned lang_flag_5 : 1;
2539 unsigned lang_flag_6 : 1;
2540 unsigned lang_flag_7 : 1;
2541
2542 /* In LABEL_DECL, this is DECL_ERROR_ISSUED.
2543 In VAR_DECL and PARM_DECL, this is DECL_REGISTER. */
2544 unsigned decl_flag_0 : 1;
52dd234b 2545 /* In FIELD_DECL, this is DECL_PACKED. */
820cc88f
DB		 2546 unsigned decl_flag_1 : 1;
2547 /* In FIELD_DECL, this is DECL_BIT_FIELD
2548 In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL.
52dd234b 2549 In TYPE_DECL, this is TYPE_DECL_SUPRESS_DEBUG. */
820cc88f
DB		 2550 unsigned decl_flag_2 : 1;
2551 /* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
2552 In VAR_DECL and PARM_DECL, this is DECL_HAS_VALUE_EXPR. */
2553 unsigned decl_flag_3 : 1;
fe1f8f44
DB		 2554 /* Logically, these two would go in a theoretical base shared by var and
2555 parm decl. */
820cc88f 2556 unsigned gimple_reg_flag : 1;
fe1f8f44 2557 unsigned call_clobbered_flag : 1;
820cc88f
DB		 2558
2559 union tree_decl_u1 {
2560 /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
2561 DECL_FUNCTION_CODE. */
2562 enum built_in_function f;
2563 /* In a FUNCTION_DECL for which DECL_BUILT_IN does not hold, this
2564 is used by language-dependent code. */
2565 HOST_WIDE_INT i;
2566 /* DECL_ALIGN and DECL_OFFSET_ALIGN. (These are not used for
2567 FUNCTION_DECLs). */
2568 struct tree_decl_u1_a {
2569 unsigned int align : 24;
2570 unsigned int off_align : 8;
2571 } a;
2572 } GTY ((skip)) u1;
2573
2574 tree size_unit;
2575 tree initial;
2576 tree attributes;
2577 tree abstract_origin;
2578
2579 HOST_WIDE_INT pointer_alias_set;
2580 /* Points to a structure whose details depend on the language in use. */
2581 struct lang_decl *lang_specific;
2582};
588d3ade 2583
833b3afe
DB		 2584extern tree decl_value_expr_lookup (tree);
2585extern void decl_value_expr_insert (tree, tree);
2586
1a186ec5
RH		 2587/* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
2588 if transformations have made this more complicated than evaluating the
2589 decl itself. This should only be used for debugging; once this field has
2590 been set, the decl itself may not legitimately appear in the function. */
833b3afe 2591#define DECL_HAS_VALUE_EXPR_P(NODE) \
820cc88f 2592 (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_flag_3)
1a186ec5 2593#define DECL_VALUE_EXPR(NODE) \
820cc88f 2594 (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
833b3afe 2595#define SET_DECL_VALUE_EXPR(NODE, VAL) \
820cc88f 2596 (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
1a186ec5 2597
820cc88f
DB		 2598/* Holds the RTL expression for the value of a variable or function.
2599 This value can be evaluated lazily for functions, variables with
2600 static storage duration, and labels. */
2601#define DECL_RTL(NODE) \
2602 (DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl \
2603 ? (NODE)->decl_with_rtl.rtl \
2604 : (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl))
140592a0 2605
820cc88f
DB		 2606/* Set the DECL_RTL for NODE to RTL. */
2607#define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)
6e9a3221 2608
820cc88f
DB		 2609/* Returns nonzero if NODE is a tree node that can contain RTL. */
2610#define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))
2611
2612/* Returns nonzero if the DECL_RTL for NODE has already been set. */
2613#define DECL_RTL_SET_P(NODE) (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
2614
2615/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for
2616 NODE1, it will not be set for NODE2; this is a lazy copy. */
2617#define COPY_DECL_RTL(NODE1, NODE2) \
2618 (DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl = DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl)
2619
2620/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
2621#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
2622
2623/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
2624#define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)
2625
2626struct tree_decl_with_rtl GTY(())
2627{
2628 struct tree_decl_common common;
2629 rtx rtl;
2630};
2631
2632/* In a FIELD_DECL, this is the field position, counting in bytes, of the
2633 byte containing the bit closest to the beginning of the structure. */
2634#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset)
2635
2636/* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
2637 field from DECL_FIELD_OFFSET. */
2638#define DECL_FIELD_BIT_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
2639
2640/* In a FIELD_DECL, this indicates whether the field was a bit-field and
2641 if so, the type that was originally specified for it.
2642 TREE_TYPE may have been modified (in finish_struct). */
2643#define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
2644
2645/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
2646 if nonzero, indicates that the field occupies the type. */
2647#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
2648
2649/* For FIELD_DECLs, off_align holds the number of low-order bits of
2650 DECL_FIELD_OFFSET which are known to be always zero.
2651 DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
2652 has. */
2653#define DECL_OFFSET_ALIGN(NODE) \
2654 (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl_common.u1.a.off_align)
2655
2656/* Specify that DECL_ALIGN(NODE) is a multiple of X. */
2657#define SET_DECL_OFFSET_ALIGN(NODE, X) \
2658 (FIELD_DECL_CHECK (NODE)->decl_common.u1.a.off_align = exact_log2 ((X) & -(X)))
2659/* 1 if the alignment for this type was requested by "aligned" attribute,
2660 0 if it is the default for this type. */
2661
2662/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
2663 which this FIELD_DECL is defined. This information is needed when
2664 writing debugging information about vfield and vbase decls for C++. */
2665#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
2666
2667/* In a FIELD_DECL, indicates this field should be bit-packed. */
2668#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
2a8f6b90 2669
8da1b058
RS		 2670/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
2671 specially. */
820cc88f 2672#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
c46080ab 2673
820cc88f
DB		 2674/* Used in a FIELD_DECL to indicate that we cannot form the address of
2675 this component. */
2676#define DECL_NONADDRESSABLE_P(NODE) \
2677 (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
26db82d8 2678
820cc88f
DB		 2679struct tree_field_decl GTY(())
2680{
2681 struct tree_decl_common common;
2682
2683 tree offset;
2684 tree bit_field_type;
2685 tree qualifier;
2686 tree bit_offset;
2687 tree fcontext;
2688
2689};
8da1b058 2690
820cc88f
DB		 2691/* A numeric unique identifier for a LABEL_DECL. The UID allocation is
2692 dense, unique within any one function, and may be used to index arrays.
2693 If the value is -1, then no UID has been assigned. */
2694#define LABEL_DECL_UID(NODE) \
2695 (LABEL_DECL_CHECK (NODE)->decl_common.pointer_alias_set)
c46080ab 2696
820cc88f
DB		 2697/* In LABEL_DECL nodes, nonzero means that an error message about
2698 jumping into such a binding contour has been printed for this label. */
2699#define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl_common.decl_flag_0)
12a22e76 2700
820cc88f
DB		 2701struct tree_label_decl GTY(())
2702{
2703 struct tree_decl_with_rtl common;
2704 /* Java's verifier has some need to store information about labels,
2705 and was using fields that no longer exist on labels.
2706 Once the verifier doesn't need these anymore, they should be removed. */
2707 tree java_field_1;
2708 tree java_field_2;
2709 tree java_field_3;
2710 unsigned int java_field_4;
8da1b058 2711
820cc88f
DB		 2712};
2713
2714struct tree_result_decl GTY(())
2715{
2716 struct tree_decl_with_rtl common;
2717};
2718
2719struct tree_const_decl GTY(())
2720{
2721 struct tree_decl_with_rtl common;
2722};
2723
2724/* For a PARM_DECL, records the data type used to pass the argument,
2725 which may be different from the type seen in the program. */
2726#define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)
2727
2728/* For PARM_DECL, holds an RTL for the stack slot or register
2729 where the data was actually passed. */
2730#define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
30801830 2731
820cc88f
DB		 2732struct tree_parm_decl GTY(())
2733{
2734 struct tree_decl_with_rtl common;
2735 rtx incoming_rtl;
2736};
770ae6cc 2737
2c5f4139 2738
820cc88f
DB		 2739/* Nonzero in a decl means that the gimplifier has seen (or placed)
2740 this variable in a BIND_EXPR. */
2741#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
2742 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
3edbc4b9 2743
820cc88f
DB		 2744/* Used to indicate that the linkage status of this DECL is not yet known,
2745 so it should not be output now. */
2746#define DECL_DEFER_OUTPUT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
2747
2748/* Nonzero for a given ..._DECL node means that no warnings should be
2749 generated just because this node is unused. */
2750#define DECL_IN_SYSTEM_HEADER(NODE) \
2751 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.in_system_header_flag)
2752
2753 /* Used to indicate that this DECL has weak linkage. */
2754#define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
2755
2756/* Internal to the gimplifier. Indicates that the value is a formal
2757 temporary controlled by the gimplifier. */
2758#define DECL_GIMPLE_FORMAL_TEMP_P(DECL) \
2759 DECL_WITH_VIS_CHECK (DECL)->decl_with_vis.gimple_formal_temp
2760
43d9ad1d
DS		 2761/* Used to indicate that the DECL is a dllimport. */
2762#define DECL_DLLIMPORT_P(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
daefd78b 2763
0b494699
ILT		 2764/* DECL_BASED_ON_RESTRICT_P records whether a VAR_DECL is a temporary
2765 based on a variable with a restrict qualified type. If it is,
2766 DECL_RESTRICT_BASE returns the restrict qualified variable on which
2767 it is based. */
2768
2769#define DECL_BASED_ON_RESTRICT_P(NODE) \
2770 (VAR_DECL_CHECK (NODE)->decl_with_vis.based_on_restrict_p)
2771#define DECL_GET_RESTRICT_BASE(NODE) \
2772 (decl_restrict_base_lookup (VAR_DECL_CHECK (NODE)))
2773#define SET_DECL_RESTRICT_BASE(NODE, VAL) \
2774 (decl_restrict_base_insert (VAR_DECL_CHECK (NODE), (VAL)))
2775
2776extern tree decl_restrict_base_lookup (tree);
2777extern void decl_restrict_base_insert (tree, tree);
c5bd82cb 2778
59182242
MM		 2779/* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
2780 not be put out unless it is needed in this translation unit.
2781 Entities like this are shared across translation units (like weak
2782 entities), but are guaranteed to be generated by any translation
2783 unit that needs them, and therefore need not be put out anywhere
2784 where they are not needed. DECL_COMDAT is just a hint to the
2785 back-end; it is up to front-ends which set this flag to ensure
2786 that there will never be any harm, other than bloat, in putting out
2787 something which is DECL_COMDAT. */
820cc88f 2788#define DECL_COMDAT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)
59182242 2789
820cc88f
DB		 2790/* The name of the object as the assembler will see it (but before any
2791 translations made by ASM_OUTPUT_LABELREF). Often this is the same
2792 as DECL_NAME. It is an IDENTIFIER_NODE. */
2793#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
07417085 2794
820cc88f
DB		 2795/* Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME.
2796 This is true of all DECL nodes except FIELD_DECL. */
2797#define HAS_DECL_ASSEMBLER_NAME_P(NODE) \
2798 (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))
a157febd 2799
820cc88f
DB		 2800/* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
2801 the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
2802 yet. */
2803#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
2804 (HAS_DECL_ASSEMBLER_NAME_P (NODE) && DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name != NULL_TREE)
8da1b058 2805
820cc88f
DB		 2806/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
2807#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
2808 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name = (NAME))
27da1b4d 2809
820cc88f
DB		 2810/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's
2811 DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause
2812 the DECL_ASSEMBLER_NAME of either DECL to be set. In other words, the
2813 semantics of using this macro, are different than saying:
2bf105ab 2814
820cc88f 2815 SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))
3932261a 2816
820cc88f 2817 which will try to set the DECL_ASSEMBLER_NAME for DECL1. */
6de9cd9a 2818
820cc88f
DB		 2819#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2) \
2820 (DECL_ASSEMBLER_NAME_SET_P (DECL1) \
2821 ? (void) SET_DECL_ASSEMBLER_NAME (DECL2, \
2822 DECL_ASSEMBLER_NAME (DECL1)) \
2823 : (void) 0)
6de9cd9a 2824
820cc88f
DB		 2825/* Records the section name in a section attribute. Used to pass
2826 the name from decl_attributes to make_function_rtl and make_decl_rtl. */
2827#define DECL_SECTION_NAME(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name)
3932261a 2828
820cc88f
DB		 2829/* Value of the decls's visibility attribute */
2830#define DECL_VISIBILITY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
2831
2832/* Nonzero means that the decl had its visibility specified rather than
2833 being inferred. */
2834#define DECL_VISIBILITY_SPECIFIED(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
2835
2836/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
2837 multiple translation units should be merged. */
2838#define DECL_ONE_ONLY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.one_only)
2839
2840struct tree_decl_with_vis GTY(())
2841{
2842 struct tree_decl_with_rtl common;
2843 tree assembler_name;
2844 tree section_name;
2845
2846 /* Belong to VAR_DECL exclusively. */
2847 unsigned defer_output:1;
2848 unsigned hard_register:1;
2849 unsigned thread_local:1;
2850 unsigned common_flag:1;
2851 unsigned in_text_section : 1;
2852 unsigned gimple_formal_temp : 1;
43d9ad1d 2853 unsigned dllimport_flag : 1;
0b494699 2854 unsigned based_on_restrict_p : 1;
820cc88f
DB		 2855 /* Used by C++. Might become a generic decl flag. */
2856 unsigned shadowed_for_var_p : 1;
2857
2858 /* Don't belong to VAR_DECL exclusively. */
2859 unsigned in_system_header_flag : 1;
2860 unsigned weak_flag:1;
2861 unsigned seen_in_bind_expr : 1;
2862 unsigned comdat_flag : 1;
2863 ENUM_BITFIELD(symbol_visibility) visibility : 2;
2864 unsigned visibility_specified : 1;
2865 /* Belong to FUNCTION_DECL exclusively. */
2866 unsigned one_only : 1;
2867 unsigned init_priority_p:1;
2868
2869 /* Belongs to VAR_DECL exclusively. */
2870 ENUM_BITFIELD(tls_model) tls_model : 3;
0b494699 2871 /* 11 unused bits. */
820cc88f
DB		 2872};
2873
2874/* In a VAR_DECL that's static,
2875 nonzero if the space is in the text section. */
2876#define DECL_IN_TEXT_SECTION(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)
2877
2878/* Nonzero for a given ..._DECL node means that this node should be
2879 put in .common, if possible. If a DECL_INITIAL is given, and it
2880 is not error_mark_node, then the decl cannot be put in .common. */
2881#define DECL_COMMON(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
2882
2883/* In a VAR_DECL, nonzero if the decl is a register variable with
2884 an explicit asm specification. */
2885#define DECL_HARD_REGISTER(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
2886
2887extern tree decl_debug_expr_lookup (tree);
2888extern void decl_debug_expr_insert (tree, tree);
2889/* For VAR_DECL, this is set to either an expression that it was split
2890 from (if DECL_DEBUG_EXPR_IS_FROM is true), otherwise a tree_list of
2891 subexpressions that it was split into. */
2892#define DECL_DEBUG_EXPR(NODE) \
2893 (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))
2894
2895#define SET_DECL_DEBUG_EXPR(NODE, VAL) \
2896 (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))
2897
2898
2899extern unsigned short decl_init_priority_lookup (tree);
2900extern void decl_init_priority_insert (tree, unsigned short);
2901
2902/* In a non-local VAR_DECL with static storage duration, this is the
2903 initialization priority. If this value is zero, the NODE will be
2904 initialized at the DEFAULT_INIT_PRIORITY. Only used by C++ FE*/
2905
2906#define DECL_HAS_INIT_PRIORITY_P(NODE) \
2907 (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
2908#define DECL_INIT_PRIORITY(NODE) \
2909 (decl_init_priority_lookup (VAR_DECL_CHECK (NODE)))
2910#define SET_DECL_INIT_PRIORITY(NODE, VAL) \
2911 (decl_init_priority_insert (VAR_DECL_CHECK (NODE), VAL))
2912
2913/* In a VAR_DECL, the model to use if the data should be allocated from
2914 thread-local storage. */
2915#define DECL_TLS_MODEL(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model)
2916
2917/* In a VAR_DECL, nonzero if the data should be allocated from
2918 thread-local storage. */
2919#define DECL_THREAD_LOCAL_P(NODE) \
2920 (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model != TLS_MODEL_NONE)
2921
2922struct tree_var_decl GTY(())
2923{
2924 struct tree_decl_with_vis common;
2925};
2926
2927
2928/* This field is used to reference anything in decl.result and is meant only
2929 for use by the garbage collector. */
2930#define DECL_RESULT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
2931
2932/* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
2933 Before the struct containing the FUNCTION_DECL is laid out,
2934 DECL_VINDEX may point to a FUNCTION_DECL in a base class which
2935 is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
2936 function. When the class is laid out, this pointer is changed
2937 to an INTEGER_CST node which is suitable for use as an index
2938 into the virtual function table.
2939 C++ also uses this field in namespaces, hence the DECL_NON_COMMON_CHECK. */
2940#define DECL_VINDEX(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex)
2941
2942struct tree_decl_non_common GTY(())
2943
2944{
2945 struct tree_decl_with_vis common;
2946 /* C++ uses this in namespaces. */
2947 tree saved_tree;
2948 /* C++ uses this in templates. */
2949 tree arguments;
2950 /* Almost all FE's use this. */
2951 tree result;
2952 /* C++ uses this in namespaces. */
2953 tree vindex;
2954};
2955
2956/* In FUNCTION_DECL, holds the decl for the return value. */
2957#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
2958
2959/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
2960#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
2961
2962/* In a FUNCTION_DECL, the saved representation of the body of the
2963 entire function. */
2964#define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.saved_tree)
2965
2966/* Nonzero in a FUNCTION_DECL means this function should be treated
2967 as if it were a malloc, meaning it returns a pointer that is
2968 not an alias. */
2969#define DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
2970
2971/* Nonzero in a FUNCTION_DECL means this function may return more
2972 than once. */
2973#define DECL_IS_RETURNS_TWICE(NODE) \
2974 (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)
2975
2976/* Nonzero in a FUNCTION_DECL means this function should be treated
2977 as "pure" function (like const function, but may read global memory). */
2978#define DECL_IS_PURE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)
2979
2980/* Nonzero in a FUNCTION_DECL means this function should be treated
2981 as "novops" function (function that does not read global memory,
2982 but may have arbitrary side effects). */
2983#define DECL_IS_NOVOPS(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
2984
2985/* Used in FUNCTION_DECLs to indicate that they should be run automatically
2986 at the beginning or end of execution. */
2987#define DECL_STATIC_CONSTRUCTOR(NODE) \
2988 (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)
2989
2990#define DECL_STATIC_DESTRUCTOR(NODE) \
2991(FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)
2992
2993/* Used in FUNCTION_DECLs to indicate that function entry and exit should
2994 be instrumented with calls to support routines. */
2995#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
2996 (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)
2997
2998/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
2999 disabled in this function. */
3000#define DECL_NO_LIMIT_STACK(NODE) \
3001 (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)
3002
3003/* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
3004 static chain is not needed. */
3005#define DECL_NO_STATIC_CHAIN(NODE) \
3006 (FUNCTION_DECL_CHECK (NODE)->function_decl.regdecl_flag)
4b1e44be 3007
6f312d18
ZW		 3008/* Nonzero for a decl that cgraph has decided should be inlined into
3009 at least one call site. It is not meaningful to look at this
3010 directly; always use cgraph_function_possibly_inlined_p. */
3011#define DECL_POSSIBLY_INLINED(DECL) \
820cc88f 3012 FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined
6f312d18 3013
820cc88f
DB		 3014/* Nonzero in a FUNCTION_DECL means this function can be substituted
3015 where it is called. */
3016#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.inline_flag)
8e3e233b 3017
820cc88f
DB		 3018/* Nonzero in a FUNCTION_DECL means that this function was declared inline,
3019 such as via the `inline' keyword in C/C++. This flag controls the linkage
3020 semantics of 'inline'; whether or not the function is inlined is
3021 controlled by DECL_INLINE. */
3022#define DECL_DECLARED_INLINE_P(NODE) \
3023 (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
17ad5b5e 3024
820cc88f
DB		 3025/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
3026 that describes the status of this function. */
3027#define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.f)
e41d82f5 3028
820cc88f
DB		 3029/* In a FUNCTION_DECL, nonzero means a built in function. */
3030#define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
968b41a1 3031
820cc88f
DB		 3032/* For a builtin function, identify which part of the compiler defined it. */
3033#define DECL_BUILT_IN_CLASS(NODE) \
3034 (FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
c2f7fa15 3035
820cc88f
DB		 3036/* In FUNCTION_DECL, a chain of ..._DECL nodes.
3037 VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
3038 uses. */
3039#define DECL_ARGUMENTS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.arguments)
046a69e0 3040#define DECL_ARGUMENT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments)
8da1b058 3041
820cc88f
DB		 3042/* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the
3043 arguments/result/saved_tree fields by front ends. It was either inherit
3044 FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL,
3045 which seemed a bit strange. */
8da1b058 3046
820cc88f
DB		 3047struct tree_function_decl GTY(())
3048{
3049 struct tree_decl_non_common common;
3050
2c5f4139
JM		 3051 unsigned static_ctor_flag : 1;
3052 unsigned static_dtor_flag : 1;
820cc88f
DB		 3053 unsigned uninlinable : 1;
3054 unsigned possibly_inlined : 1;
3055 unsigned novops_flag : 1;
3056 unsigned returns_twice_flag : 1;
9df2c88c 3057 unsigned malloc_flag : 1;
2bf105ab 3058 unsigned pure_flag : 1;
820cc88f 3059
b3c3af2f 3060 unsigned declared_inline_flag : 1;
820cc88f
DB		 3061 unsigned regdecl_flag : 1;
3062 unsigned inline_flag : 1;
3063 unsigned no_instrument_function_entry_exit : 1;
3064 unsigned no_limit_stack : 1;
3065 ENUM_BITFIELD(built_in_class) built_in_class : 2;
9df2c88c 3066
820cc88f
DB		 3067 struct function *f;
3068};
8da1b058 3069
820cc88f
DB		 3070/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
3071#define DECL_ORIGINAL_TYPE(NODE) (TYPE_DECL_CHECK (NODE)->decl_non_common.result)
c2f7fa15 3072
820cc88f
DB		 3073/* In a TYPE_DECL nonzero means the detail info about this type is not dumped
3074 into stabs. Instead it will generate cross reference ('x') of names.
3075 This uses the same flag as DECL_EXTERNAL. */
3076#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
3077 (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_2)
6de9cd9a 3078
820cc88f
DB		 3079struct tree_type_decl GTY(())
3080{
3081 struct tree_decl_non_common common;
09f532c9 3082
8da1b058 3083};
6de9cd9a
DN		 3084\f
3085/* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
3086 To reduce overhead, the nodes containing the statements are not trees.
3087 This avoids the overhead of tree_common on all linked list elements.
3088
3089 Use the interface in tree-iterator.h to access this node. */
3090
3091#define STATEMENT_LIST_HEAD(NODE) \
3092 (STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
3093#define STATEMENT_LIST_TAIL(NODE) \
3094 (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
3095
3096struct tree_statement_list_node
3097 GTY ((chain_next ("%h.next"), chain_prev ("%h.prev")))
3098{
3099 struct tree_statement_list_node *prev;
3100 struct tree_statement_list_node *next;
3101 tree stmt;
3102};
3103
3104struct tree_statement_list
3105 GTY(())
3106{
3107 struct tree_common common;
3108 struct tree_statement_list_node *head;
3109 struct tree_statement_list_node *tail;
3110};
33c94679
DN		 3111
3112#define VALUE_HANDLE_ID(NODE) \
3113 (VALUE_HANDLE_CHECK (NODE)->value_handle.id)
3114
3115#define VALUE_HANDLE_EXPR_SET(NODE) \
3116 (VALUE_HANDLE_CHECK (NODE)->value_handle.expr_set)
3117
c90186eb
DB		 3118#define VALUE_HANDLE_VUSES(NODE) \
3119 (VALUE_HANDLE_CHECK (NODE)->value_handle.vuses)
3120
33c94679
DN		 3121/* Defined and used in tree-ssa-pre.c. */
3122struct value_set;
3123
3124struct tree_value_handle GTY(())
3125{
3126 struct tree_common common;
3127
3128 /* The set of expressions represented by this handle. */
3129 struct value_set * GTY ((skip)) expr_set;
3130
3131 /* Unique ID for this value handle. IDs are handed out in a
3132 conveniently dense form starting at 0, so that we can make
8c27b7d4 3133 bitmaps of value handles. */
33c94679 3134 unsigned int id;
c90186eb
DB		 3135
3136 /* Set of virtual uses represented by this handle. */
3137 VEC (tree, gc) *vuses;
33c94679 3138};
8da1b058
RS		 3139\f
3140/* Define the overall contents of a tree node.
3141 It may be any of the structures declared above
3142 for various types of node. */
3143
e2500fed
GK		 3144union tree_node GTY ((ptr_alias (union lang_tree_node),
3145 desc ("tree_node_structure (&%h)")))
8da1b058 3146{
e2500fed
GK		 3147 struct tree_common GTY ((tag ("TS_COMMON"))) common;
3148 struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst;
3149 struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst;
3150 struct tree_vector GTY ((tag ("TS_VECTOR"))) vector;
3151 struct tree_string GTY ((tag ("TS_STRING"))) string;
3152 struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
3153 struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
820cc88f
DB		 3154 struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal;
3155 struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common;
3156 struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl;
3157 struct tree_decl_non_common GTY ((tag ("TS_DECL_NON_COMMON"))) decl_non_common;
3158 struct tree_parm_decl GTY ((tag ("TS_PARM_DECL"))) parm_decl;
3159 struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis;
3160 struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl;
3161 struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl;
3162 struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl;
3163 struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl;
3164 struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl;
3165 struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl;
3166 struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl;
e2500fed
GK		 3167 struct tree_type GTY ((tag ("TS_TYPE"))) type;
3168 struct tree_list GTY ((tag ("TS_LIST"))) list;
3169 struct tree_vec GTY ((tag ("TS_VEC"))) vec;
3170 struct tree_exp GTY ((tag ("TS_EXP"))) exp;
6de9cd9a
DN		 3171 struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name;
3172 struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi;
e2500fed 3173 struct tree_block GTY ((tag ("TS_BLOCK"))) block;
95b4aca6 3174 struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo;
6de9cd9a 3175 struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
33c94679 3176 struct tree_value_handle GTY ((tag ("TS_VALUE_HANDLE"))) value_handle;
4038c495 3177 struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
326eda4b 3178 struct tree_memory_tag GTY ((tag ("TS_MEMORY_TAG"))) mtag;
3c0b6c43 3179 struct tree_struct_field_tag GTY ((tag ("TS_STRUCT_FIELD_TAG"))) sft;
aaf46ef9 3180 struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
6de9cd9a 3181};
1d2a8985 3182\f
81b3411c
BS		 3183/* Standard named or nameless data types of the C compiler. */
3184
3185enum tree_index
3186{
3187 TI_ERROR_MARK,
3188 TI_INTQI_TYPE,
3189 TI_INTHI_TYPE,
3190 TI_INTSI_TYPE,
3191 TI_INTDI_TYPE,
3192 TI_INTTI_TYPE,
3193
3194 TI_UINTQI_TYPE,
3195 TI_UINTHI_TYPE,
3196 TI_UINTSI_TYPE,
3197 TI_UINTDI_TYPE,
3198 TI_UINTTI_TYPE,
41077ce4 3199
81b3411c
BS		 3200 TI_INTEGER_ZERO,
3201 TI_INTEGER_ONE,
f2d1f0ba 3202 TI_INTEGER_MINUS_ONE,
81b3411c
BS		 3203 TI_NULL_POINTER,
3204
3205 TI_SIZE_ZERO,
3206 TI_SIZE_ONE,
770ae6cc
RK		 3207
3208 TI_BITSIZE_ZERO,
3209 TI_BITSIZE_ONE,
3210 TI_BITSIZE_UNIT,
3211
5a98fa7b
MM		 3212 TI_PUBLIC,
3213 TI_PROTECTED,
3214 TI_PRIVATE,
3215
de7df9eb
JM		 3216 TI_BOOLEAN_FALSE,
3217 TI_BOOLEAN_TRUE,
3218
81b3411c
BS		 3219 TI_COMPLEX_INTEGER_TYPE,
3220 TI_COMPLEX_FLOAT_TYPE,
3221 TI_COMPLEX_DOUBLE_TYPE,
3222 TI_COMPLEX_LONG_DOUBLE_TYPE,
3223
3224 TI_FLOAT_TYPE,
3225 TI_DOUBLE_TYPE,
3226 TI_LONG_DOUBLE_TYPE,
3227
a2a919aa
KG		 3228 TI_FLOAT_PTR_TYPE,
3229 TI_DOUBLE_PTR_TYPE,
3230 TI_LONG_DOUBLE_PTR_TYPE,
3231 TI_INTEGER_PTR_TYPE,
3232
81b3411c
BS		 3233 TI_VOID_TYPE,
3234 TI_PTR_TYPE,
3235 TI_CONST_PTR_TYPE,
c9f8536c 3236 TI_SIZE_TYPE,
d1c38823 3237 TI_PID_TYPE,
81b3411c
BS		 3238 TI_PTRDIFF_TYPE,
3239 TI_VA_LIST_TYPE,
9d30f3c1
JJ		 3240 TI_VA_LIST_GPR_COUNTER_FIELD,
3241 TI_VA_LIST_FPR_COUNTER_FIELD,
de7df9eb 3242 TI_BOOLEAN_TYPE,
498c0f27 3243 TI_FILEPTR_TYPE,
81b3411c 3244
9a8ce21f
JG		 3245 TI_DFLOAT32_TYPE,
3246 TI_DFLOAT64_TYPE,
3247 TI_DFLOAT128_TYPE,
3248 TI_DFLOAT32_PTR_TYPE,
3249 TI_DFLOAT64_PTR_TYPE,
3250 TI_DFLOAT128_PTR_TYPE,
3251
cbd5937a
MM		 3252 TI_VOID_LIST_NODE,
3253
5b47282c
GM		 3254 TI_MAIN_IDENTIFIER,
3255
81b3411c
BS		 3256 TI_MAX
3257};
3258
e2500fed 3259extern GTY(()) tree global_trees[TI_MAX];
81b3411c
BS		 3260
3261#define error_mark_node global_trees[TI_ERROR_MARK]
41077ce4 3262
81b3411c
BS		 3263#define intQI_type_node global_trees[TI_INTQI_TYPE]
3264#define intHI_type_node global_trees[TI_INTHI_TYPE]
3265#define intSI_type_node global_trees[TI_INTSI_TYPE]
3266#define intDI_type_node global_trees[TI_INTDI_TYPE]
3267#define intTI_type_node global_trees[TI_INTTI_TYPE]
3268
3269#define unsigned_intQI_type_node global_trees[TI_UINTQI_TYPE]
3270#define unsigned_intHI_type_node global_trees[TI_UINTHI_TYPE]
3271#define unsigned_intSI_type_node global_trees[TI_UINTSI_TYPE]
3272#define unsigned_intDI_type_node global_trees[TI_UINTDI_TYPE]
3273#define unsigned_intTI_type_node global_trees[TI_UINTTI_TYPE]
3274
81b3411c
BS		 3275#define integer_zero_node global_trees[TI_INTEGER_ZERO]
3276#define integer_one_node global_trees[TI_INTEGER_ONE]
f2d1f0ba 3277#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]
81b3411c
BS		 3278#define size_zero_node global_trees[TI_SIZE_ZERO]
3279#define size_one_node global_trees[TI_SIZE_ONE]
770ae6cc
RK		 3280#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]
3281#define bitsize_one_node global_trees[TI_BITSIZE_ONE]
3282#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT]
3283
dbbf88d1 3284/* Base access nodes. */
5a98fa7b
MM		 3285#define access_public_node global_trees[TI_PUBLIC]
3286#define access_protected_node global_trees[TI_PROTECTED]
3287#define access_private_node global_trees[TI_PRIVATE]
dbbf88d1 3288
81b3411c
BS		 3289#define null_pointer_node global_trees[TI_NULL_POINTER]
3290
3291#define float_type_node global_trees[TI_FLOAT_TYPE]
3292#define double_type_node global_trees[TI_DOUBLE_TYPE]
3293#define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE]
3294
a2a919aa
KG		 3295#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE]
3296#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE]
3297#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE]
3298#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE]
3299
81b3411c
BS		 3300#define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE]
3301#define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE]
3302#define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE]
3303#define complex_long_double_type_node global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
3304
3305#define void_type_node global_trees[TI_VOID_TYPE]
fc693822 3306/* The C type `void *'. */
81b3411c 3307#define ptr_type_node global_trees[TI_PTR_TYPE]
fc693822 3308/* The C type `const void *'. */
81b3411c 3309#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE]
c9f8536c
MM		 3310/* The C type `size_t'. */
3311#define size_type_node global_trees[TI_SIZE_TYPE]
d1c38823 3312#define pid_type_node global_trees[TI_PID_TYPE]
81b3411c
BS		 3313#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
3314#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
9d30f3c1
JJ		 3315#define va_list_gpr_counter_field global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]
3316#define va_list_fpr_counter_field global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]
498c0f27
JJ		 3317/* The C type `FILE *'. */
3318#define fileptr_type_node global_trees[TI_FILEPTR_TYPE]
7145ef21 3319
de7df9eb
JM		 3320#define boolean_type_node global_trees[TI_BOOLEAN_TYPE]
3321#define boolean_false_node global_trees[TI_BOOLEAN_FALSE]
3322#define boolean_true_node global_trees[TI_BOOLEAN_TRUE]
3323
9a8ce21f
JG		 3324/* The decimal floating point types. */
3325#define dfloat32_type_node global_trees[TI_DFLOAT32_TYPE]
3326#define dfloat64_type_node global_trees[TI_DFLOAT64_TYPE]
3327#define dfloat128_type_node global_trees[TI_DFLOAT128_TYPE]
3328#define dfloat32_ptr_type_node global_trees[TI_DFLOAT32_PTR_TYPE]
3329#define dfloat64_ptr_type_node global_trees[TI_DFLOAT64_PTR_TYPE]
3330#define dfloat128_ptr_type_node global_trees[TI_DFLOAT128_PTR_TYPE]
3331
cbd5937a
MM		 3332/* The node that should be placed at the end of a parameter list to
3333 indicate that the function does not take a variable number of
3334 arguments. The TREE_VALUE will be void_type_node and there will be
3335 no TREE_CHAIN. Language-independent code should not assume
3336 anything else about this node. */
3337#define void_list_node global_trees[TI_VOID_LIST_NODE]
3338
5b47282c
GM		 3339#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
3340#define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
3341
7145ef21 3342/* An enumeration of the standard C integer types. These must be
ceeedfc1
NB		 3343 ordered so that shorter types appear before longer ones, and so
3344 that signed types appear before unsigned ones, for the correct
3345 functioning of interpret_integer() in c-lex.c. */
41077ce4 3346enum integer_type_kind
7145ef21
MM		 3347{
3348 itk_char,
3349 itk_signed_char,
3350 itk_unsigned_char,
3351 itk_short,
3352 itk_unsigned_short,
3353 itk_int,
3354 itk_unsigned_int,
3355 itk_long,
3356 itk_unsigned_long,
3357 itk_long_long,
3358 itk_unsigned_long_long,
3359 itk_none
3360};
3361
3362typedef enum integer_type_kind integer_type_kind;
3363
3364/* The standard C integer types. Use integer_type_kind to index into
3365 this array. */
e2500fed 3366extern GTY(()) tree integer_types[itk_none];
7145ef21
MM		 3367
3368#define char_type_node integer_types[itk_char]
3369#define signed_char_type_node integer_types[itk_signed_char]
3370#define unsigned_char_type_node integer_types[itk_unsigned_char]
3371#define short_integer_type_node integer_types[itk_short]
3372#define short_unsigned_type_node integer_types[itk_unsigned_short]
3373#define integer_type_node integer_types[itk_int]
3374#define unsigned_type_node integer_types[itk_unsigned_int]
3375#define long_integer_type_node integer_types[itk_long]
3376#define long_unsigned_type_node integer_types[itk_unsigned_long]
3377#define long_long_integer_type_node integer_types[itk_long_long]
3378#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]
dce81a1a
JJ		 3379\f
3380/* Set to the default thread-local storage (tls) model to use. */
3381
dce81a1a 3382extern enum tls_model flag_tls_default;
25fdb4dc 3383
81b3411c 3384\f
f963b5d9
RS		 3385/* A pointer-to-function member type looks like:
3386
3387 struct {
3388 __P __pfn;
3389 ptrdiff_t __delta;
3390 };
3391
3392 If __pfn is NULL, it is a NULL pointer-to-member-function.
3393
3394 (Because the vtable is always the first thing in the object, we
3395 don't need its offset.) If the function is virtual, then PFN is
3396 one plus twice the index into the vtable; otherwise, it is just a
3397 pointer to the function.
3398
3399 Unfortunately, using the lowest bit of PFN doesn't work in
3400 architectures that don't impose alignment requirements on function
3401 addresses, or that use the lowest bit to tell one ISA from another,
3402 for example. For such architectures, we use the lowest bit of
3403 DELTA instead of the lowest bit of the PFN, and DELTA will be
3404 multiplied by 2. */
3405
3406enum ptrmemfunc_vbit_where_t
3407{
3408 ptrmemfunc_vbit_in_pfn,
3409 ptrmemfunc_vbit_in_delta
3410};
3411\f
f837a861
MM		 3412#define NULL_TREE (tree) NULL
3413
46c5ad27 3414extern tree decl_assembler_name (tree);
8da1b058 3415
c5620996
GK		 3416/* Compute the number of bytes occupied by 'node'. This routine only
3417 looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
3418
46c5ad27 3419extern size_t tree_size (tree);
c5620996 3420
a38b644b
ZW		 3421/* Compute the number of bytes occupied by a tree with code CODE. This
3422 function cannot be used for TREE_VEC or PHI_NODE codes, which are of
3423 variable length. */
3424extern size_t tree_code_size (enum tree_code);
3425
8da1b058
RS		 3426/* Lowest level primitive for allocating a node.
3427 The TREE_CODE is the only argument. Contents are initialized
3428 to zero except for a few of the common fields. */
3429
b9dcdee4
JH		 3430extern tree make_node_stat (enum tree_code MEM_STAT_DECL);
3431#define make_node(t) make_node_stat (t MEM_STAT_INFO)
8da1b058 3432
1b70d38a 3433/* Make a copy of a node, with all the same contents. */
8da1b058 3434
b9dcdee4
JH		 3435extern tree copy_node_stat (tree MEM_STAT_DECL);
3436#define copy_node(t) copy_node_stat (t MEM_STAT_INFO)
8da1b058
RS		 3437
3438/* Make a copy of a chain of TREE_LIST nodes. */
3439
46c5ad27 3440extern tree copy_list (tree);
8da1b058 3441
95b4aca6
NS		 3442/* Make a BINFO. */
3443extern tree make_tree_binfo_stat (unsigned MEM_STAT_DECL);
3444#define make_tree_binfo(t) make_tree_binfo_stat (t MEM_STAT_INFO)
3445
8da1b058
RS		 3446/* Make a TREE_VEC. */
3447
b9dcdee4
JH		 3448extern tree make_tree_vec_stat (int MEM_STAT_DECL);
3449#define make_tree_vec(t) make_tree_vec_stat (t MEM_STAT_INFO)
8da1b058 3450
6de9cd9a
DN		 3451/* Tree nodes for SSA analysis. */
3452
6de9cd9a
DN		 3453extern void init_phinodes (void);
3454extern void fini_phinodes (void);
3455extern void release_phi_node (tree);
3456#ifdef GATHER_STATISTICS
3457extern void phinodes_print_statistics (void);
3458#endif
3459
3460extern void init_ssanames (void);
3461extern void fini_ssanames (void);
3462extern tree make_ssa_name (tree, tree);
d7621d3c 3463extern tree duplicate_ssa_name (tree, tree);
8bb46326 3464extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *);
6de9cd9a 3465extern void release_ssa_name (tree);
53b4bf74 3466extern void release_defs (tree);
bbc630f5 3467extern void replace_ssa_name_symbol (tree, tree);
53b4bf74 3468
6de9cd9a
DN		 3469#ifdef GATHER_STATISTICS
3470extern void ssanames_print_statistics (void);
3471#endif
3472
8da1b058
RS		 3473/* Return the (unique) IDENTIFIER_NODE node for a given name.
3474 The name is supplied as a char *. */
3475
46c5ad27 3476extern tree get_identifier (const char *);
8da1b058 3477
7bb3fbbb
RS		 3478#if GCC_VERSION >= 3000
3479#define get_identifier(str) \
3480 (__builtin_constant_p (str) \
3481 ? get_identifier_with_length ((str), strlen (str)) \
3482 : get_identifier (str))
3483#endif
3484
3485
4bad9e39
APB		 3486/* Identical to get_identifier, except that the length is assumed
3487 known. */
3488
7bb3fbbb 3489extern tree get_identifier_with_length (const char *, size_t);
4bad9e39 3490
6b9300aa
RK		 3491/* If an identifier with the name TEXT (a null-terminated string) has
3492 previously been referred to, return that node; otherwise return
3493 NULL_TREE. */
3494
46c5ad27 3495extern tree maybe_get_identifier (const char *);
6b9300aa 3496
8da1b058
RS		 3497/* Construct various types of nodes. */
3498
46c5ad27
AJ		 3499extern tree build_nt (enum tree_code, ...);
3500
b9dcdee4
JH		 3501extern tree build0_stat (enum tree_code, tree MEM_STAT_DECL);
3502#define build0(c,t) build0_stat (c,t MEM_STAT_INFO)
3503extern tree build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
3504#define build1(c,t1,t2) build1_stat (c,t1,t2 MEM_STAT_INFO)
3505extern tree build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
3506#define build2(c,t1,t2,t3) build2_stat (c,t1,t2,t3 MEM_STAT_INFO)
3507extern tree build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
3508#define build3(c,t1,t2,t3,t4) build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO)
3509extern tree build4_stat (enum tree_code, tree, tree, tree, tree,
3510 tree MEM_STAT_DECL);
3511#define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
953ff289
DN		 3512extern tree build5_stat (enum tree_code, tree, tree, tree, tree, tree,
3513 tree MEM_STAT_DECL);
3514#define build5(c,t1,t2,t3,t4,t5,t6) build5_stat (c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
ac182688
ZD		 3515extern tree build7_stat (enum tree_code, tree, tree, tree, tree, tree,
3516 tree, tree, tree MEM_STAT_DECL);
3517#define build7(c,t1,t2,t3,t4,t5,t6,t7,t8) \
3518 build7_stat (c,t1,t2,t3,t4,t5,t6,t7,t8 MEM_STAT_INFO)
4221057e 3519
7d60be94 3520extern tree build_int_cst (tree, HOST_WIDE_INT);
8b11a64c 3521extern tree build_int_cst_type (tree, HOST_WIDE_INT);
7d60be94
NS		 3522extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT);
3523extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
46c5ad27 3524extern tree build_vector (tree, tree);
4038c495
GB		 3525extern tree build_vector_from_ctor (tree, VEC(constructor_elt,gc) *);
3526extern tree build_constructor (tree, VEC(constructor_elt,gc) *);
3527extern tree build_constructor_single (tree, tree, tree);
3528extern tree build_constructor_from_list (tree, tree);
46c5ad27
AJ		 3529extern tree build_real_from_int_cst (tree, tree);
3530extern tree build_complex (tree, tree, tree);
3531extern tree build_string (int, const char *);
b9dcdee4
JH		 3532extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL);
3533#define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO)
3534extern tree build_decl_stat (enum tree_code, tree, tree MEM_STAT_DECL);
9885da8e 3535extern tree build_fn_decl (const char *, tree);
b9dcdee4 3536#define build_decl(c,t,q) build_decl_stat (c,t,q MEM_STAT_INFO)
22e8617b 3537extern tree build_block (tree, tree, tree, tree);
c1667470 3538#ifndef USE_MAPPED_LOCATION
6de9cd9a
DN		 3539extern void annotate_with_file_line (tree, const char *, int);
3540extern void annotate_with_locus (tree, location_t);
c1667470 3541#endif
6de9cd9a 3542extern tree build_empty_stmt (void);
aaf46ef9 3543extern tree build_omp_clause (enum omp_clause_code);
8da1b058
RS		 3544
3545/* Construct various nodes representing data types. */
3546
46c5ad27
AJ		 3547extern tree make_signed_type (int);
3548extern tree make_unsigned_type (int);
2f4675b4 3549extern tree signed_type_for (tree);
8b11a64c 3550extern tree unsigned_type_for (tree);
8c1d6d62 3551extern void initialize_sizetypes (bool);
46c5ad27
AJ		 3552extern void set_sizetype (tree);
3553extern void fixup_unsigned_type (tree);
22421b79 3554extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool);
46c5ad27 3555extern tree build_pointer_type (tree);
22421b79 3556extern tree build_reference_type_for_mode (tree, enum machine_mode, bool);
46c5ad27 3557extern tree build_reference_type (tree);
4a5eab38
PB		 3558extern tree build_vector_type_for_mode (tree, enum machine_mode);
3559extern tree build_vector_type (tree innertype, int nunits);
46c5ad27
AJ		 3560extern tree build_type_no_quals (tree);
3561extern tree build_index_type (tree);
3562extern tree build_index_2_type (tree, tree);
3563extern tree build_array_type (tree, tree);
3564extern tree build_function_type (tree, tree);
3565extern tree build_function_type_list (tree, ...);
43dc123f 3566extern tree build_method_type_directly (tree, tree, tree);
46c5ad27
AJ		 3567extern tree build_method_type (tree, tree);
3568extern tree build_offset_type (tree, tree);
3569extern tree build_complex_type (tree);
b4660e5a 3570extern tree build_resx (int);
46c5ad27 3571extern tree array_type_nelts (tree);
a7e5372d 3572extern bool in_array_bounds_p (tree);
46c5ad27
AJ		 3573
3574extern tree value_member (tree, tree);
3575extern tree purpose_member (tree, tree);
fd917e0d 3576
46c5ad27
AJ		 3577extern int attribute_list_equal (tree, tree);
3578extern int attribute_list_contained (tree, tree);
3579extern int tree_int_cst_equal (tree, tree);
3580extern int tree_int_cst_lt (tree, tree);
3581extern int tree_int_cst_compare (tree, tree);
3582extern int host_integerp (tree, int);
3583extern HOST_WIDE_INT tree_low_cst (tree, int);
3584extern int tree_int_cst_msb (tree);
3585extern int tree_int_cst_sgn (tree);
d7bf3bcf 3586extern int tree_int_cst_sign_bit (tree);
46c5ad27 3587extern int tree_expr_nonnegative_p (tree);
82b85a85 3588extern bool may_negate_without_overflow_p (tree);
46c5ad27 3589extern tree get_inner_array_type (tree);
12cfc830 3590
f837a861
MM		 3591/* From expmed.c. Since rtl.h is included after tree.h, we can't
3592 put the prototype here. Rtl.h does declare the prototype if
3593 tree.h had been included. */
3594
46c5ad27 3595extern tree make_tree (tree, rtx);
8da1b058 3596\f
bad1b4ba
RK		 3597/* Return a type like TTYPE except that its TYPE_ATTRIBUTES
3598 is ATTRIBUTE.
3599
3600 Such modified types already made are recorded so that duplicates
2ba84f36 3601 are not made. */
bad1b4ba 3602
46c5ad27
AJ		 3603extern tree build_type_attribute_variant (tree, tree);
3604extern tree build_decl_attribute_variant (tree, tree);
bad1b4ba 3605
91d231cb
JM		 3606/* Structure describing an attribute and a function to handle it. */
3607struct attribute_spec
3608{
3609 /* The name of the attribute (without any leading or trailing __),
3610 or NULL to mark the end of a table of attributes. */
8b60264b 3611 const char *const name;
91d231cb 3612 /* The minimum length of the list of arguments of the attribute. */
8b60264b 3613 const int min_length;
91d231cb
JM		 3614 /* The maximum length of the list of arguments of the attribute
3615 (-1 for no maximum). */
8b60264b 3616 const int max_length;
91d231cb
JM		 3617 /* Whether this attribute requires a DECL. If it does, it will be passed
3618 from types of DECLs, function return types and array element types to
3619 the DECLs, function types and array types respectively; but when
3620 applied to a type in any other circumstances, it will be ignored with
3621 a warning. (If greater control is desired for a given attribute,
3622 this should be false, and the flags argument to the handler may be
3623 used to gain greater control in that case.) */
8b60264b 3624 const bool decl_required;
91d231cb
JM		 3625 /* Whether this attribute requires a type. If it does, it will be passed
3626 from a DECL to the type of that DECL. */
8b60264b 3627 const bool type_required;
91d231cb
JM		 3628 /* Whether this attribute requires a function (or method) type. If it does,
3629 it will be passed from a function pointer type to the target type,
3630 and from a function return type (which is not itself a function
3631 pointer type) to the function type. */
8b60264b 3632 const bool function_type_required;
91d231cb
JM		 3633 /* Function to handle this attribute. NODE points to the node to which
3634 the attribute is to be applied. If a DECL, it should be modified in
3635 place; if a TYPE, a copy should be created. NAME is the name of the
3636 attribute (possibly with leading or trailing __). ARGS is the TREE_LIST
3637 of the arguments (which may be NULL). FLAGS gives further information
3638 about the context of the attribute. Afterwards, the attributes will
3639 be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
3640 unless *NO_ADD_ATTRS is set to true (which should be done on error,
3641 as well as in any other cases when the attributes should not be added
3642 to the DECL or TYPE). Depending on FLAGS, any attributes to be
3643 applied to another type or DECL later may be returned;
3644 otherwise the return value should be NULL_TREE. This pointer may be
3645 NULL if no special handling is required beyond the checks implied
3646 by the rest of this structure. */
46c5ad27
AJ		 3647 tree (*const handler) (tree *node, tree name, tree args,
3648 int flags, bool *no_add_attrs);
91d231cb
JM		 3649};
3650
91d231cb
JM		 3651/* Flags that may be passed in the third argument of decl_attributes, and
3652 to handler functions for attributes. */
3653enum attribute_flags
3654{
3655 /* The type passed in is the type of a DECL, and any attributes that
3656 should be passed in again to be applied to the DECL rather than the
3657 type should be returned. */
3658 ATTR_FLAG_DECL_NEXT = 1,
3659 /* The type passed in is a function return type, and any attributes that
3660 should be passed in again to be applied to the function type rather
3661 than the return type should be returned. */
3662 ATTR_FLAG_FUNCTION_NEXT = 2,
3663 /* The type passed in is an array element type, and any attributes that
3664 should be passed in again to be applied to the array type rather
3665 than the element type should be returned. */
3666 ATTR_FLAG_ARRAY_NEXT = 4,
3667 /* The type passed in is a structure, union or enumeration type being
3668 created, and should be modified in place. */
6431177a
JM		 3669 ATTR_FLAG_TYPE_IN_PLACE = 8,
3670 /* The attributes are being applied by default to a library function whose
3671 name indicates known behavior, and should be silently ignored if they
3672 are not in fact compatible with the function type. */
3673 ATTR_FLAG_BUILT_IN = 16
91d231cb
JM		 3674};
3675
501990bb
NB		 3676/* Default versions of target-overridable functions. */
3677
46c5ad27
AJ		 3678extern tree merge_decl_attributes (tree, tree);
3679extern tree merge_type_attributes (tree, tree);
d9525bec 3680
0e9e1e0a 3681/* Given a tree node and a string, return nonzero if the tree node is
9c130398
DE		 3682 a valid attribute name for the string. */
3683
46c5ad27 3684extern int is_attribute_p (const char *, tree);
9c130398
DE		 3685
3686/* Given an attribute name and a list of attributes, return the list element
3687 of the attribute or NULL_TREE if not found. */
3688
46c5ad27 3689extern tree lookup_attribute (const char *, tree);
6cb3d314
DE		 3690
3691/* Given two attributes lists, return a list of their union. */
3692
46c5ad27 3693extern tree merge_attributes (tree, tree);
9c130398 3694
b2ca3702 3695#if TARGET_DLLIMPORT_DECL_ATTRIBUTES
672a6f42
NB		 3696/* Given two Windows decl attributes lists, possibly including
3697 dllimport, return a list of their union . */
46c5ad27 3698extern tree merge_dllimport_decl_attributes (tree, tree);
b2ca3702
MM		 3699
3700/* Handle a "dllimport" or "dllexport" attribute. */
3701extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
672a6f42
NB		 3702#endif
3703
896c3aa3
JM		 3704/* Check whether CAND is suitable to be returned from get_qualified_type
3705 (BASE, TYPE_QUALS). */
3706
3707extern bool check_qualified_type (tree, tree, int);
3708
5101b304
MM		 3709/* Return a version of the TYPE, qualified as indicated by the
3710 TYPE_QUALS, if one exists. If no qualified version exists yet,
3711 return NULL_TREE. */
3712
46c5ad27 3713extern tree get_qualified_type (tree, int);
5101b304
MM		 3714
3715/* Like get_qualified_type, but creates the type if it does not
3716 exist. This function never returns NULL_TREE. */
3932261a 3717
46c5ad27 3718extern tree build_qualified_type (tree, int);
3932261a
MM		 3719
3720/* Like build_qualified_type, but only deals with the `const' and
3721 `volatile' qualifiers. This interface is retained for backwards
14b493d6 3722 compatibility with the various front-ends; new code should use
3932261a 3723 build_qualified_type instead. */
8da1b058 3724
3932261a 3725#define build_type_variant(TYPE, CONST_P, VOLATILE_P) \
b9daac31 3726 build_qualified_type ((TYPE), \
3932261a
MM		 3727 ((CONST_P) ? TYPE_QUAL_CONST : 0) \
3728 | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))
8da1b058 3729
43100b14
RS		 3730/* Make a copy of a type node. */
3731
8dd16ecc
NS		 3732extern tree build_distinct_type_copy (tree);
3733extern tree build_variant_type_copy (tree);
43100b14 3734
4977bab6 3735/* Finish up a builtin RECORD_TYPE. Give it a name and provide its
86df8c86 3736 fields. Optionally specify an alignment, and then lay it out. */
4977bab6 3737
46c5ad27
AJ		 3738extern void finish_builtin_struct (tree, const char *,
3739 tree, tree);
4977bab6 3740
8da1b058 3741/* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
9328904c
MM		 3742 TYPE_ALIGN and TYPE_MODE fields. If called more than once on one
3743 node, does nothing except for the first time. */
8da1b058 3744
46c5ad27 3745extern void layout_type (tree);
8da1b058 3746
9328904c
MM		 3747/* These functions allow a front-end to perform a manual layout of a
3748 RECORD_TYPE. (For instance, if the placement of subsequent fields
3749 depends on the placement of fields so far.) Begin by calling
770ae6cc 3750 start_record_layout. Then, call place_field for each of the
9328904c
MM		 3751 fields. Then, call finish_record_layout. See layout_type for the
3752 default way in which these functions are used. */
3753
defd0dea 3754typedef struct record_layout_info_s
9328904c
MM		 3755{
3756 /* The RECORD_TYPE that we are laying out. */
3757 tree t;
770ae6cc
RK		 3758 /* The offset into the record so far, in bytes, not including bits in
3759 BITPOS. */
3760 tree offset;
3761 /* The last known alignment of SIZE. */
3762 unsigned int offset_align;
3763 /* The bit position within the last OFFSET_ALIGN bits, in bits. */
3764 tree bitpos;
9328904c
MM		 3765 /* The alignment of the record so far, in bits. */
3766 unsigned int record_align;
78d55cc8
JM		 3767 /* The alignment of the record so far, ignoring #pragma pack and
3768 __attribute__ ((packed)), in bits. */
770ae6cc 3769 unsigned int unpacked_align;
f913c102
AO		 3770 /* The previous field layed out. */
3771 tree prev_field;
9328904c
MM		 3772 /* The static variables (i.e., class variables, as opposed to
3773 instance variables) encountered in T. */
3774 tree pending_statics;
e4850f36
DR		 3775 /* Bits remaining in the current alignment group */
3776 int remaining_in_alignment;
cbbaf4ae
R		 3777 /* True if prev_field was packed and we haven't found any non-packed
3778 fields that we have put in the same alignment group. */
3779 int prev_packed;
78d55cc8
JM		 3780 /* True if we've seen a packed field that didn't have normal
3781 alignment anyway. */
9328904c 3782 int packed_maybe_necessary;
770ae6cc 3783} *record_layout_info;
9328904c 3784
46c5ad27
AJ		 3785extern void set_lang_adjust_rli (void (*) (record_layout_info));
3786extern record_layout_info start_record_layout (tree);
3787extern tree bit_from_pos (tree, tree);
3788extern tree byte_from_pos (tree, tree);
3789extern void pos_from_bit (tree *, tree *, unsigned int, tree);
3790extern void normalize_offset (tree *, tree *, unsigned int);
3791extern tree rli_size_unit_so_far (record_layout_info);
3792extern tree rli_size_so_far (record_layout_info);
3793extern void normalize_rli (record_layout_info);
3794extern void place_field (record_layout_info, tree);
3795extern void compute_record_mode (tree);
3796extern void finish_record_layout (record_layout_info, int);
9328904c 3797
8da1b058
RS		 3798/* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
3799 return a canonicalized ..._TYPE node, so that duplicates are not made.
3800 How the hash code is computed is up to the caller, as long as any two
3801 callers that could hash identical-looking type nodes agree. */
3802
46c5ad27 3803extern tree type_hash_canon (unsigned int, tree);
8da1b058
RS		 3804
3805/* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
3806 calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
3807 fields. Call this only once for any given decl node.
3808
3809 Second argument is the boundary that this field can be assumed to
3810 be starting at (in bits). Zero means it can be assumed aligned
3811 on any boundary that may be needed. */
3812
46c5ad27 3813extern void layout_decl (tree, unsigned);
8da1b058 3814
d8472c75
JM		 3815/* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
3816 a previous call to layout_decl and calls it again. */
3817
3818extern void relayout_decl (tree);
3819
72c602fc
RK		 3820/* Return the mode for data of a given size SIZE and mode class CLASS.
3821 If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
3822 The value is BLKmode if no other mode is found. This is like
3823 mode_for_size, but is passed a tree. */
3824
46c5ad27 3825extern enum machine_mode mode_for_size_tree (tree, enum mode_class, int);
72c602fc 3826
8da1b058
RS		 3827/* Return an expr equal to X but certainly not valid as an lvalue. */
3828
46c5ad27 3829extern tree non_lvalue (tree);
46c5ad27
AJ		 3830
3831extern tree convert (tree, tree);
3832extern unsigned int expr_align (tree);
3833extern tree expr_first (tree);
3834extern tree expr_last (tree);
6de9cd9a 3835extern tree expr_only (tree);
46c5ad27
AJ		 3836extern tree size_in_bytes (tree);
3837extern HOST_WIDE_INT int_size_in_bytes (tree);
3838extern tree bit_position (tree);
3839extern HOST_WIDE_INT int_bit_position (tree);
3840extern tree byte_position (tree);
3841extern HOST_WIDE_INT int_byte_position (tree);
fed3cef0
RK		 3842
3843/* Define data structures, macros, and functions for handling sizes
3844 and the various types used to represent sizes. */
3845
3846enum size_type_kind
3847{
2ba84f36
KH		 3848 SIZETYPE, /* Normal representation of sizes in bytes. */
3849 SSIZETYPE, /* Signed representation of sizes in bytes. */
fed3cef0
RK		 3850 BITSIZETYPE, /* Normal representation of sizes in bits. */
3851 SBITSIZETYPE, /* Signed representation of sizes in bits. */
fed3cef0
RK		 3852 TYPE_KIND_LAST};
3853
e2500fed 3854extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST];
fed3cef0
RK		 3855
3856#define sizetype sizetype_tab[(int) SIZETYPE]
3857#define bitsizetype sizetype_tab[(int) BITSIZETYPE]
3858#define ssizetype sizetype_tab[(int) SSIZETYPE]
fed3cef0 3859#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
fed3cef0 3860
ce552f75 3861extern tree size_int_kind (HOST_WIDE_INT, enum size_type_kind);
46c5ad27
AJ		 3862extern tree size_binop (enum tree_code, tree, tree);
3863extern tree size_diffop (tree, tree);
3e95a7cb
ZW		 3864
3865#define size_int(L) size_int_kind (L, SIZETYPE)
3866#define ssize_int(L) size_int_kind (L, SSIZETYPE)
3867#define bitsize_int(L) size_int_kind (L, BITSIZETYPE)
3868#define sbitsize_int(L) size_int_kind (L, SBITSIZETYPE)
f8dac6eb 3869
46c5ad27
AJ		 3870extern tree round_up (tree, int);
3871extern tree round_down (tree, int);
3872extern tree get_pending_sizes (void);
46c5ad27
AJ		 3873extern void put_pending_size (tree);
3874extern void put_pending_sizes (tree);
8da1b058
RS		 3875
3876/* Type for sizes of data-type. */
3877
f8dac6eb
R		 3878#define BITS_PER_UNIT_LOG \
3879 ((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) \
3880 + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
3881 + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))
3882
467cecf3 3883/* If nonzero, an upper limit on alignment of structure fields, in bits, */
729a2125 3884extern unsigned int maximum_field_alignment;
8c27b7d4 3885/* and its original value in bytes, specified via -fpack-struct=<value>. */
467cecf3 3886extern unsigned int initial_max_fld_align;
8294accf 3887
8da1b058
RS		 3888/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
3889 by making the last node in X point to Y.
3890 Returns X, except if X is 0 returns Y. */
3891
46c5ad27 3892extern tree chainon (tree, tree);
8da1b058
RS		 3893
3894/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
3895
b9dcdee4
JH		 3896extern tree tree_cons_stat (tree, tree, tree MEM_STAT_DECL);
3897#define tree_cons(t,q,w) tree_cons_stat (t,q,w MEM_STAT_INFO)
8da1b058
RS		 3898
3899/* Return the last tree node in a chain. */
3900
46c5ad27 3901extern tree tree_last (tree);
8da1b058
RS		 3902
3903/* Reverse the order of elements in a chain, and return the new head. */
3904
46c5ad27 3905extern tree nreverse (tree);
8da1b058
RS		 3906
3907/* Returns the length of a chain of nodes
3908 (number of chain pointers to follow before reaching a null pointer). */
3909
46c5ad27 3910extern int list_length (tree);
8da1b058 3911
c3b247b4
JM		 3912/* Returns the number of FIELD_DECLs in a type. */
3913
46c5ad27 3914extern int fields_length (tree);
c3b247b4 3915
27b41650
KG		 3916/* Given an initializer INIT, return TRUE if INIT is zero or some
3917 aggregate of zeros. Otherwise return FALSE. */
3918
46c5ad27 3919extern bool initializer_zerop (tree);
27b41650 3920
6f642f98
RH		 3921extern void categorize_ctor_elements (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
3922 HOST_WIDE_INT *, bool *);
73ed17ff 3923extern HOST_WIDE_INT count_type_elements (tree, bool);
40209195 3924
ea4b7848 3925/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0. */
8da1b058 3926
46c5ad27 3927extern int integer_zerop (tree);
8da1b058 3928
ea4b7848 3929/* integer_onep (tree x) is nonzero if X is an integer constant of value 1. */
8da1b058 3930
46c5ad27 3931extern int integer_onep (tree);
8da1b058
RS		 3932
3933/* integer_all_onesp (tree x) is nonzero if X is an integer constant
3934 all of whose significant bits are 1. */
3935
46c5ad27 3936extern int integer_all_onesp (tree);
8da1b058
RS		 3937
3938/* integer_pow2p (tree x) is nonzero is X is an integer constant with
3939 exactly one bit 1. */
3940
46c5ad27 3941extern int integer_pow2p (tree);
8da1b058 3942
4977bab6
ZW		 3943/* integer_nonzerop (tree x) is nonzero if X is an integer constant
3944 with a nonzero value. */
3945
46c5ad27 3946extern int integer_nonzerop (tree);
4977bab6 3947
8b11a64c
ZD		 3948extern bool zero_p (tree);
3949extern bool cst_and_fits_in_hwi (tree);
ca4c3169 3950extern tree num_ending_zeros (tree);
8b11a64c 3951
525c6bf5
RH		 3952/* staticp (tree x) is nonzero if X is a reference to data allocated
3953 at a fixed address in memory. Returns the outermost data. */
8da1b058 3954
525c6bf5 3955extern tree staticp (tree);
8da1b058 3956
8da1b058
RS		 3957/* save_expr (EXP) returns an expression equivalent to EXP
3958 but it can be used multiple times within context CTX
3959 and only evaluate EXP once. */
3960
46c5ad27 3961extern tree save_expr (tree);
8da1b058 3962
a9ecacf6
OH		 3963/* Look inside EXPR and into any simple arithmetic operations. Return
3964 the innermost non-arithmetic node. */
3965
46c5ad27 3966extern tree skip_simple_arithmetic (tree);
a9ecacf6 3967
e2500fed
GK		 3968/* Return which tree structure is used by T. */
3969
46c5ad27 3970enum tree_node_structure_enum tree_node_structure (tree);
e2500fed 3971
7380d707
RK		 3972/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
3973 or offset that depends on a field within a record.
3974
3975 Note that we only allow such expressions within simple arithmetic
3976 or a COND_EXPR. */
3977
46c5ad27 3978extern bool contains_placeholder_p (tree);
7a6cdb44
RK		 3979
3980/* This macro calls the above function but short-circuits the common
3981 case of a constant to save time. Also check for null. */
3982
3983#define CONTAINS_PLACEHOLDER_P(EXP) \
3984 ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
3985
3986/* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
3987 This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
3988 positions. */
3989
46c5ad27 3990extern bool type_contains_placeholder_p (tree);
7380d707
RK		 3991
3992/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3993 return a tree with all occurrences of references to F in a
3994 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
3995 contains only arithmetic expressions. */
3996
46c5ad27 3997extern tree substitute_in_expr (tree, tree, tree);
7380d707 3998
6fce44af
RK		 3999/* This macro calls the above function but short-circuits the common
4000 case of a constant to save time and also checks for NULL. */
4001
4002#define SUBSTITUTE_IN_EXPR(EXP, F, R) \
4003 ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
4004
4005/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
4006 for it within OBJ, a tree that is an object or a chain of references. */
4007
4008extern tree substitute_placeholder_in_expr (tree, tree);
4009
4010/* This macro calls the above function but short-circuits the common
4011 case of a constant to save time and also checks for NULL. */
4012
4013#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
4014 ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \
4015 : substitute_placeholder_in_expr (EXP, OBJ))
4016
90ca31be
RS		 4017/* variable_size (EXP) is like save_expr (EXP) except that it
4018 is for the special case of something that is part of a
4019 variable size for a data type. It makes special arrangements
4020 to compute the value at the right time when the data type
4021 belongs to a function parameter. */
4022
46c5ad27 4023extern tree variable_size (tree);
90ca31be 4024
dcc24678 4025/* stabilize_reference (EXP) returns a reference equivalent to EXP
8da1b058
RS		 4026 but it can be used multiple times
4027 and only evaluate the subexpressions once. */
4028
46c5ad27 4029extern tree stabilize_reference (tree);
8da1b058 4030
1c8b10bb
RK		 4031/* Subroutine of stabilize_reference; this is called for subtrees of
4032 references. Any expression with side-effects must be put in a SAVE_EXPR
4033 to ensure that it is only evaluated once. */
4034
46c5ad27 4035extern tree stabilize_reference_1 (tree);
1c8b10bb 4036
8da1b058
RS		 4037/* Return EXP, stripped of any conversions to wider types
4038 in such a way that the result of converting to type FOR_TYPE
4039 is the same as if EXP were converted to FOR_TYPE.
4040 If FOR_TYPE is 0, it signifies EXP's type. */
4041
46c5ad27 4042extern tree get_unwidened (tree, tree);
8da1b058
RS		 4043
4044/* Return OP or a simpler expression for a narrower value
4045 which can be sign-extended or zero-extended to give back OP.
4046 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4047 or 0 if the value should be sign-extended. */
4048
46c5ad27 4049extern tree get_narrower (tree, int *);
8da1b058 4050
8da1b058
RS		 4051/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
4052 look for nested component-refs or array-refs at constant positions
4053 and find the ultimate containing object, which is returned. */
4054
46c5ad27 4055extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
579eab58
EB		 4056 tree *, enum machine_mode *, int *, int *,
4057 bool);
8da1b058 4058
ed239f5a
RK		 4059/* Return 1 if T is an expression that get_inner_reference handles. */
4060
46c5ad27 4061extern int handled_component_p (tree);
ed239f5a 4062
44de5aeb
RK		 4063/* Return a tree of sizetype representing the size, in bytes, of the element
4064 of EXP, an ARRAY_REF. */
4065
4066extern tree array_ref_element_size (tree);
4067
4068/* Return a tree representing the lower bound of the array mentioned in
4069 EXP, an ARRAY_REF. */
4070
4071extern tree array_ref_low_bound (tree);
4072
a7e5372d
ZD		 4073/* Return a tree representing the upper bound of the array mentioned in
4074 EXP, an ARRAY_REF. */
4075
4076extern tree array_ref_up_bound (tree);
4077
44de5aeb
RK		 4078/* Return a tree representing the offset, in bytes, of the field referenced
4079 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
4080
4081extern tree component_ref_field_offset (tree);
4082
140b60b4
MM		 4083/* Given a DECL or TYPE, return the scope in which it was declared, or
4084 NUL_TREE if there is no containing scope. */
4085
46c5ad27 4086extern tree get_containing_scope (tree);
140b60b4 4087
8da1b058
RS		 4088/* Return the FUNCTION_DECL which provides this _DECL with its context,
4089 or zero if none. */
46c5ad27 4090extern tree decl_function_context (tree);
8da1b058 4091
3635a54b
RK		 4092/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
4093 this _DECL with its context, or zero if none. */
46c5ad27 4094extern tree decl_type_context (tree);
8da1b058 4095
a3c11cd3 4096/* Return 1 if EXPR is the real constant zero. */
46c5ad27 4097extern int real_zerop (tree);
8da1b058
RS		 4098\f
4099/* Declare commonly used variables for tree structure. */
4100
4812480a
JM		 4101/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
4102 Zero means allow extended lvalues. */
4103
4104extern int pedantic_lvalues;
4105
2ba84f36 4106/* Points to the FUNCTION_DECL of the function whose body we are reading. */
8da1b058 4107
e2500fed 4108extern GTY(()) tree current_function_decl;
8da1b058 4109
00262c8a 4110/* Nonzero means a FUNC_BEGIN label was emitted. */
375d2edc 4111extern GTY(()) const char * current_function_func_begin_label;
8da1b058 4112\f
143f1945 4113/* In tree.c */
2aab7ceb 4114extern unsigned crc32_string (unsigned, const char *);
46c5ad27
AJ		 4115extern void clean_symbol_name (char *);
4116extern tree get_file_function_name_long (const char *);
46c5ad27 4117extern tree get_callee_fndecl (tree);
fccc4eb2 4118extern void change_decl_assembler_name (tree, tree);
46c5ad27 4119extern int type_num_arguments (tree);
3168cb99
JL		 4120extern bool associative_tree_code (enum tree_code);
4121extern bool commutative_tree_code (enum tree_code);
18522563
ZD		 4122extern tree upper_bound_in_type (tree, tree);
4123extern tree lower_bound_in_type (tree, tree);
cdef8bc6 4124extern int operand_equal_for_phi_arg_p (tree, tree);
953ff289 4125extern bool empty_body_p (tree);
143f1945 4126\f
8da1b058
RS		 4127/* In stmt.c */
4128
46c5ad27 4129extern void expand_expr_stmt (tree);
b9861bff 4130extern int warn_if_unused_value (tree, location_t);
46c5ad27
AJ		 4131extern void expand_label (tree);
4132extern void expand_goto (tree);
46c5ad27 4133
6de9cd9a
DN		 4134extern rtx expand_stack_save (void);
4135extern void expand_stack_restore (tree);
46c5ad27 4136extern void expand_return (tree);
46c5ad27
AJ		 4137extern int is_body_block (tree);
4138
165b54c3 4139/* In tree-eh.c */
46c5ad27 4140extern void using_eh_for_cleanups (void);
8da1b058
RS		 4141
4142/* In fold-const.c */
4143
4b63dccb
RK		 4144/* Fold constants as much as possible in an expression.
4145 Returns the simplified expression.
4146 Acts only on the top level of the expression;
4147 if the argument itself cannot be simplified, its
4148 subexpressions are not changed. */
4149
46c5ad27 4150extern tree fold (tree);
721425b6
KH		 4151extern tree fold_unary (enum tree_code, tree, tree);
4152extern tree fold_binary (enum tree_code, tree, tree, tree);
4153extern tree fold_ternary (enum tree_code, tree, tree, tree, tree);
5808968e
AP		 4154extern tree fold_build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
4155#define fold_build1(c,t1,t2) fold_build1_stat (c, t1, t2 MEM_STAT_INFO)
4156extern tree fold_build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
4157#define fold_build2(c,t1,t2,t3) fold_build2_stat (c, t1, t2, t3 MEM_STAT_INFO)
4158extern tree fold_build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
4159#define fold_build3(c,t1,t2,t3,t4) fold_build3_stat (c, t1, t2, t3, t4 MEM_STAT_INFO)
00d1b1d6
JM		 4160extern tree fold_build1_initializer (enum tree_code, tree, tree);
4161extern tree fold_build2_initializer (enum tree_code, tree, tree, tree);
4162extern tree fold_build3_initializer (enum tree_code, tree, tree, tree, tree);
e419fe91 4163extern tree fold_convert (tree, tree);
46c5ad27 4164extern tree fold_single_bit_test (enum tree_code, tree, tree, tree);
9675412f 4165extern tree fold_ignored_result (tree);
9655d83b 4166extern tree fold_abs_const (tree, tree);
095ecc24 4167extern tree fold_indirect_ref_1 (tree, tree);
46c5ad27 4168
ca7a3bd7
NS		 4169extern tree force_fit_type (tree, int, bool, bool);
4170
46c5ad27
AJ		 4171extern int add_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4172 unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4173 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4174extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4175 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4176extern int mul_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4177 unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4178 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4179extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4180 HOST_WIDE_INT, unsigned int,
4181 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
4182extern void rshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4183 HOST_WIDE_INT, unsigned int,
4184 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
4185extern void lrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4186 HOST_WIDE_INT, unsigned int,
4187 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4188extern void rrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4189 HOST_WIDE_INT, unsigned int,
4190 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4191
4192extern int div_and_round_double (enum tree_code, int, unsigned HOST_WIDE_INT,
4193 HOST_WIDE_INT, unsigned HOST_WIDE_INT,
4194 HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
4195 HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
4196 HOST_WIDE_INT *);
4197
6de9cd9a
DN		 4198enum operand_equal_flag
4199{
4200 OEP_ONLY_CONST = 1,
4201 OEP_PURE_SAME = 2
4202};
4203
4204extern int operand_equal_p (tree, tree, unsigned int);
4205
46c5ad27 4206extern tree omit_one_operand (tree, tree, tree);
08039bd8 4207extern tree omit_two_operands (tree, tree, tree, tree);
46c5ad27 4208extern tree invert_truthvalue (tree);
b52d5eaa
RS		 4209extern tree fold_unary_to_constant (enum tree_code, tree, tree);
4210extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree);
6de9cd9a
DN		 4211extern tree fold_read_from_constant_string (tree);
4212extern tree int_const_binop (enum tree_code, tree, tree, int);
cd3ce9b4 4213extern tree build_fold_addr_expr (tree);
e3bb43c0
RS		 4214extern tree fold_build_cleanup_point_expr (tree type, tree expr);
4215extern tree fold_strip_sign_ops (tree);
cd3ce9b4
JM		 4216extern tree build_fold_addr_expr_with_type (tree, tree);
4217extern tree build_fold_indirect_ref (tree);
6a720599 4218extern tree fold_indirect_ref (tree);
e9ea8bd5 4219extern tree constant_boolean_node (int, tree);
38b0dcb8 4220extern tree build_low_bits_mask (tree, unsigned);
c530479e 4221
fd660b1b 4222extern bool tree_swap_operands_p (tree, tree, bool);
3c7d0735 4223extern void swap_tree_operands (tree, tree *, tree *);
fd660b1b
JL		 4224extern enum tree_code swap_tree_comparison (enum tree_code);
4225
2f4675b4 4226extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *);
227858d1 4227extern enum tree_code invert_tree_comparison (enum tree_code, bool);
2f4675b4 4228
4db8040c
JM		 4229extern bool tree_expr_nonzero_p (tree);
4230
4977bab6 4231/* In builtins.c */
49d1af89 4232extern tree fold_builtin (tree, tree, bool);
a32e70c3 4233extern tree fold_builtin_fputs (tree, bool, bool, tree);
a456b432
KH		 4234extern tree fold_builtin_strcpy (tree, tree, tree);
4235extern tree fold_builtin_strncpy (tree, tree, tree);
10a0d495
JJ		 4236extern tree fold_builtin_memory_chk (tree, tree, tree, bool,
4237 enum built_in_function);
4238extern tree fold_builtin_stxcpy_chk (tree, tree, tree, bool,
4239 enum built_in_function);
4240extern tree fold_builtin_strncpy_chk (tree, tree);
4241extern tree fold_builtin_snprintf_chk (tree, tree, enum built_in_function);
2efcfa4e 4242extern bool fold_builtin_next_arg (tree);
46c5ad27
AJ		 4243extern enum built_in_function builtin_mathfn_code (tree);
4244extern tree build_function_call_expr (tree, tree);
4245extern tree mathfn_built_in (tree, enum built_in_function fn);
6de9cd9a 4246extern tree strip_float_extensions (tree);
6de9cd9a 4247extern tree c_strlen (tree, int);
e5da415c 4248extern tree std_gimplify_va_arg_expr (tree, tree, tree *, tree *);
c2433d7d 4249extern tree build_va_arg_indirect_ref (tree);
953ff289 4250tree build_string_literal (int, const char *);
a3c11cd3 4251
77f9af81 4252/* In convert.c */
46c5ad27 4253extern tree strip_float_extensions (tree);
77f9af81 4254
a0c33338 4255/* In alias.c */
46c5ad27
AJ		 4256extern void record_component_aliases (tree);
4257extern HOST_WIDE_INT get_alias_set (tree);
4258extern int alias_sets_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT);
5399d643 4259extern int alias_sets_might_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT);
46c5ad27 4260extern int objects_must_conflict_p (tree, tree);
bebe2280 4261
a1d061a1 4262/* In tree.c */
46c5ad27
AJ		 4263extern int really_constant_p (tree);
4264extern int int_fits_type_p (tree, tree);
5377d5ba 4265extern bool variably_modified_type_p (tree, tree);
46c5ad27
AJ		 4266extern int tree_log2 (tree);
4267extern int tree_floor_log2 (tree);
4268extern int simple_cst_equal (tree, tree);
4269extern unsigned int iterative_hash_expr (tree, unsigned int);
4270extern int compare_tree_int (tree, unsigned HOST_WIDE_INT);
4271extern int type_list_equal (tree, tree);
4272extern int chain_member (tree, tree);
4273extern tree type_hash_lookup (unsigned int, tree);
4274extern void type_hash_add (unsigned int, tree);
46c5ad27
AJ		 4275extern int simple_cst_list_equal (tree, tree);
4276extern void dump_tree_statistics (void);
4277extern void expand_function_end (void);
b79c5284 4278extern void expand_function_start (tree);
7d69de61 4279extern void stack_protect_prologue (void);
b755446c 4280extern void stack_protect_epilogue (void);
127203ac 4281extern void recompute_tree_invariant_for_addr_expr (tree);
c597ef4e 4282extern bool is_global_var (tree t);
6de9cd9a 4283extern bool needs_to_live_in_memory (tree);
b34417a4 4284extern tree reconstruct_complex_type (tree, tree);
46c5ad27
AJ		 4285
4286extern int real_onep (tree);
4287extern int real_twop (tree);
4288extern int real_minus_onep (tree);
4289extern void init_ttree (void);
8c1d6d62 4290extern void build_common_tree_nodes (bool, bool);
46c5ad27 4291extern void build_common_tree_nodes_2 (int);
c6a912da 4292extern void build_common_builtin_nodes (void);
bc15d0ef 4293extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int);
46c5ad27 4294extern tree build_range_type (tree, tree, tree);
56cf8686
SP		 4295extern HOST_WIDE_INT int_cst_value (tree);
4296extern tree tree_fold_gcd (tree, tree);
bde6c65d 4297extern tree build_addr (tree, tree);
a1d061a1 4298
fa27426e
RH		 4299extern bool fields_compatible_p (tree, tree);
4300extern tree find_compatible_field (tree, tree);
4301
a1d061a1 4302/* In function.c */
46c5ad27
AJ		 4303extern void expand_main_function (void);
4304extern void init_dummy_function_start (void);
4305extern void expand_dummy_function_end (void);
c2924966 4306extern unsigned int init_function_for_compilation (void);
3a70d621 4307extern void allocate_struct_function (tree);
46c5ad27 4308extern void init_function_start (tree);
8fff4fc1 4309extern bool use_register_for_decl (tree);
6de9cd9a 4310extern void setjmp_vars_warning (tree);
46c5ad27 4311extern void setjmp_args_warning (void);
46c5ad27 4312extern void init_temp_slots (void);
46c5ad27
AJ		 4313extern void free_temp_slots (void);
4314extern void pop_temp_slots (void);
4315extern void push_temp_slots (void);
4316extern void preserve_temp_slots (rtx);
61f71b34 4317extern int aggregate_value_p (tree, tree);
46c5ad27
AJ		 4318extern void push_function_context (void);
4319extern void pop_function_context (void);
4320extern void push_function_context_to (tree);
4321extern void pop_function_context_from (tree);
4744afba 4322extern tree gimplify_parameters (void);
a1d061a1
JL		 4323
4324/* In print-rtl.c */
4325#ifdef BUFSIZ
46c5ad27 4326extern void print_rtl (FILE *, rtx);
a1d061a1
JL		 4327#endif
4328
4329/* In print-tree.c */
46c5ad27 4330extern void debug_tree (tree);
a1d061a1 4331#ifdef BUFSIZ
46c5ad27
AJ		 4332extern void print_node (FILE *, const char *, tree, int);
4333extern void print_node_brief (FILE *, const char *, tree, int);
4334extern void indent_to (FILE *, int);
a1d061a1
JL		 4335#endif
4336
61a36b9b
RK		 4337/* In tree-inline.c: */
4338extern bool debug_find_tree (tree, tree);
19114537
EC		 4339/* This is in tree-inline.c since the routine uses
4340 data structures from the inliner. */
4341extern tree unsave_expr_now (tree);
52dd234b 4342extern tree build_duplicate_type (tree);
61a36b9b 4343
a1d061a1 4344/* In emit-rtl.c */
0cea056b 4345extern rtx emit_line_note (location_t);
a1d061a1 4346
3a8c995b 4347/* In calls.c */
f2d33f13 4348
6e14af16
ZW		 4349/* Nonzero if this is a call to a function whose return value depends
4350 solely on its arguments, has no side effects, and does not read
4351 global memory. */
fa5b060f 4352#define ECF_CONST 1
6e14af16 4353/* Nonzero if this call will never return. */
fa5b060f
SB		 4354#define ECF_NORETURN 2
4355/* Nonzero if this is a call to malloc or a related function. */
4356#define ECF_MALLOC 4
4357/* Nonzero if it is plausible that this is a call to alloca. */
4358#define ECF_MAY_BE_ALLOCA 8
4359/* Nonzero if this is a call to a function that won't throw an exception. */
4360#define ECF_NOTHROW 16
4361/* Nonzero if this is a call to setjmp or a related function. */
4362#define ECF_RETURNS_TWICE 32
6e14af16
ZW		 4363/* Nonzero if this call replaces the current stack frame. */
4364#define ECF_SIBCALL 64
fa5b060f
SB		 4365/* Nonzero if this is a call to "pure" function (like const function,
4366 but may read memory. */
6e14af16 4367#define ECF_PURE 128
fa5b060f
SB		 4368/* Nonzero if this is a call to a function that returns with the stack
4369 pointer depressed. */
6e14af16 4370#define ECF_SP_DEPRESSED 256
fa5b060f 4371/* Create libcall block around the call. */
321cf1f2 4372#define ECF_LIBCALL_BLOCK 512
dcd6de6d
ZD		 4373/* Function does not read or write memory (but may have side effects, so
4374 it does not necessarily fit ECF_CONST). */
4375#define ECF_NOVOPS 1024
fa5b060f 4376
46c5ad27 4377extern int flags_from_decl_or_type (tree);
f027e0a2 4378extern int call_expr_flags (tree);
fa5b060f 4379
46c5ad27
AJ		 4380extern int setjmp_call_p (tree);
4381extern bool alloca_call_p (tree);
fe984136
RH		 4382extern bool must_pass_in_stack_var_size (enum machine_mode, tree);
4383extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, tree);
3a8c995b 4384
bb9f8221 4385/* In attribs.c. */
0c96e965
RK		 4386
4387/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
4388 which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
4389 it should be modified in place; if a TYPE, a copy should be created
4390 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
4391 information, in the form of a bitwise OR of flags in enum attribute_flags
4392 from tree.h. Depending on these flags, some attributes may be
4393 returned to be applied at a later stage (for example, to apply
4394 a decl attribute to the declaration rather than to its type). */
4682ae04 4395extern tree decl_attributes (tree *, tree, int);
bb9f8221 4396
a1d061a1 4397/* In integrate.c */
46c5ad27 4398extern void set_decl_abstract_flags (tree, int);
46c5ad27 4399extern void set_decl_origin_self (tree);
a1d061a1 4400
a1d061a1 4401/* In stor-layout.c */
7b6d72fc 4402extern void set_min_and_max_values_for_integral_type (tree, int, bool);
46c5ad27
AJ		 4403extern void fixup_signed_type (tree);
4404extern void internal_reference_types (void);
6de9cd9a
DN		 4405extern unsigned int update_alignment_for_field (record_layout_info, tree,
4406 unsigned int);
a1d061a1 4407/* varasm.c */
0e6df31e 4408extern void make_decl_rtl (tree);
46c5ad27
AJ		 4409extern void make_decl_one_only (tree);
4410extern int supports_one_only (void);
46c5ad27
AJ		 4411extern void resolve_unique_section (tree, int, int);
4412extern void mark_referenced (tree);
bb9a388d 4413extern void mark_decl_referenced (tree);
810db579 4414extern void notice_global_symbol (tree);
0e6df31e 4415extern void set_user_assembler_name (tree, const char *);
857e7259 4416extern void process_pending_assemble_externals (void);
e4d5432a
RH		 4417extern void finish_aliases_1 (void);
4418extern void finish_aliases_2 (void);
a1d061a1 4419
a1d061a1 4420/* In stmt.c */
46c5ad27
AJ		 4421extern void expand_computed_goto (tree);
4422extern bool parse_output_constraint (const char **, int, int, int,
4423 bool *, bool *, bool *);
1456deaf
JM		 4424extern bool parse_input_constraint (const char **, int, int, int, int,
4425 const char * const *, bool *, bool *);
6de9cd9a 4426extern void expand_asm_expr (tree);
7dc8b126 4427extern tree resolve_asm_operand_names (tree, tree, tree);
7efcb746 4428extern void expand_case (tree);
46c5ad27 4429extern void expand_decl (tree);
46c5ad27 4430extern void expand_anon_union_decl (tree, tree, tree);
61158923
HPN		 4431#ifdef HARD_CONST
4432/* Silly ifdef to avoid having all includers depend on hard-reg-set.h. */
91b4415a 4433extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *);
61158923 4434#endif
6de9cd9a
DN		 4435
4436/* In gimplify.c. */
4437extern tree create_artificial_label (void);
4438extern void gimplify_function_tree (tree);
4439extern const char *get_name (tree);
4440extern tree unshare_expr (tree);
0f1f6967 4441extern void sort_case_labels (tree);
a1d061a1 4442
496651db
MM		 4443/* If KIND=='I', return a suitable global initializer (constructor) name.
4444 If KIND=='D', return a suitable global clean-up (destructor) name. */
46c5ad27 4445extern tree get_file_function_name (int);
af4142d5
JM		 4446\f
4447/* Interface of the DWARF2 unwind info support. */
4448
af4142d5
JM		 4449/* Generate a new label for the CFI info to refer to. */
4450
46c5ad27 4451extern char *dwarf2out_cfi_label (void);
af4142d5
JM		 4452
4453/* Entry point to update the canonical frame address (CFA). */
4454
0ab5b679 4455extern void dwarf2out_def_cfa (const char *, unsigned, HOST_WIDE_INT);
af4142d5
JM		 4456
4457/* Add the CFI for saving a register window. */
4458
46c5ad27 4459extern void dwarf2out_window_save (const char *);
af4142d5
JM		 4460
4461/* Add a CFI to update the running total of the size of arguments pushed
4462 onto the stack. */
4463
0ab5b679 4464extern void dwarf2out_args_size (const char *, HOST_WIDE_INT);
af4142d5
JM		 4465
4466/* Entry point for saving a register to the stack. */
4467
0ab5b679 4468extern void dwarf2out_reg_save (const char *, unsigned, HOST_WIDE_INT);
af4142d5
JM		 4469
4470/* Entry point for saving the return address in the stack. */
4471
0ab5b679 4472extern void dwarf2out_return_save (const char *, HOST_WIDE_INT);
af4142d5
JM		 4473
4474/* Entry point for saving the return address in a register. */
4475
46c5ad27 4476extern void dwarf2out_return_reg (const char *, unsigned);
af4142d5 4477
150cdc9e
RH		 4478/* Entry point for saving the first register into the second. */
4479
4480extern void dwarf2out_reg_save_reg (const char *, rtx, rtx);
4481
d8472c75
JM		 4482/* In tree-inline.c */
4483
0c58f841
MA		 4484/* The type of a set of already-visited pointers. Functions for creating
4485 and manipulating it are declared in pointer-set.h */
4486struct pointer_set_t;
4487
6de9cd9a 4488/* The type of a callback function for walking over tree structure. */
588d3ade 4489
46c5ad27 4490typedef tree (*walk_tree_fn) (tree *, int *, void *);
0c58f841 4491extern tree walk_tree (tree*, walk_tree_fn, void*, struct pointer_set_t*);
d8472c75 4492extern tree walk_tree_without_duplicates (tree*, walk_tree_fn, void*);
588d3ade 4493
a560d4d4
JH		 4494/* Assign the RTX to declaration. */
4495
46c5ad27 4496extern void set_decl_rtl (tree, rtx);
fbe6ec81 4497extern void set_decl_incoming_rtl (tree, rtx);
9a6bb3f7 4498\f
caf93cb0 4499/* Enum and arrays used for tree allocation stats.
938d968e 4500 Keep in sync with tree.c:tree_node_kind_names. */
adc4adcd
GP		 4501typedef enum
4502{
4503 d_kind,
4504 t_kind,
4505 b_kind,
4506 s_kind,
4507 r_kind,
4508 e_kind,
4509 c_kind,
4510 id_kind,
4511 perm_list_kind,
4512 temp_list_kind,
4513 vec_kind,
95b4aca6 4514 binfo_kind,
6de9cd9a
DN		 4515 phi_kind,
4516 ssa_name_kind,
4038c495 4517 constr_kind,
adc4adcd
GP		 4518 x_kind,
4519 lang_decl,
4520 lang_type,
aaf46ef9 4521 omp_clause_kind,
adc4adcd
GP		 4522 all_kinds
4523} tree_node_kind;
4524
4525extern int tree_node_counts[];
4526extern int tree_node_sizes[];
6de9cd9a
DN		 4527
4528/* True if we are in gimple form and the actions of the folders need to
4529 be restricted. False if we are not in gimple form and folding is not
4530 restricted to creating gimple expressions. */
4531extern bool in_gimple_form;
caf93cb0 4532
389fdba0
RH		 4533/* In tree-gimple.c. */
4534extern tree get_base_address (tree t);
4535
c866976a
LB		 4536/* In tree-vectorizer.c. */
4537extern void vect_set_verbosity_level (const char *);
4538
820cc88f
DB		 4539struct tree_map GTY(())
4540{
4541 unsigned int hash;
4542 tree from;
4543 tree to;
4544};
4545
4546extern unsigned int tree_map_hash (const void *);
4547extern int tree_map_marked_p (const void *);
4548extern int tree_map_eq (const void *, const void *);
4549
ac182688
ZD		 4550/* In tree-ssa-address.c. */
4551extern tree tree_mem_ref_addr (tree, tree);
4552extern void copy_mem_ref_info (tree, tree);
4553
b16caf72
JL		 4554/* In tree-vrp.c */
4555extern bool ssa_name_nonzero_p (tree);
4556extern bool ssa_name_nonnegative_p (tree);
4557
10a0d495
JJ		 4558/* In tree-object-size.c. */
4559extern void init_object_sizes (void);
4560extern void fini_object_sizes (void);
4561extern unsigned HOST_WIDE_INT compute_builtin_object_size (tree, int);
4562
86a07404
IR		 4563/* In expr.c. */
4564extern unsigned HOST_WIDE_INT highest_pow2_factor (tree);
4565
df89f8e7 4566#endif /* GCC_TREE_H */
GNU Compiler Collection
This page took 4.724616 seconds and 5 git commands to generate.