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