![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-decl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to c-decl.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Process declarations and variables for C compiler. 1.1.1.8 ! root 2: Copyright (C) 1988, 1992, 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: 22: /* Process declarations and symbol lookup for C front end. 23: Also constructs types; the standard scalar types at initialization, 24: and structure, union, array and enum types when they are declared. */ 25: 26: /* ??? not all decl nodes are given the most useful possible 27: line numbers. For example, the CONST_DECLs for enum values. */ 28: 29: #include "config.h" 30: #include "tree.h" 31: #include "flags.h" 1.1.1.8 ! root 32: #include "output.h" 1.1 root 33: #include "c-tree.h" 34: #include "c-lex.h" 35: #include <stdio.h> 36: 37: /* In grokdeclarator, distinguish syntactic contexts of declarators. */ 38: enum decl_context 39: { NORMAL, /* Ordinary declaration */ 40: FUNCDEF, /* Function definition */ 41: PARM, /* Declaration of parm before function body */ 42: FIELD, /* Declaration inside struct or union */ 43: BITFIELD, /* Likewise but with specified width */ 44: TYPENAME}; /* Typename (inside cast or sizeof) */ 45: 46: #ifndef CHAR_TYPE_SIZE 47: #define CHAR_TYPE_SIZE BITS_PER_UNIT 48: #endif 49: 50: #ifndef SHORT_TYPE_SIZE 51: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) 52: #endif 53: 54: #ifndef INT_TYPE_SIZE 55: #define INT_TYPE_SIZE BITS_PER_WORD 56: #endif 57: 58: #ifndef LONG_TYPE_SIZE 59: #define LONG_TYPE_SIZE BITS_PER_WORD 60: #endif 61: 62: #ifndef LONG_LONG_TYPE_SIZE 63: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) 64: #endif 65: 66: #ifndef WCHAR_UNSIGNED 67: #define WCHAR_UNSIGNED 0 68: #endif 69: 70: #ifndef FLOAT_TYPE_SIZE 71: #define FLOAT_TYPE_SIZE BITS_PER_WORD 72: #endif 73: 74: #ifndef DOUBLE_TYPE_SIZE 75: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) 76: #endif 77: 78: #ifndef LONG_DOUBLE_TYPE_SIZE 79: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) 80: #endif 81: 82: /* We let tm.h override the types used here, to handle trivial differences 83: such as the choice of unsigned int or long unsigned int for size_t. 84: When machines start needing nontrivial differences in the size type, 85: it would be best to do something here to figure out automatically 86: from other information what type to use. */ 87: 88: #ifndef SIZE_TYPE 89: #define SIZE_TYPE "long unsigned int" 90: #endif 91: 92: #ifndef PTRDIFF_TYPE 93: #define PTRDIFF_TYPE "long int" 94: #endif 95: 96: #ifndef WCHAR_TYPE 97: #define WCHAR_TYPE "int" 98: #endif 99: 100: /* a node which has tree code ERROR_MARK, and whose type is itself. 101: All erroneous expressions are replaced with this node. All functions 102: that accept nodes as arguments should avoid generating error messages 103: if this node is one of the arguments, since it is undesirable to get 104: multiple error messages from one error in the input. */ 105: 106: tree error_mark_node; 107: 108: /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */ 109: 110: tree short_integer_type_node; 111: tree integer_type_node; 112: tree long_integer_type_node; 113: tree long_long_integer_type_node; 114: 115: tree short_unsigned_type_node; 116: tree unsigned_type_node; 117: tree long_unsigned_type_node; 118: tree long_long_unsigned_type_node; 119: 1.1.1.8 ! root 120: tree boolean_type_node; ! 121: tree boolean_false_node; ! 122: tree boolean_true_node; ! 123: 1.1 root 124: tree ptrdiff_type_node; 125: 126: tree unsigned_char_type_node; 127: tree signed_char_type_node; 128: tree char_type_node; 129: tree wchar_type_node; 130: tree signed_wchar_type_node; 131: tree unsigned_wchar_type_node; 132: 133: tree float_type_node; 134: tree double_type_node; 135: tree long_double_type_node; 136: 1.1.1.5 root 137: tree complex_integer_type_node; 138: tree complex_float_type_node; 139: tree complex_double_type_node; 140: tree complex_long_double_type_node; 141: 1.1.1.4 root 142: tree intQI_type_node; 143: tree intHI_type_node; 144: tree intSI_type_node; 145: tree intDI_type_node; 146: 147: tree unsigned_intQI_type_node; 148: tree unsigned_intHI_type_node; 149: tree unsigned_intSI_type_node; 150: tree unsigned_intDI_type_node; 151: 1.1 root 152: /* a VOID_TYPE node. */ 153: 154: tree void_type_node; 155: 156: /* Nodes for types `void *' and `const void *'. */ 157: 158: tree ptr_type_node, const_ptr_type_node; 159: 160: /* Nodes for types `char *' and `const char *'. */ 161: 162: tree string_type_node, const_string_type_node; 163: 1.1.1.5 root 164: /* Type `char[SOMENUMBER]'. 1.1 root 165: Used when an array of char is needed and the size is irrelevant. */ 166: 167: tree char_array_type_node; 168: 1.1.1.5 root 169: /* Type `int[SOMENUMBER]' or something like it. 1.1 root 170: Used when an array of int needed and the size is irrelevant. */ 171: 172: tree int_array_type_node; 173: 1.1.1.5 root 174: /* Type `wchar_t[SOMENUMBER]' or something like it. 1.1 root 175: Used when a wide string literal is created. */ 176: 177: tree wchar_array_type_node; 178: 179: /* type `int ()' -- used for implicit declaration of functions. */ 180: 181: tree default_function_type; 182: 183: /* function types `double (double)' and `double (double, double)', etc. */ 184: 185: tree double_ftype_double, double_ftype_double_double; 186: tree int_ftype_int, long_ftype_long; 1.1.1.8 ! root 187: tree float_ftype_float; ! 188: tree ldouble_ftype_ldouble; 1.1 root 189: 190: /* Function type `void (void *, void *, int)' and similar ones */ 191: 192: tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int; 193: 194: /* Function type `char *(char *, char *)' and similar ones */ 195: tree string_ftype_ptr_ptr, int_ftype_string_string; 196: 197: /* Function type `int (const void *, const void *, size_t)' */ 198: tree int_ftype_cptr_cptr_sizet; 199: 200: /* Two expressions that are constants with value zero. 201: The first is of type `int', the second of type `void *'. */ 202: 203: tree integer_zero_node; 204: tree null_pointer_node; 205: 206: /* A node for the integer constant 1. */ 207: 208: tree integer_one_node; 209: 210: /* Nonzero if we have seen an invalid cross reference 211: to a struct, union, or enum, but not yet printed the message. */ 212: 213: tree pending_invalid_xref; 214: /* File and line to appear in the eventual error message. */ 215: char *pending_invalid_xref_file; 216: int pending_invalid_xref_line; 217: 218: /* While defining an enum type, this is 1 plus the last enumerator 1.1.1.6 root 219: constant value. Note that will do not have to save this or `enum_overflow' 220: around nested function definition since such a definition could only 221: occur in an enum value expression and we don't use these variables in 222: that case. */ 1.1 root 223: 224: static tree enum_next_value; 225: 1.1.1.3 root 226: /* Nonzero means that there was overflow computing enum_next_value. */ 227: 228: static int enum_overflow; 229: 1.1 root 230: /* Parsing a function declarator leaves a list of parameter names 231: or a chain or parameter decls here. */ 232: 233: static tree last_function_parms; 234: 235: /* Parsing a function declarator leaves here a chain of structure 236: and enum types declared in the parmlist. */ 237: 238: static tree last_function_parm_tags; 239: 240: /* After parsing the declarator that starts a function definition, 241: `start_function' puts here the list of parameter names or chain of decls. 242: `store_parm_decls' finds it here. */ 243: 244: static tree current_function_parms; 245: 246: /* Similar, for last_function_parm_tags. */ 247: static tree current_function_parm_tags; 248: 1.1.1.5 root 249: /* Similar, for the file and line that the prototype came from if this is 250: an old-style definition. */ 251: static char *current_function_prototype_file; 252: static int current_function_prototype_line; 253: 1.1 root 254: /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function 255: that have names. Here so we can clear out their names' definitions 256: at the end of the function. */ 257: 1.1.1.4 root 258: static tree named_labels; 1.1 root 259: 260: /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */ 261: 262: static tree shadowed_labels; 263: 264: /* Nonzero when store_parm_decls is called indicates a varargs function. 265: Value not meaningful after store_parm_decls. */ 266: 267: static int c_function_varargs; 268: 269: /* The FUNCTION_DECL for the function currently being compiled, 270: or 0 if between functions. */ 271: tree current_function_decl; 272: 273: /* Set to 0 at beginning of a function definition, set to 1 if 274: a return statement that specifies a return value is seen. */ 275: 276: int current_function_returns_value; 277: 278: /* Set to 0 at beginning of a function definition, set to 1 if 279: a return statement with no argument is seen. */ 280: 281: int current_function_returns_null; 282: 283: /* Set to nonzero by `grokdeclarator' for a function 284: whose return type is defaulted, if warnings for this are desired. */ 285: 286: static int warn_about_return_type; 287: 1.1.1.2 root 288: /* Nonzero when starting a function declared `extern inline'. */ 1.1 root 289: 290: static int current_extern_inline; 291: 292: /* For each binding contour we allocate a binding_level structure 293: * which records the names defined in that contour. 294: * Contours include: 295: * 0) the global one 296: * 1) one for each function definition, 297: * where internal declarations of the parameters appear. 298: * 2) one for each compound statement, 299: * to record its declarations. 300: * 301: * The current meaning of a name can be found by searching the levels from 302: * the current one out to the global one. 303: */ 304: 305: /* Note that the information in the `names' component of the global contour 306: is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */ 307: 308: struct binding_level 309: { 310: /* A chain of _DECL nodes for all variables, constants, functions, 311: and typedef types. These are in the reverse of the order supplied. 312: */ 313: tree names; 314: 315: /* A list of structure, union and enum definitions, 316: * for looking up tag names. 317: * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name, 318: * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE, 319: * or ENUMERAL_TYPE node. 320: */ 321: tree tags; 322: 323: /* For each level, a list of shadowed outer-level local definitions 324: to be restored when this level is popped. 325: Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and 326: whose TREE_VALUE is its old definition (a kind of ..._DECL node). */ 327: tree shadowed; 328: 329: /* For each level (except not the global one), 330: a chain of BLOCK nodes for all the levels 331: that were entered and exited one level down. */ 332: tree blocks; 333: 1.1.1.4 root 334: /* The BLOCK node for this level, if one has been preallocated. 335: If 0, the BLOCK is allocated (if needed) when the level is popped. */ 336: tree this_block; 337: 1.1 root 338: /* The binding level which this one is contained in (inherits from). */ 339: struct binding_level *level_chain; 340: 341: /* Nonzero for the level that holds the parameters of a function. */ 342: char parm_flag; 343: 344: /* Nonzero if this level "doesn't exist" for tags. */ 345: char tag_transparent; 346: 347: /* Nonzero if sublevels of this level "don't exist" for tags. 348: This is set in the parm level of a function definition 349: while reading the function body, so that the outermost block 350: of the function body will be tag-transparent. */ 351: char subblocks_tag_transparent; 352: 353: /* Nonzero means make a BLOCK for this level regardless of all else. */ 354: char keep; 355: 356: /* Nonzero means make a BLOCK if this level has any subblocks. */ 357: char keep_if_subblocks; 358: 359: /* Number of decls in `names' that have incomplete 360: structure or union types. */ 361: int n_incomplete; 362: 363: /* A list of decls giving the (reversed) specified order of parms, 364: not including any forward-decls in the parmlist. 365: This is so we can put the parms in proper order for assign_parms. */ 366: tree parm_order; 367: }; 368: 369: #define NULL_BINDING_LEVEL (struct binding_level *) NULL 370: 371: /* The binding level currently in effect. */ 372: 373: static struct binding_level *current_binding_level; 374: 375: /* A chain of binding_level structures awaiting reuse. */ 376: 377: static struct binding_level *free_binding_level; 378: 379: /* The outermost binding level, for names of file scope. 380: This is created when the compiler is started and exists 381: through the entire run. */ 382: 383: static struct binding_level *global_binding_level; 384: 385: /* Binding level structures are initialized by copying this one. */ 386: 387: static struct binding_level clear_binding_level 1.1.1.7 root 388: = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, 0, 389: NULL}; 1.1 root 390: 391: /* Nonzero means unconditionally make a BLOCK for the next level pushed. */ 392: 393: static int keep_next_level_flag; 394: 395: /* Nonzero means make a BLOCK for the next level pushed 396: if it has subblocks. */ 397: 398: static int keep_next_if_subblocks; 399: 400: /* The chain of outer levels of label scopes. 401: This uses the same data structure used for binding levels, 402: but it works differently: each link in the chain records 403: saved values of named_labels and shadowed_labels for 404: a label binding level outside the current one. */ 405: 406: static struct binding_level *label_level_chain; 407: 1.1.1.8 ! root 408: /* Functions called automatically at the beginning and end of execution. */ ! 409: ! 410: tree static_ctors, static_dtors; ! 411: 1.1 root 412: /* Forward declarations. */ 413: 414: static tree grokparms (), grokdeclarator (); 415: tree pushdecl (); 1.1.1.2 root 416: tree builtin_function (); 1.1.1.4 root 417: void shadow_tag_warned (); 1.1 root 418: 419: static tree lookup_tag (); 420: static tree lookup_tag_reverse (); 1.1.1.5 root 421: tree lookup_name_current_level (); 1.1 root 422: static char *redeclaration_error_message (); 423: static void layout_array_type (); 424: 425: /* C-specific option variables. */ 426: 427: /* Nonzero means allow type mismatches in conditional expressions; 428: just make their values `void'. */ 429: 430: int flag_cond_mismatch; 431: 432: /* Nonzero means give `double' the same size as `float'. */ 433: 434: int flag_short_double; 435: 436: /* Nonzero means don't recognize the keyword `asm'. */ 437: 438: int flag_no_asm; 439: 1.1.1.3 root 440: /* Nonzero means don't recognize any builtin functions. */ 1.1 root 441: 442: int flag_no_builtin; 443: 1.1.1.3 root 444: /* Nonzero means don't recognize the non-ANSI builtin functions. 445: -ansi sets this. */ 446: 447: int flag_no_nonansi_builtin; 448: 1.1 root 449: /* Nonzero means do some things the same way PCC does. */ 450: 451: int flag_traditional; 452: 1.1.1.6 root 453: /* Nonzero means to allow single precision math even if we're generally 454: being traditional. */ 455: int flag_allow_single_precision = 0; 456: 1.1 root 457: /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */ 458: 459: int flag_signed_bitfields = 1; 1.1.1.4 root 460: int explicit_flag_signed_bitfields = 0; 1.1 root 461: 462: /* Nonzero means handle `#ident' directives. 0 means ignore them. */ 463: 464: int flag_no_ident = 0; 465: 466: /* Nonzero means warn about implicit declarations. */ 467: 468: int warn_implicit; 469: 470: /* Nonzero means give string constants the type `const char *' 471: to get extra warnings from them. These warnings will be too numerous 472: to be useful, except in thoroughly ANSIfied programs. */ 473: 474: int warn_write_strings; 475: 476: /* Nonzero means warn about pointer casts that can drop a type qualifier 477: from the pointer target type. */ 478: 479: int warn_cast_qual; 480: 1.1.1.7 root 481: /* Nonzero means warn when casting a function call to a type that does 482: not match the return type (e.g. (float)sqrt() or (anything*)malloc() 483: when there is no previous declaration of sqrt or malloc. */ 484: 485: int warn_bad_function_cast; 486: 1.1 root 487: /* Warn about traditional constructs whose meanings changed in ANSI C. */ 488: 489: int warn_traditional; 490: 491: /* Nonzero means warn about sizeof(function) or addition/subtraction 492: of function pointers. */ 493: 494: int warn_pointer_arith; 495: 496: /* Nonzero means warn for non-prototype function decls 497: or non-prototyped defs without previous prototype. */ 498: 499: int warn_strict_prototypes; 500: 501: /* Nonzero means warn for any global function def 502: without separate previous prototype decl. */ 503: 504: int warn_missing_prototypes; 505: 1.1.1.7 root 506: /* Nonzero means warn for any global function def 507: without separate previous decl. */ 508: 509: int warn_missing_declarations; 510: 1.1 root 511: /* Nonzero means warn about multiple (redundant) decls for the same single 512: variable or function. */ 513: 514: int warn_redundant_decls = 0; 515: 516: /* Nonzero means warn about extern declarations of objects not at 517: file-scope level and about *all* declarations of functions (whether 518: extern or static) not at file-scope level. Note that we exclude 519: implicit function declarations. To get warnings about those, use 520: -Wimplicit. */ 521: 522: int warn_nested_externs = 0; 523: 524: /* Warn about *printf or *scanf format/argument anomalies. */ 525: 526: int warn_format; 527: 528: /* Warn about a subscript that has type char. */ 529: 530: int warn_char_subscripts = 0; 531: 532: /* Warn if a type conversion is done that might have confusing results. */ 533: 534: int warn_conversion; 535: 536: /* Warn if adding () is suggested. */ 537: 1.1.1.2 root 538: int warn_parentheses; 1.1 root 539: 1.1.1.5 root 540: /* Warn if initializer is not completely bracketed. */ 541: 542: int warn_missing_braces; 543: 1.1 root 544: /* Nonzero means `$' can be in an identifier. 545: See cccp.c for reasons why this breaks some obscure ANSI C programs. */ 546: 547: #ifndef DOLLARS_IN_IDENTIFIERS 548: #define DOLLARS_IN_IDENTIFIERS 1 549: #endif 550: int dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1; 551: 552: /* Decode the string P as a language-specific option for C. 553: Return 1 if it is recognized (and handle it); 554: return 0 if not recognized. */ 555: 556: int 557: c_decode_option (p) 558: char *p; 559: { 560: if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional")) 561: { 562: flag_traditional = 1; 563: flag_writable_strings = 1; 564: #if DOLLARS_IN_IDENTIFIERS > 0 565: dollars_in_ident = 1; 566: #endif 567: } 1.1.1.6 root 568: else if (!strcmp (p, "-fallow-single-precision")) 569: flag_allow_single_precision = 1; 1.1.1.4 root 570: else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional")) 571: { 572: flag_traditional = 0; 573: flag_writable_strings = 0; 574: dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1; 575: } 1.1.1.6 root 576: else if (!strcmp (p, "-fdollars-in-identifiers")) 577: { 578: #if DOLLARS_IN_IDENTIFIERS > 0 579: dollars_in_ident = 1; 580: #endif 581: } 1.1.1.7 root 582: else if (!strcmp (p, "-fno-dollars-in-identifiers")) 1.1.1.6 root 583: dollars_in_ident = 0; 1.1 root 584: else if (!strcmp (p, "-fsigned-char")) 585: flag_signed_char = 1; 586: else if (!strcmp (p, "-funsigned-char")) 587: flag_signed_char = 0; 588: else if (!strcmp (p, "-fno-signed-char")) 589: flag_signed_char = 0; 590: else if (!strcmp (p, "-fno-unsigned-char")) 591: flag_signed_char = 1; 1.1.1.4 root 592: else if (!strcmp (p, "-fsigned-bitfields") 593: || !strcmp (p, "-fno-unsigned-bitfields")) 594: { 595: flag_signed_bitfields = 1; 596: explicit_flag_signed_bitfields = 1; 597: } 598: else if (!strcmp (p, "-funsigned-bitfields") 599: || !strcmp (p, "-fno-signed-bitfields")) 600: { 601: flag_signed_bitfields = 0; 602: explicit_flag_signed_bitfields = 1; 603: } 1.1 root 604: else if (!strcmp (p, "-fshort-enums")) 605: flag_short_enums = 1; 606: else if (!strcmp (p, "-fno-short-enums")) 607: flag_short_enums = 0; 608: else if (!strcmp (p, "-fcond-mismatch")) 609: flag_cond_mismatch = 1; 610: else if (!strcmp (p, "-fno-cond-mismatch")) 611: flag_cond_mismatch = 0; 612: else if (!strcmp (p, "-fshort-double")) 613: flag_short_double = 1; 614: else if (!strcmp (p, "-fno-short-double")) 615: flag_short_double = 0; 616: else if (!strcmp (p, "-fasm")) 617: flag_no_asm = 0; 618: else if (!strcmp (p, "-fno-asm")) 619: flag_no_asm = 1; 620: else if (!strcmp (p, "-fbuiltin")) 621: flag_no_builtin = 0; 622: else if (!strcmp (p, "-fno-builtin")) 623: flag_no_builtin = 1; 624: else if (!strcmp (p, "-fno-ident")) 625: flag_no_ident = 1; 626: else if (!strcmp (p, "-fident")) 627: flag_no_ident = 0; 628: else if (!strcmp (p, "-ansi")) 1.1.1.3 root 629: flag_no_asm = 1, flag_no_nonansi_builtin = 1, dollars_in_ident = 0; 1.1 root 630: else if (!strcmp (p, "-Wimplicit")) 631: warn_implicit = 1; 632: else if (!strcmp (p, "-Wno-implicit")) 633: warn_implicit = 0; 634: else if (!strcmp (p, "-Wwrite-strings")) 635: warn_write_strings = 1; 636: else if (!strcmp (p, "-Wno-write-strings")) 637: warn_write_strings = 0; 638: else if (!strcmp (p, "-Wcast-qual")) 639: warn_cast_qual = 1; 640: else if (!strcmp (p, "-Wno-cast-qual")) 641: warn_cast_qual = 0; 1.1.1.7 root 642: else if (!strcmp (p, "-Wbad-function-cast")) 643: warn_bad_function_cast = 1; 644: else if (!strcmp (p, "-Wno-bad-function-cast")) 645: warn_bad_function_cast = 0; 1.1 root 646: else if (!strcmp (p, "-Wpointer-arith")) 647: warn_pointer_arith = 1; 648: else if (!strcmp (p, "-Wno-pointer-arith")) 649: warn_pointer_arith = 0; 650: else if (!strcmp (p, "-Wstrict-prototypes")) 651: warn_strict_prototypes = 1; 652: else if (!strcmp (p, "-Wno-strict-prototypes")) 653: warn_strict_prototypes = 0; 654: else if (!strcmp (p, "-Wmissing-prototypes")) 655: warn_missing_prototypes = 1; 656: else if (!strcmp (p, "-Wno-missing-prototypes")) 657: warn_missing_prototypes = 0; 1.1.1.7 root 658: else if (!strcmp (p, "-Wmissing-declarations")) 659: warn_missing_declarations = 1; 660: else if (!strcmp (p, "-Wno-missing-declarations")) 661: warn_missing_declarations = 0; 1.1 root 662: else if (!strcmp (p, "-Wredundant-decls")) 663: warn_redundant_decls = 1; 1.1.1.3 root 664: else if (!strcmp (p, "-Wno-redundant-decls")) 1.1 root 665: warn_redundant_decls = 0; 666: else if (!strcmp (p, "-Wnested-externs")) 667: warn_nested_externs = 1; 668: else if (!strcmp (p, "-Wno-nested-externs")) 669: warn_nested_externs = 0; 670: else if (!strcmp (p, "-Wtraditional")) 671: warn_traditional = 1; 672: else if (!strcmp (p, "-Wno-traditional")) 673: warn_traditional = 0; 674: else if (!strcmp (p, "-Wformat")) 675: warn_format = 1; 676: else if (!strcmp (p, "-Wno-format")) 677: warn_format = 0; 678: else if (!strcmp (p, "-Wchar-subscripts")) 679: warn_char_subscripts = 1; 680: else if (!strcmp (p, "-Wno-char-subscripts")) 681: warn_char_subscripts = 0; 682: else if (!strcmp (p, "-Wconversion")) 683: warn_conversion = 1; 684: else if (!strcmp (p, "-Wno-conversion")) 685: warn_conversion = 0; 686: else if (!strcmp (p, "-Wparentheses")) 687: warn_parentheses = 1; 688: else if (!strcmp (p, "-Wno-parentheses")) 689: warn_parentheses = 0; 1.1.1.4 root 690: else if (!strcmp (p, "-Wreturn-type")) 691: warn_return_type = 1; 692: else if (!strcmp (p, "-Wno-return-type")) 693: warn_return_type = 0; 1.1 root 694: else if (!strcmp (p, "-Wcomment")) 695: ; /* cpp handles this one. */ 696: else if (!strcmp (p, "-Wno-comment")) 697: ; /* cpp handles this one. */ 698: else if (!strcmp (p, "-Wcomments")) 699: ; /* cpp handles this one. */ 700: else if (!strcmp (p, "-Wno-comments")) 701: ; /* cpp handles this one. */ 702: else if (!strcmp (p, "-Wtrigraphs")) 703: ; /* cpp handles this one. */ 704: else if (!strcmp (p, "-Wno-trigraphs")) 705: ; /* cpp handles this one. */ 1.1.1.3 root 706: else if (!strcmp (p, "-Wimport")) 707: ; /* cpp handles this one. */ 708: else if (!strcmp (p, "-Wno-import")) 709: ; /* cpp handles this one. */ 1.1.1.5 root 710: else if (!strcmp (p, "-Wmissing-braces")) 711: warn_missing_braces = 1; 712: else if (!strcmp (p, "-Wno-missing-braces")) 713: warn_missing_braces = 0; 1.1 root 714: else if (!strcmp (p, "-Wall")) 715: { 1.1.1.5 root 716: /* We save the value of warn_uninitialized, since if they put 717: -Wuninitialized on the command line, we need to generate a 718: warning about not using it without also specifying -O. */ 719: if (warn_uninitialized != 1) 720: warn_uninitialized = 2; 1.1 root 721: warn_implicit = 1; 722: warn_return_type = 1; 723: warn_unused = 1; 724: warn_switch = 1; 725: warn_format = 1; 726: warn_char_subscripts = 1; 1.1.1.2 root 727: warn_parentheses = 1; 1.1.1.5 root 728: warn_missing_braces = 1; 1.1 root 729: } 730: else 731: return 0; 732: 733: return 1; 734: } 735: 736: /* Hooks for print_node. */ 737: 738: void 1.1.1.6 root 739: print_lang_decl (file, node, indent) 740: FILE *file; 741: tree node; 742: int indent; 1.1 root 743: { 744: } 745: 746: void 1.1.1.6 root 747: print_lang_type (file, node, indent) 748: FILE *file; 749: tree node; 750: int indent; 1.1 root 751: { 752: } 753: 754: void 755: print_lang_identifier (file, node, indent) 756: FILE *file; 757: tree node; 758: int indent; 759: { 760: print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4); 761: print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4); 762: print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4); 763: print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4); 764: print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4); 1.1.1.4 root 765: print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4); 1.1 root 766: } 767: 1.1.1.5 root 768: /* Hook called at end of compilation to assume 1 elt 769: for a top-level array decl that wasn't complete before. */ 770: 771: void 772: finish_incomplete_decl (decl) 773: tree decl; 774: { 775: if (TREE_CODE (decl) == VAR_DECL && TREE_TYPE (decl) != error_mark_node) 776: { 777: tree type = TREE_TYPE (decl); 778: if (TREE_CODE (type) == ARRAY_TYPE 779: && TYPE_DOMAIN (type) == 0 780: && TREE_CODE (decl) != TYPE_DECL) 781: { 782: complete_array_type (type, NULL_TREE, 1); 783: 784: layout_decl (decl, 0); 785: } 786: } 787: } 788: 1.1 root 789: /* Create a new `struct binding_level'. */ 790: 791: static 792: struct binding_level * 793: make_binding_level () 794: { 795: /* NOSTRICT */ 796: return (struct binding_level *) xmalloc (sizeof (struct binding_level)); 797: } 798: 799: /* Nonzero if we are currently in the global binding level. */ 800: 801: int 802: global_bindings_p () 803: { 804: return current_binding_level == global_binding_level; 805: } 806: 807: void 808: keep_next_level () 809: { 810: keep_next_level_flag = 1; 811: } 812: 813: /* Nonzero if the current level needs to have a BLOCK made. */ 814: 815: int 816: kept_level_p () 817: { 818: return ((current_binding_level->keep_if_subblocks 819: && current_binding_level->blocks != 0) 820: || current_binding_level->keep 821: || current_binding_level->names != 0 822: || (current_binding_level->tags != 0 823: && !current_binding_level->tag_transparent)); 824: } 825: 826: /* Identify this binding level as a level of parameters. 1.1.1.5 root 827: DEFINITION_FLAG is 1 for a definition, 0 for a declaration. 828: But it turns out there is no way to pass the right value for 829: DEFINITION_FLAG, so we ignore it. */ 1.1 root 830: 831: void 832: declare_parm_level (definition_flag) 833: int definition_flag; 834: { 1.1.1.5 root 835: current_binding_level->parm_flag = 1; 1.1 root 836: } 837: 838: /* Nonzero if currently making parm declarations. */ 839: 840: int 841: in_parm_level_p () 842: { 843: return current_binding_level->parm_flag; 844: } 845: 846: /* Enter a new binding level. 847: If TAG_TRANSPARENT is nonzero, do so only for the name space of variables, 848: not for that of tags. */ 849: 850: void 851: pushlevel (tag_transparent) 852: int tag_transparent; 853: { 854: register struct binding_level *newlevel = NULL_BINDING_LEVEL; 855: 856: /* If this is the top level of a function, 857: just make sure that NAMED_LABELS is 0. */ 858: 859: if (current_binding_level == global_binding_level) 860: { 861: named_labels = 0; 862: } 863: 864: /* Reuse or create a struct for this binding level. */ 865: 866: if (free_binding_level) 867: { 868: newlevel = free_binding_level; 869: free_binding_level = free_binding_level->level_chain; 870: } 871: else 872: { 873: newlevel = make_binding_level (); 874: } 875: 876: /* Add this level to the front of the chain (stack) of levels that 877: are active. */ 878: 879: *newlevel = clear_binding_level; 880: newlevel->tag_transparent 881: = (tag_transparent 882: || (current_binding_level 883: ? current_binding_level->subblocks_tag_transparent 884: : 0)); 885: newlevel->level_chain = current_binding_level; 886: current_binding_level = newlevel; 887: newlevel->keep = keep_next_level_flag; 888: keep_next_level_flag = 0; 889: newlevel->keep_if_subblocks = keep_next_if_subblocks; 890: keep_next_if_subblocks = 0; 891: } 892: 893: /* Exit a binding level. 894: Pop the level off, and restore the state of the identifier-decl mappings 895: that were in effect when this level was entered. 896: 897: If KEEP is nonzero, this level had explicit declarations, so 898: and create a "block" (a BLOCK node) for the level 899: to record its declarations and subblocks for symbol table output. 900: 901: If FUNCTIONBODY is nonzero, this level is the body of a function, 902: so create a block as if KEEP were set and also clear out all 903: label names. 904: 905: If REVERSE is nonzero, reverse the order of decls before putting 906: them into the BLOCK. */ 907: 908: tree 909: poplevel (keep, reverse, functionbody) 910: int keep; 911: int reverse; 912: int functionbody; 913: { 914: register tree link; 915: /* The chain of decls was accumulated in reverse order. 916: Put it into forward order, just for cleanliness. */ 917: tree decls; 918: tree tags = current_binding_level->tags; 919: tree subblocks = current_binding_level->blocks; 920: tree block = 0; 921: tree decl; 1.1.1.4 root 922: int block_previously_created; 1.1 root 923: 924: keep |= current_binding_level->keep; 925: 926: /* This warning is turned off because it causes warnings for 927: declarations like `extern struct foo *x'. */ 928: #if 0 929: /* Warn about incomplete structure types in this level. */ 930: for (link = tags; link; link = TREE_CHAIN (link)) 931: if (TYPE_SIZE (TREE_VALUE (link)) == 0) 932: { 933: tree type = TREE_VALUE (link); 934: char *errmsg; 935: switch (TREE_CODE (type)) 936: { 937: case RECORD_TYPE: 938: errmsg = "`struct %s' incomplete in scope ending here"; 939: break; 940: case UNION_TYPE: 941: errmsg = "`union %s' incomplete in scope ending here"; 942: break; 943: case ENUMERAL_TYPE: 944: errmsg = "`enum %s' incomplete in scope ending here"; 945: break; 946: } 947: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 948: error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type))); 949: else 950: /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */ 951: error (errmsg, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); 952: } 953: #endif /* 0 */ 954: 955: /* Get the decls in the order they were written. 956: Usually current_binding_level->names is in reverse order. 957: But parameter decls were previously put in forward order. */ 958: 959: if (reverse) 960: current_binding_level->names 961: = decls = nreverse (current_binding_level->names); 962: else 963: decls = current_binding_level->names; 964: 965: /* Output any nested inline functions within this block 966: if they weren't already output. */ 967: 968: for (decl = decls; decl; decl = TREE_CHAIN (decl)) 969: if (TREE_CODE (decl) == FUNCTION_DECL 970: && ! TREE_ASM_WRITTEN (decl) 971: && DECL_INITIAL (decl) != 0 972: && TREE_ADDRESSABLE (decl)) 1.1.1.4 root 973: { 974: /* If this decl was copied from a file-scope decl 975: on account of a block-scope extern decl, 1.1.1.8 ! root 976: propagate TREE_ADDRESSABLE to the file-scope decl. ! 977: ! 978: DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is ! 979: true, since then the decl goes through save_for_inline_copying. */ ! 980: if (DECL_ABSTRACT_ORIGIN (decl) != 0 ! 981: && DECL_ABSTRACT_ORIGIN (decl) != decl) 1.1.1.4 root 982: TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1; 983: else 1.1.1.6 root 984: { 985: push_function_context (); 986: output_inline_function (decl); 987: pop_function_context (); 988: } 1.1.1.4 root 989: } 1.1 root 990: 991: /* If there were any declarations or structure tags in that level, 992: or if this level is a function body, 993: create a BLOCK to record them for the life of this function. */ 994: 1.1.1.4 root 995: block = 0; 996: block_previously_created = (current_binding_level->this_block != 0); 997: if (block_previously_created) 998: block = current_binding_level->this_block; 999: else if (keep || functionbody 1000: || (current_binding_level->keep_if_subblocks && subblocks != 0)) 1001: block = make_node (BLOCK); 1002: if (block != 0) 1003: { 1004: BLOCK_VARS (block) = decls; 1005: BLOCK_TYPE_TAGS (block) = tags; 1006: BLOCK_SUBBLOCKS (block) = subblocks; 1007: remember_end_note (block); 1008: } 1.1 root 1009: 1010: /* In each subblock, record that this is its superior. */ 1011: 1012: for (link = subblocks; link; link = TREE_CHAIN (link)) 1013: BLOCK_SUPERCONTEXT (link) = block; 1014: 1015: /* Clear out the meanings of the local variables of this level. */ 1016: 1017: for (link = decls; link; link = TREE_CHAIN (link)) 1018: { 1019: if (DECL_NAME (link) != 0) 1020: { 1021: /* If the ident. was used or addressed via a local extern decl, 1022: don't forget that fact. */ 1.1.1.4 root 1023: if (DECL_EXTERNAL (link)) 1.1 root 1024: { 1025: if (TREE_USED (link)) 1026: TREE_USED (DECL_NAME (link)) = 1; 1027: if (TREE_ADDRESSABLE (link)) 1028: TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1; 1029: } 1030: IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0; 1031: } 1032: } 1033: 1034: /* Restore all name-meanings of the outer levels 1035: that were shadowed by this level. */ 1036: 1037: for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link)) 1038: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link); 1039: 1040: /* If the level being exited is the top level of a function, 1041: check over all the labels, and clear out the current 1042: (function local) meanings of their names. */ 1043: 1044: if (functionbody) 1045: { 1046: /* If this is the top level block of a function, 1047: the vars are the function's parameters. 1048: Don't leave them in the BLOCK because they are 1049: found in the FUNCTION_DECL instead. */ 1050: 1051: BLOCK_VARS (block) = 0; 1052: 1053: /* Clear out the definitions of all label names, 1054: since their scopes end here, 1055: and add them to BLOCK_VARS. */ 1056: 1057: for (link = named_labels; link; link = TREE_CHAIN (link)) 1058: { 1059: register tree label = TREE_VALUE (link); 1060: 1061: if (DECL_INITIAL (label) == 0) 1062: { 1063: error_with_decl (label, "label `%s' used but not defined"); 1064: /* Avoid crashing later. */ 1065: define_label (input_filename, lineno, 1066: DECL_NAME (label)); 1067: } 1068: else if (warn_unused && !TREE_USED (label)) 1069: warning_with_decl (label, "label `%s' defined but not used"); 1070: IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0; 1071: 1072: /* Put the labels into the "variables" of the 1073: top-level block, so debugger can see them. */ 1074: TREE_CHAIN (label) = BLOCK_VARS (block); 1075: BLOCK_VARS (block) = label; 1076: } 1077: } 1078: 1079: /* Pop the current level, and free the structure for reuse. */ 1080: 1081: { 1082: register struct binding_level *level = current_binding_level; 1083: current_binding_level = current_binding_level->level_chain; 1084: 1085: level->level_chain = free_binding_level; 1086: free_binding_level = level; 1087: } 1088: 1089: /* Dispose of the block that we just made inside some higher level. */ 1090: if (functionbody) 1091: DECL_INITIAL (current_function_decl) = block; 1092: else if (block) 1.1.1.4 root 1093: { 1094: if (!block_previously_created) 1095: current_binding_level->blocks 1096: = chainon (current_binding_level->blocks, block); 1097: } 1.1 root 1098: /* If we did not make a block for the level just exited, 1099: any blocks made for inner levels 1100: (since they cannot be recorded as subblocks in that level) 1101: must be carried forward so they will later become subblocks 1102: of something else. */ 1103: else if (subblocks) 1104: current_binding_level->blocks 1105: = chainon (current_binding_level->blocks, subblocks); 1106: 1107: /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this 1108: binding contour so that they point to the appropriate construct, i.e. 1109: either to the current FUNCTION_DECL node, or else to the BLOCK node 1110: we just constructed. 1111: 1112: Note that for tagged types whose scope is just the formal parameter 1113: list for some function type specification, we can't properly set 1114: their TYPE_CONTEXTs here, because we don't have a pointer to the 1115: appropriate FUNCTION_TYPE node readily available to us. For those 1116: cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set 1117: in `grokdeclarator' as soon as we have created the FUNCTION_TYPE 1118: node which will represent the "scope" for these "parameter list local" 1119: tagged types. 1120: */ 1121: 1122: if (functionbody) 1123: for (link = tags; link; link = TREE_CHAIN (link)) 1124: TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl; 1125: else if (block) 1126: for (link = tags; link; link = TREE_CHAIN (link)) 1127: TYPE_CONTEXT (TREE_VALUE (link)) = block; 1128: 1129: if (block) 1130: TREE_USED (block) = 1; 1131: return block; 1132: } 1.1.1.4 root 1133: 1134: /* Delete the node BLOCK from the current binding level. 1135: This is used for the block inside a stmt expr ({...}) 1136: so that the block can be reinserted where appropriate. */ 1137: 1138: void 1139: delete_block (block) 1140: tree block; 1141: { 1142: tree t; 1143: if (current_binding_level->blocks == block) 1144: current_binding_level->blocks = TREE_CHAIN (block); 1145: for (t = current_binding_level->blocks; t;) 1146: { 1147: if (TREE_CHAIN (t) == block) 1148: TREE_CHAIN (t) = TREE_CHAIN (block); 1149: else 1150: t = TREE_CHAIN (t); 1151: } 1152: TREE_CHAIN (block) = NULL; 1153: /* Clear TREE_USED which is always set by poplevel. 1154: The flag is set again if insert_block is called. */ 1155: TREE_USED (block) = 0; 1156: } 1157: 1158: /* Insert BLOCK at the end of the list of subblocks of the 1159: current binding level. This is used when a BIND_EXPR is expanded, 1.1.1.6 root 1160: to handle the BLOCK node inside the BIND_EXPR. */ 1.1.1.4 root 1161: 1162: void 1163: insert_block (block) 1164: tree block; 1165: { 1166: TREE_USED (block) = 1; 1167: current_binding_level->blocks 1168: = chainon (current_binding_level->blocks, block); 1169: } 1170: 1171: /* Set the BLOCK node for the innermost scope 1172: (the one we are currently in). */ 1173: 1174: void 1175: set_block (block) 1176: register tree block; 1177: { 1178: current_binding_level->this_block = block; 1179: } 1.1 root 1180: 1181: void 1182: push_label_level () 1183: { 1184: register struct binding_level *newlevel; 1185: 1186: /* Reuse or create a struct for this binding level. */ 1187: 1188: if (free_binding_level) 1189: { 1190: newlevel = free_binding_level; 1191: free_binding_level = free_binding_level->level_chain; 1192: } 1193: else 1194: { 1195: newlevel = make_binding_level (); 1196: } 1197: 1198: /* Add this level to the front of the chain (stack) of label levels. */ 1199: 1200: newlevel->level_chain = label_level_chain; 1201: label_level_chain = newlevel; 1202: 1203: newlevel->names = named_labels; 1204: newlevel->shadowed = shadowed_labels; 1205: named_labels = 0; 1206: shadowed_labels = 0; 1207: } 1208: 1209: void 1210: pop_label_level () 1211: { 1212: register struct binding_level *level = label_level_chain; 1213: tree link, prev; 1214: 1215: /* Clear out the definitions of the declared labels in this level. 1216: Leave in the list any ordinary, non-declared labels. */ 1217: for (link = named_labels, prev = 0; link;) 1218: { 1219: if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link))) 1220: { 1221: if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0) 1222: { 1.1.1.5 root 1223: error_with_decl (TREE_VALUE (link), 1224: "label `%s' used but not defined"); 1.1 root 1225: /* Avoid crashing later. */ 1226: define_label (input_filename, lineno, 1227: DECL_NAME (TREE_VALUE (link))); 1228: } 1229: else if (warn_unused && !TREE_USED (TREE_VALUE (link))) 1230: warning_with_decl (TREE_VALUE (link), 1231: "label `%s' defined but not used"); 1232: IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0; 1233: 1234: /* Delete this element from the list. */ 1235: link = TREE_CHAIN (link); 1236: if (prev) 1237: TREE_CHAIN (prev) = link; 1238: else 1239: named_labels = link; 1240: } 1241: else 1242: { 1243: prev = link; 1244: link = TREE_CHAIN (link); 1245: } 1246: } 1247: 1248: /* Bring back all the labels that were shadowed. */ 1249: for (link = shadowed_labels; link; link = TREE_CHAIN (link)) 1250: if (DECL_NAME (TREE_VALUE (link)) != 0) 1251: IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) 1252: = TREE_VALUE (link); 1253: 1254: named_labels = chainon (named_labels, level->names); 1255: shadowed_labels = level->shadowed; 1256: 1257: /* Pop the current level, and free the structure for reuse. */ 1258: label_level_chain = label_level_chain->level_chain; 1259: level->level_chain = free_binding_level; 1260: free_binding_level = level; 1261: } 1262: 1263: /* Push a definition or a declaration of struct, union or enum tag "name". 1264: "type" should be the type node. 1265: We assume that the tag "name" is not already defined. 1266: 1267: Note that the definition may really be just a forward reference. 1268: In that case, the TYPE_SIZE will be zero. */ 1269: 1270: void 1271: pushtag (name, type) 1272: tree name, type; 1273: { 1274: register struct binding_level *b; 1275: 1276: /* Find the proper binding level for this type tag. */ 1277: 1278: for (b = current_binding_level; b->tag_transparent; b = b->level_chain) 1279: continue; 1280: 1281: if (name) 1282: { 1283: /* Record the identifier as the type's name if it has none. */ 1284: 1285: if (TYPE_NAME (type) == 0) 1286: TYPE_NAME (type) = name; 1287: } 1288: 1.1.1.2 root 1289: if (b == global_binding_level) 1290: b->tags = perm_tree_cons (name, type, b->tags); 1291: else 1292: b->tags = saveable_tree_cons (name, type, b->tags); 1293: 1.1 root 1294: /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the 1295: tagged type we just added to the current binding level. This fake 1296: NULL-named TYPE_DECL node helps dwarfout.c to know when it needs 1.1.1.4 root 1297: to output a representation of a tagged type, and it also gives 1.1 root 1298: us a convenient place to record the "scope start" address for the 1299: tagged type. */ 1300: 1.1.1.4 root 1301: TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type)); 1.1 root 1302: } 1303: 1304: /* Handle when a new declaration NEWDECL 1305: has the same name as an old one OLDDECL 1306: in the same binding contour. 1307: Prints an error message if appropriate. 1308: 1309: If safely possible, alter OLDDECL to look like NEWDECL, and return 1. 1310: Otherwise, return 0. */ 1311: 1312: static int 1313: duplicate_decls (newdecl, olddecl) 1314: register tree newdecl, olddecl; 1315: { 1316: int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl)); 1317: int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL 1318: && DECL_INITIAL (newdecl) != 0); 1.1.1.4 root 1319: tree oldtype = TREE_TYPE (olddecl); 1320: tree newtype = TREE_TYPE (newdecl); 1.1.1.7 root 1321: char *errmsg = 0; 1.1 root 1322: 1.1.1.8 ! root 1323: if (TREE_CODE_CLASS (TREE_CODE (olddecl)) == 'd') ! 1324: DECL_MACHINE_ATTRIBUTES (newdecl) = DECL_MACHINE_ATTRIBUTES (olddecl); ! 1325: 1.1.1.4 root 1326: if (TREE_CODE (newtype) == ERROR_MARK 1327: || TREE_CODE (oldtype) == ERROR_MARK) 1.1 root 1328: types_match = 0; 1329: 1330: /* New decl is completely inconsistent with the old one => 1331: tell caller to replace the old one. 1332: This is always an error except in the case of shadowing a builtin. */ 1333: if (TREE_CODE (olddecl) != TREE_CODE (newdecl)) 1334: { 1335: if (TREE_CODE (olddecl) == FUNCTION_DECL 1.1.1.6 root 1336: && (DECL_BUILT_IN (olddecl) 1337: || DECL_BUILT_IN_NONANSI (olddecl))) 1.1 root 1338: { 1.1.1.6 root 1339: /* If you declare a built-in or predefined function name as static, 1340: the old definition is overridden, 1.1 root 1341: but optionally warn this was a bad choice of name. */ 1342: if (!TREE_PUBLIC (newdecl)) 1343: { 1.1.1.6 root 1344: if (!warn_shadow) 1345: ; 1346: else if (DECL_BUILT_IN (olddecl)) 1.1 root 1347: warning_with_decl (newdecl, "shadowing built-in function `%s'"); 1.1.1.6 root 1348: else 1349: warning_with_decl (newdecl, "shadowing library function `%s'"); 1.1 root 1350: } 1351: /* Likewise, if the built-in is not ansi, then programs can 1.1.1.2 root 1352: override it even globally without an error. */ 1.1.1.6 root 1353: else if (! DECL_BUILT_IN (olddecl)) 1354: warning_with_decl (newdecl, 1355: "library function `%s' declared as non-function"); 1356: 1.1 root 1357: else if (DECL_BUILT_IN_NONANSI (olddecl)) 1358: warning_with_decl (newdecl, 1359: "built-in function `%s' declared as non-function"); 1360: else 1361: warning_with_decl (newdecl, 1.1.1.6 root 1362: "built-in function `%s' declared as non-function"); 1.1 root 1363: } 1364: else 1365: { 1366: error_with_decl (newdecl, "`%s' redeclared as different kind of symbol"); 1367: error_with_decl (olddecl, "previous declaration of `%s'"); 1368: } 1369: 1370: return 0; 1371: } 1372: 1373: /* For real parm decl following a forward decl, 1374: return 1 so old decl will be reused. */ 1375: if (types_match && TREE_CODE (newdecl) == PARM_DECL 1376: && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl)) 1377: return 1; 1378: 1379: /* The new declaration is the same kind of object as the old one. 1380: The declarations may partially match. Print warnings if they don't 1381: match enough. Ultimately, copy most of the information from the new 1382: decl to the old one, and keep using the old one. */ 1383: 1384: if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL 1385: && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl 1386: && DECL_INITIAL (olddecl) == 0) 1387: /* If -traditional, avoid error for redeclaring fcn 1388: after implicit decl. */ 1389: ; 1390: else if (TREE_CODE (olddecl) == FUNCTION_DECL 1391: && DECL_BUILT_IN (olddecl)) 1392: { 1.1.1.4 root 1393: /* A function declaration for a built-in function. */ 1.1 root 1394: if (!TREE_PUBLIC (newdecl)) 1395: { 1396: /* If you declare a built-in function name as static, the 1397: built-in definition is overridden, 1398: but optionally warn this was a bad choice of name. */ 1399: if (warn_shadow) 1400: warning_with_decl (newdecl, "shadowing built-in function `%s'"); 1401: /* Discard the old built-in function. */ 1402: return 0; 1403: } 1404: else if (!types_match) 1.1.1.4 root 1405: { 1406: /* Accept the return type of the new declaration if same modes. */ 1407: tree oldreturntype = TREE_TYPE (TREE_TYPE (olddecl)); 1408: tree newreturntype = TREE_TYPE (TREE_TYPE (newdecl)); 1.1.1.8 ! root 1409: ! 1410: /* Make sure we put the new type in the same obstack as the old ones. ! 1411: If the old types are not both in the same obstack, use the ! 1412: permanent one. */ ! 1413: if (TYPE_OBSTACK (oldtype) == TYPE_OBSTACK (newtype)) ! 1414: push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype)); ! 1415: else ! 1416: { ! 1417: push_obstacks_nochange (); ! 1418: end_temporary_allocation (); ! 1419: } ! 1420: 1.1.1.4 root 1421: if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype)) 1422: { 1423: /* Function types may be shared, so we can't just modify 1424: the return type of olddecl's function type. */ 1425: tree newtype 1426: = build_function_type (newreturntype, 1427: TYPE_ARG_TYPES (TREE_TYPE (olddecl))); 1428: 1429: types_match = comptypes (TREE_TYPE (newdecl), newtype); 1430: if (types_match) 1431: TREE_TYPE (olddecl) = newtype; 1432: } 1.1.1.5 root 1433: /* Accept harmless mismatch in first argument type also. 1434: This is for ffs. */ 1435: if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0 1436: && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0 1437: && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))) != 0 1438: && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl))) != 0 1439: && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl)))) 1440: == 1441: TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl)))))) 1442: { 1443: /* Function types may be shared, so we can't just modify 1444: the return type of olddecl's function type. */ 1445: tree newtype 1446: = build_function_type (TREE_TYPE (TREE_TYPE (olddecl)), 1447: tree_cons (NULL_TREE, 1448: TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))), 1449: TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (olddecl))))); 1450: 1451: types_match = comptypes (TREE_TYPE (newdecl), newtype); 1452: if (types_match) 1453: TREE_TYPE (olddecl) = newtype; 1454: } 1.1.1.8 ! root 1455: ! 1456: pop_obstacks (); 1.1.1.4 root 1457: } 1458: if (!types_match) 1459: { 1460: /* If types don't match for a built-in, throw away the built-in. */ 1461: warning_with_decl (newdecl, "conflicting types for built-in function `%s'"); 1462: return 0; 1463: } 1.1 root 1464: } 1465: else if (TREE_CODE (olddecl) == FUNCTION_DECL 1.1.1.4 root 1466: && DECL_SOURCE_LINE (olddecl) == 0) 1.1 root 1467: { 1.1.1.4 root 1468: /* A function declaration for a predeclared function 1469: that isn't actually built in. */ 1.1 root 1470: if (!TREE_PUBLIC (newdecl)) 1471: { 1.1.1.4 root 1472: /* If you declare it as static, the 1473: default definition is overridden. */ 1.1 root 1474: return 0; 1475: } 1476: else if (!types_match) 1.1.1.4 root 1477: { 1478: /* If the types don't match, preserve volatility indication. 1479: Later on, we will discard everything else about the 1480: default declaration. */ 1481: TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); 1482: } 1483: } 1484: /* Permit char *foo () to match void *foo (...) if not pedantic, 1485: if one of them came from a system header file. */ 1486: else if (!types_match 1487: && TREE_CODE (olddecl) == FUNCTION_DECL 1488: && TREE_CODE (newdecl) == FUNCTION_DECL 1489: && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE 1490: && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE 1491: && (DECL_IN_SYSTEM_HEADER (olddecl) 1492: || DECL_IN_SYSTEM_HEADER (newdecl)) 1493: && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node 1494: && TYPE_ARG_TYPES (oldtype) == 0 1495: && self_promoting_args_p (TYPE_ARG_TYPES (newtype)) 1496: && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node) 1497: || 1498: (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node 1499: && TYPE_ARG_TYPES (newtype) == 0 1500: && self_promoting_args_p (TYPE_ARG_TYPES (oldtype)) 1501: && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node))) 1502: { 1503: if (pedantic) 1504: pedwarn_with_decl (newdecl, "conflicting types for `%s'"); 1505: /* Make sure we keep void * as ret type, not char *. */ 1506: if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node) 1507: TREE_TYPE (newdecl) = newtype = oldtype; 1.1.1.7 root 1508: 1509: /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration 1510: we will come back here again. */ 1511: DECL_IN_SYSTEM_HEADER (newdecl) = 1; 1.1 root 1512: } 1513: else if (!types_match 1514: /* Permit char *foo (int, ...); followed by char *foo (); 1515: if not pedantic. */ 1516: && ! (TREE_CODE (olddecl) == FUNCTION_DECL 1517: && ! pedantic 1518: /* Return types must still match. */ 1.1.1.4 root 1519: && comptypes (TREE_TYPE (oldtype), 1520: TREE_TYPE (newtype)) 1521: && TYPE_ARG_TYPES (newtype) == 0)) 1.1 root 1522: { 1523: error_with_decl (newdecl, "conflicting types for `%s'"); 1524: /* Check for function type mismatch 1525: involving an empty arglist vs a nonempty one. */ 1526: if (TREE_CODE (olddecl) == FUNCTION_DECL 1.1.1.4 root 1527: && comptypes (TREE_TYPE (oldtype), 1528: TREE_TYPE (newtype)) 1529: && ((TYPE_ARG_TYPES (oldtype) == 0 1.1 root 1530: && DECL_INITIAL (olddecl) == 0) 1531: || 1.1.1.4 root 1532: (TYPE_ARG_TYPES (newtype) == 0 1.1 root 1533: && DECL_INITIAL (newdecl) == 0))) 1534: { 1535: /* Classify the problem further. */ 1.1.1.4 root 1536: register tree t = TYPE_ARG_TYPES (oldtype); 1.1 root 1537: if (t == 0) 1.1.1.4 root 1538: t = TYPE_ARG_TYPES (newtype); 1.1 root 1539: for (; t; t = TREE_CHAIN (t)) 1540: { 1541: register tree type = TREE_VALUE (t); 1542: 1.1.1.4 root 1543: if (TREE_CHAIN (t) == 0 1544: && TYPE_MAIN_VARIANT (type) != void_type_node) 1.1 root 1545: { 1546: error ("A parameter list with an ellipsis can't match"); 1547: error ("an empty parameter name list declaration."); 1548: break; 1549: } 1550: 1.1.1.4 root 1551: if (TYPE_MAIN_VARIANT (type) == float_type_node 1552: || C_PROMOTING_INTEGER_TYPE_P (type)) 1.1 root 1553: { 1554: error ("An argument type that has a default promotion"); 1555: error ("can't match an empty parameter name list declaration."); 1556: break; 1557: } 1558: } 1559: } 1560: error_with_decl (olddecl, "previous declaration of `%s'"); 1561: } 1562: else 1563: { 1.1.1.7 root 1564: errmsg = redeclaration_error_message (newdecl, olddecl); 1.1 root 1565: if (errmsg) 1566: { 1567: error_with_decl (newdecl, errmsg); 1568: error_with_decl (olddecl, 1.1.1.4 root 1569: ((DECL_INITIAL (olddecl) 1570: && current_binding_level == global_binding_level) 1571: ? "`%s' previously defined here" 1572: : "`%s' previously declared here")); 1.1 root 1573: } 1.1.1.8 ! root 1574: else if (TREE_CODE (newdecl) == TYPE_DECL ! 1575: && (DECL_IN_SYSTEM_HEADER (olddecl) ! 1576: || DECL_IN_SYSTEM_HEADER (newdecl))) ! 1577: { ! 1578: warning_with_decl (newdecl, "redefinition of `%s'"); ! 1579: warning_with_decl ! 1580: (olddecl, ! 1581: ((DECL_INITIAL (olddecl) ! 1582: && current_binding_level == global_binding_level) ! 1583: ? "`%s' previously defined here" ! 1584: : "`%s' previously declared here")); ! 1585: } 1.1 root 1586: else if (TREE_CODE (olddecl) == FUNCTION_DECL 1587: && DECL_INITIAL (olddecl) != 0 1.1.1.4 root 1588: && TYPE_ARG_TYPES (oldtype) == 0 1.1.1.8 ! root 1589: && TYPE_ARG_TYPES (newtype) != 0 ! 1590: && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0) 1.1 root 1591: { 1592: register tree type, parm; 1593: register int nargs; 1594: /* Prototype decl follows defn w/o prototype. */ 1595: 1.1.1.4 root 1596: for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype), 1597: type = TYPE_ARG_TYPES (newtype), 1.1 root 1598: nargs = 1; 1.1.1.4 root 1599: (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) != void_type_node 1600: || TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node); 1.1 root 1601: parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++) 1602: { 1.1.1.4 root 1603: if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node 1604: || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node) 1.1 root 1605: { 1606: errmsg = "prototype for `%s' follows and number of arguments"; 1607: break; 1608: } 1609: /* Type for passing arg must be consistent 1610: with that declared for the arg. */ 1611: if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type)) 1612: /* If -traditional, allow `unsigned int' instead of `int' 1613: in the prototype. */ 1614: && (! (flag_traditional 1.1.1.4 root 1615: && TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == integer_type_node 1616: && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))) 1.1 root 1617: { 1618: errmsg = "prototype for `%s' follows and argument %d"; 1619: break; 1620: } 1621: } 1622: if (errmsg) 1623: { 1624: error_with_decl (newdecl, errmsg, nargs); 1625: error_with_decl (olddecl, 1626: "doesn't match non-prototype definition here"); 1627: } 1628: else 1629: { 1630: warning_with_decl (newdecl, "prototype for `%s' follows"); 1631: warning_with_decl (olddecl, "non-prototype definition here"); 1632: } 1633: } 1.1.1.3 root 1634: /* Warn about mismatches in various flags. */ 1.1 root 1635: else 1636: { 1.1.1.3 root 1637: /* Warn if function is now inline 1638: but was previously declared not inline and has been called. */ 1.1 root 1639: if (TREE_CODE (olddecl) == FUNCTION_DECL 1.1.1.4 root 1640: && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl) 1.1 root 1641: && TREE_USED (olddecl)) 1642: warning_with_decl (newdecl, 1643: "`%s' declared inline after being called"); 1644: if (TREE_CODE (olddecl) == FUNCTION_DECL 1.1.1.4 root 1645: && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl) 1646: && DECL_INITIAL (olddecl) != 0) 1.1 root 1647: warning_with_decl (newdecl, 1.1.1.4 root 1648: "`%s' declared inline after its definition"); 1.1.1.7 root 1649: 1650: /* If pedantic, warn when static declaration follows a non-static 1651: declaration. Otherwise, do so only for functions. */ 1652: if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL) 1.1 root 1653: && TREE_PUBLIC (olddecl) 1654: && !TREE_PUBLIC (newdecl)) 1655: warning_with_decl (newdecl, "static declaration for `%s' follows non-static"); 1656: 1.1.1.7 root 1657: /* Warn when const declaration follows a non-const 1658: declaration, but not for functions. */ 1659: if (TREE_CODE (olddecl) != FUNCTION_DECL 1660: && !TREE_READONLY (olddecl) 1661: && TREE_READONLY (newdecl)) 1662: warning_with_decl (newdecl, "const declaration for `%s' follows non-const"); 1.1.1.3 root 1663: /* These bits are logically part of the type, for variables. 1664: But not for functions 1665: (where qualifiers are not valid ANSI anyway). */ 1.1.1.7 root 1666: else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL 1.1 root 1667: && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl) 1668: || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl))) 1669: pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl"); 1670: } 1671: } 1672: 1.1.1.4 root 1673: /* Optionally warn about more than one declaration for the same name. */ 1.1.1.7 root 1674: if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0 1.1.1.4 root 1675: /* Dont warn about a function declaration 1676: followed by a definition. */ 1677: && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0 1.1.1.6 root 1678: && DECL_INITIAL (olddecl) == 0) 1679: /* Don't warn about extern decl followed by (tentative) definition. */ 1680: && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))) 1.1.1.4 root 1681: { 1682: warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope"); 1683: warning_with_decl (olddecl, "previous declaration of `%s'"); 1684: } 1685: 1.1 root 1686: /* Copy all the DECL_... slots specified in the new decl 1.1.1.4 root 1687: except for any that we copy here from the old type. 1688: 1689: Past this point, we don't change OLDTYPE and NEWTYPE 1690: even if we change the types of NEWDECL and OLDDECL. */ 1.1 root 1691: 1692: if (types_match) 1693: { 1.1.1.7 root 1694: /* Make sure we put the new type in the same obstack as the old ones. 1695: If the old types are not both in the same obstack, use the permanent 1696: one. */ 1697: if (TYPE_OBSTACK (oldtype) == TYPE_OBSTACK (newtype)) 1698: push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype)); 1699: else 1700: { 1701: push_obstacks_nochange (); 1702: end_temporary_allocation (); 1703: } 1704: 1.1 root 1705: /* Merge the data types specified in the two decls. */ 1706: if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl)) 1707: TREE_TYPE (newdecl) 1708: = TREE_TYPE (olddecl) 1.1.1.4 root 1709: = common_type (newtype, oldtype); 1.1 root 1710: 1711: /* Lay the type out, unless already done. */ 1712: if (oldtype != TREE_TYPE (newdecl)) 1713: { 1714: if (TREE_TYPE (newdecl) != error_mark_node) 1715: layout_type (TREE_TYPE (newdecl)); 1716: if (TREE_CODE (newdecl) != FUNCTION_DECL 1717: && TREE_CODE (newdecl) != TYPE_DECL 1718: && TREE_CODE (newdecl) != CONST_DECL) 1719: layout_decl (newdecl, 0); 1720: } 1721: else 1722: { 1723: /* Since the type is OLDDECL's, make OLDDECL's size go with. */ 1724: DECL_SIZE (newdecl) = DECL_SIZE (olddecl); 1.1.1.3 root 1725: if (TREE_CODE (olddecl) != FUNCTION_DECL) 1726: if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl)) 1727: DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl); 1.1 root 1728: } 1729: 1.1.1.4 root 1730: /* Keep the old rtl since we can safely use it. */ 1731: DECL_RTL (newdecl) = DECL_RTL (olddecl); 1732: 1.1 root 1733: /* Merge the type qualifiers. */ 1734: if (DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl) 1735: && !TREE_THIS_VOLATILE (newdecl)) 1736: TREE_THIS_VOLATILE (olddecl) = 0; 1737: if (TREE_READONLY (newdecl)) 1738: TREE_READONLY (olddecl) = 1; 1739: if (TREE_THIS_VOLATILE (newdecl)) 1.1.1.4 root 1740: { 1741: TREE_THIS_VOLATILE (olddecl) = 1; 1742: if (TREE_CODE (newdecl) == VAR_DECL) 1743: make_var_volatile (newdecl); 1744: } 1.1 root 1745: 1.1.1.7 root 1746: /* Keep source location of definition rather than declaration. 1747: Likewise, keep decl at outer scope. */ 1748: if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0) 1749: || (DECL_CONTEXT (newdecl) != 0 && DECL_CONTEXT (olddecl) == 0)) 1.1 root 1750: { 1751: DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl); 1752: DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl); 1.1.1.7 root 1753: 1.1.1.8 ! root 1754: if (DECL_CONTEXT (olddecl) == 0 ! 1755: && TREE_CODE (newdecl) != FUNCTION_DECL) 1.1.1.7 root 1756: DECL_CONTEXT (newdecl) = 0; 1.1 root 1757: } 1758: 1.1.1.4 root 1759: /* Merge the unused-warning information. */ 1760: if (DECL_IN_SYSTEM_HEADER (olddecl)) 1761: DECL_IN_SYSTEM_HEADER (newdecl) = 1; 1762: else if (DECL_IN_SYSTEM_HEADER (newdecl)) 1763: DECL_IN_SYSTEM_HEADER (olddecl) = 1; 1764: 1.1 root 1765: /* Merge the initialization information. */ 1766: if (DECL_INITIAL (newdecl) == 0) 1767: DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); 1.1.1.7 root 1768: 1769: /* Merge the section attribute. 1770: We want to issue an error if the sections conflict but that must be 1771: done later in decl_attributes since we are called before attributes 1772: are assigned. */ 1773: if (DECL_SECTION_NAME (newdecl) == NULL_TREE) 1774: DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl); 1775: 1.1.1.8 ! root 1776: if (TREE_CODE (newdecl) == FUNCTION_DECL) ! 1777: { ! 1778: DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl); ! 1779: DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl); ! 1780: } ! 1781: 1.1.1.7 root 1782: pop_obstacks (); 1.1 root 1783: } 1784: /* If cannot merge, then use the new type and qualifiers, 1785: and don't preserve the old rtl. */ 1786: else 1787: { 1788: TREE_TYPE (olddecl) = TREE_TYPE (newdecl); 1789: TREE_READONLY (olddecl) = TREE_READONLY (newdecl); 1790: TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl); 1791: TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl); 1792: } 1793: 1794: /* Merge the storage class information. */ 1.1.1.8 ! root 1795: DECL_WEAK (newdecl) |= DECL_WEAK (olddecl); 1.1 root 1796: /* For functions, static overrides non-static. */ 1797: if (TREE_CODE (newdecl) == FUNCTION_DECL) 1798: { 1799: TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl); 1800: /* This is since we don't automatically 1801: copy the attributes of NEWDECL into OLDDECL. */ 1802: TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl); 1803: /* If this clears `static', clear it in the identifier too. */ 1804: if (! TREE_PUBLIC (olddecl)) 1805: TREE_PUBLIC (DECL_NAME (olddecl)) = 0; 1806: } 1.1.1.4 root 1807: if (DECL_EXTERNAL (newdecl)) 1.1 root 1808: { 1809: TREE_STATIC (newdecl) = TREE_STATIC (olddecl); 1.1.1.4 root 1810: DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl); 1.1 root 1811: /* An extern decl does not override previous storage class. */ 1812: TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl); 1813: } 1814: else 1815: { 1816: TREE_STATIC (olddecl) = TREE_STATIC (newdecl); 1817: TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl); 1818: } 1.1.1.4 root 1819: 1.1 root 1820: /* If either decl says `inline', this fn is inline, 1821: unless its definition was passed already. */ 1.1.1.4 root 1822: if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0) 1823: DECL_INLINE (olddecl) = 1; 1824: DECL_INLINE (newdecl) = DECL_INLINE (olddecl); 1.1 root 1825: 1826: /* Get rid of any built-in function if new arg types don't match it 1827: or if we have a function definition. */ 1828: if (TREE_CODE (newdecl) == FUNCTION_DECL 1829: && DECL_BUILT_IN (olddecl) 1830: && (!types_match || new_is_definition)) 1831: { 1832: TREE_TYPE (olddecl) = TREE_TYPE (newdecl); 1833: DECL_BUILT_IN (olddecl) = 0; 1834: } 1835: 1836: /* If redeclaring a builtin function, and not a definition, 1837: it stays built in. 1838: Also preserve various other info from the definition. */ 1839: if (TREE_CODE (newdecl) == FUNCTION_DECL && !new_is_definition) 1840: { 1841: if (DECL_BUILT_IN (olddecl)) 1842: { 1843: DECL_BUILT_IN (newdecl) = 1; 1.1.1.7 root 1844: DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl); 1.1 root 1845: } 1846: else 1847: DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl); 1848: 1849: DECL_RESULT (newdecl) = DECL_RESULT (olddecl); 1850: DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); 1851: DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl); 1852: DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl); 1853: } 1854: 1.1.1.4 root 1855: /* Copy most of the decl-specific fields of NEWDECL into OLDDECL. 1856: But preserve OLDdECL's DECL_UID. */ 1857: { 1858: register unsigned olddecl_uid = DECL_UID (olddecl); 1859: 1860: bcopy ((char *) newdecl + sizeof (struct tree_common), 1861: (char *) olddecl + sizeof (struct tree_common), 1862: sizeof (struct tree_decl) - sizeof (struct tree_common)); 1863: DECL_UID (olddecl) = olddecl_uid; 1864: } 1.1 root 1865: 1866: return 1; 1867: } 1868: 1869: /* Record a decl-node X as belonging to the current lexical scope. 1870: Check for errors (such as an incompatible declaration for the same 1871: name already seen in the same scope). 1872: 1873: Returns either X or an old decl for the same name. 1874: If an old decl is returned, it may have been smashed 1875: to agree with what X says. */ 1876: 1877: tree 1878: pushdecl (x) 1879: tree x; 1880: { 1881: register tree t; 1882: register tree name = DECL_NAME (x); 1883: register struct binding_level *b = current_binding_level; 1884: 1885: DECL_CONTEXT (x) = current_function_decl; 1.1.1.5 root 1886: /* A local extern declaration for a function doesn't constitute nesting. 1887: A local auto declaration does, since it's a forward decl 1888: for a nested function coming later. */ 1889: if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0 1890: && DECL_EXTERNAL (x)) 1.1 root 1891: DECL_CONTEXT (x) = 0; 1892: 1.1.1.4 root 1893: if (warn_nested_externs && DECL_EXTERNAL (x) && b != global_binding_level 1.1.1.6 root 1894: && x != IDENTIFIER_IMPLICIT_DECL (name) 1895: /* Don't print error messages for __FUNCTION__ and __PRETTY_FUNCTION__ */ 1896: && !DECL_IN_SYSTEM_HEADER (x)) 1.1 root 1897: warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name)); 1898: 1899: if (name) 1900: { 1901: char *file; 1902: int line; 1.1.1.8 ! root 1903: int declared_global; 1.1 root 1904: 1.1.1.7 root 1905: /* Don't type check externs here when -traditional. This is so that 1906: code with conflicting declarations inside blocks will get warnings 1907: not errors. X11 for instance depends on this. */ 1908: if (DECL_EXTERNAL (x) && TREE_PUBLIC (x) && ! flag_traditional) 1909: t = lookup_name_current_level_global (name); 1910: else 1911: t = lookup_name_current_level (name); 1.1 root 1912: if (t != 0 && t == error_mark_node) 1913: /* error_mark_node is 0 for a while during initialization! */ 1914: { 1915: t = 0; 1916: error_with_decl (x, "`%s' used prior to declaration"); 1917: } 1918: 1919: if (t != 0) 1920: { 1921: file = DECL_SOURCE_FILE (t); 1922: line = DECL_SOURCE_LINE (t); 1923: } 1924: 1.1.1.8 ! root 1925: /* duplicate_decls might write to TREE_PUBLIC (x) and DECL_EXTERNAL (x) ! 1926: to make it identical to the initial declaration. */ ! 1927: declared_global = TREE_PUBLIC (x) || DECL_EXTERNAL (x); 1.1 root 1928: if (t != 0 && duplicate_decls (x, t)) 1929: { 1930: if (TREE_CODE (t) == PARM_DECL) 1931: { 1932: /* Don't allow more than one "real" duplicate 1933: of a forward parm decl. */ 1934: TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x); 1935: return t; 1936: } 1937: /* If this decl is `static' and an implicit decl was seen previously, 1938: warn. But don't complain if -traditional, 1939: since traditional compilers don't complain. */ 1940: if (!flag_traditional && TREE_PUBLIC (name) 1.1.1.8 ! root 1941: ! 1942: /* should this be '&& ! declared_global' ? */ 1.1.1.4 root 1943: && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x) 1.1.1.8 ! root 1944: 1.1 root 1945: /* We used to warn also for explicit extern followed by static, 1946: but sometimes you need to do it that way. */ 1947: && IDENTIFIER_IMPLICIT_DECL (name) != 0) 1948: { 1949: pedwarn ("`%s' was declared implicitly `extern' and later `static'", 1950: IDENTIFIER_POINTER (name)); 1951: pedwarn_with_file_and_line (file, line, 1952: "previous declaration of `%s'", 1953: IDENTIFIER_POINTER (name)); 1954: } 1.1.1.4 root 1955: 1.1.1.7 root 1956: /* If this is a global decl, and there exists a conflicting local 1957: decl in a parent block, then we can't return as yet, because we 1958: need to register this decl in the current binding block. */ 1.1.1.8 ! root 1959: /* A test for TREE_PUBLIC (x) will fail for variables that have ! 1960: been declared static first, and extern now. */ ! 1961: if (! declared_global || lookup_name (name) == t) 1.1.1.7 root 1962: return t; 1.1 root 1963: } 1964: 1.1.1.3 root 1965: /* If we are processing a typedef statement, generate a whole new 1966: ..._TYPE node (which will be just an variant of the existing 1967: ..._TYPE node with identical properties) and then install the 1968: TYPE_DECL node generated to represent the typedef name as the 1969: TYPE_NAME of this brand new (duplicate) ..._TYPE node. 1970: 1971: The whole point here is to end up with a situation where each 1972: and every ..._TYPE node the compiler creates will be uniquely 1973: associated with AT MOST one node representing a typedef name. 1974: This way, even though the compiler substitutes corresponding 1975: ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very 1976: early on, later parts of the compiler can always do the reverse 1977: translation and get back the corresponding typedef name. For 1978: example, given: 1979: 1980: typedef struct S MY_TYPE; 1981: MY_TYPE object; 1982: 1983: Later parts of the compiler might only know that `object' was of 1984: type `struct S' if if were not for code just below. With this 1985: code however, later parts of the compiler see something like: 1986: 1987: struct S' == struct S 1988: typedef struct S' MY_TYPE; 1989: struct S' object; 1990: 1991: And they can then deduce (from the node for type struct S') that 1992: the original object declaration was: 1993: 1994: MY_TYPE object; 1995: 1996: Being able to do this is important for proper support of protoize, 1997: and also for generating precise symbolic debugging information 1998: which takes full account of the programmer's (typedef) vocabulary. 1999: 2000: Obviously, we don't want to generate a duplicate ..._TYPE node if 2001: the TYPE_DECL node that we are now processing really represents a 2002: standard built-in type. 2003: 1.1 root 2004: Since all standard types are effectively declared at line zero 2005: in the source file, we can easily check to see if we are working 2006: on a standard type by checking the current value of lineno. */ 2007: 2008: if (TREE_CODE (x) == TYPE_DECL) 2009: { 1.1.1.4 root 2010: if (DECL_SOURCE_LINE (x) == 0) 1.1 root 2011: { 2012: if (TYPE_NAME (TREE_TYPE (x)) == 0) 2013: TYPE_NAME (TREE_TYPE (x)) = x; 2014: } 1.1.1.5 root 2015: else if (TREE_TYPE (x) != error_mark_node) 1.1 root 2016: { 2017: tree tt = TREE_TYPE (x); 2018: 1.1.1.3 root 2019: tt = build_type_copy (tt); 1.1 root 2020: TYPE_NAME (tt) = x; 2021: TREE_TYPE (x) = tt; 2022: } 2023: } 2024: 1.1.1.4 root 2025: /* Multiple external decls of the same identifier ought to match. 1.1.1.7 root 2026: Check against both global declarations (when traditional) and out of 2027: scope (limbo) block level declarations. 1.1.1.4 root 2028: 2029: We get warnings about inline functions where they are defined. 2030: Avoid duplicate warnings where they are used. */ 1.1.1.5 root 2031: if (TREE_PUBLIC (x) && ! DECL_INLINE (x)) 1.1.1.4 root 2032: { 2033: tree decl; 2034: 1.1.1.7 root 2035: if (flag_traditional && IDENTIFIER_GLOBAL_VALUE (name) != 0 1.1.1.4 root 2036: && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name)) 2037: || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name)))) 2038: decl = IDENTIFIER_GLOBAL_VALUE (name); 2039: else if (IDENTIFIER_LIMBO_VALUE (name) != 0) 2040: /* Decls in limbo are always extern, so no need to check that. */ 2041: decl = IDENTIFIER_LIMBO_VALUE (name); 2042: else 2043: decl = 0; 1.1 root 2044: 1.1.1.5 root 2045: if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl)) 2046: /* If old decl is built-in, we already warned if we should. */ 2047: && !DECL_BUILT_IN (decl)) 1.1 root 2048: { 2049: pedwarn_with_decl (x, 2050: "type mismatch with previous external decl"); 1.1.1.4 root 2051: pedwarn_with_decl (decl, "previous external decl of `%s'"); 1.1 root 2052: } 2053: } 2054: 2055: /* If a function has had an implicit declaration, and then is defined, 2056: make sure they are compatible. */ 2057: 2058: if (IDENTIFIER_IMPLICIT_DECL (name) != 0 2059: && IDENTIFIER_GLOBAL_VALUE (name) == 0 2060: && TREE_CODE (x) == FUNCTION_DECL 2061: && ! comptypes (TREE_TYPE (x), 2062: TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name)))) 2063: { 2064: warning_with_decl (x, "type mismatch with previous implicit declaration"); 1.1.1.2 root 2065: warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name), 2066: "previous implicit declaration of `%s'"); 1.1 root 2067: } 2068: 2069: /* In PCC-compatibility mode, extern decls of vars with no current decl 2070: take effect at top level no matter where they are. */ 1.1.1.4 root 2071: if (flag_traditional && DECL_EXTERNAL (x) 1.1 root 2072: && lookup_name (name) == 0) 2073: { 2074: tree type = TREE_TYPE (x); 2075: 2076: /* But don't do this if the type contains temporary nodes. */ 2077: while (type) 2078: { 2079: if (type == error_mark_node) 2080: break; 2081: if (! TREE_PERMANENT (type)) 2082: { 2083: warning_with_decl (x, "type of external `%s' is not global"); 2084: /* By exiting the loop early, we leave TYPE nonzero, 2085: and thus prevent globalization of the decl. */ 2086: break; 2087: } 2088: else if (TREE_CODE (type) == FUNCTION_TYPE 2089: && TYPE_ARG_TYPES (type) != 0) 2090: /* The types might not be truly local, 2091: but the list of arg types certainly is temporary. 2092: Since prototypes are nontraditional, 2093: ok not to do the traditional thing. */ 2094: break; 2095: type = TREE_TYPE (type); 2096: } 2097: 2098: if (type == 0) 2099: b = global_binding_level; 2100: } 2101: 2102: /* This name is new in its binding level. 2103: Install the new declaration and return it. */ 2104: if (b == global_binding_level) 2105: { 2106: /* Install a global value. */ 2107: 2108: /* If the first global decl has external linkage, 2109: warn if we later see static one. */ 2110: if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x)) 2111: TREE_PUBLIC (name) = 1; 2112: 2113: IDENTIFIER_GLOBAL_VALUE (name) = x; 2114: 1.1.1.4 root 2115: /* We no longer care about any previous block level declarations. */ 2116: IDENTIFIER_LIMBO_VALUE (name) = 0; 2117: 1.1 root 2118: /* Don't forget if the function was used via an implicit decl. */ 2119: if (IDENTIFIER_IMPLICIT_DECL (name) 2120: && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name))) 2121: TREE_USED (x) = 1, TREE_USED (name) = 1; 2122: 2123: /* Don't forget if its address was taken in that way. */ 2124: if (IDENTIFIER_IMPLICIT_DECL (name) 2125: && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name))) 2126: TREE_ADDRESSABLE (x) = 1; 2127: 2128: /* Warn about mismatches against previous implicit decl. */ 2129: if (IDENTIFIER_IMPLICIT_DECL (name) != 0 2130: /* If this real decl matches the implicit, don't complain. */ 2131: && ! (TREE_CODE (x) == FUNCTION_DECL 1.1.1.4 root 2132: && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x))) 2133: == integer_type_node))) 1.1 root 2134: pedwarn ("`%s' was previously implicitly declared to return `int'", 2135: IDENTIFIER_POINTER (name)); 2136: 2137: /* If this decl is `static' and an `extern' was seen previously, 2138: that is erroneous. */ 2139: if (TREE_PUBLIC (name) 1.1.1.4 root 2140: && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x)) 1.1 root 2141: { 1.1.1.4 root 2142: /* Okay to redeclare an ANSI built-in as static. */ 2143: if (t != 0 && DECL_BUILT_IN (t)) 1.1.1.2 root 2144: ; 2145: /* Okay to declare a non-ANSI built-in as anything. */ 2146: else if (t != 0 && DECL_BUILT_IN_NONANSI (t)) 2147: ; 2148: else if (IDENTIFIER_IMPLICIT_DECL (name)) 1.1 root 2149: pedwarn ("`%s' was declared implicitly `extern' and later `static'", 2150: IDENTIFIER_POINTER (name)); 2151: else 2152: pedwarn ("`%s' was declared `extern' and later `static'", 2153: IDENTIFIER_POINTER (name)); 2154: } 2155: } 2156: else 2157: { 2158: /* Here to install a non-global value. */ 2159: tree oldlocal = IDENTIFIER_LOCAL_VALUE (name); 2160: tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name); 2161: IDENTIFIER_LOCAL_VALUE (name) = x; 2162: 2163: /* If this is an extern function declaration, see if we 1.1.1.4 root 2164: have a global definition or declaration for the function. */ 1.1 root 2165: if (oldlocal == 0 1.1.1.4 root 2166: && DECL_EXTERNAL (x) && !DECL_INLINE (x) 1.1 root 2167: && oldglobal != 0 2168: && TREE_CODE (x) == FUNCTION_DECL 2169: && TREE_CODE (oldglobal) == FUNCTION_DECL) 2170: { 2171: /* We have one. Their types must agree. */ 2172: if (! comptypes (TREE_TYPE (x), 2173: TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)))) 1.1.1.4 root 2174: pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one"); 2175: else 2176: { 2177: /* Inner extern decl is inline if global one is. 2178: Copy enough to really inline it. */ 2179: if (DECL_INLINE (oldglobal)) 2180: { 2181: DECL_INLINE (x) = DECL_INLINE (oldglobal); 2182: DECL_INITIAL (x) = (current_function_decl == oldglobal 2183: ? 0 : DECL_INITIAL (oldglobal)); 2184: DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal); 1.1.1.5 root 2185: DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal); 1.1.1.4 root 2186: DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal); 2187: DECL_RESULT (x) = DECL_RESULT (oldglobal); 2188: TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal); 2189: DECL_ABSTRACT_ORIGIN (x) = oldglobal; 2190: } 2191: /* Inner extern decl is built-in if global one is. */ 2192: if (DECL_BUILT_IN (oldglobal)) 2193: { 2194: DECL_BUILT_IN (x) = DECL_BUILT_IN (oldglobal); 1.1.1.7 root 2195: DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal); 1.1.1.4 root 2196: } 2197: /* Keep the arg types from a file-scope fcn defn. */ 2198: if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0 2199: && DECL_INITIAL (oldglobal) 2200: && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0) 2201: TREE_TYPE (x) = TREE_TYPE (oldglobal); 2202: } 1.1 root 2203: } 2204: 2205: #if 0 /* This case is probably sometimes the right thing to do. */ 2206: /* If we have a local external declaration, 2207: then any file-scope declaration should not 2208: have been static. */ 2209: if (oldlocal == 0 && oldglobal != 0 2210: && !TREE_PUBLIC (oldglobal) 1.1.1.4 root 2211: && DECL_EXTERNAL (x) && TREE_PUBLIC (x)) 1.1 root 2212: warning ("`%s' locally external but globally static", 2213: IDENTIFIER_POINTER (name)); 2214: #endif 2215: 2216: /* If we have a local external declaration, 2217: and no file-scope declaration has yet been seen, 2218: then if we later have a file-scope decl it must not be static. */ 2219: if (oldlocal == 0 2220: && oldglobal == 0 1.1.1.4 root 2221: && DECL_EXTERNAL (x) 1.1 root 2222: && TREE_PUBLIC (x)) 2223: { 2224: TREE_PUBLIC (name) = 1; 1.1.1.4 root 2225: 2226: /* Save this decl, so that we can do type checking against 2227: other decls after it falls out of scope. 2228: 2229: Only save it once. This prevents temporary decls created in 2230: expand_inline_function from being used here, since this 2231: will have been set when the inline function was parsed. 2232: It also helps give slightly better warnings. */ 2233: if (IDENTIFIER_LIMBO_VALUE (name) == 0) 2234: IDENTIFIER_LIMBO_VALUE (name) = x; 1.1 root 2235: } 2236: 2237: /* Warn if shadowing an argument at the top level of the body. */ 1.1.1.4 root 2238: if (oldlocal != 0 && !DECL_EXTERNAL (x) 1.1 root 2239: /* This warning doesn't apply to the parms of a nested fcn. */ 2240: && ! current_binding_level->parm_flag 2241: /* Check that this is one level down from the parms. */ 2242: && current_binding_level->level_chain->parm_flag 2243: /* Check that the decl being shadowed 2244: comes from the parm level, one level up. */ 2245: && chain_member (oldlocal, current_binding_level->level_chain->names)) 2246: { 2247: if (TREE_CODE (oldlocal) == PARM_DECL) 2248: pedwarn ("declaration of `%s' shadows a parameter", 2249: IDENTIFIER_POINTER (name)); 2250: else 2251: pedwarn ("declaration of `%s' shadows a symbol from the parameter list", 2252: IDENTIFIER_POINTER (name)); 2253: } 2254: 2255: /* Maybe warn if shadowing something else. */ 1.1.1.4 root 2256: else if (warn_shadow && !DECL_EXTERNAL (x) 1.1.1.3 root 2257: /* No shadow warnings for internally generated vars. */ 1.1.1.4 root 2258: && DECL_SOURCE_LINE (x) != 0 1.1 root 2259: /* No shadow warnings for vars made for inlining. */ 2260: && ! DECL_FROM_INLINE (x)) 2261: { 2262: char *warnstring = 0; 2263: 2264: if (TREE_CODE (x) == PARM_DECL 1.1.1.5 root 2265: && current_binding_level->level_chain->parm_flag) 2266: /* Don't warn about the parm names in function declarator 2267: within a function declarator. 2268: It would be nice to avoid warning in any function 2269: declarator in a declaration, as opposed to a definition, 2270: but there is no way to tell it's not a definition. */ 1.1 root 2271: ; 2272: else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL) 2273: warnstring = "declaration of `%s' shadows a parameter"; 2274: else if (oldlocal != 0) 2275: warnstring = "declaration of `%s' shadows previous local"; 2276: else if (IDENTIFIER_GLOBAL_VALUE (name) != 0 2277: && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node) 2278: warnstring = "declaration of `%s' shadows global declaration"; 2279: 2280: if (warnstring) 2281: warning (warnstring, IDENTIFIER_POINTER (name)); 2282: } 2283: 2284: /* If storing a local value, there may already be one (inherited). 2285: If so, record it for restoration when this binding level ends. */ 2286: if (oldlocal != 0) 2287: b->shadowed = tree_cons (name, oldlocal, b->shadowed); 2288: } 2289: 2290: /* Keep count of variables in this level with incomplete type. */ 2291: if (TYPE_SIZE (TREE_TYPE (x)) == 0) 2292: ++b->n_incomplete; 2293: } 2294: 2295: /* Put decls on list in reverse order. 2296: We will reverse them later if necessary. */ 2297: TREE_CHAIN (x) = b->names; 2298: b->names = x; 2299: 2300: return x; 2301: } 2302: 2303: /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */ 2304: 2305: tree 2306: pushdecl_top_level (x) 2307: tree x; 2308: { 2309: register tree t; 2310: register struct binding_level *b = current_binding_level; 2311: 2312: current_binding_level = global_binding_level; 2313: t = pushdecl (x); 2314: current_binding_level = b; 2315: return t; 2316: } 2317: 2318: /* Generate an implicit declaration for identifier FUNCTIONID 2319: as a function of type int (). Print a warning if appropriate. */ 2320: 2321: tree 2322: implicitly_declare (functionid) 2323: tree functionid; 2324: { 2325: register tree decl; 2326: int traditional_warning = 0; 2327: /* Only one "implicit declaration" warning per identifier. */ 2328: int implicit_warning; 2329: 2330: /* Save the decl permanently so we can warn if definition follows. */ 2331: push_obstacks_nochange (); 2332: end_temporary_allocation (); 2333: 2334: /* We used to reuse an old implicit decl here, 2335: but this loses with inline functions because it can clobber 2336: the saved decl chains. */ 2337: /* if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0) 2338: decl = IDENTIFIER_IMPLICIT_DECL (functionid); 2339: else */ 2340: decl = build_decl (FUNCTION_DECL, functionid, default_function_type); 2341: 2342: /* Warn of implicit decl following explicit local extern decl. 2343: This is probably a program designed for traditional C. */ 2344: if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0) 2345: traditional_warning = 1; 2346: 2347: /* Warn once of an implicit declaration. */ 2348: implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0); 2349: 1.1.1.4 root 2350: DECL_EXTERNAL (decl) = 1; 1.1 root 2351: TREE_PUBLIC (decl) = 1; 2352: 2353: /* Record that we have an implicit decl and this is it. */ 2354: IDENTIFIER_IMPLICIT_DECL (functionid) = decl; 2355: 2356: /* ANSI standard says implicit declarations are in the innermost block. 2357: So we record the decl in the standard fashion. 2358: If flag_traditional is set, pushdecl does it top-level. */ 2359: pushdecl (decl); 2360: 2361: /* This is a no-op in c-lang.c or something real in objc-actions.c. */ 2362: maybe_objc_check_decl (decl); 2363: 1.1.1.4 root 2364: rest_of_decl_compilation (decl, NULL_PTR, 0, 0); 1.1 root 2365: 2366: if (warn_implicit && implicit_warning) 2367: warning ("implicit declaration of function `%s'", 2368: IDENTIFIER_POINTER (functionid)); 2369: else if (warn_traditional && traditional_warning) 2370: warning ("function `%s' was previously declared within a block", 2371: IDENTIFIER_POINTER (functionid)); 2372: 2373: /* Write a record describing this implicit function declaration to the 2374: prototypes file (if requested). */ 2375: 2376: gen_aux_info_record (decl, 0, 1, 0); 2377: 2378: pop_obstacks (); 2379: 2380: return decl; 2381: } 2382: 2383: /* Return zero if the declaration NEWDECL is valid 2384: when the declaration OLDDECL (assumed to be for the same name) 2385: has already been seen. 2386: Otherwise return an error message format string with a %s 2387: where the identifier should go. */ 2388: 2389: static char * 2390: redeclaration_error_message (newdecl, olddecl) 2391: tree newdecl, olddecl; 2392: { 2393: if (TREE_CODE (newdecl) == TYPE_DECL) 2394: { 2395: if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl)) 2396: return 0; 1.1.1.8 ! root 2397: /* pushdecl creates distinct types for TYPE_DECLs by calling ! 2398: build_type_copy, so the above comparison generally fails. We do ! 2399: another test against the TYPE_MAIN_VARIANT of the olddecl, which ! 2400: is equivalent to what this code used to do before the build_type_copy ! 2401: call. The variant type distinction should not matter for traditional ! 2402: code, because it doesn't have type qualifiers. */ ! 2403: if (flag_traditional ! 2404: && TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)) == TREE_TYPE (newdecl)) ! 2405: return 0; ! 2406: if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl)) ! 2407: return 0; 1.1 root 2408: return "redefinition of `%s'"; 2409: } 2410: else if (TREE_CODE (newdecl) == FUNCTION_DECL) 2411: { 2412: /* Declarations of functions can insist on internal linkage 2413: but they can't be inconsistent with internal linkage, 2414: so there can be no error on that account. 2415: However defining the same name twice is no good. */ 2416: if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0 2417: /* However, defining once as extern inline and a second 2418: time in another way is ok. */ 1.1.1.4 root 2419: && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl) 2420: && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl)))) 1.1 root 2421: return "redefinition of `%s'"; 2422: return 0; 2423: } 2424: else if (current_binding_level == global_binding_level) 2425: { 2426: /* Objects declared at top level: */ 2427: /* If at least one is a reference, it's ok. */ 1.1.1.4 root 2428: if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl)) 1.1 root 2429: return 0; 2430: /* Reject two definitions. */ 2431: if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0) 2432: return "redefinition of `%s'"; 2433: /* Now we have two tentative defs, or one tentative and one real def. */ 2434: /* Insist that the linkage match. */ 2435: if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl)) 2436: return "conflicting declarations of `%s'"; 2437: return 0; 2438: } 2439: else if (current_binding_level->parm_flag 2440: && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)) 2441: return 0; 2442: else 2443: { 1.1.1.7 root 2444: /* Newdecl has block scope. If olddecl has block scope also, then 2445: reject two definitions, and reject a definition together with an 2446: external reference. Otherwise, it is OK, because newdecl must 2447: be an extern reference to olddecl. */ 2448: if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)) 2449: && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl)) 1.1 root 2450: return "redeclaration of `%s'"; 2451: return 0; 2452: } 2453: } 2454: 2455: /* Get the LABEL_DECL corresponding to identifier ID as a label. 2456: Create one if none exists so far for the current function. 2457: This function is called for both label definitions and label references. */ 2458: 2459: tree 2460: lookup_label (id) 2461: tree id; 2462: { 2463: register tree decl = IDENTIFIER_LABEL_VALUE (id); 2464: 1.1.1.5 root 2465: if (current_function_decl == 0) 2466: { 2467: error ("label %s referenced outside of any function", 2468: IDENTIFIER_POINTER (id)); 2469: return 0; 2470: } 2471: 1.1 root 2472: /* Use a label already defined or ref'd with this name. */ 2473: if (decl != 0) 2474: { 2475: /* But not if it is inherited and wasn't declared to be inheritable. */ 2476: if (DECL_CONTEXT (decl) != current_function_decl 2477: && ! C_DECLARED_LABEL_FLAG (decl)) 2478: return shadow_label (id); 2479: return decl; 2480: } 2481: 2482: decl = build_decl (LABEL_DECL, id, void_type_node); 2483: 1.1.1.4 root 2484: /* Make sure every label has an rtx. */ 2485: label_rtx (decl); 2486: 1.1 root 2487: /* A label not explicitly declared must be local to where it's ref'd. */ 2488: DECL_CONTEXT (decl) = current_function_decl; 2489: 2490: DECL_MODE (decl) = VOIDmode; 2491: 2492: /* Say where one reference is to the label, 2493: for the sake of the error if it is not defined. */ 2494: DECL_SOURCE_LINE (decl) = lineno; 2495: DECL_SOURCE_FILE (decl) = input_filename; 2496: 2497: IDENTIFIER_LABEL_VALUE (id) = decl; 2498: 2499: named_labels = tree_cons (NULL_TREE, decl, named_labels); 2500: 2501: return decl; 2502: } 2503: 2504: /* Make a label named NAME in the current function, 2505: shadowing silently any that may be inherited from containing functions 2506: or containing scopes. 2507: 2508: Note that valid use, if the label being shadowed 2509: comes from another scope in the same function, 2510: requires calling declare_nonlocal_label right away. */ 2511: 2512: tree 2513: shadow_label (name) 2514: tree name; 2515: { 2516: register tree decl = IDENTIFIER_LABEL_VALUE (name); 2517: 2518: if (decl != 0) 2519: { 1.1.1.7 root 2520: register tree dup; 2521: 2522: /* Check to make sure that the label hasn't already been declared 2523: at this label scope */ 2524: for (dup = named_labels; dup; dup = TREE_CHAIN (dup)) 2525: if (TREE_VALUE (dup) == decl) 2526: { 2527: error ("duplicate label declaration `%s'", 2528: IDENTIFIER_POINTER (name)); 2529: error_with_decl (TREE_VALUE (dup), 2530: "this is a previous declaration"); 2531: /* Just use the previous declaration. */ 2532: return lookup_label (name); 2533: } 2534: 1.1 root 2535: shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels); 2536: IDENTIFIER_LABEL_VALUE (name) = decl = 0; 2537: } 2538: 2539: return lookup_label (name); 2540: } 2541: 2542: /* Define a label, specifying the location in the source file. 2543: Return the LABEL_DECL node for the label, if the definition is valid. 2544: Otherwise return 0. */ 2545: 2546: tree 2547: define_label (filename, line, name) 2548: char *filename; 2549: int line; 2550: tree name; 2551: { 2552: tree decl = lookup_label (name); 2553: 2554: /* If label with this name is known from an outer context, shadow it. */ 2555: if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl) 2556: { 2557: shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels); 2558: IDENTIFIER_LABEL_VALUE (name) = 0; 2559: decl = lookup_label (name); 2560: } 2561: 2562: if (DECL_INITIAL (decl) != 0) 2563: { 1.1.1.5 root 2564: error ("duplicate label `%s'", IDENTIFIER_POINTER (name)); 1.1 root 2565: return 0; 2566: } 2567: else 2568: { 2569: /* Mark label as having been defined. */ 2570: DECL_INITIAL (decl) = error_mark_node; 2571: /* Say where in the source. */ 2572: DECL_SOURCE_FILE (decl) = filename; 2573: DECL_SOURCE_LINE (decl) = line; 2574: return decl; 2575: } 2576: } 2577: 2578: /* Return the list of declarations of the current level. 2579: Note that this list is in reverse order unless/until 2580: you nreverse it; and when you do nreverse it, you must 2581: store the result back using `storedecls' or you will lose. */ 2582: 2583: tree 2584: getdecls () 2585: { 2586: return current_binding_level->names; 2587: } 2588: 2589: /* Return the list of type-tags (for structs, etc) of the current level. */ 2590: 2591: tree 2592: gettags () 2593: { 2594: return current_binding_level->tags; 2595: } 2596: 2597: /* Store the list of declarations of the current level. 2598: This is done for the parameter declarations of a function being defined, 2599: after they are modified in the light of any missing parameters. */ 2600: 2601: static void 2602: storedecls (decls) 2603: tree decls; 2604: { 2605: current_binding_level->names = decls; 2606: } 2607: 2608: /* Similarly, store the list of tags of the current level. */ 2609: 2610: static void 2611: storetags (tags) 2612: tree tags; 2613: { 2614: current_binding_level->tags = tags; 2615: } 2616: 2617: /* Given NAME, an IDENTIFIER_NODE, 2618: return the structure (or union or enum) definition for that name. 2619: Searches binding levels from BINDING_LEVEL up to the global level. 2620: If THISLEVEL_ONLY is nonzero, searches only the specified context 2621: (but skips any tag-transparent contexts to find one that is 2622: meaningful for tags). 2623: CODE says which kind of type the caller wants; 2624: it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE. 2625: If the wrong kind of type is found, an error is reported. */ 2626: 2627: static tree 2628: lookup_tag (code, name, binding_level, thislevel_only) 2629: enum tree_code code; 2630: struct binding_level *binding_level; 2631: tree name; 2632: int thislevel_only; 2633: { 2634: register struct binding_level *level; 2635: 2636: for (level = binding_level; level; level = level->level_chain) 2637: { 2638: register tree tail; 2639: for (tail = level->tags; tail; tail = TREE_CHAIN (tail)) 2640: { 2641: if (TREE_PURPOSE (tail) == name) 2642: { 2643: if (TREE_CODE (TREE_VALUE (tail)) != code) 2644: { 2645: /* Definition isn't the kind we were looking for. */ 2646: pending_invalid_xref = name; 2647: pending_invalid_xref_file = input_filename; 2648: pending_invalid_xref_line = lineno; 2649: } 2650: return TREE_VALUE (tail); 2651: } 2652: } 2653: if (thislevel_only && ! level->tag_transparent) 2654: return NULL_TREE; 2655: } 2656: return NULL_TREE; 2657: } 2658: 2659: /* Print an error message now 2660: for a recent invalid struct, union or enum cross reference. 2661: We don't print them immediately because they are not invalid 2662: when used in the `struct foo;' construct for shadowing. */ 2663: 2664: void 2665: pending_xref_error () 2666: { 2667: if (pending_invalid_xref != 0) 2668: error_with_file_and_line (pending_invalid_xref_file, 2669: pending_invalid_xref_line, 2670: "`%s' defined as wrong kind of tag", 2671: IDENTIFIER_POINTER (pending_invalid_xref)); 2672: pending_invalid_xref = 0; 2673: } 2674: 2675: /* Given a type, find the tag that was defined for it and return the tag name. 2676: Otherwise return 0. */ 2677: 2678: static tree 2679: lookup_tag_reverse (type) 2680: tree type; 2681: { 2682: register struct binding_level *level; 2683: 2684: for (level = current_binding_level; level; level = level->level_chain) 2685: { 2686: register tree tail; 2687: for (tail = level->tags; tail; tail = TREE_CHAIN (tail)) 2688: { 2689: if (TREE_VALUE (tail) == type) 2690: return TREE_PURPOSE (tail); 2691: } 2692: } 2693: return NULL_TREE; 2694: } 2695: 2696: /* Look up NAME in the current binding level and its superiors 2697: in the namespace of variables, functions and typedefs. 2698: Return a ..._DECL node of some kind representing its definition, 2699: or return 0 if it is undefined. */ 2700: 2701: tree 2702: lookup_name (name) 2703: tree name; 2704: { 2705: register tree val; 2706: if (current_binding_level != global_binding_level 2707: && IDENTIFIER_LOCAL_VALUE (name)) 2708: val = IDENTIFIER_LOCAL_VALUE (name); 2709: else 2710: val = IDENTIFIER_GLOBAL_VALUE (name); 2711: return val; 2712: } 2713: 2714: /* Similar to `lookup_name' but look only at current binding level. */ 2715: 1.1.1.5 root 2716: tree 1.1 root 2717: lookup_name_current_level (name) 2718: tree name; 2719: { 2720: register tree t; 2721: 2722: if (current_binding_level == global_binding_level) 2723: return IDENTIFIER_GLOBAL_VALUE (name); 2724: 2725: if (IDENTIFIER_LOCAL_VALUE (name) == 0) 2726: return 0; 2727: 2728: for (t = current_binding_level->names; t; t = TREE_CHAIN (t)) 2729: if (DECL_NAME (t) == name) 2730: break; 2731: 2732: return t; 2733: } 1.1.1.7 root 2734: 2735: /* Similar to `lookup_name_current_level' but also look at the global binding 2736: level. */ 2737: 2738: tree 2739: lookup_name_current_level_global (name) 2740: tree name; 2741: { 2742: register tree t = 0; 2743: 2744: if (current_binding_level == global_binding_level) 2745: return IDENTIFIER_GLOBAL_VALUE (name); 2746: 2747: if (IDENTIFIER_LOCAL_VALUE (name) != 0) 2748: for (t = current_binding_level->names; t; t = TREE_CHAIN (t)) 2749: if (DECL_NAME (t) == name) 2750: break; 2751: 2752: if (t == 0) 2753: t = IDENTIFIER_GLOBAL_VALUE (name); 2754: 2755: return t; 2756: } 1.1 root 2757: 2758: /* Create the predefined scalar types of C, 2759: and some nodes representing standard constants (0, 1, (void *)0). 2760: Initialize the global binding level. 2761: Make definitions for built-in primitive functions. */ 2762: 2763: void 2764: init_decl_processing () 2765: { 2766: register tree endlink; 2767: /* Either char* or void*. */ 2768: tree traditional_ptr_type_node; 1.1.1.3 root 2769: /* Data types of memcpy and strlen. */ 2770: tree memcpy_ftype, strlen_ftype; 2771: tree void_ftype_any; 1.1 root 2772: int wchar_type_size; 2773: tree temp; 1.1.1.5 root 2774: tree array_domain_type; 1.1 root 2775: 2776: current_function_decl = NULL; 2777: named_labels = NULL; 2778: current_binding_level = NULL_BINDING_LEVEL; 2779: free_binding_level = NULL_BINDING_LEVEL; 2780: pushlevel (0); /* make the binding_level structure for global names */ 2781: global_binding_level = current_binding_level; 2782: 2783: /* Define `int' and `char' first so that dbx will output them first. */ 2784: 2785: integer_type_node = make_signed_type (INT_TYPE_SIZE); 2786: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT], 2787: integer_type_node)); 2788: 2789: /* Define `char', which is like either `signed char' or `unsigned char' 2790: but not the same as either. */ 2791: 1.1.1.4 root 2792: char_type_node 2793: = (flag_signed_char 2794: ? make_signed_type (CHAR_TYPE_SIZE) 2795: : make_unsigned_type (CHAR_TYPE_SIZE)); 1.1 root 2796: pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), 2797: char_type_node)); 2798: 2799: long_integer_type_node = make_signed_type (LONG_TYPE_SIZE); 2800: pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"), 2801: long_integer_type_node)); 2802: 2803: unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE); 2804: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"), 2805: unsigned_type_node)); 2806: 2807: long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE); 2808: pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"), 2809: long_unsigned_type_node)); 2810: 1.1.1.6 root 2811: long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE); 2812: pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"), 2813: long_long_integer_type_node)); 2814: 2815: long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE); 2816: pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"), 2817: long_long_unsigned_type_node)); 2818: 1.1 root 2819: /* `unsigned long' is the standard type for sizeof. 2820: Traditionally, use a signed type. 2821: Note that stddef.h uses `unsigned long', 2822: and this must agree, even of long and int are the same size. */ 1.1.1.6 root 2823: sizetype 2824: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))); 2825: if (flag_traditional && TREE_UNSIGNED (sizetype)) 2826: sizetype = signed_type (sizetype); 1.1 root 2827: 2828: ptrdiff_type_node 2829: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE))); 2830: 2831: TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype; 2832: TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype; 2833: TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype; 2834: TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype; 2835: TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype; 1.1.1.6 root 2836: TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype; 2837: TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype; 1.1 root 2838: 2839: error_mark_node = make_node (ERROR_MARK); 2840: TREE_TYPE (error_mark_node) = error_mark_node; 2841: 2842: short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE); 2843: pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"), 2844: short_integer_type_node)); 2845: 2846: short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE); 2847: pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"), 2848: short_unsigned_type_node)); 2849: 2850: /* Define both `signed char' and `unsigned char'. */ 2851: signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE); 2852: pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"), 2853: signed_char_type_node)); 2854: 2855: unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE); 2856: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"), 2857: unsigned_char_type_node)); 2858: 1.1.1.4 root 2859: intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode)); 2860: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node)); 2861: 2862: intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode)); 2863: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node)); 2864: 2865: intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode)); 2866: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node)); 2867: 2868: intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode)); 2869: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node)); 2870: 2871: unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode)); 2872: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node)); 2873: 2874: unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode)); 2875: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node)); 2876: 2877: unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode)); 2878: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node)); 2879: 2880: unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode)); 2881: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node)); 2882: 1.1 root 2883: float_type_node = make_node (REAL_TYPE); 2884: TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE; 2885: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT], 2886: float_type_node)); 2887: layout_type (float_type_node); 2888: 2889: double_type_node = make_node (REAL_TYPE); 2890: if (flag_short_double) 2891: TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE; 2892: else 2893: TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE; 2894: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE], 2895: double_type_node)); 2896: layout_type (double_type_node); 2897: 2898: long_double_type_node = make_node (REAL_TYPE); 2899: TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE; 2900: pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"), 2901: long_double_type_node)); 2902: layout_type (long_double_type_node); 2903: 1.1.1.5 root 2904: complex_integer_type_node = make_node (COMPLEX_TYPE); 2905: pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"), 2906: complex_integer_type_node)); 2907: TREE_TYPE (complex_integer_type_node) = integer_type_node; 2908: layout_type (complex_integer_type_node); 2909: 2910: complex_float_type_node = make_node (COMPLEX_TYPE); 2911: pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"), 2912: complex_float_type_node)); 2913: TREE_TYPE (complex_float_type_node) = float_type_node; 2914: layout_type (complex_float_type_node); 2915: 2916: complex_double_type_node = make_node (COMPLEX_TYPE); 2917: pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"), 2918: complex_double_type_node)); 2919: TREE_TYPE (complex_double_type_node) = double_type_node; 2920: layout_type (complex_double_type_node); 2921: 2922: complex_long_double_type_node = make_node (COMPLEX_TYPE); 2923: pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"), 2924: complex_long_double_type_node)); 2925: TREE_TYPE (complex_long_double_type_node) = long_double_type_node; 2926: layout_type (complex_long_double_type_node); 2927: 1.1 root 2928: wchar_type_node 2929: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE))); 2930: wchar_type_size = TYPE_PRECISION (wchar_type_node); 1.1.1.6 root 2931: signed_wchar_type_node = signed_type (wchar_type_node); 2932: unsigned_wchar_type_node = unsigned_type (wchar_type_node); 1.1 root 2933: 2934: integer_zero_node = build_int_2 (0, 0); 2935: TREE_TYPE (integer_zero_node) = integer_type_node; 2936: integer_one_node = build_int_2 (1, 0); 2937: TREE_TYPE (integer_one_node) = integer_type_node; 2938: 1.1.1.8 ! root 2939: boolean_type_node = integer_type_node; ! 2940: boolean_true_node = integer_one_node; ! 2941: boolean_false_node = integer_zero_node; ! 2942: 1.1 root 2943: size_zero_node = build_int_2 (0, 0); 2944: TREE_TYPE (size_zero_node) = sizetype; 2945: size_one_node = build_int_2 (1, 0); 2946: TREE_TYPE (size_one_node) = sizetype; 2947: 2948: void_type_node = make_node (VOID_TYPE); 2949: pushdecl (build_decl (TYPE_DECL, 2950: ridpointers[(int) RID_VOID], void_type_node)); 2951: layout_type (void_type_node); /* Uses integer_zero_node */ 2952: /* We are not going to have real types in C with less than byte alignment, 2953: so we might as well not have any types that claim to have it. */ 2954: TYPE_ALIGN (void_type_node) = BITS_PER_UNIT; 2955: 2956: null_pointer_node = build_int_2 (0, 0); 2957: TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node); 2958: layout_type (TREE_TYPE (null_pointer_node)); 2959: 2960: string_type_node = build_pointer_type (char_type_node); 2961: const_string_type_node 2962: = build_pointer_type (build_type_variant (char_type_node, 1, 0)); 2963: 1.1.1.5 root 2964: /* Make a type to be the domain of a few array types 2965: whose domains don't really matter. 2966: 200 is small enough that it always fits in size_t 2967: and large enough that it can hold most function names for the 2968: initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */ 2969: array_domain_type = build_index_type (build_int_2 (200, 0)); 2970: 2971: /* make a type for arrays of characters. 1.1 root 2972: With luck nothing will ever really depend on the length of this 2973: array type. */ 2974: char_array_type_node 1.1.1.5 root 2975: = build_array_type (char_type_node, array_domain_type); 1.1 root 2976: /* Likewise for arrays of ints. */ 2977: int_array_type_node 1.1.1.5 root 2978: = build_array_type (integer_type_node, array_domain_type); 1.1 root 2979: /* This is for wide string constants. */ 2980: wchar_array_type_node 1.1.1.5 root 2981: = build_array_type (wchar_type_node, array_domain_type); 1.1 root 2982: 2983: default_function_type 2984: = build_function_type (integer_type_node, NULL_TREE); 2985: 2986: ptr_type_node = build_pointer_type (void_type_node); 2987: const_ptr_type_node 2988: = build_pointer_type (build_type_variant (void_type_node, 1, 0)); 2989: 2990: endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE); 2991: 1.1.1.3 root 2992: void_ftype_any 1.1.1.4 root 2993: = build_function_type (void_type_node, NULL_TREE); 1.1.1.3 root 2994: 1.1.1.8 ! root 2995: float_ftype_float ! 2996: = build_function_type (float_type_node, ! 2997: tree_cons (NULL_TREE, float_type_node, endlink)); ! 2998: 1.1 root 2999: double_ftype_double 3000: = build_function_type (double_type_node, 3001: tree_cons (NULL_TREE, double_type_node, endlink)); 3002: 1.1.1.8 ! root 3003: ldouble_ftype_ldouble ! 3004: = build_function_type (long_double_type_node, ! 3005: tree_cons (NULL_TREE, long_double_type_node, ! 3006: endlink)); ! 3007: 1.1 root 3008: double_ftype_double_double 3009: = build_function_type (double_type_node, 3010: tree_cons (NULL_TREE, double_type_node, 3011: tree_cons (NULL_TREE, 3012: double_type_node, endlink))); 3013: 3014: int_ftype_int 3015: = build_function_type (integer_type_node, 3016: tree_cons (NULL_TREE, integer_type_node, endlink)); 3017: 3018: long_ftype_long 3019: = build_function_type (long_integer_type_node, 3020: tree_cons (NULL_TREE, 3021: long_integer_type_node, endlink)); 3022: 3023: void_ftype_ptr_ptr_int 3024: = build_function_type (void_type_node, 3025: tree_cons (NULL_TREE, ptr_type_node, 3026: tree_cons (NULL_TREE, ptr_type_node, 3027: tree_cons (NULL_TREE, 3028: integer_type_node, 3029: endlink)))); 3030: 3031: int_ftype_cptr_cptr_sizet 3032: = build_function_type (integer_type_node, 3033: tree_cons (NULL_TREE, const_ptr_type_node, 3034: tree_cons (NULL_TREE, const_ptr_type_node, 3035: tree_cons (NULL_TREE, 3036: sizetype, 3037: endlink)))); 3038: 3039: void_ftype_ptr_int_int 3040: = build_function_type (void_type_node, 3041: tree_cons (NULL_TREE, ptr_type_node, 3042: tree_cons (NULL_TREE, integer_type_node, 3043: tree_cons (NULL_TREE, 3044: integer_type_node, 3045: endlink)))); 3046: 3047: string_ftype_ptr_ptr /* strcpy prototype */ 3048: = build_function_type (string_type_node, 3049: tree_cons (NULL_TREE, string_type_node, 3050: tree_cons (NULL_TREE, 3051: const_string_type_node, 3052: endlink))); 3053: 3054: int_ftype_string_string /* strcmp prototype */ 3055: = build_function_type (integer_type_node, 3056: tree_cons (NULL_TREE, const_string_type_node, 3057: tree_cons (NULL_TREE, 3058: const_string_type_node, 3059: endlink))); 3060: 1.1.1.3 root 3061: strlen_ftype /* strlen prototype */ 3062: = build_function_type (flag_traditional ? integer_type_node : sizetype, 1.1 root 3063: tree_cons (NULL_TREE, const_string_type_node, 3064: endlink)); 3065: 3066: traditional_ptr_type_node 3067: = (flag_traditional ? string_type_node : ptr_type_node); 3068: 3069: memcpy_ftype /* memcpy prototype */ 3070: = build_function_type (traditional_ptr_type_node, 3071: tree_cons (NULL_TREE, ptr_type_node, 3072: tree_cons (NULL_TREE, const_ptr_type_node, 3073: tree_cons (NULL_TREE, 3074: sizetype, 3075: endlink)))); 3076: 1.1.1.8 ! root 3077: builtin_function ("__builtin_constant_p", default_function_type, 1.1.1.4 root 3078: BUILT_IN_CONSTANT_P, NULL_PTR); 1.1 root 3079: 3080: builtin_function ("__builtin_return_address", 1.1.1.4 root 3081: build_function_type (ptr_type_node, 1.1 root 3082: tree_cons (NULL_TREE, 3083: unsigned_type_node, 3084: endlink)), 1.1.1.4 root 3085: BUILT_IN_RETURN_ADDRESS, NULL_PTR); 1.1 root 3086: 3087: builtin_function ("__builtin_frame_address", 1.1.1.4 root 3088: build_function_type (ptr_type_node, 1.1 root 3089: tree_cons (NULL_TREE, 3090: unsigned_type_node, 3091: endlink)), 1.1.1.4 root 3092: BUILT_IN_FRAME_ADDRESS, NULL_PTR); 1.1 root 3093: 3094: builtin_function ("__builtin_alloca", 3095: build_function_type (ptr_type_node, 3096: tree_cons (NULL_TREE, 3097: sizetype, 3098: endlink)), 3099: BUILT_IN_ALLOCA, "alloca"); 1.1.1.5 root 3100: builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR); 3101: /* Define alloca, ffs as builtins. 3102: Declare _exit just to mark it as volatile. */ 1.1.1.3 root 3103: if (! flag_no_builtin && !flag_no_nonansi_builtin) 1.1 root 3104: { 3105: temp = builtin_function ("alloca", 3106: build_function_type (ptr_type_node, 3107: tree_cons (NULL_TREE, 3108: sizetype, 3109: endlink)), 1.1.1.4 root 3110: BUILT_IN_ALLOCA, NULL_PTR); 1.1 root 3111: /* Suppress error if redefined as a non-function. */ 3112: DECL_BUILT_IN_NONANSI (temp) = 1; 1.1.1.5 root 3113: temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR); 3114: /* Suppress error if redefined as a non-function. */ 3115: DECL_BUILT_IN_NONANSI (temp) = 1; 1.1.1.4 root 3116: temp = builtin_function ("_exit", void_ftype_any, NOT_BUILT_IN, 3117: NULL_PTR); 1.1 root 3118: TREE_THIS_VOLATILE (temp) = 1; 3119: TREE_SIDE_EFFECTS (temp) = 1; 3120: /* Suppress error if redefined as a non-function. */ 3121: DECL_BUILT_IN_NONANSI (temp) = 1; 3122: } 3123: 1.1.1.4 root 3124: builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR); 1.1.1.8 ! root 3125: builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS, ! 3126: NULL_PTR); 1.1.1.4 root 3127: builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS, 3128: NULL_PTR); 1.1.1.8 ! root 3129: builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS, ! 3130: NULL_PTR); 1.1.1.4 root 3131: builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS, 3132: NULL_PTR); 3133: builtin_function ("__builtin_saveregs", 3134: build_function_type (ptr_type_node, NULL_TREE), 3135: BUILT_IN_SAVEREGS, NULL_PTR); 1.1 root 3136: /* EXPAND_BUILTIN_VARARGS is obsolete. */ 3137: #if 0 3138: builtin_function ("__builtin_varargs", 3139: build_function_type (ptr_type_node, 3140: tree_cons (NULL_TREE, 3141: integer_type_node, 3142: endlink)), 1.1.1.4 root 3143: BUILT_IN_VARARGS, NULL_PTR); 1.1 root 3144: #endif 3145: builtin_function ("__builtin_classify_type", default_function_type, 1.1.1.4 root 3146: BUILT_IN_CLASSIFY_TYPE, NULL_PTR); 1.1 root 3147: builtin_function ("__builtin_next_arg", 1.1.1.7 root 3148: build_function_type (ptr_type_node, NULL_TREE), 1.1.1.4 root 3149: BUILT_IN_NEXT_ARG, NULL_PTR); 1.1 root 3150: builtin_function ("__builtin_args_info", 3151: build_function_type (integer_type_node, 3152: tree_cons (NULL_TREE, 3153: integer_type_node, 3154: endlink)), 1.1.1.4 root 3155: BUILT_IN_ARGS_INFO, NULL_PTR); 1.1 root 3156: 1.1.1.5 root 3157: /* Untyped call and return. */ 3158: builtin_function ("__builtin_apply_args", 3159: build_function_type (ptr_type_node, NULL_TREE), 3160: BUILT_IN_APPLY_ARGS, NULL_PTR); 3161: 3162: temp = tree_cons (NULL_TREE, 3163: build_pointer_type (build_function_type (void_type_node, 3164: NULL_TREE)), 3165: tree_cons (NULL_TREE, 3166: ptr_type_node, 3167: tree_cons (NULL_TREE, 3168: sizetype, 3169: endlink))); 3170: builtin_function ("__builtin_apply", 3171: build_function_type (ptr_type_node, temp), 3172: BUILT_IN_APPLY, NULL_PTR); 3173: builtin_function ("__builtin_return", 3174: build_function_type (void_type_node, 3175: tree_cons (NULL_TREE, 3176: ptr_type_node, 3177: endlink)), 3178: BUILT_IN_RETURN, NULL_PTR); 3179: 1.1 root 3180: /* Currently under experimentation. */ 3181: builtin_function ("__builtin_memcpy", memcpy_ftype, 3182: BUILT_IN_MEMCPY, "memcpy"); 3183: builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet, 3184: BUILT_IN_MEMCMP, "memcmp"); 3185: builtin_function ("__builtin_strcmp", int_ftype_string_string, 3186: BUILT_IN_STRCMP, "strcmp"); 3187: builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr, 3188: BUILT_IN_STRCPY, "strcpy"); 1.1.1.3 root 3189: builtin_function ("__builtin_strlen", strlen_ftype, 1.1 root 3190: BUILT_IN_STRLEN, "strlen"); 1.1.1.8 ! root 3191: builtin_function ("__builtin_sqrtf", float_ftype_float, ! 3192: BUILT_IN_FSQRT, "sqrtf"); 1.1.1.2 root 3193: builtin_function ("__builtin_fsqrt", double_ftype_double, 3194: BUILT_IN_FSQRT, "sqrt"); 1.1.1.8 ! root 3195: builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble, ! 3196: BUILT_IN_FSQRT, "sqrtl"); ! 3197: builtin_function ("__builtin_sinf", float_ftype_float, ! 3198: BUILT_IN_SIN, "sinf"); 1.1.1.4 root 3199: builtin_function ("__builtin_sin", double_ftype_double, 3200: BUILT_IN_SIN, "sin"); 1.1.1.8 ! root 3201: builtin_function ("__builtin_sinl", ldouble_ftype_ldouble, ! 3202: BUILT_IN_SIN, "sinl"); ! 3203: builtin_function ("__builtin_cosf", float_ftype_float, ! 3204: BUILT_IN_COS, "cosf"); 1.1.1.4 root 3205: builtin_function ("__builtin_cos", double_ftype_double, 3206: BUILT_IN_COS, "cos"); 1.1.1.8 ! root 3207: builtin_function ("__builtin_cosl", ldouble_ftype_ldouble, ! 3208: BUILT_IN_COS, "cosl"); 1.1.1.4 root 3209: 1.1 root 3210: /* In an ANSI C program, it is okay to supply built-in meanings 3211: for these functions, since applications cannot validly use them 3212: with any other meaning. 1.1.1.3 root 3213: However, honor the -fno-builtin option. */ 3214: if (!flag_no_builtin) 1.1 root 3215: { 1.1.1.4 root 3216: builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR); 1.1.1.8 ! root 3217: builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR); 1.1.1.4 root 3218: builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR); 1.1.1.8 ! root 3219: builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS, ! 3220: NULL_PTR); 1.1.1.4 root 3221: builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR); 3222: builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR); 3223: builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP, 3224: NULL_PTR); 3225: builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP, 3226: NULL_PTR); 3227: builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY, 3228: NULL_PTR); 3229: builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR); 1.1.1.8 ! root 3230: builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR); 1.1.1.4 root 3231: builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR); 1.1.1.8 ! root 3232: builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT, ! 3233: NULL_PTR); ! 3234: builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR); 1.1.1.4 root 3235: builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR); 1.1.1.8 ! root 3236: builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR); ! 3237: builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR); 1.1.1.4 root 3238: builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR); 1.1.1.8 ! root 3239: builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR); 1.1.1.3 root 3240: 3241: /* Declare these functions volatile 3242: to avoid spurious "control drops through" warnings. */ 3243: /* Don't specify the argument types, to avoid errors 3244: from certain code which isn't valid in ANSI but which exists. */ 1.1.1.4 root 3245: temp = builtin_function ("abort", void_ftype_any, NOT_BUILT_IN, 3246: NULL_PTR); 1.1.1.3 root 3247: TREE_THIS_VOLATILE (temp) = 1; 3248: TREE_SIDE_EFFECTS (temp) = 1; 1.1.1.4 root 3249: temp = builtin_function ("exit", void_ftype_any, NOT_BUILT_IN, NULL_PTR); 1.1.1.3 root 3250: TREE_THIS_VOLATILE (temp) = 1; 3251: TREE_SIDE_EFFECTS (temp) = 1; 1.1 root 3252: } 3253: 3254: #if 0 3255: /* Support for these has not been written in either expand_builtin 3256: or build_function_call. */ 1.1.1.4 root 3257: builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR); 3258: builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR); 3259: builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR, 3260: NULL_PTR); 3261: builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL, 3262: NULL_PTR); 3263: builtin_function ("__builtin_fmod", double_ftype_double_double, 3264: BUILT_IN_FMOD, NULL_PTR); 3265: builtin_function ("__builtin_frem", double_ftype_double_double, 3266: BUILT_IN_FREM, NULL_PTR); 3267: builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int, 3268: BUILT_IN_MEMSET, NULL_PTR); 3269: builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP, 3270: NULL_PTR); 3271: builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN, 3272: NULL_PTR); 1.1 root 3273: #endif 3274: 1.1.1.8 ! root 3275: pedantic_lvalues = pedantic; ! 3276: 1.1.1.3 root 3277: /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */ 3278: declare_function_name (); 3279: 1.1 root 3280: start_identifier_warnings (); 3281: 1.1.1.6 root 3282: /* Prepare to check format strings against argument lists. */ 3283: init_function_format_info (); 1.1.1.5 root 3284: 3285: init_iterators (); 3286: 3287: incomplete_decl_finalize_hook = finish_incomplete_decl; 1.1 root 3288: } 3289: 3290: /* Return a definition for a builtin function named NAME and whose data type 3291: is TYPE. TYPE should be a function type with argument types. 3292: FUNCTION_CODE tells later passes how to compile calls to this function. 3293: See tree.h for its possible values. 3294: 3295: If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME, 3296: the name to be called if we can't opencode the function. */ 3297: 1.1.1.2 root 3298: tree 1.1 root 3299: builtin_function (name, type, function_code, library_name) 3300: char *name; 3301: tree type; 3302: enum built_in_function function_code; 3303: char *library_name; 3304: { 3305: tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type); 1.1.1.4 root 3306: DECL_EXTERNAL (decl) = 1; 1.1 root 3307: TREE_PUBLIC (decl) = 1; 1.1.1.3 root 3308: /* If -traditional, permit redefining a builtin function any way you like. 3309: (Though really, if the program redefines these functions, 3310: it probably won't work right unless compiled with -fno-builtin.) */ 3311: if (flag_traditional && name[0] != '_') 3312: DECL_BUILT_IN_NONANSI (decl) = 1; 1.1 root 3313: if (library_name) 3314: DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name); 1.1.1.4 root 3315: make_decl_rtl (decl, NULL_PTR, 1); 1.1 root 3316: pushdecl (decl); 3317: if (function_code != NOT_BUILT_IN) 3318: { 3319: DECL_BUILT_IN (decl) = 1; 1.1.1.7 root 3320: DECL_FUNCTION_CODE (decl) = function_code; 1.1 root 3321: } 1.1.1.4 root 3322: /* Warn if a function in the namespace for users 3323: is used without an occasion to consider it declared. */ 3324: if (name[0] != '_' || name[1] != '_') 3325: C_DECL_ANTICIPATED (decl) = 1; 1.1 root 3326: 3327: return decl; 3328: } 3329: 3330: /* Called when a declaration is seen that contains no names to declare. 3331: If its type is a reference to a structure, union or enum inherited 3332: from a containing scope, shadow that tag name for the current scope 3333: with a forward reference. 3334: If its type defines a new named structure or union 3335: or defines an enum, it is valid but we need not do anything here. 3336: Otherwise, it is an error. */ 3337: 3338: void 3339: shadow_tag (declspecs) 3340: tree declspecs; 3341: { 1.1.1.4 root 3342: shadow_tag_warned (declspecs, 0); 3343: } 3344: 3345: void 3346: shadow_tag_warned (declspecs, warned) 3347: tree declspecs; 3348: int warned; 1.1.1.5 root 3349: /* 1 => we have done a pedwarn. 2 => we have done a warning, but 3350: no pedwarn. */ 1.1.1.4 root 3351: { 1.1 root 3352: int found_tag = 0; 3353: register tree link; 3354: 3355: pending_invalid_xref = 0; 3356: 3357: for (link = declspecs; link; link = TREE_CHAIN (link)) 3358: { 3359: register tree value = TREE_VALUE (link); 3360: register enum tree_code code = TREE_CODE (value); 3361: 3362: if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE) 3363: /* Used to test also that TYPE_SIZE (value) != 0. 3364: That caused warning for `struct foo;' at top level in the file. */ 3365: { 3366: register tree name = lookup_tag_reverse (value); 3367: register tree t; 3368: 3369: found_tag++; 3370: 3371: if (name == 0) 3372: { 1.1.1.5 root 3373: if (warned != 1 && code != ENUMERAL_TYPE) 3374: /* Empty unnamed enum OK */ 1.1 root 3375: { 3376: pedwarn ("unnamed struct/union that defines no instances"); 3377: warned = 1; 3378: } 3379: } 3380: else 3381: { 3382: t = lookup_tag (code, name, current_binding_level, 1); 3383: 3384: if (t == 0) 3385: { 3386: t = make_node (code); 3387: pushtag (name, t); 3388: } 3389: } 3390: } 3391: else 3392: { 1.1.1.8 ! root 3393: if (!warned && ! in_system_header) 1.1.1.5 root 3394: { 3395: warning ("useless keyword or type name in empty declaration"); 3396: warned = 2; 3397: } 1.1 root 3398: } 3399: } 3400: 1.1.1.5 root 3401: if (found_tag > 1) 3402: error ("two types specified in one empty declaration"); 3403: 3404: if (warned != 1) 1.1 root 3405: { 3406: if (found_tag == 0) 3407: pedwarn ("empty declaration"); 3408: } 3409: } 3410: 3411: /* Decode a "typename", such as "int **", returning a ..._TYPE node. */ 3412: 3413: tree 3414: groktypename (typename) 3415: tree typename; 3416: { 3417: if (TREE_CODE (typename) != TREE_LIST) 3418: return typename; 3419: return grokdeclarator (TREE_VALUE (typename), 3420: TREE_PURPOSE (typename), 3421: TYPENAME, 0); 3422: } 3423: 3424: /* Return a PARM_DECL node for a given pair of specs and declarator. */ 3425: 3426: tree 3427: groktypename_in_parm_context (typename) 3428: tree typename; 3429: { 3430: if (TREE_CODE (typename) != TREE_LIST) 3431: return typename; 3432: return grokdeclarator (TREE_VALUE (typename), 3433: TREE_PURPOSE (typename), 3434: PARM, 0); 3435: } 3436: 3437: /* Decode a declarator in an ordinary declaration or data definition. 3438: This is called as soon as the type information and variable name 3439: have been parsed, before parsing the initializer if any. 3440: Here we create the ..._DECL node, fill in its type, 3441: and put it on the list of decls for the current context. 3442: The ..._DECL node is returned as the value. 3443: 3444: Exception: for arrays where the length is not specified, 3445: the type is left null, to be filled in by `finish_decl'. 3446: 3447: Function definitions do not come here; they go to start_function 3448: instead. However, external and forward declarations of functions 3449: do go through here. Structure field declarations are done by 3450: grokfield and not through here. */ 3451: 3452: /* Set this to zero to debug not using the temporary obstack 3453: to parse initializers. */ 3454: int debug_temp_inits = 1; 3455: 3456: tree 1.1.1.8 ! root 3457: start_decl (declarator, declspecs, initialized, attributes, prefix_attributes) 1.1.1.5 root 3458: tree declarator, declspecs; 1.1 root 3459: int initialized; 1.1.1.8 ! root 3460: tree attributes, prefix_attributes; 1.1 root 3461: { 3462: register tree decl = grokdeclarator (declarator, declspecs, 3463: NORMAL, initialized); 3464: register tree tem; 3465: int init_written = initialized; 3466: 3467: /* The corresponding pop_obstacks is in finish_decl. */ 3468: push_obstacks_nochange (); 3469: 3470: if (initialized) 3471: /* Is it valid for this decl to have an initializer at all? 3472: If not, set INITIALIZED to zero, which will indirectly 3473: tell `finish_decl' to ignore the initializer once it is parsed. */ 3474: switch (TREE_CODE (decl)) 3475: { 3476: case TYPE_DECL: 3477: /* typedef foo = bar means give foo the same type as bar. 3478: We haven't parsed bar yet, so `finish_decl' will fix that up. 3479: Any other case of an initialization in a TYPE_DECL is an error. */ 3480: if (pedantic || list_length (declspecs) > 1) 3481: { 3482: error ("typedef `%s' is initialized", 3483: IDENTIFIER_POINTER (DECL_NAME (decl))); 3484: initialized = 0; 3485: } 3486: break; 3487: 3488: case FUNCTION_DECL: 3489: error ("function `%s' is initialized like a variable", 3490: IDENTIFIER_POINTER (DECL_NAME (decl))); 3491: initialized = 0; 3492: break; 3493: 3494: case PARM_DECL: 3495: /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */ 3496: error ("parameter `%s' is initialized", 3497: IDENTIFIER_POINTER (DECL_NAME (decl))); 3498: initialized = 0; 3499: break; 3500: 3501: default: 3502: /* Don't allow initializations for incomplete types 3503: except for arrays which might be completed by the initialization. */ 3504: if (TYPE_SIZE (TREE_TYPE (decl)) != 0) 3505: { 3506: /* A complete type is ok if size is fixed. */ 3507: 3508: if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST 3509: || C_DECL_VARIABLE_SIZE (decl)) 3510: { 3511: error ("variable-sized object may not be initialized"); 3512: initialized = 0; 3513: } 3514: } 3515: else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE) 3516: { 3517: error ("variable `%s' has initializer but incomplete type", 3518: IDENTIFIER_POINTER (DECL_NAME (decl))); 3519: initialized = 0; 3520: } 3521: else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0) 3522: { 3523: error ("elements of array `%s' have incomplete type", 3524: IDENTIFIER_POINTER (DECL_NAME (decl))); 3525: initialized = 0; 3526: } 3527: } 3528: 3529: if (initialized) 3530: { 3531: #if 0 /* Seems redundant with grokdeclarator. */ 3532: if (current_binding_level != global_binding_level 1.1.1.4 root 3533: && DECL_EXTERNAL (decl) 1.1 root 3534: && TREE_CODE (decl) != FUNCTION_DECL) 3535: warning ("declaration of `%s' has `extern' and is initialized", 3536: IDENTIFIER_POINTER (DECL_NAME (decl))); 3537: #endif 1.1.1.4 root 3538: DECL_EXTERNAL (decl) = 0; 1.1 root 3539: if (current_binding_level == global_binding_level) 3540: TREE_STATIC (decl) = 1; 3541: 3542: /* Tell `pushdecl' this is an initialized decl 3543: even though we don't yet have the initializer expression. 3544: Also tell `finish_decl' it may store the real initializer. */ 3545: DECL_INITIAL (decl) = error_mark_node; 3546: } 3547: 3548: /* If this is a function declaration, write a record describing it to the 3549: prototypes file (if requested). */ 3550: 3551: if (TREE_CODE (decl) == FUNCTION_DECL) 3552: gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0); 3553: 1.1.1.8 ! root 3554: /* For C and Objective-C, we by default put things in .common when ! 3555: possible. */ ! 3556: DECL_COMMON (decl) = 1; ! 3557: ! 3558: /* Set attributes here so if duplicate decl, will have proper attributes. */ ! 3559: decl_attributes (decl, attributes, prefix_attributes); ! 3560: 1.1 root 3561: /* Add this decl to the current binding level. 3562: TEM may equal DECL or it may be a previous decl of the same name. */ 3563: tem = pushdecl (decl); 3564: 3565: /* For a local variable, define the RTL now. */ 3566: if (current_binding_level != global_binding_level 3567: /* But not if this is a duplicate decl 3568: and we preserved the rtl from the previous one 3569: (which may or may not happen). */ 3570: && DECL_RTL (tem) == 0) 3571: { 3572: if (TYPE_SIZE (TREE_TYPE (tem)) != 0) 3573: expand_decl (tem); 3574: else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE 3575: && DECL_INITIAL (tem) != 0) 3576: expand_decl (tem); 3577: } 3578: 3579: if (init_written) 3580: { 3581: /* When parsing and digesting the initializer, 3582: use temporary storage. Do this even if we will ignore the value. */ 3583: if (current_binding_level == global_binding_level && debug_temp_inits) 3584: temporary_allocation (); 3585: } 3586: 3587: return tem; 3588: } 3589: 3590: /* Finish processing of a declaration; 3591: install its initial value. 3592: If the length of an array type is not known before, 3593: it must be determined now, from the initial value, or it is an error. */ 3594: 3595: void 3596: finish_decl (decl, init, asmspec_tree) 3597: tree decl, init; 3598: tree asmspec_tree; 3599: { 3600: register tree type = TREE_TYPE (decl); 3601: int was_incomplete = (DECL_SIZE (decl) == 0); 3602: int temporary = allocation_temporary_p (); 3603: char *asmspec = 0; 3604: 1.1.1.7 root 3605: /* If a name was specified, get the string. */ 1.1 root 3606: if (asmspec_tree) 3607: asmspec = TREE_STRING_POINTER (asmspec_tree); 3608: 3609: /* If `start_decl' didn't like having an initialization, ignore it now. */ 3610: 3611: if (init != 0 && DECL_INITIAL (decl) == 0) 3612: init = 0; 3613: /* Don't crash if parm is initialized. */ 3614: if (TREE_CODE (decl) == PARM_DECL) 3615: init = 0; 3616: 1.1.1.5 root 3617: if (ITERATOR_P (decl)) 3618: { 3619: if (init == 0) 3620: error_with_decl (decl, "iterator has no initial value"); 3621: else 3622: init = save_expr (init); 3623: } 3624: 1.1 root 3625: if (init) 3626: { 3627: if (TREE_CODE (decl) != TYPE_DECL) 3628: store_init_value (decl, init); 3629: else 3630: { 3631: /* typedef foo = bar; store the type of bar as the type of foo. */ 3632: TREE_TYPE (decl) = TREE_TYPE (init); 3633: DECL_INITIAL (decl) = init = 0; 3634: } 3635: } 3636: 1.1.1.4 root 3637: /* Pop back to the obstack that is current for this binding level. 3638: This is because MAXINDEX, rtl, etc. to be made below 3639: must go in the permanent obstack. But don't discard the 1.1 root 3640: temporary data yet. */ 1.1.1.4 root 3641: pop_obstacks (); 3642: #if 0 /* pop_obstacks was near the end; this is what was here. */ 1.1 root 3643: if (current_binding_level == global_binding_level && temporary) 3644: end_temporary_allocation (); 1.1.1.4 root 3645: #endif 1.1 root 3646: 3647: /* Deduce size of array from initialization, if not already known */ 3648: 3649: if (TREE_CODE (type) == ARRAY_TYPE 3650: && TYPE_DOMAIN (type) == 0 3651: && TREE_CODE (decl) != TYPE_DECL) 3652: { 3653: int do_default 3654: = (TREE_STATIC (decl) 3655: /* Even if pedantic, an external linkage array 3656: may have incomplete type at first. */ 3657: ? pedantic && !TREE_PUBLIC (decl) 1.1.1.4 root 3658: : !DECL_EXTERNAL (decl)); 1.1 root 3659: int failure 3660: = complete_array_type (type, DECL_INITIAL (decl), do_default); 3661: 3662: /* Get the completed type made by complete_array_type. */ 3663: type = TREE_TYPE (decl); 3664: 3665: if (failure == 1) 3666: error_with_decl (decl, "initializer fails to determine size of `%s'"); 3667: 3668: if (failure == 2) 3669: { 3670: if (do_default) 3671: error_with_decl (decl, "array size missing in `%s'"); 1.1.1.5 root 3672: /* If a `static' var's size isn't known, 3673: make it extern as well as static, so it does not get 3674: allocated. 3675: If it is not `static', then do not mark extern; 3676: finish_incomplete_decl will give it a default size 3677: and it will get allocated. */ 3678: else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl)) 1.1.1.4 root 3679: DECL_EXTERNAL (decl) = 1; 1.1 root 3680: } 3681: 1.1.1.7 root 3682: /* TYPE_MAX_VALUE is always one less than the number of elements 3683: in the array, because we start counting at zero. Therefore, 3684: warn only if the value is less than zero. */ 1.1 root 3685: if (pedantic && TYPE_DOMAIN (type) != 0 1.1.1.7 root 3686: && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0) 3687: error_with_decl (decl, "zero or negative size array `%s'"); 1.1 root 3688: 3689: layout_decl (decl, 0); 3690: } 3691: 3692: if (TREE_CODE (decl) == VAR_DECL) 3693: { 1.1.1.4 root 3694: if (DECL_SIZE (decl) == 0 1.1.1.5 root 3695: && TYPE_SIZE (TREE_TYPE (decl)) != 0) 3696: layout_decl (decl, 0); 3697: 3698: if (DECL_SIZE (decl) == 0 1.1.1.4 root 3699: && (TREE_STATIC (decl) 3700: ? 3701: /* A static variable with an incomplete type 1.1.1.6 root 3702: is an error if it is initialized. 3703: Also if it is not file scope. 1.1.1.4 root 3704: Otherwise, let it through, but if it is not `extern' 3705: then it may cause an error message later. */ 1.1.1.8 ! root 3706: /* We must use DECL_CONTEXT instead of current_binding_level, ! 3707: because a duplicate_decls call could have changed the binding ! 3708: level of this decl. */ ! 3709: (DECL_INITIAL (decl) != 0 || DECL_CONTEXT (decl) != 0) 1.1.1.4 root 3710: : 3711: /* An automatic variable with an incomplete type 3712: is an error. */ 3713: !DECL_EXTERNAL (decl))) 1.1 root 3714: { 3715: error_with_decl (decl, "storage size of `%s' isn't known"); 3716: TREE_TYPE (decl) = error_mark_node; 3717: } 3718: 1.1.1.4 root 3719: if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl)) 1.1.1.5 root 3720: && DECL_SIZE (decl) != 0) 3721: { 3722: if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST) 3723: constant_expression_warning (DECL_SIZE (decl)); 3724: else 3725: error_with_decl (decl, "storage size of `%s' isn't constant"); 3726: } 1.1 root 3727: } 3728: 1.1.1.7 root 3729: /* If this is a function and an assembler name is specified, it isn't 3730: builtin any more. Also reset DECL_RTL so we can give it its new 3731: name. */ 3732: if (TREE_CODE (decl) == FUNCTION_DECL && asmspec) 3733: { 3734: DECL_BUILT_IN (decl) = 0; 3735: DECL_RTL (decl) = 0; 3736: } 3737: 1.1 root 3738: /* Output the assembler code and/or RTL code for variables and functions, 3739: unless the type is an undefined structure or union. 3740: If not, it will get done when the type is completed. */ 3741: 3742: if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL) 3743: { 1.1.1.7 root 3744: if ((flag_traditional || TREE_PERMANENT (decl)) 3745: && allocation_temporary_p ()) 1.1 root 3746: { 3747: push_obstacks_nochange (); 3748: end_temporary_allocation (); 3749: /* This is a no-op in c-lang.c or something real in objc-actions.c. */ 3750: maybe_objc_check_decl (decl); 1.1.1.8 ! root 3751: rest_of_decl_compilation (decl, asmspec, DECL_CONTEXT (decl) == 0, 1.1 root 3752: 0); 3753: pop_obstacks (); 3754: } 3755: else 3756: { 3757: /* This is a no-op in c-lang.c or something real in objc-actions.c. */ 3758: maybe_objc_check_decl (decl); 1.1.1.8 ! root 3759: rest_of_decl_compilation (decl, asmspec, DECL_CONTEXT (decl) == 0, 1.1 root 3760: 0); 3761: } 1.1.1.8 ! root 3762: if (DECL_CONTEXT (decl) != 0) 1.1 root 3763: { 3764: /* Recompute the RTL of a local array now 3765: if it used to be an incomplete type. */ 3766: if (was_incomplete 1.1.1.4 root 3767: && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl)) 1.1 root 3768: { 3769: /* If we used it already as memory, it must stay in memory. */ 3770: TREE_ADDRESSABLE (decl) = TREE_USED (decl); 3771: /* If it's still incomplete now, no init will save it. */ 3772: if (DECL_SIZE (decl) == 0) 3773: DECL_INITIAL (decl) = 0; 3774: expand_decl (decl); 3775: } 3776: /* Compute and store the initial value. */ 1.1.1.4 root 3777: if (TREE_CODE (decl) != FUNCTION_DECL) 3778: expand_decl_init (decl); 1.1 root 3779: } 3780: } 3781: 3782: if (TREE_CODE (decl) == TYPE_DECL) 3783: { 3784: /* This is a no-op in c-lang.c or something real in objc-actions.c. */ 3785: maybe_objc_check_decl (decl); 1.1.1.8 ! root 3786: rest_of_decl_compilation (decl, NULL_PTR, DECL_CONTEXT (decl) == 0, 1.1 root 3787: 0); 3788: } 3789: 1.1.1.4 root 3790: /* ??? After 2.3, test (init != 0) instead of TREE_CODE. */ 1.1.1.7 root 3791: /* This test used to include TREE_PERMANENT, however, we have the same 3792: problem with initializers at the function level. Such initializers get 3793: saved until the end of the function on the momentary_obstack. */ 1.1.1.4 root 3794: if (!(TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl)) 1.1.1.7 root 3795: && temporary 1.1.1.5 root 3796: /* DECL_INITIAL is not defined in PARM_DECLs, since it shares 3797: space with DECL_ARG_TYPE. */ 3798: && TREE_CODE (decl) != PARM_DECL) 1.1 root 3799: { 3800: /* We need to remember that this array HAD an initialization, 3801: but discard the actual temporary nodes, 3802: since we can't have a permanent node keep pointing to them. */ 1.1.1.4 root 3803: /* We make an exception for inline functions, since it's 3804: normal for a local extern redeclaration of an inline function 3805: to have a copy of the top-level decl's DECL_INLINE. */ 1.1.1.7 root 3806: if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node) 1.1.1.6 root 3807: { 1.1.1.7 root 3808: /* If this is a const variable, then preserve the 1.1.1.6 root 3809: initializer instead of discarding it so that we can optimize 3810: references to it. */ 1.1.1.7 root 3811: /* This test used to include TREE_STATIC, but this won't be set 3812: for function level initializers. */ 3813: if (TREE_READONLY (decl) || ITERATOR_P (decl)) 1.1.1.6 root 3814: { 3815: preserve_initializer (); 3816: /* Hack? Set the permanent bit for something that is permanent, 1.1.1.8 ! root 3817: but not on the permanent obstack, so as to convince 1.1.1.6 root 3818: output_constant_def to make its rtl on the permanent 3819: obstack. */ 3820: TREE_PERMANENT (DECL_INITIAL (decl)) = 1; 1.1.1.7 root 3821: 3822: /* The initializer and DECL must have the same (or equivalent 3823: types), but if the initializer is a STRING_CST, its type 3824: might not be on the right obstack, so copy the type 3825: of DECL. */ 3826: TREE_TYPE (DECL_INITIAL (decl)) = type; 1.1.1.6 root 3827: } 3828: else 3829: DECL_INITIAL (decl) = error_mark_node; 3830: } 1.1 root 3831: } 3832: 1.1.1.7 root 3833: /* If requested, warn about definitions of large data objects. */ 3834: 3835: if (warn_larger_than 3836: && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL) 3837: && !DECL_EXTERNAL (decl)) 3838: { 3839: register tree decl_size = DECL_SIZE (decl); 3840: 3841: if (decl_size && TREE_CODE (decl_size) == INTEGER_CST) 3842: { 3843: unsigned units = TREE_INT_CST_LOW(decl_size) / BITS_PER_UNIT; 3844: 3845: if (units > larger_than_size) 3846: warning_with_decl (decl, "size of `%s' is %u bytes", units); 3847: } 3848: } 3849: 1.1.1.4 root 3850: #if 0 1.1 root 3851: /* Resume permanent allocation, if not within a function. */ 3852: /* The corresponding push_obstacks_nochange is in start_decl, 3853: and in push_parm_decl and in grokfield. */ 3854: pop_obstacks (); 1.1.1.4 root 3855: #endif 3856: 3857: /* If we have gone back from temporary to permanent allocation, 3858: actually free the temporary space that we no longer need. */ 3859: if (temporary && !allocation_temporary_p ()) 1.1.1.7 root 3860: permanent_allocation (0); 1.1 root 3861: 3862: /* At the end of a declaration, throw away any variable type sizes 3863: of types defined inside that declaration. There is no use 3864: computing them in the following function definition. */ 3865: if (current_binding_level == global_binding_level) 3866: get_pending_sizes (); 3867: } 3868: 3869: /* If DECL has a cleanup, build and return that cleanup here. 3870: This is a callback called by expand_expr. */ 3871: 3872: tree 3873: maybe_build_cleanup (decl) 3874: tree decl; 3875: { 3876: /* There are no cleanups in C. */ 3877: return NULL_TREE; 3878: } 3879: 3880: /* Given a parsed parameter declaration, 3881: decode it into a PARM_DECL and push that on the current binding level. 3882: Also, for the sake of forward parm decls, 3883: record the given order of parms in `parm_order'. */ 3884: 3885: void 3886: push_parm_decl (parm) 3887: tree parm; 3888: { 1.1.1.7 root 3889: tree decl; 1.1.1.2 root 3890: int old_immediate_size_expand = immediate_size_expand; 3891: /* Don't try computing parm sizes now -- wait till fn is called. */ 3892: immediate_size_expand = 0; 1.1 root 3893: 3894: /* The corresponding pop_obstacks is in finish_decl. */ 3895: push_obstacks_nochange (); 3896: 1.1.1.8 ! root 3897: decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)), ! 3898: TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0); ! 3899: decl_attributes (decl, TREE_VALUE (TREE_VALUE (parm)), ! 3900: TREE_PURPOSE (TREE_VALUE (parm))); 1.1.1.5 root 3901: 3902: #if 0 1.1.1.3 root 3903: if (DECL_NAME (decl)) 3904: { 1.1.1.7 root 3905: tree olddecl; 1.1.1.3 root 3906: olddecl = lookup_name (DECL_NAME (decl)); 3907: if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL) 3908: pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef"); 3909: } 1.1.1.5 root 3910: #endif 3911: 1.1 root 3912: decl = pushdecl (decl); 3913: 1.1.1.2 root 3914: immediate_size_expand = old_immediate_size_expand; 3915: 1.1 root 3916: current_binding_level->parm_order 3917: = tree_cons (NULL_TREE, decl, current_binding_level->parm_order); 3918: 3919: /* Add this decl to the current binding level. */ 3920: finish_decl (decl, NULL_TREE, NULL_TREE); 3921: } 3922: 3923: /* Clear the given order of parms in `parm_order'. 3924: Used at start of parm list, 3925: and also at semicolon terminating forward decls. */ 3926: 3927: void 3928: clear_parm_order () 3929: { 3930: current_binding_level->parm_order = NULL_TREE; 3931: } 3932: 3933: /* Make TYPE a complete type based on INITIAL_VALUE. 1.1.1.2 root 3934: Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, 1.1 root 3935: 2 if there was no information (in which case assume 1 if DO_DEFAULT). */ 3936: 3937: int 3938: complete_array_type (type, initial_value, do_default) 3939: tree type; 3940: tree initial_value; 3941: int do_default; 3942: { 3943: register tree maxindex = NULL_TREE; 3944: int value = 0; 3945: 3946: if (initial_value) 3947: { 3948: /* Note MAXINDEX is really the maximum index, 3949: one less than the size. */ 3950: if (TREE_CODE (initial_value) == STRING_CST) 3951: { 3952: int eltsize 3953: = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value))); 1.1.1.6 root 3954: maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value) 3955: / eltsize) - 1, 0); 1.1 root 3956: } 3957: else if (TREE_CODE (initial_value) == CONSTRUCTOR) 3958: { 1.1.1.6 root 3959: tree elts = CONSTRUCTOR_ELTS (initial_value); 3960: maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node); 3961: for (; elts; elts = TREE_CHAIN (elts)) 3962: { 3963: if (TREE_PURPOSE (elts)) 3964: maxindex = TREE_PURPOSE (elts); 3965: else 3966: maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node); 3967: } 3968: maxindex = copy_node (maxindex); 1.1 root 3969: } 3970: else 3971: { 3972: /* Make an error message unless that happened already. */ 3973: if (initial_value != error_mark_node) 3974: value = 1; 3975: 3976: /* Prevent further error messages. */ 1.1.1.5 root 3977: maxindex = build_int_2 (0, 0); 1.1 root 3978: } 3979: } 3980: 3981: if (!maxindex) 3982: { 3983: if (do_default) 1.1.1.5 root 3984: maxindex = build_int_2 (0, 0); 1.1 root 3985: value = 2; 3986: } 3987: 3988: if (maxindex) 3989: { 3990: TYPE_DOMAIN (type) = build_index_type (maxindex); 3991: if (!TREE_TYPE (maxindex)) 3992: TREE_TYPE (maxindex) = TYPE_DOMAIN (type); 1.1.1.5 root 3993: #if 0 /* I took out this change 3994: together with the change in build_array_type. --rms */ 3995: change_main_variant (type, 3996: build_array_type (TREE_TYPE (type), 3997: TYPE_DOMAIN (type))); 3998: #endif 1.1 root 3999: } 4000: 4001: /* Lay out the type now that we can get the real answer. */ 4002: 4003: layout_type (type); 4004: 4005: return value; 4006: } 4007: 4008: /* Given declspecs and a declarator, 4009: determine the name and type of the object declared 4010: and construct a ..._DECL node for it. 4011: (In one case we can return a ..._TYPE node instead. 4012: For invalid input we sometimes return 0.) 4013: 4014: DECLSPECS is a chain of tree_list nodes whose value fields 4015: are the storage classes and type specifiers. 4016: 4017: DECL_CONTEXT says which syntactic context this declaration is in: 4018: NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL. 4019: FUNCDEF for a function definition. Like NORMAL but a few different 4020: error messages in each case. Return value may be zero meaning 4021: this definition is too screwy to try to parse. 4022: PARM for a parameter declaration (either within a function prototype 4023: or before a function body). Make a PARM_DECL, or return void_type_node. 4024: TYPENAME if for a typename (in a cast or sizeof). 4025: Don't make a DECL node; just return the ..._TYPE node. 4026: FIELD for a struct or union field; make a FIELD_DECL. 4027: BITFIELD for a field with specified width. 4028: INITIALIZED is 1 if the decl has an initializer. 4029: 4030: In the TYPENAME case, DECLARATOR is really an absolute declarator. 4031: It may also be so in the PARM case, for a prototype where the 4032: argument type is specified but not the name. 4033: 4034: This function is where the complicated C meanings of `static' 1.1.1.2 root 4035: and `extern' are interpreted. */ 1.1 root 4036: 4037: static tree 4038: grokdeclarator (declarator, declspecs, decl_context, initialized) 4039: tree declspecs; 4040: tree declarator; 4041: enum decl_context decl_context; 4042: int initialized; 4043: { 4044: int specbits = 0; 4045: tree spec; 4046: tree type = NULL_TREE; 4047: int longlong = 0; 4048: int constp; 4049: int volatilep; 4050: int inlinep; 4051: int explicit_int = 0; 4052: int explicit_char = 0; 1.1.1.5 root 4053: int defaulted_int = 0; 1.1 root 4054: tree typedef_decl = 0; 4055: char *name; 4056: tree typedef_type = 0; 4057: int funcdef_flag = 0; 4058: enum tree_code innermost_code = ERROR_MARK; 4059: int bitfield = 0; 1.1.1.2 root 4060: int size_varies = 0; 1.1.1.8 ! root 4061: tree decl_machine_attr = NULL_TREE; 1.1 root 4062: 4063: if (decl_context == BITFIELD) 4064: bitfield = 1, decl_context = FIELD; 4065: 4066: if (decl_context == FUNCDEF) 4067: funcdef_flag = 1, decl_context = NORMAL; 4068: 4069: push_obstacks_nochange (); 4070: 4071: if (flag_traditional && allocation_temporary_p ()) 4072: end_temporary_allocation (); 4073: 4074: /* Look inside a declarator for the name being declared 4075: and get it as a string, for an error message. */ 4076: { 4077: register tree decl = declarator; 4078: name = 0; 4079: 4080: while (decl) 4081: switch (TREE_CODE (decl)) 4082: { 4083: case ARRAY_REF: 4084: case INDIRECT_REF: 4085: case CALL_EXPR: 4086: innermost_code = TREE_CODE (decl); 4087: decl = TREE_OPERAND (decl, 0); 4088: break; 4089: 4090: case IDENTIFIER_NODE: 4091: name = IDENTIFIER_POINTER (decl); 4092: decl = 0; 4093: break; 4094: 4095: default: 4096: abort (); 4097: } 4098: if (name == 0) 4099: name = "type name"; 4100: } 4101: 4102: /* A function definition's declarator must have the form of 4103: a function declarator. */ 4104: 4105: if (funcdef_flag && innermost_code != CALL_EXPR) 4106: return 0; 4107: 4108: /* Anything declared one level down from the top level 4109: must be one of the parameters of a function 4110: (because the body is at least two levels down). */ 4111: 4112: /* If this looks like a function definition, make it one, 4113: even if it occurs where parms are expected. 4114: Then store_parm_decls will reject it and not use it as a parm. */ 4115: if (decl_context == NORMAL && !funcdef_flag 1.1.1.8 ! root 4116: && current_binding_level->parm_flag) 1.1 root 4117: decl_context = PARM; 4118: 4119: /* Look through the decl specs and record which ones appear. 4120: Some typespecs are defined as built-in typenames. 4121: Others, the ones that are modifiers of other types, 4122: are represented by bits in SPECBITS: set the bits for 4123: the modifiers that appear. Storage class keywords are also in SPECBITS. 4124: 4125: If there is a typedef name or a type, store the type in TYPE. 4126: This includes builtin typedefs such as `int'. 4127: 4128: Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char' 4129: and did not come from a user typedef. 4130: 4131: Set LONGLONG if `long' is mentioned twice. */ 4132: 4133: for (spec = declspecs; spec; spec = TREE_CHAIN (spec)) 4134: { 4135: register int i; 4136: register tree id = TREE_VALUE (spec); 4137: 4138: if (id == ridpointers[(int) RID_INT]) 4139: explicit_int = 1; 4140: if (id == ridpointers[(int) RID_CHAR]) 4141: explicit_char = 1; 4142: 4143: if (TREE_CODE (id) == IDENTIFIER_NODE) 4144: for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++) 4145: { 4146: if (ridpointers[i] == id) 4147: { 4148: if (i == (int) RID_LONG && specbits & (1<<i)) 4149: { 1.1.1.5 root 4150: if (longlong) 1.1.1.4 root 4151: error ("`long long long' is too long for GCC"); 1.1 root 4152: else 1.1.1.5 root 4153: { 1.1.1.7 root 4154: if (pedantic && ! in_system_header) 1.1.1.5 root 4155: pedwarn ("ANSI C does not support `long long'"); 4156: longlong = 1; 4157: } 1.1 root 4158: } 4159: else if (specbits & (1 << i)) 1.1.1.3 root 4160: pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id)); 1.1 root 4161: specbits |= 1 << i; 4162: goto found; 4163: } 4164: } 4165: if (type) 4166: error ("two or more data types in declaration of `%s'", name); 4167: /* Actual typedefs come to us as TYPE_DECL nodes. */ 4168: else if (TREE_CODE (id) == TYPE_DECL) 4169: { 4170: type = TREE_TYPE (id); 1.1.1.8 ! root 4171: decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id); 1.1 root 4172: typedef_decl = id; 4173: } 4174: /* Built-in types come as identifiers. */ 4175: else if (TREE_CODE (id) == IDENTIFIER_NODE) 4176: { 4177: register tree t = lookup_name (id); 4178: if (TREE_TYPE (t) == error_mark_node) 4179: ; 4180: else if (!t || TREE_CODE (t) != TYPE_DECL) 4181: error ("`%s' fails to be a typedef or built in type", 4182: IDENTIFIER_POINTER (id)); 4183: else 4184: { 4185: type = TREE_TYPE (t); 4186: typedef_decl = t; 4187: } 4188: } 4189: else if (TREE_CODE (id) != ERROR_MARK) 4190: type = id; 4191: 4192: found: {} 4193: } 4194: 4195: typedef_type = type; 4196: if (type) 1.1.1.2 root 4197: size_varies = C_TYPE_VARIABLE_SIZE (type); 1.1 root 4198: 1.1.1.5 root 4199: /* No type at all: default to `int', and set DEFAULTED_INT 1.1 root 4200: because it was not a user-defined typedef. */ 4201: 4202: if (type == 0) 4203: { 4204: if (funcdef_flag && warn_return_type 4205: && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT) 4206: | (1 << (int) RID_SIGNED) | (1 << (int) RID_UNSIGNED)))) 4207: warn_about_return_type = 1; 1.1.1.5 root 4208: defaulted_int = 1; 1.1 root 4209: type = integer_type_node; 4210: } 4211: 4212: /* Now process the modifiers that were specified 4213: and check for invalid combinations. */ 4214: 4215: /* Long double is a special combination. */ 4216: 1.1.1.4 root 4217: if ((specbits & 1 << (int) RID_LONG) 4218: && TYPE_MAIN_VARIANT (type) == double_type_node) 1.1 root 4219: { 4220: specbits &= ~ (1 << (int) RID_LONG); 4221: type = long_double_type_node; 4222: } 4223: 4224: /* Check all other uses of type modifiers. */ 4225: 4226: if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT) 4227: | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED))) 4228: { 4229: int ok = 0; 4230: 4231: if (TREE_CODE (type) != INTEGER_TYPE) 4232: error ("long, short, signed or unsigned invalid for `%s'", name); 4233: else if ((specbits & 1 << (int) RID_LONG) 4234: && (specbits & 1 << (int) RID_SHORT)) 4235: error ("long and short specified together for `%s'", name); 4236: else if (((specbits & 1 << (int) RID_LONG) 4237: || (specbits & 1 << (int) RID_SHORT)) 4238: && explicit_char) 4239: error ("long or short specified with char for `%s'", name); 4240: else if (((specbits & 1 << (int) RID_LONG) 4241: || (specbits & 1 << (int) RID_SHORT)) 4242: && TREE_CODE (type) == REAL_TYPE) 4243: error ("long or short specified with floating type for `%s'", name); 4244: else if ((specbits & 1 << (int) RID_SIGNED) 4245: && (specbits & 1 << (int) RID_UNSIGNED)) 4246: error ("signed and unsigned given together for `%s'", name); 4247: else 4248: { 4249: ok = 1; 1.1.1.5 root 4250: if (!explicit_int && !defaulted_int && !explicit_char && pedantic) 1.1 root 4251: { 4252: pedwarn ("long, short, signed or unsigned used invalidly for `%s'", 4253: name); 4254: if (flag_pedantic_errors) 4255: ok = 0; 4256: } 4257: } 4258: 4259: /* Discard the type modifiers if they are invalid. */ 4260: if (! ok) 4261: { 4262: specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT) 4263: | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)); 4264: longlong = 0; 4265: } 4266: } 4267: 1.1.1.7 root 4268: if ((specbits & (1 << (int) RID_COMPLEX)) 4269: && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE) 4270: { 4271: error ("complex invalid for `%s'", name); 4272: specbits &= ~ (1 << (int) RID_COMPLEX); 4273: } 4274: 1.1 root 4275: /* Decide whether an integer type is signed or not. 4276: Optionally treat bitfields as signed by default. */ 4277: if (specbits & 1 << (int) RID_UNSIGNED 4278: /* Traditionally, all bitfields are unsigned. */ 1.1.1.4 root 4279: || (bitfield && flag_traditional 4280: && (! explicit_flag_signed_bitfields || !flag_signed_bitfields)) 1.1 root 4281: || (bitfield && ! flag_signed_bitfields 1.1.1.5 root 4282: && (explicit_int || defaulted_int || explicit_char 1.1 root 4283: /* A typedef for plain `int' without `signed' 4284: can be controlled just like plain `int'. */ 4285: || ! (typedef_decl != 0 4286: && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))) 4287: && TREE_CODE (type) != ENUMERAL_TYPE 4288: && !(specbits & 1 << (int) RID_SIGNED))) 4289: { 4290: if (longlong) 4291: type = long_long_unsigned_type_node; 4292: else if (specbits & 1 << (int) RID_LONG) 4293: type = long_unsigned_type_node; 4294: else if (specbits & 1 << (int) RID_SHORT) 4295: type = short_unsigned_type_node; 4296: else if (type == char_type_node) 4297: type = unsigned_char_type_node; 4298: else if (typedef_decl) 4299: type = unsigned_type (type); 4300: else 4301: type = unsigned_type_node; 4302: } 4303: else if ((specbits & 1 << (int) RID_SIGNED) 4304: && type == char_type_node) 4305: type = signed_char_type_node; 4306: else if (longlong) 4307: type = long_long_integer_type_node; 4308: else if (specbits & 1 << (int) RID_LONG) 4309: type = long_integer_type_node; 4310: else if (specbits & 1 << (int) RID_SHORT) 4311: type = short_integer_type_node; 1.1.1.7 root 4312: 4313: if (specbits & 1 << (int) RID_COMPLEX) 1.1.1.5 root 4314: { 1.1.1.7 root 4315: /* If we just have "complex", it is equivalent to 4316: "complex double", but if any modifiers at all are specified it is 4317: the complex form of TYPE. E.g, "complex short" is 4318: "complex short int". */ 4319: 4320: if (defaulted_int && ! longlong 4321: && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT) 4322: | (1 << (int) RID_SIGNED) 4323: | (1 << (int) RID_UNSIGNED)))) 1.1.1.5 root 4324: type = complex_double_type_node; 4325: else if (type == integer_type_node) 4326: type = complex_integer_type_node; 4327: else if (type == float_type_node) 4328: type = complex_float_type_node; 4329: else if (type == double_type_node) 4330: type = complex_double_type_node; 4331: else if (type == long_double_type_node) 4332: type = complex_long_double_type_node; 4333: else 1.1.1.7 root 4334: type = build_complex_type (type); 1.1.1.5 root 4335: } 1.1 root 4336: 4337: /* Set CONSTP if this declaration is `const', whether by 4338: explicit specification or via a typedef. 4339: Likewise for VOLATILEP. */ 4340: 4341: constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type); 4342: volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type); 4343: inlinep = !! (specbits & (1 << (int) RID_INLINE)); 4344: if (constp > 1) 1.1.1.3 root 4345: pedwarn ("duplicate `const'"); 1.1 root 4346: if (volatilep > 1) 1.1.1.3 root 4347: pedwarn ("duplicate `volatile'"); 1.1 root 4348: if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type))) 4349: type = TYPE_MAIN_VARIANT (type); 4350: 4351: /* Warn if two storage classes are given. Default to `auto'. */ 4352: 4353: { 4354: int nclasses = 0; 4355: 4356: if (specbits & 1 << (int) RID_AUTO) nclasses++; 4357: if (specbits & 1 << (int) RID_STATIC) nclasses++; 4358: if (specbits & 1 << (int) RID_EXTERN) nclasses++; 4359: if (specbits & 1 << (int) RID_REGISTER) nclasses++; 4360: if (specbits & 1 << (int) RID_TYPEDEF) nclasses++; 1.1.1.5 root 4361: if (specbits & 1 << (int) RID_ITERATOR) nclasses++; 1.1 root 4362: 4363: /* Warn about storage classes that are invalid for certain 4364: kinds of declarations (parameters, typenames, etc.). */ 4365: 4366: if (nclasses > 1) 4367: error ("multiple storage classes in declaration of `%s'", name); 4368: else if (funcdef_flag 4369: && (specbits 4370: & ((1 << (int) RID_REGISTER) 4371: | (1 << (int) RID_AUTO) 4372: | (1 << (int) RID_TYPEDEF)))) 4373: { 4374: if (specbits & 1 << (int) RID_AUTO 4375: && (pedantic || current_binding_level == global_binding_level)) 4376: pedwarn ("function definition declared `auto'"); 4377: if (specbits & 1 << (int) RID_REGISTER) 4378: error ("function definition declared `register'"); 4379: if (specbits & 1 << (int) RID_TYPEDEF) 4380: error ("function definition declared `typedef'"); 4381: specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER) 4382: | (1 << (int) RID_AUTO)); 4383: } 4384: else if (decl_context != NORMAL && nclasses > 0) 4385: { 4386: if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER) 4387: ; 4388: else 4389: { 4390: error ((decl_context == FIELD 4391: ? "storage class specified for structure field `%s'" 4392: : (decl_context == PARM 4393: ? "storage class specified for parameter `%s'" 4394: : "storage class specified for typename")), 4395: name); 4396: specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER) 4397: | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC) 4398: | (1 << (int) RID_EXTERN)); 4399: } 4400: } 4401: else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag) 4402: { 4403: /* `extern' with initialization is invalid if not at top level. */ 4404: if (current_binding_level == global_binding_level) 4405: warning ("`%s' initialized and declared `extern'", name); 4406: else 4407: error ("`%s' has both `extern' and initializer", name); 4408: } 4409: else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag 4410: && current_binding_level != global_binding_level) 4411: error ("nested function `%s' declared `extern'", name); 4412: else if (current_binding_level == global_binding_level 4413: && specbits & (1 << (int) RID_AUTO)) 4414: error ("top-level declaration of `%s' specifies `auto'", name); 1.1.1.5 root 4415: else if ((specbits & 1 << (int) RID_ITERATOR) 4416: && TREE_CODE (declarator) != IDENTIFIER_NODE) 4417: { 4418: error ("iterator `%s' has derived type", name); 4419: type = error_mark_node; 4420: } 4421: else if ((specbits & 1 << (int) RID_ITERATOR) 4422: && TREE_CODE (type) != INTEGER_TYPE) 4423: { 4424: error ("iterator `%s' has noninteger type", name); 4425: type = error_mark_node; 4426: } 1.1 root 4427: } 4428: 4429: /* Now figure out the structure of the declarator proper. 4430: Descend through it, creating more complex types, until we reach 4431: the declared identifier (or NULL_TREE, in an absolute declarator). */ 4432: 4433: while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE) 4434: { 4435: if (type == error_mark_node) 4436: { 4437: declarator = TREE_OPERAND (declarator, 0); 4438: continue; 4439: } 4440: 4441: /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]), 4442: an INDIRECT_REF (for *...), 4443: a CALL_EXPR (for ...(...)), 4444: an identifier (for the name being declared) 4445: or a null pointer (for the place in an absolute declarator 4446: where the name was omitted). 4447: For the last two cases, we have just exited the loop. 4448: 4449: At this point, TYPE is the type of elements of an array, 4450: or for a function to return, or for a pointer to point to. 4451: After this sequence of ifs, TYPE is the type of the 4452: array or function or pointer, and DECLARATOR has had its 4453: outermost layer removed. */ 4454: 4455: if (TREE_CODE (declarator) == ARRAY_REF) 4456: { 4457: register tree itype = NULL_TREE; 4458: register tree size = TREE_OPERAND (declarator, 1); 1.1.1.5 root 4459: /* An uninitialized decl with `extern' is a reference. */ 4460: int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN)); 1.1.1.7 root 4461: /* The index is a signed object `sizetype' bits wide. */ 4462: tree index_type = signed_type (sizetype); 1.1 root 4463: 4464: declarator = TREE_OPERAND (declarator, 0); 4465: 4466: /* Check for some types that there cannot be arrays of. */ 4467: 1.1.1.4 root 4468: if (TYPE_MAIN_VARIANT (type) == void_type_node) 1.1 root 4469: { 4470: error ("declaration of `%s' as array of voids", name); 4471: type = error_mark_node; 4472: } 4473: 4474: if (TREE_CODE (type) == FUNCTION_TYPE) 4475: { 4476: error ("declaration of `%s' as array of functions", name); 4477: type = error_mark_node; 4478: } 4479: 4480: if (size == error_mark_node) 4481: type = error_mark_node; 4482: 4483: if (type == error_mark_node) 4484: continue; 4485: 1.1.1.5 root 4486: /* If this is a block level extern, it must live past the end 4487: of the function so that we can check it against other extern 4488: declarations (IDENTIFIER_LIMBO_VALUE). */ 4489: if (extern_ref && allocation_temporary_p ()) 4490: end_temporary_allocation (); 4491: 1.1 root 4492: /* If size was specified, set ITYPE to a range-type for that size. 4493: Otherwise, ITYPE remains null. finish_decl may figure it out 4494: from an initial value. */ 4495: 4496: if (size) 4497: { 4498: /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 1.1.1.4 root 4499: STRIP_TYPE_NOPS (size); 1.1 root 4500: 4501: if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE 4502: && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE) 4503: { 4504: error ("size of array `%s' has non-integer type", name); 4505: size = integer_one_node; 4506: } 1.1.1.7 root 4507: 1.1 root 4508: if (pedantic && integer_zerop (size)) 4509: pedwarn ("ANSI C forbids zero-size array `%s'", name); 1.1.1.7 root 4510: 1.1 root 4511: if (TREE_CODE (size) == INTEGER_CST) 4512: { 1.1.1.5 root 4513: constant_expression_warning (size); 1.1.1.7 root 4514: if (tree_int_cst_sgn (size) < 0) 1.1 root 4515: { 4516: error ("size of array `%s' is negative", name); 4517: size = integer_one_node; 4518: } 4519: } 4520: else 4521: { 1.1.1.7 root 4522: /* Make sure the array size remains visibly nonconstant 4523: even if it is (eg) a const variable with known value. */ 4524: size_varies = 1; 4525: 1.1 root 4526: if (pedantic) 1.1.1.5 root 4527: { 4528: if (TREE_CONSTANT (size)) 4529: pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name); 4530: else 4531: pedwarn ("ANSI C forbids variable-size array `%s'", name); 4532: } 1.1 root 4533: } 1.1.1.7 root 4534: 4535: /* Convert size to index_type, so that if it is a variable 4536: the computations will be done in the proper mode. */ 4537: itype = fold (build (MINUS_EXPR, index_type, 4538: convert (index_type, size), 4539: convert (index_type, size_one_node))); 4540: 4541: if (size_varies) 4542: itype = variable_size (itype); 4543: itype = build_index_type (itype); 1.1 root 4544: } 4545: 4546: #if 0 /* This had bad results for pointers to arrays, as in 4547: union incomplete (*foo)[4]; */ 4548: /* Complain about arrays of incomplete types, except in typedefs. */ 4549: 4550: if (TYPE_SIZE (type) == 0 4551: /* Avoid multiple warnings for nested array types. */ 4552: && TREE_CODE (type) != ARRAY_TYPE 4553: && !(specbits & (1 << (int) RID_TYPEDEF)) 4554: && !C_TYPE_BEING_DEFINED (type)) 4555: warning ("array type has incomplete element type"); 4556: #endif 4557: 4558: #if 0 /* We shouldn't have a function type here at all! 4559: Functions aren't allowed as array elements. */ 4560: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE 4561: && (constp || volatilep)) 4562: pedwarn ("ANSI C forbids const or volatile function types"); 4563: #endif 1.1.1.5 root 4564: 4565: /* Build the array type itself, then merge any constancy or 4566: volatility into the target type. We must do it in this order 4567: to ensure that the TYPE_MAIN_VARIANT field of the array type 4568: is set correctly. */ 4569: 4570: type = build_array_type (type, itype); 1.1 root 4571: if (constp || volatilep) 4572: type = c_build_type_variant (type, constp, volatilep); 4573: 4574: #if 0 /* don't clear these; leave them set so that the array type 4575: or the variable is itself const or volatile. */ 4576: constp = 0; 4577: volatilep = 0; 4578: #endif 4579: 1.1.1.2 root 4580: if (size_varies) 1.1 root 4581: C_TYPE_VARIABLE_SIZE (type) = 1; 4582: } 4583: else if (TREE_CODE (declarator) == CALL_EXPR) 4584: { 1.1.1.4 root 4585: int extern_ref = (!(specbits & (1 << (int) RID_AUTO)) 4586: || current_binding_level == global_binding_level); 1.1 root 4587: tree arg_types; 4588: 4589: /* Declaring a function type. 4590: Make sure we have a valid type for the function to return. */ 4591: if (type == error_mark_node) 4592: continue; 4593: 1.1.1.2 root 4594: size_varies = 0; 1.1 root 4595: 4596: /* Warn about some types functions can't return. */ 4597: 4598: if (TREE_CODE (type) == FUNCTION_TYPE) 4599: { 4600: error ("`%s' declared as function returning a function", name); 4601: type = integer_type_node; 4602: } 4603: if (TREE_CODE (type) == ARRAY_TYPE) 4604: { 4605: error ("`%s' declared as function returning an array", name); 4606: type = integer_type_node; 4607: } 4608: 4609: #ifndef TRADITIONAL_RETURN_FLOAT 4610: /* Traditionally, declaring return type float means double. */ 4611: 1.1.1.4 root 4612: if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node) 1.1 root 4613: type = double_type_node; 4614: #endif /* TRADITIONAL_RETURN_FLOAT */ 4615: 1.1.1.4 root 4616: /* If this is a block level extern, it must live past the end 4617: of the function so that we can check it against other extern 4618: declarations (IDENTIFIER_LIMBO_VALUE). */ 4619: if (extern_ref && allocation_temporary_p ()) 4620: end_temporary_allocation (); 4621: 1.1 root 4622: /* Construct the function type and go to the next 4623: inner layer of declarator. */ 4624: 4625: arg_types = grokparms (TREE_OPERAND (declarator, 1), 4626: funcdef_flag 4627: /* Say it's a definition 4628: only for the CALL_EXPR 4629: closest to the identifier. */ 4630: && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE); 4631: #if 0 /* This seems to be false. We turn off temporary allocation 4632: above in this function if -traditional. 4633: And this code caused inconsistent results with prototypes: 4634: callers would ignore them, and pass arguments wrong. */ 4635: 4636: /* Omit the arg types if -traditional, since the arg types 4637: and the list links might not be permanent. */ 1.1.1.4 root 4638: type = build_function_type (type, 4639: flag_traditional 4640: ? NULL_TREE : arg_types); 1.1 root 4641: #endif 1.1.1.6 root 4642: /* ANSI seems to say that `const int foo ();' 4643: does not make the function foo const. */ 4644: if (constp || volatilep) 4645: type = c_build_type_variant (type, constp, volatilep); 4646: constp = 0; 4647: volatilep = 0; 4648: 1.1 root 4649: type = build_function_type (type, arg_types); 4650: declarator = TREE_OPERAND (declarator, 0); 4651: 4652: /* Set the TYPE_CONTEXTs for each tagged type which is local to 4653: the formal parameter list of this FUNCTION_TYPE to point to 4654: the FUNCTION_TYPE node itself. */ 4655: 4656: { 4657: register tree link; 4658: 4659: for (link = current_function_parm_tags; 4660: link; 4661: link = TREE_CHAIN (link)) 4662: TYPE_CONTEXT (TREE_VALUE (link)) = type; 4663: } 4664: } 4665: else if (TREE_CODE (declarator) == INDIRECT_REF) 4666: { 4667: /* Merge any constancy or volatility into the target type 4668: for the pointer. */ 4669: 4670: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE 4671: && (constp || volatilep)) 4672: pedwarn ("ANSI C forbids const or volatile function types"); 4673: if (constp || volatilep) 4674: type = c_build_type_variant (type, constp, volatilep); 4675: constp = 0; 4676: volatilep = 0; 1.1.1.2 root 4677: size_varies = 0; 1.1 root 4678: 4679: type = build_pointer_type (type); 4680: 4681: /* Process a list of type modifier keywords 4682: (such as const or volatile) that were given inside the `*'. */ 4683: 4684: if (TREE_TYPE (declarator)) 4685: { 4686: register tree typemodlist; 4687: int erred = 0; 4688: for (typemodlist = TREE_TYPE (declarator); typemodlist; 4689: typemodlist = TREE_CHAIN (typemodlist)) 4690: { 4691: if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST]) 4692: constp++; 4693: else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE]) 4694: volatilep++; 4695: else if (!erred) 4696: { 4697: erred = 1; 4698: error ("invalid type modifier within pointer declarator"); 4699: } 4700: } 4701: if (constp > 1) 1.1.1.4 root 4702: pedwarn ("duplicate `const'"); 1.1 root 4703: if (volatilep > 1) 1.1.1.4 root 4704: pedwarn ("duplicate `volatile'"); 1.1 root 4705: } 4706: 4707: declarator = TREE_OPERAND (declarator, 0); 4708: } 4709: else 4710: abort (); 4711: 4712: } 4713: 4714: /* Now TYPE has the actual type. */ 4715: 4716: /* If this is declaring a typedef name, return a TYPE_DECL. */ 4717: 4718: if (specbits & (1 << (int) RID_TYPEDEF)) 4719: { 4720: tree decl; 4721: /* Note that the grammar rejects storage classes 4722: in typenames, fields or parameters */ 4723: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE 4724: && (constp || volatilep)) 4725: pedwarn ("ANSI C forbids const or volatile function types"); 4726: if (constp || volatilep) 4727: type = c_build_type_variant (type, constp, volatilep); 4728: pop_obstacks (); 4729: decl = build_decl (TYPE_DECL, declarator, type); 4730: if ((specbits & (1 << (int) RID_SIGNED)) 4731: || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))) 4732: C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1; 4733: return decl; 4734: } 4735: 4736: /* Detect the case of an array type of unspecified size 4737: which came, as such, direct from a typedef name. 4738: We must copy the type, so that each identifier gets 4739: a distinct type, so that each identifier's size can be 4740: controlled separately by its own initializer. */ 4741: 4742: if (type != 0 && typedef_type != 0 4743: && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type) 4744: && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0) 4745: { 4746: type = build_array_type (TREE_TYPE (type), 0); 1.1.1.2 root 4747: if (size_varies) 1.1 root 4748: C_TYPE_VARIABLE_SIZE (type) = 1; 4749: } 4750: 4751: /* If this is a type name (such as, in a cast or sizeof), 4752: compute the type and return it now. */ 4753: 4754: if (decl_context == TYPENAME) 4755: { 4756: /* Note that the grammar rejects storage classes 4757: in typenames, fields or parameters */ 4758: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE 4759: && (constp || volatilep)) 4760: pedwarn ("ANSI C forbids const or volatile function types"); 4761: if (constp || volatilep) 4762: type = c_build_type_variant (type, constp, volatilep); 4763: pop_obstacks (); 4764: return type; 4765: } 4766: 1.1.1.6 root 4767: /* Aside from typedefs and type names (handle above), 4768: `void' at top level (not within pointer) 4769: is allowed only in public variables. 1.1 root 4770: We don't complain about parms either, but that is because 4771: a better error message can be made later. */ 4772: 1.1.1.6 root 4773: if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM 4774: && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE) 4775: && ((specbits & (1 << (int) RID_EXTERN)) 4776: || (current_binding_level == global_binding_level 4777: && !(specbits 4778: & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER))))))) 1.1 root 4779: { 1.1.1.8 ! root 4780: error ("variable or field `%s' declared void", name); 1.1 root 4781: type = integer_type_node; 4782: } 4783: 4784: /* Now create the decl, which may be a VAR_DECL, a PARM_DECL 4785: or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */ 4786: 4787: { 4788: register tree decl; 4789: 4790: if (decl_context == PARM) 4791: { 4792: tree type_as_written = type; 1.1.1.4 root 4793: tree main_type; 1.1 root 4794: 4795: /* A parameter declared as an array of T is really a pointer to T. 4796: One declared as a function is really a pointer to a function. */ 4797: 4798: if (TREE_CODE (type) == ARRAY_TYPE) 4799: { 4800: /* Transfer const-ness of array into that of type pointed to. */ 1.1.1.6 root 4801: type = TREE_TYPE (type); 4802: if (constp || volatilep) 4803: type = c_build_type_variant (type, constp, volatilep); 4804: type = build_pointer_type (type); 1.1 root 4805: volatilep = constp = 0; 1.1.1.2 root 4806: size_varies = 0; 1.1 root 4807: } 4808: else if (TREE_CODE (type) == FUNCTION_TYPE) 4809: { 4810: if (pedantic && (constp || volatilep)) 4811: pedwarn ("ANSI C forbids const or volatile function types"); 1.1.1.6 root 4812: if (constp || volatilep) 4813: type = c_build_type_variant (type, constp, volatilep); 4814: type = build_pointer_type (type); 1.1 root 4815: volatilep = constp = 0; 4816: } 4817: 4818: decl = build_decl (PARM_DECL, declarator, type); 1.1.1.2 root 4819: if (size_varies) 1.1 root 4820: C_DECL_VARIABLE_SIZE (decl) = 1; 4821: 4822: /* Compute the type actually passed in the parmlist, 4823: for the case where there is no prototype. 4824: (For example, shorts and chars are passed as ints.) 4825: When there is a prototype, this is overridden later. */ 4826: 4827: DECL_ARG_TYPE (decl) = type; 1.1.1.5 root 4828: main_type = (type == error_mark_node 4829: ? error_mark_node 4830: : TYPE_MAIN_VARIANT (type)); 1.1.1.4 root 4831: if (main_type == float_type_node) 1.1 root 4832: DECL_ARG_TYPE (decl) = double_type_node; 1.1.1.5 root 4833: /* Don't use TYPE_PRECISION to decide whether to promote, 1.1.1.3 root 4834: because we should convert short if it's the same size as int, 4835: but we should not convert long if it's the same size as int. */ 1.1.1.5 root 4836: else if (TREE_CODE (main_type) != ERROR_MARK 4837: && C_PROMOTING_INTEGER_TYPE_P (main_type)) 1.1.1.3 root 4838: { 4839: if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node) 4840: && TREE_UNSIGNED (type)) 4841: DECL_ARG_TYPE (decl) = unsigned_type_node; 4842: else 4843: DECL_ARG_TYPE (decl) = integer_type_node; 4844: } 1.1 root 4845: 4846: DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written; 4847: } 4848: else if (decl_context == FIELD) 4849: { 4850: /* Structure field. It may not be a function. */ 4851: 4852: if (TREE_CODE (type) == FUNCTION_TYPE) 4853: { 1.1.1.8 ! root 4854: error ("field `%s' declared as a function", name); 1.1 root 4855: type = build_pointer_type (type); 4856: } 4857: else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0) 4858: { 1.1.1.8 ! root 4859: error ("field `%s' has incomplete type", name); 1.1 root 4860: type = error_mark_node; 4861: } 4862: /* Move type qualifiers down to element of an array. */ 4863: if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep)) 4864: { 4865: type = build_array_type (c_build_type_variant (TREE_TYPE (type), 4866: constp, volatilep), 4867: TYPE_DOMAIN (type)); 4868: #if 0 /* Leave the field const or volatile as well. */ 4869: constp = volatilep = 0; 4870: #endif 4871: } 4872: decl = build_decl (FIELD_DECL, declarator, type); 1.1.1.2 root 4873: if (size_varies) 1.1 root 4874: C_DECL_VARIABLE_SIZE (decl) = 1; 4875: } 4876: else if (TREE_CODE (type) == FUNCTION_TYPE) 4877: { 1.1.1.4 root 4878: /* Every function declaration is "external" 4879: except for those which are inside a function body 4880: in which `auto' is used. 4881: That is a case not specified by ANSI C, 4882: and we use it for forward declarations for nested functions. */ 4883: int extern_ref = (!(specbits & (1 << (int) RID_AUTO)) 4884: || current_binding_level == global_binding_level); 4885: 1.1 root 4886: if (specbits & (1 << (int) RID_AUTO) 4887: && (pedantic || current_binding_level == global_binding_level)) 1.1.1.8 ! root 4888: pedwarn ("invalid storage class for function `%s'", name); 1.1 root 4889: if (specbits & (1 << (int) RID_REGISTER)) 1.1.1.8 ! root 4890: error ("invalid storage class for function `%s'", name); 1.1 root 4891: /* Function declaration not at top level. 4892: Storage classes other than `extern' are not allowed 4893: and `extern' makes no difference. */ 4894: if (current_binding_level != global_binding_level 4895: && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE))) 4896: && pedantic) 1.1.1.8 ! root 4897: pedwarn ("invalid storage class for function `%s'", name); 1.1.1.4 root 4898: 4899: /* If this is a block level extern, it must live past the end 4900: of the function so that we can check it against other 4901: extern declarations (IDENTIFIER_LIMBO_VALUE). */ 4902: if (extern_ref && allocation_temporary_p ()) 4903: end_temporary_allocation (); 4904: 1.1 root 4905: decl = build_decl (FUNCTION_DECL, declarator, type); 1.1.1.8 ! root 4906: decl = build_decl_attribute_variant (decl, decl_machine_attr); 1.1 root 4907: 1.1.1.4 root 4908: if (pedantic && (constp || volatilep) 4909: && ! DECL_IN_SYSTEM_HEADER (decl)) 1.1 root 4910: pedwarn ("ANSI C forbids const or volatile functions"); 4911: 1.1.1.6 root 4912: if (volatilep 4913: && TREE_TYPE (TREE_TYPE (decl)) != void_type_node) 1.1.1.7 root 4914: warning ("`noreturn' function returns non-void value"); 1.1.1.6 root 4915: 1.1.1.4 root 4916: if (extern_ref) 4917: DECL_EXTERNAL (decl) = 1; 1.1 root 4918: /* Record absence of global scope for `static' or `auto'. */ 4919: TREE_PUBLIC (decl) 4920: = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO))); 1.1.1.8 ! root 4921: 1.1 root 4922: /* Record presence of `inline', if it is reasonable. */ 4923: if (inlinep) 4924: { 4925: tree last = tree_last (TYPE_ARG_TYPES (type)); 4926: 4927: if (! strcmp (IDENTIFIER_POINTER (declarator), "main")) 4928: warning ("cannot inline function `main'"); 1.1.1.4 root 4929: else if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last)) 4930: != void_type_node)) 1.1 root 4931: warning ("inline declaration ignored for function with `...'"); 4932: else 4933: /* Assume that otherwise the function can be inlined. */ 1.1.1.4 root 4934: DECL_INLINE (decl) = 1; 1.1 root 4935: 4936: if (specbits & (1 << (int) RID_EXTERN)) 4937: current_extern_inline = 1; 4938: } 4939: } 4940: else 4941: { 4942: /* It's a variable. */ 1.1.1.4 root 4943: /* An uninitialized decl with `extern' is a reference. */ 4944: int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN)); 1.1 root 4945: 4946: /* Move type qualifiers down to element of an array. */ 4947: if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep)) 4948: { 4949: type = build_array_type (c_build_type_variant (TREE_TYPE (type), 4950: constp, volatilep), 4951: TYPE_DOMAIN (type)); 4952: #if 0 /* Leave the variable const or volatile as well. */ 4953: constp = volatilep = 0; 4954: #endif 4955: } 4956: 1.1.1.4 root 4957: /* If this is a block level extern, it must live past the end 4958: of the function so that we can check it against other 4959: extern declarations (IDENTIFIER_LIMBO_VALUE). */ 4960: if (extern_ref && allocation_temporary_p ()) 4961: end_temporary_allocation (); 4962: 1.1 root 4963: decl = build_decl (VAR_DECL, declarator, type); 1.1.1.2 root 4964: if (size_varies) 1.1 root 4965: C_DECL_VARIABLE_SIZE (decl) = 1; 4966: 4967: if (inlinep) 4968: pedwarn_with_decl (decl, "variable `%s' declared `inline'"); 4969: 1.1.1.4 root 4970: DECL_EXTERNAL (decl) = extern_ref; 4971: /* At top level, the presence of a `static' or `register' storage 4972: class specifier, or the absence of all storage class specifiers 4973: makes this declaration a definition (perhaps tentative). Also, 4974: the absence of both `static' and `register' makes it public. */ 1.1 root 4975: if (current_binding_level == global_binding_level) 4976: { 1.1.1.4 root 4977: TREE_PUBLIC (decl) 4978: = !(specbits 4979: & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER))); 4980: TREE_STATIC (decl) = ! DECL_EXTERNAL (decl); 1.1 root 4981: } 4982: /* Not at top level, only `static' makes a static definition. */ 4983: else 4984: { 4985: TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0; 1.1.1.4 root 4986: TREE_PUBLIC (decl) = DECL_EXTERNAL (decl); 1.1 root 4987: } 1.1.1.5 root 4988: 4989: if (specbits & 1 << (int) RID_ITERATOR) 4990: ITERATOR_P (decl) = 1; 1.1 root 4991: } 4992: 4993: /* Record `register' declaration for warnings on & 4994: and in case doing stupid register allocation. */ 4995: 4996: if (specbits & (1 << (int) RID_REGISTER)) 1.1.1.4 root 4997: DECL_REGISTER (decl) = 1; 1.1 root 4998: 4999: /* Record constancy and volatility. */ 5000: 5001: if (constp) 5002: TREE_READONLY (decl) = 1; 5003: if (volatilep) 5004: { 5005: TREE_SIDE_EFFECTS (decl) = 1; 5006: TREE_THIS_VOLATILE (decl) = 1; 5007: } 5008: /* If a type has volatile components, it should be stored in memory. 5009: Otherwise, the fact that those components are volatile 5010: will be ignored, and would even crash the compiler. */ 5011: if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))) 5012: mark_addressable (decl); 5013: 5014: pop_obstacks (); 5015: 5016: return decl; 5017: } 5018: } 5019: 5020: /* Decode the parameter-list info for a function type or function definition. 5021: The argument is the value returned by `get_parm_info' (or made in parse.y 5022: if there is an identifier list instead of a parameter decl list). 5023: These two functions are separate because when a function returns 5024: or receives functions then each is called multiple times but the order 5025: of calls is different. The last call to `grokparms' is always the one 5026: that contains the formal parameter names of a function definition. 5027: 5028: Store in `last_function_parms' a chain of the decls of parms. 5029: Also store in `last_function_parm_tags' a chain of the struct, union, 5030: and enum tags declared among the parms. 5031: 5032: Return a list of arg types to use in the FUNCTION_TYPE for this function. 5033: 5034: FUNCDEF_FLAG is nonzero for a function definition, 0 for 5035: a mere declaration. A nonempty identifier-list gets an error message 5036: when FUNCDEF_FLAG is zero. */ 5037: 5038: static tree 5039: grokparms (parms_info, funcdef_flag) 5040: tree parms_info; 5041: int funcdef_flag; 5042: { 5043: tree first_parm = TREE_CHAIN (parms_info); 5044: 5045: last_function_parms = TREE_PURPOSE (parms_info); 5046: last_function_parm_tags = TREE_VALUE (parms_info); 5047: 1.1.1.4 root 5048: if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag 5049: && !in_system_header) 1.1 root 5050: warning ("function declaration isn't a prototype"); 5051: 5052: if (first_parm != 0 5053: && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE) 5054: { 5055: if (! funcdef_flag) 5056: pedwarn ("parameter names (without types) in function declaration"); 5057: 5058: last_function_parms = first_parm; 5059: return 0; 5060: } 5061: else 5062: { 5063: tree parm; 5064: tree typelt; 5065: /* We no longer test FUNCDEF_FLAG. 5066: If the arg types are incomplete in a declaration, 5067: they must include undefined tags. 5068: These tags can never be defined in the scope of the declaration, 5069: so the types can never be completed, 5070: and no call can be compiled successfully. */ 5071: #if 0 5072: /* In a fcn definition, arg types must be complete. */ 5073: if (funcdef_flag) 5074: #endif 5075: for (parm = last_function_parms, typelt = first_parm; 5076: parm; 5077: parm = TREE_CHAIN (parm)) 5078: /* Skip over any enumeration constants declared here. */ 5079: if (TREE_CODE (parm) == PARM_DECL) 5080: { 5081: /* Barf if the parameter itself has an incomplete type. */ 5082: tree type = TREE_VALUE (typelt); 5083: if (TYPE_SIZE (type) == 0) 5084: { 5085: if (funcdef_flag && DECL_NAME (parm) != 0) 5086: error ("parameter `%s' has incomplete type", 5087: IDENTIFIER_POINTER (DECL_NAME (parm))); 5088: else 5089: warning ("parameter has incomplete type"); 5090: if (funcdef_flag) 5091: { 5092: TREE_VALUE (typelt) = error_mark_node; 5093: TREE_TYPE (parm) = error_mark_node; 5094: } 5095: } 5096: #if 0 /* This has been replaced by parm_tags_warning 5097: which uses a more accurate criterion for what to warn about. */ 5098: else 5099: { 5100: /* Now warn if is a pointer to an incomplete type. */ 5101: while (TREE_CODE (type) == POINTER_TYPE 5102: || TREE_CODE (type) == REFERENCE_TYPE) 5103: type = TREE_TYPE (type); 5104: type = TYPE_MAIN_VARIANT (type); 5105: if (TYPE_SIZE (type) == 0) 5106: { 5107: if (DECL_NAME (parm) != 0) 5108: warning ("parameter `%s' points to incomplete type", 5109: IDENTIFIER_POINTER (DECL_NAME (parm))); 5110: else 5111: warning ("parameter points to incomplete type"); 5112: } 5113: } 5114: #endif 5115: typelt = TREE_CHAIN (typelt); 5116: } 5117: 1.1.1.4 root 5118: /* Allocate the list of types the way we allocate a type. */ 5119: if (first_parm && ! TREE_PERMANENT (first_parm)) 5120: { 5121: /* Construct a copy of the list of types 5122: on the saveable obstack. */ 5123: tree result = NULL; 5124: for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt)) 5125: result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt), 5126: result); 5127: return nreverse (result); 5128: } 5129: else 5130: /* The list we have is permanent already. */ 5131: return first_parm; 1.1 root 5132: } 5133: } 5134: 5135: 5136: /* Return a tree_list node with info on a parameter list just parsed. 5137: The TREE_PURPOSE is a chain of decls of those parms. 5138: The TREE_VALUE is a list of structure, union and enum tags defined. 5139: The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE. 5140: This tree_list node is later fed to `grokparms'. 5141: 5142: VOID_AT_END nonzero means append `void' to the end of the type-list. 5143: Zero means the parmlist ended with an ellipsis so don't append `void'. */ 5144: 5145: tree 5146: get_parm_info (void_at_end) 5147: int void_at_end; 5148: { 5149: register tree decl, t; 5150: register tree types = 0; 5151: int erred = 0; 5152: tree tags = gettags (); 5153: tree parms = getdecls (); 5154: tree new_parms = 0; 5155: tree order = current_binding_level->parm_order; 5156: 5157: /* Just `void' (and no ellipsis) is special. There are really no parms. */ 5158: if (void_at_end && parms != 0 5159: && TREE_CHAIN (parms) == 0 1.1.1.4 root 5160: && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node 1.1 root 5161: && DECL_NAME (parms) == 0) 5162: { 5163: parms = NULL_TREE; 5164: storedecls (NULL_TREE); 5165: return saveable_tree_cons (NULL_TREE, NULL_TREE, 5166: saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE)); 5167: } 5168: 1.1.1.3 root 5169: /* Extract enumerator values and other non-parms declared with the parms. 5170: Likewise any forward parm decls that didn't have real parm decls. */ 1.1 root 5171: for (decl = parms; decl; ) 5172: { 5173: tree next = TREE_CHAIN (decl); 5174: 5175: if (TREE_CODE (decl) != PARM_DECL) 5176: { 5177: TREE_CHAIN (decl) = new_parms; 5178: new_parms = decl; 5179: } 1.1.1.3 root 5180: else if (TREE_ASM_WRITTEN (decl)) 5181: { 5182: error_with_decl (decl, "parameter `%s' has just a forward declaration"); 5183: TREE_CHAIN (decl) = new_parms; 5184: new_parms = decl; 5185: } 1.1 root 5186: decl = next; 5187: } 5188: 5189: /* Put the parm decls back in the order they were in in the parm list. */ 5190: for (t = order; t; t = TREE_CHAIN (t)) 5191: { 5192: if (TREE_CHAIN (t)) 5193: TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t)); 5194: else 5195: TREE_CHAIN (TREE_VALUE (t)) = 0; 5196: } 5197: 5198: new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0, 5199: new_parms); 5200: 5201: /* Store the parmlist in the binding level since the old one 5202: is no longer a valid list. (We have changed the chain pointers.) */ 5203: storedecls (new_parms); 5204: 5205: for (decl = new_parms; decl; decl = TREE_CHAIN (decl)) 5206: /* There may also be declarations for enumerators if an enumeration 5207: type is declared among the parms. Ignore them here. */ 5208: if (TREE_CODE (decl) == PARM_DECL) 5209: { 5210: /* Since there is a prototype, 5211: args are passed in their declared types. */ 5212: tree type = TREE_TYPE (decl); 5213: DECL_ARG_TYPE (decl) = type; 5214: #ifdef PROMOTE_PROTOTYPES 1.1.1.6 root 5215: if ((TREE_CODE (type) == INTEGER_TYPE 5216: || TREE_CODE (type) == ENUMERAL_TYPE) 1.1 root 5217: && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) 5218: DECL_ARG_TYPE (decl) = integer_type_node; 5219: #endif 5220: 5221: types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types); 1.1.1.4 root 5222: if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred 1.1 root 5223: && DECL_NAME (decl) == 0) 5224: { 5225: error ("`void' in parameter list must be the entire list"); 5226: erred = 1; 5227: } 5228: } 5229: 5230: if (void_at_end) 5231: return saveable_tree_cons (new_parms, tags, 5232: nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types))); 5233: 5234: return saveable_tree_cons (new_parms, tags, nreverse (types)); 5235: } 5236: 5237: /* At end of parameter list, warn about any struct, union or enum tags 5238: defined within. Do so because these types cannot ever become complete. */ 5239: 5240: void 5241: parmlist_tags_warning () 5242: { 5243: tree elt; 5244: static int already; 5245: 5246: for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt)) 5247: { 5248: enum tree_code code = TREE_CODE (TREE_VALUE (elt)); 1.1.1.3 root 5249: /* An anonymous union parm type is meaningful as a GNU extension. 5250: So don't warn for that. */ 5251: if (code == UNION_TYPE && !pedantic) 5252: continue; 1.1.1.2 root 5253: if (TREE_PURPOSE (elt) != 0) 5254: warning ("`%s %s' declared inside parameter list", 5255: (code == RECORD_TYPE ? "struct" 5256: : code == UNION_TYPE ? "union" 5257: : "enum"), 5258: IDENTIFIER_POINTER (TREE_PURPOSE (elt))); 5259: else 5260: warning ("anonymous %s declared inside parameter list", 5261: (code == RECORD_TYPE ? "struct" 5262: : code == UNION_TYPE ? "union" 5263: : "enum")); 5264: 1.1 root 5265: if (! already) 5266: { 5267: warning ("its scope is only this definition or declaration,"); 5268: warning ("which is probably not what you want."); 5269: already = 1; 5270: } 5271: } 5272: } 5273: 5274: /* Get the struct, enum or union (CODE says which) with tag NAME. 5275: Define the tag as a forward-reference if it is not defined. */ 5276: 5277: tree 5278: xref_tag (code, name) 5279: enum tree_code code; 5280: tree name; 5281: { 5282: int temporary = allocation_temporary_p (); 5283: 5284: /* If a cross reference is requested, look up the type 5285: already defined for this tag and return it. */ 5286: 5287: register tree ref = lookup_tag (code, name, current_binding_level, 0); 5288: /* Even if this is the wrong type of tag, return what we found. 5289: There will be an error message anyway, from pending_xref_error. 5290: If we create an empty xref just for an invalid use of the type, 1.1.1.2 root 5291: the main result is to create lots of superfluous error messages. */ 1.1 root 5292: if (ref) 5293: return ref; 5294: 5295: push_obstacks_nochange (); 5296: 5297: if (current_binding_level == global_binding_level && temporary) 5298: end_temporary_allocation (); 5299: 5300: /* If no such tag is yet defined, create a forward-reference node 5301: and record it as the "definition". 5302: When a real declaration of this type is found, 5303: the forward-reference will be altered into a real type. */ 5304: 5305: ref = make_node (code); 5306: if (code == ENUMERAL_TYPE) 5307: { 5308: /* (In ANSI, Enums can be referred to only if already defined.) */ 5309: if (pedantic) 5310: pedwarn ("ANSI C forbids forward references to `enum' types"); 5311: /* Give the type a default layout like unsigned int 5312: to avoid crashing if it does not get defined. */ 5313: TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node); 5314: TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node); 5315: TREE_UNSIGNED (ref) = 1; 5316: TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node); 5317: TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node); 5318: TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node); 5319: } 5320: 5321: pushtag (name, ref); 5322: 5323: pop_obstacks (); 5324: 5325: return ref; 5326: } 5327: 5328: /* Make sure that the tag NAME is defined *in the current binding level* 5329: at least as a forward reference. 1.1.1.4 root 5330: CODE says which kind of tag NAME ought to be. 5331: 5332: We also do a push_obstacks_nochange 5333: whose matching pop is in finish_struct. */ 1.1 root 5334: 5335: tree 5336: start_struct (code, name) 5337: enum tree_code code; 5338: tree name; 5339: { 5340: /* If there is already a tag defined at this binding level 5341: (as a forward reference), just return it. */ 5342: 5343: register tree ref = 0; 5344: 1.1.1.4 root 5345: push_obstacks_nochange (); 5346: if (current_binding_level == global_binding_level) 5347: end_temporary_allocation (); 5348: 1.1 root 5349: if (name != 0) 5350: ref = lookup_tag (code, name, current_binding_level, 1); 5351: if (ref && TREE_CODE (ref) == code) 5352: { 5353: C_TYPE_BEING_DEFINED (ref) = 1; 5354: if (TYPE_FIELDS (ref)) 5355: error ((code == UNION_TYPE ? "redefinition of `union %s'" 5356: : "redefinition of `struct %s'"), 5357: IDENTIFIER_POINTER (name)); 5358: 5359: return ref; 5360: } 5361: 5362: /* Otherwise create a forward-reference just so the tag is in scope. */ 5363: 5364: ref = make_node (code); 5365: pushtag (name, ref); 5366: C_TYPE_BEING_DEFINED (ref) = 1; 5367: return ref; 5368: } 5369: 5370: /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted) 5371: of a structure component, returning a FIELD_DECL node. 5372: WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. 5373: 5374: This is done during the parsing of the struct declaration. 5375: The FIELD_DECL nodes are chained together and the lot of them 5376: are ultimately passed to `build_struct' to make the RECORD_TYPE node. */ 5377: 5378: tree 5379: grokfield (filename, line, declarator, declspecs, width) 5380: char *filename; 5381: int line; 5382: tree declarator, declspecs, width; 5383: { 5384: tree value; 5385: 5386: /* The corresponding pop_obstacks is in finish_decl. */ 5387: push_obstacks_nochange (); 5388: 5389: value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0); 5390: 1.1.1.4 root 5391: finish_decl (value, NULL_TREE, NULL_TREE); 1.1 root 5392: DECL_INITIAL (value) = width; 5393: 1.1.1.5 root 5394: maybe_objc_check_decl (value); 1.1 root 5395: return value; 5396: } 5397: 5398: /* Function to help qsort sort FIELD_DECLs by name order. */ 5399: 5400: static int 5401: field_decl_cmp (x, y) 5402: tree *x, *y; 5403: { 1.1.1.8 ! root 5404: if (DECL_NAME (*x) == DECL_NAME (*y)) ! 5405: return 0; ! 5406: if (DECL_NAME (*x) == NULL) ! 5407: return -1; ! 5408: if (DECL_NAME (*y) == NULL) ! 5409: return 1; ! 5410: if (DECL_NAME (*x) < DECL_NAME (*y)) ! 5411: return -1; ! 5412: return 1; 1.1 root 5413: } 5414: 5415: /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T. 1.1.1.4 root 5416: FIELDLIST is a chain of FIELD_DECL nodes for the fields. 1.1.1.8 ! root 5417: ATTRIBUTES are attributes to be applied to the structure. 1.1.1.4 root 5418: 5419: We also do a pop_obstacks to match the push in start_struct. */ 1.1 root 5420: 5421: tree 1.1.1.8 ! root 5422: finish_struct (t, fieldlist, attributes) ! 5423: tree t; ! 5424: tree fieldlist; ! 5425: tree attributes; 1.1 root 5426: { 5427: register tree x; 5428: int old_momentary; 5429: int toplevel = global_binding_level == current_binding_level; 5430: 5431: /* If this type was previously laid out as a forward reference, 5432: make sure we lay it out again. */ 5433: 5434: TYPE_SIZE (t) = 0; 5435: 1.1.1.8 ! root 5436: decl_attributes (t, attributes, NULL_TREE); ! 5437: 1.1 root 5438: /* Nameless union parm types are useful as GCC extension. */ 5439: if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic) 5440: /* Otherwise, warn about any struct or union def. in parmlist. */ 5441: if (in_parm_level_p ()) 5442: { 5443: if (pedantic) 5444: pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms" 5445: : "structure defined inside parms")); 1.1.1.5 root 5446: else if (! flag_traditional) 1.1 root 5447: warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms" 5448: : "structure defined inside parms")); 5449: } 5450: 5451: old_momentary = suspend_momentary (); 5452: 5453: if (fieldlist == 0 && pedantic) 5454: pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union has no members" 5455: : "structure has no members")); 5456: 5457: /* Install struct as DECL_CONTEXT of each field decl. 5458: Also process specified field sizes. 1.1.1.3 root 5459: Set DECL_FIELD_SIZE to the specified size, or 0 if none specified. 1.1 root 5460: The specified size is found in the DECL_INITIAL. 5461: Store 0 there, except for ": 0" fields (so we can find them 5462: and delete them, below). */ 5463: 5464: for (x = fieldlist; x; x = TREE_CHAIN (x)) 5465: { 5466: DECL_CONTEXT (x) = t; 1.1.1.8 ! root 5467: DECL_PACKED (x) |= TYPE_PACKED (t); 1.1.1.3 root 5468: DECL_FIELD_SIZE (x) = 0; 1.1 root 5469: 5470: /* If any field is const, the structure type is pseudo-const. */ 5471: if (TREE_READONLY (x)) 5472: C_TYPE_FIELDS_READONLY (t) = 1; 5473: else 5474: { 5475: /* A field that is pseudo-const makes the structure likewise. */ 5476: tree t1 = TREE_TYPE (x); 5477: while (TREE_CODE (t1) == ARRAY_TYPE) 5478: t1 = TREE_TYPE (t1); 5479: if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE) 5480: && C_TYPE_FIELDS_READONLY (t1)) 5481: C_TYPE_FIELDS_READONLY (t) = 1; 5482: } 5483: 5484: /* Any field that is volatile means variables of this type must be 5485: treated in some ways as volatile. */ 5486: if (TREE_THIS_VOLATILE (x)) 5487: C_TYPE_FIELDS_VOLATILE (t) = 1; 5488: 5489: /* Any field of nominal variable size implies structure is too. */ 5490: if (C_DECL_VARIABLE_SIZE (x)) 5491: C_TYPE_VARIABLE_SIZE (t) = 1; 5492: 1.1.1.4 root 5493: /* Detect invalid nested redefinition. */ 5494: if (TREE_TYPE (x) == t) 5495: error ("nested redefinition of `%s'", 5496: IDENTIFIER_POINTER (TYPE_NAME (t))); 5497: 1.1 root 5498: /* Detect invalid bit-field size. */ 1.1.1.4 root 5499: if (DECL_INITIAL (x)) 5500: STRIP_NOPS (DECL_INITIAL (x)); 1.1.1.5 root 5501: if (DECL_INITIAL (x)) 1.1 root 5502: { 1.1.1.5 root 5503: if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST) 5504: constant_expression_warning (DECL_INITIAL (x)); 5505: else 5506: { 5507: error_with_decl (x, "bit-field `%s' width not an integer constant"); 5508: DECL_INITIAL (x) = NULL; 5509: } 1.1 root 5510: } 5511: 5512: /* Detect invalid bit-field type. */ 5513: if (DECL_INITIAL (x) 5514: && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE 5515: && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE) 5516: { 5517: error_with_decl (x, "bit-field `%s' has invalid type"); 5518: DECL_INITIAL (x) = NULL; 5519: } 5520: if (DECL_INITIAL (x) && pedantic 5521: && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node 1.1.1.6 root 5522: && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node 5523: /* Accept an enum that's equivalent to int or unsigned int. */ 5524: && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE 5525: && (TYPE_PRECISION (TREE_TYPE (x)) 5526: == TYPE_PRECISION (integer_type_node)))) 1.1 root 5527: pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C"); 5528: 5529: /* Detect and ignore out of range field width. */ 5530: if (DECL_INITIAL (x)) 5531: { 1.1.1.4 root 5532: unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x)); 1.1 root 5533: 1.1.1.7 root 5534: if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0) 1.1 root 5535: { 5536: DECL_INITIAL (x) = NULL; 5537: error_with_decl (x, "negative width in bit-field `%s'"); 5538: } 1.1.1.4 root 5539: else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0 5540: || width > TYPE_PRECISION (TREE_TYPE (x))) 1.1 root 5541: { 5542: DECL_INITIAL (x) = NULL; 1.1.1.4 root 5543: pedwarn_with_decl (x, "width of `%s' exceeds its type"); 1.1 root 5544: } 1.1.1.4 root 5545: else if (width == 0 && DECL_NAME (x) != 0) 1.1 root 5546: { 1.1.1.4 root 5547: error_with_decl (x, "zero width for bit-field `%s'"); 1.1 root 5548: DECL_INITIAL (x) = NULL; 5549: } 5550: } 5551: 5552: /* Process valid field width. */ 5553: if (DECL_INITIAL (x)) 5554: { 5555: register int width = TREE_INT_CST_LOW (DECL_INITIAL (x)); 5556: 1.1.1.3 root 5557: DECL_FIELD_SIZE (x) = width; 1.1 root 5558: DECL_BIT_FIELD (x) = 1; 5559: DECL_INITIAL (x) = NULL; 5560: 5561: if (width == 0) 5562: { 5563: /* field size 0 => force desired amount of alignment. */ 5564: #ifdef EMPTY_FIELD_BOUNDARY 5565: DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY); 5566: #endif 5567: #ifdef PCC_BITFIELD_TYPE_MATTERS 5568: DECL_ALIGN (x) = MAX (DECL_ALIGN (x), 5569: TYPE_ALIGN (TREE_TYPE (x))); 5570: #endif 5571: } 5572: } 1.1.1.7 root 5573: else if (TREE_TYPE (x) != error_mark_node) 1.1.1.3 root 5574: { 5575: int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT 5576: : TYPE_ALIGN (TREE_TYPE (x))); 5577: /* Non-bit-fields are aligned for their type, except packed 5578: fields which require only BITS_PER_UNIT alignment. */ 5579: DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align); 5580: } 1.1 root 5581: } 5582: 5583: /* Now DECL_INITIAL is null on all members. */ 5584: 5585: /* Delete all duplicate fields from the fieldlist */ 5586: for (x = fieldlist; x && TREE_CHAIN (x);) 5587: /* Anonymous fields aren't duplicates. */ 5588: if (DECL_NAME (TREE_CHAIN (x)) == 0) 5589: x = TREE_CHAIN (x); 5590: else 5591: { 5592: register tree y = fieldlist; 5593: 5594: while (1) 5595: { 5596: if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x))) 5597: break; 5598: if (y == x) 5599: break; 5600: y = TREE_CHAIN (y); 5601: } 5602: if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x))) 5603: { 5604: error_with_decl (TREE_CHAIN (x), "duplicate member `%s'"); 5605: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x)); 5606: } 5607: else x = TREE_CHAIN (x); 5608: } 5609: 5610: /* Now we have the nearly final fieldlist. Record it, 5611: then lay out the structure or union (including the fields). */ 5612: 5613: TYPE_FIELDS (t) = fieldlist; 5614: 5615: layout_type (t); 5616: 5617: /* Delete all zero-width bit-fields from the front of the fieldlist */ 5618: while (fieldlist 5619: && DECL_INITIAL (fieldlist)) 5620: fieldlist = TREE_CHAIN (fieldlist); 5621: /* Delete all such members from the rest of the fieldlist */ 5622: for (x = fieldlist; x;) 5623: { 5624: if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x))) 5625: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x)); 5626: else x = TREE_CHAIN (x); 5627: } 5628: 5629: /* Now we have the truly final field list. 5630: Store it in this type and in the variants. */ 5631: 5632: TYPE_FIELDS (t) = fieldlist; 5633: 5634: /* If there are lots of fields, sort so we can look through them fast. 5635: We arbitrarily consider 16 or more elts to be "a lot". */ 5636: { 5637: int len = 0; 5638: 5639: for (x = fieldlist; x; x = TREE_CHAIN (x)) 5640: { 5641: if (len > 15) 5642: break; 5643: len += 1; 5644: } 5645: if (len > 15) 5646: { 5647: tree *field_array; 5648: char *space; 5649: 5650: len += list_length (x); 5651: /* Use the same allocation policy here that make_node uses, to 5652: ensure that this lives as long as the rest of the struct decl. 5653: All decls in an inline function need to be saved. */ 5654: if (allocation_temporary_p ()) 5655: space = savealloc (sizeof (struct lang_type) + len * sizeof (tree)); 5656: else 5657: space = oballoc (sizeof (struct lang_type) + len * sizeof (tree)); 5658: 5659: TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space; 5660: TYPE_LANG_SPECIFIC (t)->len = len; 5661: 5662: field_array = &TYPE_LANG_SPECIFIC (t)->elts[0]; 5663: len = 0; 5664: for (x = fieldlist; x; x = TREE_CHAIN (x)) 5665: field_array[len++] = x; 5666: 5667: qsort (field_array, len, sizeof (tree), field_decl_cmp); 5668: } 5669: } 5670: 5671: for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x)) 5672: { 5673: TYPE_FIELDS (x) = TYPE_FIELDS (t); 5674: TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t); 5675: TYPE_ALIGN (x) = TYPE_ALIGN (t); 5676: } 5677: 5678: /* Promote each bit-field's type to int if it is narrower than that. */ 5679: for (x = fieldlist; x; x = TREE_CHAIN (x)) 5680: if (DECL_BIT_FIELD (x) 1.1.1.5 root 5681: && (C_PROMOTING_INTEGER_TYPE_P (TREE_TYPE (x)) 5682: || DECL_FIELD_SIZE (x) < TYPE_PRECISION (integer_type_node))) 5683: { 5684: tree type = TREE_TYPE (x); 1.1.1.4 root 5685: 1.1.1.5 root 5686: /* Preserve unsignedness if traditional 5687: or if not really getting any wider. */ 5688: if (TREE_UNSIGNED (type) 5689: && (flag_traditional 5690: || 5691: (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node) 5692: && 5693: DECL_FIELD_SIZE (x) == TYPE_PRECISION (integer_type_node)))) 5694: TREE_TYPE (x) = unsigned_type_node; 5695: else 5696: TREE_TYPE (x) = integer_type_node; 5697: } 1.1 root 5698: 1.1.1.8 ! root 5699: /* If this was supposed to be a transparent union, but we can't ! 5700: make it one, warn and turn off the flag. */ ! 5701: if (TREE_CODE (t) == UNION_TYPE ! 5702: && TYPE_TRANSPARENT_UNION (t) ! 5703: && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))) ! 5704: { ! 5705: TYPE_TRANSPARENT_UNION (t) = 0; ! 5706: warning ("cannot make `%s' a transparent union"); ! 5707: } ! 5708: 1.1 root 5709: /* If this structure or union completes the type of any previous 5710: variable declaration, lay it out and output its rtl. */ 5711: 5712: if (current_binding_level->n_incomplete != 0) 5713: { 5714: tree decl; 5715: for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl)) 5716: { 5717: if (TREE_TYPE (decl) == t 5718: && TREE_CODE (decl) != TYPE_DECL) 5719: { 5720: layout_decl (decl, 0); 5721: /* This is a no-op in c-lang.c or something real in objc-actions.c. */ 5722: maybe_objc_check_decl (decl); 1.1.1.4 root 5723: rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0); 1.1 root 5724: if (! toplevel) 5725: expand_decl (decl); 5726: --current_binding_level->n_incomplete; 5727: } 5728: else if (TYPE_SIZE (TREE_TYPE (decl)) == 0 5729: && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 5730: { 5731: tree element = TREE_TYPE (decl); 5732: while (TREE_CODE (element) == ARRAY_TYPE) 5733: element = TREE_TYPE (element); 5734: if (element == t) 5735: layout_array_type (TREE_TYPE (decl)); 5736: } 5737: } 5738: } 5739: 5740: resume_momentary (old_momentary); 5741: 5742: /* Finish debugging output for this type. */ 5743: rest_of_type_compilation (t, toplevel); 5744: 1.1.1.4 root 5745: /* The matching push is in start_struct. */ 5746: pop_obstacks (); 5747: 1.1 root 5748: return t; 5749: } 5750: 5751: /* Lay out the type T, and its element type, and so on. */ 5752: 5753: static void 5754: layout_array_type (t) 5755: tree t; 5756: { 5757: if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 5758: layout_array_type (TREE_TYPE (t)); 5759: layout_type (t); 5760: } 5761: 5762: /* Begin compiling the definition of an enumeration type. 5763: NAME is its name (or null if anonymous). 5764: Returns the type object, as yet incomplete. 5765: Also records info about it so that build_enumerator 5766: may be used to declare the individual values as they are read. */ 5767: 5768: tree 5769: start_enum (name) 5770: tree name; 5771: { 5772: register tree enumtype = 0; 5773: 5774: /* If this is the real definition for a previous forward reference, 5775: fill in the contents in the same object that used to be the 5776: forward reference. */ 5777: 5778: if (name != 0) 5779: enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1); 5780: 1.1.1.4 root 5781: /* The corresponding pop_obstacks is in finish_enum. */ 5782: push_obstacks_nochange (); 5783: /* If these symbols and types are global, make them permanent. */ 5784: if (current_binding_level == global_binding_level) 5785: end_temporary_allocation (); 5786: 1.1 root 5787: if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE) 5788: { 5789: enumtype = make_node (ENUMERAL_TYPE); 5790: pushtag (name, enumtype); 5791: } 5792: 5793: C_TYPE_BEING_DEFINED (enumtype) = 1; 5794: 5795: if (TYPE_VALUES (enumtype) != 0) 5796: { 5797: /* This enum is a named one that has been declared already. */ 5798: error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name)); 5799: 5800: /* Completely replace its old definition. 5801: The old enumerators remain defined, however. */ 5802: TYPE_VALUES (enumtype) = 0; 5803: } 5804: 5805: enum_next_value = integer_zero_node; 1.1.1.3 root 5806: enum_overflow = 0; 1.1 root 5807: 5808: return enumtype; 5809: } 5810: 5811: /* After processing and defining all the values of an enumeration type, 5812: install their decls in the enumeration type and finish it off. 1.1.1.8 ! root 5813: ENUMTYPE is the type object, VALUES a list of decl-value pairs, ! 5814: and ATTRIBUTES are the specified attributes. 1.1 root 5815: Returns ENUMTYPE. */ 5816: 5817: tree 1.1.1.8 ! root 5818: finish_enum (enumtype, values, attributes) ! 5819: tree enumtype; ! 5820: tree values; ! 5821: tree attributes; 1.1 root 5822: { 1.1.1.5 root 5823: register tree pair, tem; 1.1 root 5824: tree minnode = 0, maxnode = 0; 1.1.1.7 root 5825: int lowprec, highprec, precision; 1.1 root 5826: int toplevel = global_binding_level == current_binding_level; 5827: 5828: if (in_parm_level_p ()) 5829: warning ("enum defined inside parms"); 5830: 1.1.1.8 ! root 5831: decl_attributes (enumtype, attributes, NULL_TREE); ! 5832: 1.1 root 5833: /* Calculate the maximum value of any enumerator in this type. */ 5834: 1.1.1.7 root 5835: if (values == error_mark_node) 5836: minnode = maxnode = integer_zero_node; 5837: else 5838: for (pair = values; pair; pair = TREE_CHAIN (pair)) 5839: { 5840: tree value = TREE_VALUE (pair); 5841: if (pair == values) 5842: minnode = maxnode = TREE_VALUE (pair); 5843: else 5844: { 5845: if (tree_int_cst_lt (maxnode, value)) 5846: maxnode = value; 5847: if (tree_int_cst_lt (value, minnode)) 5848: minnode = value; 5849: } 5850: } 1.1 root 5851: 5852: TYPE_MIN_VALUE (enumtype) = minnode; 5853: TYPE_MAX_VALUE (enumtype) = maxnode; 5854: 1.1.1.7 root 5855: /* An enum can have some negative values; then it is signed. */ 5856: TREE_UNSIGNED (enumtype) = tree_int_cst_sgn (minnode) >= 0; 1.1 root 5857: 1.1.1.7 root 5858: /* Determine the precision this type needs. */ 1.1 root 5859: 1.1.1.7 root 5860: lowprec = min_precision (minnode, TREE_UNSIGNED (enumtype)); 5861: highprec = min_precision (maxnode, TREE_UNSIGNED (enumtype)); 5862: precision = MAX (lowprec, highprec); 1.1 root 5863: 1.1.1.8 ! root 5864: if (flag_short_enums || TYPE_PACKED (enumtype) ! 5865: || precision > TYPE_PRECISION (integer_type_node)) 1.1 root 5866: /* Use the width of the narrowest normal C type which is wide enough. */ 5867: TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1)); 5868: else 5869: TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node); 5870: 5871: TYPE_SIZE (enumtype) = 0; 5872: layout_type (enumtype); 5873: 1.1.1.7 root 5874: if (values != error_mark_node) 5875: { 5876: /* Change the type of the enumerators to be the enum type. 5877: Formerly this was done only for enums that fit in an int, 5878: but the comment said it was done only for enums wider than int. 5879: It seems necessary to do this for wide enums, 5880: and best not to change what's done for ordinary narrower ones. */ 5881: for (pair = values; pair; pair = TREE_CHAIN (pair)) 5882: { 5883: TREE_TYPE (TREE_PURPOSE (pair)) = enumtype; 5884: DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype); 5885: if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL) 5886: DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype); 5887: } 5888: 5889: /* Replace the decl nodes in VALUES with their names. */ 5890: for (pair = values; pair; pair = TREE_CHAIN (pair)) 5891: TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair)); 1.1 root 5892: 1.1.1.7 root 5893: TYPE_VALUES (enumtype) = values; 5894: } 1.1 root 5895: 1.1.1.5 root 5896: /* Fix up all variant types of this enum type. */ 5897: for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem)) 5898: { 5899: TYPE_VALUES (tem) = TYPE_VALUES (enumtype); 5900: TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype); 5901: TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype); 5902: TYPE_SIZE (tem) = TYPE_SIZE (enumtype); 5903: TYPE_MODE (tem) = TYPE_MODE (enumtype); 5904: TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype); 5905: TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype); 5906: TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype); 5907: } 5908: 1.1 root 5909: /* Finish debugging output for this type. */ 5910: rest_of_type_compilation (enumtype, toplevel); 5911: 1.1.1.4 root 5912: /* This matches a push in start_enum. */ 5913: pop_obstacks (); 5914: 1.1 root 5915: return enumtype; 5916: } 5917: 5918: /* Build and install a CONST_DECL for one value of the 5919: current enumeration type (one that was begun with start_enum). 5920: Return a tree-list containing the CONST_DECL and its value. 5921: Assignment of sequential values by default is handled here. */ 5922: 5923: tree 5924: build_enumerator (name, value) 5925: tree name, value; 5926: { 1.1.1.6 root 5927: register tree decl, type; 1.1 root 5928: 5929: /* Validate and default VALUE. */ 5930: 5931: /* Remove no-op casts from the value. */ 1.1.1.4 root 5932: if (value) 5933: STRIP_TYPE_NOPS (value); 1.1 root 5934: 1.1.1.5 root 5935: if (value != 0) 1.1 root 5936: { 1.1.1.5 root 5937: if (TREE_CODE (value) == INTEGER_CST) 1.1.1.6 root 5938: { 5939: value = default_conversion (value); 5940: constant_expression_warning (value); 5941: } 1.1.1.5 root 5942: else 5943: { 5944: error ("enumerator value for `%s' not integer constant", 5945: IDENTIFIER_POINTER (name)); 5946: value = 0; 5947: } 1.1 root 5948: } 5949: 5950: /* Default based on previous value. */ 5951: /* It should no longer be possible to have NON_LVALUE_EXPR 5952: in the default. */ 5953: if (value == 0) 1.1.1.3 root 5954: { 5955: value = enum_next_value; 5956: if (enum_overflow) 5957: error ("overflow in enumeration values"); 5958: } 1.1 root 5959: 5960: if (pedantic && ! int_fits_type_p (value, integer_type_node)) 5961: { 5962: pedwarn ("ANSI C restricts enumerator values to range of `int'"); 5963: value = integer_zero_node; 5964: } 5965: 5966: /* Set basis for default for next value. */ 5967: enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0); 1.1.1.3 root 5968: enum_overflow = tree_int_cst_lt (enum_next_value, value); 1.1 root 5969: 5970: /* Now create a declaration for the enum value name. */ 5971: 1.1.1.6 root 5972: type = TREE_TYPE (value); 5973: type = type_for_size (MAX (TYPE_PRECISION (type), 5974: TYPE_PRECISION (integer_type_node)), 5975: ((flag_traditional 5976: || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node)) 5977: && TREE_UNSIGNED (type))); 5978: 5979: decl = build_decl (CONST_DECL, name, type); 1.1 root 5980: DECL_INITIAL (decl) = value; 1.1.1.6 root 5981: TREE_TYPE (value) = type; 1.1 root 5982: pushdecl (decl); 5983: 1.1.1.4 root 5984: return saveable_tree_cons (decl, value, NULL_TREE); 1.1 root 5985: } 5986: 5987: /* Create the FUNCTION_DECL for a function definition. 1.1.1.8 ! root 5988: DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of ! 5989: the declaration; they describe the function's name and the type it returns, 1.1 root 5990: but twisted together in a fashion that parallels the syntax of C. 5991: 5992: This function creates a binding context for the function body 5993: as well as setting up the FUNCTION_DECL in current_function_decl. 5994: 5995: Returns 1 on success. If the DECLARATOR is not suitable for a function 5996: (it defines a datum instead), we return 0, which tells 5997: yyparse to report a parse error. 5998: 5999: NESTED is nonzero for a function nested within another function. */ 6000: 6001: int 1.1.1.8 ! root 6002: start_function (declspecs, declarator, prefix_attributes, attributes, nested) ! 6003: tree declarator, declspecs, prefix_attributes, attributes; 1.1 root 6004: int nested; 6005: { 6006: tree decl1, old_decl; 6007: tree restype; 1.1.1.7 root 6008: int old_immediate_size_expand = immediate_size_expand; 1.1 root 6009: 6010: current_function_returns_value = 0; /* Assume, until we see it does. */ 6011: current_function_returns_null = 0; 6012: warn_about_return_type = 0; 6013: current_extern_inline = 0; 6014: c_function_varargs = 0; 6015: named_labels = 0; 6016: shadowed_labels = 0; 6017: 1.1.1.7 root 6018: /* Don't expand any sizes in the return type of the function. */ 6019: immediate_size_expand = 0; 6020: 1.1 root 6021: decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1); 6022: 6023: /* If the declarator is not suitable for a function definition, 6024: cause a syntax error. */ 6025: if (decl1 == 0) 6026: return 0; 6027: 1.1.1.8 ! root 6028: decl_attributes (decl1, prefix_attributes, attributes); ! 6029: 1.1 root 6030: announce_function (decl1); 6031: 6032: if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0) 6033: { 6034: error ("return-type is an incomplete type"); 6035: /* Make it return void instead. */ 6036: TREE_TYPE (decl1) 6037: = build_function_type (void_type_node, 6038: TYPE_ARG_TYPES (TREE_TYPE (decl1))); 6039: } 6040: 6041: if (warn_about_return_type) 6042: warning ("return-type defaults to `int'"); 6043: 6044: /* Save the parm names or decls from this function's declarator 6045: where store_parm_decls will find them. */ 6046: current_function_parms = last_function_parms; 6047: current_function_parm_tags = last_function_parm_tags; 6048: 6049: /* Make the init_value nonzero so pushdecl knows this is not tentative. 6050: error_mark_node is replaced below (in poplevel) with the BLOCK. */ 6051: DECL_INITIAL (decl1) = error_mark_node; 6052: 6053: /* If this definition isn't a prototype and we had a prototype declaration 6054: before, copy the arg type info from that prototype. 6055: But not if what we had before was a builtin function. */ 6056: old_decl = lookup_name_current_level (DECL_NAME (decl1)); 6057: if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE 6058: && !DECL_BUILT_IN (old_decl) 1.1.1.4 root 6059: && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1))) 6060: == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl)))) 1.1 root 6061: && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0) 1.1.1.5 root 6062: { 6063: TREE_TYPE (decl1) = TREE_TYPE (old_decl); 6064: current_function_prototype_file = DECL_SOURCE_FILE (old_decl); 6065: current_function_prototype_line = DECL_SOURCE_LINE (old_decl); 6066: } 1.1 root 6067: 1.1.1.7 root 6068: /* If there is no explicit declaration, look for any out-of-scope implicit 6069: declarations. */ 6070: if (old_decl == 0) 6071: old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)); 6072: 1.1 root 6073: /* Optionally warn of old-fashioned def with no previous prototype. */ 6074: if (warn_strict_prototypes 6075: && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0 6076: && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)) 6077: warning ("function declaration isn't a prototype"); 6078: /* Optionally warn of any global def with no previous prototype. */ 6079: else if (warn_missing_prototypes 6080: && TREE_PUBLIC (decl1) 1.1.1.5 root 6081: && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0) 6082: && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1)))) 1.1 root 6083: warning_with_decl (decl1, "no previous prototype for `%s'"); 6084: /* Optionally warn of any def with no previous prototype 6085: if the function has already been used. */ 6086: else if (warn_missing_prototypes 6087: && old_decl != 0 && TREE_USED (old_decl) 1.1.1.7 root 6088: && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0) 6089: warning_with_decl (decl1, 6090: "`%s' was used with no prototype before its definition"); 6091: /* Optionally warn of any global def with no previous declaration. */ 6092: else if (warn_missing_declarations 6093: && TREE_PUBLIC (decl1) 6094: && old_decl == 0 6095: && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1)))) 6096: warning_with_decl (decl1, "no previous declaration for `%s'"); 6097: /* Optionally warn of any def with no previous declaration 6098: if the function has already been used. */ 6099: else if (warn_missing_declarations 6100: && old_decl != 0 && TREE_USED (old_decl) 6101: && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1))) 6102: warning_with_decl (decl1, 6103: "`%s' was used with no declaration before its definition"); 1.1 root 6104: 6105: /* This is a definition, not a reference. 1.1.1.4 root 6106: So normally clear DECL_EXTERNAL. 1.1 root 6107: However, `extern inline' acts like a declaration 1.1.1.4 root 6108: except for defining how to inline. So set DECL_EXTERNAL in that case. */ 6109: DECL_EXTERNAL (decl1) = current_extern_inline; 1.1 root 6110: 6111: /* This function exists in static storage. 6112: (This does not mean `static' in the C sense!) */ 6113: TREE_STATIC (decl1) = 1; 6114: 6115: /* A nested function is not global. */ 6116: if (current_function_decl != 0) 6117: TREE_PUBLIC (decl1) = 0; 6118: 6119: /* Record the decl so that the function name is defined. 6120: If we already have a decl for this name, and it is a FUNCTION_DECL, 6121: use the old decl. */ 6122: 6123: current_function_decl = pushdecl (decl1); 6124: 6125: pushlevel (0); 6126: declare_parm_level (1); 6127: current_binding_level->subblocks_tag_transparent = 1; 6128: 6129: make_function_rtl (current_function_decl); 6130: 6131: restype = TREE_TYPE (TREE_TYPE (current_function_decl)); 6132: /* Promote the value to int before returning it. */ 1.1.1.4 root 6133: if (C_PROMOTING_INTEGER_TYPE_P (restype)) 6134: { 6135: /* It retains unsignedness if traditional 6136: or if not really getting wider. */ 6137: if (TREE_UNSIGNED (restype) 6138: && (flag_traditional 6139: || (TYPE_PRECISION (restype) 6140: == TYPE_PRECISION (integer_type_node)))) 6141: restype = unsigned_type_node; 6142: else 6143: restype = integer_type_node; 6144: } 6145: DECL_RESULT (current_function_decl) 6146: = build_decl (RESULT_DECL, NULL_TREE, restype); 1.1 root 6147: 6148: if (!nested) 6149: /* Allocate further tree nodes temporarily during compilation 6150: of this function only. */ 6151: temporary_allocation (); 6152: 6153: /* If this fcn was already referenced via a block-scope `extern' decl 6154: (or an implicit decl), propagate certain information about the usage. */ 6155: if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl))) 6156: TREE_ADDRESSABLE (current_function_decl) = 1; 6157: 1.1.1.7 root 6158: immediate_size_expand = old_immediate_size_expand; 6159: 1.1 root 6160: return 1; 6161: } 6162: 6163: /* Record that this function is going to be a varargs function. 6164: This is called before store_parm_decls, which is too early 6165: to call mark_varargs directly. */ 6166: 6167: void 6168: c_mark_varargs () 6169: { 6170: c_function_varargs = 1; 6171: } 6172: 6173: /* Store the parameter declarations into the current function declaration. 6174: This is called after parsing the parameter declarations, before 6175: digesting the body of the function. 6176: 6177: For an old-style definition, modify the function's type 6178: to specify at least the number of arguments. */ 6179: 6180: void 6181: store_parm_decls () 6182: { 6183: register tree fndecl = current_function_decl; 6184: register tree parm; 6185: 6186: /* This is either a chain of PARM_DECLs (if a prototype was used) 6187: or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */ 6188: tree specparms = current_function_parms; 6189: 6190: /* This is a list of types declared among parms in a prototype. */ 6191: tree parmtags = current_function_parm_tags; 6192: 6193: /* This is a chain of PARM_DECLs from old-style parm declarations. */ 6194: register tree parmdecls = getdecls (); 6195: 6196: /* This is a chain of any other decls that came in among the parm 6197: declarations. If a parm is declared with enum {foo, bar} x; 6198: then CONST_DECLs for foo and bar are put here. */ 6199: tree nonparms = 0; 6200: 6201: /* Nonzero if this definition is written with a prototype. */ 6202: int prototype = 0; 6203: 6204: if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST) 6205: { 6206: /* This case is when the function was defined with an ANSI prototype. 6207: The parms already have decls, so we need not do anything here 6208: except record them as in effect 6209: and complain if any redundant old-style parm decls were written. */ 6210: 6211: register tree next; 6212: tree others = 0; 6213: 6214: prototype = 1; 6215: 6216: if (parmdecls != 0) 1.1.1.4 root 6217: { 6218: tree decl, link; 6219: 6220: error_with_decl (fndecl, 6221: "parm types given both in parmlist and separately"); 6222: /* Get rid of the erroneous decls; don't keep them on 6223: the list of parms, since they might not be PARM_DECLs. */ 6224: for (decl = current_binding_level->names; 6225: decl; decl = TREE_CHAIN (decl)) 6226: if (DECL_NAME (decl)) 6227: IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0; 6228: for (link = current_binding_level->shadowed; 6229: link; link = TREE_CHAIN (link)) 6230: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link); 6231: current_binding_level->names = 0; 6232: current_binding_level->shadowed = 0; 6233: } 1.1 root 6234: 6235: specparms = nreverse (specparms); 6236: for (parm = specparms; parm; parm = next) 6237: { 6238: next = TREE_CHAIN (parm); 6239: if (TREE_CODE (parm) == PARM_DECL) 6240: { 6241: if (DECL_NAME (parm) == 0) 6242: error_with_decl (parm, "parameter name omitted"); 1.1.1.4 root 6243: else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node) 6244: { 6245: error_with_decl (parm, "parameter `%s' declared void"); 6246: /* Change the type to error_mark_node so this parameter 6247: will be ignored by assign_parms. */ 6248: TREE_TYPE (parm) = error_mark_node; 6249: } 1.1 root 6250: pushdecl (parm); 6251: } 6252: else 6253: { 6254: /* If we find an enum constant or a type tag, 6255: put it aside for the moment. */ 6256: TREE_CHAIN (parm) = 0; 6257: others = chainon (others, parm); 6258: } 6259: } 6260: 6261: /* Get the decls in their original chain order 6262: and record in the function. */ 6263: DECL_ARGUMENTS (fndecl) = getdecls (); 6264: 6265: #if 0 6266: /* If this function takes a variable number of arguments, 6267: add a phony parameter to the end of the parm list, 6268: to represent the position of the first unnamed argument. */ 6269: if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))) 6270: != void_type_node) 6271: { 6272: tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node); 6273: /* Let's hope the address of the unnamed parm 6274: won't depend on its type. */ 6275: TREE_TYPE (dummy) = integer_type_node; 6276: DECL_ARG_TYPE (dummy) = integer_type_node; 6277: DECL_ARGUMENTS (fndecl) 6278: = chainon (DECL_ARGUMENTS (fndecl), dummy); 6279: } 6280: #endif 6281: 6282: /* Now pushdecl the enum constants. */ 6283: for (parm = others; parm; parm = next) 6284: { 6285: next = TREE_CHAIN (parm); 6286: if (DECL_NAME (parm) == 0) 6287: ; 1.1.1.4 root 6288: else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node) 1.1 root 6289: ; 6290: else if (TREE_CODE (parm) != PARM_DECL) 6291: pushdecl (parm); 6292: } 6293: 6294: storetags (chainon (parmtags, gettags ())); 6295: } 6296: else 6297: { 6298: /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes 6299: each with a parm name as the TREE_VALUE. 6300: 6301: PARMDECLS is a chain of declarations for parameters. 6302: Warning! It can also contain CONST_DECLs which are not parameters 6303: but are names of enumerators of any enum types 6304: declared among the parameters. 6305: 6306: First match each formal parameter name with its declaration. 6307: Associate decls with the names and store the decls 6308: into the TREE_PURPOSE slots. */ 6309: 6310: for (parm = parmdecls; parm; parm = TREE_CHAIN (parm)) 6311: DECL_RESULT (parm) = 0; 6312: 6313: for (parm = specparms; parm; parm = TREE_CHAIN (parm)) 6314: { 6315: register tree tail, found = NULL; 6316: 6317: if (TREE_VALUE (parm) == 0) 6318: { 6319: error_with_decl (fndecl, "parameter name missing from parameter list"); 6320: TREE_PURPOSE (parm) = 0; 6321: continue; 6322: } 6323: 6324: /* See if any of the parmdecls specifies this parm by name. 6325: Ignore any enumerator decls. */ 6326: for (tail = parmdecls; tail; tail = TREE_CHAIN (tail)) 6327: if (DECL_NAME (tail) == TREE_VALUE (parm) 6328: && TREE_CODE (tail) == PARM_DECL) 6329: { 6330: found = tail; 6331: break; 6332: } 6333: 6334: /* If declaration already marked, we have a duplicate name. 6335: Complain, and don't use this decl twice. */ 6336: if (found && DECL_RESULT (found) != 0) 6337: { 6338: error_with_decl (found, "multiple parameters named `%s'"); 6339: found = 0; 6340: } 6341: 6342: /* If the declaration says "void", complain and ignore it. */ 1.1.1.4 root 6343: if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node) 1.1 root 6344: { 6345: error_with_decl (found, "parameter `%s' declared void"); 6346: TREE_TYPE (found) = integer_type_node; 6347: DECL_ARG_TYPE (found) = integer_type_node; 6348: layout_decl (found, 0); 6349: } 6350: 6351: /* Traditionally, a parm declared float is actually a double. */ 6352: if (found && flag_traditional 1.1.1.4 root 6353: && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node) 1.1.1.5 root 6354: { 6355: TREE_TYPE (found) = double_type_node; 6356: DECL_ARG_TYPE (found) = double_type_node; 6357: layout_decl (found, 0); 6358: } 1.1 root 6359: 6360: /* If no declaration found, default to int. */ 6361: if (!found) 6362: { 6363: found = build_decl (PARM_DECL, TREE_VALUE (parm), 6364: integer_type_node); 6365: DECL_ARG_TYPE (found) = TREE_TYPE (found); 6366: DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl); 6367: DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl); 6368: if (extra_warnings) 6369: warning_with_decl (found, "type of `%s' defaults to `int'"); 6370: pushdecl (found); 6371: } 6372: 6373: TREE_PURPOSE (parm) = found; 6374: 6375: /* Mark this decl as "already found" -- see test, above. 6376: It is safe to use DECL_RESULT for this 6377: since it is not used in PARM_DECLs or CONST_DECLs. */ 6378: DECL_RESULT (found) = error_mark_node; 6379: } 6380: 6381: /* Put anything which is on the parmdecls chain and which is 6382: not a PARM_DECL onto the list NONPARMS. (The types of 6383: non-parm things which might appear on the list include 6384: enumerators and NULL-named TYPE_DECL nodes.) Complain about 6385: any actual PARM_DECLs not matched with any names. */ 6386: 6387: nonparms = 0; 6388: for (parm = parmdecls; parm; ) 6389: { 6390: tree next = TREE_CHAIN (parm); 6391: TREE_CHAIN (parm) = 0; 6392: 6393: if (TREE_CODE (parm) != PARM_DECL) 6394: nonparms = chainon (nonparms, parm); 6395: else 6396: { 6397: /* Complain about args with incomplete types. */ 6398: if (TYPE_SIZE (TREE_TYPE (parm)) == 0) 6399: { 6400: error_with_decl (parm, "parameter `%s' has incomplete type"); 6401: TREE_TYPE (parm) = error_mark_node; 6402: } 6403: 6404: if (DECL_RESULT (parm) == 0) 6405: { 6406: error_with_decl (parm, 6407: "declaration for parameter `%s' but no such parameter"); 6408: /* Pretend the parameter was not missing. 6409: This gets us to a standard state and minimizes 6410: further error messages. */ 6411: specparms 6412: = chainon (specparms, 6413: tree_cons (parm, NULL_TREE, NULL_TREE)); 6414: } 6415: } 6416: 6417: parm = next; 6418: } 6419: 6420: /* Chain the declarations together in the order of the list of names. */ 6421: /* Store that chain in the function decl, replacing the list of names. */ 6422: parm = specparms; 6423: DECL_ARGUMENTS (fndecl) = 0; 6424: { 6425: register tree last; 6426: for (last = 0; parm; parm = TREE_CHAIN (parm)) 6427: if (TREE_PURPOSE (parm)) 6428: { 6429: if (last == 0) 6430: DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm); 6431: else 6432: TREE_CHAIN (last) = TREE_PURPOSE (parm); 6433: last = TREE_PURPOSE (parm); 6434: TREE_CHAIN (last) = 0; 6435: } 6436: } 6437: 6438: /* If there was a previous prototype, 6439: set the DECL_ARG_TYPE of each argument according to 6440: the type previously specified, and report any mismatches. */ 6441: 6442: if (TYPE_ARG_TYPES (TREE_TYPE (fndecl))) 6443: { 6444: register tree type; 6445: for (parm = DECL_ARGUMENTS (fndecl), 6446: type = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); 1.1.1.4 root 6447: parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) 6448: != void_type_node)); 1.1 root 6449: parm = TREE_CHAIN (parm), type = TREE_CHAIN (type)) 6450: { 6451: if (parm == 0 || type == 0 1.1.1.4 root 6452: || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node) 1.1 root 6453: { 6454: error ("number of arguments doesn't match prototype"); 1.1.1.5 root 6455: error_with_file_and_line (current_function_prototype_file, 6456: current_function_prototype_line, 6457: "prototype declaration"); 1.1 root 6458: break; 6459: } 6460: /* Type for passing arg must be consistent 6461: with that declared for the arg. */ 1.1.1.3 root 6462: if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type))) 1.1 root 6463: { 1.1.1.4 root 6464: if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) 6465: == TYPE_MAIN_VARIANT (TREE_VALUE (type))) 1.1 root 6466: { 1.1.1.3 root 6467: /* Adjust argument to match prototype. E.g. a previous 6468: `int foo(float);' prototype causes 6469: `int foo(x) float x; {...}' to be treated like 6470: `int foo(float x) {...}'. This is particularly 6471: useful for argument types like uid_t. */ 6472: DECL_ARG_TYPE (parm) = TREE_TYPE (parm); 6473: #ifdef PROMOTE_PROTOTYPES 1.1.1.6 root 6474: if ((TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE 6475: || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE) 1.1.1.3 root 6476: && TYPE_PRECISION (TREE_TYPE (parm)) 6477: < TYPE_PRECISION (integer_type_node)) 6478: DECL_ARG_TYPE (parm) = integer_type_node; 6479: #endif 6480: if (pedantic) 1.1.1.5 root 6481: { 6482: pedwarn ("promoted argument `%s' doesn't match prototype", 6483: IDENTIFIER_POINTER (DECL_NAME (parm))); 6484: warning_with_file_and_line 6485: (current_function_prototype_file, 6486: current_function_prototype_line, 6487: "prototype declaration"); 6488: } 1.1 root 6489: } 1.1.1.3 root 6490: /* If -traditional, allow `int' argument to match 6491: `unsigned' prototype. */ 6492: else if (! (flag_traditional 1.1.1.4 root 6493: && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node 6494: && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node)) 1.1.1.5 root 6495: { 6496: error ("argument `%s' doesn't match prototype", 6497: IDENTIFIER_POINTER (DECL_NAME (parm))); 6498: error_with_file_and_line (current_function_prototype_file, 6499: current_function_prototype_line, 6500: "prototype declaration"); 6501: } 1.1 root 6502: } 6503: } 6504: TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0; 6505: } 6506: 6507: /* Otherwise, create a prototype that would match. */ 6508: 6509: else 6510: { 1.1.1.7 root 6511: tree actual = 0, last = 0, type; 1.1 root 6512: 6513: for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm)) 6514: { 1.1.1.4 root 6515: type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), 6516: NULL_TREE); 1.1 root 6517: if (last) 6518: TREE_CHAIN (last) = type; 6519: else 6520: actual = type; 6521: last = type; 6522: } 1.1.1.4 root 6523: type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE); 1.1 root 6524: if (last) 6525: TREE_CHAIN (last) = type; 6526: else 6527: actual = type; 6528: 1.1.1.2 root 6529: /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES 6530: of the type of this function, but we need to avoid having this 6531: affect the types of other similarly-typed functions, so we must 6532: first force the generation of an identical (but separate) type 6533: node for the relevant function type. The new node we create 6534: will be a variant of the main variant of the original function 6535: type. */ 6536: 6537: TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl)); 6538: 1.1 root 6539: TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual; 6540: } 6541: 6542: /* Now store the final chain of decls for the arguments 6543: as the decl-chain of the current lexical scope. 6544: Put the enumerators in as well, at the front so that 6545: DECL_ARGUMENTS is not modified. */ 6546: 6547: storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl))); 6548: } 6549: 6550: /* Make sure the binding level for the top of the function body 6551: gets a BLOCK if there are any in the function. 6552: Otherwise, the dbx output is wrong. */ 6553: 6554: keep_next_if_subblocks = 1; 6555: 6556: /* ??? This might be an improvement, 6557: but needs to be thought about some more. */ 6558: #if 0 6559: keep_next_level_flag = 1; 6560: #endif 6561: 6562: /* Write a record describing this function definition to the prototypes 6563: file (if requested). */ 6564: 6565: gen_aux_info_record (fndecl, 1, 0, prototype); 6566: 6567: /* Initialize the RTL code for the function. */ 6568: 6569: init_function_start (fndecl, input_filename, lineno); 6570: 6571: /* If this is a varargs function, inform function.c. */ 6572: 6573: if (c_function_varargs) 6574: mark_varargs (); 6575: 1.1.1.3 root 6576: /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */ 6577: 6578: declare_function_name (); 6579: 1.1 root 6580: /* Set up parameters and prepare for return, for the function. */ 6581: 6582: expand_function_start (fndecl, 0); 6583: 6584: /* If this function is `main', emit a call to `__main' 6585: to run global initializers, etc. */ 6586: if (DECL_NAME (fndecl) 6587: && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0 6588: && DECL_CONTEXT (fndecl) == NULL_TREE) 6589: expand_main_function (); 6590: } 6591: 6592: /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes 6593: each with a parm name as the TREE_VALUE. A null pointer as TREE_VALUE 6594: stands for an ellipsis in the identifier list. 6595: 6596: PARMLIST is the data returned by get_parm_info for the 6597: parmlist that follows the semicolon. 6598: 6599: We return a value of the same sort that get_parm_info returns, 6600: except that it describes the combination of identifiers and parmlist. */ 6601: 6602: tree 6603: combine_parm_decls (specparms, parmlist, void_at_end) 6604: tree specparms, parmlist; 6605: int void_at_end; 6606: { 6607: register tree fndecl = current_function_decl; 6608: register tree parm; 6609: 6610: tree parmdecls = TREE_PURPOSE (parmlist); 6611: 6612: /* This is a chain of any other decls that came in among the parm 6613: declarations. They were separated already by get_parm_info, 6614: so we just need to keep them separate. */ 6615: tree nonparms = TREE_VALUE (parmlist); 6616: 6617: tree types = 0; 6618: 6619: for (parm = parmdecls; parm; parm = TREE_CHAIN (parm)) 6620: DECL_RESULT (parm) = 0; 6621: 6622: for (parm = specparms; parm; parm = TREE_CHAIN (parm)) 6623: { 6624: register tree tail, found = NULL; 6625: 6626: /* See if any of the parmdecls specifies this parm by name. */ 6627: for (tail = parmdecls; tail; tail = TREE_CHAIN (tail)) 6628: if (DECL_NAME (tail) == TREE_VALUE (parm)) 6629: { 6630: found = tail; 6631: break; 6632: } 6633: 6634: /* If declaration already marked, we have a duplicate name. 6635: Complain, and don't use this decl twice. */ 6636: if (found && DECL_RESULT (found) != 0) 6637: { 6638: error_with_decl (found, "multiple parameters named `%s'"); 6639: found = 0; 6640: } 6641: 6642: /* If the declaration says "void", complain and ignore it. */ 1.1.1.4 root 6643: if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node) 1.1 root 6644: { 6645: error_with_decl (found, "parameter `%s' declared void"); 6646: TREE_TYPE (found) = integer_type_node; 6647: DECL_ARG_TYPE (found) = integer_type_node; 6648: layout_decl (found, 0); 6649: } 6650: 6651: /* Traditionally, a parm declared float is actually a double. */ 6652: if (found && flag_traditional 1.1.1.4 root 6653: && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node) 1.1.1.5 root 6654: { 6655: TREE_TYPE (found) = double_type_node; 6656: DECL_ARG_TYPE (found) = double_type_node; 6657: layout_decl (found, 0); 6658: } 1.1 root 6659: 6660: /* If no declaration found, default to int. */ 6661: if (!found) 6662: { 6663: found = build_decl (PARM_DECL, TREE_VALUE (parm), 6664: integer_type_node); 6665: DECL_ARG_TYPE (found) = TREE_TYPE (found); 6666: DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl); 6667: DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl); 1.1.1.5 root 6668: error_with_decl (found, "type of parameter `%s' is not declared"); 1.1 root 6669: pushdecl (found); 6670: } 6671: 6672: TREE_PURPOSE (parm) = found; 6673: 6674: /* Mark this decl as "already found" -- see test, above. 6675: It is safe to use DECL_RESULT for this 6676: since it is not used in PARM_DECLs or CONST_DECLs. */ 6677: DECL_RESULT (found) = error_mark_node; 6678: } 6679: 6680: /* Complain about any actual PARM_DECLs not matched with any names. */ 6681: 6682: for (parm = parmdecls; parm; ) 6683: { 6684: tree next = TREE_CHAIN (parm); 6685: TREE_CHAIN (parm) = 0; 6686: 6687: /* Complain about args with incomplete types. */ 6688: if (TYPE_SIZE (TREE_TYPE (parm)) == 0) 6689: { 6690: error_with_decl (parm, "parameter `%s' has incomplete type"); 6691: TREE_TYPE (parm) = error_mark_node; 6692: } 6693: 6694: if (DECL_RESULT (parm) == 0) 6695: { 6696: error_with_decl (parm, 6697: "declaration for parameter `%s' but no such parameter"); 6698: /* Pretend the parameter was not missing. 6699: This gets us to a standard state and minimizes 6700: further error messages. */ 6701: specparms 6702: = chainon (specparms, 6703: tree_cons (parm, NULL_TREE, NULL_TREE)); 6704: } 6705: 6706: parm = next; 6707: } 6708: 6709: /* Chain the declarations together in the order of the list of names. 6710: At the same time, build up a list of their types, in reverse order. */ 6711: 6712: parm = specparms; 6713: parmdecls = 0; 6714: { 6715: register tree last; 6716: for (last = 0; parm; parm = TREE_CHAIN (parm)) 6717: if (TREE_PURPOSE (parm)) 6718: { 6719: if (last == 0) 6720: parmdecls = TREE_PURPOSE (parm); 6721: else 6722: TREE_CHAIN (last) = TREE_PURPOSE (parm); 6723: last = TREE_PURPOSE (parm); 6724: TREE_CHAIN (last) = 0; 6725: 6726: types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types); 6727: } 6728: } 6729: 6730: if (void_at_end) 6731: return saveable_tree_cons (parmdecls, nonparms, 6732: nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types))); 6733: 6734: return saveable_tree_cons (parmdecls, nonparms, nreverse (types)); 6735: } 6736: 6737: /* Finish up a function declaration and compile that function 6738: all the way to assembler language output. The free the storage 6739: for the function definition. 6740: 6741: This is called after parsing the body of the function definition. 6742: 6743: NESTED is nonzero if the function being finished is nested in another. */ 6744: 6745: void 6746: finish_function (nested) 6747: int nested; 6748: { 6749: register tree fndecl = current_function_decl; 6750: 6751: /* TREE_READONLY (fndecl) = 1; 6752: This caused &foo to be of type ptr-to-const-function 6753: which then got a warning when stored in a ptr-to-function variable. */ 6754: 6755: poplevel (1, 0, 1); 1.1.1.4 root 6756: BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; 1.1 root 6757: 6758: /* Must mark the RESULT_DECL as being in this function. */ 6759: 6760: DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; 6761: 6762: /* Obey `register' declarations if `setjmp' is called in this fn. */ 6763: if (flag_traditional && current_function_calls_setjmp) 6764: { 6765: setjmp_protect (DECL_INITIAL (fndecl)); 6766: setjmp_protect_args (); 6767: } 6768: 6769: #ifdef DEFAULT_MAIN_RETURN 6770: if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main")) 6771: { 1.1.1.4 root 6772: if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) 6773: != integer_type_node) 6774: warning_with_decl (fndecl, "return type of `%s' is not `int'"); 6775: else 6776: { 6777: /* Make it so that `main' always returns success by default. */ 6778: DEFAULT_MAIN_RETURN; 6779: } 1.1 root 6780: } 6781: #endif 6782: 6783: /* Generate rtl for function exit. */ 1.1.1.6 root 6784: expand_function_end (input_filename, lineno, 0); 1.1 root 6785: 6786: /* So we can tell if jump_optimize sets it to 1. */ 6787: can_reach_end = 0; 6788: 6789: /* Run the optimizers and output the assembler code for this function. */ 6790: rest_of_compilation (fndecl); 6791: 6792: current_function_returns_null |= can_reach_end; 6793: 6794: if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null) 1.1.1.7 root 6795: warning ("`noreturn' function does return"); 1.1.1.4 root 6796: else if (warn_return_type && can_reach_end 1.1 root 6797: && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node) 6798: /* If this function returns non-void and control can drop through, 6799: complain. */ 6800: warning ("control reaches end of non-void function"); 6801: /* With just -W, complain only if function returns both with 6802: and without a value. */ 6803: else if (extra_warnings 6804: && current_function_returns_value && current_function_returns_null) 6805: warning ("this function may return with or without a value"); 6806: 1.1.1.7 root 6807: /* If requested, warn about function definitions where the function will 6808: return a value (usually of some struct or union type) which itself will 6809: take up a lot of stack space. */ 6810: 6811: if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl)) 6812: { 6813: register tree ret_type = TREE_TYPE (TREE_TYPE (fndecl)); 6814: 6815: if (ret_type) 6816: { 6817: register tree ret_type_size = TYPE_SIZE (ret_type); 6818: 6819: if (TREE_CODE (ret_type_size) == INTEGER_CST) 6820: { 6821: unsigned units 6822: = TREE_INT_CST_LOW (ret_type_size) / BITS_PER_UNIT; 6823: 6824: if (units > larger_than_size) 6825: warning_with_decl (fndecl, 6826: "size of return value of `%s' is %u bytes", 6827: units); 6828: } 6829: } 6830: } 6831: 1.1 root 6832: /* Free all the tree nodes making up this function. */ 6833: /* Switch back to allocating nodes permanently 6834: until we start another function. */ 6835: if (! nested) 1.1.1.7 root 6836: permanent_allocation (1); 1.1 root 6837: 6838: if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested) 6839: { 6840: /* Stop pointing to the local nodes about to be freed. */ 6841: /* But DECL_INITIAL must remain nonzero so we know this 6842: was an actual function definition. */ 6843: /* For a nested function, this is done in pop_c_function_context. */ 1.1.1.6 root 6844: /* If rest_of_compilation set this to 0, leave it 0. */ 6845: if (DECL_INITIAL (fndecl) != 0) 6846: DECL_INITIAL (fndecl) = error_mark_node; 1.1 root 6847: DECL_ARGUMENTS (fndecl) = 0; 6848: } 6849: 1.1.1.8 ! root 6850: if (DECL_STATIC_CONSTRUCTOR (fndecl)) ! 6851: { ! 6852: #ifndef ASM_OUTPUT_CONSTRUCTOR ! 6853: if (! flag_gnu_linker) ! 6854: static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors); ! 6855: else ! 6856: #endif ! 6857: assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl))); ! 6858: } ! 6859: if (DECL_STATIC_DESTRUCTOR (fndecl)) ! 6860: { ! 6861: #ifndef ASM_OUTPUT_DESTRUCTOR ! 6862: if (! flag_gnu_linker) ! 6863: static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors); ! 6864: else ! 6865: #endif ! 6866: assemble_destructor (IDENTIFIER_POINTER (DECL_NAME (fndecl))); ! 6867: } ! 6868: 1.1 root 6869: if (! nested) 6870: { 6871: /* Let the error reporting routines know that we're outside a 6872: function. For a nested function, this value is used in 6873: pop_c_function_context and then reset via pop_function_context. */ 6874: current_function_decl = NULL; 6875: } 6876: } 6877: 6878: /* Save and restore the variables in this file and elsewhere 6879: that keep track of the progress of compilation of the current function. 6880: Used for nested functions. */ 6881: 6882: struct c_function 6883: { 6884: struct c_function *next; 6885: tree named_labels; 6886: tree shadowed_labels; 6887: int returns_value; 6888: int returns_null; 6889: int warn_about_return_type; 6890: int extern_inline; 6891: struct binding_level *binding_level; 6892: }; 6893: 6894: struct c_function *c_function_chain; 6895: 6896: /* Save and reinitialize the variables 6897: used during compilation of a C function. */ 6898: 6899: void 6900: push_c_function_context () 6901: { 6902: struct c_function *p 6903: = (struct c_function *) xmalloc (sizeof (struct c_function)); 6904: 1.1.1.3 root 6905: if (pedantic) 6906: pedwarn ("ANSI C forbids nested functions"); 6907: 1.1 root 6908: push_function_context (); 6909: 6910: p->next = c_function_chain; 6911: c_function_chain = p; 6912: 6913: p->named_labels = named_labels; 6914: p->shadowed_labels = shadowed_labels; 6915: p->returns_value = current_function_returns_value; 6916: p->returns_null = current_function_returns_null; 6917: p->warn_about_return_type = warn_about_return_type; 6918: p->extern_inline = current_extern_inline; 6919: p->binding_level = current_binding_level; 6920: } 6921: 6922: /* Restore the variables used during compilation of a C function. */ 6923: 6924: void 6925: pop_c_function_context () 6926: { 6927: struct c_function *p = c_function_chain; 6928: tree link; 6929: 6930: /* Bring back all the labels that were shadowed. */ 6931: for (link = shadowed_labels; link; link = TREE_CHAIN (link)) 6932: if (DECL_NAME (TREE_VALUE (link)) != 0) 6933: IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) 6934: = TREE_VALUE (link); 6935: 6936: if (DECL_SAVED_INSNS (current_function_decl) == 0) 6937: { 6938: /* Stop pointing to the local nodes about to be freed. */ 6939: /* But DECL_INITIAL must remain nonzero so we know this 6940: was an actual function definition. */ 6941: DECL_INITIAL (current_function_decl) = error_mark_node; 6942: DECL_ARGUMENTS (current_function_decl) = 0; 6943: } 6944: 6945: pop_function_context (); 6946: 6947: c_function_chain = p->next; 6948: 6949: named_labels = p->named_labels; 6950: shadowed_labels = p->shadowed_labels; 6951: current_function_returns_value = p->returns_value; 6952: current_function_returns_null = p->returns_null; 6953: warn_about_return_type = p->warn_about_return_type; 6954: current_extern_inline = p->extern_inline; 6955: current_binding_level = p->binding_level; 6956: 6957: free (p); 6958: } 1.1.1.7 root 6959: 6960: /* integrate_decl_tree calls this function, but since we don't use the 6961: DECL_LANG_SPECIFIC field, this is a no-op. */ 6962: 6963: void 6964: copy_lang_decl (node) 6965: tree node; 6966: { 6967: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.