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