1 | /* Front-end tree definitions for GNU compiler. |
---|
2 | Copyright (C) 1989, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc. |
---|
3 | |
---|
4 | This file is part of GNU CC. |
---|
5 | |
---|
6 | GNU CC is free software; you can redistribute it and/or modify |
---|
7 | it under the terms of the GNU General Public License as published by |
---|
8 | the Free Software Foundation; either version 2, or (at your option) |
---|
9 | any later version. |
---|
10 | |
---|
11 | GNU CC is distributed in the hope that it will be useful, |
---|
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
14 | GNU General Public License for more details. |
---|
15 | |
---|
16 | You should have received a copy of the GNU General Public License |
---|
17 | along with GNU CC; see the file COPYING. If not, write to |
---|
18 | the Free Software Foundation, 59 Temple Place - Suite 330, |
---|
19 | Boston, MA 02111-1307, USA. */ |
---|
20 | |
---|
21 | #include "machmode.h" |
---|
22 | |
---|
23 | #ifndef RTX_CODE |
---|
24 | struct rtx_def; |
---|
25 | #endif |
---|
26 | |
---|
27 | /* Codes of tree nodes */ |
---|
28 | |
---|
29 | #define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM, |
---|
30 | |
---|
31 | enum tree_code { |
---|
32 | #include "tree.def" |
---|
33 | |
---|
34 | LAST_AND_UNUSED_TREE_CODE /* A convenient way to get a value for |
---|
35 | NUM_TREE_CODE. */ |
---|
36 | }; |
---|
37 | |
---|
38 | #undef DEFTREECODE |
---|
39 | |
---|
40 | /* Number of tree codes. */ |
---|
41 | #define NUM_TREE_CODES ((int)LAST_AND_UNUSED_TREE_CODE) |
---|
42 | |
---|
43 | /* Indexed by enum tree_code, contains a character which is |
---|
44 | `<' for a comparison expression, `1', for a unary arithmetic |
---|
45 | expression, `2' for a binary arithmetic expression, `e' for |
---|
46 | other types of expressions, `r' for a reference, `c' for a |
---|
47 | constant, `d' for a decl, `t' for a type, `s' for a statement, |
---|
48 | and `x' for anything else (TREE_LIST, IDENTIFIER, etc). */ |
---|
49 | |
---|
50 | extern char **tree_code_type; |
---|
51 | #define TREE_CODE_CLASS(CODE) (*tree_code_type[(int) (CODE)]) |
---|
52 | |
---|
53 | /* Number of argument-words in each kind of tree-node. */ |
---|
54 | |
---|
55 | extern int *tree_code_length; |
---|
56 | |
---|
57 | /* Names of tree components. */ |
---|
58 | |
---|
59 | extern char **tree_code_name; |
---|
60 | |
---|
61 | /* Codes that identify the various built in functions |
---|
62 | so that expand_call can identify them quickly. */ |
---|
63 | |
---|
64 | enum built_in_function |
---|
65 | { |
---|
66 | NOT_BUILT_IN, |
---|
67 | BUILT_IN_ALLOCA, |
---|
68 | BUILT_IN_ABS, |
---|
69 | BUILT_IN_FABS, |
---|
70 | BUILT_IN_LABS, |
---|
71 | BUILT_IN_FFS, |
---|
72 | BUILT_IN_DIV, |
---|
73 | BUILT_IN_LDIV, |
---|
74 | BUILT_IN_FFLOOR, |
---|
75 | BUILT_IN_FCEIL, |
---|
76 | BUILT_IN_FMOD, |
---|
77 | BUILT_IN_FREM, |
---|
78 | BUILT_IN_MEMCPY, |
---|
79 | BUILT_IN_MEMCMP, |
---|
80 | BUILT_IN_MEMSET, |
---|
81 | BUILT_IN_STRCPY, |
---|
82 | BUILT_IN_STRCMP, |
---|
83 | BUILT_IN_STRLEN, |
---|
84 | BUILT_IN_FSQRT, |
---|
85 | BUILT_IN_SIN, |
---|
86 | BUILT_IN_COS, |
---|
87 | BUILT_IN_GETEXP, |
---|
88 | BUILT_IN_GETMAN, |
---|
89 | BUILT_IN_SAVEREGS, |
---|
90 | BUILT_IN_CLASSIFY_TYPE, |
---|
91 | BUILT_IN_NEXT_ARG, |
---|
92 | BUILT_IN_ARGS_INFO, |
---|
93 | BUILT_IN_CONSTANT_P, |
---|
94 | BUILT_IN_FRAME_ADDRESS, |
---|
95 | BUILT_IN_RETURN_ADDRESS, |
---|
96 | BUILT_IN_AGGREGATE_INCOMING_ADDRESS, |
---|
97 | BUILT_IN_CALLER_RETURN_ADDRESS, |
---|
98 | BUILT_IN_APPLY_ARGS, |
---|
99 | BUILT_IN_APPLY, |
---|
100 | BUILT_IN_RETURN, |
---|
101 | BUILT_IN_SETJMP, |
---|
102 | BUILT_IN_LONGJMP, |
---|
103 | |
---|
104 | /* Various hooks for the DWARF 2 __throw routine. */ |
---|
105 | BUILT_IN_FP, BUILT_IN_SP, |
---|
106 | BUILT_IN_UNWIND_INIT, |
---|
107 | BUILT_IN_DWARF_FP_REGNUM, |
---|
108 | BUILT_IN_DWARF_REG_SIZE, |
---|
109 | BUILT_IN_FROB_RETURN_ADDR, |
---|
110 | BUILT_IN_EXTRACT_RETURN_ADDR, |
---|
111 | BUILT_IN_SET_RETURN_ADDR_REG, |
---|
112 | BUILT_IN_EH_STUB, |
---|
113 | BUILT_IN_SET_EH_REGS, |
---|
114 | |
---|
115 | /* C++ extensions */ |
---|
116 | BUILT_IN_NEW, |
---|
117 | BUILT_IN_VEC_NEW, |
---|
118 | BUILT_IN_DELETE, |
---|
119 | BUILT_IN_VEC_DELETE, |
---|
120 | |
---|
121 | /* Upper bound on non-language-specific builtins. */ |
---|
122 | END_BUILTINS |
---|
123 | }; |
---|
124 | |
---|
125 | /* The definition of tree nodes fills the next several pages. */ |
---|
126 | |
---|
127 | /* A tree node can represent a data type, a variable, an expression |
---|
128 | or a statement. Each node has a TREE_CODE which says what kind of |
---|
129 | thing it represents. Some common codes are: |
---|
130 | INTEGER_TYPE -- represents a type of integers. |
---|
131 | ARRAY_TYPE -- represents a type of pointer. |
---|
132 | VAR_DECL -- represents a declared variable. |
---|
133 | INTEGER_CST -- represents a constant integer value. |
---|
134 | PLUS_EXPR -- represents a sum (an expression). |
---|
135 | |
---|
136 | As for the contents of a tree node: there are some fields |
---|
137 | that all nodes share. Each TREE_CODE has various special-purpose |
---|
138 | fields as well. The fields of a node are never accessed directly, |
---|
139 | always through accessor macros. */ |
---|
140 | |
---|
141 | /* This type is used everywhere to refer to a tree node. */ |
---|
142 | |
---|
143 | typedef union tree_node *tree; |
---|
144 | |
---|
145 | /* Every kind of tree node starts with this structure, |
---|
146 | so all nodes have these fields. |
---|
147 | |
---|
148 | See the accessor macros, defined below, for documentation of the fields. */ |
---|
149 | |
---|
150 | struct tree_common |
---|
151 | { |
---|
152 | union tree_node *chain; |
---|
153 | union tree_node *type; |
---|
154 | #ifdef ONLY_INT_FIELDS |
---|
155 | unsigned int code : 8; |
---|
156 | #else |
---|
157 | enum tree_code code : 8; |
---|
158 | #endif |
---|
159 | |
---|
160 | unsigned side_effects_flag : 1; |
---|
161 | unsigned constant_flag : 1; |
---|
162 | unsigned permanent_flag : 1; |
---|
163 | unsigned addressable_flag : 1; |
---|
164 | unsigned volatile_flag : 1; |
---|
165 | unsigned readonly_flag : 1; |
---|
166 | unsigned unsigned_flag : 1; |
---|
167 | unsigned asm_written_flag: 1; |
---|
168 | |
---|
169 | unsigned used_flag : 1; |
---|
170 | unsigned raises_flag : 1; |
---|
171 | unsigned static_flag : 1; |
---|
172 | unsigned public_flag : 1; |
---|
173 | unsigned private_flag : 1; |
---|
174 | unsigned protected_flag : 1; |
---|
175 | |
---|
176 | unsigned lang_flag_0 : 1; |
---|
177 | unsigned lang_flag_1 : 1; |
---|
178 | unsigned lang_flag_2 : 1; |
---|
179 | unsigned lang_flag_3 : 1; |
---|
180 | unsigned lang_flag_4 : 1; |
---|
181 | unsigned lang_flag_5 : 1; |
---|
182 | unsigned lang_flag_6 : 1; |
---|
183 | /* There is room for three more flags. */ |
---|
184 | }; |
---|
185 | |
---|
186 | /* The following table lists the uses of each of the above flags and |
---|
187 | for which types of nodes they are defined. Note that expressions |
---|
188 | include decls. |
---|
189 | |
---|
190 | addressable_flag: |
---|
191 | |
---|
192 | TREE_ADDRESSABLE in |
---|
193 | VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, LABEL_DECL, ..._TYPE |
---|
194 | IDENTIFIER_NODE |
---|
195 | |
---|
196 | static_flag: |
---|
197 | |
---|
198 | TREE_STATIC in |
---|
199 | VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR |
---|
200 | TREE_NO_UNUSED_WARNING in |
---|
201 | CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR |
---|
202 | TREE_VIA_VIRTUAL in |
---|
203 | TREE_LIST or TREE_VEC |
---|
204 | TREE_CONSTANT_OVERFLOW in |
---|
205 | INTEGER_CST, REAL_CST, COMPLEX_CST |
---|
206 | TREE_SYMBOL_REFERENCED in |
---|
207 | IDENTIFIER_NODE |
---|
208 | |
---|
209 | public_flag: |
---|
210 | |
---|
211 | TREE_OVERFLOW in |
---|
212 | INTEGER_CST, REAL_CST, COMPLEX_CST |
---|
213 | TREE_PUBLIC in |
---|
214 | VAR_DECL or FUNCTION_DECL |
---|
215 | TREE_VIA_PUBLIC in |
---|
216 | TREE_LIST or TREE_VEC |
---|
217 | |
---|
218 | private_flag: |
---|
219 | |
---|
220 | TREE_VIA_PRIVATE in |
---|
221 | TREE_LIST or TREE_VEC |
---|
222 | TREE_PRIVATE in |
---|
223 | ??? unspecified nodes |
---|
224 | |
---|
225 | protected_flag: |
---|
226 | |
---|
227 | TREE_VIA_PROTECTED in |
---|
228 | TREE_LIST |
---|
229 | TREE_PROTECTED in |
---|
230 | BLOCK |
---|
231 | ??? unspecified nodes |
---|
232 | |
---|
233 | side_effects_flag: |
---|
234 | |
---|
235 | TREE_SIDE_EFFECTS in |
---|
236 | all expressions |
---|
237 | |
---|
238 | volatile_flag: |
---|
239 | |
---|
240 | TREE_THIS_VOLATILE in |
---|
241 | all expressions |
---|
242 | TYPE_VOLATILE in |
---|
243 | ..._TYPE |
---|
244 | |
---|
245 | readonly_flag: |
---|
246 | |
---|
247 | TREE_READONLY in |
---|
248 | all expressions |
---|
249 | ITERATOR_BOUND_P in |
---|
250 | VAR_DECL if iterator (C) |
---|
251 | TYPE_READONLY in |
---|
252 | ..._TYPE |
---|
253 | |
---|
254 | constant_flag: |
---|
255 | |
---|
256 | TREE_CONSTANT in |
---|
257 | all expressions |
---|
258 | |
---|
259 | permanent_flag: TREE_PERMANENT in all nodes |
---|
260 | |
---|
261 | unsigned_flag: |
---|
262 | |
---|
263 | TREE_UNSIGNED in |
---|
264 | INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL |
---|
265 | DECL_BUILT_IN_NONANSI in |
---|
266 | FUNCTION_DECL |
---|
267 | TREE_PARMLIST in |
---|
268 | TREE_PARMLIST (C++) |
---|
269 | SAVE_EXPR_NOPLACEHOLDER in |
---|
270 | SAVE_EXPR |
---|
271 | |
---|
272 | asm_written_flag: |
---|
273 | |
---|
274 | TREE_ASM_WRITTEN in |
---|
275 | VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE |
---|
276 | BLOCK |
---|
277 | |
---|
278 | used_flag: |
---|
279 | |
---|
280 | TREE_USED in |
---|
281 | expressions, IDENTIFIER_NODE |
---|
282 | |
---|
283 | raises_flag: |
---|
284 | |
---|
285 | TREE_RAISES in |
---|
286 | expressions |
---|
287 | |
---|
288 | */ |
---|
289 | /* Define accessors for the fields that all tree nodes have |
---|
290 | (though some fields are not used for all kinds of nodes). */ |
---|
291 | |
---|
292 | /* The tree-code says what kind of node it is. |
---|
293 | Codes are defined in tree.def. */ |
---|
294 | #define TREE_CODE(NODE) ((enum tree_code) (NODE)->common.code) |
---|
295 | #define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (int) (VALUE)) |
---|
296 | |
---|
297 | /* In all nodes that are expressions, this is the data type of the expression. |
---|
298 | In POINTER_TYPE nodes, this is the type that the pointer points to. |
---|
299 | In ARRAY_TYPE nodes, this is the type of the elements. */ |
---|
300 | #define TREE_TYPE(NODE) ((NODE)->common.type) |
---|
301 | |
---|
302 | /* Nodes are chained together for many purposes. |
---|
303 | Types are chained together to record them for being output to the debugger |
---|
304 | (see the function `chain_type'). |
---|
305 | Decls in the same scope are chained together to record the contents |
---|
306 | of the scope. |
---|
307 | Statement nodes for successive statements used to be chained together. |
---|
308 | Often lists of things are represented by TREE_LIST nodes that |
---|
309 | are chained together. */ |
---|
310 | |
---|
311 | #define TREE_CHAIN(NODE) ((NODE)->common.chain) |
---|
312 | |
---|
313 | /* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs |
---|
314 | that don't change the machine mode. */ |
---|
315 | |
---|
316 | #define STRIP_NOPS(EXP) \ |
---|
317 | while ((TREE_CODE (EXP) == NOP_EXPR \ |
---|
318 | || TREE_CODE (EXP) == CONVERT_EXPR \ |
---|
319 | || TREE_CODE (EXP) == NON_LVALUE_EXPR) \ |
---|
320 | && (TYPE_MODE (TREE_TYPE (EXP)) \ |
---|
321 | == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \ |
---|
322 | (EXP) = TREE_OPERAND (EXP, 0); |
---|
323 | |
---|
324 | /* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */ |
---|
325 | |
---|
326 | #define STRIP_TYPE_NOPS(EXP) \ |
---|
327 | while ((TREE_CODE (EXP) == NOP_EXPR \ |
---|
328 | || TREE_CODE (EXP) == CONVERT_EXPR \ |
---|
329 | || TREE_CODE (EXP) == NON_LVALUE_EXPR) \ |
---|
330 | && (TREE_TYPE (EXP) \ |
---|
331 | == TREE_TYPE (TREE_OPERAND (EXP, 0)))) \ |
---|
332 | (EXP) = TREE_OPERAND (EXP, 0); |
---|
333 | |
---|
334 | /* Nonzero if TYPE represents an integral type. Note that we do not |
---|
335 | include COMPLEX types here. */ |
---|
336 | |
---|
337 | #define INTEGRAL_TYPE_P(TYPE) \ |
---|
338 | (TREE_CODE (TYPE) == INTEGER_TYPE || TREE_CODE (TYPE) == ENUMERAL_TYPE \ |
---|
339 | || TREE_CODE (TYPE) == BOOLEAN_TYPE || TREE_CODE (TYPE) == CHAR_TYPE) |
---|
340 | |
---|
341 | /* Nonzero if TYPE represents a floating-point type, including complex |
---|
342 | floating-point types. */ |
---|
343 | |
---|
344 | #define FLOAT_TYPE_P(TYPE) \ |
---|
345 | (TREE_CODE (TYPE) == REAL_TYPE \ |
---|
346 | || (TREE_CODE (TYPE) == COMPLEX_TYPE \ |
---|
347 | && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)) |
---|
348 | |
---|
349 | /* Nonzero if TYPE represents an aggregate (multi-component) type. */ |
---|
350 | |
---|
351 | #define AGGREGATE_TYPE_P(TYPE) \ |
---|
352 | (TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \ |
---|
353 | || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \ |
---|
354 | || TREE_CODE (TYPE) == SET_TYPE) |
---|
355 | |
---|
356 | /* Nonzero if TYPE represents a pointer type. */ |
---|
357 | |
---|
358 | #define POINTER_TYPE_P(TYPE) \ |
---|
359 | (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE) |
---|
360 | |
---|
361 | /* Define many boolean fields that all tree nodes have. */ |
---|
362 | |
---|
363 | /* In VAR_DECL nodes, nonzero means address of this is needed. |
---|
364 | So it cannot be in a register. |
---|
365 | In a FUNCTION_DECL, nonzero means its address is needed. |
---|
366 | So it must be compiled even if it is an inline function. |
---|
367 | In CONSTRUCTOR nodes, it means object constructed must be in memory. |
---|
368 | In LABEL_DECL nodes, it means a goto for this label has been seen |
---|
369 | from a place outside all binding contours that restore stack levels. |
---|
370 | In ..._TYPE nodes, it means that objects of this type must |
---|
371 | be fully addressable. This means that pieces of this |
---|
372 | object cannot go into register parameters, for example. |
---|
373 | In IDENTIFIER_NODEs, this means that some extern decl for this name |
---|
374 | had its address taken. That matters for inline functions. */ |
---|
375 | #define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag) |
---|
376 | |
---|
377 | /* In a VAR_DECL, nonzero means allocate static storage. |
---|
378 | In a FUNCTION_DECL, nonzero if function has been defined. |
---|
379 | In a CONSTRUCTOR, nonzero means allocate static storage. */ |
---|
380 | #define TREE_STATIC(NODE) ((NODE)->common.static_flag) |
---|
381 | |
---|
382 | /* In a CONVERT_EXPR, NOP_EXPR or COMPOUND_EXPR, this means the node was |
---|
383 | made implicitly and should not lead to an "unused value" warning. */ |
---|
384 | #define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag) |
---|
385 | |
---|
386 | /* Nonzero for a TREE_LIST or TREE_VEC node means that the derivation |
---|
387 | chain is via a `virtual' declaration. */ |
---|
388 | #define TREE_VIA_VIRTUAL(NODE) ((NODE)->common.static_flag) |
---|
389 | |
---|
390 | /* In an INTEGER_CST, REAL_CST, or COMPLEX_CST, this means there was an |
---|
391 | overflow in folding. This is distinct from TREE_OVERFLOW because ANSI C |
---|
392 | requires a diagnostic when overflows occur in constant expressions. */ |
---|
393 | #define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag) |
---|
394 | |
---|
395 | /* In an IDENTIFIER_NODE, this means that assemble_name was called with |
---|
396 | this string as an argument. */ |
---|
397 | #define TREE_SYMBOL_REFERENCED(NODE) ((NODE)->common.static_flag) |
---|
398 | |
---|
399 | /* In an INTEGER_CST, REAL_CST, of COMPLEX_CST, this means there was an |
---|
400 | overflow in folding, and no warning has been issued for this subexpression. |
---|
401 | TREE_OVERFLOW implies TREE_CONSTANT_OVERFLOW, but not vice versa. */ |
---|
402 | #define TREE_OVERFLOW(NODE) ((NODE)->common.public_flag) |
---|
403 | |
---|
404 | /* In a VAR_DECL or FUNCTION_DECL, |
---|
405 | nonzero means name is to be accessible from outside this module. |
---|
406 | In an identifier node, nonzero means an external declaration |
---|
407 | accessible from outside this module was previously seen |
---|
408 | for this name in an inner scope. */ |
---|
409 | #define TREE_PUBLIC(NODE) ((NODE)->common.public_flag) |
---|
410 | |
---|
411 | /* Nonzero for TREE_LIST or TREE_VEC node means that the path to the |
---|
412 | base class is via a `public' declaration, which preserves public |
---|
413 | fields from the base class as public. */ |
---|
414 | #define TREE_VIA_PUBLIC(NODE) ((NODE)->common.public_flag) |
---|
415 | |
---|
416 | /* Ditto, for `private' declarations. */ |
---|
417 | #define TREE_VIA_PRIVATE(NODE) ((NODE)->common.private_flag) |
---|
418 | |
---|
419 | /* Nonzero for TREE_LIST node means that the path to the |
---|
420 | base class is via a `protected' declaration, which preserves |
---|
421 | protected fields from the base class as protected. |
---|
422 | OVERLOADED. */ |
---|
423 | #define TREE_VIA_PROTECTED(NODE) ((NODE)->common.protected_flag) |
---|
424 | |
---|
425 | /* In any expression, nonzero means it has side effects or reevaluation |
---|
426 | of the whole expression could produce a different value. |
---|
427 | This is set if any subexpression is a function call, a side effect |
---|
428 | or a reference to a volatile variable. |
---|
429 | In a ..._DECL, this is set only if the declaration said `volatile'. */ |
---|
430 | #define TREE_SIDE_EFFECTS(NODE) ((NODE)->common.side_effects_flag) |
---|
431 | |
---|
432 | /* Nonzero means this expression is volatile in the C sense: |
---|
433 | its address should be of type `volatile WHATEVER *'. |
---|
434 | In other words, the declared item is volatile qualified. |
---|
435 | This is used in _DECL nodes and _REF nodes. |
---|
436 | |
---|
437 | In a ..._TYPE node, means this type is volatile-qualified. |
---|
438 | But use TYPE_VOLATILE instead of this macro when the node is a type, |
---|
439 | because eventually we may make that a different bit. |
---|
440 | |
---|
441 | If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */ |
---|
442 | #define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag) |
---|
443 | |
---|
444 | /* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node, |
---|
445 | nonzero means it may not be the lhs of an assignment. |
---|
446 | In a ..._TYPE node, means this type is const-qualified |
---|
447 | (but the macro TYPE_READONLY should be used instead of this macro |
---|
448 | when the node is a type). */ |
---|
449 | #define TREE_READONLY(NODE) ((NODE)->common.readonly_flag) |
---|
450 | |
---|
451 | /* Value of expression is constant. |
---|
452 | Always appears in all ..._CST nodes. |
---|
453 | May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR |
---|
454 | if the value is constant. */ |
---|
455 | #define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag) |
---|
456 | |
---|
457 | /* Nonzero means permanent node; |
---|
458 | node will continue to exist for the entire compiler run. |
---|
459 | Otherwise it will be recycled at the end of the function. */ |
---|
460 | #define TREE_PERMANENT(NODE) ((NODE)->common.permanent_flag) |
---|
461 | |
---|
462 | /* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type. |
---|
463 | In FIELD_DECL nodes, means an unsigned bit field. |
---|
464 | The same bit is used in functions as DECL_BUILT_IN_NONANSI. */ |
---|
465 | #define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag) |
---|
466 | |
---|
467 | /* Nonzero in a VAR_DECL means assembler code has been written. |
---|
468 | Nonzero in a FUNCTION_DECL means that the function has been compiled. |
---|
469 | This is interesting in an inline function, since it might not need |
---|
470 | to be compiled separately. |
---|
471 | Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE |
---|
472 | if the sdb debugging info for the type has been written. |
---|
473 | In a BLOCK node, nonzero if reorder_blocks has already seen this block. */ |
---|
474 | #define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag) |
---|
475 | |
---|
476 | /* Nonzero in a _DECL if the name is used in its scope. |
---|
477 | Nonzero in an expr node means inhibit warning if value is unused. |
---|
478 | In IDENTIFIER_NODEs, this means that some extern decl for this name |
---|
479 | was used. */ |
---|
480 | #define TREE_USED(NODE) ((NODE)->common.used_flag) |
---|
481 | |
---|
482 | /* Nonzero for a tree node whose evaluation could result |
---|
483 | in the raising of an exception. Not implemented yet. */ |
---|
484 | #define TREE_RAISES(NODE) ((NODE)->common.raises_flag) |
---|
485 | |
---|
486 | /* Used in classes in C++. */ |
---|
487 | #define TREE_PRIVATE(NODE) ((NODE)->common.private_flag) |
---|
488 | /* Used in classes in C++. |
---|
489 | In a BLOCK node, this is BLOCK_HANDLER_BLOCK. */ |
---|
490 | #define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag) |
---|
491 | |
---|
492 | /* These flags are available for each language front end to use internally. */ |
---|
493 | #define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0) |
---|
494 | #define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1) |
---|
495 | #define TREE_LANG_FLAG_2(NODE) ((NODE)->common.lang_flag_2) |
---|
496 | #define TREE_LANG_FLAG_3(NODE) ((NODE)->common.lang_flag_3) |
---|
497 | #define TREE_LANG_FLAG_4(NODE) ((NODE)->common.lang_flag_4) |
---|
498 | #define TREE_LANG_FLAG_5(NODE) ((NODE)->common.lang_flag_5) |
---|
499 | #define TREE_LANG_FLAG_6(NODE) ((NODE)->common.lang_flag_6) |
---|
500 | |
---|
501 | /* Define additional fields and accessors for nodes representing constants. */ |
---|
502 | |
---|
503 | /* In an INTEGER_CST node. These two together make a 2-word integer. |
---|
504 | If the data type is signed, the value is sign-extended to 2 words |
---|
505 | even though not all of them may really be in use. |
---|
506 | In an unsigned constant shorter than 2 words, the extra bits are 0. */ |
---|
507 | #define TREE_INT_CST_LOW(NODE) ((NODE)->int_cst.int_cst_low) |
---|
508 | #define TREE_INT_CST_HIGH(NODE) ((NODE)->int_cst.int_cst_high) |
---|
509 | |
---|
510 | #define INT_CST_LT(A, B) \ |
---|
511 | (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \ |
---|
512 | || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \ |
---|
513 | && ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (A) \ |
---|
514 | < (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (B)))) |
---|
515 | |
---|
516 | #define INT_CST_LT_UNSIGNED(A, B) \ |
---|
517 | (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ |
---|
518 | < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ |
---|
519 | || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ |
---|
520 | == (unsigned HOST_WIDE_INT ) TREE_INT_CST_HIGH (B)) \ |
---|
521 | && (((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (A) \ |
---|
522 | < (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (B))))) |
---|
523 | |
---|
524 | struct tree_int_cst |
---|
525 | { |
---|
526 | char common[sizeof (struct tree_common)]; |
---|
527 | struct rtx_def *rtl; /* acts as link to register transfer language |
---|
528 | (rtl) info */ |
---|
529 | HOST_WIDE_INT int_cst_low; |
---|
530 | HOST_WIDE_INT int_cst_high; |
---|
531 | }; |
---|
532 | |
---|
533 | /* In REAL_CST, STRING_CST, COMPLEX_CST nodes, and CONSTRUCTOR nodes, |
---|
534 | and generally in all kinds of constants that could |
---|
535 | be given labels (rather than being immediate). */ |
---|
536 | |
---|
537 | #define TREE_CST_RTL(NODE) ((NODE)->real_cst.rtl) |
---|
538 | |
---|
539 | /* In a REAL_CST node. */ |
---|
540 | /* We can represent a real value as either a `double' or a string. |
---|
541 | Strings don't allow for any optimization, but they do allow |
---|
542 | for cross-compilation. */ |
---|
543 | |
---|
544 | #define TREE_REAL_CST(NODE) ((NODE)->real_cst.real_cst) |
---|
545 | |
---|
546 | #include "real.h" |
---|
547 | |
---|
548 | struct tree_real_cst |
---|
549 | { |
---|
550 | char common[sizeof (struct tree_common)]; |
---|
551 | struct rtx_def *rtl; /* acts as link to register transfer language |
---|
552 | (rtl) info */ |
---|
553 | REAL_VALUE_TYPE real_cst; |
---|
554 | }; |
---|
555 | |
---|
556 | /* In a STRING_CST */ |
---|
557 | #define TREE_STRING_LENGTH(NODE) ((NODE)->string.length) |
---|
558 | #define TREE_STRING_POINTER(NODE) ((NODE)->string.pointer) |
---|
559 | |
---|
560 | struct tree_string |
---|
561 | { |
---|
562 | char common[sizeof (struct tree_common)]; |
---|
563 | struct rtx_def *rtl; /* acts as link to register transfer language |
---|
564 | (rtl) info */ |
---|
565 | int length; |
---|
566 | char *pointer; |
---|
567 | }; |
---|
568 | |
---|
569 | /* In a COMPLEX_CST node. */ |
---|
570 | #define TREE_REALPART(NODE) ((NODE)->complex.real) |
---|
571 | #define TREE_IMAGPART(NODE) ((NODE)->complex.imag) |
---|
572 | |
---|
573 | struct tree_complex |
---|
574 | { |
---|
575 | char common[sizeof (struct tree_common)]; |
---|
576 | struct rtx_def *rtl; /* acts as link to register transfer language |
---|
577 | (rtl) info */ |
---|
578 | union tree_node *real; |
---|
579 | union tree_node *imag; |
---|
580 | }; |
---|
581 | |
---|
582 | /* Define fields and accessors for some special-purpose tree nodes. */ |
---|
583 | |
---|
584 | #define IDENTIFIER_LENGTH(NODE) ((NODE)->identifier.length) |
---|
585 | #define IDENTIFIER_POINTER(NODE) ((NODE)->identifier.pointer) |
---|
586 | |
---|
587 | struct tree_identifier |
---|
588 | { |
---|
589 | char common[sizeof (struct tree_common)]; |
---|
590 | int length; |
---|
591 | char *pointer; |
---|
592 | }; |
---|
593 | |
---|
594 | /* In a TREE_LIST node. */ |
---|
595 | #define TREE_PURPOSE(NODE) ((NODE)->list.purpose) |
---|
596 | #define TREE_VALUE(NODE) ((NODE)->list.value) |
---|
597 | |
---|
598 | struct tree_list |
---|
599 | { |
---|
600 | char common[sizeof (struct tree_common)]; |
---|
601 | union tree_node *purpose; |
---|
602 | union tree_node *value; |
---|
603 | }; |
---|
604 | |
---|
605 | /* In a TREE_VEC node. */ |
---|
606 | #define TREE_VEC_LENGTH(NODE) ((NODE)->vec.length) |
---|
607 | #define TREE_VEC_ELT(NODE,I) ((NODE)->vec.a[I]) |
---|
608 | #define TREE_VEC_END(NODE) (&((NODE)->vec.a[(NODE)->vec.length])) |
---|
609 | |
---|
610 | struct tree_vec |
---|
611 | { |
---|
612 | char common[sizeof (struct tree_common)]; |
---|
613 | int length; |
---|
614 | union tree_node *a[1]; |
---|
615 | }; |
---|
616 | |
---|
617 | /* Define fields and accessors for some nodes that represent expressions. */ |
---|
618 | |
---|
619 | /* In a SAVE_EXPR node. */ |
---|
620 | #define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND(NODE, 1) |
---|
621 | #define SAVE_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[2]) |
---|
622 | #define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (NODE) |
---|
623 | |
---|
624 | /* In a RTL_EXPR node. */ |
---|
625 | #define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[0]) |
---|
626 | #define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[1]) |
---|
627 | |
---|
628 | /* In a CALL_EXPR node. */ |
---|
629 | #define CALL_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[2]) |
---|
630 | |
---|
631 | /* In a CONSTRUCTOR node. */ |
---|
632 | #define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1) |
---|
633 | |
---|
634 | /* In ordinary expression nodes. */ |
---|
635 | #define TREE_OPERAND(NODE, I) ((NODE)->exp.operands[I]) |
---|
636 | #define TREE_COMPLEXITY(NODE) ((NODE)->exp.complexity) |
---|
637 | |
---|
638 | struct tree_exp |
---|
639 | { |
---|
640 | char common[sizeof (struct tree_common)]; |
---|
641 | int complexity; |
---|
642 | union tree_node *operands[1]; |
---|
643 | }; |
---|
644 | |
---|
645 | /* In a BLOCK node. */ |
---|
646 | #define BLOCK_VARS(NODE) ((NODE)->block.vars) |
---|
647 | #define BLOCK_TYPE_TAGS(NODE) ((NODE)->block.type_tags) |
---|
648 | #define BLOCK_SUBBLOCKS(NODE) ((NODE)->block.subblocks) |
---|
649 | #define BLOCK_SUPERCONTEXT(NODE) ((NODE)->block.supercontext) |
---|
650 | /* Note: when changing this, make sure to find the places |
---|
651 | that use chainon or nreverse. */ |
---|
652 | #define BLOCK_CHAIN(NODE) TREE_CHAIN (NODE) |
---|
653 | #define BLOCK_ABSTRACT_ORIGIN(NODE) ((NODE)->block.abstract_origin) |
---|
654 | #define BLOCK_ABSTRACT(NODE) ((NODE)->block.abstract_flag) |
---|
655 | #define BLOCK_END_NOTE(NODE) ((NODE)->block.end_note) |
---|
656 | |
---|
657 | /* Nonzero means that this block is prepared to handle exceptions |
---|
658 | listed in the BLOCK_VARS slot. */ |
---|
659 | #define BLOCK_HANDLER_BLOCK(NODE) ((NODE)->block.handler_block_flag) |
---|
660 | |
---|
661 | struct tree_block |
---|
662 | { |
---|
663 | char common[sizeof (struct tree_common)]; |
---|
664 | |
---|
665 | unsigned handler_block_flag : 1; |
---|
666 | unsigned abstract_flag : 1; |
---|
667 | |
---|
668 | union tree_node *vars; |
---|
669 | union tree_node *type_tags; |
---|
670 | union tree_node *subblocks; |
---|
671 | union tree_node *supercontext; |
---|
672 | union tree_node *abstract_origin; |
---|
673 | struct rtx_def *end_note; |
---|
674 | }; |
---|
675 | |
---|
676 | /* Define fields and accessors for nodes representing data types. */ |
---|
677 | |
---|
678 | /* See tree.def for documentation of the use of these fields. |
---|
679 | Look at the documentation of the various ..._TYPE tree codes. */ |
---|
680 | |
---|
681 | #define TYPE_UID(NODE) ((NODE)->type.uid) |
---|
682 | #define TYPE_SIZE(NODE) ((NODE)->type.size) |
---|
683 | #define TYPE_MODE(NODE) ((NODE)->type.mode) |
---|
684 | #define TYPE_VALUES(NODE) ((NODE)->type.values) |
---|
685 | #define TYPE_DOMAIN(NODE) ((NODE)->type.values) |
---|
686 | #define TYPE_FIELDS(NODE) ((NODE)->type.values) |
---|
687 | #define TYPE_METHODS(NODE) ((NODE)->type.maxval) |
---|
688 | #define TYPE_VFIELD(NODE) ((NODE)->type.minval) |
---|
689 | #define TYPE_ARG_TYPES(NODE) ((NODE)->type.values) |
---|
690 | #define TYPE_METHOD_BASETYPE(NODE) ((NODE)->type.maxval) |
---|
691 | #define TYPE_OFFSET_BASETYPE(NODE) ((NODE)->type.maxval) |
---|
692 | #define TYPE_POINTER_TO(NODE) ((NODE)->type.pointer_to) |
---|
693 | #define TYPE_REFERENCE_TO(NODE) ((NODE)->type.reference_to) |
---|
694 | #define TYPE_MIN_VALUE(NODE) ((NODE)->type.minval) |
---|
695 | #define TYPE_MAX_VALUE(NODE) ((NODE)->type.maxval) |
---|
696 | #define TYPE_PRECISION(NODE) ((NODE)->type.precision) |
---|
697 | #define TYPE_SYMTAB_ADDRESS(NODE) ((NODE)->type.symtab.address) |
---|
698 | #define TYPE_SYMTAB_POINTER(NODE) ((NODE)->type.symtab.pointer) |
---|
699 | #define TYPE_NAME(NODE) ((NODE)->type.name) |
---|
700 | #define TYPE_NEXT_VARIANT(NODE) ((NODE)->type.next_variant) |
---|
701 | #define TYPE_MAIN_VARIANT(NODE) ((NODE)->type.main_variant) |
---|
702 | #define TYPE_BINFO(NODE) ((NODE)->type.binfo) |
---|
703 | #define TYPE_NONCOPIED_PARTS(NODE) ((NODE)->type.noncopied_parts) |
---|
704 | #define TYPE_CONTEXT(NODE) ((NODE)->type.context) |
---|
705 | #define TYPE_OBSTACK(NODE) ((NODE)->type.obstack) |
---|
706 | #define TYPE_LANG_SPECIFIC(NODE) ((NODE)->type.lang_specific) |
---|
707 | |
---|
708 | /* A TREE_LIST of IDENTIFIER nodes of the attributes that apply |
---|
709 | to this type. */ |
---|
710 | #define TYPE_ATTRIBUTES(NODE) ((NODE)->type.attributes) |
---|
711 | |
---|
712 | /* The alignment necessary for objects of this type. |
---|
713 | The value is an int, measured in bits. */ |
---|
714 | #define TYPE_ALIGN(NODE) ((NODE)->type.align) |
---|
715 | |
---|
716 | #define TYPE_STUB_DECL(NODE) (TREE_CHAIN (NODE)) |
---|
717 | |
---|
718 | /* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type |
---|
719 | has BLKmode only because it lacks the alignment requirement for |
---|
720 | its size. */ |
---|
721 | #define TYPE_NO_FORCE_BLK(NODE) ((NODE)->type.no_force_blk_flag) |
---|
722 | |
---|
723 | /* Nonzero in a type considered volatile as a whole. */ |
---|
724 | #define TYPE_VOLATILE(NODE) ((NODE)->common.volatile_flag) |
---|
725 | |
---|
726 | /* Means this type is const-qualified. */ |
---|
727 | #define TYPE_READONLY(NODE) ((NODE)->common.readonly_flag) |
---|
728 | |
---|
729 | /* These flags are available for each language front end to use internally. */ |
---|
730 | #define TYPE_LANG_FLAG_0(NODE) ((NODE)->type.lang_flag_0) |
---|
731 | #define TYPE_LANG_FLAG_1(NODE) ((NODE)->type.lang_flag_1) |
---|
732 | #define TYPE_LANG_FLAG_2(NODE) ((NODE)->type.lang_flag_2) |
---|
733 | #define TYPE_LANG_FLAG_3(NODE) ((NODE)->type.lang_flag_3) |
---|
734 | #define TYPE_LANG_FLAG_4(NODE) ((NODE)->type.lang_flag_4) |
---|
735 | #define TYPE_LANG_FLAG_5(NODE) ((NODE)->type.lang_flag_5) |
---|
736 | #define TYPE_LANG_FLAG_6(NODE) ((NODE)->type.lang_flag_6) |
---|
737 | |
---|
738 | /* If set in an ARRAY_TYPE, indicates a string type (for languages |
---|
739 | that distinguish string from array of char). |
---|
740 | If set in a SET_TYPE, indicates a bitstring type. */ |
---|
741 | #define TYPE_STRING_FLAG(NODE) ((NODE)->type.string_flag) |
---|
742 | |
---|
743 | /* If non-NULL, this is a upper bound of the size (in bytes) of an |
---|
744 | object of the given ARRAY_TYPE. This allows temporaries to be allocated. */ |
---|
745 | #define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) TYPE_MAX_VALUE (ARRAY_TYPE) |
---|
746 | |
---|
747 | /* Indicates that objects of this type must be initialized by calling a |
---|
748 | function when they are created. */ |
---|
749 | #define TYPE_NEEDS_CONSTRUCTING(NODE) ((NODE)->type.needs_constructing_flag) |
---|
750 | |
---|
751 | /* Indicates that objects of this type (a UNION_TYPE), should be passed |
---|
752 | the same way that the first union alternative would be passed. */ |
---|
753 | #define TYPE_TRANSPARENT_UNION(NODE) ((NODE)->type.transparent_union_flag) |
---|
754 | |
---|
755 | /* Indicated that objects of this type should be laid out in as |
---|
756 | compact a way as possible. */ |
---|
757 | #define TYPE_PACKED(NODE) ((NODE)->type.packed_flag) |
---|
758 | |
---|
759 | struct tree_type |
---|
760 | { |
---|
761 | char common[sizeof (struct tree_common)]; |
---|
762 | union tree_node *values; |
---|
763 | union tree_node *size; |
---|
764 | union tree_node *attributes; |
---|
765 | unsigned uid; |
---|
766 | |
---|
767 | unsigned char precision; |
---|
768 | #ifdef ONLY_INT_FIELDS |
---|
769 | int mode : 8; |
---|
770 | #else |
---|
771 | enum machine_mode mode : 8; |
---|
772 | #endif |
---|
773 | |
---|
774 | unsigned string_flag : 1; |
---|
775 | unsigned no_force_blk_flag : 1; |
---|
776 | unsigned needs_constructing_flag : 1; |
---|
777 | unsigned transparent_union_flag : 1; |
---|
778 | unsigned packed_flag : 1; |
---|
779 | unsigned lang_flag_0 : 1; |
---|
780 | unsigned lang_flag_1 : 1; |
---|
781 | unsigned lang_flag_2 : 1; |
---|
782 | unsigned lang_flag_3 : 1; |
---|
783 | unsigned lang_flag_4 : 1; |
---|
784 | unsigned lang_flag_5 : 1; |
---|
785 | unsigned lang_flag_6 : 1; |
---|
786 | /* room for 4 more bits */ |
---|
787 | |
---|
788 | unsigned int align; |
---|
789 | union tree_node *pointer_to; |
---|
790 | union tree_node *reference_to; |
---|
791 | union {int address; char *pointer; } symtab; |
---|
792 | union tree_node *name; |
---|
793 | union tree_node *minval; |
---|
794 | union tree_node *maxval; |
---|
795 | union tree_node *next_variant; |
---|
796 | union tree_node *main_variant; |
---|
797 | union tree_node *binfo; |
---|
798 | union tree_node *noncopied_parts; |
---|
799 | union tree_node *context; |
---|
800 | struct obstack *obstack; |
---|
801 | /* Points to a structure whose details depend on the language in use. */ |
---|
802 | struct lang_type *lang_specific; |
---|
803 | }; |
---|
804 | |
---|
805 | /* Define accessor macros for information about type inheritance |
---|
806 | and basetypes. |
---|
807 | |
---|
808 | A "basetype" means a particular usage of a data type for inheritance |
---|
809 | in another type. Each such basetype usage has its own "binfo" |
---|
810 | object to describe it. The binfo object is a TREE_VEC node. |
---|
811 | |
---|
812 | Inheritance is represented by the binfo nodes allocated for a |
---|
813 | given type. For example, given types C and D, such that D is |
---|
814 | inherited by C, 3 binfo nodes will be allocated: one for describing |
---|
815 | the binfo properties of C, similarly one for D, and one for |
---|
816 | describing the binfo properties of D as a base type for C. |
---|
817 | Thus, given a pointer to class C, one can get a pointer to the binfo |
---|
818 | of D acting as a basetype for C by looking at C's binfo's basetypes. */ |
---|
819 | |
---|
820 | /* The actual data type node being inherited in this basetype. */ |
---|
821 | #define BINFO_TYPE(NODE) TREE_TYPE (NODE) |
---|
822 | |
---|
823 | /* The offset where this basetype appears in its containing type. |
---|
824 | BINFO_OFFSET slot holds the offset (in bytes) |
---|
825 | from the base of the complete object to the base of the part of the |
---|
826 | object that is allocated on behalf of this `type'. |
---|
827 | This is always 0 except when there is multiple inheritance. */ |
---|
828 | |
---|
829 | #define BINFO_OFFSET(NODE) TREE_VEC_ELT ((NODE), 1) |
---|
830 | #define TYPE_BINFO_OFFSET(NODE) BINFO_OFFSET (TYPE_BINFO (NODE)) |
---|
831 | #define BINFO_OFFSET_ZEROP(NODE) (BINFO_OFFSET (NODE) == integer_zero_node) |
---|
832 | |
---|
833 | /* The virtual function table belonging to this basetype. Virtual |
---|
834 | function tables provide a mechanism for run-time method dispatching. |
---|
835 | The entries of a virtual function table are language-dependent. */ |
---|
836 | |
---|
837 | #define BINFO_VTABLE(NODE) TREE_VEC_ELT ((NODE), 2) |
---|
838 | #define TYPE_BINFO_VTABLE(NODE) BINFO_VTABLE (TYPE_BINFO (NODE)) |
---|
839 | |
---|
840 | /* The virtual functions in the virtual function table. This is |
---|
841 | a TREE_LIST that is used as an initial approximation for building |
---|
842 | a virtual function table for this basetype. */ |
---|
843 | #define BINFO_VIRTUALS(NODE) TREE_VEC_ELT ((NODE), 3) |
---|
844 | #define TYPE_BINFO_VIRTUALS(NODE) BINFO_VIRTUALS (TYPE_BINFO (NODE)) |
---|
845 | |
---|
846 | /* A vector of additional binfos for the types inherited by this basetype. |
---|
847 | |
---|
848 | If this basetype describes type D as inherited in C, |
---|
849 | and if the basetypes of D are E anf F, |
---|
850 | then this vector contains binfos for inheritance of E and F by C. |
---|
851 | |
---|
852 | ??? This could probably be done by just allocating the |
---|
853 | base types at the end of this TREE_VEC (instead of using |
---|
854 | another TREE_VEC). This would simplify the calculation |
---|
855 | of how many basetypes a given type had. */ |
---|
856 | #define BINFO_BASETYPES(NODE) TREE_VEC_ELT ((NODE), 4) |
---|
857 | #define TYPE_BINFO_BASETYPES(NODE) TREE_VEC_ELT (TYPE_BINFO (NODE), 4) |
---|
858 | |
---|
859 | /* For a BINFO record describing an inheritance, this yields a pointer |
---|
860 | to the artificial FIELD_DECL node which contains the "virtual base |
---|
861 | class pointer" for the given inheritance. */ |
---|
862 | |
---|
863 | #define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT ((NODE), 5) |
---|
864 | |
---|
865 | /* Accessor macro to get to the Nth basetype of this basetype. */ |
---|
866 | #define BINFO_BASETYPE(NODE,N) TREE_VEC_ELT (BINFO_BASETYPES (NODE), (N)) |
---|
867 | #define TYPE_BINFO_BASETYPE(NODE,N) BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N))) |
---|
868 | |
---|
869 | /* Slot used to build a chain that represents a use of inheritance. |
---|
870 | For example, if X is derived from Y, and Y is derived from Z, |
---|
871 | then this field can be used to link the binfo node for X to |
---|
872 | the binfo node for X's Y to represent the use of inheritance |
---|
873 | from X to Y. Similarly, this slot of the binfo node for X's Y |
---|
874 | can point to the Z from which Y is inherited (in X's inheritance |
---|
875 | hierarchy). In this fashion, one can represent and traverse specific |
---|
876 | uses of inheritance using the binfo nodes themselves (instead of |
---|
877 | consing new space pointing to binfo nodes). |
---|
878 | It is up to the language-dependent front-ends to maintain |
---|
879 | this information as necessary. */ |
---|
880 | #define BINFO_INHERITANCE_CHAIN(NODE) TREE_VEC_ELT ((NODE), 0) |
---|
881 | |
---|
882 | /* Define fields and accessors for nodes representing declared names. */ |
---|
883 | |
---|
884 | /* This is the name of the object as written by the user. |
---|
885 | It is an IDENTIFIER_NODE. */ |
---|
886 | #define DECL_NAME(NODE) ((NODE)->decl.name) |
---|
887 | /* This is the name of the object as the assembler will see it |
---|
888 | (but before any translations made by ASM_OUTPUT_LABELREF). |
---|
889 | Often this is the same as DECL_NAME. |
---|
890 | It is an IDENTIFIER_NODE. */ |
---|
891 | #define DECL_ASSEMBLER_NAME(NODE) ((NODE)->decl.assembler_name) |
---|
892 | /* Records the section name in a section attribute. Used to pass |
---|
893 | the name from decl_attributes to make_function_rtl and make_decl_rtl. */ |
---|
894 | #define DECL_SECTION_NAME(NODE) ((NODE)->decl.section_name) |
---|
895 | /* For FIELD_DECLs, this is the |
---|
896 | RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field is |
---|
897 | a member of. For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL, |
---|
898 | and CONST_DECL nodes, this points to either the FUNCTION_DECL for the |
---|
899 | containing function, the RECORD_TYPE or UNION_TYPE for the containing |
---|
900 | type, or NULL_TREE if the given decl has "file scope". */ |
---|
901 | #define DECL_CONTEXT(NODE) ((NODE)->decl.context) |
---|
902 | #define DECL_FIELD_CONTEXT(NODE) ((NODE)->decl.context) |
---|
903 | /* In a DECL this is the field where configuration dependent machine |
---|
904 | attributes are store */ |
---|
905 | #define DECL_MACHINE_ATTRIBUTES(NODE) ((NODE)->decl.machine_attributes) |
---|
906 | /* In a FIELD_DECL, this is the field position, counting in bits, |
---|
907 | of the bit closest to the beginning of the structure. */ |
---|
908 | #define DECL_FIELD_BITPOS(NODE) ((NODE)->decl.arguments) |
---|
909 | /* In a FIELD_DECL, this indicates whether the field was a bit-field and |
---|
910 | if so, the type that was originally specified for it. |
---|
911 | TREE_TYPE may have been modified (in finish_struct). */ |
---|
912 | #define DECL_BIT_FIELD_TYPE(NODE) ((NODE)->decl.result) |
---|
913 | /* In FUNCTION_DECL, a chain of ..._DECL nodes. */ |
---|
914 | /* VAR_DECL and PARM_DECL reserve the arguments slot |
---|
915 | for language-specific uses. */ |
---|
916 | #define DECL_ARGUMENTS(NODE) ((NODE)->decl.arguments) |
---|
917 | /* In FUNCTION_DECL, holds the decl for the return value. */ |
---|
918 | #define DECL_RESULT(NODE) ((NODE)->decl.result) |
---|
919 | /* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */ |
---|
920 | #define DECL_ORIGINAL_TYPE(NODE) ((NODE)->decl.result) |
---|
921 | /* In PARM_DECL, holds the type as written (perhaps a function or array). */ |
---|
922 | #define DECL_ARG_TYPE_AS_WRITTEN(NODE) ((NODE)->decl.result) |
---|
923 | /* For a FUNCTION_DECL, holds the tree of BINDINGs. |
---|
924 | For a VAR_DECL, holds the initial value. |
---|
925 | For a PARM_DECL, not used--default |
---|
926 | values for parameters are encoded in the type of the function, |
---|
927 | not in the PARM_DECL slot. */ |
---|
928 | #define DECL_INITIAL(NODE) ((NODE)->decl.initial) |
---|
929 | /* For a PARM_DECL, records the data type used to pass the argument, |
---|
930 | which may be different from the type seen in the program. */ |
---|
931 | #define DECL_ARG_TYPE(NODE) ((NODE)->decl.initial) /* In PARM_DECL. */ |
---|
932 | /* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which |
---|
933 | if nonzero, indicates that the field occupies the type. */ |
---|
934 | #define DECL_QUALIFIER(NODE) ((NODE)->decl.initial) |
---|
935 | /* These two fields describe where in the source code the declaration was. */ |
---|
936 | #define DECL_SOURCE_FILE(NODE) ((NODE)->decl.filename) |
---|
937 | #define DECL_SOURCE_LINE(NODE) ((NODE)->decl.linenum) |
---|
938 | /* Holds the size of the datum, as a tree expression. |
---|
939 | Need not be constant. */ |
---|
940 | #define DECL_SIZE(NODE) ((NODE)->decl.size) |
---|
941 | /* Holds the alignment required for the datum. */ |
---|
942 | #define DECL_ALIGN(NODE) ((NODE)->decl.frame_size.u) |
---|
943 | /* Holds the machine mode corresponding to the declaration of a variable or |
---|
944 | field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a |
---|
945 | FIELD_DECL. */ |
---|
946 | #define DECL_MODE(NODE) ((NODE)->decl.mode) |
---|
947 | /* Holds the RTL expression for the value of a variable or function. If |
---|
948 | PROMOTED_MODE is defined, the mode of this expression may not be same |
---|
949 | as DECL_MODE. In that case, DECL_MODE contains the mode corresponding |
---|
950 | to the variable's data type, while the mode |
---|
951 | of DECL_RTL is the mode actually used to contain the data. */ |
---|
952 | #define DECL_RTL(NODE) ((NODE)->decl.rtl) |
---|
953 | /* For PARM_DECL, holds an RTL for the stack slot or register |
---|
954 | where the data was actually passed. */ |
---|
955 | #define DECL_INCOMING_RTL(NODE) ((NODE)->decl.saved_insns.r) |
---|
956 | /* For FUNCTION_DECL, if it is inline, holds the saved insn chain. */ |
---|
957 | #define DECL_SAVED_INSNS(NODE) ((NODE)->decl.saved_insns.r) |
---|
958 | /* For FUNCTION_DECL, if it is inline, |
---|
959 | holds the size of the stack frame, as an integer. */ |
---|
960 | #define DECL_FRAME_SIZE(NODE) ((NODE)->decl.frame_size.i) |
---|
961 | /* For FUNCTION_DECL, if it is built-in, |
---|
962 | this identifies which built-in operation it is. */ |
---|
963 | #define DECL_FUNCTION_CODE(NODE) ((NODE)->decl.frame_size.f) |
---|
964 | #define DECL_SET_FUNCTION_CODE(NODE,VAL) ((NODE)->decl.frame_size.f = (VAL)) |
---|
965 | /* For a FIELD_DECL, holds the size of the member as an integer. */ |
---|
966 | #define DECL_FIELD_SIZE(NODE) ((NODE)->decl.saved_insns.i) |
---|
967 | |
---|
968 | /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways. |
---|
969 | Before the struct containing the FUNCTION_DECL is laid out, |
---|
970 | DECL_VINDEX may point to a FUNCTION_DECL in a base class which |
---|
971 | is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual |
---|
972 | function. When the class is laid out, this pointer is changed |
---|
973 | to an INTEGER_CST node which is suitable for use as an index |
---|
974 | into the virtual function table. */ |
---|
975 | #define DECL_VINDEX(NODE) ((NODE)->decl.vindex) |
---|
976 | /* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in |
---|
977 | which this FIELD_DECL is defined. This information is needed when |
---|
978 | writing debugging information about vfield and vbase decls for C++. */ |
---|
979 | #define DECL_FCONTEXT(NODE) ((NODE)->decl.vindex) |
---|
980 | |
---|
981 | /* Every ..._DECL node gets a unique number. */ |
---|
982 | #define DECL_UID(NODE) ((NODE)->decl.uid) |
---|
983 | |
---|
984 | /* For any sort of a ..._DECL node, this points to the original (abstract) |
---|
985 | decl node which this decl is an instance of, or else it is NULL indicating |
---|
986 | that this decl is not an instance of some other decl. For example, |
---|
987 | in a nested declaration of an inline function, this points back to the |
---|
988 | definition. */ |
---|
989 | #define DECL_ABSTRACT_ORIGIN(NODE) ((NODE)->decl.abstract_origin) |
---|
990 | |
---|
991 | /* Nonzero for any sort of ..._DECL node means this decl node represents |
---|
992 | an inline instance of some original (abstract) decl from an inline function; |
---|
993 | suppress any warnings about shadowing some other variable. */ |
---|
994 | #define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != (tree) 0) |
---|
995 | |
---|
996 | /* Nonzero if a _DECL means that the name of this decl should be ignored |
---|
997 | for symbolic debug purposes. */ |
---|
998 | #define DECL_IGNORED_P(NODE) ((NODE)->decl.ignored_flag) |
---|
999 | |
---|
1000 | /* Nonzero for a given ..._DECL node means that this node represents an |
---|
1001 | "abstract instance" of the given declaration (e.g. in the original |
---|
1002 | declaration of an inline function). When generating symbolic debugging |
---|
1003 | information, we mustn't try to generate any address information for nodes |
---|
1004 | marked as "abstract instances" because we don't actually generate |
---|
1005 | any code or allocate any data space for such instances. */ |
---|
1006 | #define DECL_ABSTRACT(NODE) ((NODE)->decl.abstract_flag) |
---|
1007 | |
---|
1008 | /* Nonzero if a _DECL means that no warnings should be generated just |
---|
1009 | because this decl is unused. */ |
---|
1010 | #define DECL_IN_SYSTEM_HEADER(NODE) ((NODE)->decl.in_system_header_flag) |
---|
1011 | |
---|
1012 | /* Nonzero for a given ..._DECL node means that this node should be |
---|
1013 | put in .common, if possible. If a DECL_INITIAL is given, and it |
---|
1014 | is not error_mark_node, then the decl cannot be put in .common. */ |
---|
1015 | #define DECL_COMMON(NODE) ((NODE)->decl.common_flag) |
---|
1016 | |
---|
1017 | /* Language-specific decl information. */ |
---|
1018 | #define DECL_LANG_SPECIFIC(NODE) ((NODE)->decl.lang_specific) |
---|
1019 | |
---|
1020 | /* In a VAR_DECL or FUNCTION_DECL, |
---|
1021 | nonzero means external reference: |
---|
1022 | do not allocate storage, and refer to a definition elsewhere. */ |
---|
1023 | #define DECL_EXTERNAL(NODE) ((NODE)->decl.external_flag) |
---|
1024 | |
---|
1025 | /* In a TYPE_DECL |
---|
1026 | nonzero means the detail info about this type is not dumped into stabs. |
---|
1027 | Instead it will generate cross reference ('x') of names. |
---|
1028 | This uses the same flag as DECL_EXTERNAL. */ |
---|
1029 | #define TYPE_DECL_SUPPRESS_DEBUG(NODE) ((NODE)->decl.external_flag) |
---|
1030 | |
---|
1031 | |
---|
1032 | /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */ |
---|
1033 | #define DECL_REGISTER(NODE) ((NODE)->decl.regdecl_flag) |
---|
1034 | /* In LABEL_DECL nodes, nonzero means that an error message about |
---|
1035 | jumping into such a binding contour has been printed for this label. */ |
---|
1036 | #define DECL_ERROR_ISSUED(NODE) ((NODE)->decl.regdecl_flag) |
---|
1037 | /* In a FIELD_DECL, indicates this field should be bit-packed. */ |
---|
1038 | #define DECL_PACKED(NODE) ((NODE)->decl.regdecl_flag) |
---|
1039 | /* In a FUNCTION_DECL with a non-zero DECL_CONTEXT, indicates that a |
---|
1040 | static chain is not needed. */ |
---|
1041 | #define DECL_NO_STATIC_CHAIN(NODE) ((NODE)->decl.regdecl_flag) |
---|
1042 | |
---|
1043 | /* Nonzero in a ..._DECL means this variable is ref'd from a nested function. |
---|
1044 | For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes. |
---|
1045 | |
---|
1046 | For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted. |
---|
1047 | |
---|
1048 | Also set in some languages for variables, etc., outside the normal |
---|
1049 | lexical scope, such as class instance variables. */ |
---|
1050 | #define DECL_NONLOCAL(NODE) ((NODE)->decl.nonlocal_flag) |
---|
1051 | |
---|
1052 | /* Nonzero in a FUNCTION_DECL means this function can be substituted |
---|
1053 | where it is called. */ |
---|
1054 | #define DECL_INLINE(NODE) ((NODE)->decl.inline_flag) |
---|
1055 | |
---|
1056 | /* Nonzero in a FUNCTION_DECL means this is a built-in function |
---|
1057 | that is not specified by ansi C and that users are supposed to be allowed |
---|
1058 | to redefine for any purpose whatever. */ |
---|
1059 | #define DECL_BUILT_IN_NONANSI(NODE) ((NODE)->common.unsigned_flag) |
---|
1060 | |
---|
1061 | /* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed |
---|
1062 | specially. */ |
---|
1063 | #define DECL_BIT_FIELD(NODE) ((NODE)->decl.bit_field_flag) |
---|
1064 | /* In a LABEL_DECL, nonzero means label was defined inside a binding |
---|
1065 | contour that restored a stack level and which is now exited. */ |
---|
1066 | #define DECL_TOO_LATE(NODE) ((NODE)->decl.bit_field_flag) |
---|
1067 | /* In a FUNCTION_DECL, nonzero means a built in function. */ |
---|
1068 | #define DECL_BUILT_IN(NODE) ((NODE)->decl.bit_field_flag) |
---|
1069 | /* In a VAR_DECL that's static, |
---|
1070 | nonzero if the space is in the text section. */ |
---|
1071 | #define DECL_IN_TEXT_SECTION(NODE) ((NODE)->decl.bit_field_flag) |
---|
1072 | |
---|
1073 | /* Used in VAR_DECLs to indicate that the variable is a vtable. |
---|
1074 | Used in FIELD_DECLs for vtable pointers. |
---|
1075 | Used in FUNCTION_DECLs to indicate that the function is virtual. */ |
---|
1076 | #define DECL_VIRTUAL_P(NODE) ((NODE)->decl.virtual_flag) |
---|
1077 | |
---|
1078 | /* Used to indicate that the linkage status of this DECL is not yet known, |
---|
1079 | so it should not be output now. */ |
---|
1080 | #define DECL_DEFER_OUTPUT(NODE) ((NODE)->decl.defer_output) |
---|
1081 | |
---|
1082 | /* Used in PARM_DECLs whose type are unions to indicate that the |
---|
1083 | argument should be passed in the same way that the first union |
---|
1084 | alternative would be passed. */ |
---|
1085 | #define DECL_TRANSPARENT_UNION(NODE) ((NODE)->decl.transparent_union) |
---|
1086 | |
---|
1087 | /* Used in FUNCTION_DECLs to indicate that they should be run automatically |
---|
1088 | at the beginning or end of execution. */ |
---|
1089 | #define DECL_STATIC_CONSTRUCTOR(NODE) ((NODE)->decl.static_ctor_flag) |
---|
1090 | #define DECL_STATIC_DESTRUCTOR(NODE) ((NODE)->decl.static_dtor_flag) |
---|
1091 | |
---|
1092 | /* Used to indicate that this DECL represents a compiler-generated entity. */ |
---|
1093 | #define DECL_ARTIFICIAL(NODE) ((NODE)->decl.artificial_flag) |
---|
1094 | |
---|
1095 | /* Used to indicate that this DECL has weak linkage. */ |
---|
1096 | #define DECL_WEAK(NODE) ((NODE)->decl.weak_flag) |
---|
1097 | |
---|
1098 | /* Used in TREE_PUBLIC decls to indicate that copies of this DECL in |
---|
1099 | multiple translation units should be merged. */ |
---|
1100 | #define DECL_ONE_ONLY(NODE) ((NODE)->decl.transparent_union) |
---|
1101 | |
---|
1102 | /* Additional flags for language-specific uses. */ |
---|
1103 | #define DECL_LANG_FLAG_0(NODE) ((NODE)->decl.lang_flag_0) |
---|
1104 | #define DECL_LANG_FLAG_1(NODE) ((NODE)->decl.lang_flag_1) |
---|
1105 | #define DECL_LANG_FLAG_2(NODE) ((NODE)->decl.lang_flag_2) |
---|
1106 | #define DECL_LANG_FLAG_3(NODE) ((NODE)->decl.lang_flag_3) |
---|
1107 | #define DECL_LANG_FLAG_4(NODE) ((NODE)->decl.lang_flag_4) |
---|
1108 | #define DECL_LANG_FLAG_5(NODE) ((NODE)->decl.lang_flag_5) |
---|
1109 | #define DECL_LANG_FLAG_6(NODE) ((NODE)->decl.lang_flag_6) |
---|
1110 | #define DECL_LANG_FLAG_7(NODE) ((NODE)->decl.lang_flag_7) |
---|
1111 | |
---|
1112 | struct tree_decl |
---|
1113 | { |
---|
1114 | char common[sizeof (struct tree_common)]; |
---|
1115 | char *filename; |
---|
1116 | int linenum; |
---|
1117 | unsigned int uid; |
---|
1118 | union tree_node *size; |
---|
1119 | #ifdef ONLY_INT_FIELDS |
---|
1120 | int mode : 8; |
---|
1121 | #else |
---|
1122 | enum machine_mode mode : 8; |
---|
1123 | #endif |
---|
1124 | |
---|
1125 | unsigned external_flag : 1; |
---|
1126 | unsigned nonlocal_flag : 1; |
---|
1127 | unsigned regdecl_flag : 1; |
---|
1128 | unsigned inline_flag : 1; |
---|
1129 | unsigned bit_field_flag : 1; |
---|
1130 | unsigned virtual_flag : 1; |
---|
1131 | unsigned ignored_flag : 1; |
---|
1132 | unsigned abstract_flag : 1; |
---|
1133 | |
---|
1134 | unsigned in_system_header_flag : 1; |
---|
1135 | unsigned common_flag : 1; |
---|
1136 | unsigned defer_output : 1; |
---|
1137 | unsigned transparent_union : 1; |
---|
1138 | unsigned static_ctor_flag : 1; |
---|
1139 | unsigned static_dtor_flag : 1; |
---|
1140 | unsigned artificial_flag : 1; |
---|
1141 | unsigned weak_flag : 1; |
---|
1142 | /* room for no more */ |
---|
1143 | |
---|
1144 | unsigned lang_flag_0 : 1; |
---|
1145 | unsigned lang_flag_1 : 1; |
---|
1146 | unsigned lang_flag_2 : 1; |
---|
1147 | unsigned lang_flag_3 : 1; |
---|
1148 | unsigned lang_flag_4 : 1; |
---|
1149 | unsigned lang_flag_5 : 1; |
---|
1150 | unsigned lang_flag_6 : 1; |
---|
1151 | unsigned lang_flag_7 : 1; |
---|
1152 | |
---|
1153 | /* For a FUNCTION_DECL, if inline, this is the size of frame needed. |
---|
1154 | If built-in, this is the code for which built-in function. |
---|
1155 | For other kinds of decls, this is DECL_ALIGN. */ |
---|
1156 | union { |
---|
1157 | int i; |
---|
1158 | unsigned int u; |
---|
1159 | enum built_in_function f; |
---|
1160 | } frame_size; |
---|
1161 | |
---|
1162 | union tree_node *name; |
---|
1163 | union tree_node *context; |
---|
1164 | union tree_node *arguments; |
---|
1165 | union tree_node *result; |
---|
1166 | union tree_node *initial; |
---|
1167 | union tree_node *abstract_origin; |
---|
1168 | union tree_node *assembler_name; |
---|
1169 | union tree_node *section_name; |
---|
1170 | union tree_node *machine_attributes; |
---|
1171 | struct rtx_def *rtl; /* acts as link to register transfer language |
---|
1172 | (rtl) info */ |
---|
1173 | /* For FUNCTION_DECLs: points to insn that constitutes its definition |
---|
1174 | on the permanent obstack. For FIELD_DECL, this is DECL_FIELD_SIZE. */ |
---|
1175 | union { |
---|
1176 | struct rtx_def *r; |
---|
1177 | HOST_WIDE_INT i; |
---|
1178 | } saved_insns; |
---|
1179 | union tree_node *vindex; |
---|
1180 | /* Points to a structure whose details depend on the language in use. */ |
---|
1181 | struct lang_decl *lang_specific; |
---|
1182 | }; |
---|
1183 | |
---|
1184 | /* Define the overall contents of a tree node. |
---|
1185 | It may be any of the structures declared above |
---|
1186 | for various types of node. */ |
---|
1187 | |
---|
1188 | union tree_node |
---|
1189 | { |
---|
1190 | struct tree_common common; |
---|
1191 | struct tree_int_cst int_cst; |
---|
1192 | struct tree_real_cst real_cst; |
---|
1193 | struct tree_string string; |
---|
1194 | struct tree_complex complex; |
---|
1195 | struct tree_identifier identifier; |
---|
1196 | struct tree_decl decl; |
---|
1197 | struct tree_type type; |
---|
1198 | struct tree_list list; |
---|
1199 | struct tree_vec vec; |
---|
1200 | struct tree_exp exp; |
---|
1201 | struct tree_block block; |
---|
1202 | }; |
---|
1203 | |
---|
1204 | #include "gansidecl.h" |
---|
1205 | |
---|
1206 | #define NULL_TREE (tree) NULL |
---|
1207 | |
---|
1208 | /* The following functions accept a wide integer argument. Rather than |
---|
1209 | having to cast on every function call, we use a macro instead, that is |
---|
1210 | defined here and in rtl.h. */ |
---|
1211 | |
---|
1212 | #ifndef exact_log2 |
---|
1213 | #define exact_log2(N) exact_log2_wide ((HOST_WIDE_INT) (N)) |
---|
1214 | #define floor_log2(N) floor_log2_wide ((HOST_WIDE_INT) (N)) |
---|
1215 | #endif |
---|
1216 | |
---|
1217 | #if 0 |
---|
1218 | /* At present, don't prototype xrealloc, since all of the callers don't |
---|
1219 | cast their pointers to char *, and all of the xrealloc's don't use |
---|
1220 | void * yet. */ |
---|
1221 | extern char *xmalloc PROTO((size_t)); |
---|
1222 | extern char *xrealloc PROTO((void *, size_t)); |
---|
1223 | #else |
---|
1224 | extern char *xmalloc (); |
---|
1225 | extern char *xrealloc (); |
---|
1226 | #endif |
---|
1227 | |
---|
1228 | extern char *xstrdup PROTO((char *)); |
---|
1229 | |
---|
1230 | extern char *oballoc PROTO((int)); |
---|
1231 | extern char *permalloc PROTO((int)); |
---|
1232 | extern char *savealloc PROTO((int)); |
---|
1233 | extern char *expralloc PROTO((int)); |
---|
1234 | #ifdef NEED_DECLARATION_FREE |
---|
1235 | extern void free PROTO((void *)); |
---|
1236 | #endif |
---|
1237 | |
---|
1238 | /* Lowest level primitive for allocating a node. |
---|
1239 | The TREE_CODE is the only argument. Contents are initialized |
---|
1240 | to zero except for a few of the common fields. */ |
---|
1241 | |
---|
1242 | extern tree make_node PROTO((enum tree_code)); |
---|
1243 | |
---|
1244 | /* Make a copy of a node, with all the same contents except |
---|
1245 | for TREE_PERMANENT. (The copy is permanent |
---|
1246 | iff nodes being made now are permanent.) */ |
---|
1247 | |
---|
1248 | extern tree copy_node PROTO((tree)); |
---|
1249 | |
---|
1250 | /* Make a copy of a chain of TREE_LIST nodes. */ |
---|
1251 | |
---|
1252 | extern tree copy_list PROTO((tree)); |
---|
1253 | |
---|
1254 | /* Make a TREE_VEC. */ |
---|
1255 | |
---|
1256 | extern tree make_tree_vec PROTO((int)); |
---|
1257 | |
---|
1258 | /* Return the (unique) IDENTIFIER_NODE node for a given name. |
---|
1259 | The name is supplied as a char *. */ |
---|
1260 | |
---|
1261 | extern tree get_identifier PROTO((char *)); |
---|
1262 | |
---|
1263 | /* If an identifier with the name TEXT (a null-terminated string) has |
---|
1264 | previously been referred to, return that node; otherwise return |
---|
1265 | NULL_TREE. */ |
---|
1266 | |
---|
1267 | extern tree maybe_get_identifier PROTO((char *)); |
---|
1268 | |
---|
1269 | /* Construct various types of nodes. */ |
---|
1270 | |
---|
1271 | #define build_int_2(LO,HI) \ |
---|
1272 | build_int_2_wide ((HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI)) |
---|
1273 | |
---|
1274 | extern tree build PVPROTO((enum tree_code, tree, ...)); |
---|
1275 | extern tree build_nt PVPROTO((enum tree_code, ...)); |
---|
1276 | extern tree build_parse_node PVPROTO((enum tree_code, ...)); |
---|
1277 | |
---|
1278 | extern tree build_int_2_wide PROTO((HOST_WIDE_INT, HOST_WIDE_INT)); |
---|
1279 | extern tree build_real PROTO((tree, REAL_VALUE_TYPE)); |
---|
1280 | extern tree build_real_from_int_cst PROTO((tree, tree)); |
---|
1281 | extern tree build_complex PROTO((tree, tree, tree)); |
---|
1282 | extern tree build_string PROTO((int, char *)); |
---|
1283 | extern tree build1 PROTO((enum tree_code, tree, tree)); |
---|
1284 | extern tree build_tree_list PROTO((tree, tree)); |
---|
1285 | extern tree build_decl_list PROTO((tree, tree)); |
---|
1286 | extern tree build_expr_list PROTO((tree, tree)); |
---|
1287 | extern tree build_decl PROTO((enum tree_code, tree, tree)); |
---|
1288 | extern tree build_block PROTO((tree, tree, tree, tree, tree)); |
---|
1289 | |
---|
1290 | /* Construct various nodes representing data types. */ |
---|
1291 | |
---|
1292 | extern tree make_signed_type PROTO((int)); |
---|
1293 | extern tree make_unsigned_type PROTO((int)); |
---|
1294 | extern tree signed_or_unsigned_type PROTO((int, tree)); |
---|
1295 | extern void fixup_unsigned_type PROTO((tree)); |
---|
1296 | extern tree build_pointer_type PROTO((tree)); |
---|
1297 | extern tree build_reference_type PROTO((tree)); |
---|
1298 | extern tree build_index_type PROTO((tree)); |
---|
1299 | extern tree build_index_2_type PROTO((tree, tree)); |
---|
1300 | extern tree build_array_type PROTO((tree, tree)); |
---|
1301 | extern tree build_function_type PROTO((tree, tree)); |
---|
1302 | extern tree build_method_type PROTO((tree, tree)); |
---|
1303 | extern tree build_offset_type PROTO((tree, tree)); |
---|
1304 | extern tree build_complex_type PROTO((tree)); |
---|
1305 | extern tree array_type_nelts PROTO((tree)); |
---|
1306 | |
---|
1307 | extern tree value_member PROTO((tree, tree)); |
---|
1308 | extern tree purpose_member PROTO((tree, tree)); |
---|
1309 | extern tree binfo_member PROTO((tree, tree)); |
---|
1310 | extern int attribute_hash_list PROTO((tree)); |
---|
1311 | extern int attribute_list_equal PROTO((tree, tree)); |
---|
1312 | extern int attribute_list_contained PROTO((tree, tree)); |
---|
1313 | extern int tree_int_cst_equal PROTO((tree, tree)); |
---|
1314 | extern int tree_int_cst_lt PROTO((tree, tree)); |
---|
1315 | extern int tree_int_cst_sgn PROTO((tree)); |
---|
1316 | extern int index_type_equal PROTO((tree, tree)); |
---|
1317 | |
---|
1318 | /* From expmed.c. Since rtl.h is included after tree.h, we can't |
---|
1319 | put the prototype here. Rtl.h does declare the prototype if |
---|
1320 | tree.h had been included. */ |
---|
1321 | |
---|
1322 | extern tree make_tree (); |
---|
1323 | |
---|
1324 | /* Return a type like TTYPE except that its TYPE_ATTRIBUTES |
---|
1325 | is ATTRIBUTE. |
---|
1326 | |
---|
1327 | Such modified types already made are recorded so that duplicates |
---|
1328 | are not made. */ |
---|
1329 | |
---|
1330 | extern tree build_type_attribute_variant PROTO((tree, tree)); |
---|
1331 | extern tree build_decl_attribute_variant PROTO((tree, tree)); |
---|
1332 | |
---|
1333 | /* Return 1 if an attribute and its arguments are valid for a decl or type. */ |
---|
1334 | |
---|
1335 | extern int valid_machine_attribute PROTO((tree, tree, tree, tree)); |
---|
1336 | |
---|
1337 | /* Given a tree node and a string, return non-zero if the tree node is |
---|
1338 | a valid attribute name for the string. */ |
---|
1339 | |
---|
1340 | extern int is_attribute_p PROTO((char *, tree)); |
---|
1341 | |
---|
1342 | /* Given an attribute name and a list of attributes, return the list element |
---|
1343 | of the attribute or NULL_TREE if not found. */ |
---|
1344 | |
---|
1345 | extern tree lookup_attribute PROTO((char *, tree)); |
---|
1346 | |
---|
1347 | /* Given two attributes lists, return a list of their union. */ |
---|
1348 | |
---|
1349 | extern tree merge_attributes PROTO((tree, tree)); |
---|
1350 | |
---|
1351 | /* Given a type node TYPE, and CONSTP and VOLATILEP, return a type |
---|
1352 | for the same kind of data as TYPE describes. |
---|
1353 | Variants point to the "main variant" (which has neither CONST nor VOLATILE) |
---|
1354 | via TYPE_MAIN_VARIANT, and it points to a chain of other variants |
---|
1355 | so that duplicate variants are never made. |
---|
1356 | Only main variants should ever appear as types of expressions. */ |
---|
1357 | |
---|
1358 | extern tree build_type_variant PROTO((tree, int, int)); |
---|
1359 | |
---|
1360 | /* Make a copy of a type node. */ |
---|
1361 | |
---|
1362 | extern tree build_type_copy PROTO((tree)); |
---|
1363 | |
---|
1364 | /* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT, |
---|
1365 | TYPE_ALIGN and TYPE_MODE fields. |
---|
1366 | If called more than once on one node, does nothing except |
---|
1367 | for the first time. */ |
---|
1368 | |
---|
1369 | extern void layout_type PROTO((tree)); |
---|
1370 | |
---|
1371 | /* Given a hashcode and a ..._TYPE node (for which the hashcode was made), |
---|
1372 | return a canonicalized ..._TYPE node, so that duplicates are not made. |
---|
1373 | How the hash code is computed is up to the caller, as long as any two |
---|
1374 | callers that could hash identical-looking type nodes agree. */ |
---|
1375 | |
---|
1376 | extern tree type_hash_canon PROTO((int, tree)); |
---|
1377 | |
---|
1378 | /* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node, |
---|
1379 | calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE |
---|
1380 | fields. Call this only once for any given decl node. |
---|
1381 | |
---|
1382 | Second argument is the boundary that this field can be assumed to |
---|
1383 | be starting at (in bits). Zero means it can be assumed aligned |
---|
1384 | on any boundary that may be needed. */ |
---|
1385 | |
---|
1386 | extern void layout_decl PROTO((tree, unsigned)); |
---|
1387 | |
---|
1388 | /* Return an expr equal to X but certainly not valid as an lvalue. */ |
---|
1389 | |
---|
1390 | extern tree non_lvalue PROTO((tree)); |
---|
1391 | extern tree pedantic_non_lvalue PROTO((tree)); |
---|
1392 | |
---|
1393 | extern tree convert PROTO((tree, tree)); |
---|
1394 | extern tree size_in_bytes PROTO((tree)); |
---|
1395 | extern HOST_WIDE_INT int_size_in_bytes PROTO((tree)); |
---|
1396 | extern tree size_binop PROTO((enum tree_code, tree, tree)); |
---|
1397 | extern tree size_int PROTO((unsigned HOST_WIDE_INT)); |
---|
1398 | extern tree round_up PROTO((tree, int)); |
---|
1399 | extern tree get_pending_sizes PROTO((void)); |
---|
1400 | extern void put_pending_sizes PROTO((tree)); |
---|
1401 | |
---|
1402 | /* Type for sizes of data-type. */ |
---|
1403 | |
---|
1404 | extern tree sizetype; |
---|
1405 | |
---|
1406 | /* If nonzero, an upper limit on alignment of structure fields, in bits. */ |
---|
1407 | extern int maximum_field_alignment; |
---|
1408 | |
---|
1409 | /* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */ |
---|
1410 | extern int set_alignment; |
---|
1411 | |
---|
1412 | /* Concatenate two lists (chains of TREE_LIST nodes) X and Y |
---|
1413 | by making the last node in X point to Y. |
---|
1414 | Returns X, except if X is 0 returns Y. */ |
---|
1415 | |
---|
1416 | extern tree chainon PROTO((tree, tree)); |
---|
1417 | |
---|
1418 | /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */ |
---|
1419 | |
---|
1420 | extern tree tree_cons PROTO((tree, tree, tree)); |
---|
1421 | extern tree perm_tree_cons PROTO((tree, tree, tree)); |
---|
1422 | extern tree temp_tree_cons PROTO((tree, tree, tree)); |
---|
1423 | extern tree saveable_tree_cons PROTO((tree, tree, tree)); |
---|
1424 | extern tree decl_tree_cons PROTO((tree, tree, tree)); |
---|
1425 | extern tree expr_tree_cons PROTO((tree, tree, tree)); |
---|
1426 | |
---|
1427 | /* Return the last tree node in a chain. */ |
---|
1428 | |
---|
1429 | extern tree tree_last PROTO((tree)); |
---|
1430 | |
---|
1431 | /* Reverse the order of elements in a chain, and return the new head. */ |
---|
1432 | |
---|
1433 | extern tree nreverse PROTO((tree)); |
---|
1434 | |
---|
1435 | /* Returns the length of a chain of nodes |
---|
1436 | (number of chain pointers to follow before reaching a null pointer). */ |
---|
1437 | |
---|
1438 | extern int list_length PROTO((tree)); |
---|
1439 | |
---|
1440 | /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */ |
---|
1441 | |
---|
1442 | extern int integer_zerop PROTO((tree)); |
---|
1443 | |
---|
1444 | /* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */ |
---|
1445 | |
---|
1446 | extern int integer_onep PROTO((tree)); |
---|
1447 | |
---|
1448 | /* integer_all_onesp (tree x) is nonzero if X is an integer constant |
---|
1449 | all of whose significant bits are 1. */ |
---|
1450 | |
---|
1451 | extern int integer_all_onesp PROTO((tree)); |
---|
1452 | |
---|
1453 | /* integer_pow2p (tree x) is nonzero is X is an integer constant with |
---|
1454 | exactly one bit 1. */ |
---|
1455 | |
---|
1456 | extern int integer_pow2p PROTO((tree)); |
---|
1457 | |
---|
1458 | /* staticp (tree x) is nonzero if X is a reference to data allocated |
---|
1459 | at a fixed address in memory. */ |
---|
1460 | |
---|
1461 | extern int staticp PROTO((tree)); |
---|
1462 | |
---|
1463 | /* Gets an error if argument X is not an lvalue. |
---|
1464 | Also returns 1 if X is an lvalue, 0 if not. */ |
---|
1465 | |
---|
1466 | extern int lvalue_or_else PROTO((tree, char *)); |
---|
1467 | |
---|
1468 | /* save_expr (EXP) returns an expression equivalent to EXP |
---|
1469 | but it can be used multiple times within context CTX |
---|
1470 | and only evaluate EXP once. */ |
---|
1471 | |
---|
1472 | extern tree save_expr PROTO((tree)); |
---|
1473 | |
---|
1474 | /* unsave_expr (EXP) returns an expression equivalent to EXP but it |
---|
1475 | can be used multiple times and will evaluate EXP, in it's entirety |
---|
1476 | each time. */ |
---|
1477 | |
---|
1478 | extern tree unsave_expr PROTO((tree)); |
---|
1479 | |
---|
1480 | /* unsave_expr_now (EXP) resets EXP in place, so that it can be |
---|
1481 | expanded again. */ |
---|
1482 | |
---|
1483 | extern tree unsave_expr_now PROTO((tree)); |
---|
1484 | |
---|
1485 | /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size |
---|
1486 | or offset that depends on a field within a record. |
---|
1487 | |
---|
1488 | Note that we only allow such expressions within simple arithmetic |
---|
1489 | or a COND_EXPR. */ |
---|
1490 | |
---|
1491 | extern int contains_placeholder_p PROTO((tree)); |
---|
1492 | |
---|
1493 | /* Given a tree EXP, a FIELD_DECL F, and a replacement value R, |
---|
1494 | return a tree with all occurrences of references to F in a |
---|
1495 | PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP |
---|
1496 | contains only arithmetic expressions. */ |
---|
1497 | |
---|
1498 | extern tree substitute_in_expr PROTO((tree, tree, tree)); |
---|
1499 | |
---|
1500 | /* variable_size (EXP) is like save_expr (EXP) except that it |
---|
1501 | is for the special case of something that is part of a |
---|
1502 | variable size for a data type. It makes special arrangements |
---|
1503 | to compute the value at the right time when the data type |
---|
1504 | belongs to a function parameter. */ |
---|
1505 | |
---|
1506 | extern tree variable_size PROTO((tree)); |
---|
1507 | |
---|
1508 | /* stabilize_reference (EXP) returns an reference equivalent to EXP |
---|
1509 | but it can be used multiple times |
---|
1510 | and only evaluate the subexpressions once. */ |
---|
1511 | |
---|
1512 | extern tree stabilize_reference PROTO((tree)); |
---|
1513 | |
---|
1514 | /* Subroutine of stabilize_reference; this is called for subtrees of |
---|
1515 | references. Any expression with side-effects must be put in a SAVE_EXPR |
---|
1516 | to ensure that it is only evaluated once. */ |
---|
1517 | |
---|
1518 | extern tree stabilize_reference_1 PROTO((tree)); |
---|
1519 | |
---|
1520 | /* Return EXP, stripped of any conversions to wider types |
---|
1521 | in such a way that the result of converting to type FOR_TYPE |
---|
1522 | is the same as if EXP were converted to FOR_TYPE. |
---|
1523 | If FOR_TYPE is 0, it signifies EXP's type. */ |
---|
1524 | |
---|
1525 | extern tree get_unwidened PROTO((tree, tree)); |
---|
1526 | |
---|
1527 | /* Return OP or a simpler expression for a narrower value |
---|
1528 | which can be sign-extended or zero-extended to give back OP. |
---|
1529 | Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended |
---|
1530 | or 0 if the value should be sign-extended. */ |
---|
1531 | |
---|
1532 | extern tree get_narrower PROTO((tree, int *)); |
---|
1533 | |
---|
1534 | /* Given MODE and UNSIGNEDP, return a suitable type-tree |
---|
1535 | with that mode. |
---|
1536 | The definition of this resides in language-specific code |
---|
1537 | as the repertoire of available types may vary. */ |
---|
1538 | |
---|
1539 | extern tree type_for_mode PROTO((enum machine_mode, int)); |
---|
1540 | |
---|
1541 | /* Given PRECISION and UNSIGNEDP, return a suitable type-tree |
---|
1542 | for an integer type with at least that precision. |
---|
1543 | The definition of this resides in language-specific code |
---|
1544 | as the repertoire of available types may vary. */ |
---|
1545 | |
---|
1546 | extern tree type_for_size PROTO((unsigned, int)); |
---|
1547 | |
---|
1548 | /* Given an integer type T, return a type like T but unsigned. |
---|
1549 | If T is unsigned, the value is T. |
---|
1550 | The definition of this resides in language-specific code |
---|
1551 | as the repertoire of available types may vary. */ |
---|
1552 | |
---|
1553 | extern tree unsigned_type PROTO((tree)); |
---|
1554 | |
---|
1555 | /* Given an integer type T, return a type like T but signed. |
---|
1556 | If T is signed, the value is T. |
---|
1557 | The definition of this resides in language-specific code |
---|
1558 | as the repertoire of available types may vary. */ |
---|
1559 | |
---|
1560 | extern tree signed_type PROTO((tree)); |
---|
1561 | |
---|
1562 | /* This function must be defined in the language-specific files. |
---|
1563 | expand_expr calls it to build the cleanup-expression for a TARGET_EXPR. |
---|
1564 | This is defined in a language-specific file. */ |
---|
1565 | |
---|
1566 | extern tree maybe_build_cleanup PROTO((tree)); |
---|
1567 | |
---|
1568 | /* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF, |
---|
1569 | look for nested component-refs or array-refs at constant positions |
---|
1570 | and find the ultimate containing object, which is returned. */ |
---|
1571 | |
---|
1572 | extern tree get_inner_reference PROTO((tree, int *, int *, tree *, |
---|
1573 | enum machine_mode *, int *, |
---|
1574 | int *, int *)); |
---|
1575 | |
---|
1576 | /* Return the FUNCTION_DECL which provides this _DECL with its context, |
---|
1577 | or zero if none. */ |
---|
1578 | extern tree decl_function_context PROTO((tree)); |
---|
1579 | |
---|
1580 | /* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides |
---|
1581 | this _DECL with its context, or zero if none. */ |
---|
1582 | extern tree decl_type_context PROTO((tree)); |
---|
1583 | |
---|
1584 | /* Given the FUNCTION_DECL for the current function, |
---|
1585 | return zero if it is ok for this function to be inline. |
---|
1586 | Otherwise return a warning message with a single %s |
---|
1587 | for the function's name. */ |
---|
1588 | |
---|
1589 | extern char *function_cannot_inline_p PROTO((tree)); |
---|
1590 | |
---|
1591 | /* Return 1 if EXPR is the real constant zero. */ |
---|
1592 | extern int real_zerop PROTO((tree)); |
---|
1593 | |
---|
1594 | /* Declare commonly used variables for tree structure. */ |
---|
1595 | |
---|
1596 | /* An integer constant with value 0 */ |
---|
1597 | extern tree integer_zero_node; |
---|
1598 | |
---|
1599 | /* An integer constant with value 1 */ |
---|
1600 | extern tree integer_one_node; |
---|
1601 | |
---|
1602 | /* An integer constant with value 0 whose type is sizetype. */ |
---|
1603 | extern tree size_zero_node; |
---|
1604 | |
---|
1605 | /* An integer constant with value 1 whose type is sizetype. */ |
---|
1606 | extern tree size_one_node; |
---|
1607 | |
---|
1608 | /* A constant of type pointer-to-int and value 0 */ |
---|
1609 | extern tree null_pointer_node; |
---|
1610 | |
---|
1611 | /* A node of type ERROR_MARK. */ |
---|
1612 | extern tree error_mark_node; |
---|
1613 | |
---|
1614 | /* The type node for the void type. */ |
---|
1615 | extern tree void_type_node; |
---|
1616 | |
---|
1617 | /* The type node for the ordinary (signed) integer type. */ |
---|
1618 | extern tree integer_type_node; |
---|
1619 | |
---|
1620 | /* The type node for the unsigned integer type. */ |
---|
1621 | extern tree unsigned_type_node; |
---|
1622 | |
---|
1623 | /* The type node for the ordinary character type. */ |
---|
1624 | extern tree char_type_node; |
---|
1625 | |
---|
1626 | /* Points to the name of the input file from which the current input |
---|
1627 | being parsed originally came (before it went into cpp). */ |
---|
1628 | extern char *input_filename; |
---|
1629 | |
---|
1630 | /* Current line number in input file. */ |
---|
1631 | extern int lineno; |
---|
1632 | |
---|
1633 | /* Nonzero for -pedantic switch: warn about anything |
---|
1634 | that standard C forbids. */ |
---|
1635 | extern int pedantic; |
---|
1636 | |
---|
1637 | /* Nonzero means lvalues are limited to those valid in pedantic ANSI C. |
---|
1638 | Zero means allow extended lvalues. */ |
---|
1639 | |
---|
1640 | extern int pedantic_lvalues; |
---|
1641 | |
---|
1642 | /* Nonzero means can safely call expand_expr now; |
---|
1643 | otherwise layout_type puts variable sizes onto `pending_sizes' instead. */ |
---|
1644 | |
---|
1645 | extern int immediate_size_expand; |
---|
1646 | |
---|
1647 | /* Points to the FUNCTION_DECL of the function whose body we are reading. */ |
---|
1648 | |
---|
1649 | extern tree current_function_decl; |
---|
1650 | |
---|
1651 | /* Nonzero if function being compiled can call setjmp. */ |
---|
1652 | |
---|
1653 | extern int current_function_calls_setjmp; |
---|
1654 | |
---|
1655 | /* Nonzero if function being compiled can call longjmp. */ |
---|
1656 | |
---|
1657 | extern int current_function_calls_longjmp; |
---|
1658 | |
---|
1659 | /* Nonzero means all ..._TYPE nodes should be allocated permanently. */ |
---|
1660 | |
---|
1661 | extern int all_types_permanent; |
---|
1662 | |
---|
1663 | /* Pointer to function to compute the name to use to print a declaration. |
---|
1664 | DECL is the declaration in question. |
---|
1665 | VERBOSITY determines what information will be printed: |
---|
1666 | 0: DECL_NAME, demangled as necessary. |
---|
1667 | 1: and scope information. |
---|
1668 | 2: and any other information that might be interesting, such as function |
---|
1669 | parameter types in C++. */ |
---|
1670 | |
---|
1671 | extern char *(*decl_printable_name) (/* tree decl, int verbosity */); |
---|
1672 | |
---|
1673 | /* Pointer to function to finish handling an incomplete decl at the |
---|
1674 | end of compilation. */ |
---|
1675 | |
---|
1676 | extern void (*incomplete_decl_finalize_hook) (); |
---|
1677 | |
---|
1678 | /* In tree.c */ |
---|
1679 | extern char *perm_calloc PROTO((int, long)); |
---|
1680 | extern tree get_file_function_name PROTO((int)); |
---|
1681 | extern tree get_set_constructor_bits PROTO((tree, char *, int)); |
---|
1682 | extern tree get_set_constructor_bytes PROTO((tree, |
---|
1683 | unsigned char *, int)); |
---|
1684 | |
---|
1685 | /* In stmt.c */ |
---|
1686 | |
---|
1687 | extern void expand_fixups PROTO((struct rtx_def *)); |
---|
1688 | extern tree expand_start_stmt_expr PROTO((void)); |
---|
1689 | extern tree expand_end_stmt_expr PROTO((tree)); |
---|
1690 | extern void expand_expr_stmt PROTO((tree)); |
---|
1691 | extern int warn_if_unused_value PROTO((tree)); |
---|
1692 | extern void expand_decl_init PROTO((tree)); |
---|
1693 | extern void clear_last_expr PROTO((void)); |
---|
1694 | extern void expand_label PROTO((tree)); |
---|
1695 | extern void expand_goto PROTO((tree)); |
---|
1696 | extern void expand_asm PROTO((tree)); |
---|
1697 | extern void expand_start_cond PROTO((tree, int)); |
---|
1698 | extern void expand_end_cond PROTO((void)); |
---|
1699 | extern void expand_start_else PROTO((void)); |
---|
1700 | extern void expand_start_elseif PROTO((tree)); |
---|
1701 | extern struct nesting *expand_start_loop PROTO((int)); |
---|
1702 | extern struct nesting *expand_start_loop_continue_elsewhere PROTO((int)); |
---|
1703 | extern void expand_loop_continue_here PROTO((void)); |
---|
1704 | extern void expand_end_loop PROTO((void)); |
---|
1705 | extern int expand_continue_loop PROTO((struct nesting *)); |
---|
1706 | extern int expand_exit_loop PROTO((struct nesting *)); |
---|
1707 | extern int expand_exit_loop_if_false PROTO((struct nesting *, |
---|
1708 | tree)); |
---|
1709 | extern int expand_exit_something PROTO((void)); |
---|
1710 | |
---|
1711 | extern void expand_null_return PROTO((void)); |
---|
1712 | extern void expand_return PROTO((tree)); |
---|
1713 | extern void expand_start_bindings PROTO((int)); |
---|
1714 | extern void expand_end_bindings PROTO((tree, int, int)); |
---|
1715 | extern void start_cleanup_deferral PROTO((void)); |
---|
1716 | extern void end_cleanup_deferral PROTO((void)); |
---|
1717 | extern void mark_block_as_eh_region PROTO((void)); |
---|
1718 | extern void mark_block_as_not_eh_region PROTO((void)); |
---|
1719 | extern int is_eh_region PROTO((void)); |
---|
1720 | extern int conditional_context PROTO((void)); |
---|
1721 | extern tree last_cleanup_this_contour PROTO((void)); |
---|
1722 | extern int expand_dhc_cleanup PROTO((tree)); |
---|
1723 | extern int expand_dcc_cleanup PROTO((tree)); |
---|
1724 | extern void expand_start_case PROTO((int, tree, tree, |
---|
1725 | char *)); |
---|
1726 | extern void expand_end_case PROTO((tree)); |
---|
1727 | extern int pushcase PROTO((tree, |
---|
1728 | tree (*) (tree, tree), |
---|
1729 | tree, tree *)); |
---|
1730 | extern int pushcase_range PROTO((tree, tree, |
---|
1731 | tree (*) (tree, tree), |
---|
1732 | tree, tree *)); |
---|
1733 | |
---|
1734 | /* In fold-const.c */ |
---|
1735 | |
---|
1736 | /* Fold constants as much as possible in an expression. |
---|
1737 | Returns the simplified expression. |
---|
1738 | Acts only on the top level of the expression; |
---|
1739 | if the argument itself cannot be simplified, its |
---|
1740 | subexpressions are not changed. */ |
---|
1741 | |
---|
1742 | extern tree fold PROTO((tree)); |
---|
1743 | |
---|
1744 | extern int force_fit_type PROTO((tree, int)); |
---|
1745 | extern int add_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1746 | HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1747 | HOST_WIDE_INT *, HOST_WIDE_INT *)); |
---|
1748 | extern int neg_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1749 | HOST_WIDE_INT *, HOST_WIDE_INT *)); |
---|
1750 | extern int mul_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1751 | HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1752 | HOST_WIDE_INT *, HOST_WIDE_INT *)); |
---|
1753 | extern void lshift_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1754 | HOST_WIDE_INT, int, HOST_WIDE_INT *, |
---|
1755 | HOST_WIDE_INT *, int)); |
---|
1756 | extern void rshift_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1757 | HOST_WIDE_INT, int, |
---|
1758 | HOST_WIDE_INT *, HOST_WIDE_INT *, int)); |
---|
1759 | extern void lrotate_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1760 | HOST_WIDE_INT, int, HOST_WIDE_INT *, |
---|
1761 | HOST_WIDE_INT *)); |
---|
1762 | extern void rrotate_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT, |
---|
1763 | HOST_WIDE_INT, int, HOST_WIDE_INT *, |
---|
1764 | HOST_WIDE_INT *)); |
---|
1765 | extern int operand_equal_p PROTO((tree, tree, int)); |
---|
1766 | extern tree invert_truthvalue PROTO((tree)); |
---|
1767 | |
---|
1768 | /* Interface of the DWARF2 unwind info support. */ |
---|
1769 | |
---|
1770 | /* Decide whether we want to emit frame unwind information for the current |
---|
1771 | translation unit. */ |
---|
1772 | |
---|
1773 | extern int dwarf2out_do_frame PROTO((void)); |
---|
1774 | |
---|
1775 | /* Generate a new label for the CFI info to refer to. */ |
---|
1776 | |
---|
1777 | extern char *dwarf2out_cfi_label PROTO((void)); |
---|
1778 | |
---|
1779 | /* Entry point to update the canonical frame address (CFA). */ |
---|
1780 | |
---|
1781 | extern void dwarf2out_def_cfa PROTO((char *, unsigned, long)); |
---|
1782 | |
---|
1783 | /* Add the CFI for saving a register window. */ |
---|
1784 | |
---|
1785 | extern void dwarf2out_window_save PROTO((char *)); |
---|
1786 | |
---|
1787 | /* Add a CFI to update the running total of the size of arguments pushed |
---|
1788 | onto the stack. */ |
---|
1789 | |
---|
1790 | extern void dwarf2out_args_size PROTO((char *, long)); |
---|
1791 | |
---|
1792 | /* Entry point for saving a register to the stack. */ |
---|
1793 | |
---|
1794 | extern void dwarf2out_reg_save PROTO((char *, unsigned, long)); |
---|
1795 | |
---|
1796 | /* Entry point for saving the return address in the stack. */ |
---|
1797 | |
---|
1798 | extern void dwarf2out_return_save PROTO((char *, long)); |
---|
1799 | |
---|
1800 | /* Entry point for saving the return address in a register. */ |
---|
1801 | |
---|
1802 | extern void dwarf2out_return_reg PROTO((char *, unsigned)); |
---|
1803 | |
---|
1804 | /* Output a marker (i.e. a label) for the beginning of a function, before |
---|
1805 | the prologue. */ |
---|
1806 | |
---|
1807 | extern void dwarf2out_begin_prologue PROTO((void)); |
---|
1808 | |
---|
1809 | /* Output a marker (i.e. a label) for the absolute end of the generated |
---|
1810 | code for a function definition. */ |
---|
1811 | |
---|
1812 | extern void dwarf2out_end_epilogue PROTO((void)); |
---|
1813 | |
---|
1814 | /* The language front-end must define these functions. */ |
---|
1815 | |
---|
1816 | /* Function of no arguments for initializing lexical scanning. */ |
---|
1817 | extern void init_lex PROTO((void)); |
---|
1818 | /* Function of no arguments for initializing the symbol table. */ |
---|
1819 | extern void init_decl_processing PROTO((void)); |
---|
1820 | |
---|
1821 | /* Functions called with no arguments at the beginning and end or processing |
---|
1822 | the input source file. */ |
---|
1823 | extern void lang_init PROTO((void)); |
---|
1824 | extern void lang_finish PROTO((void)); |
---|
1825 | |
---|
1826 | /* Function to identify which front-end produced the output file. */ |
---|
1827 | extern char *lang_identify PROTO((void)); |
---|
1828 | |
---|
1829 | /* Function to replace the DECL_LANG_SPECIFIC field of a DECL with a copy. */ |
---|
1830 | extern void copy_lang_decl PROTO((tree)); |
---|
1831 | |
---|
1832 | /* Function called with no arguments to parse and compile the input. */ |
---|
1833 | extern int yyparse PROTO((void)); |
---|
1834 | /* Function called with option as argument |
---|
1835 | to decode options starting with -f or -W or +. |
---|
1836 | It should return nonzero if it handles the option. */ |
---|
1837 | extern int lang_decode_option PROTO((char *)); |
---|
1838 | |
---|
1839 | /* Functions for processing symbol declarations. */ |
---|
1840 | /* Function to enter a new lexical scope. |
---|
1841 | Takes one argument: always zero when called from outside the front end. */ |
---|
1842 | extern void pushlevel PROTO((int)); |
---|
1843 | /* Function to exit a lexical scope. It returns a BINDING for that scope. |
---|
1844 | Takes three arguments: |
---|
1845 | KEEP -- nonzero if there were declarations in this scope. |
---|
1846 | REVERSE -- reverse the order of decls before returning them. |
---|
1847 | FUNCTIONBODY -- nonzero if this level is the body of a function. */ |
---|
1848 | extern tree poplevel PROTO((int, int, int)); |
---|
1849 | /* Set the BLOCK node for the current scope level. */ |
---|
1850 | extern void set_block PROTO((tree)); |
---|
1851 | /* Function to add a decl to the current scope level. |
---|
1852 | Takes one argument, a decl to add. |
---|
1853 | Returns that decl, or, if the same symbol is already declared, may |
---|
1854 | return a different decl for that name. */ |
---|
1855 | extern tree pushdecl PROTO((tree)); |
---|
1856 | /* Function to return the chain of decls so far in the current scope level. */ |
---|
1857 | extern tree getdecls PROTO((void)); |
---|
1858 | /* Function to return the chain of structure tags in the current scope level. */ |
---|
1859 | extern tree gettags PROTO((void)); |
---|
1860 | |
---|
1861 | extern tree build_range_type PROTO((tree, tree, tree)); |
---|
1862 | |
---|
1863 | /* Call when starting to parse a declaration: |
---|
1864 | make expressions in the declaration last the length of the function. |
---|
1865 | Returns an argument that should be passed to resume_momentary later. */ |
---|
1866 | extern int suspend_momentary PROTO((void)); |
---|
1867 | |
---|
1868 | extern int allocation_temporary_p PROTO((void)); |
---|
1869 | |
---|
1870 | /* Call when finished parsing a declaration: |
---|
1871 | restore the treatment of node-allocation that was |
---|
1872 | in effect before the suspension. |
---|
1873 | YES should be the value previously returned by suspend_momentary. */ |
---|
1874 | extern void resume_momentary PROTO((int)); |
---|
1875 | |
---|
1876 | /* Called after finishing a record, union or enumeral type. */ |
---|
1877 | extern void rest_of_type_compilation PROTO((tree, int)); |
---|
1878 | |
---|
1879 | /* Save the current set of obstacks, but don't change them. */ |
---|
1880 | extern void push_obstacks_nochange PROTO((void)); |
---|
1881 | |
---|
1882 | extern void permanent_allocation PROTO((int)); |
---|
1883 | |
---|
1884 | extern void push_momentary PROTO((void)); |
---|
1885 | |
---|
1886 | extern void clear_momentary PROTO((void)); |
---|
1887 | |
---|
1888 | extern void pop_momentary PROTO((void)); |
---|
1889 | |
---|
1890 | extern void end_temporary_allocation PROTO((void)); |
---|
1891 | |
---|
1892 | /* Pop the obstack selection stack. */ |
---|
1893 | extern void pop_obstacks PROTO((void)); |
---|