![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to decl2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to decl2.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 root 1: /* Process declarations and variables for C compiler. 1.1.1.2 root 2: Copyright (C) 1988, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. 1.1 root 3: Hacked by Michael Tiemann ([email protected]) 4: 5: This file is part of GNU CC. 6: 7: GNU CC is free software; you can redistribute it and/or modify 8: it under the terms of the GNU General Public License as published by 9: the Free Software Foundation; either version 2, or (at your option) 10: any later version. 11: 12: GNU CC is distributed in the hope that it will be useful, 13: but WITHOUT ANY WARRANTY; without even the implied warranty of 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15: GNU General Public License for more details. 16: 17: You should have received a copy of the GNU General Public License 18: along with GNU CC; see the file COPYING. If not, write to 1.1.1.2 root 19: the Free Software Foundation, 59 Temple Place - Suite 330, 20: Boston, MA 02111-1307, USA. */ 1.1 root 21: 22: 23: /* Process declarations and symbol lookup for C front end. 24: Also constructs types; the standard scalar types at initialization, 25: and structure, union, array and enum types when they are declared. */ 26: 27: /* ??? not all decl nodes are given the most useful possible 28: line numbers. For example, the CONST_DECLs for enum values. */ 29: 30: #include "config.h" 31: #include <stdio.h> 32: #include "tree.h" 33: #include "rtl.h" 34: #include "flags.h" 35: #include "cp-tree.h" 36: #include "decl.h" 37: #include "lex.h" 1.1.1.2 root 38: #include "output.h" 39: #include "defaults.h" 1.1 root 40: 41: extern tree get_file_function_name (); 42: extern tree cleanups_this_call; 43: static void grok_function_init (); 44: 45: /* A list of virtual function tables we must make sure to write out. */ 46: tree pending_vtables; 47: 48: /* A list of static class variables. This is needed, because a 49: static class variable can be declared inside the class without 50: an initializer, and then initialized, staticly, outside the class. */ 51: tree pending_statics; 52: 53: /* A list of functions which were declared inline, but which we 54: may need to emit outline anyway. */ 55: static tree saved_inlines; 56: 57: /* Used to help generate temporary names which are unique within 58: a function. Reset to 0 by start_function. */ 59: 1.1.1.2 root 60: int temp_name_counter; 1.1 root 61: 62: /* Same, but not reset. Local temp variables and global temp variables 63: can have the same name. */ 64: static int global_temp_name_counter; 65: 66: /* Flag used when debugging spew.c */ 67: 68: extern int spew_debug; 1.1.1.2 root 69: 70: /* Functions called along with real static constructors and destructors. */ 71: 72: tree static_ctors, static_dtors; 1.1 root 73: 74: /* C (and C++) language-specific option variables. */ 75: 76: /* Nonzero means allow type mismatches in conditional expressions; 77: just make their values `void'. */ 78: 79: int flag_cond_mismatch; 80: 81: /* Nonzero means give `double' the same size as `float'. */ 82: 83: int flag_short_double; 84: 85: /* Nonzero means don't recognize the keyword `asm'. */ 86: 87: int flag_no_asm; 88: 1.1.1.2 root 89: /* Nonzero means don't recognize any extension keywords. */ 90: 91: int flag_no_gnu_keywords; 92: 1.1 root 93: /* Nonzero means don't recognize the non-ANSI builtin functions. */ 94: 95: int flag_no_builtin; 96: 97: /* Nonzero means don't recognize the non-ANSI builtin functions. 98: -ansi sets this. */ 99: 100: int flag_no_nonansi_builtin; 101: 102: /* Nonzero means do some things the same way PCC does. */ 103: 104: int flag_traditional; 105: 106: /* Nonzero means to treat bitfields as unsigned unless they say `signed'. */ 107: 108: int flag_signed_bitfields = 1; 109: 110: /* Nonzero means handle `#ident' directives. 0 means ignore them. */ 111: 1.1.1.2 root 112: int flag_no_ident; 1.1 root 113: 1.1.1.2 root 114: /* Nonzero means enable obscure ANSI features and disable GNU extensions 115: that might cause ANSI-compliant code to be miscompiled. */ 1.1 root 116: 1.1.1.2 root 117: int flag_ansi; 1.1 root 118: 119: /* Nonzero means do emit exported implementations of functions even if 120: they can be inlined. */ 121: 122: int flag_implement_inlines = 1; 123: 124: /* Nonzero means do emit exported implementations of templates, instead of 125: multiple static copies in each file that needs a definition. */ 126: 1.1.1.2 root 127: int flag_external_templates; 1.1 root 128: 129: /* Nonzero means that the decision to emit or not emit the implementation of a 130: template depends on where the template is instantiated, rather than where 131: it is defined. */ 132: 1.1.1.2 root 133: int flag_alt_external_templates; 1.1 root 134: 135: /* Nonzero means that implicit instantiations will be emitted if needed. */ 136: 137: int flag_implicit_templates = 1; 138: 139: /* Nonzero means warn about implicit declarations. */ 140: 141: int warn_implicit = 1; 142: 143: /* Nonzero means warn when all ctors or dtors are private, and the class 144: has no friends. */ 145: 146: int warn_ctor_dtor_privacy = 1; 147: 148: /* True if we want to implement vtbvales using "thunks". 1.1.1.2 root 149: The default is off now, but will be on later. */ 150: 151: int flag_vtable_thunks; 152: 153: /* True if we want to deal with repository information. */ 1.1 root 154: 1.1.1.2 root 155: int flag_use_repository; 1.1 root 156: 157: /* Nonzero means give string constants the type `const char *' 158: to get extra warnings from them. These warnings will be too numerous 159: to be useful, except in thoroughly ANSIfied programs. */ 160: 161: int warn_write_strings; 162: 163: /* Nonzero means warn about pointer casts that can drop a type qualifier 164: from the pointer target type. */ 165: 166: int warn_cast_qual; 167: 168: /* Nonzero means warn that dbx info for template class methods isn't fully 169: supported yet. */ 170: 171: int warn_template_debugging; 172: 173: /* Warn about traditional constructs whose meanings changed in ANSI C. */ 174: 175: int warn_traditional; 176: 177: /* Nonzero means warn about sizeof(function) or addition/subtraction 178: of function pointers. */ 179: 180: int warn_pointer_arith; 181: 182: /* Nonzero means warn for non-prototype function decls 183: or non-prototyped defs without previous prototype. */ 184: 185: int warn_strict_prototypes; 186: 187: /* Nonzero means warn for any function def without prototype decl. */ 188: 189: int warn_missing_prototypes; 190: 191: /* Nonzero means warn about multiple (redundant) decls for the same single 192: variable or function. */ 193: 194: int warn_redundant_decls; 195: 196: /* Warn if initializer is not completely bracketed. */ 197: 198: int warn_missing_braces; 199: 200: /* Warn about *printf or *scanf format/argument anomalies. */ 201: 202: int warn_format; 203: 204: /* Warn about a subscript that has type char. */ 205: 206: int warn_char_subscripts; 207: 208: /* Warn if a type conversion is done that might have confusing results. */ 209: 210: int warn_conversion; 211: 212: /* Warn if adding () is suggested. */ 213: 1.1.1.2 root 214: int warn_parentheses; 1.1 root 215: 216: /* Non-zero means warn in function declared in derived class has the 217: same name as a virtual in the base class, but fails to match the 218: type signature of any virtual function in the base class. */ 219: int warn_overloaded_virtual; 220: 221: /* Non-zero means warn when declaring a class that has a non virtual 222: destructor, when it really ought to have a virtual one. */ 223: int warn_nonvdtor; 224: 225: /* Non-zero means warn when a function is declared extern and later inline. */ 226: int warn_extern_inline; 227: 228: /* Non-zero means warn when the compiler will reorder code. */ 229: int warn_reorder; 230: 1.1.1.2 root 231: /* Non-zero means warn when synthesis behavior differs from Cfront's. */ 1.1 root 232: int warn_synth; 233: 234: /* Nonzero means `$' can be in an identifier. 235: See cccp.c for reasons why this breaks some obscure ANSI C programs. */ 236: 237: #ifndef DOLLARS_IN_IDENTIFIERS 238: #define DOLLARS_IN_IDENTIFIERS 1 239: #endif 240: int dollars_in_ident = DOLLARS_IN_IDENTIFIERS; 241: 242: /* Nonzero for -fno-strict-prototype switch: do not consider empty 243: argument prototype to mean function takes no arguments. */ 244: 1.1.1.2 root 245: int flag_strict_prototype = 2; 1.1 root 246: int strict_prototype = 1; 247: int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus = 1; 248: 249: /* Nonzero means that labels can be used as first-class objects */ 250: 251: int flag_labels_ok; 252: 253: /* Non-zero means to collect statistics which might be expensive 254: and to print them when we are done. */ 255: int flag_detailed_statistics; 256: 257: /* C++ specific flags. */ 258: /* Nonzero for -fall-virtual: make every member function (except 259: constructors) lay down in the virtual function table. Calls 260: can then either go through the virtual function table or not, 261: depending. */ 262: 263: int flag_all_virtual; 264: 265: /* Zero means that `this' is a *const. This gives nice behavior in the 266: 2.0 world. 1 gives 1.2-compatible behavior. 2 gives Spring behavior. 267: -2 means we're constructing an object and it has fixed type. */ 268: 269: int flag_this_is_variable; 270: 271: /* Nonzero means memoize our member lookups. */ 272: 273: int flag_memoize_lookups; int flag_save_memoized_contexts; 274: 275: /* 3 means write out only virtuals function tables `defined' 276: in this implementation file. 277: 2 means write out only specific virtual function tables 278: and give them (C) public access. 279: 1 means write out virtual function tables and give them 280: (C) public access. 281: 0 means write out virtual function tables and give them 282: (C) static access (default). 283: -1 means declare virtual function tables extern. */ 284: 285: int write_virtuals; 286: 287: /* Nonzero means we should attempt to elide constructors when possible. */ 288: 289: int flag_elide_constructors; 290: 291: /* Nonzero means recognize and handle exception handling constructs. 292: Use ansi syntax and semantics. WORK IN PROGRESS! */ 293: 294: int flag_handle_exceptions; 295: 296: /* Nonzero means recognize and handle signature language constructs. */ 297: 298: int flag_handle_signatures; 299: 300: /* Nonzero means that member functions defined in class scope are 301: inline by default. */ 302: 303: int flag_default_inline = 1; 304: 305: /* Controls whether enums and ints freely convert. 306: 1 means with complete freedom. 307: 0 means enums can convert to ints, but not vice-versa. */ 308: int flag_int_enum_equivalence; 309: 310: /* Controls whether compiler is operating under LUCID's Cadillac 311: system. 1 means yes, 0 means no. */ 312: int flag_cadillac; 313: 314: /* Controls whether compiler generates code to build objects 315: that can be collected when they become garbage. */ 316: int flag_gc; 317: 1.1.1.2 root 318: /* Controls whether compiler generates 'type descriptor' that give 1.1 root 319: run-time type information. */ 1.1.1.2 root 320: int flag_rtti; 1.1 root 321: 322: /* Nonzero if we wish to output cross-referencing information 323: for the GNU class browser. */ 324: extern int flag_gnu_xref; 325: 326: /* Nonzero if compiler can make `reasonable' assumptions about 327: references and objects. For example, the compiler must be 328: conservative about the following and not assume that `a' is nonnull: 329: 330: obj &a = g (); 331: a.f (2); 332: 333: In general, it is `reasonable' to assume that for many programs, 334: and better code can be generated in that case. */ 335: 1.1.1.2 root 336: int flag_assume_nonnull_objects = 1; 1.1 root 337: 338: /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes) 339: objects. */ 1.1.1.2 root 340: 1.1 root 341: int flag_huge_objects; 342: 343: /* Nonzero if we want to conserve space in the .o files. We do this 344: by putting uninitialized data and runtime initialized data into 1.1.1.2 root 345: .common instead of .data at the expense of not flagging multiple 1.1 root 346: definitions. */ 1.1.1.2 root 347: 1.1 root 348: int flag_conserve_space; 349: 350: /* Nonzero if we want to obey access control semantics. */ 1.1.1.2 root 351: 1.1 root 352: int flag_access_control = 1; 353: 1.1.1.2 root 354: /* Nonzero if we want to understand the operator names, i.e. 'bitand'. */ 355: 356: int flag_operator_names; 357: 358: /* Nonzero if we want to check the return value of new and avoid calling 359: constructors if it is a null pointer. */ 360: 361: int flag_check_new; 362: 363: /* Nonzero if we want the new ANSI rules for pushing a new scope for `for' 364: initialization variables. 365: 0: Old rules, set by -fno-for-scope. 366: 2: New ANSI rules, set by -ffor-scope. 367: 1: Try to implement new ANSI rules, but with backup compatibility 368: (and warnings). This is the default, for now. */ 369: 370: int flag_new_for_scope = 1; 371: 1.1 root 372: /* Table of language-dependent -f options. 373: STRING is the option name. VARIABLE is the address of the variable. 374: ON_VALUE is the value to store in VARIABLE 375: if `-fSTRING' is seen as an option. 376: (If `-fno-STRING' is seen as an option, the opposite value is stored.) */ 377: 378: static struct { char *string; int *variable; int on_value;} lang_f_options[] = 379: { 380: {"signed-char", &flag_signed_char, 1}, 381: {"unsigned-char", &flag_signed_char, 0}, 382: {"signed-bitfields", &flag_signed_bitfields, 1}, 383: {"unsigned-bitfields", &flag_signed_bitfields, 0}, 384: {"short-enums", &flag_short_enums, 1}, 385: {"short-double", &flag_short_double, 1}, 386: {"cond-mismatch", &flag_cond_mismatch, 1}, 387: {"asm", &flag_no_asm, 0}, 388: {"builtin", &flag_no_builtin, 0}, 389: {"ident", &flag_no_ident, 0}, 390: {"labels-ok", &flag_labels_ok, 1}, 391: {"stats", &flag_detailed_statistics, 1}, 392: {"this-is-variable", &flag_this_is_variable, 1}, 1.1.1.2 root 393: {"strict-prototype", &flag_strict_prototype, 1}, 1.1 root 394: {"all-virtual", &flag_all_virtual, 1}, 395: {"memoize-lookups", &flag_memoize_lookups, 1}, 396: {"elide-constructors", &flag_elide_constructors, 1}, 397: {"handle-exceptions", &flag_handle_exceptions, 1}, 398: {"handle-signatures", &flag_handle_signatures, 1}, 399: {"default-inline", &flag_default_inline, 1}, 400: {"dollars-in-identifiers", &dollars_in_ident, 1}, 401: {"enum-int-equiv", &flag_int_enum_equivalence, 1}, 402: {"gc", &flag_gc, 1}, 1.1.1.2 root 403: {"rtti", &flag_rtti, 1}, 1.1 root 404: {"xref", &flag_gnu_xref, 1}, 405: {"nonnull-objects", &flag_assume_nonnull_objects, 1}, 406: {"implement-inlines", &flag_implement_inlines, 1}, 407: {"external-templates", &flag_external_templates, 1}, 408: {"implicit-templates", &flag_implicit_templates, 1}, 409: {"huge-objects", &flag_huge_objects, 1}, 410: {"conserve-space", &flag_conserve_space, 1}, 411: {"vtable-thunks", &flag_vtable_thunks, 1}, 412: {"short-temps", &flag_short_temps, 1}, 413: {"access-control", &flag_access_control, 1}, 1.1.1.2 root 414: {"nonansi-builtins", &flag_no_nonansi_builtin, 0}, 415: {"gnu-keywords", &flag_no_gnu_keywords, 0}, 416: {"operator-names", &flag_operator_names, 1}, 417: {"check-new", &flag_check_new, 1}, 418: {"repo", &flag_use_repository, 1}, 419: {"for-scope", &flag_new_for_scope, 2} 1.1 root 420: }; 421: 422: /* Decode the string P as a language-specific option. 423: Return 1 if it is recognized (and handle it); 424: return 0 if not recognized. */ 425: 426: int 427: lang_decode_option (p) 428: char *p; 429: { 430: if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional")) 431: flag_traditional = 1, dollars_in_ident = 1, flag_writable_strings = 1, 1.1.1.2 root 432: flag_this_is_variable = 1, flag_new_for_scope = 0; 1.1 root 433: /* The +e options are for cfront compatibility. They come in as 434: `-+eN', to kludge around gcc.c's argument handling. */ 435: else if (p[0] == '-' && p[1] == '+' && p[2] == 'e') 436: { 437: int old_write_virtuals = write_virtuals; 438: if (p[3] == '1') 439: write_virtuals = 1; 440: else if (p[3] == '0') 441: write_virtuals = -1; 442: else if (p[3] == '2') 443: write_virtuals = 2; 444: else error ("invalid +e option"); 445: if (old_write_virtuals != 0 446: && write_virtuals != old_write_virtuals) 447: error ("conflicting +e options given"); 448: } 449: else if (p[0] == '-' && p[1] == 'f') 450: { 451: /* Some kind of -f option. 452: P's value is the option sans `-f'. 453: Search for it in the table of options. */ 454: int found = 0, j; 455: 456: p += 2; 457: /* Try special -f options. */ 458: 459: if (!strcmp (p, "save-memoized")) 460: { 461: flag_memoize_lookups = 1; 462: flag_save_memoized_contexts = 1; 463: found = 1; 464: } 465: if (!strcmp (p, "no-save-memoized")) 466: { 467: flag_memoize_lookups = 0; 468: flag_save_memoized_contexts = 0; 469: found = 1; 470: } 471: else if (! strncmp (p, "cadillac", 8)) 472: { 473: flag_cadillac = atoi (p+9); 474: found = 1; 475: } 476: else if (! strncmp (p, "no-cadillac", 11)) 477: { 478: flag_cadillac = 0; 479: found = 1; 480: } 481: else if (! strcmp (p, "gc")) 482: { 483: flag_gc = 1; 484: /* This must come along for the ride. */ 1.1.1.2 root 485: flag_rtti = 1; 1.1 root 486: found = 1; 487: } 488: else if (! strcmp (p, "no-gc")) 489: { 490: flag_gc = 0; 491: /* This must come along for the ride. */ 1.1.1.2 root 492: flag_rtti = 0; 1.1 root 493: found = 1; 494: } 495: else if (! strcmp (p, "alt-external-templates")) 496: { 497: flag_external_templates = 1; 498: flag_alt_external_templates = 1; 499: found = 1; 500: } 501: else if (! strcmp (p, "no-alt-external-templates")) 502: { 503: flag_alt_external_templates = 0; 504: found = 1; 505: } 506: else if (!strcmp (p, "ansi-overloading")) 507: { 508: warning ("-fansi-overloading is no longer meaningful"); 1.1.1.2 root 509: found = 1; 510: } 511: else if (!strcmp (p, "repo")) 512: { 513: flag_use_repository = 1; 514: flag_implicit_templates = 0; 515: found = 1; 1.1 root 516: } 517: else for (j = 0; 518: !found && j < sizeof (lang_f_options) / sizeof (lang_f_options[0]); 519: j++) 520: { 521: if (!strcmp (p, lang_f_options[j].string)) 522: { 523: *lang_f_options[j].variable = lang_f_options[j].on_value; 524: /* A goto here would be cleaner, 525: but breaks the vax pcc. */ 526: found = 1; 527: } 528: if (p[0] == 'n' && p[1] == 'o' && p[2] == '-' 529: && ! strcmp (p+3, lang_f_options[j].string)) 530: { 531: *lang_f_options[j].variable = ! lang_f_options[j].on_value; 532: found = 1; 533: } 534: } 535: return found; 536: } 537: else if (p[0] == '-' && p[1] == 'W') 538: { 539: int setting = 1; 540: 541: /* The -W options control the warning behavior of the compiler. */ 542: p += 2; 543: 544: if (p[0] == 'n' && p[1] == 'o' && p[2] == '-') 545: setting = 0, p += 3; 546: 547: if (!strcmp (p, "implicit")) 548: warn_implicit = setting; 549: else if (!strcmp (p, "return-type")) 550: warn_return_type = setting; 551: else if (!strcmp (p, "ctor-dtor-privacy")) 552: warn_ctor_dtor_privacy = setting; 553: else if (!strcmp (p, "write-strings")) 554: warn_write_strings = setting; 555: else if (!strcmp (p, "cast-qual")) 556: warn_cast_qual = setting; 557: else if (!strcmp (p, "traditional")) 558: warn_traditional = setting; 559: else if (!strcmp (p, "char-subscripts")) 560: warn_char_subscripts = setting; 561: else if (!strcmp (p, "pointer-arith")) 562: warn_pointer_arith = setting; 563: else if (!strcmp (p, "strict-prototypes")) 564: warn_strict_prototypes = setting; 565: else if (!strcmp (p, "missing-prototypes")) 566: warn_missing_prototypes = setting; 567: else if (!strcmp (p, "redundant-decls")) 568: warn_redundant_decls = setting; 569: else if (!strcmp (p, "missing-braces")) 570: warn_missing_braces = setting; 571: else if (!strcmp (p, "format")) 572: warn_format = setting; 573: else if (!strcmp (p, "conversion")) 574: warn_conversion = setting; 575: else if (!strcmp (p, "parentheses")) 576: warn_parentheses = setting; 577: else if (!strcmp (p, "non-virtual-dtor")) 578: warn_nonvdtor = setting; 579: else if (!strcmp (p, "extern-inline")) 580: warn_extern_inline = setting; 581: else if (!strcmp (p, "reorder")) 582: warn_reorder = setting; 583: else if (!strcmp (p, "synth")) 584: warn_synth = setting; 585: else if (!strcmp (p, "comment")) 586: ; /* cpp handles this one. */ 587: else if (!strcmp (p, "comments")) 588: ; /* cpp handles this one. */ 589: else if (!strcmp (p, "trigraphs")) 590: ; /* cpp handles this one. */ 591: else if (!strcmp (p, "import")) 592: ; /* cpp handles this one. */ 593: else if (!strcmp (p, "all")) 594: { 595: extra_warnings = setting; 596: warn_return_type = setting; 597: warn_unused = setting; 598: warn_implicit = setting; 599: warn_ctor_dtor_privacy = setting; 600: warn_switch = setting; 601: warn_format = setting; 1.1.1.2 root 602: warn_parentheses = setting; 1.1 root 603: warn_missing_braces = setting; 604: warn_extern_inline = setting; 605: warn_nonvdtor = setting; 606: /* We save the value of warn_uninitialized, since if they put 607: -Wuninitialized on the command line, we need to generate a 608: warning about not using it without also specifying -O. */ 609: if (warn_uninitialized != 1) 610: warn_uninitialized = (setting ? 2 : 0); 611: warn_template_debugging = setting; 612: warn_reorder = setting; 613: } 614: 615: else if (!strcmp (p, "overloaded-virtual")) 616: warn_overloaded_virtual = setting; 617: else return 0; 618: } 619: else if (!strcmp (p, "-ansi")) 1.1.1.2 root 620: dollars_in_ident = 0, flag_no_nonansi_builtin = 1, flag_ansi = 1, 621: flag_no_gnu_keywords = 1, flag_operator_names = 1; 1.1 root 622: #ifdef SPEW_DEBUG 623: /* Undocumented, only ever used when you're invoking cc1plus by hand, since 624: it's probably safe to assume no sane person would ever want to use this 625: under normal circumstances. */ 626: else if (!strcmp (p, "-spew-debug")) 627: spew_debug = 1; 628: #endif 629: else 630: return 0; 631: 632: return 1; 633: } 634: 635: /* Incorporate `const' and `volatile' qualifiers for member functions. 636: FUNCTION is a TYPE_DECL or a FUNCTION_DECL. 637: QUALS is a list of qualifiers. */ 638: tree 639: grok_method_quals (ctype, function, quals) 640: tree ctype, function, quals; 641: { 642: tree fntype = TREE_TYPE (function); 643: tree raises = TYPE_RAISES_EXCEPTIONS (fntype); 644: 645: do 646: { 647: extern tree ridpointers[]; 648: 649: if (TREE_VALUE (quals) == ridpointers[(int)RID_CONST]) 650: { 651: if (TYPE_READONLY (ctype)) 652: error ("duplicate `%s' %s", 653: IDENTIFIER_POINTER (TREE_VALUE (quals)), 654: (TREE_CODE (function) == FUNCTION_DECL 655: ? "for member function" : "in type declaration")); 656: ctype = build_type_variant (ctype, 1, TYPE_VOLATILE (ctype)); 657: build_pointer_type (ctype); 658: } 659: else if (TREE_VALUE (quals) == ridpointers[(int)RID_VOLATILE]) 660: { 661: if (TYPE_VOLATILE (ctype)) 662: error ("duplicate `%s' %s", 663: IDENTIFIER_POINTER (TREE_VALUE (quals)), 664: (TREE_CODE (function) == FUNCTION_DECL 665: ? "for member function" : "in type declaration")); 666: ctype = build_type_variant (ctype, TYPE_READONLY (ctype), 1); 667: build_pointer_type (ctype); 668: } 669: else 670: my_friendly_abort (20); 671: quals = TREE_CHAIN (quals); 672: } 673: while (quals); 674: fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype), 675: (TREE_CODE (fntype) == METHOD_TYPE 676: ? TREE_CHAIN (TYPE_ARG_TYPES (fntype)) 677: : TYPE_ARG_TYPES (fntype))); 678: if (raises) 1.1.1.2 root 679: fntype = build_exception_variant (fntype, raises); 1.1 root 680: 681: TREE_TYPE (function) = fntype; 682: return ctype; 683: } 684: 685: #if 0 /* Not used. */ 686: /* This routine replaces cryptic DECL_NAMEs with readable DECL_NAMEs. 687: It leaves DECL_ASSEMBLER_NAMEs with the correct value. */ 688: /* This does not yet work with user defined conversion operators 689: It should. */ 690: static void 691: substitute_nice_name (decl) 692: tree decl; 693: { 694: if (DECL_NAME (decl) && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE) 695: { 696: char *n = decl_as_string (DECL_NAME (decl), 1); 697: if (n[strlen (n) - 1] == ' ') 698: n[strlen (n) - 1] = 0; 699: DECL_NAME (decl) = get_identifier (n); 700: } 701: } 702: #endif 703: 704: /* Warn when -fexternal-templates is used and #pragma 705: interface/implementation is not used all the times it should be, 706: inform the user. */ 707: void 1.1.1.2 root 708: warn_if_unknown_interface (decl) 709: tree decl; 1.1 root 710: { 711: static int already_warned = 0; 1.1.1.2 root 712: if (already_warned++) 713: return; 714: 715: if (flag_alt_external_templates) 716: { 717: struct tinst_level *til = tinst_for_decl (); 718: int sl = lineno; 719: char *sf = input_filename; 720: 721: if (til) 722: { 723: lineno = til->line; 724: input_filename = til->file; 725: } 726: cp_warning ("template `%#D' instantiated in file without #pragma interface", 727: decl); 728: lineno = sl; 729: input_filename = sf; 730: } 731: else 732: cp_warning_at ("template `%#D' defined in file without #pragma interface", 733: decl); 1.1 root 734: } 735: 736: /* A subroutine of the parser, to handle a component list. */ 737: tree 738: grok_x_components (specs, components) 739: tree specs, components; 740: { 741: register tree t, x, tcode; 742: 743: /* We just got some friends. They have been recorded elsewhere. */ 744: if (components == void_type_node) 745: return NULL_TREE; 746: 747: if (components == NULL_TREE) 748: { 749: t = groktypename (build_decl_list (specs, NULL_TREE)); 750: 751: if (t == NULL_TREE) 752: { 753: error ("error in component specification"); 754: return NULL_TREE; 755: } 756: 757: switch (TREE_CODE (t)) 758: { 759: case VAR_DECL: 760: /* Static anonymous unions come out as VAR_DECLs. */ 761: if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE 762: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_TYPE (t)))) 763: return t; 764: 765: /* We return SPECS here, because in the parser it was ending 766: up with not doing anything to $$, which is what SPECS 767: represents. */ 768: return specs; 769: break; 770: 771: case RECORD_TYPE: 772: /* This code may be needed for UNION_TYPEs as 773: well. */ 774: tcode = record_type_node; 775: if (CLASSTYPE_DECLARED_CLASS(t)) 776: tcode = class_type_node; 777: else if (IS_SIGNATURE(t)) 778: tcode = signature_type_node; 779: 1.1.1.2 root 780: t = xref_tag (tcode, TYPE_IDENTIFIER (t), NULL_TREE, 0); 1.1 root 781: if (TYPE_CONTEXT(t)) 782: CLASSTYPE_NO_GLOBALIZE(t) = 1; 783: return NULL_TREE; 784: break; 785: 786: case UNION_TYPE: 787: case ENUMERAL_TYPE: 788: if (TREE_CODE(t) == UNION_TYPE) 789: tcode = union_type_node; 790: else 791: tcode = enum_type_node; 792: 1.1.1.2 root 793: t = xref_tag (tcode, TYPE_IDENTIFIER (t), NULL_TREE, 0); 1.1 root 794: if (TREE_CODE(t) == UNION_TYPE && TYPE_CONTEXT(t)) 795: CLASSTYPE_NO_GLOBALIZE(t) = 1; 796: if (TREE_CODE (t) == UNION_TYPE 797: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))) 798: { 799: struct pending_inline **p; 800: x = build_lang_field_decl (FIELD_DECL, NULL_TREE, t); 801: 802: /* Wipe out memory of synthesized methods */ 803: TYPE_HAS_CONSTRUCTOR (t) = 0; 804: TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0; 805: TYPE_HAS_INIT_REF (t) = 0; 806: TYPE_HAS_CONST_INIT_REF (t) = 0; 807: TYPE_HAS_ASSIGN_REF (t) = 0; 808: TYPE_HAS_ASSIGNMENT (t) = 0; 809: TYPE_HAS_CONST_ASSIGN_REF (t) = 0; 810: 811: p = &pending_inlines; 812: for (; *p; *p = (*p)->next) 813: if (DECL_CONTEXT ((*p)->fndecl) != t) 814: break; 815: } 816: else if (TREE_CODE (t) == ENUMERAL_TYPE) 817: x = grok_enum_decls (t, NULL_TREE); 818: else 819: x = NULL_TREE; 820: return x; 821: break; 822: 823: default: 824: if (t != void_type_node) 825: error ("empty component declaration"); 826: return NULL_TREE; 827: } 828: } 829: else 830: { 831: t = TREE_TYPE (components); 832: if (TREE_CODE (t) == ENUMERAL_TYPE && TREE_NONLOCAL_FLAG (t)) 833: return grok_enum_decls (t, components); 834: else 835: return components; 836: } 837: } 838: 839: /* Classes overload their constituent function names automatically. 840: When a function name is declared in a record structure, 841: its name is changed to it overloaded name. Since names for 842: constructors and destructors can conflict, we place a leading 843: '$' for destructors. 844: 845: CNAME is the name of the class we are grokking for. 846: 847: FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'. 848: 849: FLAGS contains bits saying what's special about today's 850: arguments. 1 == DESTRUCTOR. 2 == OPERATOR. 851: 852: If FUNCTION is a destructor, then we must add the `auto-delete' field 853: as a second parameter. There is some hair associated with the fact 854: that we must "declare" this variable in the manner consistent with the 855: way the rest of the arguments were declared. 856: 857: QUALS are the qualifiers for the this pointer. */ 858: 859: void 860: grokclassfn (ctype, cname, function, flags, quals) 861: tree ctype, cname, function; 862: enum overload_flags flags; 863: tree quals; 864: { 865: tree fn_name = DECL_NAME (function); 866: tree arg_types; 867: tree parm; 868: tree qualtype; 1.1.1.2 root 869: tree fntype = TREE_TYPE (function); 870: tree raises = TYPE_RAISES_EXCEPTIONS (fntype); 1.1 root 871: 872: if (fn_name == NULL_TREE) 873: { 874: error ("name missing for member function"); 875: fn_name = get_identifier ("<anonymous>"); 876: DECL_NAME (function) = fn_name; 877: } 878: 879: if (quals) 880: qualtype = grok_method_quals (ctype, function, quals); 881: else 882: qualtype = ctype; 883: 884: arg_types = TYPE_ARG_TYPES (TREE_TYPE (function)); 885: if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) 886: { 887: /* Must add the class instance variable up front. */ 888: /* Right now we just make this a pointer. But later 889: we may wish to make it special. */ 890: tree type = TREE_VALUE (arg_types); 1.1.1.2 root 891: int constp = 1; 1.1 root 892: 893: if ((flag_this_is_variable > 0) 894: && (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))) 1.1.1.2 root 895: constp = 0; 1.1 root 896: 897: if (DECL_CONSTRUCTOR_P (function)) 898: { 899: if (TYPE_USES_VIRTUAL_BASECLASSES (ctype)) 900: { 901: DECL_CONSTRUCTOR_FOR_VBASE_P (function) = 1; 902: /* In this case we need "in-charge" flag saying whether 903: this constructor is responsible for initialization 904: of virtual baseclasses or not. */ 905: parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node); 906: /* Mark the artificial `__in_chrg' parameter as "artificial". */ 907: SET_DECL_ARTIFICIAL (parm); 908: DECL_ARG_TYPE (parm) = integer_type_node; 909: DECL_REGISTER (parm) = 1; 910: TREE_CHAIN (parm) = last_function_parms; 911: last_function_parms = parm; 912: } 913: } 914: 915: parm = build_decl (PARM_DECL, this_identifier, type); 916: /* Mark the artificial `this' parameter as "artificial". */ 917: SET_DECL_ARTIFICIAL (parm); 918: DECL_ARG_TYPE (parm) = type; 919: /* We can make this a register, so long as we don't 920: accidentally complain if someone tries to take its address. */ 921: DECL_REGISTER (parm) = 1; 1.1.1.2 root 922: if (constp) 1.1 root 923: TREE_READONLY (parm) = 1; 924: TREE_CHAIN (parm) = last_function_parms; 925: last_function_parms = parm; 926: } 927: 928: if (flags == DTOR_FLAG) 929: { 930: char *buf, *dbuf; 931: tree const_integer_type = build_type_variant (integer_type_node, 1, 0); 932: int len = sizeof (DESTRUCTOR_DECL_PREFIX)-1; 933: 934: arg_types = hash_tree_chain (const_integer_type, void_list_node); 935: TREE_SIDE_EFFECTS (arg_types) = 1; 936: /* Build the overload name. It will look like `7Example'. */ 937: if (IDENTIFIER_TYPE_VALUE (cname)) 938: dbuf = build_overload_name (IDENTIFIER_TYPE_VALUE (cname), 1, 1); 939: else if (IDENTIFIER_LOCAL_VALUE (cname)) 940: dbuf = build_overload_name (TREE_TYPE (IDENTIFIER_LOCAL_VALUE (cname)), 1, 1); 941: else 942: /* Using ctype fixes the `X::Y::~Y()' crash. The cname has no type when 943: it's defined out of the class definition, since poplevel_class wipes 944: it out. This used to be internal error 346. */ 945: dbuf = build_overload_name (ctype, 1, 1); 946: buf = (char *) alloca (strlen (dbuf) + sizeof (DESTRUCTOR_DECL_PREFIX)); 947: bcopy (DESTRUCTOR_DECL_PREFIX, buf, len); 948: buf[len] = '\0'; 949: strcat (buf, dbuf); 950: DECL_ASSEMBLER_NAME (function) = get_identifier (buf); 951: parm = build_decl (PARM_DECL, in_charge_identifier, const_integer_type); 952: /* Mark the artificial `__in_chrg' parameter as "artificial". */ 953: SET_DECL_ARTIFICIAL (parm); 954: TREE_USED (parm) = 1; 955: #if 0 956: /* We don't need to mark the __in_chrg parameter itself as `const' 957: since its type is already `const int'. In fact we MUST NOT mark 958: it as `const' cuz that will screw up the debug info (causing it 959: to say that the type of __in_chrg is `const const int'). */ 960: TREE_READONLY (parm) = 1; 961: #endif 962: DECL_ARG_TYPE (parm) = const_integer_type; 963: /* This is the same chain as DECL_ARGUMENTS (...). */ 964: TREE_CHAIN (last_function_parms) = parm; 965: 1.1.1.2 root 966: fntype = build_cplus_method_type (qualtype, void_type_node, 967: arg_types); 968: if (raises) 969: { 970: fntype = build_exception_variant (fntype, raises); 971: } 972: TREE_TYPE (function) = fntype; 1.1 root 973: TYPE_HAS_DESTRUCTOR (ctype) = 1; 974: } 975: else 976: { 977: tree these_arg_types; 978: 979: if (DECL_CONSTRUCTOR_FOR_VBASE_P (function)) 980: { 981: arg_types = hash_tree_chain (integer_type_node, 982: TREE_CHAIN (arg_types)); 1.1.1.2 root 983: fntype = build_cplus_method_type (qualtype, 984: TREE_TYPE (TREE_TYPE (function)), 985: arg_types); 986: if (raises) 987: { 988: fntype = build_exception_variant (fntype, raises); 989: } 990: TREE_TYPE (function) = fntype; 1.1 root 991: arg_types = TYPE_ARG_TYPES (TREE_TYPE (function)); 992: } 993: 994: these_arg_types = arg_types; 995: 996: if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) 997: /* Only true for static member functions. */ 1.1.1.2 root 998: these_arg_types = hash_tree_chain (build_pointer_type (qualtype), 1.1 root 999: arg_types); 1000: 1001: DECL_ASSEMBLER_NAME (function) 1002: = build_decl_overload (fn_name, these_arg_types, 1003: 1 + DECL_CONSTRUCTOR_P (function)); 1004: 1005: #if 0 1006: /* This code is going into the compiler, but currently, it makes 1.1.1.2 root 1007: libg++/src/Integer.cc not compile. The problem is that the nice name 1.1 root 1008: winds up going into the symbol table, and conversion operations look 1009: for the manged name. */ 1010: substitute_nice_name (function); 1011: #endif 1012: } 1013: 1014: DECL_ARGUMENTS (function) = last_function_parms; 1015: /* First approximations. */ 1016: DECL_CONTEXT (function) = ctype; 1017: DECL_CLASS_CONTEXT (function) = ctype; 1018: } 1019: 1020: /* Work on the expr used by alignof (this is only called by the parser). */ 1021: tree 1022: grok_alignof (expr) 1023: tree expr; 1024: { 1025: tree best, t; 1026: int bestalign; 1027: 1028: if (TREE_CODE (expr) == COMPONENT_REF 1029: && DECL_BIT_FIELD (TREE_OPERAND (expr, 1))) 1030: error ("`__alignof__' applied to a bit-field"); 1031: 1032: if (TREE_CODE (expr) == INDIRECT_REF) 1033: { 1034: best = t = TREE_OPERAND (expr, 0); 1035: bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 1036: 1037: while (TREE_CODE (t) == NOP_EXPR 1038: && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE) 1039: { 1040: int thisalign; 1041: t = TREE_OPERAND (t, 0); 1042: thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 1043: if (thisalign > bestalign) 1044: best = t, bestalign = thisalign; 1045: } 1046: return c_alignof (TREE_TYPE (TREE_TYPE (best))); 1047: } 1048: else 1049: { 1050: /* ANSI says arrays and fns are converted inside comma. 1051: But we can't convert them in build_compound_expr 1052: because that would break commas in lvalues. 1053: So do the conversion here if operand was a comma. */ 1054: if (TREE_CODE (expr) == COMPOUND_EXPR 1055: && (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE 1056: || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)) 1057: expr = default_conversion (expr); 1058: return c_alignof (TREE_TYPE (expr)); 1059: } 1060: } 1061: 1062: /* Create an ARRAY_REF, checking for the user doing things backwards 1063: along the way. */ 1064: tree 1065: grok_array_decl (array_expr, index_exp) 1066: tree array_expr, index_exp; 1067: { 1068: tree type = TREE_TYPE (array_expr); 1.1.1.2 root 1069: tree p1, p2, i1, i2; 1.1 root 1070: 1071: if (type == error_mark_node || index_exp == error_mark_node) 1072: return error_mark_node; 1073: if (type == NULL_TREE) 1074: { 1075: /* Something has gone very wrong. Assume we are mistakenly reducing 1076: an expression instead of a declaration. */ 1077: error ("parser may be lost: is there a '{' missing somewhere?"); 1078: return NULL_TREE; 1079: } 1080: 1081: if (TREE_CODE (type) == OFFSET_TYPE 1082: || TREE_CODE (type) == REFERENCE_TYPE) 1083: type = TREE_TYPE (type); 1084: 1085: /* If they have an `operator[]', use that. */ 1086: if (TYPE_LANG_SPECIFIC (type) 1087: && TYPE_OVERLOADS_ARRAY_REF (type)) 1088: return build_opfncall (ARRAY_REF, LOOKUP_NORMAL, 1089: array_expr, index_exp, NULL_TREE); 1090: 1091: /* Otherwise, create an ARRAY_REF for a pointer or array type. */ 1092: 1.1.1.2 root 1093: if (TREE_CODE (type) == ARRAY_TYPE) 1094: p1 = array_expr; 1095: else 1096: p1 = build_expr_type_conversion (WANT_POINTER, array_expr, 0); 1.1 root 1097: 1.1.1.2 root 1098: if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE) 1099: p2 = index_exp; 1100: else 1101: p2 = build_expr_type_conversion (WANT_POINTER, index_exp, 0); 1102: 1103: i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 0); 1104: i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 0); 1.1 root 1105: 1.1.1.2 root 1106: if ((p1 && i2) && (i1 && p2)) 1107: error ("ambiguous conversion for array subscript"); 1108: 1109: if (p1 && i2) 1110: array_expr = p1, index_exp = i2; 1111: else if (i1 && p2) 1112: array_expr = p2, index_exp = i1; 1113: else 1114: { 1115: cp_error ("invalid types `%T[%T]' for array subscript", 1116: type, TREE_TYPE (index_exp)); 1117: return error_mark_node; 1118: } 1119: 1120: if (array_expr == error_mark_node || index_exp == error_mark_node) 1121: error ("ambiguous conversion for array subscript"); 1122: 1123: return build_array_ref (array_expr, index_exp); 1.1 root 1124: } 1125: 1126: /* Given the cast expression EXP, checking out its validity. Either return 1127: an error_mark_node if there was an unavoidable error, return a cast to 1128: void for trying to delete a pointer w/ the value 0, or return the 1129: call to delete. If DOING_VEC is 1, we handle things differently 1130: for doing an array delete. If DOING_VEC is 2, they gave us the 1131: array size as an argument to delete. 1132: Implements ARM $5.3.4. This is called from the parser. */ 1133: tree 1134: delete_sanity (exp, size, doing_vec, use_global_delete) 1135: tree exp, size; 1136: int doing_vec, use_global_delete; 1137: { 1138: tree t = stabilize_reference (convert_from_reference (exp)); 1139: tree type = TREE_TYPE (t); 1140: enum tree_code code = TREE_CODE (type); 1141: /* For a regular vector delete (aka, no size argument) we will pass 1142: this down as a NULL_TREE into build_vec_delete. */ 1143: tree maxindex = NULL_TREE; 1144: /* This is used for deleting arrays. */ 1145: tree elt_size; 1146: 1147: switch (doing_vec) 1148: { 1149: case 2: 1150: maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1); 1151: if (! flag_traditional) 1152: pedwarn ("anachronistic use of array size in vector delete"); 1153: /* Fall through. */ 1154: case 1: 1155: elt_size = c_sizeof (type); 1156: break; 1157: default: 1158: if (code != POINTER_TYPE) 1159: { 1160: cp_error ("type `%#T' argument given to `delete', expected pointer", 1161: type); 1162: return error_mark_node; 1163: } 1164: 1.1.1.2 root 1165: /* Deleting a pointer with the value zero is valid and has no effect. */ 1.1 root 1166: if (integer_zerop (t)) 1167: return build1 (NOP_EXPR, void_type_node, t); 1168: } 1169: 1170: if (code == POINTER_TYPE) 1171: { 1.1.1.2 root 1172: #if 0 1173: /* As of Valley Forge, you can delete a pointer to constant. */ 1.1 root 1174: /* You can't delete a pointer to constant. */ 1175: if (TREE_READONLY (TREE_TYPE (type))) 1176: { 1177: error ("`const *' cannot be deleted"); 1178: return error_mark_node; 1179: } 1.1.1.2 root 1180: #endif 1.1 root 1181: /* You also can't delete functions. */ 1182: if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 1183: { 1184: error ("cannot delete a function"); 1185: return error_mark_node; 1186: } 1187: } 1188: 1189: #if 0 1190: /* If the type has no destructor, then we should build a regular 1191: delete, instead of a vector delete. Otherwise, we would end 1192: up passing a bogus offset into __builtin_delete, which is 1193: not expecting it. */ 1194: if (doing_vec 1195: && TREE_CODE (type) == POINTER_TYPE 1196: && !TYPE_HAS_DESTRUCTOR (TREE_TYPE (type))) 1197: { 1198: doing_vec = 0; 1199: use_global_delete = 1; 1200: } 1201: #endif 1202: 1203: if (doing_vec) 1204: return build_vec_delete (t, maxindex, elt_size, integer_one_node, 1205: integer_two_node, use_global_delete); 1206: else 1.1.1.2 root 1207: { 1208: if (IS_AGGR_TYPE (TREE_TYPE (type)) 1209: && TYPE_GETS_REG_DELETE (TREE_TYPE (type))) 1210: { 1211: /* Only do access checking here; we'll be calling op delete 1212: from the destructor. */ 1213: tree tmp = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, t, 1214: size_zero_node, NULL_TREE); 1215: if (tmp == error_mark_node) 1216: return error_mark_node; 1217: } 1218: 1219: return build_delete (type, t, integer_three_node, 1220: LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE, 1221: use_global_delete); 1222: } 1.1 root 1223: } 1224: 1225: /* Sanity check: report error if this function FUNCTION is not 1226: really a member of the class (CTYPE) it is supposed to belong to. 1227: CNAME is the same here as it is for grokclassfn above. */ 1228: 1.1.1.2 root 1229: tree 1.1 root 1230: check_classfn (ctype, cname, function) 1231: tree ctype, cname, function; 1232: { 1233: tree fn_name = DECL_NAME (function); 1234: tree fndecl; 1235: tree method_vec = CLASSTYPE_METHOD_VEC (ctype); 1236: tree *methods = 0; 1237: tree *end = 0; 1238: 1239: if (method_vec != 0) 1240: { 1241: methods = &TREE_VEC_ELT (method_vec, 0); 1242: end = TREE_VEC_END (method_vec); 1243: 1244: /* First suss out ctors and dtors. */ 1.1.1.2 root 1245: if (*methods && fn_name == DECL_NAME (*methods)) 1.1 root 1246: goto got_it; 1247: 1248: while (++methods != end) 1249: { 1250: if (fn_name == DECL_NAME (*methods)) 1251: { 1252: got_it: 1253: fndecl = *methods; 1254: while (fndecl) 1255: { 1256: if (DECL_ASSEMBLER_NAME (function) == DECL_ASSEMBLER_NAME (fndecl)) 1.1.1.2 root 1257: return fndecl; 1258: #if 0 1259: /* This should work, but causes libg++ to fail 1260: make check-tFix. */ 1261: /* We have to do more extensive argument checking here, as 1262: the name may have been changed by asm("new_name"). */ 1263: if (decls_match (function, fndecl)) 1264: return fndecl; 1265: #else 1266: if (DECL_NAME (function) == DECL_NAME (fndecl)) 1267: { 1268: tree p1 = TYPE_ARG_TYPES (TREE_TYPE (function)); 1269: tree p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); 1270: 1271: /* Get rid of the this parameter on functions that become 1272: static. */ 1273: if (DECL_STATIC_FUNCTION_P (fndecl) 1274: && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) 1275: p1 = TREE_CHAIN (p1); 1276: 1277: if (comptypes (TREE_TYPE (TREE_TYPE (function)), 1278: TREE_TYPE (TREE_TYPE (fndecl)), 1) 1279: && compparms (p1, p2, 3)) 1280: { 1281: if (DECL_STATIC_FUNCTION_P (fndecl) 1282: && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) 1283: revert_static_member_fn (&function, NULL, NULL); 1284: return fndecl; 1285: } 1286: } 1287: #endif 1.1 root 1288: fndecl = DECL_CHAIN (fndecl); 1289: } 1290: break; /* loser */ 1291: } 1292: } 1293: } 1294: 1295: if (methods != end) 1.1.1.2 root 1296: { 1297: tree fndecl = *methods; 1298: cp_error ("prototype for `%#D' does not match any in class `%T'", 1299: function, ctype); 1300: cp_error_at ("candidate%s: %+#D", DECL_CHAIN (fndecl) ? "s are" : " is", 1301: fndecl); 1302: while (fndecl = DECL_CHAIN (fndecl), fndecl) 1303: cp_error_at (" %#D", fndecl); 1304: } 1.1 root 1305: else 1306: { 1307: methods = 0; 1308: cp_error ("no `%#D' member function declared in class `%T'", 1309: function, ctype); 1310: } 1311: 1312: /* If we did not find the method in the class, add it to 1313: avoid spurious errors. */ 1314: add_method (ctype, methods, function); 1.1.1.2 root 1315: return NULL_TREE; 1.1 root 1316: } 1317: 1318: /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted) 1319: of a structure component, returning a FIELD_DECL node. 1320: QUALS is a list of type qualifiers for this decl (such as for declaring 1321: const member functions). 1322: 1323: This is done during the parsing of the struct declaration. 1324: The FIELD_DECL nodes are chained together and the lot of them 1325: are ultimately passed to `build_struct' to make the RECORD_TYPE node. 1326: 1327: C++: 1328: 1329: If class A defines that certain functions in class B are friends, then 1330: the way I have set things up, it is B who is interested in permission 1331: granted by A. However, it is in A's context that these declarations 1332: are parsed. By returning a void_type_node, class A does not attempt 1333: to incorporate the declarations of the friends within its structure. 1334: 1335: DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING 1336: CHANGES TO CODE IN `start_method'. */ 1337: 1338: tree 1.1.1.2 root 1339: grokfield (declarator, declspecs, raises, init, asmspec_tree, attrlist) 1340: tree declarator, declspecs, raises, init, asmspec_tree, attrlist; 1.1 root 1341: { 1342: register tree value; 1343: char *asmspec = 0; 1.1.1.2 root 1344: int flags = LOOKUP_ONLYCONVERTING; 1.1 root 1345: 1346: /* Convert () initializers to = initializers. */ 1347: if (init == NULL_TREE && declarator != NULL_TREE 1348: && TREE_CODE (declarator) == CALL_EXPR 1349: && TREE_OPERAND (declarator, 0) 1350: && (TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE 1351: || TREE_CODE (TREE_OPERAND (declarator, 0)) == SCOPE_REF) 1352: && parmlist_is_exprlist (TREE_OPERAND (declarator, 1))) 1353: { 1354: init = TREE_OPERAND (declarator, 1); 1355: declarator = TREE_OPERAND (declarator, 0); 1.1.1.2 root 1356: flags = 0; 1.1 root 1357: } 1358: 1359: if (init 1360: && TREE_CODE (init) == TREE_LIST 1361: && TREE_VALUE (init) == error_mark_node 1362: && TREE_CHAIN (init) == NULL_TREE) 1363: init = NULL_TREE; 1364: 1.1.1.2 root 1365: value = grokdeclarator (declarator, declspecs, FIELD, init != 0, 1.1.1.3 ! root 1366: raises, NULL_TREE); 1.1 root 1367: if (! value) 1368: return value; /* friend or constructor went bad. */ 1369: 1370: /* Pass friendly classes back. */ 1371: if (TREE_CODE (value) == VOID_TYPE) 1372: return void_type_node; 1373: 1374: if (DECL_NAME (value) != NULL_TREE 1375: && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_' 1376: && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr")) 1377: cp_error ("member `%D' conflicts with virtual function table field name", value); 1378: 1379: /* Stash away type declarations. */ 1380: if (TREE_CODE (value) == TYPE_DECL) 1381: { 1382: DECL_NONLOCAL (value) = 1; 1383: DECL_CONTEXT (value) = current_class_type; 1384: DECL_CLASS_CONTEXT (value) = current_class_type; 1385: CLASSTYPE_LOCAL_TYPEDECLS (current_class_type) = 1; 1.1.1.2 root 1386: 1387: /* If we declare a typedef name for something that has no name, 1388: the typedef name is used for linkage. See 7.1.3 p4 94/0158. */ 1389: if (TYPE_NAME (TREE_TYPE (value)) 1390: && TREE_CODE (TYPE_NAME (TREE_TYPE (value))) == TYPE_DECL 1391: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_TYPE (value)))) 1392: { 1393: TYPE_NAME (TREE_TYPE (value)) = value; 1394: TYPE_STUB_DECL (TREE_TYPE (value)) = value; 1395: } 1396: 1.1 root 1397: pushdecl_class_level (value); 1398: return value; 1399: } 1400: 1401: if (IS_SIGNATURE (current_class_type) 1402: && TREE_CODE (value) != FUNCTION_DECL) 1403: { 1404: error ("field declaration not allowed in signature"); 1405: return void_type_node; 1406: } 1407: 1408: if (DECL_IN_AGGR_P (value)) 1409: { 1410: cp_error ("`%D' is already defined in the class %T", value, 1411: DECL_CONTEXT (value)); 1412: return void_type_node; 1413: } 1414: 1415: if (flag_cadillac) 1416: cadillac_start_decl (value); 1417: 1418: if (asmspec_tree) 1419: asmspec = TREE_STRING_POINTER (asmspec_tree); 1420: 1421: if (init) 1422: { 1423: if (IS_SIGNATURE (current_class_type) 1424: && TREE_CODE (value) == FUNCTION_DECL) 1425: { 1426: error ("function declarations cannot have initializers in signature"); 1427: init = NULL_TREE; 1428: } 1429: else if (TREE_CODE (value) == FUNCTION_DECL) 1430: { 1431: grok_function_init (value, init); 1432: init = NULL_TREE; 1433: } 1434: else if (pedantic && TREE_CODE (value) != VAR_DECL) 1435: /* Already complained in grokdeclarator. */ 1436: init = NULL_TREE; 1437: else 1438: { 1439: /* We allow initializers to become parameters to base 1440: initializers. */ 1441: if (TREE_CODE (init) == TREE_LIST) 1442: { 1443: if (TREE_CHAIN (init) == NULL_TREE) 1444: init = TREE_VALUE (init); 1445: else 1446: init = digest_init (TREE_TYPE (value), init, (tree *)0); 1447: } 1448: 1449: if (TREE_CODE (init) == CONST_DECL) 1450: init = DECL_INITIAL (init); 1451: else if (TREE_READONLY_DECL_P (init)) 1452: init = decl_constant_value (init); 1453: else if (TREE_CODE (init) == CONSTRUCTOR) 1454: init = digest_init (TREE_TYPE (value), init, (tree *)0); 1455: my_friendly_assert (TREE_PERMANENT (init), 192); 1456: if (init == error_mark_node) 1457: /* We must make this look different than `error_mark_node' 1458: because `decl_const_value' would mis-interpret it 1459: as only meaning that this VAR_DECL is defined. */ 1460: init = build1 (NOP_EXPR, TREE_TYPE (value), init); 1461: else if (! TREE_CONSTANT (init)) 1462: { 1463: /* We can allow references to things that are effectively 1464: static, since references are initialized with the address. */ 1465: if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE 1466: || (TREE_STATIC (init) == 0 1467: && (TREE_CODE_CLASS (TREE_CODE (init)) != 'd' 1468: || DECL_EXTERNAL (init) == 0))) 1469: { 1470: error ("field initializer is not constant"); 1471: init = error_mark_node; 1472: } 1473: } 1474: } 1475: } 1476: 1.1.1.2 root 1477: /* The corresponding pop_obstacks is in cp_finish_decl. */ 1.1 root 1478: push_obstacks_nochange (); 1479: 1.1.1.3 ! root 1480: if (attrlist) ! 1481: cplus_decl_attributes (value, TREE_PURPOSE (attrlist), ! 1482: TREE_VALUE (attrlist)); ! 1483: 1.1 root 1484: if (TREE_CODE (value) == VAR_DECL) 1485: { 1486: /* We cannot call pushdecl here, because that would 1487: fill in the value of our TREE_CHAIN. Instead, we 1.1.1.2 root 1488: modify cp_finish_decl to do the right thing, namely, to 1.1 root 1489: put this decl out straight away. */ 1490: if (TREE_PUBLIC (value)) 1491: { 1492: /* current_class_type can be NULL_TREE in case of error. */ 1493: if (asmspec == 0 && current_class_type) 1494: { 1495: TREE_PUBLIC (value) = 1; 1496: DECL_INITIAL (value) = error_mark_node; 1497: DECL_ASSEMBLER_NAME (value) 1498: = build_static_name (current_class_type, DECL_NAME (value)); 1499: } 1500: pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics); 1501: 1502: /* Static consts need not be initialized in the class definition. */ 1503: if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (value))) 1504: { 1505: static int explanation = 0; 1506: 1507: error ("initializer invalid for static member with constructor"); 1508: if (explanation++ == 0) 1509: error ("(you really want to initialize it separately)"); 1510: init = 0; 1511: } 1512: /* Force the compiler to know when an uninitialized static 1513: const member is being used. */ 1514: if (TYPE_READONLY (value) && init == 0) 1515: TREE_USED (value) = 1; 1516: } 1517: DECL_INITIAL (value) = init; 1518: DECL_IN_AGGR_P (value) = 1; 1519: 1.1.1.2 root 1520: cp_finish_decl (value, init, asmspec_tree, 1, flags); 1.1 root 1521: pushdecl_class_level (value); 1522: return value; 1523: } 1524: if (TREE_CODE (value) == FIELD_DECL) 1525: { 1526: if (asmspec) 1.1.1.2 root 1527: { 1528: /* This must override the asm specifier which was placed 1529: by grokclassfn. Lay this out fresh. */ 1530: DECL_RTL (value) = NULL_RTX; 1531: DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec); 1532: } 1.1 root 1533: if (DECL_INITIAL (value) == error_mark_node) 1534: init = error_mark_node; 1.1.1.2 root 1535: cp_finish_decl (value, init, asmspec_tree, 1, flags); 1.1 root 1536: DECL_INITIAL (value) = init; 1537: DECL_IN_AGGR_P (value) = 1; 1538: return value; 1539: } 1540: if (TREE_CODE (value) == FUNCTION_DECL) 1541: { 1.1.1.2 root 1542: check_default_args (value); 1.1 root 1543: if (DECL_CHAIN (value) != NULL_TREE) 1544: { 1545: /* Need a fresh node here so that we don't get circularity 1546: when we link these together. */ 1547: value = copy_node (value); 1548: /* When does this happen? */ 1549: my_friendly_assert (init == NULL_TREE, 193); 1550: } 1.1.1.2 root 1551: if (asmspec) 1552: { 1553: /* This must override the asm specifier which was placed 1554: by grokclassfn. Lay this out fresh. */ 1555: DECL_RTL (value) = NULL_RTX; 1556: DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec); 1557: } 1558: cp_finish_decl (value, init, asmspec_tree, 1, flags); 1.1 root 1559: 1560: /* Pass friends back this way. */ 1561: if (DECL_FRIEND_P (value)) 1562: return void_type_node; 1563: 1564: #if 0 /* Just because a fn is declared doesn't mean we'll try to define it. */ 1565: if (current_function_decl && ! IS_SIGNATURE (current_class_type)) 1566: cp_error ("method `%#D' of local class must be defined in class body", 1567: value); 1568: #endif 1569: 1570: DECL_IN_AGGR_P (value) = 1; 1571: return value; 1572: } 1573: my_friendly_abort (21); 1574: /* NOTREACHED */ 1575: return NULL_TREE; 1576: } 1577: 1578: /* Like `grokfield', but for bitfields. 1579: WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */ 1580: 1581: tree 1582: grokbitfield (declarator, declspecs, width) 1583: tree declarator, declspecs, width; 1584: { 1.1.1.2 root 1585: register tree value = grokdeclarator (declarator, declspecs, BITFIELD, 1586: 0, NULL_TREE, NULL_TREE); 1.1 root 1587: 1588: if (! value) return NULL_TREE; /* friends went bad. */ 1589: 1590: /* Pass friendly classes back. */ 1591: if (TREE_CODE (value) == VOID_TYPE) 1592: return void_type_node; 1593: 1594: if (TREE_CODE (value) == TYPE_DECL) 1595: { 1596: cp_error ("cannot declare `%D' to be a bitfield type", value); 1597: return NULL_TREE; 1598: } 1599: 1600: if (IS_SIGNATURE (current_class_type)) 1601: { 1602: error ("field declaration not allowed in signature"); 1603: return void_type_node; 1604: } 1605: 1606: if (DECL_IN_AGGR_P (value)) 1607: { 1608: cp_error ("`%D' is already defined in the class %T", value, 1609: DECL_CONTEXT (value)); 1610: return void_type_node; 1611: } 1612: 1613: GNU_xref_member (current_class_name, value); 1614: 1615: if (TREE_STATIC (value)) 1616: { 1617: cp_error ("static member `%D' cannot be a bitfield", value); 1618: return NULL_TREE; 1619: } 1.1.1.2 root 1620: cp_finish_decl (value, NULL_TREE, NULL_TREE, 0, 0); 1.1 root 1621: 1622: if (width != error_mark_node) 1623: { 1624: /* detect invalid field size. */ 1625: if (TREE_CODE (width) == CONST_DECL) 1626: width = DECL_INITIAL (width); 1627: else if (TREE_READONLY_DECL_P (width)) 1628: width = decl_constant_value (width); 1629: if (TREE_CODE (width) != INTEGER_CST) 1630: { 1631: cp_error ("structure field `%D' width not an integer constant", 1632: value); 1633: DECL_INITIAL (value) = NULL_TREE; 1634: } 1635: else 1636: { 1637: constant_expression_warning (width); 1638: DECL_INITIAL (value) = width; 1639: DECL_BIT_FIELD (value) = 1; 1640: } 1641: } 1642: 1643: DECL_IN_AGGR_P (value) = 1; 1644: return value; 1645: } 1646: 1647: #if 0 1648: /* Like GROKFIELD, except that the declarator has been 1649: buried in DECLSPECS. Find the declarator, and 1650: return something that looks like it came from 1651: GROKFIELD. */ 1652: tree 1653: groktypefield (declspecs, parmlist) 1654: tree declspecs; 1655: tree parmlist; 1656: { 1657: tree spec = declspecs; 1658: tree prev = NULL_TREE; 1659: 1660: tree type_id = NULL_TREE; 1661: tree quals = NULL_TREE; 1662: tree lengths = NULL_TREE; 1663: tree decl = NULL_TREE; 1664: 1665: while (spec) 1666: { 1667: register tree id = TREE_VALUE (spec); 1668: 1669: if (TREE_CODE (spec) != TREE_LIST) 1670: /* Certain parse errors slip through. For example, 1671: `int class ();' is not caught by the parser. Try 1672: weakly to recover here. */ 1673: return NULL_TREE; 1674: 1675: if (TREE_CODE (id) == TYPE_DECL 1676: || (TREE_CODE (id) == IDENTIFIER_NODE && TREE_TYPE (id))) 1677: { 1678: /* We have a constructor/destructor or 1679: conversion operator. Use it. */ 1680: if (prev) 1681: TREE_CHAIN (prev) = TREE_CHAIN (spec); 1682: else 1683: declspecs = TREE_CHAIN (spec); 1684: 1685: type_id = id; 1686: goto found; 1687: } 1688: prev = spec; 1689: spec = TREE_CHAIN (spec); 1690: } 1691: 1692: /* Nope, we have a conversion operator to a scalar type or something 1693: else, that includes things like constructor declarations for 1694: templates. */ 1695: spec = declspecs; 1696: while (spec) 1697: { 1698: tree id = TREE_VALUE (spec); 1699: 1700: if (TREE_CODE (id) == IDENTIFIER_NODE) 1701: { 1702: if (id == ridpointers[(int)RID_INT] 1703: || id == ridpointers[(int)RID_DOUBLE] 1704: || id == ridpointers[(int)RID_FLOAT] 1705: || id == ridpointers[(int)RID_WCHAR]) 1706: { 1707: if (type_id) 1708: error ("extra `%s' ignored", 1709: IDENTIFIER_POINTER (id)); 1710: else 1711: type_id = id; 1712: } 1713: else if (id == ridpointers[(int)RID_LONG] 1714: || id == ridpointers[(int)RID_SHORT] 1715: || id == ridpointers[(int)RID_CHAR]) 1716: { 1717: lengths = tree_cons (NULL_TREE, id, lengths); 1718: } 1719: else if (id == ridpointers[(int)RID_VOID]) 1720: { 1721: if (type_id) 1722: error ("spurious `void' type ignored"); 1723: else 1724: error ("conversion to `void' type invalid"); 1725: } 1726: else if (id == ridpointers[(int)RID_AUTO] 1727: || id == ridpointers[(int)RID_REGISTER] 1728: || id == ridpointers[(int)RID_TYPEDEF] 1729: || id == ridpointers[(int)RID_CONST] 1730: || id == ridpointers[(int)RID_VOLATILE]) 1731: { 1732: error ("type specifier `%s' used invalidly", 1733: IDENTIFIER_POINTER (id)); 1734: } 1735: else if (id == ridpointers[(int)RID_FRIEND] 1736: || id == ridpointers[(int)RID_VIRTUAL] 1737: || id == ridpointers[(int)RID_INLINE] 1738: || id == ridpointers[(int)RID_UNSIGNED] 1739: || id == ridpointers[(int)RID_SIGNED] 1740: || id == ridpointers[(int)RID_STATIC] 1741: || id == ridpointers[(int)RID_EXTERN]) 1742: { 1743: quals = tree_cons (NULL_TREE, id, quals); 1744: } 1745: else 1746: { 1747: /* Happens when we have a global typedef 1748: and a class-local member function with 1749: the same name. */ 1750: type_id = id; 1751: goto found; 1752: } 1753: } 1754: else if (TREE_CODE (id) == RECORD_TYPE) 1755: { 1756: type_id = TYPE_NAME (id); 1757: if (TREE_CODE (type_id) == TYPE_DECL) 1758: type_id = DECL_NAME (type_id); 1759: if (type_id == NULL_TREE) 1760: error ("identifier for aggregate type conversion omitted"); 1761: } 1762: else if (TREE_CODE_CLASS (TREE_CODE (id)) == 't') 1763: error ("`operator' missing on conversion operator or tag missing from type"); 1764: else 1765: my_friendly_abort (194); 1766: spec = TREE_CHAIN (spec); 1767: } 1768: 1769: if (type_id) 1770: declspecs = chainon (lengths, quals); 1771: else if (lengths) 1772: { 1773: if (TREE_CHAIN (lengths)) 1774: error ("multiple length specifiers"); 1775: type_id = ridpointers[(int)RID_INT]; 1776: declspecs = chainon (lengths, quals); 1777: } 1778: else if (quals) 1779: { 1780: error ("no type given, defaulting to `operator int ...'"); 1781: type_id = ridpointers[(int)RID_INT]; 1782: declspecs = quals; 1783: } 1784: else 1785: return NULL_TREE; 1786: 1787: found: 1788: decl = grokdeclarator (build_parse_node (CALL_EXPR, type_id, parmlist, NULL_TREE), 1.1.1.2 root 1789: declspecs, FIELD, 0, NULL_TREE, NULL_TREE); 1.1 root 1790: if (decl == NULL_TREE) 1791: return NULL_TREE; 1792: 1793: if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CHAIN (decl) != NULL_TREE) 1794: { 1795: /* Need a fresh node here so that we don't get circularity 1796: when we link these together. */ 1797: decl = copy_node (decl); 1798: } 1799: 1800: if (decl == void_type_node 1801: || (TREE_CODE (decl) == FUNCTION_DECL 1802: && TREE_CODE (TREE_TYPE (decl)) != METHOD_TYPE)) 1803: /* bunch of friends. */ 1804: return decl; 1805: 1806: if (DECL_IN_AGGR_P (decl)) 1807: { 1808: cp_error ("`%D' already defined in the class ", decl); 1809: return void_type_node; 1810: } 1811: 1.1.1.2 root 1812: cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0, 0); 1.1 root 1813: 1814: /* If this declaration is common to another declaration 1815: complain about such redundancy, and return NULL_TREE 1816: so that we don't build a circular list. */ 1817: if (DECL_CHAIN (decl)) 1818: { 1819: cp_error ("function `%D' declared twice in class %T", decl, 1820: DECL_CONTEXT (decl)); 1821: return NULL_TREE; 1822: } 1823: DECL_IN_AGGR_P (decl) = 1; 1824: return decl; 1825: } 1826: #endif 1827: 1828: tree 1829: grokoptypename (declspecs, declarator) 1830: tree declspecs, declarator; 1831: { 1.1.1.2 root 1832: tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0, 1833: NULL_TREE, NULL_TREE); 1.1 root 1834: return build_typename_overload (t); 1835: } 1836: 1837: /* When a function is declared with an initializer, 1838: do the right thing. Currently, there are two possibilities: 1839: 1840: class B 1841: { 1842: public: 1843: // initialization possibility #1. 1844: virtual void f () = 0; 1845: int g (); 1846: }; 1847: 1848: class D1 : B 1849: { 1850: public: 1851: int d1; 1852: // error, no f (); 1853: }; 1854: 1855: class D2 : B 1856: { 1857: public: 1858: int d2; 1859: void f (); 1860: }; 1861: 1862: class D3 : B 1863: { 1864: public: 1865: int d3; 1866: // initialization possibility #2 1867: void f () = B::f; 1868: }; 1869: 1870: */ 1871: 1872: int 1873: copy_assignment_arg_p (parmtype, virtualp) 1874: tree parmtype; 1875: int virtualp; 1876: { 1877: if (TREE_CODE (parmtype) == REFERENCE_TYPE) 1878: parmtype = TREE_TYPE (parmtype); 1879: 1880: if ((TYPE_MAIN_VARIANT (parmtype) == current_class_type) 1881: || (virtualp && DERIVED_FROM_P (parmtype, current_class_type))) 1882: return 1; 1883: 1884: return 0; 1885: } 1886: 1887: static void 1888: grok_function_init (decl, init) 1889: tree decl; 1890: tree init; 1891: { 1892: /* An initializer for a function tells how this function should 1893: be inherited. */ 1894: tree type = TREE_TYPE (decl); 1895: 1896: if (TREE_CODE (type) == FUNCTION_TYPE) 1897: cp_error ("initializer specified for non-member function `%D'", decl); 1898: else if (DECL_VINDEX (decl) == NULL_TREE) 1899: cp_error ("initializer specified for non-virtual method `%D'", decl); 1900: else if (integer_zerop (init)) 1901: { 1902: #if 0 1903: /* Mark this function as being "defined". */ 1904: DECL_INITIAL (decl) = error_mark_node; 1905: /* pure virtual destructors must be defined. */ 1906: /* pure virtual needs to be defined (as abort) only when put in 1907: vtbl. For wellformed call, it should be itself. pr4737 */ 1908: if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl))) 1909: { 1910: extern tree abort_fndecl; 1911: /* Give this node rtl from `abort'. */ 1912: DECL_RTL (decl) = DECL_RTL (abort_fndecl); 1913: } 1914: #endif 1915: DECL_ABSTRACT_VIRTUAL_P (decl) = 1; 1916: if (DECL_NAME (decl) == ansi_opname [(int) MODIFY_EXPR]) 1917: { 1918: tree parmtype 1919: = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))); 1920: 1921: if (copy_assignment_arg_p (parmtype, 1)) 1922: TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1; 1923: } 1924: } 1925: else if (TREE_CODE (init) == OFFSET_REF 1926: && TREE_OPERAND (init, 0) == NULL_TREE 1927: && TREE_CODE (TREE_TYPE (init)) == METHOD_TYPE) 1928: { 1929: tree basetype = DECL_CLASS_CONTEXT (init); 1930: tree basefn = TREE_OPERAND (init, 1); 1931: if (TREE_CODE (basefn) != FUNCTION_DECL) 1932: cp_error ("non-method initializer invalid for method `%D'", decl); 1933: else if (! BINFO_OFFSET_ZEROP (TYPE_BINFO (DECL_CLASS_CONTEXT (basefn)))) 1934: sorry ("base member function from other than first base class"); 1935: else 1936: { 1937: tree binfo = get_binfo (basetype, TYPE_METHOD_BASETYPE (type), 1); 1938: if (binfo == error_mark_node) 1939: ; 1940: else if (binfo == 0) 1941: error_not_base_type (TYPE_METHOD_BASETYPE (TREE_TYPE (init)), 1942: TYPE_METHOD_BASETYPE (type)); 1943: else 1944: { 1945: /* Mark this function as being defined, 1946: and give it new rtl. */ 1947: DECL_INITIAL (decl) = error_mark_node; 1948: DECL_RTL (decl) = DECL_RTL (basefn); 1949: } 1950: } 1951: } 1952: else 1953: cp_error ("invalid initializer for virtual method `%D'", decl); 1954: } 1955: 1956: /* When we get a declaration of the form 1957: 1958: type cname::fname ... 1959: 1960: the node for `cname::fname' gets built here in a special way. 1961: Namely, we push into `cname's scope. When this declaration is 1962: processed, we pop back out. */ 1963: tree 1964: build_push_scope (cname, name) 1965: tree cname; 1966: tree name; 1967: { 1968: extern int current_class_depth; 1969: tree ctype, rval; 1970: int is_ttp = 0; 1971: 1972: if (cname == error_mark_node) 1973: return error_mark_node; 1974: 1975: ctype = IDENTIFIER_TYPE_VALUE (cname); 1976: 1977: if (TREE_CODE (ctype) == TEMPLATE_TYPE_PARM) 1978: is_ttp = 1; 1979: else if (ctype == NULL_TREE || ! IS_AGGR_TYPE (ctype)) 1980: { 1981: cp_error ("`%T' not defined as aggregate type", cname); 1982: return name; 1983: } 1984: else if (IS_SIGNATURE (ctype)) 1985: { 1986: error ("cannot push into signature scope, scope resolution operator ignored"); 1987: return name; 1988: } 1989: 1990: rval = build_parse_node (SCOPE_REF, cname, name); 1991: 1992: /* Don't need to push the scope if we're already in it. 1993: We also don't need to push the scope for a ptr-to-member/method. */ 1994: 1995: if (ctype == current_class_type || TREE_CODE (name) != IDENTIFIER_NODE 1996: || is_ttp) 1997: return rval; 1998: 1999: /* We do need to push the scope in this case, since CTYPE helps 1.1.1.2 root 2000: determine subsequent initializers (i.e., Foo::Bar x = foo_enum_1;). */ 1.1 root 2001: 2002: push_nested_class (ctype, 3); 2003: TREE_COMPLEXITY (rval) = current_class_depth; 2004: return rval; 2005: } 2006: 1.1.1.2 root 2007: void 2008: cplus_decl_attributes (decl, attributes, prefix_attributes) 2009: tree decl, attributes, prefix_attributes; 1.1 root 2010: { 1.1.1.2 root 2011: if (decl == NULL_TREE || decl == void_type_node) 2012: return; 2013: 2014: if (TREE_CODE (decl) == TEMPLATE_DECL) 2015: decl = DECL_TEMPLATE_RESULT (decl); 2016: 2017: decl_attributes (decl, attributes, prefix_attributes); 2018: 2019: if (TREE_CODE (decl) == TYPE_DECL) 2020: SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (decl), TREE_TYPE (decl)); 1.1 root 2021: } 2022: 2023: /* CONSTRUCTOR_NAME: 2024: Return the name for the constructor (or destructor) for the 2025: specified class. Argument can be RECORD_TYPE, TYPE_DECL, or 2026: IDENTIFIER_NODE. When given a template, this routine doesn't 2027: lose the specialization. */ 2028: tree 2029: constructor_name_full (thing) 2030: tree thing; 2031: { 2032: if (TREE_CODE (thing) == UNINSTANTIATED_P_TYPE) 2033: return DECL_NAME (UPT_TEMPLATE (thing)); 2034: if (IS_AGGR_TYPE_CODE (TREE_CODE (thing))) 2035: { 2036: if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing)) 2037: thing = DECL_NAME (TREE_VEC_ELT (TYPE_METHODS (thing), 0)); 2038: else 2039: thing = TYPE_NAME (thing); 2040: } 2041: if (TREE_CODE (thing) == TYPE_DECL 2042: || (TREE_CODE (thing) == TEMPLATE_DECL 2043: && DECL_TEMPLATE_IS_CLASS (thing))) 2044: thing = DECL_NAME (thing); 2045: my_friendly_assert (TREE_CODE (thing) == IDENTIFIER_NODE, 197); 2046: return thing; 2047: } 2048: 2049: /* CONSTRUCTOR_NAME: 2050: Return the name for the constructor (or destructor) for the 2051: specified class. Argument can be RECORD_TYPE, TYPE_DECL, or 2052: IDENTIFIER_NODE. When given a template, return the plain 2053: unspecialized name. */ 2054: tree 2055: constructor_name (thing) 2056: tree thing; 2057: { 2058: tree t; 2059: thing = constructor_name_full (thing); 2060: t = IDENTIFIER_TEMPLATE (thing); 2061: if (!t) 2062: return thing; 2063: t = TREE_PURPOSE (t); 2064: return DECL_NAME (t); 2065: } 2066: 2067: /* Cache the value of this class's main virtual function table pointer 2068: in a register variable. This will save one indirection if a 2069: more than one virtual function call is made this function. */ 2070: void 2071: setup_vtbl_ptr () 2072: { 1.1.1.2 root 2073: extern tree base_init_expr; 1.1 root 2074: 1.1.1.2 root 2075: if (base_init_expr == 0 1.1 root 2076: && DECL_CONSTRUCTOR_P (current_function_decl)) 2077: emit_base_init (current_class_type, 0); 2078: } 2079: 2080: /* Record the existence of an addressable inline function. */ 2081: void 2082: mark_inline_for_output (decl) 2083: tree decl; 2084: { 1.1.1.2 root 2085: decl = DECL_MAIN_VARIANT (decl); 1.1 root 2086: if (DECL_SAVED_INLINE (decl)) 2087: return; 1.1.1.2 root 2088: my_friendly_assert (TREE_PERMANENT (decl), 363); 1.1 root 2089: DECL_SAVED_INLINE (decl) = 1; 1.1.1.2 root 2090: #if 0 1.1 root 2091: if (DECL_PENDING_INLINE_INFO (decl) != 0 2092: && ! DECL_PENDING_INLINE_INFO (decl)->deja_vu) 2093: { 2094: struct pending_inline *t = pending_inlines; 2095: my_friendly_assert (DECL_SAVED_INSNS (decl) == 0, 198); 2096: while (t) 2097: { 2098: if (t == DECL_PENDING_INLINE_INFO (decl)) 2099: break; 2100: t = t->next; 2101: } 2102: if (t == 0) 2103: { 2104: t = DECL_PENDING_INLINE_INFO (decl); 2105: t->next = pending_inlines; 2106: pending_inlines = t; 2107: } 2108: DECL_PENDING_INLINE_INFO (decl) = 0; 2109: } 1.1.1.2 root 2110: #endif 1.1 root 2111: saved_inlines = perm_tree_cons (NULL_TREE, decl, saved_inlines); 2112: } 2113: 2114: void 2115: clear_temp_name () 2116: { 2117: temp_name_counter = 0; 2118: } 2119: 2120: /* Hand off a unique name which can be used for variable we don't really 2121: want to know about anyway, for example, the anonymous variables which 2122: are needed to make references work. Declare this thing so we can use it. 2123: The variable created will be of type TYPE. 2124: 2125: STATICP is nonzero if this variable should be static. */ 2126: 2127: tree 2128: get_temp_name (type, staticp) 2129: tree type; 2130: int staticp; 2131: { 2132: char buf[sizeof (AUTO_TEMP_FORMAT) + 20]; 2133: tree decl; 1.1.1.2 root 2134: int toplev = toplevel_bindings_p (); 1.1 root 2135: 2136: push_obstacks_nochange (); 2137: if (toplev || staticp) 2138: { 2139: end_temporary_allocation (); 2140: sprintf (buf, AUTO_TEMP_FORMAT, global_temp_name_counter++); 2141: decl = pushdecl_top_level (build_decl (VAR_DECL, get_identifier (buf), type)); 2142: } 2143: else 2144: { 2145: sprintf (buf, AUTO_TEMP_FORMAT, temp_name_counter++); 2146: decl = pushdecl (build_decl (VAR_DECL, get_identifier (buf), type)); 2147: } 2148: TREE_USED (decl) = 1; 2149: TREE_STATIC (decl) = staticp; 2150: 2151: /* If this is a local variable, then lay out its rtl now. 2152: Otherwise, callers of this function are responsible for dealing 2153: with this variable's rtl. */ 2154: if (! toplev) 2155: { 2156: expand_decl (decl); 2157: expand_decl_init (decl); 2158: } 2159: pop_obstacks (); 2160: 2161: return decl; 2162: } 2163: 2164: /* Get a variable which we can use for multiple assignments. 2165: It is not entered into current_binding_level, because 2166: that breaks things when it comes time to do final cleanups 2167: (which take place "outside" the binding contour of the function). */ 2168: tree 2169: get_temp_regvar (type, init) 2170: tree type, init; 2171: { 2172: static char buf[sizeof (AUTO_TEMP_FORMAT) + 20] = { '_' }; 2173: tree decl; 2174: 2175: sprintf (buf+1, AUTO_TEMP_FORMAT, temp_name_counter++); 2176: decl = build_decl (VAR_DECL, get_identifier (buf), type); 2177: TREE_USED (decl) = 1; 2178: DECL_REGISTER (decl) = 1; 2179: 2180: if (init) 2181: store_init_value (decl, init); 2182: 2183: /* We can expand these without fear, since they cannot need 2184: constructors or destructors. */ 2185: expand_decl (decl); 2186: expand_decl_init (decl); 2187: 2188: if (type_needs_gc_entry (type)) 2189: DECL_GC_OFFSET (decl) = size_int (++current_function_obstack_index); 2190: 2191: return decl; 2192: } 2193: 2194: /* Make the macro TEMP_NAME_P available to units which do not 2195: include c-tree.h. */ 2196: int 2197: temp_name_p (decl) 2198: tree decl; 2199: { 2200: return TEMP_NAME_P (decl); 2201: } 2202: 2203: /* Finish off the processing of a UNION_TYPE structure. 2204: If there are static members, then all members are 2205: static, and must be laid out together. If the 2206: union is an anonymous union, we arrange for that 2207: as well. PUBLIC_P is nonzero if this union is 2208: not declared static. */ 2209: void 2210: finish_anon_union (anon_union_decl) 2211: tree anon_union_decl; 2212: { 2213: tree type = TREE_TYPE (anon_union_decl); 2214: tree field, main_decl = NULL_TREE; 2215: tree elems = NULL_TREE; 2216: int public_p = TREE_PUBLIC (anon_union_decl); 2217: int static_p = TREE_STATIC (anon_union_decl); 2218: int external_p = DECL_EXTERNAL (anon_union_decl); 2219: 2220: if ((field = TYPE_FIELDS (type)) == NULL_TREE) 2221: return; 2222: 2223: if (public_p) 2224: { 2225: error ("global anonymous unions must be declared static"); 2226: return; 2227: } 2228: 2229: for (; field; field = TREE_CHAIN (field)) 2230: { 2231: tree decl; 2232: if (TREE_CODE (field) != FIELD_DECL) 2233: continue; 2234: 1.1.1.2 root 2235: if (TREE_PRIVATE (field)) 2236: cp_pedwarn_at ("private member `%#D' in anonymous union", field); 2237: else if (TREE_PROTECTED (field)) 2238: cp_pedwarn_at ("protected member `%#D' in anonymous union", field); 2239: 1.1 root 2240: decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field)); 2241: /* tell `pushdecl' that this is not tentative. */ 2242: DECL_INITIAL (decl) = error_mark_node; 2243: TREE_PUBLIC (decl) = public_p; 2244: TREE_STATIC (decl) = static_p; 2245: DECL_EXTERNAL (decl) = external_p; 2246: decl = pushdecl (decl); 2247: 2248: /* Only write out one anon union element--choose the one that 2249: can hold them all. */ 2250: if (main_decl == NULL_TREE 1.1.1.2 root 2251: && 1 == simple_cst_equal (DECL_SIZE (decl), 2252: DECL_SIZE (anon_union_decl))) 1.1 root 2253: { 2254: main_decl = decl; 2255: } 2256: else 2257: { 2258: /* ??? This causes there to be no debug info written out 2259: about this decl. */ 2260: TREE_ASM_WRITTEN (decl) = 1; 2261: } 2262: 2263: DECL_INITIAL (decl) = NULL_TREE; 2264: /* If there's a cleanup to do, it belongs in the 2265: TREE_PURPOSE of the following TREE_LIST. */ 2266: elems = tree_cons (NULL_TREE, decl, elems); 2267: TREE_TYPE (elems) = type; 2268: } 2269: if (static_p) 2270: { 2271: if (main_decl) 2272: { 1.1.1.2 root 2273: make_decl_rtl (main_decl, 0, toplevel_bindings_p ()); 1.1 root 2274: DECL_RTL (anon_union_decl) = DECL_RTL (main_decl); 2275: } 2276: else 2277: { 2278: warning ("anonymous union with no members"); 2279: return; 2280: } 2281: } 2282: 2283: /* The following call assumes that there are never any cleanups 2284: for anonymous unions--a reasonable assumption. */ 2285: expand_anon_union_decl (anon_union_decl, NULL_TREE, elems); 2286: 2287: if (flag_cadillac) 2288: cadillac_finish_anon_union (anon_union_decl); 2289: } 2290: 2291: /* Finish and output a table which is generated by the compiler. 2292: NAME is the name to give the table. 2293: TYPE is the type of the table entry. 2294: INIT is all the elements in the table. 2295: PUBLICP is non-zero if this table should be given external access. */ 2296: tree 2297: finish_table (name, type, init, publicp) 2298: tree name, type, init; 2299: int publicp; 2300: { 2301: tree itype, atype, decl; 2302: static tree empty_table; 2303: int is_empty = 0; 2304: tree asmspec; 2305: 2306: itype = build_index_type (size_int (list_length (init) - 1)); 2307: atype = build_cplus_array_type (type, itype); 2308: layout_type (atype); 2309: 2310: if (TREE_VALUE (init) == integer_zero_node 2311: && TREE_CHAIN (init) == NULL_TREE) 2312: { 1.1.1.2 root 2313: #if 0 1.1 root 2314: if (empty_table == NULL_TREE) 1.1.1.2 root 2315: #endif 1.1 root 2316: { 2317: empty_table = get_temp_name (atype, 1); 2318: init = build (CONSTRUCTOR, atype, NULL_TREE, init); 2319: TREE_CONSTANT (init) = 1; 2320: TREE_STATIC (init) = 1; 2321: DECL_INITIAL (empty_table) = init; 2322: asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)), 2323: IDENTIFIER_POINTER (DECL_NAME (empty_table))); 1.1.1.2 root 2324: cp_finish_decl (empty_table, NULL_TREE, asmspec, 0, 0); 1.1 root 2325: } 2326: is_empty = 1; 2327: } 2328: 2329: if (name == NULL_TREE) 2330: { 2331: if (is_empty) 2332: return empty_table; 2333: decl = get_temp_name (atype, 1); 2334: } 2335: else 2336: { 2337: decl = build_decl (VAR_DECL, name, atype); 2338: decl = pushdecl (decl); 2339: TREE_STATIC (decl) = 1; 2340: } 2341: 2342: if (is_empty == 0) 2343: { 2344: TREE_PUBLIC (decl) = publicp; 2345: init = build (CONSTRUCTOR, atype, NULL_TREE, init); 2346: TREE_CONSTANT (init) = 1; 2347: TREE_STATIC (init) = 1; 2348: DECL_INITIAL (decl) = init; 2349: asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (decl)), 2350: IDENTIFIER_POINTER (DECL_NAME (decl))); 2351: } 2352: else 2353: { 2354: /* This will cause DECL to point to EMPTY_TABLE in rtl-land. */ 2355: DECL_EXTERNAL (decl) = 1; 2356: TREE_STATIC (decl) = 0; 2357: init = 0; 2358: asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)), 2359: IDENTIFIER_POINTER (DECL_NAME (empty_table))); 2360: } 2361: 1.1.1.2 root 2362: cp_finish_decl (decl, NULL_TREE, asmspec, 0, 0); 1.1 root 2363: return decl; 2364: } 2365: 2366: /* Finish processing a builtin type TYPE. It's name is NAME, 2367: its fields are in the array FIELDS. LEN is the number of elements 2368: in FIELDS minus one, or put another way, it is the maximum subscript 2369: used in FIELDS. 2370: 2371: It is given the same alignment as ALIGN_TYPE. */ 2372: void 2373: finish_builtin_type (type, name, fields, len, align_type) 2374: tree type; 2375: char *name; 2376: tree fields[]; 2377: int len; 2378: tree align_type; 2379: { 2380: register int i; 2381: 2382: TYPE_FIELDS (type) = fields[0]; 2383: for (i = 0; i < len; i++) 2384: { 2385: layout_type (TREE_TYPE (fields[i])); 2386: DECL_FIELD_CONTEXT (fields[i]) = type; 2387: TREE_CHAIN (fields[i]) = fields[i+1]; 2388: } 2389: DECL_FIELD_CONTEXT (fields[i]) = type; 2390: DECL_CLASS_CONTEXT (fields[i]) = type; 2391: TYPE_ALIGN (type) = TYPE_ALIGN (align_type); 2392: layout_type (type); 2393: #if 0 /* not yet, should get fixed properly later */ 2394: TYPE_NAME (type) = make_type_decl (get_identifier (name), type); 2395: #else 2396: TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type); 2397: #endif 2398: layout_decl (TYPE_NAME (type), 0); 2399: } 2400: 2401: /* Auxiliary functions to make type signatures for 2402: `operator new' and `operator delete' correspond to 2403: what compiler will be expecting. */ 2404: 2405: extern tree sizetype; 2406: 2407: tree 2408: coerce_new_type (type) 2409: tree type; 2410: { 2411: int e1 = 0, e2 = 0; 2412: 2413: if (TREE_CODE (type) == METHOD_TYPE) 2414: type = build_function_type (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type))); 2415: if (TREE_TYPE (type) != ptr_type_node) 2416: e1 = 1, error ("`operator new' must return type `void *'"); 2417: 2418: /* Technically the type must be `size_t', but we may not know 2419: what that is. */ 2420: if (TYPE_ARG_TYPES (type) == NULL_TREE) 2421: e1 = 1, error ("`operator new' takes type `size_t' parameter"); 2422: else if (TREE_CODE (TREE_VALUE (TYPE_ARG_TYPES (type))) != INTEGER_TYPE 2423: || TYPE_PRECISION (TREE_VALUE (TYPE_ARG_TYPES (type))) != TYPE_PRECISION (sizetype)) 2424: e2 = 1, error ("`operator new' takes type `size_t' as first parameter"); 2425: if (e2) 2426: type = build_function_type (ptr_type_node, tree_cons (NULL_TREE, sizetype, TREE_CHAIN (TYPE_ARG_TYPES (type)))); 2427: else if (e1) 2428: type = build_function_type (ptr_type_node, TYPE_ARG_TYPES (type)); 2429: return type; 2430: } 2431: 2432: tree 2433: coerce_delete_type (type) 2434: tree type; 2435: { 2436: int e1 = 0, e2 = 0, e3 = 0; 2437: tree arg_types = TYPE_ARG_TYPES (type); 2438: 2439: if (TREE_CODE (type) == METHOD_TYPE) 2440: { 2441: type = build_function_type (TREE_TYPE (type), TREE_CHAIN (arg_types)); 2442: arg_types = TREE_CHAIN (arg_types); 2443: } 2444: if (TREE_TYPE (type) != void_type_node) 2445: e1 = 1, error ("`operator delete' must return type `void'"); 2446: if (arg_types == NULL_TREE 2447: || TREE_VALUE (arg_types) != ptr_type_node) 2448: e2 = 1, error ("`operator delete' takes type `void *' as first parameter"); 2449: 2450: if (arg_types 2451: && TREE_CHAIN (arg_types) 2452: && TREE_CHAIN (arg_types) != void_list_node) 2453: { 2454: /* Again, technically this argument must be `size_t', but again 2455: we may not know what that is. */ 2456: tree t2 = TREE_VALUE (TREE_CHAIN (arg_types)); 2457: if (TREE_CODE (t2) != INTEGER_TYPE 2458: || TYPE_PRECISION (t2) != TYPE_PRECISION (sizetype)) 2459: e3 = 1, error ("second argument to `operator delete' must be of type `size_t'"); 2460: else if (TREE_CHAIN (TREE_CHAIN (arg_types)) != void_list_node) 2461: { 2462: e3 = 1; 2463: if (TREE_CHAIN (TREE_CHAIN (arg_types))) 2464: error ("too many arguments in declaration of `operator delete'"); 2465: else 2466: error ("`...' invalid in specification of `operator delete'"); 2467: } 2468: } 2469: if (e3) 2470: arg_types = tree_cons (NULL_TREE, ptr_type_node, build_tree_list (NULL_TREE, sizetype)); 2471: else if (e3 |= e2) 2472: { 2473: if (arg_types == NULL_TREE) 2474: arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 2475: else 2476: arg_types = tree_cons (NULL_TREE, ptr_type_node, TREE_CHAIN (arg_types)); 2477: } 2478: else e3 |= e1; 2479: 2480: if (e3) 2481: type = build_function_type (void_type_node, arg_types); 2482: 2483: return type; 2484: } 2485: 2486: static void 2487: mark_vtable_entries (decl) 2488: tree decl; 2489: { 1.1.1.2 root 2490: tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl)); 1.1 root 2491: 1.1.1.2 root 2492: skip_rtti_stuff (&entries); 1.1 root 2493: 2494: for (; entries; entries = TREE_CHAIN (entries)) 2495: { 2496: tree fnaddr = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries)); 2497: tree fn = TREE_OPERAND (fnaddr, 0); 2498: TREE_ADDRESSABLE (fn) = 1; 2499: if (DECL_ABSTRACT_VIRTUAL_P (fn)) 2500: { 2501: extern tree abort_fndecl; 2502: if (flag_vtable_thunks) 2503: fnaddr = TREE_VALUE (entries); 1.1.1.2 root 2504: TREE_OPERAND (fnaddr, 0) = fn = abort_fndecl; 1.1 root 2505: } 1.1.1.2 root 2506: assemble_external (fn); 1.1 root 2507: } 2508: } 2509: 1.1.1.2 root 2510: /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL, 1.1 root 2511: based on TYPE and other static flags. 2512: 2513: Note that anything public is tagged TREE_PUBLIC, whether 2514: it's public in this file or in another one. */ 2515: 2516: void 1.1.1.2 root 2517: import_export_vtable (decl, type, final) 2518: tree decl, type; 2519: int final; 1.1 root 2520: { 1.1.1.2 root 2521: if (DECL_INTERFACE_KNOWN (decl)) 2522: return; 2523: 2524: /* +e0 or +e1 */ 2525: if (write_virtuals < 2 && write_virtuals != 0) 1.1 root 2526: { 2527: TREE_PUBLIC (decl) = 1; 2528: if (write_virtuals < 0) 2529: DECL_EXTERNAL (decl) = 1; 1.1.1.2 root 2530: DECL_INTERFACE_KNOWN (decl) = 1; 2531: } 2532: else if (CLASSTYPE_INTERFACE_KNOWN (type)) 2533: { 2534: TREE_PUBLIC (decl) = 1; 2535: DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type); 2536: DECL_INTERFACE_KNOWN (decl) = 1; 2537: } 2538: else 2539: { 2540: /* We can only wait to decide if we have real non-inline virtual 2541: functions in our class, or if we come from a template. */ 2542: 2543: int found = CLASSTYPE_TEMPLATE_INSTANTIATION (type); 2544: 2545: if (! found && ! final) 2546: { 2547: tree method; 2548: for (method = CLASSTYPE_METHODS (type); method != NULL_TREE; 2549: method = DECL_NEXT_METHOD (method)) 2550: if (DECL_VINDEX (method) != NULL_TREE 2551: && ! DECL_THIS_INLINE (method) 2552: && ! DECL_ABSTRACT_VIRTUAL_P (method)) 2553: { 2554: found = 1; 2555: break; 2556: } 2557: } 2558: 2559: if (final || ! found) 2560: { 2561: #ifdef ASSEMBLE_EXTERNAL 2562: if (TREE_PUBLIC (decl)) 2563: cp_error ("all virtual functions redeclared inline"); 2564: #endif 2565: if (SUPPORTS_WEAK) 2566: DECL_WEAK (decl) = 1; 2567: else 2568: TREE_PUBLIC (decl) = 0; 2569: DECL_EXTERNAL (decl) = 0; 2570: } 2571: else 2572: { 2573: TREE_PUBLIC (decl) = 1; 2574: DECL_EXTERNAL (decl) = 1; 2575: } 1.1 root 2576: } 2577: } 2578: 2579: static void 2580: import_export_template (type) 2581: tree type; 2582: { 2583: if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) 2584: && ! flag_implicit_templates 2585: && CLASSTYPE_INTERFACE_UNKNOWN (type)) 2586: { 2587: SET_CLASSTYPE_INTERFACE_KNOWN (type); 2588: CLASSTYPE_INTERFACE_ONLY (type) = 1; 2589: CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 0; 2590: } 2591: } 2592: 2593: static void 1.1.1.2 root 2594: finish_prevtable_vardecl (prev, vars) 1.1 root 2595: tree prev, vars; 2596: { 2597: tree ctype = DECL_CONTEXT (vars); 2598: import_export_template (ctype); 2599: 1.1.1.2 root 2600: if (CLASSTYPE_INTERFACE_UNKNOWN (ctype) && TYPE_VIRTUAL_P (ctype) 2601: && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)) 1.1 root 2602: { 2603: tree method; 2604: for (method = CLASSTYPE_METHODS (ctype); method != NULL_TREE; 2605: method = DECL_NEXT_METHOD (method)) 2606: { 1.1.1.2 root 2607: if (DECL_VINDEX (method) != NULL_TREE 2608: && !DECL_THIS_INLINE (method) 1.1 root 2609: && !DECL_ABSTRACT_VIRTUAL_P (method)) 2610: { 2611: SET_CLASSTYPE_INTERFACE_KNOWN (ctype); 1.1.1.2 root 2612: CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = ! DECL_EXTERNAL (method); 1.1 root 2613: CLASSTYPE_INTERFACE_ONLY (ctype) = DECL_EXTERNAL (method); 2614: break; 2615: } 2616: } 2617: } 2618: 1.1.1.2 root 2619: import_export_vtable (vars, ctype, 1); 2620: 2621: /* We cannot use TREE_USED here, as it may be set by the expanding of a 2622: ctor that is used to build a global object. The long term plan is to 2623: make the TD entries statically initialized and move this to 2624: finish_vtable_vardecl time. */ 2625: if (flag_rtti && write_virtuals >= 0 2626: && ! DECL_EXTERNAL (vars) && (TREE_PUBLIC (vars) || 1 || TREE_USED (vars))) 2627: { 2628: /* Kick out the type descriptor before we dump out global 2629: initializers, as they are initialized at run time and 2630: we have to find them when we scan for things that need initialized 2631: at the top level. */ 2632: build_t_desc (ctype, 1); 2633: } 2634: } 2635: 2636: static void 2637: finish_vtable_vardecl (prev, vars) 2638: tree prev, vars; 2639: { 1.1 root 2640: if (write_virtuals >= 0 2641: && ! DECL_EXTERNAL (vars) && (TREE_PUBLIC (vars) || TREE_USED (vars))) 2642: { 1.1.1.2 root 2643: #if 0 2644: /* The long term plan it to make the TD entries statically initialized, 2645: have the entries built and emitted here. When that happens, this 2646: can be enabled, and the other call to build_t_desc removed. */ 2647: /* Kick out the type descriptor before writing out the vtable. */ 2648: if (flag_rtti) 2649: build_t_desc (DECL_CONTEXT (vars), 1); 2650: #endif 1.1 root 2651: 2652: /* Write it out. */ 2653: mark_vtable_entries (vars); 2654: if (TREE_TYPE (DECL_INITIAL (vars)) == 0) 1.1.1.2 root 2655: store_init_value (vars, DECL_INITIAL (vars)); 1.1 root 2656: 2657: #ifdef DWARF_DEBUGGING_INFO 2658: if (write_symbols == DWARF_DEBUG) 2659: { 2660: /* Mark the VAR_DECL node representing the vtable itself as a 2661: "gratuitous" one, thereby forcing dwarfout.c to ignore it. 2662: It is rather important that such things be ignored because 2663: any effort to actually generate DWARF for them will run 2664: into trouble when/if we encounter code like: 2665: 2666: #pragma interface 2667: struct S { virtual void member (); }; 2668: 2669: because the artificial declaration of the vtable itself (as 2670: manufactured by the g++ front end) will say that the vtable 2671: is a static member of `S' but only *after* the debug output 2672: for the definition of `S' has already been output. This causes 2673: grief because the DWARF entry for the definition of the vtable 2674: will try to refer back to an earlier *declaration* of the 2675: vtable as a static member of `S' and there won't be one. 2676: We might be able to arrange to have the "vtable static member" 2677: attached to the member list for `S' before the debug info for 2678: `S' get written (which would solve the problem) but that would 2679: require more intrusive changes to the g++ front end. */ 2680: 2681: DECL_IGNORED_P (vars) = 1; 2682: } 2683: #endif /* DWARF_DEBUGGING_INFO */ 2684: 2685: rest_of_decl_compilation (vars, NULL_PTR, 1, 1); 2686: } 1.1.1.2 root 2687: else if (! TREE_USED (vars)) 2688: /* We don't know what to do with this one yet. */ 2689: return; 2690: 2691: /* We know that PREV must be non-zero here. */ 2692: TREE_CHAIN (prev) = TREE_CHAIN (vars); 2693: } 2694: 2695: static void 2696: prune_vtable_vardecl (prev, vars) 2697: tree prev, vars; 2698: { 1.1 root 2699: /* We know that PREV must be non-zero here. */ 2700: TREE_CHAIN (prev) = TREE_CHAIN (vars); 2701: } 2702: 2703: void 2704: walk_vtables (typedecl_fn, vardecl_fn) 2705: register void (*typedecl_fn)(); 2706: register void (*vardecl_fn)(); 2707: { 2708: tree prev, vars; 2709: 2710: for (prev = 0, vars = getdecls (); vars; vars = TREE_CHAIN (vars)) 2711: { 2712: register tree type = TREE_TYPE (vars); 2713: 1.1.1.2 root 2714: if (TREE_CODE (vars) == VAR_DECL && DECL_VIRTUAL_P (vars)) 1.1 root 2715: { 1.1.1.2 root 2716: if (vardecl_fn) (*vardecl_fn) (prev, vars); 2717: 2718: if (prev && TREE_CHAIN (prev) != vars) 2719: continue; 1.1 root 2720: } 1.1.1.2 root 2721: else if (TREE_CODE (vars) == TYPE_DECL 2722: && type != error_mark_node 2723: && TYPE_LANG_SPECIFIC (type) 2724: && CLASSTYPE_VSIZE (type)) 1.1 root 2725: { 1.1.1.2 root 2726: if (typedecl_fn) (*typedecl_fn) (prev, vars); 1.1 root 2727: } 1.1.1.2 root 2728: 2729: prev = vars; 1.1 root 2730: } 2731: } 2732: 2733: static void 2734: finish_sigtable_vardecl (prev, vars) 2735: tree prev, vars; 2736: { 2737: /* We don't need to mark sigtable entries as addressable here as is done 2738: for vtables. Since sigtables, unlike vtables, are always written out, 2739: that was already done in build_signature_table_constructor. */ 2740: 2741: rest_of_decl_compilation (vars, NULL_PTR, 1, 1); 2742: 2743: /* We know that PREV must be non-zero here. */ 2744: TREE_CHAIN (prev) = TREE_CHAIN (vars); 2745: } 2746: 2747: void 2748: walk_sigtables (typedecl_fn, vardecl_fn) 2749: register void (*typedecl_fn)(); 2750: register void (*vardecl_fn)(); 2751: { 2752: tree prev, vars; 2753: 2754: for (prev = 0, vars = getdecls (); vars; vars = TREE_CHAIN (vars)) 2755: { 2756: register tree type = TREE_TYPE (vars); 2757: 2758: if (TREE_CODE (vars) == TYPE_DECL 2759: && type != error_mark_node 2760: && IS_SIGNATURE (type)) 2761: { 2762: if (typedecl_fn) (*typedecl_fn) (prev, vars); 2763: } 2764: else if (TREE_CODE (vars) == VAR_DECL 2765: && TREE_TYPE (vars) != error_mark_node 2766: && IS_SIGNATURE (TREE_TYPE (vars))) 2767: { 2768: if (vardecl_fn) (*vardecl_fn) (prev, vars); 2769: } 2770: else 2771: prev = vars; 2772: } 2773: } 2774: 2775: /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an 2776: inline function at end-of-file. */ 2777: 2778: void 2779: import_export_inline (decl) 2780: tree decl; 2781: { 1.1.1.2 root 2782: if (DECL_INTERFACE_KNOWN (decl)) 1.1 root 2783: return; 2784: 1.1.1.2 root 2785: if (DECL_TEMPLATE_INSTANTIATION (decl)) 1.1 root 2786: { 1.1.1.2 root 2787: if (DECL_IMPLICIT_INSTANTIATION (decl) && flag_implicit_templates) 2788: { 2789: if (SUPPORTS_WEAK) 2790: DECL_WEAK (decl) = 1; 2791: else 2792: TREE_PUBLIC (decl) = 0; 2793: } 2794: else 2795: DECL_NOT_REALLY_EXTERN (decl) = 0; 1.1 root 2796: } 2797: else if (DECL_FUNCTION_MEMBER_P (decl)) 2798: { 2799: tree ctype = DECL_CLASS_CONTEXT (decl); 1.1.1.2 root 2800: if (CLASSTYPE_INTERFACE_KNOWN (ctype) && ! DECL_ARTIFICIAL (decl)) 1.1 root 2801: { 1.1.1.2 root 2802: DECL_NOT_REALLY_EXTERN (decl) 2803: = ! (CLASSTYPE_INTERFACE_ONLY (ctype) 2804: || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines)); 1.1 root 2805: } 1.1.1.2 root 2806: else if (SUPPORTS_WEAK) 2807: DECL_WEAK (decl) = 1; 2808: else 2809: TREE_PUBLIC (decl) = 0; 1.1 root 2810: } 1.1.1.2 root 2811: else if (DECL_C_STATIC (decl)) 2812: TREE_PUBLIC (decl) = 0; 2813: else if (SUPPORTS_WEAK) 2814: DECL_WEAK (decl) = 1; 2815: else 2816: TREE_PUBLIC (decl) = 0; 2817: 2818: DECL_INTERFACE_KNOWN (decl) = 1; 1.1 root 2819: } 1.1.1.2 root 2820: 1.1 root 2821: extern int parse_time, varconst_time; 2822: 2823: #define TIMEVAR(VAR, BODY) \ 2824: do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0) 2825: 2826: /* This routine is called from the last rule in yyparse (). 2827: Its job is to create all the code needed to initialize and 2828: destroy the global aggregates. We do the destruction 2829: first, since that way we only need to reverse the decls once. */ 2830: 2831: void 2832: finish_file () 2833: { 2834: extern int lineno; 2835: int start_time, this_time; 2836: 2837: tree fnname; 1.1.1.2 root 2838: tree vars; 1.1 root 2839: int needs_cleaning = 0, needs_messing_up = 0; 2840: 2841: if (flag_detailed_statistics) 2842: dump_tree_statistics (); 2843: 2844: /* Bad parse errors. Just forget about it. */ 2845: if (! global_bindings_p () || current_class_type) 2846: return; 2847: 2848: start_time = get_run_time (); 2849: 2850: /* Push into C language context, because that's all 2851: we'll need here. */ 2852: push_lang_context (lang_name_c); 2853: 1.1.1.2 root 2854: /* Otherwise, GDB can get confused, because in only knows 2855: about source for LINENO-1 lines. */ 2856: lineno -= 1; 2857: 2858: interface_unknown = 1; 2859: interface_only = 0; 2860: 2861: #if 1 2862: /* The reason for pushing garbage onto the global_binding_level is to 2863: ensure that we can slice out _DECLs which pertain to virtual function 2864: tables. If the last thing pushed onto the global_binding_level was a 2865: virtual function table, then slicing it out would slice away all the 2866: decls (i.e., we lose the head of the chain). 2867: 2868: There are several ways of getting the same effect, from changing the 2869: way that iterators over the chain treat the elements that pertain to 2870: virtual function tables, moving the implementation of this code to 2871: decl.c (where we can manipulate global_binding_level directly), 2872: popping the garbage after pushing it and slicing away the vtable 2873: stuff, or just leaving it alone. */ 2874: 2875: /* Make last thing in global scope not be a virtual function table. */ 2876: #if 0 /* not yet, should get fixed properly later */ 2877: vars = make_type_decl (get_identifier (" @%$#@!"), integer_type_node); 2878: #else 2879: vars = build_decl (TYPE_DECL, get_identifier (" @%$#@!"), integer_type_node); 2880: #endif 2881: DECL_IGNORED_P (vars) = 1; 2882: SET_DECL_ARTIFICIAL (vars); 2883: pushdecl (vars); 2884: #endif 2885: 2886: /* Walk to mark the inline functions we need, then output them so 2887: that we can pick up any other tdecls that those routines need. */ 2888: walk_vtables ((void (*)())0, finish_prevtable_vardecl); 2889: 2890: vars = static_aggregates; 2891: 2892: if (static_ctors || vars || might_have_exceptions_p ()) 2893: needs_messing_up = 1; 2894: if (static_dtors) 2895: needs_cleaning = 1; 1.1 root 2896: 2897: /* See if we really need the hassle. */ 2898: while (vars && needs_cleaning == 0) 2899: { 2900: tree decl = TREE_VALUE (vars); 2901: tree type = TREE_TYPE (decl); 2902: if (TYPE_NEEDS_DESTRUCTOR (type)) 2903: { 2904: needs_cleaning = 1; 2905: needs_messing_up = 1; 2906: break; 2907: } 2908: else 2909: needs_messing_up |= TYPE_NEEDS_CONSTRUCTING (type); 2910: vars = TREE_CHAIN (vars); 2911: } 1.1.1.2 root 2912: 1.1 root 2913: if (needs_cleaning == 0) 2914: goto mess_up; 2915: 2916: fnname = get_file_function_name ('D'); 1.1.1.2 root 2917: start_function (void_list_node, 2918: build_parse_node (CALL_EXPR, fnname, void_list_node, 2919: NULL_TREE), 2920: NULL_TREE, NULL_TREE, 0); 1.1 root 2921: fnname = DECL_ASSEMBLER_NAME (current_function_decl); 2922: store_parm_decls (); 2923: 2924: pushlevel (0); 2925: clear_last_expr (); 2926: push_momentary (); 2927: expand_start_bindings (0); 2928: 2929: /* These must be done in backward order to destroy, 2930: in which they happen to be! */ 1.1.1.2 root 2931: for (vars = static_aggregates; vars; vars = TREE_CHAIN (vars)) 1.1 root 2932: { 2933: tree decl = TREE_VALUE (vars); 2934: tree type = TREE_TYPE (decl); 2935: tree temp = TREE_PURPOSE (vars); 2936: 2937: if (TYPE_NEEDS_DESTRUCTOR (type)) 2938: { 2939: if (TREE_STATIC (vars)) 2940: expand_start_cond (build_binary_op (NE_EXPR, temp, integer_zero_node, 1), 0); 2941: if (TREE_CODE (type) == ARRAY_TYPE) 2942: temp = decl; 2943: else 2944: { 2945: mark_addressable (decl); 1.1.1.2 root 2946: temp = build1 (ADDR_EXPR, build_pointer_type (type), decl); 1.1 root 2947: } 2948: temp = build_delete (TREE_TYPE (temp), temp, 2949: integer_two_node, LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0); 2950: expand_expr_stmt (temp); 2951: 2952: if (TREE_STATIC (vars)) 2953: expand_end_cond (); 2954: } 2955: } 2956: 1.1.1.2 root 2957: for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors)) 2958: expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors), 2959: NULL_TREE)); 2960: 1.1 root 2961: expand_end_bindings (getdecls(), 1, 0); 2962: poplevel (1, 0, 0); 2963: pop_momentary (); 2964: 1.1.1.2 root 2965: finish_function (lineno, 0, 0); 1.1 root 2966: 2967: assemble_destructor (IDENTIFIER_POINTER (fnname)); 2968: 2969: /* if it needed cleaning, then it will need messing up: drop through */ 2970: 2971: mess_up: 2972: /* Must do this while we think we are at the top level. */ 2973: vars = nreverse (static_aggregates); 1.1.1.2 root 2974: if (needs_messing_up) 1.1 root 2975: { 2976: fnname = get_file_function_name ('I'); 1.1.1.2 root 2977: start_function (void_list_node, 2978: build_parse_node (CALL_EXPR, fnname, 2979: void_list_node, NULL_TREE), 2980: NULL_TREE, NULL_TREE, 0); 1.1 root 2981: fnname = DECL_ASSEMBLER_NAME (current_function_decl); 2982: store_parm_decls (); 2983: 2984: pushlevel (0); 2985: clear_last_expr (); 2986: push_momentary (); 2987: expand_start_bindings (0); 2988: 1.1.1.2 root 2989: if (might_have_exceptions_p ()) 1.1 root 2990: register_exception_table (); 2991: 2992: while (vars) 2993: { 2994: tree decl = TREE_VALUE (vars); 2995: tree init = TREE_PURPOSE (vars); 2996: tree old_cleanups = cleanups_this_call; 2997: 2998: /* If this was a static attribute within some function's scope, 2999: then don't initialize it here. Also, don't bother 3000: with initializers that contain errors. */ 3001: if (TREE_STATIC (vars) 3002: || (init && TREE_CODE (init) == TREE_LIST 3003: && value_member (error_mark_node, init))) 3004: { 3005: vars = TREE_CHAIN (vars); 3006: continue; 3007: } 3008: 3009: if (TREE_CODE (decl) == VAR_DECL) 3010: { 3011: /* Set these global variables so that GDB at least puts 3012: us near the declaration which required the initialization. */ 3013: input_filename = DECL_SOURCE_FILE (decl); 3014: lineno = DECL_SOURCE_LINE (decl); 3015: emit_note (input_filename, lineno); 3016: 3017: /* 9.5p5: The initializer of a static member of a class has 1.1.1.2 root 3018: the same access rights as a member function. */ 1.1 root 3019: DECL_CLASS_CONTEXT (current_function_decl) = DECL_CONTEXT (decl); 1.1.1.2 root 3020: DECL_STATIC_FUNCTION_P (current_function_decl) = 1; 1.1 root 3021: 3022: if (IS_AGGR_TYPE (TREE_TYPE (decl)) 3023: || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 1.1.1.2 root 3024: expand_aggr_init (decl, init, 0, 0); 1.1 root 3025: else if (TREE_CODE (init) == TREE_VEC) 3026: { 3027: expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0), 3028: TREE_VEC_ELT (init, 1), 3029: TREE_VEC_ELT (init, 2), 0), 3030: const0_rtx, VOIDmode, 0); 3031: free_temp_slots (); 3032: } 3033: else 3034: expand_assignment (decl, init, 0, 0); 3035: 3036: DECL_CLASS_CONTEXT (current_function_decl) = NULL_TREE; 3037: } 3038: else if (TREE_CODE (decl) == SAVE_EXPR) 3039: { 3040: if (! PARM_DECL_EXPR (decl)) 3041: { 3042: /* a `new' expression at top level. */ 3043: expand_expr (decl, const0_rtx, VOIDmode, 0); 3044: free_temp_slots (); 1.1.1.2 root 3045: if (TREE_CODE (init) == TREE_VEC) 3046: { 3047: expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0), 3048: TREE_VEC_ELT (init, 1), 3049: TREE_VEC_ELT (init, 2), 0), 3050: const0_rtx, VOIDmode, 0); 3051: free_temp_slots (); 3052: } 3053: else 3054: expand_aggr_init (build_indirect_ref (decl, NULL_PTR), init, 0, 0); 1.1 root 3055: } 3056: } 3057: else if (decl == error_mark_node) 3058: ; 3059: else my_friendly_abort (22); 3060: vars = TREE_CHAIN (vars); 3061: /* Cleanup any temporaries needed for the initial value. */ 3062: expand_cleanups_to (old_cleanups); 3063: } 3064: 1.1.1.2 root 3065: for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors)) 3066: expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors), 3067: NULL_TREE)); 3068: 1.1 root 3069: expand_end_bindings (getdecls(), 1, 0); 3070: poplevel (1, 0, 0); 3071: pop_momentary (); 3072: 1.1.1.2 root 3073: finish_function (lineno, 0, 0); 1.1 root 3074: assemble_constructor (IDENTIFIER_POINTER (fnname)); 3075: } 3076: 1.1.1.2 root 3077: expand_builtin_throw (); 3078: 3079: permanent_allocation (1); 3080: 1.1 root 3081: /* Done with C language context needs. */ 3082: pop_lang_context (); 3083: 3084: /* Now write out any static class variables (which may have since 3085: learned how to be initialized). */ 3086: while (pending_statics) 3087: { 3088: tree decl = TREE_VALUE (pending_statics); 3089: if (TREE_USED (decl) == 1 3090: || TREE_READONLY (decl) == 0 3091: || DECL_INITIAL (decl) == 0) 3092: rest_of_decl_compilation (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1, 1); 3093: pending_statics = TREE_CHAIN (pending_statics); 3094: } 3095: 3096: this_time = get_run_time (); 3097: parse_time -= this_time - start_time; 3098: varconst_time += this_time - start_time; 3099: 3100: start_time = get_run_time (); 3101: 3102: if (flag_handle_signatures) 3103: walk_sigtables ((void (*)())0, finish_sigtable_vardecl); 3104: 1.1.1.2 root 3105: for (fnname = saved_inlines; fnname; fnname = TREE_CHAIN (fnname)) 1.1 root 3106: { 1.1.1.2 root 3107: tree decl = TREE_VALUE (fnname); 3108: import_export_inline (decl); 3109: if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl) 3110: && TREE_PUBLIC (decl) && ! DECL_WEAK (decl) 3111: && DECL_NOT_REALLY_EXTERN (decl)) 3112: synthesize_method (decl); 1.1 root 3113: } 3114: 1.1.1.2 root 3115: /* Now write out inline functions which had their addresses taken and 3116: which were not declared virtual and which were not declared `extern 3117: inline'. */ 1.1 root 3118: { 1.1.1.2 root 3119: int reconsider = 1; /* More may be referenced; check again */ 1.1 root 3120: 1.1.1.2 root 3121: while (reconsider) 1.1 root 3122: { 1.1.1.2 root 3123: tree last = saved_inlines = tree_cons (NULL_TREE, NULL_TREE, 3124: saved_inlines); 3125: tree last_head = last; 3126: tree place = TREE_CHAIN (saved_inlines); 3127: reconsider = 0; 3128: 3129: walk_vtables ((void (*)())0, finish_vtable_vardecl); 3130: 3131: for (; place; place = TREE_CHAIN (place)) 1.1 root 3132: { 1.1.1.2 root 3133: tree decl = TREE_VALUE (place); 3134: 3135: /* Slice out the empty elements put in just above in the 3136: previous reconsidering. */ 3137: if (decl == NULL_TREE) 1.1 root 3138: { 1.1.1.2 root 3139: TREE_CHAIN (last) = TREE_CHAIN (place); 3140: continue; 1.1 root 3141: } 3142: 1.1.1.2 root 3143: if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)) 1.1 root 3144: { 1.1.1.2 root 3145: if (TREE_USED (decl)) 3146: { 3147: synthesize_method (decl); 3148: if (TREE_ASM_WRITTEN (decl)) 3149: reconsider = 1; 3150: } 3151: else 1.1 root 3152: { 1.1.1.2 root 3153: last = place; 3154: continue; 1.1 root 3155: } 3156: } 1.1.1.2 root 3157: 3158: if (TREE_ASM_WRITTEN (decl) || DECL_SAVED_INSNS (decl) == 0) 3159: { 3160: TREE_CHAIN (last) = TREE_CHAIN (place); 3161: continue; 3162: } 3163: 3164: if ((TREE_PUBLIC (decl) && ! DECL_WEAK (decl)) 3165: || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) 3166: || flag_keep_inline_functions) 3167: { 3168: TREE_CHAIN (last) = TREE_CHAIN (place); 3169: 3170: if (DECL_NOT_REALLY_EXTERN (decl)) 3171: { 3172: DECL_EXTERNAL (decl) = 0; 3173: reconsider = 1; 3174: temporary_allocation (); 3175: output_inline_function (decl); 3176: permanent_allocation (1); 3177: } 3178: 3179: continue; 3180: } 3181: 3182: last = place; 1.1 root 3183: } 3184: } 3185: } 3186: 1.1.1.2 root 3187: /* Now delete from the chain of variables all virtual function tables. 3188: We output them all ourselves, because each will be treated specially. */ 3189: 3190: walk_vtables ((void (*)())0, prune_vtable_vardecl); 3191: 3192: for (vars = getdecls (); vars; vars = TREE_CHAIN (vars)) 3193: { 3194: if (TREE_CODE (vars) == THUNK_DECL) 3195: emit_thunk (vars); 3196: else if (TREE_CODE (vars) == FUNCTION_DECL 3197: && ! DECL_INTERFACE_KNOWN (vars) 3198: && DECL_C_STATIC (vars)) 3199: TREE_PUBLIC (vars) = 0; 3200: } 3201: 3202: if (might_have_exceptions_p ()) 3203: emit_exception_table (); 3204: 1.1 root 3205: if (write_virtuals == 2) 3206: { 3207: /* Now complain about an virtual function tables promised 3208: but not delivered. */ 3209: while (pending_vtables) 3210: { 3211: if (TREE_PURPOSE (pending_vtables) == NULL_TREE) 3212: error ("virtual function table for `%s' not defined", 3213: IDENTIFIER_POINTER (TREE_VALUE (pending_vtables))); 3214: pending_vtables = TREE_CHAIN (pending_vtables); 3215: } 3216: } 3217: 1.1.1.2 root 3218: finish_repo (); 3219: 1.1 root 3220: this_time = get_run_time (); 3221: parse_time -= this_time - start_time; 3222: varconst_time += this_time - start_time; 3223: 3224: if (flag_detailed_statistics) 3225: dump_time_statistics (); 3226: } 3227: 3228: /* This is something of the form 'A()()()()()+1' that has turned out to be an 3229: expr. Since it was parsed like a type, we need to wade through and fix 3230: that. Unfortunately, since operator() is left-associative, we can't use 3231: tail recursion. In the above example, TYPE is `A', and DECL is 3232: `()()()()()'. 3233: 3234: Maybe this shouldn't be recursive, but how often will it actually be 3235: used? (jason) */ 3236: tree 3237: reparse_absdcl_as_expr (type, decl) 3238: tree type, decl; 3239: { 3240: /* do build_functional_cast (type, NULL_TREE) at bottom */ 3241: if (TREE_OPERAND (decl, 0) == NULL_TREE) 3242: return build_functional_cast (type, NULL_TREE); 3243: 3244: /* recurse */ 3245: decl = reparse_decl_as_expr (type, TREE_OPERAND (decl, 0)); 3246: 3247: decl = build_x_function_call (decl, NULL_TREE, current_class_decl); 3248: 3249: if (TREE_CODE (decl) == CALL_EXPR && TREE_TYPE (decl) != void_type_node) 3250: decl = require_complete_type (decl); 3251: 3252: return decl; 3253: } 3254: 3255: /* This is something of the form `int ((int)(int)(int)1)' that has turned 3256: out to be an expr. Since it was parsed like a type, we need to wade 3257: through and fix that. Since casts are right-associative, we are 3258: reversing the order, so we don't have to recurse. 3259: 3260: In the above example, DECL is the `(int)(int)(int)', and EXPR is the 3261: `1'. */ 3262: tree 3263: reparse_absdcl_as_casts (decl, expr) 3264: tree decl, expr; 3265: { 3266: tree type; 3267: 3268: if (TREE_CODE (expr) == CONSTRUCTOR) 3269: { 3270: type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1))); 3271: decl = TREE_OPERAND (decl, 0); 3272: 3273: if (IS_SIGNATURE (type)) 3274: { 3275: error ("cast specifies signature type"); 3276: return error_mark_node; 3277: } 3278: 3279: expr = digest_init (type, expr, (tree *) 0); 3280: if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0) 3281: { 3282: int failure = complete_array_type (type, expr, 1); 3283: if (failure) 3284: my_friendly_abort (78); 3285: } 3286: } 3287: 3288: while (decl) 3289: { 3290: type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1))); 3291: decl = TREE_OPERAND (decl, 0); 1.1.1.2 root 3292: expr = build_c_cast (type, expr, 0); 1.1 root 3293: } 3294: 3295: return expr; 3296: } 3297: 3298: /* Recursive helper function for reparse_decl_as_expr. It may be a good 3299: idea to reimplement this using an explicit stack, rather than recursion. */ 3300: static tree 3301: reparse_decl_as_expr1 (decl) 3302: tree decl; 3303: { 3304: switch (TREE_CODE (decl)) 3305: { 3306: case IDENTIFIER_NODE: 3307: return do_identifier (decl); 3308: case INDIRECT_REF: 3309: return build_x_indirect_ref 3310: (reparse_decl_as_expr1 (TREE_OPERAND (decl, 0)), "unary *"); 3311: case ADDR_EXPR: 3312: return build_x_unary_op (ADDR_EXPR, 3313: reparse_decl_as_expr1 (TREE_OPERAND (decl, 0))); 3314: case BIT_NOT_EXPR: 3315: return build_x_unary_op (BIT_NOT_EXPR, 3316: reparse_decl_as_expr1 (TREE_OPERAND (decl, 0))); 3317: case SCOPE_REF: 3318: return build_offset_ref (TREE_OPERAND (decl, 0), TREE_OPERAND (decl, 1)); 3319: case ARRAY_REF: 3320: return grok_array_decl (reparse_decl_as_expr1 (TREE_OPERAND (decl, 0)), 3321: TREE_OPERAND (decl, 1)); 3322: default: 3323: my_friendly_abort (5); 3324: return NULL_TREE; 3325: } 3326: } 3327: 3328: /* This is something of the form `int (*a)++' that has turned out to be an 3329: expr. It was only converted into parse nodes, so we need to go through 3330: and build up the semantics. Most of the work is done by 3331: reparse_decl_as_expr1, above. 3332: 3333: In the above example, TYPE is `int' and DECL is `*a'. */ 3334: tree 3335: reparse_decl_as_expr (type, decl) 3336: tree type, decl; 3337: { 1.1.1.2 root 3338: decl = reparse_decl_as_expr1 (decl); 3339: if (type) 3340: return build_functional_cast (type, build_tree_list (NULL_TREE, decl)); 3341: else 3342: return decl; 1.1 root 3343: } 3344: 3345: /* This is something of the form `int (*a)' that has turned out to be a 3346: decl. It was only converted into parse nodes, so we need to do the 3347: checking that make_{pointer,reference}_declarator do. */ 3348: 3349: tree 3350: finish_decl_parsing (decl) 3351: tree decl; 3352: { 3353: extern int current_class_depth; 3354: 3355: switch (TREE_CODE (decl)) 3356: { 3357: case IDENTIFIER_NODE: 3358: return decl; 3359: case INDIRECT_REF: 3360: return make_pointer_declarator 3361: (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0))); 3362: case ADDR_EXPR: 3363: return make_reference_declarator 3364: (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0))); 3365: case BIT_NOT_EXPR: 3366: TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0)); 3367: return decl; 3368: case SCOPE_REF: 3369: push_nested_class (TREE_TYPE (TREE_OPERAND (decl, 0)), 3); 3370: TREE_COMPLEXITY (decl) = current_class_depth; 3371: return decl; 3372: case ARRAY_REF: 3373: TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0)); 3374: return decl; 3375: default: 3376: my_friendly_abort (5); 3377: return NULL_TREE; 3378: } 3379: } 3380: 3381: tree 3382: check_cp_case_value (value) 3383: tree value; 3384: { 3385: if (value == NULL_TREE) 3386: return value; 3387: 3388: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. 3389: Strip such NOP_EXPRs. */ 3390: if (TREE_CODE (value) == NOP_EXPR 3391: && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0))) 3392: value = TREE_OPERAND (value, 0); 3393: 3394: if (TREE_READONLY_DECL_P (value)) 3395: { 3396: value = decl_constant_value (value); 3397: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. 3398: Strip such NOP_EXPRs. */ 3399: if (TREE_CODE (value) == NOP_EXPR 3400: && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0))) 3401: value = TREE_OPERAND (value, 0); 3402: } 3403: value = fold (value); 3404: 3405: if (TREE_CODE (value) != INTEGER_CST 3406: && value != error_mark_node) 3407: { 3408: cp_error ("case label `%E' does not reduce to an integer constant", 3409: value); 3410: value = error_mark_node; 3411: } 3412: else 3413: /* Promote char or short to int. */ 3414: value = default_conversion (value); 3415: 3416: constant_expression_warning (value); 3417: 3418: return value; 3419: } 1.1.1.2 root 3420: 3421: tree current_namespace; 3422: 3423: /* Get the inner part of a namespace id. It doesn't have any prefix, nor 3424: postfix. Returns 0 if in global namespace. */ 3425: tree 3426: get_namespace_id () 3427: { 3428: tree x = current_namespace; 3429: if (x) 3430: x = TREE_PURPOSE (x); 3431: return x; 3432: } 3433: 3434: /* Build up a DECL_ASSEMBLER_NAME for NAME in the current namespace. */ 3435: tree 3436: current_namespace_id (name) 3437: tree name; 3438: { 3439: tree old_id = get_namespace_id (); 3440: char *buf; 3441: 3442: /* Global names retain old encoding. */ 3443: if (! old_id) 3444: return name; 3445: 3446: buf = (char *) alloca (8 + IDENTIFIER_LENGTH (old_id) 3447: + IDENTIFIER_LENGTH (name)); 3448: sprintf (buf, "__ns_%s_%s", IDENTIFIER_POINTER (old_id), 3449: IDENTIFIER_POINTER (name)); 3450: return get_identifier (buf); 3451: } 3452: 3453: void 3454: do_namespace_alias (alias, namespace) 3455: tree alias, namespace; 3456: { 3457: } 3458: 3459: tree 3460: do_toplevel_using_decl (decl) 3461: tree decl; 3462: { 3463: if (decl == NULL_TREE || decl == error_mark_node) 3464: return; 3465: 3466: if (TREE_CODE (decl) == SCOPE_REF) 3467: decl = resolve_scope_to_name (NULL_TREE, decl); 3468: 3469: /* Is this the right way to do an id list? */ 3470: if (TREE_CODE (decl) != TREE_LIST) 3471: { 3472: pushdecl (decl); 3473: } 3474: else 3475: while (decl) 3476: { 3477: pushdecl (TREE_VALUE (decl)); 3478: decl = TREE_CHAIN (decl); 3479: } 3480: } 3481: 3482: tree 3483: do_class_using_decl (decl) 3484: tree decl; 3485: { 3486: tree type; 3487: 3488: /* Ignore for now, unimplemented. */ 3489: return NULL_TREE; 3490: } 3491: 3492: void 3493: do_using_directive (namespace) 3494: tree namespace; 3495: { 3496: } 3497: 3498: void 3499: check_default_args (x) 3500: tree x; 3501: { 3502: tree arg = TYPE_ARG_TYPES (TREE_TYPE (x)); 3503: int saw_def = 0, i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE); 3504: for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i) 3505: { 3506: if (TREE_PURPOSE (arg)) 3507: saw_def = 1; 3508: else if (saw_def) 3509: { 3510: cp_error ("default argument missing for parameter %P of `%#D'", 3511: i, x); 3512: break; 3513: } 3514: } 3515: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.