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