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