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