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