![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to tree.h CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Front-end tree definitions for GNU compiler.
2: Copyright (C) 1989 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: #include "machmode.h"
21:
22: /* codes of tree nodes */
23:
24: #define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM,
25:
26: enum tree_code {
27: #include "tree.def"
28:
1.1.1.3 root 29: LAST_AND_UNUSED_TREE_CODE /* A convenient way to get a value for
1.1 root 30: NUM_TREE_CODE. */
31: };
32:
33: #undef DEFTREECODE
34:
35: /* Number of tree codes. */
36: #define NUM_TREE_CODES ((int)LAST_AND_UNUSED_TREE_CODE)
37:
38: /* Indexed by enum tree_code, contains a character which is
39: `<' for a comparison expression, `1', for a unary arithmetic
40: expression, `2' for a binary arithmetic expression, `e' for
41: other types of expressions, `r' for a reference, `c' for a
42: constant, `d' for a decl, `t' for a type, `s' for a statement,
43: and `x' for anything else (TREE_LIST, IDENTIFIER, etc). */
44:
45: extern char **tree_code_type;
46: #define TREE_CODE_CLASS(CODE) (*tree_code_type[(int) (CODE)])
47:
48: /* Number of argument-words in each kind of tree-node. */
49:
50: extern int *tree_code_length;
51:
52: /* Names of tree components. */
53:
54: extern char **tree_code_name;
55:
56: /* Codes that identify the various built in functions
57: so that expand_call can identify them quickly. */
58:
59: enum built_in_function
60: {
61: NOT_BUILT_IN,
62: BUILT_IN_ALLOCA,
63: BUILT_IN_ABS,
64: BUILT_IN_FABS,
65: BUILT_IN_LABS,
66: BUILT_IN_FFS,
67: BUILT_IN_DIV,
68: BUILT_IN_LDIV,
69: BUILT_IN_FFLOOR,
70: BUILT_IN_FCEIL,
71: BUILT_IN_FMOD,
72: BUILT_IN_FREM,
73: BUILT_IN_MEMCPY,
74: BUILT_IN_MEMCMP,
75: BUILT_IN_MEMSET,
76: BUILT_IN_STRCPY,
77: BUILT_IN_STRCMP,
78: BUILT_IN_STRLEN,
79: BUILT_IN_FSQRT,
1.1.1.4 root 80: BUILT_IN_SIN,
81: BUILT_IN_COS,
1.1 root 82: BUILT_IN_GETEXP,
83: BUILT_IN_GETMAN,
84: BUILT_IN_SAVEREGS,
85: BUILT_IN_CLASSIFY_TYPE,
86: BUILT_IN_NEXT_ARG,
87: BUILT_IN_ARGS_INFO,
88: BUILT_IN_CONSTANT_P,
89: BUILT_IN_FRAME_ADDRESS,
90: BUILT_IN_RETURN_ADDRESS,
91: BUILT_IN_CALLER_RETURN_ADDRESS,
1.1.1.5 ! root 92: BUILT_IN_APPLY_ARGS,
! 93: BUILT_IN_APPLY,
! 94: BUILT_IN_RETURN,
1.1 root 95:
96: /* C++ extensions */
97: BUILT_IN_NEW,
98: BUILT_IN_VEC_NEW,
99: BUILT_IN_DELETE,
100: BUILT_IN_VEC_DELETE
101: };
102:
103: /* The definition of tree nodes fills the next several pages. */
104:
105: /* A tree node can represent a data type, a variable, an expression
106: or a statement. Each node has a TREE_CODE which says what kind of
107: thing it represents. Some common codes are:
108: INTEGER_TYPE -- represents a type of integers.
109: ARRAY_TYPE -- represents a type of pointer.
110: VAR_DECL -- represents a declared variable.
111: INTEGER_CST -- represents a constant integer value.
112: PLUS_EXPR -- represents a sum (an expression).
113:
114: As for the contents of a tree node: there are some fields
115: that all nodes share. Each TREE_CODE has various special-purpose
116: fields as well. The fields of a node are never accessed directly,
117: always through accessor macros. */
118:
119: /* This type is used everywhere to refer to a tree node. */
120:
121: typedef union tree_node *tree;
122:
123: /* Every kind of tree node starts with this structure,
124: so all nodes have these fields.
125:
126: See the accessor macros, defined below, for documentation of the fields. */
127:
128: struct tree_common
129: {
130: union tree_node *chain;
131: union tree_node *type;
132: #ifdef ONLY_INT_FIELDS
133: unsigned int code : 8;
134: #else
135: enum tree_code code : 8;
136: #endif
137:
138: unsigned side_effects_flag : 1;
139: unsigned constant_flag : 1;
140: unsigned permanent_flag : 1;
141: unsigned addressable_flag : 1;
142: unsigned volatile_flag : 1;
143: unsigned readonly_flag : 1;
144: unsigned unsigned_flag : 1;
145: unsigned asm_written_flag: 1;
146:
147: unsigned used_flag : 1;
148: unsigned raises_flag : 1;
149: unsigned static_flag : 1;
150: unsigned public_flag : 1;
151: unsigned private_flag : 1;
152: unsigned protected_flag : 1;
153:
154: unsigned lang_flag_0 : 1;
155: unsigned lang_flag_1 : 1;
156: unsigned lang_flag_2 : 1;
157: unsigned lang_flag_3 : 1;
158: unsigned lang_flag_4 : 1;
159: unsigned lang_flag_5 : 1;
160: unsigned lang_flag_6 : 1;
161: /* There is room for two more flags. */
162: };
163:
164: /* Define accessors for the fields that all tree nodes have
165: (though some fields are not used for all kinds of nodes). */
166:
167: /* The tree-code says what kind of node it is.
168: Codes are defined in tree.def. */
169: #define TREE_CODE(NODE) ((enum tree_code) (NODE)->common.code)
170: #define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (int) (VALUE))
171:
172: /* In all nodes that are expressions, this is the data type of the expression.
173: In POINTER_TYPE nodes, this is the type that the pointer points to.
174: In ARRAY_TYPE nodes, this is the type of the elements. */
175: #define TREE_TYPE(NODE) ((NODE)->common.type)
176:
177: /* Nodes are chained together for many purposes.
178: Types are chained together to record them for being output to the debugger
179: (see the function `chain_type').
180: Decls in the same scope are chained together to record the contents
181: of the scope.
182: Statement nodes for successive statements used to be chained together.
183: Often lists of things are represented by TREE_LIST nodes that
184: are chained together. */
185:
186: #define TREE_CHAIN(NODE) ((NODE)->common.chain)
187:
188: /* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs
189: that don't change the machine mode. */
190:
191: #define STRIP_NOPS(EXP) \
192: while ((TREE_CODE (EXP) == NOP_EXPR \
193: || TREE_CODE (EXP) == CONVERT_EXPR \
194: || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
195: && (TYPE_MODE (TREE_TYPE (EXP)) \
196: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
197: (EXP) = TREE_OPERAND (EXP, 0);
1.1.1.4 root 198:
199: /* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
200:
201: #define STRIP_TYPE_NOPS(EXP) \
202: while ((TREE_CODE (EXP) == NOP_EXPR \
203: || TREE_CODE (EXP) == CONVERT_EXPR \
204: || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
205: && (TREE_TYPE (EXP) \
206: == TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
207: (EXP) = TREE_OPERAND (EXP, 0);
1.1.1.5 ! root 208:
! 209: /* Nonzero if TYPE represents an integral type. Note that we do not
! 210: include COMPLEX types here. */
! 211:
! 212: #define INTEGRAL_TYPE_P(TYPE) \
! 213: (TREE_CODE (TYPE) == INTEGER_TYPE || TREE_CODE (TYPE) == ENUMERAL_TYPE \
! 214: || TREE_CODE (TYPE) == BOOLEAN_TYPE || TREE_CODE (TYPE) == CHAR_TYPE)
! 215:
! 216: /* Nonzero if TYPE represents a floating-point type, including complex
! 217: floating-point types. */
! 218:
! 219: #define FLOAT_TYPE_P(TYPE) \
! 220: (TREE_CODE (TYPE) == REAL_TYPE \
! 221: || (TREE_CODE (TYPE) == COMPLEX_TYPE \
! 222: && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE))
1.1 root 223:
224: /* Define many boolean fields that all tree nodes have. */
225:
226: /* In VAR_DECL nodes, nonzero means address of this is needed.
227: So it cannot be in a register.
228: In a FUNCTION_DECL, nonzero means its address is needed.
229: So it must be compiled even if it is an inline function.
230: In CONSTRUCTOR nodes, it means object constructed must be in memory.
231: In LABEL_DECL nodes, it means a goto for this label has been seen
232: from a place outside all binding contours that restore stack levels.
233: In ..._TYPE nodes, it means that objects of this type must
234: be fully addressable. This means that pieces of this
235: object cannot go into register parameters, for example.
236: In IDENTIFIER_NODEs, this means that some extern decl for this name
237: had its address taken. That matters for inline functions. */
238: #define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag)
239:
240: /* In a VAR_DECL, nonzero means allocate static storage.
1.1.1.4 root 241: In a FUNCTION_DECL, nonzero if function has been defined.
1.1 root 242: In a CONSTRUCTOR, nonzero means allocate static storage. */
243: #define TREE_STATIC(NODE) ((NODE)->common.static_flag)
244:
245: /* In a CONVERT_EXPR or NOP_EXPR, this means the node was made
246: implicitly and should not lead to an "unused value" warning. */
247: #define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag)
248:
1.1.1.4 root 249: /* In an INTEGER_CST, this means there was overflow in folding. */
1.1.1.3 root 250: #define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag)
251:
1.1 root 252: /* Nonzero for a TREE_LIST or TREE_VEC node means that the derivation
253: chain is via a `virtual' declaration. */
254: #define TREE_VIA_VIRTUAL(NODE) ((NODE)->common.static_flag)
255:
256: /* In a VAR_DECL or FUNCTION_DECL,
257: nonzero means name is to be accessible from outside this module.
1.1.1.4 root 258: In an identifier node, nonzero means an external declaration
1.1.1.3 root 259: accessible from outside this module was previously seen
1.1 root 260: for this name in an inner scope. */
261: #define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
262:
263: /* Nonzero for TREE_LIST or TREE_VEC node means that the path to the
264: base class is via a `public' declaration, which preserves public
265: fields from the base class as public. */
266: #define TREE_VIA_PUBLIC(NODE) ((NODE)->common.public_flag)
267:
1.1.1.4 root 268: /* Ditto, for `private' declarations. */
269: #define TREE_VIA_PRIVATE(NODE) ((NODE)->common.private_flag)
270:
271: /* Nonzero for TREE_LIST node means that the path to the
272: base class is via a `protected' declaration, which preserves
273: protected fields from the base class as protected.
274: OVERLOADED. */
275: #define TREE_VIA_PROTECTED(NODE) ((NODE)->common.protected_flag)
276:
1.1 root 277: /* In any expression, nonzero means it has side effects or reevaluation
278: of the whole expression could produce a different value.
279: This is set if any subexpression is a function call, a side effect
280: or a reference to a volatile variable.
281: In a ..._DECL, this is set only if the declaration said `volatile'. */
282: #define TREE_SIDE_EFFECTS(NODE) ((NODE)->common.side_effects_flag)
283:
284: /* Nonzero means this expression is volatile in the C sense:
285: its address should be of type `volatile WHATEVER *'.
286: In other words, the declared item is volatile qualified.
287: This is used in _DECL nodes and _REF nodes.
288:
289: In a ..._TYPE node, means this type is volatile-qualified.
290: But use TYPE_VOLATILE instead of this macro when the node is a type,
291: because eventually we may make that a different bit.
292:
293: If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
294: #define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag)
295:
296: /* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
297: nonzero means it may not be the lhs of an assignment.
298: In a ..._TYPE node, means this type is const-qualified
299: (but the macro TYPE_READONLY should be used instead of this macro
300: when the node is a type). */
301: #define TREE_READONLY(NODE) ((NODE)->common.readonly_flag)
302:
303: /* Value of expression is constant.
304: Always appears in all ..._CST nodes.
305: May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR
306: if the value is constant. */
307: #define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
308:
309: /* Nonzero means permanent node;
310: node will continue to exist for the entire compiler run.
311: Otherwise it will be recycled at the end of the function. */
312: #define TREE_PERMANENT(NODE) ((NODE)->common.permanent_flag)
313:
314: /* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type.
315: In FIELD_DECL nodes, means an unsigned bit field.
316: The same bit is used in functions as DECL_BUILT_IN_NONANSI. */
317: #define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
318:
319: /* Nonzero in a VAR_DECL means assembler code has been written.
320: Nonzero in a FUNCTION_DECL means that the function has been compiled.
321: This is interesting in an inline function, since it might not need
322: to be compiled separately.
1.1.1.5 ! root 323: Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
1.1.1.4 root 324: if the sdb debugging info for the type has been written.
325: In a BLOCK node, nonzero if reorder_blocks has already seen this block. */
1.1 root 326: #define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag)
327:
328: /* Nonzero in a _DECL if the name is used in its scope.
329: Nonzero in an expr node means inhibit warning if value is unused.
330: In IDENTIFIER_NODEs, this means that some extern decl for this name
331: was used. */
332: #define TREE_USED(NODE) ((NODE)->common.used_flag)
333:
334: /* Nonzero for a tree node whose evaluation could result
335: in the raising of an exception. Not implemented yet. */
336: #define TREE_RAISES(NODE) ((NODE)->common.raises_flag)
337:
1.1.1.4 root 338: /* Used in classes in C++. */
1.1 root 339: #define TREE_PRIVATE(NODE) ((NODE)->common.private_flag)
1.1.1.4 root 340: /* Used in classes in C++.
341: In a BLOCK node, this is BLOCK_HANDLER_BLOCK. */
1.1 root 342: #define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)
343:
1.1.1.4 root 344: /* These flags are available for each language front end to use internally. */
1.1 root 345: #define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0)
346: #define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1)
347: #define TREE_LANG_FLAG_2(NODE) ((NODE)->common.lang_flag_2)
348: #define TREE_LANG_FLAG_3(NODE) ((NODE)->common.lang_flag_3)
349: #define TREE_LANG_FLAG_4(NODE) ((NODE)->common.lang_flag_4)
350: #define TREE_LANG_FLAG_5(NODE) ((NODE)->common.lang_flag_5)
351: #define TREE_LANG_FLAG_6(NODE) ((NODE)->common.lang_flag_6)
352:
353: /* Define additional fields and accessors for nodes representing constants. */
354:
1.1.1.4 root 355: /* In an INTEGER_CST node. These two together make a 2-word integer.
356: If the data type is signed, the value is sign-extended to 2 words
1.1 root 357: even though not all of them may really be in use.
1.1.1.4 root 358: In an unsigned constant shorter than 2 words, the extra bits are 0. */
1.1 root 359: #define TREE_INT_CST_LOW(NODE) ((NODE)->int_cst.int_cst_low)
360: #define TREE_INT_CST_HIGH(NODE) ((NODE)->int_cst.int_cst_high)
361:
362: #define INT_CST_LT(A, B) \
363: (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
364: || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
1.1.1.4 root 365: && ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (A) \
366: < (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (B))))
1.1 root 367:
368: #define INT_CST_LT_UNSIGNED(A, B) \
1.1.1.4 root 369: (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
370: < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
371: || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
372: == (unsigned HOST_WIDE_INT ) TREE_INT_CST_HIGH (B)) \
373: && (((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (A) \
374: < (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (B)))))
1.1 root 375:
376: struct tree_int_cst
377: {
378: char common[sizeof (struct tree_common)];
1.1.1.4 root 379: HOST_WIDE_INT int_cst_low;
380: HOST_WIDE_INT int_cst_high;
1.1 root 381: };
382:
383: /* In REAL_CST, STRING_CST, COMPLEX_CST nodes, and CONSTRUCTOR nodes,
384: and generally in all kinds of constants that could
385: be given labels (rather than being immediate). */
386:
387: #define TREE_CST_RTL(NODE) ((NODE)->real_cst.rtl)
388:
389: /* In a REAL_CST node. */
390: /* We can represent a real value as either a `double' or a string.
391: Strings don't allow for any optimization, but they do allow
392: for cross-compilation. */
393:
394: #define TREE_REAL_CST(NODE) ((NODE)->real_cst.real_cst)
395:
396: #include "real.h"
397:
398: struct tree_real_cst
399: {
400: char common[sizeof (struct tree_common)];
401: struct rtx_def *rtl; /* acts as link to register transfer language
402: (rtl) info */
403: REAL_VALUE_TYPE real_cst;
404: };
405:
406: /* In a STRING_CST */
407: #define TREE_STRING_LENGTH(NODE) ((NODE)->string.length)
408: #define TREE_STRING_POINTER(NODE) ((NODE)->string.pointer)
409:
410: struct tree_string
411: {
412: char common[sizeof (struct tree_common)];
413: struct rtx_def *rtl; /* acts as link to register transfer language
414: (rtl) info */
415: int length;
416: char *pointer;
417: };
418:
419: /* In a COMPLEX_CST node. */
420: #define TREE_REALPART(NODE) ((NODE)->complex.real)
421: #define TREE_IMAGPART(NODE) ((NODE)->complex.imag)
422:
423: struct tree_complex
424: {
425: char common[sizeof (struct tree_common)];
426: struct rtx_def *rtl; /* acts as link to register transfer language
427: (rtl) info */
428: union tree_node *real;
429: union tree_node *imag;
430: };
431:
432: /* Define fields and accessors for some special-purpose tree nodes. */
433:
434: #define IDENTIFIER_LENGTH(NODE) ((NODE)->identifier.length)
435: #define IDENTIFIER_POINTER(NODE) ((NODE)->identifier.pointer)
436:
437: struct tree_identifier
438: {
439: char common[sizeof (struct tree_common)];
440: int length;
441: char *pointer;
442: };
443:
444: /* In a TREE_LIST node. */
445: #define TREE_PURPOSE(NODE) ((NODE)->list.purpose)
446: #define TREE_VALUE(NODE) ((NODE)->list.value)
447:
448: struct tree_list
449: {
450: char common[sizeof (struct tree_common)];
451: union tree_node *purpose;
452: union tree_node *value;
453: };
454:
455: /* In a TREE_VEC node. */
456: #define TREE_VEC_LENGTH(NODE) ((NODE)->vec.length)
457: #define TREE_VEC_ELT(NODE,I) ((NODE)->vec.a[I])
458: #define TREE_VEC_END(NODE) (&((NODE)->vec.a[(NODE)->vec.length]))
459:
460: struct tree_vec
461: {
462: char common[sizeof (struct tree_common)];
463: int length;
464: union tree_node *a[1];
465: };
466:
467: /* Define fields and accessors for some nodes that represent expressions. */
468:
469: /* In a SAVE_EXPR node. */
470: #define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND(NODE, 1)
471: #define SAVE_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[2])
472:
473: /* In a RTL_EXPR node. */
474: #define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[0])
475: #define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[1])
476:
477: /* In a CALL_EXPR node. */
478: #define CALL_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[2])
479:
480: /* In a CONSTRUCTOR node. */
481: #define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1)
482:
1.1.1.4 root 483: /* In ordinary expression nodes. */
484: #define TREE_OPERAND(NODE, I) ((NODE)->exp.operands[I])
485: #define TREE_COMPLEXITY(NODE) ((NODE)->exp.complexity)
486:
487: struct tree_exp
488: {
489: char common[sizeof (struct tree_common)];
490: int complexity;
491: union tree_node *operands[1];
492: };
493:
1.1 root 494: /* In a BLOCK node. */
1.1.1.4 root 495: #define BLOCK_VARS(NODE) ((NODE)->block.vars)
496: #define BLOCK_TYPE_TAGS(NODE) ((NODE)->block.type_tags)
497: #define BLOCK_SUBBLOCKS(NODE) ((NODE)->block.subblocks)
498: #define BLOCK_SUPERCONTEXT(NODE) ((NODE)->block.supercontext)
1.1 root 499: /* Note: when changing this, make sure to find the places
500: that use chainon or nreverse. */
501: #define BLOCK_CHAIN(NODE) TREE_CHAIN (NODE)
1.1.1.4 root 502: #define BLOCK_ABSTRACT_ORIGIN(NODE) ((NODE)->block.abstract_origin)
503: #define BLOCK_ABSTRACT(NODE) ((NODE)->block.abstract_flag)
504: #define BLOCK_END_NOTE(NODE) ((NODE)->block.end_note)
1.1 root 505:
506: /* Nonzero means that this block is prepared to handle exceptions
507: listed in the BLOCK_VARS slot. */
1.1.1.4 root 508: #define BLOCK_HANDLER_BLOCK(NODE) ((NODE)->block.handler_block_flag)
1.1 root 509:
1.1.1.4 root 510: struct tree_block
1.1 root 511: {
512: char common[sizeof (struct tree_common)];
1.1.1.4 root 513:
514: unsigned handler_block_flag : 1;
515: unsigned abstract_flag : 1;
516:
517: union tree_node *vars;
518: union tree_node *type_tags;
519: union tree_node *subblocks;
520: union tree_node *supercontext;
521: union tree_node *abstract_origin;
522: struct rtx_def *end_note;
1.1 root 523: };
524:
525: /* Define fields and accessors for nodes representing data types. */
526:
527: /* See tree.def for documentation of the use of these fields.
528: Look at the documentation of the various ..._TYPE tree codes. */
529:
530: #define TYPE_UID(NODE) ((NODE)->type.uid)
531: #define TYPE_SIZE(NODE) ((NODE)->type.size)
532: #define TYPE_MODE(NODE) ((NODE)->type.mode)
533: #define TYPE_VALUES(NODE) ((NODE)->type.values)
534: #define TYPE_DOMAIN(NODE) ((NODE)->type.values)
535: #define TYPE_FIELDS(NODE) ((NODE)->type.values)
536: #define TYPE_METHODS(NODE) ((NODE)->type.maxval)
537: #define TYPE_VFIELD(NODE) ((NODE)->type.minval)
538: #define TYPE_ARG_TYPES(NODE) ((NODE)->type.values)
539: #define TYPE_METHOD_BASETYPE(NODE) ((NODE)->type.maxval)
540: #define TYPE_OFFSET_BASETYPE(NODE) ((NODE)->type.maxval)
541: #define TYPE_POINTER_TO(NODE) ((NODE)->type.pointer_to)
542: #define TYPE_REFERENCE_TO(NODE) ((NODE)->type.reference_to)
543: #define TYPE_MIN_VALUE(NODE) ((NODE)->type.minval)
544: #define TYPE_MAX_VALUE(NODE) ((NODE)->type.maxval)
545: #define TYPE_PRECISION(NODE) ((NODE)->type.precision)
546: #define TYPE_PARSE_INFO(NODE) ((NODE)->type.parse_info)
547: #define TYPE_SYMTAB_ADDRESS(NODE) ((NODE)->type.symtab_address)
548: #define TYPE_NAME(NODE) ((NODE)->type.name)
549: #define TYPE_NEXT_VARIANT(NODE) ((NODE)->type.next_variant)
550: #define TYPE_MAIN_VARIANT(NODE) ((NODE)->type.main_variant)
551: #define TYPE_BINFO(NODE) ((NODE)->type.binfo)
552: #define TYPE_NONCOPIED_PARTS(NODE) ((NODE)->type.noncopied_parts)
553: #define TYPE_CONTEXT(NODE) ((NODE)->type.context)
554: #define TYPE_LANG_SPECIFIC(NODE) ((NODE)->type.lang_specific)
555:
1.1.1.3 root 556: /* The alignment necessary for objects of this type.
557: The value is an int, measured in bits. */
558: #define TYPE_ALIGN(NODE) ((NODE)->type.align)
559:
1.1 root 560: #define TYPE_STUB_DECL(NODE) (TREE_CHAIN (NODE))
561:
1.1.1.5 ! root 562: /* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
! 563: has BLKmode only because it lacks the alignment requirement for
! 564: its size. */
1.1 root 565: #define TYPE_NO_FORCE_BLK(NODE) ((NODE)->type.no_force_blk_flag)
566:
567: /* Nonzero in a type considered volatile as a whole. */
568: #define TYPE_VOLATILE(NODE) ((NODE)->common.volatile_flag)
569:
570: /* Means this type is const-qualified. */
571: #define TYPE_READONLY(NODE) ((NODE)->common.readonly_flag)
572:
1.1.1.4 root 573: /* These flags are available for each language front end to use internally. */
1.1 root 574: #define TYPE_LANG_FLAG_0(NODE) ((NODE)->type.lang_flag_0)
575: #define TYPE_LANG_FLAG_1(NODE) ((NODE)->type.lang_flag_1)
576: #define TYPE_LANG_FLAG_2(NODE) ((NODE)->type.lang_flag_2)
577: #define TYPE_LANG_FLAG_3(NODE) ((NODE)->type.lang_flag_3)
578: #define TYPE_LANG_FLAG_4(NODE) ((NODE)->type.lang_flag_4)
579: #define TYPE_LANG_FLAG_5(NODE) ((NODE)->type.lang_flag_5)
580: #define TYPE_LANG_FLAG_6(NODE) ((NODE)->type.lang_flag_6)
581:
582: struct tree_type
583: {
584: char common[sizeof (struct tree_common)];
585: union tree_node *values;
586: union tree_node *size;
587: unsigned uid;
588:
589: #ifdef ONLY_INT_FIELDS
590: int mode : 8;
591: #else
592: enum machine_mode mode : 8;
593: #endif
594: unsigned char precision;
595:
596: unsigned no_force_blk_flag : 1;
597: unsigned lang_flag_0 : 1;
598: unsigned lang_flag_1 : 1;
599: unsigned lang_flag_2 : 1;
600: unsigned lang_flag_3 : 1;
601: unsigned lang_flag_4 : 1;
602: unsigned lang_flag_5 : 1;
603: unsigned lang_flag_6 : 1;
604:
1.1.1.4 root 605: unsigned int align;
1.1 root 606: union tree_node *pointer_to;
607: union tree_node *reference_to;
608: int parse_info;
609: int symtab_address;
610: union tree_node *name;
611: union tree_node *minval;
612: union tree_node *maxval;
613: union tree_node *next_variant;
614: union tree_node *main_variant;
615: union tree_node *binfo;
616: union tree_node *noncopied_parts;
617: union tree_node *context;
618: /* Points to a structure whose details depend on the language in use. */
619: struct lang_type *lang_specific;
620: };
621:
622: /* Define accessor macros for information about type inheritance
623: and basetypes.
624:
625: A "basetype" means a particular usage of a data type for inheritance
626: in another type. Each such basetype usage has its own "binfo"
627: object to describe it. The binfo object is a TREE_VEC node.
628:
629: Inheritance is represented by the binfo nodes allocated for a
630: given type. For example, given types C and D, such that D is
631: inherited by C, 3 binfo nodes will be allocated: one for describing
632: the binfo properties of C, similarly one for D, and one for
633: describing the binfo properties of D as a base type for C.
634: Thus, given a pointer to class C, one can get a pointer to the binfo
635: of D acting as a basetype for C by looking at C's binfo's basetypes. */
636:
637: /* The actual data type node being inherited in this basetype. */
638: #define BINFO_TYPE(NODE) TREE_TYPE (NODE)
639:
640: /* The offset where this basetype appears in its containing type.
641: BINFO_OFFSET slot holds the offset (in bytes)
642: from the base of the complete object to the base of the part of the
643: object that is allocated on behalf of this `type'.
644: This is always 0 except when there is multiple inheritance. */
645:
646: #define BINFO_OFFSET(NODE) TREE_VEC_ELT ((NODE), 1)
647: #define TYPE_BINFO_OFFSET(NODE) BINFO_OFFSET (TYPE_BINFO (NODE))
648: #define BINFO_OFFSET_ZEROP(NODE) (BINFO_OFFSET (NODE) == integer_zero_node)
649:
650: /* The virtual function table belonging to this basetype. Virtual
651: function tables provide a mechanism for run-time method dispatching.
652: The entries of a virtual function table are language-dependent. */
653:
654: #define BINFO_VTABLE(NODE) TREE_VEC_ELT ((NODE), 2)
655: #define TYPE_BINFO_VTABLE(NODE) BINFO_VTABLE (TYPE_BINFO (NODE))
656:
657: /* The virtual functions in the virtual function table. This is
658: a TREE_LIST that is used as an initial approximation for building
659: a virtual function table for this basetype. */
660: #define BINFO_VIRTUALS(NODE) TREE_VEC_ELT ((NODE), 3)
661: #define TYPE_BINFO_VIRTUALS(NODE) BINFO_VIRTUALS (TYPE_BINFO (NODE))
662:
663: /* A vector of additional binfos for the types inherited by this basetype.
664:
665: If this basetype describes type D as inherited in C,
666: and if the basetypes of D are E anf F,
667: then this vector contains binfos for inheritance of E and F by C.
668:
669: ??? This could probably be done by just allocating the
670: base types at the end of this TREE_VEC (instead of using
671: another TREE_VEC). This would simplify the calculation
672: of how many basetypes a given type had. */
673: #define BINFO_BASETYPES(NODE) TREE_VEC_ELT ((NODE), 4)
674: #define TYPE_BINFO_BASETYPES(NODE) TREE_VEC_ELT (TYPE_BINFO (NODE), 4)
675:
1.1.1.4 root 676: /* For a BINFO record describing an inheritance, this yields a pointer
677: to the artificial FIELD_DECL node which contains the "virtual base
678: class pointer" for the given inheritance. */
679:
680: #define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT ((NODE), 5)
681:
1.1 root 682: /* Accessor macro to get to the Nth basetype of this basetype. */
683: #define BINFO_BASETYPE(NODE,N) TREE_VEC_ELT (BINFO_BASETYPES (NODE), (N))
684: #define TYPE_BINFO_BASETYPE(NODE,N) BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N)))
685:
686: /* Slot used to build a chain that represents a use of inheritance.
687: For example, if X is derived from Y, and Y is derived from Z,
688: then this field can be used to link the binfo node for X to
689: the binfo node for X's Y to represent the use of inheritance
690: from X to Y. Similarly, this slot of the binfo node for X's Y
691: can point to the Z from which Y is inherited (in X's inheritance
692: hierarchy). In this fashion, one can represent and traverse specific
693: uses of inheritance using the binfo nodes themselves (instead of
694: consing new space pointing to binfo nodes).
695: It is up to the language-dependent front-ends to maintain
696: this information as necessary. */
697: #define BINFO_INHERITANCE_CHAIN(NODE) TREE_VEC_ELT ((NODE), 0)
698:
699: /* Define fields and accessors for nodes representing declared names. */
700:
701: /* This is the name of the object as written by the user.
702: It is an IDENTIFIER_NODE. */
703: #define DECL_NAME(NODE) ((NODE)->decl.name)
704: /* This macro is marked for death. */
705: #define DECL_PRINT_NAME(NODE) ((NODE)->decl.print_name)
706: /* This is the name of the object as the assembler will see it
707: (but before any translations made by ASM_OUTPUT_LABELREF).
708: Often this is the same as DECL_NAME.
709: It is an IDENTIFIER_NODE. */
710: #define DECL_ASSEMBLER_NAME(NODE) ((NODE)->decl.assembler_name)
1.1.1.4 root 711: /* For FIELD_DECLs, this is the
1.1.1.5 ! root 712: RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field is
! 713: a member of. For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL,
! 714: and CONST_DECL nodes, this points to the FUNCTION_DECL for the
! 715: containing function, or else yields NULL_TREE if the given decl has "file scope". */
1.1 root 716: #define DECL_CONTEXT(NODE) ((NODE)->decl.context)
717: #define DECL_FIELD_CONTEXT(NODE) ((NODE)->decl.context)
718: /* In a FIELD_DECL, this is the field position, counting in bits,
719: of the bit closest to the beginning of the structure. */
720: #define DECL_FIELD_BITPOS(NODE) ((NODE)->decl.arguments)
721: /* In a FIELD_DECL, this indicates whether the field was a bit-field and
1.1.1.3 root 722: if so, the type that was originally specified for it.
723: TREE_TYPE may have been modified (in finish_struct). */
1.1 root 724: #define DECL_BIT_FIELD_TYPE(NODE) ((NODE)->decl.result)
725: /* In FUNCTION_DECL, a chain of ..._DECL nodes. */
726: /* VAR_DECL and PARM_DECL reserve the arguments slot
727: for language-specific uses. */
728: #define DECL_ARGUMENTS(NODE) ((NODE)->decl.arguments)
729: /* In FUNCTION_DECL, holds the decl for the return value. */
730: #define DECL_RESULT(NODE) ((NODE)->decl.result)
731: /* In PARM_DECL, holds the type as written (perhaps a function or array). */
732: #define DECL_ARG_TYPE_AS_WRITTEN(NODE) ((NODE)->decl.result)
733: /* For a FUNCTION_DECL, holds the tree of BINDINGs.
734: For a VAR_DECL, holds the initial value.
735: For a PARM_DECL, not used--default
736: values for parameters are encoded in the type of the function,
737: not in the PARM_DECL slot. */
738: #define DECL_INITIAL(NODE) ((NODE)->decl.initial)
739: /* For a PARM_DECL, records the data type used to pass the argument,
740: which may be different from the type seen in the program. */
741: #define DECL_ARG_TYPE(NODE) ((NODE)->decl.initial) /* In PARM_DECL. */
1.1.1.5 ! root 742: /* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
! 743: if nonzero, indicates that the field occupies the type. */
! 744: #define DECL_QUALIFIER(NODE) ((NODE)->decl.initial)
1.1 root 745: /* These two fields describe where in the source code the declaration was. */
746: #define DECL_SOURCE_FILE(NODE) ((NODE)->decl.filename)
747: #define DECL_SOURCE_LINE(NODE) ((NODE)->decl.linenum)
748: /* Holds the size of the datum, as a tree expression.
749: Need not be constant. */
750: #define DECL_SIZE(NODE) ((NODE)->decl.size)
751: /* Holds the alignment required for the datum. */
1.1.1.3 root 752: #define DECL_ALIGN(NODE) ((NODE)->decl.frame_size)
1.1.1.4 root 753: /* Holds the machine mode corresponding to the declaration of a variable or
754: field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
755: FIELD_DECL. */
1.1 root 756: #define DECL_MODE(NODE) ((NODE)->decl.mode)
1.1.1.4 root 757: /* Holds the RTL expression for the value of a variable or function. If
758: PROMOTED_MODE is defined, the mode of this expression may not be same
759: as DECL_MODE. In that case, DECL_MODE contains the mode corresponding
760: to the variable's data type, while the mode
761: of DECL_RTL is the mode actually used to contain the data. */
1.1 root 762: #define DECL_RTL(NODE) ((NODE)->decl.rtl)
763: /* For PARM_DECL, holds an RTL for the stack slot or register
764: where the data was actually passed. */
1.1.1.3 root 765: #define DECL_INCOMING_RTL(NODE) ((NODE)->decl.saved_insns.r)
1.1 root 766: /* For FUNCTION_DECL, if it is inline, holds the saved insn chain. */
1.1.1.3 root 767: #define DECL_SAVED_INSNS(NODE) ((NODE)->decl.saved_insns.r)
1.1.1.4 root 768: /* For FUNCTION_DECL, if it is inline,
769: holds the size of the stack frame, as an integer. */
770: #define DECL_FRAME_SIZE(NODE) ((NODE)->decl.frame_size)
771: /* For FUNCTION_DECL, if it is built-in,
772: this identifies which built-in operation it is. */
1.1 root 773: #define DECL_FUNCTION_CODE(NODE) \
774: ((enum built_in_function) (NODE)->decl.frame_size)
775: #define DECL_SET_FUNCTION_CODE(NODE,VAL) \
776: ((NODE)->decl.frame_size = (int) (VAL))
1.1.1.3 root 777: /* For a FIELD_DECL, holds the size of the member as an integer. */
778: #define DECL_FIELD_SIZE(NODE) ((NODE)->decl.saved_insns.i)
1.1 root 779:
780: /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
781: Before the struct containing the FUNCTION_DECL is laid out,
782: DECL_VINDEX may point to a FUNCTION_DECL in a base class which
783: is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
784: function. When the class is laid out, this pointer is changed
785: to an INTEGER_CST node which is suitable for use as an index
786: into the virtual function table. */
787: #define DECL_VINDEX(NODE) ((NODE)->decl.vindex)
788: /* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
789: which this FIELD_DECL is defined. This information is needed when
790: writing debugging information about vfield and vbase decls for C++. */
791: #define DECL_FCONTEXT(NODE) ((NODE)->decl.vindex)
792:
1.1.1.4 root 793: /* Every ..._DECL node gets a unique number. */
794: #define DECL_UID(NODE) ((NODE)->decl.uid)
795:
796: /* For any sort of a ..._DECL node, this points to the original (abstract)
797: decl node which this decl is an instance of, or else it is NULL indicating
798: that this decl is not an instance of some other decl. */
799: #define DECL_ABSTRACT_ORIGIN(NODE) ((NODE)->decl.abstract_origin)
800:
801: /* Nonzero for any sort of ..._DECL node means this decl node represents
802: an inline instance of some original (abstract) decl from an inline function;
1.1 root 803: suppress any warnings about shadowing some other variable. */
1.1.1.4 root 804: #define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != (tree) 0)
1.1 root 805:
806: /* Nonzero if a _DECL means that the name of this decl should be ignored
807: for symbolic debug purposes. */
808: #define DECL_IGNORED_P(NODE) ((NODE)->decl.ignored_flag)
809:
1.1.1.4 root 810: /* Nonzero for a given ..._DECL node means that this node represents an
811: "abstract instance" of the given declaration (e.g. in the original
812: declaration of an inline function). When generating symbolic debugging
813: information, we musn't try to generate any address information for nodes
814: marked as "abstract instances" because we don't actually generate
815: any code or allocate any data space for such instances. */
816: #define DECL_ABSTRACT(NODE) ((NODE)->decl.abstract_flag)
817:
818: /* Nonzero if a _DECL means that no warnings should be generated just
819: because this decl is unused. */
820: #define DECL_IN_SYSTEM_HEADER(NODE) ((NODE)->decl.in_system_header_flag)
821:
822: /* Language-specific decl information. */
1.1 root 823: #define DECL_LANG_SPECIFIC(NODE) ((NODE)->decl.lang_specific)
824:
825: /* In a VAR_DECL or FUNCTION_DECL,
826: nonzero means external reference:
827: do not allocate storage, and refer to a definition elsewhere. */
1.1.1.4 root 828: #define DECL_EXTERNAL(NODE) ((NODE)->decl.external_flag)
1.1 root 829:
830: /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.
831: In LABEL_DECL nodes, nonzero means that an error message about
832: jumping into such a binding contour has been printed for this label. */
1.1.1.4 root 833: #define DECL_REGISTER(NODE) ((NODE)->decl.regdecl_flag)
834: /* In a FIELD_DECL, indicates this field should be bit-packed. */
835: #define DECL_PACKED(NODE) ((NODE)->decl.regdecl_flag)
1.1 root 836:
837: /* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
838: For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
839:
840: For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
841:
842: Also set in some languages for variables, etc., outside the normal
843: lexical scope, such as class instance variables. */
1.1.1.4 root 844: #define DECL_NONLOCAL(NODE) ((NODE)->decl.nonlocal_flag)
1.1 root 845:
846: /* Nonzero in a FUNCTION_DECL means this function can be substituted
847: where it is called. */
1.1.1.4 root 848: #define DECL_INLINE(NODE) ((NODE)->decl.inline_flag)
1.1 root 849:
850: /* Nonzero in a FUNCTION_DECL means this is a built-in function
851: that is not specified by ansi C and that users are supposed to be allowed
852: to redefine for any purpose whatever. */
853: #define DECL_BUILT_IN_NONANSI(NODE) ((NODE)->common.unsigned_flag)
854:
855: /* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
856: specially. */
857: #define DECL_BIT_FIELD(NODE) ((NODE)->decl.bit_field_flag)
858: /* In a LABEL_DECL, nonzero means label was defined inside a binding
859: contour that restored a stack level and which is now exited. */
860: #define DECL_TOO_LATE(NODE) ((NODE)->decl.bit_field_flag)
861: /* In a FUNCTION_DECL, nonzero means a built in function. */
862: #define DECL_BUILT_IN(NODE) ((NODE)->decl.bit_field_flag)
863:
1.1.1.4 root 864: /* Used in VAR_DECLs to indicate that the variable is a vtable.
865: It is also used in FIELD_DECLs for vtable pointers. */
1.1 root 866: #define DECL_VIRTUAL_P(NODE) ((NODE)->decl.virtual_flag)
867:
868: /* Additional flags for language-specific uses. */
869: #define DECL_LANG_FLAG_0(NODE) ((NODE)->decl.lang_flag_0)
870: #define DECL_LANG_FLAG_1(NODE) ((NODE)->decl.lang_flag_1)
871: #define DECL_LANG_FLAG_2(NODE) ((NODE)->decl.lang_flag_2)
872: #define DECL_LANG_FLAG_3(NODE) ((NODE)->decl.lang_flag_3)
873: #define DECL_LANG_FLAG_4(NODE) ((NODE)->decl.lang_flag_4)
874: #define DECL_LANG_FLAG_5(NODE) ((NODE)->decl.lang_flag_5)
875: #define DECL_LANG_FLAG_6(NODE) ((NODE)->decl.lang_flag_6)
876: #define DECL_LANG_FLAG_7(NODE) ((NODE)->decl.lang_flag_7)
877:
878: struct tree_decl
879: {
880: char common[sizeof (struct tree_common)];
881: char *filename;
882: int linenum;
883: union tree_node *size;
1.1.1.4 root 884: unsigned int uid;
1.1 root 885: #ifdef ONLY_INT_FIELDS
886: int mode : 8;
887: #else
888: enum machine_mode mode : 8;
889: #endif
890:
891: unsigned external_flag : 1;
892: unsigned nonlocal_flag : 1;
893: unsigned regdecl_flag : 1;
894: unsigned inline_flag : 1;
895: unsigned bit_field_flag : 1;
896: unsigned virtual_flag : 1;
897: unsigned ignored_flag : 1;
1.1.1.4 root 898: unsigned abstract_flag : 1;
899:
900: unsigned in_system_header_flag : 1;
901: /* room for seven more */
1.1 root 902:
903: unsigned lang_flag_0 : 1;
904: unsigned lang_flag_1 : 1;
905: unsigned lang_flag_2 : 1;
906: unsigned lang_flag_3 : 1;
907: unsigned lang_flag_4 : 1;
908: unsigned lang_flag_5 : 1;
909: unsigned lang_flag_6 : 1;
910: unsigned lang_flag_7 : 1;
911:
912: union tree_node *name;
913: union tree_node *context;
914: union tree_node *arguments;
915: union tree_node *result;
916: union tree_node *initial;
1.1.1.4 root 917: union tree_node *abstract_origin;
1.1 root 918: /* The PRINT_NAME field is marked for death. */
919: char *print_name;
920: union tree_node *assembler_name;
921: struct rtx_def *rtl; /* acts as link to register transfer language
922: (rtl) info */
1.1.1.3 root 923: /* For a FUNCTION_DECL, if inline, this is the size of frame needed.
1.1.1.4 root 924: If built-in, this is the code for which built-in function.
925: For other kinds of decls, this is DECL_ALIGN. */
1.1.1.3 root 926: int frame_size;
927: /* For FUNCTION_DECLs: points to insn that constitutes its definition
928: on the permanent obstack. For any other kind of decl, this is the
929: alignment. */
930: union {
931: struct rtx_def *r;
932: int i;
933: } saved_insns;
1.1 root 934: union tree_node *vindex;
935: /* Points to a structure whose details depend on the language in use. */
936: struct lang_decl *lang_specific;
937: };
938:
939: /* Define the overall contents of a tree node.
940: It may be any of the structures declared above
941: for various types of node. */
942:
943: union tree_node
944: {
945: struct tree_common common;
946: struct tree_int_cst int_cst;
947: struct tree_real_cst real_cst;
948: struct tree_string string;
949: struct tree_complex complex;
950: struct tree_identifier identifier;
951: struct tree_decl decl;
952: struct tree_type type;
953: struct tree_list list;
954: struct tree_vec vec;
955: struct tree_exp exp;
1.1.1.4 root 956: struct tree_block block;
1.1 root 957: };
958:
1.1.1.4 root 959: /* Add prototype support. */
960: #ifndef PROTO
961: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
962: #define PROTO(ARGS) ARGS
963: #else
964: #define PROTO(ARGS) ()
965: #endif
966: #endif
967:
968:
969: #define NULL_TREE (tree) NULL
970:
971: /* Define a generic NULL if one hasn't already been defined. */
972:
973: #ifndef NULL
974: #define NULL 0
975: #endif
976:
977: #ifndef GENERIC_PTR
978: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
979: #define GENERIC_PTR void *
980: #else
981: #define GENERIC_PTR char *
982: #endif
983: #endif
984:
985: #ifndef NULL_PTR
986: #define NULL_PTR ((GENERIC_PTR)0)
987: #endif
988:
1.1 root 989: /* Format for global names of constructor and destructor functions. */
1.1.1.4 root 990: #ifndef CONSTRUCTOR_NAME_FORMAT /* Some machines need to override this. */
1.1 root 991: #ifndef NO_DOLLAR_IN_LABEL
992: #define CONSTRUCTOR_NAME_FORMAT "_GLOBAL_$I$%s"
993: #else
1.1.1.5 ! root 994: #ifdef NO_DOT_IN_LABEL
! 995: #define CONSTRUCTOR_NAME_FORMAT "____GLOBAL__I_%s"
! 996: #else
1.1 root 997: #define CONSTRUCTOR_NAME_FORMAT "_GLOBAL_.I.%s"
998: #endif
1.1.1.4 root 999: #endif
1.1.1.5 ! root 1000: #endif
1.1 root 1001:
1.1.1.4 root 1002: /* The following functions accept a wide integer argument. Rather than
1003: having to cast on every function call, we use a macro instead, that is
1004: defined here and in rtl.h. */
1005:
1006: #ifndef exact_log2
1007: #define exact_log2(N) exact_log2_wide ((HOST_WIDE_INT) (N))
1008: #define floor_log2(N) floor_log2_wide ((HOST_WIDE_INT) (N))
1009: #endif
1010:
1011: #if 0
1012: /* At present, don't prototype xrealloc, since all of the callers don't
1013: cast their pointers to char *, and all of the xrealloc's don't use
1014: void * yet. */
1.1.1.5 ! root 1015: extern char *xmalloc PROTO((size_t));
! 1016: extern char *xrealloc PROTO((void *, size_t));
1.1.1.4 root 1017: #else
1.1.1.5 ! root 1018: extern char *xmalloc ();
1.1.1.4 root 1019: extern char *xrealloc ();
1020: #endif
1021:
1022: extern char *oballoc PROTO((int));
1023: extern char *permalloc PROTO((int));
1024: extern char *savealloc PROTO((int));
1025: extern void free PROTO((void *));
1.1 root 1026:
1027: /* Lowest level primitive for allocating a node.
1028: The TREE_CODE is the only argument. Contents are initialized
1029: to zero except for a few of the common fields. */
1030:
1.1.1.4 root 1031: extern tree make_node PROTO((enum tree_code));
1.1 root 1032:
1033: /* Make a copy of a node, with all the same contents except
1034: for TREE_PERMANENT. (The copy is permanent
1035: iff nodes being made now are permanent.) */
1036:
1.1.1.4 root 1037: extern tree copy_node PROTO((tree));
1.1 root 1038:
1039: /* Make a copy of a chain of TREE_LIST nodes. */
1040:
1.1.1.4 root 1041: extern tree copy_list PROTO((tree));
1.1 root 1042:
1043: /* Make a TREE_VEC. */
1044:
1.1.1.4 root 1045: extern tree make_tree_vec PROTO((int));
1.1 root 1046:
1047: /* Return the (unique) IDENTIFIER_NODE node for a given name.
1048: The name is supplied as a char *. */
1049:
1.1.1.4 root 1050: extern tree get_identifier PROTO((char *));
1.1 root 1051:
1052: /* Construct various types of nodes. */
1053:
1.1.1.4 root 1054: #define build_int_2(LO,HI) \
1055: build_int_2_wide ((HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))
1.1 root 1056:
1.1.1.4 root 1057: #if 0
1058: /* We cannot define prototypes for the variable argument functions,
1059: since they have not been ANSI-fied, and an ANSI compiler would
1060: complain when compiling the definition of these functions. */
1061:
1062: extern tree build PROTO((enum tree_code, tree, ...));
1063: extern tree build_nt PROTO((enum tree_code, ...));
1064: extern tree build_parse_node PROTO((enum tree_code, ...));
1065: #else
1066: extern tree build ();
1067: extern tree build_nt ();
1068: extern tree build_parse_node ();
1069: #endif
1070:
1071: extern tree build_int_2_wide PROTO((HOST_WIDE_INT, HOST_WIDE_INT));
1072: extern tree build_real PROTO((tree, REAL_VALUE_TYPE));
1073: extern tree build_real_from_int_cst PROTO((tree, tree));
1074: extern tree build_complex PROTO((tree, tree));
1075: extern tree build_string PROTO((int, char *));
1076: extern tree build1 PROTO((enum tree_code, tree, tree));
1077: extern tree build_tree_list PROTO((tree, tree));
1078: extern tree build_decl_list PROTO((tree, tree));
1079: extern tree build_decl PROTO((enum tree_code, tree, tree));
1080: extern tree build_block PROTO((tree, tree, tree, tree, tree));
1.1 root 1081:
1.1.1.4 root 1082: /* Construct various nodes representing data types. */
1.1 root 1083:
1.1.1.4 root 1084: extern tree make_signed_type PROTO((int));
1085: extern tree make_unsigned_type PROTO((int));
1086: extern tree signed_or_unsigned_type PROTO((int, tree));
1087: extern void fixup_unsigned_type PROTO((tree));
1088: extern tree build_pointer_type PROTO((tree));
1089: extern tree build_reference_type PROTO((tree));
1090: extern tree build_index_type PROTO((tree));
1091: extern tree build_index_2_type PROTO((tree, tree));
1092: extern tree build_array_type PROTO((tree, tree));
1093: extern tree build_function_type PROTO((tree, tree));
1094: extern tree build_method_type PROTO((tree, tree));
1095: extern tree build_offset_type PROTO((tree, tree));
1096: extern tree build_complex_type PROTO((tree));
1097: extern tree array_type_nelts PROTO((tree));
1098:
1.1.1.5 ! root 1099: extern tree value_member PROTO((tree, tree));
! 1100: extern tree purpose_member PROTO((tree, tree));
! 1101: extern tree binfo_member PROTO((tree, tree));
! 1102: extern int tree_int_cst_equal PROTO((tree, tree));
! 1103: extern int tree_int_cst_lt PROTO((tree, tree));
! 1104: extern int index_type_equal PROTO((tree, tree));
1.1.1.4 root 1105:
1106: /* From expmed.c. Since rtl.h is included after tree.h, we can't
1107: put the prototype here. Rtl.h does declare the prototype if
1108: tree.h had been included. */
1109:
1110: extern tree make_tree ();
1.1 root 1111:
1112: /* Given a type node TYPE, and CONSTP and VOLATILEP, return a type
1113: for the same kind of data as TYPE describes.
1114: Variants point to the "main variant" (which has neither CONST nor VOLATILE)
1115: via TYPE_MAIN_VARIANT, and it points to a chain of other variants
1116: so that duplicate variants are never made.
1117: Only main variants should ever appear as types of expressions. */
1118:
1.1.1.4 root 1119: extern tree build_type_variant PROTO((tree, int, int));
1.1 root 1120:
1.1.1.2 root 1121: /* Make a copy of a type node. */
1.1 root 1122:
1.1.1.4 root 1123: extern tree build_type_copy PROTO((tree));
1.1 root 1124:
1125: /* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
1126: TYPE_ALIGN and TYPE_MODE fields.
1127: If called more than once on one node, does nothing except
1128: for the first time. */
1129:
1.1.1.4 root 1130: extern void layout_type PROTO((tree));
1.1 root 1131:
1132: /* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
1133: return a canonicalized ..._TYPE node, so that duplicates are not made.
1134: How the hash code is computed is up to the caller, as long as any two
1135: callers that could hash identical-looking type nodes agree. */
1136:
1.1.1.4 root 1137: extern tree type_hash_canon PROTO((int, tree));
1.1 root 1138:
1139: /* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
1140: calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
1141: fields. Call this only once for any given decl node.
1142:
1143: Second argument is the boundary that this field can be assumed to
1144: be starting at (in bits). Zero means it can be assumed aligned
1145: on any boundary that may be needed. */
1146:
1.1.1.4 root 1147: extern void layout_decl PROTO((tree, unsigned));
1.1 root 1148:
1149: /* Fold constants as much as possible in an expression.
1150: Returns the simplified expression.
1151: Acts only on the top level of the expression;
1152: if the argument itself cannot be simplified, its
1153: subexpressions are not changed. */
1154:
1.1.1.4 root 1155: extern tree fold PROTO((tree));
1.1 root 1156:
1157: /* Return an expr equal to X but certainly not valid as an lvalue. */
1158:
1.1.1.4 root 1159: extern tree non_lvalue PROTO((tree));
1.1 root 1160:
1.1.1.4 root 1161: extern tree convert PROTO((tree, tree));
1162: extern tree size_in_bytes PROTO((tree));
1163: extern int int_size_in_bytes PROTO((tree));
1164: extern tree size_binop PROTO((enum tree_code, tree, tree));
1165: extern tree size_int PROTO((unsigned));
1166: extern tree round_up PROTO((tree, int));
1167: extern tree get_pending_sizes PROTO((void));
1.1 root 1168:
1169: /* Type for sizes of data-type. */
1170:
1171: extern tree sizetype;
1172:
1173: /* Concatenate two lists (chains of TREE_LIST nodes) X and Y
1174: by making the last node in X point to Y.
1175: Returns X, except if X is 0 returns Y. */
1176:
1.1.1.4 root 1177: extern tree chainon PROTO((tree, tree));
1.1 root 1178:
1179: /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
1180:
1.1.1.4 root 1181: extern tree tree_cons PROTO((tree, tree, tree));
1182: extern tree perm_tree_cons PROTO((tree, tree, tree));
1183: extern tree temp_tree_cons PROTO((tree, tree, tree));
1184: extern tree saveable_tree_cons PROTO((tree, tree, tree));
1185: extern tree decl_tree_cons PROTO((tree, tree, tree));
1.1 root 1186:
1187: /* Return the last tree node in a chain. */
1188:
1.1.1.4 root 1189: extern tree tree_last PROTO((tree));
1.1 root 1190:
1191: /* Reverse the order of elements in a chain, and return the new head. */
1192:
1.1.1.4 root 1193: extern tree nreverse PROTO((tree));
1.1 root 1194:
1195: /* Returns the length of a chain of nodes
1196: (number of chain pointers to follow before reaching a null pointer). */
1197:
1.1.1.4 root 1198: extern int list_length PROTO((tree));
1.1 root 1199:
1200: /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
1201:
1.1.1.4 root 1202: extern int integer_zerop PROTO((tree));
1.1 root 1203:
1204: /* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */
1205:
1.1.1.4 root 1206: extern int integer_onep PROTO((tree));
1.1 root 1207:
1208: /* integer_all_onesp (tree x) is nonzero if X is an integer constant
1209: all of whose significant bits are 1. */
1210:
1.1.1.4 root 1211: extern int integer_all_onesp PROTO((tree));
1.1 root 1212:
1213: /* integer_pow2p (tree x) is nonzero is X is an integer constant with
1214: exactly one bit 1. */
1215:
1.1.1.4 root 1216: extern int integer_pow2p PROTO((tree));
1.1 root 1217:
1218: /* staticp (tree x) is nonzero if X is a reference to data allocated
1219: at a fixed address in memory. */
1220:
1.1.1.4 root 1221: extern int staticp PROTO((tree));
1.1 root 1222:
1223: /* Gets an error if argument X is not an lvalue.
1224: Also returns 1 if X is an lvalue, 0 if not. */
1225:
1.1.1.4 root 1226: extern int lvalue_or_else PROTO((tree, char *));
1.1 root 1227:
1228: /* save_expr (EXP) returns an expression equivalent to EXP
1229: but it can be used multiple times within context CTX
1230: and only evaluate EXP once. */
1231:
1.1.1.4 root 1232: extern tree save_expr PROTO((tree));
1.1 root 1233:
1.1.1.2 root 1234: /* variable_size (EXP) is like save_expr (EXP) except that it
1235: is for the special case of something that is part of a
1236: variable size for a data type. It makes special arrangements
1237: to compute the value at the right time when the data type
1238: belongs to a function parameter. */
1239:
1.1.1.4 root 1240: extern tree variable_size PROTO((tree));
1.1.1.2 root 1241:
1.1 root 1242: /* stabilize_reference (EXP) returns an reference equivalent to EXP
1243: but it can be used multiple times
1244: and only evaluate the subexpressions once. */
1245:
1.1.1.4 root 1246: extern tree stabilize_reference PROTO((tree));
1.1 root 1247:
1248: /* Return EXP, stripped of any conversions to wider types
1249: in such a way that the result of converting to type FOR_TYPE
1250: is the same as if EXP were converted to FOR_TYPE.
1251: If FOR_TYPE is 0, it signifies EXP's type. */
1252:
1.1.1.4 root 1253: extern tree get_unwidened PROTO((tree, tree));
1.1 root 1254:
1255: /* Return OP or a simpler expression for a narrower value
1256: which can be sign-extended or zero-extended to give back OP.
1257: Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
1258: or 0 if the value should be sign-extended. */
1259:
1.1.1.4 root 1260: extern tree get_narrower PROTO((tree, int *));
1.1 root 1261:
1262: /* Given MODE and UNSIGNEDP, return a suitable type-tree
1263: with that mode.
1264: The definition of this resides in language-specific code
1265: as the repertoire of available types may vary. */
1266:
1.1.1.4 root 1267: extern tree type_for_mode PROTO((enum machine_mode, int));
1.1 root 1268:
1269: /* Given PRECISION and UNSIGNEDP, return a suitable type-tree
1270: for an integer type with at least that precision.
1271: The definition of this resides in language-specific code
1272: as the repertoire of available types may vary. */
1273:
1.1.1.4 root 1274: extern tree type_for_size PROTO((unsigned, int));
1.1 root 1275:
1276: /* Given an integer type T, return a type like T but unsigned.
1277: If T is unsigned, the value is T.
1278: The definition of this resides in language-specific code
1279: as the repertoire of available types may vary. */
1280:
1.1.1.4 root 1281: extern tree unsigned_type PROTO((tree));
1.1 root 1282:
1283: /* Given an integer type T, return a type like T but signed.
1284: If T is signed, the value is T.
1285: The definition of this resides in language-specific code
1286: as the repertoire of available types may vary. */
1287:
1.1.1.4 root 1288: extern tree signed_type PROTO((tree));
1.1 root 1289:
1290: /* This function must be defined in the language-specific files.
1291: expand_expr calls it to build the cleanup-expression for a TARGET_EXPR.
1292: This is defined in a language-specific file. */
1293:
1.1.1.4 root 1294: extern tree maybe_build_cleanup PROTO((tree));
1.1 root 1295:
1296: /* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
1297: look for nested component-refs or array-refs at constant positions
1298: and find the ultimate containing object, which is returned. */
1299:
1.1.1.4 root 1300: extern tree get_inner_reference PROTO((tree, int *, int *, tree *, enum machine_mode *, int *, int *));
1.1 root 1301:
1302: /* Return the FUNCTION_DECL which provides this _DECL with its context,
1303: or zero if none. */
1.1.1.4 root 1304: extern tree decl_function_context PROTO((tree));
1.1 root 1305:
1.1.1.5 ! root 1306: /* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
! 1307: this _DECL with its context, or zero if none. */
1.1.1.4 root 1308: extern tree decl_type_context PROTO((tree));
1.1 root 1309:
1310: /* Given the FUNCTION_DECL for the current function,
1311: return zero if it is ok for this function to be inline.
1312: Otherwise return a warning message with a single %s
1313: for the function's name. */
1314:
1.1.1.4 root 1315: extern char *function_cannot_inline_p PROTO((tree));
1.1.1.5 ! root 1316:
! 1317: /* Return 1 if EXPR is the real constant zero. */
! 1318: extern int real_zerop PROTO((tree));
1.1 root 1319:
1320: /* Declare commonly used variables for tree structure. */
1321:
1322: /* An integer constant with value 0 */
1323: extern tree integer_zero_node;
1324:
1325: /* An integer constant with value 1 */
1326: extern tree integer_one_node;
1327:
1328: /* An integer constant with value 0 whose type is sizetype. */
1329: extern tree size_zero_node;
1330:
1331: /* An integer constant with value 1 whose type is sizetype. */
1332: extern tree size_one_node;
1333:
1334: /* A constant of type pointer-to-int and value 0 */
1335: extern tree null_pointer_node;
1336:
1337: /* A node of type ERROR_MARK. */
1338: extern tree error_mark_node;
1339:
1340: /* The type node for the void type. */
1341: extern tree void_type_node;
1342:
1343: /* The type node for the ordinary (signed) integer type. */
1344: extern tree integer_type_node;
1345:
1346: /* The type node for the unsigned integer type. */
1347: extern tree unsigned_type_node;
1348:
1349: /* The type node for the ordinary character type. */
1350: extern tree char_type_node;
1351:
1352: /* Points to the name of the input file from which the current input
1353: being parsed originally came (before it went into cpp). */
1354: extern char *input_filename;
1355:
1356: /* Current line number in input file. */
1357: extern int lineno;
1358:
1359: /* Nonzero for -pedantic switch: warn about anything
1360: that standard C forbids. */
1361: extern int pedantic;
1362:
1363: /* Nonzero means can safely call expand_expr now;
1364: otherwise layout_type puts variable sizes onto `pending_sizes' instead. */
1365:
1366: extern int immediate_size_expand;
1367:
1368: /* Points to the FUNCTION_DECL of the function whose body we are reading. */
1369:
1370: extern tree current_function_decl;
1371:
1372: /* Nonzero if function being compiled can call setjmp. */
1373:
1374: extern int current_function_calls_setjmp;
1375:
1376: /* Nonzero if function being compiled can call longjmp. */
1377:
1378: extern int current_function_calls_longjmp;
1379:
1380: /* Nonzero means all ..._TYPE nodes should be allocated permanently. */
1381:
1382: extern int all_types_permanent;
1383:
1384: /* Pointer to function to compute the name to use to print a declaration. */
1385:
1386: extern char *(*decl_printable_name) ();
1.1.1.5 ! root 1387:
! 1388: /* Pointer to function to finish handling an incomplete decl at the
! 1389: end of compilation. */
! 1390:
! 1391: extern void (*incomplete_decl_finalize_hook) ();
1.1 root 1392:
1.1.1.4 root 1393: /* In tree.c */
1394: extern char *perm_calloc PROTO((int, long));
1395:
1.1 root 1396: /* In stmt.c */
1397:
1.1.1.4 root 1398: extern tree expand_start_stmt_expr PROTO((void));
1399: extern tree expand_end_stmt_expr PROTO((tree));
1400: extern void expand_expr_stmt PROTO((tree));
1.1.1.5 ! root 1401: extern void expand_decl_init PROTO((tree));
1.1.1.4 root 1402: extern void clear_last_expr PROTO((void));
1403: extern void expand_label PROTO((tree));
1404: extern void expand_goto PROTO((tree));
1405: extern void expand_asm PROTO((tree));
1406: extern void expand_start_cond PROTO((tree, int));
1407: extern void expand_end_cond PROTO((void));
1408: extern void expand_start_else PROTO((void));
1409: extern void expand_start_elseif PROTO((tree));
1410: extern struct nesting *expand_start_loop PROTO((int));
1411: extern struct nesting *expand_start_loop_continue_elsewhere PROTO((int));
1412: extern void expand_loop_continue_here PROTO((void));
1413: extern void expand_end_loop PROTO((void));
1414: extern int expand_continue_loop PROTO((struct nesting *));
1415: extern int expand_exit_loop PROTO((struct nesting *));
1416: extern int expand_exit_loop_if_false PROTO((struct nesting *, tree));
1417: extern int expand_exit_something PROTO((void));
1418:
1419: extern void expand_null_return PROTO((void));
1420: extern void expand_return PROTO((tree));
1421: extern void expand_start_bindings PROTO((int));
1422: extern void expand_end_bindings PROTO((tree, int, int));
1423: extern tree last_cleanup_this_contour PROTO((void));
1424: extern void expand_start_case PROTO((int, tree, tree, char *));
1425: extern void expand_end_case PROTO((tree));
1426: extern int pushcase PROTO((tree, tree, tree *));
1427: extern int pushcase_range PROTO((tree, tree, tree, tree *));
1.1 root 1428:
1429: /* In fold-const.c */
1430:
1.1.1.4 root 1431: extern tree invert_truthvalue PROTO((tree));
1.1 root 1432:
1433: /* The language front-end must define these functions. */
1434:
1435: /* Function of no arguments for initializing lexical scanning. */
1.1.1.4 root 1436: extern void init_lex PROTO((void));
1.1 root 1437: /* Function of no arguments for initializing the symbol table. */
1.1.1.4 root 1438: extern void init_decl_processing PROTO((void));
1.1 root 1439:
1440: /* Functions called with no arguments at the beginning and end or processing
1441: the input source file. */
1.1.1.4 root 1442: extern void lang_init PROTO((void));
1443: extern void lang_finish PROTO((void));
1.1 root 1444:
1.1.1.5 ! root 1445: /* Funtion to identify which front-end produced the output file. */
! 1446: extern char *lang_identify PROTO((void));
! 1447:
1.1 root 1448: /* Function called with no arguments to parse and compile the input. */
1.1.1.4 root 1449: extern int yyparse PROTO((void));
1.1 root 1450: /* Function called with option as argument
1451: to decode options starting with -f or -W or +.
1452: It should return nonzero if it handles the option. */
1.1.1.4 root 1453: extern int lang_decode_option PROTO((char *));
1.1 root 1454:
1455: /* Functions for processing symbol declarations. */
1456: /* Function to enter a new lexical scope.
1457: Takes one argument: always zero when called from outside the front end. */
1.1.1.4 root 1458: extern void pushlevel PROTO((int));
1.1 root 1459: /* Function to exit a lexical scope. It returns a BINDING for that scope.
1460: Takes three arguments:
1461: KEEP -- nonzero if there were declarations in this scope.
1462: REVERSE -- reverse the order of decls before returning them.
1463: FUNCTIONBODY -- nonzero if this level is the body of a function. */
1.1.1.4 root 1464: extern tree poplevel PROTO((int, int, int));
1465: /* Set the BLOCK node for the current scope level. */
1466: extern void set_block PROTO((tree));
1.1 root 1467: /* Function to add a decl to the current scope level.
1468: Takes one argument, a decl to add.
1469: Returns that decl, or, if the same symbol is already declared, may
1470: return a different decl for that name. */
1.1.1.4 root 1471: extern tree pushdecl PROTO((tree));
1.1 root 1472: /* Function to return the chain of decls so far in the current scope level. */
1.1.1.4 root 1473: extern tree getdecls PROTO((void));
1.1 root 1474: /* Function to return the chain of structure tags in the current scope level. */
1.1.1.4 root 1475: extern tree gettags PROTO((void));
1.1.1.5 ! root 1476:
! 1477: extern tree build_range_type PROTO((tree, tree, tree));
! 1478:
! 1479: /* Call when starting to parse a declaration:
! 1480: make expressions in the declaration last the length of the function.
! 1481: Returns an argument that should be passed to resume_momentary later. */
! 1482: extern int suspend_momentary PROTO((void));
! 1483:
! 1484: extern int allocation_temporary_p PROTO((void));
! 1485:
! 1486: /* Call when finished parsing a declaration:
! 1487: restore the treatment of node-allocation that was
! 1488: in effect before the suspension.
! 1489: YES should be the value previously returned by suspend_momentary. */
! 1490: extern void resume_momentary PROTO((int));
! 1491:
! 1492: /* Called after finishing a record, union or enumeral type. */
! 1493: extern void rest_of_type_compilation PROTO((tree, int));
! 1494:
! 1495: /* Save the current set of obstacks, but don't change them. */
! 1496: extern void push_obstacks_nochange PROTO((void));
! 1497:
! 1498: extern void push_momentary PROTO((void));
! 1499:
! 1500: extern void clear_momentary PROTO((void));
! 1501:
! 1502: extern void pop_momentary PROTO((void));
! 1503:
! 1504: extern void end_temporary_allocation PROTO((void));
! 1505:
! 1506: /* Pop the obstack selection stack. */
! 1507: extern void pop_obstacks PROTO((void));
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.