![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to tree.h CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: /* Front-end tree definitions for GNU compiler. ! 2: Copyright (C) 1987 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU CC General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU CC, but only under the conditions described in the ! 15: GNU CC General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU CC so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* codes of tree nodes */ ! 23: ! 24: #define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM, ! 25: ! 26: enum tree_code { ! 27: #include "tree.def" ! 28: }; ! 29: ! 30: #undef DEFTREECODE ! 31: ! 32: /* Indexed by enum tree_code, contains a character which is ! 33: `e' for an expression, `r' for a reference, `c' for a constant, ! 34: `d' for a decl, `t' for a type, `s' for a statement, ! 35: and `x' for anything else (TREE_LIST, IDENTIFIER, etc). */ ! 36: ! 37: extern char *tree_code_type[]; ! 38: ! 39: /* Number of argument-words in each kind of tree-node. */ ! 40: ! 41: extern int tree_code_length[]; ! 42: ! 43: /* Get the definition of `enum machine_mode' */ ! 44: ! 45: #ifndef HAVE_MACHINE_MODES ! 46: #define DEF_MACHMODE(SYM, NAME, TYPE, SIZE, UNIT) SYM, ! 47: ! 48: enum machine_mode { ! 49: #include "machmode.def" ! 50: }; ! 51: ! 52: #undef DEF_MACHMODE ! 53: ! 54: #define HAVE_MACHINE_MODES ! 55: ! 56: #endif /* not HAVE_MACHINE_MODES */ ! 57: ! 58: #ifndef NUM_MACHINE_MODES ! 59: #define NUM_MACHINE_MODES (int) MAX_MACHINE_MODE ! 60: #endif ! 61: ! 62: /* Codes that identify the various built in functions ! 63: so that expand_call can identify them quickly. */ ! 64: ! 65: enum built_in_function ! 66: { ! 67: NOT_BUILT_IN, ! 68: BUILT_IN_ALLOCA, ! 69: BUILT_IN_ABS, ! 70: BUILT_IN_FABS, ! 71: BUILT_IN_LABS, ! 72: BUILT_IN_FFS, ! 73: BUILT_IN_DIV, ! 74: BUILT_IN_LDIV, ! 75: BUILT_IN_FFLOOR, ! 76: BUILT_IN_FCEIL, ! 77: BUILT_IN_FMOD, ! 78: BUILT_IN_FREM, ! 79: BUILT_IN_MEMCPY, ! 80: BUILT_IN_MEMCMP, ! 81: BUILT_IN_MEMSET, ! 82: BUILT_IN_FSQRT, ! 83: BUILT_IN_GETEXP, ! 84: BUILT_IN_GETMAN ! 85: }; ! 86: ! 87: /* The definition of tree nodes fills the next several pages. */ ! 88: ! 89: /* A tree node can represent a data type, a variable, an expression ! 90: or a statement. Each node has a TREE_CODE which says what kind of ! 91: thing it represents. Some common codes are: ! 92: INTEGER_TYPE -- represents a type of integers. ! 93: ARRAY_TYPE -- represents a type of pointer. ! 94: VAR_DECL -- represents a declared variable. ! 95: INTEGER_CST -- represents a constant integer value. ! 96: PLUS_EXPR -- represents a sum (an expression). ! 97: ! 98: As for the contents of a tree node: there are some fields ! 99: that all nodes share. Each TREE_CODE has various special-purpose ! 100: fields as well. The fields of a node are never accessed directly, ! 101: always through accessor macros. */ ! 102: ! 103: /* This type is used everywhere to refer to a tree node. */ ! 104: ! 105: typedef union tree_node *tree; ! 106: ! 107: #define NULL_TREE (tree) NULL ! 108: ! 109: /* Every kind of tree node starts with this structure, ! 110: so all nodes have these fields. ! 111: ! 112: See the accessor macros, defined below, for documentation of the fields. */ ! 113: ! 114: struct tree_common ! 115: { ! 116: int uid; ! 117: union tree_node *chain; ! 118: union tree_node *type; ! 119: enum tree_code code : 8; ! 120: ! 121: unsigned external_attr : 1; ! 122: unsigned public_attr : 1; ! 123: unsigned static_attr : 1; ! 124: unsigned volatile_attr : 1; ! 125: unsigned packed_attr : 1; ! 126: unsigned readonly_attr : 1; ! 127: unsigned literal_attr : 1; ! 128: unsigned nonlocal_attr : 1; ! 129: unsigned permanent_attr : 1; ! 130: unsigned addressable_attr : 1; ! 131: unsigned regdecl_attr : 1; ! 132: unsigned this_vol_attr : 1; ! 133: unsigned unsigned_attr : 1; ! 134: unsigned asm_written_attr: 1; ! 135: unsigned inline_attr : 1; ! 136: }; ! 137: ! 138: /* Define accessors for the fields that all tree nodes have ! 139: (though some fields are not used for all kinds of nodes). */ ! 140: ! 141: /* The unique id of a tree node distinguishes it from all other nodes ! 142: in the same compiler run. */ ! 143: #define TREE_UID(NODE) ((NODE)->common.uid) ! 144: ! 145: /* The tree-code says what kind of node it is. ! 146: Codes are defined in tree.def. */ ! 147: #define TREE_CODE(NODE) ((NODE)->common.code) ! 148: #define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (VALUE)) ! 149: ! 150: /* In all nodes that are expressions, this is the data type of the expression. ! 151: In POINTER_TYPE nodes, this is the type that the pointer points to. ! 152: In ARRAY_TYPE nodes, this is the type of the elements. */ ! 153: #define TREE_TYPE(NODE) ((NODE)->common.type) ! 154: ! 155: /* Nodes are chained together for many purposes. ! 156: Types are chained together to record them for being output to the debugger ! 157: (see the function `chain_type'). ! 158: Decls in the same scope are chained together to record the contents ! 159: of the scope. ! 160: Statement nodes for successive statements used to be chained together. ! 161: Often lists of things are represented by TREE_LIST nodes thaht ! 162: are chained together. */ ! 163: ! 164: #define TREE_CHAIN(NODE) ((NODE)->common.chain) ! 165: ! 166: /* Define many boolean fields that all tree nodes have. */ ! 167: ! 168: /* In a VAR_DECL or FUNCTION_DECL, ! 169: nonzero means external reference: ! 170: do not allocate storage, and refer to a definition elsewhere. */ ! 171: #define TREE_EXTERNAL(NODE) ((NODE)->common.external_attr) ! 172: ! 173: /* In a VAR_DECL, nonzero means allocate static storage. ! 174: In a FUNCTION_DECL, currently nonzero if function has been defined. */ ! 175: #define TREE_STATIC(NODE) ((NODE)->common.static_attr) ! 176: ! 177: /* In a VAR_DECL or FUNCTION_DECL, ! 178: nonzero means name is to be accessible from outside this module. */ ! 179: #define TREE_PUBLIC(NODE) ((NODE)->common.public_attr) ! 180: ! 181: /* In VAR_DECL nodes, nonzero means address of this is needed. ! 182: So it cannot be in a register. ! 183: In a FUNCTION_DECL, nonzero means its address is needed. ! 184: So it must be compiled even if it is an inline function. ! 185: In CONSTRUCTOR nodes, it means are all constants suitable ! 186: for output as assembly-language initializers. ! 187: In LABEL_DECL nodes, it means a goto for this label has been seen ! 188: from a place outside all binding contours that restore stack levels, ! 189: or that an error message about jumping into such a binding contour ! 190: has been printed for this label. */ ! 191: #define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_attr) ! 192: ! 193: /* In VAR_DECL nodes, nonzero means declared `register'. */ ! 194: #define TREE_REGDECL(NODE) ((NODE)->common.regdecl_attr) ! 195: ! 196: /* In any expression, nonzero means it has side effects or reevaluation ! 197: of the whole expression could produce a different value. ! 198: This is set if any subexpression is a function call, a side effect ! 199: or a reference to a volatile variable. ! 200: In a ..._DECL, this is set only of the declaration said `volatile'. ! 201: In a ..._TYPE, nonzero means the type is volatile-qualified. */ ! 202: #define TREE_VOLATILE(NODE) ((NODE)->common.volatile_attr) ! 203: ! 204: /* Nonzero means this expression is volatile in the C sense: ! 205: its address should be of type `volatile WHATEVER *'. ! 206: If this bit is set, so is `volatile_attr'. */ ! 207: #define TREE_THIS_VOLATILE(NODE) ((NODE)->common.this_vol_attr) ! 208: ! 209: /* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node, ! 210: nonzero means it may not be the lhs of an assignment. ! 211: In a ..._TYPE node, means this type is const-qualified. */ ! 212: #define TREE_READONLY(NODE) ((NODE)->common.readonly_attr) ! 213: ! 214: /* Nonzero in a FIELD_DECL means it is a bit-field; it may occupy ! 215: less than a storage unit, and its address may not be taken, etc. ! 216: This controls layout of the containing record. ! 217: In a LABEL_DECL, nonzero means label was defined inside a binding ! 218: contour that restored a stack level and which is now exited. */ ! 219: #define TREE_PACKED(NODE) ((NODE)->common.packed_attr) ! 220: ! 221: /* Value of expression is constant. ! 222: Always appears in all ..._CST nodes. ! 223: May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR ! 224: if the value is constant. */ ! 225: #define TREE_LITERAL(NODE) ((NODE)->common.literal_attr) ! 226: ! 227: /* Nonzero in a ..._DECL means this variable is ref'd from a nested function. ! 228: Cannot happen in C because it does not allow nested functions, as of now. ! 229: For VAR_DECL nodes, PARM_DECL nodes, and ! 230: maybe FUNCTION_DECL or LABEL_DECL nodes. */ ! 231: #define TREE_NONLOCAL(NODE) ((NODE)->common.nonlocal_attr) ! 232: ! 233: /* Nonzero means permanent node; ! 234: node will continue to exist for the entire compiler run. ! 235: Otherwise it will be recycled at the end of the function. */ ! 236: #define TREE_PERMANENT(NODE) ((NODE)->common.permanent_attr) ! 237: ! 238: /* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type. ! 239: In FIELD_DECL nodes, means an unsigned bit field. */ ! 240: #define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_attr) ! 241: ! 242: /* Nonzero in a VAR_DECL means assembler code has been written. ! 243: Nonzero in a FUNCTION_DECL means that the function has been compiled. ! 244: This is interesting in an inline function, since it might not need ! 245: to be compiled separately. */ ! 246: #define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_attr) ! 247: ! 248: /* Nonzero in a FUNCTION_DECL means this function can be substituted ! 249: where it is called. */ ! 250: #define TREE_INLINE(NODE) ((NODE)->common.inline_attr) ! 251: ! 252: /* Define additional fields and accessors for nodes representing constants. */ ! 253: ! 254: /* In an INTEGER_CST node. These two together make a 64 bit integer. ! 255: If the data type is signed, the value is sign-extended to 64 bits ! 256: even though not all of them may really be in use. ! 257: In an unsigned constant shorter than 64 bits, the extra bits are 0. */ ! 258: #define TREE_INT_CST_LOW(NODE) ((NODE)->int_cst.int_cst_low) ! 259: #define TREE_INT_CST_HIGH(NODE) ((NODE)->int_cst.int_cst_high) ! 260: ! 261: #define INT_CST_LT(A, B) \ ! 262: (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \ ! 263: || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \ ! 264: && ((unsigned) TREE_INT_CST_LOW (A) < (unsigned) TREE_INT_CST_LOW (B)))) ! 265: ! 266: #define INT_CST_LT_UNSIGNED(A, B) \ ! 267: ((unsigned) TREE_INT_CST_HIGH (A) < (unsigned) TREE_INT_CST_HIGH (B) \ ! 268: || ((unsigned) TREE_INT_CST_HIGH (A) == (unsigned) TREE_INT_CST_HIGH (B) \ ! 269: && ((unsigned) TREE_INT_CST_LOW (A) < (unsigned) TREE_INT_CST_LOW (B)))) ! 270: ! 271: struct tree_int_cst ! 272: { ! 273: char common[sizeof (struct tree_common)]; ! 274: long int_cst_low; ! 275: long int_cst_high; ! 276: }; ! 277: ! 278: /* In REAL_CST, STRING_CST, COMPLEX_CST nodes, and CONSTRUCTOR nodes, ! 279: and generally in all kinds of constants that could ! 280: be given labels (rather than being immediate). */ ! 281: ! 282: #define TREE_CST_RTL(NODE) ((NODE)->real_cst.rtl) ! 283: ! 284: /* In a REAL_CST node. */ ! 285: #define TREE_REAL_CST(NODE) ((NODE)->real_cst.real_cst) ! 286: ! 287: struct tree_real_cst ! 288: { ! 289: char common[sizeof (struct tree_common)]; ! 290: struct rtx_def *rtl; /* acts as link to register transfer language ! 291: (rtl) info */ ! 292: double real_cst; ! 293: }; ! 294: ! 295: /* In a STRING_CST */ ! 296: #define TREE_STRING_LENGTH(NODE) ((NODE)->string.length) ! 297: #define TREE_STRING_POINTER(NODE) ((NODE)->string.pointer) ! 298: ! 299: struct tree_string ! 300: { ! 301: char common[sizeof (struct tree_common)]; ! 302: struct rtx_def *rtl; /* acts as link to register transfer language ! 303: (rtl) info */ ! 304: int length; ! 305: char *pointer; ! 306: }; ! 307: ! 308: /* In a COMPLEX_CST node. */ ! 309: #define TREE_REALPART(NODE) ((NODE)->complex.real) ! 310: #define TREE_IMAGPART(NODE) ((NODE)->complex.imag) ! 311: ! 312: struct tree_complex ! 313: { ! 314: char common[sizeof (struct tree_common)]; ! 315: struct rtx_def *rtl; /* acts as link to register transfer language ! 316: (rtl) info */ ! 317: union tree_node *real; ! 318: union tree_node *imag; ! 319: }; ! 320: ! 321: /* Define fields and accessors for some special-purpose tree nodes. */ ! 322: ! 323: #define IDENTIFIER_LENGTH(NODE) ((NODE)->identifier.length) ! 324: #define IDENTIFIER_POINTER(NODE) ((NODE)->identifier.pointer) ! 325: #define IDENTIFIER_GLOBAL_VALUE(NODE) ((NODE)->identifier.global_value) ! 326: #define IDENTIFIER_LOCAL_VALUE(NODE) ((NODE)->identifier.local_value) ! 327: #define IDENTIFIER_LABEL_VALUE(NODE) ((NODE)->identifier.label_value) ! 328: #define IDENTIFIER_IMPLICIT_DECL(NODE) ((NODE)->identifier.implicit_decl) ! 329: ! 330: struct tree_identifier ! 331: { ! 332: char common[sizeof (struct tree_common)]; ! 333: int length; ! 334: char *pointer; ! 335: union tree_node *global_value; ! 336: union tree_node *local_value; ! 337: union tree_node *label_value; ! 338: union tree_node *implicit_decl; ! 339: }; ! 340: ! 341: /* In a TREE_LIST node. */ ! 342: #define TREE_PURPOSE(NODE) ((NODE)->list.purpose) ! 343: #define TREE_VALUE(NODE) ((NODE)->list.value) ! 344: ! 345: struct tree_list ! 346: { ! 347: char common[sizeof (struct tree_common)]; ! 348: union tree_node *purpose; ! 349: union tree_node *value; ! 350: }; ! 351: ! 352: /* Define fields and accessors for some nodes that represent expressions. */ ! 353: ! 354: /* In a SAVE_EXPR node. */ ! 355: #define SAVE_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[1]) ! 356: ! 357: /* In a RTL_EXPR node. */ ! 358: #define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[0]) ! 359: #define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[1]) ! 360: ! 361: /* In a CALL_EXPR node. */ ! 362: #define CALL_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[2]) ! 363: ! 364: /* In a CONSTRUCTOR node. */ ! 365: #define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1) ! 366: ! 367: /* In expression and reference nodes. */ ! 368: #define TREE_OPERAND(NODE, I) ((NODE)->exp.operands[I]) ! 369: #define TREE_COMPLEXITY(NODE, I) ((NODE)->exp.complexity) ! 370: ! 371: struct tree_exp ! 372: { ! 373: char common[sizeof (struct tree_common)]; ! 374: int complexity; ! 375: union tree_node *operands[1]; ! 376: }; ! 377: ! 378: /* Define fields and accessors for nodes representing data types. */ ! 379: ! 380: /* See tree.def for documentation of the use of these fields. */ ! 381: ! 382: #define TYPE_SIZE(NODE) ((NODE)->type.size) ! 383: #define TYPE_SIZE_UNIT(NODE) ((NODE)->type.size_unit) ! 384: #define TYPE_MODE(NODE) ((NODE)->type.mode) ! 385: #define TYPE_ALIGN(NODE) ((NODE)->type.align) ! 386: #define TYPE_VALUES(NODE) ((NODE)->type.values) ! 387: #define TYPE_DOMAIN(NODE) ((NODE)->type.values) ! 388: #define TYPE_FIELDS(NODE) ((NODE)->type.values) ! 389: #define TYPE_ARG_TYPES(NODE) ((NODE)->type.values) ! 390: #define TYPE_SEP(NODE) ((NODE)->type.sep) ! 391: #define TYPE_SEP_UNIT(NODE) ((NODE)->type.sep_unit) ! 392: #define TYPE_POINTER_TO(NODE) ((NODE)->type.pointer_to) ! 393: #define TYPE_MIN_VALUE(NODE) ((NODE)->type.sep) ! 394: #define TYPE_MAX_VALUE(NODE) ((NODE)->type.max) ! 395: #define TYPE_PRECISION(NODE) ((NODE)->type.sep_unit) ! 396: #define TYPE_PARSE_INFO(NODE) ((NODE)->type.parse_info) ! 397: #define TYPE_SYMTAB_ADDRESS(NODE) ((NODE)->type.symtab_address) ! 398: #define TYPE_NAME(NODE) ((NODE)->type.name) ! 399: #define TYPE_NEXT_VARIANT(NODE) ((NODE)->type.next_variant) ! 400: #define TYPE_MAIN_VARIANT(NODE) ((NODE)->type.main_variant) ! 401: ! 402: struct tree_type ! 403: { ! 404: char common[sizeof (struct tree_common)]; ! 405: union tree_node *values; ! 406: union tree_node *sep; ! 407: union tree_node *size; ! 408: enum machine_mode mode; ! 409: unsigned char size_unit; ! 410: unsigned char align; ! 411: unsigned char sep_unit; ! 412: enum machine_mode elt_mode; /* Unused */ ! 413: union tree_node *pointer_to; ! 414: int parse_info; ! 415: int symtab_address; ! 416: union tree_node *name; ! 417: union tree_node *max; ! 418: union tree_node *next_variant; ! 419: union tree_node *main_variant; ! 420: }; ! 421: ! 422: /* Define fields and accessors for nodes representing declared names. */ ! 423: ! 424: #define DECL_VOFFSET(NODE) ((NODE)->decl.voffset) ! 425: #define DECL_VOFFSET_UNIT(NODE) ((NODE)->decl.voffset_unit) ! 426: #define DECL_OFFSET(NODE) ((NODE)->decl.offset) ! 427: #define DECL_FUNCTION_CODE(NODE) ((enum built_in_function) (NODE)->decl.offset) ! 428: #define DECL_SET_FUNCTION_CODE(NODE,VAL) ((NODE)->decl.offset = (int) (VAL)) ! 429: #define DECL_NAME(NODE) ((NODE)->decl.name) ! 430: #define DECL_CONTEXT(NODE) ((NODE)->decl.context) ! 431: #define DECL_ARGUMENTS(NODE) ((NODE)->decl.arguments) ! 432: #define DECL_ARG_TYPE(NODE) ((NODE)->decl.arguments) ! 433: #define DECL_RESULT(NODE) ((NODE)->decl.result) ! 434: #define DECL_INITIAL(NODE) ((NODE)->decl.initial) ! 435: #define DECL_SOURCE_FILE(NODE) ((NODE)->decl.filename) ! 436: #define DECL_SOURCE_LINE(NODE) ((NODE)->decl.linenum) ! 437: #define DECL_SIZE(NODE) ((NODE)->decl.size) ! 438: #define DECL_SIZE_UNIT(NODE) ((NODE)->decl.size_unit) ! 439: #define DECL_ALIGN(NODE) ((NODE)->decl.align) ! 440: #define DECL_MODE(NODE) ((NODE)->decl.mode) ! 441: #define DECL_RTL(NODE) ((NODE)->decl.rtl) ! 442: #define DECL_BLOCK_SYMTAB_ADDRESS(NODE) ((NODE)->decl.block_symtab_address) ! 443: #define DECL_SYMTAB_INDEX(NODE) ((NODE)->decl.block_symtab_address) ! 444: #define DECL_SAVED_INSNS(NODE) ((NODE)->decl.saved_insns) ! 445: #define DECL_FRAME_SIZE(NODE) ((NODE)->decl.frame_size) ! 446: ! 447: struct tree_decl ! 448: { ! 449: char common[sizeof (struct tree_common)]; ! 450: char *filename; ! 451: int linenum; ! 452: union tree_node *size; ! 453: enum machine_mode mode; ! 454: unsigned char size_unit; ! 455: unsigned char align; ! 456: unsigned char voffset_unit; ! 457: union tree_node *name; ! 458: union tree_node *context; ! 459: int offset; ! 460: union tree_node *voffset; ! 461: union tree_node *arguments; ! 462: union tree_node *result; ! 463: union tree_node *initial; ! 464: struct rtx_def *rtl; /* acts as link to register transfer language ! 465: (rtl) info */ ! 466: int frame_size; /* For FUNCTION_DECLs: size of stack frame */ ! 467: struct rtx_def *saved_insns; /* For FUNCTION_DECLs: points to insn that ! 468: constitute its definition on the ! 469: permanent obstack. */ ! 470: int block_symtab_address; ! 471: }; ! 472: ! 473: /* Define fields and accessors for nodes representing statements. ! 474: These are now obsolete for C, except for LET_STMT, which is used ! 475: to record the structure of binding contours (and the names declared ! 476: in each contour) for the sake of outputting debugging info. ! 477: Perhaps they will be used once again for other languages. */ ! 478: ! 479: /* For LABEL_STMT, GOTO_STMT, RETURN_STMT, LOOP_STMT, ! 480: COMPOUND_STMT, ASM_STMT. */ ! 481: #define STMT_SOURCE_LINE(NODE) ((NODE)->stmt.linenum) ! 482: #define STMT_SOURCE_FILE(NODE) ((NODE)->stmt.filename) ! 483: #define STMT_BODY(NODE) ((NODE)->stmt.body) ! 484: ! 485: struct tree_stmt ! 486: { ! 487: char common[sizeof (struct tree_common)]; ! 488: char *filename; ! 489: int linenum; ! 490: union tree_node *body; ! 491: }; ! 492: ! 493: /* For IF_STMT. */ ! 494: ! 495: /* #define STMT_SOURCE_LINE(NODE) */ ! 496: /* #define STMT_SOURCE_FILE(NODE) */ ! 497: #define STMT_COND(NODE) ((NODE)->if_stmt.cond) ! 498: #define STMT_THEN(NODE) ((NODE)->if_stmt.thenpart) ! 499: #define STMT_ELSE(NODE) ((NODE)->if_stmt.elsepart) ! 500: ! 501: struct tree_if_stmt ! 502: { ! 503: char common[sizeof (struct tree_common)]; ! 504: char *filename; ! 505: int linenum; ! 506: union tree_node *cond, *thenpart, *elsepart; ! 507: }; ! 508: ! 509: /* For LET_STMT and WITH_STMT. */ ! 510: ! 511: /* #define STMT_SOURCE_LINE(NODE) */ ! 512: /* #define STMT_SOURCE_FILE(NODE) */ ! 513: /* #define STMT_BODY(NODE) */ ! 514: #define STMT_VARS(NODE) ((NODE)->bind_stmt.vars) ! 515: #define STMT_SUPERCONTEXT(NODE) ((NODE)->bind_stmt.supercontext) ! 516: #define STMT_BIND_SIZE(NODE) ((NODE)->bind_stmt.bind_size) ! 517: #define STMT_TYPE_TAGS(NODE) ((NODE)->bind_stmt.type_tags) ! 518: ! 519: struct tree_bind_stmt ! 520: { ! 521: char common[sizeof (struct tree_common)]; ! 522: char *filename; ! 523: int linenum; ! 524: union tree_node *body, *vars, *supercontext, *bind_size, *type_tags; ! 525: }; ! 526: ! 527: /* For CASE_STMT. */ ! 528: ! 529: #define STMT_CASE_INDEX(NODE) ((NODE)->case_stmt.index) ! 530: #define STMT_CASE_LIST(NODE) ((NODE)->case_stmt.case_list) ! 531: ! 532: struct tree_case_stmt ! 533: { ! 534: char common[sizeof (struct tree_common)]; ! 535: char *filename; ! 536: int linenum; ! 537: union tree_node *index, *case_list; ! 538: }; ! 539: ! 540: /* Define the overall contents of a tree node. ! 541: It may be any of the structures declared above ! 542: for various types of node. */ ! 543: ! 544: union tree_node ! 545: { ! 546: struct tree_common common; ! 547: struct tree_int_cst int_cst; ! 548: struct tree_real_cst real_cst; ! 549: struct tree_string string; ! 550: struct tree_complex complex; ! 551: struct tree_identifier identifier; ! 552: struct tree_decl decl; ! 553: struct tree_type type; ! 554: struct tree_list list; ! 555: struct tree_exp exp; ! 556: struct tree_stmt stmt; ! 557: struct tree_if_stmt if_stmt; ! 558: struct tree_bind_stmt bind_stmt; ! 559: struct tree_case_stmt case_stmt; ! 560: }; ! 561: ! 562: extern char *oballoc (); ! 563: extern char *permalloc (); ! 564: ! 565: /* Lowest level primitive for allocating a node. ! 566: The TREE_CODE is the only argument. Contents are initialized ! 567: to zero except for a few of the common fields. */ ! 568: ! 569: extern tree make_node (); ! 570: ! 571: /* Make a copy of a node, with all the same contents except ! 572: for TREE_UID and TREE_PERMANENT. (The copy is permanent ! 573: iff nodes being made now are permanent.) */ ! 574: ! 575: extern tree copy_node (); ! 576: ! 577: /* Return the (unique) IDENTIFIER_NODE node for a given name. ! 578: The name is supplied as a char *. */ ! 579: ! 580: extern tree get_identifier (); ! 581: ! 582: /* Construct various types of nodes. */ ! 583: ! 584: extern tree build_int_2 (); ! 585: extern tree build_real (); ! 586: extern tree build_real_from_string (); ! 587: extern tree build_real_from_int_cst (); ! 588: extern tree build_complex (); ! 589: extern tree build_string (); ! 590: extern tree build (); ! 591: extern tree build_nt (); ! 592: extern tree build_tree_list (); ! 593: extern tree build_decl (); ! 594: extern tree build_let (); ! 595: ! 596: /* Construct various nodes representing data types. */ ! 597: ! 598: extern tree make_signed_type (); ! 599: extern tree make_unsigned_type (); ! 600: extern void fixup_unsigned_type (); ! 601: extern tree build_pointer_type (); ! 602: extern tree build_array_type (); ! 603: extern tree build_function_type (); ! 604: ! 605: /* Construct expressions, performing type checking. */ ! 606: ! 607: extern tree build_binary_op (); ! 608: extern tree build_indirect_ref (); ! 609: extern tree build_unary_op (); ! 610: ! 611: /* Given a type node TYPE, and CONSTP and VOLATILEP, return a type ! 612: for the same kind of data as TYPE describes. ! 613: Variants point to the "main variant" (which has neither CONST nor VOLATILE) ! 614: via TYPE_MAIN_VARIANT, and it points to a chain of other variants ! 615: so that duplicate variants are never made. ! 616: Only main variants should ever appear as types of expressions. */ ! 617: ! 618: extern tree build_type_variant (); ! 619: ! 620: /* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT, ! 621: TYPE_ALIGN and TYPE_MODE fields. ! 622: If called more than once on one node, does nothing except ! 623: for the first time. */ ! 624: ! 625: extern void layout_type (); ! 626: ! 627: /* Given a hashcode and a ..._TYPE node (for which the hashcode was made), ! 628: return a canonicalized ..._TYPE node, so that duplicates are not made. ! 629: How the hash code is computed is up to the caller, as long as any two ! 630: callers that could hash identical-looking type nodes agree. */ ! 631: ! 632: extern tree type_hash_canon (); ! 633: ! 634: /* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node, ! 635: calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE ! 636: fields. Call this only once for any given decl node. ! 637: ! 638: Second argument is the boundary that this field can be assumed to ! 639: be starting at (in bits). Zero means it can be assumed aligned ! 640: on any boundary that may be needed. */ ! 641: ! 642: extern void layout_decl (); ! 643: ! 644: /* Fold constants as much as possible in an expression. ! 645: Returns the simplified expression. ! 646: Acts only on the top level of the expression; ! 647: if the argument itself cannot be simplified, its ! 648: subexpressions are not changed. */ ! 649: ! 650: extern tree fold (); ! 651: ! 652: /* combine (tree_code, exp1, exp2) where EXP1 and EXP2 are constants ! 653: returns a constant expression for the result of performing ! 654: the operation specified by TREE_CODE on EXP1 and EXP2. */ ! 655: ! 656: extern tree combine (); ! 657: ! 658: extern tree convert (); ! 659: extern tree convert_units (); ! 660: extern tree size_in_bytes (); ! 661: extern tree genop (); ! 662: extern tree build_int (); ! 663: ! 664: /* Type for sizes of data-type. */ ! 665: ! 666: extern tree sizetype; ! 667: ! 668: /* Concatenate two lists (chains of TREE_LIST nodes) X and Y ! 669: by making the last node in X point to Y. ! 670: Returns X, except if X is 0 returns Y. */ ! 671: ! 672: extern tree chainon (); ! 673: ! 674: /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */ ! 675: ! 676: extern tree tree_cons (); ! 677: ! 678: /* Return the last tree node in a chain. */ ! 679: ! 680: extern tree tree_last (); ! 681: ! 682: /* Reverse the order of elements in a chain, and return the new head. */ ! 683: ! 684: extern tree nreverse (); ! 685: ! 686: /* Returns the length of a chain of nodes ! 687: (number of chain pointers to follow before reaching a null pointer). */ ! 688: ! 689: extern int list_length (); ! 690: ! 691: /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */ ! 692: ! 693: extern int integer_zerop (); ! 694: ! 695: /* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */ ! 696: ! 697: extern int integer_onep (); ! 698: ! 699: /* integer_all_onesp (tree x) is nonzero if X is an integer constant ! 700: all of whose significant bits are 1. */ ! 701: ! 702: extern int integer_all_onesp (); ! 703: ! 704: /* type_unsigned_p (tree x) is nonzero if the type X is an unsigned type ! 705: (all of its possible values are >= 0). ! 706: If X is a pointer type, the value is 1. ! 707: If X is a real type, the value is 0. */ ! 708: ! 709: extern int type_unsigned_p (); ! 710: ! 711: /* staticp (tree x) is nonzero if X is a reference to data allocated ! 712: at a fixed address in memory. */ ! 713: ! 714: extern int staticp (); ! 715: ! 716: /* Gets an error if argument X is not an lvalue. ! 717: Also returns 1 if X is an lvalue, 0 if not. */ ! 718: ! 719: extern int lvalue_or_else (); ! 720: ! 721: /* save_expr (EXP) returns an expression equivalent to EXP ! 722: but it can be used multiple times within context CTX ! 723: and only evaluate EXP once. */ ! 724: ! 725: extern tree save_expr (); ! 726: ! 727: /* stabilize_reference (EXP) returns an reference equivalent to EXP ! 728: but it can be used multiple times ! 729: and only evaluate the subexpressions once. */ ! 730: ! 731: extern tree stabilize_reference (); ! 732: ! 733: /* Return EXP, stripped of any conversions to wider types ! 734: in such a way that the result of converting to type FOR_TYPE ! 735: is the same as if EXP were converted to FOR_TYPE. ! 736: If FOR_TYPE is 0, it signifies EXP's type. */ ! 737: ! 738: extern tree get_unwidened (); ! 739: ! 740: /* Return OP or a simpler expression for a narrower value ! 741: which can be sign-extended or zero-extended to give back OP. ! 742: Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended ! 743: or 0 if the value should be sign-extended. */ ! 744: ! 745: extern tree get_narrower (); ! 746: ! 747: /* Given PRECISION and UNSIGNEDP, return a suitable type-tree ! 748: for an integer type with at least that precision. ! 749: The definition of this resides in language-specific code ! 750: as the repertoir of available types may vary. */ ! 751: ! 752: extern tree type_for_size (); ! 753: ! 754: /* Given an integer type T, return a type like T but unsigned. ! 755: If T is unsigned, the value is T. ! 756: The definition of this resides in language-specific code ! 757: as the repertoir of available types may vary. */ ! 758: ! 759: extern tree unsigned_type (); ! 760: ! 761: /* Given an integer type T, return a type like T but signed. ! 762: If T is signed, the value is T. ! 763: The definition of this resides in language-specific code ! 764: as the repertoir of available types may vary. */ ! 765: ! 766: extern tree signed_type (); ! 767: ! 768: /* Return the floating type node for a given floating machine mode. */ ! 769: ! 770: extern tree get_floating_type (); ! 771: ! 772: /* Given the FUNCTION_DECL for the current function, ! 773: return zero if it is ok for this function to be inline. ! 774: Otherwise return a warning message with a single %s ! 775: for the function's name. */ ! 776: ! 777: extern char *function_cannot_inline_p (); ! 778: ! 779: /* Declare commonly used variables for tree structure. */ ! 780: ! 781: /* An integer constant with value 0 */ ! 782: extern tree integer_zero_node; ! 783: ! 784: /* An integer constant with value 1 */ ! 785: extern tree integer_one_node; ! 786: ! 787: /* An integer constant with value 0 whose type is sizetype. */ ! 788: extern tree size_zero_node; ! 789: ! 790: /* An integer constant with value 1 whose type is sizetype. */ ! 791: extern tree size_one_node; ! 792: ! 793: /* A constant of type pointer-to-int and value 0 */ ! 794: extern tree null_pointer_node; ! 795: ! 796: /* A node of type ERROR_MARK. */ ! 797: extern tree error_mark_node; ! 798: ! 799: /* The type node for the void type. */ ! 800: extern tree void_type_node; ! 801: ! 802: /* The type node for the ordinary (signed) integer type. */ ! 803: extern tree integer_type_node; ! 804: ! 805: /* The type node for the unsigned integer type. */ ! 806: extern tree unsigned_type_node; ! 807: ! 808: /* The type node for the ordinary character type. */ ! 809: extern tree char_type_node; ! 810: ! 811: /* Points to the name of the input file from which the current input ! 812: being parsed originally came (before it went into cpp). */ ! 813: extern char *input_filename; ! 814: ! 815: /* Nonzero for -pedantic switch: warn about anything ! 816: that standard C forbids. */ ! 817: extern int pedantic; ! 818: ! 819: /* In stmt.c */ ! 820: ! 821: extern tree get_last_expr (); ! 822: extern void expand_expr_stmt(), clear_last_expr(); ! 823: extern void expand_label(), expand_goto(), expand_asm(); ! 824: extern void expand_start_cond(), expand_end_cond(); ! 825: extern void expand_start_else(), expand_end_else(); ! 826: extern void expand_start_loop(), expand_start_loop_continue_elsewhere(); ! 827: extern void expand_loop_continue_here(); ! 828: extern void expand_end_loop(); ! 829: extern int expand_continue_loop(); ! 830: extern int expand_exit_loop(), expand_exit_loop_if_false(); ! 831: extern int expand_exit_something(); ! 832: ! 833: extern void expand_start_delayed_expr (); ! 834: extern tree expand_end_delayed_expr (); ! 835: extern void expand_emit_delayed_expr (); ! 836: ! 837: extern void expand_null_return(), expand_return(); ! 838: extern void expand_start_bindings(), expand_end_bindings(); ! 839: extern void expand_start_case(), expand_end_case(); ! 840: extern int pushcase(); ! 841: extern void expand_start_function(), expand_end_function();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.