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