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. --- 26 unchanged lines hidden (view full) --- 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. */ --- 53 unchanged lines hidden (view full) --- 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 --- 9 unchanged lines hidden (view full) --- 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 --- 14 unchanged lines hidden (view full) --- 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 --- 72 unchanged lines hidden (view full) --- 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 --- 7 unchanged lines hidden (view full) --- 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 --- 50 unchanged lines hidden (view full) --- 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 { --- 7 unchanged lines hidden (view full) --- 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; --- 69 unchanged lines hidden (view full) --- 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 --- 13 unchanged lines hidden (view full) --- 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; --- 30 unchanged lines hidden (view full) --- 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 --- 58 unchanged lines hidden (view full) --- 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 --- 47 unchanged lines hidden (view full) --- 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 --- 49 unchanged lines hidden (view full) --- 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; --- 62 unchanged lines hidden (view full) --- 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, --- 46 unchanged lines hidden (view full) --- 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); --- 20 unchanged lines hidden (view full) --- 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. --- 33 unchanged lines hidden (view full) --- 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 { --- 61 unchanged lines hidden (view full) --- 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. */ --- 53 unchanged lines hidden (view full) --- 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 { --- 10 unchanged lines hidden (view full) --- 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) --- 36 unchanged lines hidden (view full) --- 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) --- 142 unchanged lines hidden (view full) --- 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 --- 67 unchanged lines hidden (view full) --- 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; --- 52 unchanged lines hidden (view full) --- 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++) --- 22 unchanged lines hidden (view full) --- 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 --- 12 unchanged lines hidden (view full) --- 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'"); --- 25 unchanged lines hidden (view full) --- 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)) --- 9 unchanged lines hidden (view full) --- 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 /* This is not necessary on targets that support weak symbols, because 2489 the implicit instantiations will defer to the explicit one. */ 2490 if (! supports_one_only () || SUPPORTS_WEAK) 2491 return; 2492 2493 /* We can't set DECL_COMDAT on functions, or finish_file will think |
2494 we can get away with not emitting them if they aren't used. We need 2495 to for variables so that cp_finish_decl will update their linkage, 2496 because their DECL_INITIAL may not have been set properly yet. */ |
2497 |
2498 make_decl_one_only (decl); 2499 2500 if (TREE_CODE (decl) == VAR_DECL && DECL_LANG_SPECIFIC (decl)) 2501 DECL_COMDAT (decl) = 1; |
2502} 2503 2504/* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL, 2505 based on TYPE and other static flags. 2506 2507 Note that anything public is tagged TREE_PUBLIC, whether 2508 it's public in this file or in another one. */ 2509 2510void 2511import_export_vtable (decl, type, final) 2512 tree decl, type; 2513 int final; 2514{ 2515 if (DECL_INTERFACE_KNOWN (decl)) 2516 return; 2517 |
2518 if (TYPE_FOR_JAVA (type)) |
2519 { 2520 TREE_PUBLIC (decl) = 1; |
2521 DECL_EXTERNAL (decl) = 1; |
2522 DECL_INTERFACE_KNOWN (decl) = 1; 2523 } 2524 else if (CLASSTYPE_INTERFACE_KNOWN (type)) 2525 { 2526 TREE_PUBLIC (decl) = 1; 2527 DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type); 2528 DECL_INTERFACE_KNOWN (decl) = 1; |
2529 } 2530 else 2531 { 2532 /* We can only wait to decide if we have real non-inline virtual 2533 functions in our class, or if we come from a template. */ 2534 2535 int found = CLASSTYPE_TEMPLATE_INSTANTIATION (type); 2536 |
2537 if (! found && ! final) 2538 { 2539 tree method; 2540 for (method = TYPE_METHODS (type); method != NULL_TREE; 2541 method = TREE_CHAIN (method)) 2542 if (DECL_VINDEX (method) != NULL_TREE 2543 && ! DECL_THIS_INLINE (method) 2544 && ! DECL_ABSTRACT_VIRTUAL_P (method)) 2545 { 2546 found = 1; 2547 break; 2548 } 2549 } |
2550 2551 if (final || ! found) 2552 { 2553 comdat_linkage (decl); 2554 DECL_EXTERNAL (decl) = 0; 2555 } 2556 else 2557 { --- 11 unchanged lines hidden (view full) --- 2569 tree ctype; 2570{ 2571 /* -1 for imported, 1 for exported. */ 2572 int import_export = 0; 2573 2574 if (CLASSTYPE_INTERFACE_KNOWN (ctype)) 2575 return; 2576 |
2577 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface, 2578 we will have CLASSTYPE_INTERFACE_ONLY set but not 2579 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this 2580 heuristic because someone will supply a #pragma implementation 2581 elsewhere, and deducing it here would produce a conflict. */ 2582 if (CLASSTYPE_INTERFACE_ONLY (ctype)) 2583 return; 2584 |
2585#ifdef VALID_MACHINE_TYPE_ATTRIBUTE 2586 /* FIXME this should really use some sort of target-independent macro. */ 2587 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype))) 2588 import_export = -1; |
2589 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype))) 2590 import_export = 1; |
2591#endif 2592 2593 /* If we got -fno-implicit-templates, we import template classes that 2594 weren't explicitly instantiated. */ 2595 if (import_export == 0 2596 && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype) 2597 && ! flag_implicit_templates) 2598 import_export = -1; 2599 |
2600 /* Base our import/export status on that of the first non-inline, 2601 non-abstract virtual function, if any. */ 2602 if (import_export == 0 2603 && TYPE_VIRTUAL_P (ctype) 2604 && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)) 2605 { 2606 tree method; 2607 for (method = TYPE_METHODS (ctype); method != NULL_TREE; 2608 method = TREE_CHAIN (method)) 2609 { 2610 if (DECL_VINDEX (method) != NULL_TREE 2611 && !DECL_THIS_INLINE (method) 2612 && !DECL_ABSTRACT_VIRTUAL_P (method)) 2613 { 2614 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1); 2615 break; 2616 } 2617 } 2618 } |
2619 2620#ifdef MULTIPLE_SYMBOL_SPACES 2621 if (import_export == -1) 2622 import_export = 0; |
2623#endif 2624 2625 if (import_export) 2626 { 2627 SET_CLASSTYPE_INTERFACE_KNOWN (ctype); 2628 CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = (import_export > 0); 2629 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0); 2630 } 2631} 2632 |
2633/* We need to describe to the assembler the relationship between 2634 a vtable and the vtable of the parent class. */ 2635 2636static void 2637output_vtable_inherit (vars) 2638 tree vars; 2639{ 2640 tree parent; 2641 rtx op[2]; 2642 2643 op[0] = XEXP (DECL_RTL (vars), 0); /* strip the mem ref */ 2644 2645 parent = binfo_for_vtable (vars); 2646 2647 if (parent == TYPE_BINFO (DECL_CONTEXT (vars))) 2648 op[1] = const0_rtx; 2649 else if (parent) 2650 { 2651 parent = TYPE_BINFO_VTABLE (BINFO_TYPE (parent)); 2652 op[1] = XEXP (DECL_RTL (parent), 0); /* strip the mem ref */ 2653 } 2654 else 2655 my_friendly_abort (980826); 2656 2657 output_asm_insn (".vtable_inherit %c0, %c1", op); 2658} 2659 |
2660static int |
2661finish_vtable_vardecl (t, data) 2662 tree *t; 2663 void *data ATTRIBUTE_UNUSED; |
2664{ |
2665 tree vars = *t; |
2666 tree ctype = DECL_CONTEXT (vars); 2667 import_export_class (ctype); 2668 import_export_vtable (vars, ctype, 1); 2669 |
2670 if (! DECL_EXTERNAL (vars) 2671 && (DECL_INTERFACE_KNOWN (vars) |
2672 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars)) 2673 || (hack_decl_function_context (vars) && TREE_USED (vars))) 2674 && ! TREE_ASM_WRITTEN (vars)) 2675 { 2676 /* Write it out. */ 2677 mark_vtable_entries (vars); 2678 if (TREE_TYPE (DECL_INITIAL (vars)) == 0) 2679 store_init_value (vars, DECL_INITIAL (vars)); --- 19 unchanged lines hidden (view full) --- 2699 We might be able to arrange to have the "vtable static member" 2700 attached to the member list for `S' before the debug info for 2701 `S' get written (which would solve the problem) but that would 2702 require more intrusive changes to the g++ front end. */ 2703 2704 DECL_IGNORED_P (vars) = 1; 2705 } 2706 |
2707 /* Always make vtables weak. */ 2708 if (flag_weak) 2709 comdat_linkage (vars); 2710 |
2711 rest_of_decl_compilation (vars, NULL_PTR, 1, 1); |
2712 2713 if (flag_vtable_gc) 2714 output_vtable_inherit (vars); 2715 |
2716 return 1; 2717 } 2718 else if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars))) 2719 /* We don't know what to do with this one yet. */ 2720 return 0; 2721 |
2722 *t = TREE_CHAIN (vars); |
2723 return 0; 2724} 2725 2726static int |
2727prune_vtable_vardecl (t, data) 2728 tree *t; 2729 void *data ATTRIBUTE_UNUSED; |
2730{ |
2731 *t = TREE_CHAIN (*t); |
2732 return 1; 2733} 2734 |
2735static int 2736finish_sigtable_vardecl (t, data) 2737 tree *t; 2738 void *data ATTRIBUTE_UNUSED; |
2739{ |
2740 /* We don't need to mark sigtable entries as addressable here as is done 2741 for vtables. Since sigtables, unlike vtables, are always written out, 2742 that was already done in build_signature_table_constructor. */ 2743 |
2744 rest_of_decl_compilation (*t, NULL_PTR, 1, 1); 2745 *t = TREE_CHAIN (*t); 2746 return 1; |
2747} 2748 |
2749/* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an 2750 inline function or template instantiation at end-of-file. */ 2751 2752void 2753import_export_decl (decl) 2754 tree decl; 2755{ 2756 if (DECL_INTERFACE_KNOWN (decl)) 2757 return; 2758 |
2759 if (DECL_TEMPLATE_INSTANTIATION (decl) 2760 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) |
2761 { 2762 DECL_NOT_REALLY_EXTERN (decl) = 1; |
2763 if ((DECL_IMPLICIT_INSTANTIATION (decl) 2764 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) 2765 && (flag_implicit_templates 2766 || (flag_implicit_inline_templates && DECL_THIS_INLINE (decl)))) |
2767 { 2768 if (!TREE_PUBLIC (decl)) 2769 /* Templates are allowed to have internal linkage. See 2770 [basic.link]. */ 2771 ; |
2772 else |
2773 comdat_linkage (decl); |
2774 } 2775 else 2776 DECL_NOT_REALLY_EXTERN (decl) = 0; 2777 } 2778 else if (DECL_FUNCTION_MEMBER_P (decl)) 2779 { 2780 tree ctype = DECL_CLASS_CONTEXT (decl); 2781 import_export_class (ctype); 2782 if (CLASSTYPE_INTERFACE_KNOWN (ctype) 2783 && (! DECL_ARTIFICIAL (decl) || DECL_VINDEX (decl))) 2784 { 2785 DECL_NOT_REALLY_EXTERN (decl) 2786 = ! (CLASSTYPE_INTERFACE_ONLY (ctype) |
2787 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines 2788 && !DECL_VINDEX (decl))); 2789 2790 /* Always make artificials weak. */ 2791 if (DECL_ARTIFICIAL (decl) && flag_weak) 2792 comdat_linkage (decl); 2793 else 2794 maybe_make_one_only (decl); |
2795 } 2796 else 2797 comdat_linkage (decl); 2798 } |
2799 else if (DECL_TINFO_FN_P (decl)) |
2800 { 2801 tree ctype = TREE_TYPE (DECL_NAME (decl)); 2802 2803 if (IS_AGGR_TYPE (ctype)) 2804 import_export_class (ctype); 2805 2806 if (IS_AGGR_TYPE (ctype) && CLASSTYPE_INTERFACE_KNOWN (ctype) 2807 && TYPE_VIRTUAL_P (ctype) 2808 /* If the type is a cv-qualified variant of a type, then we 2809 must emit the tinfo function in this translation unit 2810 since it will not be emitted when the vtable for the type 2811 is output (which is when the unqualified version is 2812 generated). */ |
2813 && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype))) |
2814 { 2815 DECL_NOT_REALLY_EXTERN (decl) 2816 = ! (CLASSTYPE_INTERFACE_ONLY (ctype) |
2817 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines 2818 && !DECL_VINDEX (decl))); |
2819 |
2820 /* Always make artificials weak. */ 2821 if (flag_weak) 2822 comdat_linkage (decl); |
2823 } |
2824 else if (TYPE_BUILT_IN (ctype) 2825 && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype))) |
2826 DECL_NOT_REALLY_EXTERN (decl) = 0; 2827 else 2828 comdat_linkage (decl); 2829 } 2830 else 2831 comdat_linkage (decl); 2832 2833 DECL_INTERFACE_KNOWN (decl) = 1; --- 15 unchanged lines hidden (view full) --- 2849 } 2850 temp = build_delete (TREE_TYPE (temp), temp, 2851 integer_two_node, 2852 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0); 2853 return temp; 2854} 2855 2856extern int parse_time, varconst_time; |
2857 2858static tree 2859get_sentry (base) 2860 tree base; 2861{ 2862 tree sname = get_id_2 ("__sn", base); 2863 /* For struct X foo __attribute__((weak)), there is a counter 2864 __snfoo. Since base is already an assembler name, sname should --- 15 unchanged lines hidden (view full) --- 2880 } 2881 return sentry; 2882} 2883 2884/* Start the process of running a particular set of global constructors 2885 or destructors. Subroutine of do_[cd]tors. */ 2886 2887static void |
2888start_objects (method_type, initp) 2889 int method_type, initp; |
2890{ 2891 tree fnname; |
2892 char type[10]; |
2893 2894 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */ 2895 |
2896 if (initp != DEFAULT_INIT_PRIORITY) 2897 { 2898 char joiner; |
2899 |
2900#ifdef JOINER 2901 joiner = JOINER; 2902#else 2903 joiner = '_'; 2904#endif 2905 2906 sprintf (type, "%c%c%.5u", method_type, joiner, initp); 2907 } 2908 else 2909 sprintf (type, "%c", method_type); 2910 2911 fnname = get_file_function_name_long (type); 2912 |
2913 start_function (void_list_node, 2914 make_call_declarator (fnname, void_list_node, NULL_TREE, 2915 NULL_TREE), 2916 NULL_TREE, 0); 2917 2918#if defined(ASM_OUTPUT_CONSTRUCTOR) && defined(ASM_OUTPUT_DESTRUCTOR) 2919 /* It can be a static function as long as collect2 does not have 2920 to scan the object file to find its ctor/dtor routine. */ 2921 TREE_PUBLIC (current_function_decl) = 0; 2922#endif 2923 2924 store_parm_decls (); 2925 pushlevel (0); 2926 clear_last_expr (); 2927 push_momentary (); 2928 expand_start_bindings (0); |
2929 2930 /* We cannot allow these functions to be elided, even if they do not 2931 have external linkage. And, there's no point in deferring 2932 copmilation of thes functions; they're all going to have to be 2933 out anyhow. */ 2934 current_function_cannot_inline 2935 = "static constructors and destructors cannot be inlined"; |
2936} 2937 2938/* Finish the process of running a particular set of global constructors 2939 or destructors. Subroutine of do_[cd]tors. */ 2940 2941static void |
2942finish_objects (method_type, initp) 2943 int method_type, initp; |
2944{ |
2945 char *fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); |
2946 |
2947 /* Finish up. */ 2948 expand_end_bindings (getdecls (), 1, 0); 2949 poplevel (1, 0, 0); 2950 pop_momentary (); 2951 finish_function (lineno, 0, 0); 2952 |
2953 if (initp == DEFAULT_INIT_PRIORITY) 2954 { 2955 if (method_type == 'I') 2956 assemble_constructor (fnname); 2957 else 2958 assemble_destructor (fnname); 2959 } 2960 2961#if defined (ASM_OUTPUT_SECTION_NAME) && defined (ASM_OUTPUT_CONSTRUCTOR) 2962 /* If we're using init priority we can't use assemble_*tor, but on ELF 2963 targets we can stick the references into named sections for GNU ld 2964 to collect. */ |
2965 else |
2966 { 2967 char buf[15]; 2968 sprintf (buf, ".%ctors.%.5u", method_type == 'I' ? 'c' : 'd', 2969 /* invert the numbering so the linker puts us in the proper 2970 order; constructors are run from right to left, and the 2971 linker sorts in increasing order. */ 2972 MAX_INIT_PRIORITY - initp); 2973 named_section (NULL_TREE, buf, 0); 2974 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, fnname), 2975 POINTER_SIZE / BITS_PER_UNIT, 1); 2976 } 2977#endif |
2978} 2979 |
2980/* The names of the parameters to the function created to handle 2981 initializations and destructions for objects with static storage 2982 duration. */ 2983#define INITIALIZE_P_IDENTIFIER "__initialize_p" 2984#define PRIORITY_IDENTIFIER "__priority" |
2985 |
2986/* The name of the function we create to handle initializations and 2987 destructions for objects with static storage duration. */ 2988#define SSDF_IDENTIFIER "__static_initialization_and_destruction" 2989 2990/* The declaration for the __INITIALIZE_P argument. */ 2991static tree initialize_p_decl; 2992 2993/* The declaration for the __PRIORITY argument. */ 2994static tree priority_decl; 2995 2996/* The declaration for the static storage duration function. */ 2997static tree ssdf_decl; 2998 2999/* All the static storage duration functions created in this 3000 translation unit. */ 3001static varray_type ssdf_decls; 3002static size_t ssdf_decls_used; 3003 3004/* A map from priority levels to information about that priority 3005 level. There may be many such levels, so efficient lookup is 3006 important. */ 3007static splay_tree priority_info_map; 3008 3009/* Begins the generation of the function that will handle all 3010 initialization and destruction of objects with static storage 3011 duration. The function generated takes two parameters of type 3012 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is 3013 non-zero, it performs initializations. Otherwise, it performs 3014 destructions. It only performs those initializations or 3015 destructions with the indicated __PRIORITY. The generated function 3016 returns no value. 3017 3018 It is assumed that this function will only be called once per 3019 translation unit. */ 3020 |
3021static void |
3022start_static_storage_duration_function () |
3023{ |
3024 static unsigned ssdf_number; |
3025 |
3026 tree parm_types; 3027 tree type; 3028 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32]; 3029 3030 /* Create the identifier for this function. It will be of the form 3031 SSDF_IDENTIFIER_<number>. */ 3032 sprintf (id, "%s_%u", SSDF_IDENTIFIER, ssdf_number++); 3033 if (ssdf_number == 0) |
3034 { |
3035 /* Overflow occurred. That means there are at least 4 billion 3036 initialization functions. */ 3037 sorry ("too many initialization functions required"); 3038 my_friendly_abort (19990430); 3039 } |
3040 |
3041 /* Create the parameters. */ 3042 parm_types = void_list_node; 3043 parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types); 3044 parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types); 3045 type = build_function_type (void_type_node, parm_types); |
3046 |
3047 /* Create the FUNCTION_DECL itself. */ 3048 ssdf_decl = build_lang_decl (FUNCTION_DECL, 3049 get_identifier (id), 3050 type); 3051 TREE_PUBLIC (ssdf_decl) = 0; 3052 DECL_ARTIFICIAL (ssdf_decl) = 1; |
3053 |
3054 /* Put this function in the list of functions to be called from the 3055 static constructors and destructors. */ 3056 if (!ssdf_decls) 3057 { 3058 VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls"); |
3059 |
3060 /* Take this opportunity to initialize the map from priority 3061 numbers to information about that priority level. */ 3062 priority_info_map = splay_tree_new (splay_tree_compare_ints, 3063 /*delete_key_fn=*/0, 3064 /*delete_value_fn=*/ 3065 (splay_tree_delete_value_fn) &free); |
3066 |
3067 /* We always need to generate functions for the 3068 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk 3069 priorities later, we'll be sure to find the 3070 DEFAULT_INIT_PRIORITY. */ 3071 get_priority_info (DEFAULT_INIT_PRIORITY); |
3072 } 3073 |
3074 if (ssdf_decls_used == ssdf_decls->num_elements) 3075 VARRAY_GROW (ssdf_decls, 2 * ssdf_decls_used); 3076 VARRAY_TREE (ssdf_decls, ssdf_decls_used) = ssdf_decl; 3077 ++ssdf_decls_used; 3078 3079 /* Create the argument list. */ 3080 initialize_p_decl = build_decl (PARM_DECL, 3081 get_identifier (INITIALIZE_P_IDENTIFIER), 3082 integer_type_node); 3083 DECL_CONTEXT (initialize_p_decl) = ssdf_decl; 3084 DECL_ARG_TYPE (initialize_p_decl) = integer_type_node; 3085 TREE_USED (initialize_p_decl) = 1; 3086 priority_decl = build_decl (PARM_DECL, get_identifier (PRIORITY_IDENTIFIER), 3087 integer_type_node); 3088 DECL_CONTEXT (priority_decl) = ssdf_decl; 3089 DECL_ARG_TYPE (priority_decl) = integer_type_node; 3090 TREE_USED (priority_decl) = 1; 3091 3092 TREE_CHAIN (initialize_p_decl) = priority_decl; 3093 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl; 3094 3095 /* Start the function itself. This is equivalent to declarating the 3096 function as: 3097 3098 static void __ssdf (int __initialize_p, init __priority_p); 3099 3100 It is static because we only need to call this function from the 3101 various constructor and destructor functions for this module. */ 3102 start_function (/*specs=*/NULL_TREE, 3103 ssdf_decl, 3104 /*attrs=*/NULL_TREE, 3105 /*pre_parsed_p=*/1); 3106 3107 /* Set up the scope of the outermost block in the function. */ 3108 store_parm_decls (); 3109 pushlevel (0); 3110 clear_last_expr (); 3111 push_momentary (); 3112 expand_start_bindings (0); 3113 3114 /* This function must not be deferred because we are depending on 3115 its compilation to tell us what is TREE_SYMBOL_REFERENCED. */ 3116 current_function_cannot_inline 3117 = "static storage duration functions cannot be inlined"; |
3118} 3119 |
3120/* Generate the initialization code for the priority indicated in N. */ |
3121 |
3122static int 3123generate_inits_for_priority (n, data) 3124 splay_tree_node n; 3125 void *data ATTRIBUTE_UNUSED; |
3126{ |
3127 int priority = (int) n->key; 3128 priority_info pi = (priority_info) n->value; |
3129 |
3130 /* For each priority N which has been used generate code which looks 3131 like: |
3132 |
3133 if (__priority == N) { 3134 if (__initialize_p) 3135 ... 3136 else 3137 ... 3138 } 3139 3140 We use the sequences we've accumulated to fill in the `...'s. */ 3141 expand_start_cond (build_binary_op (EQ_EXPR, 3142 priority_decl, 3143 build_int_2 (priority, 0)), 3144 /*exit_flag=*/0); 3145 3146 /* Do the initializations. */ 3147 expand_start_cond (build_binary_op (NE_EXPR, 3148 initialize_p_decl, 3149 integer_zero_node), 3150 /*exit_flag=*/0); 3151 if (pi->initialization_sequence) |
3152 { |
3153 rtx insns; |
3154 |
3155 push_to_sequence (pi->initialization_sequence); 3156 insns = gen_sequence (); 3157 end_sequence (); |
3158 |
3159 emit_insn (insns); 3160 pi->initialization_sequence = NULL_RTX; 3161 pi->initializations_p = 1; 3162 } |
3163 |
3164 /* Do the destructions. */ 3165 expand_start_else (); 3166 if (pi->destruction_sequence) 3167 { 3168 rtx insns; |
3169 |
3170 push_to_sequence (pi->destruction_sequence); 3171 insns = gen_sequence (); 3172 end_sequence (); |
3173 |
3174 emit_insn (insns); 3175 pi->destruction_sequence = NULL_RTX; 3176 pi->destructions_p = 1; 3177 } 3178 3179 /* Close out the conditionals. */ 3180 expand_end_cond (); 3181 expand_end_cond (); |
3182 |
3183 /* Don't stop iterating. */ 3184 return 0; 3185} |
3186 |
3187/* Finish the generation of the function which performs initialization 3188 and destruction of objects with static storage duration. After 3189 this point, no more such objects can be created. */ |
3190 |
3191static void 3192finish_static_storage_duration_function () 3193{ 3194 splay_tree_foreach (priority_info_map, 3195 generate_inits_for_priority, 3196 /*data=*/0); |
3197 |
3198 /* Close out the function. */ 3199 expand_end_bindings (getdecls (), 1, 0); 3200 poplevel (1, 0, 0); 3201 pop_momentary (); 3202 finish_function (lineno, 0, 0); 3203} |
3204 |
3205/* Return the information about the indicated PRIORITY level. If no 3206 code to handle this level has yet been generated, generate the 3207 appropriate prologue. */ |
3208 |
3209static priority_info 3210get_priority_info (priority) 3211 int priority; 3212{ 3213 priority_info pi; 3214 splay_tree_node n; 3215 3216 n = splay_tree_lookup (priority_info_map, 3217 (splay_tree_key) priority); 3218 if (!n) 3219 { 3220 /* Create a new priority information structure, and insert it 3221 into the map. */ 3222 pi = (priority_info) xmalloc (sizeof (struct priority_info_s)); 3223 pi->initialization_sequence = NULL_RTX; 3224 pi->destruction_sequence = NULL_RTX; 3225 pi->initializations_p = 0; 3226 pi->destructions_p = 0; 3227 splay_tree_insert (priority_info_map, 3228 (splay_tree_key) priority, 3229 (splay_tree_value) pi); |
3230 } |
3231 else 3232 pi = (priority_info) n->value; |
3233 |
3234 return pi; |
3235} 3236 |
3237/* Generate code to do the static initialization of DECL. The 3238 initialization is INIT. If DECL may be initialized more than once 3239 in different object files, SENTRY is the guard variable to 3240 check. PRIORITY is the priority for the initialization. */ |
3241 |
3242static void 3243do_static_initialization (decl, init, sentry, priority) 3244 tree decl; 3245 tree init; 3246 tree sentry; 3247 int priority; |
3248{ |
3249 priority_info pi; |
3250 |
3251 /* Get the priority information for this PRIORITY, */ 3252 pi = get_priority_info (priority); 3253 if (!pi->initialization_sequence) 3254 start_sequence (); 3255 else 3256 push_to_sequence (pi->initialization_sequence); |
3257 |
3258 /* Tell the debugger that we are at the location of the static 3259 variable in question. */ 3260 emit_note (input_filename, lineno); |
3261 |
3262 /* If there's a SENTRY, we only do the initialization if it is 3263 zero, i.e., if we are the first to initialize it. */ 3264 if (sentry) 3265 expand_start_cond (build_binary_op (EQ_EXPR, 3266 build_unary_op (PREINCREMENT_EXPR, 3267 sentry, 3268 /*noconvert=*/0), 3269 integer_one_node), 3270 /*exit_flag=*/0); 3271 3272 /* Prepare a binding level for temporaries created during the 3273 initialization. */ 3274 expand_start_target_temps (); 3275 3276 if (IS_AGGR_TYPE (TREE_TYPE (decl)) 3277 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 3278 expand_aggr_init (decl, init, 0); 3279 else if (TREE_CODE (init) == TREE_VEC) 3280 expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0), 3281 TREE_VEC_ELT (init, 1), 3282 TREE_VEC_ELT (init, 2), 0), 3283 const0_rtx, VOIDmode, EXPAND_NORMAL); 3284 else 3285 expand_assignment (decl, init, 0, 0); 3286 3287 /* The expression might have involved increments and decrements. */ 3288 emit_queue (); 3289 3290 /* Cleanup any temporaries needed for the initial value. */ 3291 expand_end_target_temps (); 3292 3293 /* Cleanup any deferred pops from function calls. This would be done 3294 by expand_end_cond, but we also need it when !SENTRY, since we are 3295 constructing these sequences by parts. */ 3296 do_pending_stack_adjust (); 3297 3298 /* Close the conditional opened above. */ 3299 if (sentry) 3300 expand_end_cond (); 3301 3302 /* Save the sequence for later use. */ 3303 pi->initialization_sequence = get_insns (); 3304 end_sequence (); 3305} 3306 3307/* Generate code to do the static destruction of DECL. If DECL may be 3308 initialized more than once in different object files, SENTRY is the 3309 guard variable to check. PRIORITY is the priority for the 3310 destruction. */ 3311 3312static void 3313do_static_destruction (decl, sentry, priority) 3314 tree decl; 3315 tree sentry; 3316 int priority; 3317{ 3318 rtx new_insns; 3319 priority_info pi; 3320 3321 /* If we don't need a destructor, there's nothing to do. */ 3322 if (!TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl))) |
3323 return; |
3324 3325 /* Get the priority information for this PRIORITY, */ 3326 pi = get_priority_info (priority); 3327 if (!pi->destruction_sequence) 3328 start_sequence (); 3329 else 3330 push_to_sequence (pi->destruction_sequence); |
3331 |
3332 /* Start a new sequence to handle just this destruction. */ 3333 start_sequence (); |
3334 |
3335 /* Tell the debugger that we are at the location of the static 3336 variable in question. */ 3337 emit_note (input_filename, lineno); 3338 3339 /* If there's a SENTRY, we only do the destruction if it is one, 3340 i.e., if we are the last to destroy it. */ 3341 if (sentry) 3342 expand_start_cond (build_binary_op (EQ_EXPR, 3343 build_unary_op (PREDECREMENT_EXPR, 3344 sentry, 3345 /*nonconvert=*/1), 3346 integer_zero_node), 3347 /*exit_flag=*/0); 3348 3349 /* Actually to the destruction. */ 3350 expand_expr_stmt (build_cleanup (decl)); |
3351 |
3352 /* Cleanup any deferred pops from function calls. This would be done 3353 by expand_end_cond, but we also need it when !SENTRY, since we are 3354 constructing these sequences by parts. */ 3355 do_pending_stack_adjust (); |
3356 |
3357 /* Close the conditional opened above. */ 3358 if (sentry) 3359 expand_end_cond (); |
3360 |
3361 /* Insert the NEW_INSNS before the current insns. (Destructions are 3362 run in reverse order of initializations.) */ 3363 new_insns = gen_sequence (); 3364 end_sequence (); 3365 if (pi->destruction_sequence) 3366 emit_insn_before (new_insns, pi->destruction_sequence); 3367 else 3368 emit_insn (new_insns); |
3369 |
3370 /* Save the sequence for later use. */ 3371 pi->destruction_sequence = get_insns (); 3372 end_sequence (); 3373} |
3374 |
3375/* Add code to the static storage duration function that will handle 3376 DECL (a static variable that needs initializing and/or destruction) 3377 with the indicated PRIORITY. If DECL needs initializing, INIT is 3378 the initializer. */ |
3379 |
3380static void 3381do_static_initialization_and_destruction (decl, init) 3382 tree decl; 3383 tree init; 3384{ 3385 tree sentry = NULL_TREE; 3386 int priority; |
3387 |
3388 /* Deal gracefully with error. */ 3389 if (decl == error_mark_node) 3390 return; |
3391 |
3392 /* The only things that can be initialized are variables. */ 3393 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420); |
3394 |
3395 /* If this object is not defined, we don't need to do anything 3396 here. */ 3397 if (DECL_EXTERNAL (decl)) 3398 return; |
3399 |
3400 /* Also, if the initializer already contains errors, we can bail out 3401 now. */ 3402 if (init && TREE_CODE (init) == TREE_LIST 3403 && value_member (error_mark_node, init)) 3404 return; |
3405 |
3406 /* Trick the compiler into thinking we are at the file and line 3407 where DECL was declared so that error-messages make sense, and so 3408 that the debugger will show somewhat sensible file and line 3409 information. */ 3410 input_filename = DECL_SOURCE_FILE (decl); 3411 lineno = DECL_SOURCE_LINE (decl); |
3412 |
3413 /* Because of: |
3414 |
3415 [class.access.spec] |
3416 |
3417 Access control for implicit calls to the constructors, 3418 the conversion functions, or the destructor called to 3419 create and destroy a static data member is performed as 3420 if these calls appeared in the scope of the member's 3421 class. |
3422 |
3423 we pretend we are in a static member function of the class of 3424 which the DECL is a member. */ 3425 if (member_p (decl)) 3426 { 3427 DECL_CLASS_CONTEXT (current_function_decl) = DECL_CONTEXT (decl); 3428 DECL_STATIC_FUNCTION_P (current_function_decl) = 1; 3429 } 3430 3431 /* We need a sentry if this is an object with external linkage that 3432 might be initialized in more than one place. */ 3433 if (TREE_PUBLIC (decl) && (DECL_COMMON (decl) 3434 || DECL_ONE_ONLY (decl) 3435 || DECL_WEAK (decl))) 3436 sentry = get_sentry (DECL_ASSEMBLER_NAME (decl)); |
3437 |
3438 /* Generate the code to actually do the intialization and 3439 destruction. */ 3440 priority = DECL_INIT_PRIORITY (decl); 3441 if (!priority) 3442 priority = DEFAULT_INIT_PRIORITY; 3443 do_static_initialization (decl, init, sentry, priority); 3444 do_static_destruction (decl, sentry, priority); 3445 3446 /* Now that we're done with DECL we don't need to pretend to be a 3447 member of its class any longer. */ 3448 DECL_CLASS_CONTEXT (current_function_decl) = NULL_TREE; 3449 DECL_STATIC_FUNCTION_P (current_function_decl) = 0; 3450} 3451 3452/* Generate a static constructor (if CONSTRUCTOR_P) or destructor 3453 (otherwise) that will initialize all gobal objects with static 3454 storage duration having the indicated PRIORITY. */ 3455 3456static void 3457generate_ctor_or_dtor_function (constructor_p, priority) 3458 int constructor_p; 3459 int priority; 3460{ 3461 char function_key; 3462 tree arguments; 3463 size_t i; 3464 3465 /* We use `I' to indicate initialization and `D' to indicate 3466 destruction. */ 3467 if (constructor_p) 3468 function_key = 'I'; 3469 else 3470 function_key = 'D'; 3471 3472 /* Begin the function. */ 3473 start_objects (function_key, priority); 3474 3475 /* Call the static storage duration function with appropriate 3476 arguments. */ 3477 for (i = 0; i < ssdf_decls_used; ++i) |
3478 { |
3479 arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0), 3480 NULL_TREE); 3481 arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0), 3482 arguments); 3483 expand_expr_stmt (build_function_call (VARRAY_TREE (ssdf_decls, i), 3484 arguments)); |
3485 } 3486 |
3487 /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in 3488 calls to any functions marked with attributes indicating that 3489 they should be called at initialization- or destruction-time. */ 3490 if (priority == DEFAULT_INIT_PRIORITY) |
3491 { |
3492 tree fns; 3493 3494 for (fns = constructor_p ? static_ctors : static_dtors; 3495 fns; 3496 fns = TREE_CHAIN (fns)) 3497 expand_expr_stmt (build_function_call (TREE_VALUE (fns), NULL_TREE)); |
3498 } 3499 |
3500 /* Close out the function. */ 3501 finish_objects (function_key, priority); 3502} |
3503 |
3504/* Generate constructor and destructor functions for the priority 3505 indicated by N. */ |
3506 |
3507static int 3508generate_ctor_and_dtor_functions_for_priority (n, data) 3509 splay_tree_node n; 3510 void *data ATTRIBUTE_UNUSED; 3511{ 3512 int priority = (int) n->key; 3513 priority_info pi = (priority_info) n->value; |
3514 |
3515 /* Generate the functions themselves, but only if they are really 3516 needed. */ 3517 if (pi->initializations_p 3518 || (priority == DEFAULT_INIT_PRIORITY && static_ctors)) 3519 generate_ctor_or_dtor_function (/*constructor_p=*/1, 3520 priority); 3521 if (pi->destructions_p 3522 || (priority == DEFAULT_INIT_PRIORITY && static_dtors)) 3523 generate_ctor_or_dtor_function (/*constructor_p=*/0, 3524 priority); |
3525 |
3526 /* Keep iterating. */ 3527 return 0; 3528} |
3529 |
3530/* This routine is called from the last rule in yyparse (). 3531 Its job is to create all the code needed to initialize and 3532 destroy the global aggregates. We do the destruction 3533 first, since that way we only need to reverse the decls once. */ |
3534 |
3535void 3536finish_file () 3537{ 3538 extern int lineno; 3539 int start_time, this_time; 3540 tree vars; 3541 int reconsider; 3542 size_t i; 3543 3544 at_eof = 1; 3545 3546 /* Bad parse errors. Just forget about it. */ 3547 if (! global_bindings_p () || current_class_type || decl_namespace_list) 3548 return; 3549 3550 start_time = get_run_time (); 3551 3552 /* Otherwise, GDB can get confused, because in only knows 3553 about source for LINENO-1 lines. */ 3554 lineno -= 1; 3555 3556 interface_unknown = 1; 3557 interface_only = 0; 3558 3559 /* We now have to write out all the stuff we put off writing out. 3560 These include: 3561 3562 o Template specializations that we have not yet instantiated, 3563 but which are needed. 3564 o Initialization and destruction for non-local objects with 3565 static storage duration. (Local objects with static storage 3566 duration are initialized when their scope is first entered, 3567 and are cleaned up via atexit.) 3568 o Virtual function tables. 3569 3570 All of these may cause others to be needed. For example, 3571 instantiating one function may cause another to be needed, and 3572 generating the intiailzer for an object may cause templates to be 3573 instantiated, etc., etc. */ 3574 |
3575 this_time = get_run_time (); 3576 parse_time -= this_time - start_time; 3577 varconst_time += this_time - start_time; |
3578 start_time = get_run_time (); |
3579 permanent_allocation (1); |
3580 |
3581 do |
3582 { |
3583 /* Non-zero if we need a static storage duration function on 3584 this iteration through the loop. */ 3585 int need_ssdf_p = 0; |
3586 |
3587 reconsider = 0; |
3588 |
3589 /* If there are templates that we've put off instantiating, do 3590 them now. */ 3591 instantiate_pending_templates (); |
3592 |
3593 /* Write out signature-tables and virtual tables as required. 3594 Note that writing out the virtual table for a template class 3595 may cause the instantiation of members of that class. */ 3596 if (flag_handle_signatures 3597 && walk_globals (sigtable_decl_p, 3598 finish_sigtable_vardecl, 3599 /*data=*/0)) 3600 reconsider = 1; 3601 if (walk_globals (vtable_decl_p, 3602 finish_vtable_vardecl, 3603 /*data=*/0)) 3604 reconsider = 1; 3605 3606 /* The list of objects with static storage duration is built up 3607 in reverse order, so we reverse it here. We also clear 3608 STATIC_AGGREGATES so that any new aggregates added during the 3609 initialization of these will be initialized in the correct 3610 order when we next come around the loop. */ 3611 vars = nreverse (static_aggregates); 3612 static_aggregates = NULL_TREE; 3613 while (vars) 3614 { 3615 if (! TREE_ASM_WRITTEN (TREE_VALUE (vars))) 3616 rest_of_decl_compilation (TREE_VALUE (vars), 0, 1, 1); 3617 if (!need_ssdf_p) 3618 { 3619 /* We need to start a new initialization function each 3620 time through the loop. That's because we need to 3621 know which vtables have been referenced, and 3622 TREE_SYMBOL_REFERENCED isn't computed until a 3623 function is finished, and written out. That's a 3624 deficiency in the back-end. When this is fixed, 3625 these initialization functions could all become 3626 inline, with resulting performance improvements. */ 3627 start_static_storage_duration_function (); 3628 need_ssdf_p = 1; 3629 } |
3630 |
3631 do_static_initialization_and_destruction (TREE_VALUE (vars), 3632 TREE_PURPOSE (vars)); 3633 reconsider = 1; 3634 vars = TREE_CHAIN (vars); 3635 } 3636 3637 /* Finish up the static storage duration function for this 3638 round. */ 3639 if (need_ssdf_p) 3640 finish_static_storage_duration_function (); |
3641 |
3642 /* Go through the various inline functions, and see if any need 3643 synthesizing. */ 3644 for (i = 0; i < saved_inlines_used; ++i) 3645 { 3646 tree decl = VARRAY_TREE (saved_inlines, i); 3647 import_export_decl (decl); 3648 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl) 3649 && TREE_USED (decl) 3650 && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl))) 3651 { 3652 /* Even though we're already at the top-level, we push 3653 there again. That way, when we pop back a few lines 3654 hence, all of our state is restored. Otherwise, 3655 finish_function doesn't clean things up, and we end 3656 up with CURRENT_FUNCTION_DECL set. */ 3657 push_to_top_level (); 3658 if (DECL_TINFO_FN_P (decl)) 3659 synthesize_tinfo_fn (decl); 3660 else 3661 synthesize_method (decl); 3662 pop_from_top_level (); 3663 reconsider = 1; 3664 } 3665 } |
3666 |
3667 /* Mark all functions that might deal with exception-handling as 3668 referenced. */ 3669 mark_all_runtime_matches (); |
3670 |
3671 /* We lie to the back-end, pretending that some functions are 3672 not defined when they really are. This keeps these functions 3673 from being put out unncessarily. But, we must stop lying 3674 when the functions are referenced, or if they are not comdat 3675 since they need to be put out now. */ 3676 for (i = 0; i < saved_inlines_used; ++i) 3677 { 3678 tree decl = VARRAY_TREE (saved_inlines, i); 3679 3680 if (DECL_NOT_REALLY_EXTERN (decl) 3681 && DECL_INITIAL (decl) 3682 && (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) 3683 || !DECL_COMDAT (decl))) 3684 DECL_EXTERNAL (decl) = 0; 3685 } |
3686 |
3687 if (saved_inlines_used 3688 && wrapup_global_declarations (&VARRAY_TREE (saved_inlines, 0), 3689 saved_inlines_used)) 3690 reconsider = 1; 3691 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0)) 3692 reconsider = 1; |
3693 |
3694 /* Static data members are just like namespace-scope globals. */ 3695 for (i = 0; i < pending_statics_used; ++i) 3696 { 3697 tree decl = VARRAY_TREE (pending_statics, i); 3698 if (TREE_ASM_WRITTEN (decl)) 3699 continue; 3700 import_export_decl (decl); 3701 if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl)) 3702 DECL_EXTERNAL (decl) = 0; 3703 } 3704 if (pending_statics 3705 && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0), 3706 pending_statics_used)) 3707 reconsider = 1; 3708 } 3709 while (reconsider); |
3710 |
3711 /* We give C linkage to static constructors and destructors. */ 3712 push_lang_context (lang_name_c); |
3713 |
3714 /* Generate initialization and destruction functions for all 3715 priorities for which they are required. */ 3716 if (priority_info_map) 3717 splay_tree_foreach (priority_info_map, 3718 generate_ctor_and_dtor_functions_for_priority, 3719 /*data=*/0); |
3720 |
3721 /* We're done with the splay-tree now. */ 3722 if (priority_info_map) 3723 splay_tree_delete (priority_info_map); |
3724 |
3725 /* We're done with static constructors, so we can go back to "C++" 3726 linkage now. */ 3727 pop_lang_context (); |
3728 3729 /* Now delete from the chain of variables all virtual function tables. |
3730 We output them all ourselves, because each will be treated 3731 specially. */ 3732 walk_globals (vtable_decl_p, prune_vtable_vardecl, /*data=*/0); |
3733 |
3734 /* Now, issue warnings about static, but not defined, functions, 3735 etc. */ 3736 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider); |
3737 |
3738 finish_repo (); 3739 3740 this_time = get_run_time (); 3741 parse_time -= this_time - start_time; 3742 varconst_time += this_time - start_time; 3743 3744 if (flag_detailed_statistics) 3745 { --- 15 unchanged lines hidden (view full) --- 3761reparse_absdcl_as_expr (type, decl) 3762 tree type, decl; 3763{ 3764 /* do build_functional_cast (type, NULL_TREE) at bottom */ 3765 if (TREE_OPERAND (decl, 0) == NULL_TREE) 3766 return build_functional_cast (type, NULL_TREE); 3767 3768 /* recurse */ |
3769 decl = reparse_absdcl_as_expr (type, TREE_OPERAND (decl, 0)); |
3770 3771 decl = build_x_function_call (decl, NULL_TREE, current_class_ref); 3772 |
3773 if (TREE_CODE (decl) == CALL_EXPR 3774 && (! TREE_TYPE (decl) 3775 || TREE_CODE (TREE_TYPE (decl)) != VOID_TYPE)) |
3776 decl = require_complete_type (decl); 3777 3778 return decl; 3779} 3780 3781/* This is something of the form `int ((int)(int)(int)1)' that has turned 3782 out to be an expr. Since it was parsed like a type, we need to wade 3783 through and fix that. Since casts are right-associative, we are --- 31 unchanged lines hidden (view full) --- 3815 3816 while (decl) 3817 { 3818 type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1))); 3819 decl = TREE_OPERAND (decl, 0); 3820 expr = build_c_cast (type, expr); 3821 } 3822 |
3823 if (warn_old_style_cast && ! in_system_header 3824 && current_lang_name != lang_name_c) |
3825 warning ("use of old-style cast"); 3826 3827 return expr; 3828} 3829 3830/* Given plain tree nodes for an expression, build up the full semantics. */ 3831 3832tree --- 154 unchanged lines hidden (view full) --- 3987 { 3988 tree ref = TREE_OPERAND (t, 0); 3989 return build_scoped_method_call 3990 (build_expr_from_tree (TREE_OPERAND (t, 1)), 3991 build_expr_from_tree (TREE_OPERAND (ref, 0)), 3992 TREE_OPERAND (ref, 1), 3993 build_expr_from_tree (TREE_OPERAND (t, 2))); 3994 } |
3995 else 3996 { 3997 tree fn = TREE_OPERAND (t, 0); |
3998 |
3999 /* We can get a TEMPLATE_ID_EXPR here on code like: 4000 4001 x->f<2>(); 4002 4003 so we must resolve that. However, we can also get things 4004 like a BIT_NOT_EXPR here, when referring to a destructor, 4005 and things like that are not correctly resolved by 4006 build_expr_from_tree. So, just use build_expr_from_tree 4007 when we really need it. */ 4008 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) 4009 fn = lookup_template_function 4010 (TREE_OPERAND (fn, 0), 4011 build_expr_from_tree (TREE_OPERAND (fn, 1))); 4012 4013 return build_method_call 4014 (build_expr_from_tree (TREE_OPERAND (t, 1)), 4015 fn, 4016 build_expr_from_tree (TREE_OPERAND (t, 2)), 4017 NULL_TREE, LOOKUP_NORMAL); 4018 } 4019 |
4020 case CALL_EXPR: 4021 if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF) 4022 { 4023 tree ref = TREE_OPERAND (t, 0); 4024 return build_member_call 4025 (build_expr_from_tree (TREE_OPERAND (ref, 0)), 4026 TREE_OPERAND (ref, 1), 4027 build_expr_from_tree (TREE_OPERAND (t, 1))); --- 39 unchanged lines hidden (view full) --- 4067 value = build_expr_from_tree (value); 4068 chain = TREE_CHAIN (t); 4069 if (chain && chain != void_type_node) 4070 chain = build_expr_from_tree (chain); 4071 return expr_tree_cons (purpose, value, chain); 4072 } 4073 4074 case COMPONENT_REF: |
4075 { 4076 tree object = build_expr_from_tree (TREE_OPERAND (t, 0)); 4077 tree field = TREE_OPERAND (t, 1); 4078 4079 /* We use a COMPONENT_REF to indicate things of the form `x.b' 4080 and `x.A::b'. We must distinguish between those cases 4081 here. */ 4082 if (TREE_CODE (field) == SCOPE_REF) 4083 return build_object_ref (object, 4084 TREE_OPERAND (field, 0), 4085 TREE_OPERAND (field, 1)); 4086 else 4087 return build_x_component_ref (object, field, 4088 NULL_TREE, 1); 4089 } 4090 |
4091 case THROW_EXPR: 4092 return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0))); 4093 4094 case CONSTRUCTOR: 4095 { 4096 tree r; 4097 4098 /* digest_init will do the wrong thing if we let it. */ 4099 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 4100 return t; 4101 4102 r = build_nt (CONSTRUCTOR, NULL_TREE, 4103 build_expr_from_tree (CONSTRUCTOR_ELTS (t))); |
4104 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t); |
4105 4106 if (TREE_TYPE (t)) 4107 return digest_init (TREE_TYPE (t), r, 0); 4108 return r; 4109 } 4110 4111 case TYPEID_EXPR: 4112 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 0))) == 't') --- 51 unchanged lines hidden (view full) --- 4164 return decl; 4165 case SCOPE_REF: 4166 push_nested_class (TREE_TYPE (TREE_OPERAND (decl, 0)), 3); 4167 TREE_COMPLEXITY (decl) = current_class_depth; 4168 return decl; 4169 case ARRAY_REF: 4170 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0)); 4171 return decl; |
4172 case TREE_LIST: 4173 /* For attribute handling. */ 4174 TREE_VALUE (decl) = finish_decl_parsing (TREE_VALUE (decl)); 4175 return decl; |
4176 default: 4177 my_friendly_abort (5); 4178 return NULL_TREE; 4179 } 4180} 4181 4182tree 4183check_cp_case_value (value) --- 100 unchanged lines hidden (view full) --- 4284 /* Tell everyone using us about the new used namespaces. */ 4285 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t)) 4286 add_using_namespace (TREE_PURPOSE (t), used, 1); 4287} 4288 4289/* Combines two sets of overloaded functions into an OVERLOAD chain, removing 4290 duplicates. The first list becomes the tail of the result. 4291 |
4292 The algorithm is O(n^2). We could get this down to O(n log n) by 4293 doing a sort on the addresses of the functions, if that becomes 4294 necessary. */ |
4295 4296static tree 4297merge_functions (s1, s2) 4298 tree s1; 4299 tree s2; 4300{ 4301 for (; s2; s2 = OVL_NEXT (s2)) 4302 { --- 25 unchanged lines hidden (view full) --- 4328 val = BINDING_VALUE (new); 4329 if (val) 4330 switch (TREE_CODE (val)) 4331 { 4332 case TEMPLATE_DECL: 4333 /* If we expect types or namespaces, and not templates, 4334 or this is not a template class. */ 4335 if (LOOKUP_QUALIFIERS_ONLY (flags) |
4336 && !DECL_CLASS_TEMPLATE_P (val)) |
4337 val = NULL_TREE; 4338 break; 4339 case TYPE_DECL: 4340 if (LOOKUP_NAMESPACES_ONLY (flags)) 4341 val = NULL_TREE; 4342 break; 4343 case NAMESPACE_DECL: 4344 if (LOOKUP_TYPES_ONLY (flags)) --- 14 unchanged lines hidden (view full) --- 4359 BINDING_VALUE (old) = merge_functions (BINDING_VALUE (old), 4360 val); 4361 } 4362 else 4363 { 4364 /* Some declarations are functions, some are not. */ 4365 if (flags & LOOKUP_COMPLAIN) 4366 { |
4367 /* If we've already given this error for this lookup, 4368 BINDING_VALUE (old) is error_mark_node, so let's not 4369 repeat ourselves. */ 4370 if (BINDING_VALUE (old) != error_mark_node) 4371 { 4372 cp_error ("use of `%D' is ambiguous", name); 4373 cp_error_at (" first declared as `%#D' here", 4374 BINDING_VALUE (old)); 4375 } |
4376 cp_error_at (" also declared as `%#D' here", val); 4377 } 4378 return error_mark_node; 4379 } 4380 } 4381 /* ... and copy the type. */ 4382 type = BINDING_TYPE (new); 4383 if (LOOKUP_NAMESPACES_ONLY (flags)) --- 77 unchanged lines hidden (view full) --- 4461} 4462 4463/* [namespace.memdef]/2 */ 4464 4465/* Set the context of a declaration to scope. Complain if we are not 4466 outside scope. */ 4467 4468void |
4469set_decl_namespace (decl, scope, friendp) |
4470 tree decl; 4471 tree scope; |
4472 int friendp; |
4473{ 4474 tree old; 4475 if (scope == std_node) 4476 scope = global_namespace; 4477 /* Get rid of namespace aliases. */ 4478 scope = ORIGINAL_NAMESPACE (scope); 4479 |
4480 /* It is ok for friends to be qualified in parallel space. */ 4481 if (!friendp && !is_namespace_ancestor (current_namespace, scope)) |
4482 cp_error ("declaration of `%D' not in a namespace surrounding `%D'", 4483 decl, scope); 4484 DECL_CONTEXT (decl) = FROB_CONTEXT (scope); 4485 if (scope != current_namespace) 4486 { 4487 /* See whether this has been declared in the namespace. */ 4488 old = namespace_binding (DECL_NAME (decl), scope); 4489 if (!old) 4490 /* No old declaration at all. */ 4491 goto complain; 4492 if (!is_overloaded_fn (decl)) 4493 /* Don't compare non-function decls with decls_match here, 4494 since it can't check for the correct constness at this 4495 point. pushdecl will find those errors later. */ 4496 return; 4497 /* Since decl is a function, old should contain a function decl. */ 4498 if (!is_overloaded_fn (old)) 4499 goto complain; |
4500 if (processing_template_decl || processing_specialization) 4501 /* We have not yet called push_template_decl to turn the 4502 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations 4503 won't match. But, we'll check later, when we construct the 4504 template. */ 4505 return; |
4506 for (; old; old = OVL_NEXT (old)) 4507 if (decls_match (decl, OVL_CURRENT (old))) 4508 return; 4509 } 4510 else 4511 return; 4512 complain: 4513 cp_error ("`%D' should have been declared inside `%D'", 4514 decl, scope); 4515} 4516 4517/* Compute the namespace where a declaration is defined. */ 4518 |
4519static tree |
4520decl_namespace (decl) 4521 tree decl; 4522{ 4523 while (DECL_CONTEXT (decl)) 4524 { 4525 decl = DECL_CONTEXT (decl); 4526 if (TREE_CODE (decl) == NAMESPACE_DECL) 4527 return decl; --- 36 unchanged lines hidden (view full) --- 4564} 4565 4566void 4567pop_decl_namespace () 4568{ 4569 decl_namespace_list = TREE_CHAIN (decl_namespace_list); 4570} 4571 |
4572/* Enter a class or namespace scope. */ 4573 4574void 4575push_scope (t) 4576 tree t; |
4577{ |
4578 if (TREE_CODE (t) == NAMESPACE_DECL) 4579 push_decl_namespace (t); 4580 else 4581 pushclass (t, 2); |
4582} 4583 |
4584/* Leave scope pushed by push_scope. */ 4585 4586void 4587pop_scope (t) 4588 tree t; 4589{ 4590 if (TREE_CODE (t) == NAMESPACE_DECL) 4591 pop_decl_namespace (); 4592 else 4593 popclass (); 4594} 4595 |
4596/* [basic.lookup.koenig] */ 4597/* A non-zero return value in the functions below indicates an error. 4598 All nodes allocated in the procedure are on the scratch obstack. */ 4599 4600struct arg_lookup 4601{ 4602 tree name; 4603 tree namespaces; 4604 tree classes; 4605 tree functions; 4606}; 4607 4608static int arg_assoc PROTO((struct arg_lookup*, tree)); 4609static int arg_assoc_args PROTO((struct arg_lookup*, tree)); |
4610static int arg_assoc_type PROTO((struct arg_lookup*, tree)); 4611static int add_function PROTO((struct arg_lookup *, tree)); 4612static int arg_assoc_namespace PROTO((struct arg_lookup *, tree)); 4613static int arg_assoc_class PROTO((struct arg_lookup *, tree)); |
4614 4615/* Add a function to the lookup structure. 4616 Returns 1 on error. */ 4617 4618static int 4619add_function (k, fn) 4620 struct arg_lookup *k; 4621 tree fn; --- 83 unchanged lines hidden (view full) --- 4705 if (TREE_PURPOSE (list) == error_mark_node && TREE_VALUE (list) 4706 && decl_namespace (TREE_VALUE (list)) == context) 4707 if (add_function (k, TREE_VALUE (list))) 4708 return 1; 4709 4710 /* Process template arguments. */ 4711 if (CLASSTYPE_TEMPLATE_INFO (type)) 4712 { |
4713 list = innermost_args (CLASSTYPE_TI_ARGS (type)); |
4714 for (i = 0; i < TREE_VEC_LENGTH (list); ++i) 4715 arg_assoc (k, TREE_VEC_ELT (list, i)); 4716 } 4717 4718 return 0; 4719} 4720 4721/* Adds everything associated with a given type. --- 34 unchanged lines hidden (view full) --- 4756 fall through. */ 4757 case FUNCTION_TYPE: 4758 /* Associate the parameter types. */ 4759 if (arg_assoc_args (k, TYPE_ARG_TYPES (type))) 4760 return 1; 4761 /* Associate the return type. */ 4762 return arg_assoc_type (k, TREE_TYPE (type)); 4763 case TEMPLATE_TYPE_PARM: |
4764 case TEMPLATE_TEMPLATE_PARM: |
4765 return 0; 4766 case LANG_TYPE: 4767 if (type == unknown_type_node) 4768 return 0; 4769 /* else fall through */ 4770 default: 4771 my_friendly_abort (390); 4772 } --- 26 unchanged lines hidden (view full) --- 4799 if (TREE_CODE_CLASS (TREE_CODE (n)) == 't') 4800 return arg_assoc_type (k, n); 4801 4802 if (! type_unknown_p (n)) 4803 return arg_assoc_type (k, TREE_TYPE (n)); 4804 4805 if (TREE_CODE (n) == ADDR_EXPR) 4806 n = TREE_OPERAND (n, 0); |
4807 if (TREE_CODE (n) == COMPONENT_REF) 4808 n = TREE_OPERAND (n, 1); 4809 if (TREE_CODE (n) == OFFSET_REF) 4810 n = TREE_OPERAND (n, 1); |
4811 while (TREE_CODE (n) == TREE_LIST) 4812 n = TREE_VALUE (n); 4813 |
4814 if (TREE_CODE (n) == FUNCTION_DECL) 4815 return arg_assoc_type (k, TREE_TYPE (n)); 4816 if (TREE_CODE (n) == TEMPLATE_ID_EXPR) 4817 { 4818 /* [basic.lookup.koenig] |
4819 |
4820 If T is a template-id, its associated namespaces and classes 4821 are the namespace in which the template is defined; for 4822 member templates, the member template's class; the namespaces 4823 and classes associated with the types of the template 4824 arguments provided for template type parameters (excluding 4825 template template parameters); the namespaces in which any 4826 template template arguments are defined; and the classes in 4827 which any member templates used as template template 4828 arguments are defined. [Note: non-type template arguments do 4829 not contribute to the set of associated namespaces. ] */ 4830 tree template = TREE_OPERAND (n, 0); 4831 tree args = TREE_OPERAND (n, 1); 4832 tree ctx; 4833 tree arg; |
4834 |
4835 /* First, the template. There may actually be more than one if 4836 this is an overloaded function template. But, in that case, 4837 we only need the first; all the functions will be in the same 4838 namespace. */ 4839 template = OVL_CURRENT (template); 4840 4841 ctx = CP_DECL_CONTEXT (template); 4842 4843 if (TREE_CODE (ctx) == NAMESPACE_DECL) 4844 { 4845 if (arg_assoc_namespace (k, ctx) == 1) 4846 return 1; 4847 } 4848 /* It must be a member template. */ 4849 else if (arg_assoc_class (k, ctx) == 1) 4850 return 1; 4851 4852 /* Now the arguments. */ 4853 for (arg = args; arg != NULL_TREE; arg = TREE_CHAIN (arg)) 4854 { 4855 tree t = TREE_VALUE (arg); 4856 4857 if (TREE_CODE (t) == TEMPLATE_DECL) 4858 { 4859 ctx = CP_DECL_CONTEXT (t); 4860 if (TREE_CODE (ctx) == NAMESPACE_DECL) 4861 { 4862 if (arg_assoc_namespace (k, ctx) == 1) 4863 return 1; 4864 } 4865 else if (arg_assoc_class (k, ctx) == 1) 4866 return 1; 4867 } 4868 else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't' 4869 && arg_assoc_type (k, t) == 1) 4870 return 1; 4871 } 4872 } 4873 else 4874 { 4875 my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715); 4876 4877 for (; n; n = OVL_CHAIN (n)) 4878 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n)))) 4879 return 1; 4880 } 4881 |
4882 return 0; 4883} 4884 4885/* Performs Koenig lookup depending on arguments, where fns 4886 are the functions found in normal lookup. */ 4887 4888tree 4889lookup_arg_dependent (name, fns, args) --- 14 unchanged lines hidden (view full) --- 4904} 4905 4906/* Process a namespace-alias declaration. */ 4907 4908void 4909do_namespace_alias (alias, namespace) 4910 tree alias, namespace; 4911{ |
4912 if (TREE_CODE (namespace) != NAMESPACE_DECL) 4913 { 4914 /* The parser did not find it, so it's not there. */ 4915 cp_error ("unknown namespace `%D'", namespace); 4916 return; 4917 } 4918 4919 namespace = ORIGINAL_NAMESPACE (namespace); --- 11 unchanged lines hidden (view full) --- 4931validate_nonmember_using_decl (decl, scope, name) 4932 tree decl; 4933 tree *scope; 4934 tree *name; 4935{ 4936 if (TREE_CODE (decl) == SCOPE_REF 4937 && TREE_OPERAND (decl, 0) == std_node) 4938 { |
4939 if (namespace_bindings_p () 4940 && current_namespace == global_namespace) 4941 /* There's no need for a using declaration at all, here, 4942 since `std' is the same as `::'. We can't just pass this 4943 on because we'll complain later about declaring something 4944 in the same scope as a using declaration with the same 4945 name. We return NULL_TREE which indicates to the caller 4946 that there's no need to do any further processing. */ 4947 return NULL_TREE; 4948 |
4949 *scope = global_namespace; 4950 *name = TREE_OPERAND (decl, 1); 4951 } 4952 else if (TREE_CODE (decl) == SCOPE_REF) 4953 { 4954 *scope = TREE_OPERAND (decl, 0); 4955 *name = TREE_OPERAND (decl, 1); |
4956 4957 /* [namespace.udecl] 4958 4959 A using-declaration for a class member shall be a 4960 member-declaration. */ 4961 if (TREE_CODE (*scope) != NAMESPACE_DECL) 4962 { 4963 if (TYPE_P (*scope)) 4964 cp_error ("`%T' is not a namespace", *scope); 4965 else 4966 cp_error ("`%D' is not a namespace", *scope); 4967 return NULL_TREE; 4968 } |
4969 } 4970 else if (TREE_CODE (decl) == IDENTIFIER_NODE |
4971 || TREE_CODE (decl) == TYPE_DECL 4972 || TREE_CODE (decl) == TEMPLATE_DECL) |
4973 { 4974 *scope = global_namespace; 4975 *name = decl; 4976 } 4977 else 4978 my_friendly_abort (382); 4979 if (TREE_CODE_CLASS (TREE_CODE (*name)) == 'd') 4980 *name = DECL_NAME (*name); --- 33 unchanged lines hidden (view full) --- 5014 { 5015 duplicate_decls (OVL_CURRENT (BINDING_VALUE (decls)), oldval); 5016 oldval = NULL_TREE; 5017 } 5018 5019 *newval = oldval; 5020 for (tmp = BINDING_VALUE (decls); tmp; tmp = OVL_NEXT (tmp)) 5021 { |
5022 tree new_fn = OVL_CURRENT (tmp); 5023 5024 /* [namespace.udecl] 5025 5026 If a function declaration in namespace scope or block 5027 scope has the same name and the same parameter types as a 5028 function introduced by a using declaration the program is 5029 ill-formed. */ |
5030 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1)) |
5031 { 5032 tree old_fn = OVL_CURRENT (tmp1); |
5033 |
5034 if (!OVL_USED (tmp1) 5035 && compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)), 5036 TYPE_ARG_TYPES (TREE_TYPE (old_fn)))) 5037 { 5038 /* There was already a non-using declaration in 5039 this scope with the same parameter types. */ 5040 cp_error ("`%D' is already declared in this scope", 5041 name); 5042 break; 5043 } 5044 else if (duplicate_decls (new_fn, old_fn)) 5045 /* We're re-using something we already used 5046 before. We don't need to add it again. */ 5047 break; 5048 } 5049 5050 /* If we broke out of the loop, there's no reason to add 5051 this function to the using declarations for this 5052 scope. */ |
5053 if (tmp1) 5054 continue; 5055 5056 *newval = build_overload (OVL_CURRENT (tmp), *newval); 5057 if (TREE_CODE (*newval) != OVERLOAD) 5058 *newval = ovl_cons (*newval, NULL_TREE); 5059 OVL_USED (*newval) = 1; 5060 } --- 56 unchanged lines hidden (view full) --- 5117 return; 5118 5119 oldval = lookup_name_current_level (name); 5120 oldtype = lookup_type_current_level (name); 5121 5122 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype); 5123 5124 if (newval) |
5125 { 5126 if (is_overloaded_fn (newval)) 5127 { 5128 tree fn, term; 5129 5130 /* We only need to push declarations for those functions 5131 that were not already bound in the current level. 5132 The old value might be NULL_TREE, it might be a single 5133 function, or an OVERLOAD. */ 5134 if (oldval && TREE_CODE (oldval) == OVERLOAD) 5135 term = OVL_FUNCTION (oldval); 5136 else 5137 term = oldval; 5138 for (fn = newval; fn && OVL_CURRENT (fn) != term; 5139 fn = OVL_NEXT (fn)) 5140 push_overloaded_decl (OVL_CURRENT (fn), 5141 PUSH_LOCAL | PUSH_USING); 5142 } 5143 else 5144 push_local_binding (name, newval, PUSH_USING); 5145 } |
5146 if (newtype) 5147 set_identifier_type_value (name, newtype); 5148} 5149 5150tree 5151do_class_using_decl (decl) 5152 tree decl; 5153{ --- 73 unchanged lines hidden (view full) --- 5227void 5228mark_used (decl) 5229 tree decl; 5230{ 5231 TREE_USED (decl) = 1; 5232 if (processing_template_decl) 5233 return; 5234 assemble_external (decl); |
5235 |
5236 /* Is it a synthesized method that needs to be synthesized? */ 5237 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CLASS_CONTEXT (decl) 5238 && DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl) 5239 /* Kludge: don't synthesize for default args. */ 5240 && current_function_decl) 5241 synthesize_method (decl); |
5242 5243 /* If this is a function or variable that is an instance of some 5244 template, we now know that we will need to actually do the 5245 instantiation. A TEMPLATE_DECL may also have DECL_TEMPLATE_INFO, 5246 if it's a partial instantiation, but there's no need to 5247 instantiate such a thing. We check that DECL is not an explicit 5248 instantiation because that is not checked in instantiate_decl. */ 5249 if (TREE_CODE (decl) != TEMPLATE_DECL 5250 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl) 5251 && !DECL_EXPLICIT_INSTANTIATION (decl)) |
5252 instantiate_decl (decl); 5253} 5254 |
5255/* Helper function for named_class_head_sans_basetype nonterminal. We 5256 have just seen something of the form `AGGR SCOPE::ID'. Return a 5257 TYPE_DECL for the type declared by ID in SCOPE. */ |
5258 5259tree 5260handle_class_head (aggr, scope, id) 5261 tree aggr, scope, id; 5262{ |
5263 tree decl; 5264 |
5265 if (TREE_CODE (id) == TYPE_DECL) |
5266 decl = id; 5267 else if (DECL_CLASS_TEMPLATE_P (id)) 5268 decl = DECL_TEMPLATE_RESULT (id); 5269 else 5270 { 5271 if (scope) 5272 cp_error ("`%T' does not have a nested type named `%D'", scope, id); 5273 else 5274 cp_error ("no file-scope type named `%D'", id); 5275 5276 decl = TYPE_MAIN_DECL (xref_tag (aggr, make_anon_name (), 1)); 5277 } |
5278 |
5279 /* This syntax is only allowed when we're defining a type, so we 5280 enter the SCOPE. */ 5281 push_scope (CP_DECL_CONTEXT (decl)); |
5282 |
5283 /* If we see something like: 5284 5285 template <typename T> struct S::I .... 5286 5287 we must create a TEMPLATE_DECL for the nested type. */ 5288 if (PROCESSING_REAL_TEMPLATE_DECL_P ()) 5289 decl = push_template_decl (decl); 5290 5291 return decl; |
5292} |