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