decl2.c revision 56385
1/* Process declarations and variables for C compiler. 2 Copyright (C) 1988, 92-98, 1999 Free Software Foundation, Inc. 3 Hacked by Michael Tiemann (tiemann@cygnus.com) 4 5This file is part of GNU CC. 6 7GNU CC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GNU CC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU CC; see the file COPYING. If not, write to 19the Free Software Foundation, 59 Temple Place - Suite 330, 20Boston, MA 02111-1307, USA. */ 21 22 23/* Process declarations and symbol lookup for C front end. 24 Also constructs types; the standard scalar types at initialization, 25 and structure, union, array and enum types when they are declared. */ 26 27/* ??? not all decl nodes are given the most useful possible 28 line numbers. For example, the CONST_DECLs for enum values. */ 29 30#include "config.h" 31#include "system.h" 32#include "tree.h" 33#include "rtl.h" 34#include "flags.h" 35#include "cp-tree.h" 36#include "decl.h" 37#include "lex.h" 38#include "output.h" 39#include "except.h" 40#include "expr.h" 41#include "defaults.h" 42#include "toplev.h" 43#include "dwarf2out.h" 44#include "dwarfout.h" 45#include "splay-tree.h" 46#include "varray.h" 47 48#if USE_CPPLIB 49#include "cpplib.h" 50extern cpp_reader parse_in; 51#endif 52 53/* This structure contains information about the initializations 54 and/or destructions required for a particular priority level. */ 55typedef struct priority_info_s { 56 /* A label indicating where we should generate the next 57 initialization with this priority. */ 58 rtx initialization_sequence; 59 /* A label indicating where we should generate the next destruction 60 with this priority. */ 61 rtx destruction_sequence; 62 /* Non-zero if there have been any initializations at this priority 63 throughout the translation unit. */ 64 int initializations_p; 65 /* Non-zero if there have been any destructions at this priority 66 throughout the translation unit. */ 67 int destructions_p; 68} *priority_info; 69 70static tree get_sentry PROTO((tree)); 71static void mark_vtable_entries PROTO((tree)); 72static void grok_function_init PROTO((tree, tree)); 73static int finish_vtable_vardecl PROTO((tree *, void *)); 74static int prune_vtable_vardecl PROTO((tree *, void *)); 75static int finish_sigtable_vardecl PROTO((tree *, void *)); 76static int is_namespace_ancestor PROTO((tree, tree)); 77static void add_using_namespace PROTO((tree, tree, int)); 78static tree ambiguous_decl PROTO((tree, tree, tree,int)); 79static tree build_anon_union_vars PROTO((tree, tree*, int, int)); 80static int acceptable_java_type PROTO((tree)); 81static void output_vtable_inherit PROTO((tree)); 82static void start_objects PROTO((int, int)); 83static void finish_objects PROTO((int, int)); 84static tree merge_functions PROTO((tree, tree)); 85static tree decl_namespace PROTO((tree)); 86static tree validate_nonmember_using_decl PROTO((tree, tree *, tree *)); 87static void do_nonmember_using_decl PROTO((tree, tree, tree, tree, 88 tree *, tree *)); 89static void start_static_storage_duration_function PROTO((void)); 90static int generate_inits_for_priority PROTO((splay_tree_node, void *)); 91static void finish_static_storage_duration_function PROTO((void)); 92static priority_info get_priority_info PROTO((int)); 93static void do_static_initialization PROTO((tree, tree, tree, int)); 94static void do_static_destruction PROTO((tree, tree, int)); 95static void do_static_initialization_and_destruction PROTO((tree, tree)); 96static void generate_ctor_or_dtor_function PROTO((int, int)); 97static int generate_ctor_and_dtor_functions_for_priority 98 PROTO((splay_tree_node, void *)); 99extern int current_class_depth; 100 101/* A list of virtual function tables we must make sure to write out. */ 102tree pending_vtables; 103 104/* A list of static class variables. This is needed, because a 105 static class variable can be declared inside the class without 106 an initializer, and then initialized, staticly, outside the class. */ 107static varray_type pending_statics; 108static size_t pending_statics_used; 109 110/* A list of functions which were declared inline, but which we 111 may need to emit outline anyway. */ 112static varray_type saved_inlines; 113static size_t saved_inlines_used; 114 115/* Used to help generate temporary names which are unique within 116 a function. Reset to 0 by start_function. */ 117 118int temp_name_counter; 119 120/* Same, but not reset. Local temp variables and global temp variables 121 can have the same name. */ 122static int global_temp_name_counter; 123 124/* Flag used when debugging spew.c */ 125 126extern int spew_debug; 127 128/* Nonzero if we're done parsing and into end-of-file activities. */ 129 130int at_eof; 131 132/* Functions called along with real static constructors and destructors. */ 133 134tree static_ctors, static_dtors; 135 136/* The current open namespace, and ::. */ 137 138tree current_namespace; 139tree global_namespace; 140 141/* The stack for namespaces of current declarations. */ 142 143static tree decl_namespace_list; 144 145 146/* C (and C++) language-specific option variables. */ 147 148/* Nonzero means allow type mismatches in conditional expressions; 149 just make their values `void'. */ 150 151int flag_cond_mismatch; 152 153/* Nonzero means give `double' the same size as `float'. */ 154 155int flag_short_double; 156 157/* Nonzero means don't recognize the keyword `asm'. */ 158 159int flag_no_asm; 160 161/* Nonzero means don't recognize any extension keywords. */ 162 163int flag_no_gnu_keywords; 164 165/* Nonzero means don't recognize the non-ANSI builtin functions. */ 166 167int flag_no_builtin; 168 169/* Nonzero means don't recognize the non-ANSI builtin functions. 170 -ansi sets this. */ 171 172int flag_no_nonansi_builtin; 173 174/* Nonzero means do some things the same way PCC does. Only provided so 175 the compiler will link. */ 176 177int flag_traditional; 178 179/* Nonzero means to treat bitfields as unsigned unless they say `signed'. */ 180 181int flag_signed_bitfields = 1; 182 183/* Nonzero means enable obscure ANSI features and disable GNU extensions 184 that might cause ANSI-compliant code to be miscompiled. */ 185 186int flag_ansi; 187 188/* Nonzero means do emit exported implementations of functions even if 189 they can be inlined. */ 190 191int flag_implement_inlines = 1; 192 193/* Nonzero means do emit exported implementations of templates, instead of 194 multiple static copies in each file that needs a definition. */ 195 196int flag_external_templates; 197 198/* Nonzero means that the decision to emit or not emit the implementation of a 199 template depends on where the template is instantiated, rather than where 200 it is defined. */ 201 202int flag_alt_external_templates; 203 204/* Nonzero means that implicit instantiations will be emitted if needed. */ 205 206int flag_implicit_templates = 1; 207 208/* Nonzero means that implicit instantiations of inline templates will be 209 emitted if needed, even if instantiations of non-inline templates 210 aren't. */ 211 212int flag_implicit_inline_templates = 1; 213 214/* Nonzero means warn about implicit declarations. */ 215 216int warn_implicit = 1; 217 218/* Nonzero means warn about usage of long long when `-pedantic'. */ 219 220int warn_long_long = 1; 221 222/* Nonzero means warn when all ctors or dtors are private, and the class 223 has no friends. */ 224 225int warn_ctor_dtor_privacy = 1; 226 227/* True if we want to implement vtables using "thunks". 228 The default is off. */ 229 230#ifndef DEFAULT_VTABLE_THUNKS 231#define DEFAULT_VTABLE_THUNKS 0 232#endif 233int flag_vtable_thunks = DEFAULT_VTABLE_THUNKS; 234 235/* True if we want to deal with repository information. */ 236 237int flag_use_repository; 238 239/* Nonzero if we want to issue diagnostics that the standard says are not 240 required. */ 241 242int flag_optional_diags = 1; 243 244/* Nonzero means give string constants the type `const char *', as mandated 245 by the standard. */ 246 247int flag_const_strings = 1; 248 249/* Nonzero means warn about deprecated conversion from string constant to 250 `char *'. */ 251 252int warn_write_strings; 253 254/* Nonzero means warn about pointer casts that can drop a type qualifier 255 from the pointer target type. */ 256 257int warn_cast_qual; 258 259/* Nonzero means warn about sizeof(function) or addition/subtraction 260 of function pointers. */ 261 262int warn_pointer_arith = 1; 263 264/* Nonzero means warn for any function def without prototype decl. */ 265 266int warn_missing_prototypes; 267 268/* Nonzero means warn about multiple (redundant) decls for the same single 269 variable or function. */ 270 271int warn_redundant_decls; 272 273/* Warn if initializer is not completely bracketed. */ 274 275int warn_missing_braces; 276 277/* Warn about comparison of signed and unsigned values. */ 278 279int warn_sign_compare; 280 281/* Warn about *printf or *scanf format/argument anomalies. */ 282 283int warn_format; 284 285/* Warn about a subscript that has type char. */ 286 287int warn_char_subscripts; 288 289/* Warn if a type conversion is done that might have confusing results. */ 290 291int warn_conversion; 292 293/* Warn if adding () is suggested. */ 294 295int warn_parentheses; 296 297/* Non-zero means warn in function declared in derived class has the 298 same name as a virtual in the base class, but fails to match the 299 type signature of any virtual function in the base class. */ 300int warn_overloaded_virtual; 301 302/* Non-zero means warn when declaring a class that has a non virtual 303 destructor, when it really ought to have a virtual one. */ 304int warn_nonvdtor; 305 306/* Non-zero means warn when a function is declared extern and later inline. */ 307int warn_extern_inline; 308 309/* Non-zero means warn when the compiler will reorder code. */ 310int warn_reorder; 311 312/* Non-zero means warn when synthesis behavior differs from Cfront's. */ 313int warn_synth; 314 315/* Non-zero means warn when we convert a pointer to member function 316 into a pointer to (void or function). */ 317int warn_pmf2ptr = 1; 318 319/* Nonzero means warn about violation of some Effective C++ style rules. */ 320 321int warn_ecpp; 322 323/* Nonzero means warn where overload resolution chooses a promotion from 324 unsigned to signed over a conversion to an unsigned of the same size. */ 325 326int warn_sign_promo; 327 328/* Nonzero means warn when an old-style cast is used. */ 329 330int warn_old_style_cast; 331 332/* Warn about #pragma directives that are not recognised. */ 333 334int warn_unknown_pragmas; /* Tri state variable. */ 335 336/* Nonzero means warn about use of multicharacter literals. */ 337 338int warn_multichar = 1; 339 340/* Nonzero means warn when non-templatized friend functions are 341 declared within a template */ 342 343int warn_nontemplate_friend = 1; 344 345/* Nonzero means complain about deprecated features. */ 346 347int warn_deprecated = 1; 348 349/* Nonzero means `$' can be in an identifier. */ 350 351#ifndef DOLLARS_IN_IDENTIFIERS 352#define DOLLARS_IN_IDENTIFIERS 1 353#endif 354int dollars_in_ident = DOLLARS_IN_IDENTIFIERS; 355 356/* Nonzero for -fno-strict-prototype switch: do not consider empty 357 argument prototype to mean function takes no arguments. */ 358 359int flag_strict_prototype = 2; 360int strict_prototype = 1; 361int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus = 1; 362 363/* Nonzero means that labels can be used as first-class objects */ 364 365int flag_labels_ok; 366 367/* Non-zero means to collect statistics which might be expensive 368 and to print them when we are done. */ 369int flag_detailed_statistics; 370 371/* C++ specific flags. */ 372/* Zero means that `this' is a *const. This gives nice behavior in the 373 2.0 world. 1 gives 1.2-compatible behavior. 2 gives Spring behavior. 374 -2 means we're constructing an object and it has fixed type. */ 375 376int flag_this_is_variable; 377 378/* 3 means write out only virtuals function tables `defined' 379 in this implementation file. 380 0 means write out virtual function tables and give them 381 (C) static access (default). */ 382 383int write_virtuals; 384 385/* Nonzero means we should attempt to elide constructors when possible. */ 386 387int flag_elide_constructors = 1; 388 389/* Nonzero means recognize and handle signature language constructs. */ 390 391int flag_handle_signatures; 392 393/* Nonzero means that member functions defined in class scope are 394 inline by default. */ 395 396int flag_default_inline = 1; 397 398/* Controls whether compiler generates 'type descriptor' that give 399 run-time type information. */ 400int flag_rtti = 1; 401 402/* Nonzero if we wish to output cross-referencing information 403 for the GNU class browser. */ 404extern int flag_gnu_xref; 405 406/* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes) 407 objects. */ 408 409int flag_huge_objects; 410 411/* Nonzero if we want to conserve space in the .o files. We do this 412 by putting uninitialized data and runtime initialized data into 413 .common instead of .data at the expense of not flagging multiple 414 definitions. */ 415 416int flag_conserve_space; 417 418/* Nonzero if we want to obey access control semantics. */ 419 420int flag_access_control = 1; 421 422/* Nonzero if we want to understand the operator names, i.e. 'bitand'. */ 423 424int flag_operator_names; 425 426/* Nonzero if we want to check the return value of new and avoid calling 427 constructors if it is a null pointer. */ 428 429int flag_check_new; 430 431/* Nonzero if we want the new ANSI rules for pushing a new scope for `for' 432 initialization variables. 433 0: Old rules, set by -fno-for-scope. 434 2: New ANSI rules, set by -ffor-scope. 435 1: Try to implement new ANSI rules, but with backup compatibility 436 (and warnings). This is the default, for now. */ 437 438int flag_new_for_scope = 1; 439 440/* Nonzero if we want to emit defined symbols with common-like linkage as 441 weak symbols where possible, in order to conform to C++ semantics. 442 Otherwise, emit them as local symbols. */ 443 444int flag_weak = 1; 445 446/* Nonzero to enable experimental ABI changes. */ 447 448int flag_new_abi; 449 450/* Nonzero to not ignore namespace std. */ 451 452int flag_honor_std; 453 454/* Maximum template instantiation depth. Must be at least 17 for ANSI 455 compliance. */ 456 457int max_tinst_depth = 17; 458 459/* The name-mangling scheme to use. Must be 1 or greater to support 460 template functions with identical types, but different template 461 arguments. */ 462int name_mangling_version = 2; 463 464/* Nonzero means that guiding declarations are allowed. */ 465int flag_guiding_decls; 466 467/* Nonzero if squashed mangling is to be performed. 468 This uses the B and K codes to reference previously seen class types 469 and class qualifiers. */ 470int flag_do_squangling; 471 472/* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */ 473 474int flag_vtable_gc; 475 476/* Nonzero means make the default pedwarns warnings instead of errors. 477 The value of this flag is ignored if -pedantic is specified. */ 478 479int flag_permissive; 480 481/* Table of language-dependent -f options. 482 STRING is the option name. VARIABLE is the address of the variable. 483 ON_VALUE is the value to store in VARIABLE 484 if `-fSTRING' is seen as an option. 485 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */ 486 487static struct { const char *string; int *variable; int on_value;} 488lang_f_options[] = 489{ 490 /* C/C++ options. */ 491 {"signed-char", &flag_signed_char, 1}, 492 {"unsigned-char", &flag_signed_char, 0}, 493 {"signed-bitfields", &flag_signed_bitfields, 1}, 494 {"unsigned-bitfields", &flag_signed_bitfields, 0}, 495 {"short-enums", &flag_short_enums, 1}, 496 {"short-double", &flag_short_double, 1}, 497 {"cond-mismatch", &flag_cond_mismatch, 1}, 498 {"asm", &flag_no_asm, 0}, 499 {"builtin", &flag_no_builtin, 0}, 500 501 /* C++-only options. */ 502 {"access-control", &flag_access_control, 1}, 503 {"check-new", &flag_check_new, 1}, 504 {"conserve-space", &flag_conserve_space, 1}, 505 {"const-strings", &flag_const_strings, 1}, 506 {"default-inline", &flag_default_inline, 1}, 507 {"dollars-in-identifiers", &dollars_in_ident, 1}, 508 {"elide-constructors", &flag_elide_constructors, 1}, 509 {"external-templates", &flag_external_templates, 1}, 510 {"for-scope", &flag_new_for_scope, 2}, 511 {"gnu-keywords", &flag_no_gnu_keywords, 0}, 512 {"handle-exceptions", &flag_exceptions, 1}, 513 {"handle-signatures", &flag_handle_signatures, 1}, 514 {"honor-std", &flag_honor_std, 1}, 515 {"huge-objects", &flag_huge_objects, 1}, 516 {"implement-inlines", &flag_implement_inlines, 1}, 517 {"implicit-inline-templates", &flag_implicit_inline_templates, 1}, 518 {"implicit-templates", &flag_implicit_templates, 1}, 519 {"labels-ok", &flag_labels_ok, 1}, 520 {"nonansi-builtins", &flag_no_nonansi_builtin, 0}, 521 {"operator-names", &flag_operator_names, 1}, 522 {"optional-diags", &flag_optional_diags, 1}, 523 {"permissive", &flag_permissive, 1}, 524 {"repo", &flag_use_repository, 1}, 525 {"rtti", &flag_rtti, 1}, 526 {"squangle", &flag_do_squangling, 1}, 527 {"stats", &flag_detailed_statistics, 1}, 528 {"strict-prototype", &flag_strict_prototype, 1}, 529 {"this-is-variable", &flag_this_is_variable, 1}, 530 {"vtable-gc", &flag_vtable_gc, 1}, 531 {"vtable-thunks", &flag_vtable_thunks, 1}, 532 {"weak", &flag_weak, 1}, 533 {"xref", &flag_gnu_xref, 1} 534}; 535 536/* Decode the string P as a language-specific option. 537 Return the number of strings consumed for a valid option. 538 Otherwise return 0. */ 539 540int 541lang_decode_option (argc, argv) 542 int argc 543#if !USE_CPPLIB 544 ATTRIBUTE_UNUSED 545#endif 546 ; 547 char **argv; 548 549{ 550 int strings_processed; 551 char *p = argv[0]; 552#if USE_CPPLIB 553 strings_processed = cpp_handle_option (&parse_in, argc, argv); 554#else 555 strings_processed = 0; 556#endif /* ! USE_CPPLIB */ 557 558 if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional")) 559 /* ignore */; 560 else if (p[0] == '-' && p[1] == 'f') 561 { 562 /* Some kind of -f option. 563 P's value is the option sans `-f'. 564 Search for it in the table of options. */ 565 int found = 0; 566 size_t j; 567 568 p += 2; 569 /* Try special -f options. */ 570 571 if (!strcmp (p, "handle-exceptions") 572 || !strcmp (p, "no-handle-exceptions")) 573 warning ("-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)"); 574 575 if (!strcmp (p, "memoize-lookups") 576 || !strcmp (p, "no-memoize-lookups") 577 || !strcmp (p, "save-memoized") 578 || !strcmp (p, "no-save-memoized") 579 || !strcmp (p, "no-all-virtual") 580 || !strcmp (p, "no-enum-int-equiv") 581 || !strcmp (p, "nonnull-objects") 582 || !strcmp (p, "ansi-overloading")) 583 { 584 /* ignore */ 585 found = 1; 586 } 587 else if (!strcmp (p, "all-virtual") 588 || !strcmp (p, "enum-int-equiv") 589 || !strcmp (p, "no-nonnull-objects") 590 || !strcmp (p, "no-ansi-overloading")) 591 { 592 warning ("-f%s is no longer supported", p); 593 found = 1; 594 } 595 else if (! strcmp (p, "alt-external-templates")) 596 { 597 flag_external_templates = 1; 598 flag_alt_external_templates = 1; 599 found = 1; 600 cp_deprecated ("-falt-external-templates"); 601 } 602 else if (! strcmp (p, "no-alt-external-templates")) 603 { 604 flag_alt_external_templates = 0; 605 found = 1; 606 } 607 else if (!strcmp (p, "repo")) 608 { 609 flag_use_repository = 1; 610 flag_implicit_templates = 0; 611 found = 1; 612 } 613 else if (!strcmp (p, "guiding-decls")) 614 { 615 flag_guiding_decls = 1; 616 name_mangling_version = 0; 617 found = 1; 618 } 619 else if (!strcmp (p, "no-guiding-decls")) 620 { 621 flag_guiding_decls = 0; 622 found = 1; 623 } 624 else if (!strcmp (p, "this-is-variable")) 625 { 626 flag_this_is_variable = 1; 627 found = 1; 628 cp_deprecated ("-fthis-is-variable"); 629 } 630 else if (!strcmp (p, "external-templates")) 631 { 632 flag_external_templates = 1; 633 found = 1; 634 cp_deprecated ("-fexternal-templates"); 635 } 636 else if (!strcmp (p, "handle-signatures")) 637 { 638 flag_handle_signatures = 1; 639 found = 1; 640 cp_deprecated ("-fhandle-signatures"); 641 } 642 else if (!strcmp (p, "new-abi")) 643 { 644 flag_new_abi = 1; 645 flag_do_squangling = 1; 646 flag_honor_std = 1; 647 flag_vtable_thunks = 1; 648 } 649 else if (!strcmp (p, "no-new-abi")) 650 { 651 flag_new_abi = 0; 652 flag_do_squangling = 0; 653 flag_honor_std = 0; 654 } 655 else if (!strncmp (p, "template-depth-", 15)) 656 { 657 max_tinst_depth = 658 read_integral_parameter (p + 15, p - 2, max_tinst_depth); 659 } 660 else if (!strncmp (p, "name-mangling-version-", 22)) 661 { 662 name_mangling_version = 663 read_integral_parameter (p + 22, p - 2, name_mangling_version); 664 } 665 else for (j = 0; 666 !found && j < sizeof (lang_f_options) / sizeof (lang_f_options[0]); 667 j++) 668 { 669 if (!strcmp (p, lang_f_options[j].string)) 670 { 671 *lang_f_options[j].variable = lang_f_options[j].on_value; 672 /* A goto here would be cleaner, 673 but breaks the vax pcc. */ 674 found = 1; 675 } 676 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-' 677 && ! strcmp (p+3, lang_f_options[j].string)) 678 { 679 *lang_f_options[j].variable = ! lang_f_options[j].on_value; 680 found = 1; 681 } 682 } 683 return found; 684 } 685 else if (p[0] == '-' && p[1] == 'W') 686 { 687 int setting = 1; 688 689 /* The -W options control the warning behavior of the compiler. */ 690 p += 2; 691 692 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-') 693 setting = 0, p += 3; 694 695 if (!strcmp (p, "implicit")) 696 warn_implicit = setting; 697 else if (!strcmp (p, "long-long")) 698 warn_long_long = setting; 699 else if (!strcmp (p, "return-type")) 700 warn_return_type = setting; 701 else if (!strcmp (p, "ctor-dtor-privacy")) 702 warn_ctor_dtor_privacy = setting; 703 else if (!strcmp (p, "write-strings")) 704 warn_write_strings = setting; 705 else if (!strcmp (p, "cast-qual")) 706 warn_cast_qual = setting; 707 else if (!strcmp (p, "char-subscripts")) 708 warn_char_subscripts = setting; 709 else if (!strcmp (p, "pointer-arith")) 710 warn_pointer_arith = setting; 711 else if (!strcmp (p, "missing-prototypes")) 712 warn_missing_prototypes = setting; 713 else if (!strcmp (p, "redundant-decls")) 714 warn_redundant_decls = setting; 715 else if (!strcmp (p, "missing-braces")) 716 warn_missing_braces = setting; 717 else if (!strcmp (p, "sign-compare")) 718 warn_sign_compare = setting; 719 else if (!strcmp (p, "format")) 720 warn_format = setting; 721 else if (!strcmp (p, "conversion")) 722 warn_conversion = setting; 723 else if (!strcmp (p, "parentheses")) 724 warn_parentheses = setting; 725 else if (!strcmp (p, "non-virtual-dtor")) 726 warn_nonvdtor = setting; 727 else if (!strcmp (p, "extern-inline")) 728 warn_extern_inline = setting; 729 else if (!strcmp (p, "reorder")) 730 warn_reorder = setting; 731 else if (!strcmp (p, "synth")) 732 warn_synth = setting; 733 else if (!strcmp (p, "pmf-conversions")) 734 warn_pmf2ptr = setting; 735 else if (!strcmp (p, "effc++")) 736 warn_ecpp = setting; 737 else if (!strcmp (p, "sign-promo")) 738 warn_sign_promo = setting; 739 else if (!strcmp (p, "old-style-cast")) 740 warn_old_style_cast = setting; 741 else if (!strcmp (p, "overloaded-virtual")) 742 warn_overloaded_virtual = setting; 743 else if (!strcmp (p, "multichar")) 744 warn_multichar = setting; 745 else if (!strcmp (p, "unknown-pragmas")) 746 /* Set to greater than 1, so that even unknown pragmas in 747 system headers will be warned about. */ 748 warn_unknown_pragmas = setting * 2; 749 else if (!strcmp (p, "non-template-friend")) 750 warn_nontemplate_friend = setting; 751 else if (!strcmp (p, "deprecated")) 752 warn_deprecated = setting; 753 else if (!strcmp (p, "comment")) 754 ; /* cpp handles this one. */ 755 else if (!strcmp (p, "comments")) 756 ; /* cpp handles this one. */ 757 else if (!strcmp (p, "trigraphs")) 758 ; /* cpp handles this one. */ 759 else if (!strcmp (p, "import")) 760 ; /* cpp handles this one. */ 761 else if (!strcmp (p, "all")) 762 { 763 warn_return_type = setting; 764 warn_unused = setting; 765 warn_implicit = setting; 766 warn_switch = setting; 767 warn_format = setting; 768 warn_parentheses = setting; 769 warn_missing_braces = setting; 770 warn_sign_compare = setting; 771 warn_multichar = setting; 772 /* We save the value of warn_uninitialized, since if they put 773 -Wuninitialized on the command line, we need to generate a 774 warning about not using it without also specifying -O. */ 775 if (warn_uninitialized != 1) 776 warn_uninitialized = (setting ? 2 : 0); 777 /* Only warn about unknown pragmas that are not in system 778 headers. */ 779 warn_unknown_pragmas = 1; 780 781 /* C++-specific warnings. */ 782 warn_ctor_dtor_privacy = setting; 783 warn_nonvdtor = setting; 784 warn_reorder = setting; 785 warn_nontemplate_friend = setting; 786 } 787 else return strings_processed; 788 } 789 else if (!strcmp (p, "-ansi")) 790 flag_no_nonansi_builtin = 1, flag_ansi = 1, 791 flag_no_gnu_keywords = 1, flag_operator_names = 1; 792#ifdef SPEW_DEBUG 793 /* Undocumented, only ever used when you're invoking cc1plus by hand, since 794 it's probably safe to assume no sane person would ever want to use this 795 under normal circumstances. */ 796 else if (!strcmp (p, "-spew-debug")) 797 spew_debug = 1; 798#endif 799 else 800 return strings_processed; 801 802 return 1; 803} 804 805/* Incorporate `const' and `volatile' qualifiers for member functions. 806 FUNCTION is a TYPE_DECL or a FUNCTION_DECL. 807 QUALS is a list of qualifiers. */ 808 809tree 810grok_method_quals (ctype, function, quals) 811 tree ctype, function, quals; 812{ 813 tree fntype = TREE_TYPE (function); 814 tree raises = TYPE_RAISES_EXCEPTIONS (fntype); 815 int type_quals = TYPE_UNQUALIFIED; 816 int dup_quals = TYPE_UNQUALIFIED; 817 818 do 819 { 820 int tq = cp_type_qual_from_rid (TREE_VALUE (quals)); 821 822 if (type_quals & tq) 823 dup_quals |= tq; 824 else 825 type_quals |= tq; 826 quals = TREE_CHAIN (quals); 827 } 828 while (quals); 829 830 if (dup_quals != TYPE_UNQUALIFIED) 831 cp_error ("duplicate type qualifiers in %s declaration", 832 TREE_CODE (function) == FUNCTION_DECL 833 ? "member function" : "type"); 834 835 ctype = cp_build_qualified_type (ctype, type_quals); 836 fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype), 837 (TREE_CODE (fntype) == METHOD_TYPE 838 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype)) 839 : TYPE_ARG_TYPES (fntype))); 840 if (raises) 841 fntype = build_exception_variant (fntype, raises); 842 843 TREE_TYPE (function) = fntype; 844 return ctype; 845} 846 847/* Warn when -fexternal-templates is used and #pragma 848 interface/implementation is not used all the times it should be, 849 inform the user. */ 850 851void 852warn_if_unknown_interface (decl) 853 tree decl; 854{ 855 static int already_warned = 0; 856 if (already_warned++) 857 return; 858 859 if (flag_alt_external_templates) 860 { 861 struct tinst_level *til = tinst_for_decl (); 862 int sl = lineno; 863 char *sf = input_filename; 864 865 if (til) 866 { 867 lineno = til->line; 868 input_filename = til->file; 869 } 870 cp_warning ("template `%#D' instantiated in file without #pragma interface", 871 decl); 872 lineno = sl; 873 input_filename = sf; 874 } 875 else 876 cp_warning_at ("template `%#D' defined in file without #pragma interface", 877 decl); 878} 879 880/* A subroutine of the parser, to handle a component list. */ 881 882void 883grok_x_components (specs) 884 tree specs; 885{ 886 struct pending_inline **p; 887 tree t; 888 889 specs = strip_attrs (specs); 890 891 check_tag_decl (specs); 892 t = groktypename (build_decl_list (specs, NULL_TREE)); 893 894 /* The only case where we need to do anything additional here is an 895 anonymous union field, e.g.: `struct S { union { int i; }; };'. */ 896 if (t == NULL_TREE || !ANON_UNION_TYPE_P (t)) 897 return; 898 899 fixup_anonymous_union (t); 900 finish_member_declaration (build_lang_field_decl (FIELD_DECL, 901 NULL_TREE, 902 t)); 903 904 /* Ignore any inline function definitions in the anonymous union 905 since an anonymous union may not have function members. */ 906 p = &pending_inlines; 907 for (; *p; *p = (*p)->next) 908 if (DECL_CONTEXT ((*p)->fndecl) != t) 909 break; 910} 911 912/* Constructors for types with virtual baseclasses need an "in-charge" flag 913 saying whether this constructor is responsible for initialization of 914 virtual baseclasses or not. All destructors also need this "in-charge" 915 flag, which additionally determines whether or not the destructor should 916 free the memory for the object. 917 918 This function adds the "in-charge" flag to member function FN if 919 appropriate. It is called from grokclassfn and tsubst. 920 FN must be either a constructor or destructor. */ 921 922void 923maybe_retrofit_in_chrg (fn) 924 tree fn; 925{ 926 tree basetype, arg_types, parms, parm, fntype; 927 928 if (DECL_CONSTRUCTOR_P (fn) 929 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CLASS_CONTEXT (fn)) 930 && ! DECL_CONSTRUCTOR_FOR_VBASE_P (fn)) 931 /* OK */; 932 else if (! DECL_CONSTRUCTOR_P (fn) 933 && TREE_CHAIN (DECL_ARGUMENTS (fn)) == NULL_TREE) 934 /* OK */; 935 else 936 return; 937 938 if (DECL_CONSTRUCTOR_P (fn)) 939 DECL_CONSTRUCTOR_FOR_VBASE_P (fn) = 1; 940 941 /* First add it to DECL_ARGUMENTS... */ 942 parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node); 943 /* Mark the artificial `__in_chrg' parameter as "artificial". */ 944 SET_DECL_ARTIFICIAL (parm); 945 DECL_ARG_TYPE (parm) = integer_type_node; 946 TREE_READONLY (parm) = 1; 947 parms = DECL_ARGUMENTS (fn); 948 TREE_CHAIN (parm) = TREE_CHAIN (parms); 949 TREE_CHAIN (parms) = parm; 950 951 /* ...and then to TYPE_ARG_TYPES. */ 952 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); 953 basetype = TREE_TYPE (TREE_VALUE (arg_types)); 954 arg_types = hash_tree_chain (integer_type_node, TREE_CHAIN (arg_types)); 955 fntype = build_cplus_method_type (basetype, TREE_TYPE (TREE_TYPE (fn)), 956 arg_types); 957 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))) 958 fntype = build_exception_variant (fntype, 959 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))); 960 TREE_TYPE (fn) = fntype; 961} 962 963/* Classes overload their constituent function names automatically. 964 When a function name is declared in a record structure, 965 its name is changed to it overloaded name. Since names for 966 constructors and destructors can conflict, we place a leading 967 '$' for destructors. 968 969 CNAME is the name of the class we are grokking for. 970 971 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'. 972 973 FLAGS contains bits saying what's special about today's 974 arguments. 1 == DESTRUCTOR. 2 == OPERATOR. 975 976 If FUNCTION is a destructor, then we must add the `auto-delete' field 977 as a second parameter. There is some hair associated with the fact 978 that we must "declare" this variable in the manner consistent with the 979 way the rest of the arguments were declared. 980 981 QUALS are the qualifiers for the this pointer. */ 982 983void 984grokclassfn (ctype, function, flags, quals) 985 tree ctype, function; 986 enum overload_flags flags; 987 tree quals; 988{ 989 tree fn_name = DECL_NAME (function); 990 tree arg_types; 991 tree parm; 992 tree qualtype; 993 994 if (fn_name == NULL_TREE) 995 { 996 error ("name missing for member function"); 997 fn_name = get_identifier ("<anonymous>"); 998 DECL_NAME (function) = fn_name; 999 } 1000 1001 if (quals) 1002 qualtype = grok_method_quals (ctype, function, quals); 1003 else 1004 qualtype = ctype; 1005 1006 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function)); 1007 if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) 1008 { 1009 /* Must add the class instance variable up front. */ 1010 /* Right now we just make this a pointer. But later 1011 we may wish to make it special. */ 1012 tree type = TREE_VALUE (arg_types); 1013 int constp = 1; 1014 1015 if ((flag_this_is_variable > 0) 1016 && (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))) 1017 constp = 0; 1018 1019 parm = build_decl (PARM_DECL, this_identifier, type); 1020 /* Mark the artificial `this' parameter as "artificial". */ 1021 SET_DECL_ARTIFICIAL (parm); 1022 DECL_ARG_TYPE (parm) = type; 1023 /* We can make this a register, so long as we don't 1024 accidentally complain if someone tries to take its address. */ 1025 DECL_REGISTER (parm) = 1; 1026 if (constp) 1027 TREE_READONLY (parm) = 1; 1028 TREE_CHAIN (parm) = last_function_parms; 1029 last_function_parms = parm; 1030 } 1031 1032 DECL_ARGUMENTS (function) = last_function_parms; 1033 /* First approximations. */ 1034 DECL_CONTEXT (function) = ctype; 1035 DECL_CLASS_CONTEXT (function) = ctype; 1036 1037 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function)) 1038 { 1039 maybe_retrofit_in_chrg (function); 1040 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function)); 1041 } 1042 1043 if (flags == DTOR_FLAG) 1044 { 1045 DECL_ASSEMBLER_NAME (function) = build_destructor_name (ctype); 1046 TYPE_HAS_DESTRUCTOR (ctype) = 1; 1047 } 1048 else 1049 set_mangled_name_for_decl (function); 1050} 1051 1052/* Work on the expr used by alignof (this is only called by the parser). */ 1053 1054tree 1055grok_alignof (expr) 1056 tree expr; 1057{ 1058 tree best, t; 1059 int bestalign; 1060 1061 if (processing_template_decl) 1062 return build_min (ALIGNOF_EXPR, sizetype, expr); 1063 1064 if (TREE_CODE (expr) == COMPONENT_REF 1065 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1))) 1066 error ("`__alignof__' applied to a bit-field"); 1067 1068 if (TREE_CODE (expr) == INDIRECT_REF) 1069 { 1070 best = t = TREE_OPERAND (expr, 0); 1071 bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 1072 1073 while (TREE_CODE (t) == NOP_EXPR 1074 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE) 1075 { 1076 int thisalign; 1077 t = TREE_OPERAND (t, 0); 1078 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 1079 if (thisalign > bestalign) 1080 best = t, bestalign = thisalign; 1081 } 1082 return c_alignof (TREE_TYPE (TREE_TYPE (best))); 1083 } 1084 else 1085 { 1086 /* ANSI says arrays and fns are converted inside comma. 1087 But we can't convert them in build_compound_expr 1088 because that would break commas in lvalues. 1089 So do the conversion here if operand was a comma. */ 1090 if (TREE_CODE (expr) == COMPOUND_EXPR 1091 && (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE 1092 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)) 1093 expr = default_conversion (expr); 1094 return c_alignof (TREE_TYPE (expr)); 1095 } 1096} 1097 1098/* Create an ARRAY_REF, checking for the user doing things backwards 1099 along the way. */ 1100 1101tree 1102grok_array_decl (array_expr, index_exp) 1103 tree array_expr, index_exp; 1104{ 1105 tree type = TREE_TYPE (array_expr); 1106 tree p1, p2, i1, i2; 1107 1108 if (type == error_mark_node || index_exp == error_mark_node) 1109 return error_mark_node; 1110 if (processing_template_decl) 1111 return build_min (ARRAY_REF, type ? TREE_TYPE (type) : NULL_TREE, 1112 array_expr, index_exp); 1113 1114 if (type == NULL_TREE) 1115 { 1116 /* Something has gone very wrong. Assume we are mistakenly reducing 1117 an expression instead of a declaration. */ 1118 error ("parser may be lost: is there a '{' missing somewhere?"); 1119 return NULL_TREE; 1120 } 1121 1122 if (TREE_CODE (type) == OFFSET_TYPE 1123 || TREE_CODE (type) == REFERENCE_TYPE) 1124 type = TREE_TYPE (type); 1125 1126 /* If they have an `operator[]', use that. */ 1127 if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp))) 1128 return build_opfncall (ARRAY_REF, LOOKUP_NORMAL, 1129 array_expr, index_exp, NULL_TREE); 1130 1131 /* Otherwise, create an ARRAY_REF for a pointer or array type. It 1132 is a little-known fact that, if `a' is an array and `i' is an 1133 int, you can write `i[a]', which means the same thing as `a[i]'. */ 1134 1135 if (TREE_CODE (type) == ARRAY_TYPE) 1136 p1 = array_expr; 1137 else 1138 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, 0); 1139 1140 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE) 1141 p2 = index_exp; 1142 else 1143 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, 0); 1144 1145 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 0); 1146 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 0); 1147 1148 if ((p1 && i2) && (i1 && p2)) 1149 error ("ambiguous conversion for array subscript"); 1150 1151 if (p1 && i2) 1152 array_expr = p1, index_exp = i2; 1153 else if (i1 && p2) 1154 array_expr = p2, index_exp = i1; 1155 else 1156 { 1157 cp_error ("invalid types `%T[%T]' for array subscript", 1158 type, TREE_TYPE (index_exp)); 1159 return error_mark_node; 1160 } 1161 1162 if (array_expr == error_mark_node || index_exp == error_mark_node) 1163 error ("ambiguous conversion for array subscript"); 1164 1165 return build_array_ref (array_expr, index_exp); 1166} 1167 1168/* Given the cast expression EXP, checking out its validity. Either return 1169 an error_mark_node if there was an unavoidable error, return a cast to 1170 void for trying to delete a pointer w/ the value 0, or return the 1171 call to delete. If DOING_VEC is 1, we handle things differently 1172 for doing an array delete. If DOING_VEC is 2, they gave us the 1173 array size as an argument to delete. 1174 Implements ARM $5.3.4. This is called from the parser. */ 1175 1176tree 1177delete_sanity (exp, size, doing_vec, use_global_delete) 1178 tree exp, size; 1179 int doing_vec, use_global_delete; 1180{ 1181 tree t, type; 1182 /* For a regular vector delete (aka, no size argument) we will pass 1183 this down as a NULL_TREE into build_vec_delete. */ 1184 tree maxindex = NULL_TREE; 1185 1186 if (exp == error_mark_node) 1187 return exp; 1188 1189 if (processing_template_decl) 1190 { 1191 t = build_min (DELETE_EXPR, void_type_node, exp, size); 1192 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete; 1193 DELETE_EXPR_USE_VEC (t) = doing_vec; 1194 return t; 1195 } 1196 1197 if (TREE_CODE (exp) == OFFSET_REF) 1198 exp = resolve_offset_ref (exp); 1199 exp = convert_from_reference (exp); 1200 t = stabilize_reference (exp); 1201 t = build_expr_type_conversion (WANT_POINTER, t, 1); 1202 1203 if (t == NULL_TREE || t == error_mark_node) 1204 { 1205 cp_error ("type `%#T' argument given to `delete', expected pointer", 1206 TREE_TYPE (exp)); 1207 return error_mark_node; 1208 } 1209 1210 if (doing_vec == 2) 1211 { 1212 maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node); 1213 pedwarn ("anachronistic use of array size in vector delete"); 1214 } 1215 1216 type = TREE_TYPE (t); 1217 1218 /* As of Valley Forge, you can delete a pointer to const. */ 1219 1220 /* You can't delete functions. */ 1221 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 1222 { 1223 error ("cannot delete a function"); 1224 return error_mark_node; 1225 } 1226 1227 /* Deleting ptr to void is undefined behaviour [expr.delete/3]. */ 1228 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE) 1229 cp_warning ("`%T' is not a pointer-to-object type", type); 1230 1231 /* An array can't have been allocated by new, so complain. */ 1232 if (TREE_CODE (t) == ADDR_EXPR 1233 && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL 1234 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE) 1235 cp_warning ("deleting array `%#D'", TREE_OPERAND (t, 0)); 1236 1237 /* Deleting a pointer with the value zero is valid and has no effect. */ 1238 if (integer_zerop (t)) 1239 return build1 (NOP_EXPR, void_type_node, t); 1240 1241 if (doing_vec) 1242 return build_vec_delete (t, maxindex, integer_one_node, 1243 integer_zero_node, use_global_delete); 1244 else 1245 { 1246 if (IS_AGGR_TYPE (TREE_TYPE (type)) 1247 && TYPE_GETS_REG_DELETE (TREE_TYPE (type))) 1248 { 1249 /* Only do access checking here; we'll be calling op delete 1250 from the destructor. */ 1251 tree tmp = build_op_delete_call (DELETE_EXPR, t, size_zero_node, 1252 LOOKUP_NORMAL, NULL_TREE); 1253 if (tmp == error_mark_node) 1254 return error_mark_node; 1255 } 1256 1257 return build_delete (type, t, integer_three_node, 1258 LOOKUP_NORMAL, use_global_delete); 1259 } 1260} 1261 1262/* Report an error if the indicated template declaration is not the 1263 sort of thing that should be a member template. */ 1264 1265void 1266check_member_template (tmpl) 1267 tree tmpl; 1268{ 1269 tree decl; 1270 1271 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); 1272 decl = DECL_TEMPLATE_RESULT (tmpl); 1273 1274 if (TREE_CODE (decl) == FUNCTION_DECL 1275 || (TREE_CODE (decl) == TYPE_DECL 1276 && IS_AGGR_TYPE (TREE_TYPE (decl)))) 1277 { 1278 if (current_function_decl) 1279 /* 14.5.2.2 [temp.mem] 1280 1281 A local class shall not have member templates. */ 1282 cp_error ("declaration of member template `%#D' in local class", 1283 decl); 1284 1285 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl)) 1286 { 1287 /* 14.5.2.3 [temp.mem] 1288 1289 A member function template shall not be virtual. */ 1290 cp_error 1291 ("invalid use of `virtual' in template declaration of `%#D'", 1292 decl); 1293 DECL_VIRTUAL_P (decl) = 0; 1294 } 1295 1296 /* The debug-information generating code doesn't know what to do 1297 with member templates. */ 1298 DECL_IGNORED_P (tmpl) = 1; 1299 } 1300 else 1301 cp_error ("template declaration of `%#D'", decl); 1302} 1303 1304/* Return true iff TYPE is a valid Java parameter or return type. */ 1305 1306static int 1307acceptable_java_type (type) 1308 tree type; 1309{ 1310 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type)) 1311 return 1; 1312 if (TREE_CODE (type) == POINTER_TYPE) 1313 { 1314 type = TREE_TYPE (type); 1315 if (TREE_CODE (type) == RECORD_TYPE) 1316 { 1317 tree args; int i; 1318 if (! TYPE_FOR_JAVA (type)) 1319 return 0; 1320 if (! CLASSTYPE_TEMPLATE_INFO (type)) 1321 return 1; 1322 args = CLASSTYPE_TI_ARGS (type); 1323 i = TREE_VEC_LENGTH (args); 1324 while (--i >= 0) 1325 { 1326 type = TREE_VEC_ELT (args, i); 1327 if (TREE_CODE (type) == POINTER_TYPE) 1328 type = TREE_TYPE (type); 1329 if (! TYPE_FOR_JAVA (type)) 1330 return 0; 1331 } 1332 return 1; 1333 } 1334 } 1335 return 0; 1336} 1337 1338/* For a METHOD in a Java class CTYPE, return 1 if 1339 the parameter and return types are valid Java types. 1340 Otherwise, print appropriate error messages, and return 0. */ 1341 1342int 1343check_java_method (method) 1344 tree method; 1345{ 1346 int jerr = 0; 1347 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method)); 1348 tree ret_type = TREE_TYPE (TREE_TYPE (method)); 1349 if (! acceptable_java_type (ret_type)) 1350 { 1351 cp_error ("Java method '%D' has non-Java return type `%T'", 1352 method, ret_type); 1353 jerr++; 1354 } 1355 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types)) 1356 { 1357 tree type = TREE_VALUE (arg_types); 1358 if (! acceptable_java_type (type)) 1359 { 1360 cp_error ("Java method '%D' has non-Java parameter type `%T'", 1361 method, type); 1362 jerr++; 1363 } 1364 } 1365 return jerr ? 0 : 1; 1366} 1367 1368/* Sanity check: report error if this function FUNCTION is not 1369 really a member of the class (CTYPE) it is supposed to belong to. 1370 CNAME is the same here as it is for grokclassfn above. */ 1371 1372tree 1373check_classfn (ctype, function) 1374 tree ctype, function; 1375{ 1376 tree fn_name = DECL_NAME (function); 1377 tree fndecl, fndecls; 1378 tree method_vec = CLASSTYPE_METHOD_VEC (complete_type (ctype)); 1379 tree *methods = 0; 1380 tree *end = 0; 1381 1382 if (DECL_USE_TEMPLATE (function) 1383 && is_member_template (DECL_TI_TEMPLATE (function))) 1384 /* Since this is a specialization of a member template, 1385 we're not going to find the declaration in the class. 1386 For example, in: 1387 1388 struct S { template <typename T> void f(T); }; 1389 template <> void S::f(int); 1390 1391 we're not going to find `S::f(int)', but there's no 1392 reason we should, either. We let our callers know we didn't 1393 find the method, but we don't complain. */ 1394 return NULL_TREE; 1395 1396 if (method_vec != 0) 1397 { 1398 methods = &TREE_VEC_ELT (method_vec, 0); 1399 end = TREE_VEC_END (method_vec); 1400 1401 /* First suss out ctors and dtors. */ 1402 if (*methods && fn_name == DECL_NAME (OVL_CURRENT (*methods)) 1403 && DECL_CONSTRUCTOR_P (function)) 1404 goto got_it; 1405 if (*++methods && fn_name == DECL_NAME (OVL_CURRENT (*methods)) 1406 && DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function))) 1407 goto got_it; 1408 1409 while (++methods != end && *methods) 1410 { 1411 fndecl = *methods; 1412 if (fn_name == DECL_NAME (OVL_CURRENT (*methods))) 1413 { 1414 got_it: 1415 for (fndecls = *methods; fndecls != NULL_TREE; 1416 fndecls = OVL_NEXT (fndecls)) 1417 { 1418 fndecl = OVL_CURRENT (fndecls); 1419 /* The DECL_ASSEMBLER_NAME for a TEMPLATE_DECL, or 1420 for a for member function of a template class, is 1421 not mangled, so the check below does not work 1422 correctly in that case. Since mangled destructor 1423 names do not include the type of the arguments, 1424 we can't use this short-cut for them, either. 1425 (It's not legal to declare arguments for a 1426 destructor, but some people try.) */ 1427 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function)) 1428 && (DECL_ASSEMBLER_NAME (function) 1429 != DECL_NAME (function)) 1430 && (DECL_ASSEMBLER_NAME (fndecl) 1431 != DECL_NAME (fndecl)) 1432 && (DECL_ASSEMBLER_NAME (function) 1433 == DECL_ASSEMBLER_NAME (fndecl))) 1434 return fndecl; 1435 1436 /* We cannot simply call decls_match because this 1437 doesn't work for static member functions that are 1438 pretending to be methods, and because the name 1439 may have been changed by asm("new_name"). */ 1440 if (DECL_NAME (function) == DECL_NAME (fndecl)) 1441 { 1442 tree p1 = TYPE_ARG_TYPES (TREE_TYPE (function)); 1443 tree p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); 1444 1445 /* Get rid of the this parameter on functions that become 1446 static. */ 1447 if (DECL_STATIC_FUNCTION_P (fndecl) 1448 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) 1449 p1 = TREE_CHAIN (p1); 1450 1451 if (same_type_p (TREE_TYPE (TREE_TYPE (function)), 1452 TREE_TYPE (TREE_TYPE (fndecl))) 1453 && compparms (p1, p2) 1454 && (DECL_TEMPLATE_SPECIALIZATION (function) 1455 == DECL_TEMPLATE_SPECIALIZATION (fndecl)) 1456 && (!DECL_TEMPLATE_SPECIALIZATION (function) 1457 || (DECL_TI_TEMPLATE (function) 1458 == DECL_TI_TEMPLATE (fndecl)))) 1459 return fndecl; 1460 } 1461 } 1462 break; /* loser */ 1463 } 1464 } 1465 } 1466 1467 if (methods != end && *methods) 1468 { 1469 tree fndecl = *methods; 1470 cp_error ("prototype for `%#D' does not match any in class `%T'", 1471 function, ctype); 1472 cp_error_at ("candidate%s: %+#D", OVL_NEXT (fndecl) ? "s are" : " is", 1473 OVL_CURRENT (fndecl)); 1474 while (fndecl = OVL_NEXT (fndecl), fndecl) 1475 cp_error_at (" %#D", OVL_CURRENT(fndecl)); 1476 } 1477 else 1478 { 1479 methods = 0; 1480 if (TYPE_SIZE (ctype) == 0) 1481 incomplete_type_error (function, ctype); 1482 else 1483 cp_error ("no `%#D' member function declared in class `%T'", 1484 function, ctype); 1485 } 1486 1487 /* If we did not find the method in the class, add it to avoid 1488 spurious errors (unless the CTYPE is not yet defined, in which 1489 case we'll only confuse ourselves when the function is declared 1490 properly within the class. */ 1491 if (TYPE_SIZE (ctype)) 1492 add_method (ctype, methods, function); 1493 return NULL_TREE; 1494} 1495 1496/* We have just processed the DECL, which is a static data member. 1497 Its initializer, if present, is INIT. The ASMSPEC_TREE, if 1498 present, is the assembly-language name for the data member. 1499 NEED_POP and FLAGS are as for cp_finish_decl. */ 1500 1501void 1502finish_static_data_member_decl (decl, init, asmspec_tree, need_pop, flags) 1503 tree decl; 1504 tree init; 1505 tree asmspec_tree; 1506 int need_pop; 1507 int flags; 1508{ 1509 char* asmspec = 0; 1510 1511 if (asmspec_tree) 1512 asmspec = TREE_STRING_POINTER (asmspec_tree); 1513 1514 my_friendly_assert (TREE_PUBLIC (decl), 0); 1515 1516 /* We cannot call pushdecl here, because that would fill in the 1517 decl of our TREE_CHAIN. Instead, we modify cp_finish_decl to do 1518 the right thing, namely, to put this decl out straight away. */ 1519 /* current_class_type can be NULL_TREE in case of error. */ 1520 if (!asmspec && current_class_type) 1521 { 1522 DECL_INITIAL (decl) = error_mark_node; 1523 DECL_ASSEMBLER_NAME (decl) 1524 = build_static_name (current_class_type, DECL_NAME (decl)); 1525 } 1526 if (! processing_template_decl) 1527 { 1528 if (!pending_statics) 1529 VARRAY_TREE_INIT (pending_statics, 32, "pending_statics"); 1530 1531 if (pending_statics_used == pending_statics->num_elements) 1532 VARRAY_GROW (pending_statics, 1533 2 * pending_statics->num_elements); 1534 VARRAY_TREE (pending_statics, pending_statics_used) = decl; 1535 ++pending_statics_used; 1536 } 1537 1538 /* Static consts need not be initialized in the class definition. */ 1539 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))) 1540 { 1541 static int explanation = 0; 1542 1543 error ("initializer invalid for static member with constructor"); 1544 if (explanation++ == 0) 1545 error ("(you really want to initialize it separately)"); 1546 init = 0; 1547 } 1548 /* Force the compiler to know when an uninitialized static const 1549 member is being used. */ 1550 if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0) 1551 TREE_USED (decl) = 1; 1552 DECL_INITIAL (decl) = init; 1553 DECL_IN_AGGR_P (decl) = 1; 1554 DECL_CONTEXT (decl) = current_class_type; 1555 DECL_CLASS_CONTEXT (decl) = current_class_type; 1556 1557 cp_finish_decl (decl, init, asmspec_tree, need_pop, flags); 1558} 1559 1560/* Process the specs, declarator (NULL if omitted) and width (NULL if omitted) 1561 of a structure component, returning a FIELD_DECL node. 1562 QUALS is a list of type qualifiers for this decl (such as for declaring 1563 const member functions). 1564 1565 This is done during the parsing of the struct declaration. 1566 The FIELD_DECL nodes are chained together and the lot of them 1567 are ultimately passed to `build_struct' to make the RECORD_TYPE node. 1568 1569 C++: 1570 1571 If class A defines that certain functions in class B are friends, then 1572 the way I have set things up, it is B who is interested in permission 1573 granted by A. However, it is in A's context that these declarations 1574 are parsed. By returning a void_type_node, class A does not attempt 1575 to incorporate the declarations of the friends within its structure. 1576 1577 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING 1578 CHANGES TO CODE IN `start_method'. */ 1579 1580tree 1581grokfield (declarator, declspecs, init, asmspec_tree, attrlist) 1582 tree declarator, declspecs, init, asmspec_tree, attrlist; 1583{ 1584 register tree value; 1585 char *asmspec = 0; 1586 int flags = LOOKUP_ONLYCONVERTING; 1587 1588 /* Convert () initializers to = initializers. */ 1589 if (init == NULL_TREE && declarator != NULL_TREE 1590 && TREE_CODE (declarator) == CALL_EXPR 1591 && TREE_OPERAND (declarator, 0) 1592 && (TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE 1593 || TREE_CODE (TREE_OPERAND (declarator, 0)) == SCOPE_REF) 1594 && parmlist_is_exprlist (TREE_OPERAND (declarator, 1))) 1595 { 1596 init = TREE_OPERAND (declarator, 1); 1597 declarator = TREE_OPERAND (declarator, 0); 1598 flags = 0; 1599 } 1600 1601 if (declspecs == NULL_TREE 1602 && TREE_CODE (declarator) == SCOPE_REF 1603 && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE) 1604 { 1605 /* Access declaration */ 1606 if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0)))) 1607 ; 1608 else if (TREE_COMPLEXITY (declarator) == current_class_depth) 1609 pop_nested_class (); 1610 return do_class_using_decl (declarator); 1611 } 1612 1613 if (init 1614 && TREE_CODE (init) == TREE_LIST 1615 && TREE_VALUE (init) == error_mark_node 1616 && TREE_CHAIN (init) == NULL_TREE) 1617 init = NULL_TREE; 1618 1619 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, attrlist); 1620 if (! value || value == error_mark_node) 1621 /* friend or constructor went bad. */ 1622 return value; 1623 1624 /* Pass friendly classes back. */ 1625 if (TREE_CODE (value) == VOID_TYPE) 1626 return void_type_node; 1627 1628 if (DECL_NAME (value) != NULL_TREE 1629 && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_' 1630 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr")) 1631 cp_error ("member `%D' conflicts with virtual function table field name", 1632 value); 1633 1634 /* Stash away type declarations. */ 1635 if (TREE_CODE (value) == TYPE_DECL) 1636 { 1637 DECL_NONLOCAL (value) = 1; 1638 DECL_CONTEXT (value) = current_class_type; 1639 DECL_CLASS_CONTEXT (value) = current_class_type; 1640 1641 /* Now that we've updated the context, we need to remangle the 1642 name for this TYPE_DECL. */ 1643 DECL_ASSEMBLER_NAME (value) = DECL_NAME (value); 1644 if (!uses_template_parms (value)) 1645 DECL_ASSEMBLER_NAME (value) = 1646 get_identifier (build_overload_name (TREE_TYPE (value), 1, 1)); 1647 1648 return value; 1649 } 1650 1651 if (IS_SIGNATURE (current_class_type) 1652 && TREE_CODE (value) != FUNCTION_DECL) 1653 { 1654 error ("field declaration not allowed in signature"); 1655 return void_type_node; 1656 } 1657 1658 if (DECL_IN_AGGR_P (value)) 1659 { 1660 cp_error ("`%D' is already defined in `%T'", value, 1661 DECL_CONTEXT (value)); 1662 return void_type_node; 1663 } 1664 1665 if (asmspec_tree) 1666 asmspec = TREE_STRING_POINTER (asmspec_tree); 1667 1668 if (init) 1669 { 1670 if (IS_SIGNATURE (current_class_type) 1671 && TREE_CODE (value) == FUNCTION_DECL) 1672 { 1673 error ("function declarations cannot have initializers in signature"); 1674 init = NULL_TREE; 1675 } 1676 else if (TREE_CODE (value) == FUNCTION_DECL) 1677 { 1678 grok_function_init (value, init); 1679 init = NULL_TREE; 1680 } 1681 else if (pedantic && TREE_CODE (value) != VAR_DECL) 1682 /* Already complained in grokdeclarator. */ 1683 init = NULL_TREE; 1684 else 1685 { 1686 /* We allow initializers to become parameters to base 1687 initializers. */ 1688 if (TREE_CODE (init) == TREE_LIST) 1689 { 1690 if (TREE_CHAIN (init) == NULL_TREE) 1691 init = TREE_VALUE (init); 1692 else 1693 init = digest_init (TREE_TYPE (value), init, (tree *)0); 1694 } 1695 1696 if (TREE_CODE (init) == CONST_DECL) 1697 init = DECL_INITIAL (init); 1698 else if (TREE_READONLY_DECL_P (init)) 1699 init = decl_constant_value (init); 1700 else if (TREE_CODE (init) == CONSTRUCTOR) 1701 init = digest_init (TREE_TYPE (value), init, (tree *)0); 1702 my_friendly_assert (TREE_PERMANENT (init), 192); 1703 if (init == error_mark_node) 1704 /* We must make this look different than `error_mark_node' 1705 because `decl_const_value' would mis-interpret it 1706 as only meaning that this VAR_DECL is defined. */ 1707 init = build1 (NOP_EXPR, TREE_TYPE (value), init); 1708 else if (processing_template_decl) 1709 ; 1710 else if (! TREE_CONSTANT (init)) 1711 { 1712 /* We can allow references to things that are effectively 1713 static, since references are initialized with the address. */ 1714 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE 1715 || (TREE_STATIC (init) == 0 1716 && (TREE_CODE_CLASS (TREE_CODE (init)) != 'd' 1717 || DECL_EXTERNAL (init) == 0))) 1718 { 1719 error ("field initializer is not constant"); 1720 init = error_mark_node; 1721 } 1722 } 1723 } 1724 } 1725 1726 /* The corresponding pop_obstacks is in cp_finish_decl. */ 1727 push_obstacks_nochange (); 1728 1729 if (processing_template_decl && ! current_function_decl 1730 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL)) 1731 value = push_template_decl (value); 1732 1733 if (attrlist) 1734 cplus_decl_attributes (value, TREE_PURPOSE (attrlist), 1735 TREE_VALUE (attrlist)); 1736 1737 if (TREE_CODE (value) == VAR_DECL) 1738 { 1739 finish_static_data_member_decl (value, init, asmspec_tree, 1740 /*need_pop=*/1, flags); 1741 return value; 1742 } 1743 if (TREE_CODE (value) == FIELD_DECL) 1744 { 1745 if (asmspec) 1746 { 1747 /* This must override the asm specifier which was placed 1748 by grokclassfn. Lay this out fresh. */ 1749 DECL_RTL (value) = NULL_RTX; 1750 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec); 1751 } 1752 if (DECL_INITIAL (value) == error_mark_node) 1753 init = error_mark_node; 1754 cp_finish_decl (value, init, asmspec_tree, 1, flags); 1755 DECL_INITIAL (value) = init; 1756 DECL_IN_AGGR_P (value) = 1; 1757 return value; 1758 } 1759 if (TREE_CODE (value) == FUNCTION_DECL) 1760 { 1761 if (asmspec) 1762 { 1763 /* This must override the asm specifier which was placed 1764 by grokclassfn. Lay this out fresh. */ 1765 DECL_RTL (value) = NULL_RTX; 1766 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec); 1767 } 1768 cp_finish_decl (value, init, asmspec_tree, 1, flags); 1769 1770 /* Pass friends back this way. */ 1771 if (DECL_FRIEND_P (value)) 1772 return void_type_node; 1773 1774#if 0 /* Just because a fn is declared doesn't mean we'll try to define it. */ 1775 if (current_function_decl && ! IS_SIGNATURE (current_class_type)) 1776 cp_error ("method `%#D' of local class must be defined in class body", 1777 value); 1778#endif 1779 1780 DECL_IN_AGGR_P (value) = 1; 1781 return value; 1782 } 1783 my_friendly_abort (21); 1784 /* NOTREACHED */ 1785 return NULL_TREE; 1786} 1787 1788/* Like `grokfield', but for bitfields. 1789 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */ 1790 1791tree 1792grokbitfield (declarator, declspecs, width) 1793 tree declarator, declspecs, width; 1794{ 1795 register tree value = grokdeclarator (declarator, declspecs, BITFIELD, 1796 0, NULL_TREE); 1797 1798 if (! value) return NULL_TREE; /* friends went bad. */ 1799 1800 /* Pass friendly classes back. */ 1801 if (TREE_CODE (value) == VOID_TYPE) 1802 return void_type_node; 1803 1804 if (TREE_CODE (value) == TYPE_DECL) 1805 { 1806 cp_error ("cannot declare `%D' to be a bitfield type", value); 1807 return NULL_TREE; 1808 } 1809 1810 /* Usually, finish_struct_1 catches bitifields with invalid types. 1811 But, in the case of bitfields with function type, we confuse 1812 ourselves into thinking they are member functions, so we must 1813 check here. */ 1814 if (TREE_CODE (value) == FUNCTION_DECL) 1815 { 1816 cp_error ("cannot declare bitfield `%D' with funcion type", 1817 DECL_NAME (value)); 1818 return NULL_TREE; 1819 } 1820 1821 if (IS_SIGNATURE (current_class_type)) 1822 { 1823 error ("field declaration not allowed in signature"); 1824 return void_type_node; 1825 } 1826 1827 if (DECL_IN_AGGR_P (value)) 1828 { 1829 cp_error ("`%D' is already defined in the class %T", value, 1830 DECL_CONTEXT (value)); 1831 return void_type_node; 1832 } 1833 1834 GNU_xref_member (current_class_name, value); 1835 1836 if (TREE_STATIC (value)) 1837 { 1838 cp_error ("static member `%D' cannot be a bitfield", value); 1839 return NULL_TREE; 1840 } 1841 cp_finish_decl (value, NULL_TREE, NULL_TREE, 0, 0); 1842 1843 if (width != error_mark_node) 1844 { 1845 constant_expression_warning (width); 1846 DECL_INITIAL (value) = width; 1847 SET_DECL_C_BIT_FIELD (value); 1848 } 1849 1850 DECL_IN_AGGR_P (value) = 1; 1851 return value; 1852} 1853 1854tree 1855grokoptypename (declspecs, declarator) 1856 tree declspecs, declarator; 1857{ 1858 tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0, NULL_TREE); 1859 return build_typename_overload (t); 1860} 1861 1862/* When a function is declared with an initializer, 1863 do the right thing. Currently, there are two possibilities: 1864 1865 class B 1866 { 1867 public: 1868 // initialization possibility #1. 1869 virtual void f () = 0; 1870 int g (); 1871 }; 1872 1873 class D1 : B 1874 { 1875 public: 1876 int d1; 1877 // error, no f (); 1878 }; 1879 1880 class D2 : B 1881 { 1882 public: 1883 int d2; 1884 void f (); 1885 }; 1886 1887 class D3 : B 1888 { 1889 public: 1890 int d3; 1891 // initialization possibility #2 1892 void f () = B::f; 1893 }; 1894 1895*/ 1896 1897int 1898copy_assignment_arg_p (parmtype, virtualp) 1899 tree parmtype; 1900 int virtualp ATTRIBUTE_UNUSED; 1901{ 1902 if (current_class_type == NULL_TREE) 1903 return 0; 1904 1905 if (TREE_CODE (parmtype) == REFERENCE_TYPE) 1906 parmtype = TREE_TYPE (parmtype); 1907 1908 if ((TYPE_MAIN_VARIANT (parmtype) == current_class_type) 1909#if 0 1910 /* Non-standard hack to support old Booch components. */ 1911 || (! virtualp && DERIVED_FROM_P (parmtype, current_class_type)) 1912#endif 1913 ) 1914 return 1; 1915 1916 return 0; 1917} 1918 1919static void 1920grok_function_init (decl, init) 1921 tree decl; 1922 tree init; 1923{ 1924 /* An initializer for a function tells how this function should 1925 be inherited. */ 1926 tree type = TREE_TYPE (decl); 1927 1928 if (TREE_CODE (type) == FUNCTION_TYPE) 1929 cp_error ("initializer specified for non-member function `%D'", decl); 1930#if 0 1931 /* We'll check for this in finish_struct_1. */ 1932 else if (DECL_VINDEX (decl) == NULL_TREE) 1933 cp_error ("initializer specified for non-virtual method `%D'", decl); 1934#endif 1935 else if (integer_zerop (init)) 1936 { 1937#if 0 1938 /* Mark this function as being "defined". */ 1939 DECL_INITIAL (decl) = error_mark_node; 1940 /* pure virtual destructors must be defined. */ 1941 /* pure virtual needs to be defined (as abort) only when put in 1942 vtbl. For wellformed call, it should be itself. pr4737 */ 1943 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl))) 1944 { 1945 extern tree abort_fndecl; 1946 /* Give this node rtl from `abort'. */ 1947 DECL_RTL (decl) = DECL_RTL (abort_fndecl); 1948 } 1949#endif 1950 DECL_ABSTRACT_VIRTUAL_P (decl) = 1; 1951 if (DECL_NAME (decl) == ansi_opname [(int) MODIFY_EXPR]) 1952 { 1953 tree parmtype 1954 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))); 1955 1956 if (copy_assignment_arg_p (parmtype, 1)) 1957 TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1; 1958 } 1959 } 1960 else 1961 cp_error ("invalid initializer for virtual method `%D'", decl); 1962} 1963 1964void 1965cplus_decl_attributes (decl, attributes, prefix_attributes) 1966 tree decl, attributes, prefix_attributes; 1967{ 1968 if (decl == NULL_TREE || decl == void_type_node) 1969 return; 1970 1971 if (TREE_CODE (decl) == TEMPLATE_DECL) 1972 decl = DECL_TEMPLATE_RESULT (decl); 1973 1974 decl_attributes (decl, attributes, prefix_attributes); 1975 1976 if (TREE_CODE (decl) == TYPE_DECL) 1977 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (decl), TREE_TYPE (decl)); 1978} 1979 1980/* CONSTRUCTOR_NAME: 1981 Return the name for the constructor (or destructor) for the 1982 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or 1983 IDENTIFIER_NODE. When given a template, this routine doesn't 1984 lose the specialization. */ 1985 1986tree 1987constructor_name_full (thing) 1988 tree thing; 1989{ 1990 if (TREE_CODE (thing) == TEMPLATE_TYPE_PARM 1991 || TREE_CODE (thing) == TEMPLATE_TEMPLATE_PARM 1992 || TREE_CODE (thing) == TYPENAME_TYPE) 1993 thing = TYPE_NAME (thing); 1994 else if (IS_AGGR_TYPE_CODE (TREE_CODE (thing))) 1995 { 1996 if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing)) 1997 thing = DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (thing), 0))); 1998 else 1999 thing = TYPE_NAME (thing); 2000 } 2001 if (TREE_CODE (thing) == TYPE_DECL 2002 || (TREE_CODE (thing) == TEMPLATE_DECL 2003 && TREE_CODE (DECL_TEMPLATE_RESULT (thing)) == TYPE_DECL)) 2004 thing = DECL_NAME (thing); 2005 my_friendly_assert (TREE_CODE (thing) == IDENTIFIER_NODE, 197); 2006 return thing; 2007} 2008 2009/* CONSTRUCTOR_NAME: 2010 Return the name for the constructor (or destructor) for the 2011 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or 2012 IDENTIFIER_NODE. When given a template, return the plain 2013 unspecialized name. */ 2014 2015tree 2016constructor_name (thing) 2017 tree thing; 2018{ 2019 tree t; 2020 thing = constructor_name_full (thing); 2021 t = IDENTIFIER_TEMPLATE (thing); 2022 if (!t) 2023 return thing; 2024 return t; 2025} 2026 2027/* Cache the value of this class's main virtual function table pointer 2028 in a register variable. This will save one indirection if a 2029 more than one virtual function call is made this function. */ 2030 2031void 2032setup_vtbl_ptr () 2033{ 2034 extern tree base_init_expr; 2035 2036 if (base_init_expr == 0 2037 && DECL_CONSTRUCTOR_P (current_function_decl)) 2038 { 2039 if (processing_template_decl) 2040 add_tree (build_min_nt 2041 (CTOR_INITIALIZER, 2042 current_member_init_list, current_base_init_list)); 2043 else 2044 emit_base_init (current_class_type, 0); 2045 } 2046} 2047 2048/* Record the existence of an addressable inline function. */ 2049 2050void 2051mark_inline_for_output (decl) 2052 tree decl; 2053{ 2054 decl = DECL_MAIN_VARIANT (decl); 2055 if (DECL_SAVED_INLINE (decl)) 2056 return; 2057 my_friendly_assert (TREE_PERMANENT (decl), 363); 2058 DECL_SAVED_INLINE (decl) = 1; 2059 if (!saved_inlines) 2060 VARRAY_TREE_INIT (saved_inlines, 32, "saved_inlines"); 2061 2062 if (saved_inlines_used == saved_inlines->num_elements) 2063 VARRAY_GROW (saved_inlines, 2064 2 * saved_inlines->num_elements); 2065 VARRAY_TREE (saved_inlines, saved_inlines_used) = decl; 2066 ++saved_inlines_used; 2067} 2068 2069void 2070clear_temp_name () 2071{ 2072 temp_name_counter = 0; 2073} 2074 2075/* Hand off a unique name which can be used for variable we don't really 2076 want to know about anyway, for example, the anonymous variables which 2077 are needed to make references work. Declare this thing so we can use it. 2078 The variable created will be of type TYPE. 2079 2080 STATICP is nonzero if this variable should be static. */ 2081 2082tree 2083get_temp_name (type, staticp) 2084 tree type; 2085 int staticp; 2086{ 2087 char buf[sizeof (AUTO_TEMP_FORMAT) + 20]; 2088 tree decl; 2089 int toplev = toplevel_bindings_p (); 2090 2091 push_obstacks_nochange (); 2092 if (toplev || staticp) 2093 { 2094 end_temporary_allocation (); 2095 sprintf (buf, AUTO_TEMP_FORMAT, global_temp_name_counter++); 2096 decl = pushdecl_top_level (build_decl (VAR_DECL, get_identifier (buf), type)); 2097 } 2098 else 2099 { 2100 sprintf (buf, AUTO_TEMP_FORMAT, temp_name_counter++); 2101 decl = pushdecl (build_decl (VAR_DECL, get_identifier (buf), type)); 2102 } 2103 TREE_USED (decl) = 1; 2104 TREE_STATIC (decl) = staticp; 2105 DECL_ARTIFICIAL (decl) = 1; 2106 2107 /* If this is a local variable, then lay out its rtl now. 2108 Otherwise, callers of this function are responsible for dealing 2109 with this variable's rtl. */ 2110 if (! toplev) 2111 { 2112 expand_decl (decl); 2113 expand_decl_init (decl); 2114 } 2115 pop_obstacks (); 2116 2117 return decl; 2118} 2119 2120/* Get a variable which we can use for multiple assignments. 2121 It is not entered into current_binding_level, because 2122 that breaks things when it comes time to do final cleanups 2123 (which take place "outside" the binding contour of the function). */ 2124 2125tree 2126get_temp_regvar (type, init) 2127 tree type, init; 2128{ 2129 tree decl; 2130 2131 decl = build_decl (VAR_DECL, NULL_TREE, type); 2132 TREE_USED (decl) = 1; 2133 DECL_REGISTER (decl) = 1; 2134 DECL_ARTIFICIAL (decl) = 1; 2135 2136 DECL_RTL (decl) = assign_temp (type, 2, 0, 1); 2137 /* We can expand these without fear, since they cannot need 2138 constructors or destructors. */ 2139 expand_expr (build_modify_expr (decl, INIT_EXPR, init), 2140 NULL_RTX, VOIDmode, 0); 2141 2142 return decl; 2143} 2144 2145/* Hunts through the global anonymous union ANON_DECL, building 2146 appropriate VAR_DECLs. Stores cleanups on the list of ELEMS, and 2147 returns a VAR_DECL whose size is the same as the size of the 2148 ANON_DECL, if one is available. */ 2149 2150static tree 2151build_anon_union_vars (anon_decl, elems, static_p, external_p) 2152 tree anon_decl; 2153 tree* elems; 2154 int static_p; 2155 int external_p; 2156{ 2157 tree type = TREE_TYPE (anon_decl); 2158 tree main_decl = NULL_TREE; 2159 tree field; 2160 2161 for (field = TYPE_FIELDS (type); 2162 field != NULL_TREE; 2163 field = TREE_CHAIN (field)) 2164 { 2165 tree decl; 2166 2167 if (DECL_ARTIFICIAL (field)) 2168 continue; 2169 if (TREE_CODE (field) != FIELD_DECL) 2170 { 2171 cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members", 2172 field); 2173 continue; 2174 } 2175 2176 if (TREE_PRIVATE (field)) 2177 cp_pedwarn_at ("private member `%#D' in anonymous union", field); 2178 else if (TREE_PROTECTED (field)) 2179 cp_pedwarn_at ("protected member `%#D' in anonymous union", field); 2180 2181 if (DECL_NAME (field) == NULL_TREE 2182 && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) 2183 { 2184 decl = build_anon_union_vars (field, elems, static_p, external_p); 2185 if (!decl) 2186 continue; 2187 } 2188 else if (DECL_NAME (field) == NULL_TREE) 2189 continue; 2190 else 2191 { 2192 decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field)); 2193 /* tell `pushdecl' that this is not tentative. */ 2194 DECL_INITIAL (decl) = error_mark_node; 2195 TREE_PUBLIC (decl) = 0; 2196 TREE_STATIC (decl) = static_p; 2197 DECL_EXTERNAL (decl) = external_p; 2198 decl = pushdecl (decl); 2199 DECL_INITIAL (decl) = NULL_TREE; 2200 } 2201 2202 /* Only write out one anon union element--choose the one that 2203 can hold them all. */ 2204 if (main_decl == NULL_TREE 2205 && simple_cst_equal (DECL_SIZE (decl), 2206 DECL_SIZE (anon_decl)) == 1) 2207 main_decl = decl; 2208 else 2209 /* ??? This causes there to be no debug info written out 2210 about this decl. */ 2211 TREE_ASM_WRITTEN (decl) = 1; 2212 2213 if (DECL_NAME (field) == NULL_TREE 2214 && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) 2215 /* The remainder of the processing was already done in the 2216 recursive call. */ 2217 continue; 2218 2219 /* If there's a cleanup to do, it belongs in the 2220 TREE_PURPOSE of the following TREE_LIST. */ 2221 *elems = scratch_tree_cons (NULL_TREE, decl, *elems); 2222 TREE_TYPE (*elems) = type; 2223 } 2224 2225 return main_decl; 2226} 2227 2228/* Finish off the processing of a UNION_TYPE structure. 2229 If there are static members, then all members are 2230 static, and must be laid out together. If the 2231 union is an anonymous union, we arrange for that 2232 as well. PUBLIC_P is nonzero if this union is 2233 not declared static. */ 2234 2235void 2236finish_anon_union (anon_union_decl) 2237 tree anon_union_decl; 2238{ 2239 tree type = TREE_TYPE (anon_union_decl); 2240 tree elems = NULL_TREE; 2241 tree main_decl; 2242 int public_p = TREE_PUBLIC (anon_union_decl); 2243 int static_p = TREE_STATIC (anon_union_decl); 2244 int external_p = DECL_EXTERNAL (anon_union_decl); 2245 2246 if (TYPE_FIELDS (type) == NULL_TREE) 2247 return; 2248 2249 if (public_p) 2250 { 2251 error ("global anonymous unions must be declared static"); 2252 return; 2253 } 2254 2255 main_decl = build_anon_union_vars (anon_union_decl, &elems, 2256 static_p, external_p); 2257 2258 if (main_decl == NULL_TREE) 2259 { 2260 warning ("anonymous union with no members"); 2261 return; 2262 } 2263 2264 if (static_p) 2265 { 2266 make_decl_rtl (main_decl, 0, toplevel_bindings_p ()); 2267 DECL_RTL (anon_union_decl) = DECL_RTL (main_decl); 2268 } 2269 2270 /* The following call assumes that there are never any cleanups 2271 for anonymous unions--a reasonable assumption. */ 2272 expand_anon_union_decl (anon_union_decl, NULL_TREE, elems); 2273} 2274 2275/* Finish processing a builtin type TYPE. It's name is NAME, 2276 its fields are in the array FIELDS. LEN is the number of elements 2277 in FIELDS minus one, or put another way, it is the maximum subscript 2278 used in FIELDS. 2279 2280 It is given the same alignment as ALIGN_TYPE. */ 2281 2282void 2283finish_builtin_type (type, name, fields, len, align_type) 2284 tree type; 2285 const char *name; 2286 tree fields[]; 2287 int len; 2288 tree align_type; 2289{ 2290 register int i; 2291 2292 TYPE_FIELDS (type) = fields[0]; 2293 for (i = 0; i < len; i++) 2294 { 2295 layout_type (TREE_TYPE (fields[i])); 2296 DECL_FIELD_CONTEXT (fields[i]) = type; 2297 TREE_CHAIN (fields[i]) = fields[i+1]; 2298 } 2299 DECL_FIELD_CONTEXT (fields[i]) = type; 2300 DECL_CLASS_CONTEXT (fields[i]) = type; 2301 TYPE_ALIGN (type) = TYPE_ALIGN (align_type); 2302 layout_type (type); 2303#if 0 /* not yet, should get fixed properly later */ 2304 TYPE_NAME (type) = make_type_decl (get_identifier (name), type); 2305#else 2306 TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type); 2307#endif 2308 TYPE_STUB_DECL (type) = TYPE_NAME (type); 2309 layout_decl (TYPE_NAME (type), 0); 2310} 2311 2312/* Auxiliary functions to make type signatures for 2313 `operator new' and `operator delete' correspond to 2314 what compiler will be expecting. */ 2315 2316tree 2317coerce_new_type (type) 2318 tree type; 2319{ 2320 int e1 = 0, e2 = 0; 2321 2322 if (TREE_CODE (type) == METHOD_TYPE) 2323 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type))); 2324 if (! same_type_p (TREE_TYPE (type), ptr_type_node)) 2325 e1 = 1, error ("`operator new' must return type `void *'"); 2326 2327 /* Technically the type must be `size_t', but we may not know 2328 what that is. */ 2329 if (TYPE_ARG_TYPES (type) == NULL_TREE) 2330 e1 = 1, error ("`operator new' takes type `size_t' parameter"); 2331 else if (! same_type_p (TREE_VALUE (TYPE_ARG_TYPES (type)), sizetype)) 2332 e2 = 1, error ("`operator new' takes type `size_t' as first parameter"); 2333 if (e2) 2334 type = build_function_type (ptr_type_node, tree_cons (NULL_TREE, sizetype, TREE_CHAIN (TYPE_ARG_TYPES (type)))); 2335 else if (e1) 2336 type = build_function_type (ptr_type_node, TYPE_ARG_TYPES (type)); 2337 return type; 2338} 2339 2340tree 2341coerce_delete_type (type) 2342 tree type; 2343{ 2344 int e1 = 0, e2 = 0; 2345#if 0 2346 e3 = 0; 2347#endif 2348 tree arg_types = TYPE_ARG_TYPES (type); 2349 2350 if (TREE_CODE (type) == METHOD_TYPE) 2351 { 2352 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (arg_types)); 2353 arg_types = TREE_CHAIN (arg_types); 2354 } 2355 2356 if (TREE_TYPE (type) != void_type_node) 2357 e1 = 1, error ("`operator delete' must return type `void'"); 2358 2359 if (arg_types == NULL_TREE 2360 || ! same_type_p (TREE_VALUE (arg_types), ptr_type_node)) 2361 e2 = 1, error ("`operator delete' takes type `void *' as first parameter"); 2362 2363#if 0 2364 if (arg_types 2365 && TREE_CHAIN (arg_types) 2366 && TREE_CHAIN (arg_types) != void_list_node) 2367 { 2368 /* Again, technically this argument must be `size_t', but again 2369 we may not know what that is. */ 2370 tree t2 = TREE_VALUE (TREE_CHAIN (arg_types)); 2371 if (! same_type_p (t2, sizetype)) 2372 e3 = 1, error ("second argument to `operator delete' must be of type `size_t'"); 2373 else if (TREE_CHAIN (TREE_CHAIN (arg_types)) != void_list_node) 2374 { 2375 e3 = 1; 2376 if (TREE_CHAIN (TREE_CHAIN (arg_types))) 2377 error ("too many arguments in declaration of `operator delete'"); 2378 else 2379 error ("`...' invalid in specification of `operator delete'"); 2380 } 2381 } 2382 2383 if (e3) 2384 arg_types = tree_cons (NULL_TREE, ptr_type_node, 2385 build_tree_list (NULL_TREE, sizetype)); 2386 else if (e3 |= e2) 2387 { 2388 if (arg_types == NULL_TREE) 2389 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 2390 else 2391 arg_types = tree_cons (NULL_TREE, ptr_type_node, TREE_CHAIN (arg_types)); 2392 } 2393 else e3 |= e1; 2394#endif 2395 2396 if (e2) 2397 arg_types = tree_cons (NULL_TREE, ptr_type_node, 2398 arg_types ? TREE_CHAIN (arg_types): NULL_TREE); 2399 if (e2 || e1) 2400 type = build_function_type (void_type_node, arg_types); 2401 2402 return type; 2403} 2404 2405extern tree abort_fndecl; 2406 2407static void 2408mark_vtable_entries (decl) 2409 tree decl; 2410{ 2411 tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl)); 2412 2413 for (; entries; entries = TREE_CHAIN (entries)) 2414 { 2415 tree fnaddr; 2416 tree fn; 2417 2418 fnaddr = (flag_vtable_thunks ? TREE_VALUE (entries) 2419 : FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries))); 2420 2421 if (TREE_CODE (fnaddr) == NOP_EXPR) 2422 /* RTTI offset. */ 2423 continue; 2424 2425 fn = TREE_OPERAND (fnaddr, 0); 2426 TREE_ADDRESSABLE (fn) = 1; 2427 if (DECL_LANG_SPECIFIC (fn) && DECL_ABSTRACT_VIRTUAL_P (fn)) 2428 { 2429 TREE_OPERAND (fnaddr, 0) = fn = copy_node (fn); 2430 DECL_RTL (fn) = DECL_RTL (abort_fndecl); 2431 mark_used (abort_fndecl); 2432 } 2433 if (TREE_CODE (fn) == THUNK_DECL && DECL_EXTERNAL (fn)) 2434 { 2435 DECL_EXTERNAL (fn) = 0; 2436 emit_thunk (fn); 2437 } 2438 mark_used (fn); 2439 } 2440} 2441 2442/* Set DECL up to have the closest approximation of "initialized common" 2443 linkage available. */ 2444 2445void 2446comdat_linkage (decl) 2447 tree decl; 2448{ 2449 if (flag_weak) 2450 make_decl_one_only (decl); 2451 else if (TREE_CODE (decl) == FUNCTION_DECL || DECL_VIRTUAL_P (decl)) 2452 /* We can just emit functions and vtables statically; it doesn't really 2453 matter if we have multiple copies. */ 2454 TREE_PUBLIC (decl) = 0; 2455 else 2456 { 2457 /* Static data member template instantiations, however, cannot 2458 have multiple copies. */ 2459 if (DECL_INITIAL (decl) == 0 2460 || DECL_INITIAL (decl) == error_mark_node) 2461 DECL_COMMON (decl) = 1; 2462 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))) 2463 { 2464 DECL_COMMON (decl) = 1; 2465 DECL_INITIAL (decl) = error_mark_node; 2466 } 2467 else 2468 { 2469 /* We can't do anything useful; leave vars for explicit 2470 instantiation. */ 2471 DECL_EXTERNAL (decl) = 1; 2472 DECL_NOT_REALLY_EXTERN (decl) = 0; 2473 } 2474 } 2475 2476 if (DECL_LANG_SPECIFIC (decl)) 2477 DECL_COMDAT (decl) = 1; 2478} 2479 2480/* For win32 we also want to put explicit instantiations in 2481 linkonce sections, so that they will be merged with implicit 2482 instantiations; otherwise we get duplicate symbol errors. */ 2483 2484void 2485maybe_make_one_only (decl) 2486 tree decl; 2487{ 2488 /* We used to say that this was not necessary on targets that support weak 2489 symbols, because the implicit instantiations will defer to the explicit 2490 one. However, that's not actually the case in SVR4; a strong definition 2491 after a weak one is an error. Also, not making explicit 2492 instantiations one_only means that we can end up with two copies of 2493 some template instantiations. */ 2494 if (! supports_one_only ()) 2495 return; 2496 2497 /* We can't set DECL_COMDAT on functions, or finish_file will think 2498 we can get away with not emitting them if they aren't used. We need 2499 to for variables so that cp_finish_decl will update their linkage, 2500 because their DECL_INITIAL may not have been set properly yet. */ 2501 2502 make_decl_one_only (decl); 2503 2504 if (TREE_CODE (decl) == VAR_DECL && DECL_LANG_SPECIFIC (decl)) 2505 DECL_COMDAT (decl) = 1; 2506} 2507 2508/* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL, 2509 based on TYPE and other static flags. 2510 2511 Note that anything public is tagged TREE_PUBLIC, whether 2512 it's public in this file or in another one. */ 2513 2514void 2515import_export_vtable (decl, type, final) 2516 tree decl, type; 2517 int final; 2518{ 2519 if (DECL_INTERFACE_KNOWN (decl)) 2520 return; 2521 2522 if (TYPE_FOR_JAVA (type)) 2523 { 2524 TREE_PUBLIC (decl) = 1; 2525 DECL_EXTERNAL (decl) = 1; 2526 DECL_INTERFACE_KNOWN (decl) = 1; 2527 } 2528 else if (CLASSTYPE_INTERFACE_KNOWN (type)) 2529 { 2530 TREE_PUBLIC (decl) = 1; 2531 DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type); 2532 DECL_INTERFACE_KNOWN (decl) = 1; 2533 } 2534 else 2535 { 2536 /* We can only wait to decide if we have real non-inline virtual 2537 functions in our class, or if we come from a template. */ 2538 2539 int found = CLASSTYPE_TEMPLATE_INSTANTIATION (type); 2540 2541 if (! found && ! final) 2542 { 2543 tree method; 2544 for (method = TYPE_METHODS (type); method != NULL_TREE; 2545 method = TREE_CHAIN (method)) 2546 if (DECL_VINDEX (method) != NULL_TREE 2547 && ! DECL_THIS_INLINE (method) 2548 && ! DECL_ABSTRACT_VIRTUAL_P (method)) 2549 { 2550 found = 1; 2551 break; 2552 } 2553 } 2554 2555 if (final || ! found) 2556 { 2557 comdat_linkage (decl); 2558 DECL_EXTERNAL (decl) = 0; 2559 } 2560 else 2561 { 2562 TREE_PUBLIC (decl) = 1; 2563 DECL_EXTERNAL (decl) = 1; 2564 } 2565 } 2566} 2567 2568/* Determine whether or not we want to specifically import or export CTYPE, 2569 using various heuristics. */ 2570 2571void 2572import_export_class (ctype) 2573 tree ctype; 2574{ 2575 /* -1 for imported, 1 for exported. */ 2576 int import_export = 0; 2577 2578 if (CLASSTYPE_INTERFACE_KNOWN (ctype)) 2579 return; 2580 2581 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface, 2582 we will have CLASSTYPE_INTERFACE_ONLY set but not 2583 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this 2584 heuristic because someone will supply a #pragma implementation 2585 elsewhere, and deducing it here would produce a conflict. */ 2586 if (CLASSTYPE_INTERFACE_ONLY (ctype)) 2587 return; 2588 2589#ifdef VALID_MACHINE_TYPE_ATTRIBUTE 2590 /* FIXME this should really use some sort of target-independent macro. */ 2591 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype))) 2592 import_export = -1; 2593 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype))) 2594 import_export = 1; 2595#endif 2596 2597 /* If we got -fno-implicit-templates, we import template classes that 2598 weren't explicitly instantiated. */ 2599 if (import_export == 0 2600 && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype) 2601 && ! flag_implicit_templates) 2602 import_export = -1; 2603 2604 /* Base our import/export status on that of the first non-inline, 2605 non-abstract virtual function, if any. */ 2606 if (import_export == 0 2607 && TYPE_VIRTUAL_P (ctype) 2608 && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)) 2609 { 2610 tree method; 2611 for (method = TYPE_METHODS (ctype); method != NULL_TREE; 2612 method = TREE_CHAIN (method)) 2613 { 2614 if (DECL_VINDEX (method) != NULL_TREE 2615 && !DECL_THIS_INLINE (method) 2616 && !DECL_ABSTRACT_VIRTUAL_P (method)) 2617 { 2618 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1); 2619 break; 2620 } 2621 } 2622 } 2623 2624#ifdef MULTIPLE_SYMBOL_SPACES 2625 if (import_export == -1) 2626 import_export = 0; 2627#endif 2628 2629 if (import_export) 2630 { 2631 SET_CLASSTYPE_INTERFACE_KNOWN (ctype); 2632 CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = (import_export > 0); 2633 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0); 2634 } 2635} 2636 2637/* We need to describe to the assembler the relationship between 2638 a vtable and the vtable of the parent class. */ 2639 2640static void 2641output_vtable_inherit (vars) 2642 tree vars; 2643{ 2644 tree parent; 2645 rtx op[2]; 2646 2647 op[0] = XEXP (DECL_RTL (vars), 0); /* strip the mem ref */ 2648 2649 parent = binfo_for_vtable (vars); 2650 2651 if (parent == TYPE_BINFO (DECL_CONTEXT (vars))) 2652 op[1] = const0_rtx; 2653 else if (parent) 2654 { 2655 parent = TYPE_BINFO_VTABLE (BINFO_TYPE (parent)); 2656 op[1] = XEXP (DECL_RTL (parent), 0); /* strip the mem ref */ 2657 } 2658 else 2659 my_friendly_abort (980826); 2660 2661 output_asm_insn (".vtable_inherit %c0, %c1", op); 2662} 2663 2664static int 2665finish_vtable_vardecl (t, data) 2666 tree *t; 2667 void *data ATTRIBUTE_UNUSED; 2668{ 2669 tree vars = *t; 2670 tree ctype = DECL_CONTEXT (vars); 2671 import_export_class (ctype); 2672 import_export_vtable (vars, ctype, 1); 2673 2674 if (! DECL_EXTERNAL (vars) 2675 && (DECL_INTERFACE_KNOWN (vars) 2676 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars)) 2677 || (hack_decl_function_context (vars) && TREE_USED (vars))) 2678 && ! TREE_ASM_WRITTEN (vars)) 2679 { 2680 /* Write it out. */ 2681 mark_vtable_entries (vars); 2682 if (TREE_TYPE (DECL_INITIAL (vars)) == 0) 2683 store_init_value (vars, DECL_INITIAL (vars)); 2684 2685 if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG) 2686 { 2687 /* Mark the VAR_DECL node representing the vtable itself as a 2688 "gratuitous" one, thereby forcing dwarfout.c to ignore it. 2689 It is rather important that such things be ignored because 2690 any effort to actually generate DWARF for them will run 2691 into trouble when/if we encounter code like: 2692 2693 #pragma interface 2694 struct S { virtual void member (); }; 2695 2696 because the artificial declaration of the vtable itself (as 2697 manufactured by the g++ front end) will say that the vtable 2698 is a static member of `S' but only *after* the debug output 2699 for the definition of `S' has already been output. This causes 2700 grief because the DWARF entry for the definition of the vtable 2701 will try to refer back to an earlier *declaration* of the 2702 vtable as a static member of `S' and there won't be one. 2703 We might be able to arrange to have the "vtable static member" 2704 attached to the member list for `S' before the debug info for 2705 `S' get written (which would solve the problem) but that would 2706 require more intrusive changes to the g++ front end. */ 2707 2708 DECL_IGNORED_P (vars) = 1; 2709 } 2710 2711 /* Always make vtables weak. */ 2712 if (flag_weak) 2713 comdat_linkage (vars); 2714 2715 rest_of_decl_compilation (vars, NULL_PTR, 1, 1); 2716 2717 if (flag_vtable_gc) 2718 output_vtable_inherit (vars); 2719 2720 return 1; 2721 } 2722 else if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars))) 2723 /* We don't know what to do with this one yet. */ 2724 return 0; 2725 2726 *t = TREE_CHAIN (vars); 2727 return 0; 2728} 2729 2730static int 2731prune_vtable_vardecl (t, data) 2732 tree *t; 2733 void *data ATTRIBUTE_UNUSED; 2734{ 2735 *t = TREE_CHAIN (*t); 2736 return 1; 2737} 2738 2739static int 2740finish_sigtable_vardecl (t, data) 2741 tree *t; 2742 void *data ATTRIBUTE_UNUSED; 2743{ 2744 /* We don't need to mark sigtable entries as addressable here as is done 2745 for vtables. Since sigtables, unlike vtables, are always written out, 2746 that was already done in build_signature_table_constructor. */ 2747 2748 rest_of_decl_compilation (*t, NULL_PTR, 1, 1); 2749 *t = TREE_CHAIN (*t); 2750 return 1; 2751} 2752 2753/* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an 2754 inline function or template instantiation at end-of-file. */ 2755 2756void 2757import_export_decl (decl) 2758 tree decl; 2759{ 2760 if (DECL_INTERFACE_KNOWN (decl)) 2761 return; 2762 2763 if (DECL_TEMPLATE_INSTANTIATION (decl) 2764 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) 2765 { 2766 DECL_NOT_REALLY_EXTERN (decl) = 1; 2767 if ((DECL_IMPLICIT_INSTANTIATION (decl) 2768 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) 2769 && (flag_implicit_templates 2770 || (flag_implicit_inline_templates && DECL_THIS_INLINE (decl)))) 2771 { 2772 if (!TREE_PUBLIC (decl)) 2773 /* Templates are allowed to have internal linkage. See 2774 [basic.link]. */ 2775 ; 2776 else 2777 comdat_linkage (decl); 2778 } 2779 else 2780 DECL_NOT_REALLY_EXTERN (decl) = 0; 2781 } 2782 else if (DECL_FUNCTION_MEMBER_P (decl)) 2783 { 2784 tree ctype = DECL_CLASS_CONTEXT (decl); 2785 import_export_class (ctype); 2786 if (CLASSTYPE_INTERFACE_KNOWN (ctype) 2787 && (! DECL_ARTIFICIAL (decl) || DECL_VINDEX (decl))) 2788 { 2789 DECL_NOT_REALLY_EXTERN (decl) 2790 = ! (CLASSTYPE_INTERFACE_ONLY (ctype) 2791 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines 2792 && !DECL_VINDEX (decl))); 2793 2794 /* Always make artificials weak. */ 2795 if (DECL_ARTIFICIAL (decl) && flag_weak) 2796 comdat_linkage (decl); 2797 else 2798 maybe_make_one_only (decl); 2799 } 2800 else 2801 comdat_linkage (decl); 2802 } 2803 else if (DECL_TINFO_FN_P (decl)) 2804 { 2805 tree ctype = TREE_TYPE (DECL_NAME (decl)); 2806 2807 if (IS_AGGR_TYPE (ctype)) 2808 import_export_class (ctype); 2809 2810 if (IS_AGGR_TYPE (ctype) && CLASSTYPE_INTERFACE_KNOWN (ctype) 2811 && TYPE_VIRTUAL_P (ctype) 2812 /* If the type is a cv-qualified variant of a type, then we 2813 must emit the tinfo function in this translation unit 2814 since it will not be emitted when the vtable for the type 2815 is output (which is when the unqualified version is 2816 generated). */ 2817 && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype))) 2818 { 2819 DECL_NOT_REALLY_EXTERN (decl) 2820 = ! (CLASSTYPE_INTERFACE_ONLY (ctype) 2821 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines 2822 && !DECL_VINDEX (decl))); 2823 2824 /* Always make artificials weak. */ 2825 if (flag_weak) 2826 comdat_linkage (decl); 2827 } 2828 else if (TYPE_BUILT_IN (ctype) 2829 && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype))) 2830 DECL_NOT_REALLY_EXTERN (decl) = 0; 2831 else 2832 comdat_linkage (decl); 2833 } 2834 else 2835 comdat_linkage (decl); 2836 2837 DECL_INTERFACE_KNOWN (decl) = 1; 2838} 2839 2840tree 2841build_cleanup (decl) 2842 tree decl; 2843{ 2844 tree temp; 2845 tree type = TREE_TYPE (decl); 2846 2847 if (TREE_CODE (type) == ARRAY_TYPE) 2848 temp = decl; 2849 else 2850 { 2851 mark_addressable (decl); 2852 temp = build1 (ADDR_EXPR, build_pointer_type (type), decl); 2853 } 2854 temp = build_delete (TREE_TYPE (temp), temp, 2855 integer_two_node, 2856 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0); 2857 return temp; 2858} 2859 2860extern int parse_time, varconst_time; 2861 2862static tree 2863get_sentry (base) 2864 tree base; 2865{ 2866 tree sname = get_id_2 ("__sn", base); 2867 /* For struct X foo __attribute__((weak)), there is a counter 2868 __snfoo. Since base is already an assembler name, sname should 2869 be globally unique */ 2870 tree sentry = IDENTIFIER_GLOBAL_VALUE (sname); 2871 if (! sentry) 2872 { 2873 push_obstacks_nochange (); 2874 end_temporary_allocation (); 2875 sentry = build_decl (VAR_DECL, sname, integer_type_node); 2876 TREE_PUBLIC (sentry) = 1; 2877 DECL_ARTIFICIAL (sentry) = 1; 2878 TREE_STATIC (sentry) = 1; 2879 TREE_USED (sentry) = 1; 2880 DECL_COMMON (sentry) = 1; 2881 pushdecl_top_level (sentry); 2882 cp_finish_decl (sentry, NULL_TREE, NULL_TREE, 0, 0); 2883 pop_obstacks (); 2884 } 2885 return sentry; 2886} 2887 2888/* Start the process of running a particular set of global constructors 2889 or destructors. Subroutine of do_[cd]tors. */ 2890 2891static void 2892start_objects (method_type, initp) 2893 int method_type, initp; 2894{ 2895 tree fnname; 2896 char type[10]; 2897 2898 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */ 2899 2900 if (initp != DEFAULT_INIT_PRIORITY) 2901 { 2902 char joiner; 2903 2904#ifdef JOINER 2905 joiner = JOINER; 2906#else 2907 joiner = '_'; 2908#endif 2909 2910 sprintf (type, "%c%c%.5u", method_type, joiner, initp); 2911 } 2912 else 2913 sprintf (type, "%c", method_type); 2914 2915 fnname = get_file_function_name_long (type); 2916 2917 start_function (void_list_node, 2918 make_call_declarator (fnname, void_list_node, NULL_TREE, 2919 NULL_TREE), 2920 NULL_TREE, 0); 2921 2922#if defined(ASM_OUTPUT_CONSTRUCTOR) && defined(ASM_OUTPUT_DESTRUCTOR) 2923 /* It can be a static function as long as collect2 does not have 2924 to scan the object file to find its ctor/dtor routine. */ 2925 TREE_PUBLIC (current_function_decl) = 0; 2926#endif 2927 2928 store_parm_decls (); 2929 pushlevel (0); 2930 clear_last_expr (); 2931 push_momentary (); 2932 expand_start_bindings (0); 2933 2934 /* We cannot allow these functions to be elided, even if they do not 2935 have external linkage. And, there's no point in deferring 2936 copmilation of thes functions; they're all going to have to be 2937 out anyhow. */ 2938 current_function_cannot_inline 2939 = "static constructors and destructors cannot be inlined"; 2940} 2941 2942/* Finish the process of running a particular set of global constructors 2943 or destructors. Subroutine of do_[cd]tors. */ 2944 2945static void 2946finish_objects (method_type, initp) 2947 int method_type, initp; 2948{ 2949 char *fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); 2950 2951 /* Finish up. */ 2952 expand_end_bindings (getdecls (), 1, 0); 2953 poplevel (1, 0, 0); 2954 pop_momentary (); 2955 finish_function (lineno, 0, 0); 2956 2957 if (initp == DEFAULT_INIT_PRIORITY) 2958 { 2959 if (method_type == 'I') 2960 assemble_constructor (fnname); 2961 else 2962 assemble_destructor (fnname); 2963 } 2964 2965#if defined (ASM_OUTPUT_SECTION_NAME) && defined (ASM_OUTPUT_CONSTRUCTOR) 2966 /* If we're using init priority we can't use assemble_*tor, but on ELF 2967 targets we can stick the references into named sections for GNU ld 2968 to collect. */ 2969 else 2970 { 2971 char buf[15]; 2972 sprintf (buf, ".%ctors.%.5u", method_type == 'I' ? 'c' : 'd', 2973 /* invert the numbering so the linker puts us in the proper 2974 order; constructors are run from right to left, and the 2975 linker sorts in increasing order. */ 2976 MAX_INIT_PRIORITY - initp); 2977 named_section (NULL_TREE, buf, 0); 2978 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, fnname), 2979 POINTER_SIZE / BITS_PER_UNIT, 1); 2980 } 2981#endif 2982} 2983 2984/* The names of the parameters to the function created to handle 2985 initializations and destructions for objects with static storage 2986 duration. */ 2987#define INITIALIZE_P_IDENTIFIER "__initialize_p" 2988#define PRIORITY_IDENTIFIER "__priority" 2989 2990/* The name of the function we create to handle initializations and 2991 destructions for objects with static storage duration. */ 2992#define SSDF_IDENTIFIER "__static_initialization_and_destruction" 2993 2994/* The declaration for the __INITIALIZE_P argument. */ 2995static tree initialize_p_decl; 2996 2997/* The declaration for the __PRIORITY argument. */ 2998static tree priority_decl; 2999 3000/* The declaration for the static storage duration function. */ 3001static tree ssdf_decl; 3002 3003/* All the static storage duration functions created in this 3004 translation unit. */ 3005static varray_type ssdf_decls; 3006static size_t ssdf_decls_used; 3007 3008/* A map from priority levels to information about that priority 3009 level. There may be many such levels, so efficient lookup is 3010 important. */ 3011static splay_tree priority_info_map; 3012 3013/* Begins the generation of the function that will handle all 3014 initialization and destruction of objects with static storage 3015 duration. The function generated takes two parameters of type 3016 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is 3017 non-zero, it performs initializations. Otherwise, it performs 3018 destructions. It only performs those initializations or 3019 destructions with the indicated __PRIORITY. The generated function 3020 returns no value. 3021 3022 It is assumed that this function will only be called once per 3023 translation unit. */ 3024 3025static void 3026start_static_storage_duration_function () 3027{ 3028 static unsigned ssdf_number; 3029 3030 tree parm_types; 3031 tree type; 3032 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32]; 3033 3034 /* Create the identifier for this function. It will be of the form 3035 SSDF_IDENTIFIER_<number>. */ 3036 sprintf (id, "%s_%u", SSDF_IDENTIFIER, ssdf_number++); 3037 if (ssdf_number == 0) 3038 { 3039 /* Overflow occurred. That means there are at least 4 billion 3040 initialization functions. */ 3041 sorry ("too many initialization functions required"); 3042 my_friendly_abort (19990430); 3043 } 3044 3045 /* Create the parameters. */ 3046 parm_types = void_list_node; 3047 parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types); 3048 parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types); 3049 type = build_function_type (void_type_node, parm_types); 3050 3051 /* Create the FUNCTION_DECL itself. */ 3052 ssdf_decl = build_lang_decl (FUNCTION_DECL, 3053 get_identifier (id), 3054 type); 3055 TREE_PUBLIC (ssdf_decl) = 0; 3056 DECL_ARTIFICIAL (ssdf_decl) = 1; 3057 3058 /* Put this function in the list of functions to be called from the 3059 static constructors and destructors. */ 3060 if (!ssdf_decls) 3061 { 3062 VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls"); 3063 3064 /* Take this opportunity to initialize the map from priority 3065 numbers to information about that priority level. */ 3066 priority_info_map = splay_tree_new (splay_tree_compare_ints, 3067 /*delete_key_fn=*/0, 3068 /*delete_value_fn=*/ 3069 (splay_tree_delete_value_fn) &free); 3070 3071 /* We always need to generate functions for the 3072 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk 3073 priorities later, we'll be sure to find the 3074 DEFAULT_INIT_PRIORITY. */ 3075 get_priority_info (DEFAULT_INIT_PRIORITY); 3076 } 3077 3078 if (ssdf_decls_used == ssdf_decls->num_elements) 3079 VARRAY_GROW (ssdf_decls, 2 * ssdf_decls_used); 3080 VARRAY_TREE (ssdf_decls, ssdf_decls_used) = ssdf_decl; 3081 ++ssdf_decls_used; 3082 3083 /* Create the argument list. */ 3084 initialize_p_decl = build_decl (PARM_DECL, 3085 get_identifier (INITIALIZE_P_IDENTIFIER), 3086 integer_type_node); 3087 DECL_CONTEXT (initialize_p_decl) = ssdf_decl; 3088 DECL_ARG_TYPE (initialize_p_decl) = integer_type_node; 3089 TREE_USED (initialize_p_decl) = 1; 3090 priority_decl = build_decl (PARM_DECL, get_identifier (PRIORITY_IDENTIFIER), 3091 integer_type_node); 3092 DECL_CONTEXT (priority_decl) = ssdf_decl; 3093 DECL_ARG_TYPE (priority_decl) = integer_type_node; 3094 TREE_USED (priority_decl) = 1; 3095 3096 TREE_CHAIN (initialize_p_decl) = priority_decl; 3097 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl; 3098 3099 /* Start the function itself. This is equivalent to declarating the 3100 function as: 3101 3102 static void __ssdf (int __initialize_p, init __priority_p); 3103 3104 It is static because we only need to call this function from the 3105 various constructor and destructor functions for this module. */ 3106 start_function (/*specs=*/NULL_TREE, 3107 ssdf_decl, 3108 /*attrs=*/NULL_TREE, 3109 /*pre_parsed_p=*/1); 3110 3111 /* Set up the scope of the outermost block in the function. */ 3112 store_parm_decls (); 3113 pushlevel (0); 3114 clear_last_expr (); 3115 push_momentary (); 3116 expand_start_bindings (0); 3117 3118 /* This function must not be deferred because we are depending on 3119 its compilation to tell us what is TREE_SYMBOL_REFERENCED. */ 3120 current_function_cannot_inline 3121 = "static storage duration functions cannot be inlined"; 3122} 3123 3124/* Generate the initialization code for the priority indicated in N. */ 3125 3126static int 3127generate_inits_for_priority (n, data) 3128 splay_tree_node n; 3129 void *data ATTRIBUTE_UNUSED; 3130{ 3131 int priority = (int) n->key; 3132 priority_info pi = (priority_info) n->value; 3133 3134 /* For each priority N which has been used generate code which looks 3135 like: 3136 3137 if (__priority == N) { 3138 if (__initialize_p) 3139 ... 3140 else 3141 ... 3142 } 3143 3144 We use the sequences we've accumulated to fill in the `...'s. */ 3145 expand_start_cond (build_binary_op (EQ_EXPR, 3146 priority_decl, 3147 build_int_2 (priority, 0)), 3148 /*exit_flag=*/0); 3149 3150 /* Do the initializations. */ 3151 expand_start_cond (build_binary_op (NE_EXPR, 3152 initialize_p_decl, 3153 integer_zero_node), 3154 /*exit_flag=*/0); 3155 if (pi->initialization_sequence) 3156 { 3157 rtx insns; 3158 3159 push_to_sequence (pi->initialization_sequence); 3160 insns = gen_sequence (); 3161 end_sequence (); 3162 3163 emit_insn (insns); 3164 pi->initialization_sequence = NULL_RTX; 3165 pi->initializations_p = 1; 3166 } 3167 3168 /* Do the destructions. */ 3169 expand_start_else (); 3170 if (pi->destruction_sequence) 3171 { 3172 rtx insns; 3173 3174 push_to_sequence (pi->destruction_sequence); 3175 insns = gen_sequence (); 3176 end_sequence (); 3177 3178 emit_insn (insns); 3179 pi->destruction_sequence = NULL_RTX; 3180 pi->destructions_p = 1; 3181 } 3182 3183 /* Close out the conditionals. */ 3184 expand_end_cond (); 3185 expand_end_cond (); 3186 3187 /* Don't stop iterating. */ 3188 return 0; 3189} 3190 3191/* Finish the generation of the function which performs initialization 3192 and destruction of objects with static storage duration. After 3193 this point, no more such objects can be created. */ 3194 3195static void 3196finish_static_storage_duration_function () 3197{ 3198 splay_tree_foreach (priority_info_map, 3199 generate_inits_for_priority, 3200 /*data=*/0); 3201 3202 /* Close out the function. */ 3203 expand_end_bindings (getdecls (), 1, 0); 3204 poplevel (1, 0, 0); 3205 pop_momentary (); 3206 finish_function (lineno, 0, 0); 3207} 3208 3209/* Return the information about the indicated PRIORITY level. If no 3210 code to handle this level has yet been generated, generate the 3211 appropriate prologue. */ 3212 3213static priority_info 3214get_priority_info (priority) 3215 int priority; 3216{ 3217 priority_info pi; 3218 splay_tree_node n; 3219 3220 n = splay_tree_lookup (priority_info_map, 3221 (splay_tree_key) priority); 3222 if (!n) 3223 { 3224 /* Create a new priority information structure, and insert it 3225 into the map. */ 3226 pi = (priority_info) xmalloc (sizeof (struct priority_info_s)); 3227 pi->initialization_sequence = NULL_RTX; 3228 pi->destruction_sequence = NULL_RTX; 3229 pi->initializations_p = 0; 3230 pi->destructions_p = 0; 3231 splay_tree_insert (priority_info_map, 3232 (splay_tree_key) priority, 3233 (splay_tree_value) pi); 3234 } 3235 else 3236 pi = (priority_info) n->value; 3237 3238 return pi; 3239} 3240 3241/* Generate code to do the static initialization of DECL. The 3242 initialization is INIT. If DECL may be initialized more than once 3243 in different object files, SENTRY is the guard variable to 3244 check. PRIORITY is the priority for the initialization. */ 3245 3246static void 3247do_static_initialization (decl, init, sentry, priority) 3248 tree decl; 3249 tree init; 3250 tree sentry; 3251 int priority; 3252{ 3253 priority_info pi; 3254 3255 /* Get the priority information for this PRIORITY, */ 3256 pi = get_priority_info (priority); 3257 if (!pi->initialization_sequence) 3258 start_sequence (); 3259 else 3260 push_to_sequence (pi->initialization_sequence); 3261 3262 /* Tell the debugger that we are at the location of the static 3263 variable in question. */ 3264 emit_note (input_filename, lineno); 3265 3266 /* If there's a SENTRY, we only do the initialization if it is 3267 zero, i.e., if we are the first to initialize it. */ 3268 if (sentry) 3269 expand_start_cond (build_binary_op (EQ_EXPR, 3270 build_unary_op (PREINCREMENT_EXPR, 3271 sentry, 3272 /*noconvert=*/0), 3273 integer_one_node), 3274 /*exit_flag=*/0); 3275 3276 /* Prepare a binding level for temporaries created during the 3277 initialization. */ 3278 expand_start_target_temps (); 3279 3280 if (IS_AGGR_TYPE (TREE_TYPE (decl)) 3281 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 3282 expand_aggr_init (decl, init, 0); 3283 else if (TREE_CODE (init) == TREE_VEC) 3284 expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0), 3285 TREE_VEC_ELT (init, 1), 3286 TREE_VEC_ELT (init, 2), 0), 3287 const0_rtx, VOIDmode, EXPAND_NORMAL); 3288 else 3289 expand_assignment (decl, init, 0, 0); 3290 3291 /* The expression might have involved increments and decrements. */ 3292 emit_queue (); 3293 3294 /* Cleanup any temporaries needed for the initial value. */ 3295 expand_end_target_temps (); 3296 3297 /* Cleanup any deferred pops from function calls. This would be done 3298 by expand_end_cond, but we also need it when !SENTRY, since we are 3299 constructing these sequences by parts. */ 3300 do_pending_stack_adjust (); 3301 3302 /* Close the conditional opened above. */ 3303 if (sentry) 3304 expand_end_cond (); 3305 3306 /* Save the sequence for later use. */ 3307 pi->initialization_sequence = get_insns (); 3308 end_sequence (); 3309} 3310 3311/* Generate code to do the static destruction of DECL. If DECL may be 3312 initialized more than once in different object files, SENTRY is the 3313 guard variable to check. PRIORITY is the priority for the 3314 destruction. */ 3315 3316static void 3317do_static_destruction (decl, sentry, priority) 3318 tree decl; 3319 tree sentry; 3320 int priority; 3321{ 3322 rtx new_insns; 3323 priority_info pi; 3324 3325 /* If we don't need a destructor, there's nothing to do. */ 3326 if (!TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl))) 3327 return; 3328 3329 /* Get the priority information for this PRIORITY, */ 3330 pi = get_priority_info (priority); 3331 if (!pi->destruction_sequence) 3332 start_sequence (); 3333 else 3334 push_to_sequence (pi->destruction_sequence); 3335 3336 /* Start a new sequence to handle just this destruction. */ 3337 start_sequence (); 3338 3339 /* Tell the debugger that we are at the location of the static 3340 variable in question. */ 3341 emit_note (input_filename, lineno); 3342 3343 /* If there's a SENTRY, we only do the destruction if it is one, 3344 i.e., if we are the last to destroy it. */ 3345 if (sentry) 3346 expand_start_cond (build_binary_op (EQ_EXPR, 3347 build_unary_op (PREDECREMENT_EXPR, 3348 sentry, 3349 /*nonconvert=*/1), 3350 integer_zero_node), 3351 /*exit_flag=*/0); 3352 3353 /* Actually to the destruction. */ 3354 expand_expr_stmt (build_cleanup (decl)); 3355 3356 /* Cleanup any deferred pops from function calls. This would be done 3357 by expand_end_cond, but we also need it when !SENTRY, since we are 3358 constructing these sequences by parts. */ 3359 do_pending_stack_adjust (); 3360 3361 /* Close the conditional opened above. */ 3362 if (sentry) 3363 expand_end_cond (); 3364 3365 /* Insert the NEW_INSNS before the current insns. (Destructions are 3366 run in reverse order of initializations.) */ 3367 new_insns = gen_sequence (); 3368 end_sequence (); 3369 if (pi->destruction_sequence) 3370 emit_insn_before (new_insns, pi->destruction_sequence); 3371 else 3372 emit_insn (new_insns); 3373 3374 /* Save the sequence for later use. */ 3375 pi->destruction_sequence = get_insns (); 3376 end_sequence (); 3377} 3378 3379/* Add code to the static storage duration function that will handle 3380 DECL (a static variable that needs initializing and/or destruction) 3381 with the indicated PRIORITY. If DECL needs initializing, INIT is 3382 the initializer. */ 3383 3384static void 3385do_static_initialization_and_destruction (decl, init) 3386 tree decl; 3387 tree init; 3388{ 3389 tree sentry = NULL_TREE; 3390 int priority; 3391 3392 /* Deal gracefully with error. */ 3393 if (decl == error_mark_node) 3394 return; 3395 3396 /* The only things that can be initialized are variables. */ 3397 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420); 3398 3399 /* If this object is not defined, we don't need to do anything 3400 here. */ 3401 if (DECL_EXTERNAL (decl)) 3402 return; 3403 3404 /* Also, if the initializer already contains errors, we can bail out 3405 now. */ 3406 if (init && TREE_CODE (init) == TREE_LIST 3407 && value_member (error_mark_node, init)) 3408 return; 3409 3410 /* Trick the compiler into thinking we are at the file and line 3411 where DECL was declared so that error-messages make sense, and so 3412 that the debugger will show somewhat sensible file and line 3413 information. */ 3414 input_filename = DECL_SOURCE_FILE (decl); 3415 lineno = DECL_SOURCE_LINE (decl); 3416 3417 /* Because of: 3418 3419 [class.access.spec] 3420 3421 Access control for implicit calls to the constructors, 3422 the conversion functions, or the destructor called to 3423 create and destroy a static data member is performed as 3424 if these calls appeared in the scope of the member's 3425 class. 3426 3427 we pretend we are in a static member function of the class of 3428 which the DECL is a member. */ 3429 if (member_p (decl)) 3430 { 3431 DECL_CLASS_CONTEXT (current_function_decl) = DECL_CONTEXT (decl); 3432 DECL_STATIC_FUNCTION_P (current_function_decl) = 1; 3433 } 3434 3435 /* We need a sentry if this is an object with external linkage that 3436 might be initialized in more than one place. */ 3437 if (TREE_PUBLIC (decl) && (DECL_COMMON (decl) 3438 || DECL_ONE_ONLY (decl) 3439 || DECL_WEAK (decl))) 3440 sentry = get_sentry (DECL_ASSEMBLER_NAME (decl)); 3441 3442 /* Generate the code to actually do the intialization and 3443 destruction. */ 3444 priority = DECL_INIT_PRIORITY (decl); 3445 if (!priority) 3446 priority = DEFAULT_INIT_PRIORITY; 3447 do_static_initialization (decl, init, sentry, priority); 3448 do_static_destruction (decl, sentry, priority); 3449 3450 /* Now that we're done with DECL we don't need to pretend to be a 3451 member of its class any longer. */ 3452 DECL_CLASS_CONTEXT (current_function_decl) = NULL_TREE; 3453 DECL_STATIC_FUNCTION_P (current_function_decl) = 0; 3454} 3455 3456/* Generate a static constructor (if CONSTRUCTOR_P) or destructor 3457 (otherwise) that will initialize all gobal objects with static 3458 storage duration having the indicated PRIORITY. */ 3459 3460static void 3461generate_ctor_or_dtor_function (constructor_p, priority) 3462 int constructor_p; 3463 int priority; 3464{ 3465 char function_key; 3466 tree arguments; 3467 size_t i; 3468 3469 /* We use `I' to indicate initialization and `D' to indicate 3470 destruction. */ 3471 if (constructor_p) 3472 function_key = 'I'; 3473 else 3474 function_key = 'D'; 3475 3476 /* Begin the function. */ 3477 start_objects (function_key, priority); 3478 3479 /* Call the static storage duration function with appropriate 3480 arguments. */ 3481 for (i = 0; i < ssdf_decls_used; ++i) 3482 { 3483 arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0), 3484 NULL_TREE); 3485 arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0), 3486 arguments); 3487 expand_expr_stmt (build_function_call (VARRAY_TREE (ssdf_decls, i), 3488 arguments)); 3489 } 3490 3491 /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in 3492 calls to any functions marked with attributes indicating that 3493 they should be called at initialization- or destruction-time. */ 3494 if (priority == DEFAULT_INIT_PRIORITY) 3495 { 3496 tree fns; 3497 3498 for (fns = constructor_p ? static_ctors : static_dtors; 3499 fns; 3500 fns = TREE_CHAIN (fns)) 3501 expand_expr_stmt (build_function_call (TREE_VALUE (fns), NULL_TREE)); 3502 } 3503 3504 /* Close out the function. */ 3505 finish_objects (function_key, priority); 3506} 3507 3508/* Generate constructor and destructor functions for the priority 3509 indicated by N. */ 3510 3511static int 3512generate_ctor_and_dtor_functions_for_priority (n, data) 3513 splay_tree_node n; 3514 void *data ATTRIBUTE_UNUSED; 3515{ 3516 int priority = (int) n->key; 3517 priority_info pi = (priority_info) n->value; 3518 3519 /* Generate the functions themselves, but only if they are really 3520 needed. */ 3521 if (pi->initializations_p 3522 || (priority == DEFAULT_INIT_PRIORITY && static_ctors)) 3523 generate_ctor_or_dtor_function (/*constructor_p=*/1, 3524 priority); 3525 if (pi->destructions_p 3526 || (priority == DEFAULT_INIT_PRIORITY && static_dtors)) 3527 generate_ctor_or_dtor_function (/*constructor_p=*/0, 3528 priority); 3529 3530 /* Keep iterating. */ 3531 return 0; 3532} 3533 3534/* This routine is called from the last rule in yyparse (). 3535 Its job is to create all the code needed to initialize and 3536 destroy the global aggregates. We do the destruction 3537 first, since that way we only need to reverse the decls once. */ 3538 3539void 3540finish_file () 3541{ 3542 extern int lineno; 3543 int start_time, this_time; 3544 tree vars; 3545 int reconsider; 3546 size_t i; 3547 3548 at_eof = 1; 3549 3550 /* Bad parse errors. Just forget about it. */ 3551 if (! global_bindings_p () || current_class_type || decl_namespace_list) 3552 return; 3553 3554 start_time = get_run_time (); 3555 3556 /* Otherwise, GDB can get confused, because in only knows 3557 about source for LINENO-1 lines. */ 3558 lineno -= 1; 3559 3560 interface_unknown = 1; 3561 interface_only = 0; 3562 3563 /* We now have to write out all the stuff we put off writing out. 3564 These include: 3565 3566 o Template specializations that we have not yet instantiated, 3567 but which are needed. 3568 o Initialization and destruction for non-local objects with 3569 static storage duration. (Local objects with static storage 3570 duration are initialized when their scope is first entered, 3571 and are cleaned up via atexit.) 3572 o Virtual function tables. 3573 3574 All of these may cause others to be needed. For example, 3575 instantiating one function may cause another to be needed, and 3576 generating the intiailzer for an object may cause templates to be 3577 instantiated, etc., etc. */ 3578 3579 this_time = get_run_time (); 3580 parse_time -= this_time - start_time; 3581 varconst_time += this_time - start_time; 3582 start_time = get_run_time (); 3583 permanent_allocation (1); 3584 3585 do 3586 { 3587 /* Non-zero if we need a static storage duration function on 3588 this iteration through the loop. */ 3589 int need_ssdf_p = 0; 3590 3591 reconsider = 0; 3592 3593 /* If there are templates that we've put off instantiating, do 3594 them now. */ 3595 instantiate_pending_templates (); 3596 3597 /* Write out signature-tables and virtual tables as required. 3598 Note that writing out the virtual table for a template class 3599 may cause the instantiation of members of that class. */ 3600 if (flag_handle_signatures 3601 && walk_globals (sigtable_decl_p, 3602 finish_sigtable_vardecl, 3603 /*data=*/0)) 3604 reconsider = 1; 3605 if (walk_globals (vtable_decl_p, 3606 finish_vtable_vardecl, 3607 /*data=*/0)) 3608 reconsider = 1; 3609 3610 /* The list of objects with static storage duration is built up 3611 in reverse order, so we reverse it here. We also clear 3612 STATIC_AGGREGATES so that any new aggregates added during the 3613 initialization of these will be initialized in the correct 3614 order when we next come around the loop. */ 3615 vars = nreverse (static_aggregates); 3616 static_aggregates = NULL_TREE; 3617 while (vars) 3618 { 3619 if (! TREE_ASM_WRITTEN (TREE_VALUE (vars))) 3620 rest_of_decl_compilation (TREE_VALUE (vars), 0, 1, 1); 3621 if (!need_ssdf_p) 3622 { 3623 /* We need to start a new initialization function each 3624 time through the loop. That's because we need to 3625 know which vtables have been referenced, and 3626 TREE_SYMBOL_REFERENCED isn't computed until a 3627 function is finished, and written out. That's a 3628 deficiency in the back-end. When this is fixed, 3629 these initialization functions could all become 3630 inline, with resulting performance improvements. */ 3631 start_static_storage_duration_function (); 3632 need_ssdf_p = 1; 3633 } 3634 3635 do_static_initialization_and_destruction (TREE_VALUE (vars), 3636 TREE_PURPOSE (vars)); 3637 reconsider = 1; 3638 vars = TREE_CHAIN (vars); 3639 } 3640 3641 /* Finish up the static storage duration function for this 3642 round. */ 3643 if (need_ssdf_p) 3644 finish_static_storage_duration_function (); 3645 3646 /* Go through the various inline functions, and see if any need 3647 synthesizing. */ 3648 for (i = 0; i < saved_inlines_used; ++i) 3649 { 3650 tree decl = VARRAY_TREE (saved_inlines, i); 3651 import_export_decl (decl); 3652 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl) 3653 && TREE_USED (decl) 3654 && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl))) 3655 { 3656 /* Even though we're already at the top-level, we push 3657 there again. That way, when we pop back a few lines 3658 hence, all of our state is restored. Otherwise, 3659 finish_function doesn't clean things up, and we end 3660 up with CURRENT_FUNCTION_DECL set. */ 3661 push_to_top_level (); 3662 if (DECL_TINFO_FN_P (decl)) 3663 synthesize_tinfo_fn (decl); 3664 else 3665 synthesize_method (decl); 3666 pop_from_top_level (); 3667 reconsider = 1; 3668 } 3669 } 3670 3671 /* Mark all functions that might deal with exception-handling as 3672 referenced. */ 3673 mark_all_runtime_matches (); 3674 3675 /* We lie to the back-end, pretending that some functions are 3676 not defined when they really are. This keeps these functions 3677 from being put out unncessarily. But, we must stop lying 3678 when the functions are referenced, or if they are not comdat 3679 since they need to be put out now. */ 3680 for (i = 0; i < saved_inlines_used; ++i) 3681 { 3682 tree decl = VARRAY_TREE (saved_inlines, i); 3683 3684 if (DECL_NOT_REALLY_EXTERN (decl) 3685 && DECL_INITIAL (decl) 3686 && (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) 3687 || !DECL_COMDAT (decl))) 3688 DECL_EXTERNAL (decl) = 0; 3689 } 3690 3691 if (saved_inlines_used 3692 && wrapup_global_declarations (&VARRAY_TREE (saved_inlines, 0), 3693 saved_inlines_used)) 3694 reconsider = 1; 3695 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0)) 3696 reconsider = 1; 3697 3698 /* Static data members are just like namespace-scope globals. */ 3699 for (i = 0; i < pending_statics_used; ++i) 3700 { 3701 tree decl = VARRAY_TREE (pending_statics, i); 3702 if (TREE_ASM_WRITTEN (decl)) 3703 continue; 3704 import_export_decl (decl); 3705 if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl)) 3706 DECL_EXTERNAL (decl) = 0; 3707 } 3708 if (pending_statics 3709 && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0), 3710 pending_statics_used)) 3711 reconsider = 1; 3712 } 3713 while (reconsider); 3714 3715 /* We give C linkage to static constructors and destructors. */ 3716 push_lang_context (lang_name_c); 3717 3718 /* Generate initialization and destruction functions for all 3719 priorities for which they are required. */ 3720 if (priority_info_map) 3721 splay_tree_foreach (priority_info_map, 3722 generate_ctor_and_dtor_functions_for_priority, 3723 /*data=*/0); 3724 3725 /* We're done with the splay-tree now. */ 3726 if (priority_info_map) 3727 splay_tree_delete (priority_info_map); 3728 3729 /* We're done with static constructors, so we can go back to "C++" 3730 linkage now. */ 3731 pop_lang_context (); 3732 3733 /* Now delete from the chain of variables all virtual function tables. 3734 We output them all ourselves, because each will be treated 3735 specially. */ 3736 walk_globals (vtable_decl_p, prune_vtable_vardecl, /*data=*/0); 3737 3738 /* Now, issue warnings about static, but not defined, functions, 3739 etc. */ 3740 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider); 3741 3742 finish_repo (); 3743 3744 this_time = get_run_time (); 3745 parse_time -= this_time - start_time; 3746 varconst_time += this_time - start_time; 3747 3748 if (flag_detailed_statistics) 3749 { 3750 dump_tree_statistics (); 3751 dump_time_statistics (); 3752 } 3753} 3754 3755/* This is something of the form 'A()()()()()+1' that has turned out to be an 3756 expr. Since it was parsed like a type, we need to wade through and fix 3757 that. Unfortunately, since operator() is left-associative, we can't use 3758 tail recursion. In the above example, TYPE is `A', and DECL is 3759 `()()()()()'. 3760 3761 Maybe this shouldn't be recursive, but how often will it actually be 3762 used? (jason) */ 3763 3764tree 3765reparse_absdcl_as_expr (type, decl) 3766 tree type, decl; 3767{ 3768 /* do build_functional_cast (type, NULL_TREE) at bottom */ 3769 if (TREE_OPERAND (decl, 0) == NULL_TREE) 3770 return build_functional_cast (type, NULL_TREE); 3771 3772 /* recurse */ 3773 decl = reparse_absdcl_as_expr (type, TREE_OPERAND (decl, 0)); 3774 3775 decl = build_x_function_call (decl, NULL_TREE, current_class_ref); 3776 3777 if (TREE_CODE (decl) == CALL_EXPR 3778 && (! TREE_TYPE (decl) 3779 || TREE_CODE (TREE_TYPE (decl)) != VOID_TYPE)) 3780 decl = require_complete_type (decl); 3781 3782 return decl; 3783} 3784 3785/* This is something of the form `int ((int)(int)(int)1)' that has turned 3786 out to be an expr. Since it was parsed like a type, we need to wade 3787 through and fix that. Since casts are right-associative, we are 3788 reversing the order, so we don't have to recurse. 3789 3790 In the above example, DECL is the `(int)(int)(int)', and EXPR is the 3791 `1'. */ 3792 3793tree 3794reparse_absdcl_as_casts (decl, expr) 3795 tree decl, expr; 3796{ 3797 tree type; 3798 3799 if (TREE_CODE (expr) == CONSTRUCTOR 3800 && TREE_TYPE (expr) == 0) 3801 { 3802 type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1))); 3803 decl = TREE_OPERAND (decl, 0); 3804 3805 if (IS_SIGNATURE (type)) 3806 { 3807 error ("cast specifies signature type"); 3808 return error_mark_node; 3809 } 3810 3811 expr = digest_init (type, expr, (tree *) 0); 3812 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0) 3813 { 3814 int failure = complete_array_type (type, expr, 1); 3815 if (failure) 3816 my_friendly_abort (78); 3817 } 3818 } 3819 3820 while (decl) 3821 { 3822 type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1))); 3823 decl = TREE_OPERAND (decl, 0); 3824 expr = build_c_cast (type, expr); 3825 } 3826 3827 if (warn_old_style_cast && ! in_system_header 3828 && current_lang_name != lang_name_c) 3829 warning ("use of old-style cast"); 3830 3831 return expr; 3832} 3833 3834/* Given plain tree nodes for an expression, build up the full semantics. */ 3835 3836tree 3837build_expr_from_tree (t) 3838 tree t; 3839{ 3840 if (t == NULL_TREE || t == error_mark_node) 3841 return t; 3842 3843 switch (TREE_CODE (t)) 3844 { 3845 case IDENTIFIER_NODE: 3846 return do_identifier (t, 0, NULL_TREE); 3847 3848 case LOOKUP_EXPR: 3849 if (LOOKUP_EXPR_GLOBAL (t)) 3850 return do_scoped_id (TREE_OPERAND (t, 0), 0); 3851 else 3852 return do_identifier (TREE_OPERAND (t, 0), 0, NULL_TREE); 3853 3854 case TEMPLATE_ID_EXPR: 3855 return (lookup_template_function 3856 (build_expr_from_tree (TREE_OPERAND (t, 0)), 3857 build_expr_from_tree (TREE_OPERAND (t, 1)))); 3858 3859 case INDIRECT_REF: 3860 return build_x_indirect_ref 3861 (build_expr_from_tree (TREE_OPERAND (t, 0)), "unary *"); 3862 3863 case CAST_EXPR: 3864 return build_functional_cast 3865 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0))); 3866 3867 case REINTERPRET_CAST_EXPR: 3868 return build_reinterpret_cast 3869 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0))); 3870 3871 case CONST_CAST_EXPR: 3872 return build_const_cast 3873 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0))); 3874 3875 case DYNAMIC_CAST_EXPR: 3876 return build_dynamic_cast 3877 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0))); 3878 3879 case STATIC_CAST_EXPR: 3880 return build_static_cast 3881 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0))); 3882 3883 case PREDECREMENT_EXPR: 3884 case PREINCREMENT_EXPR: 3885 case POSTDECREMENT_EXPR: 3886 case POSTINCREMENT_EXPR: 3887 case NEGATE_EXPR: 3888 case BIT_NOT_EXPR: 3889 case ABS_EXPR: 3890 case TRUTH_NOT_EXPR: 3891 case ADDR_EXPR: 3892 case CONVERT_EXPR: /* Unary + */ 3893 if (TREE_TYPE (t)) 3894 return t; 3895 return build_x_unary_op (TREE_CODE (t), 3896 build_expr_from_tree (TREE_OPERAND (t, 0))); 3897 3898 case PLUS_EXPR: 3899 case MINUS_EXPR: 3900 case MULT_EXPR: 3901 case TRUNC_DIV_EXPR: 3902 case CEIL_DIV_EXPR: 3903 case FLOOR_DIV_EXPR: 3904 case ROUND_DIV_EXPR: 3905 case EXACT_DIV_EXPR: 3906 case BIT_AND_EXPR: 3907 case BIT_ANDTC_EXPR: 3908 case BIT_IOR_EXPR: 3909 case BIT_XOR_EXPR: 3910 case TRUNC_MOD_EXPR: 3911 case FLOOR_MOD_EXPR: 3912 case TRUTH_ANDIF_EXPR: 3913 case TRUTH_ORIF_EXPR: 3914 case TRUTH_AND_EXPR: 3915 case TRUTH_OR_EXPR: 3916 case RSHIFT_EXPR: 3917 case LSHIFT_EXPR: 3918 case RROTATE_EXPR: 3919 case LROTATE_EXPR: 3920 case EQ_EXPR: 3921 case NE_EXPR: 3922 case MAX_EXPR: 3923 case MIN_EXPR: 3924 case LE_EXPR: 3925 case GE_EXPR: 3926 case LT_EXPR: 3927 case GT_EXPR: 3928 case MEMBER_REF: 3929 return build_x_binary_op 3930 (TREE_CODE (t), 3931 build_expr_from_tree (TREE_OPERAND (t, 0)), 3932 build_expr_from_tree (TREE_OPERAND (t, 1))); 3933 3934 case DOTSTAR_EXPR: 3935 return build_m_component_ref 3936 (build_expr_from_tree (TREE_OPERAND (t, 0)), 3937 build_expr_from_tree (TREE_OPERAND (t, 1))); 3938 3939 case SCOPE_REF: 3940 return build_offset_ref (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)); 3941 3942 case ARRAY_REF: 3943 if (TREE_OPERAND (t, 0) == NULL_TREE) 3944 /* new-type-id */ 3945 return build_parse_node (ARRAY_REF, NULL_TREE, 3946 build_expr_from_tree (TREE_OPERAND (t, 1))); 3947 return grok_array_decl (build_expr_from_tree (TREE_OPERAND (t, 0)), 3948 build_expr_from_tree (TREE_OPERAND (t, 1))); 3949 3950 case SIZEOF_EXPR: 3951 case ALIGNOF_EXPR: 3952 { 3953 tree r = build_expr_from_tree (TREE_OPERAND (t, 0)); 3954 if (TREE_CODE_CLASS (TREE_CODE (r)) != 't') 3955 r = TREE_TYPE (r); 3956 return TREE_CODE (t) == SIZEOF_EXPR ? c_sizeof (r) : c_alignof (r); 3957 } 3958 3959 case MODOP_EXPR: 3960 return build_x_modify_expr 3961 (build_expr_from_tree (TREE_OPERAND (t, 0)), 3962 TREE_CODE (TREE_OPERAND (t, 1)), 3963 build_expr_from_tree (TREE_OPERAND (t, 2))); 3964 3965 case ARROW_EXPR: 3966 return build_x_arrow 3967 (build_expr_from_tree (TREE_OPERAND (t, 0))); 3968 3969 case NEW_EXPR: 3970 return build_new 3971 (build_expr_from_tree (TREE_OPERAND (t, 0)), 3972 build_expr_from_tree (TREE_OPERAND (t, 1)), 3973 build_expr_from_tree (TREE_OPERAND (t, 2)), 3974 NEW_EXPR_USE_GLOBAL (t)); 3975 3976 case DELETE_EXPR: 3977 return delete_sanity 3978 (build_expr_from_tree (TREE_OPERAND (t, 0)), 3979 build_expr_from_tree (TREE_OPERAND (t, 1)), 3980 DELETE_EXPR_USE_VEC (t), DELETE_EXPR_USE_GLOBAL (t)); 3981 3982 case COMPOUND_EXPR: 3983 if (TREE_OPERAND (t, 1) == NULL_TREE) 3984 return build_x_compound_expr 3985 (build_expr_from_tree (TREE_OPERAND (t, 0))); 3986 else 3987 my_friendly_abort (42); 3988 3989 case METHOD_CALL_EXPR: 3990 if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF) 3991 { 3992 tree ref = TREE_OPERAND (t, 0); 3993 return build_scoped_method_call 3994 (build_expr_from_tree (TREE_OPERAND (t, 1)), 3995 build_expr_from_tree (TREE_OPERAND (ref, 0)), 3996 TREE_OPERAND (ref, 1), 3997 build_expr_from_tree (TREE_OPERAND (t, 2))); 3998 } 3999 else 4000 { 4001 tree fn = TREE_OPERAND (t, 0); 4002 4003 /* We can get a TEMPLATE_ID_EXPR here on code like: 4004 4005 x->f<2>(); 4006 4007 so we must resolve that. However, we can also get things 4008 like a BIT_NOT_EXPR here, when referring to a destructor, 4009 and things like that are not correctly resolved by 4010 build_expr_from_tree. So, just use build_expr_from_tree 4011 when we really need it. */ 4012 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) 4013 fn = lookup_template_function 4014 (TREE_OPERAND (fn, 0), 4015 build_expr_from_tree (TREE_OPERAND (fn, 1))); 4016 4017 return build_method_call 4018 (build_expr_from_tree (TREE_OPERAND (t, 1)), 4019 fn, 4020 build_expr_from_tree (TREE_OPERAND (t, 2)), 4021 NULL_TREE, LOOKUP_NORMAL); 4022 } 4023 4024 case CALL_EXPR: 4025 if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF) 4026 { 4027 tree ref = TREE_OPERAND (t, 0); 4028 return build_member_call 4029 (build_expr_from_tree (TREE_OPERAND (ref, 0)), 4030 TREE_OPERAND (ref, 1), 4031 build_expr_from_tree (TREE_OPERAND (t, 1))); 4032 } 4033 else 4034 { 4035 tree name = TREE_OPERAND (t, 0); 4036 tree id; 4037 tree args = build_expr_from_tree (TREE_OPERAND (t, 1)); 4038 if (args != NULL_TREE && TREE_CODE (name) == LOOKUP_EXPR 4039 && !LOOKUP_EXPR_GLOBAL (name) 4040 && TREE_CODE ((id = TREE_OPERAND (name, 0))) == IDENTIFIER_NODE 4041 && (!current_class_type 4042 || !lookup_member (current_class_type, id, 0, 0))) 4043 { 4044 /* Do Koenig lookup if there are no class members. */ 4045 name = do_identifier (id, 0, args); 4046 } 4047 else if (TREE_CODE (name) == TEMPLATE_ID_EXPR 4048 || ! really_overloaded_fn (name)) 4049 name = build_expr_from_tree (name); 4050 return build_x_function_call (name, args, current_class_ref); 4051 } 4052 4053 case COND_EXPR: 4054 return build_x_conditional_expr 4055 (build_expr_from_tree (TREE_OPERAND (t, 0)), 4056 build_expr_from_tree (TREE_OPERAND (t, 1)), 4057 build_expr_from_tree (TREE_OPERAND (t, 2))); 4058 4059 case TREE_LIST: 4060 { 4061 tree purpose, value, chain; 4062 4063 if (t == void_list_node) 4064 return t; 4065 4066 purpose = TREE_PURPOSE (t); 4067 if (purpose) 4068 purpose = build_expr_from_tree (purpose); 4069 value = TREE_VALUE (t); 4070 if (value) 4071 value = build_expr_from_tree (value); 4072 chain = TREE_CHAIN (t); 4073 if (chain && chain != void_type_node) 4074 chain = build_expr_from_tree (chain); 4075 return expr_tree_cons (purpose, value, chain); 4076 } 4077 4078 case COMPONENT_REF: 4079 { 4080 tree object = build_expr_from_tree (TREE_OPERAND (t, 0)); 4081 tree field = TREE_OPERAND (t, 1); 4082 4083 /* We use a COMPONENT_REF to indicate things of the form `x.b' 4084 and `x.A::b'. We must distinguish between those cases 4085 here. */ 4086 if (TREE_CODE (field) == SCOPE_REF) 4087 return build_object_ref (object, 4088 TREE_OPERAND (field, 0), 4089 TREE_OPERAND (field, 1)); 4090 else 4091 return build_x_component_ref (object, field, 4092 NULL_TREE, 1); 4093 } 4094 4095 case THROW_EXPR: 4096 return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0))); 4097 4098 case CONSTRUCTOR: 4099 { 4100 tree r; 4101 4102 /* digest_init will do the wrong thing if we let it. */ 4103 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 4104 return t; 4105 4106 r = build_nt (CONSTRUCTOR, NULL_TREE, 4107 build_expr_from_tree (CONSTRUCTOR_ELTS (t))); 4108 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t); 4109 4110 if (TREE_TYPE (t)) 4111 return digest_init (TREE_TYPE (t), r, 0); 4112 return r; 4113 } 4114 4115 case TYPEID_EXPR: 4116 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 0))) == 't') 4117 return get_typeid (TREE_OPERAND (t, 0)); 4118 return build_x_typeid (build_expr_from_tree (TREE_OPERAND (t, 0))); 4119 4120 case VAR_DECL: 4121 return convert_from_reference (t); 4122 4123 default: 4124 return t; 4125 } 4126} 4127 4128/* This is something of the form `int (*a)++' that has turned out to be an 4129 expr. It was only converted into parse nodes, so we need to go through 4130 and build up the semantics. Most of the work is done by 4131 build_expr_from_tree, above. 4132 4133 In the above example, TYPE is `int' and DECL is `*a'. */ 4134 4135tree 4136reparse_decl_as_expr (type, decl) 4137 tree type, decl; 4138{ 4139 decl = build_expr_from_tree (decl); 4140 if (type) 4141 return build_functional_cast (type, build_expr_list (NULL_TREE, decl)); 4142 else 4143 return decl; 4144} 4145 4146/* This is something of the form `int (*a)' that has turned out to be a 4147 decl. It was only converted into parse nodes, so we need to do the 4148 checking that make_{pointer,reference}_declarator do. */ 4149 4150tree 4151finish_decl_parsing (decl) 4152 tree decl; 4153{ 4154 extern int current_class_depth; 4155 4156 switch (TREE_CODE (decl)) 4157 { 4158 case IDENTIFIER_NODE: 4159 return decl; 4160 case INDIRECT_REF: 4161 return make_pointer_declarator 4162 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0))); 4163 case ADDR_EXPR: 4164 return make_reference_declarator 4165 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0))); 4166 case BIT_NOT_EXPR: 4167 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0)); 4168 return decl; 4169 case SCOPE_REF: 4170 push_nested_class (TREE_TYPE (TREE_OPERAND (decl, 0)), 3); 4171 TREE_COMPLEXITY (decl) = current_class_depth; 4172 return decl; 4173 case ARRAY_REF: 4174 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0)); 4175 return decl; 4176 case TREE_LIST: 4177 /* For attribute handling. */ 4178 TREE_VALUE (decl) = finish_decl_parsing (TREE_VALUE (decl)); 4179 return decl; 4180 default: 4181 my_friendly_abort (5); 4182 return NULL_TREE; 4183 } 4184} 4185 4186tree 4187check_cp_case_value (value) 4188 tree value; 4189{ 4190 if (value == NULL_TREE) 4191 return value; 4192 4193 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 4194 STRIP_TYPE_NOPS (value); 4195 4196 if (TREE_READONLY_DECL_P (value)) 4197 { 4198 value = decl_constant_value (value); 4199 STRIP_TYPE_NOPS (value); 4200 } 4201 value = fold (value); 4202 4203 if (TREE_CODE (value) != INTEGER_CST 4204 && value != error_mark_node) 4205 { 4206 cp_error ("case label `%E' does not reduce to an integer constant", 4207 value); 4208 value = error_mark_node; 4209 } 4210 else 4211 /* Promote char or short to int. */ 4212 value = default_conversion (value); 4213 4214 constant_expression_warning (value); 4215 4216 return value; 4217} 4218 4219/* Return 1 if root encloses child. */ 4220 4221static int 4222is_namespace_ancestor (root, child) 4223 tree root, child; 4224{ 4225 if (root == child) 4226 return 1; 4227 if (root == global_namespace) 4228 return 1; 4229 if (child == global_namespace) 4230 return 0; 4231 return is_namespace_ancestor (root, CP_DECL_CONTEXT (child)); 4232} 4233 4234 4235/* Return the namespace that is the common ancestor 4236 of two given namespaces. */ 4237 4238tree 4239namespace_ancestor (ns1, ns2) 4240 tree ns1, ns2; 4241{ 4242 if (is_namespace_ancestor (ns1, ns2)) 4243 return ns1; 4244 return namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2); 4245} 4246 4247/* Insert used into the using list of user. Set indirect_flag if this 4248 directive is not directly from the source. Also find the common 4249 ancestor and let our users know about the new namespace */ 4250static void 4251add_using_namespace (user, used, indirect) 4252 tree user; 4253 tree used; 4254 int indirect; 4255{ 4256 tree t; 4257 /* Using oneself is a no-op. */ 4258 if (user == used) 4259 return; 4260 my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380); 4261 my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380); 4262 /* Check if we already have this. */ 4263 t = purpose_member (used, DECL_NAMESPACE_USING (user)); 4264 if (t != NULL_TREE) 4265 { 4266 if (!indirect) 4267 /* Promote to direct usage. */ 4268 TREE_INDIRECT_USING (t) = 0; 4269 return; 4270 } 4271 4272 /* Add used to the user's using list. */ 4273 DECL_NAMESPACE_USING (user) 4274 = perm_tree_cons (used, namespace_ancestor (user, used), 4275 DECL_NAMESPACE_USING (user)); 4276 4277 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect; 4278 4279 /* Add user to the used's users list. */ 4280 DECL_NAMESPACE_USERS (used) 4281 = perm_tree_cons (user, 0, DECL_NAMESPACE_USERS (used)); 4282 4283 /* Recursively add all namespaces used. */ 4284 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t)) 4285 /* indirect usage */ 4286 add_using_namespace (user, TREE_PURPOSE (t), 1); 4287 4288 /* Tell everyone using us about the new used namespaces. */ 4289 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t)) 4290 add_using_namespace (TREE_PURPOSE (t), used, 1); 4291} 4292 4293/* Combines two sets of overloaded functions into an OVERLOAD chain, removing 4294 duplicates. The first list becomes the tail of the result. 4295 4296 The algorithm is O(n^2). We could get this down to O(n log n) by 4297 doing a sort on the addresses of the functions, if that becomes 4298 necessary. */ 4299 4300static tree 4301merge_functions (s1, s2) 4302 tree s1; 4303 tree s2; 4304{ 4305 for (; s2; s2 = OVL_NEXT (s2)) 4306 { 4307 tree fn = OVL_CURRENT (s2); 4308 if (! ovl_member (fn, s1)) 4309 s1 = build_overload (fn, s1); 4310 } 4311 return s1; 4312} 4313 4314/* This should return an error not all definitions define functions. 4315 It is not an error if we find two functions with exactly the 4316 same signature, only if these are selected in overload resolution. 4317 old is the current set of bindings, new the freshly-found binding. 4318 XXX Do we want to give *all* candidates in case of ambiguity? 4319 XXX In what way should I treat extern declarations? 4320 XXX I don't want to repeat the entire duplicate_decls here */ 4321 4322static tree 4323ambiguous_decl (name, old, new, flags) 4324 tree name; 4325 tree old; 4326 tree new; 4327 int flags; 4328{ 4329 tree val, type; 4330 my_friendly_assert (old != NULL_TREE, 393); 4331 /* Copy the value. */ 4332 val = BINDING_VALUE (new); 4333 if (val) 4334 switch (TREE_CODE (val)) 4335 { 4336 case TEMPLATE_DECL: 4337 /* If we expect types or namespaces, and not templates, 4338 or this is not a template class. */ 4339 if (LOOKUP_QUALIFIERS_ONLY (flags) 4340 && !DECL_CLASS_TEMPLATE_P (val)) 4341 val = NULL_TREE; 4342 break; 4343 case TYPE_DECL: 4344 if (LOOKUP_NAMESPACES_ONLY (flags)) 4345 val = NULL_TREE; 4346 break; 4347 case NAMESPACE_DECL: 4348 if (LOOKUP_TYPES_ONLY (flags)) 4349 val = NULL_TREE; 4350 break; 4351 default: 4352 if (LOOKUP_QUALIFIERS_ONLY (flags)) 4353 val = NULL_TREE; 4354 } 4355 4356 if (!BINDING_VALUE (old)) 4357 BINDING_VALUE (old) = val; 4358 else if (val && val != BINDING_VALUE (old)) 4359 { 4360 if (is_overloaded_fn (BINDING_VALUE (old)) 4361 && is_overloaded_fn (val)) 4362 { 4363 BINDING_VALUE (old) = merge_functions (BINDING_VALUE (old), 4364 val); 4365 } 4366 else 4367 { 4368 /* Some declarations are functions, some are not. */ 4369 if (flags & LOOKUP_COMPLAIN) 4370 { 4371 /* If we've already given this error for this lookup, 4372 BINDING_VALUE (old) is error_mark_node, so let's not 4373 repeat ourselves. */ 4374 if (BINDING_VALUE (old) != error_mark_node) 4375 { 4376 cp_error ("use of `%D' is ambiguous", name); 4377 cp_error_at (" first declared as `%#D' here", 4378 BINDING_VALUE (old)); 4379 } 4380 cp_error_at (" also declared as `%#D' here", val); 4381 } 4382 return error_mark_node; 4383 } 4384 } 4385 /* ... and copy the type. */ 4386 type = BINDING_TYPE (new); 4387 if (LOOKUP_NAMESPACES_ONLY (flags)) 4388 type = NULL_TREE; 4389 if (!BINDING_TYPE (old)) 4390 BINDING_TYPE (old) = type; 4391 else if (type && BINDING_TYPE (old) != type) 4392 { 4393 if (flags & LOOKUP_COMPLAIN) 4394 { 4395 cp_error ("`%D' denotes an ambiguous type",name); 4396 cp_error_at (" first type here", BINDING_TYPE (old)); 4397 cp_error_at (" other type here", type); 4398 } 4399 } 4400 return old; 4401} 4402 4403/* Add the bindings of name in used namespaces to val. 4404 The using list is defined by usings, and the lookup goes to scope. 4405 Returns zero on errors. */ 4406 4407int 4408lookup_using_namespace (name, val, usings, scope, flags) 4409 tree name, val, usings, scope; 4410 int flags; 4411{ 4412 tree iter; 4413 tree val1; 4414 /* Iterate over all used namespaces in current, searching for using 4415 directives of scope. */ 4416 for (iter = usings; iter; iter = TREE_CHAIN (iter)) 4417 if (TREE_VALUE (iter) == scope) 4418 { 4419 val1 = binding_for_name (name, TREE_PURPOSE (iter)); 4420 /* Resolve ambiguities. */ 4421 val = ambiguous_decl (name, val, val1, flags); 4422 } 4423 return val != error_mark_node; 4424} 4425 4426/* [namespace.qual] 4427 Excepts the name to lookup and its qualifying scope. 4428 Returns the name/type pair found into the CPLUS_BINDING result, 4429 or 0 on error. */ 4430 4431int 4432qualified_lookup_using_namespace (name, scope, result, flags) 4433 tree name; 4434 tree scope; 4435 tree result; 4436 int flags; 4437{ 4438 /* Maintain a list of namespaces visited... */ 4439 tree seen = NULL_TREE; 4440 /* ... and a list of namespace yet to see. */ 4441 tree todo = NULL_TREE; 4442 tree usings; 4443 while (scope && (result != error_mark_node)) 4444 { 4445 seen = temp_tree_cons (scope, NULL_TREE, seen); 4446 result = ambiguous_decl (name, result, 4447 binding_for_name (name, scope), flags); 4448 if (!BINDING_VALUE (result) && !BINDING_TYPE (result)) 4449 /* Consider using directives. */ 4450 for (usings = DECL_NAMESPACE_USING (scope); usings; 4451 usings = TREE_CHAIN (usings)) 4452 /* If this was a real directive, and we have not seen it. */ 4453 if (!TREE_INDIRECT_USING (usings) 4454 && !purpose_member (TREE_PURPOSE (usings), seen)) 4455 todo = temp_tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo); 4456 if (todo) 4457 { 4458 scope = TREE_PURPOSE (todo); 4459 todo = TREE_CHAIN (todo); 4460 } 4461 else 4462 scope = NULL_TREE; /* If there never was a todo list. */ 4463 } 4464 return result != error_mark_node; 4465} 4466 4467/* [namespace.memdef]/2 */ 4468 4469/* Set the context of a declaration to scope. Complain if we are not 4470 outside scope. */ 4471 4472void 4473set_decl_namespace (decl, scope, friendp) 4474 tree decl; 4475 tree scope; 4476 int friendp; 4477{ 4478 tree old; 4479 if (scope == std_node) 4480 scope = global_namespace; 4481 /* Get rid of namespace aliases. */ 4482 scope = ORIGINAL_NAMESPACE (scope); 4483 4484 /* It is ok for friends to be qualified in parallel space. */ 4485 if (!friendp && !is_namespace_ancestor (current_namespace, scope)) 4486 cp_error ("declaration of `%D' not in a namespace surrounding `%D'", 4487 decl, scope); 4488 DECL_CONTEXT (decl) = FROB_CONTEXT (scope); 4489 if (scope != current_namespace) 4490 { 4491 /* See whether this has been declared in the namespace. */ 4492 old = namespace_binding (DECL_NAME (decl), scope); 4493 if (!old) 4494 /* No old declaration at all. */ 4495 goto complain; 4496 if (!is_overloaded_fn (decl)) 4497 /* Don't compare non-function decls with decls_match here, 4498 since it can't check for the correct constness at this 4499 point. pushdecl will find those errors later. */ 4500 return; 4501 /* Since decl is a function, old should contain a function decl. */ 4502 if (!is_overloaded_fn (old)) 4503 goto complain; 4504 if (processing_template_decl || processing_specialization) 4505 /* We have not yet called push_template_decl to turn the 4506 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations 4507 won't match. But, we'll check later, when we construct the 4508 template. */ 4509 return; 4510 for (; old; old = OVL_NEXT (old)) 4511 if (decls_match (decl, OVL_CURRENT (old))) 4512 return; 4513 } 4514 else 4515 return; 4516 complain: 4517 cp_error ("`%D' should have been declared inside `%D'", 4518 decl, scope); 4519} 4520 4521/* Compute the namespace where a declaration is defined. */ 4522 4523static tree 4524decl_namespace (decl) 4525 tree decl; 4526{ 4527 while (DECL_CONTEXT (decl)) 4528 { 4529 decl = DECL_CONTEXT (decl); 4530 if (TREE_CODE (decl) == NAMESPACE_DECL) 4531 return decl; 4532 if (TREE_CODE_CLASS (TREE_CODE (decl)) == 't') 4533 decl = TYPE_STUB_DECL (decl); 4534 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd', 390); 4535 } 4536 4537 return global_namespace; 4538} 4539 4540/* Return the namespace where the current declaration is declared. */ 4541 4542tree 4543current_decl_namespace () 4544{ 4545 tree result; 4546 /* If we have been pushed into a different namespace, use it. */ 4547 if (decl_namespace_list) 4548 return TREE_PURPOSE (decl_namespace_list); 4549 4550 if (current_class_type) 4551 result = decl_namespace (TYPE_STUB_DECL (current_class_type)); 4552 else if (current_function_decl) 4553 result = decl_namespace (current_function_decl); 4554 else 4555 result = current_namespace; 4556 return result; 4557} 4558 4559/* Temporarily set the namespace for the current declaration. */ 4560 4561void 4562push_decl_namespace (decl) 4563 tree decl; 4564{ 4565 if (TREE_CODE (decl) != NAMESPACE_DECL) 4566 decl = decl_namespace (decl); 4567 decl_namespace_list = tree_cons (decl, NULL_TREE, decl_namespace_list); 4568} 4569 4570void 4571pop_decl_namespace () 4572{ 4573 decl_namespace_list = TREE_CHAIN (decl_namespace_list); 4574} 4575 4576/* Enter a class or namespace scope. */ 4577 4578void 4579push_scope (t) 4580 tree t; 4581{ 4582 if (TREE_CODE (t) == NAMESPACE_DECL) 4583 push_decl_namespace (t); 4584 else 4585 pushclass (t, 2); 4586} 4587 4588/* Leave scope pushed by push_scope. */ 4589 4590void 4591pop_scope (t) 4592 tree t; 4593{ 4594 if (TREE_CODE (t) == NAMESPACE_DECL) 4595 pop_decl_namespace (); 4596 else 4597 popclass (); 4598} 4599 4600/* [basic.lookup.koenig] */ 4601/* A non-zero return value in the functions below indicates an error. 4602 All nodes allocated in the procedure are on the scratch obstack. */ 4603 4604struct arg_lookup 4605{ 4606 tree name; 4607 tree namespaces; 4608 tree classes; 4609 tree functions; 4610}; 4611 4612static int arg_assoc PROTO((struct arg_lookup*, tree)); 4613static int arg_assoc_args PROTO((struct arg_lookup*, tree)); 4614static int arg_assoc_type PROTO((struct arg_lookup*, tree)); 4615static int add_function PROTO((struct arg_lookup *, tree)); 4616static int arg_assoc_namespace PROTO((struct arg_lookup *, tree)); 4617static int arg_assoc_class PROTO((struct arg_lookup *, tree)); 4618 4619/* Add a function to the lookup structure. 4620 Returns 1 on error. */ 4621 4622static int 4623add_function (k, fn) 4624 struct arg_lookup *k; 4625 tree fn; 4626{ 4627 if (ovl_member (fn, k->functions)) 4628 return 0; 4629 /* We must find only functions, or exactly one non-function. */ 4630 if (k->functions && is_overloaded_fn (k->functions) 4631 && is_overloaded_fn (fn)) 4632 k->functions = build_overload (fn, k->functions); 4633 else 4634 if(k->functions) 4635 { 4636 tree f1 = OVL_CURRENT (k->functions); 4637 tree f2 = fn; 4638 if (is_overloaded_fn (f1)) 4639 { 4640 fn = f1; f1 = f2; f2 = fn; 4641 } 4642 cp_error_at ("`%D' is not a function,", f1); 4643 cp_error_at (" conflict with `%D'", f2); 4644 cp_error (" in call to `%D'", k->name); 4645 return 1; 4646 } 4647 else 4648 k->functions = fn; 4649 return 0; 4650} 4651 4652/* Add functions of a namespace to the lookup structure. 4653 Returns 1 on error. */ 4654 4655static int 4656arg_assoc_namespace (k, scope) 4657 struct arg_lookup *k; 4658 tree scope; 4659{ 4660 tree value; 4661 4662 if (purpose_member (scope, k->namespaces)) 4663 return 0; 4664 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces); 4665 4666 value = namespace_binding (k->name, scope); 4667 if (!value) 4668 return 0; 4669 4670 for (; value; value = OVL_NEXT (value)) 4671 if (add_function (k, OVL_CURRENT (value))) 4672 return 1; 4673 4674 return 0; 4675} 4676 4677/* Adds everything associated with class to the lookup structure. 4678 Returns 1 on error. */ 4679 4680static int 4681arg_assoc_class (k, type) 4682 struct arg_lookup* k; 4683 tree type; 4684{ 4685 tree list, friends, context; 4686 int i; 4687 4688 if (purpose_member (type, k->classes)) 4689 return 0; 4690 k->classes = tree_cons (type, NULL_TREE, k->classes); 4691 4692 context = decl_namespace (TYPE_MAIN_DECL (type)); 4693 if (arg_assoc_namespace (k, context)) 4694 return 1; 4695 4696 /* Process baseclasses. */ 4697 for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++) 4698 if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i))) 4699 return 1; 4700 4701 /* Process friends. */ 4702 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list; 4703 list = TREE_CHAIN (list)) 4704 if (k->name == TREE_PURPOSE (list)) 4705 for (friends = TREE_VALUE (list); friends; 4706 friends = TREE_CHAIN (friends)) 4707 /* Only interested in global functions with potentially hidden 4708 (i.e. unqualified) declarations. */ 4709 if (TREE_PURPOSE (list) == error_mark_node && TREE_VALUE (list) 4710 && decl_namespace (TREE_VALUE (list)) == context) 4711 if (add_function (k, TREE_VALUE (list))) 4712 return 1; 4713 4714 /* Process template arguments. */ 4715 if (CLASSTYPE_TEMPLATE_INFO (type)) 4716 { 4717 list = innermost_args (CLASSTYPE_TI_ARGS (type)); 4718 for (i = 0; i < TREE_VEC_LENGTH (list); ++i) 4719 arg_assoc (k, TREE_VEC_ELT (list, i)); 4720 } 4721 4722 return 0; 4723} 4724 4725/* Adds everything associated with a given type. 4726 Returns 1 on error. */ 4727 4728static int 4729arg_assoc_type (k, type) 4730 struct arg_lookup *k; 4731 tree type; 4732{ 4733 switch (TREE_CODE (type)) 4734 { 4735 case VOID_TYPE: 4736 case INTEGER_TYPE: 4737 case REAL_TYPE: 4738 case COMPLEX_TYPE: 4739 case CHAR_TYPE: 4740 case BOOLEAN_TYPE: 4741 return 0; 4742 case RECORD_TYPE: 4743 if (TYPE_PTRMEMFUNC_P (type)) 4744 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type)); 4745 return arg_assoc_class (k, type); 4746 case POINTER_TYPE: 4747 case REFERENCE_TYPE: 4748 case ARRAY_TYPE: 4749 return arg_assoc_type (k, TREE_TYPE (type)); 4750 case UNION_TYPE: 4751 case ENUMERAL_TYPE: 4752 return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type))); 4753 case OFFSET_TYPE: 4754 /* Pointer to member: associate class type and value type. */ 4755 if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type))) 4756 return 1; 4757 return arg_assoc_type (k, TREE_TYPE (type)); 4758 case METHOD_TYPE: 4759 /* The basetype is referenced in the first arg type, so just 4760 fall through. */ 4761 case FUNCTION_TYPE: 4762 /* Associate the parameter types. */ 4763 if (arg_assoc_args (k, TYPE_ARG_TYPES (type))) 4764 return 1; 4765 /* Associate the return type. */ 4766 return arg_assoc_type (k, TREE_TYPE (type)); 4767 case TEMPLATE_TYPE_PARM: 4768 case TEMPLATE_TEMPLATE_PARM: 4769 return 0; 4770 case LANG_TYPE: 4771 if (type == unknown_type_node) 4772 return 0; 4773 /* else fall through */ 4774 default: 4775 my_friendly_abort (390); 4776 } 4777 return 0; 4778} 4779 4780/* Adds everything associated with arguments. Returns 1 on error. */ 4781 4782static int 4783arg_assoc_args (k, args) 4784 struct arg_lookup* k; 4785 tree args; 4786{ 4787 for (; args; args = TREE_CHAIN (args)) 4788 if (arg_assoc (k, TREE_VALUE (args))) 4789 return 1; 4790 return 0; 4791} 4792 4793/* Adds everything associated with a given tree_node. Returns 1 on error. */ 4794 4795static int 4796arg_assoc (k, n) 4797 struct arg_lookup* k; 4798 tree n; 4799{ 4800 if (n == error_mark_node) 4801 return 0; 4802 4803 if (TREE_CODE_CLASS (TREE_CODE (n)) == 't') 4804 return arg_assoc_type (k, n); 4805 4806 if (! type_unknown_p (n)) 4807 return arg_assoc_type (k, TREE_TYPE (n)); 4808 4809 if (TREE_CODE (n) == ADDR_EXPR) 4810 n = TREE_OPERAND (n, 0); 4811 if (TREE_CODE (n) == COMPONENT_REF) 4812 n = TREE_OPERAND (n, 1); 4813 if (TREE_CODE (n) == OFFSET_REF) 4814 n = TREE_OPERAND (n, 1); 4815 while (TREE_CODE (n) == TREE_LIST) 4816 n = TREE_VALUE (n); 4817 4818 if (TREE_CODE (n) == FUNCTION_DECL) 4819 return arg_assoc_type (k, TREE_TYPE (n)); 4820 if (TREE_CODE (n) == TEMPLATE_ID_EXPR) 4821 { 4822 /* [basic.lookup.koenig] 4823 4824 If T is a template-id, its associated namespaces and classes 4825 are the namespace in which the template is defined; for 4826 member templates, the member template's class; the namespaces 4827 and classes associated with the types of the template 4828 arguments provided for template type parameters (excluding 4829 template template parameters); the namespaces in which any 4830 template template arguments are defined; and the classes in 4831 which any member templates used as template template 4832 arguments are defined. [Note: non-type template arguments do 4833 not contribute to the set of associated namespaces. ] */ 4834 tree template = TREE_OPERAND (n, 0); 4835 tree args = TREE_OPERAND (n, 1); 4836 tree ctx; 4837 tree arg; 4838 4839 /* First, the template. There may actually be more than one if 4840 this is an overloaded function template. But, in that case, 4841 we only need the first; all the functions will be in the same 4842 namespace. */ 4843 template = OVL_CURRENT (template); 4844 4845 ctx = CP_DECL_CONTEXT (template); 4846 4847 if (TREE_CODE (ctx) == NAMESPACE_DECL) 4848 { 4849 if (arg_assoc_namespace (k, ctx) == 1) 4850 return 1; 4851 } 4852 /* It must be a member template. */ 4853 else if (arg_assoc_class (k, ctx) == 1) 4854 return 1; 4855 4856 /* Now the arguments. */ 4857 for (arg = args; arg != NULL_TREE; arg = TREE_CHAIN (arg)) 4858 { 4859 tree t = TREE_VALUE (arg); 4860 4861 if (TREE_CODE (t) == TEMPLATE_DECL) 4862 { 4863 ctx = CP_DECL_CONTEXT (t); 4864 if (TREE_CODE (ctx) == NAMESPACE_DECL) 4865 { 4866 if (arg_assoc_namespace (k, ctx) == 1) 4867 return 1; 4868 } 4869 else if (arg_assoc_class (k, ctx) == 1) 4870 return 1; 4871 } 4872 else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't' 4873 && arg_assoc_type (k, t) == 1) 4874 return 1; 4875 } 4876 } 4877 else 4878 { 4879 my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715); 4880 4881 for (; n; n = OVL_CHAIN (n)) 4882 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n)))) 4883 return 1; 4884 } 4885 4886 return 0; 4887} 4888 4889/* Performs Koenig lookup depending on arguments, where fns 4890 are the functions found in normal lookup. */ 4891 4892tree 4893lookup_arg_dependent (name, fns, args) 4894 tree name; 4895 tree fns; 4896 tree args; 4897{ 4898 struct arg_lookup k; 4899 4900 k.name = name; 4901 k.functions = fns; 4902 k.classes = NULL_TREE; 4903 4904 /* Note that we've already looked at the current namespace during normal 4905 unqualified lookup, unless we found a decl in function scope. */ 4906 if (fns && ! TREE_PERMANENT (OVL_CURRENT (fns))) 4907 k.namespaces = NULL_TREE; 4908 else 4909 k.namespaces = scratch_tree_cons (current_decl_namespace (), 4910 NULL_TREE, NULL_TREE); 4911 4912 push_scratch_obstack (); 4913 arg_assoc_args (&k, args); 4914 pop_obstacks (); 4915 return k.functions; 4916} 4917 4918/* Process a namespace-alias declaration. */ 4919 4920void 4921do_namespace_alias (alias, namespace) 4922 tree alias, namespace; 4923{ 4924 if (TREE_CODE (namespace) != NAMESPACE_DECL) 4925 { 4926 /* The parser did not find it, so it's not there. */ 4927 cp_error ("unknown namespace `%D'", namespace); 4928 return; 4929 } 4930 4931 namespace = ORIGINAL_NAMESPACE (namespace); 4932 4933 /* Build the alias. */ 4934 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node); 4935 DECL_NAMESPACE_ALIAS (alias) = namespace; 4936 pushdecl (alias); 4937} 4938 4939/* Check a non-member using-declaration. Return the name and scope 4940 being used, and the USING_DECL, or NULL_TREE on failure. */ 4941 4942static tree 4943validate_nonmember_using_decl (decl, scope, name) 4944 tree decl; 4945 tree *scope; 4946 tree *name; 4947{ 4948 if (TREE_CODE (decl) == SCOPE_REF 4949 && TREE_OPERAND (decl, 0) == std_node) 4950 { 4951 if (namespace_bindings_p () 4952 && current_namespace == global_namespace) 4953 /* There's no need for a using declaration at all, here, 4954 since `std' is the same as `::'. We can't just pass this 4955 on because we'll complain later about declaring something 4956 in the same scope as a using declaration with the same 4957 name. We return NULL_TREE which indicates to the caller 4958 that there's no need to do any further processing. */ 4959 return NULL_TREE; 4960 4961 *scope = global_namespace; 4962 *name = TREE_OPERAND (decl, 1); 4963 } 4964 else if (TREE_CODE (decl) == SCOPE_REF) 4965 { 4966 *scope = TREE_OPERAND (decl, 0); 4967 *name = TREE_OPERAND (decl, 1); 4968 4969 /* [namespace.udecl] 4970 4971 A using-declaration for a class member shall be a 4972 member-declaration. */ 4973 if (TREE_CODE (*scope) != NAMESPACE_DECL) 4974 { 4975 if (TYPE_P (*scope)) 4976 cp_error ("`%T' is not a namespace", *scope); 4977 else 4978 cp_error ("`%D' is not a namespace", *scope); 4979 return NULL_TREE; 4980 } 4981 } 4982 else if (TREE_CODE (decl) == IDENTIFIER_NODE 4983 || TREE_CODE (decl) == TYPE_DECL 4984 || TREE_CODE (decl) == TEMPLATE_DECL) 4985 { 4986 *scope = global_namespace; 4987 *name = decl; 4988 } 4989 else 4990 my_friendly_abort (382); 4991 if (TREE_CODE_CLASS (TREE_CODE (*name)) == 'd') 4992 *name = DECL_NAME (*name); 4993 /* Make a USING_DECL. */ 4994 return push_using_decl (*scope, *name); 4995} 4996 4997/* Process local and global using-declarations. */ 4998 4999static void 5000do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype) 5001 tree scope, name; 5002 tree oldval, oldtype; 5003 tree *newval, *newtype; 5004{ 5005 tree decls; 5006 struct tree_binding _decls; 5007 5008 *newval = *newtype = NULL_TREE; 5009 decls = binding_init (&_decls); 5010 if (!qualified_lookup_using_namespace (name, scope, decls, 0)) 5011 /* Lookup error */ 5012 return; 5013 5014 if (!BINDING_VALUE (decls) && !BINDING_TYPE (decls)) 5015 { 5016 cp_error ("`%D' not declared", name); 5017 return; 5018 } 5019 5020 /* Check for using functions. */ 5021 if (BINDING_VALUE (decls) && is_overloaded_fn (BINDING_VALUE (decls))) 5022 { 5023 tree tmp, tmp1; 5024 5025 if (oldval && !is_overloaded_fn (oldval)) 5026 { 5027 duplicate_decls (OVL_CURRENT (BINDING_VALUE (decls)), oldval); 5028 oldval = NULL_TREE; 5029 } 5030 5031 *newval = oldval; 5032 for (tmp = BINDING_VALUE (decls); tmp; tmp = OVL_NEXT (tmp)) 5033 { 5034 tree new_fn = OVL_CURRENT (tmp); 5035 5036 /* [namespace.udecl] 5037 5038 If a function declaration in namespace scope or block 5039 scope has the same name and the same parameter types as a 5040 function introduced by a using declaration the program is 5041 ill-formed. */ 5042 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1)) 5043 { 5044 tree old_fn = OVL_CURRENT (tmp1); 5045 5046 if (!OVL_USED (tmp1) 5047 && compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)), 5048 TYPE_ARG_TYPES (TREE_TYPE (old_fn)))) 5049 { 5050 /* There was already a non-using declaration in 5051 this scope with the same parameter types. */ 5052 cp_error ("`%D' is already declared in this scope", 5053 name); 5054 break; 5055 } 5056 else if (duplicate_decls (new_fn, old_fn)) 5057 /* We're re-using something we already used 5058 before. We don't need to add it again. */ 5059 break; 5060 } 5061 5062 /* If we broke out of the loop, there's no reason to add 5063 this function to the using declarations for this 5064 scope. */ 5065 if (tmp1) 5066 continue; 5067 5068 *newval = build_overload (OVL_CURRENT (tmp), *newval); 5069 if (TREE_CODE (*newval) != OVERLOAD) 5070 *newval = ovl_cons (*newval, NULL_TREE); 5071 OVL_USED (*newval) = 1; 5072 } 5073 } 5074 else 5075 { 5076 *newval = BINDING_VALUE (decls); 5077 if (oldval) 5078 duplicate_decls (*newval, oldval); 5079 } 5080 5081 *newtype = BINDING_TYPE (decls); 5082 if (oldtype && *newtype && oldtype != *newtype) 5083 { 5084 cp_error ("using directive `%D' introduced ambiguous type `%T'", 5085 name, oldtype); 5086 return; 5087 } 5088} 5089 5090/* Process a using-declaration not appearing in class or local scope. */ 5091 5092void 5093do_toplevel_using_decl (decl) 5094 tree decl; 5095{ 5096 tree scope, name, binding; 5097 tree oldval, oldtype, newval, newtype; 5098 5099 decl = validate_nonmember_using_decl (decl, &scope, &name); 5100 if (decl == NULL_TREE) 5101 return; 5102 5103 binding = binding_for_name (name, current_namespace); 5104 5105 oldval = BINDING_VALUE (binding); 5106 oldtype = BINDING_TYPE (binding); 5107 5108 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype); 5109 5110 /* Copy declarations found. */ 5111 if (newval) 5112 BINDING_VALUE (binding) = newval; 5113 if (newtype) 5114 BINDING_TYPE (binding) = newtype; 5115 return; 5116} 5117 5118/* Process a using-declaration at function scope. */ 5119 5120void 5121do_local_using_decl (decl) 5122 tree decl; 5123{ 5124 tree scope, name; 5125 tree oldval, oldtype, newval, newtype; 5126 5127 decl = validate_nonmember_using_decl (decl, &scope, &name); 5128 if (decl == NULL_TREE) 5129 return; 5130 5131 oldval = lookup_name_current_level (name); 5132 oldtype = lookup_type_current_level (name); 5133 5134 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype); 5135 5136 if (newval) 5137 { 5138 if (is_overloaded_fn (newval)) 5139 { 5140 tree fn, term; 5141 5142 /* We only need to push declarations for those functions 5143 that were not already bound in the current level. 5144 The old value might be NULL_TREE, it might be a single 5145 function, or an OVERLOAD. */ 5146 if (oldval && TREE_CODE (oldval) == OVERLOAD) 5147 term = OVL_FUNCTION (oldval); 5148 else 5149 term = oldval; 5150 for (fn = newval; fn && OVL_CURRENT (fn) != term; 5151 fn = OVL_NEXT (fn)) 5152 push_overloaded_decl (OVL_CURRENT (fn), 5153 PUSH_LOCAL | PUSH_USING); 5154 } 5155 else 5156 push_local_binding (name, newval, PUSH_USING); 5157 } 5158 if (newtype) 5159 set_identifier_type_value (name, newtype); 5160} 5161 5162tree 5163do_class_using_decl (decl) 5164 tree decl; 5165{ 5166 tree name, value; 5167 5168 if (TREE_CODE (decl) != SCOPE_REF 5169 || TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (decl, 0))) != 't') 5170 { 5171 cp_error ("using-declaration for non-member at class scope"); 5172 return NULL_TREE; 5173 } 5174 name = TREE_OPERAND (decl, 1); 5175 if (TREE_CODE (name) == BIT_NOT_EXPR) 5176 { 5177 cp_error ("using-declaration for destructor"); 5178 return NULL_TREE; 5179 } 5180 if (TREE_CODE (name) == TYPE_DECL) 5181 name = DECL_NAME (name); 5182 5183 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716); 5184 5185 value = build_lang_field_decl (USING_DECL, name, void_type_node); 5186 DECL_INITIAL (value) = TREE_OPERAND (decl, 0); 5187 return value; 5188} 5189 5190/* Process a using-directive. */ 5191 5192void 5193do_using_directive (namespace) 5194 tree namespace; 5195{ 5196 if (namespace == std_node) 5197 return; 5198 /* using namespace A::B::C; */ 5199 if (TREE_CODE (namespace) == SCOPE_REF) 5200 namespace = TREE_OPERAND (namespace, 1); 5201 if (TREE_CODE (namespace) == IDENTIFIER_NODE) 5202 { 5203 /* Lookup in lexer did not find a namespace. */ 5204 cp_error ("namespace `%T' undeclared", namespace); 5205 return; 5206 } 5207 if (TREE_CODE (namespace) != NAMESPACE_DECL) 5208 { 5209 cp_error ("`%T' is not a namespace", namespace); 5210 return; 5211 } 5212 namespace = ORIGINAL_NAMESPACE (namespace); 5213 if (!toplevel_bindings_p ()) 5214 push_using_directive (namespace); 5215 else 5216 /* direct usage */ 5217 add_using_namespace (current_namespace, namespace, 0); 5218} 5219 5220void 5221check_default_args (x) 5222 tree x; 5223{ 5224 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x)); 5225 int saw_def = 0, i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE); 5226 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i) 5227 { 5228 if (TREE_PURPOSE (arg)) 5229 saw_def = 1; 5230 else if (saw_def) 5231 { 5232 cp_error_at ("default argument missing for parameter %P of `%+#D'", 5233 i, x); 5234 break; 5235 } 5236 } 5237} 5238 5239void 5240mark_used (decl) 5241 tree decl; 5242{ 5243 TREE_USED (decl) = 1; 5244 if (processing_template_decl) 5245 return; 5246 assemble_external (decl); 5247 5248 /* Is it a synthesized method that needs to be synthesized? */ 5249 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CLASS_CONTEXT (decl) 5250 && DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl) 5251 /* Kludge: don't synthesize for default args. */ 5252 && current_function_decl) 5253 synthesize_method (decl); 5254 5255 /* If this is a function or variable that is an instance of some 5256 template, we now know that we will need to actually do the 5257 instantiation. A TEMPLATE_DECL may also have DECL_TEMPLATE_INFO, 5258 if it's a partial instantiation, but there's no need to 5259 instantiate such a thing. We check that DECL is not an explicit 5260 instantiation because that is not checked in instantiate_decl. */ 5261 if (TREE_CODE (decl) != TEMPLATE_DECL 5262 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl) 5263 && !DECL_EXPLICIT_INSTANTIATION (decl)) 5264 instantiate_decl (decl); 5265} 5266 5267/* Helper function for named_class_head_sans_basetype nonterminal. We 5268 have just seen something of the form `AGGR SCOPE::ID'. Return a 5269 TYPE_DECL for the type declared by ID in SCOPE. */ 5270 5271tree 5272handle_class_head (aggr, scope, id) 5273 tree aggr, scope, id; 5274{ 5275 tree decl; 5276 5277 if (TREE_CODE (id) == TYPE_DECL) 5278 decl = id; 5279 else if (DECL_CLASS_TEMPLATE_P (id)) 5280 decl = DECL_TEMPLATE_RESULT (id); 5281 else 5282 { 5283 if (scope) 5284 cp_error ("`%T' does not have a nested type named `%D'", scope, id); 5285 else 5286 cp_error ("no file-scope type named `%D'", id); 5287 5288 decl = TYPE_MAIN_DECL (xref_tag (aggr, make_anon_name (), 1)); 5289 } 5290 5291 /* This syntax is only allowed when we're defining a type, so we 5292 enter the SCOPE. */ 5293 push_scope (CP_DECL_CONTEXT (decl)); 5294 5295 /* If we see something like: 5296 5297 template <typename T> struct S::I .... 5298 5299 we must create a TEMPLATE_DECL for the nested type. */ 5300 if (PROCESSING_REAL_TEMPLATE_DECL_P ()) 5301 decl = push_template_decl (decl); 5302 5303 return decl; 5304} 5305