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