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