From 331163679249393448fda18a808d360d55041ffc Mon Sep 17 00:00:00 2001 From: Dave Murphy Date: Mon, 13 Jun 2005 23:31:21 +0000 Subject: [PATCH] added proper bug report link & gcc identification --- build-devkit.sh | 4 +- patches/devkit-gcc-3.4.4.patch | 633126 ++++++++++++++- .../nds/template/combined/template.prj | 4 +- 3 files changed, 632838 insertions(+), 296 deletions(-) diff --git a/build-devkit.sh b/build-devkit.sh index 0032d49..fc913d1 100644 --- a/build-devkit.sh +++ b/build-devkit.sh @@ -29,6 +29,8 @@ LIBGBA_URL="http://osdn.dl.sourceforge.net/sourceforge/devkitpro/$LIBGBA" LIBNDS_URL="http://osdn.dl.sourceforge.net/sourceforge/devkitpro/$LIBNDS" NEWLIB_URL="ftp://sources.redhat.com/pub/newlib/$NEWLIB" +release="13" + #--------------------------------------------------------------------------------- # Ask whether to download the source packages or not #--------------------------------------------------------------------------------- @@ -318,7 +320,7 @@ patch -p1 -d $NEWLIB_SRCDIR -i $(pwd)/patches/devkit-newlib-$NEWLIB_VER.patch # #else - export CFLAGS='-O2 -pipe' + export CFLAGS='-O2 -pipe -DTOOLCHAIN="$package" -DRELEASE=$release export LDFLAGS='-s' #fi diff --git a/patches/devkit-gcc-3.4.4.patch b/patches/devkit-gcc-3.4.4.patch index eac52ef..c42bcc1 100644 --- a/patches/devkit-gcc-3.4.4.patch +++ b/patches/devkit-gcc-3.4.4.patch @@ -1,6 +1,6 @@ diff -NBaur gcc-3.4.4/config.sub gcc-3.4.4-new/config.sub --- gcc-3.4.4/config.sub Sun Feb 22 14:44:23 2004 -+++ gcc-3.4.4-new/config.sub Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/config.sub Mon Jun 13 23:42:56 2005 @@ -219,6 +219,10 @@ basic_machine=m68k-atari os=-mint @@ -14,7 +14,7 @@ diff -NBaur gcc-3.4.4/config.sub gcc-3.4.4-new/config.sub # Decode aliases for certain CPU-COMPANY combinations. diff -NBaur gcc-3.4.4/gcc/Makefile.in gcc-3.4.4-new/gcc/Makefile.in --- gcc-3.4.4/gcc/Makefile.in Thu Feb 24 09:26:57 2005 -+++ gcc-3.4.4-new/gcc/Makefile.in Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/Makefile.in Mon Jun 13 23:42:56 2005 @@ -138,7 +138,7 @@ # TCFLAGS is used for compilations with the GCC just built. XCFLAGS = @@ -34,7 +34,7 @@ diff -NBaur gcc-3.4.4/gcc/Makefile.in gcc-3.4.4-new/gcc/Makefile.in infodir = @infodir@ diff -NBaur gcc-3.4.4/gcc/c-format.c gcc-3.4.4-new/gcc/c-format.c --- gcc-3.4.4/gcc/c-format.c Sun May 1 11:38:56 2005 -+++ gcc-3.4.4-new/gcc/c-format.c Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/c-format.c Mon Jun 13 23:42:56 2005 @@ -31,6 +31,7 @@ #include "diagnostic.h" #include "langhooks.h" @@ -140,7 +140,7 @@ diff -NBaur gcc-3.4.4/gcc/c-format.c gcc-3.4.4-new/gcc/c-format.c length_chars_std = fli->std; diff -NBaur gcc-3.4.4/gcc/collect2.c gcc-3.4.4-new/gcc/collect2.c --- gcc-3.4.4/gcc/collect2.c Mon Jan 10 15:25:23 2005 -+++ gcc-3.4.4-new/gcc/collect2.c Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/collect2.c Mon Jun 13 23:42:56 2005 @@ -30,24 +30,13 @@ #include "system.h" #include "coretypes.h" @@ -696,7 +696,7 @@ diff -NBaur gcc-3.4.4/gcc/collect2.c gcc-3.4.4-new/gcc/collect2.c diff -NBaur gcc-3.4.4/gcc/config/arm/arm.md gcc-3.4.4-new/gcc/config/arm/arm.md --- gcc-3.4.4/gcc/config/arm/arm.md Tue Jan 25 12:50:34 2005 -+++ gcc-3.4.4-new/gcc/config/arm/arm.md Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/arm/arm.md Mon Jun 13 23:42:56 2005 @@ -7205,6 +7205,12 @@ { if (TARGET_CALLER_INTERWORKING) @@ -725,7 +725,7 @@ diff -NBaur gcc-3.4.4/gcc/config/arm/arm.md gcc-3.4.4-new/gcc/config/arm/arm.md }" diff -NBaur gcc-3.4.4/gcc/config/arm/t-arm-elf gcc-3.4.4-new/gcc/config/arm/t-arm-elf --- gcc-3.4.4/gcc/config/arm/t-arm-elf Tue Sep 30 11:21:41 2003 -+++ gcc-3.4.4-new/gcc/config/arm/t-arm-elf Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/arm/t-arm-elf Mon Jun 13 23:42:56 2005 @@ -18,24 +18,24 @@ # MULTILIB_DIRNAMES += le be # MULTILIB_MATCHES += mbig-endian=mbe mlittle-endian=mle @@ -799,7 +799,7 @@ diff -NBaur gcc-3.4.4/gcc/config/arm/t-arm-elf gcc-3.4.4-new/gcc/config/arm/t-ar diff -NBaur gcc-3.4.4/gcc/config/i386/cygming.h gcc-3.4.4-new/gcc/config/i386/cygming.h --- gcc-3.4.4/gcc/config/i386/cygming.h Tue Jun 8 07:30:13 2004 -+++ gcc-3.4.4-new/gcc/config/i386/cygming.h Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/cygming.h Mon Jun 13 23:42:56 2005 @@ -251,7 +251,7 @@ unit may not be bound to undefined symbols in another translation unit without user intervention. For instance, under Microsoft Windows @@ -820,7 +820,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/cygming.h gcc-3.4.4-new/gcc/config/i386/cy #define NO_IMPLICIT_EXTERN_C diff -NBaur gcc-3.4.4/gcc/config/i386/i386.c gcc-3.4.4-new/gcc/config/i386/i386.c --- gcc-3.4.4/gcc/config/i386/i386.c Wed Mar 16 15:23:40 2005 -+++ gcc-3.4.4-new/gcc/config/i386/i386.c Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/i386.c Mon Jun 13 23:42:57 2005 @@ -5284,7 +5284,7 @@ GEN_INT (-allocate), -1); else @@ -832,7 +832,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/i386.c gcc-3.4.4-new/gcc/config/i386/i386. diff -NBaur gcc-3.4.4/gcc/config/i386/mingw32-1.c gcc-3.4.4-new/gcc/config/i386/mingw32-1.c --- gcc-3.4.4/gcc/config/i386/mingw32-1.c Thu Jan 1 00:00:00 1970 -+++ gcc-3.4.4-new/gcc/config/i386/mingw32-1.c Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/mingw32-1.c Mon Jun 13 23:42:57 2005 @@ -0,0 +1,41 @@ +/* This replaces the use of stat and struct stat.st_ino to determine if + files are different in gcc.c (do_spec_1) handling of --save-temps @@ -877,7 +877,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/mingw32-1.c gcc-3.4.4-new/gcc/config/i386/ +} diff -NBaur gcc-3.4.4/gcc/config/i386/mingw32.h gcc-3.4.4-new/gcc/config/i386/mingw32.h --- gcc-3.4.4/gcc/config/i386/mingw32.h Fri Sep 26 04:46:06 2003 -+++ gcc-3.4.4-new/gcc/config/i386/mingw32.h Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/mingw32.h Mon Jun 13 23:42:57 2005 @@ -67,7 +67,11 @@ #undef STARTFILE_SPEC @@ -893,7 +893,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/mingw32.h gcc-3.4.4-new/gcc/config/i386/mi #undef MD_STARTFILE_PREFIX diff -NBaur gcc-3.4.4/gcc/config/i386/t-cygming gcc-3.4.4-new/gcc/config/i386/t-cygming --- gcc-3.4.4/gcc/config/i386/t-cygming Tue Sep 23 19:55:59 2003 -+++ gcc-3.4.4-new/gcc/config/i386/t-cygming Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/t-cygming Mon Jun 13 23:42:57 2005 @@ -10,6 +10,8 @@ # first. LIBGCC2_INCLUDES = -I$(srcdir)/../winsup/w32api/include @@ -905,7 +905,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/t-cygming gcc-3.4.4-new/gcc/config/i386/t- $(TM_P_H) toplev.h $(HASHTAB_H) $(GGC_H) diff -NBaur gcc-3.4.4/gcc/config/i386/t-mingw32 gcc-3.4.4-new/gcc/config/i386/t-mingw32 --- gcc-3.4.4/gcc/config/i386/t-mingw32 Tue Jun 11 06:25:44 2002 -+++ gcc-3.4.4-new/gcc/config/i386/t-mingw32 Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/t-mingw32 Mon Jun 13 23:42:57 2005 @@ -1,7 +1,8 @@ # # collect2 doesn't work for i386-mingw32* yet. @@ -919,7 +919,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/t-mingw32 gcc-3.4.4-new/gcc/config/i386/t- + diff -NBaur gcc-3.4.4/gcc/config/i386/w32-shared-ptr.c gcc-3.4.4-new/gcc/config/i386/w32-shared-ptr.c --- gcc-3.4.4/gcc/config/i386/w32-shared-ptr.c Thu Jan 1 00:00:00 1970 -+++ gcc-3.4.4-new/gcc/config/i386/w32-shared-ptr.c Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/w32-shared-ptr.c Mon Jun 13 23:42:57 2005 @@ -0,0 +1,244 @@ +/* + * w32-shared-ptr.c @@ -1167,7 +1167,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/w32-shared-ptr.c gcc-3.4.4-new/gcc/config/ +#endif diff -NBaur gcc-3.4.4/gcc/config/i386/w32-shared-ptr.h gcc-3.4.4-new/gcc/config/i386/w32-shared-ptr.h --- gcc-3.4.4/gcc/config/i386/w32-shared-ptr.h Thu Jan 1 00:00:00 1970 -+++ gcc-3.4.4-new/gcc/config/i386/w32-shared-ptr.h Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/w32-shared-ptr.h Mon Jun 13 23:42:57 2005 @@ -0,0 +1,65 @@ +/* + * w32-shared-ptr.h @@ -1236,7 +1236,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/w32-shared-ptr.h gcc-3.4.4-new/gcc/config/ +#endif diff -NBaur gcc-3.4.4/gcc/config/i386/winnt.c gcc-3.4.4-new/gcc/config/i386/winnt.c --- gcc-3.4.4/gcc/config/i386/winnt.c Tue Mar 23 23:18:31 2004 -+++ gcc-3.4.4-new/gcc/config/i386/winnt.c Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/winnt.c Mon Jun 13 23:42:57 2005 @@ -262,7 +262,8 @@ } @@ -1305,7 +1305,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/winnt.c gcc-3.4.4-new/gcc/config/i386/winn tree decl; diff -NBaur gcc-3.4.4/gcc/config/i386/x-mingw32 gcc-3.4.4-new/gcc/config/i386/x-mingw32 --- gcc-3.4.4/gcc/config/i386/x-mingw32 Wed May 28 22:06:23 2003 -+++ gcc-3.4.4-new/gcc/config/i386/x-mingw32 Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/x-mingw32 Mon Jun 13 23:42:57 2005 @@ -2,3 +2,26 @@ # Make local_includedir relative to EXEC_PREFIX # @@ -1335,7 +1335,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/x-mingw32 gcc-3.4.4-new/gcc/config/i386/x- + $(srcdir)/config/i386/mingw32-1.c diff -NBaur gcc-3.4.4/gcc/config/i386/x-mingw32.patch gcc-3.4.4-new/gcc/config/i386/x-mingw32.patch --- gcc-3.4.4/gcc/config/i386/x-mingw32.patch Thu Jan 1 00:00:00 1970 -+++ gcc-3.4.4-new/gcc/config/i386/x-mingw32.patch Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/x-mingw32.patch Mon Jun 13 23:42:57 2005 @@ -0,0 +1,10 @@ +--- x-mingw32.orig Sat May 15 18:33:41 2004 ++++ x-mingw32 Tue May 11 13:17:28 2004 @@ -1349,7 +1349,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/x-mingw32.patch gcc-3.4.4-new/gcc/config/i + # of 'll' for HOST_WIDEST_INT_PRINT_*. See hwint.h. diff -NBaur gcc-3.4.4/gcc/config/i386/xm-mingw32.h gcc-3.4.4-new/gcc/config/i386/xm-mingw32.h --- gcc-3.4.4/gcc/config/i386/xm-mingw32.h Sat Jan 31 06:18:23 2004 -+++ gcc-3.4.4-new/gcc/config/i386/xm-mingw32.h Fri May 20 17:42:34 2005 ++++ gcc-3.4.4-new/gcc/config/i386/xm-mingw32.h Mon Jun 13 23:42:57 2005 @@ -27,3 +27,18 @@ /* This is the name of the null device on windows. */ @@ -1371,7 +1371,7 @@ diff -NBaur gcc-3.4.4/gcc/config/i386/xm-mingw32.h gcc-3.4.4-new/gcc/config/i386 +#define HOST_FILE_ID_CMP(SRC,DST) w32_file_id_cmp (SRC, DST) diff -NBaur gcc-3.4.4/gcc/config/rs6000/sysv4.h gcc-3.4.4-new/gcc/config/rs6000/sysv4.h --- gcc-3.4.4/gcc/config/rs6000/sysv4.h Fri Feb 11 21:06:45 2005 -+++ gcc-3.4.4-new/gcc/config/rs6000/sysv4.h Fri May 20 17:42:39 2005 ++++ gcc-3.4.4-new/gcc/config/rs6000/sysv4.h Mon Jun 13 23:42:57 2005 @@ -444,7 +444,7 @@ (TARGET_RELOCATABLE || (flag_pic && DEFAULT_ABI != ABI_AIX) \ ? "\t.section\t\".got2\",\"aw\"" : "\t.section\t\".got1\",\"aw\"") @@ -1383,7 +1383,7 @@ diff -NBaur gcc-3.4.4/gcc/config/rs6000/sysv4.h gcc-3.4.4-new/gcc/config/rs6000/ diff -NBaur gcc-3.4.4/gcc/config.gcc gcc-3.4.4-new/gcc/config.gcc --- gcc-3.4.4/gcc/config.gcc Mon Apr 25 05:47:59 2005 -+++ gcc-3.4.4-new/gcc/config.gcc Fri May 20 17:42:39 2005 ++++ gcc-3.4.4-new/gcc/config.gcc Mon Jun 13 23:42:57 2005 @@ -1173,6 +1173,8 @@ xm_file=i386/xm-mingw32.h tmake_file="i386/t-cygming i386/t-mingw32" @@ -1411,7 +1411,7 @@ diff -NBaur gcc-3.4.4/gcc/config.gcc gcc-3.4.4-new/gcc/config.gcc tm_file="dbxelf.h elfos.h svr4.h ${tm_file}" diff -NBaur gcc-3.4.4/gcc/config.host gcc-3.4.4-new/gcc/config.host --- gcc-3.4.4/gcc/config.host Tue Oct 14 04:41:41 2003 -+++ gcc-3.4.4-new/gcc/config.host Fri May 20 17:42:39 2005 ++++ gcc-3.4.4-new/gcc/config.host Mon Jun 13 23:42:57 2005 @@ -135,6 +135,8 @@ host_xm_file=i386/xm-mingw32.h host_xmake_file=i386/x-mingw32 @@ -1421,66 +1421,157382 @@ diff -NBaur gcc-3.4.4/gcc/config.host gcc-3.4.4-new/gcc/config.host ;; i[34567]86-*-uwin*) echo "*** UWIN may not be used as a host platform because" +diff -NBaur gcc-3.4.4/gcc/cp/ChangeLog gcc-3.4.4-new/gcc/cp/ChangeLog +--- gcc-3.4.4/gcc/cp/ChangeLog Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/ChangeLog Thu May 19 08:48:05 2005 +@@ -0,0 +1,2019 @@ ++2005-05-19 Release Manager ++ ++ * GCC 3.4.4 released. ++ ++2005-05-08 Nathan Sidwell ++ ++ PR c++/21427 ++ Backport 2005-03-01 Nathan Sidwell ++ * class.c (update_vtable_entry_for_fn): Don't crash on invalid ++ covariancy. ++ ++ * cp-tree.h (THUNK_TARGET): Expand comment. ++ * method.c (use_thunk): Make sure we also use the target, if that ++ is a thunk. ++ ++ Backport 2005-02-11 Nathan Sidwell ++ * class.c (update_vtable_entry_for_fn): Walk the covariant's binfo ++ chain rather than using lookup_base. ++ ++2005-05-04 Mark Mitchell ++ ++ Backport: ++ 2004-12-21 Mark Mitchell ++ PR c++/19034 ++ * tree.c (cp_tree_equal): Handle OVERLOAD. ++ ++2005-05-02 Mark Mitchell ++ ++ Revert: ++ 2005-05-01 Mark Mitchell ++ * typeck.c (unary_complex_lvalue): In a template, always refuse ++ simplifications. ++ ++2005-05-01 Mark Mitchell ++ ++ Backport: ++ 2005-02-22 Mark Mitchell ++ PR c++/19991 ++ * init.c (decl_constant_value): Iterate if the value of a decl ++ is itself a constant. ++ ++2005-05-01 Mark Mitchell ++ ++ Backport: ++ 2004-12-22 Mark Mitchell ++ PR c++/18464 ++ * call.c (build_this): In templates, do not bother with ++ build_unary_op. ++ * typeck.c (unary_complex_lvalue): In a template, always refuse ++ simplifications. ++ ++2005-04-25 Roger Sayle ++ Mark Mitchell ++ ++ PR c++/20995 ++ Partial backport from mainline. ++ 2004-09-27 Mark Mitchell ++ * tree.c (fold_if_not_in_template): New function. ++ * cp-tree.h (fold_if_not_in_template): Prototype here. ++ * call.c (build_conditional_expr): Use fold_if_not_in_template. ++ * typeck.c (build_binary_op): Likewise. ++ ++2005-04-16 Mark Mitchell ++ ++ PR c++/21025 ++ * typeck.c (cxx_sizeof_or_alignof_type): Check whether the type to ++ which sizeof/alignof is dependent, rather than just whether we are ++ processing_template_decl. ++ ++2005-04-06 Jason Merrill ++ ++ PR c++/19312 ++ * tree.c (stabilize_init): Don't bother trying to stabilize ++ something with no side-effects. ++ ++2005-04-04 Mark Mitchell ++ ++ PR c++/20679 ++ * parser.c (cp_parser_template_name): Fix thinko. ++ ++2005-04-03 Gabriel Dos Reis ++ ++ PR c++/18644 ++ * call.c (build_new_op): Remove check for -Wsynth. ++ ++2005-03-21 Paolo Carlini ++ ++ PR c++/20147 ++ * semantics.c (finish_stmt_expr_expr): Return immediately ++ if error_operand_p (expr). ++ ++2005-03-19 Kriang Lerdsuwanakij ++ ++ PR c++/20240 ++ * decl.c (decls_match): Compare context of VAR_DECL. ++ ++2005-03-19 Kriang Lerdsuwanakij ++ ++ PR c++/20333 ++ * parser.c (cp_parser_postfix_expression) : ++ Check the return value of cp_parser_nested_name_specifier. ++ ++2005-03-08 Mark Mitchell ++ ++ PR c++/20142 ++ * init.c (build_vec_init): When determining whether or not the ++ element type has an asignment operator, look through all array ++ dimensions. ++ ++2005-03-06 Kriang Lerdsuwanakij ++ ++ PR c++/19311 ++ * init.c (build_offset_ref): Don't build non-dependent SCOPE_REF. ++ * pt.c (build_non_dependent_expr): Don't build NON_DEPENDENT_EXPR ++ for OFFSET_TYPE. ++ * typeck.c (build_x_unary_op): Don't build non-dependent SCOPE_REF. ++ Also set PTRMEM_OK_P for NON_DEPENDENT_EXPR. ++ (build_unary_op): Handle building ADDR_EXPR of OFFSET_REF inside ++ template. ++ ++2005-03-02 Alexandre Oliva ++ ++ * name-lookup.c (push_overloaded_decl): Don't error if the new ++ decl matches the old one. ++ * decl.c (redeclaration_error_message): Likewise. ++ ++2005-02-24 Jakub Jelinek ++ ++ PR c++/20175 ++ * decl.c (reshape_init): Don't warn about missing braces if STRING_CST ++ initializes a char/wchar_t array. ++ ++2005-02-21 Alexandre Oliva ++ ++ PR c++/20028 ++ * class.c (finish_struct): Initialize TYPE_SIZE_UNIT of a ++ template along with TYPE_SIZE. ++ ++2005-02-14 Mark Mitchell ++ ++ * decl.c (reshape_init): Use explicit quotes in error message ++ instead of %q. ++ ++2005-02-12 Kriang Lerdsuwanakij ++ ++ PR c++/14479 ++ PR c++/19487 ++ * pt.c (maybe_check_template_type): Remove. ++ * cp-tree.h (maybe_check_template_type): Remove prototype. ++ * name-lookup.c (maybe_process_template_type_declaration): Don't ++ use maybe_check_template_type. ++ ++2005-02-10 Mark Mitchell ++ ++ PR c++/19755 ++ * decl.c (reshape_init): Issue warnings about missing braces. ++ ++2005-02-09 Mark Mitchell ++ ++ * parser.c (cp_parser_unqualified_id): Initialize type_decl. ++ ++ PR c++/19787 ++ * call.c (initialize_reference): Robustify. ++ ++ PR c++/19762 ++ * parser.c (cp_parser_unqualified_id): Avoid creating destructor ++ names with invalid types. ++ ++ PR c++/19739 ++ * parser.c (cp_parser_attributes_list): Allow empty lists. ++ ++2005-02-08 Mark Mitchell ++ ++ PR c++/19733 ++ * cvt.c (convert_to_void): Issue errors about pseudo-destructor ++ expressions. ++ ++2005-02-01 Alexandre Oliva ++ ++ PR c++/18757 ++ PR c++/19366 ++ PR c++/19499 ++ * parser.c (cp_parser_template_id): Revert 2004-12-09's patch. ++ Issue an error when creating the template id. ++ * pt.c (fn_type_unification): Return early if the explicit ++ template arg list is an error_mark_node. ++ ++2005-01-27 J"orn Rennecke ++ ++ PR c++/18370 ++ * parser.c (cp_parser_initializer_clause): Initialize *non_constant_p. ++ ++2005-01-19 Kriang Lerdsuwanakij ++ ++ PR c++/19375 ++ * semantics.c (finish_id_expression): Disable access checking for ++ already lookuped FIELD_DECL. ++ ++2005-01-19 Kriang Lerdsuwanakij ++ ++ PR c++/19258 ++ * parser.c (cp_parser_late_parsing_default_args): Handle friend ++ defined in class. ++ * pt.c (push_access_scope, pop_access_scope): Likewise. ++ ++2005-01-15 Jakub Jelinek ++ ++ PR c++/19263 ++ * typeck2.c (split_nonconstant_init_1) : Put a copy ++ of CONSTRUCTOR's node into MODIFY_EXPR, as the original is modified. ++ Store code to *pcode. ++ ++2004-12-28 Jakub Jelinek ++ ++ PR c++/18384, c++/18327 ++ * decl.c (reshape_init_array): Use UHWI type for max_index_cst ++ and index. Convert max_index to size_type_node if it isn't ++ host_integerp (, 1). ++ ++2004-12-23 Alexandre Oliva ++ ++ PR c++/18962 ++ * pt.c (check_explicit_specialization): Use the argument list from ++ the definition in a template function specialization definition. ++ ++2004-12-23 Alexandre Oliva ++ ++ PR c++/18757 ++ * parser.c (cp_parser_template_id): Don't create a CPP_TEMPLATE_ID ++ if parsing failed. ++ ++2004-12-17 Nathan Sidwell ++ ++ PR c++/18975 ++ * method.c (do_build_copy_constructor): Refactor. Don't const ++ qualify a mutable field. ++ (do_build_assign_ref): Likewise. ++ ++2004-12-10 Volker Reichelt ++ ++ PR c++/18731 ++ * parser.c (cp_parser_class_head): Reject typedef-name in class head. ++ ++2004-12-09 Nathan Sidwell ++ ++ PR c++/16681 ++ * init.c (build_zero_init): Build a RANGE_EXPR for an array ++ initializer. ++ ++2004-12-08 Kriang Lerdsuwanakij ++ ++ PR c++/18100 ++ * name-lookup.c (push_class_level_binding): Diagnose nested ++ class template with the same name as enclosing class. ++ ++2004-12-04 Kriang Lerdsuwanakij ++ ++ PR c++/17011, c++/17971 ++ * pt.c (tsubst_copy) : Check and diagnose ++ invalid field. ++ (tsubst_copy_and_build) : Check ++ error_mark_node after member substitution. ++ * semantics.c (finish_id_expression): Call ++ finish_non_static_data_member for dependent FIELD_DECL. ++ ++2004-12-02 Kriang Lerdsuwanakij ++ ++ PR c++/18123 ++ * parser.c (cp_parser_type_specifier): Don't create new enum ++ type if it is not in the form 'enum [identifier] { [...] };'. ++ Catch template declaration of enum. ++ ++2004-12-01 Nathan Sidwell ++ ++ PR c++/17431 ++ * call.c (standard_conversion): Add FLAGS parameter. Do not allow ++ derived to base conversion when checking constructor ++ accessibility. ++ (implicit_conversion): Pass FLAGS to standard_conversion. ++ (check_constructir_callable): Disallow conversion functions. ++ ++2004-11-12 Mark Mitchell ++ ++ PR c++/18389 ++ * decl.c (start_decl): Make sure to set *pop_scope_p. Return ++ error_mark_node to indicate errors. ++ ++ PR c++/18436 ++ * pt.c (tsubst_copy_and_build): Do not do Koenig lookup when an ++ unqualified name resolves to a member function. ++ ++ PR c++/18407 ++ * pt.c (tsubst_copy_and_build): Handle qualified names used from a ++ derived class correctly. ++ ++2004-11-04 Release Manager ++ ++ * GCC 3.4.3 released. ++ ++2004-10-31 Mark Mitchell ++ ++ PR c++/15172 ++ * typeck2.c (store_init_value): Use split_nonconstant_init even ++ for types that require construction. ++ ++2004-10-28 Mark Mitchell ++ ++ PR c++/17132 ++ * pt.c (instantiate_class_template): Increment ++ processing_template_decl when substituting into a member class ++ template. ++ ++2004-10-27 Mark Mitchell ++ ++ PR c++/18140 ++ * parser.c (cp_parser_next_token_ends_template_argument_p): Do not ++ include ">>". ++ ++2004-10-27 Andrew Pinski ++ ++ PR c++/13560 ++ * error.c (cp_error_at): Output the context as it might be ++ different file as the other location. ++ ++2004-10-26 Mark Mitchell ++ ++ PR c++/18093 ++ * search.c (current_scope): Return the innermost non-block scope, ++ not the innermost non-block, non-namespace scope. ++ (at_namespace_scope_p): Adjust accordingly. ++ (dfs_accessible_post): Do not pass namespaces to is_friend. ++ (dfs_walk_once_accessible_r): Likewise. ++ * decl.c (grokvardecl): Adjust call to current_scope. ++ (build_enumerator): Likewise. ++ * parser.c (cp_parser_using_declaration): Likewise. ++ (cp_parser_direct_declarator): Use at_namespace_scope_p instead of ++ current_scope. ++ (cp_parser_class_head): Adjust call to current_scope. ++ * name-lookup.c (do_namespace_alias): Set the DECL_CONTEXT for the ++ alias. ++ ++ PR c++/18020 ++ * pt.c (tusbst_copy_and_build): Resolve enumeration constants to ++ their underlying values. ++ ++2004-10-17 Andrew Pinski ++ ++ PR c++/16301 ++ * name-lookup.c (parse_using_directive): If we have a ++ error_mark_node, do not set the decl namespace associations ++ on it. ++ ++2004-10-14 Mark Mitchell ++ ++ PR c++/17976 ++ * decl.c (cp_finish_decl): Do not call expand_static_init more ++ than once for a single variable. ++ ++2004-10-11 Mark Mitchell ++ ++ PR c++/15786 ++ * parser.c (cp_parser_declarator): Add member_p parameter. ++ (cp_parser_condition): Adjust calls to cp_parser_declarator. ++ (cp_parser_explicit_instantiation): Likewise. ++ (cp_parser_init_declarator): Likewise. ++ (cp_parser_direct_declarator): Add member_p parameter. Do not ++ parse tentatively when parsing the parameters to a member. ++ (cp_parser_type_id): Adjust calls to cp_parser_declarator. ++ (cp_parser_parameter_declaration): Likewise. ++ (cp_parser_member_declaration): Likewise. ++ (cp_parser_exception_declaration): Likewise. ++ ++2004-10-11 Mark Mitchell ++ ++ * decl2.c (finish_anon_union): Robustify. ++ ++2004-10-10 Mark Mitchell ++ ++ PR c++/17393 ++ * decl.c (grokdeclarator): Robustify error-recovery on invalid ++ declarations. ++ ++2004-10-09 Mark Mitchell ++ ++ PR c++/17821 ++ * parser.c (cp_parser_postfix_dot_deref_expression): If the ++ pseduo-destructor-name production does not work, fall back to the ++ ordinary production. ++ ++ PR c++/17826 ++ * tree.c (cp_tree_equal): Handle a BASELINK. ++ ++2004-10-09 Mark Mitchell ++ ++ PR c++/17524 ++ * cp-tree.h (check_var_type): New function. ++ * decl.c (check_var_type): New function, split out from ... ++ (grokdeclarator): ... here. ++ * pt.c (tsubst_decl): Use check_var_type. ++ ++ PR c++/17685 ++ * decl.c (grokdeclarator): Disallow declarations of operators as ++ non-functions. ++ ++2004-10-08 Volker Reichelt ++ ++ PR c++/17868 ++ * error.c (dump_expr): Add missing case for RDIV_EXPR. ++ ++2004-10-08 Nathan Sidwell ++ ++ PR c++/17829 ++ * parser.c (cp_parser_postfix_expression): Inhibit Koenig when ++ unqualified lookup finds a member function. ++ ++2004-09-28 Roger Sayle ++ ++ PR driver/17537 ++ * g++spec.c (lang_specific_driver): Unrecognized libraries, other ++ than -lc and -lm, may require linking against libstc++. ++ ++2004-09-27 Mark Mitchell ++ ++ PR c++/17585 ++ * cp-tree.h (shared_member_p): Declare. ++ * search.c (shared_member_p): Give it external linkage. ++ * semantics.c (finish_qualified_id_expr): Use it. ++ (finish_id_expression): Likewise. ++ ++2004-09-22 Giovanni Bajo ++ ++ PR c++/14179 ++ * parser.c (cp_parser_initializer): Speed up parsing of simple ++ literals as initializers. ++ ++2004-09-21 Giovanni Bajo ++ ++ PR c++/14179 ++ * decl.c (reshape_init): Extract array handling into... ++ (reshape_init_array): New function. Use integers instead of trees ++ for indices. Handle out-of-range designated initializers. ++ ++2004-09-16 Mark Mitchell ++ ++ PR c++/17501 ++ * parser.c (cp_parser_nested_name_specifier): Do not resolve ++ typename types if the user explicitly said "typename". ++ ++2004-09-13 Mark Mitchell ++ ++ PR c++/16162 ++ * parser.c (cp_parser_id_expression): Correct value for ++ is_declarator. ++ (cp_parser_nested_name_specifier_opt): Look through typenames as ++ necessary. ++ (cp_parser_template_name): Honor check_dependency_p. ++ ++2004-09-13 Mark Mitchell ++ ++ PR c++/17327 ++ * pt.c (unify): Add ENUMERAL_TYPE case. Replace sorry with ++ gcc_unreacable. ++ ++2004-09-06 Release Manager ++ ++ * GCC 3.4.2 released. ++ ++2004-08-25 Roger Sayle ++ ++ PR middle-end/16693 ++ PR tree-optimization/16372 ++ * decl.c (finish_enum): Make the precision of the enumerated type ++ the same width as the underlying integer type. ++ ++2004-08-24 Jason Merrill ++ ++ PR c++/16851 ++ * tree.c (stabilize_init): See through a COMPOUND_EXPR. ++ ++ PR c++/15461 ++ * semantics.c (nullify_returns_r): Replace a DECL_STMT ++ for the NRV with an INIT_EXPR. ++ ++2004-08-24 Nathan Sidwell ++ ++ PR c++/16889 ++ * (is_subobject_of_p): Resurrect & optimize. ++ (lookup_field_r): Use it. ++ ++2004-08-24 Kriang Lerdsuwanakij ++ ++ PR c++/16706 ++ * search.c (friend_accessible_p): Increment processing_template_decl ++ when deal with TEMPLATE_DECL of SCOPE. ++ ++2004-08-23 Janis Johnson ++ ++ Backports from mainline: ++ ++ 2004-02-27 Ziemowit Laski ++ 2004-03-24 Ziemowit Laski ++ ++ * Make-lang.in (cp/mangle.o): Depend on $(TARGET_H). ++ * mangle.c (write_type): Add call to 'mangle_fundamental_type' ++ target hook. ++ * tree.c (pod_type_p): Treat VECTOR_TYPEs as PODs. ++ ++2004-08-19 Mark Mitchell ++ ++ PR c++/15890 ++ * pt.c (push_template_decl_real): Disallow template allocation ++ functions with fewer than two parameters. ++ ++2004-08-18 Mark Mitchell ++ ++ PR c++/17068 ++ * pt.c (dependent_template_p): Treat IDENTIFIER_NODEs as ++ dependent. ++ ++2004-08-17 Mark Mitchell ++ ++ PR c++/16246 ++ * pt.c (unify): Make sure that non-type arguments have the same ++ type as the corresponding parameter. ++ ++2004-08-12 Mark Mitchell ++ ++ PR c++/16273 ++ * class.c (count_depth_data): New type. ++ (dfs_depth_post): New function. ++ (dfs_depth_q): Likewise. ++ (find_final_overrider_data_s): Change type of vpath. ++ Add vpath_list. ++ (dfs_find_final_overrider_1): New function. ++ (dfs_find_final_overrider): Use it. ++ (dfs_find_final_overrider_q): Adjust use of vpath. ++ (dfs_find_final_overrider_post): Likewise. ++ (find_final_overrider): Use dfs_depth. Allocate and deallocate ++ vpath_list. ++ ++2004-08-12 Jan Beulich ++ ++ * parser.c (cp_parser_asm_definition): Properly consume scope operator ++ tokens preceding the clobbers. Don't check for scope operator ++ following inputs. Simplify inputs handling to match that now used for ++ clobbers. ++ ++2004-08-11 Mark Mitchell ++ ++ PR c++/16698 ++ * except.c (build_throw): Allocate cleanup_type and the function ++ for __cxa_throw separately. ++ ++2004-08-11 Mark Mitchell ++ ++ PR c++/16717 ++ * semantics.c (expand_body): Do not update static_ctors and ++ static_dtors here. ++ (expand_or_defer_fn): Do it here, instead. ++ ++ PR c++/16853 ++ * call.c (standard_conversion): Do not accept conversions between ++ pointers to members if the class types are unrelated. ++ ++ PR c++/16870 ++ * pt.c (tsubst): Just return the unknown_type_node. ++ ++ PR c++/16964 ++ * parser.c (cp_parser_class_specifier): Robustify. ++ ++ PR c++/16904 ++ * pt.c (tsubst_copy_and_build): Complain about invalid ++ qualification. ++ ++ PR c++/16929 ++ * pt.c (tsubst_default_argument): Clear out current_class_ptr and ++ current_class_ref while tsubsting. ++ ++2004-08-01 Mark Mitchell ++ ++ PR c++/16224 ++ * name-lookup.c (decl_namespace): Remove. ++ (current_decl_namespace): Use decl_namespace_context instead of ++ decl_namespace. ++ (push_decl_namespace): Likewise. ++ (arg_assoc_class): Likewise. ++ (arg_assoc_type): Likewise. ++ * pt.c (check_specialization_namespace): New function. ++ (maybe_process_partial_specialization): Use it. ++ (register_specialization): Likewise. ++ ++2004-08-01 Mark Mitchell ++ ++ PR c++/16489 ++ * cp-tree.h (DECL_INTEGRAL_CONSTANT_VAR_P): New macro. ++ * call.c (null_ptr_cst_p): Handle variables with constant ++ initializers. ++ * pt.c (convert_nontype_argument): Use ++ DECL_INTEGRAL_CONSTANT_VAR_P. ++ * semantics.c (finish_id_expression): Likewise. ++ ++ PR c++/16529 ++ * decl.c (duplicate_decls): Reject duplicate namespace ++ declarations. ++ ++ PR c++/16810 ++ * typeck.c (build_ptrmemfunc): Loosen assertion. ++ ++2004-07-28 Kriang Lerdsuwanakij ++ ++ PR c++/13092 ++ * init.c (build_offset_ref): Build SCOPE_REF with non-null ++ TREE_TYPE for non-dependent names. ++ * typeck.c (build_x_unary_op): Handle non-dependent SCOPE_REF. ++ * pt.c (type_dependent_expression_p): Handle SCOPE_REF with ++ unknown_type_node as its TREE_TYPE. ++ * cxx-pretty_print.c (pp_cxx_unqualified_id): Handle BASELINK. ++ * error.c (dump_decl) : Use pp_expression. ++ (dump_expr) : Likewise. ++ ++2004-07-21 Kriang Lerdsuwanakij ++ ++ PR c++/16175 ++ * error.c (dump_type) : Output ++ cv qualifier. ++ ++2004-07-20 Mark Mitchell ++ ++ (cp_parser_simple_type_specifier): Fix typo. ++ ++ PR c++/16637 ++ * parser.c (cp_parser_simple_type_specifier): Do not record usage ++ of globally-qualified names. ++ ++2004-07-12 Andrew Pinski ++ ++ PR c++/16475 ++ Revert: ++ 2004-07-07 H.J. Lu ++ PR c++/16276 ++ * rtti.c (emit_tinfo_decl): Turn off DECL_ONE_ONLY if typeinfo ++ is not public. ++ ++ ++2004-07-07 H.J. Lu ++ ++ PR c++/16276 ++ * rtti.c (emit_tinfo_decl): Turn off DECL_ONE_ONLY if typeinfo ++ is not public. ++ ++2004-07-01 Release Manager ++ ++ * GCC 3.4.1 released. ++ ++2004-06-28 Nathan Sidwell ++ ++ PR C++/16174 ++ * call.c (build_temp): Declare. ++ (check_constructor_callable): New. ++ (reference_binding): Only set CHECK_COPY_CONSTRUCTOR if not for ++ CONSTRUCTOR_CALLABLE. ++ (convert_like_real, initialize_reference): Use ++ check_constructor_callable. ++ * cp-tree.h (LOOKUP_CONSTRUCTOR_CALLABLE): New. ++ (LOOKUP_*): Renumber. ++ ++2004-06-25 Jan Hubicka ++ ++ PR C++/14865 ++ * decl2.c (maybe_emit_vtables): Always import_export_vtable for the ++ reachability analysis. ++ ++2004-06-22 Jan Hubicka ++ ++ PR C++/14950 ++ * pt.c (instantiate_decl): Clean TI_PENDING_TEMPLATE_FLAG before ++ expanding the function. ++ ++2004-06-21 Nathan Sidwell ++ ++ PR c++/3518 ++ * pt.c (check_cv_quals_for_unify): Ignore bogus CV quals at outer ++ level. ++ ++ PR c++/14007 ++ * pt.c (check_cv_quals_for_unify): Correct logic for disallowed ++ cv-qualifier unification. ++ * tree.c (cp_build_qualified_type_real): Renable DR295 logic. ++ ++2004-06-15 Giovanni Bajo ++ ++ PR c++/15967 ++ * search.c (build_new_1): Robustify. ++ ++2004-06-14 Giovanni Bajo ++ ++ PR c++/15947 ++ * parser.c (cp_parser_template_name): Ctors/dtors never need a ++ template keyword to disambiguate. ++ ++2004-06-14 Mark Mitchell ++ ++ PR c++/15096 ++ * decl.c (grokdeclarator): Ignore pointer-to-members when ++ computing template depth. ++ ++ PR c++/14930 ++ * name-lookup.c (pushtag): Do not try to put class declarations in ++ explicit specialization scopes. ++ ++i2004-06-11 Mark Mitchell ++ ++ PR c++/15862 ++ * name-lookup.c (unqualified_namespace_lookup): Do not ignore type ++ bindings for undeclared built-ins. ++ ++2004-06-10 Jason Merrill ++ ++ PR c++/15875 ++ Revert: ++ 2004-06-01 Kriang Lerdsuwanakij ++ * init.c (build_offset_ref): Build SCOPE_REF with non-null ++ TREE_TYPE for non-dependent names. ++ * pt.c (type_dependent_expression_p): Handle SCOPE_REF with ++ unknown_type_node as its TREE_TYPE. ++ * cxx-pretty_print.c (pp_cxx_unqualified_id): Handle BASELINK. ++ * error.c (dump_decl) : Use pp_expression. ++ (dump_expr) : Likewise. ++ ++2004-06-10 Mark Mitchell ++ ++ PR c++/15227 ++ * parser.c (cp_parser_direct_declarator): Robustify. ++ ++ PR c++/15877 ++ * pt.c (tsubst_copy): Use decl_constant_value on enumeration ++ constants in non-dependent contexts. ++ ++ PR c++/14211 ++ PR c++/15076 ++ * typeck.c (build_static_cast): Wrap casts in NON_LVALUE_EXPR when ++ necessary. ++ ++2004-06-09 Mark Mitchell ++ ++ Revert: ++ PR c++/15815 ++ 2004-06-07 Mark Mitchell ++ * lex.c (handle_pragma_interface): Deprecate. ++ (handle_pragma_implementation): Likewise. ++ ++2004-06-07 Dan Kegel ++ ++ PR c++/14808 ++ * method.c (make_alias_for_thunk, use_thunk): Use TARGET_IS_PE_COFF ++ instead of __CYWGIN__ and __MINGW32__. ++ ++2004-06-07 Mark Mitchell ++ ++ PR c++/15815 ++ * lex.c (handle_pragma_interface): Deprecate. ++ (handle_pragma_implementation): Likewise. ++ ++ PR c++/15766 ++ * parser.c (cp_parser_iteration_statement): Fix typo in error ++ message. ++ ++ PR c++/14777 ++ * pt.c (tsubst_default_argument): Do not defer access checks ++ while substituting into the default argument. ++ ++ PR c++/15554 ++ * pt.c (tsubst_copy): Do not try to substitute for an enumeration ++ constant in a non-dependent context. ++ ++ PR c++/15057 ++ * except.c (build_throw): Ensure that temp_expr has been ++ initialized. ++ ++2004-06-06 Giovanni Bajo ++ ++ PR c++/15503 ++ * parser.c (cp_parser_mem_initializer_id): Gracefully reject ++ 'typename', and accept 'template'. ++ ++2004-06-01 Jason Merrill ++ ++ PR c++/15142 ++ * call.c (call_builtin_trap): Remove type parm. ++ (convert_arg_to_ellipsis): Change a non-POD argument to integer type. ++ (build_x_va_arg): Dereference a null pointer for a non-POD argument. ++ ++2004-06-01 Kriang Lerdsuwanakij ++ ++ PR c++/13092 ++ * init.c (build_offset_ref): Build SCOPE_REF with non-null ++ TREE_TYPE for non-dependent names. ++ * pt.c (type_dependent_expression_p): Handle SCOPE_REF with ++ unknown_type_node as its TREE_TYPE. ++ * cxx-pretty_print.c (pp_cxx_unqualified_id): Handle BASELINK. ++ * error.c (dump_decl) : Use pp_expression. ++ (dump_expr) : Likewise. ++ ++2004-06-01 Giovanni Bajo ++ ++ PR c++/14932 ++ * parser.c (cp_parser_postfix_expression): Allow subscript ++ operator in offsetof. ++ ++2004-05-31 Mark Mitchell ++ ++ PR c++/15701 ++ * friend.c (add_friend): Do not try to perform access checks for ++ functions from dependent classes. ++ ++ PR c++/15742 ++ * call.c (build_over_call): Set ++ current_function_returns_abnormally even in template functions. ++ ++ PR c++/15696 ++ * cp-tree.h (invalid_nonstatic_memfn_p): New function. ++ * cvt.c (convert_to_void): Use it. ++ * typeck.c (invalid_nonstatic_memfn_p): New function. ++ (decay_conversion): Use it. ++ ++ PR c++/15625 ++ * pt.c (tsubst_decl): Set DECL_FRIEND_CONTEXT for instantiated ++ templates. ++ ++ PR c++/15629 ++ * name-lookup.c (arg_assoc_class): Do not find template ++ specializations. ++ ++ PR c++/15209 ++ * tree.c (lvalue_p_1): Only consider the right-hand side of "." ++ expressions when determining whether or not an express is packed. ++ ++2004-05-28 Mark Mitchell ++ ++ PR c++/15083 ++ * decl2.c (delete_sanity): Set TREE_SIDE_EFFECTS on a DELETE_EXPR, ++ even in a templat.e ++ * init.c (build_new): Likewise. ++ ++ PR c++/15640 ++ * name-lookup.c (arg_assoc): Robustify. ++ ++ PR c++/15471 ++ * typeck.c (unary_complex_lvalue): Use context_for_name_lookup ++ when determining the scope to use for a pointer to member. ++ (lookup_anon_field): Give it external linkage. ++ * cp-tree.h (lookup_anon_field): Declare it. ++ * expr.c (cplus_expand_constant): Use it. ++ ++ PR c++/14668 ++ * parser.c (cp_parser_simple_type_specifier): Call ++ maybe_note_name_used_in_class. ++ ++2004-05-23 Mark Mitchell ++ ++ PR c++/15044 ++ * parser.c (cp_parser_class_head): Robustify. ++ ++ PR c++/15317 ++ * parser.c (cp_parser_decl_specifier_seq): Correct error in ++ comment. ++ (cp_parser_constructor_declarator_p): Treat attributes ++ as decl-specifiers. ++ ++ PR c++/15329 ++ * typeck.c (build_unary_op): Do not attempt to resolve casts to ++ base classes in templates. ++ ++ PR c++/15165 ++ * pt.c (instantiate_template): Robustify. ++ ++ PR c++/15025 ++ * decl.c (xref_tag): Issue errors about redeclaring template ++ classes as non-template classes. ++ ++ PR c++/14821 ++ * name-lookup.c (supplement_binding): Allow redefinitions of ++ namespace aliases. ++ ++ PR c++/14883 ++ * parser.c (cp_parser_template_argument): Robustify. ++ ++2004-05-22 Mark Mitchell ++ ++ PR c++/15285 ++ PR c++/15299 ++ * pt.c (build_non_dependent_expr): Expand the set of tree nodes ++ recognized as overloaded functions. ++ ++ PR c++/15507 ++ * class.c (layout_nonempty_base_or_field): Do not try to avoid ++ layout conflicts for unions. ++ ++ PR c++/15542 ++ * typeck.c (build_x_unary_op): Instantiate template class ++ specializations before looking for "operator &". ++ ++ PR c++/15427 ++ * typeck.c (complete_type): Layout non-dependent array types, even ++ in templates. ++ ++ PR c++/15287 ++ * typeck.c (build_unary_op): Do not optimize "&x[y]" when in a ++ template. ++ ++2004-04-23 Giovanni Bajo ++ ++ PR c++/15064 ++ * parser.c (cp_parser_postfix_expression): typeid operator cannot be ++ used in integral constant expressions. ++ ++2004-04-18 Release Manager ++ ++ * GCC 3.4.0 released. ++ ++2004-04-08 Danny Smith ++ ++ PR c++/14808 ++ * method.c (make_alias_for_thunk): Just return function decl ++ for one_only functions if __CYGWIN__ or __MINGW32__ ++ (use_thunk): Don't put function and thunk in same one_only ++ section if __CYGWIN__ or __MINGW32__. ++ ++2004-04-08 Jakub Jelinek ++ ++ * decl2.c (mark_used): Don't segfault if cfun != NULL but ++ current_function_decl == NULL. ++ ++2004-04-01 Mark Mitchell ++ ++ PR c++/14803 ++ * typeck.c (get_delta_difference): Call fold before returning the ++ value. ++ ++2004-04-01 Richard Henderson ++ ++ PR c++/14804 ++ * decl.c (cp_finish_decl): Preserve TREE_READONLY more often. ++ * typeck2.c (split_nonconstant_init): Clear TREE_READONLY. ++ ++2004-04-01 Mark Mitchell ++ ++ PR c++/14810 ++ * name-lookup.c (maybe_push_cleanup_level): Robustify. ++ ++2004-03-30 Mark Mitchell ++ ++ PR c++/14724 ++ * decl.c (start_decl_1): Do not decide whether or not to create a ++ new cleanup level until after the type has been completed. ++ ++ PR c++/14763 ++ * pt.c (tsubst_default_argument): Clear current_function_decl. ++ ++2004-03-28 Jan Hubicka ++ ++ PR C++/14639 ++ * method.c (use_think): Do not mark thunk as referenced. ++ ++2004-03-21 Mark Mitchell ++ ++ PR c++/14616 ++ * decl.c (cp_finish_decl): Compute the size of arrays declared in ++ templates, if their type is non-dependent. ++ ++2004-03-19 Mark Mitchell ++ ++ * call.c (build_op_delete_call): Do not forget the placement ++ arguments when iterating through mutiple delete operators. ++ ++ * cp-tree.h (svaed_scope): Remove last_parms. ++ (NEW_DELETE_OPNAME_P): New macro. ++ (last_function_parms): Remove. ++ (do_friend): Adjust prototype. ++ * decl.c (grokparms): Return the PARM_DECLs directly, rather than ++ using last_function_parms. ++ (grokfndecl): Take the PARM_DECLs as an argument, rather than ++ using last_function_parms. ++ (grokdeclarator): Adjust accordingly. Do not form METHOD_TYPEs ++ for class-specific operator new and operator delete. ++ (grok_op_properties): Do not look for allocation functions with ++ METHOD_TYPEs. ++ (start_function): Use DECL_ARGUMENTS instead of ++ last_function_parms. ++ * decl.h (last_function_parms): Do not declare. ++ * decl2.c (grokclassfn): Do not use last_function_parms. ++ * friend.c (do_friend): Remove parmdecls parameter. ++ * name-lookup.c (push_to_top_level): Do not save last_function_parms. ++ (pop_from_top_level): Do not restore it. ++ * pt.c (check_explicit_specialization): Do not adjust ++ last_function_parms. ++ ++ * name-lookup.c (do_local_using_decl): Create a local binding for ++ types brought in via using declarations. ++ ++ * name-lookup.c (lookup_arg_dependent): Handle block-scope ++ function declarations correctly. ++ ++ * semantics.c (finish_id_expression): Correct handling of ++ conversion operators to dependent types. ++ ++ * typeck.c (lookup_destructor): Allow the use of destructors from ++ base classes. ++ ++2004-03-19 Giovanni Bajo ++ ++ PR c++/14545 ++ * parser.c (cp_parser_functional_cast): A cast to anything ++ but integral or enumaration type is not an integral constant ++ expression. ++ * pt.c (value_dependent_expression_p): Handle cast expressions ++ without operands (such as "int()"). ++ ++2004-03-18 Mark Mitchell ++ ++ * semantics.c (finish_pseudo_destructor_expr): Allow differing ++ cv-qualification between the type named by the ++ pseudo-destructor-name and the object-type. ++ ++ * search.c (accessible_base_p): Handle non-proper bases. ++ ++ * name-lookup.c (do_nonmember_using_decl): If a using declaration ++ refers to a single overloaded function, set the type of the ++ function. ++ * tree.c (lvalue_type): Simplify. ++ * typeck.c (type_unknown_p): Do not assume all OVERLOADs have an ++ unknown type. ++ (build_unary_op): Handle OVERLOADs with known types. ++ ++ * decl.c (duplicate_decls): Do not destroy DECL_ARGUMENTS for ++ function templates. ++ ++ * parser.c (cp_parser_postfix_expression): Handle the use of ++ "typename" in non-dependent contexts. Convert appropriately when ++ when using a qualified name after "->" or ".". ++ ++ * call.c (conditional_conversion): Honor the requirement that some ++ conversions refer to the original object. ++ ++ * call.c (build_conditional_expr): Do not call force_rvalue for ++ operands of void_type when the conditional expression itself has ++ void type. ++ * name-lookup.c (pushdecl): Don't consider a declaration of a ++ function named "main" to be an overload of a type named "main". ++ * parser.c (cp_parser_template_name): Perform name lookup when the ++ template name is proceeded by "template" if the qualifying scope ++ is non-dependent. ++ * typeck.c (composite_pointer_type_r): Correctly handle ++ pointer-to-member types. ++ (build_const_cast): Likewise. ++ ++2004-03-16 Mark Mitchell ++ ++ PR c++/14586 ++ * cp-tree.h (build_new_op): Change prototype. ++ (build_x_binary_op): Likewise. ++ * call.c (build_new_op): Add overloaded_p parameter. ++ * decl2.c (grok_array_decl): Adjust call to build_new_op. ++ * parser.c (cp_parser_binary_expression): Note that uses of ++ overloaded operators prevents an expression from being considered ++ an integral constant. ++ * pt.c (tsubst_copy_and_build): Adjust calls to build_new_op and/or ++ build_x_binary_op. ++ * semantics.c (finish_call_expr): Likewise. ++ * typeck.c (rationalize_conditional_expr): Likewise. ++ (build_x_indirect_ref): Likewise. ++ (build_x_binary_op): Likewise. ++ (build_x_unary_op): Likewise. ++ (build_x_compound_expr): Likewise. ++ (build_modify_expr): Likewise. ++ * typeck2.c (build_x_arrow): Likewise. ++ ++2004-03-13 Mark Mitchell ++ ++ PR c++/14550 ++ * parser.c (cp_parser_non_integral_constant_expression): Encode ++ more of the idiom that surrounded calls to this function within ++ the function itself ++ (cp_parser_primary_expression): Adjust accordingly. ++ (cp_parser_postfix_expression): Likewise. ++ (cp_parser_unary_expression): Likewise. ++ (cp_parser_cast_expression): Likewise. ++ (cp_parser_assignment_expression): Likewise. ++ (cp_parser_expression): Likewise. ++ (cp_parser_new_expression): Note that new-expressions are not ++ allowed in integral constant expressions. ++ (cp_parser_delete_expression): Likewise. ++ ++2004-03-11 Mark Mitchell ++ ++ PR c++/14476 ++ * decl.c (xref_tag): Do not create dummy ENUMERAL_TYPEs. ++ ++2004-03-10 Mark Mitchell ++ ++ PR c++/14510 ++ * decl.c (xref_tag): Disregard non-type declarations when ++ looking up a tagged type. ++ ++2004-03-10 Jason Merrill ++ ++ PR c++/14452 ++ * tree.c (stabilize_init): Return whether or not it worked. ++ * init.c (build_new_1): If not, use a sentry. ++ * cp-tree.h: Adjust prototype. ++ ++2004-03-09 Nathan Sidwell ++ ++ PR c++/14397 ++ * call.c (convert_like_real): Build a const qualified temporary, ++ when testing ctor access. ++ ++2004-03-09 Mark Mitchell ++ ++ * call.c (initialize_reference): Fix typo. ++ ++2004-03-09 Giovanni Bajo ++ ++ PR c++/14409 ++ * pt.c (determine_specialization): For member templates, match also ++ constness. ++ ++ PR c++/14448 ++ * parser.c (cp_parser_initializer_clause): Fold initializer if it is ++ non-dependent. ++ * pt.c (tsubst_copy_and_build): Handle NOP_EXPRs. ++ ++2004-03-09 Mark Mitchell ++ ++ PR c++/14230 ++ * call.c (initialize_reference): Handle initializers that are ++ class-member access expressions applies to rvalues. ++ ++ PR c++/14432 ++ * name-lookup.c (supplement_binding): Ignore functions that are ++ marked DECL_ANTICIPATED. ++ ++2004-03-08 Mark Mitchell ++ ++ PR c++/14401 ++ * class.c (check_field_decls): Complain about non-static data ++ members of reference type in unions. Propagate ++ CLASSTYPE_REF_FIELDS_NEED_INIT and ++ CLASSTYPE_READONLY_FIELDS_NEED_INIT from the types of non-static ++ data members. ++ * init.c (perform_member_init): Complain about mbmers with const ++ type that are not explicitly initialized. ++ ++2004-03-08 Jason Merrill ++ ++ PR c++/13170 ++ * decl.c (xref_tag): Remove attribute handling. ++ * cp-tree.h: Adjust prototype. ++ * decl.c, parser.c, rtti.c: Adjust callers. ++ * parser.c (cp_parser_class_head): Pass back attributes in the ++ class head. ++ (cp_parser_class_specifier): Adjust. ++ ++2004-03-08 Matt Austern ++ ++ PR debug/14079 ++ * name-lookup.c (add_decl_to_level): Add extern variables, as well ++ as static, to static_decls array. ++ ++2004-03-01 Jason Merrill ++ ++ PR c++/13944 ++ * except.c (do_free_exception): Remove #if 0 wrapper. ++ (build_throw): Use it if we elide a copy into the ++ exception object. ++ ++ * tree.c (stabilize_call): Fix thinko. ++ ++ * init.c (build_new_1): Preevaluate initializer. Simplify EH code. ++ (build_init): Call a constructor rather than call build_aggr_init ++ for classes. ++ * except.c (stabilize_throw_expr): Remove. ++ (build_throw): Use stabilize_init instead of stabilize_throw_expr. ++ * tree.c (stabilize_call, stabilize_init): New fns. ++ * call.c (build_over_call): A constructor no longer returns the ++ address of the object. ++ ++2004-03-01 Mark Mitchell ++ ++ PR c++/14324 ++ * lex.c (retrofit_lang_decl): Treat entities with no linkage as ++ having C++ linkage for name-mangling purposes. ++ ++ PR c++/14260 ++ * parser.c (cp_parser_direct_declarator): Recognize constructor ++ declarators that use a template-id to name the class being ++ constructed. ++ ++ PR c++/14337 ++ * pt.c (tsubst_qualified_id): Handle dependent qualifying scopes. ++ (tsubst_expr): Do not call tsubst_copy, even when ++ processing_template_decl. ++ ++2004-03-01 Mark Mitchell ++ ++ PR c++/14369 ++ * pt.c (build_non_dependent_expr): Do not create a ++ NON_DEPENDENT_EXPR for a THROW_EXPR. ++ ++ PR c++/14360 ++ * parser.c (cp_parser_postfix_expression): Do not perform Koenig ++ lookup if ordinary name-lookup finds a non-function. ++ * pt.c (tsubst_copy_and_build): Likewise. ++ ++ PR c++/14361 ++ * parser.c (cp_parser_late_parsing_default_args): Check that there ++ are no extra tokens after the end of the default-argument ++ expression. ++ ++ PR c++/14359 ++ Backport 2004-02-12 Mark Mitchell ++ * decl.c (redeclaration_error_message): Correct handling of ++ templates. ++ * pt.c (tsubst_friend_declaration): Adjust code to determine ++ whether or not a friend template is a definition. ++ (tsubst_decl): Clear DECL_INITIAL for new FUNCTION_DECLs. ++ ++2004-03-01 Gabriel Dos Reis ++ ++ PR c++/14369 ++ * error.c (dump_expr): Handle THROW_EXPR. ++ ++2004-02-29 Mark Mitchell ++ ++ PR c++/14138 ++ * name-lookup.h (push_scope): Change prototype. ++ * name-lookup.c (push_scope): Do not reenter the current class ++ scope. ++ * decl.c (grokfndecl): Check return code from push_scope before ++ calling pop_scope. ++ * decl2.c (check_classfn): Likewise. ++ * parser.c (cp_parser_conversion_function_id): Likewise. ++ (cp_parser_init_declarator): Likewise. ++ (cp_parser_direct_declarator): Likewise. ++ (cp_parser_class_specifier): Likewise. ++ (cp_parser_class_head): Likewise. ++ (cp_parser_lookup_name): Likewise. ++ (cp_parser_constructor_declarator_p): Likewise. ++ * pt.c (instantiate_class_template): Likewise. ++ (resolve_typename_type): Likewise. ++ ++2004-02-27 Mark Mitchell ++ ++ PR debug/12103 ++ * class.c (update_vtable_entry_for_fn): Do not go through ++ covariance machinery if the type returned by an overrider is the ++ same as the original. ++ ++2004-02-27 Giovanni Bajo ++ ++ PR c++/14284 ++ * pt.c (dependent_type_p_r): A template template parameter is a ++ dependent type. ++ ++2004-02-26 Mark Mitchell ++ ++ PR c++/14278 ++ * parser.c (cp_parser_parameter_declaration_list): Commit ++ to fewer tentative parses. ++ ++2004-02-26 Giovanni Bajo ++ ++ PR c++/14246 ++ * mangle.c (write_template_arg_literal): Don't rely on identity for ++ boolean constants. ++ ++2004-02-23 Giovanni Bajo ++ ++ PR c++/14250 ++ * cvt.c (build_expr_type_conversion): Type must be complete before ++ looking up for conversions. ++ ++2004-02-20 Mark Mitchell ++ ++ PR c++/14199 ++ * pt.c (tsubst_copy): Call mark_used for a PARM_DECL. ++ ++ PR c++/14173 ++ * semantics.c (begin_class_definition): Set TYPE_PACKED correctly ++ for all type variants. ++ ++2004-02-19 Mark Mitchell ++ ++ PR c++/14186 ++ * name-lookup.c (push_class_level_binding): Do not complain about ++ adding a binding for a member whose name is the same as the ++ enclosing class if the member is located in a base class of the ++ current class. ++ ++2004-02-19 Giovanni Bajo ++ ++ PR c++/14181 ++ * parser.c (cp_parser_new_expression): Parse an ill-formed ++ direct-new-declarator after a parenthesized type-id to emit good ++ diagnostic. ++ ++2004-02-17 Mark Mitchell ++ ++ PR c++/11326 ++ * cp-tree.h (abi_version_at_least): Remove. ++ * mangle.c: Include flags.h. ++ ++2004-02-15 Mark Mitchell ++ ++ PR c++/13971 ++ * call.c (build_conditional_expr): Handle conversions between ++ class types which result in differently cv-qualified type ++ variants. ++ ++ PR c++/14086 ++ * class.c (delete_duplicate_fields_1): Remove. ++ (delete_duplicate_fields): Likewise. ++ (finish_struct_anon): Remove check for members with the same name ++ as their enclosing class. ++ (check_field_decls): Do not call duplicate_fields. ++ * decl.c (grokdeclarator): Remove check for static data members ++ with the same name as their enclosing class. ++ * name-lookup.c (push_class_level_binding): Check for members with ++ the same name as their enclosing class. ++ ++2004-02-15 Gabriel Dos Reis ++ ++ PR c++/14085 ++ * error.c (dump_decl): Handle TEMPLATE_TYPE_PARM. ++ ++2004-02-14 Kriang Lerdsuwanakij ++ ++ PR c++/13635 ++ * pt.c (push_template_decl_real): Make sure DECL_TI_ARGS of DECL ++ has full set of arguments. ++ ++2004-02-13 Mark Mitchell ++ ++ PR c++/14122 ++ * cp-tree.h (delete_sanity): Change prototype. ++ * decl2.c (delete_sanity): Make doing_vec a bool, not an int. ++ Remove dead code. Adjust code to warn about deleting an array. ++ * typekc.c (decay_conversion): Use build_address and build_nop. ++ ++ PR c++/14108 ++ * search.c (accessible_p): Do not check access in thunks. ++ ++2004-02-13 Giovanni Bajo ++ ++ PR c++/13927 ++ * error.c (dump_decl) : Dump as simple declarations. ++ ++2004-02-13 Mark Mitchell ++ ++ PR c++/14083 ++ * call.c (build_conditional_expr): Call force_rvalue on the ++ non-void operand in the case that one result is a throw-expression ++ and the other is not. ++ ++2004-02-13 Ian Lance Taylor ++ ++ PR c++/9851 ++ * parser.c (cp_parser_pseudo_destructor_name): Check for errors on ++ the type name and look ahead for ::~, and bail out early with a ++ better error message if the parse is going to fail. ++ ++2004-02-10 Mark Mitchell ++ ++ * typeck.c (lookup_destructor): Fix typo in error message. ++ ++2004-02-07 Zack Weinberg ++ ++ Bug 13856 ++ * optimize.c (maybe_clone_body): Don't update DECL_ESTIMATED_INSNS. ++ * decl.c (duplicate_decls, start_function): Likewise. ++ ++2004-02-07 Zack Weinberg ++ ++ * name-lookup.c (pushdecl): Issue shadow warnings directly. ++ * parser.c (free_parser_stacks): Delete. ++ ++2004-02-07 Kazu Hirata ++ ++ * rtti.c, tree.c: Update copyright. ++ ++2003-02-06 Giovanni Bajo ++ ++ PR c++/14033 ++ * decl.c (require_complete_types_for_parms): Do not insert ++ error_mark_node in the parameter list. ++ ++2003-02-06 Giovanni Bajo ++ ++ PR c++/14028 ++ * parser.c (cp_parser_enclosed_template_argument_list): Emit straight ++ error when terminator can not be found. ++ ++2004-02-05 Kelley Cook ++ ++ Make-lang.in (po-generated): Delete. ++ ++2004-02-05 Rainer Orth ++ ++ PR middle-end/13750 ++ Revert: ++ 2004-01-15 Geoffrey Keating ++ PR pch/13361 ++ * cp/lex.c (handle_pragma_interface): Duplicate string from tree. ++ (handle_pragma_implementation): Likewise. ++ ++2004-02-05 Mark Mitchell ++ ++ PR c++/13714 ++ * typeck.c (lookup_destructor): Tweak error message. ++ ++2004-02-05 Paul Brook ++ ++ Backport from mainline. ++ ++ 2003-11-05 Mark Mitchell ++ ++ * decl.c (cxx_push_function_context): Do not set ++ current_function_is_thunk. ++ * method.c (use_thunk): Set CALL_FROM_THUNK on the call to the ++ actual function. ++ ++2004-02-04 Mark Mitchell ++ ++ PR c++/13932 ++ * call.c (convert_like_real): Use "converting" rather than ++ "argument" as the descriptive keyword to ++ dubious_conversion_warnings. ++ * typeck.c (convert_for_assignment): Do not call ++ dubious_conversion_warnings. ++ ++2004-02-04 Giovanni Bajo ++ ++ PR c++/13086 ++ * init.c (build_delete): Emit a more informative error message in ++ case of an incomplete type, and on the correct source line. ++ ++2004-02-04 Mark Mitchell ++ ++ PR c++/9941 ++ * rtti.c (tinfo_base_init): Use import_export_tinfo to decide the ++ linkage for the typeinfo name string. ++ ++ PR c++/13969 ++ * cp-tree.h (fold_non_dependent_expr): New function. ++ * parser.c (cp_parser_fold_non_dependent_expr): Remove. ++ (cp_parser_template_argument): Use fold_non_dependent_expr. ++ (cp_parser_direct_declarator): Likewise. ++ * pt.c (fold_non_dependent_expr): New function. ++ (convert_nontype_argument): Use it. ++ (tsubst_qualified_id): Simplify. ++ (tsubst_copy_and_build): Likewise. ++ ++2003-02-04 Giovanni Bajo ++ ++ PR c++/13997 ++ * pt.c (more_specialized_class): Increase processing_template_decl ++ while partial ordering. ++ ++2004-02-03 Mark Mitchell ++ ++ PR c++/13950 ++ * parser.c (cp_parser_class_name): Robustify. ++ ++ PR c++/13970 ++ * parser.c (cp_parser_cache_group): Do not consume the EOF token. ++ ++2004-02-03 Mark Mitchell ++ ++ PR c++/13925 ++ * decl.c (start_function): Do not call pushdecl for any ++ instantiation or specialization of a primary template. ++ ++ PR c++/14002 ++ * semantics.c (finish_id_expression): Do not return an ++ IDENTIFIER_NODE when lookup finds a PARM_DECL. ++ ++ PR c++/13978 ++ * pt.c (build_non_dependent_expr): Do not build ++ NON_DEPENDENT_EXPRs for FUNCTION_DECLs or TEMPLATE_DECLs. ++ ++ PR c++/13968 ++ * semantics.c (finish_id_expression): Do not return an ++ IDENTIFIER_NODE when lookup finds a VAR_DECL. ++ ++ PR c++/13975 ++ * parser.c (cp_parser_simple_declaration): When skipping to the ++ end of the statement swallow the terminating semicolon. ++ ++2004-02-02 Giovanni Bajo ++ ++ DR206 ++ PR c++/13813 ++ * decl.c (grokdeclarator): Check immediatly type completeness for ++ non-dependent types. ++ ++2004-01-30 Mark Mitchell ++ ++ PR c++/13113 ++ * init.c (build_offset_ref): Improve error recovery for invalid ++ uses of non-static member functions. ++ ++ PR c++/13854 ++ * cp-tree.h (cp_build_type_attribute_variant): New function. ++ * class.c (build_clone): Use cp_build_type_attribute_variant. ++ * decl.c (duplicate_decls): Likewise. ++ * pt.c (copy_default_args_to_explicit_spec): Likewise. ++ (tsubst_function_type): Likewise. ++ * tree.c (build_exception_variant): Check attributes before ++ concluding that two types are the same. ++ (cp_build_type-attribute_variant): New method. ++ * typeck.c (merge_types): Use cp_build_type_attribute_variant. ++ ++ PR c++/13907 ++ * call.c (convert_class_to_reference): Keep better track of ++ pedantically invalid user-defined conversions. ++ ++2004-02-02 Giovanni Bajo ++ ++ PR c++/13957 ++ * pt.c (tsubst_qualified_id): Improved error message when a type ++ is expected but not found. ++ ++2004-01-30 Michael Matz ++ ++ * parser.c (cp_parser_labeled_statement): Accept case ranges. ++ ++2004-01-28 Jan Hubicka ++ ++ PR c++/13683 ++ * call.c (convert_arg_to_ellipsis): Don't emit a warning if within ++ a sizeof expression.block ++ ++2004-01-29 Giovanni Bajo ++ ++ * parser.c (cp_parser_template_id): Parse tentatively `[:' after a ++ template name as it was `<::' (digraph typo). ++ (cp_parser_nth_token_starts_template_argument_list_p): New function. ++ (cp_parser_id_expression): Use it. ++ (cp_parser_nested_name_specifier_opt): Likewise. ++ (cp_parser_template_name): Likewise. ++ (cp_parser_class_name): Likewise. ++ (cp_lexer_get_preprocessor_token): Use c_lex_with_flags. ++ ++2004-01-29 Mark Mitchell ++ ++ PR c++/13883 ++ * mangle.c (write_encoding): Correct encoding of member template ++ constructors. ++ ++2004-01-28 Mark Mitchell ++ ++ PR c++/13791 ++ * typeck.c (merge_types): Do not merge attributes into ++ TYPENAME_TYPEs. ++ ++2004-01-28 Mark Mitchell ++ ++ PR c++/13736 ++ * parser.c (cp_parser_direct_declarator): Do not prevent ++ backtracking inside a parenthesized declarator. ++ (cp_parser_parameter_declaration): Fix typo in comment. ++ ++2004-01-26 Kaveh R. Ghazi ++ ++ * cp-tree.h (language_function, lang_type_header): Use ++ BOOL_BITFIELD. ++ * name-lookup.h (cp_binding_level): Likewise. ++ ++2004-01-26 Mark Mitchell ++ ++ PR c++/13663 ++ * semantics.c (finish_for_expr): Check for unresolved overloaded ++ functions. ++ ++2004-01-26 Mark Mitchell ++ ++ * class.c (add_method): Just check processing_template_decl to ++ determine whether or not we are within a template. ++ * decl2.c (maybe_retrofit_in_chrg): Likewise. ++ * init.c (decl_constant_value): Check the type of the declaration, ++ not TREE_READONLY. ++ * name-lookup.c (maybe_push_to_top_level): Rename to ... ++ (push_to_top_level): ... this. ++ * name-lookup.h (maybe_push_to_top_level): Do not declare it. ++ * pt.c (push_template_decl_real): Reorder condition for speed. ++ (convert_template_argument): Use dependency-checking functions in ++ place of uses_template_parms. ++ (lookup_template_class): Avoid calling uses_template_parms more ++ than once. ++ (uses_template_parms): Reimplement, using dependency-checking ++ functions. ++ (instantiate_class_template): Use push_to_top_level, not ++ maybe_push_to_top_level. ++ (type_unification_real): Simplify. ++ (type_dependent_expression_p): Handle OFFSET_REFs and ++ TEMPLATE_DECLs. ++ (any_dependent_template_arguments_p): Handle multiple levels of ++ template argument. ++ * semantics.c (expand_or_defer_fn): Do not check ++ uses_template_parms for template instantiations. ++ * typeck.c (comptypes): Avoid calling cp_type_quals. ++ ++2004-01-25 Mark Mitchell ++ ++ PR c++/13833 ++ * call.c (build_over_call): Do not convert arguments when ++ processing a template. ++ * pt.c (build_non_dependent_expr): Do not build a ++ NON_DEPENDENT_EXPR for arithmetic constants. ++ ++2004-01-25 Giovanni Bajo ++ ++ PR c++/13810 ++ * parser.c (cp_parser_type_parameter): When cp_parser_id_expression ++ returns a TYPE_DECL. no further lookup is required. ++ * semantics.c (check_template_template_default_arg): A TYPE_DECL ++ is invalid. Rework to give better diagnostics. ++ ++2004-01-25 Kriang Lerdsuwanakij ++ ++ PR c++/13797 ++ * pt.c (instantiate_class_template): Add an error_mark_node ++ check. ++ (tsubst_decl) : Likewise. ++ ++2004-01-24 Kazu Hirata ++ ++ * call.c: Update copyright. ++ * class.c: Likewise. ++ * decl2.c: Likewise. ++ * except.c: Likewise. ++ * expr.c: Likewise. ++ * init.c: Likewise. ++ * mangle.c: Likewise. ++ * optimize.c: Likewise. ++ * typeck.c: Likewise. ++ * typeck2.c: Likewise. ++ ++2004-01-23 Andrew Pinski ++ ++ PR c++/13701 ++ * decl.c (finish_function): Move the call to ++ finish_fname_decls below the call to ++ finish_eh_spec_block. ++ ++2004-01-21 Zdenek Dvorak ++ ++ * parser.c (cp_parser_class_specifier): Prevent garbage collection. ++ ++2004-01-20 Kelley Cook ++ ++ * Make-lang.in: Replace $(docdir) with doc. ++ (c++.info, c++.srcinfo): Dummy entry. ++ (c++.man, c++.srcman): New rules. ++ (c++.install-man): Revamp rule. ++ ++2004-01-19 Kelley Cook ++ ++ * Make-lang.in (CXX_INSTALL_NAME, GXX_INSTALL_NAME, ++ CXX_TARGET_INSTALL_NAME, GXX_TARGET_INSTALL_NAME): Define via a ++ immediate $(shell) instead of deferred backquote. ++ ++2004-01-19 Mark Mitchell ++ ++ PR c++/13651 ++ * parser.c (cp_parser_postfix_expression): When encountering ++ incomplete type on left-hand side of "->" or ".", treat the entire ++ expression as erroneous. ++ ++2004-01-19 Mark Mitchell ++ ++ PR c++/13592 ++ * call.c (build_field_call): Remove. ++ (n_build_method_call): Likewise. ++ (build_method_call): Likewise. ++ (build_new_method_call): Do not call build_field_call. ++ * class.c (n_build_method_call): Remove. ++ (print_class_statistics): Do not print it. ++ * cp-tree.h (build_method_call): Remove declaration. ++ (finish_object_call_expr): Likewise. ++ (build_new_1): Do not use build_method_call. ++ * parser.c (cp_parser_postfix_expression): Use finish_call_expr ++ when the function appearing on the right-hand-side of "." or "->" ++ is not actually a function. ++ * pt.c (tsubst_copy_and_build): Likewise. ++ * semantics.c (finish_object_call_expr): Remove. ++ ++2004-01-18 Mark Mitchell ++ ++ PR c++/13710 ++ * pt.c (tsubst): Use finish_typeof. ++ ++2004-01-18 Jason Merrill ++ ++ PR c++/11725 ++ * except.c (build_throw): In a template, set ++ current_function_returns_abnormally. ++ ++2004-01-17 Fred Fish ++ ++ PR c++/11895 ++ * decl.c (reshape_init): Handle VECTOR_TYPE like ARRAY_TYPE, ++ except don't call array_type_nelts() with a VECTOR_TYPE. ++ ++2004-01-16 Jan Hubicka ++ ++ * mangle.c (write_mangled_name): Remove inline modifier. ++ ++2004-01-16 Mark Mitchell ++ ++ PR c++/13574 ++ * decl.c (compute_array_index_type): Fix grammar in comment. ++ * init.c (build_zero_init): Handle zero-sized arrays correctly. ++ ++ PR c++/13178 ++ * call.c (name_as_c_string): Print conversion operator names ++ correctly. ++ ++ PR c++/13478 ++ * call.c (initialize_reference): Pass -1 for inner parameter to ++ convert_like_real. ++ ++2004-01-15 Giovanni Bajo ++ ++ PR c++/13407 ++ * parser.c (cp_parser_base_specifier): Check for an invalid ++ keyword `typename' and emit an user-friendly error message. ++ ++2004-01-15 Geoffrey Keating ++ ++ PR pch/13361 ++ * cp/lex.c (handle_pragma_interface): Duplicate string from tree. ++ (handle_pragma_implementation): Likewise. ++ ++2004-01-15 Giovanni Bajo ++ ++ PR c++/9259 ++ * typeck.c (build_class_member_access_expr): Allow to access members ++ of the currently open class. ++ (finish_class_member_access_expr): Likewise. ++ ++2004-01-15 Alexandre Oliva ++ ++ PR c++/13659 ++ * name-lookup.c (validate_nonmember_using_decl): Take scope and ++ name by value, instead of computing them. ++ (do_local_using_decl, do_toplevel_using_decl): Add scope and name ++ arguments. Pass them to validate_nonmember_using_decl. ++ * name-lookup.h (do_local_using_decl): Adjust. ++ (do_toplevel_using_decl): Likewise. ++ * parser.c (cp_parser_using_declaration): Likewise. ++ * pt.c (tsubst_expr): Likewise. ++ ++2004-01-15 Alexandre Oliva ++ ++ PR c++/13594 ++ PR c++/13658 ++ * name-lookup.c (qualified_lookup_using_namespace): Search ++ strongly-associated namespaces first, and only then try other ++ namespaces. ++ ++2004-01-15 Kelley Cook ++ ++ * Make-lang.in (c++.srcextra): Dummy entry. ++ ++2004-01-15 Giovanni Bajo ++ ++ PR c++/8856 ++ * parser.c (cp_parser_template_name): Don't try to parse a ++ conversion-function-id, as it cannot be a template-name. ++ (cp_parser_simple_type_specifier): Check for invalid template-ids ++ even after a built-in type. ++ ++2004-01-14 Jan Hubicka ++ ++ PR c++/12850 ++ * pt.c (instantiate_decl): Do not increase function_depth. ++ ++2004-01-14 Danny Smith ++ ++ PR c++/9021 ++ PR c++/11005 ++ * parser.c (cp_parser_elaborated_type_specifier): Warn about ++ attributes and discard. ++ * decl.c (xref_tag): Don't overwite existing attributes with ++ NULL_TREE. ++ ++2004-01-14 Giovanni Bajo ++ ++ PR c++/12335 ++ * parser.c (cp_parser_lookup_name): Return error_mark_node if there ++ is no destructor while looking up a BIT_NOT_EXPR. ++ ++2004-01-13 Ian Lance Taylor ++ ++ * cxxfilt.c: Remove unused file. ++ ++2004-01-14 Jan Hubicka ++ ++ Partial fix to PR c++/12850 ++ * decl2.c (mark_used): Do not proactively instantiate templates ++ when compiling in unit-at-a-time or not optimizing. ++ * optimize.c (maybe_clone_body): Do not increase function depth. ++ ++2004-01-13 Giovanni Bajo ++ ++ PR c++/13474 ++ * pt.c (tsubst) : Remove obsolete array index tweaking. ++ ++2003-01-12 Steven Bosscher ++ ++ PR c++/13558 ++ * parser.c (cp_parser_member_declaration): Any non-type is also ++ not a class or a function. ++ ++2004-01-12 Jason Merrill ++ ++ PR c++/12815 ++ * class.c (build_base_path): Do not mark vtable references as ++ TREE_CONSTANT. ++ (build_vtbl_ref_1): Likewise. ++ ++2004-01-12 Richard Henderson ++ ++ PR opt/10776 ++ * typeck2.c (split_nonconstant_init_1, split_nonconstant_init): New. ++ (store_init_value): Use it. ++ * decl.c (check_initializer): Expect full initialization code ++ from store_init_value. ++ * init.c (expand_aggr_init_1): Likewise. ++ * decl2.c (maybe_emit_vtables): Abort if runtime init needed. ++ ++2004-01-12 Mark Mitchell ++ ++ * class.c (layout_class_type): For non-POD class types, also copy ++ the DECL_SIZE and DECL_MODE of fields to the base class type. ++ ++2004-01-12 Kriang Lerdsuwanakij ++ ++ PR c++/13289 ++ * pt.c (instantiate_decl): Set DECL_TEMPLATE_INSTANTIATED before ++ calling regenerate_decl_from_template. ++ ++2004-01-12 Scott Brumbaugh ++ ++ PR c++/4100 ++ * parser.c (cp_parser_decl_specifier_seq): Add check for a friend ++ decl-specifier occurring along with a class definition. ++ ++2004-01-12 Ian Lance Taylor ++ ++ * parser.c (cp_parser_decl_specifier_seq): Add parenthetical ++ clauses to comments describing declares_class_or_enum. ++ (cp_parser_type_specifier): Set *declares_class_or_enum to 0, not ++ false. ++ ++2004-01-12 Jan Hubicka ++ ++ * pt.c (for_each_template_parm): Do not check for duplicates. ++ (for_each_template_parm): Use walk_tree duplicate checking code. ++ ++2004-01-11 Ian Lance Taylor ++ ++ PR c++/3478 ++ * parser.c (cp_parser_decl_specifier_seq): If the first decl_spec ++ is error_mark_node, don't add any more decl_specs. ++ (cp_parser_init_declarator): After committing to a declaration, if ++ the decl_specifiers start with error_mark_node, issue an error and ++ change the type to "int". ++ ++2004-01-09 Nathanael Nerode ++ ++ PR bootstrap/7817 ++ * Make-lang.in: Copy gcc.1 to g++.1 rather than using .so. ++ ++2004-01-10 Giovanni Bajo ++ ++ DR 337 ++ PR c++/9256 ++ * pt.c (tsubst): Substitution must fail if we are attempting to ++ create an array with element type that is an abstract class type. ++ * decl.c (cp_finish_decl): Strip pointers and array types recursively ++ before calling abstract_virtuals_error. ++ ++2004-01-09 Alexandre Oliva ++ ++ * name-lookup.c (qualified_lookup_using_namespace): Consider ++ strong using directives even if we've already found a binding. ++ ++2004-01-09 Mark Mitchell ++ ++ * cp-tree.h (cxx_expand_expr): Change prototype. ++ * expr.c (cxx_expand_expr): Add alt_rtl parameter. ++ ++2004-01-08 Giovanni Bajo ++ ++ PR c++/12573 ++ * pt.c (value_dependent_expression_p): Handle COMPONENT_REFs by ++ looking into them recursively. They can be there because of the ++ new __offsetof__ extension. ++ ++2004-01-07 Zack Weinberg ++ ++ * parser.c (cp_parser_save_member_function_body): Mark the ++ definition static. ++ ++2004-01-05 Mark Mitchell ++ ++ PR c++/13057 ++ * class.c (build_clone): Copy type attributes from the original ++ function to the clone. ++ ++ PR c++/12815 ++ * class.c (build_vtbl_ref_1): Do not unconditionally mark vtable ++ references as constant. ++ ++ PR c++/12132 ++ * parser.c (cp_parser_explicit_instantiation): Improve error ++ recovery. ++ (cp_parser_require): Improve indication of the error location. ++ ++ PR c++/13451 ++ * parser.c (cp_parser_class_head): Reorder logic to check for ++ invalid qualification. ++ ++2004-01-04 Mark Mitchell ++ ++ PR c++/13157 ++ * name-lookup.c (lookup_using_namespace): Remove spacesp ++ parameter. ++ (unqualified_namespace_lookup): Likewise. ++ (lookup_qualified_name): Adjust accordingly. ++ (lookup_name_real): Likewise. ++ (lookup_arg_dependent): Do not eliminate the namespace of the ++ functions found by unqualified name lookup unless that is the ++ current namespace. ++ ++2004-01-04 Andrew Pinski ++ ++ * semantics.c (push_deferring_access_checks): Fix format. ++ (resume_deferring_access_checks): Likewise. ++ (stop_deferring_access_checks): Likewise. ++ (pop_deferring_access_checks): Likewise. ++ (get_deferred_access_checks): Likewise. ++ (pop_to_parent_deferring_access_checks): Likewise. ++ (perform_deferred_access_checks): Likewise. ++ (perform_or_defer_access_check): Likewise. ++ ++2004-01-04 Richard Henderson ++ ++ * call.c (build_over_call): Don't create a save_expr of an ++ aggregate, but rather its address. ++ ++2004-01-04 Mark Mitchell ++ ++ PR c++/13529 ++ * parser.c (cp_parser_postfix_expression): Allow "." to appear in ++ an offsetof expression. ++ ++ * parser.c (cp_parser_parameter_declaration): Fix comment. ++ ++ PR c++/12226 ++ * call.c (CHECK_COPY_CONSTRUCTOR_P): New macro. ++ (reference_binding): Set it when appropriate. ++ (build_temp): New function, split out from ... ++ (convert_like_real): ... here. Honor CHECK_COPY_CONSTRUCTOR_P. ++ (initialize_reference): Likewise. ++ ++ PR c++/13536 ++ * parser.c (cp_parser): Add in_type_id_in_expr_p. ++ (cp_parser_new): Initialize it. ++ (cp_parser_postfix_expression): Set it. ++ (cp_parser_sizeof_operand): Likewise. ++ (cp_parser_parameteR_declaration): Do not commit early to tenative ++ parsers when in_type_id_in_expr_p is set. ++ ++2004-01-03 Kriang Lerdsuwanakij ++ ++ PR c++/13094 ++ * parser.c (cp_parser_template_argument): Don't call ++ make_unbound_class_template directly. ++ (cp_parser_lookup_name): Don't extract TEMPLATE_DECL from ++ UNBOUND_CLASS_TEMPLATE tree node. ++ ++2004-01-02 Richard Sandiford ++ ++ PR target/12729 ++ * method.c (use_thunk): Pass the CALL_EXPR through force_target_expr. ++ ++2004-01-02 Kriang Lerdsuwanakij ++ ++ PR c++/13520 ++ * cp-tree.h (DECL_UNBOUND_CLASS_TEMPLATE_P): New macro. ++ (DECL_FUNCTION_TEMPLATE_P): Use it. ++ (DECL_CLASS_TEMPLATE_P): Likewise. ++ * parser.c (cp_parser_lookup_name): Add is_template parameter. ++ (cp_parser_type_parameter): Adjust call to cp_parser_lookup_name. ++ (cp_parser_template_name): Likewise. ++ (cp_parser_elaborated_type_specifier): Likewise. ++ (cp_parser_namespace_name): Likewise. ++ (cp_parser_class_name): Likewise. ++ (cp_parser_lookup_name_simple): Likewise. ++ ++See ChangeLog.3 for earlier changes. +diff -NBaur gcc-3.4.4/gcc/cp/ChangeLog.1 gcc-3.4.4-new/gcc/cp/ChangeLog.1 +--- gcc-3.4.4/gcc/cp/ChangeLog.1 Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/ChangeLog.1 Sat Dec 13 04:28:49 2003 +@@ -0,0 +1,9451 @@ ++Sun Nov 26 14:47:42 1995 Richard Kenner ++ ++ * Version 2.7.2 released. ++ ++Mon Nov 20 14:05:00 1995 Mike Stump ++ ++ * g++.c (pfatal_with_name): Add missing third argument to concat. ++ ++Thu Oct 26 13:59:54 1995 Mike Stump ++ ++ * init.c (expand_aggr_init): Handle cv qualifiers on the object's ++ type. ++ ++Sat Nov 11 08:25:55 1995 Richard Kenner ++ ++ * Version 2.7.1 released. ++ ++Thu Nov 2 17:02:47 1995 Jason Merrill ++ ++ * call.c (convert_harshness): Handle references to arrays. ++ ++Fri Oct 27 14:20:21 1995 Jason Merrill ++ ++ * typeck.c (comp_target_types): Check multi-level pointer ++ conversions in both directions. ++ ++Tue Oct 17 21:39:05 1995 Jason Merrill ++ ++ * parse.y (explicit_instantiation): Fix 'extern template' with no ++ return type. ++ ++Mon Oct 16 14:35:20 1995 Jason Merrill ++ ++ * parse.y (explicit_instantiation): Support automatic instantiation ++ of constructors. ++ (named_class_head_*): Support out-of-class definition of nested ++ types. ++ ++Wed Oct 11 12:20:56 1995 Mike Stump ++ ++ * search.c (envelope_add_decl): New routine. Fix so that ++ methods are hidden in the same way that other members are. ++ (dfs_pushdecls): Cleanup and move functionality out of line, ++ into envelope_add_decl. ++ ++Tue Oct 10 15:46:01 1995 Mike Stump ++ ++ * typeck.c (mark_addressable): Only call assemble_external if we ++ have started the output file. ++ ++Tue Oct 10 11:27:18 1995 Jason Merrill ++ ++ * decl.c (start_function): Fix earlier cv-quals change. ++ ++Mon Oct 9 23:53:05 1995 Mike Stump ++ ++ * parse.y (complex_direct_notype_declarator): Only push the class if ++ we are not already in the class. ++ ++Mon Oct 9 11:22:03 1995 Doug Evans ++ ++ * decl.c (duplicate_decls): Call merge_machine_decl_attributes. ++ Update olddecl's attributes too. ++ (grokdeclarator): #if 0 out call to build_decl_attribute_variant. ++ * typeck.c (common_type): Call merge_machine_type_attributes. ++ ++Fri Oct 6 14:44:27 1995 Mike Stump ++ ++ * typeck.c (mark_addressable): Add missing call to ++ assemble_external. ++ ++Wed Oct 4 15:06:39 1995 Mike Stump ++ ++ * decl.c (store_parm_decls): Make sure the unwinder start comes ++ before the exception specification start. ++ * except.c (expand_exception_blocks): Make sure the unwinder end ++ comes after the terminate protected catch clause region and after ++ the end of the exception specification region. ++ ++Wed Oct 4 12:47:02 1995 Jason Merrill ++ ++ * lex.c (real_yylex): Fix identifier case for linemode. ++ (handle_sysv_pragma): Don't abort when we see a pragma we don't ++ recognize. ++ ++Tue Oct 3 14:09:46 1995 Mike Stump ++ ++ * decl.c (store_parm_decls): Add a call to start_eh_unwinder. ++ * except.c (init_exception_processing): __throw doesn't take any ++ arguments. ++ (expand_builtin_throw): Likewise. Always use Pmode, instead of SImode ++ for all pointers. Use expand_builtin_return_addr to unwind the ++ first level off the stack. ++ (do_unwind): Always use Pmode, instead of SImode for all pointers. ++ (expand_exception_blocks): Add a call to end_eh_unwinder. ++ (start_eh_unwinder, end_eh_unwinder): New routines to build machine ++ independent stack unwinders for function/method calls. ++ ++Mon Oct 2 17:20:42 1995 Mike Stump ++ ++ * tree.c (unsave_expr_now): Make sure we process the argument list ++ of any called functions. Fixes incorrect code generation for ++ cleanups. ++ ++Mon Oct 2 13:04:16 1995 Mike Stump ++ ++ * typeck.c (get_member_function_from_ptrfunc): Save function if it ++ needs it. Cures core dump on things like (this->*(f()))(). ++ ++Sat Sep 23 22:51:25 1995 Jason Merrill ++ ++ * decl.c (start_function): Conform to gcc cv-quals convention (no ++ expression has a cv-qualified type) in RESULT_DECLs. ++ * method.c (make_thunk): Likewise. ++ ++Fri Sep 22 10:21:13 1995 Mike Stump ++ ++ * decl.c (pushtag): Add in the namespace name for the tag. ++ ++Thu Sep 21 13:11:13 1995 Mike Stump ++ ++ * parse.y (maybe_base_class_list, base_class_list, base_class, ++ base_class_access_list): Make sure we see the typenames for base ++ classes. ++ * lex.c (see_typename): Instead of failing to see a typename when ++ there is no next token, perfer a typename, and get the next token. ++ ++Wed Sep 20 12:35:27 1995 Michael Meissner ++ ++ * decl.c (init_decl_processing): Add __builtin_expect. ++ ++Tue Sep 19 16:48:11 1995 Mike Stump ++ ++ * cvt.c (cp_convert_to_pointer): Don't allow leftover conversions to ++ or from pointer to member functions, they must all be handled before ++ this point. ++ ++Fri Sep 15 17:14:47 1995 Brendan Kehoe ++ ++ * init.c (resolve_offset_ref): Fix wording of non-static member ++ being referenced as a static. ++ ++Fri Sep 15 12:39:11 1995 Jason Merrill ++ ++ * typeck.c (build_indirect_ref): Only bash pointer if we actually ++ call build_expr_type_conversion. ++ ++Thu Sep 14 18:24:56 1995 Jason Merrill ++ ++ * cvt.c (build_expr_type_conversion): Handle conversion from ++ reference. ++ * typeck.c (build_indirect_ref): Avoid infinite recursion. ++ ++Thu Sep 14 17:23:28 1995 Mike Stump ++ ++ * decl.c (expand_start_early_try_stmts): New routine to start a try ++ block at the start of the function, for function-try-blocks. ++ * cp-tree.h (expand_start_early_try_stmts): Declare it. ++ * parse.y (function_try_block): Use it, instead of doing it here, as ++ we don't want to include rtl.h here, as that conflicts with RETURN ++ in the parser. ++ ++Wed Sep 13 18:32:24 1995 Mike Stump ++ ++ * lex.c (reinit_parse_for_block): Support saving inline ++ function-try-blocks, uses peekyylex. ++ * parse.y (eat_saved_input): New rule, permit the parser to see that ++ END_OF_SAVED_INPUT is ok, as it can see this when parsing the ++ handlers of a function-try-block. ++ (fndef): Use it. ++ (component_decl): Make sure TRY and RETURN can come after fn.def2. ++ * spew.c (peekyylex): New routine to peek at what will come next. ++ ++Wed Sep 13 16:52:06 1995 Jason Merrill ++ ++ * typeck.c (comptypes): Tighten up comparisons of template type ++ parms. ++ ++ * decl.c (duplicate_decls): Turn off whining about virtual functions ++ redeclared inline for now. ++ ++Wed Sep 13 11:13:40 1995 Mike Stump ++ ++ * decl.c (store_in_parms): New routine to put things before we ++ put base inits. ++ * cp-tree.h (store_in_parms): Declare it. ++ * decl.c (store_parm_decls): Use it to makr sure the starting of the ++ eh spec comes before base inits. ++ (finish_function): Use sequences instead of the obsolete ++ reorder_insns. ++ * parse.y (fndef): Enhance readability and maintainability. Update ++ to include function_try_block syntax. ++ (function_try_block): Add. ++ ++Tue Sep 12 17:43:07 1995 Brendan Kehoe ++ ++ * call.c (convert_harshness): Use comptypes, not ==, to check if ++ TYPE and PARMTYPE are equivalent on a function type. ++ ++Tue Sep 12 17:31:33 1995 Douglas Rupp ++ ++ * Make-lang.in (cc1plus): Removed unnecessary $(exeext). ++ ++Mon Sep 11 23:24:07 1995 Mike Stump ++ ++ * except.c (expand_throw): Never allocate storage for thrown pointer ++ to objects. ++ ++Mon Sep 11 19:36:45 1995 Mike Stump ++ ++ * except.c (expand_start_catch_block): Pointers to objects come ++ back from catch matching already dereferenced, don't dereference ++ again. ++ ++Mon Sep 11 15:46:28 1995 Mike Stump ++ ++ * except.c (expand_throw): Only decay the throw expression, don't do ++ any default conversions. This is so that one can throw and catch ++ characters, and not have them match integers. ++ ++Mon Sep 11 13:46:45 1995 Mike Stump ++ ++ * error.c (dump_aggr_type): Deal with anonymous unions that don't ++ have a TYPE_NAME. ++ ++Fri Sep 8 20:40:27 1995 Brendan Kehoe ++ ++ * lex.c (handle_sysv_pragma): Deal with getting a comma from yylex. ++ ++Fri Sep 8 15:51:41 1995 Mike Stump ++ ++ * except.c (expand_end_eh_spec): Handle empty EH specifications. ++ ++Fri Sep 8 15:27:22 1995 Mike Stump ++ ++ * cp-tree.h (expand_start_eh_spec): Declare new routine. ++ (expand_end_eh_spec): Likewise. ++ * decl.c (store_parm_decls): Call expand_start_eh_spec to process ++ exception specifications. ++ * except.c (expand_leftover_cleanups): Remove unused parameter. ++ (expand_end_catch_block): Likewise. ++ (expand_exception_blocks): Likewise. ++ (expand_start_eh_spec): New routine to mark the start of an ++ exception specification region. ++ (expand_end_eh_spec): New routine to mark the end of an exception ++ specification region. ++ (expand_exception_blocks): Call expand_end_eh_spec to process ++ exception specifications. ++ ++Fri Sep 8 14:40:48 1995 Per Bothner ++ ++ * lex.c (do_identifier): Use global binding in preference of ++ dead for local variable. ++ ++Wed Sep 6 19:32:59 1995 Mike Stump ++ ++ * cp-tree.h (build_exception_variant): Remove used first argument. ++ * decl.c (duplicate_decls): Likewise. ++ (grokfndecl): Likewise. ++ (revert_static_member_fn): Likewise. ++ * decl2.c (grok_method_quals): Likewise. ++ * tree.c (build_exception_variant): Likewise. ++ * typeck.c (common_type): Likewise. ++ * decl2.c (grokclassfn): After changing the type, call ++ build_exception_variant, if necessary. ++ ++Tue Sep 5 15:56:27 1995 Mike Stump ++ ++ * except.c (expand_throw): Run cleanups for the throw expression. ++ ++Wed Aug 30 15:24:38 1995 Stephen L. Favor ++ ++ * except.c (expand_builtin_throw): Moved gen_label_rtx calls beyond ++ the store_parm_decls call which does initialization in the emit_* ++ code concerning label numbering. ++ ++Thu Aug 31 09:01:07 1995 Mike Stump ++ ++ * except.c (expand_internal_throw): Let the frontend be responsible ++ for managing all frontend EH parameters, the backend routine only ++ needs to deal with backend values. type and value are no longer ++ passed to __throw. ++ (init_exception_processing): Likewise. ++ (expand_start_all_catch): Likewise. ++ (expand_end_all_catch): Likewise. ++ (expand_leftover_cleanups): Likewise. ++ (expand_end_catch_block): Likewise. ++ (expand_builtin_throw): Likewise. ++ (expand_throw): Likewise. ++ ++Tue Aug 29 15:04:36 1995 Jason Merrill ++ ++ * cp-tree.h (DECL_REAL_CONTEXT): Give the real declaration context ++ for a decl. ++ * decl.c (cp_finish_decl): Use it. ++ ++Tue Aug 29 10:30:27 1995 Mike Stump ++ ++ * except.c (expand_internal_throw): Oops, almost forgot type and ++ value are now trees. ++ ++Mon Aug 28 17:57:45 1995 Brendan Kehoe ++ ++ Fix the attribute handling to make sure they get noted before we ++ create the function's RTL, in case they can affect that. ++ * decl.c (grokfndecl): New arg ATTRLIST. Run ++ cplus_decl_attributes before creating the decl's rtl. ++ (grokdeclarator): New arg ATTRLIST, passed down into grokfndecl. ++ (shadow_tag, groktypename, start_decl, start_method): Pass a ++ NULL_TREE to grokdeclarator's new last arg. ++ * decl2.c (grokfield): New arg ATTRLIST, passed into grokdeclarator. ++ (grokbitfield, grokoptypename): Pass a NULL_TREE to ++ grokdeclarator's new last arg. ++ * except.c (expand_start_catch_block): Likewise. ++ * pt.c (process_template_parm, end_template_decl, ++ do_function_instantiation): Likewise. ++ * cp-tree.h (grokfield): Add arg. ++ (grokdeclarator): Move the prototype from here... ++ * decl.h: ...to here. ++ * lex.c (cons_up_default_function): Pass NULL_TREE to grokfield ++ ATTRLIST argument. ++ * parse.y: Create a list for the grokfield arg where appropriate, ++ and pass it down instead of calling cplus_decl_attributes. ++ ++Mon Aug 28 15:07:24 1995 Mike Stump ++ ++ * except.c: Always allow turning on exception handling. Allow cross ++ compilations to use EH. ++ ++Thu Aug 24 17:39:24 1995 Mike Stump ++ ++ * except.c (saved_pc, saved_throw_type, saved_throw_value): Use ++ trees, instead of rtxs, and don't depend on using special machine ++ dependent registers. ++ (expand_internal_throw): Likewise. ++ (init_exception_processing): Likewise. ++ (expand_start_all_catch): Likewise. ++ (expand_end_all_catch): Likewise. ++ (expand_start_catch_block): Likewise. ++ (expand_leftover_cleanups): Likewise. ++ (expand_end_catch_block): Likewise. ++ (expand_builtin_throw): Likewise. ++ (expand_throw): Likewise. ++ ++Wed Aug 23 17:25:51 1995 Jason Merrill ++ ++ * cvt.c (build_expr_type_conversion): Handle conversions to ++ reference types. ++ ++Wed Aug 23 15:33:59 1995 Mike Stump ++ ++ * except.c (do_unwind): Work around backend bug with -fpic. ++ ++Tue Aug 22 17:20:07 1995 Per Bothner ++ ++ * decl2.c (flag_new_for_scope): Add a new mode that follows ANSI ++ for-scoping, but supports (and warns about) old programs. ++ Make the new mode (with value 1) the default. ++ (lang_f_options): The on-value for flag_new_for_scope is now 2. ++ * cp-tree.h (DECL_DEAD_FOR_LOCAL, DECL_ERROR_REPORTED): New macros ++ (DECL_SHADOWED_FOR_VAR): Likewise. ++ * decl.c (struct binding_level): New fields dead_vars_from_for ++ and is_for_scope. ++ (note_level_for_for): New function. ++ (poplevel): Special processing if is_for_scope. ++ (pushdecl): Warn if for-scope variable shadows local. ++ * lex.c (do_identifier): Handle old (non-ANSI) for scoping, ++ and warn if conflicts. ++ * parse.y (FOR): Call note_level_for_for. ++ ++Mon Aug 21 10:28:31 1995 Jason Merrill ++ ++ * decl2.c (import_export_inline): Class interface hackery does not ++ apply to synthesized methods. ++ ++Sun Aug 20 16:29:00 1995 Mike Stump ++ ++ * search.c (virtual_context): Find the right context more often. ++ Solves a `recoverable compiler error, fixups for virtual function' ++ problem. ++ ++Sun Aug 20 13:53:24 1995 Mike Stump ++ ++ * except.c (expand_start_all_catch): Ensure that we always transfer ++ control to the right EH handler, by rethrowing the end label on the ++ region, instead of hoping we are nested and falling through. ++ (expand_leftover_cleanups): Likewise. ++ (end_protect): Since we now rethrow the end label, put a ++ nop after it, so that outer regions are recognized. ++ * init.c (build_vec_delete_1): New routine to handle most of vector ++ deleting, all code moved here from build_vec_delete. ++ (build_array_eh_cleanup): Use build_vec_delete_1 to do all the real ++ work. ++ (expand_vec_init): If the array needs partial destructing, setup an ++ EH region to handle it. ++ (build_vec_delete): Move lots of code to build_vec_delete_1, use ++ build_vec_delete_1 to do the grunt work. ++ ++Sat Aug 19 14:25:33 1995 Brendan Kehoe ++ ++ Handle decl attributes properly for function definitions without ++ previous attribute-loaded declarations. ++ * decl.c (start_function): New arg ATTRS. Add a call to ++ cplus_decl_attributes with it before we create the RTL. ++ * cp-tree.h (start_function): Update prototype. ++ * parse.y (fn.def1): Pass ATTRS into start_function instead of ++ trying to call cplus_decl_attributes too late. Pass a NULL_TREE ++ for other use. ++ * decl2.c (finish_file): Pass NULL_TREE as fourth arg to ++ start_function. ++ * method.c (synthesize_method): Likewise. ++ * except.c (expand_builtin_throw): Likewise for start on __throw. ++ ++Sat Aug 19 13:36:08 1995 Mike Stump ++ ++ * class.c (set_rtti_entry): Turn on -fvtable-thunk -frtti support. ++ This changes -fvtable-thunks vtable layout, so a recompile will be ++ necessary, if you use -fvtable-thunks. ++ (get_vtable_entry): Use n, instead of i to be consistent with the ++ rest of the compiler. ++ (get_vtable_entry_n): Likewise. ++ (add_virtual_function): Add a slot for the tdesc, if -fvtable-thunks ++ are being used. ++ (finish_struct_1): Likewise. ++ (skip_rtti_stuff): New routine to collapse similar code from many ++ different parts of the compiler. I think I got them all. ++ (modify_one_vtable): Use it. ++ (fixup_vtable_deltas1): Likewise. ++ (override_one_vtable): Likewise. ++ * decl2.c (mark_vtable_entries): Likewise. ++ * tree.c (debug_binfo): Likewise. ++ * search.c (expand_upcast_fixups): Likewise. ++ (get_abstract_virtuals_1): Likewise. Use virtuals, instead of tmp to ++ consistent with the rest of the compiler. ++ (get_abstract_virtuals): Likewise. ++ * cp-tree.h (skip_rtti_stuff): New routine, declare it. ++ * gc.c (build_headof): Support -fvtable-thunk and -frtti together. ++ (build_typeid): Likewise. ++ (build_classof): Remove old style way of doing rtti. Remove support ++ for `classof' and `headof'. ++ * gxx.gperf: Likewise. ++ * hash.h: Likewise. ++ * parse.y: Likewise. ++ ++Fri Aug 18 17:31:58 1995 Jason Merrill ++ ++ * decl.c (start_function): Clear ctor_label and dtor_label. ++ ++ * class.c (finish_struct_1): Fix handling of access decls. ++ ++Tue Aug 15 19:21:54 1995 Jason Merrill ++ ++ * class.c (finish_struct): Only do minimal processing here, so it ++ can be used for class template definitions, as well. ++ (finish_struct_1): New function with the rest of the code. ++ ++Tue Aug 15 09:46:16 1995 Mike Stump ++ ++ * class.c (prepare_fresh_vtable): On second though, always build the ++ offset (see Aug 10 change), unless -fvtable-thunks is given. It ++ does this by calling the new routine set_rtti_entry. ++ (finish_struct): Likewise. ++ (set_rtti_entry): New routine to update the rtti information at the ++ start of the vtable. ++ ++Mon Aug 14 12:21:22 1995 Brendan Kehoe ++ ++ * error.c (dump_decl, case IDENTIFIER_NODE): Only work on a dtor ++ if it's declared in the C++ language spec. ++ (dump_function_decl): Likewise. ++ (dump_function_name): Likewise. ++ (ident_fndecl): Make sure we got something back from lookup_name. ++ * decl.c (start_function): Likewise. ++ ++Fri Aug 11 16:52:15 1995 Jason Merrill ++ ++ * call.c (build_method_call): Don't call build_new when calling a ++ constructor without an instance. ++ ++Thu Aug 10 20:00:17 1995 Mike Stump ++ ++ * class.c (prepare_fresh_vtable): Always build the offset to the ++ complete object, as it doesn't cost much. This allows dynamic_cast ++ to void * to work when -frtti isn't given. ++ (finish_struct): Likewise. ++ ++Thu Aug 10 16:31:28 1995 Mike Stump ++ ++ * except.c (build_eh_type): Split out some functionality to new ++ routine named build_eh_type_type. ++ (build_eh_type_type): New routine. ++ (expand_start_catch_block): Use build_eh_type_type, as we never want ++ the dynamic type of the catch parameter, just the static type. ++ Fixes core dumps when -frtti is used and one catchs pointers to ++ classes. ++ ++Thu Aug 10 14:55:29 1995 Mike Stump ++ ++ * except.c (expand_builtin_throw): Since we now use normal calling ++ conventions for __throw, we have to remove the first layer off the ++ stack, so that the next context we search for handlers is the outer ++ context instead of the context that had the call to __throw, if we ++ don't immediately find the desired context. ++ ++Tue Aug 8 17:44:23 1995 Jason Merrill ++ ++ * tree.c (cp_expand_decl_cleanup): Returns int, not tree. ++ * cp-tree.h: Update. ++ ++ * parse.y (template_type_parm): Add support for `typename'. ++ ++Tue Aug 8 12:06:31 1995 Mike Stump ++ ++ * except.c (expand_internal_throw): New internal routine to throw a ++ value. ++ (expand_end_all_catch, expand_leftover_cleanups): All throwers ++ changed to use `expand_internal_throw' instead of jumping to throw ++ label. ++ (expand_end_catch_block, expand_throw): Likewise. ++ (throw_label): Removed. ++ (expand_builtin_throw): Changed so that EH parameters are passed by ++ normal function call conventions. Completes Aug 4th work. ++ ++Fri Aug 4 17:17:08 1995 Mike Stump ++ ++ * cp-tree.h (expand_builtin_throw): Declare it. ++ * decl2.c (finish_file): Call expand_builtin_throw. ++ * except.c (make_first_label): Remove. ++ (init_exception_processing): Don't use a LABEL_REF for throw_label, ++ instead use a SYMBOL_REF, this is so that we don't use LABEL_REFs in ++ other functions that don't really appear in those functions. This ++ solves a problem where cc1plus consumed exponential amounts of ++ memory when -Wall was used. ++ (expand_end_all_catch, expand_leftover_cleanups, ++ expand_end_catch_block, expand_throw): Change all uses of ++ throw_label to match new style. ++ (do_unwind): Rename parameter to inner_throw_label, as it is now ++ different from throw_label. Also, assume that our caller will wrap ++ the passed label with a LABEL_REF, if needed. ++ (expand_builtin_throw): Make external, change so that the generated ++ throw is now a real function. ++ (expand_exception_blocks): Never generate throw code inside another ++ function. ++ ++Fri Aug 4 12:20:02 1995 Mike Stump ++ ++ * decl.c (grokdeclarator): Move checking of mutable const objects ++ and mutable static objects down, as we might decide during parsing ++ to unset staticp or constp (for example, when const is part of the ++ object being pointed to). ++ ++Thu Aug 3 17:13:43 1995 Mike Stump ++ ++ * except.c (output_exception_table_entry): Enhance portability to ++ weird machines. ++ (emit_exception_table): Likewise. ++ ++Thu Aug 3 16:41:38 1995 Mike Stump ++ ++ * typeck.c (build_ptrmemfunc): Handle casting of pointer to ++ non-virtual member functions. ++ ++Wed Aug 2 11:58:25 1995 Mike Stump ++ ++ * gc.c (build_typeid): Strip cv qualifiers so that const T&, T&, T ++ and const T all match. ++ ++Wed Aug 2 11:25:33 1995 Mike Stump ++ ++ * except.c (build_eh_type): Strip cv qualifiers so that const T&, ++ T&, T and const T all match. ++ ++Tue Aug 1 14:20:16 1995 Mike Stump ++ ++ * except.c: Fix up comments, cleanup code and eliminate exceptNode, ++ exceptStack, exceptstack, push_except_stmts, pop_except_stmts, ++ new_except_stack, push_last_insn, pop_last_insn, insn_save_node and ++ InsnSave. Also, numerous speed improvements, and correctness ++ improvements. Double faulting in all situations should now be ++ handled correctly. ++ (expand_start_all_catch): Instead of having many terminate protected ++ regions, just have one. ++ (expand_start_catch_block): No longer have to protect ++ false_label_rtx, as it isn't used for EH region marking. ++ (expand_end_catch_block): Expand out EH cleanups here by using ++ expand_leftover_cleanups. ++ (expand_end_all_catch): Use sequences instead of playing with insn ++ links directly. ++ (expand_exception_blocks): Likewise. Also protect all catch clauses ++ with one terminate region. ++ ++Mon Jul 31 13:24:30 1995 Jason Merrill ++ ++ * method.c (report_type_mismatch): Don't talk about an object ++ parameter for non-methods. ++ ++Sun Jul 30 13:13:02 1995 Jason Merrill ++ ++ * class.c (finish_struct): Catch private and protected members of ++ anonymous unions here. ++ * decl2.c (finish_anon_union): And here. ++ * parse.y: Instead of here. ++ ++ * errfn.c (ARGSLIST): Support passing four args. ++ * error.c (cv_as_string): New function. ++ (cp_printers): Add it. ++ * call.c (build_method_call): Report 'const' at end of pseudo-decl. ++ ++ * method.c (report_type_mismatch): Deal with a bad_arg of 0. ++ ++ * init.c (expand_aggr_init): Handle volatile objects, too. ++ ++Sat Jul 29 13:42:03 1995 Jason Merrill ++ ++ * decl.c (struct binding_level): Keep list of incomplete decls. ++ (print_binding_level): Use list_length to count them. ++ (pushdecl): Build up the list. ++ (hack_incomplete_structures): Walk it and prune completed decls. ++ ++Fri Jul 28 15:26:44 1995 Jason Merrill ++ ++ * typeck.c (comp_target_types): Don't check const and volatile for ++ function types. ++ (comp_ptr_ttypes_real): Likewise. ++ ++Thu Jul 27 15:40:48 1995 Jason Merrill ++ ++ * typeck.c (comp_target_types): Fix. ++ ++Thu Jul 27 15:10:48 1995 Mike Stump ++ ++ * cp-tree.h (unsave_expr_now, build_unsave_expr, ++ cp_expand_decl_cleanup): Declare new routines. ++ * decl.c (cp_finish_decl, store_parm_decls, ++ hack_incomplete_structures): Change all cals from ++ expand_decl_cleanup to cp_expand_decl_cleanup. ++ * gc.c (protect_value_from_gc): Likewise. ++ * expr.c (cplus_expand_expr): Handle UNSAVE_EXPRs. ++ * tree.c (unsave_expr): New routine to build an UNSAVE_EXPR. ++ (unsave_expr_now): Backend routine used by tree expander. ++ (cp_expand_decl_cleanup): Wrap second argument in an UNSAVE_EXPR to ++ work around a limitation in the backend. The backend uses the ++ cleanups multiple times, on disjoint control flows, so we cannot ++ pass unsaved SAVE_EXPRs to the backend. ++ * tree.def (UNSAVE_EXPR): New tree code. ++ * typeck.c (c_expand_return): Move goto/return code up inside ++ conditional, as we don't always want to do this, we only want to do ++ this when we don't otherwise finish with this control flow. ++ ++Thu Jul 27 10:38:43 1995 Brendan Kehoe ++ ++ * parse.y (typespec): Only complain about typeof if we're not ++ getting it from a system header. ++ ++Thu Jul 27 10:26:23 1995 Doug Evans ++ ++ Clean up prefix attribute handling. ++ * parse.y (reserved_declspecs): Link prefix attributes with declspecs. ++ (declmods): Likewise. ++ (all rules that reference typed_declspecs and declmods): Call ++ split_specs_attrs or strip_attrs to separate declspecs and attrs. ++ (lang_extdef): Delete resetting of prefix_attributes. ++ (template_def, notype_declarator rule): Use NULL_TREE for ++ prefix_attributes. ++ (condition): Use NULL_TREE for prefix_attributes. ++ (setattrs): Deleted. ++ (nomods_initdcl0): Set prefix_attributes to NULL_TREE. ++ (component_decl): Delete resetting of prefix_attributes. ++ (component_decl_1, notype_components rule): Use NULL_TREE for ++ prefix_attributes. ++ (simple_stmt): Delete resetting of prefix_attributes. ++ ++Mon Jul 24 13:37:53 1995 Jason Merrill ++ ++ * call.c (convert_harshness): Deal with reference conversions before ++ others. Actually do array->pointer decay. Call comp_target_types ++ with pointer types rather than their targets. ++ ++ * typeck.c (comp_target_types): Avoid assigning D const * to B *. ++ ++Mon Jul 24 08:54:46 1995 Brendan Kehoe ++ ++ * pt.c (to_be_restored): Move decl to global scope. ++ ++Sat Jul 22 12:22:11 1995 Jason Merrill ++ ++ * decl.c (start_decl): Put back clearing of DECL_IN_AGGR_P. ++ ++Fri Jul 21 17:09:02 1995 Jason Merrill ++ ++ * decl.c (grokdeclarator): Downgrade error about 'extern int A::i' ++ to pedwarn. ++ ++ * pt.c (instantiate_template): Also avoid instantiation if the ++ function has already been declared to be a specialization. ++ ++ * decl2.c (check_classfn): Ignore cname argument, and return the ++ matching function. ++ ++ * decl.c (start_decl): Handle declarations of member functions ++ outside of the class (i.e. specialization declarations). ++ ++Thu Jul 20 10:34:48 1995 Jason Merrill ++ ++ * class.c (finish_struct): Don't mess with the type of bitfields. ++ ++ * various.c: s/TYPE_POINTER_TO/build_pointer_type/. ++ ++Thu Jul 20 01:43:10 1995 Mike Stump ++ ++ * init.c (expand_aggr_init): Assume LOOKUP_ONLYCONVERTING if init ++ is not a parameter list (TREE_LIST). ++ (expand_default_init): If LOOKUP_ONLYCONVERTING is set, then set ++ LOOKUP_NO_CONVERSION so that we don't allow two-level conversions, ++ but don't set it otherwise. ++ ++Wed Jul 19 20:32:01 1995 Mike Stump ++ ++ * init.c (expand_default_init): Don't allow two-level conversions ++ during construction. ++ ++Wed Jul 19 18:06:37 1995 Mike Stump ++ ++ * gc.c (build_headof): The type of dyncasting to a pointer to cv ++ void, should be pointer to cv void. ++ ++Wed Jul 19 17:25:43 1995 Mike Stump ++ ++ * gc.c (build_dynamic_cast): Allow casting in const. ++ ++Wed Jul 19 16:34:27 1995 Mike Stump ++ ++ * typeck.c (build_const_cast): If we are passed error_mark_node, ++ return it. ++ ++Wed Jul 19 15:24:48 1995 Brendan Kehoe ++ ++ * class.c (push_nested_class): Make sure TYPE is non-nil. ++ ++ * cvt.c (type_promotes_to): Watch for error_mark_node on the ++ incoming TYPE. ++ ++Wed Jul 19 13:23:12 1995 Gerald Baumgartner ++ ++ * cp-tree.h (SIGTABLE_VT_OFF_NAME): Renamed from SIGTABLE_OFFSET_NAME. ++ (SIGTABLE_VB_OFF_NAME): New macro. ++ (vt_off_identifier): Renamed from offset_identifier. ++ (vb_off_identifier): Added extern declaration. ++ ++ * decl.c (vt_off_identifier): Renamed from offset identifier. ++ (vb_off_identifier): New variable to hold the identifier for the ++ sigtable field vb_off. ++ (init_decl_processing): Initialize vb_off_identifier. ++ Renamed vt_off_identifier from offset_identifier. ++ * sig.c (build_signature_method_call): Renamed offset_identifier and ++ local variable offset to vt_off_identifier and vt_off, respectively. ++ * sig.c (build_signature_table_constructor): Renamed offset to vt_off. ++ ++ * decl.c (init_decl_processing): Add vb_off field to ++ sigtable_entry_type. Reorder fields so that pfn gets properly ++ aligned at a 64 bit boundary on the Alpha. ++ * sig.c (build_signature_table_constructor): Build the constructor ++ according to the new layout. Set the vb_off field to -1 for now. ++ ++ * decl.c (init_decl_processing): Align sigtable_entry_type on word ++ boundaries instead of double word boundaries to save space. ++ ++Tue Jul 18 16:58:37 1995 Mike Stump ++ ++ * cvt.c (cp_convert): Always call build_cplus_new for a ctor. ++ ++Tue Jul 18 14:24:53 1995 Brendan Kehoe ++ ++ * parse.y (opt.component_decl_list): Only forbid private/protected ++ in anonymous unions. We need to make this know when the type is ++ defined for an object, to not give the error. ++ ++Mon Jul 17 14:22:44 1995 Brendan Kehoe ++ ++ * parse.y (opt.component_decl_list): Don't allow access control ++ as private or protected for union members. ++ ++Sun Jul 16 14:01:00 1995 Jim Wilson ++ ++ * lex.c (check_newline): For 'p' case, move goto skipline line to ++ before end brace for 'pragma'. ++ ++Fri Jul 7 13:55:58 1995 Mike Stump ++ ++ * g++.1: Tiny updates. ++ ++Fri Jul 7 13:05:20 1995 Mike Stump ++ ++ * decl.c (cp_finish_decl): Only destruct local static variables if ++ they are constructed, and only construct the first time control ++ passes completely through its declaration (if not initialized with a ++ constant-expression). ++ (expand_static_init): Likewise. ++ ++Wed Jul 5 14:05:04 1995 Brendan Kehoe ++ ++ * typeck.c (comptypes, case OFFSET_REF): If either offset basetype ++ is a TEMPLATE_TYPE_PARM, give a match. ++ ++Fri Jun 30 15:42:57 1995 Mike Stump ++ ++ * method.c (build_overload_value): Handle encoding of null pointer ++ constants (or any pointer with a constant numeric value) for ++ templates. ++ ++Fri Jun 30 13:45:51 1995 Brendan Kehoe ++ ++ * call.c (convert_harshness): Add QUAL_CODE when we're faced with ++ const vs non-const for void conversions. ++ ++Fri Jun 30 10:19:52 1995 Mike Stump ++ ++ * except.c (expand_start_all_catch): Fix problem with finding an ++ outer nested try block when there is no code to separate it from an ++ inner try block. ++ ++Fri Jun 30 02:22:26 1995 Mike Stump ++ ++ * search.c (dfs_pushdecls): Consume 2 or 3 orders of magnitude less ++ memory please when virtual bases are used. ++ ++Thu Jun 29 19:03:47 1995 Mike Stump ++ ++ * class.c (build_vbase_path): Avoid testing things that cannot be ++ null to see if they are null. ++ * cvt.c (convert_pointer_to_vbase): Remove code that doesn't work. ++ * decl.c (finish_function): Pass a type into the new ++ convert_pointer_to_vbase instead of a binfo. ++ * search.c (convert_pointer_to_vbase): Rewritten to use get_vbase ++ and convert_pointer_to_real. ++ (expand_indirect_vtbls_init): Use convert_pointer_to_vbase instead ++ of the more cryptic call to get_vbase. ++ ++Thu Jun 29 09:35:05 1995 Mike Stump ++ ++ * decl.c (BOOL_TYPE_SIZE): Fix broken SLOW_BYTE_ACCESS check. ++ ++Thu Jun 29 03:43:55 1995 Jason Merrill ++ ++ * pt.c (instantiate_template): Don't strip 'this' twice. ++ ++ * pt.c (coerce_template_parms): Allow null pointer constants. ++ ++ * decl.c (revert_static_member_fn): But only if DECL_ARGUMENTS is ++ set. ++ ++Wed Jun 28 18:39:03 1995 Jason Merrill ++ ++ * decl.c (revert_static_member_fn): Also remove 'this' from ++ DECL_ARGUMENTS. ++ * decl2.c (check_classfn): Don't revert this function until we get a ++ match. ++ ++Wed Jun 28 14:07:27 1995 Brendan Kehoe ++ ++ * parse.y (component_decl): Clear PREFIX_ATTRIBUTES here. ++ ++Wed Jun 28 11:05:13 1995 Mike Stump ++ ++ * decl2.c (finish_file): Handle global vector news. ++ * init.c (build_new): Encode vector news so that later we will know ++ how many elements there are. ++ ++Mon Jun 26 13:38:06 1995 Jason Merrill ++ ++ * expr.c (cplus_expand_expr): Don't mess with temp slots. ++ ++ * decl2.c (warn_if_unknown_interface): Don't crash if tinst_for_decl ++ returns null. ++ ++ * decl2.c (check_classfn): Use revert_static_member_fn. ++ * decl.c (revert_static_member_fn): Diagnose static member functions ++ declared const or volatile. ++ ++ * decl2.c (grokfield): Check for missing default args here, too. ++ (check_default_args): Function to do the checking. ++ * decl.c (pushdecl): Use it. ++ ++ * decl.c (pushdecl): Don't warn about shadowing a member of `this' ++ if there is no `this'. ++ ++Sun Jun 25 11:34:25 1995 Jason Merrill ++ ++ * call.c (build_method_call): Downgrade 'called before definition' ++ to a warning, as it ought to go away after Monterey. ++ ++Sat Jun 24 14:18:42 1995 Jason Merrill ++ ++ * pt.c (coerce_template_parms): Don't do extra checking on pointer ++ to member arguments. ++ ++ * class.c (finish_struct): const and reference members don't prevent ++ a class from being an aggregate. ++ ++ * class.c (finish_struct): Signatures are always aggregates. ++ ++Fri Jun 23 17:20:29 1995 Jason Merrill ++ ++ * decl2.c (check_classfn): Improve error message. ++ ++ * pt.c (tsubst): Handle PROMOTE_PROTOTYPES. ++ ++Thu Jun 22 01:50:42 1995 Jason Merrill ++ ++ * typeck.c (comptypes): Don't ignore method quals. ++ ++ * class.c (finish_struct): Non-abstract virtuals are always USED. ++ ++ * decl.c (build_ptrmemfunc_type): The underlying union type isn't ++ IS_AGGR_TYPE, either. ++ * class.c (finish_struct): Use CLASSTYPE_NON_AGGREGATE instead. ++ * cp-tree.h: Likewise. ++ ++ * cp-tree.h (lang_type): Add aggregate. ++ (CLASSTYPE_AGGREGATE): New macro. ++ (TYPE_NON_AGGREGATE_CLASS): Likewise. ++ * class.c (finish_struct): Determine whether a class is an ++ aggregate. ++ * decl.c (cp_finish_decl): Check TYPE_NON_AGGREGATE_CLASS instead of ++ TYPE_NEEDS_CONSTRUCTING. ++ * typeck2.c (digest_init): Check TYPE_NON_AGGREGATE_CLASS for ++ subobjects, too. ++ ++ * pt.c (tsubst, PARM_TYPE): Propagate DECL_ARTIFICIAL. ++ ++ * decl.c (start_function): For pre-parsed functions, layout all of ++ the parm decls again. ++ (grokvardecl): TREE_PUBLIC depends on DECL_THIS_EXTERN, not ++ DECL_EXTERNAL. ++ ++ * pt.c (coerce_template_parms): Improve checking for invalid ++ template parms. ++ ++Wed Jun 21 12:01:16 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Forbid declaration of a static member ++ with the same name as its enclosing class. ++ ++Mon Jun 19 10:28:14 1995 Jason Merrill ++ ++ * decl.c (finish_function): Clear current_class_decl. ++ ++ * typeck.c (build_conditional_expr): Use convert (boolean_type_node ++ instead of truthvalue_conversion. ++ ++ * class.c (finish_struct): A data member with the same name as the ++ class doesn't suppress constructors. ++ ++Fri Jun 16 18:11:39 1995 Gerald Baumgartner ++ ++ * decl.c (start_function): If current_class_decl is a signature ++ pointer, don't dereference it but set C_C_D to current_class_decl. ++ ++Fri Jun 16 17:06:28 1995 Jason Merrill ++ ++ * decl.c (duplicate_decls): Complain about virtual functions ++ redeclared to be inline. ++ ++Fri Jun 16 13:20:38 1995 Mike Stump ++ ++ * decl.c (get_unique_name): New routine to name unnamed namespaces. ++ (push_namespace): Use get_unique_name for naming unnamed namespaces. ++ ++Thu Jun 15 15:00:41 1995 Jason Merrill ++ ++ * parse.y: Call cplus_decl_attributes with prefix_attributes where ++ appropriate. ++ ++Wed Jun 14 19:24:49 1995 Mike Stump ++ ++ * search.c (get_vbase): New routine to switch hierarchies from the ++ CLASSTYPE_VBASECLASSES to the normal one. ++ (expand_indirect_vtbls_init): Use get_vbase to figure out how we ++ want to convert to a vbase pointer. ++ ++Mon Jun 12 17:50:30 1995 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Add the new instantiation to ++ template_classes. ++ (do_pending_expansions): Call instantiate_member_templates on all of ++ the classes in template_classes. ++ ++Mon Jun 12 12:36:59 1995 Mike Stump ++ ++ * decl.c (complete_array_type): Fill in the TYPE_DOMAIN of our ++ TYPE_MAIN_VARIANT if it is not filled in. ++ * init.c (build_delete): If the TYPE_DOMAIN is not set, give an ++ error instead of core dumping. ++ ++Mon Jun 12 10:41:40 1995 Jason Merrill ++ ++ * call.c (can_convert): Also check for distance > 0. ++ (can_convert_arg): Likewise. ++ (user_harshness): Likewise. ++ ++Fri Jun 9 19:17:21 1995 Jason Merrill ++ ++ * g++.c (MATH_LIBRARY): Provide default. ++ (main): Always link with the math library if we link with libstdc++. ++ ++ * decl.c (start_function): Complain about redefinition of a function ++ even when the pending_inline version is compiled after the other ++ version. ++ ++Thu Jun 8 15:44:38 1995 Jason Merrill ++ ++ * gc.c (build_dynamic_cast): Build up a reference to a parameter of ++ aggregate type. ++ ++Wed Jun 7 15:31:57 1995 Brendan Kehoe ++ ++ * init.c (build_vec_delete): Resolve an offset ref before we try to ++ use it. ++ ++Wed Jun 7 14:19:32 1995 Jason Merrill ++ ++ * typeck.c (build_modify_expr): If the class lacks a constructor or ++ assignment operator, return error_mark_node. ++ (common_type): Use build_cplus_array_type. ++ ++Tue Jun 6 09:41:27 1995 Mike Stump ++ ++ * class.c (dont_allow_type_definitions): New variable set when types ++ cannot be defined. ++ (finish_struct): Use it. ++ * cp-tree.h (dont_allow_type_definitions): Define it. ++ * parse.y (primary, handler_seq): Set it. ++ ++Mon Jun 5 18:49:38 1995 Mike Stump ++ ++ * method.c (build_opfncall): Use DECL_CHAIN, not TREE_CHAIN for ++ results from lookup_fnfields. Always give warning/error on bad ++ code. ++ ++Mon Jun 5 11:39:37 1995 Brendan Kehoe ++ ++ * init.c (member_init_ok_or_else): Don't allow initialization of ++ an ancestor's member from within a constructor. ++ ++Mon Jun 5 11:20:34 1995 Gerald Baumgartner ++ ++ * sig.c (build_signature_table_constructor): Use DECL_CONTEXT ++ instead of DECL_CLASS_CONTEXT for calculating the vfield offset so ++ abstract virtual functions are handled correctly. ++ ++ * sig.c (build_signature_table_constructor): Store the correct ++ delta in signature table entries. It does not yet work for ++ classes with virtual base classes as implementations of signatures. ++ (build_signature_method_call): Add the delta to the object_ptr ++ before generating the function call. ++ ++ * call.c (build_method_call): Make instance_ptr the signature ++ pointer itself instead of dereferencing the optr. ++ * sig.c (build_signature_method_call): Dereference the optr for the ++ direct and virtual calls. ++ ++ * sig.c (build_signature_table_constructor): Make the tag for ++ default implementations -1 instead of 2. ++ (build_signature_method_call): Change the generated conditional ++ expression correspondingly. ++ ++ * sig.c (build_signature_pointer_constructor): Deleted the sorry ++ message that said we can't handle multiple inheritance for ++ implementations of signatures ++ (build_signature_method_call): Use the offset from the sigtable ++ entry instead of the vptr field from the signature pointer for ++ building a virtual function call. ++ ++ * class.c (build_vfn_ref): Deleted signature specific code, we don't ++ call this function anymore from build_signature_method_call. ++ ++ * cp-tree.h (SIGNATURE_VPTR_NAME): Deleted. We use the right vptr ++ field in the object now instead of in the signature pointer/ref. ++ (build_vptr_ref): Deleted extern declaration. ++ * sig.c (build_vptr_ref): Deleted. ++ (build_signature_pointer_or_reference_type): Deleted construction of ++ the vptr field. ++ (build_signature_pointer_constructor): Deleted initialization of/ ++ assignment to the vptr field. ++ ++ * sig.c (build_signature_table_constructor): Convert the signature ++ table entry fields to their correct types. ++ ++ * sig.c (build_signature_table_constructor): Don't call digest_init ++ for the fields of a sigtable entry, it's wasted time. ++ ++ * sig.c (build_signature_table_constructor): Correctly set the ++ offset and index fields of a sigtable entry. Build the constructor ++ the way digest_init does, digest_init can't handle initializing an ++ anonymous union inside a struct. ++ (build_signature_method_call): Use the index field instead of the ++ delta field to get the vtable index. ++ ++ * decl.c (init_decl_processing): Fix number of fields for building ++ sigtable_entry_type. ++ ++ * cp-tree.h (tag_identifier, offset_identifier): Added extern decls. ++ (SIGTABLE_CODE_NAME): Renamed to SIGTABLE_TAG_NAME. ++ (SIGTABLE_PFN_NAME): Deleted, we'll use VTABLE_PFN_NAME instead. ++ * decl.c (tag_identifier, offset_identifier): New variables to ++ hold the identifiers for the sigtable fields tag and offset. ++ (init_decl_processing): Initialize these variables. ++ (init_decl_processing): Use these variables to build the ++ sigtable_entry_type structure. Rename the code and offset fields ++ to tag and delta, respectively; add offset and index fields. Changed ++ types of fields from short_integer_type_node to delta_type_node. ++ * sig.c (build_signature_table_constructor): Rename code and offset ++ to tag and delta, respectively. ++ (build_signature_method_call): Likewise. Use above variables. ++ ++Thu Jun 1 17:03:51 1995 Jason Merrill ++ ++ * decl.c (lookup_name_real): Don't try to look anything up in an ++ erroneous object. ++ ++Fri Jun 2 10:30:14 1995 Mike Stump ++ ++ * method.c (build_overload_int): New routine. Break out ++ functionality from build_overload_value so we can reuse it. ++ (build_overload_value): Handle pointer to member functions as value ++ parameters for templates. ++ (build_overload_identifier): Since template parameters are shared ++ among all instantiations, we have to substitute in the real types ++ in TREE_TYPE (parm). ++ pt.c (coerce_template_parms): Likewise. ++ (push_template_decls): Likewise. ++ (grok_template_type): Deleted as template parameters are shared ++ among all instantiations. ++ ++Wed May 31 19:10:32 1995 Mike Stump ++ ++ * decl.c (grokdeclarator): Always give errors on constant overflow ++ for array indices. ++ ++Wed May 31 11:39:43 1995 Jason Merrill ++ ++ * typeck.c (commonparms): Don't abort if simple_cst_equal returns < 0. ++ (build_c_cast): Don't tack on a NON_LVALUE_EXPR when casting to ++ reference type. ++ (build_indirect_ref): Fix check for *&. ++ ++Fri Jun 16 06:54:03 1995 Mike Stump ++ ++ * Version 2.7.0 released. ++ ++Fri Jun 16 15:07:29 1995 Richard Kenner ++ ++ * Make-lang.in (DEMANGLER_PROG): Add LIBS. ++ ++Thu Jun 15 15:00:41 1995 Jason Merrill ++ ++ * decl.c (define_function): Don't set DECL_INTERFACE_KNOWN. ++ ++Wed Jun 7 20:00:31 1995 Mike Stump ++ ++ * *.[chy]: Change all callers of finish_decl to cp_finish_decl. ++ * decl.c (finish_decl): New routine to handle call backs from the ++ mid end (declare_hidden_char_array). ++ ++Wed Jun 7 19:02:50 1995 Jason Merrill ++ ++ * decl.c (start_function): Handle setting C_C_D here. ++ (set_C_C_D): Removed. ++ (struct saved_scope): Remove class_decl. ++ (push_to_top_level): Don't save current_class_decl. ++ (pop_from_top_level): Don't restore current_class_decl or C_C_D. ++ (struct cp_function): Add C_C_D. ++ (push_cp_function_context): Save C_C_D. ++ (pop_cp_function_context): Restore C_C_D. ++ ++Fri Jun 2 11:05:58 1995 Jason Merrill ++ ++ * decl.c (set_C_C_D): New function. suspend_momentary before ++ building C_C_D. ++ (pop_from_top_level): Call it. ++ (start_function): Likewise. ++ (pop_cp_function_context): Likewise. ++ ++ * class.c, cp-tree.h, decl.c, decl2.c, parse.y: Lose all references ++ to current_vtable_decl, CLASSTYPE_INST_VAR and CLASSTYPE_VTBL_PTR. ++ ++ * decl.c (push_cp_function_context): Save current_class_decl. ++ (pop_cp_function_context): Restore current_class_decl and set C_C_D. ++ (pop_from_top_level): Don't use CLASSTYPE_INST_VAR to set C_C_D. ++ (start_function): Likewise. ++ ++ * class.c (popclass): Don't mess with current_class_decl, ++ current_vtable_decl, or C_C_D. ++ ++Mon May 29 12:45:10 1995 Paul Eggert ++ ++ * Make-lang.in (c++.mostlyclean): Remove $(DEMANGLER_PROG). ++ ++Wed May 24 15:55:18 1995 Richard Kenner ++ ++ * decl.c (duplicate_decls): Check simple_cst_equal result against 0. ++ * decl2.c (finish_anon_union): Likewise. ++ * method.c (largest_union_member): Likewise. ++ ++Wed May 24 14:41:11 1995 H.J. Lu ++ ++ * Make-lang.in (cxxmain.o): Replace single quotes with backslashes. ++ ++Mon May 22 17:38:48 1995 Richard Kenner ++ ++ * Make-lang.in (g++, g++-cross, cc1plus, DEMANGLER_PROG): ++ Use $@ instead of output name so works even if have .exe. ++ (cxxmain.o): Use cp if ln -s fails. ++ (c++.install-man): Use $(exeext) in executable names. ++ (c++.mostlyclean, stage[1-4]): Use $(objext) in object file names. ++ * Makefile.in (../cc1plus): Use $(exeext) in name of executable. ++ ++Wed May 24 01:39:03 1995 Jason Merrill ++ ++ * call.c (build_method_call): Parms can be null, duh. ++ ++Tue May 23 01:32:09 1995 Jason Merrill ++ ++ * call.c (build_method_call): If convert_arguments failed, just bail. ++ ++Fri May 19 10:31:11 1995 Jason Merrill ++ ++ * cvt.c (convert_force): Pass LOOKUP_NORMAL to cp_convert. ++ ++ * tree.c (copy_to_permanent): Oops. ++ ++Fri May 19 10:01:07 1995 Brendan Kehoe ++ ++ * cp-tree.h (break_out_target_exprs): Add decl. ++ ++Thu May 18 13:02:30 1995 Jason Merrill ++ ++ * decl.c (start_function): Move *all* interface handling stuff after ++ the pushdecl. ++ ++ * tree.c (mapcar): Renamed from make_deep_copy and generalized. ++ (perm_manip): Return t if permanent, otherwise 0. ++ (copy_to_permanent): Use them. ++ (bot_manip): Helper for break_out_target_exprs. ++ (break_out_target_exprs): New function. Uses mapcar. ++ ++ * typeck.c (convert_arguments): Use it. ++ ++ * method.c (hack_identifier): Use convert_from_reference to ++ dereference a reference. ++ ++Wed May 17 17:54:54 1995 Mike Stump ++ ++ * call.c (convert_harshness): Move reference bashing before pointer ++ to member bashing. ++ ++Wed May 17 16:57:53 1995 Mike Stump ++ ++ * cvt.c (convert_to_reference): Only complain, if complaints are ++ wanted. ++ * typeck.c (build_function_call_real): Likewise. If ++ LOOKUP_SPECULATIVELY is set and something won't work, return ++ NULL_TREE. ++ * cvt.c (cp_convert): Likewise. Pass flags down to build_method_call. ++ (convert): Pass LOOKUP_NORMAL to cp_convert. ++ * typeck.c (convert_for_assignment): Likewise. ++ (convert_force): Pass LOOKUP_COMPLAIN to cp_convert. ++ (convert_arguments): Get out early if we get an error_mark_node. ++ (convert_for_initialization): Use cp_convert instead of convert so ++ that we can pass flags down. ++ * cp-tree.h (LOOKUP_SPECULATIVELY): Added documentation. ++ ++Wed May 17 01:43:58 1995 Jason Merrill ++ ++ * typeck2.c (store_init_value): Don't take the MAIN_VARIANT of the ++ decl type. ++ ++ * class.c (finish_struct): Don't complain about a class with no ++ user-defined constructors but with a member that has no default ++ constructor, as this is OK for aggregates. ++ ++ * expr.c (cplus_expand_expr, NEW_EXPR): If this is an explicit ++ constructor call, mark slot addressable. ++ ++Tue May 16 18:37:51 1995 Douglas Rupp ++ ++ * g++.c: Changed WINNT to _WIN32. ++ ++Tue May 16 12:40:16 1995 Jason Merrill ++ ++ * lex.c (handle_sysv_pragma): Don't use token_buffer. ++ ++Tue May 16 12:05:26 1995 Mike Stump ++ ++ * call.c (resolve_scope_to_name): Add initial semantic support for ++ namespaces. ++ * class.c (finish_struct): Likewise. ++ * cp-tree.h (NAMESPACE_LEVEL): Likewise. ++ * cvt.c (build_up_reference, convert_to_reference): Likewise. ++ * decl.c (binding_level::namespace_p, suspend_binding_level): Likewise. ++ (resume_binding_level, toplevel_bindings_p): Likewise ++ (namespace_bindings_p, declare_namespace_level): Likewise. ++ (resume_level, push_namespace, pop_namespace): Likewise. ++ (pop_everything, pushtag, duplicate_decls, pushdecl): Likewise. ++ (implicitly_declare, lookup_namespace_name): Likewise. ++ (lookup_name_real, start_decl, make_temporary_for_reference): Likewise. ++ (obscure_complex_init, finish_decl, expand_static_init): Likewise. ++ (grokvardecl, grokdeclarator, parmlist_is_exprlist): Likewise. ++ (store_parm_decls, hack_incomplete_structures): Likewise. ++ * decl2.c (get_temp_name, finish_anon_union): Likewise. ++ (current_namespace, push_namespace, pop_namespace): Likewise. ++ (do_namespace_alias, do_toplevel_using_decl): Likewise. ++ (do_class_using_decl): Likewise. ++ * error.c (dump_decl): Likewise. ++ * init.c (build_member_call, build_offset_ref): Likewise. ++ * lex.c (identifier_type): Likewise. ++ * parse.y (lang_extdef, using_decl, extdef): Likewise. ++ (component_decl_1, nested_name_specifier_1): Likewise. ++ * spew.c (yylex): Likewise. ++ * tree.def (NAMESPACE_DECL): Likewise. ++ ++Tue May 16 11:55:35 1995 Jason Merrill ++ ++ * decl.c (push_overloaded_decl): Return the new decl even if it ++ can't be pushed. ++ ++Tue May 16 11:00:37 1995 Jason Merrill ++ ++ * typeck.c (decay_conversion): Split out from default_conversion. ++ (default_conversion): Call it. ++ (build_binary_op): Likewise. ++ (build_binary_op_nodefault): Use decay_conversion for truth ops. ++ ++Mon May 15 12:47:56 1995 Jason Merrill ++ ++ * decl.c (warn_extern_redeclared_static): This is a pedwarn. ++ (duplicate_decls): Always use the old decl's linkage info. Don't ++ play with linkage of consts. ++ (pushdecl): Don't play with linkage of consts. ++ (redeclaration_error_message): Don't complain about an old public ++ decl and a new non-public decl here. ++ (grokvardecl): Handle linkage of consts here. ++ (grokdeclarator): An 'extern inline' is public. Pass constp to ++ grokvardecl. ++ (start_function): Wait until after the pushdecl to do some linkage ++ stuff. ++ ++ * decl2.c (import_export_vtable): Make duplicates weak rather than ++ static if supported. ++ (import_export_inline): Likewise. ++ * pt.c (do_pending_expansions): Likewise. ++ ++ * class.c (build_vbase_path): flag_assume_nonnull_objects only ++ affects reference conversion. ++ ++ * init.c (emit_base_init): Build up an RTL_EXPR and add it to ++ rtl_expr_chain. ++ * decl.c, decl2.c: s/base_init_insns/base_init_expr/. ++ ++Tue May 16 07:06:28 1995 Paul Eggert ++ ++ * method.c (numeric_output_need_bar): Renamed from misspelling. ++ ++ * typeck.c (build_ptrmemfunc): Fix misspellings in messages. ++ ++Sun May 14 10:26:22 1995 Richard Kenner ++ ++ * lang-options.h, lang-specs.h: New files. ++ ++Thu May 11 00:31:48 1995 Jason Merrill ++ ++ * typeck.c (default_conversion): Don't check for BLKmode before ++ pulling out the decl_constant_value. ++ ++ * decl.c (start_function): Clear named_labels and shadowed_labels. ++ ++ * typeck.c (build_function_call_real): Also synthesize methods here. ++ ++Wed May 10 00:55:59 1995 Jason Merrill ++ ++ * decl2.c (finish_file): Synthesize exported methods before the ++ reconsider loop. ++ ++ * parse.y: Move declaration of flag_new_for_scope to file scope. ++ ++Tue May 9 19:10:33 1995 Mike Stump ++ ++ * decl2.c: Add flag_new_for_scope for new -ffor-scope flag. ++ * parse.y (FOR): Conditionalize the pushing and popping of scope for ++ the for-init-statement upon the new flag_new_for_scope. ++ * parse.y (try_block): Simplify and use compstmt. ++ ++Mon May 8 12:41:52 1995 Jason Merrill ++ ++ * decl.c (define_function): Mark function decl artificial. ++ ++Sun May 7 00:51:28 1995 Jason Merrill ++ ++ * parse.y (simple_stmt, FOR): Put back push/pop for condition scope. ++ ++ * decl2.c (grokclassfn): DECLs don't have cv-qualified types. ++ * tree.c (build_cplus_method_type): Likewise. ++ ++ * cp-tree.h (SET_DECL_ARTIFICIAL): Just set DECL_ARTIFICIAL to 1. ++ ++ * typeck.c (build_function_call_real): If convert_arguments failed, ++ just bail. ++ (convert_arguments): If one of the arguments is error_mark_node, ++ just bail. ++ ++Sat May 6 02:39:41 1995 Jason Merrill ++ ++ * decl.c (duplicate_decls): Don't check DECL_NOT_REALLY_EXTERN for ++ decls that don't include it. ++ ++Fri May 5 14:23:30 1995 Jason Merrill ++ ++ * decl.c (duplicate_decls): Decls that have DECL_INTERFACE_KNOWN or ++ DECL_NOT_REALLY_EXTERN set aren't extern decls. ++ ++ * typeck.c (build_indirect_ref): Don't call default_conversion for a ++ parameter of reference_type. ++ * cvt.c (convert_from_reference): Just use build_indirect_ref. ++ ++ * pt.c (do_type_instantiation): Only instantiate member functions ++ that actually come from templates. ++ ++Fri May 5 09:46:05 1995 Mike Stump ++ ++ * parse.y: Generalized cleanup of poplevels, and compound statements ++ and compound statements in try blocks. Rewritten `for' rule so that ++ the scope of variables declared in the for clause is shortened to ++ span just to the end of the statement, instead of the whole ++ containing block. ++ ++Fri May 5 00:37:14 1995 Jason Merrill ++ ++ * call.c (convert_harshness): Handle pointers to members better. ++ ++Thu May 4 16:00:26 1995 Jason Merrill ++ ++ * decl2.c (delete_sanity): Do access control here. ++ * init.c (build_delete): Instead of here. ++ ++ * Make-lang.in: Build c++filt. ++ ++Wed May 3 02:59:53 1995 Jason Merrill ++ ++ * decl2.c (cplus_decl_attributes): If we just modified a TYPE_DECL, ++ update our IDENTIFIER_TYPE_VALUE. ++ ++Fri Apr 28 07:58:41 1995 Jason Merrill ++ ++ * lex.c (cons_up_default_function): Fix linkage of #pragma ++ implemented functions. ++ ++Thu Apr 27 16:56:24 1995 Jason Merrill ++ ++ * method.c (build_overload_name): Simplify and fix repeated type ++ folding. ++ ++ * decl.c (grokdeclarator): Prohibit pointers to void or reference ++ members. ++ ++Thu Apr 27 09:49:07 1995 Mike Stump ++ ++ * typeck2.c (process_init_constructor): Make sure initializers are ++ fully digested. ++ ++Thu Apr 27 01:11:55 1995 Jason Merrill ++ ++ * lex.c (cons_up_default_function): Always defer synthesis. ++ ++Thu Apr 27 00:20:37 1995 Jason Merrill ++ ++ * decl2.c (mark_inline_for_output): Don't play with pending_inline ++ stuff. ++ ++Wed Apr 26 17:48:24 1995 Jason Merrill ++ ++ * call.c (user_harshness): New function; like build_type_conversion, ++ but doesn't actually build anything. ++ (compute_conversion_costs): Use it instead of build_type_conversion. ++ ++Wed Apr 26 17:11:25 1995 Jason Merrill ++ ++ * typeck.c (build_function_call_real): Improve error message for ++ calling a non-function. ++ ++ * method.c (hack_identifier): Lose check for calling a data member. ++ ++Wed Apr 26 16:59:13 1995 Mike Stump ++ ++ * typeck2.c (build_functional_cast): Remove very old cruft. ++ Seems like good code is generated without it. ++ ++Wed Apr 26 00:47:16 1995 Jason Merrill ++ ++ * method.c (do_build_assign_ref): Fix handling of anonymous unions. ++ (do_build_copy_constructor): Likewise. ++ ++ * parse.y (simple_stmt, SWITCH): Call {push,pop}_switch. ++ ++ * decl.c (push_switch): New function. ++ (pop_switch): Likewise. ++ (define_case_label): Check for jumping over initialization. ++ ++ * call.c (build_method_call): Check for an inline function being ++ called before its definition has been seen. ++ * typeck.c (build_function_call_real): Likewise. ++ ++ * decl.c (duplicate_decls): Check for a function being redeclared ++ inline after its address has been taken. ++ ++ * typeck.c (build_conditional_expr): Handle related class lvalues. ++ ++Tue Apr 25 13:20:45 1995 Jason Merrill ++ ++ * pt.c (do_pending_expansions): Don't expand unused templates. ++ ++ * parse.y (component_decl): Accept a lone semicolon. ++ ++Tue Apr 25 00:25:56 1995 Jason Merrill ++ ++ * call.c (build_method_call): Don't allow an RTL_EXPR to serve as the ++ object parameter anymore. ++ ++ * expr.c (cplus_expand_expr): Don't create RTL_EXPRs with no insns. ++ ++Mon Apr 24 12:35:48 1995 Jason Merrill ++ ++ * parse.y (simple_stmt, decl case): Clear prefix_attributes. ++ (lang_extdef): Likewise. ++ ++ * parse.y (maybe_parmlist): New rule for use in declarators where ++ this could either be a list of expressions or parameters. Calls ++ suspend_momentary before deciding which. ++ (direct_after_type_declarator): Use it. ++ (complex_direct_notype_declarator): Use it. ++ ++ * pt.c (tsubst): Propagate attributes const and noreturn. ++ ++ * typeck.c (build_modify_expr): If warn_synth, call build_opfncall ++ before doing the default thing. ++ ++Thu Apr 27 21:49:36 1995 Doug Evans ++ ++ * typeck.c (common_type): Call lookup_attribute instead of ++ value_member. ++ ++Tue Apr 25 18:07:43 1995 Richard Kenner ++ ++ * Make-lang.in: Change "realclean" to "maintainer-clean". ++ ++Sun Apr 23 12:32:38 1995 Mike Stump ++ ++ * decl2.c (finish_file): Fix broken linked list handling. ++ ++Fri Apr 21 18:08:43 1995 Jason Merrill ++ ++ * class.c (finish_base_struct): Don't set TYPE_HAS_COMPLEX_*_REF ++ as often. ++ (finish_struct): Likewise. ++ ++ * various: Use TYPE_HAS_TRIVIAL_* instead of TYPE_HAS_COMPLEX_*. ++ ++ * cp-tree.h (TYPE_HAS_TRIVIAL_INIT_REF): New macro. ++ (TYPE_HAS_TRIVIAL_ASSIGN_REF): New macro. ++ ++Fri Apr 21 15:52:22 1995 Jason Merrill ++ ++ * typeck.c (c_expand_return): Only expand a returned TARGET_EXPR if ++ it is of the same type as the return value. ++ ++Fri Apr 21 03:01:46 1995 Jason Merrill ++ ++ * decl2.c (finish_file): Reconsider if synthesizing a method wrote ++ out its assembly. ++ ++ * typeck.c (convert_for_initialization): Don't call a trivial copy ++ constructor. ++ ++ * typeck2.c (store_init_value): Only abort if the type has a ++ non-trivial copy constructor. ++ ++ * typeck.c (c_expand_return): If we're returning in a register and ++ the return value is a TARGET_EXPR, expand it. Only do ++ expand_aggr_init if we're returning in memory. ++ (expand_target_expr): Function to expand a TARGET_EXPR. ++ (build_modify_expr): Use it. ++ ++ * tree.c (build_cplus_new): Layout the slot. ++ ++ * expr.c (cplus_expand_expr): Use expand_call to expand the call ++ under a NEW_EXPR, so the target is not discarded. ++ ++Thu Apr 20 14:59:31 1995 Mike Stump ++ ++ * gc.c (build_dynamic_cast): Tighten error checking. ++ ++Thu Apr 20 11:23:54 1995 Jason Merrill ++ ++ * expr.c (cplus_expand_expr): Only abort if the returned target is ++ different from what we expected if the type has a non-trivial copy ++ constructor. ++ ++ * decl2.c (cplus_decl_attributes): Attributes applied to a template ++ really apply to the template's result. ++ ++ * tree.c (lvalue_p): Check IS_AGGR_TYPE instead of TREE_ADDRESSABLE ++ to decide whether to consider a CALL_EXPR an lvalue. ++ ++ * class.c (finish_struct_bits): Only set TREE_ADDRESSABLE if the ++ type has a non-trivial copy constructor. ++ ++ * decl.c (start_function): If interface_known, unset ++ DECL_NOT_REALLY_EXTERN on the function. ++ ++Wed Apr 19 16:53:13 1995 Jason Merrill ++ ++ * pt.c (do_function_instantiation): Handle explicit instantiation of ++ member functions. ++ (do_type_instantiation): Handle 'inline template class foo', ++ meaning just spit out the vtable. ++ ++ * lex.c (cons_up_default_function): Set DECL_NOT_REALLY_EXTERN on ++ the consed functions. ++ ++ * decl2.c (import_export_inline): Set DECL_INTERFACE_KNOWN. ++ ++Wed Apr 19 16:28:17 1995 Brendan Kehoe ++ ++ * call.c, class.c, decl2.c, gc.c, init.c, parse.y, pt.c, search.c, ++ typeck.c: Include output.h. ++ ++Wed Apr 19 14:57:21 1995 Gerald Baumgartner ++ ++ * call.c (build_method_call): Allow a signature member functions to ++ be called from a default implementation. ++ ++Wed Apr 19 10:21:17 1995 Jason Merrill ++ ++ * repo.c (finish_repo): Remember what directory we are in. ++ ++ * search.c (expand_upcast_fixups): Don't mess with abort_fndecl. ++ ++ * repo.c: Use obstacks instead of fixed-size buffers. Don't spit ++ out the second copy of the symbol name. Don't remember COLLECT_GCC. ++ ++Wed Apr 19 02:32:40 1995 Mike Stump ++ ++ * search.c (virtual_context): New function to get the virtual ++ context of a function. ++ (expand_upcast_fixups): New function to generate runtime vtables. ++ (fixup_virtual_upcast_offsets): Likewise. ++ (expand_indirect_vtbls_init): Use fixup_virtual_upcast_offsets to ++ ensure that the this offsets for upcasts from virtual bases into ++ other virtual bases or non-virtual bases are correct at construction ++ time and destruction time. ++ * class.c (fixup_vtable_deltas): Modify to fixup all offsets in all ++ vtables in all virtual bases, instead of just one vtable in each ++ virtual base. ++ (fixup_vtable_deltas1): Likewise. ++ ++Tue Apr 18 03:57:35 1995 Michael Meissner ++ ++ * Makefile.in (lex.o): Add dependency on c-pragma.h. ++ ++ * lex.c (handle_sysv_pragma): Use NULL_PTR and NULL_TREE as ++ appropriate, instead of 0. ++ ++Mon Apr 17 12:28:42 1995 Jason Merrill ++ ++ * decl.c (pushdecl): Use decls_match, not duplicate_decls, for ++ comparing local and global decls. ++ ++Fri Apr 14 01:46:52 1995 Jason Merrill ++ ++ * typeck.c (convert_arguments): Only prohibit passing to ... of ++ types with non-trivial copy constructors. ++ ++ * repo.c (repo_template_used): Don't try to mess with no id. ++ ++Fri Apr 14 23:32:50 1995 Per Bothner ++ ++ * decl.c (duplicate_decls): Use cp_warning_at for redundant-decls. ++ ++Thu Apr 13 15:37:42 1995 Brendan Kehoe ++ ++ * cp-tree.h (current_tinst_level): Delete declaration, since it's ++ static inside pt.c. ++ ++ * typeck.c (build_modify_expr): Catch incompatible array assignment. ++ ++ * parse.y (attribute_list, attrib): Rewrite actions to feed the ++ right stuff to decl_attributes. ++ ++Thu Apr 13 11:24:10 1995 Jason Merrill ++ ++ * search.c (dfs_debug_mark): Check for magic virtual like ++ import_export_vtable. ++ ++ * typeck.c (build_binary_op_nodefault): Don't call cp_pedwarn with ++ four args. ++ ++Wed Apr 12 12:02:57 1995 Jason Merrill ++ ++ * decl2.c (finish_file): Move prevtable pass before needs_messing_up ++ decision. ++ ++Tue Apr 11 11:20:27 1995 Jason Merrill ++ ++ * decl.c (finish_decl): If we're writing out a static data member of ++ a class, we want the debug info for that class. ++ ++ * gc.c (build_t_desc): Check linkage of a class properly. ++ ++ * class.c (finish_struct): Set the 'headof' offset for the main ++ vtable properly. ++ (prepare_fresh_vtable): Fix typeinfo pointer here. ++ (modify_one_vtable): Instead of here. ++ ++Mon Apr 10 12:15:59 1995 Jason Merrill ++ ++ * repo.c (repo_get_id): New function to return the interesting ++ identifier for a repo entity. ++ (repo_template_used): Use it. ++ (repo_template_instantiated): Mark the id as chosen. ++ (init_repo): Record whether or not the id was chosen. ++ (finish_repo): Note if an id was newly chosen. ++ ++ * pt.c (do_function_instantiation): Call repo_template_instantiated. ++ (do_type_instantiation): Likewise. Don't diagnose multiple ++ instantiation. ++ ++ * decl2.c (finish_file): Use DECL_NOT_REALLY_EXTERN when deciding ++ whether or not to synthesize a method. ++ ++ Undo these changes: ++ * class.c (finish_vtbls): Build more vtables if flag_rtti is on. ++ * class.c (modify_all_direct_vtables): Likewise. ++ * init.c (expand_direct_vtbls_init): Expand more vtables if ++ flag_rtti is on. ++ ++Sat Apr 8 17:45:41 1995 Mike Stump ++ ++ * gc.c (build_headof): Use ptrdiff_type_node instead of ++ integer_type_node on pointer arithmetic. ++ ++Sat Apr 8 11:57:04 1995 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Undo previous change. ++ ++Thu Apr 6 01:23:50 1995 Jason Merrill ++ ++ * Makefile.in (compiler): Remove ../cc1plus before rebuilding it. ++ ++ * repo.c (get_base_filename): Put the .rpo file in the directory ++ with the object file, not the source. ++ ++ * typeck.c (build_conditional_expr): Handle pmf's better. ++ ++ * repo.c (finish_repo): Also use ASM_OUTPUT_LABELREF to print out ++ the name of the symbol. ++ ++Wed Apr 5 15:24:12 1995 Jason Merrill ++ ++ * repo.c (open_repo_file): Make repo filename DOS-compliant. ++ (*): Also write a new repo file if some previously-used ++ templates are no longer used. Only remember the identifier. ++ ++ * lex.c (cons_up_default_function): If this function belongs to a ++ template class, call repo_template_used for it. ++ ++ * repo.c (repo_template_used): Using a class means using its vtable, ++ if any. ++ (finish_repo): Likewise. ++ ++ * typeck.c (build_modify_expr): Only wrap TARGET_EXPRs in RTL_EXPRs ++ if the type has a complex copy constructor. ++ ++ * decl2.c (lang_decode_option): -frepo implies ++ -fno-implicit-templates. ++ ++ * decl.c (start_function): Clear current_{base,member}_init_list. ++ ++ * lex.c (init_lex): Also unset *_eq if ! flag_operator_names. ++ ++Tue Apr 4 16:11:08 1995 Jason Merrill ++ ++ * decl.c (struct cp_function): Add {base,member}_init_list. ++ (push_cp_function_context): Save current_{base,member}_init_list. ++ (pop_cp_function_context): Restore them. ++ ++Mon Apr 3 16:55:08 1995 Jason Merrill ++ ++ * repo.c (get_base_filename): Take filename parm, fix logic bug. ++ ++ * typeck.c (build_compound_expr): Do not warn about a compound expr ++ in which the first expression has no side effects. ++ (build_x_compound_expr): Warn here instead. ++ (build_conditional_expr): Don't warn about a conditional expression ++ between an enum and the type it promotes to. ++ ++ * init.c (build_new): Handle initialization of arrays of builtins ++ properly. ++ ++Mon Apr 3 15:08:04 1995 Brendan Kehoe ++ ++ * repo.c: Include config.h to get definitions of bcopy and rindex ++ on systems that don't have them (e.g., SVR4). ++ ++Mon Apr 3 14:41:55 1995 Mike Stump ++ ++ * decl2.c (finish_table): Pass NULL_TREE instead of init to ++ finish_decl so that it won't try and do error checking on the ++ initializer. ++ ++Mon Apr 3 10:45:50 1995 Jason Merrill ++ ++ * repo.c (get_base_filename): Analyze COLLECT_GCC_OPTIONS to ++ determine whether this compile used -c -o. ++ (open_repo_file): Use get_base_filename. Remove the extension. ++ (finish_repo): Spit out the values of main_input_filename, ++ COLLECT_GCC and COLLECT_GCC_OPTIONS. ++ ++ * parse.y (structsp): Add TYPENAME_KEYWORD complex_type_name. ++ ++Sun Apr 2 23:43:51 1995 Jason Merrill ++ ++ * search.c (compute_access): Don't try to do access control on ++ nested types. ++ ++Fri Mar 31 10:14:23 1995 Jason Merrill ++ ++ * repo.c: New file to handle things repo. ++ ++ * pt.c (instantiate_template): Call repo_template_used if the ++ definition is accessible. ++ (mark_function_instantiated): Split out from ++ do_function_instantiation. ++ (mark_class_instantiated): Split out from do_type_instantiation. ++ ++ * parse.y (template_instantiate_once): Call repo_template_used. ++ ++ * lex.c (lang_init): Call init_repo. ++ ++ * decl2.c: Handle flag_use_repository. ++ (finish_file): Call finish_repo. ++ ++ * decl.c (start_method): Call repo_template_used if this is a ++ template method. ++ ++ * Makefile.in (CXX_OBJS): Add repo.o. ++ (repo.o): Add dependencies. ++ ++ * Make-lang.in (CXX_SRCS): Add repo.c. ++ ++ * decl.c (start_function): If DECL_INTERFACE_KNOWN and ++ DECL_NOT_REALLY_EXTERN are both set, unset DECL_EXTERNAL. ++ ++ * typeck.c (build_binary_op_nodefault): Identify the invalid operand ++ types used. ++ ++ * decl.c (duplicate_decls): Propagate DECL_NOT_REALLY_EXTERN. ++ ++Thu Mar 30 17:54:42 1995 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Tidy up use of build_type ++ and result_type. When checking for comparison between signed ++ and unsigned, use result_type rather than the (possibly shortened) ++ type of op0. Also, don't warn about equality comparison of a ++ signed operand to an unsigned constant that fits in the signed ++ type. ++ ++ * method.c (do_build_copy_constructor): Reverse ++ current_base_init_list after we've built it up. ++ ++Thu Mar 30 14:35:18 1995 Mike Stump ++ ++ * except.c (build_throw): Never warn about the value of throw not ++ being used. ++ ++Thu Mar 30 13:16:54 1995 Mike Stump ++ ++ * except.c (expand_start_catch_block): Check for bad catch parameter ++ declarations. ++ ++Thu Mar 30 13:06:11 1995 Jason Merrill ++ ++ * decl.c (finish_function): Only set DECL_NOT_REALLY_EXTERN if ++ DECL_EXTERNAL is not already set. ++ ++Thu Mar 30 11:26:24 1995 Mike Stump ++ ++ * method.c (emit_thunk): Let poplevel know that the last level is ++ for a function so it can create a BLOCK_NODE and set DECL_INITIAL. ++ ++Thu Mar 30 11:15:06 1995 Jason Merrill ++ ++ * decl2.c (import_export_inline): Don't set DECL_NOT_REALLY_EXTERN ++ here. ++ ++ * decl.c (grokdeclarator): OK, don't abort if we see a decl with ++ METHOD_TYPE. ++ (finish_function): Set DECL_EXTERNAL and DECL_NOT_REALLY_EXTERN on ++ all deferred inlines. ++ ++Wed Mar 29 19:35:02 1995 Jason Merrill ++ ++ * cp-tree.h (DECL_THIS_INLINE): New macro. ++ (DECL_NOT_REALLY_EXTERN): New macro. ++ (DECL_THIS_STATIC): New macro. ++ ++ * decl.c: Lose all references to current_extern_inline. Break ++ inline semantics into DECL_INLINE for actual inlining and ++ DECL_THIS_INLINE for the linkage wierdness. Use DECL_THIS_STATIC. ++ * decl2.c: Use DECL_NOT_REALLY_EXTERN to indicate that we want to ++ emit an inline here. Associated changes. ++ * lex.c: Likewise. ++ * pt.c: Likewise. ++ * typeck.c: Likewise. ++ ++ * call.c (build_method_call): Don't bother trying to handle inlines ++ specially. ++ * cvt.c (convert_to_aggr): Likewise. ++ ++ * pt.c (do_function_instantiation): Handle instantiation of ++ public inlines, too. ++ ++Wed Mar 29 16:04:25 1995 Mike Stump ++ ++ * except.c (init_exception_processing): Change the interface for ++ __throw_type_match and add decl for new rtti matching routine ++ __throw_type_match_rtti. ++ (build_eh_type): New routine to build a run time descriptor for the ++ expression given. ++ (expand_start_catch_block): Update to use new calling convention for ++ the matcher. ++ (expand_throw): Update to use build_eh_type. ++ ++Mon Mar 27 07:14:33 1995 Warner Losh ++ ++ * g++.c: Removed __NetBSD__ from conditional. ++ Declare strerror if HAVE_STRERROR is defined; otherwise ++ declare sys_errlist and sys_nerr. ++ (my_strerror): New function. ++ ++Tue Mar 28 14:16:35 1995 Jason Merrill ++ ++ * search.c (get_binfo): Don't try to be so clever. ++ ++ * tree.c (copy_to_permanent): Also suspend_momentary(). ++ ++ * cvt.c (cp_convert_to_pointer): Hand off to convert_fn_pointer even ++ if the types are the same. ++ ++ * decl.c (start_function): Handle extern inlines more like C++ says ++ we should. ++ ++ * init.c (build_member_call): Hand constructor calls off to ++ build_functional_cast. ++ ++ * typeck2.c (build_functional_cast): Use DECL_NESTED_TYPENAME to get ++ the name of the type. ++ ++Tue Mar 28 13:13:56 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Check for the decl returned by ++ grokfndecl to be null before using build_decl_attribute_variant. ++ ++Mon Mar 27 18:04:41 1995 Brendan Kehoe ++ ++ * init.c (build_new): Use build_pointer_type instead of ++ TYPE_POINTER_TO. ++ ++Fri Mar 24 12:11:24 1995 Jason Merrill ++ ++ * typeck.c (build_conditional_expr): Handle pmfs. ++ (convert_for_assignment): Fix pmf support. ++ ++ * cvt.c (convert_fn_ptr): Support !flag_vtable_thunks. ++ (cp_convert_to_pointer): Handle pmfs. ++ (cp_convert): Pass pmfs to cp_convert_to_pointer. ++ ++ * typeck.c (common_type): Handle inheritance for pmfs. ++ ++ * typeck2.c (build_m_component_ref): Do access control. ++ ++ * typeck.c (comp_target_types): Check for conversion to void * ++ before checking trickier conversions. ++ ++ * decl.c (duplicate_decls): Propagate DECL_ABSTRACT_VIRTUAL_P. ++ ++ * pt.c (push_tinst_level): Complain if template instantiation depth ++ is greater than max_tinst_depth. ++ ++ * typeck.c (common_type): Assume that we can call common_type to ++ unify the target type of a pointer. ++ ++Thu Mar 23 00:48:44 1995 Jason Merrill ++ ++ * decl2.c (finish_file): Don't synthesize methods at ++ finish_vtable_prevardecl time. Do synthesize methods that are not ++ used, but are public and not external. ++ ++ * cvt.c (build_type_conversion): Only give an error if for_sure. ++ ++ * typeck.c (comp_target_types): Only support pointer conversions if ++ nptrs > 0. ++ ++Wed Mar 22 19:30:15 1995 Brendan Kehoe ++ ++ * init.c (build_new): Catch use of an initializer list where it ++ shouldn't be. ++ ++Wed Mar 22 16:21:07 1995 Jason Merrill ++ ++ * init.c (build_new): Wrap alloc_expr in an RTL_EXPR if nelts is ++ non-constant. ++ ++ * decl2.c: temp_name_counter is now public. ++ ++ * decl.c (struct cp_function): Add temp_name_counter field. ++ (push_cp_function_context): Save it. ++ (pop_cp_function_context): Restore it. ++ ++ * typeck.c (common_type): Handle unifying function types, and unify ++ unmatched things to void* with a compiler_error, rather than ++ silently like before. ++ ++Wed Mar 22 15:10:34 1995 Mike Stump ++ ++ * decl2.c (finish_prevtable_vardecl, finish_vtable_vardecl): Revert ++ Brendan's last change and fix latent problem that causes TD entries ++ to not come out when the things that need them has yet to be ++ expanded. ++ ++Wed Mar 22 15:12:00 1995 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault, comparison ops): Update type0 ++ and type1, since we might have changed op0 or op1. ++ ++Wed Mar 22 13:33:45 1995 Jason Merrill ++ ++ * typeck.c (common_type): Don't mess up templates. ++ ++Wed Mar 22 04:56:00 1995 Jason Merrill ++ ++ * typeck.c (common_type): Handle ptms properly. Also handle ++ T* -> void*. ++ (build_binary_op_nodefault): New variable build_type controls what ++ type is given to the expression when it is created. Set this to ++ boolean_type_node for comparison ops instead of using result_type. ++ (comp_target_types): Allow T * -> void *. ++ ++ * cvt.c (cp_convert_to_pointer): Do access control when converting ++ ptms, too. ++ ++Tue Mar 21 17:25:06 1995 Brendan Kehoe ++ ++ * parse.y (extern_lang_string): Catch use of linkage specs that ++ aren't all naming the same language. ++ ++ * class.c (finish_struct): Delete accidental duplicate code. ++ ++Tue Mar 21 14:00:57 1995 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Disable pedwarns about ++ comparing functions and incomplete types. ++ ++ * decl.c (finish_function): Only unset current_function_decl if ++ !nested. ++ (duplicate_decls): Last change went too far; we only want to stop ++ checking for value/reference ambiguity. ++ ++Tue Mar 21 01:26:39 1995 Mike Stump ++ ++ * gc.c (build_generic_desc): Zap the DECL_SIZE so that we can lay it ++ out fresh, as the new type may be larger. ++ ++Mon Mar 20 19:01:10 1995 Jason Merrill ++ ++ * expr.c (extract_init): Try to expand the RTL for the ++ initialization and figure out what it will look like so we can avoid ++ run-time initialization. Disabled for now. ++ (extract_scalar_init): Helper for scalar initialization. ++ (extract_aggr_init): Helper for aggregate initialization. ++ ++ * decl.c (duplicate_decls): Don't complain about ambiguous ++ declarations. ++ (obscure_complex_init): Now returns a tree. Call extract_init if ++ we're optimizing and this is a toplevel decl. ++ (finish_decl): Update accordingly. ++ ++ * lex.c (check_newline): If we're just changing files (not pushing ++ or popping), update input_file_stack->name. ++ ++Mon Mar 20 17:55:04 1995 Mike Stump ++ ++ * pt.c (type_unification): Only TEMPLATE_DECLs are handled right now ++ in the transitive unification code. ++ ++Mon Mar 20 16:07:50 1995 Brendan Kehoe ++ ++ * decl.c (shadow_tag): Don't allow inline, virtual, or explicit on ++ non-functions. ++ (grokdeclarator): Don't allow friends to be defined in local classes. ++ ++Sat Mar 18 04:03:33 1995 Jason Merrill ++ ++ * decl2.c (finish_prevtable_vardecl): Use DECL_DECLARED_STATIC ++ rather than DECL_SAVED_INSNS to decide whether or not this method ++ was declared inline. ++ ++ * method.c (synthesize_method): Turn off DECL_INLINE if ++ function_cannot_inline_p thinks we're too large. ++ ++ * typeck.c (build_indirect_ref): Use build_expr_type_conversion. ++ ++Fri Mar 17 17:47:36 1995 Jason Merrill ++ ++ * class.c (instantiate_type): Handle pmfs. ++ ++ * typeck.c (convert_for_assignment): Check types when assigning one ++ pmf to another. ++ ++ * decl.c (define_label): Fix logic for printing out the name of the ++ label in an error message. ++ ++ * error.c (dump_expr): Support ARRAY_REF. ++ ++Fri Mar 17 17:43:02 1995 Brendan Kehoe ++ ++ * decl2.c (finish_vtable_vardecl): Call build_t_desc here. ++ (finish_prevtable_vardecl): Instead of here. ++ ++Fri Mar 17 14:40:45 1995 Jason Merrill ++ ++ * decl.c (expand_static_init): Also use expand_aggr_init if the ++ initializer is a TREE_LIST. ++ (grokdeclarator): Only pedwarn about extra qualification if -pedantic. ++ ++ * pt.c (unify): Fix unification of return type. ++ ++ * expr.c (fixup_result_decl): Use store_expr, rather than ++ emit_move_insn, to move the return value into the place where ++ callers will expect it. ++ ++Thu Mar 16 22:05:25 1995 Jason Merrill ++ ++ * init.c (build_offset_ref): Call assmble_external on functions. ++ * typeck.c (build_component_ref): Likewise. ++ ++Thu Mar 16 20:28:16 1995 Brendan Kehoe ++ ++ * decl.c (struct saved_scope): Add members base_init_list and ++ member_init_list. ++ (push_to_top_level): Save current_base_init_list and ++ current_member_init_list to them. ++ (pop_from_top_level): Put it back. ++ ++Thu Mar 16 19:21:14 1995 Jason Merrill ++ ++ * pt.c (instantiate_template): Call assemble_external. ++ ++Thu Mar 16 18:07:54 1995 Brendan Kehoe ++ ++ * class.c: Include rtl.h, to get NULL_RTX. ++ (finish_struct): Also zero out DECL_SAVED_INSNS, to avoid problems ++ on hosts with different sizes for each part of the union. ++ * tree.c: Also include rtl.h. ++ (layout_basetypes): Same change for DECL_SAVED_INSNS. ++ ++Thu Mar 16 13:57:36 1995 Jason Merrill ++ ++ * pt.c (unify): Fix array domain unification for 64-bit targets. ++ ++ * decl2.c (finish_file): Push bizarre type decl before walking the ++ vtables the first time. ++ (walk_vtables): OK, don't set prev to vars if the vardecl_fn messed ++ with TREE_CHAIN (prev). ++ ++ * init.c (emit_base_init): Use convert_pointer_to_real instead of ++ convert_pointer_to when converting to a direct base. ++ ++Wed Mar 15 20:26:29 1995 Mike Stump ++ ++ * pt.c (type_unification): Handle transitive unification better. ++ ++Wed Mar 15 13:56:16 1995 Jason Merrill ++ ++ * decl2.c (walk_vtables): Always set prev to vars. ++ (mark_vtable_entries): Call assemble_external on the vtable entries. ++ ++ * class.c (finish_struct): Set the vtable's size to NULL_TREE before ++ calling layout_decl, so that it gets updated properly. ++ ++ Finally re-enable dynamic synthesis. This time it works. ++ * method.c (synthesize_method): Pass decl_function_context (fndecl) ++ to {push,pop}_cp_function_context. ++ * decl.c (push_cp_function_context): Now takes a tree argument. ++ (pop_cp_function_context): Likewise. ++ * call.c (build_method_call): Enable synthesis. ++ * lex.c (cons_up_default_function): Likewise. ++ ++Tue Mar 14 19:14:19 1995 Doug Evans ++ ++ * parse.y (setattrs): Chain onto prefix_attributes rather than ++ setting it. ++ ++Wed Mar 15 13:00:00 1995 Brendan Kehoe ++ ++ * decl.c (pushdecl): Check if the type of the VAR_DECL is an ++ error_mark_node before trying to read TYPE_LANG_SPECIFIC. ++ ++Mon Mar 13 21:00:28 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator, case ARRAY_REF): Wrap the exp with fold, ++ and convert the size and integer_one_node to the index type. ++ ++Mon Mar 13 08:01:02 1995 Jason Merrill ++ ++ * typeck.c (get_member_function_from_ptrfunc): Save the instance ++ argument, and tack it onto the front of the COND_EXPR to make the ++ semantics come out right. Grab the instance argument from ++ '*instance_ptrptr', rather than having it passed in separately. ++ ++ * various: Change various consed-up comparison operations to have ++ boolean type. Remove the instance argument in calls to ++ get_member_function_from_ptrfunc. ++ ++ * error.c (dump_expr): Dump true and false as "true" and "false". ++ ++ * decl2.c (finish_file): Also set DECL_STATIC_FUNCTION_P on the ++ global init function. ++ ++ * decl.c (finish_function): Only set DECL_EXTERNAL here if the ++ inline function is public. ++ ++Sat Mar 11 00:58:03 1995 Jason Merrill ++ ++ * init.c (is_friend): Be more careful about checking ++ DECL_CLASS_CONTEXT on non-member functions. ++ ++ * decl2.c (finish_vtable_vardecl): Don't bother calling ++ assemble_external here. ++ (prune_vtable_vardecl): New function that just splices out the ++ vtable decl from the top-level decls. ++ (import_export_inline): Unset DECL_EXTERNAL at first. ++ (finish_file): Don't bother calling assemble_external here. Do ++ splice out all of the vtables. ++ ++Fri Mar 10 14:42:29 1995 Jason Merrill ++ ++ * decl.c (finish_function): If we're not emitting the function yet, ++ call assemble_external for it. ++ ++ * decl2.c (finish_prevtable_vardecl): Don't call mark_vtable_entries ++ here. ++ (finish_vtable_vardecl): Don't do the linkage deduction thing here. ++ Also don't splice out the current vtable if it is unused. ++ (finish_file): Move the second walk_vtables and the synthesis check ++ inside the 'reconsider' loop. Move thunk emission after the ++ 'reconsider' loop. ++ ++Thu Mar 9 16:28:16 1995 Brendan Kehoe ++ ++ * pt.c (tsubst): Don't bother calling cp_build_type_variant, since it ++ was passing bogus values for readonly and volatile from the original ++ template decl, not the resultant type of the tsubst call. ++ ++ * class.c (duplicate_tag_error): Use cp_error_at to point out the ++ previous definition of the tag. ++ ++Thu Mar 9 10:46:17 1995 Jason Merrill ++ ++ * decl.c (start_function): Clear base_init_insns and protect_list. ++ (struct cp_function): Add base_init_insns field. ++ (push_cp_function_context): Also save base_init_insns. ++ (pop_cp_function_context): Also restore base_init_insns. ++ ++Wed Mar 8 13:31:44 1995 Jason Merrill ++ ++ * init.c (member_init_ok_or_else): Check for initializing a static ++ member here. ++ (emit_base_init): Instead of here. ++ ++Tue Mar 7 16:03:26 1995 Jason Merrill ++ ++ * call.c (build_method_call): Disable synthesis as needed. ++ * lex.c (cons_up_default_function): Likewise. ++ ++Tue Mar 7 10:14:29 1995 Brendan Kehoe ++ ++ * parse.y: New rules to allow attributes in a prefix position. ++ (prefix_attributes): New variable. Pass it into cplus_decl_attributes. ++ (setattr): New rule. ++ (reserved_declspecs, declmods): Catch attributes here. ++ * decl2.c (cplus_decl_attributes): Add PREFIX_ATTRIBUTES argument. ++ * decl.c (duplicate_decls): Pass DECL_MACHINE_ATTRIBUTES to ++ descendent typedef. ++ (grokdeclarator): Added code to support machine attributes. ++ * Makefile.in (stamp-parse): Expect 5 shift/reduce failures. ++ ++Mon Mar 6 15:07:02 1995 Jason Merrill ++ ++ * call.c (build_method_call): Don't synthesize methods outside of a ++ function. ++ ++ Make base initialization more re-entrant so that synthesis on the ++ fly will work (and, eventually, template instantiation on the fly). ++ * init.c (sort_member_init): Don't bother with members that can't be ++ initialized. Reorganize a bit. Don't initialize base members here. ++ (sort_base_init): New function, like sort_member_init, but for base ++ classes. Steals some code from emit_base_init. ++ (emit_base_init): Simplify. Call sort_{member,base}_init before ++ doing any initialization, so we don't have to save ++ current_{member,base}_init_list in push_cp_function_context. ++ (expand_aggr_vbase_init_1): Adjust for sort_base_init. ++ (expand_aggr_vbase_init): Simplify. ++ * decl.c (struct cp_function): Add protect_list field. ++ (push_cp_function_context): Also save protect_list. ++ (pop_cp_function_context): Also restore protect_list. ++ * call.c (build_method_call): Enable synthesis at point of call. ++ * lex.c (cons_up_default_function): Likewise. ++ ++ * parse.y: Turn -ansi checks back into -pedantic checks. ++ ++ * init.c (build_new): Fix -fcheck-new for array new. ++ ++Sat Mar 4 15:55:42 1995 Fergus Henderson ++ ++ * typeck.c (build_compound_expr): warn if left-hand operand of ++ comma expression has no side-effects. ++ ++Fri Mar 3 15:16:45 1995 Jason Merrill ++ ++ * parse.y (primary): Change 'object qualified_id *' rules to 'object ++ overqualified_id *'. ++ ++Fri Mar 3 12:48:17 1995 Brendan Kehoe ++ ++ * parse.y (unary_expr): Catch doing sizeof an overloaded function. ++ Make the error look the same as the one we issue in c_sizeof. ++ ++ * typeck.c (build_binary_op_nodefault): Give an error for trying ++ to compare a pointer-to-member to `void *'. ++ ++Fri Mar 3 11:28:50 1995 Jason Merrill ++ ++ * typeck.c (build_unary_op): Handle bool increment with smoke and ++ mirrors here, rather than in expand_increment where it belongs, ++ because Kenner doesn't agree with me. ++ ++Fri Mar 3 00:08:10 1995 Brendan Kehoe ++ ++ * decl.c (grokparms): Catch a PARM_DECL being used for a default ++ argument as well. ++ ++Thu Mar 2 20:05:54 1995 Brendan Kehoe ++ ++ * init.c (build_new): Don't allow new on a function type. ++ ++ * parse.y (primary): Avoid a crash when seeing if the arg is of ++ the same type as that given for the typespec in an explicit dtor call. ++ ++Thu Mar 2 00:49:38 1995 Jason Merrill ++ ++ * decl.c (finish_function): Change test for calling ++ mark_inline_for_output. ++ ++Wed Mar 1 11:23:46 1995 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Complain if ++ build_default_binary_type_conversion fails. ++ ++ * init.c (expand_default_init): Handle arguments of unknown type ++ properly. ++ ++ * cvt.c (build_expr_type_conversion): Only complain about ambiguity ++ if 'complain'. ++ * various: Pass 'complain'. ++ ++ * typeck.c (comptypes): Be more picky about comparing UPTs. ++ ++Wed Mar 1 11:03:41 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): If declarator is null, say that the ++ type used has an incomplete type. ++ ++Wed Mar 1 10:06:20 1995 Jason Merrill ++ ++ * pt.c (instantiate_template): Copy the template arguments to the ++ permanent_obstack. Also use simple_cst_equal to compare them when ++ looking for a previous instantiation. ++ ++ * tree.c (make_deep_copy): Support copying INTEGER_TYPEs (assuming ++ they are array domain types). ++ ++Tue Feb 28 23:24:55 1995 Jason Merrill ++ ++ * cp-tree.h: Define WANT_* constants for passing to ++ build_expr_type_conversion. ++ * cvt.c (build_expr_type_conversion): New function to build ++ conversion to one of a group of suitable types. ++ (build_default_binary_type_conversion): Use it. ++ * decl2.c (grok_array_decl): Likewise. ++ * typeck.c (build_unary_op): Likewise. ++ (build_array_ref): Tidy up a bit. ++ (build_binary_op): Likewise. ++ ++Tue Feb 28 19:57:31 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Don't allow decl of an argument as `void'. ++ ++Tue Feb 28 17:23:36 1995 Jason Merrill ++ ++ * parse.y (typed_declspecs1): Add 'typespec reserved_typespecquals ++ reserved_declspecs' rule. ++ ++ * parse.y (expr_or_declarator): Remove notype_qualified_id rule. ++ (direct_notype_declarator): Likewise. ++ (complex_direct_notype_declarator): Add notype_qualified_id rule. ++ ++ * lex.c (real_yylex): Handle :> digraph properly. ++ ++Tue Feb 28 12:26:29 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Check if it's a friend, not if it's ++ non-virtual, that's being initialized. Move the check up to ++ before FRIENDP would get cleared. Catch an unnamed var/field ++ being declared void. Say just `field' instead of `structure field' ++ in the error message. Only go for the operator name if DECLARATOR ++ is non-null. ++ ++Tue Feb 28 00:08:01 1995 Jason Merrill ++ ++ * decl.c (start_function): Complain about abstract return type. ++ (grokdeclarator): Complain about declaring constructors and ++ destructors to be const or volatile. Complain about declaring ++ destructors to be static. ++ ++ * pt.c (uses_template_parms): Handle pmfs. ++ ++ * decl.c (grokdeclarator): Don't call variable_size for array bounds ++ that only depend on template constant parameters. ++ ++Mon Feb 27 15:38:16 1995 Brendan Kehoe ++ ++ * error.c (dump_decl): Only look to see if it's a vtable if we ++ actually have a name to check out. ++ ++Mon Feb 27 13:37:53 1995 Jason Merrill ++ ++ * cvt.c (convert_to_aggr): Lose misleading shortcut. ++ ++Sun Feb 26 17:27:32 1995 Doug Evans ++ ++ * decl.c (set_nested_typename): Always set DECL_IGNORED_P, ++ not just for dwarf. ++ ++Sun Feb 26 00:10:18 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Don't allow a static member to be ++ declared `register'. ++ ++ * init.c (make_friend_class): Move up to a pedwarn for the warning ++ about a class declaring friends with itself. ++ ++ * decl.c (grokdeclarator): You can't do `volatile friend class foo' ++ or `inline friend class foo'. Only try to make a friend out of ++ TYPE if we didn't already reset it to integer_type_node. ++ ++Sat Feb 25 22:32:03 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Don't allow initialization of a ++ non-virtual function. ++ ++ * decl.c (start_function): Do a pedwarn if we're changing `main' ++ to have an int return type. ++ ++Sat Feb 25 00:02:05 1995 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Handle simple assignment from ++ TARGET_EXPRs by building up an RTL_EXPR to force expansion. Whew. ++ ++Fri Feb 24 18:27:14 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Also don't allow virtual outside of a ++ class decl for a scope method definition performed at global binding. ++ ++ * init.c (build_offset_ref): Don't allow creation of an OFFSET_REF ++ of a bitfield. ++ ++ * decl.c (grokdeclarator): Don't allow a const to be declared mutable. ++ ++ * typeck.c (build_binary_op): Return an error_mark_node if either ++ one of the args turned into an error_mark_node when we tried to ++ use default_conversion. ++ ++ * typeck.c (build_unary_op): Forbid using postfix -- on a bool. ++ ++ * decl.c (grokdeclarator): Allow `signed' and `unsigned' to be ++ used on `__wchar_t'. ++ ++Fri Feb 24 13:59:53 1995 Mike Stump ++ ++ * except.c (end_protect_partials): Do it the right way. ++ ++Wed Feb 22 15:42:56 1995 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Upgrade warning about ++ comparing distinct pointer types to pedwarn. ++ ++ * typeck2.c (digest_init): Cope with extra braces. ++ ++ * typeck.c (build_binary_op_nodefault): Use tree_int_cst_sgn instead ++ of INT_CST_LT (..., interger_zero_node). ++ ++Wed Feb 22 14:45:52 1995 Brendan Kehoe ++ ++ * except.c [!TRY_NEW_EH] (end_protect_partials): Define dummy ++ function for systems that don't have EH. ++ ++Tue Feb 21 19:18:31 1995 Jason Merrill ++ ++ * call.c (can_convert_arg): Like can_convert, but takes an arg as ++ well. ++ ++ * pt.c (type_unification): Allow implicit conversions for parameters ++ that do not depend on template parameters. ++ ++Tue Feb 21 18:43:48 1995 Douglas Rupp ++ ++ * Make-lang.in, config-lang.in: ($exeext): New macro. ++ * Make-lang.in: Try a "cp" if "ln" fails. ++ * cp-tree.h (decl_attributes): Added argument. ++ * decl2.c (cplus_decl_attribute): Add arg to decl_attributes. ++ * cp/g++.c: Added #ifdefs for sys/file.h and process.h for NT. ++ Modified spawnvp to have to correct number of arguments for OS/2, NT. ++ ++Tue Feb 21 18:36:55 1995 Mike Stump ++ ++ * decl.c (finish_function): Add calls to end_protect_partials to end ++ the exception region that protects constructors so that partially ++ constructed objects can be partially destructed when the constructor ++ throws an exception. ++ * init.c (perform_member_init, sort_member_init, emit_base_init): ++ Added support for partially constructed objects. ++ * init.c (build_partial_cleanup_for): New routine to do partial ++ cleanups of a base class. ++ * decl2.c (finish_file): Move the emitting of the exception table ++ down, after we emit all code that might have exception regions in ++ them. ++ * except.c (end_protect_partials, might_have_exceptions_p): New ++ routines. ++ (emit_exception_table): Always output table if called. ++ * cp-tree.h (protect_list, end_protect_partials, ++ might_have_exceptions_p, emit_exception_table): Added. ++ ++Tue Feb 21 16:05:59 1995 Brendan Kehoe ++ ++ * gc.c (build_typeid): Pass a NULL_TREE, not the bogus, unused ++ address of a local variable. ++ * class.c (build_vfn_ref): Only try to build the PLUS_EXPR if we ++ were given a non-null PTR_TO_INSTPTR. ++ ++Tue Feb 21 01:53:18 1995 Jason Merrill ++ ++ * decl.c (duplicate_decls): Always lay out the merged decl. ++ ++ * decl2.c (finish_vtable_vardecl): Don't do vtable hack on templates. ++ (finish_prevtable_vardecl): Likewise. ++ ++ * method.c (synthesize_method): Set interface_{unknown,only} ++ according to the settings for our class, not the file where it comes ++ from. ++ ++Sat Feb 18 12:26:48 1995 Mike Stump ++ ++ * except.c: Handle systems that define __i386__ but not __i386. ++ ++Fri Feb 17 15:31:31 1995 Jason Merrill ++ ++ * decl2.c (reparse_decl_as_expr): Support being called without a ++ type argument. ++ ++ * parse.y (primary): Add '(' expr_or_declarator ')'. Adds 4 r/r ++ conflicts. Sigh. ++ ++Fri Feb 17 12:02:06 1995 Mike Stump ++ ++ * parse.y (template_def, fndef, fn.def1, return_init, condition, ++ initdcl0, initdcl, notype_initdcl0, nomods_initdcl0, ++ component_decl_1, after_type_component_declarator0, ++ notype_component_declarator0, after_type_component_declarator, ++ notype_component_declarator, after_type_component_declarator, ++ full_parm, maybe_raises, exception_specification_opt): Fix up, ++ include exception_specification_opt maybeasm maybe_attribute and ++ maybe_init if missing. Rename maybe_raises to ++ exception_specification_opt to match draft wording. Use maybe_init ++ to simplify rules. ++ ++Fri Feb 17 01:54:46 1995 Jason Merrill ++ ++ * init.c (build_new): Set TREE_NO_UNUSED_WARNING on COMPOUND_EXPRs ++ built for news of scalar types. ++ ++Thu Feb 16 17:48:28 1995 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Update code for warning ++ about signed/unsigned comparisons from C frontend. Realize that the ++ code in the C frontend is, if anything, even more bogus. Fix it. ++ (build_binary_op): Undo default_conversion if it wasn't useful. ++ ++ * typeck.c (build_unary_op, ADDR_EXPR): Lose bogus special case for ++ PRE*CREMENT_EXPR. ++ ++ * decl2.c (import_export_vtable): Don't try the vtable hack ++ if the class doesn't have any real non-inline virtual functions. ++ (finish_vtable_vardecl): Don't bother trying to find a non-inline ++ virtual function in a non-polymorphic class. ++ (finish_prevtable_vardecl): Likewise. ++ ++ * decl2.c (import_export_vtable): Use and set DECL_INTERFACE_KNOWN. ++ ++ * cp-tree.h (DECL_INTERFACE_KNOWN): Use DECL_LANG_FLAG_5. ++ ++ * init.c (expand_virtual_init): Always call assemble_external. ++ ++ * class.c (build_vfn_ref): Always call assemble_external. ++ (build_vtable): Always call import_export_vtable. ++ (prepare_fresh_vtable): Likewise. ++ (add_virtual_function): Don't bother setting TREE_ADDRESSABLE. ++ ++Thu Feb 16 03:28:49 1995 Jason Merrill ++ ++ * class.c (finish_struct): Use TYPE_{MIN,MAX}_VALUE to determine ++ whether an enumerated type fits in a bitfield. ++ ++Wed Feb 15 15:38:12 1995 Jason Merrill ++ ++ * class.c (grow_method): Update method_vec after growing the class ++ obstack. ++ ++Wed Feb 15 13:42:59 1995 Mike Stump ++ ++ * parse.y (handler_seq): Push a level for the catch parameters. ++ ++Wed Feb 15 12:42:57 1995 Jason Merrill ++ ++ * init.c (emit_base_init): Update BINFO_INHERITANCE_CHAIN on my ++ bases, in case they've been clobbered. ++ ++Wed Feb 15 12:07:29 1995 Mike Stump ++ ++ * class.c (finish_base_struct): Set up BINFO_INHERITANCE_CHAIN here, ++ so that one day it will always be valid. ++ * tree.c (propagate_binfo_offsets, layout_vbasetypes): Likewise. ++ ++ * cp-tree.h (copy_binfo): Removed, unused. ++ * tree.c (copy_binfo): Likewise. ++ ++Wed Feb 15 00:05:30 1995 Jason Merrill ++ ++ * init.c (build_new): Save the allocation before calling ++ expand_vec_init on it. ++ ++ * decl.c (finish_enum): The TYPE_PRECISION of the enum type mush ++ match the TYPE_PRECISION of the underlying type for constant folding ++ to work. ++ ++Tue Feb 14 15:31:25 1995 Mike Stump ++ ++ * except.c (push_eh_entry, expand_start_all_catch, ++ expand_leftover_cleanups, expand_end_catch_block): Keep track of ++ the context in which the exception region occurs. ++ (build_exception_table): If the region was not output, don't output ++ the entry in the eh table for it. ++ ++Tue Feb 14 02:15:43 1995 Jason Merrill ++ ++ * init.c (expand_default_init): Only use a previous constructor call ++ if it's a call to our constructor. Does the word "Duh" mean ++ anything to you? ++ ++ * decl.c (grokparms): Fine, just don't call ++ convert_for_initialization at all. OK? Happy now? ++ ++Mon Feb 13 02:23:44 1995 Jason Merrill ++ ++ * cp-tree.h (CLASSTYPE_FIRST_CONVERSION): Make sure that the class ++ method vector has a second element before returning it. ++ ++ * decl.c (grokparms): Don't strip REFERENCE_TYPE before calling ++ convert_for_initialization. ++ ++Sun Feb 12 03:57:06 1995 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Compare function name to ++ constructor_name (current_class_type) instead of current_class_name. ++ ++ * decl.c (grokparms): Don't do anything with the return value of ++ convert_for_initialization. ++ ++ * error.c (dump_decl): Also dump_readonly_or_volatile on the decl. ++ ++ * decl.c (duplicate_decls): Tweak error message. ++ ++ * typeck.c (build_const_cast): Implement checking. ++ (build_reinterpret_cast): Implement some checking. ++ ++ * cp-tree.h (CONV_FORCE_TEMP): Require a new temporary when ++ converting to the same aggregate type. ++ (CONV_STATIC_CAST): Include it. ++ (CONV_C_CAST): Likewise. ++ * cvt.c (convert_force): Use CONV_C_CAST instead of CONV_OLD_CONVERT. ++ (cp_convert): Only force a new temporary if CONV_FORCE_TEMP. ++ ++Fri Feb 10 16:18:52 1995 Jason Merrill ++ ++ * typeck.c (build_c_cast): Use non_lvalue to tack something on ++ where necessary. ++ ++ * decl.c (auto_function): Now a function. ++ * except.c (init_exception_processing): terminate, unexpected, ++ set_terminate, and set_unexpected have C++ linkage. ++ ++ * typeck.c (build_unary_op, TRUTH_NOT_EXPR): Use convert instead of ++ truthvalue_conversion for converting to bool, as it handles ++ user-defined conversions properly. ++ (condition_conversion): Likewise. ++ ++ * except.c (expand_throw): Don't call convert_to_reference. ++ Pass the correct parameters to build_new. ++ ++ * method.c (do_build_assign_ref): Don't use access control when ++ converting to a base reference here. ++ (do_build_copy_constructor): Or here. ++ ++ * init.c (build_new): Unset TREE_READONLY on the dereferenced ++ pointer before assigning to it. ++ ++ * decl.c (maybe_build_cleanup): Don't bother stripping const here. ++ ++ * decl2.c (delete_sanity): You can now delete pointer to const. ++ ++Fri Feb 10 13:28:38 1995 Jason Merrill ++ ++ * decl.c (finish_function): Don't rely on actual parameters being ++ evaluated left-to-right. ++ * except.c (expand_end_catch_block): Likewise. ++ ++Fri Feb 10 00:52:04 1995 Jason Merrill ++ ++ * tree.c (real_lvalue_p): Like lvalue_p, but class temps aren't ++ considered lvalues. ++ * cvt.c (convert_to_reference): Use real_lvalue_p instead of ++ lvalue_p. ++ ++ * cvt.c (build_type_conversion_1): Don't call convert on aggregate ++ types. ++ (convert_to_reference): Fix erroneous text substitution. ++ ++ * typeck2.c (initializer_constant_valid_p): Update from C frontend. ++ Add new argument to all callers. ++ ++ * typeck.c (convert_arguments): Check for error_mark_node before ++ trying to do anything with the actual parameter. ++ ++ * typeck.c (condition_conversion): Build up a CLEANUP_POINT_EXPR and ++ fold it. ++ (bool_truthvalue_conversion): Remove. Fix all callers to call ++ truthvalue_conversion instead. ++ (various): Fold CLEANUP_POINT_EXPRs. ++ ++ * parse.y (conditions): Call condition_conversion rather than ++ building up a CLEANUP_POINT_EXPR. ++ ++ * pt.c (end_template_decl): Don't warn_if_unknown_interface here ++ under -falt-external-templates. ++ ++Thu Feb 9 05:24:10 1995 Jason Merrill ++ ++ * init.c (build_new): Complain about new of const type without ++ initializer. Other cleanup. ++ ++ * call.c (compute_conversion_costs): Don't call ++ build_type_conversion with a reference type; convert to the target ++ type and check its lvaluetude. ++ * cvt.c (convert_to_reference): Likewise. ++ ++ * cvt.c (build_type_conversion_1): There will never be any need to ++ dereference references here now. ++ ++Thu Feb 9 00:37:47 1995 Mike Stump ++ ++ * except.c (expand_builtin_throw): Make sure we only `use' the ++ value of return_val_rtx. ++ ++Wed Feb 8 15:45:55 1995 Jason Merrill ++ ++ * parse.y (structsp): Don't complain about declaring a type being ++ defined to be a friend. ++ ++ * decl2.c (warn_if_unknown_interface): Note the template in question ++ and the point of instantiation, for -falt-external-templates. ++ * lex.c (reinit_parse_for_method): Pass the decl to ++ warn_if_unknown_interface. ++ * pt.c (instantiate_template): Likewise. ++ (end_template_decl): Likewise. ++ ++ * decl.c (set_nested_typename): Set IDENTIFIER_TYPE_VALUE on the ++ nested name again, to make local classes work a bit better. ++ ++ * typeck.c (build_function_call_real): Dereference reference after ++ checking for incomplete type. ++ ++ * init.c (build_new): Accept new of const and volatile types. ++ ++Wed Feb 8 14:04:16 1995 Jason Merrill ++ ++ * decl.c (grokdeclarator): Fix error message. ++ ++Wed Feb 8 03:16:15 1995 Jason Merrill ++ ++ * typeck.c (convert_for_initialization): Do bash arrays when ++ converting to a reference to non-array. ++ ++Tue Feb 7 15:50:33 1995 Jason Merrill ++ ++ * cvt.c (cp_convert): Don't call convert_to_reference, or ++ automatically dereference references. Do pass reference conversions ++ to cp_convert_to_pointer. ++ (cp_convert_to_pointer): Support references. ++ ++ * call.c (build_method_call): Don't build up a reference to the ++ parameter here; let build_overload_call handle that. ++ ++ * typeck.c (build_c_cast): Call convert_to_reference directly if ++ converting to a reference type. ++ * method.c (do_build_copy_constructor): Likewise. ++ * method.c (do_build_copy_constructor): Likewise. ++ (do_build_assign_ref): Likewise. ++ ++ * call.c (build_method_call): Dereference a returned reference. ++ * typeck.c (build_function_call_real): Likewise. ++ ++ * decl.c (xref_basetypes): Check for unions with basetypes here. ++ (xref_tag): Instead of here. ++ ++ * pt.c (process_template_parm): Template type parm decls are ++ artificial. ++ ++Mon Feb 6 04:32:09 1995 Jason Merrill ++ ++ * parse.y (typed_declspecs): Add missing semicolon. ++ (do_xref_defn): Resurrect. ++ (named_class_head_sans_basetype): Move template specialization ++ definition cases to named_class_head_sans_basetype_defn. ++ ++ * decl2.c (grokfield): Call pushdecl_class_level after setting the ++ TYPE_NAME, not before. ++ ++Sun Feb 5 02:50:45 1995 Jason Merrill ++ ++ * call.c (convert_harshness): Don't call sorry here. Don't allow ++ conversions between function pointer types if pedantic. ++ ++ * pt.c (overload_template_name): Pass globalize=1 to xref_tag. ++ ++ * lex.c (cons_up_default_function): Use the full name for the return ++ type of op=. ++ ++ * decl.c (set_nested_typename): Don't worry about anonymous types, ++ as they already have a unique name. ++ (pushdecl): Remove redundant set_nested_typename ++ (xref_tag): Split out base handling into xref_basetypes. ++ ++ * cp-tree.h (TYPE_INCOMPLETE): New macro; TEMPLATE_TYPE_PARMs are ++ not considered incomplete even though their definition is unknown. ++ ++ * decl.c (xref_defn_tag): Lose. ++ (xref_tag): xref_next_defn = ! globalize. ++ (pushdecl): Don't set DECL_NESTED_TYPENAME on artificial decls. The ++ ones that should have it set will have it set by pushtag. ++ (pushdecl_class_level): Likewise. ++ (pushtag): Tidy up a bit. ++ (set_nested_typename): Push a decl for the nested typename from ++ here, rather than from xref_defn_tag. ++ ++ * parse.y (do_xref): Lose. ++ (named_class_head): If we see 'class foo:' we know it's a ++ definition, so don't worry about base lists for non-definitions. ++ ++ * pt.c (push_template_decls): Template parm decls are artificial. ++ ++ * decl.c (duplicate_decls): Restore check for qualifier ++ disagreement for non-functions. ++ (decls_match): Remove check for qualifier disagreement. ++ ++Fri Feb 3 14:58:58 1995 Jason Merrill ++ ++ * decl.c (grok_reference_init): Convert initializer from ++ reference. ++ * typeck.c (convert_for_initialization): Likewise. ++ ++ * decl.c (duplicate_decls): Propagate DECL_NESTED_TYPENAME. ++ ++ * cvt.c (cp_convert): Don't convert to the same class type by just ++ tacking on a NOP_EXPR. ++ (convert_to_reference): Use comp_target_types instead of comptypes ++ so that we don't allow conversions two levels down. ++ ++Thu Feb 2 15:07:58 1995 Jason Merrill ++ ++ * class.c (build_vbase_path): Bash types to make the backend happy. ++ * cvt.c (build_up_reference): Bash the types bashed by ++ build_vbase_path to be reference types instead of pointer types. ++ (convert_to_reference): Likewise. ++ ++ * typeck.c (build_c_cast): Don't strip NOPs if we're converting to a ++ reference type. ++ ++ * parse.y (structsp): Put back error for 'struct B: public A;'. ++ ++Wed Feb 1 23:02:06 1995 Mike Stump ++ ++ * except.c: Add support for mips systems that don't define __mips ++ but do define mips, like Ultrix. ++ ++Wed Feb 1 22:39:07 1995 Mike Stump ++ ++ * except.c: Add support for exception handling on the Alpha. ++ ++Wed Feb 1 10:12:14 1995 Mike Stump ++ ++ * decl2.c (finish_file): Fix bug in Jan 31st change. ++ ++Tue Jan 31 16:59:15 1995 Gerald Baumgartner ++ ++ * sig.c (build_signature_pointer_or_reference_type): Don't set ++ IS_AGGR_TYPE for signature pointers/reference so expand_default_init ++ doesn't expect to find a copy constructor. ++ * call.c (build_method_call): Treat signature pointers/reference ++ as if IS_AGGR_TYPE were set. ++ ++Tue Jan 31 13:28:56 1995 Mike Stump ++ ++ * gc.c (get_typeid): Pawn off error messages to build_t_desc. ++ (build_t_desc): Inform the user here if they try and build ++ with -frtti and don't include . ++ ++ * decl2.c (finish_prevtable_vardecl): Support rescanning. ++ (finish_file): Move finish_prevtable_vardecl up to before the global ++ initializers are done as tdecls are initialized in the global ++ initializer. Also Pick up any new tdecls or vtables needed by ++ synthesized methods. ++ ++ * class.c (finish_struct): Simplify. We have to do rtti scanning at ++ end, so we might as well do all of it there. ++ ++Tue Jan 31 05:35:02 1995 Jason Merrill ++ ++ * call.c (build_method_call): Fix -fthis-is-variable for 32-bit ++ targets, too. ++ ++Tue Jan 31 00:11:04 1995 Mike Stump ++ ++ * decl2.c (finish_prevtable_vardecl): New routine, mostly split from ++ finish_vtable_vardecl. It has the first half functionality from ++ that routine. ++ * decl2.c (finish_vtable_vardecl): Update to not include stuff not ++ in finish_prevtable_vardecl. ++ * decl2.c (finish_file): Call finish_prevtable_vardecl. ++ * gc.c (build_generic_desc): Allow it to be called when not at the ++ global binding layer, but behave as if we were. ++ (build_t_desc): Rearrange a bit so that it really works and is ++ easier to follow. ++ * class.c (finish_struct): Don't decide on tdecls here, as we have ++ to wait until the end of the file in general to decide whether or ++ not they come out. ++ ++Mon Jan 30 01:00:40 1995 Jason Merrill ++ ++ * init.c (build_delete): Check access to operator delete before ++ calling the destructor. ++ * method.c (build_opfncall, DELETE_EXPR): build_method is allowed to ++ return error_mark_node. ++ * call.c (build_method_call): Use the one-argument op delete even if ++ it's an error. ++ ++ * init.c (build_new): Fix -fthis-is-variable support. ++ * call.c (build_method_call): Likewise. ++ ++ * call.c (convert_harshness): Make conversion from a pointer to bool ++ worse than conversion to another pointer. ++ ++Sat Jan 28 16:46:10 1995 Jason Merrill ++ ++ * init.c (build_new): Check new return value if -fcheck-new. ++ ++ * lex.c (check_newline): Clear end_of_file when we're done, too. ++ ++Sat Jan 28 10:38:39 1995 Mike Stump ++ ++ * decl2.c (finish_vtable_vardecl): Make rtti TD tables follow ++ vtables whereever they go. ++ ++ * gc.c (build_t_desc): Remove old way of setting it up, as it wasn't ++ right. ++ ++Sat Jan 28 09:10:44 1995 Mike Stump ++ ++ * decl2.c (finish_vtable_vardecl): Now set the ++ interface/implementation of vtables on the first virtual function, ++ if one exists, otherwise we use the old method. This is a major win ++ in terms of cutting down the size of objects and executables in ++ terms of text space and data space. Now most of the savings that ++ #pragma interface/implementation gives is automatic in a fair number ++ of cases. ++ ++Sat Jan 28 04:57:33 1995 Jason Merrill ++ ++ * decl.c (grokdeclarator): Discard the template parameters in a ++ template constructor declaration so that the function is always ++ named constructor_name (ctype). ++ ++ * lex.c (check_newline): Use ungetc to put back the character before ++ calling HANDLE_PRAGMA. ++ ++Fri Jan 27 17:23:47 1995 Mike Stump ++ ++ * decl2.c (check_classfn): If the cname is T and fn_name is T, ++ make sure we still match them. ++ ++Fri Jan 27 16:32:10 1995 Jason Merrill ++ ++ * parse.y: Add END_OF_LINE token. ++ ++ * lex.c (check_newline): Set linemode when we see a # directive, and ++ unset it when we're done. Turn all 'return's into 'goto skipline'. ++ Fix all uses of '\n', since we won't see it anymore. Put back the ++ character we read before checking for a sysv or target pragma. ++ (real_yylex): If we see an EOF in linemode, return END_OF_LINE. ++ (handle_sysv_pragma): Don't look at the input stream; quit when we ++ see an END_OF_LINE token. ++ ++ * input.c (getch): Return EOF if we're in line mode and at the end ++ of a line. ++ (put_back): Don't put back an EOF. ++ ++Thu Jan 26 19:26:34 1995 Mike Stump ++ ++ * except.c (expand_throw): Do the newing of the exception object ++ before we load the type descriptor or the address so that we don't ++ wipe any of the values out. ++ ++Thu Jan 26 19:20:00 1995 Mike Stump ++ ++ * except.c (init_exception_processing): Don't use r12 on the rs6000. ++ ++Tue Jan 24 16:36:31 1995 Jason Merrill ++ ++ * decl.c (grokparms): Don't try to build up a reference at this point. ++ ++ * typeck2.c (build_functional_cast): Don't assume that a NOP_EXPR ++ will suffice to convert from integer_zero_node. ++ ++Wed Jan 25 15:02:09 1995 David S. Miller ++ ++ * class.c (instantiate_type): Change error message text. ++ * typeck2.c (store_init_value): Likewise. ++ ++Mon Jan 23 21:57:14 1995 Mike Stump ++ ++ * pt.c (tsubst): When we copy a node, don't forget to copy ++ TREE_CHAIN, we use it later. ++ ++Mon Jan 23 03:33:47 1995 Jason Merrill ++ ++ * typeck.c (convert_for_assignment): Initialize variable before use. ++ ++Fri Jan 20 01:17:59 1995 Jason Merrill ++ ++ * g++.c (main): Link with both libstdc++ and libg++ if called as ++ something ending with "g++", otherwise only libstdc++. Move -lm to ++ the end of the line. ++ ++Thu Jan 19 15:43:11 1995 Jason Merrill ++ ++ * call.c (build_method_call): Don't mess with 'this' before calling ++ compute_conversion_costs. ++ ++Wed Jan 18 15:40:55 1995 Jason Merrill ++ ++ * search.c (get_matching_virtual): Give line number for previous ++ declaration. ++ ++ * call.c (convert_harshness): Handle conversions to references ++ better. ++ ++ * cvt.c (build_up_reference): OK, handle {MIN,MAX}_EXPR *properly*. ++ ++Wed Jan 18 15:21:38 1995 Mike Stump ++ ++ * class.c (instantiate_type): Use DECL_CHAIN to walk lists instead, ++ as the TREE_CHAIN for methods will take us to the next differently ++ named function, DECL_CHAIN won't. ++ ++Wed Jan 18 14:26:59 1995 Jason Merrill ++ ++ * tree.c (lvalue_p): Handle {MIN,MAX}_EXPR. ++ ++ * decl2.c (lang_decode_option): -Wall implies -Wparentheses. ++ warn_parentheses defaults to 0. ++ ++ * decl.c (grokparms): Put back call to require_instantiated_type. ++ ++Tue Jan 17 19:56:15 1995 Mike Stump ++ ++ * except.c (exception_section): Use the data section on the rs6000. ++ Change calling convention for named_section. ++ ++Wed Jan 17 18:20:57 1994 Fergus Henderson ++ ++ * cp-tree.h: Make if (x=0) warn with wall ++ * parse.y: Make if (x=0) warn with wall ++ ++Tue Jan 17 14:12:00 1995 Jason Merrill ++ ++ * decl.c (BOOL_TYPE_SIZE): BITS_PER_WORD if SLOW_BYTE_ACCESS, ++ BITS_PER_UNIT otherwise. ++ ++ * search.c (get_matching_virtual): Don't check the binfo if the ++ types are the same. ++ ++ * cvt.c (cp_convert): Just call truthvalue_conversion to convert to ++ bool. ++ ++Mon Jan 16 13:28:48 1995 Jason Merrill ++ ++ * various: Use boolean_type_node, boolean_true_node, ++ boolean_false_node. ++ ++ * search.c (get_matching_virtual): Allow covariant returns that ++ don't require pointer adjustment. ++ ++ * typeck.c (build_conditional_expr): Don't call default_conversion ++ on ifexp. ++ ++ * cvt.c (build_up_reference): Handle MIN_EXPR and MAX_EXPR. ++ ++ * decl.c (grokdeclarator): Upgrade warning about &const to pedwarn. ++ ++Sun Jan 15 22:17:32 1995 David Binderman ++ ++ * pt.c (do_function_instantiation): Free targs once we're done. ++ ++Sun Jan 15 22:17:32 1995 Jason Merrill ++ ++ * decl.c (BOOL_TYPE_SIZE): Defaults to BITS_PER_WORD. ++ (init_decl_processing): Use BOOL_TYPE_SIZE instead of CHAR_TYPE_SIZE ++ for bool. ++ ++Sat Jan 14 05:33:55 1995 Jason Merrill ++ ++ * decl2.c (finish_file): We need to mess up if there are any ++ variables in the list, not just if there is one with a constructor. ++ ++Fri Jan 13 14:42:55 1995 Jason Merrill ++ ++ * decl.c (duplicate_decls): Propagate DECL_STATIC_{CON,DE}STRUCTOR. ++ (finish_function): Handle DECL_STATIC_{CON,DE}STRUCTOR. ++ (finish_function): Trust rest_of_compilation. ++ ++ * decl2.c (finish_file): Also call functions designated as static ++ constructors/destructors. ++ ++ * decl.c (grokdeclarator): Allow access decls of operator functions. ++ (grokparms): Only do convert_for_initialization if the initializer ++ has a type. ++ (duplicate_decls): Put back push_obstacks_nochange call. ++ ++ * lex.c (real_yylex): Downgrade complaint about the escape sequence ++ being too large from pedwarn to warning. ++ ++ * decl.c (grokdeclarator): Don't complain about long long in system ++ headers. ++ ++ * lex.c (real_yylex): Handle digraphs. ++ ++Thu Jan 12 12:17:24 1995 Jason Merrill ++ ++ * decl.c (init_decl_processing): -f{no-,}strict-prototype only ++ affects C linkage declarations now. ++ ++ * typeck.c (comp_target_types): Grok simple contravariant conversions. ++ (common_type): t1 and t2 are interchangeable. ++ ++ * various: Test return value of comp_target_types differently in ++ different places; it now returns -1 for a contravariant conversion ++ (which is fine in symmetric cases). ++ ++ (common_type): Prefer long double to double even when ++ they have the same precision. ++ ++ * decl.c (grokparms): Call convert_for_initialization to check ++ default arguments. ++ ++ * init.c (build_new): void_type_node has a size (of 0). ++ ++ * decl.c (decls_match): Also check for agreement of TREE_READONLY ++ and TREE_THIS_VOLATILE. ++ (push_class_level_binding): Properly handle shadowing of ++ nested tags by fields. ++ ++ * search.c (dfs_pushdecls): Likewise. ++ ++ * decl2.c (finish_file): Don't second-guess self-initialization. ++ ++ * cvt.c (convert_to_reference): Work with expr directly, rather than ++ a copy. ++ ++ * decl.c (push_overloaded_decl): Only shadow artificial TYPE_DECLs. ++ ++ * init.c (add_friend): Downgrade duplicate friend message from ++ pedwarn to warning. ++ ++ * decl.c (duplicate_decls): Push obstacks before calling common_type. ++ ++Thu Jan 12 17:15:21 1995 Michael Ben-Gershon ++ ++ * except.c (push_eh_entry): Set LABEL_PRESERVE_P flag for ++ exception table labels. ++ (expand_start_all_catch): Likewise. ++ (expand_leftover_cleanups): Likewise. ++ (expand_end_catch_block): Likewise. ++ * except.c (make_first_label): New function. ++ (expand_start_all_catch): Add a call to make_first_label() before ++ using a label as a jump destination. ++ (expand_end_all_catch): Likewise. ++ (expand_leftover_cleanups): Likewise. ++ (expand_end_catch_block): Likewise. ++ (expand_builtin_throw): Likewise. ++ (expand_throw): Likewise. ++ * except.c: Add ARM processor support for exception handling. ++ ++Thu Jan 12 12:17:24 1995 Jason Merrill ++ ++ (complete_array_type): Copy code from C frontend. ++ ++ * lex.c (real_yylex): Don't multiply the length of a wide string ++ literal by WCHAR_BYTES. ++ ++ * decl.c (pushdecl): Check for redeclaration of wchar_t here. ++ (duplicate_decls): Instead of here. ++ (define_label): Complain about a label named wchar_t. ++ (grokdeclarator): Complain about declarations of ++ operator-function-ids as non-functions. ++ ++ * typeck.c (unary_complex_lvalue): Also wrap prefix -- and ++ in ++ COMPOUND_EXPRs. ++ (build_unary_op): Wrap unary plus in a NON_LVALUE_EXPR. ++ ++ * lex.c (real_yylex): Don't skip whitespace when reading the next ++ character after ->. ++ ++Wed Jan 11 16:32:49 1995 Mike Stump ++ ++ * except.c: Allow cc1plus to be built with native compiler on rs6000. ++ (expand_start_all_catch): Add assemble_external calls for various ++ routines we call. ++ (expand_leftover_cleanups): Likewise. ++ (expand_start_catch_block): Likewise. ++ (do_unwind): Likewise. ++ (expand_builtin_throw): Likewise. ++ ++Wed Jan 11 01:05:42 1995 Jason Merrill ++ ++ * decl.c (pushtag): Only look for a previous decl in the current ++ binding level. Use explicit global scope in DECL_NESTED_TYPENAME. ++ ++ * gxx.gperf: Add __signature__ and __sigof__ keywords. ++ ++ * decl2.c (lang_decode_option): -ansi does not set flag_no_asm. It ++ does set flag_no_gnu_keywords and flag_operator_names. ++ ++ * lex.c (init_lex): 'overload' is not a keyword unless -traditional. ++ Unset extension keywords if -fno-gnu-keywords. ++ Allow operator names ('bitand') if -foperator-names. ++ Never unset 'asm'; -fno-asm only affects 'typeof'. ++ ++ * decl.c (lookup_name_real): The got_object special lookup only ++ applies to types. ++ ++Tue Jan 10 18:07:51 1995 Jason Merrill ++ ++ * spew.c (yylex): Also use DECL_NESTED_TYPENAME if got_object is set. ++ ++ * parse.y (primary): Unset got_object after all rules that use the ++ 'object' nonterminal. ++ (object): Set got_object. ++ ++ * lex.h: Declare got_object. ++ ++ * decl.c (lookup_name_real): Also lookup names in the context of an ++ object specified. ++ ++Tue Jan 10 14:30:30 1995 Mike Stump ++ ++ * typeck.c (get_member_function_from_ptrfunc): Use ptrdiff_type_node ++ for things that have to be added to pointers, not size_type. Cures ++ problems with pointer to members on Alphas. ++ (build_binary_op_nodefault): Likewise. ++ (get_delta_difference_: Likewise. ++ (build_ptrmemfunc): Likewise. ++ ++Tue Jan 10 01:49:25 1995 Jason Merrill ++ ++ * decl.c (pushtag): Stick the new decl in TYPE_NAME before pushing ++ it. ++ ++ * typeck.c (build_component_ref): Don't build up a COMPONENT_REF ++ when dealing with overloaded member functions; just act like ++ build_offset_ref. ++ (commonparms): Remove misleading comment. ++ ++ * decl.c (duplicate_decls): Complain about repeated default ++ arguments here. ++ (redeclaration_error_message): Instead of here. ++ (pushdecl): Complain about missing default arguments here. ++ (grokparms): Instead of here. ++ (lookup_name_current_level): Also match on DECL_ASSEMBLER_NAME. ++ (grok_reference_init): Do not complain about missing initializer if ++ declared 'extern'. ++ ++ * search.c (lookup_field): Don't return a TYPE_DECL if there is a ++ function alternative and want_type is not set. ++ ++Mon Jan 9 18:16:23 1995 Jason Merrill ++ ++ * decl.c (pushtag): Don't set TYPE_NAME to an identifier. Do push ++ the decl when the type has no TYPE_NAME. ++ (lookup_nested_type): Don't assume that type has TYPE_NAME set. ++ (lookup_name_real): Call lookup_field with want_type = ++ prefer_type. ++ ++ * search.c (lookup_field): Handle want_type properly in the presence ++ of fields with the same name. ++ ++ * decl.c (set_nested_typename): Set nested name for file-scope types ++ to include leading ::. ++ (pushdecl): Set the nested typename if the decl doesn't have one, ++ rather than if the type's canonical decl doesn't have one. ++ ++Mon Jan 9 03:44:33 1995 Jason Merrill ++ ++ * typeck.c (convert_for_assignment): Complain about contravariance ++ violation here. ++ (comp_target_types): Instead of here. ++ (build_unary_op): resolve_offset_ref before checking for a valid ++ type. ++ ++ * spew.c (yylex): Decrement looking_for_typename after we see a ++ _DEFN. ++ ++ * decl.c (pushdecl): Don't install an artificial TYPE_DECL in ++ IDENTIFIER_LOCAL_VALUE if we already have a decl with that name. ++ ++ * typeck.c (convert_for_assignment): Converting pointers to bool ++ does not need a cast. ++ ++Sun Jan 8 18:16:45 1995 Jason Merrill ++ ++ * class.c (instantiate_type): Initialize nsubsts parm. ++ ++ * pt.c (do_function_instantiation): Likewise. ++ ++Sat Jan 7 14:37:05 1995 Jason Merrill ++ ++ * pt.c (tsubst): Use TREE_STATIC instead of DECL_INLINE && ++ DECL_SAVED_INSNS to determine whether or not we've seen a definition ++ of this function. ++ (instantiate_template): Likewise. ++ ++ * call.c (convert_harshness): Allow const reference binding when ++ called from the overloading code, but not when called from ++ can_convert (since it isn't a conversion). ++ (convert_harshness): Put back some disabled code. ++ ++Fri Jan 6 14:10:57 1995 Jason Merrill ++ ++ * call.c (convert_harshness): There is no implicit conversion from ++ void* to other pointer types (unless the parameter is (void*)0). ++ (convert_harshness): Non-lvalues do not convert to reference types. ++ ++ * class.c (finish_struct_methods): Still set ++ TYPE_HAS_{INT,REAL}_CONVERSION. ++ ++ * call.c (can_convert): Don't use aggregate initialization. ++ ++ * cp-tree.h: Declare lookup_conversions. ++ ++Thu Jan 5 21:08:00 1995 Mike Stump ++ ++ * parse.y (simple_stmt): Fix duplicate case value error messages to ++ be more readable. ++ ++Wed Jan 4 16:44:19 1995 Jason Merrill ++ ++ * cvt.c (build_type_conversion): Total rewrite to use ++ convert_harshness instead of reproducing conversion logic here. Now ++ much shorter. ++ ++ * call.c (convert_harshness): Support conversions to bool. ++ (can_convert): Checks whether a conversion is less harsh ++ than USER_CODE, for build_type_conversion. ++ ++ * search.c (add_conversions): Function for passing to dfs_walk which ++ adds all the type conversion operators in the current type to a list. ++ (lookup_conversions): Calls dfs_walk with add_conversions and return ++ the list. ++ (dfs_walk): Don't require a qfn. ++ ++ * cp-tree.h: Lose CLASSTYPE_CONVERSIONS hackery. ++ (CLASSTYPE_FIRST_CONVERSION): Points to elt 1 of CLASSTYPE_METHOD_VEC. ++ ++ * class.c (finish_struct_bits): Lose CLASSTYPE_CONVERSIONS hackery. ++ (grow_method): A separate function for building onto the growing ++ method vector. ++ (finish_struct_methods): Use it. Put all type conversion operators ++ right after the constructors. Perhaps we should sort the methods ++ alphabetically? ++ ++Mon Jan 2 14:42:58 1995 Jason Merrill ++ ++ * call.c (build_method_call): Lose another misleading shortcut. ++ ++Fri Dec 30 17:57:30 1994 Mike Stump ++ ++ * gc.c (build_bltn_desc): Handle bool as a built-in type. ++ ++Fri Dec 30 14:20:21 1994 Mike Stump ++ ++ * tree.c (layout_vbasetypes): Ensure that we don't loose alignment ++ on the complete type because of small virtual bases. ++ ++Fri Dec 30 12:22:29 1994 Mike Stump ++ ++ * decl.c (n_incomplete): Bump n_incomplete up to int to match C ++ front end. ++ (pushdecl): Also count decls pushed that are of a type being defined ++ as incomplete things. ++ * class.c (finish_struct): Move hack_incomplete_structures up to ++ just after we set it as not being defined, so that the decls we ++ build for RTTI don't count as incomplete. ++ ++Thu Dec 29 18:20:57 1994 Mike Stump ++ ++ * pt.c (tsubst): Fix problem with defining constructors in templated ++ classes with virtual bases. ++ ++Wed Dec 28 08:31:00 1994 Mike Stump ++ ++ * parse.y (TYPEID): Strip top-level cv-qualifiers on typeid ++ expressions. ++ * gc.c (build_typeid): Likewise. ++ ++Thu Dec 22 17:26:33 1994 Mike Stump ++ ++ * cvt.c (build_up_reference): Fix breakage introduced on Nov 29, ++ don't assert on complex AGGR inits. ++ ++Thu Dec 22 14:32:31 1994 Mike Stump ++ ++ * method.c (build_overload_value): Handle pointer to members as ++ template arguments. ++ ++Thu Dec 22 13:09:07 1994 Mike Stump ++ ++ * typeck.c (unary_complex_lvalue): Don't call sorry if we know how ++ to do take the address of a data member for a pointer to data ++ member. ++ ++Thu Dec 22 10:04:19 1994 Mike Stump ++ ++ * decl.c (grokdeclarator): Use the typedef name for linkage if the ++ type doesn't otherwise have a name. ++ ++ * decl2.c (grokfield): Likewise. ++ ++ * class.c (finish_struct): Since we reuse the TYPE_DECL for the ++ DECL_NAME of enums, structs and classes, we have to avoid trying to ++ put it in the TYPE_FIELDS again. ++ ++Wed Dec 21 11:07:05 1994 Mike Stump ++ ++ * decl2.c (check_classfn): Ignore this parameter on static functions ++ when checking to see if we match. ++ ++Tue Dec 20 17:47:02 1994 Mike Stump ++ ++ * typeck.c (unary_complex_lvalue): Handle address of non-left most ++ pointers to members by calling get_delta_difference. ++ ++Mon Dec 19 22:40:53 1994 Mike Stump ++ ++ * decl2.c (check_classfn): Don't use decls_match yet, as it modifies ++ static functions to early. ++ ++Thu Dec 19 22:37:48 1994 Mike Stump ++ ++ * method.c (make_thunk): Handle encoding of positive thunk offsets. ++ ++Sat Dec 17 13:29:50 1994 Doug Evans ++ ++ * Make-lang.in (.PHONY): Tell GNU make C++ and c++ are phony targets. ++ ++Thu Dec 15 16:32:12 1994 Mike Stump ++ ++ * decl2.c (check_classfn): Use decls_match to check if this has ++ already been declared, as the DECL_ASSEMBLER_NAME may have been ++ changed via asm("new_name"). ++ * decl.c (decls_match): Make public. ++ ++Thu Dec 15 15:17:55 1994 Mike Stump ++ ++ * *.[chy] (expand_aggr_init): Add fourth argument to handle ++ distinction between = init and (init) style of initializations. ++ * *.[chy] (finish_decl): Add fifth argument to handle ++ distinction between = init and (init) style of initializations. ++ ++Tue Dec 13 19:16:05 1994 Mike Stump ++ ++ Fix some random `explicit' bugs. ++ ++ * cvt.c (convert_to_reference): Add third parameter to ++ convert_force. ++ (convert_force): Likewise. ++ * call.c (build_method_call): Likewise. ++ * decl2.c (setup_vtbl_ptr): Likewise. ++ * init.c (expand_virtual_init): Likewise. ++ (build_member_call): Likewise. ++ (build_delete): Likewise. ++ (build_vbase_delete): Likewise. ++ * typeck.c (build_component_addr): Likewise. ++ (build_c_cast): Likewise. ++ (build_modify_expr): Likewise. ++ * cp-tree.h (CONV_NONCONVERTING): Likewise. Add so that we can ++ distinguish the context in which the conversion appears. Add thrid ++ argument to build_c_cast. ++ * cvt.c (cp_convert): Pass whether or not we want to consider ++ non-converting constructors down to build_method_call. ++ * decl2.c (reparse_absdcl_as_casts): Add third argument to ++ build_c_cast. ++ * gc.c (build_m_desc): Likewise. ++ * init.c (build_new): Likewise. ++ * parse.y (expr_no_commas): Likewise. ++ (primary): Likewise. ++ * typeck.c (build_x_function_call): Likewise. ++ (build_static_cast): Likewise. ++ (build_reinterpret_cast): Likewise. ++ (build_const_cast): Likewise. ++ (build_c_cast): Likewise. ++ (build_ptrmemfunc): Likewise. ++ * typeck2.c (build_functional_cast): Likewise. ++ * init.c (expand_aggr_init): Added LOOKUP_ONLYCONVERTING to ++ expand_aggr_init_1 as inits are converted to the destination type. ++ ++Tue Dec 13 16:18:57 1994 Jason Merrill ++ ++ * Make-lang.in (cc1plus): Depends on c-pragma.o. ++ ++ * Makefile.in (OBJ{DEP,}S): Add ../c-pragma.o. ++ ++ * lex.c (check_newline): If the #pragma is not recognized by g++, ++ try machine-specific ones too. ++ (handle_sysv_pragma): Copied from c-lex.c. ++ ++Mon Dec 12 23:53:06 1994 Mike Stump ++ ++ * except.c (expand_throw): Fix Dec 6th change, build_new likes a ++ reference better. ++ ++Mon Dec 12 18:01:00 1994 Jason Merrill ++ ++ * typeck.c (build_binary_op): Lose checks on TYPE_PTRMEMFUNC_P with ++ IS_AGGR_TYPE, since now they will not both be set on the same type. ++ ++ * pt.c (do_pending_expansions): Don't clear TREE_PUBLIC on ++ instantiations controlled by -fexternal-templates. ++ ++ * decl.c (duplicate_decls): Don't complain about different values of ++ __attribute__ ((const)) and ((noreturn)). ++ ++Fri Dec 9 18:17:37 1994 Doug Evans ++ ++ * Makefile.in (BISONFLAGS): Delete --yacc. ++ (PARSE_H): Depend on $(PARSE_C), for parallel makes. ++ (PARSE_C): Undo last patch. ++ ++Fri Dec 2 10:44:36 1994 Mike Stump ++ ++ * Makefile.in (BISONFLAGS): Add --yacc so that output winds up in ++ y.tab.c. ++ ++Thu Dec 8 17:39:46 1994 Jason Merrill ++ ++ * decl.c (finish_decl): Don't call obscure_complex_init for decls ++ of indeterminate size. ++ ++Wed Dec 7 16:49:22 1994 Jason Merrill ++ ++ * decl.c (obscure_complex_init): Function to tweak the decl to ++ prevent expand_decl from tring to initialize it. ++ (finish_decl): Use it rather than writing the same code in three ++ different places. ++ ++ * parse.y (bad_parm): Stop trying to support parms without types. ++ ++Wed Dec 7 12:06:56 1994 Mike Stump ++ ++ * decl2.c (grokfield): Make asm specs on static member functions ++ work. ++ ++Tue Dec 6 15:43:20 1994 Mike Stump ++ ++ * except.c (expand_throw): Make a copy of the thrown object. ++ ++Tue Dec 6 14:16:34 1994 Jason Merrill ++ ++ * parse.y: : Has lower precedence than =. ++ ++Tue Dec 6 12:46:17 1994 Mike Stump ++ ++ * decl.c (pushdecl): Use DECL_NAME of VAR_DECLs to avoid namespace ++ manglings. ++ (grokvardecl): Add namespace into variable name. ++ ++Tue Dec 6 11:26:55 1994 Mike Stump ++ ++ * decl2.c (current_namespace_id): New routine to transform a simple ++ name into a name in a namespace. ++ * decl.c (grokdeclarator): Use it. ++ * decl2.c (get_namespace_id): Find the name of the current ++ namespace. ++ (push_namespace, pop_namespace): Complete out missing ++ functionality. ++ ++Mon Dec 5 17:11:51 1994 Jason Merrill ++ ++ * class.c (finish_struct): Don't use LONG_LONG_TYPE_SIZE, as it may ++ not be defined. Fix warning message for enums and restore warning ++ for non-enums. ++ ++ * decl2.c (push_namespace): Dummy function. ++ (pop_namespace): Likewise. ++ (do_namespace_alias): Likewise. ++ (do_using_decl): Likewise. ++ (do_using_directive): Likewise. ++ ++ * parse.y: New token NSNAME for namespace names. ++ (extdef): Add namespace, using definitions. ++ (using_decl): New rule for using declarations. ++ (any_id): New rule for identifiers with any degree of scoping. ++ (identifier): Add NSNAME. ++ (notype_identifier): Likewise. ++ (component_decl): Add using_decl. ++ (nested_name_specifier): Add NSNAME SCOPE. ++ ++ * typeck.c (convert_for_assignment): Handle conversions between ++ enums and bool. ++ ++ * decl.c (duplicate_decls): Only propagate DECL_MAIN_VARIANT on ++ FUNCTION_DECLs. ++ ++Mon Dec 5 13:03:16 1994 Mike Stump ++ ++ * class.c (finish_struct): Give an error if one tries to declare a ++ bit-field's size greater than a long long, as the backend will dump. ++ It is not an error to declare an enum bit-field greater than its ++ precision. Warn if an enum bit-field is too small to hold all ++ its values. ++ ++Mon Dec 5 11:41:50 1994 Mike Stump ++ ++ * typeck.c (convert_for_assignment): Use cp_convert instead of ++ convert so that we don't get static casts. ++ ++Sun Dec 4 11:59:01 1994 Mike Stump ++ ++ * cvt.c (cp_convert): Don't complain about int->enum conversion if ++ we are doing static casts. ++ ++Fri Dec 2 18:32:41 1994 Mike Stump ++ ++ * error.c (dump_expr): Do something more intelligent with SAVE_EXPRs ++ when dumping expressions in error messages. ++ ++Fri Dec 2 17:04:27 1994 Mike Stump ++ ++ * gc.c (build_dynamic_cast): Change interface to libg++, ensure that ++ the return type is the right type, and make references work. ++ ++Fri Dec 2 16:36:43 1994 Jason Merrill ++ ++ * decl.c (poplevel): Don't be confused by function-scope ++ declarations of non-nested functions. ++ (duplicate_decls): Propagate DECL_MAIN_VARIANT. ++ (pushdecl): Use duplicate_decls to copy info from old decl into new ++ function-scope one rather than doing it here. ++ ++ * decl2.c (mark_inline_for_output): Deal with the DECL_MAIN_VARIANT ++ of this decl, in case this is a function-scope declaration. ++ ++ * decl.c (finish_enum): Make sure that the type has the right ++ precision when we call fixup_*_type. ++ ++Tue Nov 29 19:12:07 1994 Jason Merrill ++ ++ * cvt.c (build_up_reference): Strip superfluous NOP_EXPRs; we do ++ want to build up references to rvalues if possible. ++ (cp_convert): Stick on a NOP_EXPR when converting to the same type. ++ ++Tue Nov 29 11:28:59 1994 Mike Stump ++ ++ * parse.y (maybe_raises): Handle throw (). ++ * parse.y (ansi_raise_identifier): Grok type-ids in exception ++ specifications. ++ * tree.c (build_exception_variant): Use list compare to check if ++ two exception specifications match. ++ * decl.c (duplicate_decls, bad_specifiers): Enhance wording on error ++ messages. ++ * call.c (build_method_call): Remove TREE_RAISES. ++ * cvt.c (convert_to_aggr): Likewise. ++ * typeck.c (build_function_call_real, convert_arguments): Likewise. ++ * init.c (expand_aggr_init_1): Likewise. ++ ++Tue Nov 29 09:50:39 1994 Mike Stump ++ ++ * except.c: Add support for m68k and mips exception handling ++ support. ++ ++Tue Nov 29 08:48:33 1994 Mike Stump ++ ++ * except.c (expand_end_all_catch): Throw into outer context, if we ++ fall off end of catch handlers. ++ ++Mon Nov 28 16:44:41 1994 Mike Stump ++ ++ * Makefile.in: Make is easier to decide where parse.[ch] will be ++ built. ++ ++Thu Nov 17 20:11:24 1994 Doug Evans ++ ++ * cp/Make-lang.in (CXX_INSTALL_NAME): Use program_transform_name. ++ (GXX_INSTALL_NAME): Likewise. ++ (CXX_CROSS_NAME): Use program_transform_cross_name. ++ (GXX_CROSS_NAME): Likewise. ++ (c++.install-man): Use program_transform_name on g++.1. ++ (c++.uninstall): Likewise. ++ ++Mon Nov 28 13:53:03 1994 Mike Stump ++ ++ * parse.y (THROW): Fix precedence of throw expressions. ++ ++Mon Nov 28 13:15:16 1994 Mike Stump ++ ++ * typeck.c (build_unary_op): Allow promotions from bool to int on ++ unary ~. ++ ++Sun Nov 27 00:16:21 1994 Jason Merrill ++ ++ * method.c (build_overload_name): Use DECL_ASSEMBLER_NAME for ++ classes when appropriate. ++ (build_overload_nested_name): When dealing with a function context, ++ use ASM_FORMAT_PRIVATE_NAME to tweak the name of the function to ++ avoid conflicts between local classes of the same name. ++ ++Wed Nov 23 17:59:42 1994 Mike Stump ++ ++ * gxx.gperf, parse.y, lex.h, hash.h, lex.c (init_lex), delc.c ++ (duplicate_decls, grokdeclarator), cp-tree.h: Add support for ++ `explicit'. ++ * cvt.c (convert_to_reference, cp_convert, build_type_conversion_1, ++ build_type_conversion): Use LOOKUP_ONLYCONVERTING in ++ build_method_calls so that non-converting constructors are not used. ++ * call.c (build_method_call): If we shouldn't use a non-converting ++ constructor, then don't. ++ ++Wed Nov 23 14:46:56 1994 Jason Merrill ++ ++ * call.c (build_method_call): Don't try to synthesize methods yet. ++ ++Tue Nov 22 12:45:21 1994 Jason Merrill ++ ++ * pt.c (push_template_decls): Create CONST_DECLs for template ++ constant parameters, not VAR_DECLs. ++ ++Sat Nov 19 15:28:31 1994 Jim Wilson ++ ++ * typeck.c (build_binary_op_nodefault): Can shorten shift only if ++ shift count is less than size in bits of arg0. ++ ++Thu Nov 17 15:30:50 1994 Mike Stump ++ ++ * gxx.gperf, hash.h, lex.c (init_lex, real_yylex), parse.y: Add new ++ ANSI keywords and, and_eq, bitand, bitor, explicit, namespace, not, ++ not_eq, or, or_eq, typename, using, xor, xor_eq to g++. Still need ++ to add support for explicit, namespace, typename, and using, support ++ for the rest is already in. ++ ++Fri Nov 4 19:04:18 1994 Mike Stump ++ ++ * gc.c (get_bad_cast_node): New routine to support compile time ++ throws of bad_cast. ++ * gc.c (build_dynamic_cast): Support throwing of bad_cast at compile ++ time. ++ ++Fri Nov 4 11:12:00 1994 Mike Stump ++ ++ * except.c: Add hppa support. ++ ++Fri Nov 4 10:50:50 1994 Mike Stump ++ ++ * except.c: Add rs6000 support. ++ ++Thu Nov 3 14:24:23 1994 Mike Stump ++ ++ * except.c (do_unwind): Add i[34]86 support. ++ ++Thu Nov 3 00:10:46 1994 Jason Merrill ++ ++ * pt.c (do_pending_expansions): Unset TREE_PUBLIC on implicit ++ instantiations. ++ ++Wed Nov 2 15:08:24 1994 Kung Hsu ++ ++ * decl.c (finish_function): Emit types used in method parameters ++ into symbol table. ++ ++Wed Nov 2 15:05:47 1994 Jason Merrill ++ ++ * pt.c (process_template_parm): Allow pointer to member function ++ template parameter types. ++ (uses_template_parms): Handle pointer to member function ++ CONSTRUCTORs. ++ ++ * g++.c (main): Cast first argument of bzero to (char *). ++ Pass -lstdc++ instead of -lg++ unless we are invoked as 'g++'. ++ ++Mon Oct 31 14:50:48 1994 Kung Hsu ++ ++ * gc.c (build_dynamic_cast): Rewrite to make it work. ++ * class.c (finish_vtbls): Build more vtables if flag_rtti is on. ++ * class.c (modify_all_direct_vtables): Likewise. ++ * init.c (expand_direct_vtbls_init): Expand more vtables if ++ flag_rtti is on. ++ * decl.c (init_type_desc): Add default return. ++ ++Tue Oct 25 17:13:09 1994 Kung Hsu ++ ++ * tree.c (debug_binfo): Get rid of the initial size entry of ++ vtable. ++ * cp-tree.h: Change flag_dossier to flag rtti, define type ++ descriptor type nodes. ++ * decl.c (init_type_desc): New function to initialize type ++ descriptor type nodes. ++ * decl.c (record_builtin_type): Change flag_dossier to flag_rtti. ++ * lex.c (init_lex): Likewise. ++ * decl.c: Change variable flag_dossier to flag_rtti. ++ * decl.c (duplicate_decls): Get rid initial size entry of vtable. ++ * decl.c (hack_incomplete_structures): Take out assert 164. ++ * search.c (get_abstract_virtuals_1): Likewise. ++ * search.c (dfs_init_vbase_pointers): Change CLASSTYPE_DOSSIER to ++ CLASSTYPE_RTTI. ++ * parse.y: Likewise. ++ * class.c (prepare_fresh_vtable): For virtual bases, get right ++ offset. ++ * class.c (add_virtual_function): Change flag_dossier to ++ flag_rtti. ++ * class.c (modify_one_vtable): Modify the right rtti entry. ++ * class.c (override_one_vtable): Get rid of size entry. ++ * class.c (finish_struct): Change flag_dossier to flag_rtti, and ++ build extra vtables, build type descriptors for polymorphic ++ classes. ++ * gc.c (build_headof): Make headof() works correctly with new ++ rtti. ++ * gc.c (build_typeid): Make this function work with new rtti. ++ * gc.c (get_typeid): Make this function work with new rtti. ++ * gc.c (build_bltn_desc): New function for new rtti. ++ * gc.c (build_user_desc): Likewise. ++ * gc.c (build_class_desc): Ditto. ++ * gc.c (build_ptr_desc): Ditto. ++ * gc.c (build_attr_desc): Ditto. ++ * gc.c (build_func_desc): Ditto. ++ * gc.c (build_ptmf_desc): Ditto. ++ * gc.c (build_ptmd_desc): Ditto. ++ * gc.c (build_t_desc): Ditto. ++ * gc.c: Comment out old build_t_desc, build_i_desc, build_m_desc. ++ ++Tue Oct 25 13:37:41 1994 Jason Merrill ++ ++ * call.c (convert_harshness): Check for TREE_UNSIGNED differences ++ after checking for integral conversions. ++ ++Wed Nov 30 19:13:50 1994 Mike Stump ++ ++ * Version 2.6.3 released. ++ ++Thu Nov 17 10:56:50 1994 Jason Merrill ++ ++ * typeck2.c (build_m_component_ref): Check the basetype of the ++ member pointer against the main variant of the object type. ++ ++Mon Nov 14 14:21:52 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): Make sure that the original expr ++ gets its type back when converting a reference. ++ ++ * method.c (build_overload_name): Clear numeric_outputed_need_bar here. ++ (build_decl_overload): Instead of here. ++ ++Tue Nov 8 17:11:24 1994 Jason Merrill ++ ++ * cvt.c (cp_convert): Don't build a TARGET_EXPR if we're not in a ++ function. ++ ++ * typeck.c (convert_for_initialization): Handle initialization from ++ a TARGET_EXPR. ++ ++Sun Nov 6 01:34:24 1994 Jason Merrill ++ ++ * pt.c (lookup_nested_type_by_name): Fix list-walking logic. ++ (tsubst): When replacing a TEMPLATE_TYPE_PARM, propagate ++ TYPE_READONLY and TYPE_VOLATILE from the argument. ++ (unify): When unifying with a TEMPLATE_TYPE_PARM, remove cv-quals ++ present in parm from arg. ++ (type_unification): Strip REFERENCE_TYPE from the argument type. ++ (unify): Don't strip REFERENCE_TYPE from the argument type. ++ ++Sat Nov 5 22:42:15 1994 Greg McGary ++ ++ * pt.c (do_type_instantiation): Check to see if there's a ++ IDENTIFIER_TEMPLATE on a class before calling ++ instantiate_member_templates(). ++ ++Sat Nov 12 06:35:42 1994 Mike Stump ++ ++ * Version 2.6.2 released. ++ ++Thu Nov 3 18:48:19 1994 Paul Eggert ++ ++ * Makefile.in (spew.o, lex.o, pt.o): ++ Depend on $(srcdir)/parse.h, not parse.h. ++ ++Tue Nov 1 19:19:41 1994 Mike Stump ++ ++ * Version 2.6.1 released. ++ ++Sun Oct 23 13:19:55 1994 Jason Merrill ++ ++ * decl2.c: Declare flag_access_control. ++ (struct lang_f_options): Add access-control. ++ * expr.c (cplus_expand_expr, NEW_EXPR): Unset flag_access_control ++ for the call to expand_aggr_init to copy the object out of the ++ pcc_struct_return slot. ++ * search.c (compute_access): if (!flag_access_control) return ++ access_public. ++ ++Fri Oct 21 00:32:54 1994 Jason Merrill ++ ++ * lex.c (cons_up_default_function): Don't try to defer method ++ synthesis now. ++ ++ * decl.c (init_decl_processing): Use __pure_virtual for abort_fndecl ++ instead of abort, since the OSF/1 dynamic linker doesn't like to see ++ relocation entries for abort. ++ ++ * tree.c (array_type_nelts_total): Use sizetype, not ++ integer_type_node. ++ (array_type_nelts_top): Likewise. ++ ++Thu Oct 20 15:48:27 1994 Mike Stump ++ ++ * decl.c (grokdeclarator): Added handling for catch parameters ++ (CATCHPARM). ++ * except.c (expand_start_catch_block): Use the new CATCHPARM context ++ instead of NORMAL. ++ * except.c (expand_throw): Don't let convert_to_reference complain ++ about what we are doing. ++ ++Thu Oct 20 12:55:24 1994 Jim Wilson ++ ++ * method.c (emit_thunk): Call instantiate_virtual_regs. ++ ++Wed Oct 19 14:15:33 1994 Mike Stump ++ ++ * except.c (expand_exception_blocks): Make sure throw code doesn't ++ get put in function that won't be output. ++ ++Mon Oct 17 18:03:15 1994 Jason Merrill ++ ++ * decl.c (init_decl_processing): Make alloca a builtin. ++ ++Thu Oct 27 21:10:25 1994 Craig Burley ++ ++ * g++.c (main): Only decrement "added" and set "library" to ++ NULL when "library" != NULL (just like 940829 fix). ++ ++Mon Oct 17 15:56:11 1994 Mike Stump ++ ++ * except.c (expand_start_catch_block): Make sure the false label ++ gets onto the permanent obstack, as it is used for the exception ++ table. ++ ++Fri Oct 14 18:54:48 1994 Mike Stump ++ ++ * class.c (modify_one_vtable): Since the DECL_CONTEXT of fndecl can ++ be set just below, use current_fndecl instead. ++ ++Fri Oct 14 15:12:22 1994 Jason Merrill ++ ++ * init.c (expand_aggr_vbase_init_1): Don't call expand_aggr_init_1 ++ with LOOKUP_SPECULATIVELY. ++ (expand_default_init): Abort if build_method_call returns NULL_TREE. ++ ++ * typeck.c (build_modify_expr): Don't just build a MODIFY_EXPR if ++ the rhs is a TARGET_EXPR. ++ ++ * parse.y (left_curly): Anonymous types are not affected by #pragma ++ interface/implementation. ++ ++ * method.c (synthesize_method): Don't call setup_vtbl_ptr for the ++ default constructor if it isn't needed. ++ ++ * lex.c (cons_up_default_function): Do synthesize methods for ++ anonymous types if necessary. ++ ++Thu Oct 13 17:44:55 1994 Jason Merrill ++ ++ * method.c (build_decl_overload): Set numeric_outputed_need_bar to 0. ++ ++Wed Oct 12 13:27:57 1994 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Understand how to copy an aggregate. ++ ++ * init.c (expand_default_init): Likewise. Also remove some of the ++ crufty code that assumes methods will not be synthesized properly. ++ ++ * lex.c (cons_up_default_function): If the containing type has no ++ name, these functions should never need to be called, so just ++ declare them. ++ ++ * lex.c (real_yylex): Use HOST_BITS_PER_WIDE_INT to determine the ++ bitmask for lexing character constants. ++ ++ * call.c (build_method_call): Disable code that tries to do tricky ++ stuff with a default parameter that is a constructor call, but ++ actually does other tricky stuff that breaks things. ++ ++Wed Oct 12 16:14:01 1994 Benoit Belley ++ ++ * decl.c (finish_enum): Disable code which forces enums to be signed, ++ since this conflicts with their use as bitfields. type_promotes_to ++ handles promotion of enums of underlying unsigned types to signed ++ integer types. ++ ++Wed Oct 12 13:24:03 1994 Jason Merrill ++ ++ * cvt.c (type_promotes_to): Also promote enums to long if ++ appropriate. ++ ++ * typeck.c (default_conversion): Don't expect type_promotes_to to ++ return a main variant. ++ ++Wed Oct 12 12:19:45 1994 Jason Merrill ++ ++ * call.c (build_scoped_method_call): Don't lose side effects in the ++ object expression when calling a non-existent destructor. ++ ++Fri Sep 2 19:05:21 1994 Rohan Lenard ++ ++ * call.c (build_scoped_method_call): Remove erroneous error message ++ when destructor call is written as a scoped call. ++ ++Tue Oct 11 23:48:31 1994 Jason Merrill ++ ++ * various: Cast pointer arguments to bzero and bcopy to char *. ++ ++Tue Oct 11 19:34:32 1994 Mike Stump ++ ++ * class.c (get_derived_offset): Added a type parameter to limit how ++ far up the CLASSTYPE_VFIELD_PARENT chain we search. ++ * class.c (modify_one_vtable, fixup_vtable_deltas): When forming the ++ offset to put into the vtable for the this parameter, make sure we ++ don't offset from a parent of the DECL_CONTEXT of the function. ++ ++Tue Oct 11 16:10:52 1994 Jason Merrill ++ ++ * pt.c (do_function_instantiation): Set DECL_EXTERNAL and ++ TREE_STATIC when setting DECL_INTERFACE_KNOWN. ++ (do_type_instantiation): Likewise. ++ ++ * lex.c (cons_up_default_function): Set DECL_INTERFACE_KNOWN, ++ DECL_EXTERNAL and TREE_STATIC as appropriate. ++ ++ * decl2.c (finish_file): Also synthesize methods that don't have ++ DECL_EXTERNAL set. Set interface_unknown before doing so. ++ ++ * decl.c (start_function): If DECL_INTERFACE_KNOWN is set on the ++ function decl, don't muck with TREE_PUBLIC and DECL_EXTERNAL. ++ ++Mon Oct 10 00:56:53 1994 Jason Merrill ++ ++ * lex.c (cons_up_default_function): Mark methods in a template class ++ as template instances. Store the values of interface_unknown and ++ interface_only for do_pending_inlines. ++ (do_pending_inlines): Use them. ++ ++ * decl2.c (finish_file): If we haven't seen a definition of a ++ function declared static, make the decl non-PUBLIC so compile_file ++ can give an error. ++ ++Sun Oct 9 02:42:29 1994 Jason Merrill ++ ++ * method.c (do_build_copy_constructor): Handle anonymous unions. ++ (do_build_assign_ref): Likewise. ++ (largest_union_member): Move from lex.c. ++ ++Sat Oct 8 14:59:43 1994 Jason Merrill ++ ++ Re-implement g++'s vague linkage independent of TREE_PUBLIC. ++ * pt.c (instantiate_member_templates): Lose redundant ++ -fexternal-templates handling. ++ (tsubst): Set TREE_PUBLIC and DECL_EXTERNAL on new decls. Don't set ++ TREE_STATIC or DECL_INTERFACE_KNOWN. ++ (do_pending_expansions): Predicate on DECL_INTERFACE_KNOWN instead ++ of DECL_EXTERNAL for explicit instantiations. ++ (do_function_instantiation): Do the new thing. ++ (do_type_instantiation): Likewise. ++ (instantiate_template): Deal with member templates defined in a .cc ++ file with -fexternal-templates. ++ * except.c (expand_exception_blocks): Use DECL_LINKAGE_KNOWN to ++ decide whether to stick builtin_throw here. ++ * decl2.c (import_export_inline): Predicate on DECL_INTERFACE_KNOWN ++ rather than TREE_PUBLIC. Generally fix rules. ++ (finish_file): Use DECL_INITIAL to determine whether or not a method ++ has been synthesized, rather than TREE_ASM_WRITTEN. ++ * decl.c (warn_extern_redeclared_static): Use DECL_PUBLIC instead of ++ TREE_PUBLIC. ++ (pushdecl): Likewise. ++ (duplicate_decls): Likewise. Deal with DECL_DECLARED_STATIC and ++ DECL_INTERFACE_KNOWN. ++ (redeclaration_error_message): Fix checking for conflicting linkage. ++ (define_function): Set DECL_INTERFACE_KNOWN. ++ (grokfndecl): Function decls are PUBLIC until we are sure about ++ their linkage. Set DECL_DECLARED_STATIC as needed. ++ (start_function): Deal with linkage. Move pushdecl after linkage ++ magic. ++ (finish_function): Don't set TREE_ASM_WRITTEN on discarded inlines. ++ * cp-tree.h (lang_decl_flags): Add interface_known and ++ declared_static. ++ (DECL_INTERFACE_KNOWN): New macro. ++ (DECL_DECLARED_STATIC): New macro. ++ (DECL_PUBLIC): New macro. ++ ++ Clean up bogus use of TREE_PUBLIC. ++ * class.c (alter_access): Fix mistaken use of TREE_PUBLIC (it ++ doesn't correspond to TREE_PROTECTED and TREE_PRIVATE). ++ * init.c (do_friend): Don't arbitrarily set TREE_PUBLIC. ++ ++Wed Oct 5 13:44:41 1994 Jason Merrill ++ ++ * call.c (build_overload_call_real): Don't immediately do ++ array->pointer conversion. ++ ++ * pt.c (type_unification): If not passing to a reference, strip ++ cv-quals. Also handle array->pointer conversion. ++ ++Tue Oct 4 17:45:37 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Don't warn about applying const to a ++ const typedef or template type parameter. ++ ++ * decl2.c (finish_file): Also synthesize methods after walking the ++ vtables. Ugly ugly ugly. ++ ++Mon Oct 3 15:02:41 1994 Jason Merrill ++ ++ * various: Remove lingering remnants of old exception handling code. ++ ++ * decl2.c (finish_file): Synthesize methods before walking the ++ vtables, so that the vtables get emitted as needed. ++ ++ * decl.c (shadow_tag): Remove obsolete code for pushing tags and ++ dealing with exceptions. ++ ++Mon Oct 3 13:05:27 1994 Ian Lance Taylor ++ ++ * Make-lang.in (g++-cross): Depend upon version.o and $(LIBDEPS). ++ ++Mon Oct 3 02:59:28 1994 Jason Merrill ++ ++ * decl2.c (finish_file): Fix inline handling. ++ ++Sun Oct 2 00:21:56 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Handle redundant scope even better. ++ ({push,pop}_cp_function_context): Take toplev parameter. ++ ++ * method.c (synthesize_method): Pass toplev parameter to ++ {push,pop}_cp_function_context depending on decl_function_context ++ (fndecl). ++ ++ * typeck.c (build_x_unary_op): Unary & on OFFSET_REFs is always the ++ built-in version. ++ ++ * method.c (synthesize_method): Don't be confused by __in_chrg ++ parameter. ++ ++ * class.c (popclass): Set C_C_D like start_function does. ++ ++ * decl.c (grokdeclarator): Handle redundant scope better. ++ ++ * parse.y (expr_or_declarator): Add '(' expr_or_declarator ')' rule. ++ (direct_notype_declarator): Likewise. ++ (complex_direct_notype_declarator): Remove it here. ++ ++Sat Oct 1 21:42:18 1994 Jason Merrill ++ ++ * init.c (resolve_offset_ref): Fix types used in resolving .* ++ expressions. ++ ++Sat Oct 1 15:18:49 1994 Jason Merrill ++ ++ Beginnings of work to synthesize methods only when needed. ++ * call.c (build_method_call): Synthesize methods as necessary ++ (currently never necessary). ++ * class.c (popclass): Don't try to set C_C_D here, as it'll end up ++ on the wrong obstack. ++ * decl.c (push_cp_function_context): Mostly copied from ++ push_c_function_context. ++ (pop_cp_function_context): Similarly. ++ (finish_function): Reverse order of poplevel and pop_nested_class so ++ that current_class_decl is restored properly. ++ (start_function): Likewise. ++ (finish_function): Add parameter 'nested'. Don't call ++ permanent_allocation if (nested). ++ * various: Pass extra parameter to finish_function. ++ * decl2.c (finish_file): Reorganize end-of-file inline handling, ++ synthesizing methods as necessary. ++ * lex.c (cons_up_default_function): Call mark_inline_for_output. ++ Only synthesize methods immediately if #pragma implementation ++ (currently disabled). ++ (do_pending_inlines): Call synthesize_method. ++ * method.c (synthesize_method): New function; all method synthesis ++ goes through here. Calls do_build_assign_ref and ++ do_build_copy_constructor. ++ (build_default_constructor): Remove. ++ (build_dtor): Likewise. ++ (build_assign_ref): Rename to do_build_assign_ref and remove stuff ++ done by synthesize_method. ++ (build_copy_constructor): Similarly. ++ ++Thu Sep 29 16:58:52 1994 Mike Stump ++ ++ * typeck.c (c_expand_return): Use magic so the backend can fixup the ++ assignment into the return register, so cleanups won't clobber it. ++ ++Thu Sep 29 13:08:50 1994 Jason Merrill ++ ++ * method.c (hack_identifier): Don't call assemble_external for ++ template decls. ++ ++ * decl.c (finish_decl): Also end temporary allocation if the decl in ++ question has a type of error_mark_node. ++ ++Wed Sep 28 21:45:00 1994 Mike Stump ++ ++ * typeck.c (build_modify_expr): When optimizing ?: on lhs, make sure ++ that if the ?: was a reference type, that the subparts will be also. ++ ++Wed Sep 28 16:14:04 1994 Brendan Kehoe ++ ++ * except.c (register_exception_table): Use Pmode, not PTRmode. ++ ++Fri Sep 23 13:54:27 1994 Jason Merrill ++ ++ * lex.c (do_pending_inlines): Do method synthesis after the ++ pending_inlines have been reversed. ++ ++Thu Sep 22 12:53:03 1994 Per Bothner ++ ++ * decl2.c (finish_file): Fix Brendan's fix: Only call ++ register_exception_table if there is a non-empty exception table. ++ ++Thu Sep 22 12:03:46 1994 Brendan Kehoe ++ ++ * decl2.c (finish_file): Only do register_exception_table if ++ -fhandle-exceptions is being used. ++ ++Wed Sep 21 19:01:51 1994 Per Bothner ++ ++ * except.c (output_exception_table_entry): Simplify ++ by using assemble_integer. ++ (build_exception_table): Change to return a count. ++ Cleanup to use standard macros, instead of hard-wired ++ sparc asm format. Don't make __EXCEPTION_TABLE__ global. ++ (register_exception_table): New function. Generate call to builtin. ++ * decl2.c (finish_file): Call register_exception_table. ++ * cp-tree.h (build_exception_table): Fix prototype. ++ ++Wed Sep 21 13:20:42 1994 Brendan Kehoe ++ ++ * tree.c (break_out_calls): Don't try to duplicate the DECL_INITIAL. ++ ++ * decl2.c (delete_sanity): Give an error at trying to delete a ++ function. ++ ++Wed Sep 21 11:47:10 1994 Jason Merrill ++ ++ * lex.c (cons_up_default_function): Mark synthesized destructors ++ inline. ++ ++ * decl.c (duplicate_decls): Ignore redeclarations of wchar_t as ++ something other than __wchar_t, complaining if -pedantic and not in ++ a system header. ++ ++Tue Sep 20 09:43:28 1994 Jason Merrill ++ ++ * decl.c (xref_tag): Set up BINFO_INHERITANCE_CHAIN on base binfos ++ here. ++ ++ * typeck.c (build_modify_expr): Require complete type after checking ++ for error_mark_node. ++ ++ * call.c (build_method_call): Print parmtypes when complaining of ++ ambiguous call. ++ ++ * typeck.c (build_modify_expr): Handle assignment to array from ++ non-array. ++ ++ * decl.c (lookup_name_real): Deal with got_scope == error_mark_node. ++ ++ * call.c (build_method_call): Don't bother with the exact match. ++ ++Mon Sep 19 00:51:39 1994 Jason Merrill ++ ++ * init.c (expand_aggr_init): If we munge the type of the variable, ++ also munge the type of the initializer. ++ ++ * decl.c (grokdeclarator): Use <= when comparing to RID_LAST_MODIFIER. ++ (init_decl_processing): Push artificial declaration of wchar_t so ++ people don't have to declare it before they can use it. ++ ++ * error.c (cp_line_of): Return lineno in lieu of 0. ++ ++ * typeck.c (convert_for_assignment): Handle conversion of pmfs to ++ int and bool. ++ (build_component_ref): Fold the COMPONENT_REF in case it can be ++ reduced. ++ ++ * typeck2.c (store_init_value): Don't pedwarn about non-constant ++ bracketed initializers for automatic variables. ++ ++Sun Sep 18 10:12:12 1994 Jason Merrill ++ ++ * error.c (dump_decl): Don't say `typedef enum foo foo'. ++ ++ * decl.c (start_decl): Don't set TREE_PUBLIC on template decls just ++ because they're affected by #pragma i/i. We'll deal with that when ++ they get instantiated. ++ ++ * typeck.c (build_unary_op): Clean up cruft in ADDR_EXPR case. ++ ++ * class.c (instantiate_type): Set TREE_CONSTANT on instantiated ++ ADDR_EXPRs if appropriate. ++ ++ * decl.c (build_ptrmemfunc_type): Unset IS_AGGR_TYPE on pmf types. ++ ++ * typeck.c (build_ptrmemfunc): Handle &overloaded_method as an ++ initializer properly. ++ * typeck2.c (digest_init): Likewise. ++ ++ * tree.c (cp_build_type_variant): Like c_build_type_variant, except ++ it uses build_cplus_array_type. ++ * *.c: Use cp_build_type_variant instead of c_build_type_variant. ++ ++ * pt.c (do_type_instantiation): Don't try to instantiate nested ++ enums. ++ ++Tue Sep 13 10:56:58 1994 Jason Merrill ++ ++ * cvt.c (build_up_reference): Handle preincrement and predecrement ++ properly. ++ ++Tue Sep 13 09:51:59 1994 Brendan Kehoe ++ ++ * decl.c (finish_decl): Only lay out the rtl for DECL if it is, in ++ fact, static. ++ ++Mon Sep 12 14:40:30 1994 Brendan Kehoe ++ ++ * decl.c (finish_decl): Lay out the rtl for DECL before doing ++ grok_reference_init, in case it's static. ++ ++Mon Sep 12 12:45:38 1994 Jason Merrill ++ ++ * class.c (finish_struct): Don't synthesize constructors if the ++ class has a field with the same name as the class. Don't die on ++ classes with no constructors or destructors. Don't die if the head ++ and tail of the class are in different files. ++ ++ * decl.c (grokdeclarator): Don't treat a function pointer field ++ with the same name as the class as a constructor. ++ ++Fri Sep 9 13:17:00 1994 Jason Merrill ++ ++ * typeck.c (build_c_cast): Pull constant values out of their ++ variables here. ++ ++ * decl.c (duplicate_decls): Only propagate DECL_CHAIN in ++ FUNCTION_DECLs and TEMPLATE_DECLs. ++ ++Thu Sep 8 10:07:48 1994 Jason Merrill ++ ++ * decl.c (duplicate_decls): Propagate DECL_CHAIN in all DECLs that ++ have it. ++ ++ * pt.c (unify): REALs and INTEGERs only unify with their own genus. ++ (instantiate_member_templates): Don't muck with DECL_EXTERNAL and ++ TREE_PUBLIC unless -fexternal-templates. ++ ++Wed Sep 7 13:17:10 1994 Jason Merrill ++ ++ * pt.c (do_type_instantiation): Call instantiate_member_templates. ++ Deal with specializations. ++ (tsubst): Don't stick the mangled name in DECL_NAME for function ++ instantiations. Don't push them, either. ++ ++ * decl2.c (grokfield): Move code for generating the ++ DECL_ASSEMBLER_NAME for static members from here. ++ * method.c (build_static_name): To here. ++ * decl.c (grokvardecl): Call build_static_name. ++ (duplicate_decls): Keep old DECL_ASSEMBLER_NAME. ++ ++Mon Sep 5 12:49:18 1994 Jason Merrill ++ ++ * call.c (build_method_call): If -Wsynth, warn when selecting ++ synthesized op= over user-supplied one cfront would select. ++ * decl2.c (lang_decode_option): Handle -Wsynth. ++ ++Fri Sep 2 15:11:59 1994 Jason Merrill ++ ++ * decl.c (finish_enum): Overhaul to fix several bugs. ++ (start_enum): Disable useless code. ++ ++Thu Sep 1 16:04:54 1994 Jason Merrill ++ ++ * typeck.c (c_expand_return): Warn about returning a reference to a ++ temporary. ++ (convert_arguments): Increment argument counter when using default ++ arguments, too. ++ ++Wed Aug 31 14:29:22 1994 Jason Merrill ++ ++ * decl.c (finish_decl): If the type of decl is error_mark_node, ++ don't bother trying to do anything. ++ ++ * typeck.c (convert_for_initialization): If the rhs contains a ++ constructor call, pretend the lhs type needs to be constructed. ++ ++ * init.c (expand_default_init): If we stick the object inside the ++ initializer, mark the initializer used. ++ ++Tue Aug 30 13:50:18 1994 Jason Merrill ++ ++ * method.c (build_assign_ref): Return *this; ++ (build_assign_ref): Fix base assignment order. ++ (build_copy_constructor): Fix member init order. ++ ++Mon Aug 29 13:54:39 1994 Brendan Kehoe ++ ++ * g++.c (main): Remember to clear out SAW_SPECLANG after we see ++ its argument. ++ ++Sat Aug 27 09:36:03 1994 Jason Merrill ++ ++ * method.c (build_copy_constructor): Also copy virtual bases. ++ ++Fri Aug 26 17:05:15 1994 Jason Merrill ++ ++ * lex.c (do_pending_inlines): Clear out pending_inlines before doing ++ any synthesis. Also first set deja_vu on all pending_inlines. ++ ++ * method.c (build_assign_ref): Use build_member_call to invoke base ++ operator=, rather than build_modify_expr. And use ++ build_reference_type instead of TYPE_REFERENCE_TO. ++ (build_copy_constructor): Use TYPE_NESTED_NAME to identify the ++ basetype. ++ ++ * decl2.c (grokfield): Don't complain about undefined local class ++ methods. ++ ++ * class.c (finish_struct): Don't try to synthesize methods here. ++ * lex.c (do_pending_inlines): Instead, synthesize them here. ++ (init_lex): Initialize synth_obstack. ++ (cons_up_default_function): Stick synthesis request on ++ pending_inlines. ++ ++Fri Aug 26 12:24:14 1994 Brendan Kehoe ++ ++ * call.c (build_method_call) [PCC_STATIC_STRUCT_RETURN]: Also ++ accept an RTL_EXPR in what we're about to use for the instance, ++ since anything which would end up with pcc_struct_return set ++ inside cplus_expand_expr. ++ ++ * cp-tree.h (cons_up_default_function): Note change of prototype. ++ ++Thu Aug 25 23:05:30 1994 Gerald Baumgartner ++ ++ * class.c (finish_struct): Undid change from Aug 21 testing ++ CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING. ++ * parse.y (left_curly): Likewise, undid change from Aug 21. ++ * decl.c (xref_tag): Undid change from Aug 21, set ++ CLASSTYPE_INTERFACE correctly, and added comments. ++ ++Thu Aug 25 00:36:31 1994 Jason Merrill ++ ++ Rework approach to synthesized methods; don't go through the parser ++ anymore. ++ * class.c (finish_struct): Use new synthesis approach. ++ * lex.c (cons_up_default_function): Now just creates declaration, ++ not code. ++ (largest_union_member): #if 0 out. ++ (default_assign_ref_body): Likewise. ++ (default_copy_constructor_body): Likewise. ++ * method.c (build_default_constructor): New function to synthesize X(). ++ (build_copy_constructor): Synthesize X(X&). ++ (build_assign_ref): Synthesize X::operator=(X&). ++ (build_dtor): Synthesize ~X(). ++ ++ * error.c (cp_line_of): If we're dealing with an artificial ++ TYPE_DECL, look at the type instead. ++ ++Wed Aug 24 11:11:50 1994 Jason Merrill ++ ++ * init.c (sort_member_init): Check warn_reorder. ++ * decl2.c (lang_decode_option): Handle -W{no-,}reorder. ++ ++ * cp-tree.h (CLASSTYPE_SOURCE_LINE): New macro. ++ * error.c (cp_line_of): Use CLASSTYPE_SOURCE_LINE for aggregates. ++ * class.c (finish_struct): Set CLASSTYPE_SOURCE_LINE. ++ ++Tue Aug 23 09:28:35 1994 Mike Stump ++ ++ * error.c (dump_decl): Improve wording, so that error messages ++ dont't read template<, class foo>... ++ ++Mon Aug 22 15:30:51 1994 Brendan Kehoe ++ ++ * parse.y (label_colon): Also match a TYPENAME as a label name, ++ since they may have declared a class by that name but have also ++ tried to have a local label under the same name. ++ ++ * pt.c (coerce_template_parms): Call cp_error, not cp_error_at, ++ for the message so they know at what point it was instantiated. ++ ++Sun Aug 21 23:07:35 1994 Gerald Baumgartner ++ ++ * class.c (finish_struct): Move setting of CLASSTYPE_INTERFACE and ++ CLASSTYPE_VTABLE_NEEDS_WRITING for signatures up to left_curly time. ++ * decl.c (xref_tag): Move setting of CLASSTYPE_INTERFACE and ++ CLASSTYPE_VTABLE_NEEDS_WRITING for signatures down to left_curly time. ++ * parse.y (left_curly): New final resting place for setting ++ CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING for signatures. ++ ++ * class.c (finish_struct): Don't test for function/field name ++ conflicts in signatures, since all the fields are compiler-constructed. ++ ++Fri Aug 19 14:04:47 1994 Kung Hsu ++ ++ * method.c (build_overload_nested_name): In qualified name ++ mangling, the template with value instantiation will have numeric ++ at end and may mixed with the name length of next nested level. ++ Add a '_' in between. ++ * method.c (build_overload_name): Ditto. ++ * method.c (build_overload_identifier): Ditto. ++ ++Thu Aug 18 16:24:43 1994 Mike Stump ++ ++ * error.c (dump_decl): Handle NULL args. ++ ++Thu Sep 29 16:15:36 1994 Michael I Bushnell ++ ++ * g++.c: Rework last change so it's done like collect.c (and ++ gcc.c). ++ ++Wed Sep 14 10:17:27 1994 Michael I Bushnell ++ ++ * g++.c: Include in case `errno' is a macro ++ as permitted by ANSI C. ++ ++Thu Aug 18 12:48:09 1994 Mike Stump ++ ++ * class.c (finish_struct): Move setting of CLASSTYPE_INTERFACE and ++ CLASSTYPE_VTABLE_NEEDS_WRITING up to left_curly time. ++ * decl.c (xref_tag): Move setting of CLASSTYPE_INTERFACE and ++ CLASSTYPE_VTABLE_NEEDS_WRITING down to left_curly time. ++ * parse.y (left_curly): New final resting place for setting ++ CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING. ++ ++Thu Aug 11 11:32:42 1994 H.J. Lu ++ ++ * g++.c (main): Only decrement "added" and set "library" to ++ NULL when "library" != NULL. ++ ++Sat Aug 13 00:14:52 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Don't set TREE_PUBLIC on a function decl ++ just because its class has a known interface. ++ (decls_match): Deal with new format of template parms. ++ ++ * lex.c (cons_up_default_function): Don't play with TREE_PUBLIC and ++ DECL_EXTERNAL here. ++ ++Fri Aug 12 01:55:15 1994 Jason Merrill ++ ++ * decl.c (pushtag): SET_DECL_ARTIFICIAL on gratuitous typedefs. ++ (xref_defn_tag): Likewise. ++ (pushdecl): Only allow artificial typedefs to be shadowed. ++ ++ * init.c (emit_base_init): Pass the right binfos to ++ expand_aggr_init_1. ++ ++ * class.c (delete_duplicate_fields_1): Make it work right. ++ (finish_struct): Catch function/field name conflict. ++ ++ * decl2.c (check_classfn): Pass the function to cp_error, not just ++ the name. ++ ++ * init.c (sort_member_init): Warn when order of member initializers ++ does not match order of member declarations. ++ (emit_base_init): Call expand_aggr_init_1 with LOOKUP_PROTECT. ++ ++ * error.c (dump_expr): Handle lists of functions. ++ ++ * decl.c (start_function): #pragma interface only affects functions ++ that would otherwise be static. ++ (finish_decl): Don't warn about an unused variable if it has both ++ constructor and destructor, since the 'resource allocation is ++ initialization' idiom is relatively common. ++ ++ * typeck.c (comp_target_types): Don't handle TEMPLATE_TYPE_PARMs. ++ (comp_target_parms): Likewise. ++ (compparms): Never consider default parms. ++ (common_base_type): Don't choose a virtual baseclass if there is a ++ more derived class in common. ++ (build_conditional_expr): If pedantic, pedwarn about conversion to ++ common base in conditional expr. ++ ++ * class.c (instantiate_type): Handle template instantiation better. ++ ++ * typeck.c (convert_arguments): Don't try to get tricky and convert ++ to int directly when PROMOTE_PROTOTYPES is set, as it breaks ++ user-defined conversions. ++ ++ * lex.c (check_for_missing_semicolon): Also give error at end of ++ file. ++ ++ * call.c (build_method_call): Don't promote arrays to pointers here. ++ ++ * typeck.c (convert_arguments): Don't require the actual parameter ++ to be of a complete type if the formal parameter is a reference. ++ ++Thu Aug 11 15:21:40 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Soften 'static' on member function error ++ to pedwarn. ++ ++ * init.c (build_new): Don't automatically save rval. ++ (build_offset_ref): Do field lookup with proper basetype_path. ++ ++Thu Aug 11 12:46:54 1994 Brendan Kehoe ++ ++ * errfn.c (cp_silent): Declare to mark when we should avoid ++ emitting warnings and errors. ++ (cp_error): Check it. ++ (cp_warning): Likewise. ++ (cp_pedwarn): Likewise. ++ (cp_compiler_error): Likewise. ++ (cp_error_at): Likewise. ++ (cp_warning_at): Likewise. ++ (cp_pedwarn_at): Likewise. ++ * call.c (compute_conversion_costs): Set CP_SILENT when we start ++ out, and make sure we turn it off before we leave. ++ ++Thu Aug 11 00:02:54 1994 Jason Merrill ++ ++ * decl2.c (grok_array_decl): Try computing *(A+B) if neither ++ argument is obviously an array. ++ ++Wed Aug 10 15:32:04 1994 Jason Merrill ++ ++ * typeck.c (c_expand_start_case): Do cleanups here. ++ ++ * parse.y (xcond): Do bool conversion here, too. ++ (simple_stmt, SWITCH case): Don't do cleanups here. ++ ++ * decl.c (duplicate_decls): Don't treat builtins that have been ++ explicitly declared specially. ++ ++Tue Aug 9 01:16:09 1994 Jason Merrill ++ ++ * tree.c (make_deep_copy): Support copying pointer, reference, ++ function, array, offset and method types. ++ ++ * decl.c (init_decl_processing): Mark exit and abort as ++ BUILT_IN_NONANSI so that duplicate_decls is kinder about ++ redeclaration. ++ (duplicate_decls): Don't give two errors for redeclaring a C ++ function with the same parms but a different return type. ++ ++ * parse.y (paren_cond_or_null): Do cleanup and bool conversion here. ++ (condition): Instead of here. ++ (simple_stmt, SWITCH case): Also do cleanup here. ++ ++ * decl2.c (finish_anon_union): Only break out FIELD_DECLs. ++ ++ * call.c (build_method_call): Don't throw away the side effects of ++ the object in a call to a non-existent constructor. ++ * parse.y (primary): Likewise. ++ ++ * method.c (build_decl_overload): Oop. ++ ++ * decl2.c (lang_decode_option): Deal with flag_no_nonansi_builtin, ++ warn about uselessness of specifying -fansi-overloading. ++ ++ * method.c (build_decl_overload): Treat any non-member new with one ++ parameter as __builtin_new. ++ ++ * decl.c (init_decl_processing): Setup built-in meanings of exit, ++ _exit and abort. ++ ++Mon Aug 8 15:03:30 1994 Jason Merrill ++ ++ * error.c (dump_readonly_or_volatile): Put a space between const and ++ volatile if both apply. ++ ++ * init.c (perform_member_init): Clean up after this initialization. ++ (emit_base_init): Clean up after each base init, not after all have ++ been done. ++ (expand_aggr_vbase_init_1): Clean up after this init. ++ ++Sun Aug 7 14:55:05 1994 Jason Merrill ++ ++ * call.c (build_method_call): Deal with destroying references. ++ ++ * parse.y (condition): Do bool_truthvalue_conversion here. ++ (paren_expr_or_null): And here. ++ (simple_if): Not here. ++ (simple_stmt): Or here. ++ ++Sat Aug 6 22:29:45 1994 Jason Merrill ++ ++ * parse.y (paren_expr_or_null): Wrap the expression in a ++ CLEANUP_POINT_EXPR. ++ (condition): Likewise. ++ ++Sat Aug 6 19:46:37 1994 Rohan Lenard ++ ++ * call.c (build_scoped_method_call): Fix error message when ++ destructor call refers to a nonexistent type. ++ ++Sat Apr 16 22:43:30 1993 Gerald Baumgartner ++ ++ * lex.h (rid): Deleted RID_RAISES, it's never used. ++ Moved RID_PUBLIC, RID_PRIVATE, RID_PROTECTED, RID_EXCEPTION, ++ RID_TEMPLATE and RID_SIGNATURE to the end of the enumeration, ++ they don't need to be touched in `grokdeclarator.' ++ (RID_LAST_MODIFIER): Defined macro to be RID_MUTABLE. ++ ++ * decl.c (grokdeclarator): Use RID_LAST_MODIFIER instead of ++ RID_MAX as loop limit for finding declaration specifiers. ++ ++Sat Apr 3 21:59:07 1993 Gerald Baumgartner ++ ++ * lex.c (debug_yytranslate): Moved to parse.y since it needs to ++ access `yytname,' which is static in parse.c. ++ ++Fri Apr 2 23:36:57 1993 Gerald Baumgarnter ++ ++ * cp-tree.h (GNU_xref_ref): Fixed typo in extern declaration, it ++ was `GNU_xref_def' instead of `GNU_xref_ref.' ++ ++Fri Aug 5 14:20:16 1994 Jason Merrill ++ ++ * pt.c (do_function_instantiation): Don't set TREE_PUBLIC and ++ DECL_EXTERNAL on 'extern' instantiations; wait until EOF to do that. ++ (do_type_instantiation): Likewise. ++ ++ * decl2.c (import_export_inline): Decides at EOF what an inline's ++ linkage should be. ++ (finish_file): Call it. ++ ++ * decl.c (start_function): Don't rely on the settings of TREE_PUBLIC ++ and DECL_EXTERNAL from do_*_instantiation. Only set ++ DECL_DEFER_OUTPUT on inlines whose linkage might actually change. ++ (finish_function): Use DECL_DEFER_OUTPUT to decide which inlines to ++ mark for later consideration, rather than DECL_FUNCTION_MEMBER_P. ++ ++Fri Aug 5 01:12:20 1994 Mike Stump ++ ++ * class.c (get_class_offset_1, get_class_offset): New routine to ++ find the offset of the class where a virtual function is defined, ++ from the complete type. ++ * class.c (modify_one_vtable, fixup_vtable_deltas): Use ++ get_class_offset instead of virtual_offset as get_class_offset will ++ always provide the right answer. ++ * tree.c (virtual_offset): Remove. It only ever worked some of the ++ time. ++ ++Tue Aug 2 12:44:21 1994 Jason Merrill ++ ++ * call.c (build_method_call): Put back unary_complex_lvalue call ++ that I thought was redundant. ++ ++ * typeck.c (c_expand_return): Fix a case I missed before. ++ ++Sun Jul 31 17:54:02 1994 Jason Merrill ++ ++ * pt.c (unify): Strip cv-quals from template type arguments (when ++ 'const T*' is matched to 'const char*', that does not mean that T is ++ 'const char'). ++ ++Fri Jul 29 01:03:06 1994 Jason Merrill ++ ++ * pt.c (do_type_instantiation): Instantiate nested TAGS, not ++ typedefs. Third time's the charm? ++ ++ * parse.y (template_parm): Support default template parms. ++ * pt.c (process_template_parm): Likewise. ++ (end_template_parm_list): Likewise. ++ (coerce_template_parms): Likewise. ++ (mangle_class_name_for_template): Likewise. ++ (push_template_decls): Likewise. ++ (unify): Likewise. ++ * method.c (build_overload_identifier): Likewise. ++ * error.c (dump_decl): Likewise. ++ ++Wed Jul 27 17:47:00 1994 Jason Merrill ++ ++ * pt.c (do_type_instantiation): Only instantiate nested *classes*. ++ ++Tue Jul 26 13:22:40 1994 Jason Merrill ++ ++ * search.c (note_debug_info_needed): Also emit debugging information ++ for the types of fields. ++ ++Mon Jul 25 00:34:44 1994 Jason Merrill ++ ++ * pt.c (lookup_template_class): Pass 'template' to ++ coerce_template_parms instead of 'in_decl', since it's a more ++ meaningful context. ++ ++ * typeck.c (c_expand_return): Make sure any cleanups for the return ++ expression get run. ++ (build_c_cast): Use CONVERT_EXPR for conversion to void. ++ ++ * pt.c (do_type_instantiation): Also instantiate nested types. ++ ++ * typeck.c (convert_for_assignment): Don't die when comparing ++ pointers with different levels of indirection. ++ ++ * decl.c (grokdeclarator): The sub-call to grokdeclarator for ++ class-local typedefs sets DECL_ARGUMENTS, so we need to clear it ++ out. ++ ++ * decl2.c (finish_anon_union): Don't die if the union has no ++ members. ++ ++ * decl.c (grokdeclarator): Undo changes to declspecs when we're done ++ so that 'typedef int foo, bar;' will work. ++ ++ * decl2.c (finish_file): Don't call expand_aggr_init for ++ non-aggregates. ++ ++Mon Jul 25 00:03:10 1994 Teemu Torma ++ ++ * decl.c (finish_function): We can't inline constructors and ++ destructors under some conditions with -fpic, but don't unset ++ DECL_INLINE. ++ ++Mon Jul 25 00:03:10 1994 Jason Merrill ++ ++ * typeck.c (build_object_ref): Make sure 'datum' is a valid object. ++ ++Sun Jul 24 14:19:31 1994 Jason Merrill ++ ++ * class.c (finish_struct): Don't set DECL_FIELD_BITPOS on ++ non-fields. ++ (finish_struct_methods): Use copy_assignment_arg_p. ++ ++ * cvt.c (cp_convert): If expr is an OFFSET_REF, resolve it instead ++ of giving an error. ++ ++ * typeck.c (build_binary_op_nodefault): Don't set result_type if we ++ don't know how to compare the operands. ++ ++ * decl.c (grokdeclarator): Avoid seg fault when someone uses '__op' ++ as a declarator-id in their program. Like the Linux headers do. ++ Arrgh. ++ ++ * tree.c (lvalue_p): Treat calls to functions returning objects by ++ value as lvalues again. ++ ++ * typeck.c (build_component_addr): Use convert_force to convert the ++ pointer in case the component type is also a private base class. ++ ++ * search.c (get_matching_virtual): Fix bogus warning of overloaded ++ virtual. ++ ++ * pt.c (overload_template_name): Set DECL_ARTIFICIAL on the created ++ TYPE_DECL to fix bogus shadowing warnings. ++ ++Fri Jul 22 01:15:32 1994 Jason Merrill ++ ++ * init.c (expand_aggr_init_1): const and volatile mismatches do not ++ prevent a TARGET_EXPR from initializing an object directly. ++ ++Tue Jul 19 17:55:37 1994 Jason Merrill ++ ++ * cvt.c (build_up_reference): Allow building up references to ++ `this', don't warn about making references to artificial variables ++ (like `this'). ++ ++ * tree.c (lvalue_p): `this' is not an lvalue. ++ ++ * call.c (build_method_call): Accept using a typedef name (or ++ template type parameter) for explicit destructor calls. ++ ++Thu Jul 14 09:42:23 1994 Mike Stump ++ ++ * Version 2.6.0 released. ++ ++Wed Jul 13 03:57:54 1994 Jason Merrill ++ ++ * method.c (hack_identifier): Put back old code so lists of ++ non-functions will be handled properly. ++ ++ * cp-tree.h (TYPE_NEEDS_CONSTRUCTING): #if 0 out; this macro is now ++ defined in the language-independent tree.h. ++ ++ * tree.c (count_functions): Avoid bogus warning when compiling this ++ function. ++ ++Mon Jul 11 18:37:20 1994 Jason Merrill ++ ++ * decl.c (grok_reference_init): Always save the initializer of a ++ reference. ++ ++Fri Jul 8 17:41:46 1994 Mike Stump ++ ++ * decl.c (cplus_expand_expr_stmt): Wrap statement expressions inside ++ CLEANUP_POINT_EXPRs so that the stack slots can be reused. ++ (disabled for now) ++ ++Fri Jul 8 12:59:38 1994 Jason Merrill ++ ++ * method.c (hack_identifier): Fix for new overloading. ++ ++ * typeck.c (build_binary_op_nodefault): Don't mess with division by ++ zero. ++ ++Fri Jul 8 13:20:28 1994 Gerald Baumgartner ++ ++ * decl2.c (finish_file): Only call walk_sigtables, if ++ flag_handle_signatures is turned on, don't waste time otherwise. ++ ++Fri Jul 8 02:27:41 1994 Jason Merrill ++ ++ * decl.c (push_overloaded_decl): Don't create overloads of one when ++ shadowing a class type. ++ * typeck.c (build_x_function_call): Complain about overloads of one. ++ ++ * decl.c (grokdeclarator): Don't try to treat a char* as a tree. ++ (grokdeclarator): Fix setting of TREE_STATIC. ++ (start_decl): Clear DECL_IN_AGGR_P after calling duplicate_decls. ++ ++Thu Jul 7 22:20:46 1994 Gerald Baumgartner ++ ++ * cp-tree.h (walk_sigtables): Created extern declaration. ++ * decl2.c (walk_sigtables): Created function, patterned after ++ walk_vtables, even though we only need it to write out sigtables. ++ (finish_sigtable_vardecl): Created function. ++ (finish_vtable_vardecl): Changed 0 to NULL_PTR. ++ (finish_file): Call walk_sigtables. ++ ++ * sig.c (build_signature_table_constructor): Mark class member ++ function pointed to from signature table entry as addressable. ++ ++Thu Jul 7 13:39:37 1994 Jason Merrill ++ ++ * decl.c (start_decl): Check new decl of static member variable ++ against the declaration in the class here. ++ (grokvardecl): Instead of here. ++ ++ * class.c (prepare_fresh_vtable): Call import_export_vtable if not ++ -fvtable-thunks. ++ (build_vtable): Likewise. ++ ++ * decl2.c (import_export_vtable): Move logic for deciding the ++ interface of a template class from here. ++ (import_export_template): To here. ++ (finish_vtable_vardecl): Call import_export_template before ++ import_export_vtable. ++ ++Wed Jul 6 20:25:48 1994 Mike Stump ++ ++ * except.c (init_exception_processing): Setup interim_eh_hook to ++ call lang_interim_eh. ++ * except.c (do_unwind): Propagate throw object value across ++ stack unwinding. ++ * except.c (saved_throw_value): Used to hold the value of the object ++ being thrown. It is always a reference to the real value. ++ * except.c (expand_start_catch_block): Add handling for the ++ value of the exception object. ++ * except.c (expand_start_catch_block): Add handler for the handler, ++ so that throws inside the handler go to the outer block. ++ * except.c (expand_end_catch_block): Likewise. ++ * parse.y (handler_args): Use parm instead, as the other doesn't yet ++ handle references correctly. ++ ++Wed Jul 6 17:55:32 1994 Per Bothner ++ ++ * decl2.c (mark_vtable_entries): If -ftable-thunks, set the ++ vtable entry properly to abort. ++ ++Tue Jul 5 14:07:54 1994 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Downgrade division by zero ++ errors to warnings. ++ ++ * call.c (build_overload_call_real): Handle fnname being a list of ++ functions. ++ * typeck.c (build_x_function_call): Pass list of functions to ++ build_overload_call, not just the name. ++ * tree.c (count_functions): Complain when called for invalid ++ argument. ++ ++ * decl.c (grokdeclarator): Fix settings of TREE_STATIC, TREE_PUBLIC ++ and DECL_EXTERNAL on static members and initialized const members. ++ * decl2.c (grokfield): Reflect this change. ++ ++Fri Jul 1 09:35:51 1994 Jason Merrill ++ ++ * parse.y (init): ANSI C++ does not forbid { }. ++ ++Thu Jun 30 00:35:22 1994 Jason Merrill ++ ++ * decl2.c (lang_decode_option): Set warn_nonvdtor along with -Wall. ++ warn_nonvdtor defaults to off. ++ ++ * class.c (instantiate_type): Use comptypes rather than relying on ++ types to satisfy ==. ++ ++ * decl.c (start_function): Set DECL_DEFER_OUTPUT on all inlines that ++ might be static. ++ ++ * tree.c (build_cplus_new): Never build WITH_CLEANUP_EXPRs. ++ ++ * decl.c (grok_reference_init): Deal with ADDR_EXPRs of TARGET_EXPRs. ++ ++ * cvt.c (cp_convert): Pass 0 to with_cleanup_p arg of ++ build_cplus_new. ++ ++Wed Jun 29 22:31:09 1994 Jason Merrill ++ ++ * decl2.c (finish_file): Maybe consider static inlines multiple ++ times, in case they reference each other. ++ ++Tue Jun 28 11:58:38 1994 Gerald Baumgartner ++ ++ * class.c (finish_struct): Don't `cons_up_default_function's ++ for signatures. ++ (finish_struct): Handle an empty method_vec correctly. ++ ++ * decl.c (grokdeclarator): Don't warn about a signature being ++ empty in a signature pointer declaration if we only saw a ++ forward declaration of the signature. Changed `warning's into ++ `cp_warning's. ++ ++ * sig.c (build_sigtable): Don't die if a null signature table ++ constructor is returned. ++ (build_signature_pointer_constructor): If the signature table ++ constructor is null, the _sptr field is set to a null pointer ++ and cast to the appropriate type. Make copies of all null ++ pointers so that the type null_pointer_node doesn't get changed. ++ (build_signature_table_constructor): Added comments. ++ ++ * sig.c (build_signature_pointer_constructor): Complain if we ++ try to assign to/initialize a signature pointer/reference of ++ an undefined signature. ++ ++Mon Jun 27 14:05:16 1994 Gerald Baumgartner ++ ++ * typeck2.c (store_init_value): Don't be pedantic about ++ non-constant initializers of signature tables/pointers/references. ++ ++Fri Jun 24 16:49:41 1994 Gerald Baumgartner ++ ++ * decl.c (grokdeclarator): If we are grokking an opaque typedef ++ in a signature, don't complain about it begin static. ++ ++Wed Jun 29 16:44:45 1994 Mike Stump ++ ++ Fixes a problem of the this pointer being wrong in virtual calls to ++ methods that are not overridden in more derived classes. ++ ++ * class.c (fixup_vtable_delta): New routine. It will fixup the ++ delta entries in vtables, wheever they need updating. ++ * class.c (finish_struct): Call the new routine for all virtual ++ bases, as they can have different offsets, than those used in base ++ classes that we derive our vtable from. ++ ++Tue Jun 28 23:49:28 1994 Jason Merrill ++ ++ * typeck.c (build_binary_op): Use the types before default ++ conversions in the error message. ++ ++ * *.c: Use c_build_type_variant instead of build_type_variant where ++ the type might be an array. ++ ++ * call.c (build_method_call): Call build_type_variant and ++ build_reference_type in the right order. ++ * decl.c (record_builtin_type): Likewise. ++ ++Wed Jun 29 16:58:53 1994 Jason Merrill ++ ++ * call.c (build_method_call): Call build_type_variant and ++ build_reference_type in the right order. ++ * decl.c (record_builtin_type): Likewise. ++ ++Tue Jun 28 23:49:28 1994 Jason Merrill ++ ++ * typeck.c (build_binary_op): Use the types before default ++ conversions in the error message. ++ ++ * *.c: Use c_build_type_variant instead of build_type_variant where ++ the type might be an array. ++ ++Sat Jun 25 11:50:54 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): Try UDC's before doing the ++ reinterpret_cast thang, though. ++ ++Fri Jun 24 01:24:01 1994 Jason Merrill ++ ++ * typeck.c (c_expand_return): Don't USE the return value location ++ after we've expanded the jump. ++ ++ * decl2.c (finish_file): Make sure DECL_SAVED_INSNS is not 0 before ++ trying to write out an inline. ++ ++ * cvt.c (build_up_reference): Also do address adjustment when the ++ target type uses MI. ++ (convert_to_reference): Try UDCs only after built-in conversions. ++ (build_type_conversion_1): Don't play games with the argument to the ++ method. ++ (build_type_conversion): #if 0 out code for binding to reference. ++ ++Thu Jun 23 00:22:28 1994 Jason Merrill ++ ++ * decl2.c (finish_file): Use TREE_SYMBOL_REFERENCED to decide ++ whether to emit inlines. ++ ++ * decl.c (grokdeclarator): Set explicit_int for decls that just ++ specify, say, 'long'. ++ ++ * init.c (do_friend): Do overload C functions (or call pushdecl, ++ anyaway). ++ ++Wed Jun 22 13:40:49 1994 Jason Merrill ++ ++ * cvt.c (build_up_reference): Don't call readonly_error. ++ (convert_to_reference): Propagate const and volatile from expr to ++ its type. ++ ++ * tree.c (lvalue_p): Random CALL_EXPRs are not lvalues. ++ ++ * cvt.c (build_up_reference): Break out WITH_CLEANUP_EXPR when ++ creating a temporary. ++ (convert_to_reference): Lose excessive and incorrect trickiness. ++ (cp_convert): Call build_cplus_new with with_cleanup_p set. ++ ++ * typeck2.c (build_functional_cast): Likewise. ++ ++Tue Jun 21 17:38:38 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): signed, unsigned, long and short all ++ imply 'int'. ++ ++ * decl.c (grokdeclarator): Allow "this is a type" syntax. ++ (grok_reference_init): Simplify and fix. ++ ++Sun Jun 19 17:08:48 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): pedwarn about a typedef that specifies no ++ type. ++ ++Sat Jun 18 04:16:50 1994 Jason Merrill ++ ++ * decl.c (start_function): Move TREE_PUBLIC and DECL_EXTERNAL ++ tinkering to after call to pushdecl. ++ ++Fri Jun 17 14:48:28 1994 Jason Merrill ++ ++ * call.c (build_method_call): Handle destructors for non-aggregate ++ types properly. ++ ++Thu Jun 16 16:48:05 1994 Jason Merrill ++ ++ * call.c (build_method_call): Make sure that the name given for the ++ destructor matches the constructor_name of the instance. ++ ++ * pt.c (do_function_instantiation): A non-extern instantiation ++ overrides a later extern one. ++ (do_type_instantiation): Likewise. ++ ++Wed Jun 15 19:34:54 1994 Jason Merrill ++ ++ * init.c (expand_aggr_init): Use TYPE_MAIN_VARIANT to get the ++ unqualified array type. ++ ++ * cp-tree.h (EMPTY_CONSTRUCTOR_P): Tests whether NODE is a ++ CONSTRUCTOR with no elements. ++ ++ * decl.c (various): Lose empty_init_node. ++ (finish_decl): Use EMPTY_CONSTRUCTOR_P, do the empty CONSTRUCTOR ++ thing depending on the value of DECL_COMMON instead of ++ flag_conserve_space, do the empty CONSTRUCTOR thing for types that ++ don't have constructors, don't treat a real empty CONSTRUCTOR ++ specially. ++ ++ * typeck2.c (process_init_constructor): Don't treat empty_init_node ++ specially. ++ ++Wed Jun 15 19:05:25 1994 Mike Stump ++ ++ * class.c (override_one_vtable): Don't forget to merge in an old ++ overrider when we wanted to reuse a vtable, but couldn't. ++ ++Wed Jun 15 15:03:16 1994 Jason Merrill ++ ++ * decl.c (start_decl): Put statics in common again. ++ ++ * decl.c (grokdeclarator): Return NULL_TREE for an error rather than ++ setting the type to error_mark_node. ++ ++ * typeck.c (build_modify_expr): Build up a COMPOUND_EXPR for enum ++ bitfield assignments. ++ ++Tue Jun 14 12:23:38 1994 Jason Merrill ++ ++ * decl.c (grok_op_properties): Const objects can be passed by value. ++ ++Mon Jun 13 03:10:59 1994 Jason Merrill ++ ++ * decl2.c (import_export_vtable): Force implicit instantiations to ++ be interface_only when -fno-implicit-templates. ++ ++ * decl.c (duplicate_decls): Redeclaring a class template name is an ++ error. ++ ++ * pt.c (end_template_decl): Call GNU_xref_decl for class templates. ++ * xref.c (GNU_xref_decl): Support templates. ++ ++Sat Jun 11 17:09:05 1994 Jason Merrill ++ ++ * decl.c (grok_op_properties): Split out checking for whether this ++ function should suppress the default assignment operator. ++ * decl2.c (grok_function_init): Likewise. ++ (copy_assignment_arg_p): New function to do just that. ++ Now considers virtual assignment operators that take a base as an ++ argument to count as copy assignment operators. ++ ++ * search.c (dfs_debug_mark): Lose checks for DWARF_DEBUG and ++ TREE_ASM_WRITTEN, as they are redundant. ++ ++ * pt.c (end_template_decl): Don't try to set DECL_CLASS_CONTEXT on a ++ decl that has no LANG_SPECIFIC part. ++ (do_type_instantiation): Force the debugging information for this ++ type to be emitted. ++ ++ * decl.c (start_decl): Clear up uses of various types of templates ++ (say sorry for static data members, rather than "invalid template"). ++ (expand_static_init): Fix initialization of static data members of ++ template classes. ++ ++Fri Jun 10 00:41:19 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Set DECL_CONTEXT on static data members. ++ ++ * g++.c (main): Use -xc++-cpp-output for .i files. ++ ++ * pt.c (tsubst): Give meaningful error about declaring template for ++ a copy constructor which was not declared in the class template. ++ (do_type_instantiation): Explicit instantiation before the class ++ template is an error. ++ (instantiate_template): Don't die if tsubst returns error_mark_node. ++ ++Thu Jun 9 19:04:59 1994 Jason Merrill ++ ++ Don't synthesize the copy assignment operator if the one in a base ++ class is pure virtual. ++ * cp-tree.h (TYPE_HAS_ABSTRACT_ASSIGN_REF): New macro to indicate ++ whether the type has a pure virtual copy assignment operator. ++ * class.c (finish_base_struct): Don't generate the copy assignment ++ operator if a base class has a pure virtual one. ++ * decl.c (grok_op_properties): Add disabled code to set ++ TYPE_HAS_ABSTRACT_ASSIGN_REF with comment pointing to where it is ++ actually set. ++ * decl2.c (grok_function_init): Set TYPE_HAS_ABSTRACT_ASSIGN_REF. ++ ++ * decl2.c (import_export_vtable): Always treat template ++ instantiations as if write_virtuals >= 2, and treat implicit ++ instantiations as external if -fno-implicit-templates. ++ (finish_file): Output all pending inlines if ++ flag_keep_inline_functions. ++ ++Wed Jun 8 20:48:02 1994 Mike Stump ++ ++ * tree.c (layout_vbasetypes): Align virtual base classes inside ++ complete objects, so that we don't core dump on machines such as ++ SPARCs when we access members that require larger than normal ++ alignments, such as a double. Also, we bump up the total alignment ++ on the complete type, as necessary. ++ ++Wed Jun 8 16:18:14 1994 Jason Merrill ++ ++ * gxxint.texi (Free Store): New section with code for examining ++ cookie. ++ (Limitations of g++): Remove operator delete entry, since it is no ++ longer accurate. Fix access control entry. ++ ++ * typeck.c (build_unary_op): Pedwarn about taking the address of or ++ incrementing a cast to non-reference type. ++ (build_modify_expr): Use convert instead of convert_force again. ++ ++ * search.c (get_base_distance): Use IS_AGGR_TYPE_CODE to check for ++ class type, not == RECORD_TYPE. ++ ++ * decl.c (grokdeclarator): Cope with grokfndecl returning NULL_TREE. ++ ++ * typeck2.c (report_case_error): #if 0 out. ++ * lex.c (real_yylex): Lose RANGE. ++ * parse.y: Likewise. ++ ++Tue Jun 7 18:17:35 1994 Jason Merrill ++ ++ * parse.y (simple_stmt, case ranges): Use ELLIPSIS instead of RANGE. ++ ++Mon Jun 6 19:39:57 1994 Jason Merrill ++ ++ * typeck.c (build_c_cast): Don't shortcut conversions to the same ++ type. Don't replace consts with their values here, since that's now ++ done in cp_convert. ++ ++ * cvt.c (cp_convert): When converting to bool, take ++ integer_zero_node to false_node and all other INTEGER_CSTs to ++ true_node. ++ (build_type_conversion): Don't complain about multiple conversions ++ to float if we're not really converting. ++ ++Fri Jun 3 02:10:56 1994 Jason Merrill ++ ++ Implement 'extern template class A;' syntax for suppressing ++ specific implicit instantiations. ++ * cp-tree.h: Update prototypes for do_*_instantiation. ++ * pt.c (do_pending_expansions): Don't compile 'extern' explicit ++ instantiations. ++ (do_function_instantiation): Set DECL_EXTERNAL on 'extern' explicit ++ instantiations. ++ (do_type_instantiation): Likewise. ++ * parse.y (explicit_instantiation): Support 'extern template class ++ A;' syntax. ++ * decl.c (start_function): Don't modify the settings of TREE_PUBLIC ++ and DECL_EXTERNAL on explicit instantiations. ++ ++ * cvt.c (cp_convert): Replace constants with their values before ++ converting. ++ (cp_convert): Consistently use 'e' instead of 'expr'. ++ ++Thu Jun 2 03:53:30 1994 Jason Merrill ++ ++ * typeck2.c (build_x_arrow): Resolve OFFSET_REFs first. ++ ++Wed Jun 1 18:57:35 1994 Jason Merrill ++ ++ * typeck2.c (digest_init): Handle initializing a pmf with an ++ overloaded method. ++ * typeck.c (build_ptrmemfunc): Handle overloaded methods. ++ ++ * decl.c (pushtag): Use build_decl to make TYPE_DECLs. ++ (xref_defn_tag): Likewise. ++ * pt.c (process_template_parm): Likewise. ++ (lookup_template_class): Likewise. ++ (push_template_decls): Likewise. ++ (instantiate_class_template): Likewise. ++ (create_nested_upt): Likewise. ++ * class.c (finish_struct): Don't try to set DECL_CLASS_CONTEXT on ++ TYPE_DECLs. ++ ++ * typeck.c (convert_arguments): Make sure type is not NULL before ++ checking its TREE_CODE. ++ ++Wed Jun 1 17:40:39 1994 Mike Stump ++ ++ * class.c (get_derived_offset): New routine. ++ * class.c (finish_base_struct): Make sure we set BINFO_VTABLE and ++ BINFO_VIRTUALS when we choose a new base class to inherit from. ++ * class.c (modify_one_vtable): Use get_derived_offset to get the ++ offset to the most base class subobject that we derived this binfo ++ from. ++ * class.c (finish_struct): Move code to calculate the ++ DECL_FIELD_BITPOS of the vfield up, as we need might need it for ++ new calls to get_derived_offset in modify_one_vtable. ++ ++Wed Jun 1 16:50:59 1994 Jason Merrill ++ ++ * init.c (build_member_call): Use build_pointer_type instead of ++ TYPE_POINTER_TO. ++ ++Wed Jun 1 11:11:15 1994 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Make sure we have a DNAME set before we ++ try to use it in an error. ++ ++Wed Jun 1 09:48:49 1994 Mike Stump ++ ++ * typeck.c (convert_arguments, convert_for_initialization): Don't ++ strip NOP_EXPRs, when we are converting to a reference. ++ ++Wed Jun 1 01:11:38 1994 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Don't dereference references when ++ initializing them. ++ ++ * decl2.c (grokfield): Don't check for grokdeclarator returning ++ error_mark_node any more. ++ ++ * decl.c (grokfndecl): Return NULL_TREE instead of error_mark_node. ++ (start_method): Return void_type_node instead of error_mark_node. ++ ++ * typeck.c (build_modify_expr): Resolve offset refs earlier. ++ ++Tue May 31 16:06:58 1994 Jason Merrill ++ ++ * call.c (build_method_call): Resolve OFFSET_REFs in the object. ++ ++ * typeck.c (build_modify_expr): Dereference references before trying ++ to assign to them. ++ ++ * call.c (build_method_call): Don't confuse type conversion ++ operators with constructors. ++ * typeck2.c (build_functional_cast): Just call build_c_cast if there ++ was only one parameter. ++ * method.c (build_typename_overload): Don't set ++ IDENTIFIER_GLOBAL_VALUE on these identifiers. ++ * decl.c (grok_op_properties): Warn about defining a type conversion ++ operator that converts to a base class (or reference to it). ++ * cvt.c (cp_convert): Don't try to use a type conversion operator ++ when converting to a base class. ++ (build_type_conversion_1): Don't call constructor_name_full on an ++ identifier. ++ * cp-tree.h (DERIVED_FROM_P): Should be self-explanatory. ++ ++ * decl.c (start_decl): Don't complain that error_mark_node is an ++ incomplete type. ++ (finish_decl): Check for type == error_mark_node. ++ ++Mon May 30 23:38:55 1994 Jason Merrill ++ ++ * decl.c (start_function): Set DECL_DEFER_OUTPUT on implicit ++ instantiations and inline members. ++ ++ * spew.c (yylex): Set looking_for_template if the next token is a '<'. ++ ++ * lex.h: Declare looking_for_template. ++ ++ * decl.c (lookup_name_real): Use looking_for_template to arbitrate ++ between type and template interpretations of an identifier. ++ ++Sat May 28 04:07:40 1994 Jason Merrill ++ ++ * pt.c (instantiate_template): Zero out p if we found a ++ specialization. ++ ++ * decl.c (grokdeclarator): Elucidate warning. ++ (grokdeclarator): If pedantic AND -ansi, complain about long long. ++ ++ Make explicit instantiation work reasonably. It is now appropriate ++ to deprecate the use of -fexternal-templates. ++ * pt.c (instantiate_template): Set DECL_TEMPLATE_SPECIALIZATION or ++ DECL_IMPLICIT_INSTANTIATION on fndecl as appropriate. ++ (end_template_instantiation): Reflect changes in USE_TEMPLATE ++ semantics. ++ (do_pending_expansions): if (!flag_implicit_templates) DECIDE(0); ++ (do_function_instantiation): Don't set EXPLICIT_INST if ++ flag_external_templates is set. Do set TREE_PUBLIC and DECL_EXTERN ++ appropriately otherwise. ++ (do_type_instantiation): Set interface info for class. Set ++ TREE_PUBLIC and DECL_EXTERN for methods. Do none of this if ++ flag_external_templates is set. ++ * parse.y: Reflect changes in USE_TEMPLATE semantics. ++ * decl2.c: New flag flag_implicit_templates determines whether or ++ not implicit instantiations get emitted. This flag currently ++ defaults to true, and must be true for -fexternal-templates to work. ++ (finish_file): Consider flag_implement_inlines when ++ setting DECL_EXTERNAL. Consider flag_implicit_templates when ++ deciding whether or not to emit a static copy. ++ * decl.c (start_function): Set TREE_PUBLIC and DECL_EXTERNAL ++ properly for template instantiations. ++ (start_method): Set DECL_IMPLICIT_INSTANTIATION on methods of a ++ template class. ++ * cp-tree.h (CLASSTYPE_USE_TEMPLATE): Change semantics. ++ (DECL_USE_TEMPLATE): Parallel macro for FUNCTION and VAR_DECLs. ++ (various others): Accessor macros for the above. ++ ++Fri May 27 13:57:40 1994 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Division by constant zero is ++ an error. ++ ++Fri May 27 13:50:15 1994 Mike Stump ++ ++ * class.c (override_one_vtable): Don't modify things we don't own. ++ ++Fri May 27 01:42:58 1994 Jason Merrill ++ ++ * decl.c (finish_decl): Don't postpone processing the initializer of ++ a decl with DECL_EXTERNAL set, and do call rest_of_compilation for a ++ PUBLIC const at toplevel. ++ (grokdeclarator): pedwarn about initializing non-const or ++ non-integral statics in the class body. ++ ++ * decl.c (pushtag): Don't try to set DECL_CLASS_CONTEXT on a ++ TYPE_DECL. ++ ++ * call.c (convert_harshness): Dereference reference on rhs before ++ proceeding, properly grok passing const things to non-const ++ references. ++ ++ * typeck.c (build_unary_op): Soften error about taking the address ++ of main() to a pedwarn. ++ ++ * lex.c (default_copy_constructor_body): Unambiguously specify base ++ classes (i.e. A((const class ::A&)_ctor_arg) ). ++ (default_assign_ref_body): Likewise. ++ ++Thu May 26 13:13:55 1994 Gerald Baumgartner ++ ++ * decl2.c (grokfield): Don't complain about local signature ++ method declaration without definition. ++ ++ * call.c (convert_harshness): If `type' is a signature pointer ++ and `parmtype' is a pointer to a signature, just return 0. We ++ don't really convert in this case; it's a result of making the ++ `this' parameter of a signature method a signature pointer. ++ ++ * call.c (build_method_call): Distinguish calling the default copy ++ constructor of a signature pointer/reference from a signature ++ member function call. ++ ++Thu May 26 12:56:25 1994 Jason Merrill ++ ++ * decl2.c (grokfield): Don't set TREE_PUBLIC on member function ++ declarations. ++ ++ * decl.c (duplicate_decls): A previous function declaration as ++ static overrides a subsequent non-static definition. ++ (grokdeclarator): Don't set TREE_PUBLIC on inline method ++ declarations. ++ ++Wed May 25 14:36:38 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Handle initialization of static const ++ members. ++ (finish_decl): Likewise. ++ ++ * decl2.c (grokfield): Allow initialization of static const members ++ even when pedantic. ++ ++ * decl2.c (grokfield): Deal with grokdeclarator returning ++ error_mark_node. ++ ++ * decl.c (grok_ctor_properties): Return 0 for A(A) constructor. ++ (grokfndecl): Check the return value of grok_ctor_properties. ++ (start_method): Likewise. ++ ++ * parse.y (absdcl): Expand type_quals inline. ++ ++Tue May 24 19:10:32 1994 Jason Merrill ++ ++ * decl.c (pushtag): Use IS_AGGR_TYPE rather than checking for a ++ RECORD_TYPE. ++ ++Tue May 24 18:09:16 1994 Per Bothner ++ ++ * cp-tree.h (VTABLE_NAME_FORMAT): If flag_vtable_thunks, ++ always use "__vt_%s". ++ * decl2.c (finish_vtable_vardecl): Don't consider abstract virtuals ++ when looking for a "sentinal" method (to decide on emitting vtables). ++ * decl2.c (finish_file): Scan all decls for thunks that need ++ to be emitted. ++ * decl2.c (finish_vtable_vardecl): Don't bother calling emit_thunk. ++ * method.c (make_thunk): Use a more meaningful label. If there ++ exists a matching top-level THUNK_DECL re-use it; otherwise ++ create a new THUNK_DECL (and declare it). ++ * method.c (emit_thunk): Make thunk external/public depending ++ on the underlying method. ++ ++Tue May 24 00:22:04 1994 Jason Merrill ++ ++ * pt.c (tsubst): Use lookup_name_nonclass to find guiding decls, not ++ lookup_name. ++ ++ * call.c (build_overload_call_real): Don't immediately pick a ++ function which matches perfectly. ++ ++ * decl.c (grokdeclarator): Use c_build_type_variant for arrays. ++ (grokdeclarator): Warn about, and throw away, cv-quals attached to a ++ reference (like 'int &const j'). ++ ++ * typeck.c (convert_arguments): Don't mess with i for methods. ++ * call.c (build_method_call): Pass the function decl to ++ convert_arguments. ++ ++ * typeck.c (comp_ptr_ttypes_real): New function. Implements the ++ checking for which multi-level pointer conversions are allowed. ++ (comp_target_types): Call it. ++ (convert_for_assignment): Check const parity on the ultimate target ++ type, too. And make those warnings pedwarns. ++ ++Mon May 23 14:11:24 1994 Jason Merrill ++ ++ * error.c (dump_char): Use TARGET_* for character constants. ++ ++Mon May 23 13:03:03 1994 Brendan Kehoe ++ ++ * tree.c (debug_no_list_hash): Make static. ++ ++ * decl.c (decls_match): Say the types don't match if newdecl ends up ++ with a null type, after we've checked if olddecl does. ++ (pushdecl): Check if the decls themselves match before looking for ++ an extern redeclared as static, to avoid inappropriate and incorrect ++ warnings. ++ ++Fri May 20 14:04:34 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Make warning about duplicate short, etc. ++ a pedwarn. ++ ++ * typeck.c (build_c_cast): Casting to function or method type is an ++ error. ++ ++ * class.c (finish_struct): Make warning for anonymous class with no ++ instances a pedwarn. ++ ++ * Makefile.in (stamp-parse): Expect a s/r conflict. ++ ++ * typeck.c (build_modify_expr): pedwarn about using a non-lvalue ++ cast as an lvalue. ++ ++Thu May 19 12:08:48 1994 Jason Merrill ++ ++ * cvt.c (type_promotes_to): Make sure bool promotes to int rather ++ than unsigned on platforms where sizeof(char)==sizeof(int). ++ ++Wed May 18 14:27:06 1994 Jason Merrill ++ ++ * typeck.c (build_c_cast): Tack on a NOP_EXPR when casting to ++ another variant. ++ (build_modify_expr): Don't strip NOP_EXPRs, and don't get tricky ++ and treat them as lvalues. ++ ++ * decl.c (shadow_tag): Do complain about forward declarations of ++ enums and empty declarations. ++ * parse.y: Don't complain about forward declarations of enums and ++ empty declarations. ++ ++ * typeck.c (convert_for_assignment): Complain about changing ++ the signedness of a pointer's target type. ++ ++ * parse.y (stmt): Move duplicated code for checking case values from ++ here. ++ * decl2.c (check_cp_case_value): To here. And add a call to ++ constant_expression_warning. ++ ++ * typeck.c (convert_for_assignment): Don't complain about assigning ++ a negative value to bool. ++ ++ * decl.c (init_decl_processing): Make bool unsigned. ++ ++ * class.c (finish_struct): Allow bool bitfields. ++ ++Wed May 18 12:35:27 1994 Ian Lance Taylor ++ ++ * Make-lang.in (c++.install-man): Get g++.1 from $(srcdir)/cp. ++ ++Wed May 18 03:28:35 1994 Jason Merrill ++ ++ * cvt.c (build_type_conversion): Lose special handling of ++ truthvalues. ++ ++ * search.c (dfs_pushdecls): Improve shadowing warning. ++ ++Tue May 17 13:34:46 1994 Jason Merrill ++ ++ * init.c (build_delete): Throw away const and volatile on `this'. ++ ++ * decl.c (finish_enum): Put the constants in TYPE_VALUES again, ++ rather than the enumerators. ++ (pushtag): s/cdecl/c_decl/g ++ ++Mon May 16 23:04:01 1994 Stephen R. van den Berg ++ ++ * cp/typeck.c (common_type): Attribute merging. ++ (comp_types): Utilize COMP_TYPE_ATTRIBUTES macro. ++ ++ * cp/parse.y: Revamp attribute parsing. ++ ++Mon May 16 01:40:34 1994 Jason Merrill ++ ++ * decl.c (shadow_tag): Also check for inappropriate use of auto and ++ register. ++ ++ * method.c (build_overload_name): Clarify that the illegal case is a ++ pointer or reference to array of unknown bound. ++ ++ * error.c (dump_type_prefix): Print references to arrays properly. ++ ++ * typeck.c (various): Be more helpful in pointer ++ comparison diagnostics. ++ ++ * tree.c (lvalue_p): MODIFY_EXPRs are lvalues again. Isn't this ++ fun? ++ ++ * parse.y: Also catch an error after valid stmts. ++ ++ * search.c (dfs_init_vbase_pointers): Don't abort because `this' is ++ const. ++ ++ * typeck.c (convert_for_initialization): If call to ++ convert_to_reference generated a diagnostic, print out the parm ++ number and function decl if any. ++ ++ * errfn.c (cp_thing): Check atarg1 to determine whether or not we're ++ specifying a line, not atarg. ++ ++ * tree.c (build_cplus_method_type): Always make `this' const. ++ ++ * decl2.c (grokclassfn): If -fthis-is-variable and this function is ++ a constructor or destructor, make `this' non-const. ++ ++ * typeck.c (build_modify_expr): Don't warn specially about ++ assignment to `this' here anymore, since it will be caught by the ++ usual machinery. ++ ++ * various: Disallow specific GNU extensions (variable-size arrays, ++ etc.) when flag_ansi is set, not necessarily when pedantic is set, ++ so that people can compile with -pedantic-errors for tighter const ++ checking and such without losing desirable extensions. ++ ++ * typeck2.c (build_functional_cast): Call build_method_call with ++ LOOKUP_PROTECT. ++ (process_init_constructor): Only process FIELD_DECLs. ++ ++ * decl.c (finish_decl): Also force static consts with no explicit ++ initializer that need constructing into the data segment. ++ ++ * init.c (build_delete): Undo last patch, as it interferes with ++ automatic cleanups. ++ ++Sat May 14 01:59:31 1994 Jason Merrill ++ ++ * call.c, class.h, cp-tree.h, cvt.c, decl2.c: Lose old overloading ++ code. ++ ++ * init.c (build_delete): pedwarn about using plain delete to delete ++ an array. ++ ++Fri May 13 16:45:07 1994 Jason Merrill ++ ++ * typeck.c (comp_target_types): Be more helpful in contravariance ++ warnings, and make them pedwarns. ++ ++ * decl.c (grokdeclarator): Use decl_context to decide whether or not ++ this is an access declaration. ++ ++ * class.c (finish_struct_bits): Set TYPE_HAS_INT_CONVERSION if it ++ has a conversion to enum or bool, too. ++ ++Fri May 13 16:31:27 1994 Mike Stump ++ ++ * method.c (emit_thunk): Make declaration for ++ current_call_is_indirect local (needed for hppa). ++ ++Fri May 13 16:16:37 1994 Jason Merrill ++ ++ * pt.c (uses_template_parms): Grok BOOLEAN_TYPE. ++ (tsubst): Likewise. ++ ++Fri May 13 16:23:32 1994 Mike Stump ++ ++ * pt.c (tsubst): If there is already a function for this expansion, ++ use it. ++ * pt.c (instantiate_template): Likewise. ++ ++Fri May 13 10:30:42 1994 Brendan Kehoe ++ ++ * parse.y (implicitly_scoped_stmt, simple_stmt case): Use ++ kept_level_p for MARK_ENDS argument to expand_end_bindings, to avoid ++ generating debug info for unemitted symbols on some systems. ++ ++ * cp-tree.h (build_static_cast, build_reinterpret_cast, ++ build_const_cast): Add declarations. ++ ++Fri May 13 09:50:31 1994 Mike Stump ++ ++ * search.c (expand_indirect_vtbls_init): Fix breakage from Apr 27 ++ fix. We now try get_binfo, and if that doesn't find what we want, ++ we go back to the old method, which still sometimes fails. ++ ++Fri May 13 01:43:18 1994 Jason Merrill ++ ++ * parse.y (initdcl): Call cplus_decl_attributes on the right ++ variable. ++ * decl2.c (cplus_decl_attributes): Don't call decl_attributes for ++ void_type_node. ++ ++ * typeck.c (build_binary_op_nodefault): Change result_type for ++ comparison ops to bool. ++ (build_binary_op): Convert args of && and || to bool. ++ * cvt.c (build_default_binary_type_conversion): Convert args of && ++ and || to bool. ++ (build_default_unary_type_conversion): Convert arg of ! to bool. ++ (type_promotes_to): bool promotes to int. ++ ++Fri May 13 01:43:18 1994 Mike Stump ++ ++ Implement the new builtin `bool' type. ++ * typeck.c (build_binary_op_nodefault): Convert args of && and || to ++ bool. ++ (build_unary_op): Convert arg of ! to bool. ++ * parse.y: Know true and false. Use bool_truthvalue_conversion. ++ * method.c (build_overload_value): Know bool. ++ (build_overload_name): Likewise. ++ * lex.c (init_lex): Set up RID_BOOL. ++ * gxx.gperf: Add bool, true, false. ++ * error.c (*): Know bool. ++ * decl.c (init_decl_processing): Set up bool, true, false. ++ * cvt.c (cp_convert): Handle conversion to bool. ++ (build_type_conversion): Likewise. ++ * *.c: Accept bool where integers and enums are accepted (use ++ INTEGRAL_CODE_P macro). ++ ++Thu May 12 19:13:54 1994 Richard Earnshaw ++ ++ * g++.c: Use #ifdef for __MSDOS__, not #if. ++ ++Thu May 12 18:05:18 1994 Mike Stump ++ ++ * decl2.c (lang_f_options): Handle -fshort-temps. -fshort-temps ++ gives old behavior , and destroys temporaries earlier. Default ++ behavior now conforms to the ANSI working paper. ++ ++Thu May 12 14:45:35 1994 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Understand MODIFY_EXPR as an lvalue. ++ Use convert_force to convert the result of a recursive call when we ++ are dealing with a NOP_EXPR. Don't automatically wrap MODIFY_EXPRs ++ in COMPOUND_EXPRs any more. ++ (various): Lose pedantic_lvalue_warning. ++ (unary_complex_lvalue): Understand MODIFY_EXPR. ++ ++ * cvt.c (convert_to_reference): Allow DECL to be error_mark_node if ++ we don't know what we're initializing. ++ ++Wed May 11 01:59:36 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): Modify to use convtype parameter. ++ Only create temporaries when initializing a reference, not when ++ casting. ++ (cp_convert): New main function. ++ (convert): Call cp_convert. ++ * cvt.c, decl.c, typeck.c: Fix calls to convert_to_reference. ++ * cp-tree.h (CONV_*): New constants used by conversion code for ++ selecting conversions to perform. ++ ++ * tree.c (lvalue_p): MODIFY_EXPRs are no longer lvalues. ++ ++ * typeck.c (build_{static,reinterpret,const_cast): Stubs that just ++ call build_c_cast. ++ * parse.y: Add {static,reinterpret,const}_cast. ++ * gxx.gperf: Likewise. ++ ++ * typeck.c (common_type): Allow methods with basetypes of different ++ UPTs. ++ (comptypes): Deal with UPTs. ++ (build_modify_expr): Wrap all MODIFY_EXPRs in a COMPOUND_EXPR. ++ ++ * pt.c (end_template_decl): Check for multiple definitions of member ++ templates. ++ ++ * call.c (build_method_call): Complain about calling an abstract ++ virtual from a constructor. ++ ++ * typeck.c (pointer_int_sum): Check for the integer operand being 0 ++ after checking the validity of the pointer operand. ++ ++ * typeck2.c (digest_init): Pedwarn about string initializer being ++ too long. ++ ++Tue May 10 12:10:28 1994 Jason Merrill ++ ++ * decl.c (push_overloaded_decl): Only throw away a builtin if the ++ decl in question is the artificial one. ++ ++ * parse.y (simple_stmt, switch): Use implicitly_scoped_stmt because ++ expand_{start,end}_case cannot happen in the middle of a block. ++ ++ * cvt.c (build_type_conversion_1): Use convert again. ++ ++Tue May 10 11:52:04 1994 Brendan Kehoe ++ ++ * typeck2.c (digest_init): Make sure we check for signed and ++ unsigned chars as well when warning about string initializers. ++ ++ * init.c (emit_base_init): Check if there's a DECL_NAME on the ++ member before trying to do an initialization for it. ++ ++Tue May 10 11:34:37 1994 Mike Stump ++ ++ * except.c: Don't do anything useful when cross compiling. ++ ++Tue May 10 03:04:13 1994 Jason Merrill ++ ++ * decl.c (duplicate_decls): Fix up handling of builtins yet again. ++ (push_overloaded_decl): Likewise. ++ ++ * cvt.c (convert): Don't look for void type conversion. ++ ++Mon May 9 18:05:41 1994 Jason Merrill ++ ++ * init.c (do_friend): Only do a pushdecl for friends, not ++ pushdecl_top_level. ++ ++Mon May 9 13:36:34 1994 Jim Wilson ++ ++ * decl.c (lookup_name_current_level): Put empty statement after ++ the label OUT to make the code valid C. ++ ++Mon May 9 12:20:57 1994 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Only complain about ++ comparing void * and a function pointer if void * is smaller. ++ ++Sun May 8 01:29:13 1994 Jason Merrill ++ ++ * decl.c (lookup_name_current_level): Move through temporary binding ++ levels. ++ ++ * parse.y (already_scoped_stmt): Revive. ++ (simple_stmt): Use it again. ++ ++ * decl.c (poplevel): Always call poplevel recursively if we're ++ dealing with a temporary binding level. ++ ++Sat May 7 10:52:28 1994 Mike Stump ++ ++ * decl.c (finish_decl): Make sure we run cleanups for initial values ++ of decls. Cures memory leak. ++ * decl.c (expand_static_init): Likewise for static variables. ++ * decl2.c (finish_file): Likewise for globals. ++ ++Sat May 7 03:57:44 1994 Jason Merrill ++ ++ * typeck.c (commonparms): Don't complain about redefining default ++ args. ++ ++ * decl.c (duplicate_decls): Don't complain twice about conflicting ++ function decls. ++ (decls_match): Don't look at default args. ++ (redeclaration_error_message): Complain about redefining default ++ args. ++ ++ * call.c (build_overload_call_real): Also deal with guiding ++ declarations coming BEFORE the template decl. ++ ++ * pt.c (unify): Allow different parms to have different ++ cv-qualifiers. ++ (unify): Allow trivial conversions on non-template parms. ++ ++Fri May 6 03:53:23 1994 Jason Merrill ++ ++ * pt.c (tsubst): Support OFFSET_TYPEs. ++ (unify): Likewise. ++ ++ * decl2.c (finish_decl_parsing): Call push_nested_class with a type. ++ ++ * init.c (build_offset_ref): Fix error message. ++ * search.c (lookup_field): Likewise. ++ ++ * call.c (build_scoped_method_call): Pass binfo to ++ build_method_call. ++ * typeck.c (build_object_ref): Likewise. ++ ++ * typeck2.c (binfo_or_else): Don't return a _TYPE. ++ ++ * class.c (finish_struct): Don't complain about re-use of inherited ++ names or shadowing of type decls. ++ * decl.c (pushdecl_class_level): Likewise. ++ ++ * decl.c (finish_enum): Set the type of all the enums. ++ ++ * class.c (finish_struct): Don't get confused by access decls. ++ ++ * cp-tree.h (TYPE_MAIN_DECL): New macro to get the _DECL for a ++ _TYPE. You can stop using TYPE_NAME for that now. ++ ++ * parse.y: Lose doing_explicit (check $0 instead). ++ * gxx.gperf: 'template' now has a RID. ++ * lex.h (rid): Likewise. ++ * lex.c (init_lex): Set up the RID for 'template'. ++ ++ * parse.y (type_specifier_seq): typed_typespecs or ++ nonempty_type_quals. Use it. ++ (handler_args): Fix bogus syntax. ++ (raise_identifier{,s}, optional_identifier): Lose. ++ * except.c (expand_start_catch_block): Use grokdeclarator to parse ++ the catch variable. ++ (init_exception_processing): The second argument to ++ __throw_type_match is ptr_type_node. ++ ++ Fri May 6 07:18:54 1994 Chip Salzenberg ++ ++ [ change propagated from c-decl.c of snapshot 940429 ] ++ * cp/decl.c (finish_decl): Setting asmspec_tree should not ++ zero out the old RTL. ++ ++Fri May 6 01:25:38 1994 Mike Stump ++ ++ Add alpha exception handling support to the compiler. ++ Quick and dirty backend in except.c. ++ ++ * cp/*: Remove most remnants of old exception handling support. ++ * decl.c (finish_function): Call expand_exception_blocks to put ++ the exception hanlding blocks at the end of the function. ++ * dec.c (hack_incomplete_structures): Make sure expand_decl_cleanup ++ comes after expand_decl_init. ++ * except.c: Reimplementation. ++ * expr.c (cplus_expand_expr): Handle THROW_EXPRs. ++ * lex.c (init_lex): Always have catch, try and throw be reserved ++ words, so that we may always parse exception handling. ++ * parse.y: Cleanup to support new interface into exception handling. ++ * tree.def (THROW_EXPR): Add. ++ ++Thu May 5 17:35:37 1994 Jason Merrill ++ ++ * parse.y (simple_stmt, for loops): Use implicitly_scoped_stmt. ++ (various): Lose .kindof_pushlevel and partially_scoped_stmt. ++ ++Thu May 5 16:17:27 1994 Kung Hsu ++ ++ * parse.y (already_scoped_stmt): Move expand_end_binding() to ++ fix the unmatched LBB/LBE in stabs. ++ ++Thu May 5 14:36:17 1994 Jason Merrill ++ ++ * decl.c (set_nested_typename): Set TREE_MANGLED on the new ++ identifiers. ++ (pushdecl): Check TREE_MANGLED. ++ (xref_tag): Likewise. ++ * cp-tree.h (TREE_MANGLED): This identifier is a ++ DECL_NESTED_TYPENAME (named to allow for future use to denote ++ mangled function names as well). ++ ++ Implement inconsistency checking specified in [class.scope0]. ++ * decl.c (lookup_name_real): Don't set ICV here after all. ++ (finish_enum): Also set the type of the enumerators themselves. ++ (build_enumerator): Put the CONST_DECL in the list instead of its ++ initial value. ++ (pushdecl_class_level): Check inconsistent use of a name in the ++ class body. ++ * class.c (finish_struct): Check inconsistent use of a name in the ++ class body. Don't set DECL_CONTEXT on types here anymore. ++ * parse.y (qualified_type_name): Note that the identifier has now ++ been used (as a type) in the class body. ++ * lex.c (do_identifier): Note that the identifier has now been used ++ (as a constant) in the class body. ++ * error.c (dump_decl): Print type and enum decls better. ++ ++Thu May 5 09:35:35 1994 Brendan Kehoe ++ ++ * typeck.c (build_modify_expr): Warn about assignment to `this'. ++ ++Wed May 4 15:55:49 1994 Jason Merrill ++ ++ * init.c (build_delete): Use the global operator delete when ++ requested. ++ ++ * decl.c (lookup_name_real): If we find the type we're looking in a ++ base class while defining a class, set IDENTIFIER_CLASS_VALUE for ++ the type. ++ ++ * class.c (finish_struct): Remove a couple of dependencies on ++ language linkage. ++ ++ * decl.c (pushtag): Classes do nest in extern "C" blocks. ++ (pushdecl): Only set DECL_NESTED_TYPENAME on the canonical one for ++ the type. ++ (pushtag): Remove another dependency on the language linkage. ++ ++ * lex.c (cons_up_default_function): Don't set DECL_CLASS_CONTEXT to ++ a const-qualified type. ++ ++ * decl.c (push_overloaded_decl): Throw away built-in decls here. ++ (duplicate_decls): Instead of here. ++ ++Wed May 4 15:27:40 1994 Per Bothner ++ ++ * typeck.c (get_member_function_from_ptrfunc): Do The Right ++ Thing (I hope) if we're using thunks. ++ ++Wed May 4 13:52:38 1994 Jason Merrill ++ ++ * parse.y (specialization): aggr template_type_name ';'. ++ (named_class_head_sans_basetype): Use it. ++ (explicit_instantiation): Likewise. ++ (tmpl.2): Revert. ++ ++ * cvt.c (build_type_conversion_1): Use convert_for_initialization, ++ rather than convert, to do conversions after the UDC. ++ ++ * cp-tree.h (SHARED_MEMBER_P): This member is shared between all ++ instances of the class. ++ ++ * search.c (lookup_field): If the entity found by two routes is the ++ same, it's not ambiguous. ++ ++Wed May 4 12:10:00 1994 Per Bothner ++ ++ * decl.c (lookup_name_real): Check for a NULL TREE_VALUE, ++ to prevent the compiler from crashing ... ++ ++Wed May 4 11:19:45 1994 Jason Merrill ++ ++ * call.c (build_method_call): If we don't have an object, check ++ basetype_path to figure out where to look up the function. ++ ++ * typeck.c (convert_for_initialization): Pass TYPE_BINFO (type) to ++ build_method_call in case exp is NULL_TREE. ++ ++Tue May 3 16:02:53 1994 Per Bothner ++ ++ Give a vtable entries a unique named type, for the sake of gdb. ++ * class.c (build_vtable_entry): The address of a thunk now has ++ type vtable_entry_type, not ptr_type_node. ++ * method.c (make_thunk): Fix type of THUNK_DECL. ++ * class.c (add_virtual_function, override_one_vtable): Use ++ vfunc_ptr_type_node, instead of ptr_type_node. ++ * cp-tree.h (vfunc_ptr_type_node): New macro. ++ * decl.c (init_decl_processing): Make vtable_entry_type ++ be a unique type of pointer to a unique function type. ++ ++Tue May 3 09:20:44 1994 Jason Merrill ++ ++ * parse.y (do_explicit): Sets doing_explicit to 1. ++ (explicit_instantiation): Use do_explicit rather than TEMPLATE ++ directly, add "do_explicit error" rule. ++ (datadef): Set doing_explicit to 0 after an explicit instantiation. ++ (tmpl.2): Don't instantiate if we see a ';' unless we're doing an ++ explicit instantiation. ++ (named_class_head_sans_basetype): Remove aggr template_type_name ++ ';' again. ++ ++Mon May 2 23:17:21 1994 Jason Merrill ++ ++ * search.c (lookup_nested_tag): Lose. ++ ++ * decl2.c (grokfield): Set DECL_CONTEXT on TYPE_DECLs. ++ (lookup_name_nonclass): Lose. ++ ++ * decl.c (poplevel_class): Add force parameter. ++ (lookup_name_real): Fix handling of explicit scoping which specifies ++ a class currently being defined. Add 'nonclass' argument. ++ (lookup_name, lookup_name_nonclass): Shells for lookup_name_real. ++ ++ * class.c (finish_struct): Don't unset IDENTIFIER_CLASS_VALUEs here. ++ (popclass): Force clearing of IDENTIFIER_CLASS_VALUEs if we're being ++ called from finish_struct. ++ ++Mon May 2 19:06:21 1994 Per Bothner ++ ++ * decl.c (init_decl_processing), cp-tree.h: Removed memptr_type. ++ (It seeems redundant, given build_ptrmemfunc_type.) ++ * typeck.c (get_member_function_from_ptrfunc), gc.c (build_headof, ++ build_classof): Use vtable_entry_type instead of memptr_type. ++ * method.c (emit_thunk): Call poplevel with functionbody==0 ++ to prevent DECL_INITIAL being set to a BLOCK. ++ ++Mon May 2 15:02:11 1994 Jason Merrill ++ ++ * parse.y (named_class_head_sans_basetype): Add "aggr ++ template_type_name ';'" rule for forward declaration of ++ specializations. ++ ++Mon May 2 15:02:11 1994 Jason Merrill ++ ++ * class.c (instantiate_type): Deal with pmf's. ++ ++ * Make-lang.in (cc1plus): Don't depend on OBJS or BC_OBJS, since ++ stamp-objlist does. ++ ++ * Makefile.in (../cc1plus): Depend on OBJDEPS. ++ (OBJDEPS): Dependency version of OBJS. ++ ++Mon May 2 12:51:31 1994 Kung Hsu ++ ++ * search.c (dfs_debug_mark): Unmark TYPE_DECL_SUPPRESS_DEBUG, not ++ DECL_IGNORED_P. ++ ++Fri Apr 29 12:29:56 1994 Jason Merrill ++ ++ * class.c (finish_struct): Clear out memory of local tags. And ++ typedefs. ++ ++ * decl2.c (grokclassfn): Don't set DECL_CONTEXT to a cv-qualified ++ type. ++ * search.c (get_matching_virtual): Be more helpful in error message. ++ ++ * *: Use DECL_ARTIFICIAL (renamed from DECL_SYNTHESIZED). ++ ++ * lex.c (default_assign_ref_body): Expect TYPE_NESTED_NAME to work. ++ (default_copy_constructor_body): Likewise. ++ ++ * class.c (finish_struct): Don't gratuitously create multiple decls ++ for nested classes. ++ ++Thu Apr 28 23:39:38 1994 Jason Merrill ++ ++ Avoid clobbering the arg types of other functions when reverting ++ static member functions. ++ * decl.c (revert_static_member_fn): Rearrange arguments, don't ++ require values for 'fn' and 'argtypes', add warning to comment ++ above. ++ (decls_match): Rearrange arguments in call to rsmf. ++ (grok_op_properties): Don't pass values for fn and argtypes. ++ * pt.c (instantiate_template): Don't pass values for fn and argtypes. ++ ++Thu Apr 28 16:29:11 1994 Doug Evans ++ ++ * Make-lang.in (cc1plus): Depend on stamp-objlist. ++ * Makefile.in (BC_OBJS): Delete. ++ (OBJS): Cat ../stamp-objlist to get language independent files. ++ Include ../c-common.o. ++ (../cc1plus): Delete reference to BC_OBJS. ++ ++Thu Apr 28 02:12:08 1994 Jason Merrill ++ ++ * search.c (compute_access): No really, deal with static members ++ properly. Would I lie to you? ++ ++ Implement lexical hiding of function declarations. ++ * pt.c (tsubst): Use lookup_name to look for function decls to guide ++ instantiation. ++ * method.c (build_opfncall): Use lookup_name_nonclass to look for ++ non-member functions. ++ * init.c (do_friend): Use lookup_name_nonclass to look for ++ functions. ++ * error.c (ident_fndecl): Use lookup_name to look for functions. ++ * decl2.c (lookup_name_nonclass): New function, skips over ++ CLASS_VALUE. ++ * decl.c (struct binding_level): Lose overloads_shadowed field. ++ (poplevel): Don't deal with overloads_shadowed. ++ (push_overloaded_decl): Do lexical hiding for functions. ++ * class.c (instantiate_type): Don't check non-members if we have ++ members with the same name. ++ * call.c (build_method_call): Use lookup_name_nonclass instead of ++ IDENTIFIER_GLOBAL_VALUE to check for non-member functions. ++ (build_overload_call_real): Likewise. ++ ++ * decl.c (duplicate_decls): Check for ambiguous overloads here. ++ (push_overloaded_decl): Instead of here. ++ ++ * decl.c (pushdecl): Back out Chip's last change. ++ ++ * decl.c (grok_op_properties): Operators cannot be static members. ++ ++ * cp-tree.h (DECL_SYNTHESIZED): DECL_SOURCE_LINE == 0 ++ (SET_DECL_SYNTHESIZED): DECL_SOURCE_LINE = 0 ++ * lex.c (cons_up_default_function): Use SET_DECL_SYNTHESIZED. ++ ++ * method.c (do_inline_function_hair): Don't put friends of local ++ classes into global scope, either. ++ ++ * typeck2.c (build_functional_cast): Don't look for a function call ++ interpretation. ++ ++Thu Apr 28 15:19:46 1994 Mike Stump ++ ++ * cp-tree.h: Disable use of backend EH. ++ ++Wed Apr 27 21:01:24 1994 Doug Evans ++ ++ * Make-lang.in (c++.distdir): mkdir tmp/cp first. ++ * Makefile.in (INCLUDES): Move definition to same place as ++ parent makefile. ++ (ALLOCA): Define. ++ (OLDAR_FLAGS): Delete. ++ (OLDCC): Define. ++ (DIR): Delete. ++ (CLIB): Define. ++ (####site): Delete. ++ (SUBDIR_USE_ALLOCA): Don't use ALLOCA if compiling with gcc. ++ ++Wed Apr 27 19:10:04 1994 Kung Hsu ++ ++ * decl.c (xref_tag): Not to use strstr(), it's not available on ++ all platforms. ++ ++Wed Apr 27 18:10:12 1994 Jason Merrill ++ ++ * class.c (finish_struct): Resolve yet another class/pmf confusion. ++ ++ * call.c (build_overload_call_real): Don't take the single-function ++ shortcut if we're dealing with an overloaded operator. ++ ++Wed Apr 27 17:35:37 1994 Mike Stump ++ ++ * search.c (get_base_distance): Search the virtual base class ++ binfos, incase someone wants to convert to a real virtual base ++ class. ++ * search.c (expand_indirect_vtbls_init): Use convert_pointer_to_real ++ instead of convert_pointer_to, as it now will work. ++ ++Wed Apr 27 15:36:49 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): Don't complain about casting away ++ const and volatile. ++ ++ * typeck.c (build_unary_op): References are too lvalues. ++ ++Wed Apr 27 13:58:05 1994 Mike Stump ++ ++ * class.c (override_one_vtable): We have to prepare_fresh_vtable ++ before we modify it, not after, also, we cannot reuse an old vtable, ++ once we commit to a new vtable. Implement ambiguous overrides in ++ virtual bases as abstract. Hack until we make the class ++ ill-formed. ++ ++Wed Apr 27 01:17:08 1994 Jason Merrill ++ ++ * parse.y (unary_expr): Expand new_placement[opt] and ++ new_initializer[opt] inline. ++ ++ * search.c (lookup_fnfields): Don't throw away the inheritance ++ information here, either. ++ (compute_access): Handle static members properly. ++ ++ * init.c (build_member_call): Always set basetype_path, and pass it ++ to lookup_fnfields. ++ ++ * search.c (lookup_field): Deal properly with the case where ++ xbasetype is a chain of binfos; don't throw away the inheritance ++ information. ++ (compute_access): protected_ok always starts out at 0. ++ ++ * init.c (resolve_offset_ref): Don't cast `this' to the base type ++ until we've got our basetype_path. ++ ++ * cp-tree.h (IS_OVERLOAD_TYPE): aggregate or enum. ++ ++ * cvt.c (build_up_reference): Use build_pointer_type rather than ++ TYPE_POINTER_TO. ++ ++ * call.c (convert_harshness_ansi): Call type_promotes_to for reals ++ as well. ++ ++ * cvt.c (type_promotes_to): Retain const and volatile, add ++ float->double promotion. ++ ++ * decl.c (grokdeclarator): Don't bash references to arrays into ++ references to pointers in function parms. Use type_promotes_to. ++ ++Tue Apr 26 23:44:36 1994 Mike Stump ++ ++ Finish off Apr 19th work. ++ ++ * class.c (finish_struct_bits): Rename has_abstract_virtuals to ++ might_have_abstract_virtuals. ++ * class.c (strictly_overrides, override_one_vtable, ++ merge_overrides): New routines to handle virtual base overrides. ++ * class.c (finish_struct): Call merge_overrides to handle overrides ++ in virtual bases. ++ ++Tue Apr 26 12:45:53 1994 Jason Merrill ++ ++ * typeck.c (build_function_call): Call build_function_call_real with ++ LOOKUP_NORMAL. ++ ++ * *: Don't deal with TYPE_EXPRs. ++ ++ * tree.c (lvalue_p): If the type of the expression is a reference, ++ it's an lvalue. ++ ++ * cvt.c (convert_to_reference): Complain about passing const ++ lvalues to non-const references. ++ (convert_from_reference): Don't arbitrarily throw away const and ++ volatile on the target type. ++ ++ * parse.y: Simplify and fix rules for `new'. ++ ++ * decl.c (grok_op_properties): operator void is illegal. ++ ++Mon Apr 25 02:36:28 1994 Jason Merrill ++ ++ * parse.y (components): Anonymous bitfields can still have declspecs. ++ ++ * decl.c (pushdecl): Postpone handling of function templates like we ++ do C functions. ++ ++ * search.c (expand_indirect_vtbls_init): Fix infinite loop when ++ convert_pointer_to fails. ++ ++ * call.c (compute_conversion_costs_ansi): A user-defined conversion ++ by itself is better than that UDC followed by standard conversions. ++ Don't treat integers and reals specially. ++ ++ * cp-tree.h: Declare flag_ansi. ++ ++ * typeck.c (c_expand_return): pedwarn on return in void function ++ even if the expression is of type void. ++ (build_c_cast): Don't do as much checking for casts to void. ++ (build_modify_expr): pedwarn about array assignment if this code ++ wasn't generated by the compiler. ++ ++ * tree.c (lvalue_p): A comma expression is an lvalue if its second ++ operand is. ++ ++ * typeck.c (default_conversion): Move code for promoting enums and ++ ints from here. ++ * cvt.c (type_promotes_to): To here. ++ * call.c (convert_harshness_ansi): Use type_promotes_to. Also fix ++ promotion semantics for reals. ++ ++Sun Apr 24 16:52:51 1994 Doug Evans ++ ++ * Make-lang.in (c++.install-common): Check for g++-cross. ++ * Makefile.in: Remove Cygnus cruft. ++ (config.status): Delete. ++ (RTL_H): Define. ++ (TREE_H): Use complete pathname, some native makes have minimal ++ VPATH support. ++ (*.o): Use complete pathname to headers in parent dir. ++ (doc, info, dvi): Delete. ++ ++Sun Apr 24 16:52:51 1994 Doug Evans ++ ++ * Make-lang.in (c++.install-common): Check for g++-cross. ++ * Makefile.in: Remove Cygnus cruft. ++ (config.status): Delete. ++ (RTL_H): Define. ++ (TREE_H): Use complete pathname, some native makes have minimal ++ VPATH support. ++ (*.o): Use complete pathname to headers in parent dir. ++ (doc, info, dvi): Delete. ++ ++Sun Apr 24 00:47:49 1994 Jason Merrill ++ ++ * decl.c (pushdecl): Avoid redundant warning on redeclaring function ++ with different return type. ++ (decls_match): Compare return types strictly. ++ ++Fri Apr 22 12:55:42 1994 Jason Merrill ++ ++ * cvt.c (build_type_conversion): Do try to convert through other ++ pointers. This will fail if the class defines multiple pointer ++ conversions. ++ ++ * error.c (dump_type_prefix): Print out pointers to arrays properly. ++ (dump_type_suffix): Likewise. (was 'int *[]', now 'int (*)[]') ++ ++ * typeck.c (build_unary_op): Disallow ++/-- on pointers to ++ incomplete type. ++ ++ * decl.c (duplicate_decls): Check mismatched TREE_CODES after ++ checking for shadowing a builtin. If we're redeclaring a builtin ++ function, bash the old decl to avoid an ambiguous overload. ++ ++ * cvt.c (convert_to_reference): Don't force arrays to decay here. ++ ++ * tree.c (lvalue_p): A MODIFY_EXPR is an lvalue. ++ ++ * decl.c (duplicate_decls): Don't assume that the decls will have ++ types. ++ ++ Mon Apr 18 11:35:32 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940318 snapshot ] ++ * c-decl.c (pushdecl): Warn if type mismatch with another external decl ++ in a global scope. ++ ++ Fri Apr 22 06:38:56 1994 Chip Salzenberg ++ ++ * cp/typeck2.c (signature_error): Use cp_error for "%T". ++ ++ Mon Apr 18 11:59:59 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940415 snapshot ] ++ * cp/decl.c (duplicate_decls, pushdecl, builtin_function): ++ Use DECL_FUNCTION_CODE instead of DECL_SET_FUNCTION_CODE. ++ ++ Mon Apr 18 11:55:18 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940409 snapshot ] ++ * cp/decl.c (duplicate_decls): Put new type in same obstack as ++ old ones, or permanent if old ones in different obstacks. ++ ++ Mon Apr 18 11:48:49 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940401 snapshot ] ++ * cp/parse.y (attrib): Handle string args as expressions, ++ merging the two rules. `mode' attribute now takes a string arg. ++ Delete the rule for an identifier as arg. ++ ++ Mon Apr 18 11:24:00 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940312 snapshot ] ++ * cp/typeck.c (pointer_int_sum): Multiplication should be done signed. ++ (pointer_diff): Likewise the division. ++ ++ Sun Mar 6 19:43:39 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940304 snapshot ] ++ * cp/decl.c (finish_decl): Issue warning for large objects, ++ if requested. ++ ++ Sat Feb 19 22:20:32 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940218 snapshot ] ++ * cp/parse.y (attrib): Handle attribute ((section ("string"))). ++ * cp/decl.c (duplicate_decls): Merge section name into new decl. ++ ++ Tue Feb 8 09:49:17 1994 Chip Salzenberg ++ ++ [ cp/* changes propagated from c-* changes in 940206 snapshot ] ++ * cp/typeck.c (signed_or_unsigned_type): Check for any ++ INTEGRAL_TYPE_P not just INTEGER_TYPE. ++ ++ Mon Dec 6 13:35:31 1993 Norbert Kiesel ++ ++ * cp/decl.c (finish_enum): Start from 0 when determining precision ++ for short enums. ++ ++ Fri Dec 3 17:07:58 1993 Ralph Campbell ++ ++ * cp/parse.y (unary_expr): Look at $1 for tree_code rather than ++ casting $$. ++ ++ Wed Nov 17 19:22:09 1993 Chip Salzenberg ++ ++ * cp/typeck.c (build_binary_op_nodefault): Propagate code ++ from C front-end to optimize unsigned short division. ++ (build_conditional_expr): Fix bug in "1 ? 42 : (void *) 8". ++ ++ Wed Nov 17 19:17:18 1993 Chip Salzenberg ++ ++ * cp/call.c (convert_harshness_ansi): Given an (e.g.) char ++ constant, prefer 'const char &' to 'int'. ++ ++ Wed Feb 3 13:11:48 1993 Chip Salzenberg ++ ++ * cp/class.c (finish_struct_methods): Handle multiple ++ constructors in fn_fields list. ++ ++Fri Apr 22 12:48:10 1994 Kung Hsu ++ ++ * class.c (finish_struct): Use TYPE_DECL_SUPPRESS_DEBUG to flag ++ types not to be dumped in stabs, like types in #pragma interface. ++ * decl.c (init_decl_processing): Use TYPE_DECL_SUPPRESS_DEBUG to ++ mark unknown type. ++ ++Fri Apr 22 03:27:26 1994 Doug Evans ++ ++ * Language directory reorganization. ++ See parent makefile. ++ ++Thu Apr 21 18:27:57 1994 Per Bothner ++ ++ * cp-tree.h (THUNK_DELTA): It is normally negative, so ++ use signed .i variant of frame_size rather than unsigned .u. ++ * cp-tree.h (VTABLE_NAME_FORMAT): If flag_vtable_thunks, ++ use "VT" rather than "vt" due to binary incompatibility. ++ * class.c (get_vtable_name): Use strlen of VTABLE_NAME_FORMAT, ++ rather than sizeof, since it is now an expression. ++ * class.c (modify_one_vtable): Modify to skip initial element ++ containing a count of the vtable. ++ ++Thu Apr 21 00:09:02 1994 Jason Merrill ++ ++ * lex.c (check_newline): Force interface_unknown on main input file. ++ ++ * pt.c (do_pending_expansions): Always emit functions that have been ++ explicitly instantiated. ++ (do_function_instantiation): Set DECL_EXPLICITLY_INSTANTIATED. ++ (do_type_instantiation): Set CLASSTYPE_VTABLE_NEEDS_WRITING and ++ DECL_EXPLICITLY_INSTANTIATED on all my methods. ++ * parse.y (explicit_instantiation): Call do_type_instantiation for ++ types. ++ * decl2.c (finish_vtable_vardecl): Call import_export_vtable. ++ * decl.c (start_function): Don't set DECL_EXTERNAL on a function ++ that has been explicitly instantiated. ++ * cp-tree.h (DECL_EXPLICITLY_INSTANTIATED): Alias for ++ DECL_LANG_FLAG_4. ++ * class.c: Move import_export_vtable to decl2.c, and comment out all ++ uses. ++ ++Wed Apr 20 16:51:06 1994 Jason Merrill ++ ++ * lex.c (process_next_inline): Don't muck with DECL_INLINE. ++ (do_pending_inlines): Likewise. ++ ++Tue Apr 19 22:25:41 1994 Mike Stump ++ ++ Reimplement vtable building, and most vtable pointer setting. ++ Allows for earier maintenance, easier understandability, and most ++ importantly, correct semantics. ++ ++ * class.c (build_vtable): Removed unneeded ++ SET_BINFO_VTABLE_PATH_MARKED. ++ * class.c (prepare_fresh_vtable): Likewise. Added argument. ++ * class.c (modify_vtable_entry): General cleanup. ++ * class.c (related_vslot, is_normal, modify_other_vtable_entries, ++ modify_vtable_entries): Removed. ++ * class.c (add_virtual_function): General cleanup. ++ * class.c (finish_base_struct): Setup BINFO_VTABLE and ++ BINFO_VIRTUALS as early as we can, so that modify_all_vtables can ++ work. ++ * class.c (finish_vtbls): New routine, mostly from ++ unmark_finished_struct. ++ * class.c (overrides): New routine. ++ * class.c (modify_one_vtable): New routine, mostly from ++ modify_other_vtable_entries and modify_vtable_entries. ++ * class.c (modify_all_direct_vtables, modify_all_indirect_vtables, ++ modify_all_vtables): New routines. ++ * class.c (finish_struct): Added arguemnt to prepare_fresh_vtable ++ call. General cleanup on how pending_hard_virtuals are handled. ++ General cleanup on modifying vtables. Use finish_vtbls, instead of ++ unmark_finished_struct. ++ * cp-tree.h (init_vtbl_ptrs, expand_direct_vtbls_init, ++ get_first_matching_virtual, get_matching_virtual, ++ expand_vbase_vtables_init, expand_indirect_vtbls_init): Update. ++ * cvt.c (convert_pointer_to_real): Cleanup error message. ++ * decl.c (grokfndecl): General cleanup. ++ * decl.c (finish_function): Change init_vtbl_ptrs call to ++ expand_direct_vtbls_init. Change expand_vbase_vtables_init call to ++ expand_indirect_vtbls_init. ++ * init.c (expand_virtual_init): Remove unneeded argument. ++ * init.c (init_vtbl_ptrs): Rename to expand_direct_vtbls_init, added ++ two arguments to make more general. Made more general. Now can be ++ used for vtable pointer initialization from virtual bases. ++ * init.c (emit_base_init): Change expand_vbase_vtables_init call to ++ expand_indirect_vtbls_init. Change init_vtbl_ptrs call to ++ expand_direct_vtbls_init. ++ * init.c (expand_virtual_init): General cleanup. ++ * init.c (expand_default_init): Change expand_vbase_vtables_init ++ call to expand_indirect_vtbls_init. ++ * init.c (expand_recursive_init_1): Change expand_vbase_vtables_init ++ call to expand_indirect_vtbls_init. ++ * init.c (expand_recursive_init): Change expand_vbase_vtables_init ++ call to expand_indirect_vtbls_init. ++ * search.c (get_first_matching_virtual): Rename to ++ get_matching_virtual. General cleanup and remove setting of ++ DECL_CONTEXT. That is now done in a cleaner way in ++ modify_vtable_entry and add_virtual_function. ++ * search.c (expand_vbase_vtables_init): Rename to ++ expand_indirect_vtbls_init. General cleanup. Use ++ expand_direct_vtbls_init to do hard work. Ensures that _all_ vtable ++ pointers from virtual bases are set up. ++ * search.c (bfs_unmark_finished_struct, unmark_finished_struct): ++ Removed. ++ ++ * *.[chy]: Remove support for VTABLE_USES_MASK. ++ ++Tue Apr 19 12:51:59 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): Use NOP_EXPRs to switch between ++ reference and pointer types instead of bashing the types directly. ++ ++ * call.c (build_overload_call_real): Use the TREE_CODE to determine ++ whether the function is overloaded or not, rather than ++ TREE_OVERLOADED. ++ * *: Remove all uses of TREE_OVERLOADED. ++ ++ * decl.c (grokdeclarator): Only complain about initializing const ++ fields when -ansi or -pedantic. ++ ++Tue Apr 19 12:42:42 1994 Doug Evans ++ ++ * cp-tree.h (THUNK_DELTA): frame_size is now a union. ++ ++Mon Apr 18 00:17:13 1994 Jason Merrill ++ ++ Do overloading on a block-by-block basis, not function-by-function. ++ * decl.c: Lose overloads_to_forget. ++ (struct binding_level): Add overloads_shadowed field. ++ (poplevel): Restore overloads_shadowed. ++ (push_overloaded_decl): Use overloads_shadowed instead of ++ overloads_to_forget. ++ (finish_function): Don't look at overloads_to_forget. ++ ++ Copy enum_overflow logic from c-decl.c. ++ * decl.c (start_enum): Initialize enum_overflow. ++ (build_enumerator): Use enum_overflow. Also use current_scope(). ++ ++ * search.c (current_scope): Move Brendan's comment from ++ build_enumerator here. ++ ++ * typeck.c (convert_for_assignment): Change warnings to pedwarns for ++ discarding const/volatile. ++ ++Sat Apr 16 01:18:21 1994 Jason Merrill ++ ++ * typeck.c (comp_target_parms): Accept TEMPLATE_TYPE_PARMs on the rhs. ++ (comp_target_types): Likewise. ++ ++ * decl.c (lookup_name): Don't unset got_scope here. ++ ++ * spew.c (yylex): Only replace yylval with the TYPE_NESTED_NAME if ++ got_scope != NULL_TREE. ++ ++Fri Apr 15 16:36:33 1994 Jason Merrill ++ ++ Horrible kludge to prevent templates from being instantiated by ++ their base classes. ++ * parse.y (template_instantiate_once): Unset TYPE_BEING_DEFINED ++ before we get to left_curly. ++ * pt.c (instantiate_class_template): Set TYPE_BEING_DEFINED. ++ ++ * error.c (dump_decl): If it's a typedef, print out the name of the ++ decl, not just the underlying type. ++ ++ * decl.c (pushdecl): If the old duplicate decl was a TYPE_DECL, ++ update the IDENTIFIER_TYPE_VALUE of its name. ++ ++ * decl2.c (finish_file): When processing the initializer for a ++ static member, pretend that the dummy function is a member of the ++ same class. ++ ++Fri Apr 15 15:56:35 1994 Kung Hsu ++ ++ * class.c (build_vtable_entry): Revert Apr 4 change. ++ * decl2.c (mark_vtable_entries): Replace pure virtual function ++ decl with abort's. ++ ++Fri Apr 15 13:49:33 1994 Jason Merrill ++ ++ * typeck.c (build_conditional_expr): Pedwarn on pointer/integer ++ mismatch, and don't pedwarn on 0/function pointer mismatch. ++ ++ * typeck2.c (digest_init): Lose code for special handling of unions. ++ (process_init_constructor): Since they're handled just fine here. ++ Pedwarn on excess elements. ++ ++ * decl2.c (grokfield): Complain about local class method declaration ++ without definition. ++ ++Fri Apr 15 13:19:40 1994 Per Bothner ++ ++ * method.c (emit_thunk): Add extern declaration for ++ current_call_is_indirect (needed for hppa). ++ ++Thu Apr 14 16:12:31 1994 Jason Merrill ++ ++ Improve local class support; allow classes in different blocks to ++ have the same name. ++ * decl.c (pushtag): Support local classes better. ++ (pushdecl_nonclass_level): New function for pushing mangled decls of ++ nested types into the appropriate scope. ++ (xref_defn_tag): Use pushdecl_nonclass_level instead of ++ pushdecl_top_level. ++ (grokfndecl): Don't mess with IDENTIFIER_GLOBAL_VALUE for local ++ class methods. ++ * method.c (do_inline_function_hair): Likewise. ++ ++ * class.c (finish_struct): It is legal for a class with no ++ constructors to have nonstatic const and reference members. ++ ++Thu Apr 14 07:15:11 1994 Brendan Kehoe ++ ++ * decl.c (push_overloaded_decl): Avoid giving errors about ++ built-ins, since duplicate_decls will have given warnings/errors ++ for them. ++ ++Thu Apr 14 03:45:12 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): Warn about casting pointer type to ++ reference type when this is probably not what they wanted. ++ ++Wed Apr 13 13:12:35 1994 Per Bothner ++ ++ * decl.c (finish_decl): Don't mindlessly set TREE_USED for ++ static consts any more (toplev.c has now been modified to ++ not emit warnings if they are unused). ++ ++Wed Apr 13 00:22:35 1994 Jason Merrill ++ ++ * decl.c (grok_op_properties): If op new/delete get here with ++ METHOD_TYPEs, do a revert_static_member_fn. ++ ++ * cp-tree.h (IDENTIFIER_CLASS_TYPE_VALUE): Lose. ++ * init.c (is_aggr_typedef): Don't look at ++ IDENTIFIER_CLASS_TYPE_VALUE. ++ (get_aggr_from_typedef): Likewise. ++ (get_type_value): Likewise. ++ * call.c (build_scoped_method_call): Don't rely on overloaded ++ template names having IDENTIFIER_CLASS_VALUE set. ++ ++ * parse.y (component_decl_1, fn.def2): Revert rules for ++ constructors. ++ (component_decl_1, fn.def2): Use $1 instead of $$, since $$ is being ++ clobbered. ++ ++ * decl.c (start_function): Only warn about `void main()' if pedantic ++ || warn_return_type. ++ ++Tue Apr 12 02:14:17 1994 Jason Merrill ++ ++ Clean up overloading of the template name. ++ * class.c (pushclass): Overload the template name whenever pushing ++ into the scope of a template class, not just if it is ++ uninstantiated. ++ (popclass): Correspondingly. ++ * search.c (push_class_decls): Don't overload_template_name. ++ * pt.c (overload_template_name): Don't set IDENTIFIER_LOCAL_VALUE or ++ DECL_CONTEXT on things. ++ * parse.y (left_curly): Don't overload_template_name. ++ * class.c (finish_struct): Don't undo_template_name_overload. ++ ++ * method.c (build_opfncall): Only pass one argument to global op ++ delete. ++ ++ * call.c (build_method_call): Use TYPE_VEC_DELETE_TAKES_SIZE to ++ decide how many arguments to use for vec delete. ++ ++ * decl.c (grok_op_properties): Be consistent in modifying ++ current_class_type. ++ (grokdeclarator): Only complain about function decls with no return ++ type if we're being pedantic. ++ ++Mon Apr 11 00:10:53 1994 Jason Merrill ++ ++ Add support for operator new [] and operator delete []. ++ ++ * tree.def: Add VEC_NEW_EXPR and VEC_DELETE_EXPR. ++ * ptree.c (print_lang_type): Indicate vec new/delete. ++ * parse.y: Support vec new/delete. ++ * method.c (build_decl_overload): Deal with vec new/delete. ++ (build_opfncall): Likewise. ++ * lex.c (init_lex): Set up values of ansi_opname and opname_tab for ++ vec new/delete. vec new uses "__vn", and vec delete uses "__vd". ++ * init.c (init_init_processing): Set up BIVN and BIVD. ++ (do_friend): Don't clean up after mistaken setting of TREE_GETS_NEW, ++ since it doesn't happen any more. ++ (build_new): Support vec new. Always call something. ++ (build_x_delete): Support vec delete. ++ (build_vec_delete): Lose dtor_dummy argument, add use_global_delete, ++ and pass it to build_x_delete. ++ * decl2.c (delete_sanity): Don't change behavior by whether or not ++ the type has a destructor. Pass use_global_delete to ++ build_vec_delete. ++ (coerce_delete_type): Make sure that the type returned has a first ++ argument of ptr_type_node. ++ * decl.c (init_decl_processing): Also declare the global vec ++ new/delete. ++ (grokdeclarator): Also force vec new/delete to be static. ++ (grok_op_properties): Note presence of vec new/delete, and play with ++ their args. If vec delete takes the optional size_t argument, set ++ TYPE_VEC_DELETE_TAKES_SIZE. ++ * cp-tree.h (TYPE_GETS_{REG,VEC}_DELETE): New macros to simplify ++ checking for one delete or the other. ++ (lang_type): gets_new and gets_delete are now two bits long. The ++ low bit is for the non-array version. Lose gets_placed_new. ++ (TYPE_VEC_DELETE_TAKES_SIZE): New macro indicating that the vec ++ delete defined by this class wants to know how much space it is ++ deleting. ++ (TYPE_VEC_NEW_USES_COOKIE): New macro to indicate when vec new must ++ add a header containing the number of elements in the vector; i.e. ++ when the elements need to be destroyed or vec delete wants to know ++ the size. ++ * class.c (finish_struct_methods): Also check for overloading vec ++ delete. ++ * call.c (build_method_call): Also delete second argument for vec ++ delete. ++ ++ * decl.c (grokdeclarator): Correct complaints again. ++ (grokdeclarator): Fix segfault on null declarator. ++ (decls_match): Also accept redeclaration with no arguments if both ++ declarations were in C context. Bash TREE_TYPE (newdecl) here. ++ (duplicate_decls): Instead of here. ++ ++ * parse.y (nested_name_specifier_1): Lose rules for dealing with ++ syntax errors nicely, since they break parsing of 'const i;'. ++ ++ * decl.c (lookup_name): if (got_scope == current_class_type) ++ val = IDENTIFIER_CLASS_VALUE (name). ++ ++ * search.c (lookup_nested_tag): Look in enclosing classes, too. ++ ++ * spew.c (yylex): Only look one character ahead when checking for a ++ SCOPE. ++ ++ * lex.c (check_newline): Read first nonwhite char before ++ incrementing lineno. ++ ++ * decl.c (grokdeclarator): Don't claim that typedefs are variables ++ in warning. ++ ++ * parse.y: Divide up uses of unqualified_id into ++ notype_unqualified_id and unqualified_id, so that TYPENAME can be ++ used as an identifier after an object. ++ ++ * class.c (push_nested_class): Don't push into non-class scope. ++ ++ * decl.c (grokdeclarator): If an identifier could be a type ++ conversion operator, but has no associated type, it's not a type ++ conversion operator. ++ ++ * pt.c (unify): Check for equality of constants better. ++ ++ * decl.c (grokdeclarator): Don't complain about access decls. ++ ++Sun Apr 10 02:39:55 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): pedwarn about data definitions without ++ types here. ++ ++ * parse.y (datadef): Don't pedwarn about decls without types here, ++ since that is valid for functions. ++ (fn.def2, component_decl): Support constructors with declmods again. ++ (nomods_initdecls): For decls without any mods, so that we don't try ++ to get declspecs from some arbitrary $0. ++ ++ * search.c (lookup_field): Use cp_error. ++ ++ * parse.y (nested_name_specifier_1): Don't check aggr/non-aggr type ++ here; it breaks destructors for non-aggr types. ++ ++ * decl.c (lookup_name): Only look for TYPE_DECLs in base classes of ++ a type being defined, like the comment says. ++ If got_scope is not an aggregate, just return NULL_TREE. ++ ++ * pt.c (create_nested_upt): Kung's code for creating types nested ++ within uninstantiated templates now lives here (it used to live in ++ hack_more_ids). It needs to be expanded. ++ ++ * parse.y: Stop calling see_typename so much. ++ ++ * decl.c (lookup_name): Deal with TTPs and UPTs. ++ ++ * lex.c (real_yylex): Don't set looking_for_typename just because we ++ saw a 'new'. ++ (dont_see_typename): #if 0 out. ++ ++ * spew.c (yylex): Increment looking_for_typename if the next ++ character is SCOPE, rather than setting it to 1; this way, the value ++ from seeing an aggr specifier will not be lost. This kinda relies ++ on looking_for_typename never being < 0, which is now true. ++ ++ * parse.y (nested_name_specifier_1): Accept TEMPLATE_TYPE_PARMs, ++ too. ++ (named_class_head_sans_basetype): Accept template types, too. Oops. ++ ++Fri Apr 8 16:39:35 1994 Jason Merrill ++ ++ * decl2.c (reparse_decl_as_expr1): Handle SCOPE_REFs. ++ ++ * parse.y: Lose START_DECLARATOR. ++ ++ * search.c (lookup_nested_tag): New function to scan CLASSTYPE_TAGS ++ for a class. ++ ++ * parse.y: Simplify fn.def2 and component_decl. Support 'enum ++ A::foo' syntax. Catch invalid scopes better. ++ ++ * parse.y, lex.c: Lose TYPENAME_COLON. ++ ++ * decl2.c (groktypefield): #if 0 out. ++ ++ * decl.c (lookup_name): If the type denoted by got_scope is ++ currently being defined, look in CLASSTYPE_TAGS rather than FIELDS. ++ ++ * class.c (push_nested_class): Don't try to push into ++ error_mark_node. ++ ++Fri Apr 8 07:26:36 1994 Brendan Kehoe ++ ++ * Makefile.in (stamp-parse): Update count of conflicts to 33. ++ ++Thu Apr 7 17:47:53 1994 Jason Merrill ++ ++ A saner implementation of nested types that treats template types ++ no differently from non-template types. There are still some ++ shortcomings of our system; most notably, it is difficult to look ++ for a nested type that is hidden by another name, because of the way ++ we keep track of hidden types. But this shouldn't be a problem for ++ just about anyone. Perhaps lookup_field should be fixed up a bit. ++ ++ * spew.c: Moved handling of nested types/scoping from the lexer ++ into the parser. Removed variable template_type_seen_before_scope. ++ Removed functions frob_identifier, hack_more_ids, and various cruft ++ that was #if 0'd out in the past, reducing the size of the file from ++ 1146 lines to 450 lines. We can't quite do away with spew.c yet, ++ though; we still need it for do_aggr () and checking for SCOPE after ++ the current identifier. And setting lastiddecl. ++ ++ * parse.y: Moved handling of nested types/scoping from the lexer ++ into the parser, using a new global variable `got_scope'. Reduced ++ the number of states by 53. Implemented all uses of explicit global ++ scope. Removed terminals SCOPED_TYPENAME and SCOPED_NAME. Removed ++ nonterminals tmpl.1, scoped_base_class, id_scope, typename_scope, ++ scoped_typename. Added nonterminals nested_type, ++ qualified_type_name, complete_type_name, qualified_id, ptr_to_mem, ++ nested_name_specifier, global_scope, overqualified_id, type_name. ++ Changed many others. Added 9 new reduce/reduce conflicts, which are ++ nested type parallels of 9 that were already in the grammar for ++ non-nested types. Eight of the now 33 conflicts should be removed ++ in the process of resolving the late binding between variable and ++ function decls. ++ ++ * gxxint.texi (Parser): Update. ++ ++ * cp-tree.h (IS_AGGR_TYPE_CODE): Add UNINSTANTIATED_P_TYPE. ++ ++ * lex.h: Add decl for got_scope. ++ ++ * lex.c (see_typename): Claim to be the lexer when calling ++ lookup_name. ++ ++ * decl.c (lookup_name): When called from the lexer, look at ++ got_scope and looking_at_typename; otherwise don't. ++ ++Thu Apr 7 22:05:47 1994 Mike Stump ++ ++ 31th Cygnus<->FSF merge. ++ ++Thu Apr 7 17:47:53 1994 Jason Merrill ++ ++ * decl2.c (mark_vtable_entries): Call this to mark all the ++ entries in the vtable addressable. ++ (finish_decl_parsing): Handle SCOPE_REFs. ++ ++ * decl.c (decls_match): Always call compparms with strict == 1. ++ Handle the special case of C function redecl here. ++ (duplicate_decls): Only keep the old type if the new decl takes no ++ arguments. ++ ++ * typeck.c (compparms): Also allow t1 to be ... if strict == 0. ++ ++Thu Apr 7 16:17:50 1994 Mike Stump ++ ++ * class.c (build_vtable_entry): Fix breakage introduced Apr 5 ++ 17:48:41. ++ ++Wed Apr 6 16:05:10 1994 Per Bothner ++ ++ * init.c (build_virtual_init), search.c (build_vbase_vtables_init), ++ ch-tree.h: Every place these functions were called, the result was ++ immediately passed to expand_expr_stmt. Reduce redundancy by ++ calling expand_expr_init *inside* these functions. These ++ makes for a simpler interface, and we don't have to build ++ compound expressions. Hence, rename these function to: ++ expand_virtual_init and expand_vbase_vtables_init respectively. ++ * init.c, decl.c: Change callers of these functions. ++ * init.c, cp-tree.h (expand_virtual_init): Make static. ++ ++ * decl2.c (finish_file): Check TREE_PUBLIC||TREE_ADDRESSABLE ++ rather than DECL_SAVED_INSNS before emitting inlines. ++ ++Wed Apr 6 13:06:39 1994 Jason Merrill ++ ++ * spew.c (init_spew): #if 0 out stuff used by arbitrate_lookup. ++ ++ * decl.c (duplicate_decls): If this is a new declaration of an ++ extern "C" function, keep the type (for the argtypes). ++ (redeclaration_error_message): Don't check DECL_LANGUAGE here. ++ (decls_match): Call compparms with a value of strict dependent on ++ the value of strict_prototypes for DECL_LANGUAGE (oldecl). ++ ++ * typeck.c (compparms): ... is only equivalent to non-promoting ++ parms if we're not being strict. ++ ++ * parse.y (empty_parms): Don't check flag_ansi || pedantic here. ++ ++ * decl.c (init_decl_processing): if (flag_ansi || pedantic) ++ strict_prototypes_lang_c = strict_prototypes_lang_cplusplus; ++ ++ * decl2.c (grok_function_init): Don't set DECL_INITIAL on pure ++ virtuals. ++ ++Tue Apr 5 17:48:41 1994 Per Bothner ++ ++ Support for implementing vtables with thunks. ++ * tree.def (THUNK_DECL): New TREE_CODE. ++ * cp-tree.h (FNADDR_FROM_VTABLE_ENTRY), tree.c ++ (fnaddr_from_vtable_entry): Handle flag_vtable_thunks case. ++ * cp-tree.h (memptr_type): New variable. ++ * class.c (build_vtable_entry): Build thunk if necessary. ++ * class.c (build_vfn_ref): If using thunks, don't need ++ to add delta field from vtable (there is none!). ++ * decl.c: Add memptr_type as well as vtable_entry_type. ++ If using thunks, the latter is just ptr_type_node. ++ * gc.c, typeck.c: Use memptr_typeChange, not vtable_entry_type. ++ * decl2.c (finish_vtable_vardecl): Handle thunks. ++ * expr.c (cplus_expand_expr): Support THUNK_DECL. ++ ++ * decl.c (grokdeclarator): Set DECL_THIS_EXTERN if "extern". ++ * decl.c (start_function): Set current_extern_inline based on ++ DECL_THIS_EXTERN, not TREE_PUBLIC. ++ * decl.c (finish_function): Call mark_inline_for_output if needed, ++ ++ Improve intelligence about when to emit inlines. ++ * cp-tree.h (lang_decl_flags): New field saved_inline. ++ * cp-tree.h (DECL_SAVED_INLINE): New macro. ++ * class.c (add_virtual_function): Don't set TREE_ADDRESSABLE. ++ * decl.h, decl.c (pending_addressable_inlines): Removed. ++ * decl2.c (pending_addressable_inlines): Renamed to saved_inlines. ++ * decl2.c (mark_inline_for_output): Do nothing if ++ DECL_SAVED_INLINE; otherwise set it (and add to saved_inlines list). ++ * decl2.c (finish_vtable_vardecl): SET_CLASSTYPE_INTERFACE_KNOWN ++ and set CLASSTYPE_INTERFACE_ONLY if there is a non-inline virtual. ++ * decl2.c (finish_file): Writing out inlines later, so we can ++ also handle the ones needed for vtbales. ++ * decl2.c (write_vtable_entries, finish_vtable_typedecl): Removed. ++ ++ * cp-tree.h, class.c, decl2.c, search.c: Remove -fvtable-hack ++ and flag_vtable_hack. Use -fvtable-thunks and flag_vtable_thunks ++ instead. (The rationale is that these optimizations both break binary ++ compatibility, but should become the default in a future release.) ++ ++Wed Apr 6 10:53:56 1994 Mike Stump ++ ++ * class.c (modify_vtable_entries): Never reset the DECL_CONTEXT ++ of a fndecl, as we might not be from that vfield. ++ ++Tue Apr 5 17:43:35 1994 Kung Hsu ++ ++ * class.c (add_virtual_function): Fix bug for pure virtual, so ++ that DECL_VINDEX of the dummy decl copied won't be error. ++ (see also Apr 4 change) ++ ++Tue Apr 5 17:23:45 1994 Per Bothner ++ ++ * typeck.c (c_expand_return): Before checking that we're not ++ returning the address of a local, make sure it's a VAR_DECL. ++ (And don't worry about it being a TREE_LIST.) ++ ++Tue Apr 5 13:26:42 1994 Jason Merrill ++ ++ * parse.y (YYDEBUG): Always define. ++ * lex.c (YYDEBUG): Likewise. ++ ++Mon Apr 4 11:28:17 1994 Kung Hsu ++ ++ * class.c (finish_struct): Backup out the change below, put the ++ new change for the same purpose. The change below breaks code. ++ ++ * class.c (finish_struct): If pure virtual, copy node and make ++ RTL point to abort, then put in virtual table. ++ * decl2.c (grok_function_iit): Reinstate Mar 31 change. ++ ++Sat Apr 2 03:12:58 1994 Jason Merrill ++ ++ * init.c (build_new): pedwarn about newing const and volatile ++ types. ++ ++ * tree.c (get_identifier_list): Only do the special handling ++ thing if we're dealing with the main variant of the record type. ++ ++ * cvt.c (convert_to_reference): When converting between ++ compatible reference types, use the pointer conversion machinery. ++ Don't just blindly overwrite the old type. ++ ++Fri Apr 1 17:14:42 1994 Jason Merrill ++ ++ * call.c (build_method_call): When looking at global functions, ++ be sure to use instance_ptr for the first argument, not some version ++ of it that has been cast to a base class. Also do this before ++ comparing candidates. ++ ++Thu Mar 31 19:50:35 1994 Jason Merrill ++ ++ * call.c (build_method_call): Constructors can be called for ++ const objects. ++ ++Thu Mar 31 16:20:16 1994 Kung Hsu ++ ++ * decl2.c (grok_func_init): Do not abort as rtl for pur virtual ++ functions. They can be defined somewhere else. ++ ++Sat Jan 23 23:23:26 1994 Stephen R. van den Berg ++ ++ * decl.c (init_decl_processing): Declare __builtin_return_address ++ and __builtin_frame_address for C++ as well. ++ ++Thu Mar 31 12:35:49 1994 Mike Stump ++ ++ * typeck2.c (store_init_value): Integral constant variables are ++ always constant, even when doing -fpic. ++ ++Sat Jan 23 23:23:26 1994 Stephen R. van den Berg ++ ++ * decl.c (redeclaration_error_message): Pass the types to ++ comptypes. ++ ++Wed Mar 30 21:29:25 1994 Mike Stump ++ ++ Cures incorrect errors about pure virtuals in a class, when they ++ have been overridden in a derived class. ++ ++ * search.c (get_abstract_virtuals): Reimplement. ++ * search.c (get_abstract_virtuals_1): New routine. ++ ++Wed Mar 30 14:10:04 1994 Jason Merrill ++ ++ * pt.c (push_template_decls): Make the pushed level pseudo ++ global. ++ ++ * parse.y (extdefs): Don't pop everything if the current binding ++ level is pseudo_global. ++ ++ * decl.c (pop_everything): Stop on reaching a pseudo-global ++ binding level. ++ ++ * cp-tree.h (DECL_FUNCTION_MEMBER_P): Change to more reliable test. ++ ++ * decl.c (duplicate_decls): Only copy DECL_SOURCE_{FILE_LINE} if ++ the old decl actually had an initializer. ++ ++ * {various}: Clean up gcc -W complaints. ++ ++ * cp-tree.h (DECL_FUNCTION_MEMBER_P): Currently defined to be ++ (DECL_CONTEXT (NODE) != NULL_TREE). ++ ++ * parse.y (lang_extdef): Call pop_everything if necessary. ++ ++ * decl.c (pop_everything): New function for popping binding ++ levels left over after a syntax error. ++ (pushdecl): Use DECL_FUNCTION_MEMBER_P to decide whether or not ++ a function is a member. ++ ++Wed Mar 30 14:20:50 1994 Mike Stump ++ ++ Cures calling a more base base class function, when a more derived ++ base class member should be called in some MI situations. ++ ++ * search.c (make_binfo): Use more the more specialized base ++ binfos from the binfo given as the second argument to make_binfo, ++ instead of the unspecialized ones from the TYPE_BINFO. ++ * class.c (finish_base_struct): Likewise, update callers. ++ * search.c (dfs_get_vbase_types): Likewise. ++ * tree.c (propagate_binfo_offsets, layout_vbasetypes): Likewise. ++ * decl.c (xref_tag): Use NULL_TREE instead of 0. ++ * lex.c (make_lang_type): Likewise. ++ ++Wed Mar 30 14:10:04 1994 Jason Merrill ++ ++ * decl.c (pushdecl): If pushing a C-linkage function, only do a ++ push_overloaded_decl. ++ (duplicate_decls): Standard overloading does not shadow built-ins. ++ ++Tue Mar 29 00:54:18 1994 Jason Merrill ++ ++ * pt.c (end_template_decl): Don't call push_overloaded_decl. ++ ++ * init.c (do_friend): Don't call push_overloaded_decl. ++ ++ * decl.c (pushdecl): Call push_overloaded_decl for functions and ++ function templates. ++ (duplicate_decls): Functions and function templates are not ++ duplicates, but don't complain about calling this function to ++ compare them. ++ (push_overloaded_decl): Don't deal with linkage. Call ++ duplicate_decls. ++ (redeclaration_error_message): Deal with linkage. ++ ++ * decl.c (start_function): If push_overloaded_decl returns an ++ older version of the function, deal with it. ++ ++ * decl.c (start_function): Be sure only to push_overloaded_decl ++ for non-members. ++ ++ * decl.c (grokfndecl): Put back clearing of DECL_CHAIN for ++ methods. ++ (start_function): Lose broken and redundant code for checking old ++ decl. ++ ++ * init.c (add_friend): Give line numbers of both friend decls ++ when warning about re-friending. ++ ++ * pt.c (tsubst): Use comptypes rather than == to compare the ++ types of the method as declared and as defined, since default ++ parameters may be different. ++ ++ * call.c (build_method_call): Use brendan's candidate printing ++ routine. ++ ++ * decl.c (start_method): Methods defined in the class body are ++ inline whether or not it's a template class. ++ ++Mon Mar 28 16:39:26 1994 Jason Merrill ++ ++ * parse.y (initdcl0): Add "extern" to current_declspecs if ++ have_extern_spec && ! used_extern_spcec. ++ ++ * tree.c (really_overloaded_fn): A fn with more than one ++ overload. ++ ++ * pt.c (end_template_decl): Use really_overloaded_fn. ++ ++ * decl.c (duplicate_decls): When smashing a decl into a previous ++ definition, keep the old file and line. ++ Don't deal with overloaded functions. ++ Lose old code for checking arg types of functions. ++ Check for overloaded C functions. ++ (pushdecl): Deal with overloaded functions. ++ (start_decl): Expect pushdecl to return an appropriate function decl. ++ (start_function): Likewise. ++ (push_overloaded_decl): Don't check for overloaded C functions. ++ ++ * *.c: Stop using DECL_OVERLOADED, it being archaic. ++ TREE_OVERLOADED should probably go, too. ++ ++Mon Mar 28 14:00:45 1994 Ron Guilmette ++ ++ * typeck.c (comp_target_types): Call comp_target_parms with ++ strict == 1. ++ ++Sun Mar 27 00:07:45 1994 Jason Merrill ++ ++ * parse.y (empty_parms): Don't parse () as (...) in extern "C" ++ sections if we're compiling with -ansi or -pedantic. ++ ++ * decl.c (decls_match): Don't treat (int) and (int&) as matching. ++ ++ * decl2.c (grokfield): Don't pedwarn twice about initializing ++ field. ++ ++ * decl.c (push_overloaded_decl): Warn about shadowing ++ constructor. ++ (redeclaration_error_message): Don't allow 'int a; int a;' ++ ++ * cvt.c (build_up_reference): Only check for valid upcast if ++ LOOKUP_PROTECT is set, not just any flag. ++ ++Fri Mar 25 01:22:31 1994 Jason Merrill ++ ++ * lex.c (check_newline): When we see a #pragma implementation, ++ also set it for the main input file. ++ ++ * init.c (build_new): Convert array size argument to size_t. ++ ++ * parse.y (primary): If we're doing a parenthesized type-id, call ++ groktypename before passing it to build_new. ++ ++ * call.c (build_method_call): Deal properly with const and ++ volatile for instances of reference type. ++ ++ * decl.c (store_return_init): Change 'if (pedantic) error' to 'if ++ (pedantic) pedwarn'. ++ ++ * decl.c (grokdeclarator): Don't complain about putting `static' ++ and `inline' on template function decls. ++ ++Thu Mar 24 23:18:19 1994 Jason Merrill ++ ++ * call.c (build_method_call): Preserve const & volatile on ++ `this'. ++ ++Thu Mar 24 16:21:52 1994 Mike Stump ++ ++ * init.c (build_new, build_vec_delete): Use global new and delete ++ for arrays. ++ * decl2.c (delete_sanity): Likewise. ++ ++Thu Mar 24 02:10:46 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): If i is an lvalue, ++ (int &)i -> *(int*)&i, as per 5.2.8p9 of the latest WP. ++ (convert_force): Call convert_to_reference with LOOKUP_COMPLAIN. ++ ++Wed Mar 23 17:45:37 1994 Jason Merrill ++ ++ * decl.c (duplicate_decls): Also propagate DECL_TEMPLATE_MEMBERS ++ and DECL_TEMPLATE_INSTANTIATIONS. ++ ++ * init.c (build_new): Handle array typedefs properly. ++ ++Wed Mar 23 18:23:33 1994 Mike Stump ++ ++ 30th Cygnus<->FSF merge. ++ ++Wed Mar 23 00:46:24 1994 Mike Stump ++ ++ * class.c (modify_vtable_entries): Avoid running off the end of the ++ virtuals list when processing a virtual destructor. ++ * class.c (get_vtable_entry): Likewise. ++ ++Wed Mar 23 00:23:59 1994 Jason Merrill ++ ++ * decl.c (duplicate_decls): If two template decls don't match, ++ just return 0. ++ ++Tue Mar 22 23:49:41 1994 Jason Merrill ++ ++ * typeck.c (convert_for_assignment): Don't pedwarn about ++ converting function pointer to void *. ++ ++Tue Mar 22 22:23:19 1994 Mike Stump ++ ++ Major revamp of pointer to member functions. Cures major ++ nonfunctionality when used in casts, and MI situations. ++ ++ * cvt.c (convert_force): Update call site of build_ptrmemfunc. ++ * typeck.c (convert_for_assignment): Likewise. ++ * typeck2.c (digest_init): Likewise. ++ * typeck2.c (process_init_constructor): Simplify by moving code into ++ digest_init. ++ * typeck2.c (digest_init): Do default_conversions on init value, if ++ we are processing pointer to member functions. ++ * class.c (get_vfield_offset): Now non-static. Convert bit offset ++ into byte offset. ++ * cp-tree.h (get_vfield_offset): Likewise. ++ * typeck.c (get_member_function_from_ptrfunc): Convert down to right ++ instance, before fetching vtable pointer. ++ * typeck.c (get_delta_difference): New routine. ++ * typeck.c (build_ptrmemfunc): Revamp to handle casting better, also ++ get vtable pointer out of right subobject. ++ ++Tue Mar 22 17:56:48 1994 Mike Stump ++ ++ * search.c (get_binfo): Return NULL instead of aborting, when ++ passed a UNION_TYPE. ++ ++Tue Mar 22 12:44:54 1994 Jason Merrill ++ ++ These patches implement handling of redefinition/redeclaration of ++ templates. ++ ++ * typeck.c (comptypes): Simplify. All TEMPLATE_TYPE_PARMs are ++ considered compatible. ++ ++ * parse.y (template_def): Pass defn argument to end_template_decl. ++ ++ * pt.c (end_template_decl): Add defn argument. Check for ++ redefinition. Simplify. ++ ++ * error.c (OB_UNPUT): New macro, to remove mistakes. ++ (aggr_variety): Subroutine of dump_aggr_type. ++ ++ * decl.c (decls_match): Support templates. ++ (duplicate_decls): No longer static. Don't try to lay out template ++ decls. ++ (pushdecl): Simplify. ++ ++ * cp-tree.h (DECL_TEMPLATE_MEMBERS): Use DECL_SIZE instead of ++ DECL_INITIAL. ++ ++Mon Mar 21 11:46:55 1994 Jason Merrill ++ ++ * error.c (dump_decl): Support class template decls. ++ (dump_type): Don't adorn template type parms. ++ ++ * decl.c (duplicate_decls): Save DECL_TEMPLATE_INFO from old decl ++ if it was a definition. ++ (redeclaration_error_message): Do the cp_error thang, and reject ++ redefinition of templates. ++ ++Mon Mar 21 19:36:06 1994 Per Bothner ++ ++ * decl.c (grokdeclarator): Set TREE_PUBLIC for METHOD_TYPE ++ in FIELD context, when appropriate. Also, ++ CLASSTYPE_INTERFACE_ONLY is irrelevant to setting TREE_PUBLIC. ++ Also, simplify check for bogus return specifiers. ++ ++Mon Mar 21 11:46:55 1994 Jason Merrill ++ ++ * parse.y (after_type_declarator1): Expand type_quals. ++ (notype_declarator1): Likewise. ++ (absdcl1): Likewise. ++ ++Sat Mar 19 01:05:17 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Treat class-local typedefs like static ++ members; i.e. 'typedef int f();' means that f is a function type, ++ not a method type. ++ ++ * parse.y (decl): Change direct_* back to *. ++ (type_id): Change direct_abstract_declarator to absdcl. ++ (direct_declarator, direct_initdecls, direct_initdcl0): Remove again. ++ ++Fri Mar 18 12:47:59 1994 Jason Merrill ++ ++ These two patches fix crashes on instantiating a template inside a ++ function with C linkage or containing labels. ++ ++ * class.c (current_lang_stacksize): No longer static. ++ ++ * decl.c (struct saved_scope): Add lang_base, lang_stack, ++ lang_name, lang_stacksize, and named_labels. ++ (push_to_top_level): Save them. ++ (pop_from_top_level): Restore them. ++ ++ * gxxint.texi (Parser): Update. ++ ++ These two patches finish moving the task of expr/declarator ++ ambiguity resolution from the lexer to the parser, and add one more ++ r/r conflict. START_DECLARATOR can now be nuked. ++ ++ * parse.y (decl): Add "direct_" in typespec X rules. ++ (direct_declarator): New nonterminal for ++ direct_after_type_declarator and direct_notype_declarator. ++ (direct_initdecls): Like initdecls, but uses direct_initdcl0. ++ (direct_initdcl0): Like initdcl0, but uses direct_declarator. ++ (named_parm): Add typespec direct_declarator rule. ++ ++ * spew.c (yylex): #if 0 out START_DECLARATOR insertion. ++ ++ These two patches disable some excessive cleverness on the part of ++ g++; a non-class declaration always hides a class declaration in the ++ same scope, and g++ was trying to unhide it depending on the ++ enclosing expression. ++ ++ * spew.c (arbitrate_lookup): #if 0 out. ++ ++ * decl.c (lookup_name): Never call arbitrate_lookup. ++ ++ * parse.y (complex_notype_declarator1): Add '*' ++ complex_notype_declarator1 and '&' complex_notype_declarator1 rules. ++ ++ * parse.y (complex_direct_notype_declarator): Restore id_scope ++ see_typename TYPENAME rule, remove all other rules beginning with ++ those tokens. ++ (notype_unqualified_id): Add '~' see_typename IDENTIFIER rule. ++ ++Thu Mar 17 17:30:01 1994 Jason Merrill ++ ++ These changes fix the compiler's handling of the functional cast/ ++ object declaration ambiguities in section 6.8 of the ARM. They also ++ add 11 reduce/reduce conflicts. Sigh. ++ ++ * parse.y: Add precedence decls for OPERATOR and '~'. ++ (notype_unqualified_id): New nonterminal, encompasses all of the ++ ANSI unqualified-id nonterminal except TYPENAMEs. ++ (expr_or_declarator): New nonterminal to delay parsing of code like ++ `int (*a)'. ++ (primary): Use notype_unqualified_id. ++ (decl): Add typespec initdecls ';' and typespec declarator ';' ++ rules. ++ (initdcl0): Deal with the above. ++ (complex_notype_declarator1): A notype_declarator that is not also ++ an expr_or_declarator. ++ (complex_direct_notype_declarator): A direct_notype_declarator that ++ doesn't conflict with expr_or_declarator. Use ++ notype_unqualified_id. Remove id_scope see_typename TYPENAME rule. ++ (functional_cast): New nonterminal, for the three functional cast ++ rules. So that they can be moved after ++ complex_direct_notype_declarator. ++ (see_typename): Don't accept type_quals any more. ++ ++ * decl2.c (reparse_decl_as_expr): New function to deal with parse ++ nodes for code like `int (*a)++;'. ++ (reparse_decl_as_expr1): Recursive subroutine of the above. ++ (finish_decl_parsing): New function to deal with parse nodes for ++ code like `int (*a);'. See the difference? ++ ++Thu Mar 17 12:16:10 1994 Mike Stump ++ ++ These changes break binary compatibility in code with classes ++ that use virtual bases. ++ ++ * search.c (dfs_get_vbase_types): Simplify and correct to make ++ sure virtual bases are initialized in dfs ordering. ++ * search.c (get_vbase_types): Simplify and make readable. ++ ++Thu Mar 17 12:01:10 1994 Jason Merrill ++ ++ * parse.y: s/ typename / type_id /g ++ ++Wed Mar 16 17:42:52 1994 Kung Hsu ++ ++ * parse.y (typespec): Add SCOPE TYPENAME for global scoped ++ type. e.g. ::B x. ++ ++ * decl.c (complete_array_type): Fix a bug that in -pendantic ++ mode even there's no initializer, it will continue to build ++ default index. ++ ++Wed Mar 16 17:43:07 1994 Jason Merrill ++ ++ * parse.y (direct_notype_declarator): Add PTYPENAME rule, remove ++ all of the scoped PTYPENAME rules. ++ ++Wed Mar 16 16:39:02 1994 Mike Stump ++ ++ * init.c (build_offset_ref): The value of A::typedef_name is ++ always the TYPE_DECL, and never an error. ++ ++Tue Mar 15 20:02:35 1994 Jason Merrill ++ ++ * search.c (get_base_distance_recursive): Two binfos can only ++ represent the same object if they are both via_virtual. ++ ++ * class.c (finish_base_struct): Check vbases for ambiguity, too. ++ ++ * search.c (get_vbase_types): Accept binfo argument, too. ++ ++Tue Mar 15 19:22:05 1994 Kung Hsu ++ ++ * decl.c (complete_array_type): Complete TYPE_DOMAIN of the ++ initializer also, because back-end requires it. ++ ++Tue Mar 15 15:33:31 1994 Jason Merrill ++ ++ * error.c (dump_expr): Support member functions (which show up as ++ OFFSET_REFs). ++ ++Mon Mar 14 16:24:36 1994 Mike Stump ++ ++ * init.c (build_new): Set the return type of multidimensional ++ news correctly. ++ ++Fri Mar 11 15:35:39 1994 Kung Hsu ++ ++ * call.c (build_method_call): If basetype not equal to type ++ of the instance, use the type of the instance in building ++ destructor. ++ ++Thu Mar 10 17:07:10 1994 Kung Hsu ++ ++ * parse.y (direct_notype_declarator): Add push_nested_type for ++ 'template_type SCOPED_NAME' rule. ++ ++Tue Mar 8 00:19:58 1994 Jason Merrill ++ ++ * parse.y (parm): Add typed_declspec1 {absdcl, epsilon} rules. ++ ++Sat Mar 5 04:47:48 1994 Jason Merrill ++ ++ * parse.y (regcast_or_absdcl): New nonterminal to implement late ++ reduction of constructs like `int ((int)(int)(int))'. ++ (cast_expr): Use it. ++ (sub_cast_expr): Everything that can come after a cast. ++ (typed_declspecs1): typed_declspecs that are not typed_typespecs. ++ (direct_after_type_declarator): Lose PAREN_STAR_PAREN rule. ++ (direct_abstract_declarator): Replace '(' parmlist ')' rule with ++ '(' complex_parmlist ')' and regcast_or_absdcl. ++ (parmlist): Split ++ (complex_parmlist): Parmlists that are not also typenames. ++ (parms_comma): Enabler. ++ (named_parm): A parm that is not also a typename. Use declarator ++ rather than dont_see_typename abs_or_notype_decl. Expand ++ typed_declspecs inline. ++ (abs_or_notype_decl): Lose. ++ (dont_see_typename): Comment out. ++ (bad_parm): Break out abs_or_notype_decl into two rules. ++ ++Fri Mar 4 18:22:39 1994 Jason Merrill ++ ++ * decl2.c (reparse_decl_as_casts): New function to change parse ++ nodes for `(int)(int)(int)' from "function taking int and returning ++ function taking int and returning function taking int" to "... cast ++ to int, cast to int, cast to int". ++ ++ * decl2.c (reparse_decl_as_expr): Recursive function to change ++ parse nodes for `A()()' from "function returning function returning ++ A" to "A().operator()". ++ ++ * parse.y (primary): Replace `typespec LEFT_RIGHT' rule with ++ `typespec fcast_or_absdcl' rule. ++ (fcast_or_absdcl): New nonterminal to implement late reduction of ++ constructs like `A()()()()'. ++ (typename): Replace `typespec absdcl1' rule with ++ `typespec direct_abstract_declarator' rule. ++ (direct_abstract_declarator): Replace `LEFT_RIGHT type_quals' rule ++ with `fcast_or_absdcl type_quals' rule. ++ ++Fri Mar 4 16:18:03 1994 Mike Stump ++ ++ * tree.c (lvalue_p): Improve OFFSET_REF handling, so that it ++ matches Section 5.5. ++ ++Fri Mar 4 14:01:59 1994 Jason Merrill ++ ++ * error.c (dump_type_prefix): Don't print basetype twice for ++ pmfs. ++ ++Fri Mar 4 13:24:33 1994 Mike Stump ++ ++ * typeck.c (convert_arguments): Handle setHandler(A::handlerFn) ++ so that it is like setHandler(&A::handlerFn). Cures an `invalid ++ lvalue in unary `&''. ++ ++Fri Mar 4 11:15:59 1994 Jason Merrill ++ ++ * gxxint.texi (Copying Objects): New section discussing default ++ op= problems with virtual inheritance. ++ ++ * decl2.c (grokoptypename): Just does grokdeclarator and ++ build_typename_overload, since the parser can't call grokdeclarator ++ directly. ++ ++ * method.c (build_typename_overload): Set IDENTIFIER_GLOBAL_VALUE ++ and TREE_TYPE on generated identifiers. ++ ++ * decl.c (grokdeclarator): Don't deal with TYPE_EXPRs anymore. ++ ++ * parse.y (parm): Convert `const char *' to `__opPCc' here. ++ ++ * error.c (dump_decl): Say sorry rather than my_friendly_aborting ++ if we can't figure out what to do. ++ (dump_type*): Likewise. ++ ++ * typeck2.c (build_m_component_ref): 'component' is an expr, not ++ a decl. Also move the IS_AGGR_TYPE check after the stripping of ++ REFERENCE_TYPE. ++ ++Fri Mar 4 04:46:05 1994 Mike Stump ++ ++ * call.c (build_method_call): Handle b->setHandler(A::handlerFn) ++ so that it is like b->setHandler(&A::handlerFn). Cures an `invalid ++ lvalue in unary `&''. ++ ++Thu Mar 3 12:38:15 1994 Jason Merrill ++ ++ * parse.y: Add precedence specification for START_DECLARATOR. ++ (type_quals): Move before primary. ++ (typename): Move before typed_declspecs, add 'typespec absdcl1' rule. ++ ++ * decl2.c (grokoptypename): Lose. ++ ++ * decl.c (grokdeclarator): Parse TYPE_EXPRs in the initial scan, ++ rather than waiting until later. ++ ++Wed Mar 2 14:12:23 1994 Jason Merrill ++ ++ * parse.y (unary_expr): Use 'typename' in 'new' rules, rather ++ than expanding it inline. ++ (typename): Expand empty option of (former) absdcl inline. ++ (abs_or_notype_decl): Likewise. ++ (absdcl): Lose empty rule. ++ (conversion_declarator): New nonterminal for 'typename' of 'operator ++ typename'. ++ (operator_name): Use it instead of absdcl. ++ ++ * parse.y: Add precedence declarations for SCOPED_TYPENAME, ++ TYPEOF, and SIGOF. ++ (typed_declspecs): Accept typed_typespecs, rather than typespec ++ directly. Add rules with reserved_typespecquals. ++ (reserved_declspecs): Don't accept typespecqual_reserved at the ++ beginning of the list. The typed_declspecs rule will deal with this ++ omission. ++ (declmods): Accept nonempty_type_quals, rather than TYPE_QUAL ++ directly. ++ ++ * parse.y (direct_notype_declarator, ++ direct_after_type_declarator, direct_abstract_declarator): Split up ++ the declarator1 nonterminals to match the draft standard and avoid ++ ambiguities. ++ (new_type_id, new_declarator, direct_new_declarator, ++ new_member_declarator): New nonterminals to implement the subset of ++ 'typename' allowed in new expressions. ++ (unary_expr): Use new_type_id instead of typename. ++ (after_type_declarator1, absdcl1): Fix semantics of member pointers. ++ (abs_member_declarator, after_type_member_declarator): Lose. ++ ++ * parse.y (absdcl1): Don't require parens around ++ abs_member_declarator. ++ (abs_member_declarator): Lose see_typename from rules. ++ (after_type_member_declarator): Likewise. ++ ++ * tree.c (get_identifier_list): New function, containing code ++ previously duplicated in get_decl_list and list_hash_lookup_or_cons. ++ (get_decl_list): Use it. ++ (list_hash_lookup_or_cons): Likewise. ++ ++ * parse.y (typed_declspecs, declmods): It's not necessary to hash ++ the declspecs on class_obstack, so don't. This way typed_typespecs ++ can reduce to typed_declspecs. ++ ++Wed Mar 2 14:29:18 1994 Jason Merrill ++ ++ * cvt.c (build_up_reference): If we aren't checking visibility, ++ also allow base->derived conversions. ++ ++Mon Feb 28 15:14:29 1994 Per Bothner ++ ++ * typeck.c (build_c_cast): Remove bogus hack when converting ++ to a reference type. ++ ++ * cp-tree.h (lang_decl::vbase_init_list, DECL_VBASE_INIT_LIST): ++ Removed, not used. ++ (lang_stype::methods, lang_decl::next_method): New fields. ++ (CLASSTYPE_METHODS, DECL_NEXT_METHOD): New macros. ++ * decl.c (duplicate_decls): Preserve DECL_NEXT_METHOD. ++ ++ * cp-tree.h, decl2.c (flag_vtable_hack): New flag. ++ * decl2.c (finish_vtable_vardecl): If flag_vtable_hack, ++ and !CLASSTYPE_INTERFACE_KNOWN, try to use the presence of ++ a non-inline virtual function to control emitting of vtables. ++ * class.c (finish_struct): Build CLASSTYPE_METHODS list. ++ * search.c (build_vbase_vtables_init): Don't assemble_external ++ (yet) if flag_vtable_hack. ++ * class.c (build_vfn_ref): Likewise. ++ ++Mon Feb 28 14:54:13 1994 Jason Merrill ++ ++ * parse.y (component_decl): Don't include "typed_declspecs ++ declarator ';'" speedup, since it breaks enums. ++ ++Fri Feb 25 15:43:44 1994 Per Bothner ++ ++ * class.c (finish_struct): Minor optimization for building ++ fn_fields list. ++ ++Fri Feb 25 15:23:42 1994 Jason Merrill ++ ++ * decl.c (start_function): Fix detection of function overloading. ++ ++Thu Feb 24 22:26:19 1994 Mike Stump ++ ++ * lex.c (check_newline): #pragma interface can take a string ++ argument, just like #pragma implementation. #pragma implementation ++ checks for garbage on the line, line #pragma interface does. Main ++ input files do not auto implement like named files, #pragma ++ implementation must be used explicitly. ++ ++Thu Feb 24 17:09:01 1994 Jason Merrill ++ ++ * parse.y (components): Handle list of one again. ++ (notype_components): Likewise. ++ (after_type_declarator1): Take maybe_raises out again. ++ ++ * gxxint.texi (Parser): Document additional r/r conflict. ++ ++Wed Feb 23 14:42:55 1994 Jason Merrill ++ ++ * gxxint.texi (Parser): Add node. ++ ++ * Makefile.in (stamp-parse): Update expected conflict count. ++ ++ * parse.y (various): Replace "declmods declarator" with "declmods ++ notype_declarator". The comment saying that "declmods declarator ';'" ++ corresponds to "int i;" was wrong; it corresponds to "const i;". ++ (component_decl): Add "typed_declspecs declarator ';'" rule; this ++ *does* correspond to "int i;". Change "declmods components" to ++ "declmods notype_components". ++ (components): Don't deal with a list of one anymore. ++ (notype_components): New nonterminal, corresponds to notype_declarator. ++ ({after_,no}type_component_decl{,0}): More new nonterminals. ++ ({after_,no}type_declarator): Fold in START_DECLARATOR token. ++ Eliminates four reduce/reduce conflicts. ++ ++ (expr): Depend on nontrivial_exprlist instead of nonnull_exprlist. ++ (nontrivial_exprlist): New nonterminal: A list of at least two ++ expr_no_commas's. ++ (nonnull_exprlist): Depend on nontrival_exprlist. ++ Eliminates four reduce/reduce conflicts. ++ ++ (named_class_head): Move intermediate code block into separate ++ nonterminal so that we can stick %prec EMPTY on it. ++ ++ Add more %prec EMPTY's to eliminate remaining shift/reduce ++ conflicts. ++ ++ (after_type_declarator): Add maybe_raises to fndecl rules. ++ (after_type_declarator_no_typename): Remove. ++ For correctness. ++ ++ Document remaining reduce/reduce conflicts. ++ ++Tue Feb 22 12:10:32 1994 Jason Merrill ++ ++ * search.c (get_base_distance): Only bash BINFO_INHERITANCE_CHAIN ++ (TYPE_BINFO (type)) if we care about the path. ++ ++ * tree.c (lvalue_p): A COND_EXPR is an lvalue if both of the ++ options are. ++ ++Mon Feb 21 19:59:40 1994 Mike Stump ++ ++ * Makefile.in (mostlyclean): lex.c is a source file, don't ++ remove. ++ ++Sat Feb 19 01:27:14 1994 Jason Merrill ++ ++ * parse.y: Eliminate 20 shift/reduce conflicts. ++ ++Fri Feb 18 11:49:42 1994 Jason Merrill ++ ++ * pt.c (type_unification): Add subr argument; if set, it means ++ that we are calling ourselves recursively, so a partial match is OK. ++ (unify): Support pointers to methods and functions. ++ (tsubst): Support method pointers. ++ * decl.c (build_ptrmemfunc_type): No longer static, so that ++ tsubst can get at it. ++ ++ * init.c (is_aggr_typedef): Pretend template type parms are ++ aggregates. ++ * decl2.c (build_push_scope): If cname refers to a template type ++ parm, just grin and nod. ++ ++ * call.c (build_overload_call_real): Pass subr argument to ++ type_unification. ++ * pt.c (do_function_instantiation): Likewise. ++ * class.c (instantiate_type): Likewise. ++ ++ * search.c (get_base_distance): If BINFO is a binfo, use it and ++ don't mess with its BINFO_INHERITANCE_CHAIN. ++ ++ * cvt.c (convert_to_reference): Fix temporary generation. ++ If ambiguous, return error_mark_node. ++ ++ * init.c (build_new): Put back some necessary code. ++ ++Thu Feb 17 15:39:47 1994 Jason Merrill ++ ++ * init.c (build_new): Deal with array types properly. ++ ++ * search.c (get_binfo): Become a shell for get_base_distance. ++ (get_binfo_recursive): Lose. ++ (get_base_distance_recursive): Find the path to the via_virtual base ++ that provides the most access. ++ (get_base_distance): Likewise. ++ ++ * parse.y (explicit_instantiation): Syntax is 'template class ++ A', not 'template A'. ++ ++ * typeck.c (convert_for_initialization): Remove bogus warning. ++ ++ * parse.y (datadef): Revert patch of Oct 27. ++ ++Thu Feb 17 15:12:29 1994 Per Bothner ++ ++ * class.c (build_vfn_ref): Cast delta field to ptrdiff_type_node, ++ rather than integer_type_node. Does wonders for the Alpha. ++ ++Thu Feb 17 13:36:21 1994 Jason Merrill ++ ++ * decl.c (build_ptrmemfunc_type): Make sure that the pmf type ++ goes onto the same obstack as its target type. ++ ++Wed Feb 16 00:34:46 1994 Jason Merrill ++ ++ * cvt.c (convert_to_reference): If converting via constructor ++ on local level, go back to build_cplus_new approach. ++ ++ * tree.c (build_cplus_new): If with_cleanup_p, set cleanup slot ++ to error_mark_node to prevent expand_expr from building a cleanup ++ for this variable. ++ ++ * lex.c (default_assign_ref_body): Return *this from the memcpy ++ version, too. ++ ++ * decl.c (grok_reference_init): Just return if called with ++ error_mark_node, don't worry about initializing non-const reference ++ with temporary. ++ ++ * cvt.c (convert_to_reference): Do the right thing for ++ non-aggregate reference conversions, pedwarn when generating a ++ non-const reference to a temporary. ++ ++ * class.c (finish_struct): TYPE_HAS_COMPLEX_{INIT,ASSIGN}_REF and ++ TYPE_NEEDS_CONSTRUCTING all depend on TYPE_USES_VIRTUAL_BASECLASSES ++ again. ++ ++Tue Feb 15 19:47:19 1994 Jason Merrill ++ ++ * decl.c (grok_reference_init): Pawn off a lot of the work on ++ convert_to_reference. Generally do the right thing. ++ ++ * cvt.c (convert_to_reference): Conform to the initial comment; ++ i.e. don't create temps if decl != error_mark_node. Handle ++ cleanups better for temps that do get created. Don't pretend ++ that we can use an 'A' to initialize a 'const double &' just by ++ tacking on a NOP_EXPR. Support LOOKUP_SPECULATIVELY. ++ ++ * call.c (build_method_call): Set TREE_HAS_CONSTRUCTOR on ++ constructor calls. ++ ++Mon Feb 14 14:50:17 1994 Jason Merrill ++ ++ * decl.c (grok_reference_init): Make a temporary for initializing ++ const reference from constant expression. ++ ++Mon Feb 14 11:31:31 1994 Per Bothner ++ ++ * cp-tree.h, decl.c (set_identifier_local_value): Deleted function. ++ * decl.c (pushdecl): Define decl in correct binding_level ++ (which isn't always the inner_binding_level). ++ ++ * cvt.c (build_up_reference): Don't ever call expand_aggr_init. ++ It's ugly, and I don't think it's the right thing to do. ++ ++ * cp-tree.h, class.c, decl.c, decl2.c, sp/search.c: ++ Remove NEW_CLASS_SCOPING, assuming it is always 1. ++ * decl.c (pop_decl_level): Removed; manually inlined. ++ ++Sun Feb 13 19:04:56 1994 Jason Merrill ++ ++ * class.h (candidate): Add basetypes field. ++ ++ * call.c (build_method_call): Do access checking after choosing a ++ function, not before. ++ ++ * Makefile.in (cvt.o, call.o, method.o): Depend on class.h. ++ (mostlyclean): Remove ../cc1plus. ++ ++Fri Feb 11 11:52:26 1994 Jason Merrill ++ ++ * class.c (finish_struct): Don't allow adjusting access to a field ++ of a base class if a local field has the same name. ++ ++ * error.c (dump_type_prefix): Output basetype for METHOD_TYPEs. ++ ++Thu Jan 13 17:55:51 1994 Gnanasekaran Swaminathan ++ ++ * cp-tree.h (DESTRUCTOR_NAME_P): Do not confuse AUTO_TEMP names ++ with destructor names when either NO_DOLLAR_IN_LABEL or ++ NO_DOT_IN_LABEL are not defined. ++ ++ Now `template class A {...}' works. ++ ++ * pt.c (grok_template_type): Substitute template parm types ++ with actual types in complex type as well. ++ (coerce_template_parms): Update the grok_template_type () ++ function call. ++ ++ * pt.c (tsubst): Traverse method list using DECL_CHAIN. ++ ++ * decl.c (grok_op_properties): Allow operator++/-- to have ++ default arguments. ++ ++ * typeck2.c (store_init_value): Don't abort when called to ++ initialize a type that needs constructing with a CONSTRUCTOR. ++ ++ * init.c (expand_aggr_init_1, CONSTRUCTOR case): If ++ store_init_value fails, build and expand an INIT_EXPR. If ++ store_init_value succeeds, call expand_decl_init. ++ ++Fri Feb 11 02:49:23 1994 Mike Stump ++ ++ * class.c (build_vbase_path): Use complete_type_p instead of ++ resolves_to_fixed_type_p to determine if the virtual bases are in ++ their right place for the type of expr. Cures problem of thinking a ++ virtual base class is one place, when it is in fact someplace else. ++ ++Fri Feb 11 00:26:46 1994 Mike Stump ++ ++ * init.c (resolve_offset_ref): Make sure we first convert to ++ intermediate type, if given, when dealing with members off `this'. ++ Solves an incorrrect `type `foo' is not a base type for type ++ `multiple'' when it is infact, a base type. ++ ++Thu Feb 10 21:49:35 1994 Mike Stump ++ ++ * class.c (modify_other_vtable_entries): Use get_binfo, instead ++ of binfo_value. Solves problem with compiler giving a `base class ++ `B' ambiguous in binfo_value (compiler error)' on complex MI ++ herarchies, when a virtual function is first defied in a virtual ++ base class. ++ ++Thu Feb 10 17:19:32 1994 Mike Stump ++ ++ * class.c (build_vbase_path): Don't complain about ambiguous ++ intermediate conversion when converting down to a virtual base ++ class, even if they might seem to be ambiguous. ++ ++Thu Feb 10 12:18:26 1994 Jason Merrill ++ ++ * typeck2.c (build_functional_cast): #if 0 out constructor ++ inheritance code, improve error messages. ++ ++ * class.c (finish_base_struct): Complain about base with only ++ non-default constructors in derived class with no constructors. ++ ++ * decl.c (grokdeclarator): Fix detection of virtual new/delete. ++ ++Wed Feb 9 22:02:32 1994 Mike Stump ++ ++ * search.c (build_mi_virtuals, add_mi_virtuals, ++ report_ambiguous_mi_virtuals): Removed unneeded code. ++ * class.c (finish_struct_bits): Likewise. ++ ++Wed Feb 9 11:27:17 1994 Jason Merrill ++ ++ * pt.c (end_template_instantiation): Push decl before ++ pop_from_top_level. ++ ++ * typeck2.c (build_m_component_ref): Make sure datum is of ++ aggregate type. ++ ++ * init.c (get_type_value): New function, returns ++ IDENTIFIER_TYPE_VALUE or IDENTIFIER_CLASS_TYPE_VALUE or NULL_TREE. ++ ++ * call.c (build_method_call): Don't die on call to destructor for ++ non-type. ++ ++ * decl.c (grokdeclarator): Complain about virtual op new and op ++ delete, make static virtuals unvirtual instead of unstatic. ++ ++ * typeck.c (build_c_cast): Also call default_conversion on ++ methods. ++ ++ * decl.c (grokdeclarator): Don't complain about anonymous ++ bitfields. ++ ++ * parse.y (simple_stmt, for loops): Move the continue point after ++ the cleanups. ++ ++ * class.c (finish_struct): Fix setting of ++ TYPE_HAS_COMPLEX_INIT_REF. ++ ++Tue Feb 8 13:21:40 1994 Jason Merrill ++ ++ * init.c (build_new): Deal with `new double (1)'. ++ ++ * class.c (finish_struct): TYPE_HAS_COMPLEX_*_REF are supersets of ++ TYPE_HAS_REAL_*_REF, but TYPE_HAS_COMPLEX_INIT_REF is independent of ++ TYPE_NEEDS_CONSTRUCTING. ++ ++ * decl.c (duplicate_decls): Propagate access decls. ++ ++ * typeck2.c (process_init_constructor): Accept empty_init_node ++ for initializing unions. ++ ++ * class.c, lex.c, cp-tree.h: Use ++ TYPE_HAS_COMPLEX_ASSIGN_REF where TYPE_HAS_REAL_ASSIGN_REF was used ++ before, use TYPE_HAS_COMPLEX_INIT_REF for TYPE_NEEDS_CONSTRUCTING in ++ some places. ++ ++ * decl.c (finish_decl): Don't complain about uninitialized const ++ if it was initialized before. ++ ++Mon Feb 7 18:12:34 1994 Jason Merrill ++ ++ * lex.c (default_assign_ref_body): Don't deal with vbases for ++ now. ++ ++ * decl.c (finish_decl): Fix reversed logic for objects and other ++ things that need to be constructed but have no initializer. ++ ++ * class.c (finish_struct): Don't set TYPE_HAS_* flags that are ++ set by grok_op_properties or finish_decl. ++ ++ * decl.c: Don't warn about extern redeclared inline unless ++ -Wextern-inline is given. ++ * decl2.c (lang_decode_option): Likewise. ++ * cp-tree.h: Likewise. ++ ++Mon Feb 7 17:29:24 1994 Per Bothner ++ ++ * decl.c (pushdecl_with_scope): Fix thinko. Add forward ++ declaration. ++ ++ * decl.c (pushdecl_with_scope): New function. ++ * decl.c (pushdecl_top_level): Use new function. ++ * decl.c (pushtag): Initialize newdecl. ++ * decl.c (pushtag): Push new type decl into correct scope. ++ ++Mon Feb 7 14:42:03 1994 Jason Merrill ++ ++ * call.c, cvt.c, init.c, search.c, cp-tree.h: ++ Eradicate LOOKUP_PROTECTED_OK. ++ ++Mon Feb 7 13:57:19 1994 Per Bothner ++ ++ * decl.c (pushtag, xref_tag), cp-tree.h: Add extra parameter ++ 'globalize' to signify implicit declarations. ++ * decl.c (globalize_nested_type, maybe_globalize_type): Removed. ++ * decl.c (set_identifier_type_value_with_scope): New function. ++ * decl.c (set_identifier_local_value): Simplify. ++ * spew.c (yylex, do_addr): Modify to return a _DEFN if a ++ forward declaration (followed by ';' and not preceded by 'friend'). ++ * class.c, decl.c, except.c, init.c, parse.y, ++ pt.c, search.c: Add new argument to calls to xref_tag and ++ pushtag. ++ ++Mon Feb 7 00:22:59 1994 Jason Merrill ++ ++ * cp-tree.h (ACCESSIBLY_UNIQUELY_DERIVED_P): New macro, means what ++ ACCESSIBLY_DERIVED_FROM_P meant before. ++ (ACCESSIBLY_DERIVED_FROM_P): Now disregards ambiguity. ++ ++ * cvt.c (build_up_reference): Call get_binfo with PROTECT == 1. ++ ++ * search.c (get_base_distance_recursive): Members and friends of ++ a class X can implicitly convert an X* to a pointer to a private or ++ protected immediate base class of X. ++ (get_binfo_recursive): Likewise. ++ (get_base_distance): Ignore ambiguity if PROTECT < 0. ++ (get_binfo): Lose multiple values of PROTECT. ++ (compute_access): Protected is OK if the start of the ++ search is an accessible base class of current_class_type. ++ ++ * method.c (build_opfncall): Do check access on operator new here. ++ ++ * decl.c (finish_function): Don't check access on operator new ++ here. ++ ++Sun Feb 6 14:06:58 1994 Jason Merrill ++ ++ * decl.c (xref_tag): The base of a derived struct is NOT always ++ public. Duh. ++ ++ * pt.c (do_explicit_instantiation): New function, called from ++ parser to do explicit function instantiation. ++ (type_unification): Allow the args list to be terminated with ++ void_list_node. ++ (do_pending_expansions): Look at i->interface for non-member ++ templates. ++ ++ * parse.y (datadef): Move explicit_instantiation here. ++ (structsp): From here. ++ (datadef): Complain about `int;'. ++ ++Sun Feb 6 12:33:18 1994 Per Bothner ++ ++ * pt.c (end_template_instantiation), cp-tree.h: Remove unused ++ second parameter, and simplify first from a TREE_LIST where ++ we only care about its TREE_VALUE to just the value (an IDENTIFIER). ++ * pt.c (instantiate_member_templates): Simplify argument list ++ from a TREE_LIST to just an IDENTIFIER. ++ * lex.c (yyprint): PRE_PARSED_CLASS_DECL is now just an IDENTIFIER. ++ * parse.y (template_instantiate_once): Simplify accordingly. ++ * decl.c (inner_binding_level): New. Use various places to ++ simplify. ++ ++Sun Feb 6 02:49:37 1994 Jason Merrill ++ ++ * typeck2.c (build_functional_cast): int() -> int(0). ++ ++Sat Feb 5 00:53:21 1994 Jason Merrill ++ ++ * class.c (finish_struct): Don't do a bitwise copy for op= if the ++ class has a virtual function table. ++ ++ * typeck.c (convert_for_initialization): Restore warnings about ++ not using defined op=. Should really be my_friendly_aborts, I ++ s'pose. ++ ++Fri Feb 4 14:21:00 1994 Jason Merrill ++ ++ * class.c (finish_struct): Tidy up conditions for doing bitwise ++ copies of objects. ++ ++ * decl.c (build_default_constructor): #if 0 out. ++ ++ * *: Eradicate TYPE_GETS_{ASSIGNMENT,ASSIGN_REF,CONST_ASSIGN_REF, ++ CONST_INIT_REF}, TYPE_HAS_REAL_CONSTRUCTOR. ++ ++ * decl.c (grokdeclarator): Don't return void_type_node for ++ friends being defined here. ++ ++ * init.c (perform_member_init): Only do the init if it's useful. ++ ++ * lex.c (default_copy_constructor_body): If we don't need to do ++ memberwise init, just call __builtin_memcpy. ++ (default_assign_ref_body): Likewise. ++ ++ * decl.c (grokdeclarator): If friendp && virtualp, friendp = 0. ++ ++Fri Feb 4 13:02:56 1994 Mike Stump ++ ++ * lex.c (reinit_parse_for_method, cons_up_default_function): ++ Don't give warn_if_unknown_interface warning when it came from a ++ system header file. ++ * pt.c (end_template_decl, instantiate_template): Likewise. ++ * decl.c (start_decl): Likewise. ++ ++Fri Feb 4 00:41:21 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Don't try to set TYPE_WAS_ANONYMOUS on ++ enums. ++ ++ * decl2.c (constructor_name_full): Use IS_AGGR_TYPE_CODE instead of ++ IS_AGGR_TYPE, since we don't know it's a type. ++ ++Thu Feb 3 11:36:46 1994 Jason Merrill ++ ++ * decl.c (grokdeclarator): Don't complain about anonymous unions. ++ ++ * cp-tree.h (TYPE_WAS_ANONYMOUS): This struct was originally ++ anonymous, but had a name given to it by a typedef. ++ ++ * decl.c (grokdeclarator): When renaming an anonymous struct, set ++ TYPE_WAS_ANONYMOUS. ++ ++ * decl2.c (constructor_name_full): Use TYPE_WAS_ANONYMOUS. ++ ++ * cp-tree.h (DECL_UNDEFINED_FRIENDS): #if 0 out. ++ ++ * init.c (xref_friend): Don't set up DECL_UNDEFINED_FRIENDS. ++ (embrace_waiting_friends): Don't use DECL_UNDEFINED_FRIENDS. ++ ++ * decl.c (grokdeclarator): Set TYPE_NESTED_NAME properly on nested ++ anonymous structs that get typedef'd. ++ ++ * decl.c (grokdeclarator): Always return void_type_node for ++ friends. ++ ++ * error.c (dump_function_decl): Don't use DECL_CLASS_CONTEXT for ++ friends. ++ (dump_function_decl): Don't print out default args for ++ a function used in an expression. ++ ++ * decl.c (grokdeclarator): Give error on abstract declarator used ++ in an invalid context (i.e. `void (*)();'). ++ ++ * error.c (cp_line_of): Support _TYPE nodes. ++ (cp_file_of): Likewise. ++ ++ * cvt.c (build_up_reference): Don't abort if passed a SAVE_EXPR; ++ it can happen for the RHS of an assignment stmt where the LHS is ++ a COND_EXPR. ++ ++ * init.c (expand_aggr_init_1): Deal with bracketed initializer ++ lists properly. ++ ++ * class.c (finish_struct): Deal with enumerators and typedefs ++ again. ++ ++Wed Feb 2 11:30:22 1994 Jason Merrill ++ ++ * class.c (finish_struct): Tidy up loop over fields. ++ ++ * errfn.c (cp_thing): Don't advance twice after a format. ++ ++ * class.c (finish_struct): Complain about needing a constructor ++ if a member has only non-default constructors, and don't try to ++ generate a default constructor. ++ ++ * decl.c (finish_decl): Also do the constructor thing if ++ TYPE_NEEDS_CONSTRUCTING is set (for arrays). ++ ++ * search.c (unuse_fields): New function: mark all fields in this ++ type unused. ++ (dfs_unuse_fields): Helper function. ++ ++ * class.c (pushclass): If the new class is the same as the old ++ class, still unuse the fields. ++ (unuse_fields): Move to search.c. ++ ++ * decl.c (grok_op_properties): Add friendp argument. ++ (grokfndecl): Pass it. ++ (start_method): Likewise. ++ ++ * decl2.c (delete_sanity): Add use_global_delete parameter to catch ++ ::delete calls. ++ ++ * parse.y (unary_expr): Pass new parameter to delete_sanity. ++ ++ * lex.c (default_copy_constructor_body): Don't choke if the union ++ has no fields. ++ (default_assign_ref_body): Likewise. ++ ++ * call.c (compute_conversion_costs_ansi): Do the right thing for ++ ellipsis matches. ++ ++ * decl.c (push_to_top_level): Optimize. ++ ++ * decl.c (start_function): Look for the lexical scope of a friend ++ in DECL_CLASS_CONTEXT. ++ ++ * init.c (do_friend): Set DECL_CLASS_CONTEXT on global friends. ++ ++Tue Feb 1 15:59:24 1994 Jason Merrill ++ ++ * cp-tree.h (TREE_GETS_PLACED_NEW): New macro. ++ ++ * init.c (init_init_processing): Don't assign BIN/BID to the ++ IDENTIFIER_GLOBAL_VALUEs of their respective operators. ++ (build_new): Check TREE_GETS_PLACED_NEW. ++ ++ * decl.c (grok_op_properties): Don't set TREE_GETS_NEW for a decl of ++ op new with placement, set TREE_GETS_PLACED_NEW. ++ ++ * cp-tree.h (ANON_UNION_P): New macro. Applies to decls. ++ ++ * class.c (finish_struct): Don't treat anonymous unions like ++ other aggregate members. Do synthesize methods for unions without ++ a name, since they may or may not be "anonymous unions". ++ ++ * decl2.c (grok_x_components): Wipe out memory of synthesized methods ++ in anonymous unions. ++ ++ * lex.c (default_copy_constructor_body): Support unions. ++ (default_assign_ref_body): Likewise. ++ ++Mon Jan 31 12:07:30 1994 Jason Merrill ++ ++ * cp-tree.h: Fix documentation of LOOKUP_GLOBAL, add prototypes. ++ ++ * error.c (args_as_string): New function (%A), like type_as_string ++ except NULL_TREE -> "..." ++ ++ * call.c (build_overload_call_real): Fix for new overloading. ++ ++ * decl.c (grok_op_properties): Set all of the TYPE_OVERLOADS_* flags ++ here. ++ ++ * parse.y (operator_name): Instead of here. ++ ++ * typeck2.c (build_functional_cast): Treat a TREE_LIST as a list ++ of functions. ++ ++ * call.c (build_overload_call_real): Support LOOKUP_SPECULATIVELY. ++ ++ * method.c (build_opfncall): Don't need to massage return value ++ any more, call build_overload_call with all flags. ++ ++ * typeck.c (build_x_binary_op): Put back speculative call to ++ build_opfncall. ++ (build_x_unary_op): Likewise. ++ (build_x_conditional_expr): Likewise. ++ ++Mon Jan 31 10:00:30 1994 Mike Stump ++ ++ * cvt.c (build_type_conversion_1): Change call to pedwarn into ++ warning, and conditionalize upon warn_cast_qual. ++ ++Fri Jan 28 11:48:15 1994 Jason Merrill ++ ++ * search.c (lookup_field): If xbasetype is a binfo, copy it to ++ avoid clobbering its inheritance info. ++ ++ * call.c (build_method_call): Don't overwrite basetype_path with ++ TYPE_BINFO (inst_ptr_basetype) if they have the same type. ++ ++ * search.c (compute_access): Fix handling of protected inheritance ++ and friendship with the enclosing class. ++ ++ * typeck2.c (store_init_value): Allow passing of TREE_CHAIN for ++ initialization of arbitrary variable. ++ ++ * typeck2.c (build_functional_cast): Only try calling a method if ++ one exists. ++ ++ * decl.c (grokdeclarator): Move handling of constructor syntax ++ initialization into first loop for generality. ++ (parmlist_is_random): Lose. ++ ++ * lex.c (cons_up_default_function): Set TREE_PARMLIST on arguments ++ to default function. ++ ++Thu Jan 27 19:26:51 1994 Jason Merrill ++ ++ * decl.c (grokparms): Abort if we get called with something we don't ++ expect. ++ ++Thu Jan 27 17:37:25 1994 Mike Stump ++ ++ * call.c (build_overload_call_real): Change argument complain to ++ flags to match style of rest of code. Pass it down to ++ build_function_call_real as necessary. ++ * call.c (build_overload_call, build_overload_call_maybe): Change ++ argument complain to flags to match style of rest of code. ++ * cp-tree.h (build_function_call_real): Added fourth flags ++ argument. ++ * cvt.c (convert_to_reference): Only give warning messages, if ++ LOOKUP_COMPLAIN is set. ++ * typeck.c (build_x_function_call): Change simple complain ++ argument to build_overload_call_maybe and build_overload_call, to ++ LOOKUP_COMPLAIN to match style of rest of code. ++ * typeck2.c (build_functional_cast): Likewise. ++ * typeck.c (build_function_call_real): Add flags, so that we can ++ not complain, if we don't want to complain. Complain about ++ arguments, if we are complaining, otherwise don't. ++ * typeck.c (build_function_call, build_function_call_maybe): ++ Stick in flags argument. ++ * typeck.c (build_x_binary_op, build_x_unary_op, ++ build_x_conditional_expr, build_x_compound_expr): Follow style of ++ build_x_indirect_ref, as it is more correct and more common. ++ ++Thu Jan 27 14:36:20 1994 Jason Merrill ++ ++ * call.c (build_method_call): Don't check for being called with ++ a pointer. ++ ++ * decl2.c (finish_file): Don't play with DECL_CLASS_CONTEXT for the ++ static initializer function. ++ ++ * init.c (build_member_call): Use convert_force here, too. ++ ++ * search.c (compute_access): Only treat static members specially ++ if they are referenced directly. ++ ++Wed Jan 26 18:28:14 1994 Jason Merrill ++ ++ * gxxint.texi (Access Control): New node. ++ ++ * search.c (current_scope): New function; returns whichever of ++ current_class_type and current_function_decl is the most nested. ++ (compute_access): Total overhaul to make it clearer and more ++ correct. Don't use the cache for now; in the only situation where ++ it was used before, it gained nothing. This frees up three of the ++ DECL_LANG_FLAGs for possible other use! ++ ++ * cp-tree.h: #if 0 out DECL_PUBLIC & friends. ++ ++ * typeck.c (build_component_ref_1): Don't check DECL_PUBLIC. ++ ++ * call.c (build_method_call): Use convert_force to cast `this' -- ++ rely on the access checking for the method itself. ++ ++ * init.c (is_friend): Do the nesting thing, handle types. I am ++ my own friend. ++ (is_friend_type): Become a shell for is_friend. ++ (add_friend): Never stick in ctype. ++ Why are the friendship functions in init.c, anyway? ++ ++Wed Jan 26 17:50:00 1994 Mike Stump ++ ++ * cvt.c (build_type_conversion_1): Don't conditionalize call to ++ pedwarn upon pedantic. ++ ++Wed Jan 26 17:20:46 1994 Mike Stump ++ ++ * cvt.c (convert_to_reference): Add 8.4.3 checking so that one ++ gets a warning if one tries to initialize a non-const & from a ++ non-lvalue. ++ * cvt.c (convert_to_reference): Use %P format for argument ++ numbers in warnings. ++ ++Wed Jan 26 14:35:06 1994 Mike Stump ++ ++ * init.c (build_delete): Follow style in call.c to construct the ++ virtual call to the desctructor, as that code is right. Fixes a ++ problem of the compiler saying a pointer conversion is ambiguous. ++ ++Wed Jan 26 11:28:14 1994 Jason Merrill ++ ++ * cp-tree.h (VTABLE_NAME_P): Change other occurrence of ++ VTABLE_NAME_FORMAT to VTABLE_NAME. ++ ++ * *: s/visibility/access/g ++ ++Tue Jan 25 18:39:12 1994 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Don't smash references if INIT_EXPR. ++ ++Tue Jan 25 13:54:29 1994 Mike Stump ++ ++ * init.c (build_delete): Back out Jan 17th & 18th pacthes, as ++ they break libg++. ++ ++Tue Jan 25 13:11:45 1994 Jason Merrill ++ ++ * decl.c (duplicate_decls): Fix pointer arithmetic. ++ ++Mon Jan 24 15:50:06 1994 Chip Salzenberg ++ ++ [ cp-* changes propagated from c-* changes in 940114 snapshot ] ++ * cp-parse.y (maybe_attribute): Allow multiple __attribute__ ++ clauses on a declaration. ++ ++Mon Jan 24 17:06:23 1994 Jason Merrill ++ ++ * class.c (finish_struct): Do synthesize methods for anon ++ structs, just not unions. ++ ++Mon Jan 24 13:50:13 1994 Kung Hsu ++ ++ * decl.c (xref_tag): Handle anonymous nested type. ++ * decl.c (globalize_nested_type): Add no globalize bit check. ++ * spew.c (hack_more_ids): Templated nested decl not push top ++ level. ++ ++ * parse.y: Get rid of 'goto do_components'. It is much better ++ for debugging. ++ ++ * decl.c (is_anon_name): Get rid of the function and use the ++ macro ANON_AGGRNAME_P. ++ * pt.c: Ditto. ++ ++Fri Jan 21 14:06:02 1994 Jason Merrill ++ ++ * class.c (finish_struct): Don't synthesize any methods for ++ anonymous structs/unions. ++ ++ * typeck.c (build_modify_expr): Don't treat pmf's as class objects. ++ ++Thu Jan 20 18:56:46 1994 Jason Merrill ++ ++ * method.c (build_opfncall): Call build_indirect_ref on ++ synthesized instance for operator delete. ++ ++ * pt.c (type_unification): Don't abort if called with a list of ++ types in ARGS. ++ ++ * class.c (instantiate_type): Deal with function templates. ++ ++Thu Jan 20 16:55:35 1994 Jim Wilson ++ ++ * Makefile.in (CC): Default to cc not gcc. ++ ++Thu Jan 20 13:47:54 1994 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Call constructor if appropriate. ++ ++ * decl.c (push_to_top_level): Clear out class-level bindings cache. ++ ++Wed Jan 19 13:51:22 1994 Jason Merrill ++ ++ * call.c (resolve_scope_to_name): Work recursively (previously only ++ looked down one level). ++ ++ * lex.c (do_pending_inlines): If we're still dealing with the last ++ batch of inlines, don't start working on a new one. ++ ++ * Makefile.in (stamp-parse): Update conflict count. ++ (TAGS): Fix. ++ ++ * parse.y (explicit_instantiation): New rule; implements ++ 'template A' syntax (though not 'template foo(int)' yet). ++ (structsp): Add explicit_instantiation. ++ ++Tue Jan 18 13:53:05 1994 Jason Merrill ++ ++ * class.c (finish_struct, etc.): Simplify decision to synthesize ++ a destructor. ++ ++ * call.c, class.c, cp-tree.h, decl.c, init.c, ++ ptree.c, search.c, typeck.c, typeck2.c: Nuke ++ TYPE_NEEDS_CONSTRUCTOR (change all calls to TYPE_NEEDS_CONSTRUCTING). ++ * init.c (expand_aggr_init_1): Don't try non-constructor methods ++ of initializing objects. ++ (build_new): Don't try other methods if the constructor lookup fails. ++ ++ * class.c (finish_base_struct): Set cant_have_default_ctor and ++ cant_synth_copy_ctor properly. ++ (finish_struct): Likewise. ++ ++Mon Jan 17 13:58:18 1994 Jason Merrill ++ ++ * typeck.c (build_modify_expr_1): #if 0 out again. ++ (build_modify_expr): #if 0 out memberwise init code again. ++ ++ * lex.c (default_copy_constructor_body): Be const-correct. ++ (default_assign_ref_body): Likewise. ++ ++ * init.c (perform_member_init): Use TYPE_HAS_CONSTRUCTOR to decide ++ whether or not to use it, rather than TYPE_NEEDS_CONSTRUCTING. ++ (expand_aggr_init): Disable silent conversion from initializer list ++ to list of args for a constructor. ++ ++ * class.c (base_info): Lose needs_default_ctor. ++ (finish_base_struct): Likewise. ++ (finish_struct): Likewise. ++ ++ * decl.c (init_decl_processing): Don't turn off flag_default_inline ++ just because flag_no_inline is on. ++ (finish_decl): Use TYPE_HAS_CONSTRUCTOR to decide to use ++ constructor. ++ ++ * class.c (finish_struct): Synthesize default ctor whenever ++ allowed. ++ ++ * Makefile.in (TAGS): Don't try to run etags on cp-parse.y. ++ ++Sat Jan 15 18:34:33 1994 Mike Stump ++ ++ * Makefile.in, configure: Handle the C++ front-end in a ++ subdirectory. ++ * cp-*: Move C++ front-end to cp/*. ++ ++Fri Jan 14 14:09:37 1994 Jason Merrill ++ ++ * cp-typeck.c (build_function_call_real): Modify to match other ++ instances of taking the address of the function. ++ ++ * cp-class.c (finish_struct): Set TYPE_HAS_REAL_CONSTRUCTOR to 1 if ++ there are non-synthesized constructors. ++ Only set TYPE_NEEDS_CONSTRUCTOR if TYPE_HAS_REAL_CONSTRUCTOR. ++ Always generate copy constructor if possible. ++ ++ * cp-tree.h (lang_type): Add has_real_constructor bitfield. ++ (TYPE_HAS_REAL_CONSTRUCTOR): Define. ++ ++ * cp-lex.c (default_copy_constructor_body): Use init syntax ++ for all bases. ++ ++ * cp-type2.c (store_init_value): Only give error for initializer list ++ if TYPE_HAS_REAL_CONSTRUCTOR. ++ ++Thu Jan 13 15:38:29 1994 Jason Merrill ++ ++ * cp-tree.h (DECL_SYNTHESIZED): Add defn. ++ (lang_decl): Add synthesized bitfield to decl_flags. ++ ++ * cp-lex.c (cons_up_default_function): Use DECL_SYNTHESIZED to mark ++ artificial methods, rather than a line # of 0. ++ ++Fri Jan 14 18:25:29 1994 Kung Hsu ++ ++ * cp-decl (xref_tag): Fix a bug in conflict type. ++ * cp-parse.y: Add SCOPED_NAME for uninstantiated template nested ++ type reference. ++ * cp-spew.c (yylex): Generated SCOPED_NAME token. ++ * cp-lex.c (yyprint): Handle SCOPED_NAME. ++ ++Fri Jan 14 17:00:29 1994 Mike Stump ++ ++ * cp-decl.c (pushdecl): Revert patch from Jan 11 19:33:03, as it is ++ not right. ++ ++Thu Jan 13 14:00:35 1994 Kung Hsu ++ ++ * cp-decl2.c (grok_x_components): Fix a bug that enum type does not ++ have type_flags. ++ ++Thu Jan 13 11:39:34 1994 Mike Stump ++ ++ Ensure that all vtable pointers are initialized with all the right ++ values. ++ ++ * cp-class.c (is_normal): Changed to reflect new meaning of ++ CLASSTYPE_VFIELD_PARENT. ++ * cp-class.c (maybe_fixup_vptrs): Use of ++ CLASSTYPE_NEEDS_VIRTUAL_REINIT here is misguided. Use ++ BINFO_MODIFIED instead. ++ * cp-class.c (finish_struct): Changed to reflect new meaning of ++ CLASSTYPE_VFIELD_PARENT. ++ * cp-decl.c (get_binfo_from_vfield): Removed, unneeded now. ++ * cp-decl.c (finish_function): Use init_vtbl_ptrs, instead of open ++ coding it here. ++ * cp-init.c (init_vfields): Changed name to init_vtbl_ptrs, and ++ re-implement. ++ * cp-init.c (emit_base_init): Use new name init_vtbl_ptrs. ++ * cp-tree.h (vfield_parent): Changed to integer. ++ * cp-tree.h (CLASSTYPE_VFIELD_PARENT): Changed docs to reflect new ++ meaning. ++ * cp-tree.h (init_vtbl_ptrs): Added init_vtbl_ptrs. ++ ++Wed Jan 12 18:24:16 1994 Kung Hsu ++ ++ * cp-decl.c (xref_tag): Re-implement globalize nested type. ++ * cp-decl2.c (grok_x_components): Ditto. ++ * cp-parse.y: Ditto. ++ * cp-tree.h (lang_type): Add no_globalize bit in type_flags. ++ ++Wed Jan 12 14:08:09 1994 Jason Merrill ++ ++ * cp-decl.c (grokdeclarator): Don't set TREE_PUBLIC on friend ++ decls with a definition attached. ++ ++ * cp-typeck.c (build_modify_expr): Undo previous change in the case ++ of INIT_EXPRs. ++ ++Tue Jan 11 19:33:03 1994 Jason Merrill ++ ++ * cp-typeck.c (build_modify_expr): Replace code for generating ++ assignment semantics for classes with an error. ++ (build_modify_expr_1): #if 0 out. ++ ++ * cp-decl.c (pushdecl): Patch bogus design of pushdecl ++ behavior for overloaded functions (it doesn't push anything). ++ ++ * cp-class.c (finish_struct): When generating default op=, ++ set TYPE_HAS_ASSIGNMENT. ++ ++Mon Jan 10 18:48:06 1994 Mike Stump ++ ++ * cp-cvt.c (convert): Make {double, clashing enum} -> enum ++ invalid. ++ * cp-typeck.c (convert_for_assignment): Simplify. ++ * cp-decl2.c (warn_enum_clash): Removed. ++ * invoke.texi (-Wenum-clash): Removed. ++ * toplev.c (-Wenum-clash): Removed. ++ ++Mon Jan 10 17:48:37 1994 Kung Hsu ++ ++ * cp-decl.c (finish_decl): Fix incorrect popclass call. ++ ++ * cp-decl.c (is_anon_name): New function, check whether the name ++ is anonymous name generated by compiler. ++ * cp-decl.c (grokdeclarator): Allow nested SCOPE_REF ++ * cp-spew.c (hack_more_ids): Handle nested type in template. ++ * cp-parse.y: Handle nested type reference in uninstantiated ++ template. ++ * cp-call.c (build_method_call): Handle uninstantiated template ++ case. ++ * cp-pt.c (search_nested_type_in_tmpl): New function, search nested ++ type in template. ++ * cp-pt.c (lookup_nested_type_by_name): New function, lookup nested ++ type by name. ++ * cp-pt.c (tsubst): Handle nested type search by name. ++ ++Mon Jan 10 14:32:18 1994 Jason Merrill ++ ++ * cp-init.c (build_member_call): Propagate qualifiers to new type. ++ ++ * cp-call.c (build_method_call): Count functions the new way. ++ ++Fri Jan 7 19:03:26 1994 Jason Merrill ++ ++ * cp-decl.c (pushtag): Set DECL_ASSEMBLER_NAME for nested classes, ++ too. ++ ++Tue Jan 4 16:45:51 1994 Kung Hsu ++ ++ * cp-parse.y: Change to handle whether to globalize nested class. ++ * cp-decl.c (xref_tag, maybe_globalize_type): Likewise. ++ ++Mon Jan 3 22:22:32 1994 Gerald Baumgartner ++ ++ * Makefile.in cp-call.c cp-class.c cp-cvt.c cp-decl.c cp-decl2.c ++ cp-error.c cp-init.c cp-lex.c cp-lex.h cp-method.c cp-parse.y ++ cp-spew.c cp-tree.c cp-tree.h cp-type2.c cp-typeck.c cp-xref.c ++ gplus.gperf toplev.c: Incorporated C++ signature extension. ++ * cp-sig.c: New file, contains most of signature processing. ++ * cp-hash.h: Regenerated from gplus.gperf. ++ ++ * gcc.1 g++.1: Added explanation for the `-fhandle-signatures' ++ and `-fno-handle-signatures' command line flags. ++ ++ * gcc.texi: Changed the last-modification date. ++ * invoke.texi: Added `-fhandle-signatures' in the list of ++ C++ language options. Added explanation for this option. ++ ++Tue Dec 28 21:10:03 1993 Mike Stump ++ ++ * cp-init.c (expand_vec_init): Remove comptypes test, as it is too ++ harsh here. ++ ++Tue Dec 28 13:42:22 1993 Mike Stump ++ ++ * cp-pt.c (do_pending_expansions): Decide to expand a template ++ member function, based upon it's class type, not the class type of ++ the first place it was declared. ++ ++Tue Dec 28 05:42:31 1993 Mike Stump ++ ++ * cp-class.c (is_normal): New routine, use to determine when the ++ given binfo is the normal one. (The one that should have the simple ++ vtable name.) ++ * cp-class.c (modify_other_vtable_entries): Use DECL_ASSEMBLER_NAME ++ to check if two fndecls are `the same'. Sometimes this routine can ++ modify the main vtable, and normal should be 1, in that case, so use ++ is_normal() to determine if this is the main vtable for the class. ++ Don't recurse down virtual bases, as they are shared, and we take ++ care of them elsewhere. ++ * cp-class.c (modify_vtable_entries): If we have already updated the ++ vtable with the new virtual, don't do it again. ++ * cp-class.c (finish_struct): Set CLASSTYPE_VFIELD_PARENT as ++ appropriate. Do virtual function overriding in virtual bases, after ++ normal overriding, so that the base function list in DECL_VINDEX is ++ not overridden, before we have a chance to run through the list. ++ Use DECL_ASSEMBLER_NAME to check if two fndecls are `the same'. ++ Make sure we pass the right address into modify_vtable_entries. ++ * cp-tree.h (CLASSTYPE_VFIELD_PARENT): New field to indicate which ++ binfo is the one that has the vtable that we based our vtable on. ++ ++Fri Dec 24 09:40:52 1993 Michael Tiemann ++ ++ * cp-typeck.c (c_expand_start_case): Use default_conversion to ++ convert expression from reference type if necessary. ++ ++Wed Dec 22 17:58:43 1993 Jason Merrill ++ ++ * cp-typeck.c (build_unary_op): Make sure that it's a TREE_LIST before ++ trying to read its TREE_VALUE. ++ ++ * cp-class.c (finish_struct_methods): Clear DECL_IN_AGGR_P here. ++ (finish_struct): Instead of here. ++ ++Tue Dec 21 14:34:25 1993 Brendan Kehoe ++ ++ * cp-tree.c (list_hash_lookup_or_cons): Make sure the type doesn't ++ have TYPE_PTRMEMFUNC_P set before we try to build its ++ CLASSTYPE_ID_AS_LIST. ++ (get_decl_list): Likewise, when trying to read it. ++ ++ * cp-tree.h (VTABLE_NAME): No def with NO_{DOLLAR,DOT} defined. ++ (VTABLE_NAME_P): Use it instead of VTABLE_NAME_FORMAT. ++ ++Mon Dec 20 13:35:03 1993 Brendan Kehoe ++ ++ * cp-typeck.c (rationalize_conditional_expr): New function. ++ (unary_complex_lvalue): Use it. ++ (build_modify_expr): Use it, since trying to do an ADDR_EXPR of it ++ with build_unary_op won't cut it. Don't wrap the COND_EXPR with a ++ SAVE_EXPR either. ++ ++ * cp-decl2.c (explicit_warn_return_type): Deleted variable. ++ (lang_decode_option): Set warn_return_type, not explicit_*, for ++ -Wreturn-type and -Wall. This is what rest_of_compilation uses to ++ decide if it should go into jump_optimize or not. ++ * cp-tree.h (explicit_warn_return_type): Deleted. ++ * cp-decl.c (grokdeclarator): Use warn_return_type, not explicit_*. ++ (finish_function): Also complain about no return in a non-void fn if ++ we're being pedantic (don't rely on use of -Wreturn-type). ++ ++Fri Dec 17 15:45:46 1993 Brendan Kehoe ++ ++ * cp-decl.c (grokdeclarator): Forbid declaration of a function as ++ static if it's being done inside another function. ++ ++ * cp-search.c (compute_visibility): Check for friendship both ways. ++ ++Fri Dec 17 14:28:25 1993 Jason Merrill ++ ++ * cp-cvt.c (build_default_binary_type_conversion): Make error ++ messages more helpful. ++ ++ * cp-error.c (op_as_string): New function, returns "operator ==" ++ given EQ_EXPR or suchlike. ++ ++Fri Dec 17 13:28:11 1993 Brendan Kehoe ++ ++ * cp-call.c (print_n_candidates): New function. ++ (build_overload_call_real): Use it when we complain about a call ++ being ambiguous. ++ ++Fri Dec 17 12:41:17 1993 Jason Merrill ++ ++ * cp-call.c (build_method_call): Fix checking for static call ++ context. ++ ++ * cp-method.c (build_opfncall): Call build_indirect_ref on argument ++ to operator new. ++ ++ * cp-init.c (build_new): Don't mess with rval when building ++ indirect ref. ++ ++Thu Dec 16 16:48:05 1993 Kung Hsu ++ ++ * cp-lex.c (default_assign_ref_body): Add check when TYPE_NESTED_ ++ NAME(type) may not be exist. It's not a problem for old compiler. ++ ++Thu Dec 16 14:46:06 1993 Brendan Kehoe ++ ++ * cp-tree.h (CLASSTYPE_ALTERS_VISIBILITIES_P): Delete macro, it's ++ never used for anything. ++ (struct lang_type, member type_flags): Delete field ++ `alters_visibility', and up `dummy' by 1. ++ * cp-class.c (finish_base_struct): Delete code that copies the ++ setting of CLASSTYPE_ALTERS_VISIBILITIES_P. ++ (finish_struct): Delete code that sets it. ++ ++Thu Dec 16 14:44:39 1993 Jason Merrill ++ ++ * cp-decl.c, cp-init.c, cp-typeck.c: Fix arguments to ++ build_method_call that I messed up before. ++ ++ * cp-search.c (get_base_distance): If protect > 1, allow immediate ++ private base. ++ ++ * cp-class.c (finish_base_struct): Set cant_synth_* correctly. ++ (finish_struct): Likewise. Well, nigh-correctly; it won't deal ++ properly with the case where a class contains an object of an ++ ambiguous base class which has a protected op=. Should be fixed ++ when the access control code gets overhauled. ++ (finish_struct_methods): Set TYPE_HAS_NONPUBLIC_* correctly. ++ ++Thu Dec 16 12:17:06 1993 Brendan Kehoe ++ ++ * cp-lex.c (real_yylex): Turn the code back on that deals with ++ __FUNCTION__ and __PRETTY_FUNCTION__. Don't use lookup_name, to ++ avoid the ambiguity problems that led to it being turned off in the ++ first place. ++ ++ * cp-method.c (hack_identifier): Also check for a TYPE_PTRMEMFUNC_P ++ to see if something is a method. ++ ++Wed Dec 15 18:35:58 1993 Mike Stump ++ ++ * cp-typeck.c (build_modify_expr): Avoid error messages on small ++ enum bit fields. ++ * cp-typeck.c (convert_for_assignment): Add missing argument to ++ cp_warning and cp_pedwarn calls. ++ ++Wed Dec 15 18:25:32 1993 Jason Merrill ++ ++ * cp-parse.y (member_init): ANSI C++ doesn't forbid old-style base ++ initializers; it's just anachronistic. ++ ++ * cp-decl.c (finish_decl): Don't require external-linkage arrays ++ to have a complete type at declaration time when pedantic. ++ ++Tue Dec 14 11:37:23 1993 Jason Merrill ++ ++ * cp-decl.c (pushdecl): Don't set DECL_CONTEXT if it's already set. ++ ++ * cp-call.c (build_method_call): Don't dereference pointer given ++ as instance. ++ ++ * cp-decl.c (finish_function): Don't pass pointer to ++ build_method_call. ++ (finish_function): Likewise. ++ ++ * cp-typeck.c (build_x_function_call): Likewise. ++ ++ * cp-method.c (build_component_type_expr): Likewise. ++ ++ * cp-init.c (build_member_call): Likewise. ++ (build_new): Likewise. ++ ++Mon Dec 13 18:04:33 1993 Kung Hsu ++ ++ * cp-decl.c (xref_tag): Fix regression created by changes made ++ in Dec. 7 1993. ++ * cp-decl.c (xref_defn_tag): Fix parallel nested class problem. ++ ++Fri Dec 10 12:40:25 1993 Brendan Kehoe ++ ++ * cp-call.c (compute_conversion_costs_ansi) [DEBUG_MATCHING]: Print ++ out the final evaluation of the function, so we can see if ELLIPSIS, ++ USER, and EVIL were set at the end. ++ ++ * cp-call.c (convert_harshness_ansi): When the parm isn't an lvalue, ++ only go for setting TRIVIAL_CODE if we are dealing with types that ++ are compatible. ++ ++Thu Dec 9 18:27:22 1993 Mike Stump ++ ++ * cp-decl.c (flag_huge_objects): New flag to allow large objects. ++ * toplev.c (lang_options): Likewise. ++ * cp-decl2.c (flag_huge_objects, lang_f_options): Likewise. ++ * cp-decl.c (delta_type_node): New type for delta entries. ++ * cp-tree.h (delta_type_node): Likewise. ++ * cp-decl.c (init_decl_processing): Setup delta_type_node. ++ * cp-decl.c (init_decl_processing, build_ptrmemfunc_type): Use ++ delta_type_node instead of short_integer_type_node. ++ * cp-class.c (build_vtable_entry): Likewise. ++ ++Thu Dec 9 16:19:05 1993 Brendan Kehoe ++ ++ * cp-tree.h (OPERATOR_TYPENAME_P): Define outside of ++ NO_{DOLLAR,DOT} macro checks, so it always gets defined. ++ (VTABLE_NAME_P): Define for NO_DOT && NO_DOLLAR_IN_LABEL. ++ ++Wed Dec 8 17:38:06 1993 Mike Stump ++ ++ * cp-decl.c (finish_decl): Make sure things that can go into ++ "common", do go into common, if -fcommon is given. ++ ++Wed Dec 8 13:01:54 1993 Brendan Kehoe ++ ++ * cp-call.c (print_harshness) [DEBUG_MATCHING]: New function. ++ (compute_conversion_costs_ansi) [DEBUG_MATCHING]: Print out ++ argument matching diagnostics to make instantly clear what the ++ compiler is doing. ++ ++ * cp-call.c (convert_harshness_ansi): If the parm isn't an lvalue, ++ then check to see if the penalty was increased due to ++ signed/unsigned mismatch, and use a TRIVIAL_CODE if it wasn't. ++ ++Tue Dec 7 18:29:14 1993 Kung Hsu ++ ++ * cp-decl.c (xref_tag, pushtag): Fix nested class search/resolution ++ problem. ++ ++Tue Dec 7 16:09:34 1993 Jason Merrill ++ ++ * cp-class.c (finish_struct): Before synthesizing methods, if no ++ methods have yet been declared then set nonprivate_method. Don't ++ set non_private method after synthesizing a method. ++ ++ * cp-lex.c (extract_interface_info): If flag_alt_external_templates ++ is set, tie emitted code to the location of template instantiation, ++ rather than definition. ++ ++ * cp-tree.h: Declare flag_alt_external_templates. ++ ++ * cp-decl2.c (lang_decode_option): Support -falt-external-templates. ++ ++ * toplev.c (lang_options): Likewise. ++ ++Mon Oct 4 12:50:02 1993 Chip Salzenberg ++ ++ [changes propagated from 930810 snapshot] ++ * cp-decl.c (init_decl_processing): Make long long available for use ++ as SIZE_TYPE and PTRDIFF_TYPE. ++ (finish_decl): Allow file-scope static incomplete array. ++ (grokdeclarator): Don't pass on const and volatile fron function ++ value type to function type. ++ Warn here for volatile fn returning non-void type. ++ * cp-parse.y (attrib): Accept attributes `volatile' with alias ++ `noreturn', and `const'. ++ * cp-typeck.c (default_conversion): Don't lose const and volatile. ++ (build_binary_op_nodefault): Generate pedantic warning for comparison ++ of complete pointer type with incomplete pointer type. ++ (build_c_cast): Be careful that null pointer constant be INTEGER_CST. ++ ++Tue Dec 7 10:46:48 1993 Jason Merrill ++ ++ * cp-init.c (expand_vec_init): When creating a temporary for copying ++ arrays, use the type of the source, not the target. ++ ++ * cp-cvt.c (convert): Pass an argument for errtype to ++ convert_to_reference. ++ ++ * cp-error.c (dump_expr, COMPONENT_REF & CALL_EXPR): Deal with ++ methods, -> and `this'. ++ ++Mon Dec 6 17:12:33 1993 Jason Merrill ++ ++ * cp-error.c (parm_as_string): New function; returns `this' or arg ++ number. Corresponds to %P. ++ (dump_expr): Deal with method calls. ++ ++ * cp-cvt.c (convert_to_reference): Stop using warn_for_assignment. ++ * cp-typeck.c (convert_for_assignment): Likewise. ++ (warn_for_assignment): Lose. ++ ++Mon Dec 6 11:33:35 1993 Brendan Kehoe ++ ++ * cp-call.c (ideal_candidate_ansi): Delete code that was never ++ doing anything useful. Instead, sort once, and DO NOT wipe ++ out any codes with EVIL_CODE, since that's what we use as a ++ marker for the end of the list of candidates. ++ ++ * cp-cvt.c (convert_to_aggr): Make sure to always set H_LEN. ++ ++Mon Dec 6 12:49:17 1993 Jason Merrill ++ ++ * cp-init.c (get_aggr_from_typedef): New function, like ++ is_aggr_typedef but returns the _TYPE. ++ ++ * cp-call.c, cp-init.c, cp-method.c: Eradicate err_name. ++ ++Sun Dec 5 18:12:48 1993 Brendan Kehoe ++ ++ * cp-lex.c (readescape): Pedwarn when a hex escape is out of range. ++ ++Thu Nov 25 23:50:19 1993 Chip Salzenberg ++ ++ Delay language context change until beginning of next decl. ++ ++ * cp-lex.h (c_header_level): Removed. ++ (pending_lang_change): Declared. ++ * cp-lex.c (c_header_level): Renamed from in_c_header, made static. ++ (pending_lang_change): Defined. ++ (check_newline): Rework code that recognizes line number and ++ filename changes. Instead of pushing and popping lang context, ++ increment and decrement pending_lang_change. ++ (do_pending_lang_change): Push and pop lang context according ++ to value of pending_lang_change. ++ * cp-parse.y (extdefs): Use lang_extdef instead of extdef. ++ (extdef): Same as extdef, but call do_pending_lang_change() first. ++ ++Mon Nov 15 15:39:15 1993 Chip Salzenberg ++ ++ * cp-typeck.c (build_binary_op_nodefault): Warn for ordered ++ compare of ptr with 0 only if pedantic in both cases. ++ ++Thu Nov 25 13:31:37 1993 Chip Salzenberg ++ ++ Reinstate the below patch, which got lost in the Cygnus merge: ++ Tue Nov 23 13:59:24 1993 Hallvard B Furuseth (hbf@durin.uio.no) ++ * cp-parse.y (maybe_type_qual): Don't fail to set $$. ++ ++Wed Nov 17 19:03:30 1993 Chip Salzenberg ++ ++ * cp-parse.y (attrib): Allow "ident(ident)" like the C front end. ++ ++Fri Oct 22 20:43:37 1993 Paul Eggert ++ ++ * cp-lex.c (real_yylex): Diagnose floating point constants ++ that are too large. ++ ++Wed Nov 17 19:10:37 1993 Chip Salzenberg ++ ++ * cp-type2.c (build_functional_cast): ARM page 16: When a class ++ and an object, function or enumerator are declared in the same ++ scope with the same name, the class name is hidden. ++ ++Wed Nov 17 19:07:18 1993 Chip Salzenberg ++ ++ * cp-call.c (convert_harshness_ansi): Distinguish float, double, ++ and long double from each other when overloading. ++ (compute_conversion_costs_{ansi,old}, build_method_call, ++ build_overlay_call_real, convert_to_aggr): Always set and ++ always use H_LEN member of candidate structure. ++ ++Mon Oct 11 23:10:53 1993 Chip Salzenberg ++ ++ * cp-decl.c (duplicate_decls): Note redeclarations of library ++ functions, and generate distinct warnings for them. ++ ++Mon Oct 4 12:26:49 1993 Chip Salzenberg ++ ++ Support format warnings in G++. ++ ++ * cp-tree.h: Protect against multiple inclusion. ++ Declare all public functions in c-common.c (copy from c-tree.h). ++ (STDIO_PROTO): Define. ++ (warn_format): Declare. ++ (record_format_info): Remove declaration. ++ * cp-decl.c (init_decl_processing): Call init_function_format_info. ++ * cp-decl2.c (lang_decode_option): Make "-Wall" include warn_format. ++ * cp-typeck.c (build_function_call_real): Call check_function_format. ++ (record_format_info): Remove -- obsolete stub. ++ ++Sat Jul 24 12:04:29 1993 Chip Salzenberg ++ ++ * cp-decl.c (duplicate_decls): Don't warn for non-extern var decl ++ following an extern one (for -Wredundant-decls). ++ * cp-parse.y (primary): In statement expression case, if compstmt ++ returns something other than a BLOCK, return it unchanged. ++ ++Thu Dec 2 20:44:58 1993 Chip Salzenberg ++ ++ * cp-decl.c (warn_extern_redeclared_static): New function made ++ from code extracted from pushdecl. ++ (duplicate_decls, pushdecl): Call new function. ++ (lookup_name_current_level): Allow for IDENTIFIER_GLOBAL_VALUE ++ to be a TREE_LIST when function is declared in 'extern "C" {}'. ++ ++Fri Dec 3 16:01:10 1993 Jason Merrill ++ ++ * cp-class.c (duplicate_tag_error): Use cp_error. ++ (finish_base_struct): Check for ambiguity with direct base, and don't ++ generate op= or copy ctor if it exists. ++ ++Fri Dec 3 15:32:34 1993 Kung Hsu ++ ++ * cp-init.c (expand_member_init): When initializer name is null, ++ don't try to build it now because emit_base_init will handle it. ++ ++Fri Dec 3 12:28:59 1993 Jason Merrill ++ ++ * cp-lex.c (init_lex): Initialize input_filename to "" for ++ code such as ExceptionHandler::operator=. ++ ++Fri Dec 3 10:32:08 1993 Jason Merrill ++ ++ * cp-decl.c (grokdeclarator): Don't try to print out dname when ++ complaining about arrays of references if decl_context==TYPENAME, ++ since it will be null. ++ ++ * cp-decl2.c: Default to flag_ansi_overloading. ++ ++Thu Dec 2 18:05:56 1993 Kung Hsu ++ ++ * cp-call.c (build_method_call): Use binfo from instance if it's ++ different from binfo (basetype_path) passed from above. ++ ++Wed Nov 17 19:14:29 1993 Chip Salzenberg ++ ++ cp-error.c (dump_expr): Use unsigned chars to output a ++ TREE_REAL_CST in hex. ++ ++Thu Dec 2 11:05:48 1993 Jason Merrill ++ ++ * cp-class.c (finish_struct): Fix typo in setting ++ cant_synth_asn_ref. ++ ++ * cp-tree.h (TYPE_NESTED_NAME): New macro, does ++ DECL_NESTED_TYPENAME (TYPE_NAME (NODE)). ++ ++ * cp-lex.c (default_copy_constructor_body): Change ++ DECL_NAME (TYPE_NAME (btype)) to TYPE_NESTED_NAME (btype). ++ (default_assign_ref_body): Likewise. ++ (default_copy_constructor_body): Call operator= explicitly for ++ base classes that have no constructor. ++ ++Thu Dec 2 10:47:15 1993 Michael Tiemann ++ ++ * cp-call.c (build_method_call): If the instance variable is ++ converted to error_mark_node when we're trying to convert it to the ++ base type of a method we're looking up, return error_mark_node. ++ ++Thu Dec 2 10:41:16 1993 Torbjorn Granlund ++ ++ * cp-typeck.c (build_binary_op_nodefault): In *_DIV_EXPR *_MOD_EXPR ++ cases, tests for unsigned operands by peeking inside a NOP_EXPR. ++ ++Wed Dec 1 13:33:34 1993 Brendan Kehoe ++ ++ * cp-call.c (compute_conversion_costs_ansi): Use the size of struct ++ harshness_code, not the size of short, for clearing out the ++ ansi_harshness. ++ ++ * cp-call.c (print_candidates): New function. ++ (build_method_call): When we had some candidates, but didn't get a ++ usable match, don't report that we got an error with the first ++ candidate. Instead, say there were no matches, and list the ++ candidates with print_candidates. In the second pass, make sure we ++ clear out ever_seen, so we can accurately count the number of ++ functions that qualified. ++ ++Wed Dec 1 09:53:59 1993 Torbjorn Granlund ++ ++ * cp-typeck.c (build_binary_op_nodefault): Shorten for *_MOD_EXPR ++ only if op1 is known to be != -1. ++ (build_binary_op_nodefault): Handle *_DIV_EXPR likewise. ++ ++Tue Nov 30 14:07:26 1993 Brendan Kehoe ++ ++ * cp-method.c (hack_identifier): If the field itself is private, and ++ not from a private base class, say so. ++ ++Mon Nov 29 03:00:56 1993 Jason Merrill ++ ++ * cp-decl.c (grokdeclarator): Always warn on initialization of ++ const member. ++ ++Wed Nov 24 00:49:35 1993 Jason Merrill ++ ++ * cp-class.c (finish_struct): Set TYPE_GETS_CONST_* properly. ++ (finish_base_struct): Set cant_synth_asn_ref properly. ++ ++ * cp-lex.c (cons_up_default_function): Add section for operator=. ++ (default_assign_ref_body): New function, mostly cribbed from ++ default_copy_constructor_body. ++ ++ * cp-class.c (base_info): Add members cant_synth_copy_ctor, ++ cant_synth_asn_ref, no_const_asn_ref. ++ (finish_base_struct): Update no_const_asn_ref, note that you should ++ update cant_synth_*, propagate TYPE_GETS_ASSIGN_REF. ++ (finish_struct): Add decls for cant_synth_*, no_const_asn_ref, and ++ initialize them properly. Set no_const_asn_ref properly. Set ++ cant_synth_* in some of the situations where they should be set. ++ Propagate TYPE_GETS_ASSIGN_REF. Use cant_synth_copy_ctor. Add call ++ to cons_up_default_function for operator=. ++ ++Tue Nov 23 20:24:58 1993 Mike Stump ++ ++ * cp-cvt.c (convert_force): Add code to perform casting of pointer ++ to member function types. ++ * cp-typeck.c (build_ptrmemfunc): Add FORCE parameter to indicate ++ when the conversion should be done, regardless. ++ * cp-tree.h (build_ptrmemfunc): Likewise. ++ * cp-type2.c (digest_init): Likewise. ++ * cp-typeck.c (convert_for_assignment): Likewise. ++ ++Tue Nov 23 18:06:58 1993 Jason Merrill ++ ++ * cp-error.c (dump_expr): Do the right thing for variables of ++ reference type. ++ ++ * cp-decl.c (grok_op_properties): Set TYPE_HAS_ASSIGN_REF ++ and its kin properly. ++ (xref_tag): Propagate TYPE_GETS_ASSIGN_REF. ++ ++Tue Nov 23 12:26:13 1993 Mike Stump ++ ++ * cp-method.c (build_opfncall): Don't count pointer to member ++ functions as aggregates here, as we don't want to look up methods in ++ them. The compiler would core dump if we did, as they don't have ++ normal names. ++ * cp-typeck.c (build_indirect_ref): Improve wording on error ++ message. ++ ++Mon Nov 22 14:22:23 1993 Jason Merrill ++ ++ * cp-decl.c (grok_op_properties): Allow operator?: with pedwarn ++ (since it's supported in other compiler bits). ++ ++ * cp-method.c (report_type_mismatch): Use cp_error; ignore err_name ++ argument. ++ ++ * cp-error.c (dump_function_decl): Don't print return type for ++ constructors and destructors. ++ ++ * cp-cvt.c (cp_convert_to_pointer): Import code from ++ convert_to_pointer so we can return error_mark_node in the case of an ++ error, and to allow more meaningful error messages. ++ (build_type_conversion): Don't go through void* when trying ++ to convert to a pointer type. ++ ++ * cp-decl.c (grokfndecl): Move call to grok_op_properties back ++ after grokclassfn so that it's dealing with the right decl. ++ (grok_op_properties): Don't assert !methodp for op new and op delete. ++ ++ * cp-init.c (build_delete): Don't use TYPE_BUILT_IN (there are now ++ no uses of it in the compiler). ++ ++ * cp-call.c (build_scoped_method_call): Fix for destructors of simple ++ types. ++ (build_method_call): Likewise. ++ ++Fri Nov 19 12:59:38 1993 Jason Merrill ++ ++ * cp-tree.c (count_functions): Abstraction function. ++ ++ * cp-call.c (build_overload_call_real): Deal with new overloading ++ properly, remove dead code. ++ ++ * gcc.c (default_compilers): Generate and use .ii files in the ++ intermediate stage of compiling C++ source. ++ ++Fri Nov 19 11:26:09 1993 Jim Wilson ++ ++ * cp-expr.c (cplus_expand_expr): Make call_target a valid memory ++ address before using it, so it can be later safely compared. ++ ++Fri Nov 12 15:30:27 1993 Jason Merrill ++ ++ * cp-pt.c (tsubst): Deal with new overloading. ++ ++ * cp-typeck.c (fntype_p): Is the arg function type? ++ (comp_target_parms): pedwarn on conversion from (anything) to (...). ++ (build_x_function_call): Deal with new overloading. ++ ++ * cp-tree.c (decl_list_length): Deal with new overloading. ++ (decl_value_member): Like value_member, but for DECL_CHAINs. ++ ++ * cp-decl.c (duplicate_decls): Deal with new overloading. ++ (start_decl): Likewise. ++ ++ * cp-class.c (instantiate_type): Deal with new overloading. ++ ++ * cp-call.c (convert_harshness_ansi): Deal with new overloading. ++ (convert_harshness_old): Deal with new overloading. ++ (build_overload_call_real): Likewise. ++ ++Mon Nov 8 13:50:49 1993 Jason Merrill ++ ++ * cp-tree.c (get_unique_fn): New function; returns FUNCTION_DECL ++ if unambiguous, NULL_TREE otherwise. ++ (get_first_fn): Returns the first appropriate FUNCTION_DECL. ++ (is_overloaded_fn): Returns whether or not the passed tree is ++ a function or list of functions. ++ ++ * cp-init.c (init_init_processing): Use `get_first_fn' to find ++ the FUNCTION_DEFN for new and delete. ++ ++ * cp-decl.c (push_overloaded_decl): Use new overloading strategy, cut ++ code size in half (I spit on special cases). ++ ++Tue Sep 7 20:03:33 1993 Jason Merrill ++ ++ * cp-decl.c: Allow references and template type parameters as well +diff -NBaur gcc-3.4.4/gcc/cp/ChangeLog.2 gcc-3.4.4-new/gcc/cp/ChangeLog.2 +--- gcc-3.4.4/gcc/cp/ChangeLog.2 Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/ChangeLog.2 Thu Jan 1 00:42:21 2004 +@@ -0,0 +1,20677 @@ ++1999-12-31 Mark Mitchell ++ ++ * cp-tree.h (VF_NORMAL_VALUE): Remove. ++ * class.c (struct base_info): Remove vfield, vfields, and rtti. ++ (set_primary_base): New function, split out from ... ++ (finish_base_struct): ... here. Rename to ... ++ (determine_primary_base): ... this. Simplify. ++ (create_vtable_ptr): Tweak accordingly. ++ (finish_struct_1): Simplify. ++ ++ * cp-tree.h (CLASSTYPE_VBASECLASSES): Update documentation. ++ (CLASSTYPE_N_BASECLASSES): Likewise. ++ (BINFO_FOR_VBASE): New macro. ++ (get_vbase_types): Change prototype. ++ * class.c (build_vbase_path): Use BINFO_FOR_VBASE. ++ (prepare_fresh_vtable): Likewise. ++ (finish_vtbls): Likewise. ++ (get_class_offset_1): Likewise. ++ (modify_all_indirect_vtables): Likewise. ++ (build_vbase_pointer_fields): Likewise. ++ * decl.c (xref_basetypes): Don't set CLASSTYPE_VBASECLASSES here. ++ * init.c (sort_base_init): Use BINFO_FOR_VBASE. ++ (expand_member_init): Likewise. ++ * search.c (get_base_distance): Likewise. ++ (lookup_field_queue_p): Likewise. ++ (virtual_context): Likewise. ++ (get_vbase_types): Don't return a value. Set ++ CLASSTYPE_VBASECLASSES here. ++ * typeck.c (get_delta_difference): Use BINFO_FOR_VBASE. ++ ++1999-12-30 Mark Mitchell ++ ++ * class.c (fixup_inline_methods): Clear CLASSTYPE_INLINE_FRIENDS. ++ ++1999-12-29 Mark Mitchell ++ ++ * class.c (create_vtable_ptr): Put the vtable at the beginning of ++ the class, not the end, in the new ABI. ++ * tree.c (propagate_binfo_offsets): Do the right thing for the new ++ ABI. ++ ++1999-12-29 Mark Mitchell ++ ++ * cp-tree.h (lang_type): Add nearly_empty_p. Adjust dummy. ++ (CLASSTYPE_NEARLY_EMPTY_P): New macro. ++ * class.c (check_bases): Update CLASSTYPE_NEARLY_EMPTY_P. ++ (check_field_decls): Likewise. ++ (check_bases_and_members): Likewise. ++ ++1999-12-28 Mark Mitchell ++ ++ * cp-tree.h (do_inline_function_hair): Remove. ++ * class.c (layout_class_type): New function, split out from ++ finish_struct_1. ++ (fixup_pending_inline): Likewise. ++ (fixup_inline_methods): New function. ++ * method.c (fixup_pending_inline): Remove. ++ (do_inline_function_hair): Likewise. ++ ++ * decl.c (BOOL_TYPE_SIZE): Bools always have size `1' under the ++ new ABI. ++ ++ * cp-tree.h (lang_type): Replace abstract_virtuals with pure_virtuals. ++ (CLASSTYPE_ABSTRACT_VIRTUALS): Rename to ... ++ (CLASSTYPE_PURE_VIRTUALS): ... this. ++ (lang_decl_flags): Replace abstract_virtual with pure_virtual. ++ (DECL_ABSTRACT_VIRTUAL_P): Rename to ... ++ (DECL_PURE_VIRTUAL_P): ... this. ++ (get_abstract_virtuals): Rename to ... ++ (get_pure_virtuals): ... this. ++ * call.c (build_new_method_call): Replace DECL_PURE_VIRTUAL_P with ++ DECL_ABSTRACT_VIRTUAL_P. Replace CLASSTYPE_ABSTRACT_VIRTUALS with ++ CLASSTYPE_PURE_VIRTUALS. ++ * class.c (build_vtable_entry): Likewise. ++ (finish_struct_bits): Likewise. Call get_pure_virtuals, not ++ get_abstract_virtuals. ++ (build_vtbl_initializer): Likewise. ++ (override_one_vtable): Likewise. ++ (check_methods): Likewise. ++ * decl.c (duplicate_decls): Likewise. ++ (redeclaration_error_message): Likewise. ++ (lang_mark_tree): Likewise. ++ * decl2.c (grok_function_init): Likewise. ++ (import_export_vtable): Likewise. ++ (import_expor_class): Likewise. ++ * typeck2.c (abstract_virtuals_error): Likewise. ++ * xref.c (GNU_xref_member): Likewise. ++ * search.c (get_abstract_virtuals): Rename to get_pure_virtuals. ++ ++1999-12-26 Zack Weinberg ++ ++ * cp-tree.h: Replace ENABLE_CHECKING with ENABLE_TREE_CHECKING ++ throughout. ++ ++1999-12-26 Mark Mitchell ++ ++ * decl.c (store_return_init): Use mode of old RTL generated for ++ DECL_RESULT, not the mode of DECL_RESULT itself. ++ * semantics.c (finish_named_return_value): Set DECL_UNINLINABLE ++ for functions that used named return values. ++ ++1999-12-24 Mark Mitchell ++ ++ * semantics.c (expand_body): Use ++ note_deferral_of_defined_inline_function. ++ ++1999-12-22 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Handle CTOR_STMTs. ++ ++1999-12-22 Alexandre Oliva ++ ++ * error.c (dump_decl): Support named return values. ++ ++1999-12-20 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_VFIELD_PARENT): Update comments. ++ (CLASSTYPE_HAS_PRIMARY_BASE_P): New macro. ++ (CLASSTYPE_PRIMARY_BINFO): Likewise. ++ * class.c (check_methods): Don't set TYPE_HAS_COMPLEX_INIT_REF, ++ TYPE_NEEDS_CONSTRUCTING, and CLASSTYPE_NON_AGGREGATE here. ++ (check_bases_and_members): Set them here instead. ++ (create_vtable_ptr): New function, split out from ... ++ (finish_struct_1): ... here. Use it. Tidy. Use ++ CLASSTYPE_HAS_PRIMARY_BASE_P and CLASSTYPE_PRIMARY_BINFO. ++ * search.c (dfs_init_vbase_pointers): Handle seeing TYPE_VFIELD as ++ the first field in the class. ++ * tree.c (layout_basetypes): Use CLASSTYPE_N_BASECLASSES. Handle ++ seeing TYPE_VFIELD as the first field in the class. ++ ++ * cp-tree.h (TYPE_VIRTUAL_P): Rename to ... ++ (TYPE_POLYMORPHIC_P): ... this. ++ (TYPE_USES_COMPLEX_INHERITANCE): Rename to ... ++ (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P): ... this. ++ (TREE_CALLS_NEW): Remove. ++ (TREE_MANGLED): Likewise. ++ * call.c (build_vfield_ref): Use TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P, ++ and TYPE_POLYMORPHIC_P. ++ * class.c (check_bases): Likewise. ++ (finish_base_struct): Likewise. ++ (finish_struct_bits): Likewise. ++ (check_for_override): Likewise. ++ (finish_struct_1): Likewise. ++ (get_vfield_name): Likewise. ++ * decl.c (xref_basetypes): Likewise. ++ * decl2.c (import_export_class): Likewise. ++ (import_export_decl): Likewise. ++ * error.c (dump_function_decl): Likewise. ++ * pt.c (instantiate_class_template): Likewise. ++ * repo.c (repo_inline_used): Likewise. ++ * rtti.c (build_headof): Likewise. ++ (get_tinfo_fn_dynamic): Likewise. ++ (build_x_typeid): Likewise. ++ (get_tinfo_var): Likewise. ++ (build_dynamic_cast_1): Likewise. ++ (synthesize_tinfo_fn): Likewise. ++ * search.c (lookup_field_1): Likewise. ++ (dfs_debug_mark): Likewise. ++ (maybe_suppress_debug_info): Likewise. ++ * typeck.c (build_component_ref): Likewise. ++ (build_component_addr): Likewise. ++ * typeck2.c (process_init_constructor): Likewise. ++ ++1999-12-20 Nathan Sidwell ++ ++ * typeck.c (strip_all_pointer_quals): New static function. ++ (build_static_cast): Use it. Don't use at_least_as_qualified_p. ++ ++1999-12-16 Mark Mitchell ++ ++ * cp-tree.h (cp_tree_index): Add CPTI_DSO_HANDLE. ++ (dso_handle_node): New macro. ++ (flag_use_cxa_atexit): New variable. ++ (declare_global_var): New function. ++ (start_anon_func): Remove declaration. ++ (end_anon_func): Likewise. ++ * decl.c (get_atexit_node): New function, split out from ++ destroy_local_static. Handle flag_use_cxa_atexit. ++ (get_dso_handle_node): Likewise. ++ (start_cleanup_fn): Renamed from start_anon_func. Moved here from ++ except.c. Handle flag_use_cxa_atexit. ++ (end_cleanup_fn): Renamed from end_anon_func. Moved here from ++ except.c. ++ (declare_global_var): New variable. ++ (destroy_local_static): Handle flag_use_cxa_atexit. ++ * decl2.c (flag_use_cxa_atexit): New variable. ++ (lang_f_options): Likewise. ++ * except.c (start_anon_func): Remove. ++ (end_anon_func): Liekwise. ++ * lang-options.h: Add -fuse-cxa-atexit and -fno-use-cxa-atexit. ++ * rtti.c (get_tinfo_var): Use declare_global_var. ++ ++1999-12-16 Mark Mitchell ++ ++ * class.c (check_field_decls): Don't return a value. ++ (avoid_overlap): Moved here from tree.c. ++ (build_base_fields): Likewise. ++ (check_bases): New function, split out from finish_base_struct. ++ (check_bases_and_members): New function, split out from ++ finish_struct_1. ++ (struct base_info): Remove cant_have_default_ctor, ++ cant_have_const_ctor, cant_have_asn_ref. ++ (finish_base_struct): Split semantic analysis into check_bases. ++ (finish_struct_methods): Fix bogus assertion. ++ (check_field_decls): Call finish_struct_anon here. ++ (build_vbase_pointer_fields): Use CLASSTYPE_N_BASECLASSES. ++ (finish_struct_1): Use check_bases_and_members. Reorganize. ++ * cp-tree.h (CLASSTYPE_VBASECLASSES): Improve documentation. ++ (build_base_fields): Don't declare. ++ * tree.c (avoid_overlap): Remove. ++ (build_base_fields): Likewise. ++ ++ * optimize.c (struct inline_data): Remove scope_stmt. ++ (remap_block): Don't use insert_block_after_note. Don't update ++ scope_stmt. ++ (expand_call_inline): Don't update scope_stmt. ++ (optimize_function): Don't initialize scope_stmt. ++ * semantics.c (expand_stmt): Set NOTE_BLOCK for newly emitted ++ NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END notes. ++ ++1999-12-15 Mark Mitchell ++ ++ * class.c (handle_using_decl): Get TYPE_FIELDS and TYPE_METHODS ++ out of the class, rather than taking them as parameters. ++ (build_vbase_pointer_fields): Move here from tree.c. ++ (build_vtbl_or_vbase_field): New function. ++ (check_methods): Likewise. ++ (remove_zero_width_bitfields): Likewise. ++ (add_virtual_function): Use tree_cons instead of temp_tree_cons. ++ (delete_duplicate_fields_1): Tidy. Don't delete duplicate ++ USING_DECLs here. ++ (finish_struct_methods): Handle the case where there are no ++ methods here. ++ (get_basefndecls): Use tree_cons instead of temp_tree_cons. ++ (check_field_decls): Call delete_duplicate_fields here. ++ (finish_struct_1): Tidy. Use check_methods and ++ remove_zero_width_bitfields. ++ * cp-tree.h (build_vbase_pointer_fields): Remove. ++ * decl.c (grokdeclarator): Use tree_cons instead of ++ temp_tree_cons. ++ * decl2.c (qualified_lookup_using_namespace): Use tree_cons ++ instead of temp_tree_cons. ++ * lex.c (cons_up_default_function): Remove dead code. ++ * method.c (fixup_pending_inline): New function, split out from ... ++ (do_inline_function_hair): ... here. ++ * tree.c (build_vbase_pointer_fields): Remove. ++ ++1999-12-15 Jason Merrill ++ ++ * tree.c (walk_tree): Walk operand subtrees in forward order. ++ * optimize.c (expand_call_inline): Likewise. ++ (optimize_function): Initialize id->scope_stmt to something useful. ++ (remap_block): Assume id->scope_stmt has a useful value. ++ ++1999-12-15 Nathan Sidwell ++ ++ * typeck.c (build_c_cast): Expand warning message. Move pointer ++ alignment warning to after the cast. Don't warn about pointer ++ alignment when given a pointer to incomplete. ++ ++1999-12-15 Richard Henderson ++ ++ * cp-tree.h (make_aggr_type): Declare. ++ * lex.c (cp_make_lang_type): Don't SET_IS_AGGR_TYPE. ++ (make_aggr_type): New. ++ ++ * decl.c (build_typename_type, init_decl_processing): Use it. ++ (build_ptrmemfunc_type, xref_tag): Likewise. ++ * except.c (call_eh_info): Likewise. ++ * init.c (init_init_processing): Likewise. ++ * pt.c (process_template_parm, lookup_template_class): Likewise. ++ * rtti.c (expand_class_desc): Likewise. ++ * semantics.c (begin_class_definition, finish_typeof): Likewise. ++ * tree.c (copy_template_template_parm): Likewise. ++ ++1999-12-15 Jason Merrill ++ ++ * cp-tree.def (TEMPLATE_PARM_INDEX): Calculate size using ++ sizeof (struct tree_common). ++ ++1999-12-14 Jason Merrill ++ ++ * optimize.c (expand_call_inline): Set BLOCK_ABSTRACT_ORIGIN on the ++ outermost block to point to the inlined function decl. ++ ++ * error.c (dump_decl): operator==, not operator ==. ++ (op_to_string): Likewise. ++ ++ * decl.c (compute_array_index_type): Handle null name. ++ ++ * decl2.c (ambiguous_decl): Fix to match comment. ++ (lookup_using_namespace): Adjust. ++ ++ * decl2.c (import_export_class): Don't ignore dllimport. ++ ++1999-12-14 Mark Mitchell ++ ++ * class.c (check_field_decls): Split out from ... ++ (finish_struct_1): ... here. Use it. Tidy. ++ ++ * cp-tree.h (remap_save_expr): Add walk_subtrees parameter. ++ * optimize.c (copy_body_r): Pass it. ++ * tree.c (remap_save_expr): Clear walk_subtrees for an ++ already-handled SAVE_EXPR. ++ (cp_unsave_r): Pass walk_subtrees to remap_save_expr. ++ ++ * dump.c (dequeue_and_dump): Dump DECL_NAMESPACE_ALIAS. ++ * ir.texi (DECL_NAMESPACE_ALIAS): Document it. ++ ++ * error.c (dump_expr): Handle EXPR_WITH_FILE_LOCATION. ++ ++1999-12-14 Mumit Khan ++ ++ * class.c (finish_base_struct): Allow multiple COM base classes ++ as well as non-COM bases as long as it's not the leftmost. ++ ++1999-12-13 Mumit Khan ++ ++ * lex.c (saving_parse_to_obstack): New global. ++ (reinit_parse_for_block): Use. ++ (reinit_parse_for_expr): Use. ++ (check_newline): Use. ++ ++1999-12-13 Mark Mitchell ++ ++ * optimize.c (initialize_inlined_parameters): Take FN to which the ++ parameters belong as an argument. ++ (expand_call_inline): Expand calls into the parameter ++ initializations before pushing the function onto the list of ++ functions we are presently expanding. ++ ++1999-12-11 Kaveh R. Ghazi ++ ++ * class.c (get_vtable_name): Use a literal format string and ++ VTABLE_NAME_PREFIX macro instead of VTABLE_NAME_FORMAT. ++ (prepare_fresh_vtable): Likewise. ++ ++ * cp-tree.h (VTABLE_NAME_PREFIX): Define this instead of ++ VTABLE_NAME_FORMAT. ++ ++ * decl.c (make_rtl_for_local_static): Remove unused variable `type'. ++ ++ * init.c (build_vec_init): Initialize variable `try_body'. ++ ++ * lex.c (yyerror): Don't call a variadic function with a ++ non-literal format string. ++ ++ * optimize.c (optimize_function): Call memset, not bzero. ++ ++ * pt.c (for_each_template_parm_r): Add static prototype. ++ ++1999-12-09 Andreas Jaeger ++ ++ * except.c (expand_throw): Add static attribute to match ++ prototype. ++ ++ * Makefile.in (semantics.o): Add dependency on output.h. ++ * semantics.c: Include output.h for declaration of ++ make_function_rtl. ++ ++1999-12-09 Mark Mitchell ++ ++ * decl.c (init_decl_processing): Reenable inlining on trees. ++ (finish_function): Likewise. ++ * expr.c (cplus_expand_expr): Don't handle AGGR_INIT_EXPR here. ++ * semantics.c (simplify_aggr_init_exprs): New function. ++ (expand_body): Use it. ++ * tree.c (walk_tree): Special-case TARGET_EXPRs since they ++ sometimes present the same sub-tree twice. ++ ++ * dump.c (dequeue_and_dump): Abbreviate `class' as `cls', not ++ `csl'. ++ ++ * semantics.c (finish_switch_cond): Do conversions here, not ... ++ * typeck.c (c_expand_start_case): Here. ++ ++ * semantics.c (do_poplevel): Remove unused variable. ++ ++1999-12-06 Mark Mitchell ++ ++ * tree.c (walk_tree): Don't recurse into DECL_INITIAL or DECL_SIZE ++ unless we're declaring the variable in question. ++ ++1999-12-06 Mark Mitchell ++ ++ * decl.c (init_decl_processing): #if 0 last patch. ++ (finish_function): Likewise. ++ ++1999-12-05 Mark Mitchell ++ ++ * decl.c (init_decl_processing): Set flag_inline_trees if ++ !flag_no_inline. ++ ++ * cp-tree.h (calls_setjmp_p): Declare. ++ * decl.c (finish_function): Mark functions that call setjmp as ++ uninlinable. ++ * optimize.c (calls_setjmp_r): New function. ++ (calls_setjmp_p): Likewise. ++ ++1999-12-04 Mark Mitchell ++ ++ * optimize.c (expand_call_inline): Wrap the expanded call in an ++ EXPR_WITH_FILE_LOCATION node to get correct line numbers for ++ inlined functions. ++ ++ * optimize.c (inline_data): Remove fns_top. Add scope_stmt. Add ++ in_target_cleanup_p. ++ (remap_decl): New function. ++ (remap_block): Likewise. ++ (copy_scope_stmt): Likewise. ++ (copy_body_r): Use remap_decl and copy_scope_stmt. ++ (copy_body): Use VARRAY_TOP_TREE. ++ (initialize_inlined_parameters): Likewise. ++ (declare_return_variable): Likewise. ++ (inlinable_function_p): Check flag_inline_trees. ++ (expand_call_inline): Handle SCOPE_STMTs and TARGET_EXPRs ++ specially. Use VARRAY_PUSH_TREE. Create a BLOCK for the ++ parameters of the inlined function. ++ (optimize_function): Prevent recursion into partially complete ++ functions. ++ ++ * cp-tree.def (SCOPE_STMT): Take one operand. ++ * cp-tree.h (SCOPE_STMT_BLOCK): New macro. ++ (SCOPE_NULLIFIED_P): Redefine. ++ (SCOPE_NO_CLEANUPS_P): New macro. ++ (add_scope_stmt): Change prototype. ++ * decl.c (poplevel): Tidy. Warn about unused variables here. ++ Record SCOPE_STMT_BLOCKs. ++ (finish_function): Keep DECL_INITIAL for functions that might be ++ inlined. ++ * ir.texi: Document SCOPE_NO_CLEANUPS_P. ++ * semantics.c: Include rtl.h. ++ (add_scope_stmt): Return the new scope statement and, for an ++ end-of-scope statement, its matching begin statement. Don't set ++ SCOPE_NULLIFIED_P. ++ (do_pushlevel): Simplify, now that we are always ++ function-at-a-time. ++ (do_poplevel): Likewise. Record SCOPE_STMT_BLOCKs. ++ (expand_stmt): Don't call expand_start_bindings or ++ expand_end_bindings for a scope with SCOPE_NO_CLEANUPS_P set. ++ * tree.c (copy_tree_r): Clear SCOPE_STMT_BLOCK rather than setting ++ SCOPE_NULLIFIED_P. ++ * Makefile.in (semantics.o): Depend on RTL_H. ++ ++ * decl2.c (pending_statics_used): Make it a macro. ++ (saved_inlines_used): Likewise. ++ (finish_static_data_member_decl): Use VARRAY_PUSH_TREE. ++ (mark_inline_for_output): Likewise. ++ (ssdf_decls_used): Remove. ++ (start_static_storage_duration_function): Use VARRAY_PUSH_TREE. ++ (generate_ctor_or_dtor_function): Adjust accordingly. ++ ++1999-11-24 Geoffrey Keating ++ Greg McGary ++ ++ * decl.c (duplicate_decls): Merge ++ DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT, ++ DECL_NO_CHECK_MEMORY_USAGE, DECL_NO_LIMIT_STACK. ++ ++1999-12-02 Mike Stump ++ ++ * init.c (perform_member_init): Handle parse errors better. ++ ++1999-12-01 Mark Mitchell ++ ++ * cp-tree.h (min_tree_cons): Remove. ++ (scratch_ovl_cons): Likewise. ++ * decl.c (saveable_obstack): Don't declare. ++ (duplicate_decls): Tweak error-message. ++ (initialize_local_var): Explicitly mark the definition as static. ++ (finish_function): Call permanent_allocation, just so ++ that the middle-end sees the obstacks it expects. ++ (mark_cp_function_context): Likewise. ++ * init.c (build_new): Don't use min_tree_cons. ++ * lex.c (permanent_obstack): Don't declare. ++ (current_obstack, saveable_obstack): Likewise. ++ * spew.c (current_obstack, saveable_obstack): Likewise. ++ * tree.c (current_obstack, saveable_obstack): Likewise. ++ (scratch_ovl_cons): Remove. ++ (build_min_nt): Don't mess with obstacks. ++ (build_min): Likewise. ++ (min_tree_cons): Remove ++ * typeck.c (build_component_ref): Don't use scratch_ovl_cons. ++ (build_x_function_call): Likewise. ++ (build_c_cast): Don't use min_tree_cons. ++ ++1999-11-29 Mark Mitchell ++ ++ * pt.c (tsubst_decl): Robustify. ++ ++1999-11-27 Mark Mitchell ++ ++ * decl2.c (finish_file): Call expand_body for inline functions ++ that will be written out but that do not yet have RTL. ++ * semantics.c (expand_body): Do not generate RTL For inline ++ functions that do not yet need to be written out. ++ ++1999-11-25 Mark Mitchell ++ ++ * Make-lang.in (CXX_SRCS): Add optimize.c. ++ * Makefile.in (CXX_OBJS): Add optimize.o. ++ (CXX_TREE_H): Add splay-tree.h, system.h, and $(CONFIG_H). ++ (spew.o, lex.o, decl.o, decl2.o, typeck2.o, typeck.o): Adjust. ++ (class.o, call.o, friend.o, init.o, method.o, cvt.o): Likewise. ++ (search.o, tree.o, ptree.o, rtti.o, except.o, expr.o): Likewise. ++ (xref.o, pt.o, error.o, errfn.o, repo.o, semantics.o): Likewise. ++ (dump.o): Likewise. ++ (optimize.o): New target. ++ * class.c: Don't include splay-tree.h. ++ * cp-tree.def (CTOR_COMPLETE): Rename to CTOR_STMT. ++ * cp-tree.h: Include splay-tree.h. ++ (DECL_UNINLINABLE): New macro. ++ (CTOR_BEGIN_P, CTOR_END_P): New macros. ++ (flag_inline_trees): New variable. ++ (local_variable_p): New function. ++ (nonstatic_local_decl_p): Likewise. ++ (optimize_function): Likewise. ++ (cplus_unsave_expr_now): Remove. ++ (copy_tree_r): Declare. ++ (remap_save_expr): Likewise. ++ * decl.c (local_variable_p): Don't ++ make it static. ++ (local_variable_p_walkfn): New function. ++ (make_rtl_for_local_static): Remove code to try to avoid writing ++ out static constants. ++ (emit_local_var): Fix indentation. ++ (nonstatic_local_decl_p): New function. ++ (check_default_argument): Use local_variable_p_walkfn, not ++ local_variable_p, when walking the tree. ++ (start_function): Set the DECL_CONTEXT for automatically generated ++ labels. ++ (finish_constructor_body): Use CTOR_STMT to mark the end of a ++ constructor. ++ * decl2.c: Don't include splay-tree.h. ++ (flag_inline_trees): Define. ++ * dump.c: Don't include ++ splay-tree.h. ++ * except.c (expand_end_catch_block): Fix comment formatting. ++ (expand_end_eh_spec): Set DECL_CONTEXT on temporary variables. ++ (expand_throw): Tidy comment. ++ * init.c (build_vec_delete_1): Use create_temporary_var. ++ * lex.c (cplus_tree_code_type): Make it static. ++ (cplus_tree_code_length): Likewise. ++ (cplus_tree_code_name): Likewise. ++ * optimize.c: New file. ++ * semantics.c (finish_goto_stmt): Set DECL_UNLINABLE for functions ++ with computed gotos. ++ (setup_vtbl_ptr): Mark the beginnings of constructors with ++ CTOR_STMT. ++ (expand_stmt): Handle CTOR_STMT, not CTOR_COMPLETE. ++ (expand_body): Call optimize_function. Save bodies if we're doing ++ inlining on trees. ++ * tree.c: Don't include splay-tree.h. Include insn-config.h and ++ integrate.h. ++ (copy_tree_r): Make it public. ++ (statement_code_p): New function. ++ (mark_local_for_remap_r): Likewise. ++ (cp_usave_r): Likewise. ++ (cp_unsave): Likewise. ++ (build_cplus_new): Set DECL_CONTEXT for temporary variables. ++ (walk_tree): Walk into `s' class nodes. Walk statement chains. ++ (copy_tree_r): Handle 's' class nodes. Restore chains for ++ statements. Nullify scopes. Don't copy types. ++ (init_tree): Set lang_unsave to cp_unsave. ++ (remap_save_expr): Define. ++ * ir.texi: Document CTOR_STMT. ++ ++1999-11-24 Jason Merrill ++ ++ * search.c (note_debug_info_needed): Do perform this optimization ++ for dwarf2. ++ (maybe_suppress_debug_info): Likewise. Start by clearing ++ TYPE_DECL_SUPPRESS_DEBUG. ++ ++1999-11-24 Mark Mitchell ++ ++ * pt.c (tsubst_decl): Copy TREE_ASM_WRITTEN for VAR_DECLs. ++ ++ * decl2.c (finish_vtable_vardecl): Don't prune vtables here. ++ ++1999-11-23 Kaveh R. Ghazi ++ ++ * decl.c (pushdecl, grokdeclarator): Don't call a variadic ++ function with a non-literal format string. ++ ++ * lex.c (do_identifier): Likewise. ++ ++ * typeck.c (build_unary_op): Likewise. ++ ++1999-11-23 Mark Mitchell ++ ++ * cp-tree.h (DECL_NEEDED_P): Tweak to match documentation. ++ ++1999-11-22 Mark Mitchell ++ ++ * cp-tree.def (CTOR_COMPLETE): New tree node. ++ * decl.c (finish_constructor_body): Add it, to mark the end of the ++ constructor. ++ (finish_function): Don't call end_protect_partials here. ++ * ir.texi (CTOR_COMPLETE): Document it. ++ * semantics.c (expand_stmt): Handle it. ++ ++ * cp-tree.def (FUNCTION_NAME): New tree node. ++ * cp-tree.h (current_function_name_declared): Tweak documentation. ++ (lang_decl_flags): Add pretty_function_p, adjust dummy. ++ (DECL_PRETTY_FUNCTION_P): New macro. ++ * decl.c (cp_finish_decl): Handle declarations of __FUNCTION__, ++ etc., in a template function. Use at_function_scope_p instead of ++ expanding it inline. ++ * pt.c (tsubst_decl): Handle DECL_PRETTY_FUNCTION_P declarations ++ specially. ++ (tsubst): Handle FUNCTION_NAME. ++ (tsubst_copy): Likewise. ++ (instantiate_decl): Prevent redeclarations of __PRETTY_FUNCTION__, ++ etc. in instantiation. ++ * semantics.c (begin_compound_stmt): Declare __FUNCTION__, etc., ++ even in template functions. ++ (setup_vtbl_ptr): Don't declare __PRETTY_FUNCTION in the ++ conditional scope at the top of a destructor. ++ ++ * error.c (dump_function_decl): Use `[ with ... ]' syntax for ++ specializations too. ++ ++1999-11-22 Nathan Sidwell ++ ++ * semantics.c (finish_unary_op_expr): Only set TREE_NEGATED_INT ++ when actually negative. ++ ++ * typeck.c (convert_for_assignment): Expand comment about ++ strange NULL check, moved from ... ++ (convert_for_initialization): ... here. Remove unneeded ++ code. ++ ++1999-11-21 Alexandre Oliva ++ ++ * cp-tree.h (build_vec_delete): Remove `auto_delete' argument. ++ * init.c (build_vec_delete, build_vec_delete_1): Likewise. ++ Always destruct virtual bases of array components, but never ++ delete them. ++ (build_vec_init): Adjust invocations. ++ (build_delete): Likewise. ++ * decl2.c (delete_sanity): Likewise. ++ ++1999-11-19 Nathan Sidwell ++ ++ * cp-tree.h (grok_method_quals): Return this pointer qualifiers. ++ * decl.c (grokdeclarator): Adjust calls to grok_method_quals. ++ * decl2.c (grok_method_quals): Accept `restrict' as applying to ++ the object pointer. Return such qualifiers. ++ (grokclassfn): Apply this pointer qualifiers. Cleanup unused ++ variables. ++ ++1999-11-18 Mark Mitchell ++ ++ * except.c (expand_end_catch_block): Fix typo. ++ (expand_exception_blocks): Simplify. Don't call ++ expand_leftover_cleanups. ++ ++1999-11-15 Jason Merrill ++ ++ * cp-tree.h, decl.c (compute_array_index_type): Make nonstatic. ++ * pt.c (tsubst, case INTEGER_TYPE): Call it. ++ Check uses_template_parms. ++ ++ * class.c (finish_struct): If we're a local class in a template ++ function, add a TAG_DEFN. ++ * pt.c (lookup_template_class): If this is a local class in a ++ template function, call pushtag. ++ (tsubst_expr, case TAG_DEFN): Handle classes, too. ++ ++ Emit debug info with the vtable. ++ * search.c (maybe_suppress_debug_info): New function... ++ * class.c (finish_struct_1): ...split out from here. ++ * cp-tree.h: Declare it. ++ * decl2.c (finish_vtable_vardecl): Override TYPE_DECL_SUPPRESS_DEBUG ++ if we're writing out the vtable. ++ * decl.c, search.c (dfs_debug_mark, dfs_debug_unmarked_p, ++ note_debug_info_needed): #if 0 out. ++ ++1999-11-14 Mark Mitchell ++ ++ * cp-tree.h (DECL_LOCAL_FUCNTION_P): New macro. ++ * call.c (equal_functions): Use DECL_LOCAL_FUCNTION_P, not ++ TREE_PERMANENT. ++ * decl.c (pushdecl): Set DECL_LOCAL_FUNCTION_P. ++ * decl2.c (lookup_arg_dependent): Use it. ++ ++ * cp-tree.h (cp_finish_decl): Change prototype. ++ (finish_static_data_member_decl): Likewise. ++ (push_permanent_obstack): Remove declaration. ++ (push_expression_obstack): Likewise. ++ (push_scratch_obstack): Likewise. ++ (DECL_TEMPLATE_PARM_P): Robustify. ++ (SET_DECL_TEMPLATE_PARM_P): New macro. ++ * class.c (add_method): Don't manipulate obstacks. ++ (finish_vtbls): Likewise. ++ * cvt.c (build_up_reference): Adjust calls to cp_finish_decl. ++ * decl.c (binding_for_name): Don't manipulate obstacks. ++ (maybe_push_to_top_level): Likewise. ++ (pop_from_top_level): Likewise. ++ (duplicate_decls): Likewise. ++ (pushdecl): Likewise. ++ (implicitly_declare): Likewise. ++ (build_typename_type): Likewise. ++ (start_decl): Likewise. ++ (cp_finish_decl): Likewise. ++ (finish_decl): Likewise. ++ (destroy_local_static): Likewise. ++ (expand_static_init): Likewise. ++ (complete_array_type): Likewise. ++ (grokvardecl): Likewise. ++ (build_ptrmemfnc_type): Likewise. ++ (grokdeclarator): Likewise. ++ (xref_tag): Likewise. ++ (xref_basetypes): Likewise. ++ (start_enum): Likewise. ++ (finish_enum): Likewise. ++ (start_function): Likewise. ++ (finish_function): Likewise. ++ (start_method): Adjust call to cp_finish_decl. ++ * decl2.c (finish_static_data_member_decl): Don't manipulate ++ obstacks. ++ (grokfield): Likewise. ++ (grokbitfield): Likewise. ++ (get_temp_name): Likewise. ++ (get_sentry): Likewise. ++ (fnish_file): Likewise. ++ (lookup_arg_dependent): Likewise. ++ * except.c (call_eh_info): Likewise. ++ (push_eh_info): Likewise. ++ (do_pop_exception): Likewise. ++ (initialize_handler_parm): Likewise. ++ (expand_end_eh_spec): Likewise. ++ (alloc_eh_object): Likewise. ++ (expand_throw): Likewise. ++ * expr.c (extract_scalar_init): Likewise. ++ * init.c (build_java_class_ref): Likewise. ++ * lex.c (get_time_identifier): Likewise. ++ (snarf_defarg): Likewise. ++ (add_defarg_fn): Likewise. ++ (is_global): Simplify. ++ (do_identifier): Don't check TREE_PERMANENT. ++ * method.c (emit_thunk): Don't manipulate obstacks. ++ * parse.y (condition): Adjust call to cp_finish_decl. ++ (primary): Likewise. ++ (initdcl): Likewise. ++ (initdcl0_innards): Likewise. ++ (nomods_initdcl0): Likewise. ++ * pt.c (push_inline_template_parms_recursive): Use ++ SET_DECL_TEMPLATE_PARM_P. ++ (process_template_parm): Likewise. ++ (lookup_template_class): Don't manipulate obstacks. ++ (instantiate_class_template): Adjust call to ++ finish_static_data_member_decl. ++ (tsubst_decl): Don't manipulate obstacks. ++ (tsubst_expr): Likewise. ++ (instantiate_template): Likewise. ++ (instantiate_decl): Adjust calls to cp_finish_decl. ++ * rtti.c (call_void_fn): Don't manipulate obstacks. ++ (get_tinfo_var): Likewise. ++ (get_tinfo_fn_unused): Likewise. ++ (build_dynamic_cast_1): Likewise. ++ (expand_si_desc): Likewise. ++ (expand_class_desc): Likewise. ++ (expand_ptr_desc): Likewise. ++ (expand_attr_desc): Likewise. ++ (expand_generic_desc): Likewise. ++ (synthesize_tinfo_fn): Likewise. ++ * search.c (expand_upcast_fixups): Likewise. ++ * semantics.c (finish_asm_stmt): Likewise. ++ (finish_named_return_value): Likewise. ++ (begin_class_definition): Likewise. ++ (finish_class_definition): Likewise. ++ (finish_typeof): Likewise. ++ * tree.c (build_cplus_method_type): Likewise. ++ (reverse_path): Likewise. ++ (copy_template_template_parm): Likewise. ++ (build_expr_ptr_wrapper): Likewise. ++ (push_expression_obstack): Remove. ++ (push_permanent_obstack): Likewise. ++ * typeck.c (mark_addressable): Likewise. ++ ++1999-11-13 Mark Mitchell ++ ++ * call.c (build_conditional_expr): Use build_target_expr_with_type. ++ (convert_like): Likewise. ++ (build_over_call): Likewise. ++ * cp-tree.h (build_target_expr): Remove. ++ (build_target_expr_with_type): New function. ++ * cvt.c (build_up_reference): Use get_target_expr. ++ * decl.c (build_target_expr): Move to ... ++ * tree.c (build_target_expr): Here. Make it static. ++ (build_target_expr_with_type): New function. Set DECL_CONTEXT on ++ the temporary VAR_DECLs. ++ (get_target_expr): Use it. ++ ++1999-11-13 Jason Merrill ++ ++ * decl.c (duplicate_decls): Propagate DECL_DEFER_OUTPUT. ++ * decl2.c (comdat_linkage): Set DECL_DEFER_OUTPUT. ++ * rtti.c (get_tinfo_fn_unused): Split out from get_tinfo_fn. ++ * class.c (set_rtti_entry): Use it. ++ ++1999-11-12 Mark Mitchell ++ ++ * decl.c (cplus_expand_expr_stmt): Don't call break_out_cleanups ++ here. ++ * semantics.c (finish_expr_stmt): Call it here instead. Move ++ default_conversion logic to semantic-analysis time. ++ ++1999-11-12 Jason Merrill ++ ++ * rtti.c (synthesize_tinfo_fn): Set DECL_DEFER_OUTPUT. ++ ++Fri Nov 12 12:56:32 MST 1999 Diego Novillo ++ ++ * init.c (init_init_processing): Re-instated Nov 11 patch after ++ approval. ++ ++Fri Nov 12 10:42:02 MST 1999 Diego Novillo ++ ++ * init.c (init_init_processing): Undo patch from Nov 11, 1999. ++ Patch had not been approved yet. ++ ++1999-11-12 Mark Mitchell ++ ++ * decl.c (compute_array_index_type): New function, split out from ++ grokdeclarator. ++ (create_array_type_for_decl): Likewise. ++ (grokdeclarator): Use them. ++ ++ * semantics.c (expand_stmt): Don't suspend_momentary or ++ resume_momentary. ++ ++Thu Nov 11 12:42:11 MST 1999 Diego Novillo ++ ++ * init.c (init_init_processing): Header information for ++ arrays allocated via `new' should have the same alignment used by ++ malloc. ++ ++1999-11-10 Mark Mitchell ++ ++ * error.c (dump_function_name): Don't crash if given a friend ++ pseudo-instantiation. ++ ++ * cp-tree.h (build_enumerator): Change prototype. ++ * decl.c (enum_next_value): Remove. ++ (enum_overflow): Likewise. ++ (init_decl_processing): Don't register enum_next_value as a root. ++ (start_enum): Clear TYPE_VALUES for a redefined enum. ++ (finish_enum): Reset the type of enumeration constants. ++ (build_enumerator): Fix indentation. Don't copy CONST_DECLs when ++ we don't need to. Maintain the TYPE_VALUES list and look there ++ for the previously defined enumeration constant. Let enumeration ++ constants have the type of their values until the enumeration type ++ is complete. ++ * parse.y (enumlist_opt, enumlist, enumerator): Don't return a value. ++ (structsp): Adjust. ++ * parse.c: Regenerated. ++ * pt.c (tsubst_enum): Adjust according to build_enumerator changes. ++ ++Wed Nov 10 12:43:21 1999 Philippe De Muyter ++ Kaveh R. Ghazi ++ ++ * cp-tree.h: Test `GCC_VERSION', not `HAVE_GCC_VERSION'. ++ ++1999-11-09 Mark Mitchell ++ ++ * cp-tree.h (language_function): Remove x_last_dtor_insn and ++ x_last_parm_cleanup_insn. ++ * decl.c (last_dtor_insn): Remove. ++ (last_parm_cleanup_insn): Likewise. ++ (expand_start_early_try_stmts): Don't set them. ++ (store_parm_decls): Likewise. ++ (save_function_data): Or save them. ++ (mark_lang_function): Or mark them. ++ ++1999-11-08 Mark Mitchell ++ ++ * decl.c (store_parm_decls): Generate cleanup code at ++ semantic-analysis time. Destroy objects in the correct order. ++ ++1999-11-07 Mark Mitchell ++ ++ * cp-tree.h (begin_new_placement): Remove. ++ (finish_new_placement): Likewise. ++ * class.c (finish_struct_1): Don't suspend_momentary or ++ resume_momentary. ++ * decl.c (grokdeclarator): Likewise. ++ (maybe_build_cleanup_1): Likewise. ++ * except.c (push_eh_cleanup): Likewise. ++ (build_terminate_handler): Likewise. ++ * init.c (build_new_1): Likewise. ++ * parse.y (parse_decl): Change prototype. ++ (initdecls, notype_initdecls, initdcl): Don't return int. ++ (initdcl0, notype_initdcl0, initdcl0_innards): Likewise. ++ (.begin_new_placement): Remove. ++ (.finish_new_placement): Likewise. ++ (nonmomentary_expr): Likewise. ++ (suspend_mom): Likewise. ++ (condition): Don't suspend_momentary, resume_momentary, or keep ++ track of need to resume. ++ (unary_expr): Likewise. ++ (new_placement): Likewise. ++ (decl): Likewise. ++ (structsp): Likewise. ++ (new_type_id): Likewise. ++ (maybe_parmlist): Likewise. ++ (direct_after_type_declaration): Likewise. ++ (direct_new_declarator): Likewise. ++ (direct_abstract_declaration): Likewise. ++ * parse.c: Regenerated. ++ * pt.c (tsubst_expr): Don't suspend_momentary or resume_momentary. ++ * semantics.c (begin_new_placement): Remove. ++ (finish_new_placement): Likewise. ++ ++1999-11-05 Martin v. Löwis ++ ++ * cp-tree.h (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK): New macro. ++ (DECL_TEMPLATE_INFO): Use it. ++ * decl.c (warn_extern_redeclared_static): Do nothing for ++ TEMPLATE_DECLs. ++ * decl2.c (mark_used): Explicitly check for function or variable. ++ * semantics.c (finish_unary_op_expr): Check whether result is also ++ an INTEGER_CST. ++ ++1999-11-05 Mark Mitchell ++ ++ * Makefile.in (typeck2.o): Depend on output.h. ++ * typeck2.c: Include output.h. ++ ++ * decl.c (flag_ansi): Remove declaration. ++ ++ * pt.c (tinst_level_tick): Make it static. ++ (last_template_error_tick): Likewise. ++ ++ * cp-tree.h (mapcar): Remove declaration. ++ (search_tree): Likewise. ++ (walk_tree_fn): New typedef. ++ (walk_tree): New function. ++ * tree.c (bot_manip): Change prototype. Adjust to be called via ++ walk_tree. ++ (bot_replace): Likewise. ++ (no_linkage_helper): Likewise. ++ (copy_tree_r): New function. ++ (search_tree): Rename, and adjust, to become ... ++ (walk_tree): New function. ++ (mapcar): Remove. ++ (target_remap): Remove. ++ (target_remap_count): Likewise. ++ (break_out_target_exprs): Use walk_tree. ++ * decl.c (local_variable_p): Change prototype. ++ (check_default_argument): Use walk_tree. ++ * pt.c (for_each_template_parm_r): New function, split out from ... ++ (for_each_template_parm): Here. Use it, via walk_tree. ++ ++1999-11-03 Mark Mitchell ++ ++ * class.c (check_bitfield_decl): New function, split out from ++ finish_stuct_1. ++ (check_field_decl): Likewise. Recursively examine members of ++ anonymous structs. ++ (finish_struct_1): Use them. ++ * cp-tree.h (ANON_UNION_TYPE_P): New macro. ++ ++1999-11-02 Mark Mitchell ++ ++ * decl.c (grokfndecl): Remove dead code. ++ ++ * dump.c (dequeue_and_dump): Fix thinko for catch-clauses. ++ ++1999-11-02 Scott Snyder ++ ++ * decl2.c (build_expr_from_tree): Handle REALPART_EXPR and ++ IMAGPART_EXPR. ++ * pt.c (tsubst_copy): Likewise. ++ ++1999-11-01 Jason Merrill ++ ++ * decl2.c (maybe_make_one_only): Always make things comdat on ++ ELF targets, too. ++ ++1999-10-31 Mark Mitchell ++ ++ * decl.c (finish_function): Call free_after_parsing for functions ++ we are not immediately turning into RTL. ++ ++1999-10-31 Brendan Kehoe ++ ++ * cp-tree.h (flag_dump_translation_unit): Add decl. ++ ++Sat Oct 30 22:42:50 1999 Stephen L Moshier ++ ++ * lex.c (yylex): Accept 'f' in mantissa of hex float constant. ++ ++1999-10-30 Mark Mitchell ++ ++ * decl.c (pop_cp_function_context): Don't call free on a NULL ++ pointer. ++ * semantics.c: Include ggc.h. ++ (expand_body): Do garbage-collection after processing a template ++ function. Clear DECL_SAVED_TREE after generating RTL for a ++ function. ++ * Makefile.in (semantics.o): Depend on ggc.h. ++ ++1999-10-29 Mark Mitchell ++ ++ * cp-tree.h (make_typename_type): Change prototype. ++ * decl.c (make_typename_type): Only complain if so requested. ++ * parse.y (nested_name_specifier): Adjust calls. ++ (typename_sub0): Likewise. ++ (typename_sub1): Likewise. ++ * parse.c: Regenerated. ++ * pt.c (convert_template_argument): Pass complain to ++ make_typename_type. ++ (tsubst): Likewise. ++ ++1999-10-28 Mark Mitchell ++ ++ * semantics.c (finish_handler): End the scope of the handler ++ before attaching it to the statement-tree. ++ ++1999-10-28 Ian Lance Taylor ++ ++ * rtti.c (build_dynamic_cast_1): Give a better error message for ++ an attempt to dynamic_cast from a non-polymorphic type. ++ ++1999-10-27 Mark Mitchell ++ ++ * cp-tree.h (make_temp_vec): Remove. ++ (make_scratch_vec): Likewise. ++ * call.c (add_function_candidate): Use make_tree_vec. ++ (add_conv_candidate): Likewise. ++ (build_builtin_candidate): Likewise. ++ (add_template_candidate_real): Likewise. ++ * class.c (resolve_address_of_overloaded_function): Likewise. ++ * decl.c (start_function): Don't fool with the momentary obstack. ++ (finish_function): Likewise. ++ * init.c (expand_direct_vtbls_init): Likewise. ++ (begin_init_stmts): Likewise. ++ (finish_init_stmts): Likewise. ++ * pt.c (add_to_template_args): Use make_tree_vec. ++ (check_explicit_specialization): Likewise. ++ (coerce_template_parms): Likewise. ++ (lookup_template_class): Don't fool with the momentary obstack. ++ (instantiate_class_template): Likewise. ++ (tsubst_template_arg_vector): Use make_tree_vec. ++ (tsubst_aggr_type): Don't fool with the momentary obstack. ++ (tsubst_decl): Likewise. Use make_tree_vec. ++ (try_one_overload): Likewise. ++ (try_class_unification): Don't fool with the momentary obstack. ++ (get_bindings_real): Use make_tree_vec. ++ (set_mangled_name_for_template_decl): Likewise. ++ * rtti.c (synthesize_tinfo_fn): Don't fool with the momentary obstack. ++ * semantics.c (finish_expr_stmt): Likewise. ++ (finish_do_stmt): Likewise. ++ (finish_for_expr): Likewise. ++ (finish_switch_cond): Likewise. ++ (do_pushlevel): Likewise. ++ (do_poplevel): Likewise. ++ * tree.c (make_temp_vec): Remove. ++ ++ * dump.c (dequeue_and_dump): Dump HANDLERs and SAVE_EXPRs. Dump ++ CLEANUP_P for a TRY_BLOCK. ++ * ir.texi: Document SAVE_EXPR. ++ ++Tue Oct 26 23:29:56 1999 Jeffrey A Law (law@cygnus.com) ++ ++ * call.c (build_over_call): Check that the built-in function is ++ of class BUILT_IN_NORMAL before trying to recongize it as BUILT_IN_ABS. ++ * typeck.c (build_function_call_real): Similarly. ++ ++1999-10-26 Mark Mitchell ++ ++ * decl.c (poplevel): Don't set BLOCK_TYPE_TAGS. Don't call ++ remember_end_note. ++ ++1999-10-24 Mark Mitchell ++ ++ * decl.c (push_overloaded_decl_1): Use pushdecl. ++ ++ * decl.c (auto_function): Replace #ifdef'd __inline with just ++ plain inline. ++ * lex.c (my_get_run_time): Likeise. ++ (yyprint): Likewise. ++ (identifier_type): Likewise. ++ * method.c (start_squangling): Likewise. ++ (end_squangling): Likewise. ++ (icat): Likewise. ++ (old_backref_index): Likewise. ++ (flush_repeats): Likewise. ++ (issue_ktype): Likewise. ++ * parse.y (empty_parms): Likewise. ++ * parse.c: Regenerated. ++ ++1999-10-21 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Replace several uses of ++ queue_and_dump_index with dump_child. ++ ++1999-10-21 Kaveh R. Ghazi ++ ++ * expr.c: Include tm_p.h. ++ ++1999-10-21 Mark Mitchell ++ ++ * cp-tree.h (SCOPE_PARTIAL_P): New macro. ++ (pushlevel_temporary): Remove. ++ (add_scope_stmt): New function. ++ * decl.c (pushlevel_temporary): Remove. ++ (poplevel): Use add_scope_stmt. ++ (start_decl_1): Likewise. ++ * semantics.c (add_scope_stmt): New function. ++ (do_pushlevel): Use it. ++ (do_poplevel): Use it. ++ (expand_stmt): Check SCOPE_PARTIAL_P. ++ ++ * cp-tree.def (EMPTY_CLASS_EXPR): New tree node. ++ * call.c (build_call): Use EMPTY_CLASS_EXPR instead of RTL_EXPR. ++ * expr.c (cplus_expand_expr): Expand it. ++ * ir.texi: Document EMPTY_CLASS_EXPR. ++ ++1999-10-20 Mark Mitchell ++ ++ * cp-tree.h (DECL_NAMESPACE_SCOPE_P): Don't treat template ++ parameters as having namespace scope. ++ ++1999-10-19 Mark Mitchell ++ ++ * method.c (PARM_CAN_BE_ARRAY_TYPE): Remove. ++ (mangling_flags): New type. ++ (build_overload_int): Change prototype. ++ (build_overload_value): Likewise. ++ (numeric_output_need_bar): Improve comment. ++ (mangle_expression): New function, broken out from ... ++ (build_overload_int): Here. ++ (build_overload_value): Adjust for use of mangling flags. Don't ++ warn about real-valued template parameters here. Do handle ++ complex expressions involving real-valued template parameters. ++ (build_template_parm_names): Encase non-type template parameters ++ in underscores, if necessary. ++ (process_overload_item): Remove conditional on ++ PARM_CAN_BE_ARRAY_TYPE. ++ ++1999-10-17 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Handle CLEANUP_POINT_EXPR. ++ ++ * ir.texi: Clean up documentation of RETURN_INIT. ++ ++1999-10-15 Greg McGary ++ ++ * lex.c (lang_init_options): Set flag_bounds_check as "unspecified". ++ (lang_init): Set default for flag_bounds_check if still "unspecified". ++ ++1999-10-13 Andrew Haley ++ ++ * class.c (finish_struct_1): Force alignment of non-bitfields to ++ BITS_PER_UNIT. ++ ++Wed Oct 13 22:01:35 1999 J"orn Rennecke ++ ++ * typeck2.c (process_init_constructor): Handle empty constructors. ++ ++1999-10-13 Jason Merrill ++ ++ * decl.c (lang_mark_tree): Mark NAMESPACE_LEVEL. ++ ++ * pt.c (tsubst, case INTEGER_TYPE): Be more explicit in zero-size ++ array error. ++ ++1999-10-13 Mark Mitchell ++ ++ * decl.c (make_rtl_for_local_static): Don't create register RTL ++ for addressable constants. ++ ++1999-10-13 Nathan Sidwell ++ ++ * cp-tree.h (build_x_va_arg): Prototype new function. ++ * call.c (build_x_va_arg): Define it. ++ * parse.y (unary_expr): Call build_x_va_arg. ++ ++ * cp-tree.h (convert_type_from_ellipsis): Prototype new function. ++ * call.c (convert_type_from_ellipsis): Define it. ++ * decl.c (init_decl_processing): Set lang_type_promotes_to. ++ ++ * tree.c (lvalue_p_1): Accept VA_ARG_EXPR with aggregates. ++ ++1999-10-11 Jason Merrill ++ ++ * class.c (fixed_type_or_null): Always set *nonnull. ++ ++1999-10-10 Kaveh R. Ghazi ++ ++ * cp-tree.h: Use HAVE_GCC_VERSION instead of explicitly testing ++ __GNUC__ and __GNUC_MINOR__. ++ ++1999-10-09 Mark Mitchell ++ ++ * cp-tree.h (make_rtl_for_local_static): New function. ++ * decl.c (make_rtl_for_nonlocal_decl): Move code to create RTL for ++ local statics ... ++ (make_rtl_for_local_static): Here. ++ * semantics.c (expand_stmt): Use make_rtl_for_local_static. ++ ++1999-10-08 Kaveh R. Ghazi ++ ++ * method.c: Include tm_p.h. ++ ++1999-10-7 Franz Sirl ++ ++ * cp-tree.h (cp_make_lake_type): Renamed from make_lang_type. ++ * lex.c (cp_make_lake_type): Likewise. ++ * tree.c (init_tree): Init make_lang_type_fn. ++ ++1999-10-07 Mark Mitchell ++ ++ * pt.c (tsubst_expr): Set DECL_TEMPLATE_INSTANTIATED for a catch ++ parameter. ++ ++ * semantics.c (expand_stmt): Don't pretend to have asmspecs for ++ local statics if we don't really have them. ++ ++ * ir.texi: Improve documentation for STMT_EXPR. Describe ++ CLEANUP_POINT_EXPR. ++ ++1999-10-07 Jason Merrill ++ ++ * class.c (build_vtable_entry_ref): Use finish_asm_stmt. ++ ++1999-10-07 Greg McGary ++ ++ * class.c (finish_struct_1): Use simpler method of ++ removing elements of a singly-linked list which doesn't ++ lose for classes without data members. ++ ++1999-10-07 Mark Mitchell ++ ++ * friend.c (make_friend_class): Robustify. ++ ++ * semantics.c (finish_object_call_expr): Reject calls to template ++ types. ++ ++1999-10-06 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Dump all three operands to a COND_EXPR. ++ ++ * cp-tree.h (CLASSTYPE_VFIELD): Remove. ++ * call.c (build_vfield_ref): Use TYPE_VFIELD, not ++ CLASSTYPE_VFIELD. ++ * class.c (get_vfield_offset): Likewise. ++ (finish_base_struct): Likewise. ++ (modify_one_vtable): Likewise. ++ (fixup_vtable_deltas): Likewise. ++ (finish_struct_1): Likewise. ++ * init.c (expand_virtual_init): Likewise. ++ * search.c (lookup_field_1): Likewise. ++ (expand_upcast_fixups): Likewise. ++ * typeck.c (build_component_ref): Likewise. ++ (build_binary_op_nodefault): Likewise. ++ ++ * dump.c (dqueue_and_dump): Dump TYPE_VFIELD. ++ * ir.texi: Document TYPE_VFIELD. ++ ++1999-10-06 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Only warn about nonzero arrays if ++ !in_system_header (linux socketbits.h can give this for ++ __cmsg_data, which is using a GNU extension). ++ ++1999-10-05 Mark Mitchell ++ ++ * decl2.c (start_static_storage_duration_function): Push the ++ function declaration so it ends up in namespace scope. ++ ++ * dump.c (DUMP_CHILDREN): Remove. ++ (DUMP_BINFO): Adjust. ++ (struct dump_node_info): Remove dump_children_p. ++ (queue_and_dump_type): Remove dump_children_p parameter. ++ (queue): Don't set dump_children_p. ++ (dump_child): Pass DUMP_NONE, instead of DUMP_CHILDREN, to ++ queue_and_dump_index. ++ (dequeue_and_dump): Unconditionally print children. Adjust calls ++ to functions mentioned above. ++ (dump_node): Pass DUMP_NONE, instead of DUMP_CHILDREN to queue. ++ ++ * ir.texi: Document BIND_EXPR, LOOP_EXPR, and EXIT_EXPR. ++ * dump.c (dequeue_and_dump): Dump them. ++ ++ * method.c (synthesize_method): Call setup_vtbl_ptr for destructors. ++ ++ * decl.c (start_function): Set current_in_charge_parm for ++ constructors, too, where appropriate. ++ * search.c (fixup_all_virtual_upcast_offsets): New function. ++ (expand_indirect_vtbls_init): Use it. ++ ++1999-10-04 Nathan Sidwell ++ ++ * decl2.c (grok_alignof): Don't decay lvalues. ++ ++ * init.c (build_new): Remove unused variable. ++ ++1999-10-04 Mark Mitchell ++ ++ * cp-tree.h (struct language_function): Remove static_labelno. ++ (static_labelno): Remove macro. ++ * method.c (build_overload_nested_name): Make static_labelno ++ static here. ++ ++ * pt.c (instantiate_decl): Use DECL_SAVED_TREE, not DECL_INITIAL, ++ to decide whether or not a function is defined. ++ ++ * call.c (build_over_call): Don't set TREE_SIDE_EFFECTS for ++ situations where make_node will do it automatically. ++ * decl.c (grok_reference_init): Likewise. ++ (expand_static_init): Likewise. ++ (do_static_initialization): Likewise. ++ * init.c (perform_member_init): Likewise. ++ (expand_aggr_init_1): Likewise. ++ (build_new_1): Likewise. ++ * method.c (do_build_copy_constructor): Likewise. ++ (do_build_assign_ref): Likewise. ++ * search.c (expand_upcast_fixups): Likewise. ++ * semantics.c (finish_stmt_expr): Likewise. ++ * typeck.c (build_unary_op): Likewise. ++ (check_return_expr): Likewise. ++ ++1999-10-04 Jason Merrill ++ ++ * init.c (build_vec_delete_1): Fold COND_EXPRs. ++ ++1999-10-03 Mark Mitchell ++ ++ * cp-tree.def (VEC_INIT_EXPR): Remove. ++ * cp-tree.h (struct stmt_tree): New type. ++ (struct saved_scope): Remove firstobj. Add x_saved_tree, ++ x_stmt_tree. ++ (class_cache_firstobj): Remove. ++ (struct language_function): Remove stmts_are_full_exprs_p, ++ x_last_tree, and x_last_expr_type. Add x_stmt_tree. ++ (current_stmt_tree): New macro. ++ (last_tree): Adjust. ++ (last_expr_type): Likewise. ++ (doing_semantic_analysis_p): Simplify. ++ (stmts_are_full_exprs_p): Adjust. ++ (begin_tree): Remove prototype. ++ (end_tree): Likewise. ++ (begin_stmt_tree): Change prototype. ++ (finish_stmt_tree): Likewise. ++ (building_stmt_tree): Simplify. ++ * decl.c (mark_stmt_tree): New function. ++ (mark_saved_scope): Use it. ++ (start_function): Rearrange slightly to call begin_stmt_tree ++ earlier. ++ (save_function_data): Tweak. ++ (finish_function): Adjust call to finish_stmt_tree. ++ (mark_lang_function): Use mark_stmt_tree. ++ * expr.c (cplus_expand_expr): Don't handle VEC_INIT_EXPR. ++ * init.c (build_new_1): Remove creation of VEC_INIT_EXPR. ++ (build_vec_init): Remove creation of stand-in initializer. ++ * pt.c (begin_tree): Remove. ++ (end_tree): Likewise. ++ * semantics.c (SET_LAST_STMT): New macro. Use it throughout. ++ (begin_compound_stmt): Handle a compound-statement outside of a ++ function. ++ (begin_stmt_expr): Handle a statement-expression outsidef of a ++ function. ++ (finish_stmt_expr): Likewise. ++ (begin_class_definition): Don't call begin_tree. ++ (finish_inline_definitions): Don't call end_tree. ++ (begin_stmt_tree): Take a pointer to tree, not a function as input. ++ (finish_stmt_tree): Likewise. ++ * tree.c (search_tree): Don't handle VEC_INIT_EXPR. ++ (mapcar): Likewise. ++ ++ * parse.y (simple_stmt): Don't call finish_stmt unnecessarily. ++ * parse.c: Regenerated. ++ ++ * dump.c (dqueue_and_dump): Dump bitfieldness. ++ ++ * tree.c (lvalue_p_1): Use DECL_C_BIT_FIELD to check for ++ bitfields, rather than DECL_BIT_FIELD. ++ * ir.texi: Document how to tell whether or not a field is a ++ bitfield. ++ ++ * lex.c (make_lang_type): Fix typo in comment. ++ ++1999-10-01 Jason Merrill ++ ++ * typeck.c (decay_conversion): Strip cv-quals from non-class rvalues. ++ ++1999-10-01 Mark Mitchell ++ ++ * pt.c (tsubst_decl): If the type of a template instantiation is ++ bogus, so is the whole instantiation. ++ ++1999-09-30 Mark Mitchell ++ ++ * decl.c (initialize_local_var): Handle static variables here. ++ (cp_finish_decl): Tweak handling of function-scope static ++ variables. ++ * semantics.c (expand_stmt): Handle DECL_STMTs for static ++ variables. ++ ++ * method.c (emit_thunk): Don't crash when -fsyntax-only. ++ ++ * cp-tree.h (lang_decl_flags): Add global_ctor_p and ++ global_dtor_p. Add init_priority. ++ (DECL_ACCESS): Adjust accordingly. ++ (DECL_GLOBAL_CTOR_P, DECL_GLOBAL_DTOR_P): New macros. ++ (GLOBAL_INIT_PRIORITY): Likewise. ++ * decl.c (lang_mark_tree): Adjust accordingly. ++ (start_objects): Set DECL_GLOBAL_CTOR_P, DECL_GLOBAL_DTOR_P, ++ and GLOBAL_INIT_PRIORITY. ++ * dump.c (dequeue_and_dump): Print them. ++ * ir.texi: Document them. ++ ++ * decl2.c (struct priority_info_s): Remove initialization_sequence ++ and destruction_sequence. ++ (start_static_storage_duration_function): Return the body of the ++ function. Convert for function-at-a-time mode. ++ (generate_inits_for_priority): Remove. ++ (finish_static_storage_duration_function): Change prototype. ++ Adjust for function-at-a-time mode. ++ (do_static_initialization): Likewise. ++ (do_static_destruction): Likewise. ++ (do_static_initialization_and_destruction): Remove. ++ (start_static_initialization_or_destruction): New function. ++ (finish_static_initialization_or_destruction): Likewise. ++ (get_priority_info): Don't manipulation initialization_sequence or ++ destruction_sequence. ++ (prune_vars_needing_no_initialization): New function. ++ (write_out_vars): Likewise. ++ (finish_file): Use the various new functions instead of the old. ++ ++Thu Sep 30 00:13:27 1999 Dirk Zoller ++ ++ * cp-tree.h (warn_float_equal): Declare. ++ * decl2.c (warn_float_equal): Define. ++ (lang_decode_option): Recognize -W[no-]float-equal. ++ * typeck.c (build_binary_op_nodefault): Conditionally warn ++ about equality tests of floating point types. ++ ++1999-09-29 Jason Merrill ++ ++ Support normal type_info-based EH mechanisms with -fno-rtti. ++ * except.c (build_eh_type_type): Remove special -fno-rtti handling. ++ (build_eh_type_type_ref): Likewise. ++ (build_eh_type): Remove. ++ (expand_throw): Call build_eh_type_type, not build_eh_type. ++ * decl2.c (import_export_decl): Don't associate the tinfo fn with ++ the vtable if -fno-rtti. ++ * decl.c (init_decl_processing): Always init_rtti_processing. ++ ++ * rtti.c (get_typeid): Don't complain about -fno-rtti. ++ ++ * class.c (class_cache_obstack, class_obstack): Remove. ++ (init_class_processing): Don't initialize class_obstack. ++ (push_cache_obstack): Remove. ++ (pushclass): Don't call it. ++ * cp-tree.h: Remove prototype for push_cache_obstack. ++ * decl.c (decl_obstack, decl_stack, push_decl_level): Remove. ++ (pushlevel_class): Don't push_decl_level. ++ (poplevel_class): Don't pop_stack_level. ++ (push_class_level_binding): Don't push_cache_obstack. ++ (init_decl_processing): Don't initialize decl_obstack. ++ * search.c (push_class_decls): Don't push_cache_obstack. ++ * tree.c (list_hash_add): Put hash node on permanent_obstack. ++ (hash_tree_cons): Don't mess with obstacks. ++ (print_lang_statistics): Don't print stats for class_obstack and ++ decl_obstack. ++ ++1999-09-29 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Dump DECL_EXTERNAL. ++ * ir.texi: Document DECL_EXTERNAL. ++ ++ * dump.c (dequeue_and_dump): Improve support for dumping THUNK_DECLs. ++ * ir.texi: Document THUNK_DECLs. ++ ++ * cp-tree.h (TMPL_ARGS_HAVE_MULTIPLE_LEVELS): Move here from pt.c. ++ (TMPL_ARGS_DEPTH, TMPL_ARGS_LEVEL, SET_TMPL_ARGS_LEVEL): Likewise. ++ (TMPL_ARG, SET_TMPL_ARG, NUM_TMPL_ARGS, TMPL_PARMS_DEPTH): Likewise. ++ * error.c (dump_template_bindings): Remove unused parameter. ++ Handle multiple levels of template parameters. ++ (dump_template_decl): Use `parms', not `args', for template ++ parameters. Fix thinko. ++ (dump_function_decl): Use DECL_TEMPLATE_INSTANTIATION. Don't pass ++ flags to dump_template_bindings. ++ * pt.c (TMPL_ARGS_HAVE_MULTIPLE_LEVELS): Move to cp-tree.h. ++ (TMPL_ARGS_DEPTH, TMPL_ARGS_LEVEL, SET_TMPL_ARGS_LEVEL): Likewise. ++ (TMPL_ARG, SET_TMPL_ARG, NUM_TMPL_ARGS, TMPL_PARMS_DEPTH): Likewise. ++ (tsubst_copy): Clarify variable name. ++ (most_general_template): Robustify. ++ ++1999-09-29 Nathan Sidwell ++ ++ * error.c (dump_template_parms): Don't use TS_PEDANTIC_NAME ++ to change primary template rendering. ++ ++1999-09-29 Mark Mitchell ++ ++ * cp-tree.h (UPT_TEMPLATE): Remove. ++ (UPT_PARMS): Likewise. ++ (DECL_NEEDED_P): New macro. ++ * decl2.c (finish_vtable_vardecl): Use it. ++ (finish_objects): Don't crash with -fsyntax-only. ++ (finish_file): Use DECL_NEEDED_P. Don't prune vtables when ++ -fsyntax-only. ++ * pt.c (tsubst_friend_function): Remove FIXME that talks about ++ obstacks. ++ (tsubst_expr): Correct handling of function try-blocks. ++ * semantics.c: Include flags.h. ++ (expand_body): Don't do RTL generation if -fsyntax-only. ++ * Makefile.in (semantics.o): Depends on flags.h. ++ ++1999-09-28 Gabriel Dos Reis ++ ++ * pt.c (most_general_template): Adjust declaration. ++ ++ * cp-tree.h: (most_general_template): Declare. ++ ++ * error.c (dump_template_value): Rename to ... ++ (dump_template_argument): This. ++ (dump_template_argument_list): New function. ++ (dump_type): Use it. ++ (dump_template_parameter): New function. ++ (dump_template_decl): Use it. ++ (dump_template_bindings): New function. ++ (dump_function_decl): Use it. Pretty print function template ++ instantiations. ++ ++1999-09-28 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Distinguish parameter context for ++ diagnostics. Tidy up missing type diagnostic. ++ Diagnose `explicit' in one place. Diagnose `mutable' in one place. ++ ++1999-09-28 Mark Mitchell ++ ++ * ir.texi: Improve documentation for TARGET_EXPR. ++ ++1999-09-27 Nathan Sidwell ++ ++ Augment stringification of trees. ++ * cp-tree.h (tree_string_flags): New error stringifying enumeration. ++ (fndecl_as_string, type_as_string_real, args_as_string, ++ code_as_string, language_as_string, parm_as_string, ++ op_as_string, assop_as_string, cv_as_string): Remove. ++ (type_as_string, decl_as_string, expr_as_string): Adjust prototype. ++ (context_as_string): Declare new function. ++ * error.c (cp_printers): Move definition. ++ (OB_UNPUT): Remove. ++ (OB_END_TEMPLATE_ID): Adjust. ++ (interesting_scope_p): Remove. ++ (dump_scope): New static function. ++ (dump_qualifiers): Adjust prototype, reimplement. ++ (dump_template_value): Use tree_string_flags. ++ (dump_type_real): Move back to dump_type. ++ (dump_type): Adjust prototype. Use tree_string_flags. ++ (dump_aggr_type): Likewise. Use dump_template_parms. ++ (dump_type_prefix): Adjust prototype. Use tree_string_flags. ++ Return pad flag. ++ (dump_type_suffix): Adjust prototype. Use tree_string_flags. ++ (dump_simple_decl): Likewise. ++ (dump_decl): Likewise. Use dump_template_decl. ++ (dump_template_decl): New static function broken out of dump_decl. ++ (dump_function_decl): Adjust prototype. Use tree_string_flags. ++ (dump_parameters): Likewise. Prefix space. ++ (dump_exception_spec): Adjust prototype. Use tree_string_flags. ++ (dump_function_name): Likewise. Use dump_template_parms. ++ (dump_template_parms): New static function broken out of ++ dump_function_name. ++ (dump_expr_list): Adjust prototype. Use tree_string_flags. ++ (dump_expr): Likewise. ++ (fndecl_as_string): Removed ++ (type_as_string_real): Removed ++ (dump_binary_op): Adjust prototype. Use tree_string_flags. ++ (dump_unary_op): Likewise. ++ (type_as_string): Likewise. ++ (expr_as_string): Likewise. ++ (decl_as_string): Likewise. ++ (context_as_string): New function. ++ (lang_decl_name): Adjust. ++ (decl_to_string): New static print callback. ++ (expr_to_string): Likewise. ++ (fndecl_to_string): Likewise. ++ (code_as_string): Renamed to ... ++ (code_to_string): ... here. Adjust. ++ (language_as_string): Renamed to ... ++ (language_to_string): ... here. Adjust. ++ (parm_as_string): Renamed to ... ++ (parm_to_string): ... here. ++ (op_as_string): Renamed to ... ++ (op_to_string): ... here. ++ (assop_as_string): Renamed to ... ++ (assop_to_string): ... here. ++ (type_to_string): New static print callback. ++ (args_as_string): Renamed to ... ++ (args_to_string): ... here. Adjust. ++ (cv_as_string): Renamed to ... ++ (cv_to_string): ... here. Adjust. ++ * pt.c (mangle_class_name_for_template): Use tree_string_flags. ++ (print_template_context): Likewise. ++ ++1999-09-26 Mark Mitchell ++ ++ * cp-tree.h (expand_throw): Remove prototype. ++ * except.c (expand_throw): Make it static. Use tree-generation ++ functions, rather than RTL-generation functions. ++ (build_throw): Use it. ++ * expr.c: Include except.h. ++ (cplus_expand_expr): Don't call expand_throw here. ++ * Makefile.in (expr.o): Depend on except.h. ++ * ir.texi: Update documentation for THROW_EXPR. ++ ++ * decl.c (start_function): Set x_dont_save_pending_sizes rather ++ than calling get_pending_sizes. ++ * init.c (build_new): Don't save and restore ++ immediate_size_expand; instead, assert that it has the expected ++ value already. ++ ++1999-09-26 Kaveh R. Ghazi ++ ++ * lex.c (compiler_error): Add missing call to va_end(). ++ ++1999-09-25 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Handle RESULT_DECL. ++ * ir.texi: Document RESULT_DECL and DECL_RESULT. ++ ++ * cp-tree.h (check_return_expr): New function. ++ * decl.c (finish_constructor_body): New function. ++ (pushdecl): Put global friend functions in namespace binding ++ level, not the class binding level. ++ (finish_destructor_body): Make sure the dtor_label is always ++ defined. Fix typo in comment. ++ (finish_function): Move generation of constructor-termination code ++ to semantic-analysis time. Move generation of implicit `main' ++ return value to semantic-analysis time. ++ * semantics.c (finish_return_stmt): Generate goto's to ++ ctor_label/dtor_label here. Use check_return_expr to do semantic ++ analysis on the returned expression. ++ * typeck.c (maybe_warn_about_returning_address_of_local): New ++ function split out from c_expand_return. ++ (check_return_expr): Likewise. ++ (c_expand_return): Just generate the RTL for the return. ++ ++1999-09-24 Mark Mitchell ++ ++ * cp-tree.h (CPTI_CLEANUP_TYPE): New macro. ++ (cleanup_type): Likewise. ++ (search_tree): Change prototype. ++ * decl.c (local_variable_p): Adjust for new interface to ++ search_tree. ++ (check_default_argument): Likewise. ++ * error.c (dump_expr): Handle INIT_EXPR. ++ * except.c (expand_throw): Don't make cleanup_type a local static. ++ * expr.c (cplus_expand_expr): Don't handle NEW_EXPR. ++ * init.c (build_new): Call build_new_1 directly, rather than ++ building a NEW_EXPR. ++ (build_new_1): Tidy. Don't build a VEC_INIT_EXPR except when ++ processing file-scope initializers. ++ * lex.c (init_parse): Add an opname_tab entry for INIT_EXPR. ++ * tree.c: Include splay-tree.h ++ (no_linkage_helper): Adjust for new interface to search_tree. ++ (search_tree): Pass around pointers to tree nodes, rather than the ++ nodes themselves. Handle VEC_INIT_EXPR. ++ (no_linkage_check): Adjust for new interface to search_tree. ++ (mapcar): Handle VEC_INIT_EXPR. ++ (target_remap): New variable. ++ (bot_manip): Use it. ++ (bot_replace): New function. ++ (break_out_target_exprs): Use it to remap all variables used in a ++ default argument expression. ++ * typeck.c (build_modify_expr): Don't crash when outside a ++ function and presented with an INIT_EXPR assignment ++ * Makefile.in (tree.o): Depend on splay-tree.h. ++ ++Fri Sep 24 10:48:10 1999 Bernd Schmidt ++ ++ * decl.c (duplicate_decls): Use DECL_BUILT_IN_CLASS rather than ++ DECL_BUILT_IN. ++ (builtin_function): New arg CLASS. Arg CODE now of type int. All ++ callers changed. ++ Set the builtin's DECL_BUILT_IN_CLASS. ++ ++1999-09-24 Mark Mitchell ++ ++ * decl.c (pushdecl): Don't make local declarations of extern ++ variables give the variable a DECL_CONTEXT for the function. ++ (make_rtl_for_nonlocal_decl): Don't fuss with obstacks. Simplify. ++ Don't accidentally make RTL for local declarations. ++ (emit_local_var): Handle declarations with asm-specifiers here. ++ ++1999-09-23 Mark Mitchell ++ ++ * ir.texi: Improve documentation for TARGET_EXPRs. Discuss ++ STMT_IS_FULL_EXPR_P. ++ ++ * cp-tree.h (language_function): Add cannot_inline. ++ * decl.c (start_function): Restore current_function_cannot_inline ++ from the saved value. ++ (save_function_data): Save current_function_cannot_inline. ++ * decl2.c (start_objects): Change prototype. Build the function ++ in function-at-a-time mode. ++ (finish_objects): Likewise. ++ (generate_ctor_or_dtor_function): Adjust accordingly. ++ ++ * cp-tree.h (DECL_ANON_UNION_ELEMS): New macro. ++ * decl2.c (finish_anon_union): Set DECL_ANON_UNION_ELEMS. ++ Don't call expand_anon_union_decl here ++ * semantics.c (exapnd_stmt): Call it here, instead. ++ * typeck.c (mark_addressable): Addressed variables are implicitly ++ used. ++ ++1999-09-23 Martin v. Löwis ++ ++ * cp-tree.h (VAR_OR_FUNCTION_DECL_CHECK): New macro. ++ (RECORD_OR_UNION_TYPE_CHECK, LANG_IDENTIFIER_CAST): Likewise. ++ (DEFARG_NODE_CHECK): Remove; replace with DEFAULT_ARG_CHECK. ++ * cp-tree.h: Add tree checking macros to various tree access ++ macros. ++ * ptree.c (print_lang_decl): Test for function or variable ++ before accessing template info. ++ ++1999-09-23 Jason Merrill ++ ++ * lex.c: Get WCHAR_TYPE_SIZE from wchar_type_node. ++ * lang-specs.h: If -fshort-wchar, override __WCHAR_TYPE__. ++ * decl2.c (lang_f_options): Add -fshort-wchar. ++ * cp-tree.h: Declare flag_short_wchar. ++ * decl.c (init_decl_processing): If -fshort-wchar, use 'short unsigned ++ int' for wchar_t. ++ ++1999-09-23 Martin v. Löwis ++ ++ * ir.texi: Fix formatting errors and typos. ++ ++1999-09-22 Mark Mitchell ++ ++ * ir.texi: Document CLEANUP_STMT, SCOPE_STMT, and START_CATCH_STMT. ++ ++ * decl.c (pushdecl): Do create a binding for extern "C" functions, ++ but not for their DECL_ASSEMBLER_NAMEs. ++ (lookup_name_current_level): Fix formatting. ++ (xref_tag): Likewise. ++ * decl2.c (start_objects): Mark static constructors and ++ destructors as used. ++ ++1999-09-22 Jason Merrill ++ ++ * decl.c (define_case_label): Don't crash if we're not in a switch. ++ ++ * decl2.c (lang_decode_option): Don't bother explicitly ignoring flags. ++ * lang-options.h: Restore -fthis-is-variable. Remove help strings ++ for unsupported flags. ++ ++1999-09-21 Jason Merrill ++ ++ * decl2.c (lang_decode_option): Accept and ignore -finit-priority. ++ Accept and warn about -fthis-is-variable. ++ ++1999-09-21 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Handle START_CATCH_STMT, ++ CLEANUP_STMT, and SCOPE_STMT. ++ ++ * decl2.c (lang_decode_option): Adjust, in the wake of recent ++ changes to option processing. ++ ++1999-09-21 Martin v. Löwis ++ ++ * typeck.c (get_member_function_from_ptrfunc): Allow extraction of ++ function pointer from pmfs with no object given. ++ (convert_for_assignment): Do not return error when converting ++ pmfs. ++ ++1999-09-21 Alex Samuel ++ ++ * lex.c (internal_filename): New variable. ++ (INTERNAL_FILENAME): New macro. ++ (init_parse): Allocate internal_filename and mark as root. Use it ++ instead of a string constant. ++ ++1999-09-21 Nathan Sidwell ++ ++ Reimplement dynamic cast and catch matching. ++ * cp-tree.h (get_dynamic_cast_base_type): Prototype new function ++ * search.c (dynamic_cast_base_recurse): New function. ++ (get_dynamic_cast_base_type): New function for dynamic cast. ++ * rtti.c (build_dynamic_cast_1): Determine source and target ++ class relationship. Call __dynamic_cast_2. ++ * tinfo.h (__user_type_info::upcast): New catch dispatcher. ++ (__user_type_info::dyncast): New dynamic cast dispatcher. ++ (__user_type_info::sub_kind): New nested enumeration. ++ (__user_type_info::contained_p): sub_kind predicate. ++ (__user_type_info::contained_public_p): Likewise. ++ (__user_type_info::contained_nonpublic_p): Likewise. ++ (__user_type_info::contained_nonvirtual_p: Likewise. ++ (__user_type_info::upcast_result): New nested struct. ++ (__user_type_info::dyncast_result): New nested struct. ++ (*::do_upcast): New catch function. ++ (*::do_dyncast): New dynamic cast function. ++ (__user_type_info::find_public_subobj): New dynamic cast ++ helper dispatcher. ++ (*::do_find_public_subobj): New dynamic cast helper function. ++ * tinfo.cc (__user_type_info::upcast): Define catch dispatcher. ++ (__user_type_info::dyncast): Define dynamic cast dispatcher. ++ (*::do_upcast): Define catch function. ++ (*::do_dyncast): Define dynamic cast function. ++ (*::do_find_public_subobj): Define dynamic cast helper function. ++ * tinfo2.cc (__throw_type_match_rtti_2): Use upcast. ++ (__dynamic_cast): Backwards compatibility wrapper. Use dyncast. ++ (__dynamic_cast_2): New dynamic cast runtime. ++ ++1999-09-20 Mark Mitchell ++ ++ * cp-tree.h (finish_stmt_expr): Change prototype. ++ * expr.c (cplus_expand_expr): Adjust call accordingly. ++ * init.c (finish_init_stmts): Likewise. ++ * parse.y (primary): Likewise. ++ * pt.c (tsubst_copy): Likewise. ++ * semantics.c (finish_stmt_expr): Don't take two parameters. ++ Don't remove generated BLOCKs from the block-tree. ++ ++ Remove support for assigning to `this'. ++ * NEWS: Note that fact. ++ * class.c (build_vbase_path): Don't check flag_this_is_variable. ++ * cp-tree.h (EXPR_STMT_ASSIGNS_THIS): Remove. ++ (language_function): Remove assigns_this, just_assigned_this, and ++ x_base_init_expr. Add x_vcalls_possible_p. Add vtbls_set_up_p. ++ (base_init_expr): Remove. ++ (current_vcalls_possible_p): New macro. ++ (vtbls_set_up_p): Likewise. ++ (emit_base_init): Change prototype. ++ * decl.c (finish_destructor_body): New function, split out from ++ finish_function. ++ (current_function_assigns_this): Remove. ++ (current_function_just_assigned_this): Likewise. ++ (start_function): Don't set them. ++ (finish_function): Don't check them. Don't emit ++ base-initialization code here. Generate code for destructors when ++ doing semantic analysis. ++ (finish_stmt): Don't check current_function_just_assigned_this. ++ * decl2.c (lang_f_options): Remove this-is-variable. ++ (lang_decode_option): Likewise. ++ (grokclassfn): Don't check flag_this_is_variable. ++ * init.c (emit_base_init): Return the expression generated. ++ (construct_virtual_bases): Don't push/pop obstacks. Fix ++ typo. ++ (build_new_1): Don't check flag_this_is_variable. ++ (get_temp_regvar): Don't set DECL_REGISTER. ++ (build_vec_init): Don't call use_variable. ++ * lang-options.h: Remove "-fthis-is-variable" and ++ "-fno-this-is-variable". ++ * pt.c (tsubst_expr): Don't check EXPR_STMT_ASSIGNS_THIS. ++ * search.c (expand_upcast_fixups): Use finish_expr_stmt, not ++ expand_expr_stmt. ++ * semantics.c (finish_expr_stmt_real): Rename to ... ++ (finish_expr_stmt): This. Remove assigned_this parameter. ++ (begin_if_stmt): Call do_pushlevel before starting the statement. ++ (begin_compound_stmt): Don't declare __FUNCTION__ in scope-less ++ blocks. ++ (setup_vtbl_ptr): Emit initialization code for bases and members ++ at semantic-analysis time. Emit code to initialize vtables in ++ destructors here. ++ (expand_stmt): Use finish_expr_stmt, not finish_expr_stmt_real. ++ Don't handle CTOR_INITIALIZER any more. ++ * typeck.c (build_modify_expr): Don't check for assignments to ++ this. ++ (c_expand_return): Don't suggest assigning to `this'. ++ ++ * Makefile.in (decl.o): Depend on RTL_H. ++ (decl2.o): Likewise. ++ (class.o): Likewise. ++ (call.o): Likewise. ++ (method.o): Likewise. ++ (search.o): Likewise. ++ (tree.o): Likewise. ++ (pt.o): Likewise. ++ ++ * decl.c (duplicate_decls): When a builtin function is redeclared ++ as static, make sure it is mangled correctly. ++ ++ * ir.texi (CTOR_INITIALIZER): Remove mention. Fix typo. Add ++ detail about the statement-tree. ++ ++1999-09-20 Nathan Sidwell ++ ++ * parse.y (primary): Use build_functional_cast for CV_QUALIFIER. ++ ++1999-09-20 Nick Clifton ++ ++ * decl2.c (lang_decode_option): Extend comment. ++ ++Mon Sep 20 10:49:05 1999 Bernd Schmidt ++ ++ * typeck.c: Include "tm_p.h". ++ ++1999-09-19 Mark Mitchell ++ ++ * ir.texi: New file. ++ ++1999-09-19 Paul Burchard ++ ++ * semantics.c (expand_stmt): Initialize return value. ++ ++1999-09-18 Paul Burchard ++ ++ * gxxint.texi: G++ now implements namespaces. ++ ++1999-09-18 Mark Mitchell ++ ++ * decl.c (pop_label): Don't warn about unused labels more than ++ once. ++ * semantics.c (finish_goto_stmt): Always marked used labels as ++ used. ++ ++ * decl.c (layout_var_decl): Change prototype. Call layout_decl ++ even when the declaration is external. ++ (cp_finish_decl): Adjust call to layout_var_decl. ++ * pt.c (tsubst_expr): Make sure to initialize stmt before using it. ++ ++1999-09-18 Martin von Loewis ++ ++ * typeck.c (get_member_function_from_ptrfunc): Always consider ++ virtuality inside member pointer. ++ ++1999-09-17 Mark Mitchell ++ ++ Turn on function-at-a-time processing. ++ * cp-tree.h (doing_semantic_analysis_p): New macro. ++ (SF_DEFAULT): Define to zero, not SF_EXPAND. ++ (start_handler_parms): Change prototype. ++ (expand_start_catch_block): Likewise. ++ (expand_end_catch_block): Likewise. ++ (expand_start_eh_spec): Likewise. ++ (expand_end_eh_spec): Declare. ++ (finish_handler_parms): Change prototype. ++ (begin_catch_block): Declare. ++ (finish_handler): Change prototype. ++ (do_pushlevel): Declare. ++ (do_poplevel): Likewise. ++ * decl.c (pushlevel): Don't create ++ binding levels when not doing semantic analysis. ++ (poplevel): Don't pop them. ++ (pushdecl): Assert that we are never called when not doing ++ semantic analysis. ++ (pushdecl_top_level): Use push_to_top_level. ++ (make_label_decl): Don't fiddle with obstacks. Make RTL For the ++ label when expanding. ++ (cp_finish_decl): Only inject for-scope variables when doing ++ semantic analysis. Add comments. ++ (start_handler_parms): Return the handler parm. ++ (start_function): Reorganize. Don't clear DECL_INITIAL if it is ++ already set. Reinitialize from saved function data if available. ++ Don't pushlevel when not doing semantic analysis. ++ (store_parm_decls): Only generate RTL when expanding. Only ++ pushdecl when doing semantic analysis. Set ++ current_eh_spec_try_block if appropriate. ++ (finish_function): Simplify. Use do_pushlevel and do_poplevel. ++ Combine common code. Don't poplevel when not doing semantic ++ analysis. ++ (push_cp_function_context): Don't expand functions without an ++ explicit call to expand_body. ++ (mark_lang_function): Make eh_spec_try_block and ++ x_scope_stmt_stack. ++ * except.c (expand_end_eh_spec): Don't ++ declare. ++ (process_start_catch_block): Likewise. ++ (push_eh_cleanup): Use finish_decl_cleanup. ++ (initialize_handler_parm): New function. ++ (expand_start_catch_block): Use it. ++ (expand_end_catch_block): Use tree-generation functions, not ++ RTL-generation functions. ++ (expand_start_eh_spec): Likewise. ++ (expand_end_eh_spec): Likewise. ++ (expand_exception_blocks): Simplify. ++ (start_anon_func): Use do_pushlevel. ++ (end_anon_func): Use do_poplvel. Call expand_body for the ++ function. ++ * expr.c (do_case): Don't call define_case_label. ++ * init.c (create_temporary_var): Set DECL_CONTEXT for local ++ variables. ++ * method.c (emit_thunk): Call expand_body for the ++ thunk. ++ (sythesize_method): Likewise. ++ * parse.y (handler_args): Give it ttype. ++ (eat_saved_input): Call expand_body. ++ (base_init): Use do_pushlevel. ++ (pending_inline): Call expand_body. ++ (handler): Adjust calls to finish_handler_parms and ++ finish_handler. ++ (handler_args): Don't call expand_start_catch_block. Return the ++ catch parameter. * pt.c (tsubst_expr): Adjust HANDLER handling. ++ * parse.c: Regenerated. ++ * rtti.c (synthesize_tinfo_fn): Call finish_function. ++ * semantics.c (do_pushlevel): Give it external linkage. Build ++ SCOPE_STMTs. ++ (do_poplevel): Likewise. ++ (finish_case_label): Call define_case_label when doing semantic ++ analysis. ++ (finish_goto_stmt): Create RTL for labels. ++ (finish_function_try_block): Set in_function_try_handler ++ unconditionally. ++ (finish_function_handler_sequence): Unset it. ++ (finish_handler_parms): Use expand_start_catch_block even when ++ building a statement-tree. ++ (begin_catch_block): New function. ++ (finish_handler): Move a little RTL-generation logic here. ++ (finish_decl_cleanup): Allow cleanups for empty declarations. ++ (finish_named_return_value): Don't pushdecl when not doing ++ semantic analysis. ++ (expand_stmt): Don't do semantic analysis for variable ++ declarations. Handle START_CATCH_STMT. Call expand_label ++ directly for a LABEL_STMT. Tweak handling of GOTO_STMT. Adjust ++ HANDLERs. Handle SCOPE_STMT, CTOR_INITIALIZER, and RETURN_INIT. ++ (expand_body): Let expand_stmt handle CTOR_INITIALIZER, ++ RETURN_INIT and function try blocks. ++ ++ * cp-tree.h (language_function): Add x_eh_spec_try_block. Add ++ x_scope_stmt_stack. Add x_in_charge_parm. ++ (current_eh_spec_try_block): New macro. ++ (current_scope_stmt_stack): Likewise. ++ (current_in_charge_parm): Likewise. ++ * decl.c (start_function): Initialize current_in_charge_parm. ++ (finish_function): Use current_in_charge_parm rather than looking ++ up __in_chrg. ++ * search.c (expand_indirect_vtbls_init): Likewise. ++ ++ * cp-tree.def (CLEANUP_STMT): Fix spelling in dumps. ++ (TRY_BLOCK): Likewise. ++ (HANDLER): Likewise. ++ (START_CATCH_STMT): New tree node. ++ (SCOPE_STMT): Likewise. ++ * cp-tree.h (SCOPE_BEGIN_P): New macro. ++ (SCOPE_NULLIFIED_P): Likewise. ++ (struct lang_decl_flags): Add pending_inline_p. Adjust dummy. ++ (struct lang_decl): Add saved_language_function. ++ (DECL_PENDING_INLINE_INFO): Adjust documentation. ++ (DECL_PENDING_INLINE_P): New macro. ++ (TYPE_TI_ARGS): Fix typo in comment. ++ (DECL_SAVED_TREE): Add to documentation. ++ (DECL_SAVED_FUNCTION_DATA): New macro. ++ (START_CATCH_TYPE): Likewise. ++ (SCOPE_END_P): New macro. ++ (declare_parm_level): Don't declare. ++ * decl.c (mark_lang_function): New function, split out from ++ mark_cp_function_context. ++ (save_function_data): New function. ++ (declare_parm_level): Remove. ++ (finish_function): Use save_function_data to squirrel away ++ important stuff for later use. ++ (mark_cp_function_context): Use mark_function_data. ++ (lang_mark_tree): Likewise. ++ * lex.c (begin_definition_of_inclass_inline): Set ++ DECL_PENDING_INLINE_P. ++ (store_pending_inline): Clear it. ++ * pt.c (tsubst_decl): Likewise. ++ ++1999-09-17 Nathan Sidwell ++ ++ * call.c (perform_implicit_conversion): Deal with error_mark_node. ++ ++1999-09-17 Mark Mitchell ++ ++ * decl.c (warn_extern_redeclared_static): Don't get confused by ++ static member functions. ++ (duplicate_decls): Merge DECL_THIS_STATIC. ++ ++ * decl.c (expand_static_init): Make sure assignments to local ++ statics actually occur. ++ ++1999-09-17 Mark Mitchell ++ ++ * cp-tree.h (poplevel_class): Declare. ++ * class.c (popclass): Use poplevel_class, not poplevel. ++ * decl.c (poplevel_class): Don't make it static. Don't return a ++ value. ++ (poplevel): Don't call poplevel_class; abort in a class ++ binding level is seen. ++ * semantics.c (finish_translation_unit): Use pop_everything. ++ * parse.y (member_init): Allow errors. ++ (pending_inline): Call finish_function. ++ * parse.c: Regenerated. ++ * Makefile.in (CONFLICTS): Adjust. ++ ++1999-09-17 Gabriel Dos Reis ++ ++ * error.c: Reduce code duplication. ++ (dump_template_value): New function. ++ (dump_type_real): Use it. ++ (dump_decl): Likewise. ++ (dump_function_name): Likewise. ++ (dump_function_decl): Don't be too talkative about function return ++ type variety. ++ ++1999-09-16 Kaveh R. Ghazi ++ ++ * lex.c (init_cpp_parse): Call xcalloc, not malloc/bzero. ++ ++ * xref.c (SALLOC): Call xstrdup, not xmalloc/strcpy. ++ ++1999-09-16 Jason Merrill ++ ++ * decl2.c (finish_file): Also call check_global_declarations for ++ the pending_statics list. ++ ++1999-09-15 Jason Merrill ++ ++ * lex.c (cp_pragma_implementation): Allow #pragma implementation ++ in header files. ++ ++1999-09-15 Richard Henderson ++ ++ * lex.c (mark_impl_file_chain): Follow the next chain. ++ ++1999-09-15 Mark Mitchell ++ ++ * decl.c (warn_extern_redeclared_static): Simplify. Catch ++ problems with extern "C" functions redeclared as static. ++ (duplicate_decls): When a builtin is redeclared static, make the ++ new function have internal linkage. ++ ++1999-09-15 Mark Mitchell ++ ++ * decl2.c (build_expr_from_tree): Handle VA_ARG_EXPR. ++ * pt.c (tsubst_copy): Likewise. ++ * tree.c (search_tree): Likewise. ++ (mapcar): Likewise. ++ ++1999-09-15 Kaveh R. Ghazi ++ ++ * typeck2.c (ack): Don't declare progname. ++ ++1999-09-14 Alexandre Oliva ++ ++ * lex.c (cp_pragma_interface, cp_pragma_implementation): Copy ++ filenames with ggc_alloc_string. ++ ++1999-09-14 Mark Mitchell ++ ++ * decl.c (build_target_expr): Set TREE_SIDE_EFFECTS on the ++ TARGET_EXPR. ++ * call.c (build_over_call): Don't set TREE_SIDE_EFFECTS on ++ the TARGET_EXPR. ++ * cvt.c (build_up_reference): Likewise. ++ * tree.c (build_cplus_new): Likewise. ++ (get_target_expr): Likewise. ++ ++Tue Sep 14 01:45:10 1999 Marc Espie ++ ++ * Makefile.in: Prepend $(SHELL) to move-if-change calls. ++ ++1999-09-13 Mark Mitchell ++ ++ * cp-tree.h (build_target_expr): New function. ++ * call.c (build_conditional_expr): Use build_target_expr. ++ (convert_like): Likewise. ++ (build_over_call): Likewise. ++ * cvt.c (build_up_reference): Likewise. ++ * decl.c (build_cleanup_on_safe_obstack): Fold into ... ++ (destroy_local_var): Here. ++ (build_target_expr): New function. ++ * tree.c (build_cplus_new): Use it. ++ (get_target_expr): Likewise. ++ ++1999-09-13 Nathan Sidwell ++ ++ * typeck.c (expr_sizeof): Don't decay arrays and functions. ++ Remove misleading comment. ++ (build_compound_expr): Don't decay arrays. ++ ++1999-09-13 Jason Merrill ++ ++ * call.c (build_conditional_expr): Always use a TARGET_EXPR for ++ class rvalues again. ++ ++Sun Sep 12 23:29:07 1999 Kaveh R. Ghazi ++ ++ * Make-lang.in (g++spec.o): Depend on system.h and gcc.h. ++ ++ * g++spec.c: Include gcc.h. ++ (lang_specific_driver): Constify a char*. Call xcalloc, not ++ xmalloc/bzero. All calls to the function pointer parameter now ++ explicitly call `fatal'. ++ ++1999-09-12 Mark Mitchell ++ ++ * call.c (implicit_conversion): Robustify. Handle OFFSET_REFs. ++ * cvt.c (ocp_convert): Complete the from and destination types. ++ Adjust warning about functions always being `true' in conditionals. ++ * decl.c (duplicate_decls): Don't play funny games with abort. ++ * error.c (dump_expr): Handle OVERLOADs. ++ * spew.c (probe_obstack): Remove. ++ * typeck.c (condition_conversion): Use perform_implicit_conversion. ++ ++1999-09-12 Bernd Schmidt ++ ++ * cp-tree.h (auto_function, define_function): Adjust prototypes. ++ * decl.c (define_function): Lose FUNCTION_CODE arg. All callers ++ changed. ++ (auto_function): Likewise, for CODE arg. ++ Move code to set DECL_BUILT_IN and DECL_FUNCTION_CODE to... ++ (builtin_function): ... here. ++ ++1999-09-11 Mark Mitchell ++ ++ * decl.c (add_decl_to_level): Remove TREE_PERMANENT assertion. ++ (init_decl_processing): Don't set TREE_PERMANENT for the ++ error_mark_node. ++ (start_decl): Don't rebuild non-permanent ARRAY_TYPEs. ++ (grokdeclarator): Likewise. ++ (grokparms): Don't check TREE_PERMANENT when building up lists. ++ * decl2.c (grokfield): Don't assert TREE_PERMANENT. ++ (mark_inline_for_output): Likewise. ++ * expr.c (cplus_expand_expr): Don't check TREE_PERMANENT. ++ * init.c (build_offset_ref): Don't check TREE_PERMANENT. ++ * lex.c (check_newline): Don't check ggc_p; it is always one. ++ * pt.c (process_template_parm): Don't check TREE_PERMANENT. ++ * spew.c (yylex): Don't copy_node or probe_obstacks for ++ non-permanent CONSTANTs and STRINGs. ++ * tree.c (build_cplus_array_type_1): Don't fuss with ++ TREE_PERMANENT on ARRAY_TYPEs. ++ ++ * cp-tree.def (CLEANUP_STMT): New node. ++ * cp-tree.h (language_function): Add name_declared. ++ (current_function_name_declared): New macro. ++ (CLEANUP_DECL): New macro. ++ (CLEANUP_EXPR): Likewise. ++ (emit_local_var): Likewise. ++ (finish_decl_cleanup): New function. ++ * cvt.c (build_up_reference): Simplify. ++ (ocp_convert): Remove dead code. ++ * decl.c (start_decl): Remove call to add_decl_stmt. ++ (grok_reference_init): Adjust, to handle bindings temporaries to ++ references. Remove dead code. ++ (initialize_local_var): Don't generate RTL for ++ declarations here, or build cleanups here. Don't fuss with ++ obstacks. Replace expand_start_target_temps calls with explicit ++ setting of stms_are_full_exprs_p. ++ (destroy_local_var): New function. ++ (emit_local_var): Likewise. ++ (cp_finish_decl): Use them, as appropriate. ++ (start_function): Announce template functions. ++ (store_parm_decls): Don't call declare_function_name here. ++ (finish_stmt): Don't start emit base-initialization code when just ++ building the statement-tree. ++ * init.c (create_temporary_var): Move add_decl_stmt call ... ++ (get_temp_regvar): Here. ++ * pt.c (tsubst_expr): Make DECL_INITIAL look like what ++ cp_finish_decl would expect. Don't call add_decl_stmt. ++ * semantics.c (begin_compound_stmt): Call declare_function_name, ++ if appropriate. ++ (finish_decl_cleanup): New function. ++ (expand_stmt): Use emit_local_var to output variables. ++ (expand_body): Set current_function_name_declared. ++ ++1999-09-10 Mark Mitchell ++ ++ * cp-tree.h (finish_cleanup_try_block): New function. ++ * semantics.c (finish_cleanup_try_block): Add comment. ++ ++Fri Sep 10 10:32:32 1999 Bernd Schmidt ++ ++ * cp-tree.h: Delete declarations for all tree nodes now moved to ++ global_trees. ++ * decl.c: Delete their definitions. ++ (SHORT_TYPE_SIZE, INT_TYPE_SIZE, LONG_TYPE_SIZE, LONG_LONG_TYPE_SIZE, ++ FLOAT_TYPE_SIZE, DOUBLE_TYPE_SIZE, LONG_DOUBLE_TYPE_SIZE): Don't ++ provide defaults. ++ (init_decl_processing): Call build_common_tree_nodes and ++ build_common_tree_nodes_2 instead of building their nodes here. ++ Don't add gc roots for them. ++ ++1999-09-10 Mark Mitchell ++ ++ * cp-tree.h (language_function): Rename expanding_p to ++ x_expanding_p. Rename named_label_uses to x_named_label_uses. ++ (expanding_p): Adjust accordingly. ++ (TREE_VIA_PRIVATE): Fix typo in comment. ++ (DECL_REFERENCE_SLOT): Remove. ++ (SET_DECL_REFERENCE_SLOT): Likewise. ++ * decl.c (named_label_uses): Adjust. Remove chicken comment. ++ (push_overloaded_decl): Don't truncate the chain of bindings when ++ adding an overloaded function. ++ (grok_reference_init): Don't use DECL_REFERENCE_SLOT. ++ (initialize_local_var): Fix typo in comment. ++ (store_parm_decls): Don't set DECL_REFERENCE_SLOT. Tidy up. ++ * decl2.c (start_objects): Make the fact that we are expanding ++ the generated function right away explicit. ++ (start_static_storage_duration_function): Likewise. ++ (finish_file): Fix typo in comment. ++ * init.c (build_vec_init): Correct bugs in handling cleanups. ++ * semantics.c (maybe_convert_cond): New function. ++ (FINISH_COND): Always store the condition, even if there's ++ a declaration. ++ (finish_if_stmt_cond): Use maybe_convert_cond. ++ (finish_while_stmt_cond): Likewise. ++ (finish_do_stmt): Likewise. ++ (finish_for_cond): Likewise. ++ (expand_cond): Adjust. ++ ++ * cp-tree.h (FN_TRY_BLOCK_P): New macro. ++ * init.c (perform_member_init): Remove obstack machinations. ++ (expand_cleanup_for_base): Likewise. ++ (finish_init_stmts): Mark the statement-expression as used. ++ * method.c (emit_thunk): Use tree-generating functions, not ++ RTL. ++ (do_build_copy_constructor): Likewise. ++ (do_build_assign_ref): Likewise. ++ (synthesize_method): Likewise. Keep track of line numbers. ++ * pt.c (tsubst_expr): Handle various kinds of try blocks. ++ * semantics.c (expand_stmts): Remove. ++ (begin_function_try_block): Set FN_TRY_BLOCK_P. ++ (finish_function_try_block): Be careful rechaining ++ function try blocks. ++ (expand_stmt): Loop through all the statements at a given level. ++ (exapnd_body): Be careful with line-numbers here too. Prepare for ++ being called directly from the parser. ++ ++ * cp-tree.h (finish_function): Adjust prototype. ++ * decl.c (finish_function): Return the function compiled. ++ * pt.c (instantiate_decl): Don't play games with obstacks. ++ * tree.c (mapcar): Handle OFFSET_REF and BIT_FIELD_REF. ++ (search_tree): Likewise. ++ * typeck.c: Fix typo in comment. ++ * typeck2.c (store_init_value): Add comment. ++ ++ * cp-tree.h (CPTI_ATEXIT): New macro. ++ (atexit_node): Likewise. ++ * decl.c (destroy_local_static): New function, broken out from ... ++ (expand_static_init): Here. ++ ++ * rtti.c (get_tinfo_var): These should always be global ++ (expand_si_desc): Use tree, not RTL, functions to generate code. ++ (expand_class_desc): Likewise. ++ (expand_ptr_desc): Likewise. ++ (expand_attr_desc): Likewise. ++ (expand_generic_desc): Likewise. ++ (synthesize_tinfo_fn): Likewise. ++ ++1999-09-09 Mark Mitchell ++ ++ * semantics.c (RECHAIN_STMTS): Remove `last' parameter. ++ (RECHAIN_STMTS_FROM_LAST): Remove. Replace all uses with ++ RECHAIN_STMTS. ++ (RECHAIN_STMST_FROM_CHAIN): Likewise. ++ ++ * parse.y (simple_stmt): Fix typo in last change. ++ ++ * cp-tree.h (EXPR_STMT_ASSIGNS_THIS): New macro. ++ (STMT_IS_FULL_EXPR_P): Likewise. ++ (STMT_LINENO_FOR_FN_P): Likewise. ++ (prep_stmt): New function. ++ (building_stmt_tree): Tweak for safety. ++ * pt.c (tsubst_expr): Use prep_stmt throughout. ++ (add_tree): Move it to semantics.c ++ * semantics.c (add_tree): Move it here. ++ (finish_expr_stmt_real): New function. ++ (finish_expr_stmt): Use it. ++ (finish_if_stmt_cond): Use FINISH_COND. ++ (finish_while_stmt_cond): Likewise. ++ (finish_for_cond): Likewise. ++ (finish_stmt_tree): Tweak line-number handling. ++ (prep_stmt): New function. ++ (expand_stmt): Use it. ++ ++ * cp-tree.h (begin_switch_stmt): Adjust prototype. ++ (finish_switch_cond): Likewise. ++ * parse.y (simple_stmt): Adjust accordingly. ++ * parse.c: Regenerated. ++ * pt.c (tsubst_expr): Adjust accordingly. ++ * semantics.c (expand_cond): New function. ++ (FINISH_COND): New macro. ++ (begin_switch_stmt): Build the SWITCH_STMT here. ++ (finish_switch_stmt_cond): Not here. ++ (expand_stmt): Adjust calls to begin_switch_stmt and ++ finish_switch_cond. Use expand_cond throughout. ++ ++ * dump.c (dequeue_and_dump): Dump types for constants. ++ Describe DECL_ARG_TYPE more intuitively. ++ Handle ARRAY_REF. ++ ++ * decl.c (lang_mark_tree): Mark TYPE_LANG_SPECIFIC. ++ (lang_cleanup_tree): Remove. ++ * lex.c (make_lang_type): Use ggc_alloc to allocate ++ TYPE_LANG_SPECIFIC. ++ ++ Reorganize per-function data. ++ * cp-tree.h (saved_scope): Add function_decl, bindings. ++ (language_function): Rename binding_level to bindings. ++ (cp_function_chain): Use the current_function, not the ++ outer_function_chain. ++ (current_class_ptr): Make it work, even when there's no ++ current function. ++ (current_class_ref): Likewise. ++ (SF_DEFAULT, SF_PRE_PARSED, SF_INCLASS_INLINE, SF_EXPAND): New ++ macros. ++ (clear_temp_name): Remove. ++ * decl.c (check_function_type): New function, broken out from ++ start_function. ++ (current_binding_level): Adjust definition. ++ (pushlevel): Simplify. ++ (poplevel): Don't use named_label_uses when we're outside ++ a function scope. ++ (mark_saved_scope): Mark function_decl and bindings. ++ (maybe_push_to_top_level): Don't unconditionally push a new ++ function context. Save bindings and the current_function_decl. ++ Don't clear named_labels. ++ (pop_from_top_level): Pop function context if appropriate. ++ (init_decl_processing): Set init_lang_status and free_lang_status, ++ rather than save_lang_status and restore_lang_status. ++ (start_function): Take SF_* flags. Don't clear per-function data. ++ Reorder and simplify to use new per-function data code. Add ++ asserts. ++ (store_parm_decls): Don't call init_function_start here. ++ (finish_function): Adjust for new handling of per-function data. ++ (push_cp_function_context): Simplify. ++ (mark_cp_function_context): Change binding_level to bindings. ++ * decl2.c (clear_temp_name): Remove. ++ (start_objects): Use SF flags to start_function. ++ (start_static_storage_duration_function): Likewise. ++ * except.c (start_anon_func): Remove redundant calls to ++ push_function_context_to. Use SF flags to start function. ++ (end_anon_func): Remove redundant call to pop_function_context ++ from. ++ * lex.c (reinit_parse_for_function): Don't initialize per-function ++ data. ++ * method.c (emit_thunk): Clear current_function after calling ++ assemble_end_function. Use SF flags for start_function. ++ (synthesize_method): Use SF flags for start_function. ++ * parse.c: Regenerated. ++ * parse.y (fn.defpen): Likewise. ++ (pending_inline): Clear current_function, even if something goes ++ wrong. ++ * pt.c (instantiate_decl): Use SF flags to start_function. ++ Don't save and restore expanding_p. ++ (add_tree): Handle the case where we are outside any function. ++ (end_tree): Likewise. ++ * rtti.c (sythesize_tinfo_fn): Use SF flags to start_function. ++ * semantics.c (begin_function_definition): Likewise. ++ (expand_body): Likewise. ++ ++1999-09-09 Nathan Sidwell ++ ++ * cp-tree.h (convert_to_void): Prototype new function. ++ (require_complete_type_in_void): Remove prototype. ++ * cvt.c (convert_to_void): New function. ++ (ocp_convert): Use convert_to_void. ++ * decl.c (cplus_expand_expr_stmt): Likewise, for complete ++ expressions. ++ * typeck.c (require_complete_type_in_void): Remove function. ++ (build_compound_expr): Use convert_to_void. ++ (build_static_cast): Likewise. ++ (build_c_cast): Likewise. ++ * semantics.c (finish_expr_stmt): Do not decay full expressions. ++ ++ * typeck.c (build_x_compound_expr): Add FIXME. ++ ++1999-09-08 Mark Mitchell ++ ++ * cp-tree.h (scratch_tree_cons): Remove. ++ * call.c: Replace all uses of expr_tree_cons, saveable_tree_cons, ++ and perm_tree_cons with plain tree_cons. ++ * class.c: Likewise. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * except.c: Likewise. ++ * expr.c: Likewise. ++ * init.c: Likewise. ++ * lex.c: Likewise. ++ * method.c: Likewise. ++ * parse.y: Likewise. ++ * pt.c: Likewise. ++ * repo.c: Likewise. ++ * rtti.c: Likewise. ++ * search.c: Likewise. ++ * typeck.c: Likewise. ++ * parse.c: Regenerated. ++ * tree.c (build_srcloc): Simplify. ++ ++1999-09-08 Bruce Korb autogen@linuxbox.com ++ ++ * Makefile.in: Give the gperf user a hint about why "gperf -F" fails. ++ ++1999-09-08 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Remove permanent_attr. ++ Remove next. ++ (LANG_DECL_PERMANENT): Remove. ++ * decl.c (duplicate_decls): Don't mess about with obstacks trying ++ to free memory. ++ (lang_mark_tree): Mark DECL_LANG_SPECIFIC. ++ * lex.c (free_lang_decl_chain): Remove. ++ (build_lang_decl): Don't use obstacks. ++ (retrofit_lang_decl): Likewise. ++ (copy_lang_decl): Likewise. ++ ++ * cp-tree.h (saved_scope): Remove old_binding_level and ++ function_decl. Tidy up. ++ * decl.c (mark_saved_scope): Don't set them. ++ (maybe_push_to_top_level): Clear memory. ++ ++ * decl.c (layout_var_decl): Change prototype. Don't complete ++ types for external objects. ++ (check_initializer): Likewise. Tidy. ++ (initialize_local_var): Complete types here. ++ (cp_finish_decl): Not here. Reorganize a little. ++ (grokvardecl): Don't complete types here. ++ ++ * decl.c (start_function): Clear last_dtor_insn and ++ last_parm_cleanup_insn. ++ (push_cp_function_context): Just copy over a little of ++ the old context, not all of it. ++ ++ * cp-tree.h (copy_to_permanent): Remove. ++ (permanent_p): Likewise. ++ * decl.c (building_typename_type): Don't use copy_to_permanent. ++ (start_decl): Likewise. ++ (grok_reference_init): Likewise. ++ (cp_finish_decl): Likewise. ++ * init.c (build_new_1): Don't use mapcar. ++ (build_vec_delete_1): Don't use copy_to_permanent. ++ (build_vec_init): Likewise. ++ * parse.y (primary): Likewise. ++ * parse.c: Regenerated. ++ * pt.c (push_template_decl_real): Don't use copy_to_permanent. ++ (lookup_template_class): Likewise. ++ (tsubst_friend_function): Likewise. ++ (instantiate_class_template): Likewise. ++ (tsubst_decl): Likewise. ++ (tsubst): Likewise. ++ (instantiate_template): Likewise. ++ (unify): Likewise. ++ * rtti.c (get_tinfo_fn): Likewise. ++ (build_dynamic_cast): Likewise. ++ * semantics.c (finish_if_stmt_cond): Likewise. ++ (finish_while_stmt_cond): Likewise. ++ (finish_do_stmt): Likewise. ++ (finish_for_cond): Likewise. ++ (finish_for_expr): Likewise. ++ (finish_cleanup): Likewise. ++ (add_decl_stmt): Likewise. ++ (finish_named_return_value): Likewise. ++ (finish_qualified_call_expr): Likewise. ++ * tree.c (perm_manip): Remove. ++ (build_exception_variant): Don't use copy_to_permanent. ++ (permanent_p): Remove. ++ (copy_to_permament): Remove. ++ (build_min_nt): Don't use copy_to_permanent. ++ (build_min): Likewise. ++ (min_tree_cons): Likewise. ++ * typeckc.c (build_static_cast): Likewise. ++ (build_reinterpret_cast): Likewise. ++ (build_const_cast): Likewise. ++ ++1999-09-07 Mark Mitchell ++ ++ * decl.c (ggc_p): Set it to 1. ++ (mark_saved_scope): Add prototype. ++ ++1999-09-07 Richard Henderson ++ ++ * cp-tree.h (C_PROMOTING_INTEGER_TYPE_P): Delete. ++ * typeck.c (self_promoting_args_p): Delete. ++ ++1999-09-07 Jason Merrill ++ ++ * search.c (binfo_for_vtable): Use CLASSTYPE_VFIELD_PARENT. ++ (dfs_bfv_queue_p, dfs_bfv_helper, struct bfv_info): Remove. ++ ++1999-09-07 Mark Mitchell ++ ++ * Makefile.in (tree.o): Depend on ggc.h. ++ * class.c (make_method_vec): Remove. ++ (free_method_vec): Likewise. ++ (free_method_vecs): Remove. ++ (add_method): Don't use them. ++ * cp-tree.def (PTRMEM_CST): Make it longer. ++ (TEMPLATE_PARM_INDEX): Make it shorter. ++ * cp-tree.h (BINDING_HAS_LEVEL_P): New macro. ++ (template_parm_index): Remove RTL field. ++ (ptrmem_cst): Add RTL field. ++ (finish_function): Removed parameter. ++ (process_next_inline): Change prototype. ++ (init_cplus_unsave): Rename to init_tree. ++ (binding_init): Remove. ++ * decl.c (free_binding_nodes): Remove. ++ (push_binding): Don't use them. Set BINDING_HAS_LEVEL_P. ++ (pop_binding): Don't use free_binding_nodes. ++ (free_binding_vecs): Remove. ++ (store_bindings): Don't use them. ++ (pop_from_top_level): Likewise. ++ (lookup_namespace_name): Simplify. ++ (build_typename_type): Don't use obstack_free. ++ (unqualified_namespace_lookup): Simplify. ++ (lookup_name_real): Simplify. ++ (start_function): Remove comment about leaks. ++ (finish_function): Removed nested parameter. Call ++ expand_end_bindings even when building_stmt_tree. ++ Call ggc_push_context and ggc_pop_context around ++ rest_of_compilation, if necessary. ++ (mark_cp_function_context): Handle a NULL language-context. ++ (lang_mark_false_label_stack): Fix typo. ++ (lang_mark_tree): Handle CPLUS_BINDING, OVERLOAD, ++ TEMPLATE_PARM_INDEX. Handle the funny TYPE_LANG_SPECIFIC on ++ pointer to method types. ++ (lang_cleanup_tree): Use free to free TYPE_LANG_SPECIFIC. ++ * decl2.c (finish_objects): Adjust call to finish_function. ++ (finish_static_store_duration_function): Likewise. ++ (do_nonmember_using_decl): Remove call to binding_init. ++ * except.c (end_anon_func): Adjust call to finish_function. ++ * lex.c (mark_impl_file_chain): New function. ++ (init_parse): Call init_tree, not init_cplus_unsave. ++ Add GC roots. ++ (cp_pramga_interface): Use xmalloc, not permalloc. ++ (cp_pragma_implementation): Likewise. ++ (begin_definition_of_inclass_inline): Simplify. ++ (process_next_inline): Adjust prototype. ++ (do_scoped_id): Don't call binding_init. ++ (make_lang_type): Allocate TYPE_LANG_SPECIFIC with xmalloc. ++ * method.c (emit_thunk): Adjust call to finish_function. ++ (synthesize_method): Likewise. ++ * parse.y (%union): Add a new `pi' variant. ++ (PRE_PARSED_FUNCTION_DECL): Use it. ++ (fn.defpen): Likewise. ++ (fndef): Adjust call to finish_function. ++ * pt.c (instantiate_decl): Likewise. ++ * rtti.c (syntheisze_tinfo_fn): Likewise. ++ * semantics.c (expand_body): Likewise. ++ * tree.c: Include ggc.h. ++ (mark_list_hash): New function. ++ (binding_init): Remove. ++ (init_cplus_unsave): Rename to ... ++ (init_tree): This. Add GC roots. ++ ++1999-09-05 Mark Mitchell ++ ++ Get ready for garbage collection. ++ * Makefile.in (CXX_TREE_H): Add varray.h ++ (lex.o): Depend on ggc.h. ++ (decl.o): Likewise. ++ (decl2.o): Likewise. ++ (method.o): Likewise. ++ (search.o): Likewise. ++ (pt.o): Likewise. ++ (repo.o): Likewise. ++ * class.c: Include ggc.h. ++ (current_class_name): Remove. ++ (current_class_type): Likewise. ++ (current_access_specifier): Likewise. ++ (previous_class_type): Likewise. ++ (previous_class_values): Likewise. ++ (class_cache_firstobj): Likewise. ++ (current_lang_base): Likewise. ++ (current_lang_stack): Likewise. ++ (current_lang_stacksize): Likewise. ++ (lang_name_c): Likewise. ++ (lang_name_cplusplus): Likewise. ++ (lang_name_java): Likewise. ++ (current_lang_name): Likewise. ++ (base_layout_decl): Likewise. ++ (access_default_node): Likewise. ++ (access_public_node): Likewise. ++ (access_protected_node): Likewise. ++ (access_private_node): Likewise. ++ (access_default_virtual_node): Likewise. ++ (access_public_virtual_node): Likewise. ++ (access_protected_virtual_node): Likewise. ++ (access_private_virtual_node): Likewise. ++ (signed_zero_node): Likewise. ++ (init_class_processing): Don't build base_layout_decl. ++ (push_lang_context): Adjust now that current_lang_base is a varray. ++ (pop_lang_context): Likewise. ++ * cp-tree.h: Include varray.h. ++ (cp_global_trees): Add access_default, access_public, ++ access_protected, access_private, access_default_virtual, ++ access_public_virtual, access_protected_virtual, ++ access_private_virtual, ctor_identifier, delta2_identifier, ++ delta_identifier, dtor_identifier, in_charge_identifier, ++ index_identifier, nelts_identifier, this_identifier, ++ pfn_identifier, pfn_or_delta2_identifier, vptr_identifier, ++ lang_name_c, lang_name_cplusplus, lang_name_java, ++ empty_except_spec, null, jclass, minus_one, terminate. ++ (saved_scope): Move here from decl.c. Define globals in terms of ++ saved_scope: current_namespace, current_class_name, ++ current_class_type, current_access_specifier, current_lang_stack, ++ current_lang_base, current_lang_name, current_function_parms, ++ current_template_parms, processing_template_decl, ++ processing_specialization, processing_explicit_instantiation, ++ previous_class_type, previous_class_values, class_cache_firstobj. ++ (scope_chain): New variable. ++ (init_pt): New function. ++ * decl.c (current_namespace): Remove. ++ (this_identifier, in_charge_identifier, ctor_identifier): Likewise. ++ (dtor_identifier, pfn_identifier, index_identifier): Likewise. ++ (delta_identifier, delta2_identifier): Likewise. ++ (pfn_or_delta2_identifier, tag_identifier): Likewise ++ (vt_off_identifier, empty_except_spec, null_node): Likewise. ++ (current_function_parms, current_lang_base): Remove. ++ (current_lang_stack, previous_class_values): Remove. ++ (class_binding_level): Macroize. ++ (saved_scope): Remove. ++ (current_saved_scope): Rename to scope_chain. ++ (mark_saved_scope): Adjust for new scope structure. ++ (maybe_push_to_top_level): Likewise. ++ (pop_from_top_level): Likewise. ++ (duplicate_decls): Adjust now that current_lang_base is a varray. ++ (build_typename_type): Call ggc_add_tree_hash_table_root. ++ (init_decl_processing): Call init_pt. Call push_to_top_level to ++ set up globals. Add GC roots. ++ (xref_basetypes): Adjust now that current_lang_base is a varray. ++ * decl.h (this_identifier): Remove. ++ (in_charge_identifier): Likewise. ++ * decl2.c: Don't include varray.h. ++ (current_namespace): Remove. ++ (init_decl2): Add GC roots. ++ * except.c (Terminate): Remove. ++ (init_exception_processing): Use terminate_node instead. ++ (build_terminate_handler): Likewise. ++ * init.c (nc_nelts_field_id): Remove. ++ (minus_one): Likewise. ++ (init_init_processing): Use minus_one_node and nelts_identifier ++ instead. Add GC roots. ++ (jclass_node): Remove. ++ (build_new_1): Use nelts_identifier. ++ (build_vec_init): Likewise. ++ (build_vec_delete): Likewise. ++ * lex.c: Include ggc.h. ++ (defarg_fn): Move declaration early. ++ (defarg_parms): Likewise. ++ (init_parse): Add GC roots. ++ (handle_cp_pragma): Remove redundant declaration of ++ pending_vtables. ++ * method.c: Include ggc.h. ++ (btypelist): Make it a varray. All uses changed. ++ (ktypelist): Likewise. ++ (init_method): Add GC roots. ++ * pt.c: Don't include varray.h. Include ggc.h. ++ (current_template_parms): Remove. ++ (processing_template_decl): Likewise. ++ (processing_specialization): Likewise. ++ (processing_explicit_instantiation): Likewise. ++ (init_pt): New function. ++ * repo.c: Include ggc.h. ++ (init_repo): Add GC roots. ++ * search.c: Don't include varray.h. ++ (_vptr_name): Remove. ++ (lookup_field_1): Use vtpr_identifier instead. ++ (expand_indirect_vtbls_init): Remove redundant declaration of ++ in_charge_identifier. ++ (init_search_processing): Use vptr_identifier. ++ ++1999-09-05 Richard Henderson ++ Bernd Schmidt ++ Mark Mitchell ++ ++ * Makefile.in (parse.o): Depend on ggc.h. ++ (decl2.o): Depend on ggc.h. ++ (init.o): Depend on ggc.h. ++ * cp-tree.h (init_decl2): Declare. ++ (cp_parse_init): Likewise. ++ * decl.c (ggc_p): Define to zero. ++ (mark_saved_scope): New function. ++ (init_decl_processing): Call cp_parse_init, and cp_decl2. ++ Register GC roots. ++ (expand_static_init): Add GC roots. ++ * decl2.c: Include ggc.h. ++ (init_decl2): New function. ++ * init.c: Include ggc.h. ++ (init_init_processing): Add GC roots. ++ * parse.y: Include ggc.h. ++ (cp_parse_init): New function. ++ ++1999-09-04 Mark Mitchell ++ ++ * decl.c (init_decl_processing): Set mark_lang_status. ++ (lang_mark_false_label_stack): Adjust prototype. ++ * decl2.c (grok_function_init): Remove extraneous declaration of ++ abort_fndecl. ++ ++ * Make-lang.in (cc1plus): Remove dependency on GGC. ++ * Makefile.in (OBJS): Don't mention ggc-simple.o. ++ (OBJDEPS): Don't mention ggc-simple.o. ++ ++ * Make-lang.in (cc1plus): Depend on $(GGC). ++ * Makefile.in (OBJS): Add ggc-simple.o. ++ (OBJDEPS): Likewise. ++ * cp-tree.h (language_function): Rename members to `x_' versions; ++ we now have x_named_labels, x_ctor_label, x_dtor_label, ++ x_base_init_list, x_member_init_list, x_base_init_expr, ++ x_current_class_ptr, x_current_class_ref, x_last_tree, ++ x_last_expr_type, x_last_dtor_insn, x_last_parm_cleanup_insn, and ++ x_result_rtx. ++ (dtor_label, ctor_label, current_base_init_list, ++ current_member_init_list, base_init_expr, current_class_ptr, ++ current_class_ref, last_tree, last_expr_type): Adjust accordingly. ++ * decl.c: Include ggc.h. ++ (last_dtor_insn): Adjust to use x_ names. ++ (last_parm_cleanup_insn): Likewise. ++ (original_result_rtx): Likewise. ++ (named_labels): Likewise. ++ (mark_binding_level): New function. ++ (mark_cp_function_context): Likewise. ++ (mark_false_label_stack): Likewise. ++ (lang_mark_tree): Likewise. ++ (lang_cleanup_tree): Likewise. ++ ++1999-09-03 Mark Mitchell ++ ++ * Makefile.in (CXX_TREE_H): Include function.h. ++ (decl.o): Don't depend on function.h. ++ (decl2.o): Likewise. ++ (typeck.o): Likewise. ++ (init.o): Likewise. ++ (method.o): Likewise. ++ * cp-tree.h: Include function.h. ++ (cp_function): Rename to language_function. Remove next. ++ (cp_function_chain): Make it a macro, not a variable. ++ (push_cp_function_context): Don't declare. ++ (pop_cp_function_context): Likewise. ++ * decl.c: Don't include function.h. ++ (push_cp_function_context): Make it static. Make it suitable for ++ a save_lang_status callback. ++ (pop_cp_function_context): Likewise. ++ (maybe_push_to_top_level): Call push_function_context_to, not ++ push_cp_function_context. ++ (pop_from_top_level): Call pop_function_context_from, not ++ pop_cp_function_context. ++ (init_decl_processing): Set save_lang_status and ++ restore_lang_status. Call push_function_context_to, not ++ push_cp_function_context. ++ (cp_function_chain): Remove. ++ * decl2.c: Don't include function.h. ++ * except.c: Don't include function.h. ++ (start_anon_func): Call push_function_context_to, not ++ push_cp_function_context. ++ (end_anon_func): Call pop_function_context_from, not ++ pop_cp_function_context. ++ * init.c: Don't include function.h. ++ * lex.c (begin_definition_of_inclass_inline): Call ++ push_function_context_to, not push_cp_function_context. ++ (process_next_inline): Call pop_function_context_from, not ++ pop_cp_function_context. ++ * method.c: Don't include function.h. ++ (synthesize_method): Call push_function_context_to, not ++ push_cp_function_context. Call pop_function_context_from, not ++ pop_cp_function_context. ++ * typeck.c: Don't include function.h. ++ ++ * decl.c (expand_static_init): Tweak handling of static ++ initializations for objects without constructors. ++ ++1999-09-03 Nathan Sidwell ++ ++ * typeck.c (build_indirect_ref): Reject dereference of pointer to ++ void. ++ ++1999-09-02 Mark Mitchell ++ ++ * cp-tree.h (cp_function): Move here, from decl.c. ++ (cp_function_chain): Declare. ++ (dtor_label): New macro, instead of variable. ++ (ctor_label): Likewise. ++ (current_base_init_list): Likewise. ++ (current_member_init_list): Likewise. ++ (base_init_expr): Likewise. ++ (current_class_ptr): Likewise. ++ (current_class_ref): Likewise. ++ (last_tree): Likewise. ++ (last_expr_type): Likewise. ++ (current_function_returns_value): Likewise. ++ (current_function_returns_null): Likewise. ++ (current_function_just_assigned_this): Likewise. ++ (current_function_parms_stored): Likewise. ++ (temp_name_counter): Likewise. ++ (static_labelno): Likewise. ++ (expanding_p): Likewise. ++ (stmts_are_full_exprs_p): Likewise. ++ (in_function_try_handler): Likewise. ++ (lang_type): Remove nested type_flags. All uses changed. ++ * call.c (ctor_label): Remove. ++ (dtor_label): Likewise. ++ * class.c (current_class_ptr): Remove. ++ (current_class_ref): Likewise. ++ * decl.c (static_labelno): Remove. ++ (dtor_label): Likewise. ++ (last_dtor_insn): New macro, instead of variable. ++ (last_parm_cleanup_insn): Likewise. ++ (original_result_rtx): Likewise. ++ (in_function_try_handler): Remove. ++ (named_label_uses): New macro, instead of variable. ++ (named_labels): Likewise. ++ (current_function_returns_value): Remove. ++ (current_function_returns_null): Likewise. ++ (current_function_assigns_this): New macro, instead of variable. ++ (current_function_just_assigned_this): Likewise. ++ (current_binding_level): Likewise. ++ (init_decl_processing): Call push_cp_function_context. ++ (cp_function): Move to cp-tree.h ++ (cp_function_chain): Make it global. ++ (temp_name_counter): Remove. ++ (push_cp_function_context): Simplify. ++ (pop_cp_function_context): Likewise. ++ * decl2.c (temp_name_counter): Remove. ++ * init_c (current_base_init_list): Likewise. ++ (current_member_init_list): Likewise. ++ (base_init_expr): Likewise. ++ * method.c (static_labelno): Likewise. ++ * pt.c (last_tree): Likewise. ++ * semantics.c (expanding_p): Likewise. ++ (stmts_are_full_exprs_p): Likewise. ++ (last_expr_type): Likewise. ++ * typeck.c (dtor_label): Likewise. ++ (ctor_label): Likewise. ++ ++1999-09-01 Alex Samuel ++ ++ * decl2.c (arg_assoc_template_arg): New prototype. New function. ++ (arg_assoc_class): Use arg_assoc_template_arg for template ++ arguments. ++ (arg_assoc): Likewise. ++ * pt.c (mangle_class_name_for_template): Allow member template ++ template arguments. ++ ++1999-09-02 Nathan Sidwell ++ ++ * call.c (build_conditional_expr): Warn on enum mismatches. ++ (convert_arg_to_ellipsis): Move non-pod check to after ++ conversion. ++ ++1999-09-01 Kaveh R. Ghazi ++ ++ * gxx.gperf (hash, is_reserved_word): Add prototypes. ++ ++ * init.c (build_vec_init): Initialize variable `try_block'. ++ ++ * lex.c (init_parse): Call memcpy, not bcopy, to avoid casts. ++ Likewise for bzero/memset. ++ (token_getch, token_put_back): Add static prototypes. Remove ++ `inline' from the definitions. ++ (retrofit_lang_decl): Call memset, not bzero, to avoid casts. ++ ++1999-09-01 Mark Mitchell ++ ++ * cp-tree.h (lang_type): Move align into type_flags. ++ (CLASSTYPE_ALIGN): Adjust accordingly. ++ * call.c (direct_reference_binding): Remove misleading comment. ++ ++1999-08-30 Kaveh R. Ghazi ++ ++ * parse.y (language_string): Constify. ++ ++1999-08-30 Kaveh R. Ghazi ++ ++ * repo.c (getpwd): Don't prototype. ++ * xref.c (getpwd): Likewise ++ ++1999-08-30 Kaveh R. Ghazi ++ ++ * Makefile.in (LIBS, LIBDEPS): Link with & depend on libiberty.a. ++ Remove hacks for stuff which now comes from libiberty. ++ ++1999-08-30 Jason Merrill ++ ++ * cp-tree.h (IS_AGGR_TYPE_2): Fix typo. ++ ++1999-08-30 Mark Mitchell ++ ++ * cp-tree.h (begin_init_stmts): Declare. ++ (finish_init_stmts): Likewise. ++ * cvt.c (build_up_reference): Wrap the declaration of a temporary ++ in a statement-expression so that we will see it when expanding ++ tree structure later. ++ * init.c (begin_init_stmts): Don't make it static. ++ (finish_init_stmts): Likewise. ++ ++ * cp-tree.h (start_handler_parms): New function. ++ (expand_start_catch_block): Take only one parameter. ++ (start_handler_parms): New function. ++ * decl.c (start_handler_parms): Define it. ++ * except.c (process_start_catch_block): Take only one parameter. ++ Don't call grokdeclarator here. ++ (expand_start_catch_block): Don't call grokdeclarator here, ++ either. ++ * parse.y (handler_args): Adjust call to ++ expand_start_catch_block. Use start_handler_parms. ++ * pt.c (push_template_decl_real): Make permanent lists have ++ permanent elements. ++ (tsubst_expr): Adjust calls to expand_start_catch_block ++ appropriately. ++ * semantics.c (expand_stmt): Likewise. ++ ++1999-08-29 Alex Samuel ++ ++ * pt.c (push_template_decl_real): Use template declaration from ++ class type if it exists. ++ ++1999-08-29 Mark Mitchell ++ ++ * cp-tree.h (TYPE_NEEDS_CONSTRUCTING): Remove #if 0'd definition. ++ (maybe_inject_for_scope_var): Declare it. ++ (initialize_local_var): Likewise. ++ * decl.c (maybe_inject_for_scope_var): Make it global. ++ (initialize_local_var): Likewise. Move cleanup handling here, ++ from cp_finish_decl. ++ (make_rtl_for_nonlocal_decl): Use ++ push_obstacks_nochange/pop_obstacks, rather than ++ end_temporary_allocation/resume_temporary_allocation. ++ (cp_finish_decl): Try to complete the type of a variable when it ++ is declared. Move cleanup-handling to initialize_local_var. ++ (expand_static_init): Use tree-building code, rather than ++ RTL-building code. ++ * decl2.c (get_temp_name): Assert non-initializedness of ++ temporaries. ++ * init.c (create_temporary_var): Move RTL-assigning code to ... ++ (get_temp_regvar): Here. ++ * pt.c (tsbust_expr): Fix indentation. Call cp_finish_decl here. ++ * semantics.c (expand_stmt): Don't call cp_finish_decl here. Just ++ call initialize_local_var to generate initialization code. ++ ++1999-08-29 Kaveh R. Ghazi ++ ++ * cp-tree.h (fndecl_as_string, type_as_string, ++ type_as_string_real, args_as_string, decl_as_string, ++ expr_as_string, code_as_string, language_as_string, ++ parm_as_string, op_as_string, assop_as_string, cv_as_string, ++ lang_decl_name, cp_file_of, lang_printable_name): Constify a char*. ++ ++ * errfn.c (cp_printer): Likewise. ++ ++ * error.c (cp_printer, fndecl_as_string, type_as_string_real, ++ type_as_string, expr_as_string, decl_as_string, lang_decl_name, ++ cp_file_of, code_as_string, language_as_string, parm_as_string, ++ op_as_string, assop_as_string, args_as_string, cv_as_string): ++ Likewise. ++ ++ * tree.c (lang_printable_name): Likewise. ++ ++1999-08-28 Richard Henderson ++ ++ * decl2.c (arg_assoc_class): Bail if the class is a builtin type. ++ ++1999-08-28 Mark Mitchell ++ ++ * cp-tree.h (strip_array_types): New function. ++ * decl.c (maybe_deduce_size_from_array_init): New function, split ++ out from cp_finish_decl. ++ (layout_var_decl): Likewise. ++ (maybe_commonize_var): Likewise. ++ (maybe_inject_for_scope_var): Likewise. ++ (initialize_local_var): Likewise. ++ (build_cleanup_on_safe_obstack): Likewise. ++ (check_initializer): Likewise. ++ (make_rtl_for_nonlocal_decl): Likewise. ++ (cp_finish_decl): Use them. ++ * typeck.c (strip_array_types): New function. ++ ++ * cp-tree.def (LABEL_STMT): New tree node. ++ * cp-tree.h (LABEL_STMT_LABEL): New macro. ++ (shadow_label): Remove. ++ (declare_local_label): New function. ++ (finish_label_decl): Likewise. ++ * decl.c (make_label_decl): New function, split out from ++ lookup_label. ++ (shadowed_labels): Remove. ++ (binding_level): Add shadowed_labels. ++ (clear_binding_level): Remove. ++ (push_binding_level): Just bzero the new binding level. ++ (pushlevel): Fix indentation. ++ (pop_label): New function. ++ (pop_labels): Likewise, split out from poplevel. ++ (poplevel): Pop local labels. Use pop_labels. ++ (maybe_push_to_top_level): Don't clear shadowed_labels. ++ (lookup_label): Use make_label_decl. ++ (shadow_label): Remove. ++ (declare_local_label): New function. ++ (define_label): Simplify. ++ (start_function): Don't clear shadowed_labels. ++ (cp_function): Remove shadowed_labels. ++ (push_cp_function_context): Don't save shadowed_labels. ++ (pop_cp_function_context): Don't restore it. ++ * dump.c (dequeue_and_dump): Handle LABEL_STMT. ++ * parse.y (label_decl): Use finish_label_decl. ++ * pt.c (tsubst_expr): Handle LABEL_STMTs, and local label ++ declarations. ++ * semantics.c (finish_label_stmt): Add a LABEL_STMT when ++ building_stmt_tree. ++ (finish_label_decl): New function. ++ (expand_stmt): Handle LABEL_STMTs and local label declarations. ++ ++1999-08-26 Mark Mitchell ++ ++ * decl.c (lookup_label): Build labels on the permanent obstack ++ when building statement trees. Don't build RTL for labels when ++ building statement trees. ++ * semantics.c (finish_goto_stmt): Use LABEL_DECLs even when ++ building statement trees. ++ (finish_label_stmt): Likewise. ++ (expand_stmt): Adjust accordingly. ++ * pt.c (tsubst_expr); Likewise. ++ (do_decl_instantiation): Robustify. ++ ++ * cp-tree.h (AGGR_INIT_VIA_CTOR_P): New macro. ++ * tree.c (build_cplus_new): Set it. ++ * expr.c (cplus_expand_expr): Use it. ++ * dump.c (deque_and_dump): Handle AGGR_INIT_EXPR. ++ ++ * decl.c (store_parm_decls): Reset immediate_size_expand. ++ (finish_function): Likewise. ++ ++ * tree.c (cplus_unsave_expr_now): Don't return a value. ++ ++ * semantics.c (do_poplevel): Always initialize the return value. ++ ++1999-08-26 Gavin Romig-Koch ++ ++ * cp-tree.h (cplus_unsave_expr_now) : Correct return type. ++ * tree.h (cplus_unsave_expr_now) : Same. ++ ++1999-08-25 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Amend comment. ++ * except.c (expand_start_catch_block): Call push_template_decl for ++ catch-block parameters. ++ * method.c (synthesize_method): Build an empty compound statement ++ for the body of a constructor. ++ ++1999-08-25 Jason Merrill ++ ++ * tree.c (cp_build_qualified_type_real): If we're asking for the ++ same quals we already have, just return. ++ ++1999-08-25 Mark Mitchell ++ ++ * cp-tree.def (SUBOBJECT): New tree node. ++ * cp-tree.h (CLEANUP_P): New macro. ++ (SUBOBJECT_CLEANUP): Likewise. ++ (keep_next_level): Add parameter. ++ (get_temp_regvar): Don't declare. ++ (emit_base_init): Remove parameter. ++ (expand_aggr_init): Rename to build_aggr_init. ++ (expand_vec_init): Rename to build_vec_init. ++ (do_pushlevel): Remove. ++ (do_poplevel): Likewise. ++ (finish_cleanup): New function. ++ (finish_subobject): Likewise. ++ (stmts_are_full_exprs_p): New variable. ++ * decl.c (keep_next_level): Add parameter. ++ (cp_finish_decl): Use build_aggr_init, not ++ expand_aggr_init. Use finish_expr_stmt to expand the code. ++ (expand_static_init): Use tree-generating, not RTL-generating, ++ functions to handle the initialization. ++ (start_function): Remove dead code. Always have a momentary ++ obstack inside the function, even before hitting the first curly ++ brace. ++ (cplus_expand_expr_stmt): Move calls to ++ expand_{start,end}_target_temps into semantics.c. ++ (cp_function): Add stmts_are_full_exprs_p. ++ (push_cp_function_context): Save it. ++ (pop_cp_function_context): Restore it. ++ * decl2.c (get_temp_regvar): Move to init.c. ++ (do_static_initialization): Use build_{aggr,vec}_init. ++ (do_static_destruction): Fix typo in comment. ++ * dump.c (dequeue_and_dump): Handle INIT_EXPR. ++ * except.c (expand_throw): Use create_temporary_var. ++ * expr.c (cplus_expand_expr): Use build_{aggr,vec}_init. ++ * init.c (expand_vec_init_try_block): Remove. ++ (expand_vec_init_catch_clause): Likewise. ++ (get_temp_regvar): New function. ++ (begin_init_stmts): Likewise. ++ (finish_init_stmts): Likewise. ++ (perform_member_init): Use build_{aggr,vec}_init. Build up tree ++ structure here. ++ (emit_base_init): Likewise. Remove unused parameter. ++ (expand_virtual_init): Likewise. ++ (expand_cleanup_for_base): Use finish_subobject. ++ (expand_aggr_vbase_init_1): Simplify. ++ (construct_virtual_bases): Use tree-generating functions to build ++ up initialization. ++ (expand_aggr_init): Likewise. Rename to build_aggr_init. ++ (expand_default_init): Likewise. ++ (expand_aggr_init_1): Likewise. ++ (expand_vec_init): Rename to build_vec_init. ++ * method.c (do_build_copy_constructor): Use tree-generating ++ functions. Don't call clear_last_expr. ++ (do_build_assign_ref): Likewise. ++ (synthesize_method): Call clear_last_expr here. ++ * parse.y (base_init): Don't call clear_last_expr here. ++ (nodecls): Likewise. ++ * pt.c (tsubst_expr): Handle a TRY_BLOCK with CLEANUP_P set. ++ * semantics.c (do_pushlevel): Move to here. ++ (do_poplevel): Likewise. ++ (stmts_are_full_exprs_p): New variable. ++ (finish_expr_stmt): Handle logic for temoprary cleanup here. ++ (finish_for_stmt): Use finish_expr_stmt. ++ (finish_cleanup): New function. ++ (finish_function_try_block): Fix indentation. ++ (finish_subobject): New function. ++ (setup_vtbl_ptr): Call keep_next_level here. ++ (finish_stmt_expr): Handle a block with no scope inside the ++ statement-expression. ++ (expand_stmt): Handle a TRY_BLOCK with CLEANUP_P set. Handle ++ SUBOBJECT. ++ * tree.c (search_tree): Handle INIT_EXPR. ++ (mapcar): Likewise. ++ * typeck.c (build_modify_expr): Don't build an RTL_EXPR. ++ * typeck2.c (store_init_value): Change expand_aggr_init to ++ build_aggr_init in comment. ++ ++1999-08-25 Mark Mitchell ++ ++ * dump.c (dequeue_and_dump): Dump TARGET_EXPRs. ++ ++1999-08-25 Nathan Sidwell ++ ++ * decl2.c (handle_class_head): Be graceful about additional ++ scope qualifiers. Adjust comments to reflect reality. ++ ++1999-08-24 Jason Merrill ++ ++ * call.c (build_conditional_expr): Fix typo. ++ * typeck.c (build_modify_expr, COND_EXPR): Make sure we've got an ++ lvalue before trying to mess with the sides. ++ ++ * error.c (dump_expr, CONVERT_EXPR): Handle (void) properly. ++ ++Mon Aug 23 22:17:20 1999 Mumit Khan ++ ++ * g++spec.c (lang_specific_driver): Add room for NULL in arglist. ++ ++1999-08-23 Jason Merrill ++ ++ * exception.cc (__cplus_type_matcher): Call __throw_type_match_rtti_2. ++ Return arbitrary pointer or NULL. ++ (check_eh_spec): Call __throw_type_match_rtti_2. ++ * tinfo.h (*::dcast): Return int. Add valp parm. ++ * tinfo.cc (*::dcast): Likewise. Adjust to allow for null pointers. ++ * tinfo2.cc (__throw_type_match_rtti_2): Likewise. ++ (__throw_type_match_rtti): Now just a wrapper. ++ ++ * except.c: Lose CatchMatch, FirstExceptionMatch, and Unwind. ++ (init_exception_processing): Don't initialize them. ++ ++1999-08-23 Paul Burchard ++ ++ * decl.c (check_default_argument): Fix typo. ++ ++1999-08-22 Mark Mitchell ++ ++ * cp-tree.def (STMT_EXPR): Fix typo in node name. ++ ++ * dump.c (dump_next_stmt): New function. ++ (dequeue_and_dump): Use it. ++ ++ * pt.c (tsubst_copy): Make sure to initialize return value for a ++ STMT_EXPR, even when processing_template_decl. ++ * semantics.c (finish_stmt_expr): A statement-expression whose ++ last statement is not an expression-statement has type `void'. ++ ++1999-08-20 Mark Mitchell ++ ++ * semantics.c (finish_stmt_expr): Fix typo in comment. ++ * tree.c (search_tree): Handle EXIT_EXPR, LOOP_EXPR. ++ (mapcar): Likewise. ++ * init.c (build_vec_delete_1): Make the children of a permanent ++ BIND_EXPR permanent. ++ * pt.c (register_specialization): Don't register a specialization ++ more than once. ++ ++1999-08-18 Andrew Haley ++ ++ * method.c (process_overload_item): Call build_mangled_C9x_name () ++ for all integer parameter types larger than long long. ++ ++1999-08-19 Mark Mitchell ++ ++ * pt.c (redeclare_class_template): Merge default template ++ arguments in both directions. ++ ++ * typeck.c (common_type): Undo 1999-08-18 change. Remove ++ compiler_error message. ++ ++1999-08-19 Jason Merrill ++ ++ * cp-tree.h: Declare flag_use_repository. ++ * pt.c (do_decl_instantiation): Don't complain about duplicate ++ instantiation with -frepo. ++ (do_type_instantiation): Likewise. ++ ++ * pt.c (push_template_decl_real): Complain about everything ++ that isn't a valid template. ++ ++ * decl2.c (import_export_decl): If -fnew-abi, class linkage doesn't ++ affect inlines. ++ ++1999-08-19 Mark Mitchell ++ ++ * cp-tree.def (PSEUDO_DTOR_EXPR): New tree code. ++ * decl2.c (build_expr_from_tree): Handle it. ++ * error.c (dump_expr): Likewise. ++ * pt.c (for_each_template_parm): Likewise. ++ (tsubst_copy): Likewise. ++ * tree.c (search_tree): Likewise. ++ * semantics.c (finish_pseudo_destructor_call): Create it. ++ ++1999-08-18 Mark Mitchell ++ ++ * search.c (setup_class_bindings): Robustify. ++ * typeck.c (common_type): Use same_type_p, not pointer equality, ++ to compare types. ++ ++ * cp-tree.h (build_lang_field_decl): Remove. ++ * class.c (build_vtable): Replace calls to build_lang_field_decl ++ with build_lang_decl. ++ (prepare_fresh_vtable): Likewise. ++ (finish_struct_1): Likewise. ++ (init_class_processing): Likewise. ++ * decl.c (push_using_decl): Likewise. ++ (init_decl_processing): Likewise. ++ (grokvardecl): Likewise. ++ (build_ptrmemfunc_type): Likewise. ++ (grokdeclarator): Likewise. ++ (build_enumerator): Likewise. ++ * decl2.c (grok_x_components): Likewise. ++ (do_class_using_decl): Likewise. ++ * except.c (call_eh_info): Likewise. ++ * init.c (init_init_processing): Likewise. ++ * rtti.c (expand_class_decl): Likewise. ++ * tree.c (build_base_fields): Likewise. ++ (build_vbase_pointer_fields): Likewise. ++ * lex.c (build_lang_decl): Build declarations on the permanent ++ obstack if we're building statmeent trees. ++ (retrofit_lang_decl): Handle both the full lang_decl and also the ++ smaller lang_decl_flags here. ++ (build_lang_field_decl): Remove. ++ * pt.c (push_template_decl_real): Issue errors for variable ++ declarations that are not static members. ++ ++1999-08-18 Richard Henderson ++ ++ * tree.c (search_tree): Handle TRUTH_{AND,OR,XOR}_EXPR too. ++ (mapcar): Likewise. ++ ++1999-08-17 Mark Mitchell ++ ++ * cp-tree.h (back_end_hook): New variable. ++ * decl2.c (back_end_hook): Define it. ++ (finish_file): If it's non-NULL, call it. ++ ++ * decl.c (add_decl_to_level): New function. ++ (push_local_binding): Use it. ++ (find_binding): Fix typo in comment. ++ (pushdecl): Use add_decl_to_level. Put templates on the ++ corresponding namespace-scope binding levels. ++ * dump.c (dequeue_and_dump): Print the specializations of a ++ template. ++ * pt.c (push_template_decl_real): Don't push a template multiple ++ times. ++ ++1999-08-17 Mark Mitchell ++ ++ * cp-tree.h (CALL_DECLARATOR_PARMS): New macro. ++ (CALL_DECLARATOR_QUALS): Likewise. ++ (CALL_DECARATOR_EXCEPTION_SPEC): Likewise. ++ * decl.c (grokdeclarator): Adjust to use them. ++ * decl2.c (grokfield): Likewise. ++ (reparse_absdcl_as_casts): Likewise. ++ * lex.c (make_call_declarator): Likewise. ++ (set_quals_and_spec): Likewise. ++ * pt.c (tsubst): Likewise. ++ * tree.c (mapcar): Remove special hack to handle third operand of ++ a CALL_EXPR. ++ ++1999-08-16 Mark Mitchell ++ ++ * cp-tree.h (CAN_HAVE_FULL_LANG_DECL_P): New macro. ++ * class.c (build_vtable): Use build_lang_field_decl to build the ++ VAR_DECLs for vtables. ++ (prepare_fresh_vtable): Likewise. ++ * decl.c (duplicate_decls): Only copy DECL_SAVED_TREE if ++ CAN_HAVE_FULL_LANG_DECL_P. ++ (push_using_decl): Use build_lang_decl to build USING_DECLs. ++ (grokdeclarator): Use build_lang_decl to build TYPE_DECLs. ++ * lex.c (retrofit_lang_decl): Check CAN_HAVE_FULL_LANG_DECL_P. ++ (build_lang_field_decl): Likewise. ++ (copy_lang_decl): Use CAN_HAVE_FULLLANG_DECL_P to decide how much ++ to copy. ++ ++ * cp-tree.def (STMT_EXPR): New tree node. ++ * cp-tree.h (STMT_EXPR_STMT): New macro. ++ (store_return_init): Change prototype. ++ (finish_named_return_value): New function. ++ (expand_stmt): Likewise. ++ (expand_body): Likewise. ++ (begin_stmt_tree): Likewise. ++ (finish_stmt_tree): Likewise. ++ (expanding_p): New variable. ++ (last_expr_type): Likewise. ++ (building_stmt_tree): New macro. ++ * decl.c (start_function): Use building_stmt_tree, not ++ processing_template_decl, where appropriate. ++ (store_parm_decls): Likewise. ++ (store_return_init): Move most of the body to semantics.c. ++ (finish_function): Use building_stmt_tree. ++ (finish_stmt): Clear last_expr_type here. ++ (cp_function): Add expanding_p, last_tree, last_expr_type. ++ (push_cp_function_context): Save them. ++ (pop_cp_function_context): Restore them. ++ * decl2.c (setup_vtbl_ptr): Move to semantics.c. ++ * error.c (dump_expr): Handle STMT_EXPR. ++ * except.c (expand_start_catch_block): Use building_stmt_tree. ++ Use add_decl_stmt. ++ * expr.c (cplus_expand_expr): Handle STMT_EXPR. ++ (do_case): Move add_tree call to semantics.c. ++ * parse.y (return_init): Use finish_named_return_value. ++ (for.init.statement): Use finish_expr_stmt. ++ * parse.c: Regenerated. ++ * pt.c (do_pushlevel): Move to semantics.c. ++ (do_poplevel): Likewise. ++ (tsubst_copy): Handle STMT_EXPR instead of BIND_EXPR. ++ (tsubst_expr): Don't expand all the way to RTL here. Handle ++ RETURN_INIT and CTOR_INITIALIZER. ++ (instantiate_decl): Call expand_body after tsubst'ing into ++ DECL_SAVED_TREE. ++ * semantics.c (expand_stmts): New function. ++ (expanding_p): New variable. ++ (last_expr_type): Likewise. ++ (finish_expr_stmt): Use building_stmt_tree. ++ (begin_if_stmt): Likewise. ++ (finish_if_stmt_cond): Likewise. ++ (finish_then_clause): Likewise. ++ (begin_else_clause): Likewise. ++ (finish_else_clause): Likewise. ++ (begin_while_stmt): Likewise. ++ (finish_while_stmt_cond): Likewise. ++ (finish_while_stmt): Likewise. ++ (finish_do_body): Likewise. ++ (finish_do_stmt): Likewise. ++ (finish_return_stmt): Likewise. ++ (begin_for_stmt): Likewise. ++ (fnish_for_init_stmt): Likewise. ++ (finish_for_cond): Likewise. ++ (finish_for_expr): Likewise. ++ (finish_for_stmt): Likewise. ++ (finish_break_stmt): Likewise. ++ (finish_continue_stmt): Likewise. ++ (finish_switch_cond): Likewise. ++ (finish_switch_stmt): Likewise. ++ (finish_case_label): Call add_tree here if necessary. ++ (finish_goto_statement): Use building_stmt_tree. ++ (begin_try_block): Likewise. ++ (begin_function_try_block): Likewise. ++ (finish_try_block): Likewise. ++ (finish_function_try_block): Likewise. ++ (finish_handler_sequence): Likewise. ++ (finish_function_handler_sequence): Likewise. ++ (begin_handler): Likewise. ++ (finish_handler_parms): Likewise. ++ (finish_handler): Likewise. ++ (begin_compound_stmt): Likewise. ++ (finish_compound_stmt): Likewise. ++ (finish_asm_stmt): Likewise. ++ (finish_label_stmt): Likewise. ++ (finish_named_return_value): New function. ++ (setup_vtbl_ptr): Moved here from decl2.c. ++ (do_pushlevel): Moved here from pt.c. ++ (do_poplevel): Likewise. ++ (begin_stmt_expr): Use building_stmt_tree. ++ (finish_stmt_expr): Likewise. Build a STMT_EXPR, not a BIND_EXPR, ++ when building_stmt_tree. ++ (begin_stmt_tree): New function. ++ (finish_stmt_tree): Likewise. ++ (expand_stmt): Likewise. ++ (expand_body): Likewise. ++ * tree.c (build_cplus_method_type): Make sure the argument types ++ end up on the same obstack as the METHOD_TYPE. ++ (search_tree): Handle COMPOUND_EXPR, MODIFY_EXPR, ++ THROW_EXPR, STMT_EXPR. ++ (mapcar): Break out common cases. Handle COMPOUND_EXPR, ++ MODIFY_EXPR, THROW_EXPR, STMT_EXPR, RTL_EXPR. Abort, rather than ++ sorry, if an unsupported node is encountered. ++ * typeck.c (require_complete_type_in_void): Handle BIND_EXPR. ++ (c_expand_return): Don't call add_tree here. ++ ++1999-08-15 Mark Mitchell ++ ++ * pt.c (check_default_tmpl_args): Don't check in local scopes. ++ (tsubst_decl): Make sure the declaration is on a saveable ++ obstack. Clear DECL_DEAD_FOR_LOCAL when making a copy of a local ++ variable. ++ (tsubst_expr): Adjust now that DECL_STMTs really contain DECLs. ++ ++1999-08-14 Jason Merrill ++ ++ Speed up Koenig lookup. ++ * decl.c (unqualified_namespace_lookup): Nonstatic. Add spacep parm ++ to return namespaces we've looked at. ++ * decl2.c (lookup_using_namespace): Likewise. ++ (add_function): Don't call ovl_member. ++ (lookup_arg_dependent): Initialize k.namespaces to the list of ++ namespaces seen in unqualified lookup. ++ * call.c (equal_functions): Move here from tree.c. ++ (joust): Use it to handle duplicate candidates. ++ * tree.c (ovl_member): Use ==. ++ ++1999-08-13 Mark Mitchell ++ ++ * cp-tree.def (DECL_STMT): Make it smaller. ++ * cp-tree.h (lang_decl_flags): Move saved_tree to ... ++ (lang_decl): ... here. Add next. ++ (DECL_SAVED_TREE): Adjust accordingly. ++ (DECL_IMPLICIT_TYPEDEF_P): New macro. ++ (SET_DECL_IMPLICIT_TYPEDEF_P): Likewise. ++ (DECL_STMT_DECL): Likewise. ++ (create_implicit_typedef): New function. ++ (maybe_push_decl): Likewise. ++ (tsubst_default_argument): New function. ++ (at_function_scope_p): Likewise. ++ (add_decl_stmt): Likewise. ++ (push_permanent_obstack): Likewise. ++ * call.c (convert_default_arg): Use tsubst_default_argument. ++ * class.c (add_method): Use push_permanent_obstack. ++ (build_self_reference): Create a TEMPLATE_DECL for the ++ self-reference, if necessary. ++ * decl.c (pseudo_global_level_p): Only look at the current binding ++ level. ++ (push_binding): Use push_permanent_obstack. ++ (create_implicit_typedef): New function. ++ (pushtag): Use it. ++ (duplicate_decls): Use push_permanent_obstack. ++ (maybe_push_decl): New function. ++ (start_decl): Use it. Remove dead code. Use add_decl_stmt. ++ (start_decl_1): Remove dead code. ++ (cp_finish_decl): Remove DECL_STMT handling here. Don't use ++ pseudo_global_level_p. ++ (grokvardecl): Create DECL_LANG_SPECIFIC for a VAR_DECL in a ++ template. ++ (grokdeclarator): Likewise, for TYPE_DECLs. Don't use ++ pseudo_global_level_p. ++ * decl2.c (grokfield): Call push_template_decl for a TYPE_DECL in ++ a template. ++ (get_sentry): Use push_permanent_obstack. ++ * dump.c (dequeue_and_dump): Enable DECL_STMT. ++ * except.c (call_eh_info): Use push_permanent_obstack. ++ (build_eh_type_ref): Likewise. ++ (do_pop_exception): Likewise. ++ (expand_eh_spec): Likewise. ++ (alloc_eh_object): Likewise. ++ (expand_throw): Likewise. ++ * init.c (build_java_class_ref): Likewise. ++ * lex.c (get_time_identifier): Likewise. ++ (free_lang_decl_chain): Correct type. ++ (retrofit_lang_decl): Adjust accordingly. ++ (build_lang_field_decl): Likewise. ++ * lex.h (free_lang_decl_chain): Likewise. ++ * parse.y (lang_extdef): Don't use pseudo_global_level_p. ++ * parse.c: Regenerated. ++ * pt.c (tsubst_default_arguments): New function. ++ (retrieve_local_specialization): Likewise. ++ (register_local_specialization): Likewise. ++ (push_template_decl_real): Use DECL_IMPLICIT_TYPEDEF_P. Just use ++ pseudo_global_level_p to determine whether or not a template is ++ primary. ++ (lookup_template_class): Likewise. Use create_implicit_typedef. ++ (instantiate_class_template): Call tsubst_default_arguments for ++ member functions, if appropriate. ++ (tsubst_default_argument): New function. ++ (tsubst_decl): Use it. Change TYPE_DECL handling to match VAR_DECLs. ++ * search.c (at_function_scope_p): New function. ++ * semantics.c (finish_asm_stmt): Use push_permanent_obstack. ++ (finish_label_stmt): Likewise. ++ (add_decl_stmt): New function. ++ (begin_class_definition): Likewise. ++ (finish_typeof): Likewise. ++ * tree.c (copy_template_template_parm): Likewise. ++ (copy_to_permanent): Likewise. ++ (push_permanent_obstack): Define. ++ (mark_addressable): Use it. ++ * typeck.c (mark_addressable): Likewise. ++ ++1999-08-13 Gavin Romig-Koch ++ ++ * cp-tree.h (init_cplus_unsave): New. ++ (cplus_unsave_expr_now): New. ++ * lex.c (init_parse): Call init_cplus_unsave. ++ * tree.c (init_cplus_unsave): New. ++ (cplus_unsave_expr_now): New. ++ ++1999-08-13 Mark Mitchell ++ ++ * pt.c (tsubst): Back out 1999-08-06 patch. Use fold and ++ decl_constant_value to simplify array bounds. ++ ++1999-08-11 Jason Merrill ++ ++ * lang-options.h: Add -fms-extensions. ++ * cp-tree.h: Declare flag_ms_extensions. ++ * decl2.c: Define it. ++ * class.c (instantiate_type): Don't complain about taking the address ++ of a bound member function if -fms-extensions. ++ * typeck.c (build_unary_op): Likewise. ++ * decl.c (grokdeclarator): Or about implicit int. ++ * init.c (resolve_offset_ref): Or about implicit '&'. ++ ++1999-08-11 Mark Mitchell ++ ++ * cp-tree.h (minimal_parse_mode): Remove. ++ (finish_label_stmt): New function. ++ * decl.c (saved_scope): Remove minimal parse mode. ++ (maybe_push_to_top_level): Don't save it. ++ (pop_from_top_level): Don't restore it. ++ (define_label): Split out template-handling code to semantics.c. ++ (start_decl): Don't use minimal_parse_mode. ++ (cp_finish_decl): Likewise. ++ (start_function): Don't increment it. ++ (store_return_init): Don't use it. ++ (finish_function): Don't decrement it. ++ * parse.y (label_colon): Use finish_label_stmt throughout. ++ * parse.c: Regenerated. ++ * pt.c (minimal_parse_mode): Don't define it. ++ (tsubst_expr): Use finish_label_stmt. ++ * semantics.c (finish_label_stmt): New function. ++ ++ * dump.c (queue): Be careful when computing bitmasks. ++ (dequeue_and_dump): Describe binfos as binfos, not as ++ vectors. ++ ++ * parse.y (pedantic): Give it itype. Adjust usage accordingly ++ throughout. ++ * parse.c: Regenerated. ++ ++ * Make-lang.in (CXX_SRCS): Remove sig.c. ++ * Makefile.in (CXX_OBJS): Remove sig.o. ++ (sig.o): Remove. ++ * cp-tree.h (CPTI_OPAQUE_TYPE): Remove. ++ (CPTI_SIGNATURE_TYPE): Likewise. ++ (CPTI_SIGTABLE_ENTRY_TYPE): Likewise. ++ (opaque_type_node): Likewise. ++ (signature_type_node): Likewise. ++ (sigtable_entry_type): Likewise. ++ (flag_handle_signatures): Likewise. ++ (lang_type): Remove is_signature, is_signature_pointer, ++ is_signature_reference, has_opaque_typedecls, ++ sigtables_has_been_generated. Adjust dummy. Remove signature, ++ signature_pointer_to, signature_reference_to. ++ (IS_SIGNATURE): Remove. ++ (SET_SIGNATURE): Remove. ++ (CLEAR_SIGNATURE): Remove. ++ (IS_SIGNATURE_POINTER): Remove. ++ (IS_SIGNATURE_REFERENCE): Remove. ++ (SIGNATURE_HAS_OPAQUE_TYPEDECLS): Remove. ++ (SIGTABLE_HAS_BEEN_GENERATED): Remove. ++ (CLASSTYPE_SIGNATURE): Remove. ++ (SIGNATURE_TYPE): Remove. ++ (SIGNATURE_METHOD_VEC): Remove. ++ (SIGNATURE_POINTER_TO): Remove. ++ (SIGNATURE_REFERENCE_TO): Remove. ++ (lang_decl_flags): Remove is_default_implementation. Rename ++ memfunc_pointer_to to saved_tree. ++ (IS_DEFAULT_IMPLEMENTATION): Remove. ++ (DECL_MEMFUNC_POINTER_TO): Remove. ++ (DECL_MEMFUNC_POINTING_TO): Remove. ++ (DECL_SAVED_TREE): Adjust definition. ++ (tag_types): Remove signature_type_node. ++ (SIGNATURE_FIELD_NAME): Remove. ++ (SIGNATURE_FIELD_NAME_FORMAT): Likewise. ++ (SIGNATURE_OPTR_NAME): Likewise. ++ (SIGNATURE_SPTR_NAME): Likewise. ++ (SIGNATURE_POINTER_NAME): Likewise. ++ (SIGNATURE_POINTER_NAME_FORMAT): Likewise. ++ (SIGNATURE_REFERENCE_NAME): Likewise. ++ (SIGNATURE_REFERNECE_NAME_FORMAT): Likewise. ++ (SIGTABLE_PTR_TYPE): Likewise. ++ (SIGTABLE_NAME_FORMAT): Likewise. ++ (SIGTABLE_NAME_FORMAT_LONG): Likewise. ++ (SIGTABLE_TAG_NAME): Likewise. ++ (SIGTABLE_VB_OFF_NAME): Likewise. ++ (SIGTABLE_VT_OFF_NAME): Likewise. ++ (finish_base_specifiers): Change prototype. ++ (build_signature_pointer_type): Remove. ++ (build_signature_reference_type): Remove. ++ (build_signature_pointer_constructor): Remove. ++ (build_signature_method_call): Remove. ++ (build_optr_ref): Likewise. ++ (append_signature_fields): Likewise. ++ (signature_error): Likewise. ++ * call.c (build_this): Remove signature support. ++ (build_over_call): Likewise. ++ (build_new_method_call): Likewise. ++ * class.c (add_implicitly_declared_members): Likewise. ++ (finish_struct_1): Likewise. ++ (finish_struct): Likewise. ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ (convert_to_pointer_force): Likewise. ++ (ocp_convert): Likewise. ++ * decl.c (sigtable_decl_p): Remove. ++ (init_decl_processing): Remove support for signatures. ++ (cp_finish_decl): Likewise. ++ (grokdeclarator): Likewise. ++ (grokparms): Likewise. ++ (xref_tag): Likewise. ++ (start_function): Likewise. ++ (start_method): Likewise. ++ * decl2.c (finish_sigtable_vardecl): Remove. ++ (flag_handle_signatures): Remove. ++ (lang_f_options): Remove handle-signatures. ++ (grokfield): Remove support for signatures. ++ (grokbitfield): Likewise. ++ (finish_file): Likewise. ++ (reparse_absdcl_as_casts): Likewise. ++ * error.c (dump_type_real): Likewise. ++ (dump_function_decl): Likewise. ++ * friend.c (make_friend_class): Likewise. ++ * gxx.gperf: Remove __signature__, signature, __sigof__, sigof. ++ * hash.h: Regenerated. ++ * init.c (build_new_1): Remove support for signatures. ++ * lang-options.h: Remove -fhandle-signatures, ++ -fno-handle-signatures. ++ * lex.c (init_parse): Remove support for signatures. ++ (yyprint): Likewise. ++ * lex.h (rid): Remove RID_SIGNATURE. ++ * method.c (build_decl_overload_real): Remove support for ++ signatures. ++ (hack_identifier): Likewise. ++ * parse.y (base_class): Likewise. ++ (base_class.1): Likewise. ++ (access_specifier): Likewise. ++ * search.c (lookup_member): Likewise. ++ * semantics.c (finish_qualified_object_call_expr): Likewise. ++ (finish_template_type_parm): Likewise. ++ (begin_class_definition): Likewise. ++ (finish_base_specifier): Likewise. ++ * sig.c: Remove. ++ * tree.c (build_cplus_method_type): Remove support for signatures. ++ * typeck.c (require_complete_type): Likewise. ++ (c_sizeof): Likewise. ++ (c_alignof): Likewise. ++ (build_object_ref): Likewise. ++ (build_component_ref): Likewise. ++ (build_indirect_ref): Likewise. ++ (build_c_cast): Likewise. ++ (build_modify_expr): Likewise. ++ (convert_for_initialization): Likewise. ++ * typeck2.c (signature_error): Remove. ++ (store_init_value): Remove support for signatures. ++ (digest_init): Likewise. ++ (build_x_arrow): Likewise. ++ (build_functional_cast): Likewise. ++ * xref.c (GNU_xref_decl): Likewise. ++ ++1999-08-10 Martin v. Loewis ++ ++ * lex.c (do_identifier): Remove unnecessary lookup of class field. ++ ++1999-08-09 Martin v. Loewis ++ ++ * decl2.c (set_decl_namespace): Do not complain about non-matching ++ decls if processing a template. ++ ++1999-08-09 Mark Mitchell ++ ++ * decl.c (build_ptrmemfunc_type): Handle qualified ++ pointer-to-member types here. ++ * tree.c (cp_build_qualified_type_real): Simplify handling here. ++ ++1999-08-09 Kaveh R. Ghazi ++ ++ * lex.c (lang_identify): Likewise. ++ ++1999-08-09 Bernd Schmidt ++ ++ * Makefile.in: Update dependencies. ++ * class.c (finish_struct_1): Don't initialize DECL_SAVED_INSNS with ++ NULL_RTX. ++ * decl.c: Include "function.h" ++ (cleanup_label, return_label): Delete declarations. ++ (store_parm_decls): Don't initialize DECL_SAVED_INSNS with NULL_RTX. ++ (finish_function): Rename last_parm_insn variable to ++ fn_last_parm_insn. Don't compare DECL_SAVED_INSNS to NULL_RTX. ++ * decl2.c: Include "function.h". ++ (rtl_expr_chain): Delete declaration. ++ * method.c: Include "function.h" ++ * tree.c (build_vbase_pointer_fields): Don't initialize ++ DECL_SAVED_INSNS with NULL_RTX. ++ * typeck.c: Include "function.h" ++ ++1999-08-09 Jason Merrill ++ ++ * semantics.c (begin_function_try_block, finish_function_try_block, ++ finish_function_handler_sequence): New fns. ++ * parse.y (function_try_block): Use them. ++ * pt.c (instantiate_decl): Likewise. ++ ++ * cp-tree.h: Declare in_function_try_handler. ++ * decl.c: Define it. ++ (start_function): Clear it. ++ (struct cp_function, push_cp_function_context): Save it. ++ (pop_cp_function_context): Restore it. ++ * parse.y (function_try_block): Set and clear it. ++ * except.c (expand_end_catch_block): Rethrow if we reach the end ++ of a function-try-block handler in a ctor or dtor. ++ * typeck.c (c_expand_return): Complain about returning from a ++ function-try-block handler of a ctor. ++ ++ * parse.y (function_try_block): Call end_protect_partials ++ before expand_start_all_catch. ++ ++1999-08-08 Jason Merrill ++ ++ * decl.c (struct binding_level): Add eh_region field. ++ (push_binding_level): Set it. ++ (define_label): Complain about jumping into an EH block. ++ ++ * ptree.c (print_lang_type): Print the real type of a PMF. ++ Print what exceptions a fn type throws. ++ ++1999-08-07 Kaveh R. Ghazi ++ ++ * class.c (count_fields, add_fields_to_vec): Add static prototype. ++ ++ * cp-tree.h (opname_tab, assignop_tab, operator_name_string, ++ get_id_2, composite_pointer_type, dump_node_to_file): Constify a ++ char*. ++ ++ * decl.c (named_label_list, cp_finish_decl, grokdeclarator): ++ Constify a char*. ++ ++ * decl2.c (finish_static_data_member_decl, grokfield): Constify a ++ char*. ++ ++ * dump.c (queue_and_dump_index, dump_int, dump_string, ++ dump_string_field, dequeue_and_dump, dump_node_to_file): Constify ++ a char*. ++ (dump_stmt): Add static prototype. ++ ++ * errfn.c (cp_thing): Constify a char*. ++ ++ * error.c (dump_unary_op, dump_binary_op, aggr_variety, ++ dump_aggr_type, dump_global_iord, dump_decl, dump_function_name, ++ dump_expr): Constify a char*. ++ ++ * lex.c (extend_token_buffer_to, pragma_getc, pragma_ungetc, ++ read_line_number): Add static prototype. ++ (opname_tab, assignop_tab, operator_name_string): Constify a char*. ++ (real_yylex): Move label `letter' into the scope where it is used. ++ ++ * method.c (build_mangled_template_parm_index, build_overload_int, ++ build_decl_overload_real, get_id_2): Constify a char*. ++ ++ * search.c (check_final_overrider): Make static. ++ ++ * typeck.c (composite_pointer_type): Constify a char*. ++ ++1999-08-06 Jason Merrill ++ ++ * pt.c (maybe_get_template_decl_from_type_decl): Make sure that ++ we're looking at a class. ++ ++ * decl.c (lookup_name_real): Set the complain flag if we're ++ looking for a namespace member. ++ ++ * lex.c (real_yylex): We can have a number with no digits. ++ ++ * cvt.c (cp_convert_to_pointer): Don't force pmf conversions. ++ ++ * search.c (binfo_from_vbase): New fn. ++ * cp-tree.h: Declare it. ++ * cvt.c (cp_convert_to_pointer): Use it to diagnose conversion ++ from pointer to member of virtual base. ++ * typeck.c (get_delta_difference): Likewise. ++ ++1999-08-06 Alexandre Oliva ++ ++ * pt.c (tsubst): Use build_index_type to build in-template array ++ index type. Fixes g++.oliva/dwarf1.C. ++ * decl.c (grokdeclarator): Likewise, just for consistency, as it ++ doesn't seem to trigger the bug without it. ++ ++1999-08-06 Jason Merrill ++ ++ * typeck2.c (add_exception_specifier): Use complete_type. ++ ++1999-08-06 Mark Mitchell ++ ++ * error.c (dump_expr): Handle EXACT_DIV_EXPR. ++ (dump_binary_op): Bulletproof. ++ * lex.c (init_parse): Set opname_tab[EXACT_DIV_EXPR]. ++ * tree.c (search_tree): Don't enumerate all the nodes of classes ++ `1', `2', and `<'; handle them generically. Don't be sorry about ++ "unrecognized tree codes"; just abort. ++ (no_linkage_check): Don't do linkage checks for templates. ++ ++ * tree.c (cp_build_qualified_type_real): Handle ++ pointer-to-member-function types correctly. ++ ++1999-08-05 Jason Merrill ++ ++ * decl.c (pushdecl): Only give an error for shadowing a parm ++ from *this* function. ++ ++Thu Aug 5 02:40:42 1999 Jeffrey A Law (law@cygnus.com) ++ ++ * typeck2.c: Update URLs and mail addresses. ++ ++1999-08-04 Nathan Sidwell ++ ++ * cp-tree.h (empty_except_spec): New global var. ++ (compexcepttypes): Remove prototype. ++ (comp_except_specs): Prototype new global function. ++ (add_exception_specifier): Prototype new global function. ++ * decl.c (empty_except_spec): Define new global var. ++ (duplicate_decls): Use comp_except_specs, reword error message. ++ (init_decl_processing): Initialize empty_except_spec. ++ Adjust build_exception_variant calls. ++ * parse.y (exception_specification_opt): Use empty_except_spec. ++ (ansi_raise_identifier): Call check_for_new_type. ++ (ansi_raise_identifiers): Use add_exception_specifier. ++ * pt.c (tsubst): Use add_exception_specifier to build exception ++ specifier. ++ * search.c (check_final_overrider): New static function, broken ++ out of get_matching_virtual. Check throw specifiers, reword ++ diagnostics. ++ (get_matching_virtual): Use check_final_overrider. ++ * tree.c (build_exception_variant): Use comp_except_specs. ++ * typeck.c (compexcepttypes): Remove. ++ (comp_except_types): New static function, helper for ++ comp_except_specs. Compare two types as exception specifiers. ++ (comp_except_specs): New global function, compare two exception ++ specifiers. ++ (comptypes): Adjust for comp_except_specs. ++ * typeck2.c (add_exception_specifier): New global function. ++ ++ * class.c (check_for_override): Reword error message. ++ ++1999-08-03 Nathan Sidwell ++ ++ * call.c (convert_arg_to_ellipsis): Use pod_type_p. ++ * cp-tree.h (struct lang_type): Added non_pod_class flag. ++ (CLASSTYPE_NON_POD_P): New macro to access it. ++ * class.c (finish_struct_1): Determine non-PODness. ++ Check for arrays of pointers (-Weffc++). ++ Remove array inspection duplicated code. ++ * tree.c (pod_type_p): Detect non-pod non-aggregate types. ++ Use CLASSTYPE_NON_POD_P. ++ ++1999-08-03 Nathan Sidwell ++ ++ * class.c (duplicate_tag_error): Preserve template information. ++ ++1999-08-03 Nathan Sidwell ++ ++ * decl.c (start_enum): Show location of previous definition. ++ * parse.y (enumlist_opt): New reduction. ++ (structsp): Simplify enum rules to use enumlist_opt. ++ ++1999-08-03 Jason Merrill ++ ++ * lex.c (yyprint): Handle PFUNCNAME. ++ ++ * decl2.c (build_expr_from_tree, case METHOD_CALL_EXPR): Only ++ build_expr_from_tree on the args of a TEMPLATE_ID_EXPR. ++ ++1999-08-03 Mumit Khan ++ ++ * decl.c (start_decl): Set attributes before duplicate_decls call. ++ ++1999-08-02 Mark Mitchell ++ ++ * Make-lang.in (CXX_SRCS): Add dump.c. ++ * Makefile.in (CXX_OBJS): Add dump.o. ++ (dump.o): New target. ++ * cp-tree.h (DECL_CONV_FN_P): Document. ++ (DECL_OVERLOADED_OPERATOR_P): New function. ++ (TYPE_PTRMEM_CLASS_TYPE): New macro. ++ (TYPE_PTRMEM_POINTED_TO_TYPE): Likewise. ++ (PTRMEM_CST_CLASS): Use TYPE_PTRMEM_CLASS_TYPE. ++ (ASM_VOLATILE_P): New macro. ++ (STMT_LINENO): Likewise. ++ (cp_namespace_decls): New function. ++ (dump_node_to_file): New function. ++ * decl.c (cp_namespace_decls): New function. ++ (walk_namespaces_r): Use it. ++ (wrapup_globals_for_namespace): Likewise. ++ * decl2.c (flag_dump_translation_unit): New variable. ++ (lang_decode_option): Handle -fdump-translation-unit. ++ (finish_file): If flag_dump_translation_unit is set, dump the ++ translation unit. ++ * dump.c: New file. ++ * lang-options.h: Add -fdump-translation-unit. ++ * pt.c (tsubst_template_parms): Robustify. ++ (tsubst_decl): Use DECL_OVERLOADED_OPERATOR_P. ++ (tsubst_expr): Use STMT_LINENO. ++ * semantics.c (finish_asm_stmt): Eliminate duplicate code. Check ++ for invalid cv-qualifiers even while building templates. ++ ++1999-08-02 Richard Henderson ++ ++ * call.c: Include defaults.h instead of expr.h. ++ * decl.c: Likewise. ++ * pt.c: Likewise. ++ * typeck.c: Include defaults.h. ++ ++1999-08-02 Mark Mitchell ++ ++ * lex.c (errorcount, sorrycount): Don't declare. ++ * repo.c (errorcount, sorrycount): Likewise. ++ * typeck2.c (errorcount, sorrycount): Likewise. ++ ++1999-08-02 Jakub Jelinek ++ ++ * call.c (convert_default_arg, build_over_call): Change all uses of ++ PROMOTE_PROTOTYPES, so that it tests it as a C expression. ++ Ensure expr.h is included. ++ * decl.c (grokparams): Ditto. ++ * pt.c (tsubst_decl): Ditto. ++ * typeck.c (convert_arguments): Ditto. ++ ++1999-08-02 Jason Merrill ++ ++ * class.c (mark_overriders): Fix order of args to overrides. ++ (warn_hidden): Likewise. Fix for having virtual and non-virtual ++ functions with the same name. ++ ++1999-08-02 Richard Henderson ++ ++ * cp-tree.h (TYPE_PTRMEMFUNC_P): Check TYPE_LANG_SPECIFIC non-null. ++ ++1999-08-01 Mark Mitchell ++ ++ * call.c (build_conditional_expr): Fix typo in comment. ++ ++1999-08-01 Bernd Schmidt ++ ++ * decl.c (finish_stmt): Don't declare and test cond_stack, loop_stack, ++ case_stack; use in_control_zone_p. ++ * typeck.c (c_expand_return): Likewise. ++ ++1999-07-31 Bernd Schmidt ++ ++ * except.c (catch_clauses): Delete declaration. ++ ++1999-07-30 Mark Mitchell ++ ++ * call.c (build_conditional_expr): Call convert_from_reference to ++ avoid reference/non-reference type confusion. Fix typo. ++ ++1999-07-30 Richard Henderson ++ ++ * typeck2.c (initializer_constant_valid_p): Moved to c-common.c. ++ * cp-tree.h (initializer_constant_valid_p): Remove. ++ ++1999-07-28 Mark Mitchell ++ ++ * call.c (conditional_conversion): Don't build BASE_CONVs for ++ conversions between things that have the same type. ++ (build_conditional_expr): Tweak. ++ (convert_like): Some BASE_CONVs really do require the generation ++ of code. ++ ++ * init.c (perform_member_init): Don't go through build_modify_expr ++ for simple initializations. ++ ++1999-07-27 Jason Merrill ++ ++ * cp-tree.h (DECL_VIRTUAL_CONTEXT): New macro. ++ * typeck.c (expand_ptrmemfunc_cst): Calculate delta correctly for ++ virtual functions and MI. Simplify. ++ ++ * method.c: Remove prototype for largest_union_member. ++ * pt.c (determine_specialization): Fix uninitialized warning. ++ * lex.c (real_yylex): Likewise. ++ ++1999-07-27 Mark Mitchell ++ ++ * class.c (override_one_vtable): Adjust the use of BINFO_VIRTUALS ++ here too. ++ ++ * cp-tree.h (BINFO_VIRTUALS): Document new format. ++ * class.c (modify_one_vtable): Change prototype accordingly. ++ (modify_all_vtables): Likewise. ++ (modify_all_direct_vtables): Likewise. ++ (modify_all_indirect_vtables): Likewise. ++ (build_vtable_entry_for_fn): New function. ++ (set_rtti_entry): Simplify for new BINFO_VIRTUALS format. ++ (modify_vtable_entry): Likewise. ++ (add_virtual_function): Likewise. ++ (build_vtbl_initializer): New function. ++ (finish_vtbls): Simplify for new BINFO_VIRTUALS format. ++ (fixup_vtable_deltas1): Likewise. ++ (fixup_vtable_deltas): Likewise. ++ (override_one_vtable): Likewise. ++ (finish_struct_1): Likewise. ++ ++ * error.c (dump_expr): Likewise. ++ * search.c (get_abstract_virtuals_1): Likewise. ++ (get_abstract_virtuals): Likewise. ++ (expand_upcast_fixups): Likewise. ++ * tree.c (debug_binfo): Likewise. ++ * decl2.c (mark_vtable_entries): Don't bash abstract virtuals to ++ __pure_virtual here. ++ ++1999-07-26 Mark Mitchell ++ ++ * tree.c (build_cplus_new): Adjust call to abstract_virtuals_error ++ as per 1999-07-26 change. ++ ++ * typeck.c (c_sizeof): Don't allow non-static data members. ++ (expr_sizeof): Likewise. ++ ++1999-07-26 Jason Merrill ++ ++ * input.c (feed_input): Only touch lineno and input_filename ++ if !USE_CPPLIB. Save the old values before setting the new ones. ++ ++ * input.c (feed_input): Add file, line parms. ++ * lex.c (begin_definition_of_inclass_inline, feed_defarg): Adjust. ++ (real_yylex): Check linemode before input_redirected(). ++ ++ * typeck.c (c_expand_return): Downgrade pedwarn about returning NULL ++ from op new to warning. ++ ++1999-07-26 Mark Mitchell ++ ++ * cp-tree.h (ncp_convert): Rename to perform_implicit_conversion. ++ * call.c: All uses changed. ++ * typeck.c: Likewise. ++ ++1999-07-26 Nathan Sidwell ++ ++ * exception.cc (__cplus_type_matcher): Match __eh_matcher ++ prototype. ++ ++1999-07-26 Mark Mitchell ++ ++ * cp-tree.h (CP_INTEGRAL_TYPE_P): New macro. ++ (ARITHMETIC_TYPE_P): Adjust definition for standard conformance. ++ (strip_top_quals): Declare. ++ (ncp_convert): Likewise. ++ (type_after_usual_arithmetic_conversions): Likewise. ++ (composite_pointer_type): Likewise. ++ * call.c (strip_top_quals): Don't make it static. ++ (promoted_arithmetic_type_p): New function. ++ (conditional_conversion): Likewise. ++ (null_ptr_cst_p): Allow `false' as a NULL pointer constant. ++ (standard_conversion): Use same_type_p. Don't build BASE_CONVs ++ for converting a type to itself. ++ (reference_binding): Honor LOOKUP_NO_TEMP_BIND. ++ (implicit_conversion): Make sure the from and to types are ++ complete. ++ (add_builtin_candidate): Correct handling of ?: operator. ++ (add_builtin_candidates): Improve documentation. ++ (build_conditional_expr): New function. ++ (can_convert): Implement in terms of can_convert_arg. ++ (ncp_convert): New function. ++ * typeck.c (type_after_usual_arithmetic_conversions): New ++ function, split out from common_type. ++ (composite_pointer_type): New function, split out from ++ build_conditional_expr. ++ (common_type): Use type_after_usual_arithmetic_conversions. ++ Remove redundant attribute merging. ++ (comptypes): Tidy. Handle COMPLEX_TYPE. ++ (build_binary_op_nodefault): Use null_ptr_cst_p. ++ (build_conditional_expr): Remove. ++ (convert_for_assignment): Use new conversion functions. ++ ++ * cp-tree.h (abstract_virtuals_error): Change declaration. ++ * typeck2.c (abstract_virtuals_error): Check to see if an error ++ occurred, and return a boolean value accordingly. ++ (build_functional_cast): Adjust accordingly. ++ * class.c (finish_struct_1): Likewise. ++ * cvt.c (ocp_convert): Likewise. ++ * decl.c (cp_finish_decl): Likewise. ++ (grokparams): Likewise. ++ (grok_op_properties): Likewise. ++ (start_function): Likewise. ++ * init.c (build_new_1): Likewise. ++ ++ * pt.c (unify): Don't get confused by pointers-to-member functions. ++ ++ * search.c (build_cplus_new): Robustify. ++ ++1999-07-24 Richard Henderson ++ ++ * gxx.gperf (__builtin_va_arg): New. ++ * parse.y (VA_ARG): New token. ++ (unary_expr): Recognize it. ++ ++Sun Jul 25 15:24:21 1999 Jeffrey A Law (law@cygnus.com) ++ ++ * g++FAQ.texi: Deleted per Joe Buck's request. ++ * Makefile.in: Corresponding changes. ++ ++1999-07-23 Jason Merrill ++ ++ * lex.c: Sync with C frontend. ++ (whitespace_cr): New fn. ++ (skip_white_space): Use it. ++ (init_parse): Reorder. ++ (yyprint): Support CONSTANT. ++ (pragma_getc, pragma_ungetc): Bring back. ++ (read_line_number): Change in_system_header directly. ++ (handle_generic_pragma, handle_cp_pragma, yyerror): Move up in file. ++ (parse_float): Update to C version. ++ (yylex): Handle '$' under the letter case. ++ Remove looking_for_typename handling. ++ Support hex floating point constants. ++ Follow C's lead for choosing type of integer constants. ++ Rearrange stuff to match C frontend. ++ (yyungetc, reinit_parse_for_block, yylex): Support indent_level. ++ * spew.c (yylex): Clear looking_for_typename if we see a TYPESPEC. ++ ++1999-07-23 Mark Mitchell ++ ++ * call.c (reference_binding): Tweak. ++ (mayble_handle_implicit_object): Use direct_reference_binding to ++ create the right implicit conversion sequence. ++ ++1999-07-22 Mark Mitchell ++ ++ * pt.c (convert_nontype_argument): Don't call decl_constant_value ++ if we're converting to a reference type. ++ ++ * call.c (NEED_TEMPORARY_P): New macro. ++ (standard_conversion): Set it, for derived-to-base conversions. ++ (reference_related_p): New function. ++ (reference_compatible_p): Likewise. ++ (convert_class_to_reference): Likewise. ++ (direct_reference_binding): Likewise. ++ (reference_binding): Rework for standards-compliance. ++ (convert_like): Adjust accordingly. ++ (maybe_handle_ref_bind): Simplify; the right conversion sequences ++ are now built up in reference_binding. ++ (initialize_reference): New function. ++ * cp-tree.h (ICS_USER_FLAG): Document. ++ (ICS_THIS_FLAG): Likewise. ++ (ICS_BAD_FLAG): Likewise. ++ (NEED_TEMPORARY_P): Likewise. ++ (cp_lvalue_kind): New type. ++ (real_lvalue_p): Return it. ++ * error.c (dump_expr): Provide more accurate representation for ++ AGGR_INIT_EXPRs. ++ * init.c (expand_default_init): Do not try to perform implicit ++ conversions for a brace-enclosed initializer. ++ * search.c (lookup_conversions): Document. ++ * tree.c (lvalue_p_1): Return a cp_lvalue_kind. Calculate ++ appropriately. ++ (real_lvalue_p): Adjust accordingly. ++ (lvalue_p): Likewise. ++ (build_cplus_new): Don't allow the creation of an abstract class. ++ * typeck.c (convert_for_initialization): Use initialize_reference. ++ ++1999-07-21 Gavin Romig-Koch ++ ++ * lex.c (real_yylex) : Correct the test for overflow when lexing ++ integer literals. ++ ++1999-07-20 Jason Merrill ++ ++ * decl.c (warn_extern_redeclared_static): Check DECL_ARTIFICIAL, ++ not DECL_BUILT_IN, to determine if a function is internally declared. ++ (duplicate_decls): Likewise. Improve handling of builtins. ++ (push_overloaded_decl): Remove special handling of builtins. ++ ++ * cp-tree.h (ANON_AGGR_TYPE_P): Use CLASS_TYPE_P. ++ ++ * decl.c (grokdeclarator): Pull out decl_constant_value in ++ templates, too. ++ ++ * class.c (finish_struct, finish_struct_1): Remove 'warn_anon' parm. ++ * cp-tree.h, pt.c, semantics.c: Adjust. ++ * method.c (largest_union_member): Remove. ++ ++ * lang-specs.h (c++-cpp-output): Pass -fpreprocessed. ++ ++ * lex.c (token_getch, token_put_back): New fns. ++ (real_yylex): Use them. ++ ++ * lex.c (lang_init): Generalize. ++ (lang_init_options): Tell cpplib this is C++. ++ (nextchar): Remove. Replace uses with put_back. ++ (skip_white_space): Handle linemode here. Optimize for cpplib. ++ (extend_token_buffer_to): New fn. ++ (extend_token_buffer): Use it. ++ (read_line_number, check_newline): Just deal with tokens. ++ (real_yylex): More cpplib optimizations. Simplify. Don't produce ++ EXTERN_LANG_STRING, LEFT_RIGHT or PAREN_STAR_PAREN here. ++ * spew.c (yylex): Produce LEFT_RIGHT and EXTERN_LANG_STRING. ++ * parse.y (PAREN_STAR_PAREN): Remove. ++ * input.c: Don't use the putback machinery with cpplib. ++ (sub_getch): Fold back into getch. ++ (getch): Don't handle linemode here. ++ (feed_input): Unget any text in the token buffer. ++ ++ * lex.c (set_typedecl_interface_info, set_vardecl_interface_info, ++ nextyychar, nextyylval): Remove. ++ ++1999-07-20 Michael Tiemann ++ Jason Merrill ++ ++ * lex.c (indent_level): New variable. ++ (init_parse): Set cpp_token to CPP_DIRECTIVE. ++ (consume_string): Make this smart about USE_CPPLIB. ++ (yyungetc): Use put_back function. ++ (pragma_getc, pragma_ungetc): Functions deleted. ++ (check_newline): Rewrite to be intelligent about USE_CPPLIB. ++ Also, call HANDLE_PRAGMA with getch, yyungetc, not pragma_getc and ++ pragma_ungetc. ++ (real_yylex): Rewrite to be intelligent about USE_CPPLIB. ++ Also, clean up cases where we redundantly set token_buffer[0]. ++ (read_line_number): New fn. ++ * input.c (feed_input): Use integrated cpplib if USE_CPPLIB. ++ (end_input): Call cpp_pop_buffer if USE_CPPLIB. ++ (sub_getch): Conditionalize out code that's not appropriate if ++ USE_CPPLIB. ++ (put_back): Rewrite in case USE_CPPLIB is defined. ++ (input_redirected): Ditto. ++ ++Tue Jul 20 11:24:19 1999 Bernd Schmidt ++ ++ * cp-tree.h: Delete lots of declarations of tree nodes; replaced by ++ c_global_trees and accessor macros defined in c-common.h. ++ (cp_tree_index): New enumeration. ++ (cp_global_trees): Declare new array. Add accessor macros for it, and ++ delete declarations of tree nodes replaced by it. ++ (builtin_function): Delete macro, add declaration for new function. ++ Include c-common.h. ++ * decl.c: Delete definitions for tree nodes that were replaced by ++ cp_global_trees and c_global_trees. ++ (init_decl_processing): Call c_common_nodes_and_builtins; delete code ++ to generate the common builtins here. ++ (builtin_function): New function. ++ * decl2.c (abort_fndecl): Delete declaration. ++ * except.c (expand_builtin_return_address): Delete declaration. ++ (builtin_return_address_fndecl): Delete variable. ++ (const_ptr_type_node): Delete declaration. ++ * lex.c (cons_up_default_function): Delete declaration of ++ void_list_node. ++ * parse.y (void_list_node): Delete declaration. ++ * rtti.c (type_info_type_node, tinfo_fn_id, tinfo_fn_type): ++ Delete variables. ++ (const_string_type_node): Delete declaration. ++ * search.c (abort_fndecl): Delete declaration. ++ * Makefile.in: Update dependencies. ++ ++1999-07-19 Mark Mitchell ++ ++ * pt.c (check_default_tmpl_args): Move test for missing default ++ arguments here, from ... ++ (end_template_parm_list): Here. ++ ++1999-07-18 Mark Mitchell ++ ++ * decl.c (lookup_nested_type): Remove. ++ (pushtag): Don't call it. ++ ++Sat Jul 17 23:51:30 1999 Jeffrey A Law (law@cygnus.com) ++ ++ * Makefile.in (INTERFACE): Bump to 2. ++ ++1999-07-17 Alexandre Oliva ++ ++ * typeck2.c (my_friendly_abort): Updated URL with bug reporting ++ instructions to gcc.gnu.org. Removed e-mail address. ++ ++1999-07-17 Mark Mitchell ++ ++ * pt.c (determine_specialization): Tighten error-checking. ++ (end_template_parm_list): Likewise. ++ ++1999-07-14 Mark Mitchell ++ ++ * pt.c (check_default_tmpl_args): Handle friends defined in the ++ class just like member functions defined in the class. ++ ++1999-07-09 Michael Tiemann ++ Jason Merrill ++ ++ * cp-tree.h (struct lang_decl): Added field for storing sorted ++ FIELD_DECLs (used in TYPE_DECLs). ++ (DECL_PENDING_INLINE_INFO): Adjusted to use 'u' union. ++ (DECL_SORTED_FIELDS): New macro. ++ * class.c (method_name_cmp): New function. ++ (finish_struct_methods): Modified to support sorting and searching ++ methods. ++ (finish_struct_anon): Changed code in inner loop to use ELT rather ++ than UELT (which required an extra indirection for every reference). ++ (field_decl_cmp): New function to support sorting FIELD_DECLs. ++ (finish_struct_1): Sort fields. ++ * search.c (lookup_field_1): Use DECL_SORTED_FIELDS if we have them. ++ (lookup_fnfields_1): Search sorted methods in METHOD_VEC. ++ Also, switch to using array indexing rather than a changing pointer. ++ * ptree.c (print_lang_decl): Handle TYPE_DECLs that have ++ DECL_SORTED_FIELDS. ++ ++1999-07-09 Jason Merrill ++ ++ * decl2.c (reparse_absdcl_as_casts): Don't warn about old-style ++ casts in system headers or extern "C" blocks. ++ ++ * pt.c (do_decl_instantiation): Downgrade duplicate instantiation ++ errors to pedwarn. ++ ++1999-07-09 Michael Tiemann ++ ++ * decl2.c (write_virtuals): Deleted declaration. ++ * cp-tree.h (write_virtuals): Deleted extern declaration. ++ * class.c (finish_struct_1): Removed #if 0'd code that mentions ++ write_virtuals. ++ * semantics.c (begin_class_definition): Rewrite code to not depend ++ on write_virtuals. ++ ++ * lex.c (cp_pragma_interface): New function. ++ (cp_pragma_implementation): Likewise. ++ (handle_cp_pragma): Call them. ++ ++ * typeck.c (comptypes): Simplify C code in look_hard. ++ ++ * xref.c (PALLOC): Use xcalloc, not calloc. ++ (SALLOC): Use xmalloc, not malloc. ++ ++ * rtti.c (synthesize_tinfo_fn): Add missing call to pop_momentary. ++ ++ * search.c (note_debug_info_needed): Don't search if WRITE_SYMBOLS ++ is NO_DEBUG. ++ ++ * decl.c (duplicate_decls): If a redeclaration doesn't match the ++ initial declaration, then don't save the inline info and by all ++ means don't mark the function as a builtin function. ++ ++ * decl.c (lookup_name_real): Set NONCLASS to 1 if ++ CURRENT_CLASS_TYPE is 0. ++ ++ * class.c (duplicate_tag_error): Set TYPE_NONCOPIED_PARTS to ++ NULL_TREE. ++ ++ * ptree.c (print_lang_type): Added vtable-needs-writing. ++ ++Wed Jul 7 01:26:47 1999 Alexandre Oliva ++ ++ * decl2.c (mark_vtable_entries): Fix check for rtti offset. ++ ++1999-07-06 Gavin Romig-Koch ++ ++ * typeck.c (unsigned_type,signed_type,signed_or_unsigned_type) : ++ Merged into c-common. ++ ++1999-07-05 Dave Brolley ++ ++ * lex.c (errorcount): Declare it. ++ (finish_parse): Update errorcount for when using CPPLIB. ++ ++1999-07-05 Mark Mitchell ++ ++ * cp-tree.h (IS_AGGR_TYPE): Include instantiated template template ++ parameters. ++ (IMPLICIT_TYPENAME_TYPE_DECL_P): New macro. ++ * decl.c (push_class_binding): Use it. ++ (lookup_name_real): Likewise. ++ ++1999-07-02 Gavin Romig-Koch ++ ++ * cp-tree.h (widest_integer_literal_type_node, ++ widest_unsigned_literal_type) : New. ++ * decl.c (widest_integer_literal_type_node, ++ widest_unsigned_literal_type) : New. ++ (init_decl_processing): Handle/use the two new types. ++ * lex.c (real_yylex): Same. ++ * typeck.c (unsigned_type,signed_type,signed_or_unsigned_type) : ++ Same. ++ ++1999-07-01 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Don't give names "for linkage purposes" ++ to anonymous cv-qualified types. ++ ++1999-07-01 Gavin Romig-Koch ++ ++ * lex.c (real_yylex) : Change integer literal overflow handling to ++ be like c-lex.c. ++ ++ * lex.c (real_yylex): Improve 'integer constant out of range' messages. ++ ++1999-06-28 Richard Henderson ++ ++ * decl.c (cp_finish_decl): Fix typo in cp_warning_at call. ++ ++1999-06-28 Jason Merrill ++ ++ * error.c (dump_type_real): Handle TREE_LIST again. ++ ++ * typeck.c (comp_target_parms): Don't complain about ++ converting from () to (...) if !flag_strict_prototype. ++ ++ * decl.c (grokdeclarator): Update the names of all variants when ++ de-anonymizing. ++ ++1999-06-21 Mark Mitchell ++ ++ * init.c (expand_aggr_vbase_init): Rename to ++ construct_virtual_bases. Conditionalize construction here, ++ rather than ... ++ (emit_base_init): Here. ++ ++1999-06-19 Mark Mitchell ++ ++ * semantics.c (finish_asm_stmt): Apply decay conversions to ++ input operands. ++ ++ * decl.c (expand_static_init): When building an anonymous function ++ for use with atexit, compute its body before and after entering ++ the function. ++ ++ * error.c (dump_expr): Handle BIND_EXPR, LOOP_EXPR, and ++ EXIT_EXPR. ++ ++1999-06-18 Mark Mitchell ++ ++ * init.c (expand_aggr_vbase_init): Add flag parameter. ++ (build_partial_cleanup_for): Remove, inlining into .. ++ (expand_cleanup_for_base): ... here. Take flag parameter. ++ (emit_base_init): Pass the in_chrg parameter to ++ emit_aggr_vbase_init. ++ (emit_aggr_vbase_init): Pass it to expand_cleanup_for_base. ++ ++1999-06-16 Mark Mitchell ++ ++ * decl2.c (import_export_decl): Use same_type_p, rather than ++ relying on pointer-equality for types. ++ ++ * method.c (do_build_copy_constructor): Simplify. ++ ++ * call.c (build_method_call): Remove bogus code for two-argument ++ delete. ++ * init.c (build_new_1): Expand on comment, and remove dead code. ++ ++ * init.c (expand_cleanup_for_base): New function, split out ++ from ... ++ (emit_base_init): Here. ++ (expand_aggr_vbase_init): Use it. ++ ++1999-06-15 Mark Mitchell ++ ++ * cp-tree.h (class_cache_firstobj): Declare. ++ (maybe_push_cache_obstack): Rename to push_cache_obstack. ++ * class.c (permanent_obstack): Remove declaration. ++ (class_cache_firstobj): Make it global. ++ (add_method): Don't use permanent_obstack directly. ++ (pushclass): Only free the class_cache_obstack if we know how far ++ back to free it. ++ (maybe_push_cache_obstack): Rename to push_cache_obstack. ++ * decl.c: Remove dead comment. ++ (saved_scope): Add class_cache_firstobj. ++ (push_to_top_level): Save it. ++ (pop_from_top_level): Restore it. ++ (push_class_level_binding): Use push_cache_obstack, not ++ maybe_push_cache_obstack. ++ * search.c (push_class_decls): Likewise. ++ ++1999-06-14 Martin von Löwis ++ ++ * pt.c (tsubst_friend_function): Push into namespace of friend ++ function before pushdecl'ing it. ++ ++1999-06-14 Nathan Sidwell ++ ++ * call.c (build_new_op): Remove REF_BIND from all operands. ++ ++1999-06-13 Alexandre Oliva ++ ++ * init.c (build_new_1): Look up operator delete even if there was ++ no explicit new placement. ++ ++1999-06-08 Nathan Sidwell ++ ++ * except.c (complete_ptr_ref_or_void_ptr_p): New function, broken out ++ of ... ++ (build_throw): ... here. Call it. ++ (process_start_catch_block): Call it. ++ ++1999-06-07 Mark Mitchell ++ ++ * search.c (convert_pointer_to_single_level): Reimplement without ++ using get_binfo. ++ ++1999-06-06 Mark Mitchell ++ ++ * method.c (is_back_referenceable_type): Back-reference bools when ++ not squangling. ++ ++1999-06-07 Dave Brolley ++ ++ * lex.c (real_yylex): Replace unused bytes from bad multibyte char. ++ * input.c (putback_buffer): New structure type. ++ (putback): Replaces putback_char member. ++ (putback): Replaces putback_char static variable. ++ (feed_input): Use putback. ++ (end_input): Use putback. ++ (sub_getch): Use putback. ++ (put_back): Use putback. ++ ++1999-06-05 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Fix typo in last change. ++ ++1999-06-04 Jason Merrill ++ ++ * semantics.c (finish_if_stmt_cond): Copy cond to permanent_obstack. ++ (finish_while_stmt_cond, finish_do_stmt, finish_for_cond): Likewise. ++ ++1999-06-04 Nathan Sidwell ++ ++ * except.c (build_throw): Check throw expression validity. ++ ++1999-06-03 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Don't treat arbitrary types as unsigned ++ just because flag_signed_bitfields is false. ++ ++1999-06-03 Nathan Sidwell ++ ++ * semantics.c (begin_class_definition): Update the struct's ++ location here ... ++ * class.c (finish_struct): ... rather than here. ++ ++ * decl.c (make_typename_type): Don't rely on uninitialized ++ variable. ++ ++1999-05-31 Kaveh R. Ghazi ++ ++ * Makefile.in (ALL_CFLAGS): Add '-W -Wall'. ++ ++1999-05-31 Mark Mitchell ++ ++ * tree.c (build_cplus_array_type_1): Use push_obstacks_nochange ++ and friends rather than messing with current_obstack directly. ++ (cp_build_qualified_type_real): Rework ARRAY_TYPE ++ allocation to match practice throughout the rest of the ++ compiler. ++ ++1999-05-30 Mark Mitchell ++ ++ * lex.c (make_lang_type): Create TYPE_BINFO for ++ TEMPLATE_TYPE_PARMs just like for non-template types. ++ ++ * decl.c (start_decl): Move checks on initialization to ... ++ (cp_finish_decl): Here. Tidy formatting slightly. ++ ++1999-05-28 Mark Mitchell ++ ++ * decl.c (add_binding): Don't complain about a redeclaration of a ++ semantically identical typedef in a local scope. ++ ++1999-05-28 Nathan Sidwell ++ ++ * decl.c (complete_array_type): Allocate off same obstack. Fix ++ DO_DEFAULT comment to match reality. ++ ++ * friend.c (make_friend_class): Fix diagnostic typo. ++ ++1999-05-28 Mark Mitchell ++ ++ * decl.c (lookup_namespace_name): Handle getting a ++ TEMPLATE_ID_EXPR. ++ (expand_static_init): Don't call pushdecl for implicitly declared ++ `atexit' used to register destructors. ++ ++1999-05-25 Mark Mitchell ++ ++ * class.c (finish_vtbls): Copy BINFO_VIRTUALs before using it to ++ initialize a vtable. ++ ++ * cp-tree.h (NAMESPACE_LEVEL): Reformat. ++ (lang_decl_flags): Document MEMFUNC_POINTER_TO. Save four bytes ++ by combining TEMPLATE_INFO and LEVEL into a single union. ++ (DECL_TEMPLATE_INFO): Reformat. ++ (DECL_SAVED_TREE): Document. ++ (DECL_TEMPLATE_INJECT): Remove. ++ * class.c (finish_struct): Remove code to deal with ++ DECL_TEMPLATE_INJECT. ++ ++ * decl.c (maybe_process_template_type_declaration): Handle all new ++ types in templates uniformly. ++ * method.c (bulid_overload_identifier): Use CP_DECL_CONTEXT, not ++ DECL_CONTEXT. ++ * pt.c (lookup_template_class): Inject template instantiations of ++ forward-declarations. ++ (instantiate_class_template): Remove code processing ++ DECL_TEMPLATE_INJECT. ++ ++ * pt.c (lookup_template_class): Tweak lookup to find member ++ templates. ++ ++ * pt.c (tsubst_expr, case ASM_STMT): Don't tsubst into ++ ASM_CV_QUAL. ++ * semantics.c (finish_asm_stmt): Make strings permanent if they're ++ used in a template. ++ ++1999-05-25 Jason Merrill ++ ++ * typeck.c (casts_away_constness, casts_away_constness_r): Strip both ++ parts of pointer to data member types. ++ ++1999-05-24 Mark Mitchell ++ ++ * decl2.c (mark_vtable_entries): Don't make a copy of a function, ++ and then make it look like `abort'. Just use `abort' instead. ++ ++ * typeck.c (build_static_cast): Don't allow static_casts that cast ++ away constness. ++ (casts_away_constness_r): New function. ++ (casts_away_constness): Likewise. ++ ++ * decl.c (lookup_tag): Remove code no longer needed after ++ name-lookup improvements. ++ * decl2.c (handle_class_head): Make error-recovery more robust. ++ * friend.c (make_friend_class): Reject templated typename types. ++ * lex.c (is_global): A template parameter isn't global. ++ * parse.y (class_head): Robustify. ++ * parse.c: Regenerated. ++ ++1999-05-22 Mark Mitchell ++ ++ * pt.c (for_each_template_parm): Walk into TYPENAME_TYPEs, ++ INDIRECT_REFs, and COMPONENT_REFs. Handle FIELD_DECLs. ++ ++ * cp-tree.h (push_nested_namespace): Declare. ++ (pop_nested_namespace): Likewise. ++ * decl.c (push_nested_namespace): New function. ++ (pop_nested_namespace): Likewise. ++ * pt.c (instantiate_class_template): Use them. ++ ++ * tree.c (mapcar): Handle NON_LVALUE_EXPR. ++ ++ * cp-tree.h (cplus_expand_constant): Declare. ++ * cvt.c (convert_to_pointer): Expand PTRMEM_CSTs when they're ++ converted from one pointer-to-object type to another. ++ * expr.c (cplus_expand_constant): Don't make it static. ++ * typeck.c (build_component_ref): Don't crash when presented with ++ a component which is a TEMPLATE_DECL. ++ (build_ptrmemfunc): Tidy. Clarify comment. Make sure that even a ++ cast from a pointer-to-member constant to its own type does not ++ result in a valid non-type template argument. ++ ++1999-05-21 Mark Mitchell ++ Nathan Sidwell ++ ++ * Make-lang.in (cc1plus): Make it depend on gxx.gperf. ++ * cp-tree.h: Fix typo in documentation on pointers-to-members. ++ (cp_build_qualified_type): Make it a macro. ++ (cp_build_qualified_type_real): Declare. ++ * decl.c (grokdeclarator): Remove misleading comment. Avoid ++ problem with template parameters and restrict-qualification. ++ * gxx.gperf: Replace NORID with RID_UNUSED throughout. ++ * hash.h: Regenerated. ++ * lex.h (rid): Move RID_FIRST_MODIFIER and RID_LAST_MODIFIER into ++ the enumeration. ++ (NORID): Remove definition. ++ * pt.c (tsubst_aggr_type): Use cp_build_qualified_type_real. ++ (tsubst): Likewise. Remove special handling for FUNCTION_TYPEs. ++ (fn_type_unification): Check that the function type resulting from ++ the deduction is legal. ++ (check_cv_quals_for_unify): Don't handle FUNCTION_TYPEs specially. ++ (unify): Use cp_build_qualified_type_real. ++ * tree.c (build_cplus_array_type_1): Handle error_marks as inputs. ++ (cp_build_qualified_type): Rename to ... ++ (cp_build_qualified_type_real): Add additional COMPLAIN parameter ++ and modify appropriately. ++ ++ * typeck.c (build_ptrmemfunc): Handle PTRMEM_CSTs carefully to ++ reveal optimization opportunities. ++ ++ * pt.c (tsubst): Don't issue error messages when we're not ++ complaining, even if we see a qualified function type. ++ (check_cv_quals_for_unify): Don't allow a qualified function ++ type. ++ ++1999-05-20 Jason Merrill ++ ++ * class.c (instantiate_type): Downgrade errors for object-dependent ++ memfn refs to pedwarn. ++ ++1999-05-20 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Don't treat [] as indicating a ++ zero-sized array in a typedef. ++ ++ * call.c (build_object_call): Don't look at DECL_NAME for a type. ++ (pt.c): Or CP_TYPE_QUALS for an ERROR_MARK. ++ (typeck.c): Or TYPE_MAIN_VARIANT for a type. ++ ++ * pt.c (for_each_template_parm): Rework to match documentation. ++ Don't be fooled by a COMPONENT_REF with no TREE_TYPE. ++ ++1999-05-20 Jason Merrill ++ ++ * class.c (finish_struct_1): Still check for ANON_AGGR_TYPE_P. ++ ++ * class.c (finish_base_struct): Allow non-COM bases for COM classes ++ except at the leftmost position. ++ (modify_one_vtable, fixup_vtable_deltas1, override_one_vtable): ++ Pass the binfo's class, not the most derived, to skip_rtti_stuff. ++ * search.c (get_abstract_virtuals, expand_upcast_fixups): Likewise. ++ ++ * tree.c (lvalue_p_1): A NOP_EXPR can be an lvalue. ++ (build_cplus_new): Make sure that what we return is of the right type. ++ ++1999-05-20 Mark Mitchell ++ ++ * cp-tree.h (make_ptrmem_cst): New function. ++ * expr.c (cplus_expand_constant): Split out from ... ++ (cplus_expand_expr): Here. Use cplus_expand_constant. ++ (init_cplus_expand): Set lang_expand_constant. ++ * pt.c (convert_nontype_argument): Use make_ptrmem_cst. ++ ++ * tree.c (make_ptrmem_cst): Define. ++ * typeck.c (unary_complex_lvalue): Use make_ptrmem_cst. ++ * typeck2.c (initializer_constant_valid_p): Use make_ptrmem_cst. ++ ++1999-05-19 Mark Mitchell ++ ++ * pt.c (build_template_decl): Copy DECL_NONCONVERTING_P. ++ ++ * decl2.c (start_static_storage_duration_function): Fix comment. ++ (finish_file): Create static storage duration functions lazily. ++ ++1999-05-19 Jason Merrill ++ ++ Implement anonymous structs. ++ * cp-tree.h (ANON_AGGR_TYPE_P): Rename from ANON_UNION_TYPE_P. ++ * class.c, decl.c, decl2.c, init.c, pt.c, search.c, typeck.c: Adjust. ++ * class.c (finish_struct_1): Remove redundant check for anon struct. ++ * decl.c (fixup_anonymous_aggr): Renamed from fixup_anonymous_union. ++ (check_tag_decl): Check for anonymous struct here. ++ * decl2.c (build_anon_union_vars): Catch anon struct at file scope. ++ * init.c (sort_member_init, emit_base_init): Handle getting fields ++ as well as names in current_member_init_list. ++ (perform_member_init): Handle getting an anon aggr. ++ * method.c (do_build_assign_ref): Don't descend into anon aggrs. ++ (do_build_copy_constructor): Likewise. ++ ++1999-05-19 Mark Mitchell ++ ++ * tree.c (cp_build_qualified_type): Don't allow qualified function ++ types. ++ ++Wed May 19 02:50:53 1999 Arvind Sankar ++ ++ * gxxint.texi: Fix typo. ++ ++1999-05-19 Jason Merrill ++ ++ * call.c (find_scoped_type, resolve_scope_to_name): Lose. ++ * class.c (finish_struct_1): Use CLASS_TYPE_P. ++ * ptree.c (print_lang_type): Likewise. ++ * typeck.c (build_modify_expr, c_expand_asm_operands): Use ++ IS_AGGR_TYPE_CODE. ++ * typeck2.c (digest_init): Likewise. ++ ++1999-05-18 Jason Merrill ++ ++ * call.c (joust): Compare the types of the conv ops, not the ++ target types of the conversions. ++ ++Tue May 18 00:21:34 1999 Zack Weinberg ++ ++ * lang-specs.h: Define __GNUC__ and __GNUC_MINOR__ only if -no-gcc ++ was not given. ++ ++1999-05-17 Mark Mitchell ++ ++ * cp-tree.def (TEMPLATE_ID_EXPR): Update documentation. ++ * decl.c (grokfndecl): Don't allow inline declarations of friend ++ template specializations, or friend template specializations with ++ default arguments. ++ * pt.c (tsubst): Handle substitution into array types that does ++ not yield a fixed upper bound, even when not processing a ++ template. ++ (tsubst_copy): Deal with the fact that the second operand to a ++ TEMPLATE_ID_EXPR may be NULL_TREE, a TREE_LIST, or a TREE_VEC. ++ * search.c (marked_pushdecls_p): Don't descend into ++ TEMPLATE_TYPE_PARMs and the like. ++ (unmarked_pushdecls_p): Likewise. ++ ++ * call.c (build_over_call): Don't throw away ++ initializations/copies of empty classes; use MODIFY_EXPR and ++ INIT_EXPR as for non-empty classes. ++ * class.c (finish_struct_1): Put the padding byte for an empty ++ class on the TYPE_NONCOPIED_PARTS list for the class. ++ ++1999-05-16 Mark Mitchell ++ ++ * decl2.c (build_expr_from_tree): Handle COMPONENT_REFs that ++ indicate a reference to a field that is a qualified name. ++ ++1999-05-16 Jason Merrill ++ ++ * decl2.c (finish_objects): Don't use .?tors.* if we don't have ++ ASM_OUTPUT_CONSTRUCTOR. ++ ++ * friend.c (do_friend): Add attrlist arg. Remove support for ++ getting a non-decl as 'decl'. ++ * decl.c (grokfndecl): Remove attrlist arg. Don't set attrs or ++ rtl. ++ (grokdeclarator): Adjust. ++ * cp-tree.h: Adjust. ++ ++1999-05-16 Mark Mitchell ++ ++ * cp-tree.h (permanent_p): New function. ++ * init.c (build_new_1): Use mapcar, not copy_node, to copy a ++ possibly complex tree node. ++ * tree.c (mapcar): Adjust comments, and follow coding standards in ++ conditional. ++ (permanent_p): New function. ++ ++1999-05-13 Per Bothner ++ ++ * class.c (push_lang_context): Turn off DECL_IGNORED_P for ++ primitive Java types, if we actually see `extern "Java"'. ++ ++1999-05-10 18:21 -0400 Zack Weinberg ++ ++ * lang-specs.h: Pass -$ to the preprocessor. ++ ++1999-05-10 Jason Merrill ++ ++ * init.c (build_offset_ref): Wrap baselinks in OFFSET_REF, too. ++ Don't bother wrapping an OFFSET_TYPE around unknown_type_node. ++ (resolve_offset_ref): Don't handle a raw baselink. ++ * cvt.c (build_expr_type_conversion): Likewise. ++ * typeck.c (decay_conversion, build_c_cast, convert_for_assignment, ++ convert_for_initialization): Likewise. ++ * class.c (instantiate_type): Handle seeing a baselink under an ++ OFFSET_REF. ++ * error.c (dump_expr): Likewise. ++ * pt.c (for_each_template_parm): Likewise. ++ (resolve_overloaded_unification): Likewise. ++ * tree.c (is_overloaded_fn, really_overloaded_fn): Likewise. ++ * typeck.c (expr_sizeof): Also complain about other permutations ++ of overloaded functions. ++ ++1999-05-07 Jason Merrill ++ ++ * init.c (resolve_offset_ref): Don't return a raw method. ++ Use BASELINK_P. ++ * typeck.c (decay_conversion): Don't handle a raw method. ++ Resolve all OFFSET_REFs. ++ (get_member_function_from_ptrfunc): 0 is a valid vtable index. ++ (build_binary_op_nodefault): Handle resolving overloaded fns. Use ++ same_type_p for pmf bits. Don't use build_binary_op to compare ++ raw pointers to methods. ++ (convert_for_assignment): Check for OFFSET_REF, not OFFSET_TYPE, ++ to decide when to call resolve_offset_ref. ++ (build_c_cast, convert_for_initialization): Likewise. ++ * cvt.c (build_expr_type_conversion): Likewise. ++ ++1999-05-06 Nathan Sidwell ++ ++ * call.c (build_new_method_call): Use TYPE_MAIN_VARIANT of class. ++ ++1999-05-05 Mark Mitchell ++ ++ * decl2.c (start_objects): Don't let static constructors and ++ destructors get inlined. ++ ++ * parse.y (nested_name_specifier): Make sure ordinary types are ++ complete, just like template types. ++ * parse.c: Regenerated. ++ ++ * pt.c (check_explicit_specialization): Improve error messages. ++ ++1999-05-04 Martin von Löwis ++ ++ * typeck.c (string_conv_p): Use same_type_p to check whether we ++ try to convert between char and wchar_t. ++ ++1999-05-03 Mark Mitchell ++ ++ * search.c (lookup_field_r): Set the TREE_TYPE of an ambiguous ++ lookup to error_mark_node here. ++ (lookup_member): Revise documentation. Add comments. Don't set ++ the TREE_TYPE to error_mark_node here, and don't build up an extra ++ TREE_LIST for ambiguous lookups. ++ (setup_class_bindings): Adjust accordingly. ++ (push_class_decls): Revise out-of-date comments. ++ ++ * typeck.c (build_const_cast): Tighten checks for legality. ++ ++1999-05-02 Martin von Löwis ++ ++ * init.c (build_member_call): Lookup names coming from ++ namespace-scoped LOOKUP_EXPR. ++ ++1999-05-03 Jim Blandy ++ ++ * gxxint.texi: Add documentation for 'I'. ++ ++1999-05-02 Martin von Löwis ++ ++ * tinfo.cc (operator==): Qualify type_info with std::. ++ ++1999-05-02 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Remove comdat. Updated dummy. ++ (DECL_COMDAT): Remove definition. ++ ++1999-05-01 Mark Mitchell ++ ++ * decl.c (wrapup_globals_for_namespace): Fix thinko in previous ++ change. ++ ++1999-04-30 Mark Mitchell ++ ++ * class.c (build_vtable): Use build_lang_decl when building ++ vtables, not just build_decl. ++ (prepare_fresh_vtable): Likewise. ++ * decl.c (wrapup_globals_for_namespace): Mark vtables as ++ DECL_EXTERNAL when calling wrapup_global_declarations. ++ * decl2.c (priority_info_s): Add initializations_p and ++ destructions_p members. ++ (finish_vtable_vardecl): Use TREE_SYMBOL_REFERENCED, not TREE_USED, ++ when deciding what vtables to write out. ++ (ssdf_decls): New variable. ++ (ssdf_decls_used): Likewise. ++ (start_static_storage_duration_function): Deal with being called ++ multiple times. Avoid inlining this function. ++ (generate_inits_for_priority): Deal with reuse of priority map. ++ (get_priority_info): Clear initializations_p and destructions_p. ++ (do_static_initialization): Tweak comment. ++ (do_static_destruction): Likewise. Fix condition on sentries for ++ destruction. ++ (generate_ctor_or_dtor_function): Call all of the static storage ++ duration functions. ++ (generate_ctor_or_dtor_function_for_priority): Check ++ initializations_p and destructions_p to see what priorities need ++ initialization functions. ++ (finish_file): Rework to generate multiple static storage duration ++ functions, rather than just one. ++ ++ * typeck.c (build_const_cast): Tweak last change to handle ++ templates correctly. ++ ++ * typeck.c (build_const_cast): Disallow use of const_cast to ++ anything but a pointer or reference type. ++ ++1999-04-30 Nathan Sidwell ++ ++ * decl.c (cp_finish_decl): Don't permit arrays of abstract or ++ signature type. ++ ++1999-04-29 Mark Mitchell ++ ++ * decl2.c (do_static_destruction): Remove obsolete FIXME comment. ++ (finish_file): Indent comments properly. ++ ++1999-04-29 Richard Henderson ++ ++ * decl2.c (do_static_initialization): Call do_pending_stack_adjust. ++ (do_static_destruction): Likewise. ++ ++1999-04-29 Nathan Sidwell ++ ++ * cp-tree.h (TYPE_NOTHROW_P): New macro. ++ * decl2.c (delete_sanity): Warn on deleting void *. ++ * init.c (build_new_1): Use TYPE_NOTHROW_P. ++ * typeck.c (c_expand_return): cp_pedwarn on returning NULL from ++ throwing operator new. ++ ++1999-04-28 Nathan Sidwell ++ ++ * cp-tree.h (build_component_addr): Remove prototype. ++ * typeck.c (build_component_addr): Make static. Remove MSG ++ argument. ++ (build_component_addr): Remove MSG parameter, clean up ++ comment. ++ (build_x_function_call): Use cp_error. ++ (build_unary_op): Adjust call of build_component_addr. ++ ++1999-04-28 Mark Mitchell ++ ++ * pt.c (tsubst_friend_class): Check for NULL. ++ ++Wed Apr 28 11:42:22 1999 Andreas Schwab ++ ++ * search.c (binfo_for_vtable): Initialize bfvi.var. ++ ++1999-04-27 Nathan Sidwell ++ ++ * rtti.c (build_x_typeid): Check rtti is enabled. ++ ++1999-04-26 Mark Mitchell ++ ++ * search.c (is_subobject_of_p): Make sure we're looking at the ++ right baseclasses. ++ ++1999-04-26 Marc Espie ++ ++ * Make-lang.in (cplib2.ready): Don't depend on phony targets. ++ ++1999-04-23 Mark Mitchell ++ ++ * decl2.c (finish_file): Tweak handling of extern inlines so that ++ they are not unnecessarily put out. ++ ++ * search.c (is_subobject_of_p): Handle TEMPLATE_TYPE_PARMs and ++ such as base classes. ++ ++1999-04-22 Brendan Kehoe ++ ++ * tree.c (build_exception_variant): Fix typo: use the chain of U, ++ not trying V, while cycling through U. ++ ++1999-04-22 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Remove returns_first_arg and ++ preserves_first_arg. Enlarge dummy accordingly. ++ (DECL_TINFO_FN_P): New macro. ++ (SET_DECL_TINFO_FN_P): Likeiwse. ++ (DECL_RETURNS_FIRST_ARG): Remove. ++ (DECL_PRESERVES_THIS): Likewise. ++ (DECL_INIT_PRIORITY): New macro. ++ (finish_struct_1): Change prototype. ++ (cat_namespace_levels): Remove prototype. ++ (vtable_decl_p): New prototype. ++ (vtype_decl_p): Likewise. ++ (sigtable_decl_p): Likewise. ++ (walk_globals_pred): New typedef. ++ (walk_globals_fn): Likewise. ++ (walk_globals): New prototype. ++ (walk_namespaces_fn): New typedef. ++ (walk_namespaces): New prototype. ++ (wrapup_globals_for_namespace): Likewise. ++ (walk_vtables): Remove prototype. ++ (walk_sigtables): Likewise. ++ (instantiate_pending_templates): New prototype. ++ * class.c (finish_struct_1): Don't return a value. ++ * decl.h (pending_statics): Remove declaration. ++ * decl.c (walk_namespaces_r): New function. ++ (walk_globals_r): Likewise. ++ (vtable_decl_p): Likewise. ++ (vtype_decl_p): Likewise. ++ (sigtable_decl_p): Likewise. ++ (walk_namespaces): Likewise. ++ (walk_globals_data): New type. ++ (walk_globals): New function. ++ (wrapup_globals_for_namespace): Likewise. ++ (expand_static_init): Remove assertion. Remove redundancy in ++ conditional. Don't put static data members in static_aggregates ++ Tidy. ++ (finish_function): Remove redundancy in conditional. Don't set ++ DECL_RETURNS_FIRST_ARG. ++ (cat_namespace_levels): Remove. ++ * decl2.c: Include splay-tree.h and varray.h. ++ (priority_info_s): New structure. ++ (finish_vtable_vardecl): Change prototype. Adjust for new calling ++ conventions. ++ (prune_vtable_vardecl): Likewise. ++ (finish_sigtable_vardecl): Likewise. ++ (setup_initp): Remove. ++ (do_dtors): Remove. ++ (do_ctors): Remove. ++ (start_static_storage_duration_function): New function. ++ (generate_inits_for_priority): Likewise. ++ (finish_static_storage_duration_function): Likewise. ++ (get_priority_info): Likewise. ++ (do_static_initialization): Likewise. ++ (do_static_destruction): Likewise. ++ (do_static_initialization_and_destruction): Likewise. ++ (generate_ctor_or_dtor_function): Likewise. ++ (generate_ctor_and_dtor_functions_for_priority): Likewise. ++ (pending_statics): Make it a varray. ++ (pending_statics_used): New variable. ++ (saved_inlines): Make it a varray. ++ (saved_inlines_used): New variable. ++ (finish_static_data_member): Change method of updating ++ pending_statics. ++ (mark_inline_for_output): Remove #if 0'd code. Change method of ++ updating saved_inlines. ++ (walk_vtables): Remove. ++ (walk_sigtables): Likewise. ++ (import_export_decl): Use DECL_TINFO_FN_P. ++ (pending_templates): Remove declaration. ++ (maybe_templates): Likewise. ++ (static_aggregates_initp): Likewise. ++ (setup_initp): Likewise. ++ (finish_objects): Simplify. ++ (INITIALIZE_P_IDENTIFIER): New macro. ++ (PRIORITY_IDENTIFIER): New macro. ++ (SSDF_IDENTIFIER): New macro. ++ (initialize_p_decl): New variable. ++ (priority_decl): Likewise. ++ (ssdf_decl): Likewise. ++ (priority_info_map): Likewise. ++ (finish_file): Recode output of static intializers and other ++ file-scope finalization tasks. ++ * error.c (OB_END_TEMPLATE_ID): New macro. ++ (dump_type_real): Use it. ++ (dump_decl): Likewise. ++ (dump_function_name): Likewise. ++ * lex.c (set_typedecl_interface_info): Adjust for new walk_globals ++ interface. ++ (check_newline): Use walk_globals, not walk_vtables. ++ * pt.c (pending_tempalte_expansions): Remove. ++ (set_vardecl_interface_info): Likewise. ++ (pending_templates): Make static. ++ (maybe_templates): Likewise. ++ (instantiate_class_template): Adjust call to finish_struct_1. ++ (instantiate_pending_templates): New function. ++ * rtti.c (get_tinfo_fn): Use SET_DECL_TINFO_FN_P. ++ * tree.c (static_aggregates_initp): Remove. ++ (cp_valid_lang_attribute): Don't use it; use DECL_INIT_PRIORITY ++ instead. ++ * Makefile.in (decl2.o): Depend on varray.h and splay-tree.h. ++ ++ * gxx.gperf (RETURN): Rename to RETURN_KEYWORD to avoid clashes ++ with the RTL code RETURN. ++ * hash.h: Regenerated. ++ * lex.c (reinit_parse_for_block): Use RETURN_KEYWORD. ++ * parse.y: Replace RETURN with RETURN_KEYWORD throughout. ++ * parse.c: Regenerated. ++ * pt.c: Include varray.h. Include rtl.h since varray.h requires ++ it. ++ (inline_parm_levels): New variable. ++ (inline_parm_levels_used): Likewise. ++ (maybe_begin_member_template_processing): Update them. ++ (maybe_end_member_template_processing): Use them, rather than ++ guessing how many levels to pop. ++ ++ * decl.c (make_typename_type): Tighten error-checking. ++ ++1999-04-20 Mark Mitchell ++ ++ * cp-tree.h (build_binary_op): Remove unneeded parameter. ++ * class.c (build_vrable_entry_ref): Adjust call to ++ build_binary_op. ++ * decl.c (expand_static_init): Likewise. ++ (grokdeclarator): Likewise. ++ (finish_function): Likewise. ++ * decl2.c (delete_sanity): Likewise. ++ (do_dtors): Likewise. ++ (do_ctors): Likewise. ++ * error.c (dump_type_suffix): Likewise. ++ * expr.c (cplus_expand_expr): Likewise. ++ * init.c (resolve_offset_ref): Likewise. ++ (build_new): Likewise. ++ (build_new_1): Likewise. ++ (build_vec_delete_1): Likewise. ++ (expand_vec_init_catch_clause): Likewise. ++ (build_delete): Likewise. ++ * pt.c (tsubst): Likewise. ++ * rtti.c (synthesize_tinfo_fn): Likewise. ++ * search.c (expand_upcast_fixups): Likewise. ++ (expand_direct_vtbls_init): Likewise. ++ * typeck.c (get_member_function_from_ptrfunc): Likewise. ++ (build_binary_op_nodefault): Likewise. ++ (point_int_sum): Likewise. ++ (pointer_diff): Likewise. ++ (build_unary_op): Likewise. ++ (build_modify_expr): Likewise. ++ (get_delta_difference): Likewise. ++ (build_ptrmemfunc): Likewise. ++ (expand_ptrmemfunc_cst): Likewise. ++ ++1999-04-20 Jason Merrill ++ ++ * decl.c (grokfndecl): Always call cplus_decl_attributes. ++ * decl2.c (grokfield): Pass attrlist to grokdeclarator. ++ ++1999-04-19 Mark Mitchell ++ ++ * cp-tree.h (finish_static_data_member_decl): New function. ++ * decl2.c (finish_static_data_member_decl): Split out from ... ++ (grokfield): Here. ++ * pt.c (instantiate_class_template): Use it here instead of ++ trying to fake it. ++ (tsubst_decl): Don't set DECL_ASSEMBLER_NAME; ++ finish_static_data_member_decl will do that. Explicit set ++ DECL_EXTERNAL to match non-template processing. ++ ++1999-04-18 Mark Mitchell ++ ++ * cp-tree.h (finish_class_definition): Add parameter. ++ * parse.y (structsp): Use it. Don't call pop_scope here. ++ * parse.c: Regenerated. ++ * semantics.c (finish_class_definition): Pop it here. ++ ++1999-04-17 Mark Mitchell ++ ++ * decl.c (xref_tag): Revise handling of nested template ++ declarations. ++ * pt.c (check_explicit_specialization): Tweak handling of friend ++ templates in template classes. ++ (tsubst_friend_class): Handle friend declarations for nested ++ member template classes. ++ ++1999-04-16 Mark Mitchell ++ ++ * class.c (finish_struct): Remove unused variable. ++ (pushclass): Likewise. ++ (invalidate_class_lookup_cache): Likewise. ++ * cp-tree.def (TYPENAME_TYPE): Improve documentation. ++ * decl.c (build_typename_type): Make sure TYPENAME_TYPE_FULLNAME ++ doesn't get obliterated. ++ (make_typename_type): Handle template classes correctly. ++ ++ * cp-tree.h (TREE_NONLOCAL_FLAG): Remove. ++ (storetags): Declare. ++ * class.c (finish_struct): Don't use TREE_NONLOCAL_FLAG. ++ (pushclass): Likewise. Use storetags to install tag declarations, ++ not pushtag. ++ (invalidate_class_lookup_cache): Don't use TREE_NONLOCAL_FLAG. ++ * decl.c (storetags): Make it global. ++ (push_class_binding): Set INHERITED_VALUE_BINDING_P for an ++ implicit typename declaration. ++ (pushtag): Tidy. Don't use TREE_NONLOCAL_FLAG. ++ * method.c (hack_identifier): Likewise. ++ * search.c (lookup_member): Likewise. ++ ++ * decl.c (warn_about_implicit_typename_lookup): New function. ++ (lookup_name_real): Use it. Rework handling of implicit typename ++ extension. ++ ++1999-04-15 Mark Mitchell ++ ++ * cp-tree.h (lookup_nested_field): Remove. ++ * class.c (push_nested_class): Handle UNION_TYPEs. ++ (pop_nested_class): Likewise. ++ * decl.c (lookup_name_real): Don't call lookup_nested_field. ++ (start_decl): Use push_nested_class, not just pushclass. ++ (cp_finish_decl): Use pop_nested_class, not just popclass. ++ * search.c (lookup_nested_field): Remove. ++ ++ * cp-tree.h (lang_type): Add documentation. ++ * decl2.c (handle_class_head): Create template declarations here, ++ as appropriate. ++ * parse.y (class_head): Return whether or not we entered a new ++ scope, as well as the type named. ++ (named_class_head): Likewise. ++ (named_complex_class_head_sans_basetype): Likewise. ++ (structsp): Adjust accordingly. Pop scope when required. ++ * parse.c: Regenerated. ++ * pt.c (check_default_tmpl_args): Robustify. ++ (redeclare_class_template): Likewise. ++ (instantiate_class_template): An instantiation of an ++ anonymous union is itself an anonymous union. ++ * semantics.c (begin_class_definition): Don't create template ++ declarations here. ++ ++1999-04-15 Jason Merrill ++ ++ * parse.y (after_type_declarator_intern): New nonterminal. ++ (after_type_declarator): Use it. ++ (direct_after_type_declarator): Likewise. Move above ++ nonnested_type to fix reduce/reduce conflict resolution. ++ (declmods): Reducing from just 'attributes' has EMPTY precedence. ++ * Makefile.in (CONFLICTS): Update. ++ ++ * decl.c (define_label): Downgrade error for jumping over a ++ non-POD decl to pedwarn. ++ ++1999-04-14 Mark Mitchell ++ ++ * cp-tree.h (popclass): Change declaration. ++ (pop_nested_class): Likewise. ++ (poplevel_class): Remove declaration. ++ * call.c (convert_default_argument): Pass no arguments to ++ popclass. ++ * class.c (finish_struct_1): Likewise. ++ (finish_struct): Likewise. ++ (popclass): Remove argument. Simplify code accordingly. ++ (pop_nested_class): Likewise. ++ * decl.c (poplevel_class): Declare it here, and make it static. ++ (poplevel): Handle class scopes. ++ (poplevel_class): Don't take an rgument. Simplify. ++ (pop_everything): Pass no arguments to pop_nested_class. ++ (cp_finish_decl): Pass no arguments to popclass. ++ (grokdeclarator): Pass no arguments to pop_nested_class. ++ (finish_function): Likewise. ++ * decl2.c (grokfield): Likewise. ++ (pop_scope): Pass no arguments to popclass. ++ * lex.c (do_pending_defargs): Pass no arguments to pop_nested_class. ++ * pt.c (instantiate_class_template): Move call to pushclass, and ++ document. Pass no arguments to popclass. ++ (regenerate_decl_from_template): Likewise. ++ ++1999-04-14 Jason Merrill ++ ++ * typeck.c (build_unary_op): Handle taking the address of a unique ++ bound non-static member function. ++ ++1999-04-13 Martin von Loewis ++ ++ * lang-options.h (-Wdeprecated): New flag. ++ * decl2.c (warn_deprecated): New flag. ++ (lang_decode_option): Deprecated this-is-variable, ++ external-templates, alt-external-templates. ++ Support -Wdeprecated. ++ * errfn.c (cp_deprecated): New function. ++ ++1999-04-13 Jason Merrill ++ ++ * decl2.c (setup_initp): Compare DECL_ASSEMBLER_NAME instead ++ of the decls themselves. ++ ++ * pt.c (tsubst_function_type): Copy attributes over. ++ ++ * tree.c (cp_valid_lang_attribute): New fn. Handle init_priority ++ and com_interface. ++ * cp-tree.h: Add prototype. ++ * decl.c (init_decl_processing): Set valid_lang_attribute. ++ ++1999-04-13 Mark Mitchell ++ ++ * class.c (finish_struct_1): Look at the const-ness of the field's ++ type, not the TREE_READONLY-ness of the declaration. ++ * method.c (synthesize_method): Likewise. ++ * pt.c (tsubst_decl): Call c_apply_type_quals_to_decl when ++ creating new declarations. ++ ++1999-04-13 Mike Stump ++ ++ * decl2.c (import_export_decl): Because vtables always reference ++ virtual functions, even if they are inlined, don't allow ++ -fno-implement-inlines to not emit them, instead, emit them with ++ the vtable. ++ * decl.c (start_function): Likewise. ++ ++1999-04-12 Jason Merrill ++ ++ * cp-tree.h (struct lang_type): Add com_interface. ++ (CLASSTYPE_COM_INTERFACE): New macro. ++ * class.c (set_rtti_entry): COM interface classes have no RTTI ++ entries in their vtables; adjust. ++ (add_virtual_function, finish_base_struct, skip_rtti_stuff, ++ modify_one_vtable, fixup_vtable_deltas1, override_one_vtable, ++ finish_struct_1): Likewise. ++ * decl2.c (mark_vtable_entries): Likewise. ++ * rtti.c (build_headof, get_tinfo_fn_dynamic): Likewise. ++ * search.c (get_abstract_virtuals_1, get_abstract_virtuals, ++ expand_upcast_fixups): Likewise. ++ * tree.c (debug_binfo): Likewise. ++ ++ * cp-tree.h (COMPARE_NO_ATTRIBUTES): New macro. ++ * typeck.c (comptypes): If we get it, ignore attributes. ++ * class.c (instantiate_type): Use BASELINK_P. Change complain ++ parameter to flags; 2 means ignore attributes. ++ * call.c (build_op_delete_call): Pass it. ++ ++ * decl.c (xref_tag): Only complain once about using a typedef-name ++ with 'struct'. Downgrade to pedwarn. ++ ++ * decl.c (grokdeclarator): Allow [] syntax for zero-length array. ++ ++ * parse.y (absdcl_intern): New nonterminal. ++ (absdcl, direct_abstract_declarator): Use it. ++ ++ * pt.c (lookup_template_class): Look through implict typename. ++ ++1999-04-11 Mark Mitchell ++ ++ * friend.c (add_friend): Deal gracefully with error_mark_node. ++ * method.c (build_overload_value): Handle pointers-to-members as ++ template parameters. ++ ++ * decl.c (push_binding): Fix typo in comment. ++ ++1999-04-10 Mark Mitchell ++ ++ * error.c (dump_type_real): If a typename is a template-id, put ++ out the template arguments. ++ (dump_expr): Handle TEMPLATE_ID_EXPR. ++ * pt.c (lookup_template_class): Now that full arguments are ++ available everywhere, remove code that tried to guess them. ++ ++1999-04-09 Mark Mitchell ++ ++ * decl.c (make_typename_type): Complain if we don't find a type ++ when trying to make a typename type for a non-template type. ++ ++1999-04-09 Jason Merrill ++ ++ * decl.c (start_decl): Pass attributes to grokdeclarator. ++ (grokdeclarator): Handle attributes on constructor-syntax ++ initializers. ++ ++1999-04-08 Mark Mitchell ++ ++ * error.c (dump_expr): Don't crash on INDIRECT_REFs whose operands ++ don't have types. ++ ++ * search.c (template_self_reference_p): Tweak. ++ ++1999-04-07 Mark Mitchell ++ ++ * init.c (build_offset_ref): Don't build yet another weird data ++ structure to describe overloaded functions. ++ ++1999-04-06 Mark Mitchell ++ ++ * cp-tree.h (BASELINK_P): New macro. ++ (SET_BASELINK_P): Likewise. ++ * init.c (build_member_call): Remove needless assignment in if ++ statement. ++ * search.c (lookup_field_r): Fix handling when we are looking ++ specifically for a type; these are not hidden by functions and ++ variables. ++ (lookup_member): Use SET_BASELINK_P. ++ * tree.c (is_overloaded_fn): Use BASELINK_P. ++ (really_overloaed_fn): Likewise. ++ (get_first_fn): Likewise. ++ ++1999-04-05 Mark Mitchell ++ ++ * decl.c (lookup_name_current_level): Tweak, and improve ++ documentation. ++ ++ * class.c (maybe_fixup_vptrs): Remove declaration. ++ (build_class_init_list): Likewise. ++ * decl.c (pushdecl_class_level): Call check_template_shadow here ++ ... ++ (push_class_level_binding): ... not here. ++ * search.c (dfs_push_type_decls): Only avoid ++ template-self-reference TYPE_DECLs if they are from base classes. ++ ++1999-04-04 Mark Mitchell ++ ++ * pt.c (check_template_shadow): Don't treat OVERLOADs as _DECL ++ nodes. Tidy. ++ ++1999-04-03 Jason Merrill ++ ++ * class.c (maybe_fixup_vptrs, build_class_init_list): Lose. ++ (finish_struct_1): Don't call build_class_init_list. ++ ++1999-04-02 Mark Mitchell ++ ++ * tinfo.h (__class_type_info): Fix illegal declaration. ++ ++ * cp-tree.def (TEMPLATE_ID_EXPR): Update comment. ++ * cp-tree.h (INHERITED_VALUE_BINDING_P): New macro. ++ (IDENTIFIER_CLASS_VALUE): Improve documentation. ++ (is_properly_derived_from): Declare. ++ (invalidate_class_lookup_cache): Likewise. ++ (maybe_maybe_note_name_used_in_class): Likewise. ++ (note_name_declared_in_class): Likewise. ++ (push_using_decl): Remove duplicate declaration. ++ (id_in_current_class): Remove declaration. ++ (push_class_binding): Change prototype. ++ (clear_identitifer_class_values): Declare. ++ * call.c (is_properly_derived_from): Make it global. ++ (build_new_function_call): Be careful about updating candidates. ++ (build_new_method_call): Handle COMPONENT_REFs. Don't crash when ++ asked to make illegal calls. ++ * class.c: Include splay-tree.h. ++ (class_stack_node): Add names_used slot. ++ (check_member_decl_is_same_in_complete_scope): Remove. ++ (add_method): Fix comment. Push the declaration into class ++ scope. ++ (finish_struct_1): When popping the class, pop the bindings too. ++ Remove check for data member/function member conflict. ++ (finish_struct): Remove calls to ++ check_member_decl_is_same_in_complete_scope. Change calls to ++ popclass. ++ (pushclass): Clear names_used in the class stack entry. ++ Use invalidate_class_lookup_cache to remove cached entries, rather ++ than magic values with popclass. Clear IDENTIFIER_CLASS_VALUE ++ before entering a new class. Remove dead code. Don't mess with ++ current_function_decl when pushing declarations. ++ (invalidate_class_lookup_cache): New function, split out from ... ++ (popclass): Here. Clean up names_used on our way out. ++ (instantiate_type): Adjust. ++ (build_self_reference): Don't push the declaration here. ++ (maybe_note_name_used_in_class): New function. ++ (note_name_declared_in_class): Likewise. ++ * decl.c (add_binding): Change prototype. ++ (find_class_binding_level): New function. ++ (innermost_nonclass_level): Likewise. ++ (current_binding_level): Update documentation. ++ (inner_binding_level): Remove. Replace with current_binding_level ++ throughout. ++ (push_binding_level): Remove special handling of ++ class_binding_level. ++ (pop_binding_level): Likewise. Use find_class_binding_level. ++ (suspend_binding_level): Likewise. ++ (global_bindings_p): Use innermost_nonclass_level. ++ (toplevel_bindings_p): Likewise. ++ (namespace_bindings_p): Likewise. ++ (pseudo_global_level_p): Likewise. ++ (push_binding): Clear INHERITED_VALUE_BINDING_P. ++ (add_binding): Check for illegal multiple declarations. Return a ++ value indicating whether or not the new binding was legal. ++ (push_local_binding): Skip over class binding levels. Check ++ return value from add_binding. ++ (push_class_binding): Set INHERITED_VALUE_BINDING_P. Call ++ note_name_declared_in_class. ++ (pushlevel_class): Remove "fake out the rest of the compiler" ++ code. ++ (poplevel_class): Reset IDENTIFIER_CLASS_VALUEs. ++ (clear_identifier_class_values): New function. ++ (pop_from_top_level): Use it. ++ (pop_everything): Tweak. ++ (maybe_process_template_type_declaration): Don't push the ++ declaration for the template here. ++ (pushtag): Don't push tag declarations into class scope here. ++ (pushdecl): Apply DeMorgan's law for readability. ++ (pushdecl_class_level): Remove special-case code for ++ TYPE_BEING_DEFINED. Handle OVERLOADs and anonymous unions. ++ (push_class_level_bindng): Deal with inherited bindings. ++ (lookup_name_real): Remove special-case code for ++ TYPE_BEING_DEFINED, and some implicit typename magic. ++ (grokdeclarator): Handle COMPONENT_REF for a template function. ++ (build_enumerator): Don't call pushdecl_class_level here. ++ (id_in_current_class): Remove. ++ * decl2.c (grokfield): Don't call pushdecl_class_level or ++ check_template_shadow. ++ * errfn.c (cp_file_of): Don't declare. ++ (cp_line_of): Likewise. ++ * error.c (dump_decl): Handle an OVERLOAD. ++ (cp_file_of): Likewise. ++ (cp_line_of): Likewise. ++ * init.c (build_member_call): Handle a COMPONENT_REF. ++ * lex.c (do_identifier): Call maybe_note_name_used_in_class, not ++ pushdecl_class_level. ++ * method.c (hack_identifier): Build COMPONENT_REFs for references ++ to member templates as well as member functions. Remove dead ++ code. ++ * parse.y (left_curly): Remove. ++ (nonnested_type): Call maybe_note_name_used_in_class, not ++ pushdecl_class_level. ++ * parse.c: Regenerated. ++ (nested_name_specifier_1): Likewise. ++ * pt.c (check_explicit_specialization): Adjust, for robustness. ++ (check_template_shadow): Handle OVERLOADs. ++ (build_template_decl): Set DECL_CONSTRUCTOR_P on the ++ TEMPLATE_DECL, if appropriate. ++ * search.c (envelope_add_decl): Remove. ++ (dfs_pushdecls): Likewise. ++ (dfs_compress_decls): Likewise. ++ (dfs_push_decls): New function. ++ (dfs_push_type_decls): Likewise. ++ (setup_class_bindings): Likewise. ++ (template_self_reference_p): Likewise. ++ (lookup_field_r): Use it. ++ (looup_member): Remove old comment. Deal with ambiguity. ++ (push_class_decls): Use dfs_push_decls and dfs_push_type_decls, ++ and remove envelope processing. ++ * semantics.c (begin_class_definition): Let pushclass push ++ declarations for base classes. ++ (finish_member_declaration): Push declarations into class scope. ++ * typeck.c (build_component_ref): Just put an OVERLOAD into the ++ COMPONENT_REF, not a TREE_LIST of an OVERLOAD. ++ (build_x_function_call): Deal with OVERLOAD. Handle template-ids. ++ * Makefile.in (class.o): Depend on splay-tree.h. ++ ++Wed Mar 31 11:30:43 1999 Nathan Sidwell ++ ++ * cvt.c (convert_pointer_to_real): Use same_type_p. ++ * typeck.c (comp_target_types): Use same_type_p. ++ ++1999-03-31 Jason Merrill ++ ++ * semantics.c (begin_inline_definitions, ++ finish_inline_definitions): Rename from finish_default_args and ++ begin_inline_definitions, respectively, to something that isn't a ++ total lie. :) ++ * parse.y (structsp): Adjust. ++ ++ * tree.c (hash_tree_cons): Remove obsolete via_* parms. ++ (list_hash_lookup): Likewise. ++ (hash_tree_chain): Adjust. ++ * pt.c (tsubst): Adjust. ++ (tsubst_arg_types): Use plain hash_tree_cons. ++ * cp-tree.h (hash_tree_cons_simple): Lose. ++ * parse.y (declmods, nonempty_cv_qualifiers): Use hash_tree_cons. ++ ++Wed Mar 31 10:48:29 1999 Kaveh R. Ghazi ++ ++ * Makefile.in (hash.h): Generate using gperf language 'C', not ++ 'KR-C', so gperf uses the `const' keyword on strings. ++ ++ * gxx.gperf (resword): Const-ify a char*. ++ ++1999-03-30 Jason Merrill ++ ++ * cp-tree.h (IDENTIFIER_AS_DESC, IDENTIFIER_AS_LIST, ++ CLASSTYPE_BASELINK_VEC, CLASSTYPE_N_SUPERCLASSES, ++ CLASSTYPE_N_BASECLASSES, CLASSTYPE_MAX_DEPTH, ++ CLASSTYPE_BASE_INIT_LIST, CLASSTYPE_AS_LIST, CLASSTYPE_ID_AS_LIST, ++ CLASSTYPE_BINFO_AS_LIST): Remove cruft. ++ * class.c, lex.c, parse.y, ptree.c, search.c, semantics.c, ++ tree.c: Adjust. ++ ++1999-03-29 Jason Merrill ++ ++ * decl2.c (lang_decode_option): Remove -Wsign-promo from -Wall. ++ ++1999-03-28 Jason Merrill ++ ++ * pt.c (fn_type_unification): Ignore 'this' parm from conversion ops. ++ ++1999-03-27 Mark Mitchell ++ ++ * cp-tree.h (add_friend): Declare. ++ (add_friends): Likewise. ++ * friend.c (add_friend): Make it global. Don't add to ++ DECL_BEFRIENDING_CLASSES if the befriending class is a template. ++ (add_friends): Make it global. ++ (make_friend_class): Don't add to DECL_BEFRIENDING_CLASSES if the ++ befriending class is a template. ++ * parse.y (component_decl_1): Fix typo in comment. ++ * parse.c: Regenerated. ++ * pt.c (instantiate_class_template): Use add_friend and ++ add_friends rather that duplicating some of their functionality ++ here. ++ ++1999-03-27 Jason Merrill ++ ++ * call.c (build_field_call): Unify 'this' and non-'this' cases. ++ ++ * typeck.c (build_indirect_ref): Check for 'this' sooner. ++ ++Fri Mar 26 10:20:34 1999 Kaveh R. Ghazi ++ ++ * call.c (op_error): Const-ify a char*. ++ (add_candidate, source_type, add_warning): Add static prototype. ++ (print_z_candidates): Const-ify a char*. ++ ++ * class.c (resolve_address_of_overloaded_function, ++ fixed_type_or_null, build_vtable_entry_ref): Add static prototype. ++ (get_vtable_name, finish_struct_1): Const-ify a char*. ++ ++ * cvt.c (convert_to_reference): Likewise. ++ ++ * decl.c (redeclaration_error_message, record_builtin_type, ++ record_unknown_type, member_function_or_else, bad_specifiers): ++ Likewise. ++ (find_binding, select_decl, unqualified_namespace_lookup, ++ lookup_flags, qualify_lookup, record_builtin_java_type, tag_name): ++ Add static prototype. ++ (warn_extern_redeclared_static, duplicate_decls, pushdecl, ++ implicitly_declare, record_builtin_java_type, define_function, ++ grok_op_properties, tag_name): Const-ify a char*. ++ ++ * cp-tree.h (FORMAT_VBASE_NAME): Allow parameter `BUF' to be const. ++ (define_function, finish_builtin_type): Const-ify a char*. ++ (cp_error, cp_error_at, cp_warning, cp_warning_at, cp_pedwarn, ++ cp_pedwarn_at, cp_compiler_error, cp_sprintf): Add prototype args. ++ (file_name_nondirectory): Const-ify a char*. ++ (init_filename_times): Don't prototype. ++ (compiler_error): Prototype. ++ (yyerror, init_repo): Const-ify a char*. ++ (build_srcloc): Don't prototype. ++ (build_x_indirect_ref, build_indirect_ref, build_component_addr): ++ Const-ify a char*. ++ (warn_for_assignment): Don't prototype. ++ (convert_for_initialization, readonly_error, check_for_new_type, ++ GNU_xref_begin, GNU_xref_file, GNU_xref_ref, GNU_xref_call): ++ Const-ify a char*. ++ ++ * decl2.c (acceptable_java_type, output_vtable_inherit, ++ setup_initp, start_objects, finish_objects, do_dtors, do_ctors, ++ merge_functions, decl_namespace, validate_nonmember_using_decl, ++ do_nonmember_using_decl): Add static prototype. ++ (lang_f_options): Const-ify a char*. ++ (finish_builtin_type): Likewise. ++ (add_function, arg_assoc_namespace, arg_assoc_class): Add static ++ prototype. ++ ++ * errfn.c: Include cp-tree.h. ++ (cp_thing): Add static prototype. ++ (compiler_error): Don't protoptype. ++ (cp_compiler_error): Cast `compiler_error' to `errorfn' before ++ passing it to `cp_thing'. ++ ++ * error.c (interesting_scope_p): Add static prototype. ++ ++ * except.c (build_eh_type_type, build_eh_type_type_ref): Const-ify ++ a char*. ++ ++ * init.c (compiler_error): Don't prototype. ++ (member_init_ok_or_else): Const-ify a char*. ++ (build_java_class_ref): Add static prototype. ++ ++ * lex.c (compiler_error): Don't prototype. ++ (get_time_identifier, interface_strcmp, extend_token_buffer, ++ handle_cp_pragma): Const-ify a char*. ++ (is_global, init_filename_times): Add static prototype. ++ (file_name_nondirectory, cplus_tree_code_name): Const-ify a char*. ++ (compiler_error): Change from fixed args to variable args. ++ (yyerror): Const-ify a char*. ++ ++ * parse.y (cond_stmt_keyword): Const-ify a char*. ++ (parse_decl): Add static prototype. ++ ++ * pt.c (template_args_equal, print_template_context): Likewise. ++ (print_candidates, check_default_tmpl_args): Const-ify a char*. ++ (instantiate_class_template): Likewise. ++ ++ * repo.c (get_base_filename, open_repo_file, init_repo): Likewise. ++ ++ * rtti.c (call_void_fn, expand_generic_desc, expand_si_desc, ++ expand_class_desc, expand_ptr_desc, expand_attr_desc): Likewise. ++ ++ * search.c (lookup_field_info, lookup_member): Likewise. ++ (lookup_member): Cast the first argument of `bzero' to a PTR. ++ ++ * sig.c (compiler_error): Don't prototype. ++ (build_signature_pointer_or_reference_nam): Const-ify a char*. ++ (get_sigtable_name, build_member_function_pointer): Likewise. ++ ++ * tree.c (compiler_error): Don't prototype. ++ (no_linkage_helper, build_srcloc): Add static prototype. ++ (build_vbase_pointer_fields): Const-ify a char*. ++ (__eprintf): Don't unnecessarily handle `const' when !__STDC__. ++ ++ * typeck.c (compiler_error): Don't prototype. ++ (convert_for_assignment): Const-ify a char*. ++ (comp_cv_target_types): Add static prototype. ++ (build_x_indirect_ref, build_indirect_ref, convert_arguments, ++ build_component_addr, build_unary_op, convert_for_initialization): ++ Const-ify a char*. ++ ++ * typeck2.c (ack): Add static prototype and change from fixed args ++ to variable args. ++ (readonly_error, check_for_new_type): Const-ify a char*. ++ ++ * xref.c (_XREF_FILE, find_file, filename, fctname, declname, ++ fixname, open_xref_file, classname, GNU_xref_begin): Likewise. ++ (GNU_xref_file): Likewise. Also use `xmalloc' instead of `malloc'. ++ (GNU_xref_end_scope, GNU_xref_ref, GNU_xref_decl, GNU_xref_call, ++ gen_assign, GNU_xref_member): Const-ify a char*. ++ ++1999-03-25 Martin von Löwis ++ ++ * gxxint.texi: Remove old discussion on copying virtual bases. ++ ++1999-03-25 Zack Weinberg ++ ++ * Make-lang.in: Remove all references to g++.o/g++.c. ++ Link g++ from gcc.o. ++ ++1999-03-25 Jason Merrill ++ ++ * decl2.c (comdat_linkage): Treat vtables like functions. ++ ++1999-03-25 Mark Mitchell ++ ++ * pt.c (tsubst_decl): tsubst into DECL_BEFRIENDING_CLASSES. ++ ++1999-03-25 Nathan Sidwell ++ ++ * decl.c (init_decl_processing): Add `signed' type as a synonym ++ for `int'. ++ ++1999-03-25 Jason Merrill ++ ++ * typeck.c (common_type): Handle cv-qual unification for pointers ++ to members. ++ ++ * decl.c (unqualified_namespace_lookup): Return error_mark_node ++ on error. ++ (lookup_name_real): Set LOOKUP_COMPLAIN when *not* parsing. ++ * lex.c (do_identifier): If we got error_mark_node, call ++ lookup_name again. ++ ++1999-03-24 Martin von Löwis ++ ++ * class.c (finish_struct_1): Always reset TYPE_FIELDS for empty ++ classes. ++ ++1999-03-24 Jason Merrill ++ ++ * decl.c (lookup_name_real): Do nested field lookup regardless of ++ TYPE_BEING_DEFINED. ++ ++1999-03-24 Mark Mitchell ++ ++ * cp-tree.h (lang_type): Remove has_assignment and ++ has_real_assignment. Add befriending_classes. ++ (TYPE_HAS_ASSIGNMENT): Remove. ++ (TYPE_HAS_REAL_ASSIGNMENT): Likewise. ++ (CLASSTYPE_BEFRIENDING_CLASSES): New macro. ++ (lang_decl): Document. ++ (DECL_BEFRIENDING_CLASSES): New macro. ++ (FRIEND_NAME): Move declaration to more obvious location. ++ (FRIEND_DECLS): Likewise. ++ * class.c (finish_struct_1): Don't use TYPE_HAS_REAL_ASSIGNMENT. ++ * decl.c (duplicate_decls): Copy DECL_BEFRIENDING_CLASSES. ++ (fixup_anonymous_union): Don't use TYPE_HAS_ASSIGNMENT. ++ (grok_op_properties): Likewise. ++ * friend.c (is_friend): Use FRIEND_NAME and FRIEND_DECLS. ++ (add_friend): Likewise. Don't do weird things with assignment ++ operators. Update DECL_BEFRIENDING_CLASSES. ++ (add_friends): Don't do weird things with assignment operators. ++ (make_friend_class): Likewise. Update ++ CLASSTYPE_BEFRIENDING_CLASSES. ++ * pt.c (instantiate_class_template): Don't set ++ TYPE_HAS_ASSIGNMENT. ++ (tsubst_copy): Substitute the TREE_TYPE for more unary ++ expressions. ++ * ptree.c (print_lang_type): Don't look at TYPE_HAS_ASSIGNMENT. ++ * search.c (protected_accessible_p): New function. ++ (friend_accessible_p): Likewise. ++ (accessible_p): Use them. ++ ++1999-03-23 Mark Mitchell ++ ++ * pt.c (convert_nontype_argument): Don't create things that aren't ++ PTRMEM_CSTs when applying a qualification conversion to a ++ PTRMEM_CST. ++ ++1999-03-23 Mark Mitchell ++ ++ * Makefile.in (OBJS): Don't mention hash.o. ++ (OBJDEPS): Likewise. ++ ++1999-03-23 Jason Merrill ++ ++ * decl2.c (finish_file): Set at_eof to 2 after expanding ctors. ++ * decl.c (expand_static_init): Make sure we don't add any after ++ then. ++ ++ * decl.c (cp_finish_decl): Move intelligence about handling ++ DECL_COMDAT for variables from here... ++ * decl2.c (comdat_linkage): ...to here. ++ (maybe_make_one_only): Tweak. ++ (import_export_decl): Call comdat_linkage for variables, too. ++ (finish_file): Handle template statics properly. ++ ++1999-03-22 Mark Mitchell ++ ++ * cp-tree.h (TYPE_PTRMEMFUNC_P): Use TYPE_PTRMEMFUNC_FLAG. ++ Document internals of pointer-to-member-functions. ++ (DELTA2_FROM_PTRMEMFUNC): Make it call delta2_from_ptrmemfunc. ++ (PFN_FROM_PTRMEMFUNC): Likewise. ++ (build_type_conversion): Remove unused parameter. ++ (build_ptrmemfunc1): Declare. ++ (expand_ptrmemfunc_cst): New function. ++ (delta2_from_ptrmemfunc): Likewise. ++ (pfn_from_ptrmemfunc): Likewise. ++ * cvt.c (cp_convert_to_pointer): Remove unused parameter to ++ build_type_conversion. Use TYPE_PTRMEM_P for readability. ++ (convert_to_reference): Remove unused parameter to ++ build_type_conversion. ++ (ocp_convert): Likewise. ++ (build_user_type_conversion): Likewise. ++ * error.c (dump_expr): Handle NULL pointer-to-member functions. ++ * expr.c (cplus_expand_expr): Handle PTRMEM_CSTs for functions. ++ * method.c (build_overload_value): Don't go splitting CONSTRUCTORs ++ open when handling pointer-to-member functions. ++ * pt.c (convert_nontype_argument): Clean up error messages. Be ++ more stringent with pointers-to-members. ++ * typeck.c (build_ptrmemfunc1): Don't declare. Make it global. ++ (build_unary_op): Tidy ever-so-slightly. ++ (build_conditional_expr): Remove extra parameter to ++ build_type_conversion. ++ (build_ptrmemfunc): Build PTRMEM_CSTs if we know what function ++ we're using. ++ (expand_ptrmemfunc_cst): Define. ++ (delta2_from_ptrmemfunc): Likewise. ++ (pfn_from_ptrmemfunc): Likewise. ++ ++1999-03-19 Mark Mitchell ++ ++ * init.c (build_member_call): Handle template-id expressions ++ correctly. ++ * typeck.c (build_x_function_call): Likewise. ++ ++1999-03-19 Chip Salzenberg ++ ++ * friend.c (make_friend_class): Avoid core dump when ++ not-yet-defined friend type lacks TYPE_LANG_SPECIFIC(). ++ ++1999-03-18 Jason Merrill ++ ++ * decl.c (start_function): Suppress normal linkage heuristics ++ for #pragma interface under MULTIPLE_SYMBOL_SPACES. ++ ++1999-03-19 Alexandre Oliva ++ ++ * Make-lang.in: ($(INTL_TARGETS)): Depend on cp/parse.c. ++ ($(srcdir)/cp/parse.c): Moved from ../Makefile.in. ++ ++1999-03-17 Martin von Löwis ++ ++ * parse.y (named_complex_class_head_sans_basetype): ++ Do not push a scope for error_mark_node. ++ (maybe_base_class_list): Likewise. ++ ++ * decl.c (start_decl): Check for error_mark_node as a type. ++ Detected by g++.brendan/array-refs.C. ++ (start_decl_1): Likewise. Detected by g++.bugs/900322_01.C. ++ (maybe_build_cleanup_1): Likewise. Detected by ++ g++.jason/incomplete1.C. ++ ++ * tree.c (build_dummy_object): Use void_zero_node instead of the ++ error_mark_node. ++ (is_dummy_object): Check for such a node. ++ Detected by g++.bob/inherit1.C ++ ++1999-03-16 Jason Merrill ++ ++ * method.c (old_backref_index): Split out... ++ (flush_repeats): From here. Rename back from try_old_backref. ++ (build_mangled_name): Put back some old-style repeat handling. ++ ++Mon Mar 15 21:57:16 1999 Kaveh R. Ghazi ++ ++ * lex.c: Don't include setjmp.h. ++ (parse_float): New static function. ++ (pf_args): New struct. ++ (real_yylex): Use them in call to `do_float_handler'. ++ ++1999-03-15 Mark Mitchell ++ ++ * decl.c (xref_basetypes): Set CLASSTYPE_VBASECLASSES here. ++ * tree.c (layout_basetypes): Not here. ++ * search.c (dfs_search): Remove; no longer used. ++ ++1999-03-12 Mark Mitchell ++ ++ * decl2.c (validate_nonmember_using_decl): Issue sensible ++ error-messages on bogus qualifiers. ++ ++1999-03-14 Jason Merrill ++ ++ * call.c (add_function_candidate): Fix uninitialized variable. ++ ++ * Makefile.in (search.o): Add dependency on varray.h. ++ ++1999-03-13 Jason Merrill ++ ++ * decl.c (duplicate_decls): Use same_type_p. ++ * method.c (try_old_backref): Renamed from flush_repeats. Use ++ same_type_p. Don't try to handle repeats. Return success. ++ (is_back_referenceable_type): Return 0 if TYPE_FOR_JAVA. Support ++ calls from old-style code, too. ++ (check_ktype): Use same_type_p. ++ (check_btype): Use same_type_p. Don't pull out TYPE_MAIN_VARIANT. ++ (build_qualified_name): Simplify logic. ++ (process_overload_item): Strip typedefs and quals at the top. ++ (build_mangled_name_for_type_with_Gcode): Remove call to ++ type_canonical_variant. ++ (build_mangled_name): Likewise. Remove support for old-style ++ repeats, which have been disabled since 2.7.2. Don't mess with ++ TREE_USED. ++ (build_decl_overload_real): Don't mess with TREE_USED. ++ ++1999-03-13 Nathan Sidwell ++ ++ * error.c (cp_printers): Add 'F' escape character. ++ (dump_type_real): Remove TREE_LIST (fnargs) printing. ++ Functionality moved to dump_parameters. ++ (dump_type_suffix): Use dump_parameters and dump_exception_spec. ++ (dump_function_decl): Extend meaning of V parameter. Use ++ dump_parameters and dump_exception_spec. ++ (dump_parameters): New static function. ++ (dump_exception_spec): New static function. ++ (fndecl_as_string): Change argument semantics. Use ++ dump_function_decl directly. ++ ++ * sig.c (build_signature_table_constructor): Use cp_error. ++ ++1999-03-13 Martin von Löwis ++ ++ * semantics.c (finish_switch_cond): Handle error cases gracefully. ++ Detected by g++.law/enum5.C. ++ ++ * typeck.c (build_modify_expr): Check for errors after resolving ++ offsets. Detected by g++.brendan/static1.C. ++ ++ * decl.c (complete_array_type): Ignore initial_value if it is an ++ error. Detected by g++.benjamin/17930.C. ++ ++ * typeck2.c (process_init_constructor): Return error if one argument ++ is in error. Detected by g++.benjamin/13478.C. ++ ++1999-03-12 Martin von Löwis ++ ++ * decl.c (select_decl): Allow class templates when we need types. ++ * decl2.c (ambiguous_decl): Likewise. ++ ++1999-03-12 Mark Mitchell ++ ++ * lex.c (do_identifier): Correct call to enforce_access. ++ * search.c (accessible_p): Tweak comment. ++ ++1999-03-10 Mark Mitchell ++ ++ * semantics.c (begin_class_definition): Call build_self_reference. ++ (finish_member_declaration): Set DECL_CONTEXT for TYPE_DECLs. ++ ++ * search.c (assert_canonical_unmarked): Fix typo in prototype. ++ ++ * search.c (dfs_canonical_queue): New function. ++ (dfs_assert_unmarked_p): Likewise. ++ (assert_canonical_unmarked): Likewise. ++ (access_in_type): Use it. ++ (accessible_p): Likewise. Walk the whole tree when umarking. ++ ++ * sig.c (build_signature_table_constructor): Use accessible_p ++ instead of compute_access. ++ ++1999-03-09 Jason Merrill ++ ++ * call.c (add_builtin_candidates): Handle overloaded conversion ops. ++ ++1999-03-09 Mark Mitchell ++ ++ * cp-tree.h (flag_access_control): Declare. ++ (TREE_VIA_PPUBLIC): Document. ++ (DECL_NONSTATIC_MEMBER_P): New macro. ++ (enforce_access): Return an indication of whether or not access ++ was permitted. ++ (build_self_reference): Change prototype. ++ (compute_access): Replace with ... ++ (accessible_p): New function. ++ (dfs_walk): Change prototype. ++ (dfs_unmark): Likewise. ++ (markedp): Likewise. ++ * call.c (enforce_access): Use accessible_p. ++ * class.c (build_self_reference): Insert the declaration into the ++ list of members for this type, and make it public. ++ * decl.c (xref_basetypes): Avoid ill-timed recursion. ++ * init.c (build_offset_ref): Use lookup_member, not three separate ++ name-lookups. Call enforce_access rather than checking for ++ illegal accesses here. ++ (resolve_offset_ref): Likewise. ++ * lex.c (do_identifier): Likewise. ++ * method.c (hack_identifier): Likewise. ++ * parse.y (self_reference): Remove. ++ (opt_component_decl_list): Don't use it. ++ * parse.c: Regenerated. ++ * pt.c (print_candidates): Generalize to handle lists of ++ overloaded functions. ++ (instantiate_class_template): Don't rely on TREE_VIA_PRIVATE; it's ++ not set. ++ (get_template_base): Use new calling convention for dfs_walk. ++ * search.c: Include varray.h. Add prototypes. ++ (dfs_walk): Accept a data pointer to pass to the work functions. ++ All callers changed. All work functions changed. ++ (breadth_first_search): Rename to bfs_walk, and make consistent ++ with dfs_walk. ++ (dfs_walk_real): New function. ++ (canonical_binfo): New function. ++ (context_for_name_lookup): Likewise. ++ (shared_marked_p): Likewise. ++ (shared_unmarked_p): Likewise. ++ (lokup_field_queue_p): Likewise. ++ (lookup_field_r): Generalize to handle both functions and fields. ++ (lookup_field): Just call lookup_member. ++ (lookup_fnfields): Likewise. ++ (lookup_member): Move body of lookup_field here and generalize. ++ (dfs_accessible_queue_p): Likewise. ++ (dfs_accessible_p): Likewise. ++ (dfs_access_in_type): Likewise. ++ (access_in_type): Likewise. ++ (compute_access): Remove, and replace with ... ++ (accessible_p): New function. ++ (vbase_types): Remove. ++ (vbase_decl_ptr_intermediate): Likewise. ++ (vbase_decl_ptr): Likewise. ++ (vbase_init_result): Likewise. ++ (closed_envelopes): Likewise. ++ (bvtable): Likewise. ++ ++1999-03-09 Jason Merrill ++ ++ * call.c (add_function_candidate): Check for proper number of args ++ before checking the validity of those args. ++ ++1999-03-06 Jason Merrill ++ ++ * cp-tree.h (struct lang_type): Add anon_union field. ++ (ANON_UNION_TYPE_P): Use it instead of examining type. ++ (SET_ANON_UNION_TYPE_P): New macro. ++ * decl.c (check_tag_decl): Use it. ++ ++ * search.c (compute_access): Handle non-type contexts earlier, and ++ handle NULL_TREE. ++ ++ * tree.c (build_exception_variant): Use copy_to_permanent. ++ ++ * decl2.c (setup_initp): Give statics with no priority the default ++ priority here. ++ (do_dtors, do_ctors, finish_file): Remove special handling of ++ non-prioritized statics. ++ ++1999-03-05 Mark Mitchell ++ ++ * cp-tree.h (ANON_UNION_TYPE_P): Robustify. ++ * decl.c (make_typename_type): Don't issue an error if an ++ immediate lookup fails; it migt be resolved later. ++ * friend.c (is_friend): Add comment. ++ * search.c (breadth_first_search): Add POSTFN and DATA ++ parameters. Tidy. All callers changed. ++ (lookup_field_queue_p): New function. ++ (lookup_field_r): Likewise. ++ (lookup_field_post): Likewise. ++ (lookup_field): Use them, via breadth_first_search, instead of ++ duplicating logic. ++ (compute_access): Robustify. ++ (lookup_fnfield_info): New structure. ++ ++1999-03-05 Jason Merrill ++ ++ * pt.c (tsubst, case ARRAY_REF): Use tsubst_expr again. ++ ++1999-03-03 Jason Merrill ++ ++ * class.c, decl2.c, method.c, pt.c: Add 'static' to make SunOS 4 ++ cc happy. ++ ++ * decl2.c (import_export_class): Also return if ++ CLASSTYPE_INTERFACE_ONLY is set. ++ ++1999-03-03 Martin von Löwis ++ ++ * decl.c (push_overloaded_decl): Only overwrite the old binding if ++ there was one. ++ * decl2.c (do_local_using_decl): Fix loop termination. ++ ++1999-03-02 Mark Mitchell ++ ++ * cp-tree.h (determine_specialization): Don't declare. ++ * pt.c (determine_specialization): Make it static. Eliminate ++ complain parameter. Note that decl is always non-NULL now, and ++ simplify accordingly. ++ ++ * decl.c (maybe_push_to_top_level): Always call ++ push_cp_function_context. ++ (pop_from_top_level): Always call pop_cp_function_context. ++ ++1999-02-26 Nathan Sidwell ++ ++ * typeck.c (complete_type_or_else): Add VALUE arg, for helpful ++ diagnostics. ++ * cp-tree.h (complete_type_or_else): Added VALUE parameter. ++ * init.c (build_new_1): Extra arg to complete_type_or_else. ++ (build_delete): Likewise. ++ * typeck.c (require_complete_type): Likewise. ++ (pointer_int_sum): Likewise. ++ (pointer_diff): Likewise. ++ (build_component_ref): Likewise. ++ ++ * typeck2.c (incomplete_type_error): Always use cp_error. ++ Show declaration of undefined type, if appropriate. ++ Deal with UNKNOWN_TYPE nodes. ++ ++ * typeck.c (require_complete_type): Use TYPE_SIZE as ++ size_zero_node to mean incomplete type. ++ (require_complete_type_in_void): New function. ++ (build_compound_expr): Call complete_type_in_void for LHS. ++ (build_c_cast): Call complete_type_in_void for void cast. ++ * cvt.c (ocp_convert): Call complete_type_in_void for void cast. ++ * decl.c (cplus_expand_expr_stmt): Void expression checks moved to ++ require_complete_type_in_void. Call it. ++ * cp-tree.h (require_complete_type_in_void): Prototype new function. ++ ++ * typeck.c (convert_arguments): Use alternative format for ++ function decls. Don't require_complete_type here. Simplify ++ diagnostic printing. ++ (convert_for_initialization): Don't require_complete_type on RHS yet. ++ * call.c (convert_arg_to_ellipsis): Call require_complete_type. ++ ++ * call.c (build_over_call): Cope with qualified void return type. ++ * semantics.c (finish_call_expr): Likewise. ++ * typeck.c (build_function_call_real): Likewise. ++ (c_expand_return): Likewise. ++ * decl2.c (reparse_absdcl_as_expr): Cope with qualified void type. ++ ++ * call.c (print_z_candidates): Use alternate print format, to be ++ consistent with (pt.c) print_candidates. ++ * method.c (hack_identifier): List candidate members. ++ * search.c (lookup_field): Build ambiguous list, and show it, if ++ ambiguous. ++ ++1999-02-26 Mark Mitchell ++ ++ * typeck.c (decay_conversion): Don't confuse constant array ++ variables with their initializers. ++ ++ * decl.c (duplicate_decls): Copy DECL_TEMPLATE_INSTANTIATED when ++ merging decls. ++ * pt.c (regenerate_decl_from_template): Tweak for clarity. ++ (instantiate_decl): Mark a decl instantiated before regenerating ++ it to avoid recursion. ++ * tree.c (mapcar): Don't call decl_constant_value unless we know ++ something is TREE_READONLY_DECL_P. ++ ++ * class.c (check_for_override): Don't stop checking when we find ++ the first overridden function. Delete #if 0'd code. ++ * search.c (get_matching_virtual): Likewise. ++ ++1999-02-25 Richard Henderson ++ ++ * lang-specs.h: Define __FAST_MATH__ when appropriate. ++ ++1999-02-24 Mike Stump ++ ++ * typeck.c (convert_for_assignment): Allow boolean integral constant ++ expressions to convert to null pointer. ++ ++1999-02-24 Martin von Loewis ++ ++ * decl.c (lookup_namespace_name): Resolve namespace aliases. ++ ++ * class.c (push_nested_class): Allow namespaces. ++ ++ * decl2.c (set_decl_namespace): Add friendp parameter. ++ * decl.c (grokfndecl): Pass it. ++ (grokvardecl): Likewise. ++ * cp-tree.h: Change declaration. ++ ++1999-02-24 Jason Merrill ++ ++ * pt.c (tsubst): Allow an array of explicit size zero. ++ ++1999-02-23 Jason Merrill ++ ++ * errfn.c: Change varargs code to look like toplev.c. ++ ++ * method.c (process_modifiers): Don't prepend 'U' for char or ++ wchar_t. ++ ++1999-02-20 Craig Burley ++ ++ * Make-lang.in (cplib2.ready): Don't consider updating ++ cplib2 stuff if the current directory isn't writable, as ++ it won't work (such as during a `make install'). ++ ++Sun Feb 21 20:38:00 1999 H.J. Lu (hjl@gnu.org) ++ ++ * decl2.c (start_objects): Make file scope constructors and ++ destructors local to the file if ASM_OUTPUT_CONSTRUCTOR and ++ ASM_OUTPUT_DESTRUCTOR are defined. ++ ++1999-02-19 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_METHOD_VEC): Adjust comment. ++ (fn_type_unification): Adjust prototype. ++ (lookup_fnfields_1): Declare. ++ * call.c (add_template_candidate_real): Adjust call to ++ fn_type_unification. ++ * class.c (add_method): Don't allow duplicate declarations of ++ constructors or destructors. ++ (resolve_address_of_overloaded_function): Remove unused variable. ++ Adjust call to fn_type_unification. ++ * decl.c (grokfndecl): Be more robust in the face of illegal ++ specializations. ++ * decl2.c (check_classfn): Remove hokey handling of member ++ templates. ++ * pt.c (determine_specialization): Improve comments. Adjust to ++ handle template argument deduction as per the standard. ++ (check_explicit_specialization): Fix comment spacing. Handle ++ type-conversion operators correctly. Improve error-recovery. ++ (fn_type_unification): Remove EXTRA_FN_ARG parameter. ++ (get_bindings_real): Simplify handling of static members. ++ * search.c (lookup_fnfields_1): Make it have external linkage. ++ * typeck.c (compparms): Fix comment. ++ (build_unary_op): Don't try to figure out which template ++ specialization is being referred to when when the address-of ++ operator is used with a template function. ++ ++Thu Feb 18 23:40:01 1999 Kaveh R. Ghazi ++ ++ * cp-tree.h (lvalue_or_else): Qualify a char* with the `const' ++ keyword to match an analogous change at the top level. ++ ++ * tree.c (lvalue_or_else): Likewise. ++ ++1999-02-17 Mark Mitchell ++ ++ * decl.c (xref_basetypes): Comment. ++ * pt.c (instantiate_class_template): Use xref_basetypes. ++ ++1999-02-16 Mark Mitchell ++ ++ * cp-tree.h (tsubst): Change prototype. ++ (tsubst_expr): Likewise. ++ (tsubst_copy): Likewise. ++ (type_unification): Remove prototype. ++ * call.c (convert_default_arg): Adjust call to tsubst_expr. ++ * class.c (resolve_address_of_overloaded_function): Just use ++ fn_type_unification. ++ * decl.c (grokdeclarator): Adjust call to tsubst. ++ * method.c (build_template_parm_names): Likewise. ++ * pt.c (GTB_VIA_VIRTUAL): New macro. ++ (GTB_IGNORE_TYPE): Likewise. ++ (resolve_overloaded_unification): Add `complain' parameter. ++ (try_one_overload): Likewise. ++ (tsubst_template_arg_vector): Likewise. ++ (tsubst_template_parms): Likewise. ++ (tsubst_aggr_type): Likewise. ++ (tsubst_arg_types): Likewise. ++ (tsubst_call_declarator_parms): Likewise. ++ (unify): Remove explicit_mask. ++ (type_unification_real): Likewise. ++ (get_template_base_recursive): Likewise. ++ (coerce_template_template_parms): Provide prototype. ++ (tsubst_function_type): Likewise. ++ (try_class_unification): New function. ++ All callers changed to use new complain parameter. ++ (get_template_base): Use try_class_unification. ++ (unify): Adjust handling of classes derived from template types. ++ (fn_type_unification): Substitute explicit arguments before ++ unification. ++ ++1999-02-16 Kriang Lerdsuwanakij ++ ++ * decl.c (pushdecl): Remove dead code. ++ ++1999-02-16 Jason Merrill ++ ++ * decl2.c (finish_objects): Fix code I missed in previous change. ++ ++1999-02-13 Jason Merrill ++ ++ * decl.c (grokfndecl): Return NULL_TREE instead of error_mark_node. ++ (grokdeclarator): Don't expect error_mark_node from grokfndecl. ++ ++ * pt.c (maybe_process_partial_specialization): Complain about ++ 'template <>' on non-specialization. ++ ++1999-02-10 Jason Merrill ++ ++ * decl.c (grokdeclarator): Catch weird declarators. ++ * decl2.c (finish_file): Don't abort because of namespace parsing ++ failure. ++ (check_decl_namespace): Remove. ++ ++1999-02-09 Mark Mitchell ++ ++ * cp-tree.h (get_template_base): Don't declare. ++ (dfs_walk): Declare. ++ (dfs_unmark): Likewise. ++ (markedp): Likewise. ++ * pt.c (unify): Remove duplicate declaration. Pass tparms and ++ targs to get_template_base. ++ (get_template_base_recursive): Move here from search.c. Check to ++ see that the base found can be instantiated to form the desired ++ type. ++ (get_template_base): Likewise. ++ (get_class_bindings): Simplify. ++ * search.c (get_template_base_recursive): Move to pt.c. ++ (get_template_base): Likewise. ++ (markedp): Make it global. ++ (dfs_walk): Likewise. ++ (dfs_unmark): Likewise. ++ ++1999-02-07 Jason Merrill ++ ++ * pt.c (maybe_process_partial_specialization): Complain about ++ specialization in wrong namespace. ++ * tree.c (decl_namespace_context): New fn. ++ ++1999-02-06 Kriang Lerdsuwanakij ++ ++ * decl2.c (arg_assoc_type): Handle TEMPLATE_TEMPLATE_PARM. ++ * pt.c (coerce_template_template_parms): Handle nested ++ template template parameters. ++ ++Sat Feb 6 18:08:40 1999 Jeffrey A Law (law@cygnus.com) ++ ++ * typeck2.c: Update email addresses. ++ ++1999-02-04 Kriang Lerdsuwanakij ++ ++ * pt.c (unify): Call coerce_template_parms with the COMPLAIN flag ++ turned off. ++ ++1999-02-04 Jason Merrill ++ ++ * lex.c (retrofit_lang_decl): Split out... ++ (build_lang_decl): From here. ++ * decl.c (pushdecl): Call it for functions generated by the middle ++ end that don't have DECL_LANG_SPECIFIC. ++ * cp-tree.h: Declare it. ++ ++ * decl2.c: Remove flag_init_priority. Always enable initp stuff. ++ (start_objects, finish_objects): Only use special ++ init_priority code if the user specified a priority. ++ (do_ctors, do_dtors): Use DEFAULT_INIT_PRIORITY for the non-initp ++ objects. ++ ++Wed Feb 3 22:50:17 1999 Marc Espie ++ ++ * Make-lang.in (GXX_OBJS): Remove choose-temp.o, pexecute.o and ++ mkstemp.o. Get them from libiberty now. ++ (DEMANGLER_PROG): Simlarly, remove getopt.o getopt1.o. ++ ++Tue Feb 2 22:38:48 1999 Theodore Papadopoulo ++ ++ * decl2.c (lang_decode_option): Use read_integral_parameter. ++ ++1999-02-01 Mark Mitchell ++ ++ * pt.c (tsubst, case TYPENAME_TYPE): Check TYPE_BEING_DEFINED ++ before calling complete_type_or_else. ++ ++Mon Feb 1 09:49:52 1999 Kaveh R. Ghazi ++ ++ * input.c (inline): Don't define, its handled by system.h. ++ ++Sun Jan 31 20:34:29 1999 Zack Weinberg ++ ++ * decl2.c: Don't define flag_no_ident here. Don't process ++ -f(no-)ident here. ++ * cp-tree.h: Don't declare flag_no_ident here. ++ * lang-specs.h: Map -Qn to -fno-ident. ++ ++1999-01-28 Jason Merrill ++ ++ * cp-tree.h (struct tree_binding): Replace scope field with a union. ++ (BINDING_SCOPE): Adjust. ++ * decl.c (BINDING_LEVEL): Adjust. ++ ++1999-01-26 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Set up the DECL_INITIAL of ++ member constants. ++ ++ * init.c (expand_member_init): Pull out TYPE_MAIN_VARIANT in ++ a ctor initializer. ++ ++ * tree.c (equal_functions): Fix name in prototype. ++ ++ * decl.c (push_local_binding): Add FLAGS argument. ++ (pushdecl, push_overloaded_decl): Pass it. ++ * decl2.c (do_local_using_decl): Likewise. ++ * cp-tree.h: Adjust prototype. ++ * decl.c (poplevel): Fix logic. ++ ++ * decl.c (push_local_binding): Also wrap used decls in a TREE_LIST. ++ (poplevel): Handle that. Fix logic for removing TREE_LISTs. ++ (cat_namespace_levels): Don't loop forever. ++ ++1999-01-25 Richard Henderson ++ ++ * typeck.c (build_reinterpret_cast): Fix typo in duplicated test. ++ ++1999-01-25 Jason Merrill ++ ++ * class.c (resolve_address_of_overloaded_function): Mark the ++ chosen function used. ++ ++ * call.c (build_call): Make sure that a function coming in has ++ been marked used already. ++ * decl.c (expand_static_init): Call mark_used instead of ++ assemble_external. ++ * except.c (call_eh_info, do_pop_exception, expand_end_eh_spec, ++ alloc_eh_object, expand_throw): Likewise. ++ * init.c (build_builtin_delete_call): Likewise. ++ * rtti.c (call_void_fn, get_tinfo_fn, build_dynamic_cast_1, ++ expand_si_desc, expand_class_desc, expand_ptr_desc, expand_attr_desc, ++ expand_generic_desc): Likewise. ++ ++1999-01-25 Martin von Löwis ++ ++ * tree.c (equal_functions): New function. ++ (ovl_member): Call it. ++ ++1999-01-24 Jason Merrill ++ ++ * cvt.c (cp_convert_to_pointer): Fix conversion of 0 to pmf. ++ ++1999-01-25 Martin von Loewis ++ ++ * decl.c (decls_match): Return 1 if old and new are identical. ++ (push_overloaded_decl): Set OVL_USED when PUSH_USING. ++ ++1999-01-24 Jason Merrill ++ ++ * decl.c (start_function): Make member functions one_only on windows. ++ * decl2.c (import_export_decl): Likewise. ++ ++ * decl.c (grokdeclarator): Don't complain about implicit int in ++ a system header. Change same-name field check to not complain in ++ a system header instead of within extern "C". ++ ++1999-01-21 Mark Mitchell ++ ++ * cp-tree.h (PUSH_GLOBAL): New macro. ++ (PUSH_LOCAL): Likewise. ++ (PUSH_USING): Likewise. ++ (namespace_bindings_p): Declare. ++ (push_overloaded_decl): Likewise. ++ * decl.c (push_overloaded_decl): Don't make it static. Check for ++ illegal declarations after using declarations here. ++ (namespace_bindings_p): Likewise. ++ (duplicate_decls): Don't consider declarations from different ++ namespaces to be the same. ++ (pushdecl): Use symbolic PUSH_ constants in calls to ++ push_overloaded_decl. ++ (push_overloaded_decl_1): Likewise. ++ * decl2.c (validate_nonmember_using_decl): Tweak `std' handling. ++ (do_nonmember_using_decl): Check for illegal using declarations ++ after ordinary declarations here. ++ (do_local_using_decl): Call pushdecl to insert declarations. ++ ++1999-01-21 Jason Merrill ++ ++ * decl.c (grokdeclarator): Fix lang_c -> lang_name_c typo. ++ ++1999-01-21 Mark Mitchell ++ ++ * tree.c (build_cplus_array_type_1): Don't call build_array_type ++ for types involving template parameters. ++ ++ * cp-tree.h (PARM_DECL_EXPR): Delete. ++ (convert_default_arg): Change prototype. ++ (check_default_argument): Declare. ++ (search_tree): Likewise. ++ * call.c (convert_default_arg): Take the function to which the ++ default argument belongs as a parameter, and do any necessary ++ instantiation here, instead of ... ++ (build_over_call): Here. ++ * decl.c (local_variable_p): New function. ++ (check_default_argument): Likewise, split out and tidied from ... ++ (grokparms): Here. ++ * error.c (dump_expr): Don't set PARM_DECL_EXPR. ++ * pt.c (tsubst_call_declarator_parms): New function. ++ (for_each_template_parm): Handle ARRAY_REFs. Do the obvious thing ++ with CALL_EXPRs, rather than trying to be clever. ++ (tsubst): Use tsubst_call_declarator_parms. ++ * tree.c (search_tree): Don't make it static. ++ * typeck.c (convert_arguments): Use new interface to ++ convert_default_arg. ++ ++1999-01-20 Mark Mitchell ++ ++ * error.c (dump_function_decl): Don't print the argument types for ++ a function when the verbosity level is negative. ++ ++ * call.c (build_over_call): Check format attributes at call-time. ++ ++ * pt.c (tsubst_copy): Fix comment. ++ (unify): Don't allow unification with variable-sized arrays. ++ ++ * semantics.c (finish_stmt_expr): When processing a template make ++ the BIND_EXPR long-lived. ++ ++1999-01-19 Jason Merrill ++ ++ * decl2.c (finish_vtable_vardecl): Make vtables comdat here. ++ (import_export_vtable): Not here. ++ ++1999-01-18 Jason Merrill ++ ++ * typeck.c (build_component_ref): Wrap an OVERLOAD around a unique ++ non-static member function. ++ ++1999-01-18 Nathan Sidwell ++ ++ * class.c (instantiate_type): Only diagnose illegal address of member ++ function if complaining. ++ ++ * decl.c (lookup_name_real): Remove duplicate code. ++ ++1999-01-18 Jason Merrill ++ ++ * tree.c (copy_template_template_parm): Use permanent_obstack. ++ ++1999-01-18 Kriang Lerdsuwanakij ++ ++ * pt.c (unify): Remove restrictions on deduction of argument ++ of template template parameters. ++ ++1999-01-18 Nathan Sidwell ++ ++ * rtti.c (build_dynamic_cast_1): Resolve OFFSET_REF exprs. ++ ++ * class.c (resolve_address_of_overloaded_function): Show list of ++ all candidates, when none of them match. ++ ++1999-01-18 Chip Salzenberg ++ ++ * typeck.c (comp_ptr_ttypes_reinterpret): Per ANSI, tighten up ++ definition of 'casting away const' in reinterpret_cast<>. ++ ++1999-01-18 Graham ++ ++ * cvt.c: Add include for decl.h, remove extern for ++ static_aggregates which is now provided by decl.h. ++ ++ * Makefile.in (cvt.o): Add dependency for decl.h and missing ++ dependencies for convert.h and flags.h. ++ ++1999-01-18 Nathan Sidwell ++ ++ * decl2.c (do_dtors): Set current location to that of the ++ decl, for sensible diagnostics and debugging. ++ (check_classfn): Issue `incomplete type' error, if ++ class is not defined. ++ ++1999-01-16 Jason Merrill ++ ++ * cp-tree.h: Add prototype for bound_pmf_p. ++ ++1999-01-16 Jason Merrill ++ Manfred Hollstein ++ ++ * decl.c (grokdeclarator): Don't make 'main(){}' an error with only ++ -Wreturn-type. ++ ++1999-01-16 Nathan Sidwell ++ ++ * cp-tree.h (struct lang_type): Added has_mutable flag. ++ (CLASSTYPE_HAS_MUTABLE): New macro to access it. ++ (TYPE_HAS_MUTABLE_P): New macro to read it. ++ (cp_has_mutable_p): Prototype for new function. ++ * class.c (finish_struct_1): Set has_mutable from members. ++ * decl.c (cp_finish_decl): Clear decl's TREE_READONLY flag, if ++ it contains a mutable. ++ * typeck.c (cp_has_mutable_p): New function. ++ ++1999-01-15 Mark Mitchell ++ ++ * pt.c (process_template_parm): Ignore top-level qualifiers on ++ non-type parameters. ++ ++ * decl.c (start_function): Use current_function_parms in the call ++ to require_complete_type_for_parms, not the probably empty ++ DECL_ARGUMENTS. ++ ++1999-01-14 Jason Merrill ++ ++ * semantics.c (finish_asm_stmt): Don't warn about redundant volatile. ++ ++ * decl2.c (import_export_class): MULTIPLE_SYMBOL_SPACES only means ++ that we don't suppress the other copies. ++ * lex.c (handle_cp_pragma): Likewise. ++ ++1999-01-13 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Undo 1998-12-14 change. ++ * tree.c (build_cplus_array_type_1): Likewise. ++ * pt.c (instantiate_class_template): Remove misleading comment. ++ (tsubst_aggr_type): Substitute if there are template parameters, ++ regardless of whether or not they use template arguments. ++ (unify): Likewise, but for unification. ++ ++1999-01-12 Richard Henderson ++ ++ * cp-tree.h (flag_permissive): Declare extern. ++ ++1999-01-06 Mark Mitchell ++ ++ * cp-tree.h (IDENTIFIER_TYPENAME_P): Use OPERATOR_TYPENAME_FORMAT ++ here. ++ (lang_type): Add is_partial_instantiation. Decrease width of ++ dummy. ++ (PARTIAL_INSTANTIATION_P): New macro. ++ (OPERATOR_TYPENAME_P): Remove. ++ * decl.c (unary_op_p): Use IDENTIFIER_TYPENAME_P, not ++ OPERATOR_TYPENAME_P. ++ (grok_op_properties): Likewise. ++ * friend.c (do_friend): Handle friends that are member functions ++ correctly. ++ * lex.c (init_parse): Use OPERATOR_TYPENAME_FORMAT. ++ * pt.c (instantiate_class_template): Rework for clarity. Avoid ++ leaving TYPE_BEING_DEFINED set in obscure cases. Don't do ++ any more partial instantiation than is absolutely necessary for ++ implicit typename. Set PARTIAL_INSTANTIATION_P. ++ (tsubst_decl): Use IDENTIFIER_TYPENAME_P. ++ * semantics.c (begin_class_definition): Handle partial ++ specializations of a type that was previously partially ++ instantiated. ++ ++Wed Jan 6 03:18:53 1999 Mark Elbrecht ++ ++ * Make-lang.in (g++.o): Depend on prefix.h. ++ ++1999-01-04 Jason Merrill ++ ++ * tree.c (bound_pmf_p): New fn. ++ * typeck.c (build_c_cast): Use it. ++ ++ * decl.c (grok_op_properties): Use same_type_p. ++ ++Tue Dec 22 15:09:25 1998 Kaveh R. Ghazi ++ ++ * Makefile.in (cvt.o): Depend on toplev.h. ++ ++ * cp-tree.h (check_template_shadow, pod_type_p): Add prototypes. ++ ++ * cvt.c: Include toplev.h. ++ ++ * except.c (get_eh_caught, get_eh_handlers): Hide prototypes and ++ definitions. ++ ++ * init.c (expand_vec_init): Initialize variable `itype'. ++ ++ * lex.c (yyerror): Cast the argument passed to a ctype function to ++ an unsigned char. ++ ++ * method.c (build_mangled_C9x_name): Wrap prototype and definition ++ in "HOST_BITS_PER_WIDE_INT >= 64". ++ ++ * typeck.c (build_binary_op): Mark parameter `convert_p' with ++ ATTRIBUTE_UNUSED. ++ ++1998-12-22 Mark Mitchell ++ ++ * cp-tree.h (TYPE_RAISES_EXCEPTIONS): Improve documentation. ++ * tree.c (build_exception_variant): Don't crash on empty throw ++ specs. ++ ++1998-12-18 DJ Delorie ++ ++ * cvt.c (convert_to_reference): Check for both error_mark_node ++ and NULL_NODE after call to convert_for_initialization. ++ ++1998-12-17 Jason Merrill ++ ++ * error.c (interesting_scope_p): New fn. ++ (dump_simple_decl): Use it. ++ (dump_expr, case CONSTRUCTOR): Force a & for a PMF. ++ (dump_expr, case OFFSET_REF): Print ->* if appropriate. ++ ++1998-12-16 Mark Mitchell ++ ++ * class.c (resolve_address_of_overloaded_function): Do conversion ++ to correct type here, rather than ... ++ (instantiate_type): Here. ++ ++ * cp-tree.h (DECL_TEMPLATE_PARM_P): New macro. ++ (DECL_TEMPLATE_TEMPLATE_PARM_P): Use it. ++ (decl_template_parm_p): Remove. ++ * decl.c (pushdecl): Don't set DECL_CONTEXT for a template ++ parameter. ++ * lex.c (do_identifier): Use DECL_TEMPLATE_PARM_P. ++ * pt.c (push_inline_template_parms_recursive): Set it. ++ (decl_template_parm_p): Remove. ++ (check_template_shadow): Use DECL_TEMPLATE_PARM_P. ++ (process_template_parm): Set it. ++ ++Wed Dec 16 16:33:58 1998 Dave Brolley ++ ++ * lang-specs.h (default_compilers): Pass -MD, -MMD and -MG to cc1plus ++ if configured with cpplib. ++ ++1998-12-15 Mark Mitchell ++ ++ * decl.c (poplevel): Make sure ns_binding is initialized. ++ ++ * decl.c (finish_function): Undo inadvertent change in previous ++ patch. ++ ++1998-12-14 Mark Mitchell ++ ++ * class.c (pushclass): Tweak handling of class-level bindings. ++ (resolve_address_of_overloaded_function): Update pointer-to-member ++ handling. ++ (instantiate_type): Likewise. ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ * decl.c (pop_binding): Take the DECL to pop, not just the name. ++ Deal with `struct stat' hack. ++ (binding_level): Add to documentation. ++ (push_binding): Clear BINDING_TYPE. ++ (add_binding): New function. ++ (push_local_binding): Use it. ++ (push_class_binding): Likewise. ++ (poplevel): Adjust calls to pop_binding. ++ (poplevel_class): Likewise. ++ (pushdecl): Adjust handling of TYPE_DECLs; add bindings for hidden ++ declarations to current binding level. ++ (push_class_level_binding): Likewise. ++ (push_overloaded_decl): Adjust handling of OVERLOADs in local ++ bindings. ++ (lookup_namespace_name): Don't crash when confronted with a ++ TEMPLATE_DECL. ++ (lookup_name_real): Do `struct stat' hack in local binding ++ contexts. ++ (build_ptrmemfunc_type): Adjust documentation. ++ (grokdeclarator): Don't avoid building real array types when ++ processing templates unless really necessary. ++ (finish_method): Adjust calls to pop_binding. ++ * decl2.c (reparse_absdcl_as_expr): Recursively call ourselves, ++ not reparse_decl_as_expr. ++ (build_expr_from_tree): Deal with a template-id as the function to ++ call in a METHOD_CALL_EXPR. ++ * pt.c (convert_nontype_argument): Tweak pointer-to-member handling. ++ (maybe_adjust_types_For_deduction): Don't do peculiar things with ++ METHOD_TYPEs here. ++ (resolve_overloaded_unification): Handle COMPONENT_REFs. Build ++ pointer-to-member types where necessary. ++ * tree.c (build_cplus_array_type_1): Don't avoid building real ++ array types when processing templates unless really necessary. ++ (build_exception_variant): Compare the exception lists correctly. ++ ++1998-12-13 Mark Mitchell ++ ++ * cp-tree.def (CPLUS_BINDING): Update documentation. ++ * cp-tree.h (LOCAL_BINDING_P): New macro. ++ (lang_identifier): Rename local_value to bindings. ++ (tree_binding): Make `scope' of type `void*', not `tree'. ++ (BINDING_SCOPE): Update documentation. ++ (IDENTIFIER_LOCAL_VALUE): Remove. ++ (IDENTIFIER_CLASS_VALUE): Document. ++ (IDENTIFIER_BINDING): New macro. ++ (IDENTIFIER_VALUE): Likewise. ++ (TIME_IDENTIFIER_TIME): Likewise. ++ (TIME_IDENTIFIER_FILEINFO): Likewise. ++ (IMPLICIT_TYPENAME_P): Likewise. ++ (set_identifier_local_value): Remove. ++ (push_local_binding): New function. ++ (push_class_binding): Likewise. ++ * class.c (pushclass): Update comments; use push_class_binding. ++ * decl.c (set_identifier_local_value_with_scope): Remove. ++ (set_identifier_local_value): Likewise. ++ (push_binding): New function. ++ (pop_binding): Likewise. ++ (binding_level): Update documentation. Remove shadowed. ++ (BINDING_LEVEL): New macro. ++ (free_binding_nodes): New variable. ++ (poplevel): Adjust for new name-lookup scheme. Don't mess up ++ BLOCK_VARs when doing for-scope extension. Remove effectively ++ dead code. ++ (pushlevel_class): Tweak formatting. ++ (poplevel_class): Adjust for new name-lookup scheme. ++ (print_binding_level): Likewise. ++ (store_bindings): Likewise. ++ (pushdecl): Likewise. ++ (pushdecl_class_level): Likewise. ++ (push_class_level_binding): Likewise. ++ (push_overloaded_decl): Update comments. Adjust for new ++ name-lookup scheme. ++ (lookup_name_real): Likewise. ++ (lookup_name_current_level): Likewise. ++ (cp_finish_decl): Likewise. ++ (require_complete_types_for_parms): Likewise. Remove misleading ++ #if 0'd code. ++ (grok_parms): Likewise. Don't call ++ require_complete_types_for_parms here. ++ (grok_ctor_properties): Don't treat templates as copy ++ constructors. ++ (grop_op_properties): Or as assignment operators. ++ (start_function): Document. Adjust for new name-lookup scheme. ++ (finish_function): Likewise. ++ * decl2.c (do_local_using_decl): Use push_local_binding. ++ * lex.c (begin_definition_of_inclass_inline): New function, split ++ out from ... ++ (do_pending_inlines): Here, and ... ++ (process_next_inline): Here. ++ (get_time_identifier): Use TIME_IDENTIFIER_* macros. ++ (init_filename_times): Likewise. ++ (extract_interface_info): Likewise. ++ (ste_typedecl_interface_info): Likewise. ++ (check_newline): Likewise. ++ (dump_time_statistics): Likewise. ++ (handle_cp_pragma): Likewise. ++ (do_identifier): Adjust for new name-lookup scheme. ++ * parse.y (function_try_block): Return ctor_initializer_opt value. ++ (fndef): Use it. ++ (fn.defpen): Pass appropriate values to start_function. ++ (pending_inline): Use functor_try_block value, and pass ++ appropriate values to finish_function. ++ * pt.c (is_member_template): Update documentation; remove handling ++ of FUNCTION_DECLs. As per name, this function should deal only in ++ TEMPLATE_DECLs. ++ (decl_template_parm_p): Change name of olddecl parameter to decl. ++ (check_template_shadow): Adjust for new name-lookup scheme. ++ (lookup_template_class): Likewise. ++ (tsubst_decl): Tweak so as not to confuse member templates with ++ copy constructors and assignment operators. ++ (unify): Handle UNION_TYPEs. ++ * ptree.c (print_lang_identifier): Adjust for new name-lookup scheme. ++ (lang_print_xnode): Adjust for new name-lookup scheme. ++ * typeck.c (mark_addressable): Likewise. ++ (c_expand_return): Likewise. ++ ++1998-12-08 Jason Merrill ++ ++ * decl.c (grokdeclarator): Allow field with same name as class ++ in extern "C". ++ ++ * decl.c (lookup_name_real): Don't limit field lookup to types. ++ * class.c (check_member_decl_is_same_in_complete_scope): No error ++ if icv and x are the same. ++ * lex.c (do_identifier): Tweak error message. ++ ++1998-12-10 Mark Mitchell ++ ++ * decl.c (start_enum): Use push_obstacks, not ++ end_temporary_allocation. ++ (finish_enum): Call pop_obstacks. ++ ++1998-12-10 Mark Mitchell ++ ++ * class.c (instantiate_type): Return error_mark_node rather than ++ junk. ++ ++1998-12-09 Mark Mitchell ++ ++ * cp-tree.h (most_specialized_instantiation): New function. ++ (print_candidates): Likewise. ++ * class.c (validate_lhs): Remove. ++ (resolve_address_of_overloaded_function): New function, split out ++ and then substantially reworked, from ... ++ (instantiate_type): Use it. Simplify. ++ * cvt.c (convert_to_reference): Complain when caller has indicated ++ that's the right thing to do. Don't crash if instantiate_type ++ fails. ++ * pt.c: Substitute `parameters' for `paramters' throughout. ++ (print_candidates): Don't make it static. ++ (most_specialized_instantiation): Split out from ... ++ (most_specialized): Here. ++ ++Wed Dec 9 15:33:01 1998 Dave Brolley ++ ++ * lex.c (lang_init_options): Initialize cpplib. ++ * decl2.c (parse_options,cpp_initialized): Removed. ++ (lang_decode_option): Move initialization of cpplib to ++ lang_init_options. ++ ++1998-12-09 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Update the name of the TEMPLATE_DECL, as ++ well as the TYPE_DECL, when a typedef name is assigned to a ++ previously anonymous type. ++ ++1998-12-08 Andrew MacLeod ++ ++ * cp/except.c (call_eh_info): Use __start_cp_handler instead of ++ __cp_eh_info for getting the eh info pointer. Add table_index to ++ field list. ++ (push_eh_cleanup): Don't increment 'handlers' data field. ++ (process_start_catch_block): Don't set the 'caught' field. ++ ++ * cp/exception.cc (CP_EH_INFO): New macro for getting the ++ exception info pointer within library routines. ++ (__cp_eh_info): Use CP_EH_INFO. ++ (__start_cp_handler): Get exception info pointer, set caught field, ++ and increment the handlers field. Avoids this being done by handlers. ++ (__uncatch_exception, __check_eh_spec): Use CP_EH_INFO macro. ++ (uncaught_exception): Use CP_EH_INFO macro. ++ ++Tue Dec 8 10:48:21 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * Make-lang.in (cxxmain.o): Depend on $(DEMANGLE_H), not demangle.h ++ ++Mon Dec 7 17:56:06 1998 Mike Stump ++ ++ * lex.c (check_newline): Add support for \ as `natural' ++ characters in file names in #line to be consistent with #include ++ handling. We support escape processing in the # 1 "..." version of ++ the command. See also support in cp/lex.c. ++ ++1998-12-07 Zack Weinberg ++ ++ * cp/decl2.c: s/data/opts/ when initializing cpp_reader ++ structure. ++ ++1998-12-07 Jason Merrill ++ ++ * decl.c (build_typename_type): Set DECL_ARTIFICIAL. ++ ++ * error.c (dump_simple_decl): Also print namespace context. ++ (dump_function_decl): Likewise. ++ ++ * decl2.c (ambiguous_decl): Don't print old value if it's ++ error_mark_node. ++ ++ * decl.c (lookup_name_real): Fix handling of local types shadowed ++ by a non-type decl. Remove obsolete code. ++ * cp-tree.h (DECL_FUNCTION_SCOPE_P): New macro. ++ ++ * lang-options.h: Add -fpermissive. ++ * decl2.c: Likewise. ++ * cp-tree.h: Add flag_permissive. ++ * decl.c (init_decl_processing): If neither -fpermissive or -pedantic ++ were specified, set flag_pedantic_errors. ++ * call.c (build_over_call): Turn dropped qualifier messages ++ back into pedwarns. ++ * cvt.c (convert_to_reference): Likewise. ++ * typeck.c (convert_for_assignment): Likewise. ++ ++1998-12-05 Jason Merrill ++ ++ * decl2.c (coerce_new_type): Use same_type_p. ++ (coerce_delete_type): Likewise. ++ ++ * call.c (check_dtor_name): Return 1, not error_mark_node. ++ ++1998-12-04 Jason Merrill ++ ++ * lex.c (handle_cp_pragma): Disable #pragma interface/implementation ++ if MULTIPLE_SYMBOL_SPACES. ++ ++ * pt.c (check_template_shadow): New fn. ++ * decl2.c (grokfield): Use it. ++ * decl.c (pushdecl): Likewise. ++ (pushdecl_class_level): Likewise. ++ (start_method): Likewise. ++ (xref_tag): Don't try to use 't' if we're defining. ++ ++ * call.c (check_dtor_name): Just return an error_mark_node. ++ * pt.c (lookup_template_class): Complain about using non-template here. ++ * parse.y (apparent_template_type): Not here. ++ ++ * pt.c (check_explicit_specialization): Complain about specialization ++ with C linkage. ++ ++ * lang-options.h: Add -f{no-,}implicit-inline-templates. ++ ++ * pt.c (convert_nontype_argument): Don't assume that any integer ++ argument is intended to be a constant-expression. ++ ++1998-12-03 Mark Mitchell ++ ++ * class.c (handle_using_decl): Fix comment. Don't lookup ++ constructors in base classes. ++ (validate_lhs): Fix typo in comment. ++ * search.c (lookup_field_1): Don't return a USING_DECL. ++ ++ * cp-tree.h (DECL_ACCESS): Improve documentation. ++ ++ * decl.c (expand_static_init): Don't set the initialization-done ++ flag until the initialization is done. ++ ++1998-12-02 Mark Mitchell ++ ++ * decl2.c (validate_nonmember_using_decl): Complain about using ++ declarations for class members. ++ ++1998-11-29 Jason Merrill ++ ++ * typeck2.c (process_init_constructor): Use same_type_p. ++ ++ * decl.c (check_tag_decl): Don't warn about null decl inside a ++ class. ++ ++ * pt.c (unify, case OFFSET_TYPE): Pass down 'strict' rather than ++ UNIFY_ALLOW_NONE. ++ (convert_nontype_argument): Use TYPE_PTRMEMFUNC_FN_TYPE. ++ (resolve_overloaded_unification): Strip baselinks. ++ ++Fri Nov 27 13:07:23 1998 Kaveh R. Ghazi ++ ++ * g++spec.c: Don't prototype xmalloc. ++ ++1998-11-25 Jason Merrill ++ ++ * except.c (expand_throw): Use TYPE_PTR_P to check for pointers. ++ ++ * decl.c (check_tag_decl): Do complain about null friend decl at ++ file scope. ++ ++1998-11-25 Andreas Schwab ++ ++ * lex.c (make_lang_type): Clear the whole struct lang_type, not ++ only the first multiple of sizeof (int). ++ ++1998-11-24 Jason Merrill ++ ++ * decl.c (start_decl): An explicit specialization of a static data ++ member is only a definition if it has an initializer. ++ ++ * except.c (expand_throw): Use cp_finish_decl for the throw temp. ++ * cvt.c (build_up_reference): Pass DIRECT_BIND down into ++ cp_finish_decl. ++ * init.c (expand_default_init): Check for DIRECT_BIND instead of ++ DECL_ARTIFICIAL. ++ ++ * call.c (build_over_call): Use build_decl. ++ ++ * except.c (expand_throw): Just use convert, not ++ build_reinterpret_cast. ++ ++ * lex.c (handle_generic_pragma): Use token_buffer. ++ ++ * decl.c (check_tag_decl): Don't complain about null friend decl. ++ ++1998-11-24 Dave Pitts ++ ++ * Make-lang.in (DEMANGLER_PROG): Move the output arguments to the ++ first position. ++ * lex.c (check_newline): Use ISALPHA. ++ (readescape): Use ISGRAPH. ++ (yyerror): Use ISGRAPH. ++ ++1998-11-24 Nathan Sidwell ++ ++ * search.c (get_abstract_virtuals): Do not use initial ++ CLASSTYPE_ABSTRACT_VIRTUALS. ++ * typeck2.c (abstract_virtuals_error): Show location of abstract ++ declaration. ++ * call.c (build_new_method_call): Use ++ CLASSTYPE_ABSTRACT_VIRTUAL, rather than recalculate. ++ * class.c (finish_struct_bits): Don't bother working out whether ++ get_abstract_virtuals will do anything, just do it. ++ ++1998-11-24 Graham ++ ++ * typeck.c (build_component_ref): Remove unused statement. ++ ++1998-11-24 Jason Merrill ++ ++ * class.c (add_method): Catch invalid overloads. ++ ++ * class.c (add_method): Build up OVERLOADs properly for conversion ops. ++ * search.c (lookup_conversions): Handle getting real OVERLOADs. ++ (add_conversions): Likewise. Revert last change. ++ * call.c (add_conv_candidate): Pass totype to add_candidate instead ++ of fn. Don't add a new candidate if the last one was for the same ++ type. ++ (print_z_candidates): Handle getting a type as a function. ++ (joust): If we got two conversion candidates to the same type, ++ just pick one. ++ (build_object_call): Lose 'templates'. ++ (build_user_type_conversion_1): Handle getting real OVERLOADs. ++ ++1998-11-23 Jason Merrill ++ ++ * typeck2.c (process_init_constructor): If there are elements ++ that don't have initializers and they need to have constructors ++ run, supply them with initializers. ++ ++ * class.c (finish_struct_1): A class with a 0-width bitfield is ++ still empty. ++ ++1998-11-23 Mark Mitchell ++ ++ * pt.c (instantiate_class_template): Don't try to figure out what ++ specialization to use for a partial instantiation. Correct ++ typos in a couple of comments. Avoid calling uses_template_parms ++ multiple times. ++ ++1998-11-23 Benjamin Kosnik ++ ++ * method.c (process_overload_item): Add call to ++ build_mangled_C9x_name for intTI_type_nodes. ++ (build_mangled_C9x_name): Add prototype, define. ++ * decl.c (init_decl_processing): Add names for ++ TImode_type_node. ++ ++1998-11-23 Jason Merrill ++ ++ * parse.y (named_class_head): Update CLASSTYPE_DECLARED_CLASS. ++ ++ * class.c (finish_struct_1): Set things up for 0-width bitfields ++ like we do for others. ++ ++ * decl.c (check_tag_decl): New fn. ++ (shadow_tag): Split out from here. ++ * decl2.c (grok_x_components): Call it. ++ ++1998-11-22 Jason Merrill ++ ++ * decl.c: Lose warn_about_return_type. ++ (grokdeclarator): Always complain about implicit int, except for ++ `main () { ... }'. ++ ++ * decl.c (tag_name): New fn. ++ (xref_tag): Complain about using typedef-name after class-key. ++ ++ * init.c (expand_vec_init): Also keep going if from_array. ++ ++ * tree.c (is_overloaded_fn): Also handle the output of ++ build_offset_ref. ++ ++ * decl.c (grokdeclarator): Use constructor_name when comparing ++ field name against enclosing class. ++ * class.c (finish_struct_anon): Likewise. ++ ++1998-11-22 Mark Mitchell ++ ++ * decl.c (poplevel): Remove code to handle KEEP == 2. ++ (finish_function): Don't confuse BLOCK-order when ++ processing a destructor. ++ ++1998-11-21 Jason Merrill ++ ++ * decl.c (require_complete_types_for_parms): Call layout_decl ++ after we've completed the type. ++ ++1998-11-21 Martin von Löwis ++ ++ * decl2.c (validate_nonmember_using_decl): Allow using templates ++ from the global namespace. ++ ++1998-11-21 Jason Merrill ++ ++ Handle specifying template args to member function templates. ++ * tree.c (build_overload): Always create an OVERLOAD for a template. ++ * search.c (add_conversions): Handle finding an OVERLOAD. ++ * decl2.c (check_classfn): Likewise. ++ * lex.c (identifier_type): See through a baselink. ++ * parse.y (do_id): Don't call do_identifier if we got a baselink. ++ * class.c (instantiate_type, case TREE_LIST): Recurse. ++ ++ * decl.c (grokdeclarator): Allow a boolean constant for array ++ bounds, odd as that sounds. ++ ++ * pt.c (unify): Be more strict about non-type parms, except for ++ array bounds. ++ (UNIFY_ALLOW_INTEGER): New macro. ++ ++1998-11-19 Manfred Hollstein ++ ++ * Make-lang.in (mandir): Replace all uses of $(mandir) by $(man1dir). ++ ++1998-11-19 Jason Merrill ++ ++ * semantics.c (begin_class_definition): Call ++ maybe_process_partial_specialization before push_template_decl. ++ Don't call push_template_decl for a specialization. ++ * search.c (lookup_field): Do return a member template class. ++ * decl2.c (handle_class_head): Handle member template classes. ++ ++ * decl.c (grokdeclarator): A parm type need not be complete. ++ ++ * pt.c (convert_nontype_argument): Fix thinko. ++ ++1998-11-18 Mark Mitchell ++ ++ * cp-tree.h (PTRMEM_CST_CLASS): Fix typo. ++ (global_delete_fndecl): New variable. ++ * decl.c (global_delete_fndecl): Define it. ++ (init_decl_processing): Set it. ++ * init.c (build_builtin_delete_call): Use it. ++ * tree.c (mapcar): Recursively call mapcar for the type of EXPR ++ nodes. ++ ++1998-11-18 Jason Merrill ++ ++ * decl.c (cplus_expand_expr_stmt): Always complain about unresolved ++ type. ++ ++ * tree.c (lvalue_p_1): An INDIRECT_REF to a function is an lvalue. ++ * call.c (build_object_call): Also support references to functions. ++ * typeck.c (convert_for_initialization): Don't decay a function ++ if the target is a reference to function. ++ ++ * search.c (add_conversions): Get all the overloads from a class. ++ ++ * decl.c (grok_ctor_properties): Complain about any constructor ++ that will take a single arg of the class type by value. ++ ++ * typeck2.c (build_functional_cast): Can't create objects of ++ abstract classes this way. ++ * cvt.c (ocp_convert): Likewise. ++ ++ * decl.c (grokfndecl): Member functions of local classes are not ++ public. ++ ++1998-11-18 Mark Mitchell ++ ++ * Make-lang.in (cc1plus): Add dependency on hash.o. ++ ++1998-11-18 Jason Merrill ++ ++ * search.c (get_abstract_virtuals): Complain about virtuals with ++ no final overrider. ++ * typeck2.c (abstract_virtuals_error): Remove handling for virtuals ++ with no final overrider. ++ * class.c (override_one_vtable): Don't set DECL_ABSTRACT_VIRTUAL_P ++ on virtuals with no final overrider. ++ ++ * lex.c (reinit_parse_for_block): Add a space after the initial ':'. ++ ++ * class.c (finish_struct_1): Don't remove zero-width bit-fields until ++ after layout_type. ++ ++ * friend.c (do_friend): Don't set_mangled_name_for_decl. ++ ++ * class.c (finish_struct_anon): Complain about non-fields. ++ * decl2.c (build_anon_union_vars): Likewise. ++ ++ * decl.c (grokdeclarator): Normal data members can't have the same ++ name as the class, either. ++ * class.c (finish_struct_anon): Neither can members of an ++ anonymous union. ++ ++1998-11-17 Mark Mitchell ++ ++ * cp-tree.h (TYPE_ALIAS_SET): Document language-dependent uses. ++ (TYPE_BINFO): Likewise. ++ (IS_AGGR_TYPE): Tweak. ++ (SET_IS_AGGR_TYPE): New macro. ++ (CLASS_TYPE_P): Tweak. ++ (lang_type): Group mark bitfields together. Remove linenum. ++ (CLASSTYPE_SOURCE_LINE): Remove macro. ++ (CLASSTYPE_MARKED_N): New macro. ++ (SET_CLASSTYPE_MARKED_N): Likewise. ++ (CLEAR_CLASSTYPE_MARKED_N): Likewise. ++ (CLASS_TYPE_MARKED_*): Use them. ++ (SET_CLASSTYPE_MARKED_*): Likewise. ++ (CLEAR_CLASSTYPE_MARKED_*): Likewise. ++ (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO): Likewise. ++ (TYPE_TEMPLATE_INFO): Handle TEMPLATE_TEMPLATE_PARMs as well. ++ (TYPENAME_TYPE_FULLNAME): Use TYPE_BINFO rather than CLASSTYPE_SIZE. ++ * class.c (class_cache_obstack): New variable. ++ (class_cache_firstobj): Likewise. ++ (finish_struct): Don't set CLASSTYPE_SOURCE_LINE. ++ (pushclass): Free the cache, when appropriate. ++ (popclass): Tidy. ++ (maybe_push_cache_obstack): Use class_cache_obstack. ++ * decl.c (include hash.h). ++ (typename_hash): New function. ++ (typename_compare): Likewise. ++ (build_typename_type): Check the hash table to avoid creating ++ duplicates. ++ (build_ptrmemfunc_type): Use SET_IS_AGGR_TYPE. ++ (grokdeclarator): Use CLASS_TYPE_P. ++ (xref_basetypes): Likewise. ++ (start_function): Likewise. Don't put current_class_ref on the ++ permanent obstack. ++ * error.c (dump_type_real): Use TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO ++ and TYPE_TI_ARGS. ++ * lex.c (note_got_semicolon): Use CLASS_TYPE_P. ++ (make_lang_type): Don't create TYPE_LANG_SPECIFIC and associated ++ fields for types other than class types. Do clear TYPE_ALIAS_SET ++ for types other than class types, though. ++ * method.c (build_overload_identifier): Use CLASS_TYPE_P and ++ TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO. ++ * pt.c (process_template_parm): Don't set ++ CLASSTYPE_GOT_SEMICOLON. ++ (lookup_template_class): Use TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO. ++ Coerce arguments on the momentary obstack. ++ (for_each_template_parm): Use TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO. ++ (instantiate_class_template): Calculate template arguments on the ++ momentary obstack. Tidy. ++ (tsubst_template_arg_vector): Use make_temp_vec. ++ (tsubst_aggr_type): Put template arguments on the momentary ++ obstack. ++ (tsubst_decl): Likewise. ++ (tsubst): Copy the array bounds index to the permanent obstack ++ before building index types. Use new macros. ++ (unify): Use new macros. ++ (do_type_instantiation): Likewise. ++ * search.c (lookup_fnfields_1): Use new macros. ++ (dfs_pushdecls): Build envelopes on the cache obstack. ++ (dfs_compress_decls): Use new macros. ++ (push_class_decls): Build on the cache obstack. ++ * semantics.c (finish_typeof): Don't set CLASSTYPE_GOT_SEMICOLON. ++ * sign.c (build_signature_pointer_or_reference_type): Use ++ SET_IS_AGGR_TYPE. ++ * tree.c (make_binfo): Check CLASS_TYPE_P. ++ (copy_template_template_parm): Adjust. ++ (make_temp_vec): Use push_expression_obstack. ++ * typeck.c (complete_type): Use new macros. ++ (comptypes): Likewise. ++ ++1998-11-17 Jason Merrill ++ ++ * pt.c (tsubst): Add diagnostics for invalid array, reference ++ and pointer to member types. ++ ++1998-11-16 Jason Merrill ++ ++ * typeck2.c (my_friendly_abort): Don't fatal twice in a row. ++ ++ * typeck.c (c_expand_start_case): Use build_expr_type_conversion. ++ Simplify. ++ ++ * parse.y (structsp): Fix cut-and-paste error. ++ ++ * init.c (build_new): Complain about non-integral size. ++ ++ * parse.y (unary_expr): Complain about defining types in sizeof. ++ ++ * typeck.c (expr_sizeof): Complain about sizeof an overloaded fn. ++ ++ * rtti.c (build_x_typeid): Complain about typeid without ++ including . ++ (get_typeid): Likewise. Complain about typeid of incomplete type. ++ (get_tinfo_fn_dynamic): Likewise. ++ (get_typeid_1): Not static anymore. ++ * except.c (build_eh_type_type): Use get_typeid_1. ++ ++ * rtti.c (build_dynamic_cast_1): Give errors for dynamic_cast to ++ ambiguous or private bases. Fix warning for reference cast. ++ ++1998-11-16 Mark Mitchell ++ ++ * cp-tree.h (DECL_TEMPLATE_INSTANTIATED): New macro. ++ * decl.c (duplicate_decls): Remove special-case code to deal with ++ template friends, and just do the obvious thing. ++ * pt.c (register_specialization): Tweak for clarity, and also to ++ clear DECL_INITIAL for an instantiation before it is merged with a ++ specialization. ++ (check_explicit_specialization): Fix indentation. ++ (tsubst_friend_function): Handle both definitions in friend ++ declaration and outside friend declarations. ++ (tsubst_decl): Don't clear DECL_INITIAL for an instantiation. ++ (regenerate_decl_from_template): Tweak accordingly. ++ (instantiate_decl): Likewise. ++ ++1998-11-16 Jason Merrill ++ ++ * decl.c (cplus_expand_expr_stmt): Promote warning about naked ++ member function reference to error. ++ * cvt.c (ocp_convert): Complain about converting an overloaded ++ function to void. ++ ++ * init.c (build_offset_ref): Just return a lone static member ++ function. ++ ++ * decl.c (cp_finish_decl): Only complain about real CONSTRUCTORs, ++ not internal ones. ++ ++ * typeck.c (build_binary_op_nodefault): Improve error handling. ++ ++ * decl.c (grokfndecl): Complain about making 'main' a template. ++ ++ * typeck.c (string_conv_p): Don't convert from wchar_t[] to char*. ++ ++ * call.c (build_method_call): Handle a BIT_NOT_EXPR around a ++ TYPE_DECL in a template. ++ ++1998-11-15 Jason Merrill ++ ++ * typeck2.c (my_friendly_abort): Add URL in the other case, too. ++ ++ * decl.c (struct cp_function): Add named_label_uses. ++ (push_cp_function_context): Save it. ++ (pop_cp_function_context): Restore it. ++ (define_label): Also complain about jumping into the scope of ++ non-POD objects that don't have constructors. ++ * tree.c (pod_type_p): New fn. ++ ++ * pt.c (instantiate_class_template): Clear TYPE_BEING_DEFINED sooner. ++ * rtti.c (synthesize_tinfo_fn): Call import_export_decl here. ++ (get_tinfo_fn): Not here. ++ * repo.c (repo_get_id): Abort if we get called for an incomplete ++ type. ++ ++1998-11-13 Mark Mitchell ++ ++ * except.c (expand_throw): Make sure first argument to ++ __cp_push_exception is of type `void*' to avoid spurious error ++ messages. ++ ++1998-11-11 Jason Merrill ++ ++ * pt.c (try_one_overload): Take orig_targs again. Only check for ++ mismatches against them; we don't care what a previous call found. ++ (resolve_overloaded_unification): Adjust. ++ ++ * search.c (lookup_field): Don't return anything for a non-type ++ field from a dependent type. ++ * decl.c (grokdeclarator): Resolve SCOPE_REFs of the current class ++ in an array declarator. ++ (start_decl): Push into the class before looking for the field. ++ ++1998-11-08 Mark Mitchell ++ ++ * method.c (build_overload_value): Handle REFERENCE_TYPE. ++ ++1998-11-08 Martin von Löwis ++ ++ * decl.c (grokdeclarator): Allow namespace-scoped members if they ++ are friends. ++ ++1998-11-08 Jason Merrill ++ ++ * pt.c (tsubst_decl): Don't mess with the global value of an ++ un-mangled DECL_ASSEMBLER_NAME. ++ ++1998-11-03 Christopher Faylor ++ ++ * decl.c (init_decl_processing): Remove CYGWIN conditional ++ since CYGWIN is now able to deal with trapping signals. ++ ++Sat Nov 7 15:48:02 1998 Kaveh R. Ghazi ++ ++ * cp-tree.h: Don't include gansidecl.h. ++ * exception.cc: Include gansidecl.h (since we don't include config.h) ++ * g++spec.c: Don't include gansidecl.h. ++ ++1998-11-06 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Add defined_in_class. Decrease ++ size of dummy. ++ (DECL_DEFINED_IN_CLASS_P): New macro. ++ (TEMPLATE_PARMS_FOR_INLINE): Document. ++ (check_static_variable_definition): New function. ++ * decl.c (cp_finish_decl): Set DECL_DEFINED_IN_CLASS_P, if ++ appropriate. ++ (check_static_variable_definition): Split out from ... ++ (grokdeclarator): Here. ++ * pt.c (check_default_tmpl_args): New function, split out from ... ++ (push_template_decl_real): Here. ++ (instantiate_template): Fix comment. ++ ++1998-11-04 Mark Mitchell ++ ++ * cp-tree.h (CP_TYPE_CONST_P): Make {0,1}-valued. ++ (CP_TYPE_VOLATILE_P): Likewise. ++ (CP_TYPE_RESTRICT_P): Likewise. ++ ++1998-11-03 Mark Mitchell ++ ++ * pt.c (tsubst): Use build_index_type, not build_index_2_type. ++ ++1998-11-02 Jason Merrill ++ ++ * class.c (instantiate_type): Be more helpful. ++ ++ * decl2.c (import_export_decl): Call import_export_class. ++ ++ * cp-tree.h (EMPTY_CONSTRUCTOR_P): Check !TREE_HAS_CONSTRUCTOR. ++ * decl2.c (build_expr_from_tree): Propagate TREE_HAS_CONSTRUCTOR. ++ * pt.c (tsubst_copy): Likewise. ++ ++1998-11-02 Mark Mitchell ++ ++ * init.c (expand_vec_init): Fix off-by-one error. ++ ++1998-11-02 Alexandre Oliva ++ ++ * parse.y (apparent_template_type): New type. ++ (named_complex_class_head_sans_basetype): Use it. ++ * Makefile.in (CONFLICTS): One new conflict. ++ * parse.c: Regenerated. ++ ++1998-11-01 Mark Mitchell ++ ++ * cp-tree.h (COMPARE_STRICT): New macro. ++ (COMPARE_BASE): Likewise. ++ (COMPARE_RELAXED): Likewise. ++ (COMPARE_REDECLARATION): Likewise. ++ (same_type_p): Likewise. ++ (same_or_base_type_p): Likewise. ++ * call.c (standard_conversion): Use them, in place of comptypes ++ with numeric arguments. ++ (reference_binding): Likewise. ++ (convert_like): Likewise. ++ (build_over_call): Likewise. ++ (is_subseq): Likewise. ++ (is_properly_derived_from): Likewise. ++ (compare_ics): Likewise. ++ (joust): Likewise. ++ * class.c (delete_duplicate_fields_1): Likewise. ++ (resolves_to_fixed_type_p): Likewise. ++ (instantiate_type): Likewise. Remove #if 0'd code. ++ * decl.c (decls_match): Likewise. Use COMPARE_REDECLARATION here. ++ (pushdecl): Likewise. ++ (lookup_name_real): Likewise. ++ (grokdeclarator): Likewise. Check for illegal array declarations. ++ (grokparms): Likewise. ++ (grok_op_properties): Likewise. ++ * decl2.c (check_classfn): Likewise. ++ * friend.c (is_friend): Likewise. ++ (make_friend_class): Likewise. ++ * init.c (expand_aggr_init): Likewise. ++ (expand_vec_init): Likewise. ++ * pt.c (is_member_template_class): Remove declaration. ++ (is_specialization_of): Use COMPARE_* and new macros. ++ (comp_template_parms): Likewise. ++ (convert_nontype_argument): Likewise. ++ (coerce_template_template_parms): Likewise. ++ (template_args_equal): Likewise. ++ (lookup_template_class): Likewise. ++ (type_unification_real): Likewise. ++ (unify): Likewise. ++ (get_bindings_real): Likewise. ++ * search.c (covariant_return_p): Likewise. ++ (get_matching_virtual): Likewise. ++ * sig.c (match_method_types): Likewise. ++ * tree.c (vec_binfo_member): Likewise. ++ (cp_tree_equal): Likewise. ++ * typeck.c (common_type): Likewise. ++ (comp_array_types): Likewise. Get issues involving unknown array ++ bounds right. ++ (comptypes): Update comments. Use new flags. ++ (comp_target_types): Use new macros. ++ (compparms): Likewise. ++ (comp_target_parms): Likewise. ++ (string_conv_p): Likewise. ++ (build_component_ref): Likewise. ++ (build_indirect_ref): Likewise. ++ (build_conditional_expr): Likewise. ++ (build_static_cast): Likewise. ++ (build_reinterpret_cast): Likewise. ++ (build_const_cast): Likewise. ++ (build_modify_expr): Likewise. ++ (convert_for_assignment): Likewise. ++ (comp_ptr_ttypes_real): Likewise. ++ (ptr_reasonably_similar): Likewise. ++ (comp_ptr_ttypes_const): Likewise. ++ ++1998-10-31 Jason Merrill ++ ++ * rtti.c (build_dynamic_cast_1): Fix cut-and-paste error. ++ ++1998-10-30 Mark Mitchell ++ ++ * decl2.c (delete_sanity): Pass integer_zero_node, not ++ integer_two_node, to build_vec_delete. ++ * init.c (build_array_eh_cleanup): Remove. ++ (expand_vec_init_try_block): New function. ++ (expand_vec_init_catch_clause): Likewise. ++ (build_vec_delete_1): Don't deal with case that auto_delete_vec ++ might be integer_two_node anymore. ++ (expand_vec_init): Rework for initialization-correctness and ++ exception-correctness. ++ * typeck2.c (process_init_constructor): Make mutual exclusivity ++ of cases more obvious. ++ ++1998-10-29 Jason Merrill ++ ++ * decl.c (lookup_name_real): OK, only warn if not lexing. ++ Simplify suggested fix. ++ ++ * cp-tree.h (IDENTIFIER_MARKED): New macro. ++ * search.c (lookup_conversions): Use breadth_first_search. ++ (add_conversions): Avoid adding two conversions to the same type. ++ (breadth_first_search): Work with base binfos, rather ++ than binfos and base indices. ++ (get_virtual_destructor): Adjust. ++ (tree_has_any_destructor_p): Adjust. ++ (get_matching_virtual): Adjust. ++ ++ * pt.c (push_template_decl_real): Generalize check for incorrect ++ number of template parms. ++ (is_member_template_class): #if 0. ++ ++1998-10-29 Richard Henderson ++ ++ * Makefile.in (cc1plus): Put CXX_OBJS, and thence @extra_cxx_objs@, ++ last. ++ ++1998-10-28 Zack Weinberg ++ ++ * lex.c: Call check_newline from lang_init always. After ++ calling cpp_start_read, set yy_cur and yy_lim to read from the ++ cpplib token buffer. ++ ++1998-10-28 Jason Merrill ++ ++ * class.c (instantiate_type): Don't consider templates for a normal ++ match. ++ ++ * class.c (finish_struct_1): Don't complain about non-copy ++ assignment ops in union members. ++ ++ * class.c (build_vtable): Don't pass at_eof to import_export_vtable. ++ (prepare_fresh_vtable): Likewise. ++ (finish_struct_1): Don't call import_export_class. ++ * decl2.c (finish_vtable_vardecl): Do import/export stuff. ++ (finish_prevtable_vardecl): Lose. ++ (finish_file): Don't call it. ++ * pt.c (instantiate_class_template): Likewise. ++ * cp-tree.h: Remove it. ++ ++ * init.c (build_delete): Reset TYPE_HAS_DESTRUCTOR here. ++ * decl.c (finish_function): Not here. ++ (start_function): Do set DECL_INITIAL. ++ ++ * pt.c (push_template_decl_real): Complain about default template ++ args for enclosing classes. ++ ++ * call.c (add_function_candidate): Treat conversion functions ++ as coming from the argument's class. ++ * cp-tree.h (DECL_CONV_FN_P): New fn. ++ (DECL_DESTRUCTOR_P): Also check DECL_LANGUAGE. ++ * class.c (add_method): Use DECL_CONV_FN_P. ++ * decl2.c (check_classfn): Likewise. ++ * error.c (dump_function_name): Likewise. ++ (dump_function_decl): Likewise. ++ * pt.c (fn_type_unification): Likewise. ++ * search.c (add_conversions): Likewise. ++ ++1998-10-27 Jason Merrill ++ ++ * lex.c (do_identifier): Also generate LOOKUP_EXPR for RESULT_DECL. ++ * method.c (hack_identifier): Also check for using RESULT_DECL ++ from outer context. ++ ++1998-10-27 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Use type_quals, rather than constp, ++ consistently. ++ ++1998-10-27 Jason Merrill ++ ++ * call.c (standard_conversion): instantiate_type here. ++ (reference_binding): And here. ++ (implicit_conversion): Not here. ++ (build_op_delete_call): No need to cons up an OVERLOAD. ++ * cvt.c (cp_convert_to_pointer): instantiate_type here. ++ (convert_to_reference): And here. ++ * decl.c (grok_reference_init): Not here. ++ (grokparms): Or here. ++ * typeck2.c (digest_init): Or here. ++ * typeck.c (decay_conversion): Take the address of overloaded ++ functions, too. ++ (require_instantiated_type): Lose. ++ (convert_arguments): Don't handle unknown types here. ++ (build_c_cast): Likewise. ++ (build_binary_op): Gut. ++ (build_conditional_expr): Don't require_instantiated_type. ++ (build_modify_expr): Likewise. ++ (build_static_cast): Don't instantiate_type. ++ (build_reinterpret_cast): Likewise. ++ (build_const_cast): Likewise. ++ (convert_for_initialization): Likewise. ++ (build_ptrmemfunc): Use type_unknown_p. ++ (convert_for_assignment): Also do default_conversion on overloaded ++ functions. Hand them off to ocp_convert. ++ ++1998-10-26 Mark Mitchell ++ ++ * error.c (dump_decl): Deal with TEMPLATE_DECLs that are ++ VAR_DECLs. Handle vtables whose DECL_CONTEXT is not a type. ++ ++ * class.c (finish_struct_1): Use build_cplus_array_type to build ++ array types. ++ * decl.c (init_decl_processing): Likewise. ++ * except.c (expand_end_eh_spec): Likewise. ++ * search.c (expand_upcast_fixups): Simplify very slightly. ++ ++1998-10-26 Jason Merrill ++ ++ * decl.c (grokdeclarator): Complain about a variable using ++ constructor syntax coming back null from start_decl. ++ ++ * friend.c (make_friend_class): Complain about trying to make ++ a non-class type a friend. ++ ++ * decl.c (grokfndecl): Set DECL_INITIAL for a defn here. ++ (start_function): Not here. ++ ++1998-10-26 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Disallow `explicit' in a friend declaration. ++ ++1998-10-26 Jason Merrill ++ ++ * typeck2.c (process_init_constructor): Only skip anonymous fields ++ if they are bitfields. ++ ++ * cp-tree.def (TYPEOF_TYPE): New code. ++ * error.c (dump_type_real): Handle it. ++ * pt.c (tsubst): Likewise. ++ * tree.c (search_tree): Likewise. ++ * semantics.c (finish_typeof): New fn. ++ * parse.y (typespec): Use it. ++ * cp-tree.h: Declare it. ++ ++1998-10-26 Manfred Hollstein ++ ++ * cp-tree.h (FORMAT_VBASE_NAME): Make definition unconditional. ++ ++1998-10-26 Jason Merrill ++ ++ * typeck.c (convert_arguments): Don't handle pmf references ++ specially. ++ ++ * init.c (build_member_call): Don't try to convert to the base type ++ if it's ambiguous or pedantic. ++ ++ * typeck2.c (check_for_new_type): Only depend on pedantic for ++ C-style casts. ++ ++1998-10-25 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Set DECL_NONCONVERTING_P for all ++ non-converting constructors. ++ ++1998-10-24 Martin von Löwis ++ ++ * gxxint.texi: Correct documentation for n, N, Q, and B. ++ ++1998-10-23 Martin von Löwis ++ ++ * parse.y (condition): Convert VAR_DECL from reference to indirect ++ reference. ++ ++1998-10-23 Andrew MacLeod ++ ++ * exception.cc (__cp_pop_exception): Free the original exception ++ value, not the potentially coerced one. ++ ++1998-10-23 Mark Mitchell ++ ++ * Makefile.in (hash.h): Run gperf when necessary. ++ ++ * cp-tree.h (CP_TYPE_READONLY): Remove. ++ (CP_TYPE_VOLATILE): Likewise. ++ (CP_TYPE_QUALS): New macro. ++ (CP_TYPE_CONST_P): Likewise. ++ (CP_TYPE_VOLATILE_P): Likewise. ++ (CP_TYPE_RESTRICT_P): Likewise. ++ (CP_TYPE_CONST_NON_VOLATILE_P): Likewise. ++ (cp_build_type_variant): Rename to ... ++ (cp_build_qualified_type): New function. ++ (c_apply_type_quals_to_decl): Declare. ++ (SIGNATURE_POINTER_NAME_FORMAT): Modify to allow `restrict'. ++ (SIGNATURE_REFERENCE_NAME_FORMAT): Likewise. ++ (cp_type_qual_from_rid): New function. ++ (compparms): Remove unused parameter. All callers changed. ++ (cp_type_quals): New function. ++ (at_least_as_qualified_p): Likewise. ++ (more_qualified_p): Likewise. ++ ++ * call.c (standard_conversion): Replace calls to ++ cp_build_type_variant with cp_build_qualified_type. Use ++ CP_TYPE_QUALS to get qualifiers and at_least_as_qualified_p to ++ compare them. Use CP_TYPE_* macros to check qualifiers. ++ (reference_binding): Likewise. ++ (implicit_conversion): Likewise. ++ (add_builtin_candidates): Likewise. ++ (build_over_call): Likewise. ++ * class.c (overrides): Compare all qualifiers, not just `const', ++ on method declarations. ++ * cvt.c (convert_to_reference): More CP_TYPE_QUALS conversion, etc. ++ (convert_pointer_to_real): Likewise. ++ (type_promotes_to): Likewise. ++ * decl.c (check_for_uninitialized_const_var): New function. ++ (init_decl_processing): More CP_TYPE_QUALS conversion, etc. ++ (cp_finish_decl): Use check_for_uninitialized_const_var. ++ (grokdeclarator): More CP_TYPE_QUALS conversion, etc. Update to ++ handle `restrict'. ++ (grok_ctor_properties): Likewise. ++ (grok_op_properties): Likewise. ++ (start_function): Likewise. ++ (rever_static_member_fn): Likewise. ++ * decl2.c (grok_method_quals): Likewise. ++ (grokfield): Likewise. ++ * error.c (dump_readonly_or_volatile): Rename to ... ++ (dump_qualifiers): New function. Handle `restrict'. ++ (dump_type_real): Use it. ++ (dump_aggr_type): Likewise. ++ (dump_type_prefix): Likewise. ++ (dump_type_suffix): Likewise. ++ (dump_function_decl): Likewise. ++ (cv_as_string): Likewise. ++ * gxx.gperf: Add __restrict and __restrict__. ++ * gxxint.texi: Document `u' as used for `__restrict', and a few ++ other previously undocumented codes. ++ * hash.h: Regenerated. ++ * init.c (expand_aggr_init): More CP_TYPE_QUALS conversion, etc. ++ (build_member_call): Likewise. ++ (build_new_1): Likewise. ++ * lex.c (init_parse): Add entry for RID_RESTRICT. ++ (cons_up_default_function): More CP_TYPE_QUALS conversion, etc. ++ (cp_type_qual_from_rid): Define. ++ * lex.h (enum rid): Add RID_RESTRICT. ++ * method.c (process_modifiers): Deal with `restrict'. ++ * parse.y (primary): More CP_TYPE_QUALS conversion, etc. ++ * parse.c: Regenerated. ++ * pt.c (convert_nontype_argument): More CP_TYPE_QUALS conversion, etc. ++ (tsubst_aggr_type): Likewise. ++ (tsubst): Likewise. ++ (check_cv_quals_for_unify): Likewise. ++ (unify): Likewise. ++ * rtti.c (init_rtti_processing): Likewise. ++ (build_headof): Likewise. ++ (get_tinfo_var): Likewise. ++ (buidl_dynamic_cast_1): Likewise. Fix `volatile' handling. ++ (expand_class_desc): Likewise. ++ (expand_attr_desc): Likewise. ++ (synthesize_tinfo_fn): Likewise. ++ * search.c (covariant_return_p): Likewise. Fix `volatile' handling. ++ (get_matching_virtual): Likewise. ++ (expand_upcast_fixups): Likewise. ++ * sig.c (build_signature_pointer_or_reference_name): Take ++ type_quals, not constp and volatilep. ++ (build_signature_pointer_or_reference_type): Likewise. ++ (match_method_types): More CP_TYPE_QUALS conversion, etc. ++ (build_signature_pointer_constructor): Likewise. ++ (build_signature_method_call): Likewise. ++ * tree.c (build_cplus_array_type): Likewise. ++ (cp_build_type_variant): Rename to ... ++ (cp_build_qualified_type): New function. Deal with `__restrict'. ++ (canonical_type_variant): More CP_TYPE_QUALS conversion, etc. ++ (build_exception_variant): Likewise. ++ (mapcar): Likewise. ++ * typeck.c (qualif_type): Likewise. ++ (common_type): Likewise. ++ (comptypes): Likewise. ++ (comp_cv_target_types): Likewise. ++ (at_least_as_qualified_p): Define. ++ (more_qualified_p): Likewise. ++ (comp_cv_qualification): More CP_TYPE_QUALS conversion, etc. ++ (compparms): Likewise. ++ (inline_conversion): Likewise. ++ (string_conv_p): Likewise. ++ (build_component_ref): Likewise. ++ (build_indirect_ref): Likewise. ++ (build_array_ref): Likewise. ++ (build_unary_op): Likewise. ++ (build_conditional_expr): Likewise. ++ (build_static_cast): Likewise. ++ (build_c_cast): Likewise. ++ (build_modify_expr): Likewise. ++ (convert_For_assignment): Likewise. ++ (comp_ptr_ttypes_real): Likewise. ++ (cp_type_quals): New function. ++ ++1998-10-23 Jason Merrill ++ ++ * cp-tree.h (CP_TYPE_READONLY): New macro to handle arrays. ++ (CP_TYPE_VOLATILE): Likewise. ++ * decl.c (grokdeclarator): Use them. ++ * tree.c (canonical_type_variant): Likewise. ++ ++1998-10-22 Martin von Löwis ++ ++ * parse.y (named_class_head): Push into class while parsing the ++ base class list. ++ * decl2.c (push_scope, pop_scope): New functions. ++ * cp-tree.h: Declare them. ++ * init.c (build_new_1): Delay cleanup until end of full expression. ++ ++1998-10-21 Jason Merrill ++ ++ * typeck.c (build_component_ref): Use of a type here is an error. ++ ++1998-10-19 Jason Merrill ++ ++ Revamp references to member functions. ++ * method.c (hack_identifier): Call build_component_ref for a ++ reference to a member function. ++ * typeck.c (build_component_ref): Only return a single function ++ if it's static. Otherwise, return a COMPONENT_REF. ++ (build_x_function_call): Handle a COMPONENT_REF. ++ (build_unary_op): Handle all unknown-type things. ++ * decl2.c (arg_assoc): Handle COMPONENT_REF. ++ * class.c (instantiate_type): Complain if the function we get is a ++ nonstatic member function. Remove code for finding "compatible" ++ functions. ++ * pt.c (tsubst_copy): Handle NOP_EXPR. ++ * tree.c (build_dummy_object): New fn. ++ (maybe_dummy_object): New fn. ++ (is_dummy_object): New fn. ++ * cp-tree.h: Declare them. ++ * cvt.c (cp_convert_to_pointer): Use maybe_dummy_object. ++ * error.c (dump_expr, case OFFSET_REF): Use is_dummy_object. ++ * init.c (build_member_call): Use maybe_dummy_object and ++ is_dummy_object. ++ (build_offset_ref): Use maybe_dummy_object. ++ (resolve_offset_ref): Use is_dummy_object. ++ * typeck.c (build_x_function_call): Call build_dummy_object. ++ (unary_complex_lvalue): Call is_dummy_object. ++ ++ * typeck.c (build_component_addr): Make sure field is a field. ++ ++ * call.c (build_new_op): Delete obsolete code. ++ ++ * pt.c (tsubst, TEMPLATE*PARM*): Abort if we don't have any args. ++ ++1998-10-18 Martin von Löwis ++ ++ * decl2.c (validate_nonmember_using_decl): Fix using-directives of ++ std if std is ignored. ++ ++1998-10-18 Jason Merrill ++ ++ * decl.c (grokvardecl): Fix thinko. ++ ++ * decl.c (grokdeclarator): Embedded attrs bind to the right, ++ not the left. ++ ++ * parse.y (fn.def2): Fix 'attrs' format. ++ ++1998-10-18 Alastair J. Houghton ++ ++ * Makefile.in (CONFLICTS): Update. ++ * parse.y (expr_or_declarator_intern): New rule. ++ (expr_or_declarator, direct_notype_declarator, primary, ++ functional_cast): Use it. ++ (notype_declarator_intern): New rule. ++ (notype_declarator, complex_notype_declarator): Use it. ++ ++1998-10-17 Jason Merrill ++ ++ * decl.c (grokfndecl): Set DECL_CONTEXT to namespace if appropriate. ++ (grokvardecl): Likewise. ++ ++Sat Oct 17 23:27:20 1998 Kaveh R. Ghazi ++ ++ * class.c (make_method_vec): Cast 1st argument of `bzero' to (PTR). ++ (add_method): Likewise for arguments 1 & 2 of `bcopy'. ++ ++ * decl.c (signal_catch): Mark with ATTRIBUTE_NORETURN. ++ ++ * pt.c (process_partial_specialization): Cast 1st argument of ++ `bzero' to (PTR). ++ ++ * tree.c (build_base_fields): Cast `base_align' to (int) when ++ comparing against one. ++ ++1998-10-16 Mark Mitchell ++ ++ * decl.c (lookup_name_real): Handle template parameters for member ++ templates where said parameters have the same name as the ++ surrounding class. ++ ++ * decl.c (expand_static_init): Build cleanups before entering the ++ anonymous function used to do them to avoid access-checking ++ confusion. ++ ++ * decl.c (grokfndecl): Add back call to cplus_decl_attributes ++ accidentally removed by previous change, and make DECL_RTL here. ++ * class.c (add_method): Don't make DECL_RTL here. ++ ++ * pt.c (for_each_template_parm): Don't examine uninstantiated ++ default arguments. ++ ++1998-10-16 Dave Brolley ++ ++ * lex.c (real_yylex): Fix unaligned access of wchar_t. ++ ++1998-10-16 Mark Mitchell ++ ++ * class.c (add_method): Fix documentation to reflect previous ++ changes. Check for duplicate method declarations here. ++ * decl.c (decls_match): Handle FUNCTION_DECL vs TEMPLATE_DECL ++ correctly; such things never match. ++ (grokfndecl): Don't look for duplicate methods here. ++ * decl2.c (check_classfn): Don't assume names are mangled. ++ Don't add bogus member function declarations to a class before the ++ class type is complete. ++ (grokfield): Reformat error message. ++ * method.c (set_mangled_name_for_decl): Don't mangle names while ++ processing_template_decl. ++ ++1998-10-16 Jason Merrill ++ ++ * typeck.c (build_indirect_ref): Complain about a pointer to data ++ member, too. ++ * typeck2.c (build_m_component_ref): Don't indirect a pointer to ++ data member. ++ * init.c (resolve_offset_ref): Don't undo the above. ++ ++ * cp-tree.h (DECL_C_BIT_FIELD, SET_DECL_C_BIT_FIELD): New macros. ++ (struct lang_decl_flags): Add `bitfield'. ++ * class.c (finish_struct_1): Use DECL_C_BIT_FIELD instead of ++ DECL_BIT_FIELD. ++ * decl2.c (grokbitfield, grok_alignof): Likewise. ++ * init.c (build_offset_ref): Likewise. ++ * typeck.c (build_component_addr, expr_sizeof): Likewise. ++ * cvt.c (build_up_reference): Don't crash if taking the address ++ returns error_mark_node. ++ ++ * decl.c (grokfndecl): Also check ctype when checking for ::main(). ++ ++1998-10-15 Jason Merrill ++ ++ * decl.c (grokfndecl): ::main and __builtin_* get C linkage. ++ Do mangling here. ++ (grokdeclarator): Instead of here. ++ * friend.c (do_friend): Lose special handling of ::main and ++ __builtin_*. ++ * cp-tree.h (DECL_MAIN_P): Check for C linkage. ++ ++ * spew.c (yylex): Clear looking_for_typename if we got ++ 'enum { ... };'. ++ ++1998-10-15 Mark Mitchell ++ ++ * class.c (maybe_warn_about_overly_private_class): Improve error ++ messages for class with only private constructors. ++ ++ * cp-tree.def (TYPENAME_TYPE): Add to documentation. ++ * cp-tree.h (TYPENAME_TYPE_FULLNAME): Document. ++ (build_typename_type): New function. ++ * decl.c (build_typename_type): Broken out from ... ++ (make_typename_type): Use it. ++ * search.c (lookup_field): Likewise. ++ ++1998-10-14 Benjamin Kosnik ++ ++ * pt.c (convert_nontype_argument): Check against type_referred_to. ++ * decl.c (grokvardecl): Check for declarator name before building ++ DECL_ASSEMBLER_NAME. ++ ++1998-10-14 Mark Mitchell ++ ++ * pt.c (lookup_template_class): Add comment. ++ (instantiate_class_template): Don't mark the _TYPE node for ++ member class templates as an instantiation. ++ ++1998-10-14 Jason Merrill ++ ++ * decl.c (grokfndecl): Fix my thinko. ++ ++1998-10-13 Jason Merrill ++ ++ * tinfo2.cc (fast_compare): Remove. ++ (before): Just use strcmp. ++ * tinfo.cc (operator==): Just use strcmp. ++ ++1998-10-13 Klaus-Georg Adams ++ ++ * decl.c (grokfndecl): Don't check for linkage in `extern "C"' ++ declarations. ++ ++1998-10-13 Mark Mitchell ++ ++ * cp-tree.h (specializations_of_same_template_p): Remove. ++ * search.c (get_template_base): Don't use it. ++ (get_template_base_recursive): Likewise. ++ * pt.c (specializations_of_same_template_p): Remove. ++ (unify): Don't use it. ++ (lookup_template_class): Find the correct parent when setting ++ CLASSTYPE_TI_TEMPLATE. ++ ++1998-10-12 Jason Merrill ++ ++ * tinfo.cc (operator==): Always compare names. ++ ++1998-10-12 Herman ten Brugge ++ ++ * decl.c (start_function): Fix cut-and-paste error. ++ ++1998-10-12 Jason Merrill ++ ++ * inc/typeinfo: Add #pragma interface. ++ (operator!=): Just call operator==. ++ * tinfo.cc: Add #pragma implementation. ++ (operator==): Move from inc/typeinfo and tinfo2.cc. ++ Check __COMMON_UNRELIABLE instead of _WIN32. ++ ++ * typeck2.c (my_friendly_abort): Add URL. ++ ++1998-10-12 Alastair J. Houghton ++ ++ * decl.c (start_method): Added extra parameter for attributes. ++ * cp-tree.h (start_method): Update prototype. ++ * parse.y (fn.def2): Update start_method parameter list. ++ ++1998-10-11 Mark Mitchell ++ ++ * cp-tree.h (specializations_of_same_template_p): Declare. ++ * pt.c (specializations_of_same_template_p): New function. ++ (unify): Use it. ++ * search.c (get_template_base): Use it. ++ (get_template_base_recursive): Likewise. ++ ++1998-10-10 Manfred Hollstein ++ ++ * decl2.c (start_objects): Add new variable `joiner' and ++ initialize it properly. ++ ++1998-10-09 Mark Mitchell ++ ++ * search.c (expand_upcast_fixups): Tweak to match 1998-10-07 ++ change to vtable types. ++ ++ * cvt.c (ocp_convert): Avoid infinite recursion caused by ++ 1998-10-03 change. ++ ++1998-10-08 Jason Merrill ++ ++ * pt.c (resolve_overloaded_unification): New fn. ++ (try_one_overload): Likewise. ++ (unify): Don't fail on unknown type. ++ (type_unification_real): Likewise. Use resolve_overloaded_unification ++ to handle an overloaded argument. ++ (template_args_equal): Split out... ++ (comp_template_args): From here. ++ (determine_specialization): Also allow a template with more ++ parms than were explicitly specified. ++ * cp-tree.h: Add template_args_equal. ++ * call.c (resolve_args): Remove TEMPLATE_ID_EXPR code. ++ ++Thu Oct 8 15:58:30 1998 Anthony Green ++ ++ * semantics.c (finish_asm_stmt): Revert my 1998-09-28 ++ change. ++ ++Thu Oct 8 06:00:19 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * typeck.c (unsigned_type): Only return TItype nodes when ++ HOST_BITS_PER_WIDE_INT is >= 64 bits. ++ (signed_type): Likewise. ++ * decl.c (intTI_type_node, unsigned_intTI_type_node): Only declare ++ when HOST_BITS_PER_WIDE_INT is >= 64 bits. ++ (init_decl_processing): Only create TItype nodes when ++ HOST_BITS_PER_WIDE_INT is >= 64 bits. ++ * cp-tree.h (intTI_type_node, unsigned_intTI_type_node): Only declare ++ when HOST_BITS_PER_WIDE_INT is >= 64 bits. ++ ++Wed Oct 7 12:32:44 1998 Kaveh R. Ghazi ++ ++ * Makefile.in (hash.h): Add -L KR-C -F ', 0, 0' flags to gperf. ++ (gxx.gperf): Update comments describing invocation flags. ++ (hash.h): Regenerate using gperf 2.7.1 (19981006 egcs). ++ ++1998-10-07 Mark Mitchell ++ ++ * class.c (finish_struct_1): Add commentary on previous change. ++ ++ * cp-tree.h (vtbl_ptr_type_node): New variable. ++ * class.c (build_vtbl_ref): Don't indirect through the vptr; it's ++ already of the right type. ++ (finish_struct_1): Make the vptr be of type vtbl_ptr_type_node. ++ Simplify code to grow vtable. ++ * decl.c (vtbl_ptr_type_node): Define. ++ (init_decl_processing): Initialize it. ++ ++1998-10-06 Mark Mitchell ++ ++ * cp-tree.def (PTRMEM_CST): New tree node. ++ * cp-tree.h (ptrmem_cst): New type. ++ (lang_type): Remove local_typedecls. ++ (dummy): Increase to 12 bits from 11. ++ (CLASSTYPE_LOCAL_TYPEDECLS): Remove. ++ (PTRMEM_CST_CLASS): New macro. ++ (PTRMEM_CST_MEMBER): Likewise. ++ (current_access_specifier): New variable. ++ (current_class_type): Remove duplicate declaration. ++ (finish_struct): Change prototype. ++ (unreverse_member_declarations): New function. ++ (pushdecl_class_level): Change prototype. ++ (grok_enum_decls): Remove. ++ (fixup_anonymous_union): New function. ++ (grok_x_components): Change prototype. ++ (tsubst_chain): Remove. ++ (finish_member_template_decl): Likewise. ++ (check_explicit_specialization): Fix indentation. ++ (finish_class_definition): Change prototype. ++ (finish_member_class_template): Likewise. ++ (finish_member_declaration): New function. ++ (check_multiple_declarators): Likewise. ++ * class.c (class_stack_node_t): New type. ++ (current_class_base): Remove. ++ (current_class_stack): Change type. ++ (current_access_specifier): New variable. ++ (grow_method): Remove. ++ (check_member_decl_is_same_in_complete_scope): Break out from ++ finish_struct. ++ (make_method_vec): New function. ++ (free_method_vec): Likewise. ++ (add_implicitly_declared_members): Break out from finish_struct_1. ++ (free_method_vecs): New variable. ++ (add_method): Rework for direct use from parser. ++ (handle_using_decl): Watch for NULL_TREE while iterating through ++ CLASSTYPE_METHOD_VEC. ++ (finish_struct_methods): Don't build CLASSTYPE_METHOD_VEC here; ++ just do some error-checking. ++ (warn_hidden): Change iteration through CLASSTYPE_METHOD_VEC. ++ (finish_struct_1): Simplify. Use add_implicitly_declared_members. ++ (finish_struct): Change prototype. Simplify; fields and methods ++ are already set up at this point. ++ (init_class_processing): Set up current_class_stack. ++ (pushclass): Save current_access_specifier. ++ (popclass): Restore it. ++ (currently_open_class): Simplify. ++ (build_self_reference): Remove use of CLASSTYPE_LOCAL_TYPEDECLS. ++ * decl.c (saved_scope): Add access_specifier. ++ (maybe_push_to_top_level): Save it. ++ (pop_from_top_level): Restore it. ++ (maybe_process_template_type_declaration): Use ++ finish_member_declaration. ++ (pushtag): Likewise. ++ (pushdecl_class_level): Don't return a value. ++ (fixup_anonymous_union): Break out from grok_x_components. ++ (shadow_tag): Use it. ++ (xref_tag): Complain about using an elaborated type specifier to ++ reference a template type parameter or typedef name. ++ (xref_basetypes): Don't set CLASSTYPE_LOCAL_TYPEDECLS. ++ (current_local_enum): Remove. ++ (build_enumerator): Call finish_member_declaration. ++ (grok_enum_decls): Remove. ++ * decl2.c (grok_x_components): Simplify. ++ (check_classfn): Change iteration through CLASSTYPE_METHOD_VEC. ++ (grokfield): Don't set CLASSTYPE_LOCAL_TYPEDECLS. ++ (merge_functions): Add to comment. ++ (arg_assoc_type): Prototype. ++ (arg_assoc): Pass as many arguments as there are parameters. ++ * error.c (dump_expr): Handle PTRMEM_CST. Improve handling of ++ OFFSET_REF. ++ * expr.c (cpls_expand_expr): Remove dead code. Handle ++ PTRMEM_CST. ++ * friend.c (do_friend): Lookup friends when in nested classes. ++ Change comments. ++ * init.c (build_offset_ref): Do lookup even for classes that are ++ only partially defined. ++ (decl_constant_value): Remove dead code. ++ * method.c (build_overload_value): Remove hack where by TYPE was ++ not a TYPE. Handle PTRMEM_CST. ++ (build_template_parm_names): Don't pass a PARM_DECL where a TYPE ++ should go. ++ * parse.y (components, notype_components, component_decl, ++ component_decl_1, component_declarator, component_declarator0): ++ Now all are itype rather than ttype. Rework to add members to ++ classes on the fly. ++ (typesqpecqual_reserved): Use check_multiple_declarators. ++ (structsp): Update class to finish_class_definition. ++ (do_xref_defn): Unsplit into named_class_head. ++ (access_specifier): Set current_access_specifier. ++ * pt.c (set_current_access_from_decl): New function. ++ (finish_member_template_decl): Don't take the parameters. ++ (comp_template_args): Make more robust. ++ (lookup_template_class): Don't use current_local_enum. ++ (for_each_template_parm): Handle PTRMEM_CST. ++ (instantiate_class_template): Use set_current_access_from_decl, ++ finish_member_declaration and unreverse_member_declarations. Set ++ lineno/input_filename before generating implicit member functions. ++ (type_unification_real): Don't assume back-unification happens ++ only for the last argument. ++ (regenerate_decl_from_template): Call pushclass a bit earlier. ++ (tsubst_chain): Remove. ++ (tsubst_enum): Use set_current_access_from_decl. ++ (set_mangled_name_for_template_decl): Fix indentation. ++ * search.c (lookup_fnfields_1): Change iteration through ++ CLASSTYPE_METHOD_VEC. ++ (dfs_pushdecls): Likewise. ++ (dfs_compress_decls): Likewise. ++ (add_conversions): Likewise. ++ * semantics.c (finish_class_definition): Don't take components. ++ Change call to finish_struct. ++ (finish_member_declaration): New function. ++ (finish_member_class_template): Don't take template parameters. ++ Change call to grok_x_components. Call finish_member_template_decl. ++ (check_multiple_declarators): New function. ++ * sig.c (append_signature_fields): Work from the TYPE_METHODS, not ++ a passed in fieldlist. ++ * tree.c (search_tree): Handle PTRMEM_CST. ++ (mapcar): Likewise. ++ * typeck.c (unary_complex_lvalue): Build PTRMEM_CSTs, not ++ INTEGER_CSTs, for pointer-to-data members. ++ ++ * call.c (resolve_args): Resolve template specializations, if ++ possible. ++ ++Tue Oct 6 07:57:26 1998 Kaveh R. Ghazi ++ ++ * Makefile.in (spew.o): Depend on toplev.h. ++ ++ * call.c (compare_ics): Initialize variables `deref_from_type2', ++ `deref_to_type1' and `deref_to_type2'. ++ ++ * except.c (get_eh_type): Hide prototype and definition. ++ (process_start_catch_block_old): Remove unused static prototype. ++ ++ * pt.c (tsubst_decl): Initialize variable `argvec'. ++ ++ * spew.c: Include toplev.h. ++ ++1998-10-05 Jason Merrill ++ ++ * pt.c (instantiate_decl): Do save and restore file position. ++ ++1998-10-05 Martin von Löwis ++ ++ * method.c (build_decl_overload_real): Clear ++ numeric_output_need_bar after __. ++ ++1998-10-05 Nathan Sidwell ++ ++ * call.c (build_new_method_call): Issue 'incomplete type' error, ++ if class is not defined. ++ ++1998-10-05 Kaveh R. Ghazi ++ ++ * call.c (build_object_call): Move declaration of variable ++ `fn' into the scope where it is used. Don't access variable ++ `fn' when it is uninitialized, instead use `fns'. ++ ++1998-10-04 Theodore Papadopoulo ++ ++ * errfn.c (cp_thing): Print buf as a string not as a printf format ++ to avoid problems with the operator%. Consequently, `%%' sequences ++ in format are copied as `%' in buf. ++ ++1998-10-04 Jason Merrill ++ ++ * pt.c (pop_tinst_level): Call extract_interface_info. ++ (instantiate_decl): Don't save and restore file position. ++ ++ * decl.c (cp_finish_decl): Make statics in extern inlines and ++ templates common, if possible and the target doesn't support weak ++ symbols. ++ ++ * decl.c (grokdeclarator): Remove redundant calls to ++ build_type_variant and some duplicated code. ++ * sig.c (build_signature_reference_type): Only take the type parm. ++ (build_signature_pointer_type): Likewise. ++ * tree.c (build_cplus_method_type): Adjust. ++ * cp-tree.h: Update. ++ ++1998-10-04 Mark Mitchell ++ ++ * call.c (build_over_call): Make pedwarns about dropped qualifiers ++ into full-fledged errors. ++ * cvt.c (convert_to_reference): Likewise. ++ * typeck.c (convert_for_assignment): Likewise. ++ ++ * search.c (expand_upcast_vtables): In addition to unsetting ++ TREE_READONLY, remove top-level const type qualifier. ++ ++1998-10-03 Mark Mitchell ++ ++ * class.c (current_class_ptr, current_class_ref): Clarify ++ documentation. ++ * cvt.c (ocp_convert): Don't expect fold to remove all trivial ++ NOP type conversions. ++ * decl.c (decls_match): Use comptypes directly; ignore ++ qualifiers on the DECL. ++ (duplicate_decls): Remove qualifier checks on DECL. ++ (grokdeclarator): Make the type built up include top-level ++ qualifiers. ++ * decl2.c (do_dtors): Fix spelling error. ++ * error.c (dump_simple_decl): Don't look at qualifiers on the decl ++ when printing type information. ++ * init.c (build_new_1): Add documentation. Deal with the fact ++ that type of allocated memory now contains qualifiers. ++ * lex.c (is_global): Improve error-recovery. ++ * sig.c (build_member_function_pointer): Don't cast away const ++ on fields of sigtable_entry_type. ++ * tree.c (lvalue_type): Don't look at top-level qualifiers on ++ expressions. ++ * typeck.c (decay_conversion): Likewise. ++ (build_component_ref): Make sure the type of the COMPONENT_REF ++ contains top-level qualifiers, as appropriate. Improve ++ error-handling. ++ (build_indirect_ref): Simplify. Don't strip top-level qualifiers. ++ (build_array_ref): Likewise. ++ (build_unary_op): Improve error-recovery. ++ (unary_complex_lvalue): Make taking the address a bound member ++ function an error, not a sorry. ++ (build_conditional_expr): Look at the type qualifiers, not the ++ qualifiers on the expression itself. ++ ++1998-10-03 Jason Merrill ++ ++ * decl2.c (merge_functions): Remove duplicates. ++ ++ * decl2.c: Add -f{no-,}implicit-inline-templates. ++ (import_export_decl): Check it. ++ ++ * decl.c (lookup_name_real): Template parms also take precedence ++ over implicit typename. Only warn if yylex. ++ ++ * typeck.c (build_conditional_expr): Only fold if ifexp is an ++ INTEGER_CST. ++ ++ * decl2.c (finish_vtable_vardecl): Check DECL_INTERFACE_KNOWN ++ instead of linkage. ++ ++1998-10-01 Jason Merrill ++ ++ * cp-tree.h (FORMAT_VBASE_NAME): New macro. ++ * class.c (build_vbase_pointer): Use it. ++ * rtti.c (expand_class_desc): Likewise. ++ * tree.c (build_vbase_pointer_fields): Likewise. ++ ++Thu Oct 1 10:43:45 1998 Nick Clifton ++ ++ * decl.c (start_decl): Add invocation of ++ SET_DEFAULT_DECL_ATTRIBUTES, if defined. ++ (start_function): Add invocation of ++ SET_DEFAULT_DECL_ATTRIBUTES, if defined. ++ ++ * lex.c: Replace occurrences of HANDLE_SYSV_PRAGMA with ++ HANDLE_GENERIC_PRAGMAS. ++ ++1998-09-28 Anthony Green ++ ++ * semantics.c (finish_asm_stmt): Always permit volatile asms. ++ ++1998-09-28 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Tighten checks for invalid ++ destructors. Improve error-messages and error-recovery. ++ * decl2.c (check_classfn): Don't assume that mangled destructor ++ names contain type information. ++ ++1998-09-25 Jason Merrill ++ ++ * search.c (get_base_distance): Remove assert. ++ ++ * decl2.c (build_anon_union_vars): Don't process a field with no ++ name. ++ (finish_anon_union): Also complain about local anon unions with no ++ members. ++ ++1998-09-25 Martin von Löwis ++ ++ * decl.c (lookup_namespace_name): If the name is a namespace, ++ return it immediately. ++ ++Fri Sep 25 11:45:38 1998 Kaveh R. Ghazi ++ ++ * cp-tree.h (define_case_label): Remove unused parameter. ++ (check_java_method): Likewise. ++ (grokclassfn): Likewise. ++ (expand_aggr_init): Likewise. ++ (build_x_delete): Likewise. ++ (maybe_end_member_template_processing): Likewise. ++ (unshare_base_binfos): Add prototype. ++ (string_conv_p): Likewise. ++ (my_friendly_abort): Mark with ATTRIBUTE_NORETURN. ++ ++ * cvt.c (build_up_reference): Remove unused parameter ++ `checkconst', all callers changed. ++ (build_type_conversion): Mark parameter `code' with ++ ATTRIBUTE_UNUSED. ++ (build_expr_type_conversion): Initialize variable `conv'. ++ ++ * decl.c (push_namespace): Initialize variable `d'. ++ (define_case_label): Remove unused parameter `decl', all callers ++ changed. ++ ++ * decl2.c (lang_decode_option): If !USE_CPPLIB, mark parameter ++ `argc' with ATTRIBUTE_UNUSED. ++ (grokclassfn): Remove unused parameter `cname', all callers ++ changed. ++ (check_java_method): Likewise for parameter `ctype'. ++ (copy_assignment_arg_p): Mark parameter `virtualp' with ++ ATTRIBUTE_UNUSED. ++ (finish_prevtable_vardecl): Likewise for parameter `prev'. ++ ++ * expr.c (extract_init): Likewise for parameters `decl' and `init'. ++ ++ * init.c (expand_aggr_init_1): Remove unused parameter ++ `alias_this', all callers changed. ++ (expand_aggr_init): Likewise. ++ (expand_default_init): Likewise. ++ (build_new_1): Initialize variable `susp'. ++ (build_x_delete): Remove unused parameter `type', all callers ++ changed. ++ ++ * lex.c (set_typedecl_interface_info): Mark parameter `prev' with ++ ATTRIBUTE_UNUSED. ++ (readescape): Use (unsigned) value in shift. ++ (real_yylex): Likewise. Likewise. Also cast `sizeof' to int when ++ comparing to a signed quantity. ++ ++ * pt.c (maybe_end_member_template_processing): Remove unused ++ parameter `decl', all callers changed. ++ (check_explicit_specialization): Add braces around empty body in ++ an else-statement. ++ (current_template_args): Initialize variable `args'. ++ (lookup_template_class): Likewise for variable `prev_local_enum'. ++ (tsubst_decl): Likewise for variable `r'. ++ (set_mangled_name_for_template_decl): Initialize variable ++ `context'. ++ ++ * spew.c (scan_tokens): Change type of parameter `n' to unsigned. ++ Likewise for variable `i'. ++ (yylex): Initialize variable `trrr'. ++ ++ * typeck.c (compparms): Mark variable `strict' with ++ ATTRIBUTE_UNUSED. ++ ++ * xref.c (simplify_type): Cast argument of ctype function to ++ `unsigned char'. ++ ++1998-09-24 Mark Mitchell ++ ++ * cp-tree.h (language_lvalue_valid): Remove. ++ * decl.c (grokdeclarator): Don't disallow references to functions. ++ * tree.c (lvalue_p_1): New function, combining duplicated ++ code from ... ++ (lvalue_p): Use it. ++ (real_lvalue_p): Likewise. ++ * typeck.c (language_lvalue_valid): Remove. ++ (build_modify_expr): Treat FUNCTION_TYPEs as readonly, even though ++ they don't have TREE_READONLY set. ++ * typeck2.c (readonly_error): Add case for FUNCTION_DECLs. ++ ++1998-09-24 Benjamin Kosnik ++ ++ * spew.c (yylex): Give diagnostic. ++ * hash.h (is_reserved_word): Add export. ++ * gxx.gperf: Likewise. ++ * lex.h (rid): Add RID_EXPORT. ++ * lex.c (init_parse): Likewise. ++ ++Tue Sep 22 21:01:19 1998 Gerald Pfeifer ++ ++ * friend.c (do_friend): Make warning a full sentence. ++ ++1998-09-22 Mark Mitchell ++ ++ * parse.y (component_decl_list): Improve error-recovery. ++ ++1998-09-22 Benjamin Kosnik ++ ++ * decl.c (make_typename_type): Move error to point where name ++ variable can be used by dump_type. ++ ++1998-09-22 Mark Mitchell ++ ++ * decl.c (grokfndecl): Improve error-recovery. ++ * decl2.c (grokfield): Likewise. ++ * pt.c (finish_member_template_decl): Likewise. ++ ++1998-09-20 Martin von Löwis ++ ++ * method.c (hack_identifier): Finding multiple members is always ++ an error. ++ ++1998-09-21 Per Bothner ++ ++ * Make-lang.in (c++-filt): Link libiberty.a after cxxmain.o. ++ ++Mon Sep 21 01:53:05 1998 Felix Lee ++ ++ * lex.c (init_lex): Use getenv ("LANG"), not GET_ENVIRONMENT (). ++ ++1998-09-20 Mark Mitchell ++ ++ * class.c (maybe_warn_about_overly_private_class): Reformat. ++ ++1998-09-17 Andrew MacLeod ++ ++ * exception.cc (__cplus_type_matcher): Realign some code. ++ ++1998-09-16 Mark Mitchell ++ ++ * Make-lang.in (tinfo.o): Use CXXFLAGS when compiling. ++ (tinfo2.o): Likewise. ++ (exception.o): Likewise. ++ (new.o): Likewise. ++ (opnew.o): Likewise. ++ (opnewnt.o): Likewise. ++ (opvnew.o): Likewise. ++ (opvnewnt.o): Likewise. ++ (opdel.o): Likewise. ++ (opdelnt.o): Likewise. ++ (opvdel.o): Likewise. ++ (opvdelnt.o): Likewise. ++ ++1998-09-16 Richard Henderson ++ ++ * decl.c (init_decl_processing): Kill __builtin_fp and __builtin_sp. ++ ++1998-09-15 Alexandre Oliva ++ ++ * call.c (build_field_call): Handle static data members too. ++ ++ * typeck.c (comptypes): When comparing pointer types, check ++ whether referred types match even in strictest modes. ++ ++1998-09-15 Mark Mitchell ++ ++ * cp-tree.h: Revert previous change. ++ (finish_struct_methods): Remove declaration. ++ * class.c: Revert previous change. ++ (maybe_warn_about_overly_private_class): New function. ++ (finish_struct_methods): Declare here, and make static. Remove ++ unnecessary parameters. Tidy slightly. Use ++ maybe_warn_about_overly_private_class. ++ (finish_struct_1): Adjust. Remove check for private constructors, ++ now done elsewhere. ++ (finish_struct): Adjust. ++ ++1998-09-15 Andrew MacLeod ++ ++ * except.c (expand_start_catch_block): No need to check for new ++ exception model. ++ (process_start_catch_block_old): Deleted. ++ (process_start_catch_block): Add call to start_decl_1(). ++ (expand_end_catch_block): Add call to end_catch_handler(). ++ * exception.cc (__cplus_type_matcher): Only check the exception ++ language if there is an exception table. ++ ++1998-09-15 Andrew MacLeod ++ ++ * search.c (expand_indirect_vtbls_init): Mark temporary stack slots ++ as used to prevent conflicts with virtual function tables. ++ ++1998-09-14 Mark Mitchell ++ ++ * cp-tree.h (lang_type): Add has_non_private_static_mem_fn. ++ (CLASSTYPE_HAS_NON_PRIVATE_STATIC_MEM_FN): New macro, to access it. ++ * class.c (maybe_class_too_private_p): New function. ++ (finish_struct_methods): Use it. ++ (finish_struct_1): Likewise. ++ (finish_struct): Set CLASSTYPE_HAS_NON_PRIVATE_STATIC_MEM_FN if ++ appropriate. ++ ++ * pt.c (check_specialization_scope): Fix spelling error. ++ (check_explicit_specialization): Remove code to handle explicit ++ specializations in class scope; they are now correctly diagnosed ++ as errors. ++ ++1998-09-10 Mark Mitchell ++ ++ * decl.c (pushdecl): Don't copy types if the ++ DECL_ABSTRACT_ORIGIN of the new decl matches the TYPE_NAME of the ++ type. ++ ++1998-09-09 Kriang Lerdsuwanakij ++ ++ * class.c (get_enclosing_class): New function. ++ (is_base_of_enclosing_class): Likewise. ++ * cp-tree.h (get_enclosing_class): Declare. ++ (is_base_of_enclosing_class): Likewise. ++ * pt.c (coerce_template_parms): Use them. ++ ++1998-09-09 Jason Merrill ++ ++ * g++spec.c (lang_specific_driver): Check whether MATH_LIBRARY is ++ null to decide whether to use it. ++ ++ * error.c (dump_type_real): Handle NAMESPACE_DECL. ++ * parse.y (base_class.1): Avoid crash on error. ++ ++1998-09-08 Martin von Löwis ++ ++ * decl.c (make_typename_type): If context is a namespace, the code ++ is in error. ++ ++1998-09-08 Mumit Khan ++ ++ * parse.y (nomods_initdcl0): Set up the parser stack correctly. ++ ++1998-09-08 Mark Mitchell ++ ++ * cp-tree.h (anonymous_namespace_name): Declare. ++ * decl.c: Define it. ++ (push_namespace): Use anonymous_namespace_name, rather than local ++ static anon_name. ++ * error.c (dump_decl): If a namespace is named ++ anonymous_namespace_name, call it {anonymous}. ++ ++ * decl.c (grokparms): Distinguish between references and pointers ++ in error message. ++ ++1998-09-08 Richard Henderson ++ Mark Mitchell ++ ++ * pt.c (process_partial_specialization): Consistently allocate ++ and zero tpd.parms based on ntparms. Use tpd2.parms, not ++ tpd.parms, where appropriate. ++ ++Sun Sep 6 00:00:51 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * Makefile.in (INCLUDES): Update after recent toplevel gcc ++ reorganizations. ++ ++1998-09-05 Mark Mitchell ++ ++ * cp-tree.h (TI_PENDING_SPECIALIZATION_FLAG): Remove. ++ * class.c (finish_struct): Remove hackery to deal with explicit ++ specializations in class scope. ++ * decl.c (grokfndecl): Improve error-recovery. ++ * decl2.c (grokfield): Likewise. ++ * pt.c (check_specialization_scope): New function. ++ (begin_specialization): Call it. ++ (process_partial_specialization): New function, split out from ++ push_template_decl. Check partial specializations more ++ stringently. ++ (push_template_decl): Call it. ++ (check_explicit_specialization): Don't attempt to handle explicit ++ specializations in class scope. ++ (template_parm_data): Document. Add current_arg and ++ arg_uses_template_parms. ++ (mark_template_parm): Set it. ++ (tsubst_arg_types): Remove unused variable. ++ * semantics.c (begin_class_definition): Tweak. ++ ++1998-09-04 Mark Mitchell ++ ++ * inc/typeinfo (type_info::type_info(const char*)): Make ++ `explicit'. ++ ++ * cp-tree.h (hash_tree_cons_simple): New macro. ++ * pt.c (tsubst_arg_types): New function. Use hash_tree_cons. ++ (coerce_template_parms): Use make_temp_vec, instead of ++ make_tree_vec. Document this behavior. ++ (lookup_template_class): Likewise. ++ (tsubst, cases METHOD_TYPE, FUNCTION_TYPE): Use tsubst_arg_types. ++ Remove dead code (and add assertion to check its deadness). Fix ++ bug w.r.t. exception specifications. ++ ++1998-09-03 Jason Merrill ++ ++ * decl2.c (import_export_vtable): Always make artificials comdat. ++ (import_export_decl): Likewise. ++ * pt.c (mark_decl_instantiated): Likewise. ++ ++1998-09-03 Mark Mitchell ++ ++ * cp-tree.h (finish_globally_qualified_member_call_expr): ++ Rename to ... ++ (finish_qualified_call_expr). ++ * semantics.c: Likewise. ++ * parse.y (primary): Use it. ++ * method.c (hack_identifier): Remove redundant code. ++ ++ * init.c (resolve_offset_ref): Call convert_from_reference to ++ handle members of reference type. Improve error recovery. ++ ++1998-09-03 Benjamin Kosnik ++ ++ * cp-tree.h: Declare warn_nontemplate_friend. ++ * decl2.c (lang_decode_option): Set. ++ * lang-options.h: Add -Wnon-template-friend. ++ * friend.c (do_friend): Use to toggle non-template function warning. ++ ++1998-09-03 Mark Mitchell ++ ++ * decl.c (finish_enum): Don't resolve CONST_DECLs to their ++ corresponding INTEGER_CSTs when processing_template_decl. ++ * pt.c (tsubst_enum): Tweak accordingly. ++ ++1998-09-03 Benjamin Kosnik ++ ++ * decl.c (pushdecl_class_level): Add warning here. ++ (pushdecl): Tweak. ++ ++1998-09-02 Jason Merrill ++ ++ * cvt.c (convert_pointer_to_real): Tidy. ++ * search.c (get_base_distance_recursive): Simplify. ++ (get_base_distance): Likewise. ++ ++ * pt.c (unify): Only special-case INTEGER_TYPE if it uses template ++ parms. ++ ++Wed Sep 02 09:25:29 1998 Nick Clifton ++ ++ * lex.c (check_newline): Call HANDLE_PRAGMA before ++ HANDLE_SYSV_PRAGMA if both are defined. Generate warning messages ++ if unknown pragmas are encountered. ++ (handle_sysv_pragma): Interpret return code from ++ handle_pragma_token (). Return success/failure indication rather ++ than next unprocessed character. ++ (pragma_getc): New function: retrieves characters from the ++ input stream. Defined when HANDLE_PRAGMA is defined. ++ (pragma_ungetc): New function: replaces characters back into the ++ input stream. Defined when HANDLE_PRAGMA is defined. ++ ++1998-09-01 Jason Merrill ++ ++ * decl2.c (output_vtable_inherit): Use %cDIGIT in the operands. ++ * class.c (build_vtable_entry_ref): Likewise. ++ ++1998-09-01 Mark Mitchell ++ ++ * cp-tree.h (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION): New macro. ++ * decl2.c (import_export_decl): Likewise. ++ * pt.c (instantiate_decl): Use it. ++ ++1998-09-01 Jason Merrill ++ ++ * decl.c (lookup_name_real): Also do implicit typename thing for ++ artificial TYPE_DECLs. ++ * search.c (lookup_field): Likewise. ++ (lookup_fnfields, lookup_field): Adjust for implicit typename kludge. ++ * semantics.c (begin_constructor_declarator): Use enter_scope_of. ++ (enter_scope_of): Extract type from implicit typename. ++ (begin_class_definition): Likewise. ++ * lex.c (identifier_type): Handle implicit typename when checking ++ for SELFNAME. ++ ++ * cp-tree.h: Declare flag_strict_prototype. ++ * lex.c (do_scoped_id, do_identifier): Don't implicitly_declare if ++ -fstrict-prototype. ++ * decl.c (init_decl_processing): If -f{no,-}strict-prototype wasn't ++ specified, set it to the value of pedantic. ++ ++1998-09-01 Mark Mitchell ++ ++ * decl2.c (arg_assoc): Handle template-id expressions as arguments. ++ ++1998-08-31 Mark Mitchell ++ ++ * decl.c (finish_enum): Handle member enums of classes declared in ++ template functions. ++ ++ * decl2.c (grok_x_components): Strip attributes before calling ++ groktypename. ++ ++1998-08-31 Jason Merrill ++ ++ * cp-tree.h, decl2.c: Remove support for -fall-virtual, ++ -fenum-int-equivalence and -fno-nonnull-objects. ++ * class.c (check_for_override): Remove support for -fall-virtual. ++ (finish_struct_1): Likewise. ++ * call.c (build_new_op): Remove support for -fenum-int-equivalence. ++ * typeck.c (build_binary_op_nodefault): Likewise. ++ * cvt.c (ocp_convert): Likewise. ++ * call.c (build_vfield_ref): Remove support for -fno-nonnull-objects. ++ * class.c (build_vbase_path): Likewise. ++ ++Sun Aug 30 22:16:31 1998 H.J. Lu (hjl@gnu.org) ++ ++ * Makefile.in (INTERFACE): New, set to 1. ++ ++1998-08-30 Mark Mitchell ++ ++ * error.c (dump_decl): Use CP_DECL_CONTEXT, not DECL_CONTEXT, when ++ comparing with global_namespace. ++ (dump_aggr_type): Likewise. ++ ++ * decl.c (grokfndecl): Issue error on declaration of friend ++ templates with explicit template arguments. ++ ++ * pt.c (convert_template_argument): New function, split out ++ from... ++ (coerce_template_parms): Here. ++ (tsubst): Attempt better error-recovery. ++ ++1998-08-28 Benjamin Kosnik ++ ++ * pt.c (decl_template_parm_p): Add checks for ++ TEMPLATE_TEMPLATE_PARM. ++ ++1998-08-28 Mark Mitchell ++ ++ * lex.c (do_identifier): Fix thinko in previous change. ++ ++1998-08-28 Jason Merrill ++ ++ * search.c (dfs_search, binfo_for_vtable, dfs_bfv_helper): New fns. ++ * decl2.c (output_vtable_inherit): Call binfo_for_vtable. ++ ++1998-08-28 Richard Henderson ++ ++ Add support for discarding unused virtual functions. ++ * lang-options.h: Add -fvtable-gc. ++ * cp-tree.h: Add flag_vtable_gc. ++ * decl2.c (output_vtable_inherit): New fn. ++ (finish_vtable_vardecl): Call it. ++ * class.c (build_vtable_entry_ref): New fn. ++ (build_vtbl_ref): Call it. ++ ++1998-08-28 Mark Mitchell ++ ++ * cp-tree.h (build_enumerator): Take the enumeration type as a ++ parameter. ++ * decl.c (finish_enum): Don't set the TREE_TYPE for the ++ enumeration constant values if we're processing_template_decls. ++ Don't set the type for the CONST_DECLs either; that's done in ++ build_enumerator. ++ (build_enumerator): Take the enumeration type as a ++ parameter. ++ * lex.c (do_identifier): Don't resolve enumeration constants while ++ processing template declarations, even if they happen to be ++ TEMPLATE_PARM_INDEXs. ++ ++ * parse.y (current_enum_type): New variable. ++ (primary): Don't allow statement-expression in local classes just ++ as we don't in global classes. ++ (structsp): Use current_enum_type. ++ (enum_list): Likewise. ++ * pt.c (tsubst_enum): Don't check for NOP_EXPRs introduced by ++ finish_enum; they no longer occur. ++ ++ * cp-tree.h (finish_base_specifier): New function. ++ * parse.y (base_class): Use it. ++ * semantics.c (finish_base_specifier): Define it. ++ ++ * parse.y (structsp): Warn on use of typename outside of template ++ declarations. ++ ++1998-08-27 Jason Merrill ++ ++ * lex.c (handle_cp_pragma): Remove #pragma vtable. ++ * lang-options.h: Remove +e options. ++ * decl2.c (lang_decode_option): Likewise. ++ (import_export_vtable): Don't check write_virtuals. ++ (finish_vtable_vardecl, finish_file): Likewise. ++ * search.c (dfs_debug_mark): Likewise. ++ * semantics.c (begin_class_definition): Likewise. ++ * class.c (build_vtable, finish_vtbls, finish_struct_1): Likewise. ++ ++ * call.c (build_over_call): Check flag_elide_constructors. ++ * decl2.c: flag_elide_constructors defaults to 1. ++ * typeck.c (convert_arguments): Remove return_loc parm. ++ (build_function_call_real): Adjust. ++ ++ * search.c: Tear out all mi_matrix and memoize code. ++ (lookup_field, lookup_fnfields): Use scratch_tree_cons. ++ * lang-options.h: Remove documentation for -fhandle-exceptions, ++ -fmemoize-lookups and -fsave-memoized. ++ * cp-tree.h: Lose mi_matrix and memoize support. ++ * decl2.c: Ignore -fmemoize-lookups and -fsave-memoized. ++ * class.c: Lose struct class_level. ++ (pushclass, popclass): Lose memoize support. ++ * init.c (build_offset_ref): Likewise. ++ ++ Never change BINFO_INHERITANCE_CHAIN. ++ * init.c (emit_base_init): Change modification of ++ BINFO_INHERITANCE_CHAIN to an assert. ++ * search.c (get_base_distance_recursive): Likewise. ++ (get_base_distance): Likewise. ++ (lookup_member): Likewise. ++ (convert_pointer_to_single_level): Likewise. ++ (lookup_field): Likewise. Lose setting TREE_VIA_* on TREE_LISTs. ++ (lookup_fnfields): Likewise. ++ * tree.c (propagate_binfo_offsets): Don't call unshare_base_binfos. ++ (unshare_base_binfos): Don't call propagate_binfo_offsets. ++ (layout_basetypes): Call propagate_binfo_offsets instead of ++ unshare_base_binfos. ++ * decl.c (xref_basetypes): Call unshare_base_binfos. ++ * pt.c (instantiate_class_template): Likewise. ++ * tree.c (reverse_path): Remove 'copy' parm; always make a ++ temporary copy. ++ * class.c (build_vbase_path): Just call it. ++ * search.c (compute_access): Likewise. Don't re-reverse. ++ ++1998-08-27 Mark Mitchell ++ ++ * class.c (build_vbase_path): Use reverse_path. ++ (finish_base_struct): Move warnings for inaccessible bases to ++ layout_basetypes. ++ (modify_one_vtable): Remove check of TREE_USED (binfo). ++ (fixup_vtable_deltas1): Likewise. ++ * cp-tree.h (BINFO_INHERITANCE_CHAIN): Document here. ++ (xref_tag): Remove binfos parameter. ++ (make_binfo): Remove chain parameter. ++ (reverse_path): Add copy parameter. ++ * decl.c (init_decl_processing): Change calls to xref_tag. ++ (xref_tag): Remove binfos parameter. ++ (xref_basetypes): Change calls to make_binfo. ++ * decl2.c (grok_x_components): Change calls to xref_tag. ++ (handle_class_head): Likewise. ++ * friend.c (do_friend): Likewise. ++ * lex.c (make_lang_type): Change calls to make_binfo. ++ * parse.y (structsp): Change calls to xref_tag. ++ (named_complex_class_head_sans_basetype): Likewise. ++ (named_class_head): Likewise. ++ * rtti.c (init_rtti_processing): Likewise. ++ * search.c (compute_access): Change calls to reverse_path. ++ (dfs_get_vbase_types): Change calls to make_binfo. ++ (get_vbase_types): Remove dead code. ++ * tree.c (unshare_base_binfos): Change calls to make_binfo. ++ (layout_basetypes): Warn here about inaccessible bases. ++ (make_binfo): Remove chain parameter. ++ (reverse_path): Add copy parameter. ++ ++1998-08-27 Jason Merrill ++ ++ * class.c: #if 0 complete_type_p. ++ * init.c (build_java_class_ref, build_new_1): Remove unused locals. ++ * method.c (process_overload_item): Likewise. ++ * typeck.c (comp_target_types): Likewise. ++ ++ Stop sharing binfos for indirect virtual bases. ++ * tree.c (propagate_binfo_offsets): Unshare vbases, too. ++ (layout_basetypes): Likewise. ++ (unshare_base_binfos): Copy vbases, too. ++ * cp-tree.h (BINFO_VIA_PUBLIC, BINFO_BASEINIT_MARKED, ++ BINFO_VBASE_INIT_MARKED): Remove obsolete macros. ++ (BINFO_PUSHDECLS_MARKED, SET_BINFO_PUSHDECLS_MARKED, ++ CLEAR_BINFO_PUSHDECLS_MARKED): New macros. ++ * search.c (lookup_field, lookup_fnfields, lookup_member): Remove ++ reference to BINFO_VIA_PUBLIC. ++ (marked_pushdecls_p, unmarked_pushdecls_p): New fns. ++ (push_class_decls): Use them. ++ (dfs_pushdecls): Use SET_BINFO_PUSHDECLS_MARKED. ++ (dfs_compress_decls): Use CLEAR_BINFO_PUSHDECLS_MARKED. ++ ++1998-08-27 Mark Mitchell ++ ++ * decl.c (build_enumerator): Set DECL_CONTEXT for the ++ CONST_DECLs. ++ ++1998-08-26 Mark Mitchell ++ ++ * cp-tree.h (finish_enum): Change prototype. ++ * decl.c (finish_enum): Use TYPE_VALUES, rather than taking a ++ VALUES parameter. Don't try to compute mins/maxs if ++ processing_template_decl. ++ * parse.y (structsp): Use new calling sequence for finish_enum. ++ * pt.c (tsubst_enum): Likewise. Take the new type as input. ++ (lookup_template_class): Remove unused variables. Tweak. ++ Register enums on instantiation list before substituting ++ enumeration constants. ++ (tsubst_decl): Remove unused variables. ++ (regenerate_decl_from_template): Likewise. ++ ++ * decl.c (duplicate_decls): Don't obliterate the ++ DECL_TEMPLATE_INFO for a template if we're not replacing it with ++ anything. ++ ++ * lex.c (do_identifier): Fix typo in comment. ++ ++Wed Aug 26 10:54:51 1998 Kaveh R. Ghazi ++ ++ * errfn.c: Remove stdarg.h/varargs.h. ++ * tree.c: Likewise. ++ ++1998-08-25 Brendan Kehoe ++ ++ * pt.c (tsubst_copy): Only do typename overloading on an ++ IDENTIFIER_NODE that happens to look like a typename if it actually ++ has a type for us to use. ++ ++1998-08-25 Jason Merrill ++ ++ * typeck.c (comp_cv_target_types): Split out... ++ (comp_target_types): From here. Don't allow cv-qual changes under ++ a pointer if nptrs == 0. Fix OFFSET_TYPE handling. ++ (build_ptrmemfunc): Pass 1 to nptrs. ++ * cvt.c (perform_qualification_conversions): Use comp_ptr_ttypes. ++ ++1998-08-25 Mark Mitchell ++ ++ * search.c (dependent_base_p): Don't compare a binfo to ++ current_class_type; use the TREE_TYPE of the binfo instead. ++ ++ * cp-tree.h (CLASS_TYPE_P): Revise definition. ++ ++1998-08-25 Jason Merrill ++ ++ * decl.c (duplicate_decls): Don't complain about different ++ exceptions from an internal decl even if pedantic. ++ ++ * typeck.c (convert_for_assignment): Converting from pm of vbase ++ to derived is an error, not a sorry. ++ ++ * call.c (build_over_call): Use convert_pointer_to_real for 'this'. ++ * class.c (fixed_type_or_null): Rename from ++ resolves_to_fixed_type_p. Return the dynamic type of the ++ expression, if fixed, or null. ++ (resolves_to_fixed_type_p): Use it. Return 0 if the dynamic type ++ does not match the static type. ++ (build_vbase_path): Rename 'alias_this' to 'nonnull'. Use ++ resolves_to_fixed_type_p again. ++ ++1998-08-24 Mark Mitchell ++ ++ * pt.c (tsubst_decl): Move special case code for dealing with ++ tricky friend templates here from ... ++ (regenerate_decl_from_template): Here. ++ ++1998-08-24 Jason Merrill ++ ++ * decl.c (start_decl): Remove redundant linkage check. ++ ++1998-08-24 Gavin Romig-Koch ++ ++ * typeck.c (c_expand_return): Handle the case that valtype ++ is wider than the functions return type. ++ ++1998-08-24 Mark Mitchell ++ ++ * cp-tree.h (CLASS_TYPE_P): New macro. ++ * decl.c (grokdeclarator): Use it instead of IS_AGGR_TYPE. ++ * pt.c (process_template_parm): Undo previous change. ++ ++1998-08-24 Benjamin Kosnik ++ ++ * cp-tree.h: Declare. ++ * pt.c (decl_template_parm_p): New function. ++ * decl.c (pushdecl): Check decls for redeclaring template parms. ++ (xref_tag): Make redeclaration an error, print decl. ++ * decl2.c (grokfield): Check field_decls for redeclaration as well. ++ ++1998-08-24 Jason Merrill ++ ++ * parse.y (primary): Fix up the type of string constants. ++ ++1998-08-24 Mark Mitchell ++ ++ * typeck.c (convert_for_initialization): Move check for odd uses ++ of NULL to avoid duplicate warnings. ++ ++1998-08-24 Jason Merrill ++ ++ * tree.c (lvalue_type): Fix for arrays. ++ * typeck.c (string_conv_p): New fn. ++ (convert_for_assignment): Use it. ++ (build_unary_op): Use lvalue_type. ++ * call.c (standard_conversion, convert_like): Use string_conv_p. ++ (add_function_candidate): Use lvalue_type. ++ * cvt.c (convert_to_reference): Likewise. ++ * decl2.c (lang_decode_option): Ignore -traditional. ++ * decl.c (init_decl_processing): flag_writable_strings inhibits ++ flag_const_strings. ++ ++1998-08-24 Andrew MacLeod ++ ++ * lang-options.h (lang_options): Add fconst-strings to the list ++ of valid options. ++ * decl2.c (lang_f_options, lang_decode_option): Likewise. ++ ++1998-08-24 Nathan Sidwell ++ ++ * lex.c (real_yylex): Don't warn about long long constants if ++ we're allowing long long. ++ ++1998-08-24 Martin von Löwis ++ ++ * decl.c (pushdecl): Use IDENTIFIER_NAMESPACE_VALUE instead of ++ accessing bindings directly. ++ ++ * search.c (my_tree_cons): Reimplement. ++ ++ * lang-specs.h: Remove __HONOR_STD. ++ * inc/exception, inc/new, inc/new.h, inc/typeinfo: Likewise. ++ ++1998-08-23 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Complain about in-class initialization ++ of aggregates and/or references. ++ * pt.c (process_template_parm): Clear IS_AGGR_TYPE for ++ TEMPLATE_TYPE_PARMs. ++ ++ * decl2.c (grok_array_decl): Add comment. ++ (mark_used): Don't instantiate an explicit instantiation. ++ * friend.c (make_friend_class): Remove bogus comment. Fix check ++ for partial specializations. ++ * pt.c (check_explicit_specialization): Don't ++ SET_DECL_EXPLICIT_INSTANTIATION here. ++ (mark_decl_instantiated): Or here. ++ (do_decl_instantiation): Do it here, instead. Add checks for ++ duplicate explicit instantiations, etc. Tidy. ++ (do_type_instantiation): Likewise. ++ (instantiate_decl): Improve comments. Complain about explicit ++ instantiations where no definition is available. ++ ++ * cp-tree.h (ansi_null_node): Remove. ++ * call.c (build_over_call): Warn about converting NULL to an ++ arithmetic type. ++ * cvt.c (build_expr_type_conversion): Likewise. Use ++ null_ptr_cst_p instead of expanding it inline. ++ * decl.c (ansi_null_node): Remove. ++ (init_decl_processing): Make null_node always have integral type. ++ * except.c (build_throw): Warn about converting NULL to an ++ arithmetic type. ++ * lex.c (init_parse): Remove handling of ansi_null_node. ++ * pt.c (type_unification_real): Don't convert NULL to void* type. ++ * typeck.c (build_binary_op_nodefault): Fix NULL warnings. ++ (convert_for_assignment): Warn about converting NULL to an ++ arithmetic type. ++ (convert_for_initialization): Likewise. ++ ++1998-08-20 Jason Merrill ++ ++ * tree.c (search_tree, no_linkage_helper, no_linkage_check): New fn. ++ * pt.c (coerce_template_parms): Use no_linkage_check. ++ * decl.c (grokvardecl): Likewise. ++ (grokfndecl): Likewise. Members of anonymous types have no linkage. ++ ++ * method.c (process_overload_item): Remove useless code. ++ ++1998-08-20 Per Bothner ++ ++ Handle new'ing of Java classes. ++ * init.c (build_class_classref): New function. ++ (build_new_1): If type is TYPE_FOR_JAVA: Call _Jv_AllocObject; ++ constructor does not return this; don't need to exception-protect. ++ ++ * pt.c (lookup_template_class): Copy TYPE_FOR_JAVA flag. ++ * decl2.c (acceptable_java_type): Handle template-derived types. ++ ++1998-08-20 Per Bothner ++ ++ * decl2.c (import_export_vtable): Suppress vtables for Java classes. ++ ++1998-08-20 Mark Mitchell ++ ++ * decl.c (duplicate_decls): Always merge the old and new patterns ++ for templates, regardless of whether or not the new one has ++ DECL_INITIAL. Don't throw away specializations. Merge ++ DECL_SAVED_TREE. ++ * pt.c (tsubst_decl): Use the right pattern when calculating the ++ complete args for a new template instance. ++ (do_decl_instantiation): Fix typo in comment. ++ (regenerate_decl_from_template): Deal with tricky friend template ++ case. ++ (instantiate_decl): Likewise. ++ ++Thu Aug 20 09:09:45 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * init.c (build_builtin_delete_call): Add missing assemble_external ++ call. ++ ++1998-08-20 Jason Merrill ++ ++ * parse.y (notype_unqualified_id): Also accept ~A. ++ ++1998-08-19 Mark Mitchell ++ ++ * typeck.c (build_binary_op_nodefault): Warn on use of NULL in ++ arithmetic. ++ * except.c (build_throw): Warn when NULL is thrown, even with ++ -ansi. Use ansi_null_node, rather than integer_zero_node, in the ++ thrown expression. ++ ++ * cp-tree.h (ansi_null_node): New variable. ++ * decl.c (ansi_null_node): New variable. ++ (init_decl_processing): Initialize its type. ++ * lex.c (init_parse): Initialize its value. Use ansi_null_node ++ for null_node in non-ANSI mode. ++ * typeck.c (build_binary_op_nodefault): Use ansi_null_node in ++ place of null_node to avoid spurious errors. ++ ++1998-08-17 Mark Mitchell ++ ++ * cp-tree.h (enter_scope_of): New function. ++ * parse.y (complex_direct_notype_declarator): Use it. ++ * semantics.c (enter_scope_of): New function. ++ ++1998-08-17 Jason Merrill ++ ++ * decl.c (grokparms): No, here. ++ ++ * decl.c (grokdeclarator): Catch parm with pointer to array of ++ unknown bound here... ++ * method.c (process_overload_item): ...not here. ++ ++ * gxxint.texi: Remove obsolete documentation of overloading code. ++ ++ * decl.c (finish_enum): Also set TYPE_SIZE_UNIT. ++ * class.c (finish_struct_bits): Likewise. ++ ++ * tree.c (lvalue_type): Fix for arrays. ++ * typeck.c (build_unary_op): Use lvalue_type. ++ * call.c (add_function_candidate): Likewise. ++ * cvt.c (convert_to_reference): Likewise. ++ ++ * decl2.c (lang_decode_option): Ignore -traditional. ++ ++ * init.c (build_offset_ref): Don't mess with error_mark_node. ++ * lex.c (do_scoped_id): Use cp_error. ++ ++ * rtti.c (get_tinfo_fn): Don't mess with the context for now. ++ ++1998-08-17 Benjamin Kosnik ++ ++ * decl.c (grokdeclarator): Allow anonymous types to be cv-qualified. ++ ++Mon Aug 17 10:40:18 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * cp-tree.h (set_identifier_local_value): Provide prototype. ++ ++ * decl2.c (do_namespace_alias): Remove unused variables `binding' ++ and `old'. ++ ++Fri Aug 14 16:42:27 1998 Nick Clifton ++ ++ * Makefile.in: Rename BBISON to BISON so that it can be properly ++ inherited from the parent makefile. ++ ++1998-08-13 Jason Merrill ++ ++ * lang-options.h: Add -finit-priority. ++ * decl2.c: Likewise. Check flag_init_priority instead of ++ USE_INIT_PRIORITY. ++ ++ * decl2.c (setup_initp): New fn. ++ (start_objects, finish_objects, do_ctors): Handle init_priority. ++ (do_dtors, finish_file): Likewise. ++ ++1998-08-13 Jason Merrill ++ ++ * pt.c (tsubst_copy): Hush warning. ++ ++ * rtti.c (get_tinfo_fn): Also set DECL_IGNORED_P. ++ ++1998-08-12 Mark Mitchell ++ ++ * pt.c (print_template_context): Don't abort when instantiating a ++ synthesized method. ++ ++ * decl.c (grokdeclarator): Issue errors on namespace qualified ++ declarators in parameter lists or in class scope. ++ ++1998-08-09 Mark Mitchell ++ ++ * pt.c (check_explicit_specialization): Don't abort on bogus ++ explicit instantiations. ++ ++1998-08-07 Mark Mitchell ++ ++ * typeck.c (require_complete_type): Use complete_type_or_else. ++ (complete_type_or_else): Always return NULL_TREE on failure, as ++ documented. ++ ++ * pt.c (tsubst_aggr_type): Prototype. ++ (tsubst_decl): New function, split out from tsubst. Set ++ input_filename and lineno as appropriate. ++ (pop_tinst_level): Restore the file and line number saved in ++ push_tinst_level. ++ (instantiate_class_template): Set input_filename and lineno as ++ appropriate. ++ (tsubst): Move _DECL processing to tsubst_decl. Make sure the ++ context for a TYPENAME_TYPE is complete. ++ ++ * decl2.c (grokbitfield): Issue errors on bitfields declared with ++ function type. ++ (do_dtors): As in do_ctors, pretend to be a member of the same ++ class as a static data member while generating a call to its ++ destructor. ++ ++ * cvt.c (cp_convert_to_pointer): Handle NULL pointer ++ conversions, even in complex virtual base class hierarchies. ++ ++1998-08-06 Mark Mitchell ++ ++ * cp-tree.h (ENUM_TEMPLATE_INFO): New macro. ++ (TYPE_TEMPLATE_INFO): Likewise. ++ (SET_TYPE_TEMPLATE_INFO): Likewise. ++ (ENUM_TI_TEMPLATE): Likewise. ++ (ENUM_TI_ARGS): Likewise. ++ (lookup_nested_type_by_name): Remove. ++ * decl.c (maybe_process_template_type_declaration): Handle enums. ++ (start_enum): Don't check for primary-template enum declarations ++ here. ++ (finish_enum): Clean up, document. Make sure template enum ++ constants get the correct type. ++ (build_enumerator): Copy initializers for template enumerations, ++ too. ++ (grok_enum_decls): Document. ++ * lex.c (do_identifier): Document use of LOOKUP_EXPR a bit ++ better. Build LOOKUP_EXPRs for local variables, even if they are ++ TREE_PERMANENT. ++ * pt.c (tsubst_enum): Remove field_chain parameter. ++ (template_class_depth): Include the depth of surrounding function ++ contexts. ++ (push_template_decl): Check for primary-template enum declarations ++ here. Deal with enumeration templates. ++ (lookup_template_class): Likewise. ++ (for_each_template_parm): Likewise. ++ (instantiate_class_template): Don't call tsubst_enum directly, ++ call tsubst instead, to instantiate enums. Deal with all ++ field_chain issues here, not in tsubst_enum. ++ (lookup_nested_type_by_name): Remove. ++ (tsubst_aggr_type): Revise handling of enumeration types. ++ (tsubst): Likewise. ++ (tsubst_copy): Likewise. ++ (tsubst_expr): Call tsubst, not tsubst_enum for TAG_DEFNs. ++ ++1998-08-04 Mark Mitchell ++ ++ * decl.c (pushtag): Don't mangle the name of a TYPE_DECL if it ++ uses template parameters. ++ * method.c (build_template_parm_names): Use the full set of ++ template arguments for tsubst'ing. ++ (build_overload_identifier): Pass the full set of template ++ arguments to build_template_parm_names, not just the ++ innermost_args. ++ * pt.c (TMPL_ARGS_DEPTH): Define using ++ TMPL_ARGS_HAVE_MULTIPLE_LEVELS, for clarity. ++ (NUM_TMPL_ARGS): New macro. ++ (add_outermost_template_args): Deal with the case where the outer ++ args will be completely discarded. ++ (coerce_template_parms): Use the full set of template arguments ++ for tsubst'ing. Simplify. Add some asserts. Improve ++ error messages. ++ (lookup_template_class): Pass the full set of template arguments ++ to coerce_template_parms. ++ (tsubst): Add assertion. ++ (do_type_instantiation): Don't instantiate member template ++ classes. ++ ++ * init.c (build_offset_ref): Deal with a TEMPLATE_ID_EXPR whose ++ name is a LOOKUP_EXPR, rather than an IDENTIFIER_NODE. ++ ++1998-08-03 Jason Merrill ++ ++ * method.c (set_mangled_name_for_decl): Change return type to void. ++ ++ * decl.c (lookup_name_real): A namespace-level decl takes priority ++ over implicit typename. Avoid doing the same lookup twice. ++ ++ * search.c (dependent_base_p): New fn. ++ (dfs_pushdecls, dfs_compress_decls): Use it. ++ ++ * typeck.c (get_member_function_from_ptrfunc): Don't try to handle ++ virtual functions if the type doesn't have any. ++ ++1998-08-03 Mark Mitchell ++ ++ * decl2.c (grokfield): Don't mangle the name of a TYPE_DECL if it ++ uses template parameters. ++ ++1998-08-02 Mark Mitchell ++ ++ * cp-tree.def (LOOKUP_EXPR): Document. Remove second argument. ++ * cp-tree.h (DECL_TI_TEMPLATE): Improve documentation. ++ * lex.c (do_identifier): Don't use a second argument, or a type, ++ when building LOOKUP_EXPRs. ++ (do_identifier): Likewise. ++ (do_scoped_id): Likewise. ++ * method.c (hack_identifier): Improve error message. ++ * pt.c (lookup_template_function): Don't needlessly call ++ copy_to_permanent or build_min. ++ (tsubst_copy): Remove #if 0'd code. tsubst into LOOKUP_EXPRs if ++ necessary. ++ (do_decl_instantiation): Improve error message. ++ * tree.c (mapcar, case LOOKUP_EXPR): Don't be sorry; make a copy. ++ (build_min): Copy the type to the permanent obstack, too. ++ ++1998-08-01 Jason Merrill ++ ++ * init.c (init_init_processing): Remove BI* handling. ++ (build_builtin_call): Remove. ++ (build_builtin_delete_call): New fn. ++ (build_delete): Use it. ++ ++1998-07-31 Mark Mitchell ++ ++ * cp-tree.h (PROCESSING_REAL_TEMPLATE_DECL_P): New macro. ++ (maybe_check_template_type): New function. ++ * decl.c (maybe_process_template_type_declaration): New function, ++ split out from pushtag Call maybe_check_template_type. ++ (pushtag): Use it. Use PROCESSING_REAL_TEMPLATE_DECL_P. ++ (xref_tag): Use PROCESSING_REAL_TEMPLATE_DECL_P. ++ * friend.c (do_friend): Use PROCESSING_REAL_TEMPLATE_DECL_P. ++ * pt.c (template_class_depth_real): Generalization of ... ++ (template_class_depth): Use it. ++ (register_specialization): Use duplicate_decls for duplicate ++ declarations of specializations. ++ (maybe_check_template_type): New function. ++ (push_template_decl_real): Fix comment. ++ (convert_nontype_argument): Likewise. ++ (lookup_template_class): Likewise. Avoid an infinite loop on ++ erroneous code. ++ (tsubst_friend_function): Fix comment. ++ (tsubst, case FUNCTION_DECL): Deal with a DECL_TI_TEMPLATE that is ++ an IDENTIFIER_NODE. ++ * semantics.c (begin_function_definition): Use ++ reset_specialization to note that template headers don't apply ++ directly to declarations after the opening curly for a function. ++ ++1998-07-29 Jason Merrill ++ ++ * decl.c (push_overloaded_decl): Use current_namespace instead of ++ DECL_CONTEXT (decl) to determine where we go. ++ ++ * decl.c (lookup_name_real): Fix typo. ++ ++1998-07-28 Mark Mitchell ++ ++ * friend.c (is_friend): Be lenient with member functions to deal ++ with nested friends. ++ ++1998-07-28 Jason Merrill ++ ++ * class.c (finish_struct_1): Convert integer_zero_node to ++ ssizetype before passing it to set_rtti_entry. ++ * typeck2.c (initializer_constant_valid_p): Allow conversion of 0 ++ of any size to a pointer. ++ ++1998-07-27 Mark Mitchell ++ ++ * cp-tree.h (TI_USES_TEMPLATE_PARMS): Remove. ++ (build_template_decl_overload): Remove. ++ (set_mangled_name_for_decl): New function. ++ (innermost_args): Remove is_spec parameter. ++ (most_specialized, most_specialized_class): Remove declarations. ++ (lookup_template_class): Add entering_scope parameter. ++ (maybe_process_partial_specialization): New function. ++ (finish_template_decl): Likewise. ++ (finish_template_type): Likewise. ++ * class.c (finish_struct): Clean up processing of member template ++ specializations. ++ * decl.c (pushtag): Fix formatting. ++ (lookup_tag): Improve handling of pseudo-global levels. ++ (make_typename_type): Adjust call to lookup_template_class. ++ (shadow_tag): Use maybe_process_partial_specialization. ++ (xref_tag): Improve handling of member friends. ++ (start_function): Call push_nested_class before ++ push_template_decl. Don't call push_template_decl for ++ specializations. ++ * decl2.c (grok_x_components): Don't call xref_tag for ++ template instantiations. Handle UNION_TYPEs like RECORD_TYPEs. ++ (grokclassfn): Use set_mangled_name_for_decl. ++ (arg_assoc_class): Adjust call to innermost_args. ++ (mark_used): Don't call instantiate_decl for a TEMPLATE_DECL. ++ * error.c (dump_function_name): Improve printing of template ++ function names. ++ * friend.c (is_friend): Don't compare types of decls to determine ++ friendship, unless flag_guiding_decls. ++ (make_friend_class): Partial specializations cannot be friends. ++ (do_friend): Use set_mangled_name_for_decl. Call ++ push_template_decl_real instead of push_template_decl. ++ * method.c (build_decl_overload_real): Remove prototype. Give it ++ external linkage. ++ (build_overload_identifier): Adjust call to innermost_args. ++ (build_template_decl_overload): Remove. ++ (set_mangled_name_for_decl): New function. ++ * parse.y (.finish_template_type): New non-terminal. ++ (template_def): Use finish_template_decl. Use template_extdef ++ instead of extdef. ++ (template_extdef, template_datadef): New non-terminals, containing ++ only those rules for things which can be templates. ++ (datadef): Tidy. ++ (template_type, self_template_type): Use .finish_template_type. ++ (named_class_head): Use maybe_process_partial_specialization. ++ * pt.c (mangle_class_name_for_template): Remove context parameter. ++ (get_class_bindings): Remove outer_args parameter. ++ (complete_template_args): Remove. ++ (add_outermost_template_args): New function. ++ (register_specialization): Return the specialization. ++ (unregister_specialization): New function. ++ (tsubst_template_parms): Likewise. ++ (most_specialized, most_specialized_class): Prototype here as ++ static. ++ (original_template): Rename to most_general_template. ++ (tsubst_template_parms): New function. ++ (set_mangled_name_for_template_decl): Likewise. ++ (TMPL_ARGS_DEPTH): New macro. ++ (TMPL_ARGS_HAVE_MULTIPLE_LEVELS): Adjust. ++ (TMPL_ARGS_LEVEL): New macro. ++ (SET_TMPL_ARGS_LEVEL): Likewise. ++ (TMPL_ARG): Likewise. ++ (SET_TMPL_ARG): Likewise. ++ (TMPL_ARGS_DEPTH): Likewise. ++ (finish_member_template_decl): Use finish_template_decl. ++ (maybe_process_partial_specialization): New function, split out ++ from tsubst. ++ (inline_needs_template_parms): Use TMPL_PARMS_DEPTH. ++ (maybe_begin_member_template_processing): Use new macros. ++ (is_member_template): Likewise. ++ (is_member_template_class): Likewise. ++ (add_to_template_args): Likewise. Deal with multiple levels of ++ args. ++ (maybe_process_partial_specialization): New function. ++ (retrieve_specialization): Add consistency check. ++ (determine_specialization): Return full argument list. ++ (check_explicit_specialization): Tweak friend handling. Use full ++ argument lists. Simplify. ++ (current_template_args): Use new macros. ++ (push_template_decl_real): Change ill-named mainargs to specargs. ++ Check that a partial specialization actually specializes at least ++ one parameter. Improve friend handling. Modify for full ++ template arguments. ++ (classtype_mangled_name): Don't mangle the names of ++ specializations. ++ (lookup_template_class): Add entering_scope parameter. Use it to ++ avoid finding a template type when an instantiation is required. ++ Simplify. Use full template arguments. ++ (tsubst_friend_function): Use unregister_specialization. Use new ++ macros. Use full template arguments. ++ (tsubst_friend_class): Substitute, using tsubst_template_parms, ++ into the template parameters before passing them to ++ redeclare_class_template. ++ (instantiate_class_template): Simplify. Use full template ++ arguments. Adjust calls to get_class_bindings. Use ++ SET_IDENTIFIER_TYPE_VALUE where needed. Improve friend handling. ++ (innermost_args): Use new macros. ++ (tsubst_aggr_type): New function, split out from tsubst. ++ (tsubst): Use tsubst_aggr_type, tsubst_template_parms, new calling ++ conventions for lookup_template_class. Refine handling of partial ++ instantiations. Remove calls to complete_template_args. ++ Simplify. Add consistency checks. Use set_mangled_name_for_decl ++ and set_mangled_name_for_template_decl. ++ (tsubst_copy): Use tsubst_aggr_type. ++ (instantiate_template): Use full template arguments. ++ (more_specialized): Improve formatting. ++ (more_specialized_class): Adjust calls to get_class_bindings. ++ (get_bindings_real): Don't call complete_template_args. ++ (most_specialized): Don't overwrite input; create a new list. ++ (most_specialized_class): Use most_general_template. ++ (regenerate_decl_from_template): Use unregister_specialization. ++ Use full template arguments. ++ (instantiate_decl): Use full template arguments. ++ (set_mangled_name_for_template_decl): New function. ++ * semantics.c (begin_class_definition): Use ++ maybe_process_partial_specialization. ++ (finish_member_class_template): New function. ++ (finish_template_decl): Likewise. ++ (finish_template_type): Likewise. ++ (typeck.c): Don't crash after issuing a compiler_error. ++ * Makefile.in (CONFLICTS): Adjust; we removed a s/r conflict. ++ ++1998-07-27 Jason Merrill ++ ++ * typeck2.c (build_functional_cast): Handle default-initialization. ++ ++ * call.c (build_over_call): Pass 1 to popclass. ++ ++ * parse.y (direct_notype_declarator): Add precedence declaration ++ to notype_unqualified_id case. ++ * Makefile.in (EXPECT): Adjust. ++ ++ * tree.c (ovl_member): Fix for single function in OVL. ++ ++1998-07-27 Dave Brolley ++ ++ * c-lex.c (yylex): Fix boundary conditions in character literal and ++ string literal loops. ++ ++1998-07-24 Jason Merrill ++ ++ * decl.c (lookup_name_real): OK, do return the from_obj value ++ unless got_object depends on template parms. ++ ++ * parse.y (nested_name_specifier_1): Pull out the TYPE_MAIN_VARIANT. ++ ++ * pt.c (coerce_template_parms): Also complain about local enums. ++ ++ * cp-tree.h: Add prototype for set_identifier_local_value. ++ * decl.c (set_identifier_local_value_with_scope): Make static, ++ prototype. ++ * search.c (covariant_return_p): Likewise. ++ * except.c (build_terminate_handler, alloc_eh_object): Likewise. ++ ++ * call.c (build_method_call): Only pull out the type of a destructor ++ if it's a template type parm. ++ * decl.c (lookup_name_real): Never return the from_obj value. ++ ++1998-07-23 Jason Merrill ++ ++ * except.c (process_start_catch_block_old): Call start_decl_1 for ++ catch parm. ++ * decl.c (start_decl_1): Avoid duplicate error. ++ ++ * init.c (expand_default_init): Only perform the initialization if ++ it will do something. ++ ++1998-07-23 H.J. Lu (hjl@gnu.org) ++ ++ * parse.y (base_class): Check for invalid base class. ++ ++1998-07-23 Jason Merrill ++ ++ * decl2.c (import_export_template): Fold in... ++ (import_export_class): ...to here. Handle dllimport/export. ++ ++ * class.c (build_vtable): Pass at_eof to import_export_vtable. ++ (prepare_fresh_vtable): Likewise. ++ * decl2.c (import_export_class): Split out... ++ (finish_prevtable_vardecl): From here. ++ * class.c (finish_struct_1): Call import_export_class if at_eof. ++ ++ * decl.c (start_function): #if 0 mysterious code I wrote and have ++ forgotten why. ++ * rtti.c (get_tinfo_fn): If this is for a class type, set ++ DECL_CONTEXT. ++ ++1998-07-22 Jason Merrill ++ ++ * inc/exception: Change terminate and unexpected to (). ++ ++ * parse.y (named_class_head_sans_basetype_defn): A ++ named_class_head_sans_basetype followed by '{' or ':' is a defn. ++ ++1998-07-21 Jason Merrill ++ ++ * tree.c (canonical_type_variant): New fn to handle arrays. ++ * cp-tree.h (CANONICAL_TYPE_VARIANT): Remove. ++ * pt.c (unify, default case): Also fold arg. Fix array bounds case. ++ * method.c (process_overload_item): Use build_overload_value for ++ arrays. ++ ++1998-07-20 Dave Brolley ++ ++ * lex.c (mbchar.h): #include it. ++ (GET_ENVIRONMENT): New macro. ++ (init_parse): Set character set based on LANG environment variable. ++ (real_yylex): Handle multibyte characters in character literals. ++ (real_yylex): Handle multibyte characters in string literals. ++ ++1998-07-19 Jason Merrill ++ ++ * lex.c (do_identifier): Look for class value even if we don't ++ have a global value. Do implicit declaration if parsing is 2. ++ * semantics.c (finish_call_expr): Pass 2 if we're doing Koenig ++ lookup. ++ ++1998-07-19 Mark Mitchell ++ ++ * decl.c (pushtag): Revert previous change. ++ * pt.c (lookup_template_class): Don't put out debugging ++ information for types that use template parameters. ++ ++ * decl.c (pushtag): Don't put out debugging information for ++ compiler-generated typedefs. ++ ++ * error.c (dump_type_real): Don't crash when presented with ++ intQI_type_node or the like. ++ ++ * semantics.c (finish_translation_unit): Fix spelling error in ++ comment. ++ ++1998-07-17 Jason Merrill ++ ++ * decl.c (lookup_name_real): Pull out single function here. ++ (select_decl): Not here. ++ (unqualified_namespace_lookup): Use CP_DECL_CONTEXT. ++ ++ * decl.c (qualify_lookup): Tweak again. ++ ++ * pt.c (lookup_template_class): Don't mess with the context of the ++ instantiation. ++ * decl2.c (current_decl_namespace): Remove special handling for ++ templates. ++ ++ * pt.c (tsubst, case FUNCTION_DECL): Fix getting complete args for ++ a member template specialization. ++ ++ * tree.c (ovl_member): Use decls_match to compare functions. ++ * decl.c (decls_match): Check the context of a function. ++ ++ * parse.y (primary): Use notype_unqualified_id instead of IDENTIFIER ++ in Koenig lookup support rules. ++ * semantics.c (finish_call_expr): Handle the new cases. ++ ++ * typeck.c (build_x_function_call): Handle overloaded methods. ++ ++ * decl.c (grokvardecl): Don't call build_static_name for extern "C". ++ ++1998-07-16 Mark Mitchell ++ ++ * semantics.c (finish_object_call_expr): Revert previous change. ++ * call.c (build_new_method_call): Likewise. Instead, convert ++ TYPE_DECLs to IDENTIFIERs here, in the presence of templates. ++ ++1998-07-16 Jason Merrill ++ ++ * decl.c (qualify_lookup): Handle templates. ++ ++ * decl2.c (do_using_directive): Don't pass ancestor. ++ * decl.c (push_using_directive): Calculate ancestor. ++ ++ * decl2.c (do_nonmember_using_decl): Allow for type shadowing. ++ * decl.c (pushdecl): Move type shadowing handling from here... ++ (duplicate_decls): ...to here. ++ * decl.c (set_identifier_local_value_with_scope): New fn. ++ (pushdecl): Use it. ++ (set_identifier_local_value, lookup_type_current_level): New fns. ++ * decl2.c (do_local_using_decl): Handle types and binding level ++ stuff properly. ++ ++ * init.c (build_offset_ref): Don't call mark_used on an OVERLOAD. ++ * decl.c (select_decl): Extract a lone function from an OVERLOAD. ++ (lookup_namespace_name): Likewise. ++ * typeck.c (build_unary_op): Not here anymore. ++ ++ * decl2.c (do_class_using_decl): Make sure we get an identifier. ++ * class.c (handle_using_decl): Ignore TYPE_DECLs. ++ ++ * decl.c (qualify_lookup): New fn. ++ (lookup_name_real): Use it. ++ ++1998-07-16 Martin v. Loewis ++ ++ * decl2.c (add_using_namespace): When directly using a namespace ++ that was indirect before, promote it. ++ ++ * cp-tree.h (LOOKUP_PREFER_TYPES, LOOKUP_PREFER_NAMESPACES, ++ LOOKUP_PREFER_BOTH, LOOKUP_NAMESPACES_ONLY, LOOKUP_TYPES_ONLY, ++ LOOKUP_QUALIFIERS_ONLY, LOOKUP_TEMPLATES_EXPECTED): New macros. ++ * decl.c (select_decl): Replace two flag parameters by one. ++ (unqualified_namespace_lookup): Likewise, pass flag. ++ (lookup_flags): New function. ++ (lookup_name_real): Compute flags, pass them. ++ (lookup_namespace_name): Call with zero-flag. ++ * decl2.c (ambiguous_decl): Add flag parameter, complain only ++ according to flags. ++ (lookup_using_namespace, qualified_lookup_using_namespace): ++ Add flag parameter, pass them through. ++ * lex.c (do_scoped_id): Call with zero-flag. ++ ++1998-07-16 Jason Merrill ++ ++ * typeck.c (convert_for_assignment): Use comptypes. ++ ++1998-07-16 Mark Mitchell ++ ++ * semantics.c (finish_object_call_expr): Move test for the ++ function called being a TYPE_DECL to ... ++ * call.c (build_new_method_call): Here. ++ ++1998-07-15 Jason Merrill ++ ++ * decl2.c (arg_assoc_class): Also look at template arguments, if any. ++ (arg_assoc): Handle error_mark_node and multiple levels of TREE_LIST. ++ ++ * lex.c (looking_for_typename): Don't initialize. ++ ++ * decl2.c (ambiguous_decl): Clarify error message. ++ ++ * decl.c (push_using_directive): Iterate over namespaces used ++ indirectly. ++ ++1998-07-15 Martin v. Löwis ++ ++ * decl2.c (add_using_namespace): Iterate over namespaces used ++ indirectly. ++ ++ * decl.c (lookup_name_real): Accept namespace aliases as locals. ++ (cat_namespace_levels): Ignore aliases. ++ (duplicate_decls): Ignore duplicate aliases. ++ * decl2.c (do_namespace_alias): Process block level namespace ++ aliases. Store alias with pushdecl. Remove odr errors. ++ * parse.y (namespace_alias): New non-terminal. ++ (extdef): Use it. ++ ++1998-07-15 Jason Merrill ++ ++ * decl2.c (arg_assoc_type): Handle METHOD_TYPE like FUNCTION_TYPE. ++ Handle TEMPLATE_TYPE_PARM. ++ (arg_assoc): Rewrite. ++ ++ * pt.c (complete_template_args): Don't look at the context unless ++ we have to. ++ ++ * method.c (build_decl_overload_real): Fix namespace handling. ++ ++ * typeck.c (build_unary_op): Extract a lone function from an ++ OVERLOAD. ++ ++ * call.c (build_scoped_method_call): Handle getting a namespace ++ for basetype in a destructor call. ++ (check_dtor_name): Handle enums. ++ ++ * parse.y (using_directive): New nonterminal. ++ (extdef, simple_stmt): Use it. ++ ++1998-07-14 Martin von Löwis ++ ++ * decl2.c (add_function): Move error message ... ++ (arg_assoc_namespace): ... from here. ++ ++1998-07-14 Jason Merrill ++ ++ * parse.y (namespace_qualifier): Fix multiple level handling. ++ * decl2.c (namespace_ancestor): Use CP_DECL_CONTEXT. ++ (arg_assoc): Don't skip the first argument of a function. ++ ++Tue Jul 14 20:09:22 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * search.c (my_tree_cons): Clean up. ++ ++1998-07-14 Jason Merrill ++ ++ * call.c (joust): Don't warn about "confusing" conversions to the ++ same type. ++ ++1998-07-14 Martin von Löwis ++ ++ * class.c (push_nested_class): Complain about namespaces. ++ * decl.c (start_decl): Enter the object's namespace. ++ (cp_finish_decl): Leave it. ++ (grokdeclarator): Likewise. ++ * decl2.c (check_decl_namespace): New function. ++ (finish_file): Call it. ++ * parse.y (complex_direct_notype_declarator): Set complexity ++ of namespace-qualified ids to -1, enter the namespace. ++ ++ * method.c (build_template_decl_overload): Expect _DECL as first ++ parameter. Put context temporarily into current_namespace. ++ * pt.c (check_explicit_specialization): Change caller. ++ (tsubst): Likewise. ++ ++ * init.c (build_offset_ref): Call mark_used and ++ convert_from_reference for namespace members. ++ ++Mon Jul 13 23:25:28 1998 Martin von Löwis ++ ++ * search.c (my_tree_cons): The bitfield is at index 2. ++ ++Mon Jul 13 17:21:01 1998 Nick Clifton ++ ++ * lang-options.h: Format changed to work with new --help support ++ in gcc/toplev.c ++ ++1998-07-12 Martin von Löwis ++ ++ * decl2.c (build_expr_from_tree): Change calls of do_identifier. ++ Do Koenig lookup in CALL_EXPR. ++ (arg_assoc): Handle error_mark. ++ * lex.c (is_global): New function. ++ (do_identifier): Expect arguments for Koenig lookup. ++ * parse.y (primary): Add rules for calls of unqualified function calls. ++ (do_id): Change call of do_identifier. ++ * pt.c (finish_stmt_expr): Likewise. ++ * semantics.c (finish_id_expr): Likewise. ++ (finish_call_expr): Add integer parameter to indicate ++ argument-dependent lookup. ++ ++ * decl.c (struct binding_level): New field using_directives. ++ (push_using_decl): Not sorry anymore. ++ (push_using_directive): New function. ++ (lookup_tag): Use CP_DECL_CONTEXT to iterate. ++ (unqualified_namespace_lookup): New function, code from ... ++ (lookup_name_real): ... here. ++ * decl2.c (lookup_using_namespace): Pass using list instead of ++ initial scope. ++ (validate_nonmember_using_decl): New function. ++ (do_nonmember_using_decl): New function. ++ (do_toplevel_using_decl): Use them. ++ (do_local_using_decl): New function. ++ (do_using_directive): Support block-level directives. ++ * parse.y (simple_stmt): Support using declarations and ++ directives. ++ (namespace_qualifier, namespace_using_decl): New non-terminals. ++ ++ * xref.c (classname): New function. ++ (GNU_xref_hier): Change class and base parameters to tree. ++ * decl.c (xref_baseypes): Change caller. ++ * friend.c (make_friend_class): Likewise. ++ ++1998-07-12 Kriang Lerdsuwanakij ++ ++ * typeck.c (comptypes, case TEMPLATE_TEMPLATE_PARM): Add parameter ++ comparison. ++ ++ * pt.c (for_each_template_parm, case TEMPLATE_DECL): If it is a ++ template template parameter, record its use. ++ (for_each_template_parm, case TEMPLATE_TEMPLATE_PARM): Traverse ++ its template arguments if exists. ++ ++ * pt.c (coerce_template_template_parms): New function equivalent ++ to coerce_template_parms when IS_TMPL_PARM is true. ++ (coerce_template_parms): Use it. Remove the IS_TMPL_PARM parameter, ++ all callers changed. ++ ++ (coerce_template_parms): Access ARGLIST properly when creating a ++ new vector. Only accept implicit TYPE_DECL as valid argument for ++ a template template parameter when it is a base class of ++ current_class_type. Don't display error message when COMPLAIN is ++ false. ++ ++1998-07-12 Klaus Kaempf (kkaempf@progis.de) ++ ++ * repo.c (get_base_filename): Use file_name_nondirectory. ++ (open_repo_file): Likewise. ++ * cp-tree.h (file_name_nondirectory): Add prototype. ++ ++1998-07-12 Jason Merrill ++ ++ * friend.c (do_friend): Pull the identifier out of declarator. ++ Use cp_error and friends. ++ * decl2.c (qualified_lookup_using_namespace): Fix call to ++ purpose_member. ++ * decl.c (lookup_name_real): Don't call complete_type on a namespace. ++ (grokvardecl): Use DECL_CLASS_SCOPE_P. ++ * cvt.c (convert_pointer_to_real): Check for error_mark_node sooner. ++ * class.c (warn_hidden): Fix for OVERLOAD. ++ From grahams@rcp.co.uk: ++ * cp-tree.h (DEFARG_NODE_CHECK): New macro. ++ (DEFARG_LENGTH, DEFARG_POINTER): Use it. ++ ++Sun Jul 12 01:20:57 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * g++.1 (-traditional): Remove duplicated documentation. ++ ++1998-07-11 Mark Mitchell ++ ++ * method.c (flush_repeats): Add nrepeats parameter. ++ (issue_nrepeats): Likewise. ++ (is_back_referenceable_type): New function. Don't back-reference ++ TEMPLATE_TYPE_PARMs as well as simple types like integers. ++ (build_mangled_name_for_type): Likewise. ++ (build_mangled_name_for_type_with_Gcode): Likewise. ++ (lasttype): Remove. ++ (nrepeats): Likewise. ++ (Nrepeats): Likewise. ++ (start_squangling): Don't clear the variables removed above. ++ (end_squangling): Likewise. ++ (flush_repeats): Tidy. Use nrepeats parameter rather than ++ Nrepeats global. ++ (issue_nrepeats): Likewise, but with nrepeats global. Use ++ is_backreferenceable_type. ++ (build_overload_nested_name): Tidy. Add comment. Use ++ build_mangled_name_for_type. ++ (build_underscore_int): Comment. ++ (build_overload_scope_ref): Use build_mangled_name_for_type. ++ (build_overload_int): Likewise. ++ (build_template_template_parm_names): Tidy. ++ (build_template_parm_names): Use build_mangled_name_for_type. ++ (build_overload_identifier): Add comments. ++ (build_mangled_name_for_type_with_Gcode): Split out from ++ build_mangled_name. ++ (build_mangled_name_for_type): Use it. ++ (build_mangled_name): Rework to use build_mangled_name_for_type ++ and to not use global nrepeats/Nrepeats. Tidy. ++ (process_modifiers): Tidy. ++ (check_btype): Use is_backreferenceable_type. Add comment. ++ Rename `node' to `type'. ++ (process_overload_item): Set numeric_output_need_bar here. ++ Use build_mangled_name_for_type. Tidy. ++ (build_decl_overload_real): Tidy. Don't use Nrepeats. Use ++ build_mangled_name_for_type. ++ ++ * pt.c (push_template_decl_real): Don't look at DECL_TEMPLATE_INFO ++ for TYPE_DECLs. ++ ++1998-07-08 Vladimir N. Makarov ++ ++ * cp-tree.h (warn_long_long): Define. ++ * decl.c (grokdeclarator): Add flag `warn_long_long' as guard for ++ warning "ANSI C++ does not support `long long'". ++ * decl2.c (warn_long_long): Define. ++ (lang_decode_option): Parse -Wlong-long, -Wno-long-long options. ++ ++1998-07-07 Jason Merrill ++ ++ * decl.c (xref_tag): Handle attributes between 'class' and name. ++ * parse.y (aggr): Likewise. ++ * semantics.c (finish_class_definition): Likewise. ++ * Makefile.in (EXPECTED): Adjust. ++ ++ * cp-tree.h: Declare flag_optional_diags and warn_multichar. ++ * decl2.c: Define them. ++ (lang_decode_option): Handle them. ++ * lang-options.h: Add -foptional-diags. ++ * class.c (finish_struct): Don't complain about multiple meanings of ++ name if -fno-optional-diags. ++ * decl.c (pushdecl_class_level): Likewise. ++ * lex.c (real_yylex): Check warn_multichar. ++ ++1998-07-06 Jason Merrill ++ ++ * decl.c (lookup_tag): Use CP_DECL_CONTEXT. ++ ++ * tree.c (make_binfo): Fix length. ++ ++1998-06-30 Benjamin Kosnik ++ ++ * decl2.c (lang_decode_option): Remove warn_template_debugging. ++ * lang-options.h: Likewise. ++ ++Mon Jun 29 20:17:40 1998 Kaveh R. Ghazi ++ ++ * except.c (build_eh_type_type_ref): Remove unused variable `susp'. ++ (process_start_catch_block): Likewise for variables ++ `false_label_rtx', `call_rtx' and `return_value_rtx'. ++ ++1998-06-29 Brendan Kehoe ++ ++ * tree.c (build_srcloc): Make sure we allocate this node on the ++ permanent obstack. ++ ++Sat Jun 27 23:34:18 1998 Fred Fish ++ ++ * g++spec.c (NEED_MATH_LIBRARY): Define to 1 if not already defined. ++ (lang_specific_driver): Initialize need_math with NEED_MATH_LIBRARY. ++ (lang_specific_driver): Only add -lm automatically if need_math is ++ nonzero. ++ ++Sat Jun 27 12:22:56 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * Make-lang.in (g++): Depend on mkstemp.o. Link in mkstemp.o ++ ++Sat Jun 27 07:36:09 1998 Kaveh R. Ghazi ++ ++ * Makefile.in (EXPR_H): New dependency variable. ++ (decl2.o): Depend on $(EXPR_H). ++ (typeck.o): Likewise. ++ (init.o): Likewise. ++ (expr.o): Likewise. ++ ++1998-06-25 Benjamin Kosnik ++ ++ * decl.c (start_enum): Put local enums on permanent_obstack. ++ ++1998-06-25 Mark Mitchell ++ ++ * cp-tree.h (c_get_alias_set): Declare. ++ * decl.c (init_decl_processing): Set lang_get_alias_set. ++ ++1998-06-25 Andrew MacLeod ++ ++ * cp-tree.h (mark_all_runtime_matches): Add function prototype. ++ * except.c (mark_all_runtime_matches): Set TREE_SYMBOL_REFERENCED ++ flag for all function decls which are in the exception table. ++ * exception.cc (__cplus_type_matcher): Check for CATCH_ALL_TYPE match. ++ * decl2.c (finish_file): Call mark_all_runtime_matches to make sure ++ code is emitted for any referenced rtti function. ++ ++1998-06-25 Dave Brolley ++ ++ * lang-specs.h: Use new | syntax to eliminate ++ string concatenation. ++ ++1998-06-25 Jason Merrill ++ ++ * cp-tree.h (CP_DECL_CONTEXT): New macro. ++ * decl2.c (is_namespace_ancestor, lookup_using_namespace): Use it. ++ * method.c (build_overload_nested_name): Likewise. ++ * sig.c (build_signature_pointer_or_reference_type): Don't set ++ DECL_CONTEXT. ++ ++1998-06-24 Martin v. Löwis ++ ++ Set DECL_CONTEXT for globals to NULL_TREE instead of global_namespace. ++ * cp-tree.h (FROB_CONTEXT): New macro. ++ (DECL_MAIN_P): ::main should have a DECL_CONTEXT of NULL_TREE. ++ * decl.c (namespace_binding): Replace NULL_TREE with ++ global_namespace. ++ (set_namespace_binding, pop_namespace, lookup_name_real): Likewise. ++ * decl2.c (is_namespace_ancestor, lookup_using_namespace): ++ Likewise. ++ * decl.c (pushtag): Use FROB_CONTEXT. ++ (pushdecl, make_typename_type, define_function, grokdeclarator): ++ Likewise. ++ * decl2.c (set_decl_namespace, do_namespace_alias): Likewise. ++ * pt.c (push_template_decl_real, lookup_template_class, tsubst): ++ Likewise. ++ * decl2.c (decl_namespace): Return global_namespace if no context. ++ * method.c (build_overload_nested_name): Expect null as context. ++ * pt.c (mangle_class_name_for_template): Do nothing for null ++ contexts. ++ (lookup_template_class): Allow for null id_context. ++ ++1998-06-25 Richard Henderson ++ ++ * method.c (emit_thunk): Set current_function_is_thunk for the ++ ASM_OUTPUT_MI_THUNK case as well. ++ ++1998-06-23 Andrew MacLeod ++ ++ * exception.cc (__cplus_type_matcher): Get a match_info pointer ++ instead of an exception table entry as a parameter. ++ ++1998-06-23 Andrew MacLeod ++ ++ * parse.y (function_try_block): Don't call start_catch_handler. ++ * except.c (call_eh_info): Remove coerced field from declaration. ++ (build_eh_type_type_ref): New function to create an address of a ++ rtti function for the new style exception tables. ++ (expand_start_catch_block): Split function, this contains the ++ common part. ++ (process_start_catch_block_old): New function to perform the rest ++ of expand_start_catch_block under old style exceptions. ++ (process_start_catch_block_old): New function to perform the rest ++ of expand_start_catch_block under new style exceptions. ++ (expand_end_catch_block): Only pop the false label off the stack under ++ the old style of exceptions. ++ * semantics.c (finish_try_block): Don't call start_catch_handler. ++ * exception.cc (struct cp_eh_info): Add original_value field. ++ (__cplus_type_matcher): Perform type matching on the original exception ++ value, and if we have a match, set the current value. ++ (__cp_push_exception): Set the original exception value. ++ ++1998-06-23 Jason Merrill ++ ++ * call.c (joust): Fix confusing conversion warning. ++ ++ * call.c (build_op_delete_call): Add placement parm. Check ++ LOOKUP_SPECULATIVELY. ++ * cp-tree.h, decl2.c, init.c: Adjust. ++ * decl.c (finish_function): Use it. ++ ++ * pt.c (tsubst): Diagnose creating void fields or variables. ++ ++Mon Jun 22 08:50:26 1998 Kaveh R. Ghazi ++ ++ * call.c (build_scoped_method_call): Remove unused variable `tmp'. ++ ++ * cp-tree.h (check_dtor_name): Add prototype. ++ ++ * init.c (expand_member_init): Remove unused variables ++ `ptr_type_node', `parm' and `rval'. ++ ++ * ptree.c (print_lang_type): Use HOST_WIDE_INT_PRINT_DEC specifier ++ in call to fprintf. ++ (lang_print_xnode): Likewise. ++ ++ * typeck2.c (enum_name_string): Cast argument to sprintf to long ++ and use %ld specifier. ++ ++ * xref.c (GNU_xref_end_scope): Use HOST_WIDE_INT_PRINT_DEC ++ specifier in call to fprintf. ++ (GNU_xref_member): Cast argument to sprintf to int. ++ ++Fri Jun 19 23:22:42 1998 Bruno Haible ++ ++ * typeck2.c (pop_init_level): Warn about implicit zero initialization ++ of struct members. ++ ++Thu Jun 18 09:32:32 1998 Kaveh R. Ghazi ++ ++ * cp-tree.h: Prototype function `check_java_method'. ++ ++1998-06-17 Jason Merrill ++ ++ * class.c (finish_struct): Make conflicting use of id a pedwarn. ++ * decl.c (pushdecl_class_level): Likewise. ++ ++1998-06-17 Mark Mitchell ++ ++ * pt.c (convert_nontype_argument): Issue an error when presented ++ with an integer (real) constant that cannot be simplified to an ++ INT_CST (REAL_CST). ++ ++ * cp-tree.h (c_get_alias_set): Remove declaration added in ++ 1998-06-13 change that should never have been checked in. ++ ++1998-06-17 Jason Merrill ++ ++ * typeck.c (build_binary_op_nodefault): Change % in format strings ++ to %%. ++ ++ * decl.c (grokvardecl): Don't build_static_name for decls that ++ aren't at namespace scope. ++ ++ * init.c (perform_member_init): Catch default-initialization of ++ references. ++ ++1998-06-17 Mark Mitchell ++ ++ * errfn.c (cp_thing): Handle the `%%' formatting sequence. ++ ++1998-06-17 Jason Merrill ++ ++ * method.c (hack_identifier): Complain about getting a namespace ++ or class template. ++ * typeck.c (decay_conversion): Remove check for namespaces. ++ * typeck2.c (incomplete_type_error): Likewise. ++ * parse.y (template_arg): Add PTYPENAME expansion. ++ ++1998-06-16 Andrew MacLeod ++ ++ * decl.c (grokvardecl): Don't build external assembler names for ++ TYPENAMEs in other namespaces as there is no declarator. ++ * error.c (cp_file_of, cp_line_of): Don't extract file or line number ++ info from DECL_CONTEXT if it is NULL. ++ ++1998-06-16 Jason Merrill ++ ++ * call.c (check_dtor_name): Split out. ++ (build_scoped_method_call): Use it. ++ (build_method_call): Use it. ++ * init.c (build_offset_ref): Use it. ++ ++ * typeck.c (build_static_cast): Fix handling of pointers to members. ++ ++ * decl.c (finish_function): Just return nothing from a constructor. ++ * typeck.c (c_expand_return): Complain about returning a void ++ expression from a destructor. ++ ++1998-06-13 Mark Mitchell ++ ++ * class.c (alter_access): Accept a BINFO explaining how to get ++ from the entity whose accessed is being altered to the type doing ++ the altering. ++ (handle_using_decl): New function containing code split out from ... ++ (finish_struct_1): Here. ++ ++ * cp-tree.h (complete_type_or_else): Declare. ++ * init.c (build_new_1, build_delete): Use it. ++ * typeck.c (require_complete_type): Use complete_type, rather than ++ expanding it inline. ++ (complete_type_or_else): New function. ++ (build_component_ref): Use it. ++ (pointer_int_sum): Make sure the type pointed to is complete. ++ (pointer_diff): Likewise. ++ ++ * pt.c (for_each_template_parm): Traverse the TYPE_CONTEXT for ++ types. ++ ++ * search.c (get_matching_virtual): Note that member templates ++ cannot override virtual functions. ++ ++1998-06-12 Brendan Kehoe ++ ++ * pt.c (check_explicit_specialization): If DECLARATOR turned into ++ an error_mark_node from lookup_template_function, return the same. ++ (determine_specialization): Also make sure TEMPLATE_ID isn't an ++ error_mark_node, before we try to read its operands. ++ * decl.c (grokdeclarator): If we got an error_mark_node from ++ check_explicit_specialization, just return it right back. ++ ++1998-06-12 Mark Mitchell ++ ++ * class.c (instantiate_type): Don't treat template-ids that don't ++ specify any template arguments as equivalent to ordinary ++ identifiers. Use OFFSET_REF instead of SCOPE_REF to refer to ++ pointer-to-members for member templates. Tidy slightly. ++ * cp-tree.def (TEMPLATE_ID_EXPR): Revise documentation. ++ * init.c (build_offset_ref): Handle template-ids like ordinary ++ identifiers, for the most part, but store a TEMPLATE_ID_EXPR in the ++ offset part of the OFFSET_REF. ++ * typeck.c (build_unary_op): Change check for unknown types to ++ look for OFFSET_REFs, not SCOPE_REFs. ++ ++1998-06-11 Mark Mitchell ++ ++ * pt.c (is_member_template_class): New function. ++ (push_template_decl_real): Use it. ++ ++1998-06-11 Benjamin Kosnik ++ ++ * friend.c (do_friend): Add support for nested classes using ++ member functions of the enclosing class as friends. ++ ++1998-06-10 Mark Mitchell ++ ++ * call.c (convert_default_arg): Make global, not static. ++ (convert_arg_for_ellipsis): Split out from ... ++ (build_over_call): Here. ++ * cp-tree.h (convert_default_arg); Declare. ++ (convert_arg_to_ellipsis): Likewise. ++ (do_member_init): Remove. ++ * init.c (do_member_init): Remove; this code is dead. ++ (expand_member_init): Remove much of this code; it is dead. ++ * typeck.c (convert_arguments): Use convert_default_arg and ++ convert_arg_for_ellipsis, rather than duplicating here. ++ ++ * call.c (convert_like): Don't fail silently if ++ build_user_type_conversion fails. Always return error_mark_node ++ for failure. ++ ++1998-06-10 Jason Merrill ++ ++ * search.c (covariant_return_p): Complain about ambiguous base. ++ ++ * typeck.c (build_component_ref): Diagnose ref to nested type. ++ ++1998-06-10 Brendan Kehoe ++ ++ * decl.c (grokparms): Check that INIT isn't an error_mark_node ++ before giving error about invalid type for default arg. ++ ++1998-06-10 Jason Merrill ++ ++ * call.c (build_method_call): Fix thinko. ++ ++1998-06-10 Dave Brolley ++ ++ * decl2.c (lang_decode_option): New argc/argv interface. ++ * cp-tree.h (lang_decode_option): New argc/argv interface. ++ * lang-specs.h (default_compilers): Only call cpp if -E, -M or -MM is ++ specified for cpplib-enabled compilers. ++ * lex.c (lang_init): Don't check_newline for cpplib. ++ (init_parse): Don't initialize cpplib here. ++ ++1998-06-10 Brendan Kehoe ++ ++ * typeck.c (build_component_ref): Make sure FIELD has a lang_specific ++ piece before checking DECL_MUTABLE_P. ++ ++1998-06-10 John Carr ++ ++ * tree.c (debug_binfo): Make printf format match arguments. ++ ++ * error.c (OB_PUTI): Make printf format match arguments. ++ ++1998-06-10 Jason Merrill ++ ++ * init.c (perform_member_init): Handle default-initialization. ++ ++ * except.c (build_throw): Handle throwing NULL. ++ ++ * typeck.c (build_x_function_call): Use resolve_offset_ref. ++ ++ * search.c (compute_access): Only strip an anonymous union ++ for a FIELD_DECL. ++ ++ * call.c (add_builtin_candidates): Tweak. ++ ++ * cvt.c (build_expr_type_conversion): Restore code for conversion ++ from class types. ++ * decl2.c (delete_sanity): Use it. Clean up. ++ ++ * typeck.c (comp_ptr_ttypes_real): Fix cv-qual comparisons. ++ ++1998-06-10 Branko Cibej ++ ++ * typeck.c (c_expand_return): Don't warn about void expressions on ++ return statements in functions returning void. ++ ++1998-06-09 Mark Mitchell ++ ++ * pt.c (fn_type_unification): Revise documentation. Tidy. ++ (type_unification): Likewise. ++ ++1998-06-09 Andrew MacLeod ++ ++ * semantics.c (finish_try_block): Rename expand_start_catch, and delete ++ expand_end_catch. ++ * parse.y (function_try_block): Rename expand_start_catch, and delete ++ expand_end_catch. ++ * except.c (expand_end_eh_spec): Rename expand_start_catch, and delete ++ expand_end_catch. ++ ++1998-06-09 Jason Merrill ++ ++ * search.c (lookup_member): New fn. ++ * class.c (finish_struct_1): Use it. ++ * decl.c (lookup_name_real): Use it. ++ ++Mon Jun 8 20:45:52 1998 Kaveh R. Ghazi ++ ++ * Makefile.in (decl2.o): Depend on dwarf2out.h and dwarfout.h. ++ ++ * cp-tree.h: Add prototype for `maybe_print_template_context' and ++ `maybe_make_one_only'. ++ ++ * decl.c (auto_function): Remove unused variable `decl'. ++ ++ * decl2.c: Include dwarf2out.h and dwarfout.h. ++ ++ * lex.c: Remove redundant declarations of `set_float_handler' and ++ `asm_out_file'. ++ ++1998-06-08 Andrew MacLeod ++ ++ * except.c (init_exception_processing): Remove NEW_EH_MODEL compile ++ time flag. Call __cp_eh_info instead of __cp_exception_info. ++ * exception.cc (struct cp_eh_info): Remove NEW_EH_MODEL flag. ++ (__cp_exception_info): Return offset into cp_eh_info structure to ++ match what use to be the start of this structure. ++ (__cp_eh_info): New function to return a pointer to cp_eh_info struct. ++ (__cplus_type_matcher, __cp_push_exception): Remove NEW_EH_MODEL ++ compile time flag. ++ (__uncatch_exception, __check_eh_spec, std::uncaught_exception): Call ++ __cp_eh_info instead of __cp_exception_info. ++ ++1998-06-08 Jason Merrill ++ ++ * decl.c (cp_finish_decl): Disable inlining of extern inlines ++ with static variables. ++ ++1998-06-08 Mark Mitchell ++ ++ * init.c (build_offset_ref): Correct previous change to use build, ++ not build_min. ++ ++1998-06-07 Mark Mitchell ++ ++ * class.c (instantiate_type): Handle pointer-to-members where the ++ member is a template. ++ * init.c (build_offset_ref): Likewise. ++ * typeck.c (build_unary_op): Likewise. ++ ++1998-06-07 Richard Henderson ++ ++ * lex.c (lang_init_options): New function. ++ (lang_init): Remove flag_exceptions == 2 hack. ++ ++1998-06-05 Jason Merrill ++ ++ * search.c (envelope_add_decl): Tweak for implicit typename. ++ ++ * call.c (joust): Also warn about confusing conversion op/constructor ++ overload resolution. ++ ++ * spew.c (yylex): Also return the TYPE_DECL if got_object. ++ Don't clear got_object after '~'. ++ * call.c (build_scoped_method_call): Tweak destructor handling. ++ (build_method_call): Likewise. ++ * pt.c (tsubst_copy, case METHOD_CALL_EXPR): Don't mess with ++ TYPE_MAIN_VARIANT for destructors. ++ * semantics.c (finish_object_call_expr): Complain about calling a ++ TYPE_DECL. ++ ++1998-06-05 Per Bothner ++ ++ * g++spec.c (lang_specific_pre_link, lang_specific_extra_ofiles): ++ Define - update needed by gcc.c change. ++ ++1998-06-05 Jason Merrill ++ ++ * error.c (cp_printers): Use 'o' instead of '_' for the null entry. ++ ++1998-06-05 Martin v. Loewis ++ ++ * cp-tree.h (DECL_NAMESPACE_ALIAS, ORIGINAL_NAMESPACE): Declare. ++ * decl.c (lookup_name_real): Add namespaces_only parameter. ++ If set, return only NAMESPACE_DECLs. ++ (select_decl): Likewise. ++ (identifier_type_value): Give additional parameter. ++ (lookup_name_nonclass): Likewise. ++ (lookup_name): Likewise. ++ (find_binding): Skip namespace aliases. ++ (binding_for_name): Likewise. ++ (push_namespace): Check for namespace aliases. ++ (lookup_name_namespace_only): New function. ++ (begin_only_namespace_names, end_only_namespace_names): New functions. ++ * decl2.c (set_decl_namespace): Skip namespace aliases. ++ (do_using_directive): Likewise. ++ (do_namespace_alias): Produce namespace aliases, fix alias ++ redeclaration. ++ * error.c (dump_decl): Support SCOPE_REF. ++ * parse.y (extdef): Wrap lookup with namespace_only for namespace ++ aliases and using declarations. ++ ++1998-06-04 Jason Merrill ++ ++ * tree.c (really_overloaded_fn): Only see through one TREE_LIST. ++ ++ * error.c (dump_expr): Clean up NEW_EXPR case. ++ ++1998-06-04 Martin von Löwis ++ ++ Suggested by Brendan Kehoe ++ * decl2.c (do_toplevel_using_decl): When decl is a TYPE_DECL, ++ treat it as using ::decl. ++ ++ * decl2.c (arg_assoc_type): Process unknown_type_node and OFFSET_TYPE. ++ ++ * tree.c (mapcar): Support NEW_EXPR. ++ ++ * error.c (dump_expr): Support NEW_EXPR. ++ ++1998-06-03 Jason Merrill ++ ++ * method.c (make_thunk): Use overload machinery to make name. ++ * search.c (covariant_return_p): New fn. ++ (get_matching_virtual): Use it. ++ ++ * init.c (build_new_1): Fix check for void. ++ ++1998-06-01 Per Bothner ++ ++ * cp-tree.h (TYPE_FOR_JAVA): New macro. ++ * decl.c, cp-tree.h (java_byte_type_node, java_short_type_node, ++ java_int_type_node, java_long_type_node, java_float_type_node, ++ java_double_type_node, java_char_type_node, java_boolean_type_node): ++ New "primitive" types, with predefined names __java_byte etc. ++ (record_builtin_java_type): New function. ++ (init_decl_processing): Make Java types with record_builtin_java_type. ++ (pushtag, grokdeclarator): Set TYPE_FOR_JAVA if in extern "JAVA". ++ (xref_baseypes): If base class was TYPE_FOR_JAVA, so is this class. ++ (grokfndecl): Call check_java_method for Java classes. ++ * method.c (is_java_type): Removed. Replaced with TYPE_FOR_JAVA. ++ (process_overload_item): Match types against specific ++ java_XX_type_node types, rather than using is_java_type. ++ * class.c (finish_struct_1): Don't add default copy constructor ++ or operator= if TYPE_FOR_JAVA. ++ (pop_lang_conext): Restore strict_prototyp proper if Java. ++ * decl2.c (acceptable_java_type, check_java_method): New functions. ++ * pt.c (instantiate_class_template): Copy TYPE_FOR_JAVA from pattern. ++ (tsubst): Move common statement after if statement. ++ * typeck.c (comptypes): If strict, TYPE_FOR_JAVA must match. ++ ++1998-06-01 Jason Merrill ++ ++ * pt.c (for_each_template_parm): Use first_rtl_op. ++ ++ * tree.c (build_cplus_array_type_1): Also check index_type for ++ template parms. ++ ++1998-05-31 Jason Merrill ++ ++ * pt.c (tsubst): Always copy BINFO_BASETYPES. ++ ++1998-05-29 scott snyder ++ ++ * tree.c (layout_basetypes): If we change TYPE_SIZE, change ++ TYPE_SIZE_UNIT too. ++ ++1998-05-29 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Don't complain about in-class ++ initialization of static consts if we don't really know the type ++ of the variable. ++ ++1998-05-29 Jason Merrill ++ ++ * cp-tree.h (DECL_DESTRUCTOR_P): New macro. ++ * method.c (build_destructor_name): New fn. ++ * decl2.c (maybe_retrofit_in_chrg): Split out... ++ (grokclassfn): From here. Reorganize. ++ * decl.c (grok_ctor_properties): Make sure ctors for types with ++ vbases have the in_chrg parm. ++ * pt.c (instantiate_class_template): Update ++ TYPE_USES_VIRTUAL_BASECLASSES from tsubsted bases. Don't call ++ grok_*_properties. ++ (tsubst): Call grok_ctor_properties and maybe_retrofit_in_chrg. ++ ++1998-05-28 Mark Mitchell ++ ++ * pt.c (instantiate_decl): Make test for whether or not static ++ variables should be instantiated early match its comment. ++ ++1998-05-28 Jason Merrill ++ ++ * decl.c (start_decl): Always pedwarn about vacuously redeclaring ++ a member. ++ (start_function): Call check_default_args. ++ * decl2.c (grokfield): Don't call check_default_args. ++ (check_default_args): Use cp_error_at. ++ * lex.c (do_pending_defargs): Call check_default_args. ++ ++1998-05-27 Brendan Kehoe ++ ++ * call.c (build_method_call): Make sure get_type_value returns ++ something before we try to use its TYPE_MAIN_VARIANT. ++ (build_scoped_method_call): Likewise. ++ ++1998-05-27 Jason Merrill ++ ++ * typeck2.c (digest_init): Complain about getting a TREE_LIST to ++ initialize an array. ++ ++ * search.c (expand_upcast_fixups): Don't set DECL_CONTEXT and ++ DECL_VIRTUAL_P. ++ ++ * friend.c (do_friend): Clarify template warning. ++ ++1998-05-27 Mark Mitchell ++ ++ * decl.c (shadow_label): Don't treat decls as identifiers. ++ (maybe_push_to_top_level): Clear shadowed_labels. ++ ++ * pt.c (instantiate_decl): Reset lineno and filename after calling ++ regenerate_decl_from_template. ++ ++ * decl.c (grokdeclarator): Don't try to use TYPE_OBSTACK on an ++ error_mark_node. ++ ++1998-05-27 Kevin Buhr ++ ++ * parse.y (base_class): Use is_aggr_type, not IS_AGGR_TYPE. ++ ++1998-05-26 Kriang Lerdsuwanakij ++ ++ * pt.c (process_template_parm): Accept TYPENAME_TYPE nodes. ++ (convert_nontype_argument): Handle cases when nontype template ++ parameters become classes after substitution. ++ ++1998-05-26 Mark Mitchell ++ ++ * friend.c (is_friend): Use comptypes, rather than == to compare ++ types. Modify for new representation of template friends. ++ (make_friend_class): Likewise. ++ * pt.c (tsubst_friend_class): Undo 1998-05-21 change. Tweak. ++ (instantiate_class_template): Deal with template friends. ++ ++ * decl.c (store_parm_decls): Remove redundant call to ++ expand_main_function. ++ ++1998-05-26 Benjamin Kosnik ++ ++ * decl.c (start_decl): Check for DECL_LANG_SPECIFIC before ++ DECL_USE_TEMPLATE. ++ ++1998-05-26 Per Bothner ++ ++ * language_as_string: Handle lang_java. ++ ++1998-05-26 Jason Merrill ++ ++ * decl.c (pushdecl): Don't copy the type_decl. ++ ++1998-05-26 Martin v. Löwis ++ ++ * class.c (pushclass): Always store TYPE_MAIN_VARIANT in ++ current_class_type. ++ * decl.c (grokdeclarator): Put typedefs on the type's obstack. ++ ++ * parse.y (complex_direct_notype_declarator): Use $1 to access ++ scope of notype_qualified_id. ++ ++1998-05-26 Dave Brolley ++ ++ * lex.c (parse_options,yy_cur,yy_lim): Add for cpplib. ++ (init_parse): Initialize cpplib interface. ++ ++ * Makefile.in (CXX_OBJS): Make sure dependencies never end with an ++ empty continuation. ++ ++1998-05-26 Mark Mitchell ++ ++ * decl.c (pushtag): Avoid crashing on erroneous input. ++ ++1998-05-25 Martin v. Löwis ++ ++ * decl.c (push_namespace): Only produce one unique name for ++ anonymous namespaces. ++ (get_unique_name): Remove. ++ ++1998-05-25 Mark Mitchell ++ ++ * call.c (tourney): Don't do any extra comparisons. ++ ++ * decl2.c (build_anon_union_vars): Don't crash on empty sub-unions. ++ ++ * cp-tree.h (processing_template_parmlist): Declare. ++ * decl.c (pushtag): Don't call push_template_decl when we ++ shouldn't. ++ * pt.c (processing_template_parmlist): New variable. ++ (TMPL_ARGS_HAVE_MULTIPLE_LEVELS): New macro. ++ (complete_template_args): Use it. ++ (add_to_template_args): Likewise. ++ (innermost_args): Likewise. ++ (tsubst): Likewise. ++ (begin_template_parm_list): Use processing_template_parmlist. ++ (end_template_parm_list): Likewise. ++ ++ * cp-tree.h (ANON_UNION_TYPE_P): New macro. ++ * decl.c (grokdeclarator): Use it. ++ * decl2.c (grok_x_components): Likewise. ++ * init.c (initializing_context): Likewise. ++ * method.c (do_build_copy_constructor): Likewise. ++ (do_build_assign_ref): Likewise. ++ * search.c (compute_access): Likewise. ++ * typeck.c (build_component_ref): Likewise. ++ ++ * decl.c (grokdeclarator): Don't give a cv-qualified version of an ++ unnamed type a typedef name "for linkage purposes". ++ ++ * pt.c (lookup_template_class): Don't look at ++ IDENTIFIER_CLASS_VALUE when there's no current_class_type. ++ ++ * method.c (build_overload_int): Handle error cases gracefully. ++ ++ * pt.c (instantiate_decl): Handle static member variables ++ correctly. ++ ++ * pt.c (tsubst): Use the tsubst'd type when producing new ++ TEMPLATE_PARM_INDEX nodes. ++ ++1998-05-24 Mark Mitchell ++ ++ * tree.c (cp_tree_equal): Handle pointers to member functions. ++ ++ * call.c (maybe_handle_implicit_object): Handle QUAL_CONVs. Make ++ sure the type of the REF_BIND is a reference type. ++ (maybe_handle_ref_bind, compare_ics): Rename reference_type to ++ target_type for clarity. ++ ++ * parse.y (xcond): Move call to condition_conversion ... ++ * semantics.c (finish_for_cond): Here. ++ * parse.c: Regenerated. ++ ++1998-05-24 Jason Merrill ++ ++ * decl.c (push_namespace): Namespaces have type void. ++ * typeck2.c (incomplete_type_error): Complain about namespace ++ used as expression. ++ * typeck.c (decay_conversion): Likewise. ++ ++1998-05-24 Martin von Löwis ++ ++ * error.c (dump_expr): Support namespaces. ++ ++1998-05-23 Jason Merrill ++ ++ * cp-tree.def: Add SRCLOC. ++ * cp-tree.h: Add struct tree_srcloc and accessor macros. ++ * tree.c (build_srcloc, build_srcloc_here): New fns. ++ * pt.c (add_pending_template): Use build_srcloc_here. ++ (push_tinst_level): Update last_template_error_tick before erroring. ++ (instantiate_decl): Restore lineno and input_filename before ++ calling add_pending_template. ++ * decl2.c (finish_file): Set up lineno and input_filename for ++ pending templates. ++ ++1998-05-22 Jason Merrill ++ ++ * decl.c (lang_print_error_function): New fn. ++ (init_decl_processing): Set print_error_function to use it. ++ * errfn.c (cp_thing): Don't call maybe_print_template_context here. ++ ++ * call.c (maybe_handle_ref_bind): Propagate ICS_USER_FLAG and ++ ICS_BAD_FLAG. ++ ++ * cvt.c (ocp_convert): Don't set LOOKUP_NO_CONVERSION for ++ copy-initialization. ++ ++ * class.c (build_vtable_entry): Use int_fits_type_p. ++ (build_vtable): Pass a signed offset to build_vtable_entry. ++ (prepare_fresh_vtable, modify_one_vtable, fixup_vtable_deltas1, ++ set_rtti_entry): Likewise. ++ ++1998-05-22 Per Bothner ++ ++ * cp-tree.h: Add comments documenting which LANG_FLAGS are used. ++ (C_TYPE_VARIABLE_SIZE, C_DECL_VARIABLE_SIZE): Removed, not used. ++ ++1998-05-22 Jason Merrill ++ ++ * pt.c (print_template_context): Use fprintf instead of cp_error. ++ ++ * pt.c (determine_specialization): Just return an error_mark_node. ++ Also print the decl we want in error messages. If we complain, ++ return error_mark_node. ++ (tsubst_friend_function): Set lineno and input_filename so ++ error messages will be useful. ++ (instantiate_template): Just return an error_mark_node. ++ (check_explicit_specialization): Don't mess with a returned ++ error_mark_node. ++ ++ * pt.c (print_template_context): Add new argument. ++ (maybe_print_template_context): New fn. ++ (push_tinst_level): Increment tinst_level_tick. ++ (pop_tinst_level): Likewise. ++ * errfn.c (cp_thing): Call maybe_print_template_context. Use ++ xrealloc instead of xmalloc. ++ ++ * typeck.c (build_unary_op, CONVERT_EXPR): Propagate TREE_CONSTANT. ++ ++1998-05-21 Jason Merrill ++ ++ * pt.c (tsubst_friend_class): Don't call redeclare_class_template ++ if the template we looked up is the same as the one we already ++ have. ++ ++Thu May 21 11:54:44 1998 Dave Brolley ++ ++ * lex.c: (handle_sysv_pragma): FILE* parameter not used. ++ (cpp_reader,parse_in): Add for cpplib. ++ (check_newline): Call handle_sysv_pragma with new interface. ++ (check_newline): Call GET_DIRECTIVE_LINE, not get_directive_line. ++ ++ * input.c: (yy_cur,yy_lim,yy_get_token,GETC): Add for cpplib. ++ (sub_getch): Call GETC for cpplib. ++ ++ * cp-tree.h: (get_directive_line): Different prototype for cpplib. ++ (GET_DIRECTIVE_LINE): Macro wrapper for get_directive_line. ++ ++ * Makefile.in (CXX_OBJS): Add @extra_cxx_objs@ for cpplib. ++ ++1998-05-21 Jason Merrill ++ ++ * decl2.c (maybe_make_one_only): New fn. ++ (import_export_vtable): Use it. ++ (import_export_decl): Likewise. ++ * pt.c (mark_decl_instantiated): Likewise. ++ ++1998-05-21 Mark Mitchell ++ ++ * decl2.c (find_representative_member): Rename to ... ++ (build_anon_union_vars): New function. ++ (finish_anon_union): Fix stupidity of previous change. ++ ++1998-05-20 Jason Merrill ++ ++ * decl.c (grokfndecl): Handle definition of specialization in ++ friend declaration. ++ ++ * error.c (dump_decl): Fix LOOKUP_EXPR handling. ++ ++1998-05-20 Mark Mitchell ++ ++ * class.c (delete_duplicate_fields_1): Use DECL_DECLARES_TYPE_P ++ to look for type declarations. ++ (finish_struct): Deal with templates on the CLASSTYPE_TAGS list. ++ * cp-tree.h (DECL_DECLARES_TYPE_P): New macro. ++ (finish_member_class_template): Declare. ++ * decl.c (pushtag): Put member class templates on the ++ CLASSTYPE_TAGS list, just as for ordinary member classes. ++ (pushdecl_class_level): Use DECL_DECLARES_TYPE_P. ++ (lookup_tag): Look for IDENTIFIER_CLASS_VALUEs, just as with ++ IDENTIFIER_NAMESPACE_VALUEs. ++ * parse.y (component_decl): Move code to ... ++ * semantics.c (finish_member_class_template): New function. ++ Don't put member class templates on the list of components for a ++ class. ++ * parse.c: Regenerated. ++ * pt.c (classtype_mangled_name): Don't try DECL_CONTEXT on types. ++ In fact, don't use DECL_CONTEXT at all here. ++ ++1998-05-20 Martin von Loewis ++ ++ * decl.c (record_unknown_type): New function. ++ (init_decl_processing): Call it for the unknown and global type ++ nodes. ++ ++1998-05-20 Mark Mitchell ++ ++ * decl2.c (find_representative_member): New function. ++ (finish_anon_union): Use it. ++ ++ * cp-tree.h (MAIN_NAME_P): New macro. ++ (DECL_MAIN_P): Likwise. ++ * decl.c (pushdecl): Avoid crashing on redefinitions of `main'. ++ (grokfndecl): Use the new macros. ++ (grokdeclarator): Likewise. ++ (start_function): Likewise. ++ (store_parm_decls): Likewise. ++ (finsh_function): Likewise. ++ * friend.c (do_friend): Likewise. ++ * typeck.c (build_function_call_real): Likewise. ++ (build_unary_op): Likewise. ++ ++Wed May 20 02:16:01 1998 Jason Merrill ++ ++ * decl2.c (start_objects, finish_objects, do_dtors, ++ do_ctors): Split out from... ++ (finish_file): ...here. ++ ++Tue May 19 20:36:23 1998 Jason Merrill ++ ++ * tree.c (is_overloaded_fn): Don't abort on placeholders from ++ push_class_decls. ++ ++Tue May 19 15:16:22 1998 Brendan Kehoe ++ ++ * class.c (is_empty_class): Return 0 if TYPE is an error_mark_node. ++ ++ * error.c (dump_expr): Handle an ARROW_EXPR. ++ ++Tue May 19 15:13:39 1998 Mark Mitchell ++ ++ * decl.c (saveable_obstack): Declare. ++ (pushdecl): Copy TYPE_DECLs to the same obstack as the type they ++ declare, if necessary. ++ ++Tue May 19 14:50:27 1998 Mark Mitchell ++ ++ * call.c (compare_qual): Remove. ++ (is_subseq): Tweak. ++ (is_properly_derived_from): New function. ++ (maybe_handle_ref_bind): Likewise. ++ (maybe_handle_implicit_object): Likewise. ++ (compare_ics): Modify substantially to bring into conformance with ++ the standard. ++ * cp-tree.h (TYPE_PTRMEMFUNC_OBJECT_TYPE): New macro. ++ (comp_cv_qualification): Declare. ++ (comp_cv_qual_signature): Likewise. ++ * typeck.c (comp_cv_qualification): Likewise. ++ (comp_cv_qual_signature): Likewise. ++ ++Tue May 19 10:05:02 1998 Kaveh R. Ghazi ++ ++ * Makefile.in (parse.o): Depend on toplev.h. ++ ++ * class.c (typecode_p): Remove prototype and definition. ++ ++ * cp-tree.h (currently_open_class, is_empty_class, member_p): ++ Add prototype. ++ ++ * decl.c (push_overloaded_decl_top_level): Remove prototype and ++ definition. ++ ++ * errfn.c (cp_error): Cast function pointer `error' to (errorfn *) ++ in call to `cp_thing'. ++ (cp_warning): Likewise for function pointer `warning'. ++ ++ * except.c (do_function_call): Remove prototype and definition. ++ (call_eh_info): Wrap variable `t1' in macro NEW_EH_MODEL. ++ ++ * method.c (is_java_type): Add prototype and make it static. ++ ++ * parse.y: Include toplev.h. ++ ++ * pt.c (type_unification): Remove unused variable `arg'. ++ (instantiate_decl): Likewise for `save_ti'. ++ ++ * tree.c (propagate_binfo_offsets): Likewise for `base_binfos'. ++ ++Tue May 19 02:43:25 1998 Jason Merrill ++ ++ * init.c (build_member_call): Handle template_ids. ++ * parse.y (primary): Add global_scope template_id. ++ ++Mon May 18 23:22:52 1998 Jason Merrill ++ ++ * decl2.c (get_sentry): Use end_temporary_allocation. ++ Don't declare permanent_obstack. ++ ++Mon May 18 12:28:44 1998 Mark Mitchell ++ ++ * parse.y (.finish_new_placement): New non-terminal. ++ (unary_expr, new_type_id): Use it. ++ * parse.c: Regenerated. ++ ++Mon May 18 12:20:27 1998 Brendan Kehoe ++ ++ * pt.c (redeclare_class_template): Say where the original definition ++ of the template-parameter's default argument appeared. ++ ++Mon May 18 03:00:57 1998 Jason Merrill ++ ++ * call.c (build_over_call): Tweak empty class handling. ++ ++ * decl.c (make_typename_type): Use currently_open_class. ++ ++ * class.c (instantiate_type): Don't abort on TREE_NONLOCAL_FLAG. ++ ++Mon May 18 01:43:01 1998 Martin v. Loewis ++ ++ * decl.c (lookup_name_real): Don't look at IDENTIFIER_LOCAL_VALUE ++ for a type unless it is one. ++ ++ * class.c (finish_struct_1): Use OVL_CURRENT in error message. ++ ++Mon May 18 01:24:08 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * Makefile.in (program_transform_name, objdir): Define. ++ ++ * Makefile.in (BISON): Use bison from the build tree if it exists. ++ (FLEX): Likewise. ++ ++Sun May 17 14:52:08 1998 Martin v. Loewis ++ ++ * typeck.c (type_unknown_p): Return true for TREE_LIST also. ++ ++ * call.c (build_method_call): Use TYPE_MAIN_VARIANT on typedefs. ++ ++Sun May 17 14:51:41 1998 Jason Merrill ++ ++ * call.c (build_scoped_method_call): Likewise. ++ ++Sun May 17 13:53:48 1998 Mark Mitchell ++ ++ * init.c (build_new_1): Call suspend_momentary around the creation ++ of values that must be saved for exception handling. ++ * parse.y (.build_new_placement): New non-terminal. ++ (unary_expr, new_placement): Use it. ++ * parse.c: Regenerated. ++ ++Sun May 17 12:32:08 1998 Jason Merrill ++ ++ * decl.c (duplicate_decls): Use CANONICAL_TYPE_VARIANT to compare ++ old and new types. ++ ++ * pt.c (tsubst): Make sure that BINFO_TYPE of new binfos is the ++ canonical type. ++ ++ * call.c (build_over_call): Don't use IS_SIGNATURE on a namespace. ++ ++Fri May 15 20:28:00 1998 Jason Merrill ++ ++ * decl.c (start_decl): Revert problem change. ++ ++ * Makefile.in (CONFLICTS): Fix. ++ ++Fri May 15 15:34:02 1998 Benjamin Kosnik ++ ++ * decl.c (duplicate_decls): Clean up, add DECL_DATA_AREA bits. ++ ++Fri May 15 00:46:05 1998 Jason Merrill ++ ++ * class.c (finish_struct_1): Use BINFO_SIZE. ++ ++ * decl.c (start_decl): Use 'tem'. ++ ++Thu May 14 16:30:47 1998 Andrew MacLeod ++ ++ * exception.cc: Include eh-common.h. ++ (struct cp_eh_info): Add eh_info struct with NEW_EH_MODEL. ++ (__cplus_type_matcher): First stab at new C++ runtime type matcher. ++ (__cp_push_exception): Initialize eh_info struct as well. ++ * except.c: Remove local structs and include eh-common.h. ++ (init_exception_processing): Set language and version codes. ++ (call_eh_info): Add presence of eh_info to runtime description of ++ struct cp_eh_info. ++ (expand_end_eh_spec): Call start_catch_block() and end_catch_block(). ++ * semantics.c (finish_try_block): Call start_catch_block() and ++ end_catch_block(). ++ * parse.y (function_try_block): Call start_catch_block() and ++ end_catch_block(). ++ ++Thu May 14 12:27:34 1998 Brendan Kehoe ++ ++ * typeck.c (original_type): New function. ++ (common_type): Use it to get the DECL_ORIGINAL_TYPE for T1 and T2, ++ to see if they're actually the same. ++ * cp-tree.h (original_type): Declare. ++ ++Wed May 13 12:54:30 1998 Kaveh R. Ghazi ++ ++ * Makefile.in (lex.o): Depend on output.h. ++ ++ * call.c (add_function_candidate): Remove unused variable `cand'. ++ (add_conv_candidate): Likewise. ++ (build_builtin_candidate): Likewise. ++ ++ * cp-tree.h: Add prototype for `types_overlap_p'. ++ ++ * decl.c (signal_catch): Mark parameter `sig' with ATTRIBUTE_UNUSED. ++ ++ * decl2.c (merge_functions): Remove unused variables `tmp' and ++ `tempn'. ++ ++ * error.c (expr_as_string): Mark parameter `v' with ATTRIBUTE_UNUSED. ++ (code_as_string): Likewise. ++ (language_as_string): Likewise. ++ (parm_as_string): Likewise. ++ (op_as_string): Likewise. ++ (assop_as_string): Likewise. ++ (cv_as_string): Likewise. ++ ++ * lex.c: Include output.h. ++ ++ * pt.c (type_unification): Cast first argument of `bzero' to a char*. ++ ++ * search.c (dfs_no_overlap_yet): Mark parameter `t' with ++ ATTRIBUTE_UNUSED. ++ ++ * tinfo.cc (__class_type_info::dcast): Change the type of variable ++ `i' from int to size_t. ++ ++ * typeck.c (language_lvalue_valid): Mark parameter `exp' with ++ ATTRIBUTE_UNUSED. ++ ++Tue May 12 21:37:49 1998 Jason Merrill ++ ++ * error.c (dump_simple_decl): Use DECL_CLASS_SCOPE_P and/or ++ DECL_NAMESPACE_SCOPE_P. ++ (lang_decl_name): Likewise. ++ * pt.c (tsubst_friend_function, tsubst): Likewise. ++ * decl.c (pushdecl, redeclaration_error_message, start_decl, ++ cp_finish_decl, start_function): Likewise. ++ * class.c (finish_struct_1): Likewise. ++ * call.c (build_over_call): Likewise. ++ (compare_ics): Use DERIVED_FROM_P. ++ ++Tue May 12 07:24:18 1998 Mark Mitchell ++ ++ * cp-tree.h (CANONICAL_TYPE_VARIANT): New macro. ++ * method.c (build_mangled_name): Use it. ++ (build_decl_overload_real): Likewise. ++ ++ * error.c (dump_simple_decl): New function, broken out from ... ++ (dump_decl): Use it. ++ ++Mon May 11 11:38:07 1998 Mark Mitchell ++ ++ * ptree.c (lang_print_xnode): Add missing `break'. ++ ++ * pt.c (tsubst): Remove duplicate check for IDENTIFIER_NODE. ++ ++ * call.c (add_template_candidate): Adjust for changes to ++ fn_type_unification. ++ (add_template_candidate_real): Likewise. ++ (add_template_conv_candidate): Likewise. ++ (build_user_type_conversion_1): Likewise. ++ (build_new_function_call): Likewise. ++ (build_object_call): Likewise. ++ (build_new_op): Likewise. ++ (build_new_method_call): Likewise. ++ * class.c (instantiate_type): Likewise. ++ * cp-tree.h (unification_kind_t): New type. ++ (fn_type_unification): Adjust prototype. ++ (type_unificaiton): Likewise. ++ * pt.c (UNIFY_ALLOW_NONE): New macro. ++ (UNIFY_ALLOW_MORE_CV_QUAL): Likewise. ++ (UNIFY_ALLOW_LESS_CV_QUAL): Likewise. ++ (UNIFY_ALLOW_DERIVED): Likewise. ++ (unify): Change prototype. ++ (maybe_adjust_types_for_deduction): New function. ++ (check_cv_quals_for_unify): Likewise. ++ (determine_specialization): Adjust. ++ (fn_type_unification): Likewise. ++ (type_unification): Likewise. ++ (type_unification_real): Likewise. Use ++ maybe_adjust_types_for_deduction. Fix mishandling of ++ back-unification of template functions passed as arguments. Pass ++ appropriate combination of UNIFY_ALLOW_* to unify. ++ (unify): Remove unused NTPARMS parameter. Use ++ check_cv_quals_for_unify. Remove bogus code that allowed ++ too-generous unification in order to adhere more closely to standard. ++ (get_bindings_real): Adjust. ++ (get_class_bindings): Likewise. ++ ++ * method.c (build_overload_identifier): Only use the innermost ++ template arguments when mangling. ++ * pt.c (tsubst_template_argument_vector): New function. ++ (complete_template_args): Deal with the situation where the ++ extra_args contain more than one level of arguments. ++ (lookup_template_class): Deal with member template classes, which ++ may have more than one level of arguments. ++ (tsubst): Don't tsbust into the TREE_TYPE of an IDENTIFIER_NODE. ++ Improve handling of member template classes. Use ++ DECL_PRIMARY_TEMPLATE instead of inline expansion. Use ++ tsubst_template_argument_vector where appropriate. ++ (regenerate_decl_from_template): Break out from ... ++ (instantiate_decl): Here. ++ ++ * lex.c (yyprint): Remove TYPENAME_ELLIPSIS. ++ * parse.h: Regenerated. ++ * parse.c: Really regenerated. ++ ++ * cp-tree.h (finish_unary_op_expr): New function. ++ (finish_id_expr): Likewise. ++ (begin_new_placement): Likewise. ++ (finish_new_placement): Likewise. ++ (finish_declarator): Likewise. ++ (finish_translation_unit): Likewise. ++ (finish_parmlist): Likewise. ++ (begin_class_definition): Likewise. ++ (finish_class_definition): Likewise. ++ (finish_default_args): Likewise. ++ (finish_inline_definitions): Likewise. ++ * parse.y (GCC_ASM_KEYWORD): Remove. ++ (TYPENAME_ELLIPSIS): Likewise. ++ * parse.c: Regenerated. ++ Use new functions in semantics.c in the actions for many rules. ++ * gxx.gperf (GCC_ASM_KEYWORD): Just use ASM_KEYWORD. ++ * hash.h: Regenerated. ++ * semantics.c (finish_expr_stmt): Allow NULL expr. ++ (finish_unary_op_expr): New function, containing ++ code previously in parse.y. ++ (finish_id_expr): Likewise. ++ (begin_new_placement): Likewise. ++ (finish_new_placement): Likewise. ++ (finish_declarator): Likewise. ++ (finish_translation_unit): Likewise. ++ (finish_parmlist): Likewise. ++ (begin_class_definition): Likewise. ++ (finish_class_definition): Likewise. ++ (finish_default_args): Likewise. ++ (finish_inline_definitions): Likewise. ++ ++Sun May 10 23:43:13 1998 Mark Mitchell ++ ++ * typeck.c (build_c_cast): Don't decay arrays and functions to ++ pointer type when converting to a class type. ++ ++Sun May 10 22:53:56 1998 Jason Merrill ++ ++ * cp-tree.h (DECL_NAMESPACE_SCOPE_P): New macro. ++ (DECL_CLASS_SCOPE_P): Likewise. ++ ++Sun May 10 22:48:22 1998 H.J. Lu (hjl@gnu.org) ++ ++ * class.c (finish_struct_1): Use OVL_CURRENT on TREE_VEC_ELT. ++ * decl2.c (constructor_name_full): Likewise. ++ ++Sun May 10 22:48:12 1998 Mike Stump ++ ++ * tree.c (mapcar): Add OVERLOAD support. ++ ++ * init.c (resolve_offset_ref): We must use basetype_path before we ++ destroy it with a call to convert_pointer_to. ++ ++Sat May 9 14:44:37 1998 Jason Merrill ++ ++ * class.c (currently_open_class): New fn. ++ * decl.c (lookup_name_real): Use it. ++ * search.c (lookup_field): Likewise. ++ ++Fri May 8 23:32:42 1998 Martin von Loewis ++ ++ * cp-tree.def (OVERLOAD): New node. ++ * cp-tree.h (BINDING_TYPE, SET_IDENTIFIER_GLOBAL_VALUE, ++ SET_IDENTIFIER_NAMESPACE_VALUE): Define. ++ (NAMESPACE_BINDING): Remove. ++ (IDENTIFIER_GLOBAL_VALUE, IDENTIFIER_NAMESPACE_VALUE): Use ++ namespace_binding. ++ (OVL_FUNCTION, OVL_CHAIN, OVL_CURRENT, OVL_NEXT, OVL_USED): ++ Define. ++ (tree_overload): New struct. ++ (IDENTIFIER_TYPE_VALUE): Use identifier_type_value. ++ (REAL_IDENTIFIER_TYPE_VALUE): Define. ++ (IDENTIFIER_HAS_TYPE_VALUE): Use IDENTIFIER_TYPE_VALUE. ++ (lang_decl_flags): Remove in_namespace. ++ (lang_decl): Remove chain. ++ (DECL_CHAIN, DECL_NAMESPACE): Remove. ++ (flag_honor_std): Declare extern. ++ (identifier_type_value, pushdecl_namespace_level, push_using_decl, ++ namespace_binding, set_namespace_binding, ++ lookup_function_nonclass, cat_namespace_levels, ++ set_decl_namespace, lookup_arg_dependent, binding_init, ovl_cons, ++ scratch_ovl_cons, ovl_member, build_overload): Declare. ++ (decl_list_length, get_namespace_id, current_namespace_id, ++ overloaded_globals_p): Remove. ++ (lookup_using_namespace, qualified_lookup_using_namespace): Change ++ return type. ++ (push_scratch_obstack): New macro. ++ * call.c (add_function_candidate): Special-case type of OVERLOAD node. ++ (build_user_conversions_1): Iterate using OVL_NEXT for ctors, ++ convs, fns. ++ (build_new_function_call): Iterate using OVL_CHAIN. ++ Print DECL_NAME in when reporting ambiguities. ++ (build_object_call): Iterate using OVL_NEXT for fns, convs. ++ (build_new_op): Call lookup_function_nonclass. ++ Iterate using OVL_NEXT. ++ (build_op_delete_call): Change detection of members. ++ Do not wrap TREE_LIST around fields and single global functions. ++ (build_over_call): Don't push a class level if the context is a ++ namespace. ++ (build_new_method_call): Iterate using OVL_NEXT. ++ * class.c (add_method): Chain overloaded members using ++ build_overload. Remove copying of method. ++ (grow_method): When iterating through the obstack, expect OVERLOAD ++ nodes. Chain overload members. ++ (finish_struct_methods): Chain overload members. Unpack OVERLOAD ++ nodes in call to get_baselinks. ++ (duplicate_tag_error): Expect OVERLOAD nodes when unchaining. ++ (finish_struct_1): Iterate over ctor using OVL_NEXT. Handle ++ fdecls that are OVERLOAD nodes. ++ (validate_lhs): New function. ++ (instantiate_type): Do not copy OVERLOAD nodes. Remove dead ++ code. Use DECL_NAME in error messages. Split code between global ++ and member function processing. ++ * decl.c (global_type_node): New static variable. ++ (in_std): New global. ++ (struct binding_level): New field usings. ++ (resume_binding_level): Assert that we are not in a class. ++ (toplevel_bindings_p): Just check for namespace_p or ++ pseudo_global. ++ (resume_level): Remove. ++ (find_binding): New function. ++ (binding_for_name): Call it. ++ (namespace_binding, set_namespace_binding): New functions. ++ (push_namespace): Associate binding level with new namespace, ++ resume_binding_level for existing namespace. Remove old code. ++ Fake std by counting. ++ (store_bindings): Use REAL_IDENTIFIER_TYPE_VALUE. ++ (maybe_push_to_top_level): Save current namespace. ++ (pop_from_top_level): Restore saved namespace. ++ (pop_namespace): Call suspend_binding_level. Remove old code. ++ (cat_namespace_levels): New function. ++ (set_identifier_type_value_with_scope): For namespace bindings, ++ set BINDING_TYPE, and use global_type_node. ++ Use REAL_IDENTIFIER_TYPE_VALUE otherwise. ++ (identifier_type_value): New function. ++ (pushtag): If no context, use current_namespace. ++ (duplicate_decls): Don't process DECL_CHAIN. ++ (pushdecl): Set DECL_CONTEXT to current_namespace, if it is not ++ already set. Never reset it to NULL_TREE. Lookup global variables ++ in their namespace. Push overloaded templates if they are on ++ namespace level. ++ (pushdecl_namespace_level): New function. ++ (pushdecl_top_level): Implement using pushdecl_namespace_level. ++ (pushdecl_using_decl): New function. ++ (overloaded_globals_p): Remove. ++ (push_overloaded_decl): Create OVERLOAD nodes, and iterate through ++ them. Use namespace_binding and set_namespace_value. ++ (redeclaration_error_message): Complain if the declarations come ++ from different namespaces. ++ (lookup_tag): On namespace level, look in the BINDING_TYPE. ++ (lookup_namespace_name): Pass tree_bindings from stack. Remove ++ old code. ++ (select_decl): New function. ++ (lookup_name_real): Call it for qualified and unqualified lookup. ++ Pass tree_bindings from the stack. ++ If prefer_type is 1, also accept namespaces. ++ (lookup_function_nonclass): New function. ++ (init_decl_processing): Set the binding level of the global ++ namespace to global_binding_level. ++ Build a proper type list for __builtin_apply. ++ Initialize std_node to "fake std" if flag_honor_std is set. ++ Initialize global_type_node. ++ Allocated bad_alloc in namespace std if flag_honor_std. ++ (define_function): Set the DECL_CONTEXT to the current_namespace. ++ (start_decl): A namespace is not considered as a context here. If ++ the DECL_CONTEXT is a namespace, push the decl. ++ (cp_finish_decl): Check for namespaces used as initializers. ++ (grokfndecl): Add namespace parameter. Remove processing of ++ DECL_CHAIN. ++ (grokvardecl): Add namespace parameter. ++ (grokdeclarator): Process SCOPEs that are namespaces. For ++ mangling, temporarily set the DECL_CONTEXT on anonymous structs. ++ (start_function): Check for contexts that are namespaces. ++ Set context for declarations that have not been pushed. ++ (store_parm_decls): Check for ::main only. ++ (finish_function): Likewise. ++ (start_method): Check for contexts that are namespaces. ++ (start_method): Remove DECL_CHAIN processing. ++ * decl2.c (flag_honor_std): Declare. ++ (lang_decode_option): Set it if -fhonor-std or -fnew-abi is given. ++ (decl_namespace_list): New static global. ++ (grok_x_components): Ignore namespaces as type contexts. ++ (check_classfn): Expect OVERLOAD nodes. ++ (grokfield): Remove DECL_CHAIN processing. ++ (finish_file): Call cat_namespace_levels. ++ (merge_functions): New function. ++ (ambiguous_decl): Rewrite. ++ (lookup_using_namespace): Produce tree_bindings. ++ (qualified_lookup_using_namespace): Likewise. ++ (set_decl_namespace, decl_namespace, current_decl_namespace, ++ push_decl_namespace, pop_decl_namespace): New functions. ++ (arg_lookup): New struct. ++ (add_function, arg_assoc_namespace, arg_assoc_class, ++ arg_assoc_type, arg_assoc_args, arg_assoc, lookup_arg_dependent): ++ New functions. ++ (get_namespace_id, current_namespace_id): Remove. ++ (do_toplevel_using_decl): Rewrite. ++ (do_class_using_decl): Complain about namespace qualifiers. ++ (do_using_directive): Sorry if not on namespace level. Complain ++ about unknown namespaces. ++ * error.c (dump_aggr_type): Check for namespace contexts. ++ * except.c (init_exception_processing): Push terminate into std. ++ * friend.c (is_friend): A namespace is not a context, here. ++ * init.c (expand_member_init): Remove DECL_CHAIN processing. ++ (build_offset_ref): Process OVERLOAD nodes. ++ * lang-specs.h (__HONOR_STD): Define if -fnew-abi or -fhonor-std. ++ * lex.c (identifier_type): Loop using OVL_CHAIN. ++ (see_typename): Set looking_for_typename to 2. ++ (real_yylex): Likewise. ++ (do_identifier): Expect OVERLOAD nodes instead of TREE_LISTs. ++ (do_scoped_id): Expect OVERLOAD nodes. ++ Change calling convention for qualified_lookup_using_namespace. ++ (build_lang_decl): Don't set in_namespace anymore. ++ * method.c (typevec_size): New global. ++ (build_overload_nested_name): Return if global_namespace. ++ Otherwise, always expect a declaration context. ++ (build_qualified_name): Likewise. ++ Make sure we don't write beyond typevec_size. ++ (build_decl_overload_real): Likewise. ++ Allocate one extra slot for the namespace. ++ (hack_identifier): Mark code dead. ++ Process OVERLOAD and NAMESPACE_DECL nodes. ++ * parse.y (program): Pop namespaces until in global namespace. ++ (extdef): In a using-declaration, don't discard the identifier if ++ there is no declaration. ++ (left_curly): Ignore type contexts which are namespaces. ++ (typename_sub2): Use IDENTIFIER_TYPE_VALUE to retrieve the type ++ used as scope. ++ * pt.c (template_class_depth): Expect types to be namespaces. ++ (determine_specialization): Simplify by expecting OVERLOAD nodes. ++ (push_template_decl): Push into namespace level. ++ Reset ctx if it is a namespace. ++ Set DECL_CONTEXT to current_namespace if not set already. ++ Ignore real contexts that are namespaces. ++ (mangle_class_name_for_template): Skip global_namespace. ++ Mangle other namespaces as declarations. ++ (lookup_template_function): Set type of OVERLOAD nodes to unknown. ++ (lookup_template_class): Push into namespace of context. ++ If the context is a namespace, set it to global_namespace. ++ Use id_context for mangling. ++ (for_each_template_parm): Handle OVERLOAD and NAMESPACE_DECL nodes. ++ (tsubst_friend_function): Ignore namespace contexts. ++ Push into namespace level. ++ (tsubst): Handle NAMESPACE_DECL nodes. ++ Remove DECL_CHAIN processing. ++ (type_unification_real): Recognize OVERLOAD instead of TREE_LIST nodes. ++ * ptree.c (print_lang_identifier): Print bindings. ++ (lang_print_xnode): Print OVERLOAD nodes. ++ * rtti.c (init_rtti_processing): Push type_info into std. ++ * search.c (lookup_fnfields_here): Expect OVERLOAD nodes. ++ (lookup_fnfields_1, get_virtuals_named_this, get_matching_virtual, ++ dfs_debug_mark, dfs_pushdecls, dfs_compress_decls, add_conversions, ++ lookup_fnfields_here): Likewise. ++ Process all nodes, instead of going through TREE_CHAIN. ++ * sig.c (build_signature_pointer_or_reference_type): Set context ++ to global_namespace. ++ (build_signature_table_constructor): Expect OVERLOAD nodes. ++ * spew.c (yylex): Save old setting of looking_for_typename. ++ * tree.c (decl_list_length): Remove. ++ (binding_init): New function. ++ (count_functions): Rewrite. ++ (is_overloaded_fn): Expect OVERLOAD nodes. ++ (really_overloaded_fn, get_first_fn, lvalue_type): Likewise. ++ (ovl_cons, scratch_ovl_cons, build_overload, build_overload_after, ++ ovl_member): New functions. ++ * typeck.c (require_complete_type): Expect OVERLOAD nodes. ++ (type_unknown_p): Likewise. ++ (require_instantiated_type): Likewise. ++ (build_component_ref): Declare code dead. ++ (build_x_function_call): Create and expect OVERLOAD nodes. ++ (build_function_call_real): Check for ::main only. ++ (build_unary_op): Likewise. Expect OVERLOAD nodes. ++ (convert_for_assignment): Check for TREE_LIST before accessing ++ TREE_VALUE. ++ * decl.c (duplicate_decls): Check for namespace bindings instead ++ of global bindings. ++ (pushdecl, push_overloaded_decl, lookup_tag, lookup_name_real, ++ lookup_name_current_level, start_decl, xref_tag, ++ finish_enum): Likewise. ++ * init.c (build_offset_ref): Likewise. ++ * search.c (lookup_field): Likewise. ++ (lookup_fnfields): Likewise. ++ (dfs_debug_mark): Likewise. ++ * decl.c (poplevel): Use SET_IDENTIFIER_TYPE_VALUE. ++ (poplevel_class, pop_from_top_level): Likewise. ++ * decl2.c (finish_method): Likewise. ++ * class.c (build_vtable): Use SET_IDENTIFIER_GLOBAL_VALUE. ++ * decl.c (record_builtin_type): Likewise. ++ (init_decl_processing, grokfndecl): Likewise. ++ * lex.c (get_time_identifier, do_identifier, do_scoped_id): Likewise. ++ (make_lang_type): Likewise. ++ * parse.y (make_thunk): Likewise. ++ * pt.c (tsubst): Likewise. ++ * tree.c (debug_binfo): Likewise. ++ * exception.cc, new.cc, new1.cc, new2.cc, tinfo.cc, tinfo.h, ++ tinfo2.cc, inc/new.h: Add std qualifications. ++ * inc/new: Wrap with namespace std if __HONOR_STD. ++ * inc/typeinfo: Likewise. ++ ++Fri May 8 00:43:50 1998 Jason Merrill ++ ++ * call.c (build_user_type_conversion_1): Handle second_conv ++ properly for templates. ++ ++Thu May 7 17:09:25 1998 Andrew MacLeod ++ ++ * method.c (build_decl_overload_real): Set TREE_USED flag to ++ zero for build_type_variants nodes as well. ++ ++Wed May 6 19:27:09 1998 Jason Merrill ++ ++ * pt.c (tsubst): Don't tsubst the type of an IDENTIFIER_NODE. ++ ++Wed May 6 16:49:48 1998 Jim Wilson ++ ++ * Makefile.in (call.o, class.o, decl.o, decl2.o, errfn.o, error.o, ++ except.o, expr.o, friend.o, init.o, lex.o, method.o, pt.o, repo.o, ++ rtti.o, search.o, semantics.o, sig.o, tree.o, typeck.o, typeck2.o, ++ xref.o): Add toplev.h dependencies. ++ ++Wed May 6 16:44:58 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * errfn.c (cp_error, cp_warning): Remove declarations for ++ error and warning respectively. ++ ++Wed May 6 14:28:18 1998 Kaveh R. Ghazi ++ ++ * error.c: Convert to using ctype macros defined in system.h. ++ * method.c: Likewise. ++ * xref.c: Likewise. ++ * lex.c: Likewise. Also remove redundant system header stuff. ++ ++Wed May 6 06:36:41 1998 Robert Lipe ++ ++ * call.c, class.c, decl.c, decl2.c, errfn.c, error.c, except.c, ++ expr.c, friend.c, init.c, lex.c, method.c, pt.c, repo.c, rtti.c, ++ search.c, semantics.c, sig.c, tree.c, typeck.c, typeck2.c, ++ xref.c: Add include of toplev.h. ++ ++Wed May 6 02:33:39 1998 Jason Merrill ++ ++ * tree.c (perm_manip): Also regenerate the RTL of an extern. ++ (copy_to_permanent): Use end_temporary_allocation. ++ ++Tue May 5 23:54:04 1998 Jason Merrill ++ ++ * init.c (expand_vec_init): The initialization of each array ++ element is a full-expression. ++ ++Tue May 5 18:24:13 1998 Andrew MacLeod ++ ++ * method.c (build_mangled_name): Add a call to build_type_variant ++ to get the right type. ++ ++Tue May 5 01:25:03 1998 Jason Merrill ++ ++ * Makefile.in: Add .SUFFIXES. ++ ++ * cp-tree.def: Remove NAMESPACE_DECL. ++ ++Sun May 3 01:32:14 1998 Jason Merrill ++ ++ * call.c (build_over_call): Do evaluate arg even if it has empty ++ class type. ++ * decl.c (start_function): Don't push a member function. ++ ++Thu Apr 30 18:59:23 1998 Jim Wilson ++ ++ * Makefile.in (g++FAQ.info): Put -o option before input file. ++ ++Thu Apr 30 13:05:33 1998 Andrew MacLeod ++ ++ * gxxint.texi: Add info for squangling codes K and B. ++ ++Tue Apr 28 13:22:01 1998 Mark Mitchell ++ ++ * semantics.c (begin_stmt_expr): Avoid duplicating the effect of ++ the expression in templates. ++ (finish_stmt_expr): Likewise. ++ ++1998-04-28 Brendan Kehoe ++ ++ * decl2.c (ambiguous_decl): Fix NAME parm to be a tree, not int. ++ ++Mon Apr 27 13:58:10 1998 Mark Mitchell ++ ++ * decl.c (maybe_push_to_top_level): Always clear ++ current_template_parms and processing_template_decl. ++ (pushtag): Remove check of current_class_type and some comments, ++ since maybe_push_to_top_level no longer creates confusion. ++ ++Sun Apr 26 12:10:18 1998 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_IS_TEMPLATE): New macro. ++ (DECL_CLASS_TEMPLATE_P): Likewise. ++ (DECL_PRIMARY_TEMPLATE): Likewise. ++ (PRIMARY_TEMPLATE_P): Use it. ++ (push_template_decl_real): New function. ++ (redeclare_class_template): Take new template parameters as ++ input. ++ (is_specialization_of): New function. ++ (comp_template_args): Declare. ++ * decl.c (pushtag): Handle friend template classes. ++ (xref_tag): Likewise. Use new calling convention for ++ redeclare_class_template. ++ * decl2.c (grok_x_components): Handle friend templates. ++ * friend.c (is_friend): Use is_specialization_of where ++ appropriate. Deal with friend class templates. ++ (make_friend_class): Let a class template be friends with itself. ++ * pt.c (comp_template_args): Remove declaration. ++ (tsubst_friend_class): New function. ++ (push_template_decl_real): New function. ++ (push_template_decl): Use it. ++ (redeclare_class_template): Adjust for new calling convention. ++ (comp_template_args): Give it external linkage. ++ (instantiate_class_type): Use tsubst_friend_class to deal ++ with friend templates. ++ * typeck.c (comptypes): Use comp_template_args, rather than ++ expanding it inline. ++ * parse.y (component_decl): Handle a nested template type ++ like other component type declarations. ++ ++ * pt.c (check_explicit_specialization): Handle overloaded ++ constructors correctly. ++ ++ * pt.c (mabybe_get_template_decl_from_type_decl): New function. ++ (lookup_template_class): Use it. ++ ++Thu Apr 23 21:19:06 1998 Jason Merrill ++ ++ * cp-tree.def: Add WRAPPER. USER_CONV now only has two ops. ++ * cp-tree.h: Add WRAPPER support. ++ * call.c (add_candidate): Split out from add_*_candidate fns. ++ (build_over_call): Take the candidate instead of function and args. ++ Enforce access control here. Emit overload warnings here. ++ (add_warning): New fn. ++ (joust): Add WARN parm. If not set, call add_warning instead of ++ printing a warning. Re-enable some warnings. ++ (tourney): Pass it. ++ (convert_like): Adjust. ++ (build_new_op): Adjust. ++ (build_new_function_call): Adjust. ++ (build_user_type_conversion_1): Adjust. ++ (USER_CONV_FN): Adjust. ++ * tree.c (build_expr_wrapper, build_expr_ptr_wrapper, ++ build_int_wrapper): New fns. ++ ++Thu Apr 23 18:27:53 1998 Mark P. Mitchell ++ ++ * pt.c (unify): Fix typo in previous change. ++ ++Thu Apr 23 09:32:58 1998 Jason Merrill ++ ++ * error.c (dump_type_real): Declare canonical_name. ++ ++ * typeck.c (comp_target_types): Fix PMFs. ++ ++Wed Apr 22 13:24:48 1998 Mark Mitchell ++ ++ * class.c (finish_struct): Set TREE_PRIVATE and TREE_PROTECTED for ++ the DECL_RESULTs of a member TEMPLATE_DECL, not just the ++ TEMPLATE_DECL. ++ ++ * pt.c (tsubst): Decrease the template-level of ++ TEMPLATE_TEMPLATE_PARMS. Likewise for the DECL_INITIAL of a ++ TEMPLATE_PARM_INDEX. ++ (template_decl_level): New function. ++ (unify): Make sure to record unifications for template ++ parameters, even when the parameters exactly match the arguments. ++ Combine duplicated code for TEMPLATE_TEMPLATE_PARMs and ++ TEMPLATE_TYPE_PARMS. Don't try to unify template parameters that ++ aren't from the level we're currently working on. ++ ++Tue Apr 21 22:00:04 1998 Mark Mitchell ++ ++ * errfn.c (cp_thing): Use xrealloc, not xmalloc, to copy memory. ++ ++ * decl2.c (check_member_template): Set DECL_IGNORED for member ++ class templates, too. ++ ++ * decl2.c (grokfield): Remangle the name of a member TYPE_DECL. ++ ++Tue Apr 21 18:59:11 1998 Benjamin Kosnik ++ ++ * decl.c (duplicate_decls): Only check DECL_FRIEND_P if function. ++ ++Tue Apr 21 14:22:00 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * cp-tree.h (intTI_type_node, unsigned_intTI_type_node): Declare. ++ * decl.c (intTI_type_node, unsigned_intTI_type_node): Define. ++ (init_decl_processing): Handle TI types. ++ * typeck.c (unsigned_type, signed_type): Handle TI types. ++ ++Sat Apr 18 15:25:21 1998 Jim Wilson ++ ++ * g++spec.c (lang_specific_driver): New argument in_added_libraries. ++ New local added_libraries. Increment count when add library to ++ arglist. ++ ++Fri Apr 17 21:25:00 1998 Mark Mitchell ++ ++ * cp-tree.h (type_as_string_real): New function. ++ * pt.c (mangle_class_name_for_template): Use it. ++ * error.c (dump_aggr_type): Change prototype. ++ (dump_type_prefix): Likewise. ++ (dump_type_suffix): Likewise. ++ (dump_type_real): Convert from dump_type. If desired, the ++ "canonica" name of a typedef, i.e., the name of the underlying ++ type, can be printed. ++ (dump_type): Call dump_type_real. ++ ++Fri Apr 17 14:30:45 1998 Jason Merrill ++ ++ * decl2.c (lang_decode_option): -fnew-abi implies -fvtable-thunks. ++ ++ * typeck.c (comp_target_types): Tweak pedantic case. ++ (comp_target_parms): Tweak pedantic case. Clean up somewhat. ++ Return -1 or 1 instead of 1 or 2. ++ (compparms): Remove STRICT handling. ++ (convert_for_assignment): Fix handling of pmfs. ++ ++Fri Apr 17 14:04:16 1998 Mark Mitchell ++ ++ * typeck.c (comp_target_types): Handle references like pointers. ++ (comp_target_parms): Note that return code from comp_target_types ++ can be negative to indicate failure. ++ ++Fri Apr 17 09:10:52 1998 Andreas Schwab ++ ++ * Make-lang.in (c++.all.build): Don't depend on $(DEMANGLER_PROG), ++ which requires a working target compiler to build. ++ ++Fri Apr 17 08:57:35 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * tree.c (avoid_overlap): Add prototype. ++ ++ * spew.c (num_tokens): Add prototype. ++ (nth_noken, add_token, consume_token, debug_yychar): Likewise. ++ ++ * search.c (dfs_check_overlap): Add prototype. ++ (dfs_no_overlap_yet): Likewise. ++ ++ * pt.c (original_template): Add prototype. ++ (inline_needs_template_parms): Likewise. ++ (push_inline_template_parms_recursive): Likewise. ++ (retrieve_specialization, register_specialization): Likewise. ++ (print_candidates, reduce_template_parm_level): Likewise. ++ (build_template_decl, mark_template_parm): Likewise. ++ (tsubst_friend_function, get_bindings_real): Likewise. ++ ++ * method.c (start_squangling): Add prototype. ++ (end_squangling, check_ktype, issue_ktype): Likewise. ++ (build_overloaded_scope_ref, check_btype): Likewise. ++ (build_mangled_template_parm_index): Likewise. ++ ++ * lex.c (init_cpp_parse): Add prototype. ++ (handle_cp_pragma, handle_sysv_pragma): Likewise. ++ (reduce_cmp, token_cmp): Likewise. ++ ++ * except.c (call_eh_info): Add prototype. ++ (push_eh_info, get_eh_info, get_eh_value, get_eh_type): Likewise. ++ (get_eh_caught, get_eh_handlers, do_pop_exception): Likewise. ++ ++ * decl2.c (is_namespace_ancestor): Add prototype. ++ (namespace_ancestor, add_using_namespace): Likewise. ++ (ambiguous_decl): Likewise. ++ ++ * decl.c (indent): Add prototype. ++ ++ * call.c (add_template_candidate_real): Add prototype. ++ ++Fri Apr 17 01:57:12 1998 Jason Merrill ++ ++ * decl2.c (build_expr_from_tree): Just return a PMF. ++ ++Fri Apr 17 00:45:12 1998 Mark Mitchell ++ ++ * typeck2.c (process_init_constructor): Don't strip cv-qualifiers ++ when doing initializations. ++ ++ * pt.c (unify): Use comptypes to compare type args. ++ ++Fri Apr 17 00:24:22 1998 Jason Merrill ++ ++ * decl.c (duplicate_decls): Fix check for when it's safe to free ++ the new decl. ++ ++ * pt.c (mangle_class_name_for_template): Don't pass a typedef type ++ to type_as_string. ++ ++Thu Apr 16 17:47:30 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * pt.c (build_template_parm_index): Add prototype. ++ ++ * search.c (my_tree_cons): Don't clear words outside the ++ newly allocated node. ++ ++Wed Apr 15 15:34:44 1998 Dave Brolley ++ ++ * lex.c (init_parse): Now returns char* containing the filename. ++ ++Wed Apr 15 13:20:06 1998 John Carr ++ Jeff Law ++ ++ * errfn.c: Rework to avoid problems when HOST_WIDE_INT is longer ++ than a pointer. ++ ++Sun Apr 12 22:31:19 1998 Richard Kenner ++ ++ * cvt.c (cp_convert_to_pointer): Use TYPE_PRECISION. ++ ++Fri Apr 10 12:16:49 1998 Benjamin Kosnik ++ ++ * decl.c (duplicate_decls): Don't warn for redundant decls if ++ friend: let add_friend take care of it. ++ ++Thu Apr 9 02:40:48 1998 Jason Merrill ++ ++ * sig.c (build_signature_pointer_constructor): Don't set ++ TREE_HAS_CONSTRUCTOR for a signature pointer. ++ * cvt.c (ocp_convert): Don't force a temporary for internal structs. ++ * init.c (resolve_offset_ref): Warn about implicit & on pmfs ++ here, too. ++ * typeck.c (build_unary_op): Only allow taking the address of a ++ real constructor. ++ * typeck2.c (digest_init): Simplify. ++ (store_init_value): Don't pedwarn about using { } for pmfs. ++ ++Thu Apr 9 22:16:57 1998 Per Bothner ++ ++ * cp-tree.h (start_decl): Update prototype. ++ * decl.c (start_decl): Like the C version, new parameters ++ for the attributes. Call cplus_decl_attributes here, ++ (pushdecl): Like C version, do build_type_copy if TYPE_DECL, ++ (grokdeclarator): Pass NULL for new start_decl arguments. ++ * pt.c (tsubst_expr): Likewise. ++ * parse.y: Merge cplus_decl_attribute calls into start_decl calls. ++ * typeck.c (common_type): Check TYPE_MAIN_VARIANT. ++ * lex.c (build_lang_decl): Add lang_name_java. ++ * class.c (push_lang_context): Add lang_name_java. ++ * method.c (build_mangled_name): Check for is_java_type. ++ ++Thu Apr 9 22:16:57 1998 Benjamin Kosnik ++ ++ * decl.c (grokdeclarator): Check TYPE_MAIN_VARIANT. ++ * call.c (build_scoped_method_call): Check for TREE_CODE for ++ VOID_TYPE instead of type == void_type_node. ++ (build_method_call): Likewise. ++ * decl.c (lookup_name_real): Likewise. ++ (grokdeclarator): Likewise. ++ (start_decl): Likewise. ++ (grokparms): Likewise. ++ (start_function): Likewise. ++ (finish_function): Likewise. ++ (start_method): Likewise. ++ ++Thu Apr 9 00:18:44 1998 Dave Brolley (brolley@cygnus.com) ++ ++ * lex.c (finput): New variable. ++ (init_cpp_parse): Renamed from init_parse. ++ (init_parse): Handle !USE_CPPLIB. Call init_cpp_parse when finished. ++ (finish_parse): New function. ++ * cp-tree.h (init_lex, init_parse): Remove declarations. ++ ++Mon Apr 6 02:25:05 1998 Jason Merrill ++ ++ * call.c (build_call): Still evaluate the actual argument. ++ * class.c (is_empty_class): Update for -fnew-abi. ++ ++ * decl2.c: -fnew-abi implies -fsquangle. ++ ++ * method.c (do_build_assign_ref): Don't do anything to copy ++ an empty class. ++ (do_build_copy_constructor): Likewise. ++ * call.c (build_over_call): Likewise. ++ ++Sat Apr 4 18:43:58 1998 Jason Merrill ++ ++ * tree.c (avoid_overlap): Return a value. ++ ++Sat Apr 4 12:52:35 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * method.c (check_btype): Add missing argument to xrealloc. ++ (check_ktype): Likewise. ++ ++Fri Apr 3 02:22:59 1998 Jason Merrill ++ ++ Implement empty base optimization. ++ * class.c (finish_struct_1): Add vbase fields earlier. Set ++ CLASSTYPE_SIZE of an empty base to 0. Types with bases can be empty. ++ * search.c (dfs_check_overlap, dfs_no_overlap_yet): New fns. ++ (types_overlap_p): New fn. ++ * tree.c (avoid_overlap): New fn. ++ (build_base_fields): Use it to avoid overlapping empty bases. ++ * cp-tree.h, decl2.c, lang-options.h: Add -fnew-abi. ++ ++ * decl.c (cplus_expand_expr_stmt): Strip unused INDIRECT_REFs. ++ ++ Re-implement allocation of base class subobjects. ++ * tree.c (unshare_base_binfos): New fn. ++ (layout_basetypes): Use it. Now handles offsets of both virtual and ++ non-virtual bases, after layout_type. ++ (layout_vbasetypes): Remove. ++ (build_base_fields): Generate FIELD_DECLs for each non-virtual base. ++ (build_vbase_pointer_fields): Split out from old layout_basetypes. ++ * class.c (finish_base_struct): Lose offset handling code. ++ Move nonvdtor warning here. Don't mess with t_binfo anymore. ++ (finish_struct_1): Don't mess with t_binfo anymore. Use fns above. ++ * cp-tree.h: Adjust. ++ ++Thu Apr 2 14:25:13 1998 Jason Merrill ++ ++ * cp-tree.h: Lose CLASSTYPE_VBASE_SIZE, some unused stuff. ++ * decl.c, decl2.c, pt.c, ptree.c, lex.c: Likewise. ++ * class.c (duplicate_tag_error): Likewise. ++ (finish_struct_1): Set CLASSTYPE_SIZE, CLASSTYPE_MODE, CLASSTYPE_ALIGN. ++ * tree.c (layout_vbasetypes): Update from layout_record, remove ++ var_size support, use CLASSTYPE_SIZE instead of CLASSTYPE_VBASE_SIZE. ++ (layout_basetypes): Likewise. ++ ++Wed Apr 1 18:22:25 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * class.c, Make sure system.h is included just after config.h. ++ Delete lingering stdio and errno references too. ++ * decl.c, errfn.c, parse.y, ptree.c search.c, xref.c: Likewise. ++ ++Wed Apr 1 15:38:36 1998 Jason Merrill ++ ++ * friend.c (is_friend): Fix access control for local classes. ++ ++ * class.c (is_empty_class): New fn. ++ * call.c (build_call): Don't pass empty class objects to a function. ++ ++Wed Apr 1 14:58:35 1998 Mark Mitchell ++ ++ * call.c (build_over_call): Do name resolution for default ++ arguments of function templates in the scope of the templates. ++ ++Tue Mar 31 13:43:57 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * call.c: Include system.h. Remove includes, declarations and ++ defines provided by system.h. ++ * class.c, cvt.c, decl.c, decl2.c, errfn.c error.c: Likewise. ++ * except.c, expr.c friend.c, g++spec.c, init.c, input.c: Likewise. ++ * lex.c, parse.y, pt.c, ptree.c repo.c rtti.c, search.c: Likewise. ++ * semantics.c, sig.c, spew.c, tree.c, typeck.c: Likewise. ++ * typeck2.c, xref.c: Likewise. ++ * Makefile.in: Dependencies updated as appropriate. ++ * Make-lang.in: Likewise. ++ ++Mon Mar 30 12:15:00 1998 Mark Mitchell ++ ++ * pt.c (fn_type_unification): Allow incomplete unification without ++ an immediate error message. ++ ++Mon Mar 30 08:55:42 1998 Jason Merrill ++ ++ * tree.c (member_p): New fn. ++ * decl2.c (finish_file): Only set DECL_STATIC_FUNCTION_P for ++ initializing class members. ++ ++ * cp-tree.def (TEMPLATE_PARM_INDEX): Class 'x'. ++ * ptree.c (lang_print_xnode): Handle TEMPLATE_PARM_INDEX. ++ ++ * call.c (build_method_call): Handle non-scoped destructors, too. ++ * pt.c (tsubst_copy): Likewise. ++ ++ * pt.c (print_template_context): Split out... ++ (push_tinst_level): ...from here. ++ ++ * friend.c (is_friend): Don't pass a type to decl_function_context. ++ ++ * typeck.c (convert_for_initialization): Always hand off ++ conversions to class type. ++ ++Sun Mar 29 20:01:59 1998 Jason Merrill ++ ++ * friend.c (is_friend): Local classes have the same access as the ++ enclosing function. ++ ++Sun Mar 29 00:47:32 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * typeck.c (expand_target_expr): Delete dead function. ++ ++ * search.c: Put various prototypes inside #ifdef MI_MATRIX. ++ ++ * repo.c (save_string): Delete dead function. ++ ++ * method.c (thunk_printable_name): Delete dead function. ++ ++ * lex.c (yynextch): Delete dead function. ++ ++ * expr.c (tree_extract_aggr_init): #if 0 out. ++ ++ * except.c (do_unwind): Delete dead function. ++ (easy_expand_asm): Likewise. ++ ++ * cvt.c (build_conversion_type_1): Delete dead function. ++ ++ * cp-tree.h (push_expression_obstack): Declare. ++ ++ * call.c (source_type): #if 0 out. ++ ++ * class.c (alter_access): Remove unused label. Add braces ++ around empty else clause. ++ ++ * lex.c (yyprint): Fix argument to printf. ++ ++Sat Mar 28 17:43:52 1998 Mark Mitchell ++ ++ * pt.c (tsubst): Clear TREE_USED for new FUNCTION_DECLs. ++ ++ * pt.c (instantiate_class_template): Make sure template ++ arguments are permanent. ++ * init.c (resolve_offset_ref): Don't go looking around in ++ template types. ++ ++ * semantics.c: Add routines to handle expressions, and some ++ declaration processing. ++ * parse.y: Use them. ++ (current_class_depth): Move declaration to cp-tree.h. ++ * parse.c: Regenerated. ++ * cp-tree.h: Use them. ++ (current_class_depth): Declare. ++ * pt.c (tsubst_copy): Use begin_stmt_expr and finish_stmt_expr. ++ ++Fri Mar 27 20:23:18 1998 Mark Mitchell ++ ++ * error.c (dump_decl): Be a bit more explicit with template ++ type arguments, when verbose. ++ ++Fri Mar 27 18:16:40 1998 Jason Merrill ++ ++ * inc/exception: Reorder closing braces. ++ ++Fri Mar 27 13:22:18 1998 Mark Mitchell ++ ++ * pt.c (redeclare_class_template): New function. ++ * cp_tree.h (redeclare_class_template): Declare it. ++ * decl.c (xref_tag): Use it. ++ ++Thu Mar 26 11:16:30 1998 Jason Merrill ++ ++ * call.c (build_over_call): Check IS_AGGR_TYPE, not ++ TYPE_LANG_SPECIFIC. ++ * typeck.c (convert_arguments): Likewise. ++ ++ * decl.c (grokdeclarator): Remove const and volatile from type after ++ setting constp and volatilep. ++ ++ * class.c (finish_struct_1): Don't warn about bool bitfield larger ++ than one bit. ++ ++Thu Mar 26 10:25:52 1998 Mark Mitchell ++ ++ * pt.c (convert_nontype_argument): STRIP_NOPS where appropriate. ++ ++Thu Mar 26 10:24:05 1998 Mark Mitchell ++ ++ * call.c (build_object_call): Complain about ambiguous operator(), ++ rather that crashing. ++ (build_new_op): Likewise. ++ (build_op_delete_call): Likewise. ++ ++Thu Mar 26 10:23:24 1998 Mark Mitchell ++ ++ * cvt.c (perform_qualification_conversions): Use comp_target_types ++ instead of comp_ptr_ttypes. ++ ++Wed Mar 25 16:10:50 1998 Mark Mitchell ++ ++ * cp-tree.h (enforce_access): Declare. ++ * call.c (enforce_access): Make it extern, not static. ++ * class.c (alter_access): Use enforce_access; modify code for ISO ++ compliance, rather than ARM rules. ++ ++Wed Mar 25 12:10:45 1998 Kriang Lerdsuwanakij ++ ++ * cp-tree.h: Fix typo. ++ ++Wed Mar 25 02:01:02 1998 Jason Merrill ++ ++ * expr.c (cplus_expand_expr): Only do PCC_STATIC_STRUCT_RETURN thing ++ if (aggregate_value_p (type)). ++ ++ * decl2.c (constructor_name_full): Handle TYPENAME_TYPE. ++ ++Tue Mar 24 16:12:01 1998 Mark Mitchell ++ ++ * tree.c (mapcar): When dealing with a DECL, use it's constant ++ value, if any. ++ * pt.c (lookup_template_class): Don't mangle the names of template ++ classes whose arguments are unknown. ++ ++ * pt.c (tsubst_expr): Handle GOTO_STMT correctly. ++ ++Tue Mar 24 12:21:55 1998 Benjamin Kosnik ++ ++ * decl.c (init_decl_processing): Set TYPE_PRECISON for bools to 1. ++ ++Tue Mar 24 12:21:48 1998 Jim Wilson ++ ++ * decl.c (init_decl_processing): Initialize TYPE_MAX_VALUE for ++ boolean_type_node to 1. ++ ++Tue Mar 24 10:23:47 1998 Mark Mitchell ++ ++ * error.c (dump_expr): Remove unused variable `l'. ++ ++ * pt.c (for_each_template_parm): New function, created by ++ converting uses_template_parms. ++ (tree_fn_t): New typedef. ++ (uses_template_parms): Use it. ++ (mark_template_parm): New function. ++ (push_template_decl): Check that the argument list of a partial ++ specialization uses all the template parameters. ++ ++ * Make-lang.in (c++filt): Don't delete cxxmain.c after we're done ++ with it; we might want it for debugging. ++ * cp-tree.h (type_unification): Change interface. ++ * class.c (finish_struct_1): Skip nested template types, just like ++ ordinary nested types. ++ (instantiate_type): Use new interface to type_unification. ++ * lex.c (init_lex): Add __sz as opname for sizeof. ++ * method.c (build_overload_scope_ref): New function. ++ (build_overload_int): Handle complex expressions. Set ++ numeric_output_need_bar if necessary. ++ (build_overload_value): Handle non-PARM_DECL nodes; this ++ routine is now used by build_overload_int. Remove some ++ assignments to numeric_output_need_bar. Use ++ build_overload_scope_ref. ++ (build_qualified_name): Note that some template mangled names end ++ with digits, and set numeric_output_need_bar appropriately. Use ++ build_underscore_int. ++ * pt.c (unify): Change interface. ++ (type_unification_real): Likewise. ++ (determine_specialization): Use new interfaces. ++ (tsubst): Deal gracefully with situations in which the argument ++ vector is not fully filled. ++ (fn_type_unification): Use new interfaces. ++ (type_unification): Likewise. Remove NOP_EXPR hack. ++ (type_unification_real): Likewise. ++ (unify): Likewise. Deal with unification of complex expressions. ++ ++Mon Mar 23 12:24:37 1998 Jason Merrill ++ ++ * pt.c (complete_template_args): Initialize skip properly. ++ ++ * decl.c (make_typename_type): Revert. ++ (make_implicit_typename): Remove. ++ (lookup_name_real): Don't call it. Call lookup_field if we see a ++ TYPE_DECL from a template base. ++ * search.c (lookup_field): Do implicit typename stuff. ++ ++Sun Mar 22 00:50:42 1998 Nick Clifton ++ Geoff Noer ++ ++ * Makefile.in: Various fixes for building cygwin32 native toolchains. ++ * Make-lang.in: Likewise. ++ ++Fri Mar 20 18:07:39 1998 Kriang Lerdsuwanakij ++ ++ * pt.c (tsubst, TEMPLATE_TEMPLATE_PARM): Simplify. ++ ++Fri Mar 20 10:42:07 1998 Jason Merrill ++ ++ * decl.c (make_implicit_typename): Rewrite removed code. ++ (make_typename_type): Call it if the type we look up comes from ++ a base that uses template parms. ++ ++ * pt.c (complete_template_args): Rewrite. ++ (tsubst, FUNCTION_DECL): Use it. ++ ++Fri Mar 20 08:12:43 1998 H.J. Lu (hjl@gnu.org) ++ ++ * semantics.c (finish_asm_stmt): Fix combine strings. Call ++ c_expand_asm_operands () if output_operands, input_operands or ++ clobbers is not NULL_TREE. ++ ++Fri Mar 20 00:10:19 1998 Kriang Lerdsuwanakij ++ ++ * pt.c (complete_template_args): New function. ++ (get_bindings): Deal with specializations of function templates ++ with return type containing parameters from outer class ++ templates. ++ (tsubst, TEMPLATE_TEMPLATE_PARM): When reducing parameter level, ++ substitute arguments and compose a new type. ++ ++Thu Mar 19 19:01:48 1998 Mark Mitchell ++ ++ * pt.c (tsubst): Clear DECL_PENDING_INLINE_INFO for new ++ FUNCTION_DECLs. ++ ++Thu Mar 19 11:51:58 1998 Jason Merrill ++ ++ * decl.c (make_implicit_typename): Lose useless code. ++ ++ * call.c (standard_conversion): Handle A* -> const A* properly. ++ ++ * pt.c (get_bindings_real): Rename from get_bindings. Add ++ check_rettype parm. ++ (get_bindings): Pass 1. ++ (get_bindings_overload): Pass 0. ++ ++Wed Mar 19 09:08:12 1998 Mark Mitchell ++ ++ * pt.c (check_explicit_specialization): When reverting a static ++ member function, also remove the `this' parameter from ++ last_function_parms. ++ ++Thu Mar 19 02:27:48 1998 Jason Merrill ++ ++ * pt.c (tsubst_copy, CONST_DECL): Don't bother tsubsting ++ a function context. ++ ++ * decl.c (store_bindings): Use free_binding_vecs. ++ (pop_from_top_level): Likewise. ++ ++Wed Mar 18 12:41:43 1998 Jason Merrill ++ ++ * decl.c (make_implicit_typename): Only change the type of a ++ TYPENAME_TYPE. ++ ++Wed Mar 18 10:09:51 1998 Mark Mitchell ++ ++ * semantics.c: New file, containing routines to perform the ++ semantic phase of parsing. ++ * parse.y: Use it. ++ * pt.c (tsubst_expr): Likewise. ++ * cp-tree.h: Declare the various functions in semantics.c. ++ Provide macros to access _STMT tree nodes. ++ * cp-tree.def: Add ASM_STMT tree node. ++ * Makefile.in, Make-lang.in: Add dependencies on and for ++ semantics.c. ++ ++Wed Mar 18 00:24:10 1998 Jason Merrill ++ ++ * pt.c (push_template_decl): Only check primary templates. ++ ++ * pt.c (check_explicit_specialization): Complain about default args ++ in explicit specialization. ++ ++ * parse.y (nomods_initdcl0): Also call cp_finish_decl for a ++ constructor_declarator. ++ ++Tue Mar 17 14:44:54 1998 Mark Mitchell ++ ++ * typeck2.c (build_x_arrow): Don't crash when an aggregate type ++ has no overloaded operator ->. ++ ++ * call.c (build_field_call): Don't crash when presented with a ++ field that is actually a nested type. ++ ++ * decl.c (pushtag): Deal with friend class injection in local ++ classes. ++ ++ * call.c (build_object_call): Don't crash if OBJ is a ++ pointer-to-member-function. ++ ++Tue Mar 17 11:40:26 1998 Jason Merrill ++ ++ * pt.c (push_template_decl): Complain about template with C linkage, ++ anonymous template class. ++ ++Mon Mar 16 12:10:39 1998 Jason Merrill ++ ++ * class.c (pushclass): Only use the mi_matrix stuff #ifdef MI_MATRIX. ++ * search.c: Likewise. ++ ++ * lex.c (do_pending_defargs): Only call ++ maybe_{begin,end}_member_template_processing for FUNCTION_DECLs. ++ ++ * parse.y (initdcl0_innards): Move maybeasm back into initdcl0 et al. ++ ++Mon Mar 16 10:47:22 1998 Mark Mitchell ++ ++ * parse.y: Deal with CONSTRUCTORS in new_initializers. ++ ++Mon Mar 16 10:54:21 1998 Mark Mitchell ++ ++ * pt.c (tsubst_copy): Deal with BIND_EXPR in a way that more ++ closely mimics the behavior in parse.y. ++ (tsubst_expr): Return the resulting BLOCK when making a tsubst'ing ++ into a compound statement. ++ ++Sun Mar 15 02:07:26 1998 Jason Merrill ++ ++ * cp-tree.h (TEMPLATE_PARMS_FOR_INLINE): New macro. ++ * pt.c (inline_needs_template_parms): New fn. ++ (original_template): New fn. ++ (push_inline_template_parms_recursive): New fn. ++ (maybe_begin_member_template_processing): Use them. ++ (maybe_end_member_template_processing): Likewise. ++ (is_member_or_friend_template): Rename to is_member_template. ++ Member functions of local classes are never member templates. ++ ++Sun Mar 15 01:14:22 1998 Kriang Lerdsuwanakij ++ ++ * lex.c (do_identifier): Handle TEMPLATE_DECL that was ++ added in the class scope to catch redefinition error. ++ ++ * pt.c (reduce_template_parm_level): Also copy ++ the DECL_TEMPLATE_PARMS field. ++ ++Sun Mar 15 10:54:08 1998 Mark Mitchell ++ ++ * pt.c (tsubst): Clear TYPE_REFERENCE_TO when creating a ++ reduced-level template type parameter. ++ ++Sun Mar 15 12:26:02 1998 Manfred Hollstein ++ ++ * cp-tree.h (struct lang_decl_flags): Add needs_final_overrider. ++ (DECL_NEEDS_FINAL_OVERRIDER_P): New macro. ++ * class.c (override_one_vtable): Set DECL_NEEDS_FINAL_OVERRIDER_P. ++ * decl.c (duplicate_decls): Propagate it. ++ * typeck2.c (abstract_virtuals_error): Use two loops to emit ++ abstract virtual functions and virtual functions which need a ++ final overrider separately. ++ ++Thu Mar 12 09:39:40 1998 Manfred Hollstein ++ ++ * lang-specs.h: Properly put brackets around array elements in ++ initializer. ++ ++ * typeck.c (build_binary_op_nodefault): Correctly place parens around ++ && and || in expression. ++ ++Thu Mar 12 09:26:04 1998 Manfred Hollstein ++ ++ * call.c (default_parm_conversions): Remove prototype definition. ++ (build_method_call): Remove unused variable result. ++ ++ * cvt.c (ocp_convert): Remove unused variable conversion. ++ ++ * decl2.c (ambiguous_decl): Add explicit parameter definition for name. ++ ++ * except.c (do_unwind): #if 0 definition of unused variables fcall ++ and next_pc. ++ ++ * expr.c (extract_scalar_init): #if 0 prototype and function ++ definition. ++ ++ * init.c (expand_aggr_init_1): Remove unused variable init_type. ++ (build_new_1): Remove unused variable t. ++ ++ * pt.c (instantiate_class_template): Remove unused variable newtag; ++ cast called function return value to void. ++ (do_decl_instantiation): Remove unused variables name and fn. ++ ++ * tree.c (get_type_decl): Add default return to shut up compiler from ++ complaining control reaches end of non-void function. ++ ++ * typeck.c (build_x_conditional_expr): Remove unused variable rval. ++ ++Thu Mar 12 09:12:15 1998 Manfred Hollstein ++ ++ * call.c (default_parm_conversions): Remove prototype definition. ++ (build_method_call): Remove unused variable result. ++ (build_over_call): Add default case in enumeration switch. ++ ++Thu Mar 12 08:39:13 1998 Manfred Hollstein ++ ++ * decl2.c (lang_decode_option): Change j's type to size_t. ++ ++ * tree.c (layout_vbasetypes): record_align and desired_align are of ++ type unsigned int; const_size and nonvirtual_const_size likewise. ++ ++Wed Mar 11 07:25:20 1998 Mark Mitchell ++ ++ * parse.y (new_initializer): Make sure all initializers are ++ lists. ++ ++Tue Mar 10 07:32:36 1998 Mark Mitchell ++ ++ * decl2.c (import_export_decl): Mark tinfo functions for ++ cv-qualified versions of class types as DECL_NOT_REALLY_EXTERN. ++ ++Fri Mar 6 23:27:35 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * method.c: Fix typo. ++ ++Fri Mar 6 10:06:59 1998 Kaveh R. Ghazi ++ ++ * method.c: Include "system.h" to get stdlib.h, stdio.h, ++ ctype.h, string.h, etc. ++ (issue_nrepeats): Add default case in enumeration switch. ++ (check_btype): Likewise. ++ (process_overload_item): Likewise. ++ ++ * Makefile.in (method.o): Depend on system.h. ++ ++Wed Mar 4 22:26:53 1998 Andreas Schwab ++ ++ * lex.c (do_scoped_id): Fix parenthesizing. ++ ++Wed Mar 4 12:11:53 1998 Michael Tiemann ++ ++ * rtti.c (get_tinfo_fn_dynamic): If this function is called an ++ FLAG_RTTI is unset, initialize type info machinery and continue ++ with FLAG_RTTI enabled. ++ (get_typeid): Likewise. ++ ++Wed Mar 4 11:47:55 1998 Jason Merrill ++ ++ * typeck.c (unary_complex_lvalue): &D::i has type B::* if i comes ++ from B. ++ ++Wed Mar 4 11:28:08 1998 Mark Mitchell ++ ++ * pt.c (finish_member_template_decl): Deal more gracefully with ++ invalid declarations. ++ ++Tue Mar 3 01:38:17 1998 Jason Merrill ++ ++ * cvt.c, decl.c, decl2.c, init.c, rtti.c, typeck.c, typeck2.c, ++ cp-tree.h: Clean up more old overloading code, old RTTI code, and ++ some formatting quirks. ++ ++ * call.c, class.c, cp-tree.h, cvt.c, decl.c, init.c, lex.c, ++ method.c, pt.c, ptree.c, typeck.c: Remove support for ++ -fno-ansi-overloading and overloading METHOD_CALL_EXPR. ++ * class.h: Remove. ++ * Makefile.in: Adjust. ++ ++ * pt.c (unify): Don't allow reduced cv-quals when strict. ++ ++ * call.c, class.c, pt.c, cp-tree.h: Remove nsubsts parm from ++ *type_unification* and unify. ++ ++Mon Mar 2 12:11:06 1998 Jason Merrill ++ ++ * parse.y (explicit_template_type): Remove TEMPLATE keyword. ++ (nested_name_specifier): And add it before this use. ++ (typename_sub0): And this use. Also add use without the keyword. ++ (typename_sub1): Likewise. ++ * pt.c (instantiate_class_template): Don't actually instantiate ++ anything if our type uses template parms. ++ ++Mon Mar 2 11:04:59 1998 Jim Wilson ++ ++ * decl.c (start_function): Don't call temporary_allocation for a ++ nested function. ++ ++Sun Mar 1 21:06:37 1998 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Don't mess with friends if ++ our type uses template parms. ++ ++Sat Feb 28 12:06:44 1998 Jason Merrill ++ ++ * parse.y (nested_name_specifier): Use explicit_template_type. ++ (typename_sub): Allow a template_type, an explicit_template_type, ++ or an implicit template type at the end. ++ * lex.c (yyprint): Handle a PTYPENAME being a TEMPLATE_DECL. ++ * decl.c (make_typename_type): Handle template-id where the name ++ is a TEMPLATE_DECL. ++ * call.c (build_scoped_method_call): Handle member template ++ destructor call. ++ * pt.c (tsubst_copy, METHOD_CALL_EXPR): Don't assume a member ++ destructor is represented by the type. ++ ++ * cp-tree.h (TYPENAME_TYPE_FULLNAME): New macro. ++ * parse.y (nested_name_specifier): Add 'template' case. ++ (explicit_template_type): New rule. ++ (typename_sub): Use it. ++ * decl.c (make_typename_type): Handle getting a template-id for NAME. ++ * pt.c (tsubst): Likewise. ++ ++Fri Feb 27 11:17:50 1998 Jason Merrill ++ ++ * pt.c (add_to_template_args): Fix thinko. ++ (instantiate_class_template): Call it later. ++ ++ * pt.c (get_class_bindings): Add outer_args parm. ++ (most_specialized_class): Likewise. ++ (instantiate_class_template): Pass it. ++ (more_specialized_class): Likewise. ++ (lookup_template_class): Get context from template if none ++ was specified. ++ (finish_member_template_decl): Don't do anything with a ++ partial specialization. ++ * decl2.c (check_member_template): Use IS_AGGR_TYPE instead of ++ AGGREGATE_TYPE_P. ++ * class.c (finish_struct): Member class templates have already been ++ checked for name clashes. ++ * decl.c (pushdecl_with_scope): Handle pushing at class level. ++ ++Fri Feb 27 02:25:16 1998 Jason Merrill ++ ++ * pt.c (tsubst, TEMPLATE_DECL): Support member class templates. ++ (tsubst, *_PARM): Support multiple levels of template classes. ++ (instantiate_class_template): Look up the pattern from the ++ original template. ++ (lookup_template_class): Handle getting a template for d1. ++ (push_template_decl): Correct setting of 'primary'. ++ (reduce_template_parm_level): Add 'levels' parm. ++ (finish_member_template_decl): Support member class templates. ++ (template_class_depth): Handle multiple levels. ++ * parse.y (component_decl_1, fn.def2): Remove member template case. ++ (component_decl): Add member template cases. ++ * decl2.c (check_member_template): We now handle member template ++ classes. ++ * decl.c (pushtag): Handle member templates. ++ * method.c (do_inline_function_hair): Don't touch ++ IDENTIFIER_GLOBAL_VALUE. ++ * init.c (build_offset_ref): If name isn't an identifier, just ++ return it. ++ * spew.c (yylex): Handle PTYPENAME like TYPENAME. ++ ++ * typeck.c (get_delta_difference): Do adjust for conversions to ++ and from virtual base. ++ ++Wed Feb 25 09:51:29 1998 Jason Merrill ++ ++ * typeck.c (get_delta_difference): Give hard error for conversion ++ from virtual base. ++ ++ * cp-tree.h: Tweak formatting. ++ ++Wed Feb 25 00:35:33 1998 Jason Merrill ++ ++ * decl.c (push_namespace): Handle redeclaration error. ++ ++ * cp-tree.h (IDENTIFIER_NAMESPACE_VALUE): New macro. ++ (IDENTIFIER_NAMESPACE_BINDINGS): New macro. ++ (NAMESPACE_BINDING): New macro. ++ (IDENTIFIER_GLOBAL_VALUE): Use NAMESPACE_BINDING. ++ * *.c: Use them. ++ ++ * pt.c (push_template_decl): Use innermost_args. ++ ++ * decl.c (get_unique_name): Tweak from earlier in the name. ++ ++Tue Feb 24 22:15:04 1998 Martin von Loewis ++ ++ * cp-tree.def: Add CPLUS_BINDING node. ++ * cp-tree.h (tree_binding): New struct. ++ (BINDING_SCOPE, BINDING_VALUE): New macros. ++ (current_namespace, global_namespace): Declare extern. ++ (struct lang_decl_flags): New field in_namespace. ++ (DECL_NAMESPACE_USING, DECL_NAMESPACE_USERS): New macros. ++ (DECL_NAMESPACE, SET_DECL_NAMESPACE): New macros. ++ (TREE_INDIRECT_USING): New macro. ++ * decl2.c (current_namespace, global_namespace): Declare. The ++ value is a NAMESPACE_DECL now, not a TREE_LIST. ++ (is_namespace_ancestor, namespace_ancestor): New static functions. ++ (add_using_namespace, ambiguous_decl): Likewise. ++ (lookup_using_namespace): New support function for lookup_name. ++ (qualified_lookup_using_namespace): New support function for ++ do_scoped_id and lookup_namespace_name. ++ (get_namespace_id): Mark as obsolete. ++ (current_namespace_id): Likewise. ++ (do_namespace_alias): Implement. ++ (do_using_directive): Implement as call to add_using_namespace. ++ * decl.c (binding_for_name): New function. ++ (push_namespace, pop_namespace): Implement. ++ (push_decl): Don't install a FUNCTION_DECL in the global branch. ++ (lookup_namespace_name): Implement using qualified lookup. ++ (lookup_name_real): For global scoping, lookup in ++ global_namespace. For namespace scoping, lookup in given ++ namespace. For unscoped lookup, iterate over namespace, ++ considering using directives. ++ (init_decl_processing): Initialize global_namespace. ++ (grokvardecl): Build assembler name as static name for globals. ++ (grokdeclarator): Remove old namespace mangling. ++ (xref_tag): When installing a global binding for the ++ tag, make sure we have an identifier. ++ * method.c (build_overload_nested_name): Mangle namespaces. ++ (build_qualified_name): Likewise. ++ (build_decl_overload_real): Likewise. ++ * lex.c (build_lang_decl): Set namespace for new declaration to ++ current_namespace. ++ (do_scoped_id): Find global names in global or current ++ namespace, or using qualified namespace lookup, depending on ++ context. ++ * init.c (build_member_call): When scope is namespace, use ++ build_x_function_call instead. ++ (build_offset_ref): When scope is namespace, collapse processing ++ to lookup_namespace_name instead. ++ * error.c (dump_decl): Support NAMESPACE_DECL. ++ * decl.c (pushdecl): Bind globals to current namespace. ++ (push_overloaded_decl): Likewise. ++ (lookup_tag): Likewise. ++ (lookup_name_current_level): Likewise. ++ (xref_tag): Likewise. ++ (start_function): Likewise. ++ * lex.c (do_identifier): Likewise. ++ (identifier_typedecl_value): Likewise. ++ (real_yylex): Likewise. ++ * method.c (do_inline_function_hair): Likewise. ++ * parse.y (unscoped): Likewise. ++ * pt.c (check_explicit_specialization): Likewise. ++ (lookup_template_class): Likewise. ++ * rtti.c (call_void_fn): Likewise. ++ * sig.c (build_sigtable): Likewise. ++ * ptree.c (lang_print_xnode): New function. ++ ++Tue Feb 24 01:40:24 1998 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Don't instantiate if pedantic ++ and the args use template parms. ++ ++ * pt.c (push_tinst_level): If the instantiation uses template parms, ++ fail silently. ++ * decl.c (xref_basetypes): Do call complete_type for basetypes ++ that involve template parameters. ++ ++Tue Feb 24 00:36:43 1998 Jason Merrill ++ ++ * typeck2.c (process_init_constructor): Fix labeled init check. ++ ++Mon Feb 23 05:08:55 1998 Jason Merrill ++ ++ * pt.c, call.c, decl.c, method.c, cp-tree.h: Remove unused NARGS ++ argument to tsubst and friends. ++ ++ * pt.c (tsubst, FUNCTION_DECL): Tidy. ++ ++ * typeck.c (build_x_function_call): Handle static member function ++ templates like non-templates. Handle friend templates like normal ++ function templates. ++ * pt.c (tsubst, *_PARM): Don't use orig_level. ++ (get_bindings): Don't call add_to_template_args. ++ (instantiate_template): Likewise. ++ (tsubst, FUNCTION_DECL): Call add_to_template_args as appropriate. ++ * ptree.c (print_lang_type): Print index/level for template parms. ++ ++Mon Feb 23 02:52:29 1998 Mark Mitchell ++ ++ * Make-lang.in (cc1plus): Note that cc1plus depends on ++ cp/cp-tree.h and cp/cp-tree.def. ++ ++ * cp-tree.def (TEMPLATE_CONST_PARM): Remove. ++ (TEMPLATE_PARM_INDEX): New tree code, used to indicate a ++ position in a template parameter list. ++ * cp-tree.h (template_parm_index): New structure, used as the tree ++ structure for a TEMPLATE_PARM_INDEX. ++ (TEMPLATE_PARM_IDX): New macro. ++ (TEMPLATE_PARM_LEVEL): Likewise. ++ (TEMPLATE_PARM_DESCENDANTS): Likewise. ++ (TEMPLATE_PARM_ORIG_LEVEL): Likewise. ++ (TEMPLATE_PARM_DECL): Likewise. ++ (TEMPLATE_TYPE_PARM_INDEX): Likewise. ++ (TEMPLATE_TYPE_ORIG_LEVEL): Likewise. ++ (TEMPLATE_TYPE_DECL): Likewise. ++ (TEMPLATE_CONST_IDX): Remove. ++ (TEMPLATE_CONST_LEVEL): Likewise. ++ (TEMPLATE_CONST_SET_INFO): Likewise. ++ (TEMPLATE_TYPE_SET_INFO): Likewise. ++ (TEMPLATE_TYPE_IDX): Redefine in terms of TEMPLATE_PARM_INDEX ++ node. ++ (TEMPLATE_TYPE_LEVEL): Likewise. ++ * decl.c (decls_match): Call comp_template_parms, rather than ++ expanding it inline. ++ (duplicate_decls): If two template declarations are being merged, ++ then their TEMPLATE_INFOs should be merged as well. ++ (grokfndecl): Save template-id information when declaring a friend ++ with explicit template arguments. Pass arguments to ++ check_explicit_specialization via correct convention; at some ++ point check_explicit_specialization changed, but these call-sites ++ did not. ++ (grokdeclarator): Tidy up slightly. ++ * decl2.c (check_classfn): Tidy up slightly. Don't assume that ++ two template functions with the same DECL_ASSEMBLER_NAME the same, ++ since the names are not yet mangled. ++ * error.c (dump_decl): Use TEMPLATE_PARM_INDEX instead of ++ TEMPLATE_CONST_PARM. ++ (dump_expr): Likewise. Use the TEMPLATE_PARM_DECL to get at the ++ decl for a non-type parameter, rather than printing `'. ++ * friend.c (is_friend): Handle TEMPLATE_DECL friends. ++ (do_friend): Deal with template friends. ++ * lex.c (do_pending_inlines): Call ++ maybe_begin_member_template_processing, rather than ++ conditionally calling begin_member_template_processing. ++ (process_next_inline): Likewise. Call ++ maybe_end_member_template_processing, rather than ++ conditionally calling end_member_template_processing. ++ (do_pending_defargs): Likewise. ++ (do_identifier): Use TEMPLATE_PARM_INDEX instead of ++ TEMPLATE_CONST_PARM. ++ * method.c (build_mangled_template_parm_index): New function. ++ (build_overload_value): Use it. ++ (build_overload_name): Likewise. ++ * pt.c (finish_member_template_decl): Allow friend declarations. ++ (template_class_depth): New function. ++ (is_member_template): Rename, and modify, to become... ++ (is_member_or_friend_template): New function. ++ (end_member_template_processing): Rename, and modify, to become... ++ (maybe_end_member_template_processing). ++ (build_template_parm_index): New function. ++ (reduce_template_parm_level): New function. ++ (process_template_parm): Modify to use build_template_parm_index. ++ (push_template_decl): Deal with friend templates. ++ (uses_template_parms): Use TEMPLATE_PARM_INDEX instead of ++ TEMPLATE_CONST_PARM. ++ (tsubst_friend_function): New function. ++ (instantiate_class_template): Generate the DECL_FRIENDLIST ++ for a new instantiation by using tsubst_friend_function rather ++ than just tsubst. ++ (tsubst): Don't tsubst into a type which is a TEMPLATE_DECL. ++ Use TEMPLATE_PARM_INDEX instead of TEMPLATE_CONST_PARM, and the ++ appropriate new macros. Use reduce_template_parm_level to ++ generate lower-level template parameters. Handle tsubst'ing into ++ TEMPLATE_DECLS that declare TEMPLATE_TEMPLATE_PARMS. Don't forget ++ to tsubst the DECL_CONTEXT and DECL_CLASS_CONTEXT of newly created ++ templates. Similarly for the template parameters for a new ++ template. ++ (tsubst_copy): Tidy up slightly. Use TEMPLATE_PARM_INDEX instead ++ of TEMPLATE_CONST_PARM. Handle TYPE_DECLs by tsubsting into them. ++ (unify): Use TEMPLATE_PARM_INDEX instead of TEMPLATE_CONST_PARM. ++ (get_bindings): Call add_to_template_args if necessary. ++ (instantiate_decl): Handle instantiations of friend templates. ++ * search.c (lookup_field_1): Don't treat the TYPE_FIELDS of a ++ TEMPLATE_TYPE_PARM as a list of fields; it's not! ++ * spew.c (yylex): Do a little manual constant propagation to ++ clarify the code. ++ ++Sun Feb 22 19:53:29 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * error.c: Include sys/types.h. ++ ++Thu Feb 19 14:49:09 1998 Jeffrey A Law (law@cygnus.com) ++ ++ * method.c (build_mangled_name): Start CPP directives in column zero. ++ ++Thu Feb 19 10:36:48 1998 Jason Merrill ++ ++ * typeck2.c (process_init_constructor): Sorry about non-trivial ++ labeled initializers. ++ * parse.y (initlist): Re-enable labeled initializers. ++ ++Thu Feb 19 10:15:55 1998 Kriang Lerdsuwanakij ++ ++ * pt.c (coerce_template_parms): Add a new parameter, is_tmpl_parm, ++ all callers changed. Rely on the new parameter instead of arg ++ being a TREE_LIST when determine whether we are working inside ++ template template parameter. Clean up is_type test. ++ ++Thu Feb 19 10:04:12 1998 Jason Merrill ++ ++ * cvt.c (cp_convert_to_pointer): Preserve TREE_CONSTANT. ++ * typeck2.c (initializer_constant_valid_p): Allow conversions ++ between pointers and references. ++ ++1998-02-19 Brendan Kehoe ++ ++ * typeck.c (build_unary_op): Only warn about incr/decr a pointer ++ if pedantic || warn_pointer_arith. ++ ++Thu Feb 19 09:37:21 1998 Kriang Lerdsuwanakij ++ ++ * pt.c (unify): Handle TEMPLATE_DECL. ++ ++1998-02-18 Brendan Kehoe ++ ++ * cp-tree.h (strip_attrs): Remove decl. ++ ++1998-02-18 Doug Evans ++ ++ * decl.c (duplicate_decls): Call merge_machine_decl_attributes. ++ Update olddecl's attributes too. ++ (strip_attrs): Remove function. ++ * typeck.c (common_type): Call merge_machine_type_attributes. ++ ++Tue Feb 17 14:07:52 1998 Mark Mitchell ++ ++ * parse.y (initdcl0_innards): New grammar symbol. ++ (nomods_initdecls, nomods_initdcl0): Change type from itype to ++ none, since the resulting value is never used. ++ (parse_decl): New function. ++ (datadef): Remove redundant actions. ++ (initdcl0, notype_initdcl0, nomods_initdcl0): Use initdcl0_innards. ++ * parse.c: Regenerated. ++ ++Tue Feb 17 11:54:16 1998 Jason Merrill ++ ++ * parse.y (simple_stmt): Use getdecls() to check for decl. ++ ++Sat Feb 14 11:50:51 1998 Manfred Hollstein ++ ++ * Make-lang.in (DEMANGLER_INSTALL_NAME, DEMANGLER_CROSS_NAME): New ++ macros. ++ (c++.install-common): Install c++filt properly as native or as cross ++ variant. ++ (c++.uninstall): Add c++filt. ++ ++Fri Feb 13 14:55:37 1998 Jason Merrill ++ ++ * call.c (standard_conversion): Fix multi-level ptr conversions. ++ ++Fri Feb 13 14:06:22 1998 Mike Stump ++ ++ * init.c (build_new): Propagate error_mark_node up. ++ ++Fri Feb 13 13:24:32 1998 Jason Merrill ++ ++ * parse.y (simple_stmt): If the condition isn't a declaration, ++ start the controlled block after the test. ++ ++Fri Feb 13 02:26:10 1998 Andreas Schwab ++ ++ * call.c (build_over_call): Convert builtin abs, labs and fabs to ++ tree-codes. ++ * decl.c (init_decl_processing): Re-enable abs, labs and fabs as ++ builtins. ++ ++Fri Feb 13 01:36:42 1998 Jason Merrill ++ ++ * call.c (standard_conversion): A BASE_CONV replaces an RVALUE_CONV. ++ ++Fri Feb 13 00:21:59 1998 Jason Merrill ++ ++ * cp-tree.h: Add access_protected_virtual_node. ++ * class.c (init_class_processing): Initialize it. ++ * decl.c (xref_basetypes): Use it. ++ * parse.y (base_class_access_list): Likewise. ++ ++ * Make-lang.in (DEMANGLER_PROG): Add $(exeext). ++ (c++.install-common): Install c++filt. ++ ++Thu Feb 12 12:46:51 1998 Benjamin Kosnik ++ ++ * decl.c (shadow_tag): Give error for typedef-ing built-in types. ++ ++Wed Feb 11 23:28:05 1998 Mark Mitchell ++ ++ * call.c (reference_binding): Use comptypes when comparing ++ TYPE_MAIN_VARIANTS to handle non-canonical array/index types. ++ ++Wed Feb 11 16:42:04 1998 Mark Mitchell ++ ++ * tree.c (is_overloaded_fn): Use really_overloaded_fn. ++ (really_overloaded_fn): Move check here from is_overloaded_fn. ++ (get_first_fn): Use really_overloaded_fn and is_overloaded_fn. ++ ++Wed Feb 11 15:54:18 1998 Mark Mitchell ++ ++ * typeck.c (build_ptrmemfunc): Type-check pointer-to-member ++ conversions. ++ ++Mon Feb 9 22:23:31 1998 Mark Mitchell ++ ++ * cp-tree.h (push_template_decl): Return the decl passed in, or an ++ equivalent duplicate. ++ * decl.c (pushtag): Use the return value from push_template_decl. ++ (duplicate_decls): When duplicating a template declaration, merge ++ the DECL_TEMPLATE_RESULTs as well. ++ (make_implicit_typename): Don't try to dive into typename types to ++ find a context for making a new implicit typename. ++ (start_decl): Use the return value from push_template_decl. ++ (grokdeclarator): Complain about declarations list `const operator ++ int'. Since we don't correctly handle in-class initializations of ++ non-static data members, complain about this (now illegal) ++ practice. Issue an error for initializations of non-const statics ++ since that is illegal as well, and since we don't handle that case ++ correctly either. ++ (start_function): Use the return value from push_template_decl. ++ (start_method): Likewise. ++ * decl2.c (grokfield): Likewise. Since the change to ++ grokdeclarator ensures that all initialized fields are in fact ++ static, remove a redundant test for TREE_PUBLIC. ++ * parse.y (initlist): Disable labeled initializers since they do ++ not work as per the documentation, and since they do not use the ++ same syntax as the C front end. ++ * pt.c (push_template_decl): Return the decl passed in, or an ++ equivalent duplicate. ++ (lookup_template_class): When searching in a nested context, ++ use the right arguments. ++ (uses_template_parms): Handle the DECL_INITIAL for a CONST_DECL. ++ * typeck.c (build_component_ref): Assign the correct type to the ++ result of build_vfn_ref. ++ ++Tue Feb 10 23:56:46 1998 Jason Merrill ++ ++ * pt.c (convert_nontype_argument): Fix typo. ++ (check_explicit_specialization): Allow old-style specialization ++ of class template members. ++ ++Tue Feb 10 20:36:52 1998 Jason Merrill ++ Manfred Hollstein ++ ++ * decl.c (grokdeclarator): Use DECL_USE_TEMPLATE instead ++ when deciding to override DECL_ASSEMBLER_NAME. ++ ++Tue Feb 10 15:30:55 1998 Andrew MacLeod ++ ++ * decl2.c (lang_f_options): Add -fsquangle to option processing list. ++ * cp-tree.h (flag_do_squangling): Add declaration. ++ * lang-options.h: Add -fsquangle and -fno-squangle. ++ * method.c: Add macros and static variables for squangling. ++ (build_overload_name): Rename to build_mangled_name, add logic for B ++ compression, and split into process_modifiers and ++ process_overload_item. ++ (process_modifiers): New function, to handle constant, reference, ++ and pointer types. ++ (process_overload_item): New function, handles issue of type codes. ++ (build_overload_name): New function, start squangling and call ++ build_mangled_name. ++ (ALLOCATE_TYPEVEC, DEALLOCATE_TYPEVEC): Remove macro and expand inline. ++ (start_squangling): New function to initialize squangling structs. ++ (end_squangling): New function to destroy squangling structs. ++ (nrepeats): Rename variable to Nrepeats. ++ (issue_nrepeats): New function for issuing 'n' type repeats. ++ (check_ktype): New function to check for type K name compression. ++ (build_overload_nested_name): Add a check for K name compression. ++ (build_qualified_name): Add a check for K name compression and don't ++ use DECL_ASSEMBLER_NAME when squangling is on. ++ (check_btype): New function, checks for B type compression. ++ (build_static_name, build_decl_overload_real): Initiate squangling. ++ (build_typename_overload, build_overload_with_type): Initiate ++ squangling ++ ++Sun Feb 8 23:47:38 1998 scott snyder ++ ++ * method.c (make_thunk): Avoid name buffer overflow. ++ ++Sat Feb 7 16:48:54 1998 Jason Merrill ++ ++ * pt.c (instantiate_decl): Call cp_finish_decl for vars even if we ++ don't define them yet. ++ ++ * parse.y (nomods_initdcl0): Add constructor_declarator case. ++ ++Fri Feb 6 21:32:25 1998 Richard Kenner ++ ++ * config-lang.in (diff_excludes): Use basename only. ++ ++Thu Feb 5 19:10:40 1998 Jason Merrill ++ ++ * tinfo2.cc: Add tinfo for signed char. ++ ++Thu Feb 5 14:38:23 1998 Mike Stump ++ ++ * search.c (compute_access): Handle protected constructors in derived ++ classes as accessible. ++ ++Wed Feb 4 01:26:49 1998 Jason Merrill ++ ++ * expr.c (cplus_expand_expr, PCC_STATIC_STRUCT_RETURN code): ++ Call convert_from_reference sooner. ++ ++Tue Feb 3 23:50:52 1998 Mark Mitchell ++ ++ * cvt.c (ocp_convert): Obtain the constant values from constant ++ decls even if the destination type is the same as the type of the ++ decl. ++ ++ * decl2.c (finish_file): Make sure that static inlines with ++ definitions are not marked DECL_EXTERNAL before returning. ++ ++Tue Feb 3 22:43:42 1998 Jason Merrill ++ ++ * decl.c: Lose arg_looking_for_template. ++ (lookup_name_real): Likewise. ++ * parse.y: Lose processing_template_arg, template_arg1. ++ (primary): Likewise. ++ * spew.c (yylex): Set lastiddecl for PTYPENAMEs, too. ++ ++Tue Feb 3 22:04:01 1998 Kriang Lerdsuwanakij ++ ++ * error.c (dump_decl): Fix type of default arguments for template ++ template parameters and nontype template parameters. ++ * parse.y (template_parm): Handle invalid default template ++ template arguments here. ++ ++ * parse.y (template_parm): Use template_arg instead of PTYPENAME ++ for default template template argument. ++ * pt.c (coerce_template_parms): Merge default template argument ++ codes. Can treat RECORD_TYPE as template name if it is implicitly ++ created. Fix argument index in error message. ++ * typeck.c (comptypes): Merge template argument comparison codes in ++ TEMPLATE_TEMPLATE_PARM and RECORD_TYPE. ++ ++Tue Jan 6 01:42:44 1998 Mumit Khan ++ ++ * lex.c (file_name_nondirectory): Also check for '/'. ++ ++Mon Feb 2 11:24:22 1998 Mark Mitchell ++ ++ * parse.y (primary): Deal with statement-expressions in ++ templates. ++ * pt.c (tsubst_copy): Handle BIND_EXPR. ++ * tree.c (mapcar): Likewise. ++ ++ * call.c (add_template_candidate_real): Pass extra parameter to ++ fn_type_unification. ++ * cp-tree.h (fn_type_unification): Add parameter. ++ * pt.c (fn_type_unification): Add additional parameter to deal with ++ static member functions. ++ (get_bindings): Deal with static member functions. ++ ++ * cp-tree.h (DECL_NONSTATIC_MEMBER_FUNCTION_P): New macro. ++ (revert_static_member_fn): Declare. ++ * decl.c (revert_static_member_fn): Remove declaration. Change ++ linkage from internal to external. ++ (cp_finish_decl): Deal with virtual functions in classes local to ++ template functions. ++ * decl2.c (finish_file): Don't forget to emit increment/decrement ++ expressions in initializers for file-scope variables. ++ * parse.y (typename_sub2): If the typename doesn't names a ++ template, rather than a type, issue an error message. ++ * pt.c (check_explicit_specialization): Handle specializations of ++ static member functions. ++ (coerce_template_parms): Handle offset references to lists of ++ member functions. ++ * search.c (note_debug_info_needed): Don't crash when handed a ++ type which is being defined. ++ * typeck.c (complete_type): Don't crash when handed NULL_TREE; ++ that can happen with some illegal code. ++ ++Mon Feb 2 00:57:38 1998 Kaveh R. Ghazi ++ ++ * call.c (user_harshness): Initialize `code' to 0. ++ (build_method_call): Initialize `candidates', `cp' and `len' to 0. ++ (null_ptr_cst_p): Add parentheses around && within ||. ++ (standard_conversion): Likewise. ++ (z_candidate): Likewise. ++ (build_user_type_conversion_1): Initialize `args' to NULL_TREE. ++ (build_object_call): Likewise for `mem_args'. ++ (build_new_op): Likewise for `mem_arglist'. Add `return' from ++ default case in enumeration switch. ++ ++ * class.c (build_vtable_entry): Add explicit braces to avoid ++ ambiguous `else'. ++ (build_class_init_list): Likewise. ++ (finish_struct_1): Initialize `width' to 0. ++ (instantiate_type): Initialize `name' to NULL_TREE. Add ++ explicit braces to avoid ambiguous `else'. ++ ++ * cvt.c (convert_to_aggr): Add explicit braces to avoid ambiguous ++ `else'. ++ ++ * decl.c (grok_reference_init): Eliminate unused parameter, all ++ callers changed. ++ (record_builtin_type): Initialize `tdecl' to NULL_TREE. ++ (init_decl_processing): Initialize `vb_off_identifier' to NULL_TREE. ++ (cp_finish_decl): Initialize `ttype' to NULL_TREE. ++ (grokdeclarator): Add parentheses around && within ||. Add ++ explicit braces to avoid ambiguous `else'. ++ (grokparms): Initialize `type' to NULL_TREE. ++ (xref_tag): Remove unused label `just_return'. ++ (finish_enum): Initialize `minnode' and `maxnode' to NULL_TREE. ++ (finish_function): Initialize `cond' and `thenclause' to NULL_TREE. ++ (hack_incomplete_structures): Add parentheses around assignment ++ used as truth value. ++ ++ * decl2.c (coerce_delete_type): Hide definition of `e3'. ++ ++ * error.c: Include . ++ (dump_expr): Change the type of `i' to size_t. Remove unused ++ label `error'. ++ ++ * except.c (init_exception_processing): Remove unused variable `d'. ++ (expand_throw): Likewise for `label'. ++ ++ * friend.c (add_friends): Add explicit braces to avoid ambiguous ++ `else'. ++ ++ * init.c (sort_member_init): Initialize `last_field' to NULL_TREE. ++ (sort_base_init): Likewise for `binfo'. ++ (expand_member_init): Likewise for `rval'. ++ (build_member_call): Add parentheses around assignment used as ++ truth value. ++ (build_offset_ref): Add explicit braces to avoid ambiguous `else'. ++ (build_new): Initialize `nelts' to NULL_TREE. Initialize ++ `old_immediate_size_expand' to 0. ++ (build_new_1): Initialize `nelts' and `alloc_node' to NULL_TREE. ++ (build_vec_delete_1): Remove unused variable `block'. ++ (expand_vec_init): Initialize `itype' to NULL_TREE. ++ ++ * lex.c: Include if we don't have . Protect ++ declaration of `index' and `rindex' with autoconf macros. ++ (reinit_parse_for_expr): Remove unused variables ++ `look_for_semicolon' and `look_for_lbrac'. ++ (cons_up_default_function): Initialize `args' to NULL_TREE. ++ (readescape): Initialize `firstdig' to 0. ++ (real_yylex): Add parentheses around assignment used as truth value. ++ ++ * method.c: Include if we don't have . ++ Protect declaration of `index' with autoconf macro. ++ ++ * parse.y (primary): Add explicit braces to avoid ambiguous `else'. ++ Initialize `type' to NULL_TREE. ++ (structsp): Remove unused variable `id'. ++ ++ * pt.c (coerce_template_parms): Add explicit braces to avoid ++ ambiguous `else'. ++ (lookup_template_class): Initialize `template' to NULL_TREE. ++ (instantiate_class_template): Remove unused variable `name' and `e'. ++ (tsubst): Likewise for `i'. Initialize `last' to NULL_TREE. ++ (do_poplevel): Initialize `saved_warn_unused' to 0. ++ (type_unification): Remove unused varable `parm'. ++ (unify): Likewise for `j'. ++ ++ * repo.c (init_repo): Add parentheses around assignment used as ++ truth value. ++ (finish_repo): Remove unused varable `p'. ++ ++ * search.c (get_binfo): Initialize `type' to NULL_TREE. ++ (get_base_distance): Likewise. ++ (lookup_field): Initialize `rval_binfo_h', `type', `basetype_path' ++ and `new_v' to NULL_TREE. ++ (lookup_fnfields): Likewise for `rval_binfo_h'. ++ (breadth_first_search): Add parentheses around assignment used as ++ truth value. ++ (get_template_base): Initialize `type' to NULL_TREE. ++ ++ * sig.c (append_signature_fields): Initialize `last_mfptr' to ++ NULL_TREE. ++ (build_signature_table_constructor): Likewise for ++ `last_rhs_field', `pfn' and `vt_off'. ++ (build_sigtable): Likewise for `init'. ++ ++ * tree.c (break_out_calls): Initialize `t2' to NULL_TREE. ++ (propagate_binfo_offsets): Likewise for `delta'. ++ (hash_tree_cons): Initialize hashcode to 0. ++ (can_free): Likewise for `size'. ++ (cp_tree_equal): Add explicit braces to avoid ambiguous `else'. ++ ++ * typeck.c (convert_sequence): Hide prototype. ++ (common_type): Add explicit braces to avoid ambiguous `else'. ++ (comp_target_types): Likewise. ++ (build_x_function_call): Initialize `ctypeptr' to NULL_TREE. ++ (build_function_call_real): Add explicit braces to avoid ambiguous ++ `else'. ++ (convert_arguments): Initialize `called_thing' to 0. ++ (convert_for_initialization): Initialize `savew' and `savee' to 0. ++ ++ * typeck2.c (incomplete_type_error): Initialize `errmsg' to 0. ++ (digest_init): Initialize `old_tail_contents' to NULL_TREE. ++ (build_x_arrow): Likewise for `last_rval'. ++ ++ * xref.c (GNU_xref_decl): Initialize `cls' to 0. ++ ++Sun Feb 1 12:45:34 1998 J"orn Rennecke ++ ++ * decl.c (init_decl_processing): Use set_sizetype. ++ * decl2.c (sizetype): Don't declare. ++ * typeck.c (c_sizeof): Convert result of *_DIV_EXPR to sizetype. ++ (c_sizeof_nowarn, build_binary_op_nodefault): Likewise. ++ (build_component_addr, unary_complex_lvalue): Likewise. ++ * rtti.c (expand_class_desc): Likewise. ++ * class.c (get_vfield_offset): Likewise. ++ ++Thu Jan 29 10:39:30 1998 Mark Mitchell ++ ++ * pt.c (convert_nontype_argument): Move check for is_overloaded_fn ++ early to avoid bogus error. Handle overloaded function ++ names provided as template arguments correctly. ++ (coerce_template_parms): Don't mishandle overloaded functions when ++ dealing with template template parameters. ++ (lookup_template_class): Issue an error message, rather than ++ crashing, when the TYPE_DECL provided is not a template type. ++ ++Wed Jan 28 23:14:44 1998 Jason Merrill ++ ++ * class.c (instantiate_type): Don't just return a known type if ++ it's wrong. ++ ++Wed Jan 28 11:04:07 1998 Mark Mitchell ++ ++ * class.c (instantiate_type): Remove handling of FUNCTION_DECL ++ since that code could never be reached. ++ ++ * error.c (dump_decl): Avoid aborting in the midst of printing an ++ error message about an illegal template declaration. ++ ++ * parse.y (structsp): Print an error message, rather than crashing, ++ when a class-head does not name a class. ++ ++ * pt.c (convert_nontype_argument): Allow REAL_TYPE and COMPLEX_TYPE ++ template arguments as a g++ extension. ++ ++ * cp-tree.def (ALIGNOF_EXPR): New tree code. ++ * decl2.c (grok_alignof): If processing_template_decl, just store ++ the expression. ++ * typeck.c (c_alignof): Likewise. ++ * decl2.c (build_expr_from_tree): Handle ALIGNOF_EXPR. ++ * error.c (dump_expr): Likewise. ++ * pt.c (tsubst_copy): Likewise. ++ * tree.c (cp_tree_equal): Likewise. ++ * pt.c (uses_template_parms): Correctly determine whether or not a ++ SIZEOF_EXPR/ALIGNOF_EXPR uses template parameters so that constant ++ folding can be done. ++ ++ * cp-tree.h (grok_enum_decls): Remove type parameter. ++ * decl.c (grok_enum_decls): Likewise. ++ * decl2.c (grok_x_components): Call grok_enum_decls ++ unconditionally, since it will do nothing if there is no ++ current_local_enum. Use the new calling sequence. ++ * pt.c (tsubst_enum): Use the new calling sequence for ++ grok_enum_decls. ++ ++ * decl.c (start_function): Make member functions of local classes ++ in extern inline functions have comdat linkage here... ++ (grokdeclarator): Rather than here. ++ ++Wed Jan 28 10:55:47 1998 Jason Merrill ++ ++ * pt.c (convert_nontype_argument): Use decl_constant_value. ++ ++Tue Jan 27 16:42:21 1998 Mark Mitchell ++ ++ * call.c (add_template_candidate_real): New function. ++ (add_template_candidate): Use it. ++ (add_template_conv_candidate): Likewise. ++ (joust): Pass extra argument to more_specialized. ++ * class.c (instantiate_type): Handle a single FUNCTION_DECL. ++ (is_local_class): Remove. ++ (finish_struct): Check TI_PENDING_SPECIALIZATION_FLAG. ++ * cp-tree.h (is_local_class): Remove. ++ (perform_array_to_pointer_conversion): Likewise. ++ (finish_member_template_decl): Add. ++ (check_explicit_specialization): Return a tree, not an int. ++ (more_specialized): Take additional argument. ++ (get_bindings): Likewise. ++ (TI_PENDING_SPECIALIZATION_FLAG): New macro. ++ * cvt.c (perform_qualification_conversions): Use comp_ptr_ttypes. ++ (perform_array_to_pointer_conversion): Remove. ++ * decl.c (saved_scope): Add processing_specialization, ++ processing_explicit_instantiation fields. ++ (maybe_push_to_top_level): Save them. ++ (pop_from_top_level): Restore them. ++ (grokfndecl): Use new return value from ++ check_explicit_specialization. ++ (start_decl): Don't check flag_guiding_decls before pushing ++ decls. ++ (cp_finish_decl): Remove previous (bogus) change. ++ (grok_declarator): Use decl_function_context rather than ++ is_local_class. ++ * decl2.c (finish_file): Pass extra argument to get_bindings. ++ (build_expr_from_tree): Let build_x_component_ref check ++ validity of arguments rather than doing it here. ++ * lex.c (cons_up_default_function): Remove code fooling with ++ processing_specialization, processing_explicit_instantiation ++ flags, as that is now done in {maybe_push_top,pop_from}_top_level. ++ * method.c (build_overload_identifier): Mangle local classes in ++ template functions correctly. ++ * parse.y (finish_member_template_decl): Move to pt.c. ++ * pt.c (finish_member_template_decl): Moved here from parse.y. ++ (print_candidates): New function. ++ (determine_specialization): Change interface. Properly look for ++ most specialized versions of template candidates. ++ (check_explicit_specialization): Fully process explicit ++ instantiations. ++ (push_template_decl): Avoid looking at CLASSTYPE fields in ++ FUNCTION_DECLS. ++ (determine_overloaded_function): Remove. ++ (convert_nontype_argument): Change name from ++ convert_nontype_parameter. Use determine_overloaded_function ++ instead of instantiate_type. ++ (mangle_class_name_for_template): Handle type contexts as well as ++ function contexts. ++ (classtype_mangled_name): Likewise. ++ (lookup_template_class): Likewise. ++ (tsubst): Likewise. ++ (more_specialized): Take explicit template arguments as a ++ parameter. ++ (most_specialized): Likewise. ++ (get_bindings): Likewise. Check that return types match before ++ proclaiming a function a match. ++ (do_decl_instantiation): Remove code searching for function to ++ instantiate; that is now done in check_explicit_specialization. ++ (add_maybe_template): Pass extra argument to get_bindings. ++ * tree.c (really_overloaded_fn): Use is_overloaded_fn to simplify ++ implementation. ++ * typeck.c (build_component_ref): Check for invalid arguments. ++ ++Tue Jan 27 01:44:02 1998 Jason Merrill ++ ++ * expr.c (cplus_expand_expr, AGGR_INIT_EXPR): Don't check that ++ return_target and call_target are equivalent. ++ ++ * pt.c (type_unification_real): Just accept function parms that ++ don't use any template parms. ++ ++Sun Jan 25 03:30:00 1998 Jason Merrill ++ ++ * decl.c (cp_finish_decl): When bailing on a comdat variable, also ++ unset DECL_NOT_REALLY_EXTERN. ++ ++ * parse.y (typename_sub*): Fix std::. ++ ++Sat Jan 24 12:13:54 1998 Jason Merrill ++ ++ * error.c (dump_decl): Fix type default template args. ++ (dump_type): Hand TEMPLATE_DECL off to dump_decl. ++ ++Fri Jan 23 18:34:37 1998 Mumit Khan ++ ++ * lex.c (DIR_SEPARATOR): Define to be '/' if not already defined. ++ (file_name_nondirectory): Use. ++ ++Wed Jan 21 10:29:57 1998 Kriang Lerdsuwanakij ++ ++ * pt.c (coerce_template_parms): Don't access elements of ARGLIST ++ that are not really present. Substitute default arguments in ++ template template arguments. Correctly convert TEMPLATE_DECL to ++ TEMPLATE_TEMPLATE_PARM. ++ (comp_template_args): TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM ++ are no longer treated specially here. ++ * parse.y (template_template_parm): Fix copy error. ++ * decl.c (grokdeclarator): Warn about missing `typename' for nested ++ type created from template template parameters. ++ * parse.y (bad_parm): Likewise ++ ++ * class.c (finish_struct): Handle TEMPLATE_TEMPLATE_PARM. ++ (push_nested_class): Likewise. ++ * cp-tree.def (TEMPLATE_TEMPLATE_PARM): New tree code. ++ * cp-tree.h (DECL_TEMPLATE_TEMPLATE_PARM_P): New macro. ++ (copy_template_template_parm): Declare. ++ * decl.c (arg_looking_for_template): New variable. ++ (lookup_name_real): Handle TEMPLATE_TEMPLATE_PARM. ++ Try to return TEMPLATE_DECL or TEMPLATE_TEMPLATE_PARM ++ node if arg_looking_for_template is nonzero. ++ (pushdecl): Handle TEMPLATE_TEMPLATE_PARM. ++ (grok_op_properties, xref_tag, xref_basetypes): Likewise. ++ (grokdeclarator): Handle TEMPLATE_DECL. ++ * decl2.c (constructor_name_full): Handle TEMPLATE_TEMPLATE_PARM. ++ * error.c (dump_type): Add TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM. ++ (dump_type_prefix, dump_type_suffix): Handle TEMPLATE_TEMPLATE_PARM. ++ (dump_decl): Handle unnamed template type parameters. ++ Handle template template parameters. ++ (dump_function_name): Handle template template parameters. ++ * init.c (is_aggr_typedef, is_aggr_type, get_aggr_from_typedef): ++ Handle TEMPLATE_TEMPLATE_PARM. ++ * method.c (build_template_template_parm_names): New function. ++ (build_template_parm_names): Handle TEMPLATE_DECL. ++ (build_overload_nested_name, build_overload_name): ++ Handle TEMPLATE_TEMPLATE_PARM. ++ * parse.y (maybe_identifier): New nonterminal. ++ (template_type_parm): Use it. ++ (template_template_parm, template_arg1): New nonterminal. ++ (template_parm): Add template_template_parm rules. ++ (template_arg): Set processing_template_arg. ++ (template_arg1): Rules moved from template_arg. ++ (primary, nonnested_type): Set arg_looking_for_template if we are ++ processing template arguments. ++ * pt.c (begin_member_template_processing): Handle TEMPLATE_DECL. ++ (process_template_parm): Handle template template parameters. ++ (coerce_template_parms, comp_template_args): Likewise. ++ (mangle_class_name_for_template, lookup_template_class): Likewise. ++ (uses_template_parms): Handle TEMPLATE_DECL and ++ TEMPLATE_TEMPLATE_PARM. ++ (current_template_args): Handle TEMPLATE_DECL. ++ (tsubst, tsubst_copy, unify): Handle TEMPLATE_TEMPLATE_PARM. ++ * search.c (dfs_walk, dfs_record_inheritance): ++ Handle TEMPLATE_TEMPLATE_PARM. ++ * tree.c (copy_template_template_parm): New function. ++ (mapcar): Handle TEMPLATE_TEMPLATE_PARM. ++ * typeck.c (comptypes): Handle TEMPLATE_TEMPLATE_PARM. ++ ++Mon Jan 19 22:40:03 1998 Mark Mitchell ++ ++ * decl.c (start_decl): Don't allow duplicate definitions of static ++ data members. ++ ++ * call.c (build_user_type_conversion_1): Handle user-defined ++ template conversion operators correctly. ++ ++ * decl2.c (build_expr_from_tree): Issue an error message if the ++ object in a COMPONENT_REF is a TEMPLATE_DECL. ++ ++ * typeck.c (incomplete_type_error): Handle TEMPLATE_TYPE_PARMs. ++ ++ * class.c (is_local_class): New function. ++ * cp-tree.h (is_local_class): Declare it. ++ (last_tree): Likewise. ++ (begin_tree): Likewise. ++ (end_tree): Likewise. ++ (lookup_template_class): Change prototype. ++ * decl.c (cp_finish_decl): Check for NULL where necessary. ++ Consider FUNCTION_DECLS to declare objects with top-level binding, ++ when calling make_decl_rtl. ++ (grokdeclarator): Give members of local classes internal linkage. ++ (start_function): Remove declaration of last_tree. ++ (finish_function): Set flag_keep_inline_functions around call to ++ rest_of_compilation if we are processing a member function in a ++ local class. ++ (start_method): Call push_template_decl for member functions of ++ local classes in template functions. ++ * decl2.c (import_export_decl): Don't give external linkage to ++ instantiations of templates with internal linkage. ++ * parse.y (last_tree): Remove declaration. ++ (template_type): Pass extra parameter to lookup_template_class. ++ (self_template_type): Likewise. ++ (structsp): Move call to reset_specialization into left_curly. ++ (left_curly): Call reset_specialization, and begin_tree. ++ * pt.c (saved_trees): New variable. ++ (mangle_class_name_for_template): Change prototype. Use ++ additional function context to name local classes in templates ++ correctly. ++ (classtype_mangled_name): Pass the context. ++ (push_template_decl): Handle local classes and templates, and ++ member functions for such classes. ++ (convert_nontype_parameter): Fix handling of pointer-to-member ++ constants. ++ (lookup_template_class): Handle local classes in templates. ++ (tsubst): Likewise. Don't assume that template instantiations ++ have external linkage; pay attention to the template declaration. ++ (mark_decl_instantiated): Likewise. ++ (begin_tree): New function. ++ (end_tree): Likewise. ++ ++ * decl.c (xref_basetypes): Don't call complete_type for basetypes ++ that involve template parameters; that can lead to infinite ++ recursion unnecessarily. ++ ++ * pt.c (register_specialization): Do not register specializations ++ that aren't ready to be registered yet. ++ (check_explicit_specialization): Handle explicit specialization of ++ constructors and destructors. ++ (build_template_decl): New function. ++ (push_template_delc): Handle out-of-class specializations of ++ member templates. ++ ++ * pt.c (check_explicit_specialization): Set up the template ++ information before registering the specialization. ++ (coerce_template_parms): Fix thinko. ++ (tsubst): Handle specializations of member templates correctly. ++ ++ * class.c (finish_struct_methods): Remove calls to ++ check_explicit_specialization from here. ++ (finish_struct): And insert them here. ++ * cp-tree.h (perform_qualification_conversions): New function. ++ (perform_array_to_pointer_conversion): Likewise. ++ (begin_explicit_instantiation): Likewise. ++ (end_explicit_instantiation): Likewise. ++ (determine_specialization): Renamed from ++ determine_explicit_specialization. ++ (comp_template_parms): New function. ++ (processing_explicit_instantiation): New variable. ++ * cvt.c (perform_qualification_conversions): New function. ++ (perform_array_to_pointer_conversion): Likewise. ++ * decl.c (duplicate_decls): Don't consider template functions ++ alike unless they have the same parameters. Refine handling of ++ instantiation/specialization mismatches. ++ (start_decl): Don't call pushdecl for template specializations, ++ since they don't affect overloading. ++ (start_function): Likewise. ++ (grokfndecl): Call check_explicit_specialization a little later. ++ Don't call duplicate_decls for memberm template specializations. ++ (grokdeclarator): Don't update template_count for classes that are ++ themselves specializations. Remove use of `2' as parameter to ++ grokfndecl since that value isn't used. ++ * lex.c (cons_up_default_function): Save and restore ++ processing_explicit_instantiation around calls to grokfield. ++ * parse.y (finish_member_template_decl): New function. ++ (component_decl_1): Use it. ++ (fn.def2): Likewise. ++ (template_arg_list_opt): New nonterminal. ++ (template_type): Use it. ++ (self_template_type): Likewise. ++ (template_id): Likewise. ++ (object_template_id): Likewise. ++ (notype_template_declarator): Likwise. ++ (begin_explicit_instantiation): Likewise. ++ (end_explicit_instantiation): Likewise. ++ (explicit_instantiation): Use them. ++ * pt.c (coerce_template_parms): Add parameters. ++ (processing_explicit_instantiation): New variable. ++ (convert_nontype_parameter): New function. ++ (determine_overloaded_function): Likewise. ++ (begin_explicit_instantiation): Likewise. ++ (end_explicit_instantiation): Likewise. ++ (retrieve_specialization): Likewise. ++ (register_specialization): Likewise. ++ (processing_explicit_specialization): Removed. ++ (determine_specialization): Handle specializations of member ++ functions of template class instantiations. ++ (check_explicit_specialization): Refine to conform to standard. ++ (comp_template_parms): New function. ++ (coerce_template_parms): Call convert_nontype_parameter. ++ (tsubst): Refine handling of member templates. Use ++ register_specialization. ++ (instantiate_template): Use retrieve_specialization. ++ (do_decl_instantiation): Likewise. ++ (instantiate_decl): Likewise. ++ (type_unification): Improve handling of explicit template ++ arguments. ++ * tree.c (mapcar): Return error_mark_node, rather than aborting, ++ on VAR_DECLS, FUNCTION_DECLS, and CONST_DECLS. ++ * typeck.c (build_unary_op): Call determine_specialization, rather ++ than determine_explicit_specialization. ++ ++Mon Jan 19 13:18:51 1998 Jason Merrill ++ ++ * cvt.c (build_up_reference): A TARGET_EXPR has side effects. ++ ++Fri Jan 16 11:40:50 1998 Bruno Haible ++ ++ * error.c (dump_decl): For enum tags, output the tag, not its value. ++ ++1998-01-13 Brendan Kehoe ++ ++ * decl.c (init_decl_processing): Only call init_rtti_processing ++ FLAG_RTTI is set. ++ ++Mon Jan 12 01:35:18 1998 Jason Merrill ++ ++ * init.c (build_new_1): Split out from build_new. ++ (build_new): Just return a NEW_EXPR. ++ * expr.c (cplus_expand_expr): Handle NEW_EXPR. ++ ++ * decl2.c (get_temp_regvar): Tweak. ++ ++ * cp-tree.h (TREE_CALLS_NEW): Comment out. ++ * class.c (resolves_to_fixed_type_p): Remove use. ++ * method.c (build_opfncall): Likewise. ++ * call.c (build_new_op): Likewise. ++ ++Wed Jan 7 23:47:13 1998 Jason Merrill ++ ++ * exception.cc (__eh_alloc, __eh_free): New fns. ++ (__cp_push_exception, __cp_pop_exception): Use them. ++ (__uncatch_exception): Call terminate here if no exception. ++ * except.c (build_terminate_handler): New fn. ++ (expand_start_catch_block): Use it. ++ (expand_exception_blocks): Likewise. ++ (alloc_eh_object): New fn. ++ (expand_throw): Use it. Protect exception init with terminate. ++ * typeck.c (build_modify_expr): Remove code that ignores trivial ++ methods. ++ ++Mon Dec 22 11:36:27 1997 Kaveh R. Ghazi ++ ++ * call.c (add_builtin_candidate): Add default case in enumeration ++ switch. ++ (build_new_op): Likewise. ++ (convert_like): Likewise. ++ * cvt.c (build_expr_type_conversion): Likewise. ++ * tree.c (real_lvalue_p): Likewise. ++ (lvalue_p): Likewise. ++ (cp_tree_equal): Likewise. ++ * typeck.c (comptypes): Likewise. ++ (build_component_ref): Likewise. ++ (build_function_call_real): Likewise. ++ (build_binary_op_nodefault): Likewise. ++ (build_unary_op): Likewise. ++ (build_modify_expr): Likewise. ++ * typeck2.c (initializer_constant_valid_p): Likewise. ++ ++Sun Dec 21 15:59:00 1997 Nick Clifton ++ ++ * decl2.c (lang_decode_option): Add support for -Wunknown-pragmas. ++ ++Thu Dec 18 14:51:50 1997 Mark Mitchell ++ ++ * pt.c (coerce_template_parms): Make sure to digest_init if ++ possible. ++ ++ * decl.c (duplicate_decls): Make the newdecl virtual if the ++ olddecl was, just as is done with other attributes of olddecl. ++ ++Thu Dec 18 14:43:19 1997 Jason Merrill ++ ++ * typeck.c (unary_complex_lvalue): Ignore op0 when taking the ++ address of an OFFSET_REF. ++ ++ * cp-tree.def: Add AGGR_INIT_EXPR. ++ * error.c, tree.c, typeck.c: Replace uses of NEW_EXPR with ++ AGGR_INIT_EXPR where appropriate. ++ * expr.c (cplus_expand_expr): Likewise. Simplify. ++ ++ * decl2.c (finish_file): Remove call to register_exception_table. ++ ++Wed Dec 17 17:08:52 1997 Benjamin Kosnik ++ ++ * pt.c (instantiate_class_template): Don't do injection when ++ processing_template_decl is true, as pollutes current_binding_level ++ for base classes. ++ ++Wed Dec 17 21:17:39 1997 Peter Schmid ++ ++ * pt.c (maybe_fold_nontype_arg): Add prototype. ++ ++Tue Dec 16 10:31:20 1997 Jason Merrill ++ ++ * tree.c (mapcar): Handle TRY_CATCH_EXPR et al. ++ * error.c (dump_expr): Likewise. ++ ++Mon Dec 15 12:22:04 1997 Jason Merrill ++ ++ * typeck.c (build_function_call_real): Remove "inline called before ++ definition" pedwarn. ++ ++ * pt.c (coerce_template_parms): Use maybe_fold_nontype_arg. ++ ++Sun Dec 14 22:34:20 1997 Jason Merrill ++ ++ * cvt.c (cp_convert_to_pointer): Fix base conversion of pm's. ++ ++ * pt.c (type_unification_real): Change __null to type void* with ++ a warning. ++ ++Sun Dec 14 20:38:35 1997 Mark Mitchell ++ ++ * call.c (implicit_conversion): Don't call ++ build_user_type_conversion_1 with a NULL expr, since it will ++ crash. ++ ++ * pt.c (unify): Don't try to unify array bounds if either array is ++ unbounded. ++ ++Fri Dec 12 16:09:14 1997 Jason Merrill ++ ++ * errfn.c (cp_pedwarn, cp_pedwarn_at, cp_error_at, cp_warning_at): ++ Replace extern decls with casts. ++ ++ * decl.c (expand_start_early_try_stmts): Don't mess with a sequence. ++ Update last_parm_cleanup_insn. ++ (store_after_parms): Remove. ++ * cp-tree.h: Adjust. ++ ++Thu Dec 11 22:18:37 1997 Jason Merrill ++ ++ * decl2.c (comdat_linkage): Also set DECL_COMDAT. ++ (finish_file): Check DECL_COMDAT instead of weak|one_only. ++ (import_export_vtable): Use make_decl_one_only instead of ++ comdat_linkage for win32 tweak. ++ (import_export_decl): Likewise. ++ * pt.c (mark_decl_instantiated): Likewise. ++ ++ * decl2.c (finish_file): Lose handling of templates in pending_statics. ++ ++Thu Dec 11 21:12:09 1997 Jason Merrill ++ ++ * decl2.c (finish_file): Lose call to expand_builtin_throw. ++ * except.c (expand_builtin_throw): Remove. ++ * cp-tree.h: Remove ptr_ptr_type_node. ++ * decl.c: Likewise. ++ ++Thu Dec 11 20:43:33 1997 Teemu Torma ++ ++ * decl.c (ptr_ptr_type_node): Define. ++ (init_decl_processing): Initialize it. ++ * cp-tree.h: Declare it. ++ * exception.cc (__cp_exception_info): Use __get_eh_info. ++ (__cp_push_exception): Likewise. ++ (__cp_pop_exception): Likewise. ++ ++ From Scott Snyder : ++ * except.c (expand_builtin_throw): Use get_saved_pc_ref instead of ++ saved_pc. ++ (init_exception_processing): Removed saved_pc initialization. ++ ++Wed Dec 10 11:04:45 1997 Jason Merrill ++ ++ * pt.c (instantiate_decl): Defer all templates but inline functions. ++ ++Mon Dec 8 23:17:13 1997 Jason Merrill ++ ++ * init.c (expand_vec_init): Don't fold a list of parameters. ++ ++ * decl.c (copy_args_p): Handle copy elision for types with virtual ++ bases. ++ * call.c (build_over_call): Likewise. ++ ++Sun Dec 7 22:38:12 1997 Mark Mitchell ++ ++ * pt.c (lookup_template_function): Copy the template arguments, ++ not just the list containing them, to the permanent obstack. ++ ++Sun Dec 7 15:53:06 1997 Jason Merrill ++ ++ * except.c (expand_start_catch_block): suspend_momentary for the ++ terminate handler. ++ ++ * error.c (dump_decl): Handle LOOKUP_EXPR. ++ ++Sun Dec 7 15:45:07 1997 Mark Mitchell ++ ++ * rtti.c (build_dynamic_cast): Copy the cast-to type to the ++ permanent obstack if we are processing a template decl. ++ * typeck.c (build_static_cast): Likewise. ++ (build_const_cast): Likewise. ++ (build_reinterpret_cast): Likewise. ++ ++ * pt.c (coerce_template_parms): Coerce some expressions, even ++ when processing_template_decl. ++ ++Sun Dec 7 01:46:33 1997 Bruno Haible ++ ++ * typeck.c (build_binary_op_nodefault, pointer_diff): Symmetric ++ handling of pointer difference expressions. ++ ++ * typeck.c (comp_target_types): Comparison of function/method types ++ is independent of nptrs. ++ ++Sun Dec 7 01:40:27 1997 Mark Mitchell ++ ++ * pt.c (tsubst): Avoid creating pointer to reference and ++ reference to reference types. ++ ++Sat Dec 6 01:29:37 1997 Jason Merrill ++ ++ * parse.y (do_id): New nonterminal. ++ (template_id): Use it. ++ ++Fri Dec 5 01:17:34 1997 Jason Merrill ++ ++ * parse.y (template_id): do_identifier for PFUNCNAMEs, too. ++ * spew.c (yylex): Don't do_identifier here. ++ * decl2.c (build_expr_from_tree): Revert last change. ++ ++ * decl2.c (build_expr_from_tree): Expand the name for a method call. ++ * parse.y (object_template_id): Don't try to take the DECL_NAME. ++ ++Wed Dec 3 20:02:39 1997 Jason Merrill ++ ++ * init.c (build_new): Use a TARGET_EXPR instead of SAVE_EXPR for ++ alloc_expr. ++ * call.c (build_op_delete_call): Adjust. ++ ++ * except.c (expand_end_catch_block): Lose rethrow region. ++ (expand_start_catch_block): Likewise. ++ (expand_end_catch_block): Don't expand_leftover_cleanups. ++ ++Wed Dec 3 13:24:04 1997 Benjamin Kosnik ++ ++ * pt.c (tsubst): Remove tree_cons call (places redundant info into ++ DECL_TEMPLATE_INSTANTIATION). ++ ++Wed Dec 3 11:44:52 1997 Jason Merrill ++ ++ * tree.c (is_overloaded_fn): Handle getting a fn template. ++ (really_overloaded_fn): Likewise. ++ * error.c (dump_decl): Handle TEMPLATE_ID_EXPRs better. ++ * pt.c (check_explicit_specialization): Tweak. ++ (determine_explicit_specialization): Tweak. ++ ++ * tree.c, cp-tree.h (get_target_expr): New fn. ++ ++Wed Dec 3 08:47:27 1997 Paul Eggert ++ ++ * pt.c (check_explicit_specialization): Fix misspelling in ++ diagnostic: `preceeded'. ++ * typeck.c (get_delta_difference): Fix misspelling in diagnostic: ++ `conversiona'. ++ ++1997-12-02 Mark Mitchell ++ ++ * pt.c (determine_explicit_specialization): Avoid an internal ++ error for bad specializations. ++ ++ * method.c (build_overload_value): Handle SCOPE_REF. ++ ++Tue Dec 2 19:18:50 1997 Mike Stump ++ ++ * class.c (prepare_fresh_vtable): Enable even more complex MI ++ vtable names. ++ ++Tue Dec 2 01:37:19 1997 Jason Merrill ++ ++ * exception.cc (__check_eh_spec): Optimize a bit. ++ ++ * exception.cc (__cp_pop_exception): Lose handler arg. ++ * except.c (do_pop_exception): Likewise. ++ (push_eh_cleanup): Let the cleanup mechanism supply the handler. ++ (expand_end_catch_block): Likewise. ++ ++Fri Nov 28 01:58:14 1997 Jason Merrill ++ ++ * pt.c (check_explicit_specialization): Complain about using a ++ template-id for a non-specialization. ++ ++Fri Nov 28 12:35:19 1997 Scott Christley ++ ++ * repo.c: Prototype rindex only if needed. ++ * xref.c: Likewise. ++ ++Fri Nov 28 01:56:35 1997 Bruno Haible ++ ++ * error.c (dump_decl): Handle TEMPLATE_ID_EXPR. ++ ++Thu Nov 27 00:59:46 1997 Jason Merrill ++ ++ * typeck.c (build_const_cast): Handle references here instead of ++ handing off to convert_to_reference. ++ ++ * except.c: Lose Unexpected, SetTerminate, SetUnexpected, ++ TerminateFunctionCall. ++ (init_exception_processing): Likewise. Terminate et al are now ++ the fns, not ADDR_EXPRs. ++ (various): Lose redundant assemble_external calls. ++ (do_unwind): s/BuiltinReturnAddress/builtin_return_address_fndecl/. ++ ++ * cp-tree.h (struct lang_decl_flags): Add comdat. ++ (DECL_COMDAT): New macro. ++ * decl.c (duplicate_decls): Propagate it. ++ (cp_finish_decl): Handle it. ++ * decl2.c (import_export_decl): Just set DECL_COMDAT on VAR_DECLs. ++ ++ * class.c: Remove static pending_hard_virtuals. ++ (add_virtual_function): Take pointers to pending_virtuals ++ and pending_hard_virtuals. ++ (finish_struct_1): Pass them. Declare pending_hard_virtuals. ++ ++Wed Nov 26 20:28:49 1997 Jason Merrill ++ ++ * decl2.c (import_export_vtable): If we support one_only but not ++ weak symbols, mark instantiated template vtables one_only. ++ (import_export_decl): Likewise for tinfo functions. ++ (finish_vtable_vardecl): Also write out vtables from explicitly ++ instantiated template classes. ++ * pt.c (mark_class_instantiated): Revert last change. ++ ++ * except.c (expand_throw): Call mark_used on the destructor. ++ ++Wed Nov 26 15:13:48 1997 Jeffrey A Law (law@cygnus.com) ++ ++ * lex.c (lang_init): Enable flag_exceptions by default if no ++ command line switch was specified. ++ ++1997-11-26 Mark Mitchell ++ ++ * pt.c (unify): Handle `void' template parameters in ++ specializations. ++ ++Wed Nov 26 01:11:24 1997 Jason Merrill ++ ++ * rtti.c (build_dynamic_cast): Handle template case here. ++ (build_dynamic_cast_1): Not here. ++ ++ * typeck2.c (digest_init): Make copies where appropriate. ++ ++ * decl2.c (delete_sanity): resolve_offset_ref. ++ ++ * except.c: Call terminate without caching so many bits. ++ ++ * except.c (expand_start_catch_block): Fix catching a reference ++ to pointer. ++ ++Tue Nov 25 11:28:21 1997 Jason Merrill ++ ++ * init.c (build_new): Copy size to the saveable obstack. ++ ++ * init.c (build_new): Stick a CLEANUP_POINT_EXPR inside the ++ TRY_CATCH_EXPR for now. ++ ++Mon Nov 24 12:15:55 1997 Jason Merrill ++ ++ * typeck.c (mark_addressable): Don't assume a FUNCTION_DECL ++ has DECL_LANG_SPECIFIC. ++ ++ * exception.cc (struct cp_eh_info): Add handlers field. ++ (__cp_push_exception): Initialize it. ++ (__cp_pop_exception): Decrement it. Don't pop unless it's 0. ++ (__throw_bad_exception): Remove. ++ * except.c (call_eh_info): Add handlers field. ++ (get_eh_handlers): New fn. ++ (push_eh_cleanup): Increment handlers. ++ ++Fri Nov 21 12:22:07 1997 Jason Merrill ++ ++ * except.c (expand_start_eh_spec): Use the try/catch code. ++ (expand_end_eh_spec): Likewise. Call __check_eh_spec instead of ++ doing everything inline. ++ (init_exception_processing): throw_type_match now takes ++ const void pointers. ++ * exception.cc (__check_eh_spec): New fn. ++ * inc/exception: Neither terminate nor unexpected return. ++ * decl.c: Make const_ptr_type_node public. ++ * tinfo2.cc (__throw_type_match_rtti): Take the typeinfos constly. ++ ++ * except.c (expand_start_catch_block): We only need the rethrow ++ region for non-sjlj exceptions. ++ (expand_end_catch_block): Likewise. Use outer_context_label_stack. ++ ++Thu Nov 20 14:40:17 1997 Jason Merrill ++ ++ * Make-lang.in (CXX_LIB2FUNCS): Add new op new and op delete objs. ++ (various.o): Likewise. ++ * inc/new: Add placement deletes. Add throw specs for default new. ++ * new.cc (set_new_handler): Move here from libgcc2. ++ * new1.cc (new (nothrow)): Catch a bad_alloc thrown from the handler. ++ (new): Move from libgcc2. Throw bad_alloc. ++ * new2.cc: Move the rest of the op news and op deletes from libgcc2. ++ * decl.c (init_decl_processing): Update exception specs on new and ++ delete. ++ ++ * method.c (build_decl_overload_real): Don't mess with global ++ placement delete. ++ ++ * init.c (build_new): Check for null throw spec, not nothrow_t. ++ ++ * decl.c (duplicate_decls): Don't complain about different exceptions ++ from an internal declaration. ++ ++ * call.c (build_op_delete_call): Fix check for member fns again. ++ ++ * decl2.c (import_export_decl): Interface hackery affects ++ virtual synthesized methods. ++ ++Wed Nov 19 18:24:14 1997 Jason Merrill ++ ++ * decl.c (start_decl): Don't just complain about a mismatched ++ scope, fix it. ++ ++ * decl.c (make_implicit_typename): Handle case where t is not ++ actually from context. ++ * tree.c (get_type_decl): Lose identifier case. ++ * spew.c (yylex): Lose useless call to identifier_typedecl_value. ++ * parse.y (nonnested_type): Just use lookup_name. ++ (complex_type_name): Just use IDENTIFIER_GLOBAL_VALUE. ++ ++Wed Nov 19 11:45:07 1997 Michael Tiemann ++ ++ * error.c (dump_function_name): Test DECL_LANG_SPECIFIC in case ++ T was built in C language context (for example, by ++ output_func_start_profiler). ++ ++Wed Nov 19 10:39:27 1997 Jason Merrill ++ ++ * decl.c (make_implicit_typename): New fn. ++ (lookup_name_real): Use it. Use current_class_type as the context. ++ ++Mon Nov 17 23:42:03 1997 Bruno Haible ++ ++ * pt.c (do_poplevel): Don't prohibit jumps into this contour. ++ ++Mon Nov 17 02:01:28 1997 Jason Merrill ++ ++ * friend.c (do_friend): Warn about non-template friends in templates. ++ ++ * call.c (build_op_delete_call): Fix handling of inherited delete. ++ ++ * search.c (dfs_record_inheritance): Ignore template type parms. ++ ++Sat Nov 15 00:30:51 1997 Jason Merrill ++ ++ * call.c (build_new_op): Fix copy error. ++ (build_op_new_call): New fn. ++ (build_op_delete_call): New fn. ++ * cp-tree.h: Declare them. ++ * init.c (build_new): Use them. Support placement delete. ++ (build_x_delete): Use build_op_delete_call. ++ (build_delete): Likewise. ++ * decl2.c (delete_sanity): Likewise. ++ (coerce_delete_type): Don't complain about placement delete. ++ ++Thu Nov 13 01:52:36 1997 Jason Merrill ++ ++ * call.c (build_new_function_call): Remove unused 'obj' parm. ++ * cp-tree.h, typeck.c: Adjust. ++ ++ * init.c (build_new): Make the cleanup last longer. ++ (expand_vec_init): Call do_pending_stack_adjust. ++ ++Wed Nov 12 11:04:33 1997 Jason Merrill ++ ++ * pt.c (do_type_instantiation): Fix typo. ++ (mark_class_instantiated): If we support one_only but not weak ++ symbols, don't mark this as known. ++ ++ * init.c (build_new): Handle vec delete in EH cleanup. ++ ++Wed Nov 12 08:11:55 1997 Benjamin Kosnik ++ ++ * call.c (build_method_call): Call complete_type before checking ++ for destructor. ++ ++Sun Nov 9 01:29:55 1997 Jim Wilson (wilson@cygnus.com) ++ ++ * decl.c (add_block_current_level): Delete. ++ * init.c (build_vec_delete_1): Delete build_block and ++ add_block_current_level calls. ++ ++Wed Nov 12 00:48:16 1997 Jason Merrill ++ ++ * init.c (build_new): Handle freeing allocated memory when the ++ constructor throws. ++ ++ * call.c (build_new_method_call): Fix flags arg. ++ ++ * pt.c (do_type_instantiation): Don't try to instantiate ++ member templates. ++ (mark_decl_instantiated): If we support one_only but not ++ weak symbols, mark this one_only. ++ * decl2.c (import_export_vtable): Don't defer handling of vtables ++ if MULTIPLE_SYMBOL_SPACES. ++ ++Tue Nov 11 12:02:12 1997 Jason Merrill ++ ++ * except.c (expand_end_catch_block): Lose call to __sjpopnthrow. ++ ++Tue Nov 11 02:53:44 1997 Jason Merrill ++ ++ * except.c (do_pop_exception): Return a value. ++ ++Mon Nov 10 20:25:31 1997 Jason Merrill ++ ++ * call.c (build_new_method_call): Handle getting a ++ TEMPLATE_ID_EXPR around a TEMPLATE_DECL. Don't look for a field ++ if we got template parms. ++ * typeck.c (build_x_function_call): Remember the TEMPLATE_ID_EXPR, ++ not just the args. ++ * decl2.c (build_expr_from_tree): Tweak last change. ++ * pt.c (tsubst_copy): Use get_first_fn instead of TREE_VALUE. ++ (maybe_fold_nontype_arg): Split out from tsubst_copy. ++ * tree.c (get_first_fn): Just return a TEMPLATE_ID_EXPR. ++ ++Mon Nov 10 20:08:38 1997 Kriang Lerdsuwanakij ++ ++ * pt.c (tsubst_copy): Handle explicit template arguments in ++ function calls. ++ * typeck.c (build_x_function_call): Likewise. ++ * decl2.c (build_expr_from_tree): Lookup function name if it ++ hasn't been done. ++ ++ * pt.c (tsubst): Instantiate template functions properly when ++ template parameter does not appear in function arguments and return ++ type. ++ (comp_template_args): Handle member templates required by tsubst. ++ ++Mon Nov 10 20:08:38 1997 Jason Merrill ++ ++ * decl.c (grokdeclarator): Tweak conditions for pedwarn in ++ previous change. ++ ++Mon Nov 10 20:08:29 1997 Bruno Haible ++ ++ * pt.c (coerce_template_parms): Tweak error message. ++ ++ * decl.c (grokdeclarator): If -Wreturn-type, warn everytime a ++ return type defaults to `int', even if there are storage-class ++ specifiers. ++ ++Mon Nov 10 03:04:20 1997 Jason Merrill ++ ++ Complete nested exception support. ++ * except.c (do_pop_exception): Split out... ++ (push_eh_cleanup): From here. Handle the EH region by hand. ++ (expand_start_catch_block): Add a new level for the catch parm. ++ Move the rethrow region outside the two cleanup regions. ++ Protect the initializer for the catch parm with terminate. ++ (expand_end_catch_block): Likewise. End the region for the eh_cleanup. ++ * exception.cc (__cp_pop_exception): Now takes two parms. Handle ++ popping off the middle of the stack. ++ * tree.c (lvalue_p, real_lvalue_p): Handle TRY_CATCH_EXPR, ++ WITH_CLEANUP_EXPR, and UNSAVE_EXPR. ++ (build_cplus_new): Only wrap CALL_EXPRs. ++ * init.c (expand_default_init): Handle a TRY_CATCH_EXPR around ++ the constructor call. ++ ++Sun Nov 9 18:00:26 1997 Richard Kenner ++ ++ * Make-lang.in (c++.distdir): Make inc subdirectory. ++ ++Fri Nov 7 11:57:28 1997 Jason Merrill ++ ++ * decl2.c (finish_file): Put back some code. ++ ++Thu Nov 6 11:28:14 1997 Jason Merrill ++ ++ * decl2.c (finish_file): Remove redundant code. ++ * method.c (emit_thunk): Don't let the backend defer generic thunks. ++ ++Wed Nov 5 23:52:50 1997 Jason Merrill ++ ++ * except.c (call_eh_info): Split out... ++ (push_eh_info): From here. ++ (expand_builtin_throw): Use it. ++ (expand_start_catch_block): Move region start back. ++ ++Tue Nov 4 13:45:10 1997 Doug Evans ++ ++ * lex.c (MULTIBYTE_CHARS): #undef if cross compiling. ++ (real_yylex): Record wide strings using target endianness, not host. ++ ++1997-11-03 Brendan Kehoe ++ ++ * repo.c (rindex): Add decl unconditionally. ++ (get_base_filename, open_repo_file): Don't cast rindex. ++ * xref.c (rindex): Add decl unconditionally. ++ (index): Remove unused decl. ++ (open_xref_file): Don't cast rindex. ++ ++Sun Nov 2 15:04:12 1997 Jason Merrill ++ ++ * class.c (build_vbase_path): Propagate the result type properly. ++ ++1997-11-01 Brendan Kehoe ++ ++ * except.c (expand_builtin_throw) [!DWARF2_UNWIND_INFO]: Replace ++ remaining use of saved_throw_type with a call to get_eh_type. ++ ++1997-10-31 Brendan Kehoe ++ ++ * lex.c (FILE_NAME_NONDIRECTORY): Delete macro. ++ (file_name_nondirectory): New function, doing the same as the macro. ++ (set_typedecl_interface_info): Use it instead of the macro. ++ (check_newline): Likewise. ++ (handle_cp_pragma): Likewise. ++ ++ * repo.c (get_base_filename): Cast result of rindex to char*. ++ (open_repo_file): Likewise. ++ * xref.c (open_xref_file): Likewise. ++ * error.c (dump_char): Make its arg int, not char. ++ ++ * except.c (push_eh_info): Pass the number of fields - 1 down, not ++ the exact number of fields. ++ ++Fri Oct 31 01:47:57 1997 Jason Merrill ++ ++ Support for nested exceptions. ++ * tinfo2.cc (__is_pointer): New fn. ++ * exception.cc (struct cp_eh_info): Define. ++ (__cp_exception_info, __uncatch_exception): New fns. ++ (__cp_push_exception, __cp_pop_exception): New fns. ++ * except.c: Lose saved_throw_{type,value,cleanup,in_catch}. ++ Lose empty_fndecl. ++ (init_exception_processing): Likewise. __eh_pc is now external. ++ (push_eh_info): New fn. ++ (get_eh_{info,value,type,caught}): New fns. ++ (push_eh_cleanup): Just call __cp_pop_exception. ++ (expand_start_catch_block): Use push_eh_info. Start the eh region ++ sooner. ++ (expand_end_eh_spec): Use push_eh_info. ++ (expand_throw): Call __cp_push_exception to set up the exception info. ++ Just pass the destructor or 0 as the cleanup. Call __uncatch_exception ++ when we rethrow. ++ (expand_builtin_throw): Don't refer to empty_fndecl. ++ ++Thu Oct 23 02:01:30 1997 Jason Merrill ++ ++ * pt.c (instantiate_decl): SET_DECL_IMPLICIT_INSTANTIATION on new decl. ++ ++1997-10-22 Brendan Kehoe ++ ++ * method.c (build_template_parm_names, build_decl_overload_real): ++ Add static to definitions. ++ * pt.c (add_to_template_args, note_template_header, ++ processing_explicit_specialization, type_unification_real): Likewise. ++ ({determine,check}_explicit_specialization): Use a single string for ++ error messages. ++ ++Mon Oct 20 12:06:34 1997 Jason Merrill ++ ++ * except.c (expand_exception_blocks): Call do_pending_stack_adjust. ++ (expand_end_catch_block): Likewise. ++ (expand_end_eh_spec): Likewise. ++ ++Mon Oct 20 11:44:20 1997 Mark Mitchell ++ ++ * decl.c (duplicate_decls): Handle template specializations ++ correctly. ++ * error.c (dump_function_name): Fix printing of specializations of ++ member functions that are not member templates. ++ * cp-tree.h (processing_specialization): Make global. ++ * pt.c (processing_specialization): Likewise. ++ * lex.c (cons_up_default_function): Save and restore ++ processing_specialization to avoid confusion. ++ ++Mon Oct 20 10:52:22 1997 Jason Merrill ++ ++ * decl.c (init_decl_processing): Give null_node unknown* type. ++ * typeck.c (comp_target_types): Handle UNKNOWN_TYPE. ++ (common_type): Likewise. ++ * error.c (args_as_string): Recognize null_node. ++ ++Sun Oct 19 09:13:01 1997 Richard Kenner ++ ++ * typeck.c (rationalize_conditional_expr): Handle {MIN,MAX}_EXPR. ++ (unary_complex_lvalue): Call it for {MIN,MAX}_EXPR. ++ ++ * decl.c (init_decl_processing): Call using_eh_for_cleanups. ++ ++ * Make-lang.in (g++): Include prefix.o. ++ ++Thu Oct 16 15:31:09 1997 Judy Goldberg ++ ++ * pt.c (determine_explicit_specialization): Initialize "dummy" ++ to keep Purify quiet. ++ ++Thu Oct 16 00:14:48 1997 Jason Merrill ++ ++ * method.c (build_overload_value): Handle TEMPLATE_CONST_PARMs here. ++ (build_overload_int): Not here. ++ ++Wed Oct 15 00:35:28 1997 Mike Stump ++ ++ * class.c (build_type_pathname): Remove. ++ (prepare_fresh_vtable): Fix problem with complex MI vtable names. ++ ++1997-10-14 Brendan Kehoe ++ ++ * parse.y (unary_expr): Give a pedwarn if someone tries to use the ++ &&label GNU extension. ++ ++Tue Oct 14 12:01:00 1997 Mark Mitchell ++ ++ * decl.c (pushtag): Unset DECL_ASSEMBLER_NAME before setting it, ++ so as to avoid incorrect manglings. ++ * method.c (build_decl_overload_real): Don't mangle return types ++ for constructors. ++ ++Tue Oct 14 11:46:14 1997 Jason Merrill ++ ++ * cp-tree.h (scratchalloc, build_scratch_list, make_scratch_vec, ++ scratch_tree_cons): Define as macros for now. ++ * call.c, class.c, cvt.c, decl.c, decl2.c, except.c, expr.c, init.c, ++ lex.c, method.c, parse.y, pt.c, rtti.c, search.c, tree.c, typeck.c, ++ typeck2.c: Use them and the expression_obstack variants. ++ ++Mon Oct 13 17:41:26 1997 Benjamin Kosnik ++ ++ * decl.c (store_return_init): Allow classes with explicit ctors to ++ be used with the named return values extension. ++ ++Fri Oct 10 12:21:11 1997 Jason Merrill ++ ++ * pt.c (instantiate_decl): Fix previous change. ++ ++Thu Oct 9 12:08:21 1997 Jason Merrill ++ ++ * pt.c (tsubst): Fix thinko. ++ (instantiate_decl): Really use the original template. ++ ++ * call.c (build_new_method_call): Use simple constructor_name for ++ error messages. ++ ++Wed Oct 8 22:44:42 1997 Jeffrey A Law ++ ++ * method.c (build_underscore_int): Don't use ANSI specific ++ features. ++ ++Wed Oct 8 00:18:22 1997 Jason Merrill ++ ++ * decl2.c (finish_prevtable_vardecl): Check DECL_REALLY_EXTERN ++ for our key method; it might have been inlined by -O3. ++ ++Tue Oct 7 23:00:12 1997 Mark Mitchell ++ ++ * decl.c (make_typename_type): Do not try to call lookup_field for ++ non-aggregate types. ++ ++Tue Oct 7 22:52:10 1997 Jason Merrill ++ ++ * typeck.c (build_reinterpret_cast): Tweak. ++ ++Tue Oct 7 22:45:31 1997 Alexandre Oliva ++ ++ * typeck.c (build_reinterpret_cast): Converting a void pointer ++ to function pointer with a reinterpret_cast produces a warning ++ if -pedantic is issued. ++ ++Tue Oct 7 22:43:43 1997 Bruno Haible ++ ++ * typeck.c (c_expand_return): Don't warn about returning a ++ reference-type variable as a reference. ++ ++Tue Oct 7 21:11:22 1997 Jason Merrill ++ ++ * method.c (build_static_name): Fix typo. ++ ++1997-10-07 Brendan Kehoe ++ ++ * decl.c (duplicate_decls): Make sure DECL_LANG_SPECIFIC is set on ++ OLDDECL before we try to do DECL_USE_TEMPLATE. ++ ++Tue Oct 7 00:48:36 1997 Jason Merrill ++ ++ * decl.c (duplicate_decls): Don't warn about template instances. ++ ++ * typeck.c (mark_addressable): Lose ancient code that unsets ++ DECL_EXTERNAL. ++ ++ * pt.c (do_decl_instantiation): Lose support for instantiating ++ non-templates. ++ ++ * call.c (build_new_function_call): Fix handling of null explicit ++ template args. ++ (build_new_method_call): Likewise. ++ ++Mon Oct 6 23:44:34 1997 Mark Mitchell ++ ++ * method.c (build_underscore_int): Fix typo. ++ ++1997-10-06 Brendan Kehoe ++ ++ * tree.c (print_lang_statistics): #if 0 call to ++ print_inline_obstack_statistics until its definition is checked in. ++ ++Mon Oct 6 09:27:29 1997 Jason Merrill ++ ++ * decl2.c (finish_file): Move dump_tree_statistics to end. ++ ++ * pt.c (instantiate_decl): Look for the original template. ++ (tsubst): Set DECL_IMPLICIT_INSTANTIATION on partial instantiations ++ of member templates. ++ ++Wed Oct 1 08:41:38 1997 Jason Merrill ++ ++ * Makefile.in (g++FAQ.*): New rules. ++ (CONFLICTS): Update. ++ * g++FAQ.texi: Moved from libg++. ++ ++ * parse.y (PFUNCNAME): Only specify the type once. ++ ++1997-10-01 Brendan Kehoe ++ ++ * lex.c (real_yylex): Clean up the code to fully behave the way ++ the c-lex.c parser does for complex and real numbers. ++ ++Tue Sep 30 08:51:36 1997 Jason Merrill ++ ++ * method.c (build_decl_overload_real): Reformat. ++ ++Tue Sep 30 00:18:26 1997 Jason Merrill ++ ++ * method.c (synthesize_method): If at_eof, determine our linkage. ++ ++1997-09-29 Paul Eggert ++ ++ * lex.c (real_yylex): Treat `$' just like `_', except issue a ++ diagnostic if !dollars_in_ident or if pedantic. ++ ++ * lang-specs.h (@c++): -ansi no longer implies -$. ++ ++ * decl2.c (lang_decode_option): ++ -traditional and -ansi now do not mess with ++ dollars_in_ident. ++ ++Mon Sep 29 19:57:51 1997 H.J. Lu ++ ++ * Makefile.in (parse.o, decl.o): Also depend on ++ $(srcdir)/../except.h $(srcdir)/../output.h. ++ (decl2.o): Also depend on $(srcdir)/../expr.h ../insn-codes.h ++ $(srcdir)/../except.h $(srcdir)/../output.h. ++ (typeck.o, init.o): Also depend on $(srcdir)/../expr.h ++ ../insn-codes.h. ++ ++ * call.c, cp-tree.h, decl.c, tree.c: Finish prototyping. ++ ++ * expr.c (cplus_expand_expr): Make it static. ++ ++ * decl2.c, init.c, typeck.c: Include "expr.h". ++ (expand_expr): Use proper values when calling the function. ++ ++Mon Sep 29 11:05:54 1997 Alexandre Oliva ++ ++ * lang-options.h: New -Wold-style-cast flag. ++ * cp-tree.h (warn_old_style_cast): New variable. ++ * decl2.c (warn_old_style_cast): Likewise. ++ (lang_decode_option): Support -Wold-style-cast. ++ (reparse_absdcl_as_casts): Produce old-style-cast warning. ++ ++Mon Sep 29 09:20:53 1997 Benjamin Kosnik ++ ++ * decl.c (cp_finish_decl): Allow expand_aggr_init to set ++ TREE_USED, reset value based on already_used. ++ ++ * init.c (expand_member_init): Revert change. ++ ++Mon Sep 29 08:57:53 1997 Jason Merrill ++ ++ * cp-tree.h, decl.c, decl2.c, pt.c: ++ Lose DECL_C_STATIC and DECL_PUBLIC. Don't pretend statics are public. ++ ++ * decl2.c (lang_decode_option): Add missing ;. ++ ++Sat Sep 27 16:22:48 1997 Jason Merrill ++ ++ * friend.c (do_friend): Disable injection for all template-derived ++ decls. ++ * decl2.c (lang_decode_option): Handle -fguiding-decls. ++ * parse.y (notype_template_declarator): New nonterminal. ++ (direct_notype_declarator): Use it. ++ (complex_direct_notype_declarator): Likewise. ++ (object_template_id): Accept any kind of identifier after TEMPLATE. ++ (notype_qualified_id): Don't add template declarators here. ++ ++Sat Sep 27 16:21:58 1997 Mark Mitchell ++ ++ * call.c (add_template_candidate): Add explicit_targs parameter. ++ (build_scoped_method_call): Use it. ++ (build_overload_call_real): Likewise. ++ (build_user_type_conversion_1): Likewise. ++ (build_new_function_call): Likewise. ++ (build_object_call): Likewise. ++ (build_new_op): Likewise. ++ (build_new_method_call): Likewise. ++ (build_new_function_call): Handle TEMPLATE_ID_EXPR. ++ (build_new_method_call): Likewise. ++ ++ * class.c (finish_struct_methods): Add specialization pass to ++ determine which methods were specializing which other methods. ++ (instantiate_type): Handle TEMPLATE_ID_EXPR. ++ ++ * cp-tree.def (TEMPLATE_ID_EXPR): New tree code. ++ ++ * cp-tree.h (name_mangling_version): New variable. ++ (flag_guiding_decls): Likewise. ++ (build_template_decl_overload): New function. ++ (begin_specialization): Likewise. ++ (reset_specialization): Likewise. ++ (end_specialization): Likewise. ++ (determine_explicit_specialization): Likewise. ++ (check_explicit_specialization): Likewise. ++ (lookup_template_function): Likewise. ++ (fn_type_unification): Add explicit_targs parameter. ++ (type_unification): Likewise. ++ ++ * decl.c (duplicate_decls): Add smarts for explicit ++ specializations. ++ (grokdeclarator): Handle TEMPLATE_ID_EXPR, and function ++ specializations. ++ (grokfndecl): Call check_explicit_specialization. ++ ++ * decl2.c (lang_decode_option): Handle -fname-mangling-version. ++ (build_expr_from_tree): Handle TEMPLATE_ID_EXPR. ++ (check_classfn): Handle specializations. ++ ++ * error.c (dump_function_name): Print specialization arguments. ++ ++ * friend.c (do_friend): Don't call pushdecl for template ++ instantiations. ++ ++ * init.c (build_member_call): Handle TEMPLATE_ID_EXPR. ++ ++ * lang-options.h: Add -fname-mangling-version, -fguiding-decls, ++ and -fno-guiding-decls. ++ ++ * lex.c (identifier_type): Return PFUNCNAME for template function ++ names. ++ ++ * method.c (build_decl_overload_real): New function. ++ (build_template_parm_names): New function. ++ (build_overload_identifier): Use it. ++ (build_underscore_int): New function. ++ (build_overload_int): Use it. Add levels for template ++ parameters. ++ (build_overload_name): Likewise. Also, handle TYPENAME_TYPEs. ++ (build_overload_nested_names): Handle template type parameters. ++ (build_template_decl_overload): New function. ++ ++ * parse.y (YYSTYPE): New ntype member. ++ (nested_name_specifier): Use it. ++ (nested_name_specifier_1): Likewise. ++ (PFUNCNAME): New token. ++ (template_id, object_template_id): New non-terminals. ++ (template_parm_list): Note specializations. ++ (template_def): Likewise. ++ (structsp): Likewise. ++ (fn.def2): Handle member template specializations. ++ (component_decl_1): Likewise. ++ (direct_notype_declarator): Handle template-ids. ++ (component_decl_1): Likewise. ++ (direct_notype_declarator): Handle template-ids. ++ (primary): Handle TEMPLATE_ID_EXPR, and template-ids. ++ ++ * pt.c (processing_specializations): New variable. ++ (template_header_count): Likewise. ++ (type_unification_real): New function. ++ (processing_explicit_specialization): Likewise. ++ (note_template_header): Likewise. ++ (is_member_template): Handle specializations. ++ (end_template_decl): Call reset_specialization. ++ (push_template_decl): Handle member template specializations. ++ (tsubst): Likewise. ++ (tsubst_copy): Handle TEMPLATE_ID_EXPR. ++ (instantiate_template): Handle specializations. ++ (instantiate_decl): Likewise. ++ (fn_type_unification): Handle explicit_targs. ++ (type_unification): Likewise. Allow incomplete unification ++ without an error message, if allow_incomplete. ++ (get_bindings): Use new calling sequence for fn_type_unification. ++ ++ * spew.c (yylex): Handle PFUNCNAME. ++ ++ * tree.c (is_overloaded_fn): Handle TEMPLATE_ID_EXPR. ++ (really_overloaded_fn): Likewise. ++ (get_first_fn): Handle function templates. ++ ++ * typeck.c (build_x_function_call): Use really_overloaded_fn. ++ Handle TEMPLATE_ID_EXPR. ++ (build_x_unary_op): Likewise. ++ (build_unary_op): Likewise. ++ (mark_addressable): Templates whose address is taken are marked ++ as used. ++ ++1997-09-25 Andreas Schwab ++ ++ * decl.c (init_decl_processing): Declare __builtin_constant_p as ++ accepting any kind of type, not only int. ++ ++Fri Sep 26 00:22:56 1997 Jason Merrill ++ ++ * search.c (get_matching_virtual): Notice virtual bases when sorrying ++ about covariant returns. ++ ++ * parse.y (member_init): Also imply typename here. Remove ancient ++ extension for initializing base members. ++ ++Thu Sep 25 11:11:13 1997 Jason Merrill ++ ++ Handle multi-level typenames and implicit typename in base list. ++ * parse.y (typename_sub{,[0-2]}): New rules. ++ (structsp, rule TYPENAME_KEYWORD): Use typename_sub. ++ (nonnested_type): New rule. ++ (complete_type_name): Use it. ++ (base_class.1): Use typename_sub and nonnested_type. ++ (nested_name_specifier): Don't elide std:: here. ++ * decl.c (make_typename_type): Handle getting a type for NAME. ++ (lookup_name_real): Turn std:: into :: here. ++ ++ Rvalue conversions were removed in London. ++ * call.c (is_subseq): Don't consider lvalue transformations. ++ (build_conv): LVALUE_CONV and RVALUE_CONV get IDENTITY_RANK. ++ (joust): Re-enable ?: kludge. ++ ++1997-09-22 Brendan Kehoe ++ ++ * decl.c (start_function): Up warning of no return type to be a ++ pedwarn. ++ ++Mon Sep 22 14:15:34 1997 Benjamin Kosnik ++ ++ * init.c (expand_member_init): Don't set TREE_USED. ++ * decl.c (cp_finish_decl): Mark decls used if type has TREE_USED ++ set,don't clear TREE_USED wholesale. ++ ++Sat Sep 20 15:31:00 1997 Jason Merrill ++ ++ * call.c (build_over_call): Do require_complete_type before ++ build_cplus_new. ++ ++Thu Sep 18 16:47:52 1997 Jason Merrill ++ ++ * search.c (lookup_field): Call complete_type in all cases. ++ ++ * decl.c (finish_function): Just warn about flowing off the end. ++ ++Wed Sep 17 10:31:25 1997 Jason Merrill ++ ++ * decl.c (grokparms): Don't bash a permanent list node if we're ++ in a function. ++ ++1997-09-17 Brendan Kehoe ++ ++ * Makefile.in (CONFLICTS): Fix s/r conflict count to 18. ++ ++Tue Sep 16 14:06:56 1997 Jason Merrill ++ ++ * call.c (build_new_op): Give better error for syntactically ++ correct, but semantically invalid, use of undeclared template. ++ ++ * call.c (compare_qual): Handle pmfs. ++ ++ * decl.c (store_parm_decls): last_parm_cleanup_insn is the insn ++ after the exception spec. ++ ++Mon Sep 15 11:52:13 1997 Jason Merrill ++ ++ * call.c (null_ptr_cst_p): Integer type, not integral type. ++ ++ * call.c (joust): Disable warnings until they can be moved to the ++ right place. ++ ++Fri Sep 12 16:11:13 1997 Per Bothner ++ ++ * Makefile.in, config-lang.in: Convert to autoconf. ++ ++Thu Sep 11 17:14:55 1997 Jason Merrill ++ ++ * decl.c (lookup_name_real): Add implicit 'typename' to types from ++ base classes. ++ ++ * pt.c (most_specialized_class): Fix typo. ++ (tsubst): Move constant folding to TREE_VEC case. ++ ++Thu Sep 11 10:08:45 1997 Mark Mitchell ++ ++ * pt.c (do_poplevel): Don't warn about unused local variables ++ while processing_template_decl since we don't always know whether ++ or not they will need constructing/destructing. ++ ++ * pt.c (uses_template_parms): Check the values of an enumeration ++ type to make sure they don't depend on template parms. ++ ++ * decl.c (make_typename_type): Don't lookup the field if the ++ context uses template parms, even if we're not ++ processing_template_decl at the moment. ++ ++ * pt.c (coerce_template_parms): Avoid looking at the ++ TYPE_LANG_DECL portion of a typename type, since there won't be ++ one. ++ (tsubst): Do constant folding as necessary to make sure that ++ arguments passed to lookup_template_class really are constants. ++ ++Wed Sep 10 11:21:55 1997 Jason Merrill ++ ++ * except.c (expand_builtin_throw): #ifndef DWARF2_UNWIND_INFO. ++ * decl2.c (finish_file): Only register exception tables if we ++ need to. ++ ++ * decl.c (init_decl_processing): Add __builtin_[fs]p. ++ ++Tue Sep 9 19:49:38 1997 Jason Merrill ++ ++ * pt.c (unify): Just return 0 for a TYPENAME_TYPE. ++ ++Tue Sep 9 17:57:25 1997 Mark Mitchell ++ ++ * error.c (dump_decl): Avoid crashing when presented with a ++ uninitialized constant, as can occur with a template parameter. ++ (dump_expr): Make sure that there are enough levels of ++ current_template_parms before we start diving through them. ++ ++1997-09-09 Brendan Kehoe ++ ++ * typeck.c (build_indirect_ref): Heed FLAG_VOLATILE similar to ++ c-typeck.c. ++ ++Tue Sep 9 09:36:39 1997 Benjamin Kosnik ++ ++ * except.c (expand_throw): Call build_delete for all ++ exception types, not just objects with destructors. ++ ++Mon Sep 8 02:33:20 1997 Jody Goldberg ++ ++ * decl.c (current_local_enum): Remove static. ++ * pt.c (tsubst_enum): Save and restore value of current_local_enum ++ in case template is expanded in enum decl. ++ (instantiate_class_template): Use new tsubst_enum signature. ++ (tsubst_expr): Likewise. ++ ++Mon Sep 8 01:21:43 1997 Mark Mitchell ++ ++ * pt.c (begin_member_template_processing): Take a function as ++ argument, not a set of template arguments. Use the template ++ parameters, rather than the arguments. Handle non-type parameters ++ correctly. Push a binding level for the parameters so that multiple ++ member templates using the same parameter names can be declared. ++ (end_member_template_processing): Pop the binding level. ++ (push_template_decl): Mark member templates as static when ++ appropriate. ++ ++ * lex.c (do_pending_inlines): Pass the function, not its template ++ arguments, to begin_member_template_processing. ++ (process_next_inline): Likewise. ++ (do_pending_defargs): Likewise. ++ ++ * error.c (dump_expr): Obtain the correct declaration for a ++ TEMPLATE_CONST_PARM. ++ ++ * call.c (add_template_conv_candidate): New function. ++ (build_object_call): Handle member templates, as done in the other ++ build_ functions. ++ ++Sat Sep 6 10:20:27 1997 Mark Mitchell ++ ++ * decl.c (replace_defag): Undo previous change. ++ * lex.c (do_pending_defargs): Deal with member templates. ++ ++ * pt.c (is_member_template): Avoid crashing when passed a ++ non-function argument. ++ ++Fri Sep 5 17:27:38 1997 Jason Merrill ++ ++ * class.c (grow_method): Remove check for redeclaration. ++ ++Fri Sep 5 01:37:17 1997 Mark Mitchell ++ ++ * cp-tree.h (INNERMOST_TEMPLATE_PARMS): New macro. ++ (DECL_INNERMOST_TEMPLATE_PARMS): Likewise. ++ (PRIMARY_TEMPLATE_P): Use it. ++ * call.c (build_overload_call_real): Use it. ++ * class.c (instantiate_type): Likewise. ++ * decl.c (decls_match): Likewise. ++ * method.c (build_overload_identifier): Likewise. ++ * pt.c (push_template_decl): Likewise. ++ (classtype_mangled_name): Likewise. ++ (lookup_template_class): Likewise. ++ ++ * cp-tree.h (DECL_NTPARMS): Change name from DECL_NT_PARMS to ++ DECL_NTPARMS to conform to usage elsewhere. ++ * call.c (add_template_candidate): Likewise. ++ * class.c (instantiate_type): Likewise. ++ * pt.c (instantiate_template): Likewise. ++ (get_bindings): Likewise. ++ ++ * class.c (grow_method): Use DECL_FUNCTION_TEMPLATE_P instead of ++ is_member_template. ++ ++ * pt.c (unify): Undo changes to allow multiple levels of template ++ parameters. ++ (type_unification): Likewise. ++ (fn_type_unification): Likewise. ++ (get_class_bindings): Likewise. ++ * cp-tree.h (Likewise). ++ ++ * decl.c (replace_defarg): Check that the type of the default ++ parameter does not invlove a template type before complaining ++ about the initialization. ++ ++ * error.c (dump_expr): Deal with template constant parameters in ++ member templates correctly. ++ ++ * pt.c (is_member_template): Deal with class specializations ++ correctly. ++ (tsubst): Handle "partial instantiation" of member templates ++ correctly. ++ ++Wed Sep 3 12:30:24 1997 Mark Mitchell ++ ++ * pt.c (type_unification): Change calling sequence to allow for ++ multiple levels of template parameters. ++ (tsubst_expr): Likewise. ++ (tsubst): Likewise. ++ (tsubst_copy): Likewise. ++ (instantiate_template): Likewise. ++ (unify): Likewise. ++ * call.c (build_overload_call_real): Use it. ++ (add_builtin_candidate): Use it. ++ (build_new_method_call): Use it. ++ * class.c (instantiate_type): Use it. ++ * decl.c (grokdeclarator): Use it. ++ * decl2.c (finish_file): Use it. ++ * method.c (build_overload_identifier): Use it. ++ ++ * call.c (add_template_candidate): Add additional parameter for ++ the function return type. Call fn_type_unification istead of ++ type_unification. ++ (build_user_type_conversion_1): Handle member templates. ++ (build_new_function_call): Likewise. ++ (build_new_op): Likewise. ++ (build_new_method_call): Likewise. ++ ++ * class.c (grow_method): Don't give an error message indicating ++ that two member templates with the same name are ambiguous. ++ (finish_struct): Treat member template functions just like member ++ functions. ++ ++ * cp-tree.h (check_member_template): Add declaration. ++ (begin_member_template_processing): Likewise. ++ (end_member_template_processing): Likewise. ++ (fn_type_unification): Likewise. ++ (is_member_template): Likewise. ++ (tsubst): Change prototype. ++ (tsubst_expr): Likewise. ++ (tsubst_copy): Likewise. ++ (instantiate_template): Likewise. ++ (get_bindings): Likewise. ++ ++ * decl.c (decls_match): Handle multiple levels of template ++ parameters. ++ (pushdecl): Handle template type params just like other type ++ declarations. ++ (push_class_level_binding): Return immediately if the ++ class_binding_level is NULL. ++ (grokfndecl): If check_classfn() returns a member_template, use ++ the result of the template, not the template itself. ++ ++ * decl2.c (check_member_template): New function. Check to see ++ that the entity declared to be a member template can be one. ++ (check_classfn): Allow redeclaration of member template functions ++ with different types; the new functions can be specializations or ++ explicit instantiations. ++ ++ * error.c (dump_decl): Handle multiple levels of template ++ parameters. ++ (dump_function_decl): Update to handle function templates. ++ ++ * lex.c (do_pending_inlines): Set up template parameter context ++ for member templates. ++ (process_next_inline): Likewise. ++ ++ * method.c (build_overload_identifier): Adjust for multiple levels ++ of template parameters. ++ ++ * parse.y (fn.def2): Add member templates. ++ (component_decl_1): Likewise. ++ ++ * pt.c (begin_member_template_processing): New function. ++ (end_member_template_processing): Likewise. ++ (is_member_template): Likewise. ++ (fn_type_unification): Likewise. ++ (current_template_parms): Return a vector of all the template ++ parms, not just the innermost level of parms. ++ (push_template_decl): Deal with the possibility of member ++ templates. ++ (lookup_template_class): Likewise. ++ (uses_template_parms): Likewise. ++ (tsubst): Modify processing to TEMPLATE_TYPE_PARM and ++ TEMPLATE_CONST_PARM to deal with multiple levels of template ++ arguments. Add processing of TEMPLATE_DECL to produce new ++ TEMPLATE_DECLs from old ones. ++ (do_decl_instantiation): Handle member templates. ++ ++ * search.c (lookup_fnfields_1): Handle member template conversion ++ operators. ++ ++ * tree.c (cp_tree_equal): Check the levels, as well as the ++ indices, of TEMPLATE_CONST_PARMs. ++ ++ * typeck.c (comptypes): Check the levels, as well as the indices, ++ fo TEMPLATE_TYPE_PARMs. ++ (build_x_function_call): Treat member templates like member ++ functions. ++ ++Wed Sep 3 11:09:25 1997 Jason Merrill ++ ++ * typeck.c (c_expand_return): Always convert_for_initialization ++ before checking for returning a pointer to local. ++ ++ * pt.c (type_unification): If strict and the function parm doesn't ++ use template parms, just compare types. ++ ++Wed Sep 3 10:35:49 1997 Klaus Espenlaub ++ ++ * method.c (build_overloaded_value): Replace direct call ++ to the floating point emulator with REAL_VALUE_TO_DECIMAL macro. ++ ++Wed Sep 3 00:02:53 1997 Jason Merrill ++ ++ * typeck.c (convert_arguments): Don't arbitrarily choose the first ++ of a set of overloaded functions. ++ ++Tue Sep 2 12:09:13 1997 Jason Merrill ++ ++ * lex.c (real_yylex): Don't elide __FUNCTION__. ++ ++ * method.c (build_overload_value): Add in_template parm. ++ (build_overload_int): Likewise. ++ (build_overload_identifier): Pass it. ++ ++ * decl.c (duplicate_decls): Don't bash a previous template ++ definition with a redeclaration. ++ ++ * pt.c (unify): float doesn't match double. ++ ++ * pt.c (do_type_instantiation): Handle getting a _TYPE or a ++ TYPE_DECL. Handle getting non-template types. ++ * parse.y (explicit_instantiation): Use typespec instead of ++ aggr template_type. ++ ++Tue Sep 2 10:27:08 1997 Richard Henderson ++ ++ * typeck.c (build_ptrmemfunc1): Clean up ptr->int cast warnings. ++ ++Mon Sep 1 13:19:04 1997 Eugene Mamchits ++ ++ * call.c (add_builtin_candidate): Add missing TREE_TYPE. ++ (compare_ics): Likewise. ++ ++Mon Sep 1 13:19:04 1997 Jason Merrill ++ ++ * call.c (joust): Warn about choosing one conversion op over ++ another because of 'this' argument when the other return type is ++ better. ++ (source_type): New fn. ++ ++ * call.c (build_new_op): Strip leading REF_BIND from first operand ++ to builtin operator. ++ ++ * decl2.c (mark_vtable_entries): Mark abort_fndecl as used when we ++ use its RTL. ++ ++Thu Aug 28 09:45:23 1997 Jason Merrill ++ ++ * call.c (null_ptr_cst_p): Remove support for (void*)0. ++ ++Wed Aug 27 02:03:34 1997 Jeffrey A Law ++ ++ * typeck.c (expand_target_expr): Make definition match declaration. ++ ++ * class.c (get_basefndecls): Make definition match declaration. ++ ++Mon Aug 25 14:30:02 1997 Jason Merrill ++ ++ * input.c (sub_getch): Eventually give up and release the input file. ++ ++ * decl.c (cp_finish_decl): If #p i/i, put inline statics in the ++ right place. ++ ++ * call.c (joust): Tweak message. ++ ++Sat Aug 23 18:02:59 1997 Mark Mitchell ++ ++ * error.c (type_as_string): Put const/volatile on template type ++ parameters where appropriate. ++ ++Sat Aug 23 17:47:22 1997 Jeffrey A Law ++ ++ * call.c (strictly_better): Make arguments unsigned ints. ++ ++Thu Aug 21 18:48:44 1997 Jason Merrill ++ ++ * lex.c (real_yylex): Refer to __complex instead of complex. ++ ++Thu Aug 21 22:25:46 1997 J"orn Rennecke ++ ++ * lex.c (real_yylex): Don't use getc directly. ++ ++Wed Aug 20 17:25:08 1997 Jason Merrill ++ ++ * call.c (is_subseq): Don't try to be clever. ++ ++Wed Aug 20 03:13:36 1997 H.J. Lu (hjl@gnu.ai.mit.edu) ++ ++ * parse.y, pt.c: Include "except.h". ++ * call.c, class.c, class.h, cp-tree.h, cvt.c, decl.c, decl2.c, ++ error.c, except.c, expr.c, friend.c, g++spec.c, init.c, input.c, ++ lex.c, lex.h, method.c, parse.y, pt.c, repo.c, rtti.c, search.c, ++ sig.c, spew.c, tree.c, typeck.c, typeck2.c, xref.c: Finish ++ prototyping. ++ ++Wed Aug 20 01:34:40 1997 Jason Merrill ++ ++ * decl2.c (mark_vtable_entries): Instead of replacing pure ++ virtuals with a reference to __pure_virtual, copy the decl and ++ change the RTL. ++ ++Tue Aug 19 02:26:07 1997 Jason Merrill ++ ++ * pt.c (lookup_nested_type_by_name): Handle typedef wierdness. ++ ++ * typeck2.c (my_friendly_abort): Report bugs to egcs-bugs@cygnus.com. ++ ++ * pt.c (instantiate_class_template): Call repo_template_used ++ before finish_prevtable_vardecl. ++ ++ * call.c (is_subseq): New fn. ++ (compare_ics): Use it. ++ ++ * repo.c (finish_repo): Don't crash on no args. ++ ++ * parse.y (named_complex_class_head_sans_basetype): Handle ++ explicit global scope. ++ * decl2.c (handle_class_head): New fn. ++ ++ * pt.c (unify): Add CONST_DECL case. ++ ++Thu Aug 14 10:05:13 1997 Brendan Kehoe ++ ++ * rtti.c (permanent_obstack): Fix decl to not be a pointer. ++ ++ * cp-tree.h (report_type_mismatch): Add prototype. ++ * call.c (build_overload_call_real): Remove erroneous fourth ++ argument to report_type_mismatch. ++ (build_user_type_conversion_1): Remove erroneous second arg to ++ tourney. ++ (build_new_function_call): Likewise. ++ (build_object_call): Likewise. ++ (build_new_op): Likewise. ++ (build_new_method_call): Likewise. ++ ++Wed Aug 13 19:19:25 1997 Jason Merrill ++ ++ * error.c (dump_decl): Don't bother processing a function with no ++ DECL_LANG_SPECIFIC. ++ ++ * method.c (emit_thunk): Call init_function_start in the macro case. ++ ++Wed Aug 13 10:46:19 1997 H.J. Lu (hjl@gnu.ai.mit.edu) ++ ++ * decl2.c (DEFAULT_VTABLE_THUNKS): Define to be 0 if not ++ defined and used to set flag_vtable_thunks. ++ ++Tue Aug 12 20:13:57 1997 Jason Merrill ++ ++ * parse.y: Don't clear the inlines from their obstack until they've ++ all been processed. ++ ++ * decl.c (duplicate_decls): Don't complain about exception ++ specification mismatch if flag_exceptions is off. ++ ++Mon Aug 11 15:01:56 1997 Marc Lehmann ++ ++ * Make-lang.in (c++.distclean): Remove g++.c on make distclean. ++ ++Sun Aug 10 12:06:09 1997 Paul Eggert ++ ++ * cp-tree.h: Replace STDIO_PROTO with PROTO in include files. ++ * cvt.c, error.c, except.c, expr.c, friend.c, init.c, rtti.c: ++ Include before include files that formerly used STDIO_PROTO. ++ ++ * decl.c, g++spec.c, lex.c, method.c, repo.c: ++ Include "config.h" first, as per autoconf manual. ++ ++Fri Aug 8 11:47:48 1997 Jason Merrill ++ ++ * decl.c (duplicate_decls): Tweak wording. ++ * lex.c (do_pending_defargs): Don't die if we see a default arg ++ that isn't a DEFAULT_ARG. ++ * error.c (dump_expr): Handle DEFAULT_ARG. ++ ++ * decl2.c (lang_decode_option): Handle -fhandle-exceptions. ++ * lang-options.h: Add -fhandle-exceptions. ++ ++ * class.c (build_vtable): Vtables are artificial. ++ (prepare_fresh_vtable): Likewise. ++ ++Wed Aug 6 11:02:36 1997 Jason Merrill ++ ++ * cvt.c (ocp_convert): After converting to the target type, set ++ LOOKUP_NO_CONVERSION. ++ ++ * call.c (joust): Warn about potentially confusing promotion rules ++ with -Wsign-promo. ++ * cp-tree.h, lang-options.h, decl2.c: Support -Wsign-promo. ++ ++Tue Aug 5 15:15:07 1997 Michael Meissner ++ ++ * exception.cc: Declare __terminate_func with noreturn attribute. ++ ++Fri Aug 1 03:18:15 1997 Jason Merrill ++ ++ * parse.y: Break out eat_saved_input, handle errors. ++ (function_try_block): Use compstmt instead of compstmt_or_error. ++ ++Thu Jul 31 17:14:04 1997 Jason Merrill ++ ++ * tree.c (build_cplus_new): Don't set TREE_ADDRESSABLE. ++ ++Fri Jul 4 01:45:16 1997 Andreas Schwab ++ ++ * Make-lang.in (cplib2.txt, cplib2.ready): Instead of checking for ++ existence of cc1plus check whether $(LANGUAGES) contains C++. ++ ++Wed Jul 30 13:04:21 1997 Andreas Schwab ++ ++ * method.c (do_build_copy_constructor): When copying an anonymous ++ union member loop around to handle nested anonymous unions. Use ++ the offset of the member relative to the outer structure, not the ++ union. ++ ++Tue Jul 29 21:17:29 1997 Jason Merrill ++ ++ * call.c (resolve_args): New fn. ++ (build_new_function_call): Use it. ++ (build_object_call): Likewise. ++ (build_new_method_call): Likewise. ++ ++Mon Jul 28 16:02:36 1997 Jason Merrill ++ ++ * call.c (build_over_call): tsubst all default parms from templates. ++ ++Wed Jul 23 13:36:25 1997 Jason Merrill ++ ++ * decl.c (struct cp_function): Add static_labelno. ++ (push_cp_function_context): Save it. ++ (pop_cp_function_context): Restore it. ++ ++Tue Jul 22 14:43:29 1997 Jason Merrill ++ ++ * typeck.c (build_component_ref_1): Convert from reference. ++ ++Tue Jul 22 11:06:23 1997 Brendan Kehoe ++ ++ * parse.y (current_declspecs, prefix_attributes): Initialize to ++ NULL_TREE. ++ ++ * parse.y (initdcl0): Make sure CURRENT_DECLSPECS is non-nil ++ before we try to force it to be a TREE_LIST. ++ (decl): Make sure $1.t is non-nil. ++ ++Sun Jul 20 11:53:07 1997 Jason Merrill ++ ++ * pt.c (uses_template_parms): Handle template first-parse codes. ++ ++ * decl.c (cp_finish_decl): Only warn about user-defined statics. ++ ++Fri Jul 18 17:56:08 1997 Jason Merrill ++ ++ * pt.c (unify): Handle BOOLEAN_TYPE. ++ ++ * cp-tree.h: Lose PARM_DEFAULT_FROM_TEMPLATE. ++ * pt.c (tsubst): Don't set it. ++ * call.c (build_over_call): Use uses_template_parms. ++ ++Thu Jul 17 18:06:30 1997 Jason Merrill ++ ++ * method.c (build_overload_nested_name): Use static_labelno ++ instead of var_labelno. ++ (build_qualified_name): New fn. ++ (build_overload_name): Split out from here. ++ (build_static_name): Use build_qualified_name. ++ * decl.c (cp_finish_decl): Statics in extern inline functions ++ have comdat linkage. ++ (start_function): Initialize static_labelno. ++ ++Thu Jul 17 11:20:17 1997 Benjamin Kosnik ++ ++ * class.c (finish_struct_methods): Add check of warn_ctor_dtor_privacy ++ before "all member functions in class [] are private". ++ ++Wed Jul 16 23:47:08 1997 Jason Merrill ++ ++ * lex.c (do_scoped_id): convert_from_reference. ++ * init.c (build_offset_ref): Likewise. ++ ++Wed Jul 16 12:34:29 1997 Benjamin Kosnik ++ ++ * error.c (dump_expr): Check TREE_OPERAND before dump_expr_list. ++ ++Mon Jul 14 03:23:46 1997 Jason Merrill ++ ++ * typeck.c (get_member_function_from_ptrfunc): Promote index ++ before saving it. ++ ++Sun Jul 13 00:11:52 1997 Jason Merrill ++ ++ * tree.c (layout_basetypes): Move non-virtual destructor warning. ++ * decl.c (xref_basetypes): Remove non-virtual destructor warning. ++ ++Sat Jul 12 12:47:12 1997 Jason Merrill ++ ++ * decl.c (grokdeclarator): Call add_defarg_fn for the function ++ type, too. ++ * lex.c (add_defarg_fn): Adjust. ++ (do_pending_defargs): Adjust. Don't skip the first parm. ++ ++Fri Jul 11 01:39:50 1997 Jason Merrill ++ ++ * decl.c (build_enumerator): Global enumerators are also readonly. ++ ++ * rtti.c (build_dynamic_cast_1): Renamed from build_dynamic_cast. ++ (build_dynamic_cast): Call it and convert_from_reference. ++ ++ * lex.c (add_defarg_fn): New fn. ++ (snarf_defarg): Don't add to defarg_types. ++ (do_pending_defargs): Lose defarg_types. All fns we process now ++ have defargs. ++ * decl.c (grokfndecl): Call add_defarg_fn. ++ ++ * Makefile.in (CONFLICTS): Expect 18 s/r conflicts. ++ * cp-tree.def: Add DEFAULT_ARG. ++ * spew.c (yylex): Call snarf_defarg as appropriate. ++ * parse.y: New tokens DEFARG and DEFARG_MARKER. ++ (defarg_again, pending_defargs, defarg, defarg1): New rules. ++ (structsp): Use pending_defargs. ++ (parms, full_parm): Use defarg. ++ * lex.c (init_lex): Initialize inline_text_firstobj. ++ (do_pending_inlines): Never pass the obstack to feed_input. ++ (process_next_inline): Call end_input instead of restore_pending_input. ++ (clear_inline_text_obstack, reinit_parse_for_expr, do_pending_defargs, ++ finish_defarg, feed_defarg, snarf_defarg, maybe_snarf_defarg): New fns. ++ * input.c (end_input): New fn. ++ (sub_getch): At the end of some fed input, just keep returning EOF ++ until someone calls end_input. ++ Remove 'obstack' field from struct input_source. ++ * decl.c (grokparms): Handle DEFAULT_ARG. ++ (replace_defarg): New fn. ++ * cp-tree.h (DEFARG_LENGTH, DEFARG_POINTER): New macros. ++ ++Wed Jul 9 13:44:12 1997 Jason Merrill ++ ++ * call.c (implicit_conversion): If nothing else works, try binding ++ an rvalue to a reference. ++ ++Wed Jul 9 13:04:38 1997 Geoffrey Noer ++ ++ * decl.c (init_decl_processing): Fix Jun 30 patch -- move ++ ifndef for Cygwin32 to include SIGSEGV. ++ ++Thu Jul 3 01:44:05 1997 Jason Merrill ++ ++ * class.c (finish_struct_1): Only complain about pointers without ++ copy stuff if there are any constructors. ++ ++ * rtti.c (build_dynamic_cast): Call complete_type on the types. ++ ++ * decl.c (grokfndecl): If the function we chose doesn't actually ++ match, die. ++ ++ * decl2.c (grokclassfn): Don't specify 'const int' for the ++ artificial destructor parm. ++ ++ * pt.c (type_unification): If we are called recursively, nothing ++ decays. ++ ++Mon Jun 30 17:53:21 1997 Geoffrey Noer ++ ++ * decl.c (init_decl_processing): Stop trying to catch signals ++ other than SIGABRT since the Cygwin32 library doesn't support ++ them correctly yet. This fixes a situation in which g++ causes ++ a hang on SIGSEGVs and other such signals in our Win32-hosted ++ tools. ++ ++Mon Jun 30 14:50:01 1997 Jason Merrill ++ ++ * tree.c (mapcar, case CALL_EXPR): Handle all the parse node data. ++ ++Fri Jun 27 15:18:49 1997 Jason Merrill ++ ++ * typeck2.c (store_init_value): Always return the value if our ++ type needs constructing. ++ ++ * method.c (hack_identifier): Convert class statics from ++ reference, too. ++ ++Thu Jun 26 11:44:46 1997 Jason Merrill ++ ++ * Make-lang.in (cplib2.ready): Add $(LANGUAGES) dependency. ++ ++Thu Jun 19 16:49:28 1997 Mike Stump ++ ++ * typeck.c (c_expand_return): Make sure we clean up temporaries at ++ the end of return x; ++ ++Thu Jun 19 12:28:43 1997 Brendan Kehoe ++ ++ * lex.c (check_for_missing_semicolon): Also check for CV_QUALIFIER. ++ ++Tue Jun 17 18:35:57 1997 Mike Stump ++ ++ * except.c (expand_builtin_throw): Add support ++ -fno-sjlj-exceptions -fPIC exception handling on the SPARC. ++ ++Mon Jun 16 01:24:37 1997 Jason Merrill ++ ++ * repo.c (extract_string): Null-terminate. ++ ++ * cp-tree.h (TI_SPEC_INFO): New macro. ++ (CLASSTYPE_TI_SPEC_INFO): New macro. ++ * pt.c (push_template_decl): Correctly determine # of template parms ++ for partial specs. ++ ++ * call.c (compare_ics): Really fix 'this' conversions. ++ ++ * pt.c (do_decl_instantiation): Don't crash on explicit inst of ++ non-template fn. ++ ++ * pt.c (push_template_decl): Complain about mismatch in # of ++ template parms between a class template and a member template. ++ ++Sun Jun 15 02:38:20 1997 Jason Merrill ++ ++ * method.c (synthesize_method): You can't call ++ function_cannot_inline_p after finish_function. ++ * decl.c (finish_function): Turn on flag_inline_functions and turn ++ off DECL_INLINE before handing a synthesized method to the ++ backend. ++ ++Thu Jun 12 17:35:28 1997 Jason Merrill ++ ++ * method.c (synthesize_method): Remove July 30 change to never set ++ DECL_INLINE if at_eof. ++ ++Thu Jun 12 15:25:08 1997 Mike Stump ++ ++ * xref.c (GNU_xref_member): Ensure that the node has a ++ decl_lang_specific part before checking DECL_FRIEND_P. ++ ++Thu Jun 12 12:36:05 1997 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Diagnose non-class types used ++ as bases. ++ ++Wed Jun 11 17:33:40 1997 Jason Merrill ++ ++ * typeck.c (build_conditional_expr): Use convert_for_initialization ++ instead of convert_and_check. ++ ++Wed Jun 11 12:31:33 1997 Brendan Kehoe ++ ++ * parse.y (typespec): Don't pedwarn for typeof. ++ ++Tue Jun 10 00:22:09 1997 Jason Merrill ++ ++ * repo.c (finish_repo): Only check changes if we would write a ++ repo file. ++ ++ * call.c (compare_ics): Fix handling of 'this' conversions. ++ ++ * pt.c (do_decl_instantiation): Support static data too. Rename ++ from do_function_instantiation. ++ * cp-tree.h: Adjust. ++ * parse.y: Adjust. ++ ++ * repo.c (extract_string): New fn. ++ (get_base_filename): Use it. ++ (init_repo): Compare old args with current args. ++ ++Mon Jun 9 14:25:30 1997 Mike Stump ++ ++ * Makefile.in, Make-lang.in: Protect C-ls with a comment ++ character, idea from Paul Eggert . ++ ++Mon Jun 9 01:52:03 1997 Jason Merrill ++ ++ * typeck.c (c_expand_return): Be more persistent in looking for ++ returned temps. ++ ++ * cvt.c (build_up_reference): Use NOP_EXPR for switching from ++ pointer to reference. ++ ++ * class.c (build_vbase_path): Don't do anything if PATH has no steps. ++ ++Sun Jun 8 03:07:05 1997 Jason Merrill ++ ++ * init.c (build_member_call, build_offset_ref): ++ Use do_scoped_id instead of do_identifier. ++ ++ * cvt.c (convert): Remove bogosity. ++ ++Sat Jun 7 20:50:17 1997 Brendan Kehoe ++ ++ * cvt.c (build_up_reference): Do checks of ARGTYPE and ++ TARGET_TYPE before trying to use get_binfo. ++ ++Fri Jun 6 17:36:39 1997 Jason Merrill ++ ++ * cvt.c (build_up_reference): Call get_binfo to get access control. ++ ++ * decl2.c (import_export_decl): If we don't support weaks, leave ++ statics undefined. ++ ++Fri Jun 6 15:55:49 1997 Mike Stump ++ ++ * except.c (expand_builtin_throw): Add support for machines that ++ cannot access globals after throw's epilogue when ++ -fno-sjlj-exceptions is used. ++ ++Thu Jun 5 16:28:43 1997 Jason Merrill ++ ++ * parse.y: 'std::' becomes '::'. ++ * lex.c (real_yylex): Remove 'namespace' warning. ++ * init.c (build_member_call): Ignore 'std::'. ++ (build_offset_ref): Likewise. ++ * decl2.c (do_using_directive): Ignore 'using namespace std;'. ++ (do_toplevel_using_decl): Ignore 'using std::whatever'. ++ * decl.c (push_namespace): Just sorry. ++ (pop_namespace): Nop. ++ (init_decl_processing): Declare std namespace. ++ ++Tue Jun 3 18:08:23 1997 Jason Merrill ++ ++ * search.c (push_class_decls): A name which ambiguously refers to ++ several instantiations of the same template just refers to the ++ template. ++ ++Tue Jun 3 12:30:40 1997 Benjamin Kosnik ++ ++ * decl.c (build_enumerator): Fix problem with unsigned long ++ enumerated values being smashed to ints, causing overflow ++ when computing next enumerated value (for enum values around ++ MAX_VAL). ++ ++Mon Jun 2 17:40:56 1997 Jason Merrill ++ ++ * typeck.c (build_component_ref): Only call mark_used on a decl. ++ ++Thu May 29 15:54:17 1997 Brendan Kehoe ++ ++ * typeck.c (build_c_cast): Make the check for a ptr to function ++ more specific before possible default_conversion call. ++ ++Thu May 29 13:02:06 1997 Mike Stump ++ ++ * except.c (expand_exception_blocks): Simplify and fix and make ++ sure we don't end a region in a sequence, as expand_end_bindings ++ doesn't like it. ++ ++Wed May 28 17:08:03 1997 Mike Stump ++ ++ * except.c (init_exception_processing): Mark terminate as not ++ returning so that the optimizer can optimize better. ++ ++Tue May 27 19:49:19 1997 Mike Stump ++ ++ * cvt.c (convert): Don't do any extra work, if we can avoid it ++ easily. ++ ++Tue May 27 18:21:47 1997 Mike Stump ++ ++ * *.[chy]: Change cp_convert to ocp_convert, change convert to ++ cp_convert. convert is now reserved for the backend, and doesn't ++ have the semantics a frontend person should ever want. ++ ++Fri May 23 10:58:31 1997 Jason Merrill ++ ++ * lang-specs.h: Define __EXCEPTIONS if exceptions are enabled. ++ Lose -traditional support. ++ ++Thu May 22 15:41:28 1997 Jason Merrill ++ ++ * rtti.c (get_tinfo_var): Use TYPE_PRECISION (sizetype). ++ ++ * parse.y (self_reference): Do it for templates, too. ++ * class.c (pushclass): Don't overload_template_name; the alias ++ generated by build_self_reference serves the same purpose. ++ ++ * tree.c (list_hash): Make static, take more args. ++ (list_hash_lookup): Likewise. ++ (list_hash_add): Make static. ++ (list_hash_canon): Lose. ++ (hash_tree_cons): Only build a new node if one isn't already in the ++ hashtable. ++ (hash_tree_chain): Use hash_tree_cons. ++ * cp-tree.h: Adjust. ++ * decl.c (grokfndecl): Just check IDENTIFIER_GLOBAL_VALUE instead ++ of calling lookup_name. ++ ++Wed May 21 18:24:19 1997 Jason Merrill ++ ++ * pt.c (instantiate_class_template): TYPE_VALUES for an enum ++ doesn't refer to the CONST_DECLs. ++ ++Tue May 20 21:09:32 1997 Bob Manson ++ ++ * rtti.c (get_tinfo_var): Either INT_TYPE_SIZE or 32, whichever ++ is bigger. ++ (expand_class_desc): Convert the last argument to a sizetype. ++ ++Tue May 20 13:55:57 1997 Brendan Kehoe ++ ++ * gxx.gperf (__complex, __complex__, __imag, __imag__, __real, ++ __real__): Add reswords. ++ * hash.h: Regenerate. ++ * lex.h (rid): Add RID_COMPLEX. ++ (RID_LAST_MODIFIER): Set to RID_COMPLEX. ++ * lex.c (init_lex): Add building of RID_COMPLEX. ++ (real_yylex): General cleanup in line with what c-lex.c also has, ++ sans the cruft for traditional; add handling of SPEC_IMAG, complex ++ types, and imaginary numeric constants. ++ * parse.y (REALPART, IMAGPART): Add tokens. ++ (unary_expr): Add REALPART and IMAGPART rules. ++ * cp-tree.h (complex_{integer,float,double,long}_type_node): Declare. ++ * decl.c (complex_{integer,float,double,long}_type_node): Define ++ types. ++ (init_decl_processing): Set up the types. ++ (grokdeclarator): Add handling of RID_COMPLEX. Set and use ++ DEFAULTED_INT instead of EXPLICIT_INT when we default to int type. ++ * call.c (build_new_op): Add REALPART_EXPR and IMAGPART_EXPR cases. ++ * cvt.c (cp_convert): Handle COMPLEX_TYPE. ++ * error.c (dump_type_prefix, dump_type, dump_type_suffix): Add ++ COMPLEX_TYPE case. ++ * method.c (build_overload_name): Add handling of the different ++ COMPLEX_TYPEs, prefixing them with `J'. ++ * pt.c (process_template_parm): Don't let them use a COMPLEX_TYPE ++ as a template parm. ++ (uses_template_parms, tsubst, unify): Add COMPLEX_TYPE case. ++ * tree.c (lvalue_p): Add REALPART_EXPR and IMAGPART_EXPR cases. ++ (mapcar): Handle COMPLEX_CST. ++ * typeck.c (build_binary_op_nodefault): Handle COMPLEX_TYPE. ++ (common_type): Add code for complex types. ++ (build_unary_op): Add REALPART_EXPR and IMAGPART_EXPR cases. ++ (convert_for_assignment): Likewise. ++ (mark_addressable): Add REALPART_EXPR and IMAGPART_EXPR cases. ++ ++Mon May 19 12:26:27 1997 Jason Merrill ++ ++ * pt.c (tsubst): Don't pass the MINUS_EXPR for an array domain to ++ tsubst_expr, as it might try to do overload resolution. ++ ++Sat May 17 10:48:31 1997 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Oops. ++ ++Fri May 16 14:23:57 1997 Jason Merrill ++ ++ * cp-tree.def: Add TAG_DEFN. ++ * pt.c (tsubst_enum): New fn. ++ (instantiate_class_template): Use it. ++ (tsubst_expr): Support TAG_DEFN. ++ (tsubst): Support local enums. ++ (tsubst_copy): Likewise. ++ * decl.c (finish_enum): Likewise. ++ (start_enum): If this is a local enum, switch to permanent_obstack. ++ ++Wed May 14 19:08:28 1997 Mike Stump ++ ++ * decl.c (store_parm_decls): Set last_parm_cleanup_insn here. ++ (finish_function): Put the base init code for constructors just ++ after the parm cleanup insns. ++ (struct cp_function): Add last_parm_cleanup_insn. ++ (push_cp_function_context): Likewise. ++ (pop_cp_function_context): Likewise. ++ ++Tue May 13 15:51:20 1997 Jason Merrill ++ ++ * pt.c (tsubst_copy): Handle BIT_NOT_EXPR. ++ ++Wed May 7 11:17:59 1997 Brendan Kehoe ++ ++ * method.c (emit_thunk) [ASM_OUTPUT_MI_THUNK]: Build up the RTL ++ for THUNK_FNDECL before we switch to temporary allocation. ++ ++Mon May 5 14:46:53 1997 Jason Merrill ++ ++ * call.c (build_new_op): Handle null arg2 for ?:. ++ ++Thu May 1 18:26:37 1997 Mike Stump ++ ++ * except.c (expand_exception_blocks): Ensure that we flow through ++ the end of the exception region for the exception specification. ++ Move exception region for the exception specification in, so that ++ it doesn't protect the parm cleanup. Remove some obsolete code. ++ * decl.c (store_parm_decls): Likewise. ++ (finish_function): Likewise. ++ ++Tue Apr 29 15:38:54 1997 Jason Merrill ++ ++ * init.c (build_new): Fix nothrow handling. ++ ++Tue Apr 29 14:29:50 1997 Brendan Kehoe ++ ++ * init.c (emit_base_init): Don't warn about the initialization ++ list for an artificial member. ++ ++Fri Apr 25 17:47:59 1997 Brendan Kehoe ++ ++ * expr.c (do_case): Handle !START case for the error msg. ++ ++Fri Apr 25 11:55:23 1997 Jason Merrill ++ ++ * decl2.c, lang-options.h: New option -Weffc++. ++ * class.c, decl.c, init.c, typeck.c: Move Effective C++ warnings ++ to -Weffc++. ++ ++ * decl2.c (finish_prevtable_vardecl): Change NO_LINKAGE_HEURISTICS ++ to MULTIPLE_SYMBOL_SPACES. ++ ++Wed Apr 23 18:06:50 1997 Jason Merrill ++ ++ * method.c (emit_thunk, generic case): Set current_function_is_thunk. ++ ++ * method.c (emit_thunk, macro case): Set up DECL_RESULT. ++ ++ * typeck.c (c_expand_return): Don't complain about returning void ++ to void in an artificial function. ++ * method.c (make_thunk): Change settings of READONLY/VOLATILE, ++ don't set DECL_RESULT, set DECL_ARTIFICIAL. ++ (emit_thunk, generic code): Also set up DECL_LANG_SPECIFIC. ++ ++Wed Apr 23 14:43:06 1997 Mike Stump ++ ++ * init.c (init_decl_processing): Add support for setjmp/longjmp based ++ exception handling. ++ * except.c (init_exception_processing): Likewise. ++ (expand_end_catch_block): Likewise. ++ (expand_exception_blocks): Likewise. ++ (expand_throw): Likewise. ++ * exception.cc (__default_terminate): Likewise. ++ ++ * init.c (perform_member_init): Use new method of expr level ++ cleanups, instead of cleanups_this_call and friends. ++ (emit_base_init): Likewise. ++ (expand_aggr_vbase_init_1): Likewise. ++ (expand_vec_init): Likewise. ++ * decl.c (cp_finish_decl): Likewise. ++ (expand_static_init): Likewise. ++ (store_parm_decls): Likewise. ++ (cplus_expand_expr_stmt): Likewise. ++ * decl2.c (finish_file): Likewise. ++ ++ * Make-lang.in (exception.o): Ok to compile with -O now. ++ ++ * decl.c (maybe_build_cleanup_1): We no longer have to unsave, as ++ we know it will be done later by the backend. ++ ++ * decl2.c (lang_f_options): Remove support for short temps. ++ * lang-options.h: Likewise. ++ ++Wed Apr 23 04:12:06 1997 Jason Merrill ++ ++ * tree.c (varargs_function_p): New fn. ++ * method.c (emit_thunk): Replace broken generic code with code to ++ generate a heavyweight thunk function. ++ ++Tue Apr 22 02:45:18 1997 Jason Merrill ++ ++ * pt.c (process_template_parm): pedwarn about floating-point parms. ++ ++ * decl.c (grokdeclarator): inline no longer implies static. ++ ++ * spew.c (yylex): Always return the TYPE_DECL if we got a scope. ++ ++Mon Apr 21 15:42:27 1997 Jason Merrill ++ ++ * class.c (check_for_override): The signature of an overriding ++ function is not changed. ++ ++ * call.c (build_over_call): Move setting of conv into the loop. ++ Note: this change, along with the related changes of the 18th thru ++ the 20th of April, fix an infinite loop problem in conversions. ++ ++Sun Apr 20 16:24:29 1997 Jason Merrill ++ ++ * call.c (build_user_type_conversion_1): Really ignore rvalue ++ conversions when looking for a REFERENCE_TYPE. ++ ++ * cvt.c (build_up_reference): Eviscerate, use build_unary_op. ++ * cp-tree.h (TREE_REFERENCE_EXPR): #if 0. ++ * typeck.c (decay_conversion): Don't set TREE_REFERENCE_EXPR. ++ (build_unary_op): Likewise. ++ * call.c (build_over_call): See through a CONVERT_EXPR around the ++ ADDR_EXPR for on a temporary. ++ * typeck.c (c_expand_return): See through a CONVERT_EXPR around ++ the ADDR_EXPR for a local variable. ++ ++Fri Apr 18 12:11:33 1997 Jason Merrill ++ ++ * call.c (build_user_type_conversion_1): If we're trying to ++ convert to a REFERENCE_TYPE, only consider lvalue conversions. ++ (build_new_function_call): Print candidates. ++ (implicit_conversion): Try a temp binding if the lvalue conv is BAD. ++ (reference_binding): Binding a temporary of a reference-related type ++ is BAD. ++ ++Thu Apr 17 14:37:22 1997 Brendan Kehoe ++ ++ * inc/typeinfo (type_info::before): Add cv-qualifier-seq. ++ * tinfo2.cc (type_info::before): Likewise. ++ ++Mon Apr 14 12:38:17 1997 Jason Merrill ++ ++ * call.c (implicit_conversion): Oops. ++ ++Fri Apr 11 02:18:30 1997 Jason Merrill ++ ++ * call.c (implicit_conversion): Try to find a reference conversion ++ before binding a const reference to a temporary. ++ ++Wed Apr 2 12:51:36 1997 Mike Stump ++ ++ * exception.cc (__default_unexpected): Call terminate by default, ++ so that if the user overrides terminate, the correct function will ++ be called. ++ ++Wed Mar 19 14:14:45 1997 Mike Stump ++ ++ * parse.y (left_curly): Avoid trying to use any fields of ++ error_mark_node, as there aren't any. ++ ++Thu Mar 13 16:33:22 1997 Jason Merrill ++ ++ * lex.c (do_identifier): Avoid breaking on overloaded methods ++ as default arguments. ++ ++Wed Mar 12 13:55:10 1997 Hans-Peter Nilsson ++ ++ * call.c (add_template_candidate): Initialize the variable "dummy". ++ ++Mon Mar 10 15:13:14 1997 Brendan Kehoe ++ ++ * decl.c (start_decl): Make sure TYPE isn't an error_mark_node ++ before we try to use TYPE_SIZE and TREE_CONSTANT on it. ++ ++Fri Mar 7 13:19:36 1997 Brendan Kehoe ++ ++ * cp-tree.h (comp_ptr_ttypes, more_specialized): Add decl. ++ (debug_binfo): Delete decl, not needed. ++ ++ * tree.c (fnaddr_from_vtable_entry, function_arg_chain, ++ promotes_to_aggr_type): Delete fns. ++ * cp-tree.h (FNADDR_FROM_VTABLE_ENTRY, ++ SET_FNADDR_FROM_VTABLE_ENTRY, FUNCTION_ARG_CHAIN, ++ PROMOTES_TO_AGGR_TYPE): Delete alternates to #if 1. ++ ++ * decl.c (pending_invalid_xref{,_file,_line}): Delete unused vars. ++ ++ * friend.c (is_friend_type): Delete fn. ++ * cp-tree.h (is_friend_type): Delete decl. ++ ++ * decl.c (original_result_rtx, double_ftype_double, ++ double_ftype_double_double, int_ftype_int, long_ftype_long, ++ float_ftype_float, ldouble_ftype_ldouble, last_dtor_insn): Make static. ++ * typeck.c (original_result_rtx, warn_synth): Delete extern decls. ++ ++ * decl.c (push_overloaded_decl{,_top_level}): Make static, adding ++ fwd decls. ++ * cp-tree.h (push_overloaded_decl{,_top_level}): Delete decls. ++ ++ * decl.c (pushdecl_nonclass_level): #if 0, unused. ++ * cp-tree.h (pushdecl_nonclass_level): #if 0 decl. ++ ++ * lex.c (reinit_lang_specific): #if 0, unused. ++ * cp-tree.h (reinit_lang_specific): #if 0 decl. ++ ++ * decl.c (revert_static_member_fn): Make static, adding fwd decl. ++ * cp-tree.h (revert_static_member_fn): Delete decl. ++ ++ * class.c (root_lang_context_p): Delete fn. ++ * cp-tree.h (root_lang_context_p): Delete decl. ++ ++ * decl.c (set_current_level_tags_transparency): #if 0, unused. ++ * cp-tree.h (set_current_level_tags_transparency): #if 0 decl. ++ ++ * lex.c (set_vardecl_interface_info): Make static. ++ * cp-tree.h (set_vardecl_interface_info): Delete decl. ++ ++ * call.c (find_scoped_type): Make static. ++ * cp-tree.h (find_scoped_type): Delete decl. ++ ++ * search.c (convert_pointer_to_vbase): Make static. ++ * cp-tree.h (convert_pointer_to_vbase): Delete decl. ++ ++ * decl.c (const_ptr_type_node): Likewise. ++ * cp-tree.h (const_ptr_type_node): Delete decl. ++ ++ * typeck.c (common_base_type): Make static. ++ * cp-tree.h (common_base_types): Delete erroneous decl. ++ ++ * pt.c (classtype_mangled_name): Make static. ++ * cp-tree.h (classtype_mangled_name): Delete decl. ++ ++ * lex.c (check_newline): Make static. ++ * cp-tree.h (check_newline): Delete decl. ++ ++ * typeck.c (build_x_array_ref): Delete fn, same idea as ++ grok_array_decl. ++ * cp-tree.h (build_x_array_ref): Delete decl. ++ ++ * lex.c (copy_decl_lang_specific): Delete fn, same idea as ++ copy_lang_decl. ++ * cp-tree.h (copy_decl_lang_specific): #if 0 decl. ++ ++ * class.c (build_vtable_entry): Make static. ++ * cp-tree.h (build_vtable_entry): Delete decl. ++ ++ * class.c (build_vbase_pointer): Make static. ++ * cp-tree.h (build_vbase_pointer): Delete decl. ++ ++ * sig.c (build_sptr_ref): Add forward decl and make static. ++ * cp-tree.h (build_sptr_ref): Delete decl. ++ ++ * call.c (build_new_method_call): Add forward decl and make static. ++ * cp-tree.h (build_new_method_call): Delete decl. ++ ++ * call.c (build_object_call): Make static. ++ * class.c (check_for_override, complete_type_p, mark_overriders): ++ Likewise. ++ * decl.c (cp_function_chain): Likewise. ++ * lex.c (set_typedecl_interface_info, reinit_parse_for_block): ++ Likewise. ++ * pt.c (comp_template_args, get_class_bindings, push_tinst_level): ++ Likewise. ++ * tree.c (build_cplus_array_type_1): Likewise. ++ * typeck.c (comp_ptr_ttypes_{const,real,reinterpret}): Likewise. ++ (comp_target_parms): Likewise. ++ ++ * init.c (build_builtin_call): Make static. ++ * cp-tree.h (build_builtin_call): Delete decl. ++ ++ * typeck.c (binary_op_error): Delete decl. ++ * cp-tree.h (binary_op_error): Likewise. ++ ++Thu Mar 6 16:13:52 1997 Brendan Kehoe ++ ++ * call.c (build_method_call): Compare against error_mark_node ++ directly, rather than the ERROR_MARK tree code. ++ * cvt.c (cp_convert): Likewise. ++ * decl.c (print_binding_level): Likewise. ++ (duplicate_decls): Likewise. ++ (grokdeclarator): Likewise. ++ (grokdeclarator): Likewise. ++ * init.c (expand_aggr_init_1): Likewise. ++ (decl_constant_value): Likewise. ++ * method.c (build_opfncall): Likewise. ++ (hack_identifier): Likewise. ++ * typeck.c (build_modify_expr): Likewise. ++ ++ * typeck.c (build_c_cast): Don't decl TYPE as register tree. ++ ++Sun Mar 2 02:54:36 1997 Bruno Haible ++ ++ * pt.c (unify): Strip NOP_EXPR wrappers before unifying integer values. ++ ++ * pt.c (coerce_template_parms): Add new error message. ++ ++ * method.c (build_overload_value): Implement name mangling for ++ floating-point template arguments. ++ ++ * method.c (build_overload_int, icat, dicat): Fix mangling of template ++ arguments whose absolute value doesn't fit in a signed word. ++ ++Mon Mar 3 12:14:54 1997 Brendan Kehoe ++ ++ * friend.c: New file; put all of the friend stuff in here. ++ * init.c: Instead of here. ++ * Makefile.in (CXX_OBJS): Add friend.o. ++ (friend.o): Add dependencies. ++ * Make-lang.in (CXX_SRCS): Add $(srcdir)/cp/friend.c. ++ ++Sun Mar 2 11:04:43 1997 Jason Merrill ++ ++ * call.c (build_scoped_method_call): Complain if the scope isn't a ++ base. ++ ++Wed Feb 26 11:31:06 1997 Jason Merrill ++ ++ * parse.y (left_curly): Don't crash on erroneous type. ++ ++ * init.c (build_delete): Fix type of ref. ++ ++Tue Feb 25 12:41:48 1997 Jason Merrill ++ ++ * search.c (get_vbase_1): Renamed from get_vbase. ++ (get_vbase): Wrapper, now non-static. ++ (convert_pointer_to_vbase): Now static. ++ ++ * call.c (build_scoped_method_call): Accept a binfo for BASETYPE. ++ * init.c (build_delete): Pass one. ++ (build_partial_cleanup_for): Use build_scoped_method_call. ++ * decl.c (finish_function): Pass a binfo. ++ ++Mon Feb 24 15:00:12 1997 Jason Merrill ++ ++ * call.c (build_over_call): Only synthesize non-trivial copy ctors. ++ ++ * typeck.c (build_c_cast): Lose other reference to flag. ++ ++ * call.c (build_field_call): Don't look for [cd]tor_identifier. ++ * decl2.c (delete_sanity): Remove meaningless use of ++ LOOKUP_HAS_IN_CHARGE. ++ * decl.c (finish_function): Use build_scoped_method_call instead ++ of build_delete for running vbase dtors. ++ * init.c (build_delete): Call overload resolution code instead of ++ duplicating it badly. ++ ++Thu Feb 20 15:12:15 1997 Jason Merrill ++ ++ * call.c (build_over_call): Call mark_used before trying to elide ++ the call. ++ ++ * decl.c (implicitly_declare): Don't set DECL_ARTIFICIAL. ++ ++Wed Feb 19 11:18:53 1997 Brendan Kehoe ++ ++ * typeck.c (build_modify_expr): Always pedwarn for a cast to ++ non-reference used as an lvalue. ++ ++Wed Feb 19 10:35:37 1997 Jason Merrill ++ ++ * cvt.c (cp_convert_to_pointer): Convert from 0 to a pmf properly. ++ ++Tue Feb 18 15:40:57 1997 Jason Merrill ++ ++ * parse.y (handler): Fix template typo. ++ ++Sun Feb 16 02:12:28 1997 Jason Merrill ++ ++ * error.c (lang_decl_name): New fn. ++ * tree.c (lang_printable_name): Use it. ++ ++Fri Feb 14 16:57:05 1997 Mike Stump ++ ++ * g++spec.c: Include config.h so that we can catch bzero #defines ++ from the config file. ++ ++Tue Feb 11 13:50:48 1997 Mike Stump ++ ++ * new1.cc: Include a declaration for malloc, to avoid warning, and ++ avoid lossing on systems that require one (ones that define malloc ++ in xm.h). ++ ++Mon Feb 10 22:51:13 1997 Bruno Haible ++ ++ * decl2.c (max_tinst_depth): New variable. ++ (lang_decode_option): Parse "-ftemplate-depth-NN" command line ++ option. ++ * pt.c (max_tinst_depth): Variable moved. ++ * lang-options.h: Declare "-ftemplate-depth-NN" command line option ++ as legal. ++ ++Fri Feb 7 15:43:34 1997 Jason Merrill ++ ++ * decl.c (xref_basetypes): Allow a base class that depends on ++ template parms to be incomplete. ++ ++ * decl2.c (build_expr_from_tree): Support typeid(type). ++ * rtti.c (get_typeid): Support templates. ++ (expand_si_desc, expand_class_desc): Fix string length. ++ (expand_ptr_desc, expand_attr_desc, expand_generic_desc): Likewise. ++ ++Tue Feb 4 11:28:24 1997 Jason Merrill ++ ++ * pt.c (unify, case TEMPLATE_CONST_PARM): Use cp_tree_equal. ++ ++ * pt.c (tsubst): Put it back for -fno-ansi-overloading. ++ ++Mon Feb 3 18:41:12 1997 Jason Merrill ++ ++ * pt.c (tsubst, case FUNCTION_DECL): Lose obsolete code that ++ smashes together template and non-template decls of the same ++ signature. ++ ++Thu Jan 30 19:18:00 1997 Jason Merrill ++ ++ * pt.c (tsubst): Don't recurse for the type of a TYPENAME_TYPE. ++ ++Wed Jan 29 11:40:35 1997 Brendan Kehoe ++ ++ * decl.c (duplicate_decls): Next route, pedwarn about different ++ exceptions if -pedantic *or* olddecl !DECL_IN_SYSTEM_HEADER. ++ ++Tue Jan 28 20:43:29 1997 Brendan Kehoe ++ ++ * cp-tree.h (HAS_DEFAULT_IMPLEMENTATION): Delete macro. ++ (struct lang_type): Delete has_default_implementation member. ++ Increase dummy to 21. ++ * decl.c (start_method): Delete usage. ++ ++ * cp-tree.h (build_call, null_ptr_cst_p, in_function_p, ++ store_after_parms, start_decl_1, auto_function): Add decls. ++ (get_arglist_len_in_bytes, declare_implicit_exception, ++ have_exceptions_p, make_type_decl, typedecl_for_tag, ++ store_in_parms, pop_implicit_try_blocks, push_exception_cleanup, ++ build_component_type_expr, cplus_exception_name, ++ {make,clear}_anon_parm_name, dont_see_typename): Removed decls. ++ * call.c (build_this): Make static. ++ (is_complete): Likewise. ++ (implicit_conversion): Likewise. ++ (reference_binding): Likewise. ++ (standard_conversion): Likewise. ++ (strip_top_quals): Likewise. ++ (non_reference): Likewise. ++ (build_conv): Likewise. ++ (user_harshness): Likewise. ++ (rank_for_ideal): Likewise. ++ * decl.c (start_decl_1): Delete forward decl. ++ (push_decl_level): Make static. ++ (resume_binding_level): Make static. ++ (namespace_bindings_p): Make static. ++ (declare_namespace_level): Make static. ++ (lookup_name_real): Make static. ++ (duplicate_decls): Make static. Take register off NEWDECL and ++ OLDDECL parm decls. ++ * decl2.c (get_sentry): Make static. ++ (temp_name_p): Delete fn. ++ * except.c (auto_function): Delete decl. ++ * lex.c (handle_{cp,sysv}_pragma): Make static. ++ (handle_sysv_pragma) [HANDLE_SYSV_PRAGMA]: Add forward decl. ++ * method.c (do_build_{copy_constructor,assign_ref}): Make static. ++ * pt.c (tsubst_expr_values): Make static. ++ * rtti.c (combine_strings): Delete decl. ++ ++Tue Jan 28 16:40:40 1997 Jason Merrill ++ ++ * pt.c (push_template_decl): Handle getting a typedef. ++ ++ * call.c (build_new_function_call): Complain about void arg. ++ ++Tue Jan 28 15:25:09 1997 Brendan Kehoe ++ ++ * decl.c (duplicate_decls): Give pedwarn of different exceptions ++ if -pedantic, instead of olddecl !DECL_IN_SYSTEM_HEADER. ++ ++Mon Jan 27 19:21:29 1997 Mike Stump ++ ++ * except.c (expand_throw): Don't expand the cleanup tree here, ++ since we are not going to write the rtl out. Fixes problem with ++ -g -O on SPARC. ++ ++Mon Jan 27 16:24:35 1997 Sean McNeil ++ ++ * Make-lang.in: Add $(exeext) as necessary. ++ ++Mon Jan 27 13:20:39 1997 Mike Stump ++ ++ * parse.y (handler_seq): Must have at least one catch clause. ++ ++Sat Jan 25 12:00:05 1997 Jason Merrill ++ ++ * call.c (add_builtin_candidate): Restore ?: hack. ++ ++ * decl.c (grok_op_properties): More warnings. ++ ++Sat Jan 25 08:50:03 1997 Brendan Kehoe ++ ++ * decl.c (duplicate_decls): On second thought, do it as a pedwarn ++ still but only if !DECL_IN_SYSTEM_HEADER (olddecl). ++ ++ * decl.c (duplicate_decls): Scale back to a warning, and only do ++ 'em if -pedantic. ++ ++Fri Jan 24 17:52:54 1997 Mike Stump ++ ++ * decl.c (duplicate_decls): pedwarn mismatched exception ++ specifications. ++ ++Thu Jan 23 18:18:54 1997 Mike Stump ++ ++ * call.c (build_new_method_call): Don't display the invisible ++ argument for controlling virtual bases. ++ ++Thu Jan 23 16:48:10 1997 Mike Stump ++ ++ * new: Add nothrow new and delete, bad_alloc and throw specifications ++ for delete. ++ * decl.c (init_decl_processing): Add throw specification for delete. ++ * new.cc (nothrow): Define. ++ * lex.c (real_yylex): Removing warning that throw and friends are ++ keywords. ++ * new1.cc (operator new (size_t sz, const nothrow_t&)): Define. ++ * new2.cc (operator new[] (size_t sz, const nothrow_t&): Define. ++ * Make-lang.in: Add new{1,2}.{cc,o}. ++ ++Thu Jan 23 16:39:06 1997 Jason Merrill ++ ++ * lex.c (cons_up_default_function): Fix return type of synth op=. ++ ++ * init.c (emit_base_init): Add warnings for uninitialized members ++ and bases. ++ ++ * decl.c (xref_basetypes): Add warning for non-polymorphic type ++ with destructor used as base type. ++ ++ * decl.c (grok_op_properties): Add warning for op= returning void. ++ * typeck.c (c_expand_return): Add warning for op= returning anything ++ other than *this. ++ ++ * class.c (finish_struct_1): Add warning for class with pointers ++ but not copy ctor or copy op=. ++ ++ * cp-tree.h (TI_PENDING_TEMPLATE_FLAG): New macro. ++ * pt.c (add_pending_template): Use it instead of LANG_FLAG_0. ++ (instantiate_template): If -fexternal-templates, add this ++ instantiation to pending_templates. ++ ++ * decl2.c (copy_assignment_arg_p): Disable old hack to support ++ Booch components. ++ ++Tue Jan 21 18:32:04 1997 Mike Stump ++ ++ * cvt.c (cp_convert): pedwarn enum to pointer conversions. ++ ++Mon Jan 20 17:59:51 1997 Jason Merrill ++ ++ * call.c (standard_conversion): Handle getting references. Tack ++ on RVALUE_CONV here. Do it for non-class types, too. ++ (reference_binding): Pass references to standard_conversion. ++ (implicit_conversion): Likewise. ++ (add_builtin_candidate): Disable one ?: kludge. ++ (convert_like): Handle RVALUE_CONVs for non-class types. ++ (joust): Disable the other ?: kludge. ++ ++Mon Jan 20 14:53:13 1997 Brendan Kehoe ++ ++ * decl.c (init_decl_processing): Add code to build up common ++ function types beforehand, to avoid creation then removal of ++ things already in the hash table. ++ ++Mon Jan 20 14:43:49 1997 Jason Merrill ++ ++ * decl.c (finish_function): Also zero out DECL_INCOMING_RTL for ++ the arguments. ++ ++ * error.c (dump_expr, TEMPLATE_CONST_PARM): Don't require ++ current_template_parms. ++ ++Fri Jan 17 10:25:42 1997 Jason Merrill ++ ++ * search.c (lookup_field): Don't return a function, check want_type. ++ ++Thu Jan 16 18:14:35 1997 Brendan Kehoe ++ ++ * init.c (build_new): Make sure PLACEMENT has a type. ++ ++Thu Jan 16 17:40:28 1997 Jason Merrill ++ ++ * init.c (build_new): Support new (nothrow). ++ ++Wed Jan 15 12:38:14 1997 Jason Merrill ++ ++ * pt.c (instantiate_decl): Also do push_to_top_level before setting ++ up DECL_INITIAL. ++ ++ * cp-tree.h (PARM_DEFAULT_FROM_TEMPLATE): New macro. ++ * pt.c (tsubst): Defer instantiation of default args. ++ * call.c (build_over_call): Until here. ++ ++Wed Jan 15 10:08:10 1997 Brendan Kehoe ++ ++ * search.c (lookup_field): Make sure we have an ++ IDENTIFIER_CLASS_VALUE before we try to return it. ++ ++Thu Jan 9 07:19:01 1997 Brendan Kehoe ++ ++ * call.c (build_method_call): Delete unused var PARM. ++ (build_overload_call_real): Likewise. ++ (build_object_call): Delete unused var P. ++ (build_new_op): Likewise. ++ * decl.c (builtin_type_tdescs_{arr, len, max}): #if 0 out static ++ var definitions, which are never used. ++ (shadow_tag): Delete unused var FN. ++ * expr.c (cplus_expand_expr): Delete unused var ORIGINAL_TARGET. ++ * init.c (build_new): Delete unused var ALLOC_TEMP. ++ * method.c (hack_identifier): Delete unused var CONTEXT. ++ (do_build_copy_constructor): Delete unused var NAME. ++ (synthesize_method): Delete unused var BASE. ++ * pt.c (lookup_template_class): Delete unused var CODE_TYPE_NODE. ++ * rtti.c (build_headof): Delete unused var VPTR. ++ (get_typeid): Delete unused var T. ++ * typeck.c (build_conditional_expr): Delete unused vars ORIG_OP1 ++ and ORIG_OP2. ++ (build_ptrmemfunc): Delete unused vars U and NINDEX. ++ * typeck2.c (build_functional_cast): Delete unused var BINFO. ++ ++Wed Jan 8 13:09:54 1997 Jason Merrill ++ ++ * search.c (lookup_field): Use IDENTIFIER_CLASS_VALUE to look up ++ things in a type being defined. ++ * decl.c (finish_enum): Reverse the values so that they are in ++ the correct order. ++ ++ * pt.c (instantiate_class_template): Don't initialize ++ BINFO_BASETYPES until the vector is filled out. ++ (unify): Don't abort on conflicting bindings, just fail. ++ (instantiate_decl): Do push_tinst_level before any tsubsting. ++ ++ * method.c (build_overload_value): Handle getting a ++ TEMPLATE_CONST_PARM for a pointer. ++ ++Tue Jan 7 14:00:58 1997 Jason Merrill ++ ++ * init.c (expand_member_init): Don't give 'not a base' error for ++ templates. ++ ++ * pt.c (instantiate_decl): Call import_export_decl later. ++ ++ * pt.c (instantiate_class_template): Return a value. ++ ++ * parse.y (extension): New rule for __extension__. ++ (extdef, unary_expr, decl, component_decl): Use it. ++ ++Tue Jan 7 09:20:28 1997 Mike Stump ++ ++ * class.c (base_binfo): Remove unused base_has_virtual member. ++ (finish_base_struct): Likewise. ++ (finish_struct_1): Likewise. ++ ++Tue Dec 31 20:25:50 1996 Mike Stump ++ ++ * search.c (expand_upcast_fixups): Fix bogus code generation ++ problem where the generated code uses the wrong index into the ++ runtime built vtable on the stack. Old code could clobber random ++ stack values. ++ ++Tue Dec 31 15:16:56 1996 Mike Stump ++ ++ * init.c (perform_member_init): Make sure the partial EH cleanups ++ live on the function_obstack. ++ ++Fri Dec 27 10:31:40 1996 Paul Eggert ++ ++ * Make-lang.in (g++spec.o): Don't use $< with an explicit target; ++ this isn't portable to some versions of `make' (e.g. Solaris 2.5.1). ++ ++Tue Dec 24 10:24:03 1996 Jeffrey A Law ++ ++ * decl.c (grokvardecl): Avoid ANSI style initialization. ++ ++Sun Dec 22 04:22:06 1996 Jason Merrill ++ ++ * pt.c (tsubst): Tweak arg types for a FUNCTION_TYPE. ++ ++Fri Dec 20 17:09:25 1996 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Call grok_{ctor,op}_properties. ++ ++Fri Dec 20 12:17:12 1996 Brendan Kehoe ++ ++ * g++spec.c (lang_specific_driver): Put missing hyphen in front of ++ arguments we compare against. Start the count of I at 1, not 0, ++ since argv[0] is still the command. ++ ++Thu Dec 19 11:53:57 1996 Stan Shebs ++ ++ * lang-specs.h: Accept .cp as an C++ extension. ++ ++Mon Dec 16 22:43:31 1996 Brendan Kehoe ++ ++ * cp-tree.h (ptr_reasonably_similar): Add decl. ++ ++Thu Dec 12 15:00:35 1996 Brendan Kehoe ++ ++ * decl.c (grokvardecl): Change SPECBITS parm to be the SPECBITS_IN ++ pointer. New local SPECBITS with the parm's value. ++ (grokdeclarator): Pass &specbits down. ++ ++ * parse.y (expr_no_commas): Make sure $$ is not an error_mark_node ++ before we try to do C_SET_EXP_ORIGINAL_CODE on it. ++ ++ * search.c (envelope_add_decl): Check that the CLASSTYPE_CID of ++ CONTEXT is not 0 before we try to use TYPE_DERIVES_FROM. ++ ++ * decl.c (cplus_expand_expr_stmt): Only expand the expr if EXP is ++ not an error_mark_node. ++ ++Sat Dec 7 17:20:22 1996 Jason Merrill ++ ++ * cp-tree.h (TYPE_MAIN_DECL): Use TYPE_STUB_DECL. ++ * *.c: Use TYPE_MAIN_DECL instead of TYPE_NAME where appropriate. ++ ++Fri Dec 6 14:40:09 1996 Jason Merrill ++ ++ * decl.c (grokdeclarator): When giving an anonymous struct a name, ++ replace TYPE_NAME instead of TYPE_IDENTIFIER (so TYPE_STUB_DECL is ++ not affected). ++ ++ * typeck2.c (build_m_component_ref): If component is a pointer ++ to data member, resolve the OFFSET_REF now. ++ ++ * call.c (convert_like): Don't go into infinite recursion. ++ ++ * pt.c (coerce_template_parms): Use tsubst_expr for non-type args. ++ ++ * class.c (finish_struct_1): Set DECL_ARTIFICIAL on the vptr. ++ * tree.c (layout_basetypes): And on the vbase ptr. ++ ++Thu Dec 5 02:11:28 1996 Jason Merrill ++ ++ * decl.c (BOOL_TYPE_SIZE): Define in terms of POINTER_SIZE or ++ CHAR_TYPE_SIZE so bool is always the same size as another type. ++ ++ * decl.c (pushtag): Set DECL_IGNORED_P for DWARF, too. ++ ++Tue Dec 3 23:18:37 1996 Jason Merrill ++ ++ * decl2.c (grok_x_components): Remove synthesized methods from ++ TYPE_METHODS of an anonymous union, complain about member ++ functions. ++ * decl.c (shadow_tag): Wipe out memory of synthesized methods in ++ anonymous unions. ++ (finish_function): Just clear the DECL_RTL of our arguments. ++ ++Fri Nov 29 21:54:17 1996 Jason Merrill ++ ++ * decl2.c (finish_file): Emit DWARF debugging info for static data ++ members. ++ ++ * pt.c (tsubst): If t is a stub decl, return the stub decl for type. ++ ++Wed Nov 27 14:47:15 1996 Bob Manson ++ ++ * typeck.c (build_component_ref): Don't die if COMPONENT isn't a ++ IDENTIFIER_NODE. ++ ++Wed Nov 27 16:05:19 1996 Michael Meissner ++ ++ * Make-lang.in (g++-cross$(exeext)): Fix typo. ++ ++Wed Nov 27 08:14:00 1996 Brendan Kehoe ++ ++ Make the g++ driver now be a standalone program, rather than one ++ that tries to run the gcc driver after munging up the options. ++ * Make-lang.in (g++.c, g++spec.o): New rules. ++ (g++.o): New rule, based on gcc.o with -DLANG_SPECIFIC_DRIVER ++ added. ++ (g++$(exeext)): New rule, based on xgcc rule. ++ (g++-cross$(exeext)): Now just copies g++$(exeext) over. ++ * g++spec.c: New file. ++ * g++.c: Removed file. ++ ++Tue Nov 26 19:01:09 1996 Mike Stump ++ ++ * cvt.c (build_up_reference): Arrange for any temporary values ++ that have been keep in registers until now to be put into memory. ++ ++Mon Nov 25 15:16:41 1996 Kaveh R. Ghazi ++ ++ * Make-lang.in (c++.stage[1234]): Depend upon stage[1-4]-start, so ++ that make -j3 bootstrap works better. ++ ++Sun Nov 24 02:09:39 1996 Jason Merrill ++ ++ * decl.c (pushtag): Do pushdecl for anon tags. ++ ++Thu Nov 21 16:30:24 1996 Jason Merrill ++ ++ * typeck.c (c_expand_return): Fix logic. ++ (unary_complex_lvalue): Avoid unused warning on address of INIT_EXPR. ++ ++Wed Nov 20 18:47:31 1996 Bob Manson ++ ++ * g++.c (main): Make sure arglist has a final NULL entry. Add ++ PEXECUTE_LAST to the flags passed to pexecute, as otherwise ++ stdin/stdout of the invoked program are redirected to ++ nowheresville. ++ ++Tue Nov 19 16:12:44 1996 Jason Merrill ++ ++ * decl.c (implicitly_declare): Set DECL_ARTIFICIAL. ++ ++Tue Nov 19 15:48:19 1996 Mike Stump ++ ++ * init.c (resolve_offset_ref): Handle obj.vfn better. ++ * typeck.c (build_component_ref): Set TREE_TYPE on result from ++ build_vfn_ref. ++ ++Tue Nov 19 13:14:33 1996 Mike Stump ++ ++ * typeck.c (convert_for_assignment): Also handle anachronistic ++ implicit conversions from (::*)() to cv void*. ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ ++Mon Nov 18 17:05:26 1996 Jason Merrill ++ ++ * lex.c (handle_cp_pragma): Fix bogus warning. ++ ++Mon Nov 18 16:10:43 1996 Mike Stump ++ ++ * cvt.c (cp_convert_to_pointer): Avoid thinking a POINTER_TYPE ++ (METHOD_TYPE) is a TYPE_PTRMEMFUNC_P. ++ ++Thu Nov 14 23:18:17 1996 Jason Merrill ++ ++ * class.c (finish_struct_1): Support DWARF2_DEBUG. ++ * search.c (dfs_debug_mark): Likewise. ++ * decl2.c (finish_vtable_vardecl): Likewise. ++ * decl.c (pushtag, finish_enum): Likewise. ++ * lex.c (check_newline): Use debug_* instead of calling *out ++ functions directly. ++ ++Thu Nov 14 15:21:46 1996 Brendan Kehoe ++ ++ * Make-lang.in (cplib2.ready): Add else clause to avoid problems ++ on some picky hosts. ++ ++Wed Nov 13 12:32:07 1996 Jason Merrill ++ ++ * class.c (finish_struct_1): A class has a non-trivial copy ++ constructor if it has virtual functions. ++ ++ * cvt.c (cp_convert): Always call a constructor. ++ ++ * call.c (reference_binding): Still tack on a REF_BIND ++ for bad conversions. ++ (build_user_type_conversion_1): Propagate ICS_BAD_FLAG. ++ ++ * typeck.c (convert_arguments): Pass LOOKUP_ONLYCONVERTING. ++ (c_expand_return): Likewise. ++ * typeck2.c (digest_init): Likewise for { }. ++ * init.c (expand_aggr_init_1): Keep the CONSTRUCTOR handling. ++ * cvt.c (cp_convert): Handle failure better. ++ ++Wed Nov 13 11:51:20 1996 Brendan Kehoe ++ ++ * g++.c (main): Also set PEXECUTE_SEARCH, to make the invocation ++ of GCC be path-relative. ++ ++Wed Nov 13 11:27:16 1996 Michael Meissner ++ ++ * Make-lang.in (g++-cross): G++-cross doesn't need version.o, but ++ it does need choose-temp.o and pexecute.o. ++ ++Wed Nov 13 07:53:38 1996 Brendan Kehoe ++ ++ * g++.c (error) [!HAVE_VPRINTF]: Put error back for the only time ++ that we still use it. ++ (P_tmpdir, R_OK, W_OK, X_OK) [__MSDOS__]: Delete unnecessary macros. ++ ++Wed Nov 13 02:00:26 1996 Jason Merrill ++ ++ * init.c (expand_default_init): Avoid calling constructors to ++ initialize reference temps. ++ ++ * cvt.c (convert_to_reference): Fix. ++ ++Tue Nov 12 19:10:07 1996 Jason Merrill ++ ++ * cvt.c (cp_convert): Simplify for flag_ansi_overloading. ++ (convert_to_reference): Likewise. ++ * typeck.c (convert_for_initialization): Likewise. ++ * init.c (expand_default_init): Likewise. ++ (expand_aggr_init_1): Likewise. ++ * cp-tree.h (CONV_NONCONVERTING): Lose. ++ * typeck.c (build_c_cast): Lose allow_nonconverting parm. ++ * *.c: Adjust. ++ * call.c (build_user_type_conversion_1): Assume LOOKUP_ONLYCONVERTING. ++ ++Tue Nov 12 16:29:04 1996 Brendan Kehoe ++ ++ * pt.c (tsubst_expr): Reverse args to expand_start_catch_block. ++ ++Tue Nov 12 15:26:17 1996 Jason Merrill ++ ++ * init.c (expand_aggr_init_1): Don't crash on non-constructor ++ TARGET_EXPR. ++ ++Tue Nov 12 14:00:50 1996 Brendan Kehoe ++ ++ * g++.c: Include gansidecl.h. ++ (VPROTO, PVPROTO, VA_START): Delete. ++ (choose_temp_base_try, choose_temp_base, perror_exec, ++ run_dos) [__MSDOS__]: Delete fns. ++ (pfatal_with_name): Delete fn. ++ (temp_filename): Declare like in gcc.c. ++ (pexecute, pwait, choose_temp_base): Declare from gcc.c. ++ (error_count, signal_count): Define. ++ (error): Delete both definitions. ++ (PEXECUTE_{FIRST,LAST,SEARCH,VERBOSE}): Define from gcc.c. ++ (pfatal_pexecute): Add fn from gcc.c. ++ (main): Rename local VERBOSE var to VERBOSE_FLAG. Rewrite the ++ code to use the pexecute stuff also used by gcc.c. ++ (MIN_FATAL_STATUS): Define. ++ * Make-lang.in (g++): Add dependency on and linking with ++ choose-temp.o and pexecute.o. ++ ++ * cp-tree.h: Include gansidecl.h. ++ (STDIO_PROTO): Delete #undef/#define. ++ * cvt.c (NULL): Delete #undef/#define. ++ * expr.c (NULL): Likewise. ++ * init.c (NULL): Likewise. ++ * rtti.c (NULL): Likewise. ++ * xref.c (NULL): Likewise. ++ ++ * cp-tree.h (build_user_type_conversion): Add prototype. ++ * call.c (build_user_type_conversion): Delete prototype. Correct ++ decl of FLAGS arg to be an int. ++ * cvt.c (build_user_type_conversion): Likewise. ++ ++Tue Nov 12 12:16:20 1996 Jason Merrill ++ ++ * cp-tree.def: Add TRY_BLOCK and HANDLER. ++ * except.c (expand_start_catch_block): Support templates. ++ * parse.y (try_block, handler_seq): Likewise. ++ * pt.c (tsubst_expr): Support TRY_BLOCK and HANDLER. ++ ++Mon Nov 11 13:57:31 1996 Jason Merrill ++ ++ * pt.c (current_template_args): New fn. ++ (push_template_decl): Use it. ++ * decl.c (grokdeclarator): Use it. ++ ++ * decl2.c (build_expr_from_tree): Dereference ref vars. ++ ++ * decl.c (grokdeclarator): Generalize handling of TYPENAME_TYPEs in ++ the decl-specifier-seq. ++ ++ * decl.c (grok_op_properties): Don't force the type of a conversion ++ op to be complete. Don't warn about converting to the same type ++ for template instantiations. ++ ++ * decl2.c (finish_file): Don't call instantiate_decl on synthesized ++ methods. ++ ++Mon Nov 11 13:20:34 1996 Bob Manson ++ ++ * typeck.c (get_delta_difference): Remove previous bogusness. ++ Don't give errors if force is set. ++ ++Fri Nov 8 17:38:44 1996 Jason Merrill ++ ++ * decl2.c (finish_file): Don't emit debug info. ++ * decl.c (pushdecl): Lose obsolete code. ++ (grokdeclarator): Still do the long long thing after complaining. ++ * search.c (note_debug_info_needed): Don't do anything if we're in a ++ template. ++ * method.c (synthesize_method): For non-local classes, ++ push_to_top_level first. ++ ++Fri Nov 8 11:52:28 1996 Bob Manson ++ ++ * typeck.c (get_delta_difference): Add no_error parameter. ++ (build_ptrmemfunc): Call get_delta_difference with no_error set; ++ we don't want error messages when converting unrelated ++ pointer-to-member functions. ++ ++Thu Nov 7 11:16:24 1996 Mike Stump ++ ++ * error.c (dump_expr): Improve the wording on error messages that ++ involve pointer to member functions. ++ ++Tue Nov 5 17:12:05 1996 Mike Stump ++ ++ * cvt.c (cp_convert_to_pointer): Move code for conversions from ++ (::*)() to void* or (*)() up a bit, so that we can convert from ++ METHOD_TYPEs as well. ++ ++Tue Nov 5 14:54:17 1996 Jason Merrill ++ ++ * rtti.c (get_tinfo_fn): Make sure 'type' is permanent. ++ There are no 'member' types. ++ (get_tinfo_fn_dynamic): Diagnose typeid of overloaded fn. ++ (build_x_typeid): Handle errors. ++ ++Mon Nov 4 17:43:12 1996 Mike Stump ++ ++ * typeck.c (convert_for_assignment): Handle anachronistic implicit ++ conversions from (::*)() to void* or (*)(). ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ (cp_convert_to_pointer_force): Remove cp_convert_to_pointer ++ conversions from here. ++ * decl2.c (lang_decode_option): Add -W{no-,}pmf-conversions. ++ * lang-options.h: Likewise. ++ * decl2.c (warn_pmf2ptr): Define. ++ * cp-tree.h: Declare it. ++ * typeck2.c (digest_init): Allow pmfs down into ++ convert_for_initialization. ++ ++Sun Nov 3 09:43:00 1996 Jason Merrill ++ ++ * typeck.c (c_expand_return): Fix for returning overloaded fn. ++ ++Fri Nov 1 08:53:17 1996 Jason Merrill ++ ++ * cp-tree.h (DIRECT_BIND): Change from INDIRECT_BIND. ++ * decl.c (grok_reference_init): Pass DIRECT_BIND. ++ * cvt.c (build_up_reference): Don't mark 'this' addressable. Use ++ DIRECT_BIND. ++ * call.c (convert_like): Don't pass INDIRECT_BIND. ++ * typeck.c (convert_arguments): Likewise. ++ * typeck.c (mark_addressable): Allow &this if flag_this_is_variable. ++ ++Thu Oct 31 17:08:49 1996 Jason Merrill ++ ++ * typeck.c (mark_addressable): Support TARGET_EXPR, unify with ++ similar code in build_up_ref. ++ * cvt.c (build_up_reference): Drastically simplify. ++ ++Mon Oct 28 12:45:05 1996 Jeffrey A Law ++ ++ * typeck.c (signed_or_unsigned_type): If the given type already ++ as the correct signedness, then just return it. ++ ++ * typeck.c ({un,}signed_type): If can't do anything, call ++ signed_or_unsigned_type. ++ ++Thu Oct 24 14:21:59 1996 Bob Manson ++ ++ * decl2.c (copy_assignment_arg_p): Don't buy the farm if ++ current_class_type is NULL. ++ ++Wed Oct 23 00:43:10 1996 Jason Merrill ++ ++ * class.c (finish_struct_1): Avoid empty structs by adding a field ++ so layout_type gets the mode right. ++ ++ * typeck.c (c_expand_return): Drastically simplify. ++ ++Mon Oct 21 22:34:02 1996 Jason Merrill ++ ++ * typeck.c (decay_conversion): Handle overloaded methods. ++ ++Fri Oct 18 16:03:48 1996 Jason Merrill ++ ++ * call.c (build_over_call): A TARGET_EXPR has side-effects. ++ ++Thu Oct 17 11:31:59 1996 Mike Stump ++ ++ * cvt.c (convert_to_pointer_force): Add code to support pointer to ++ member function to pointer to function conversions. ++ * init.c (resolve_offset_ref): Add code to allow faked up objects, ++ ignoring them if they are not used, and giving an error, if they ++ are needed. ++ * typeck.c (get_member_function_from_ptrfunc): Fold e1 to improve ++ code, and so that we can give an error, if we needed an object, ++ and one was not provided. ++ (build_c_cast): Don't call default_conversion when we want to ++ convert to pointer to function from a METHOD_TYPE. ++ ++Mon Oct 14 00:28:51 1996 Jason Merrill ++ ++ * Make-lang.in (cplib2.ready): Fix logic. ++ ++ * decl.c (shadow_tag): Only complain about non-artificial function ++ members. ++ ++ * class.c (finish_struct_1): Add synthesized methods to TYPE_METHODS. ++ ++Fri Oct 11 16:12:40 1996 Jason Merrill ++ ++ * expr.c (cplus_expand_expr): Pre-tweak call_target like ++ expand_inline_function would. ++ ++ * pt.c (mark_decl_instantiated): If extern_p, call ++ mark_inline_for_output. ++ ++Thu Oct 10 15:58:08 1996 Mike Stump ++ ++ * typeck.c (unary_complex_lvalue): Add code to handle intermediate ++ pmd conversions. ++ ++ * typeck.c (get_delta_difference): Fix wording, as we can be used ++ for pointer to data members. ++ ++Tue Oct 8 12:43:51 1996 Bob Manson ++ ++ * pt.c (tsubst): If the function decl isn't a member of this ++ template, return a copy of the decl (including copying the ++ lang-specific part) so we don't hose ourselves later. ++ ++Thu Oct 3 16:24:28 1996 Jason Merrill ++ ++ * class.c (finish_struct): Remove DWARF-specific tag handling. ++ * decl.c (pushtag): Likewise. ++ (finish_function): Always clear DECL_ARGUMENTS on function decls with ++ no saved RTX. ++ * decl2.c (finish_file): Emit DWARF debugging info for static data ++ members. ++ ++Wed Oct 2 21:58:01 1996 Bob Manson ++ ++ * decl.c (duplicate_decls): Make sure the old DECL_LANG_SPECIFIC ++ isn't the same as the new one before we whack it. ++ ++Mon Sep 30 13:38:24 1996 Jason Merrill ++ ++ * class.c, cp-tree.h, cvt.c, decl.c, decl2.c, gxx.gperf, hash.h, ++ lex.c, method.c, parse.y, typeck.c, typeck2.c: Remove ++ warn_traditional and warn_strict_prototypes; remove ancient ++ 'overload' code; remove references to flag_traditional. ++ ++Mon Sep 30 12:58:40 1996 Mike Stump ++ ++ * input.c (sub_getch): Handle 8-bit characters in string literals. ++ ++Sun Sep 29 03:12:01 1996 Jason Merrill ++ ++ * tree.c (mapcar): Handle CONSTRUCTORs. ++ (copy_to_permanent): Handle expression_obstack properly. ++ ++ * Make-lang.in (cplib2.txt): Also depend on the headers. ++ ++ * rtti.c (get_tinfo_var): Don't assume that POINTER_SIZE == ++ INT_TYPE_SIZE. ++ (expand_class_desc): Use USItype for offset field. ++ * tinfo.h (struct __class_type_info): Likewise. ++ ++ * method.c (build_overload_int): TYPE_PRECISION should be applied ++ to types. ++ ++Sat Sep 28 14:44:50 1996 Jason Merrill ++ ++ * call.c (build_new_op): A COND_EXPR involving void must be a ++ builtin. ++ ++Fri Sep 27 16:40:30 1996 Jason Merrill ++ ++ * typeck.c (build_x_component_ref): New fn. ++ (build_object_ref): Use it. ++ * parse.y (primary): Use it. ++ * decl2.c (build_expr_from_tree): Use it. ++ * cp-tree.h: Declare it. ++ ++ * decl.c (start_decl): Variable-sized arrays cannot be initialized. ++ * error.c (dump_type_suffix): Handle variable arrays. ++ ++Fri Sep 27 13:14:05 1996 Brendan Kehoe ++ ++ * Make-lang.in (exception.o): Put back compiling it with -fPIC. ++ ++Fri Sep 27 03:00:09 1996 Jason Merrill ++ ++ * decl.c (lookup_name_real): Don't try to look up anything in a ++ TYPENAME_TYPE. ++ ++ * tinfo2.cc (__throw_type_match_rtti): Oops. ++ ++Thu Sep 26 22:11:05 1996 Brendan Kehoe ++ ++ * Make-lang.in (exception.o): Use -fno-PIC for now. ++ ++Thu Sep 26 10:59:00 1996 Jason Merrill ++ ++ * rtti.c (build_dynamic_cast): Pass tinfo fns rather than ++ calling them. ++ (get_tinfo_fn_dynamic): Extracted from build_typeid. ++ * tinfo2.cc (__dynamic_cast): Adjust. ++ ++ * rtti.c (build_typeid): Use resolves_to_fixed_type_p. ++ (build_x_typeid): Likewise. ++ ++ * parse.y: Call build_x_typeid instead of build_typeid. ++ * cp-tree.def: Add TYPEID_EXPR. ++ * pt.c (tsubst_copy): Handle typeid. ++ * decl2.c (build_expr_from_tree): Likewise. ++ * rtti.c (build_x_typeid): Throw bad_typeid from here. ++ (build_typeid): Not here. ++ * cp-tree.h: Declare build_x_typeid. ++ ++Wed Sep 25 17:26:16 1996 Jason Merrill ++ ++ * call.c (convert_like): Pull out constant values. ++ ++ * tree.c (mapcar): Use build_cplus_array_type, not build_array_type. ++ ++Wed Sep 25 17:28:53 1996 Michael Meissner ++ ++ * decl.c (init_decl_processing): Create short int types before ++ creating size_t in case a machine description needs to use ++ unsigned short for size_t. ++ ++Tue Sep 24 18:18:44 1996 Jason Merrill ++ ++ * Make-lang.in (exception.o): Turn off pic. ++ ++ * tinfo2.cc (__throw_type_match_rtti): Fix cv-variants of the same ++ type, multi-level ptr conversions. ++ ++ * rtti.c (call_void_fn): Renamed and genericized from throw_bad_cast. ++ (throw_bad_cast): Use it. ++ (throw_bad_typeid): New fn. ++ (build_typeid): Throw bad_typeid as needed. ++ Use build_call. ++ (synthesize_tinfo_fn): Handle functions and arrays before checking ++ for cv-quals. ++ ++ * Remove .h from standard C++ headers, add new.h, move into inc ++ subdirectory. ++ ++ * exception*: Remove pointer from object, constructors. Add ++ default exception::what that uses type_info::name. Add ++ __throw_bad_typeid. ++ ++ * init.c (build_new): Don't add a cookie to new (void *) T[2]. ++ ++Mon Sep 23 15:21:53 1996 Jason Merrill ++ ++ * Make-lang.in: Building C++ code depends on cc1plus. ++ ++Mon Sep 23 12:38:40 1996 Brendan Kehoe ++ ++ * decl.c (struct saved_scope): Declare PROCESSING_TEMPLATE_DECL as ++ a HOST_WIDE_INT, not a tree. ++ ++Mon Sep 23 12:36:02 1996 Jason Merrill ++ ++ * exception.cc: Don't include . ++ ++ * Make-lang.in (c++.clean): Remove cplib2.*. ++ ++Mon Sep 23 09:42:19 1996 Doug Evans ++ ++ * parse.y (component_decl_1, component_costructor_declarator case): ++ Pass attributes/prefix_attributes in tree list. ++ ++Mon Sep 23 01:18:50 1996 Jason Merrill ++ ++ * tinfo{,2}.cc: #include instead of . ++ ++Sun Sep 22 05:31:22 1996 Jason Merrill ++ ++ * lex.c (do_identifier): Don't do deferred lookup in a template ++ header. ++ ++ * typeck2.c (store_init_value): Oops. ++ ++ * new.{h,cc}, exception.{h,cc}, typeinfo.h, tinfo{2.cc,.cc,.h}: ++ New files for C++ lang-support library. ++ * Make-lang.in (CXX_EXTRA_HEADERS): Define. ++ (CXX_LIB2FUNCS): Define. ++ And rules for building the C++ lang-support code. ++ * config-lang.in (headers): Define. ++ (lib2funcs): Define. ++ ++Sat Sep 21 19:17:28 1996 Jason Merrill ++ ++ * decl2.c (build_expr_from_tree): If CONSTRUCTOR has a type, call ++ digest_init. ++ * pt.c (tsubst_copy): Compute type for CONSTRUCTOR. ++ * typeck2.c (store_init_value): Check for initializing pmf with { } ++ here. ++ (process_init_constructor): Not here. ++ ++Thu Sep 19 16:41:07 1996 Jason Merrill ++ ++ * pt.c (begin_template_parm_list): Increment ++ processing_template_decl here. ++ (end_template_parm_list): Not here. ++ (process_template_parm): No need to add 1 to it now. ++ * *.c: Use processing_template_decl instead of current_template_parms ++ to check for being in a template. ++ ++ * pt.c (uses_template_parms): Handle SCOPE_REF. Fix CONSTRUCTOR. ++ (tsubst_copy): Handle CONSTRUCTOR. ++ (instantiate_decl): Set up context properly for variables. ++ * decl2.c (build_expr_from_tree): Handle CONSTRUCTOR. ++ * class.c (finish_struct): Reverse CLASSTYPE_TAGS. ++ ++Wed Sep 18 13:30:20 1996 Brendan Kehoe ++ ++ * lex.c (enum tree_node_kind) [GATHER_STATISTICS]: Put the enum back. ++ ++Wed Sep 18 04:24:07 1996 Jason Merrill ++ ++ * method.c (make_thunk): Call comdat_linkage before setting the ++ TREE_CODE. ++ ++ * decl2.c (comdat_linkage): Use make_decl_one_only. ++ (import_export_decl): Likewise. ++ * decl.c (init_decl_processing): Check supports_one_only instead of ++ SUPPORTS_WEAK. ++ ++Sat Sep 14 08:34:41 1996 Jason Merrill ++ ++ * decl2.c (grokfield): Tighten checking for access decls. ++ ++ * decl.c (make_typename_type): Resolve references to ++ current_class_type. Set CLASSTYPE_GOT_SEMICOLON. ++ (lookup_name_real): Types that depend on a template parameter get ++ an implicit 'typename' unless they're in the current scope. ++ (start_decl_1): We don't care about incomplete types that depend ++ on a template parm. ++ (grokdeclarator): Resolve 'typename's in the type specifier that ++ refer to members of the current scope. ++ ++ * call.c (build_over_call): Remove 'inline called before ++ definition' diagnostic. ++ (build_method_call): Likewise. ++ * decl.c (duplicate_decls): Downgrade 'used before declared ++ inline' to a warning, only with -Winline. ++ ++Fri Sep 13 17:31:40 1996 Stan Shebs ++ ++ * mpw-make.sed: Fix include paths, add @DASH_C_FLAG@ to compile. ++ ++Wed Sep 11 22:38:13 1996 Gerald Baumgartner ++ ++ * call.c (build_method_call): When calling a signature ++ default implementation, as in other cases, let instance_ptr simply ++ be instance. ++ ++Wed Sep 11 22:14:44 1996 Mike Stump ++ ++ * parse.y (simple_stmt): Cleanup and use do_poplevel (). ++ ++Wed Sep 11 22:10:48 1996 Mike Stump ++ ++ * except.c (expand_start_catch_block): Add a pushlevel so that -g ++ works on hppa and SPARC. ++ ++Wed Sep 11 10:18:06 1996 Brendan Kehoe ++ ++ * typeck.c (build_indirect_ref): Catch PTR being an error_mark_node. ++ ++Mon Sep 9 19:51:14 1996 Gerald Baumgartner ++ ++ * call.c (build_over_call): Check first whether DECL_CONTEXT exists ++ before testing whether it's a signature. ++ ++Sun Sep 8 16:06:57 1996 Gerald Baumgartner ++ ++ * call.c (build_new_method_call): Don't complain about signature ++ pointers and references not being an aggr type. ++ (build_this): If a signature pointer or reference was passed in, ++ just return it. ++ (build_new_method_call): If instance is a signature pointer, set ++ basetype to the signature type of instance. ++ * sig.c (build_signature_method_call): Deleted basetype and ++ instance parameters, they can be found as the DECL_CONTEXT of ++ function and as the first argument passed in. ++ * cp-tree.h: Changed declaration of build_signature_method_call. ++ * call.c (build_method_call): Deleted first two arguments in call ++ of build_signature_method_call. ++ (build_over_call): Added call to build_signature_method_call. ++ ++Thu Sep 5 16:51:28 1996 Jason Merrill ++ ++ * typeck.c (build_c_cast): Don't tack a non_lvalue_expr onto a ++ target_expr. ++ ++Thu Sep 5 10:05:38 1996 Brendan Kehoe ++ ++ * cvt.c (convert_to_reference): Use %#T, not %#D, for error. ++ ++Wed Sep 4 17:16:09 1996 Bob Manson ++ ++ * except.c (expand_start_try_stmts): Move to except.c in the backend. ++ (expand_end_try_stmts): Remove. ++ ++ * init.c (perform_member_init): Use add_partial_entry () instead ++ of directly manipulating lists. ++ (emit_base_init): Likewise. ++ ++Wed Sep 4 12:14:36 1996 Mike Stump ++ ++ * except.c (expand_exception_blocks): Always make sure USE and ++ CLOBBER insns that came at the end still do, the backend relies ++ upon this. ++ ++Wed Sep 4 07:44:48 1996 Jason Merrill ++ ++ * call.c (build_over_call): We can only use a TARGET_EXPR of the ++ right type. ++ ++Tue Sep 3 19:26:05 1996 Jason Merrill ++ ++ * cvt.c (convert_to_reference): Revert last change, don't complain ++ about temp without target decl. ++ ++Tue Sep 3 10:22:56 1996 Mike Stump ++ ++ * decl.c (grokdeclarator): Don't core dump when void() is given. ++ ++Tue Sep 3 02:38:56 1996 Jason Merrill ++ ++ * decl.c (copy_args_p): Don't crash. ++ ++Fri Aug 30 14:26:57 1996 Mike Stump ++ ++ * pt.c (tsubst): And support template args inside the exception ++ specification. ++ ++ * pt.c (tsubst): Add support for exception specifications in ++ template functions. ++ ++Fri Aug 30 10:01:55 1996 Mike Stump ++ ++ * cp-tree.def (DECL_STMT): Eliminate the throw spec field, only 3 ++ fields now. ++ * cp-tree.h (start_decl): Eliminate the throw spec parameter. ++ (start_function): Likewise. ++ (start_method): Likewise. ++ (grokfield): Likewise. ++ (make_call_declarator): Add throw spec parameter. ++ (set_quals_and_spec): Add routine. ++ * lex.c (set_quals_and_spec): Likewise. ++ * decl.h (grokdeclarator): Eliminate the throw spec parameter. ++ * decl.c (shadow_tag): Eliminate the throw spec parameter to ++ grokdeclarator. ++ (groktypename): Likewise. ++ (start_decl): Eliminate the throw spec parameter. Eliminate the ++ throw spec parameter to grokdeclarator. Eliminate the throw spec ++ field in DECL_STMT. ++ (cp_finish_decl): Eliminate the throw spec field in DECL_STMT. ++ (grokfndecl): Remove useless set of raises. ++ (grokdeclarator): Eliminate the throw spec parameter. Eliminate ++ the throw spec parameter to start_decl. Pull the throw spec out ++ of the call declarator. ++ (grokparms): Eliminate the throw spec parameter to grokdeclarator. ++ (start_function): Eliminate the throw spec parameter. Eliminate ++ the throw spec parameter to grokdeclarator. ++ (start_method): Likewise. ++ * decl2.c (grokfield): Likewise. ++ (grokbitfield): Eliminate the throw spec parameter to grokdeclarator. ++ (grokoptypename): Likewise. ++ (finish_file): Eliminate the throw spec parameter to ++ start_function. Add throw spec to make_call_declarator. ++ * except.c (init_exception_processing): Add throw spec to ++ make_call_declarator. Eliminate the throw spec parameter to ++ start_decl. ++ (expand_start_catch_block): Eliminate the throw spec parameter to ++ grokdeclarator. ++ (expand_builtin_throw): Add throw spec to make_call_declarator. ++ Eliminate the throw spec parameter to start_function. ++ (start_anon_func): Likewise. ++ * lex.c (make_call_declarator): Add throw spec parameter. ++ (set_quals_and_spec): New routine. ++ (cons_up_default_function): Add throw spec to make_call_declarator. ++ Eliminate the throw spec parameter to grokfield. ++ * method.c (synthesize_method): Eliminate the throw spec parameter ++ to start_function. ++ * pt.c (process_template_parm): Eliminate the throw spec parameter ++ to grokdeclarator. ++ (tsubst): Add throw spec to make_call_declarator. ++ (tsubst_expr): Eliminate the throw spec parameter to start_decl. ++ (do_function_instantiation): Eliminate the throw spec parameter to ++ grokdeclarator. Eliminate the throw spec parameter to ++ start_function. ++ * rtti.c (synthesize_tinfo_fn): Eliminate the throw spec parameter ++ to start_function. ++ * parse.y (datadef): Remove non-winning optimization. ++ (decl): Likewise. ++ (fndef): Remove ambiguous error productions uncovered by grammar ++ fixing. ++ (constructor_declarator): Add exception_specification_opt here. ++ (component_constructor_declarator): Likewise. ++ (direct_after_type_declarator): Likewise. ++ (complex_direct_notype_declarator): Likewise. ++ (direct_abstract_declarator): Likewise. ++ (fn.def1): Remove exception_specification_opt. ++ (fn.def2): Likewise. ++ (condition): Likewise. ++ (initdcl0): Likewise. ++ (initdcl): Likewise. ++ (notype_initdcl0): Likewise. ++ (nomods_initdcl0): Likewise. ++ (component_decl_1): Likewise. ++ (component_declarator): Likewise. ++ (after_type_component_declarator0): Likewise. ++ (after_type_component_declarator): Likewise. ++ (notype_component_declarator): Likewise. ++ ++Wed Aug 28 01:40:30 1996 Jason Merrill ++ ++ * call.c (build_over_call): Also use an INIT_EXPR when ++ initializing anything from an rvalue. ++ ++ * call.c (build_over_call): Call stabilize_reference when building ++ an INIT_EXPR instead of calling the copy ctor. ++ ++ * call.c (joust): Extend the previous change to all comparisons. ++ ++ * decl2.c, method.c, lex.c: Use MAKE_DECL_ONE_ONLY and ++ NO_LINKAGE_HEURISTICS. ++ ++ * decl2.c (finish_file): Emit any statics that weren't already. ++ ++ * typeck.c (build_static_cast): Implement. ++ * tree.c (build_cplus_new): Handle getting a TARGET_EXPR. ++ * decl.c (grokparms): Use can_convert_arg instead of ++ implicit_conversion directly. ++ (copy_args_p): New fn. ++ * cvt.c (convert_to_reference): Don't complain about temp with ++ static_cast. ++ (build_up_reference): Handle TARGET_EXPRs. ++ * call.c (build_over_call): Elide unnecessary temps. ++ (can_convert*): Use new overloading code. ++ ++Tue Aug 27 13:12:21 1996 Jason Merrill ++ ++ * call.c: Move TYPE_PTR*_MACROS ... ++ * cp-tree.h: To here. ++ * typeck.c (build_reinterpret_cast): Implement. ++ ++ * call.c (add_builtin_candidate): Use TYPE_PTROB_P instead of ++ ptr_complete_ob. ++ (joust): If we're comparing a function to a builtin and the worst ++ conversion for the builtin is worse than the worst conversion for the ++ function, take the function. ++ ++ * typeck.c (build_const_cast): Implement. ++ (comp_ptr_ttypes_const): Like comp_ptr_ttypes, for const_cast. ++ (comp_ptr_ttypes_reinterpret): Like cpt, for reinterpret_cast. ++ ++Tue Aug 27 13:14:58 1996 Bob Manson ++ ++ * rtti.c (build_dynamic_cast): Don't try to dereference exprtype ++ too early. Make sure we explode if exprtype turns out to be a ++ NULL_TREE when it shouldn't be. ++ ++Tue Aug 27 10:56:21 1996 Mike Stump ++ ++ * cp-tree.h: New routine make_call_declarator. ++ * lex.c (make_call_declarator): Define it. ++ * except.c (init_exception_processing): Use it. ++ (expand_builtin_throw): Likewise. ++ (start_anon_func): Likewise. ++ * decl2.c (finish_file): Likewise. ++ * lex.c (cons_up_default_function): Likewise. ++ * parse.y: Likewise. ++ * pt.c (tsubst): Likewise. ++ ++Mon Aug 26 17:40:03 1996 Mike Stump ++ ++ * decl2.c (groktypefield): Remove unused code. ++ ++Mon Aug 26 17:00:33 1996 Mike Stump ++ ++ * gxx.gperf: Change TYPE_QUAL into CV_QUALIFIER. ++ * parse.y: Likewise. Change maybe_type_qual into maybe_cv_qualifier. ++ Change type_quals into cv_qualifiers. Change nonempty_type_quals into ++ nonempty_cv_qualifiers. ++ * hash.h: Rebuild. ++ ++ * lex.c (make_pointer_declarator): Change type_quals into ++ cv_qualifiers. ++ (make_reference_declarator): Likewise. ++ ++Thu Aug 22 01:09:22 1996 Jason Merrill ++ ++ * decl.c (start_function): Only check interface_* for templates ++ with flag_alt_external_templates. ++ ++ * call.c (build_new_op): Check for comparison of different enum types. ++ (build_over_call): Fix arg # output. ++ ++ * typeck.c (build_component_ref): Handle pre-found TYPE_DECL. ++ ++Wed Aug 21 00:13:15 1996 Jason Merrill ++ ++ * call.c (build_new_op): Check for erroneous args. ++ ++ * call.c (build_new_method_call): Add missing args to cp_error. ++ ++ * tree.c (error_type): Don't print reference-to-array. ++ ++ * typeck.c (convert_for_assignment): Don't say contravariance for ++ removing const. ++ ++Tue Aug 20 13:23:00 1996 Jason Merrill ++ ++ * call.c (build_over_call): Diagnose bad convs for `this'. ++ ++ * lex.c (cons_up_default_function): Set DECL_ARTIFICIAL ++ on _ctor_arg. ++ ++ * call.c (convert_like): Handle bad convs. ++ (build_over_call): Handle bad convs better. ++ ++ * decl2.c: -fansi-overloading is now the default. ++ ++ * call.c (build_new_method_call): Check for erroneous args. ++ ++ * pt.c (instantiate_class_template): Propagate ++ TYPE_USES_MULTIPLE_INHERITANCE. ++ ++Tue Aug 20 13:09:57 1996 Mike Stump ++ ++ * call.c (enforce_access): Add static to routine. ++ ++Sun Aug 18 14:35:54 1996 Jason Merrill ++ ++ * call.c (build_user_type_conversion_1): Fix bad handling. ++ (compare_ics): Likewise. ++ ++Sat Aug 17 21:54:11 1996 Jason Merrill ++ ++ * call.c (standard_conversion): Oops. ++ ++Sat Aug 17 16:28:11 1996 Geoffrey Noer ++ ++ * g++.c: Update test for win32 (&& ! cygwin32). ++ ++Sat Aug 17 03:45:31 1996 Jason Merrill ++ ++ * typeck.c (comp_ptr_ttypes_real): Handle OFFSET_TYPEs properly. ++ (ptr_reasonably_similar): New fn. ++ * call.c (BAD_RANK): New rank. ++ (ICS_BAD_FLAG): New macro. ++ (standard_conversion): Handle almost-right pointer conversions. ++ (reference_binding): Handle bad rvalue bindings. ++ (add_*_candidate): Stuff. ++ (build_over_call): Pass bad conversions to convert_for_initialization. ++ (compare_ics): Handle bad convs. ++ (joust): Likewise. ++ ++Fri Aug 16 15:02:19 1996 Bob Manson ++ ++ * init.c (expand_vec_init): Use ptrdiff_type_node instead of ++ integer_type_node when computing pointer offsets. ++ ++Fri Aug 16 01:28:32 1996 Jason Merrill ++ ++ * tree.c (lvalue_type): New fn. ++ (error_type): New fn. ++ * call.c (op_error): Use error_type. ++ (add_conv_candidate): Use lvalue_type. ++ (add_builtin_candidates): Likewise. ++ * error.c (args_as_string): Use error_type. ++ ++Thu Aug 15 17:27:13 1996 Jason Merrill ++ ++ * pt.c (instantiate_decl): Evaluate DECL_INITIAL of a VAR_DECL here. ++ (tsubst): Not here. ++ ++ * decl.c (init_decl_processing): With -ansi, __null's type is the ++ signed integral type with the same number of bits as a pointer. ++ Introduce a new variable null_node for it. ++ * cp-tree.h: Adjust. ++ * call.c (null_ptr_cst_p): Adjust. ++ ++Thu Aug 15 17:09:54 1996 Mike Stump ++ ++ * except.c (do_unwind): Mark %i7 as used on the SPARC so we can ++ optimize. ++ ++Thu Aug 15 01:36:49 1996 Jason Merrill ++ ++ * decl2.c (import_export_decl): Ignore #pragma interface for tinfo ++ fns of classes without virtual functions. ++ ++ * call.c (add_function_candidate): Handle `this' specially. ++ (compare_ics): Likewise. ++ ++Tue Aug 13 12:16:10 1996 Jason Merrill ++ ++ * typeck.c (build_conditional_expr): Fix handling of __null. ++ ++ * decl2.c (comdat_linkage): New fn. ++ (import_export_vtable): Use it. ++ (import_export_decl): Use it. ++ * method.c (make_thunk): Use it. ++ ++Mon Aug 12 00:09:18 1996 Jason Merrill ++ ++ * pt.c (end_template_decl): If we don't actually have parms, return. ++ * parse.y (template_header): Accept 'template <>'. ++ ++ * errfn.c: Allow 5 args. ++ ++Sun Aug 11 15:20:58 1996 Jason Merrill ++ ++ * tree.c (make_temp_vec): New fn. ++ * pt.c (push_template_decl): Handle partial specs. ++ (instantiate_class_template): Likewise. ++ (more_specialized): Use get_bindings. ++ (more_specialized_class): New fn. ++ (get_class_bindings): New fn. ++ (most_specialized_class): New fn. ++ (do_function_instantiation): List candidates for ambiguous case. ++ * decl.c (duplicate_decls): Lose reference to DECL_TEMPLATE_MEMBERS. ++ (shadow_tag): Call push_template_decl for partial specializations. ++ * parse.y: Likewise. ++ * cp-tree.h (DECL_TEMPLATE_SPECIALIZATIONS): Replaces ++ DECL_TEMPLATE_MEMBERS. ++ * call.c (print_z_candidates): Reduce duplication. ++ ++Fri Aug 9 14:36:08 1996 Jason Merrill ++ ++ * decl2.c (lang_decode_option): Allow -fansi-overloading. ++ ++Thu Aug 8 17:04:18 1996 Jason Merrill ++ ++ * pt.c (get_bindings): New fn. ++ (most_specialized): Likewise. ++ (do_function_instantiation): Use them. ++ (add_maybe_template): New fn. ++ * cp-tree.h (DECL_MAYBE_TEMPLATE): New macro. ++ * call.c (build_new_op): Handle guiding decls. ++ (build_new_function_call): Likewise. ++ * decl2.c (finish_file): Likewise. ++ ++ * decl2.c (mark_used): Do synthesis here. ++ * call.c (build_method_call): Not here. ++ (build_over_call): Or here. ++ * typeck.c (build_function_call_real): Or here. ++ * tree.c (bot_manip): Call mark_used on functions used in default ++ args. ++ ++Thu Aug 8 17:48:16 1996 Michael Meissner ++ ++ * decl2.c (import_export_vtable): Delete code that disabled vtable ++ heuristic on systems with ASM_OUTPUT_EXTERNAL. ++ ++Wed Aug 7 12:44:11 1996 Jason Merrill ++ ++ * typeck.c (build_x_function_call): Handle static call context ++ better. ++ ++ * decl.c (finish_function): Set the DECL_CONTEXT of the result to ++ the function, not its outer block. ++ ++ * call.c (build_field_call): Pass fields on to build_opfncall ++ regardless of TYPE_OVERLOADS_CALL_EXPR. ++ (build_method_call): Pass on to build_new_method_call sooner. ++ ++ * typeck.c (build_ptrmemfunc): Just return what instantiate_type ++ gives us. ++ * class.c (instantiate_type): Don't put a POINTER_TYPE to ++ METHOD_TYPE on an expression. Also make a copy of rhs instead of ++ modifying it. ++ ++Tue Aug 6 12:58:46 1996 Jason Merrill ++ ++ * call.c (compare_ics): Handle qual_conv after lvalue_conv. ++ (add_builtin_candidate): Don't take enums for ++. ++ (build_new_method_call): Handle non-aggregates and field calls. ++ Move new overloading code from... ++ * cvt.c: Here. ++ ++ * decl.c (grokparms): Don't check default args in templates. ++ ++Mon Aug 5 17:17:06 1996 Jason Merrill ++ ++ * cvt.c (build_new_op): Fix args to build_unary_op. ++ (add_builtin_candidates): Don't call type_promotes_to on float. ++ ++ * decl.c (grokparms): Check the type of the default arg. ++ ++ * cvt.c (build_new_op): Pass non-overloaded cases on rather than ++ returning NULL_TREE. ++ ++ * typeck.c (build_x_binary_op): Avoid doing extra work. ++ (build_x_unary_op): Likewise. ++ (build_x_conditional_expr): Likewise. ++ * cvt.c (build_over_call): Return. ++ (add_builtin_candidate): Fix MEMBER_REF. ++ (build_new_op): Likewise. ++ ++Mon Aug 5 17:07:47 1996 Mike Stump ++ ++ * method.c (build_overload_name): Put bug fix into code but leave ++ disabled for now so we can be bug compatible with older releases ++ that do repeats incorrectly. In the future, we can enable it. ++ ++Mon Aug 5 13:46:28 1996 Jason Merrill ++ ++ * cvt.c (convert_like): Don't call build_cplus_new twice. ++ ++ * call.c, cp-tree.h, cvt.c, decl2.c, init.c, method.c, pt.c, typeck.c: ++ Control new overloading code with -fansi-overloading. ++ ++Sun Aug 4 15:29:11 1996 Jason Merrill ++ ++ * cvt.c (build_over_call): Call build_cplus_new. ++ * call.c (build_method_call): Likewise. ++ * typeck.c (build_function_call_real): Likewise. ++ (build_conditional_expr): If both operands are TARGET_EXPRs, wrap ++ the COND_EXPR in a TARGET_EXPR so they use the same slot. ++ ++ * cvt.c (build_up_reference): Propagate INDIRECT_BIND to ++ recursive calls. ++ * typeck.c (complete_type): Propagate ++ TYPE_NEEDS_{CONSTRUCTING,DESTRUCTOR}. ++ ++Sat Aug 3 14:05:07 1996 Jason Merrill ++ ++ * cvt.c (joust): More ?: kludging. Sigh. ++ (build_over_call): Don't try to synthesize global fns. ++ ++ * search.c (lookup_conversions): Use binfo marking. ++ ++Sat Aug 3 12:33:42 1996 Bob Manson ++ ++ * search.c (build_mi_matrix): Use the correct value of cid ++ when determining the new mi_size. ++ ++Sat Aug 3 01:27:41 1996 Jason Merrill ++ ++ * cvt.c (add_builtin_candidates): Do consider type conversion ops ++ for the first parms of += et al. ++ (strip_top_quals): New fn. ++ (reference_binding): Use it instead of TYPE_MAIN_VARIANT. ++ (implicit_conversion): Likewise. ++ (add_builtin_candidates): Be careful about arrays. ++ (build_new_method_call): Handle vtable optimization. ++ ++Fri Aug 2 01:26:59 1996 Jason Merrill ++ ++ * cp-tree.h (LOOKUP_NO_TEMP_BIND): New flag. ++ * cvt.c (reference_binding): Use it. ++ (implicit_conversion): Use it. ++ (add_builtin_candidate, COND_EXPR): Use it. ++ ++ * cvt.c (build_new_function_call): Check for error args. ++ ++ * typeck.c (comptypes): Just check DERIVED_FROM_P, not UNIQUELY. ++ ++ * gxx.gperf: Add __null. ++ * hash.h: Regenerate. ++ * lex.h: Add RID_NULL. ++ * lex.c (init_lex): Create null_pointer_node here, stick it in ++ RID_NULL. ++ * decl.c (init_decl_processing): Still set its type here. ++ * cvt.c (cp_convert_to_pointer): Don't produce null_pointer_node. ++ (convert_to_pointer_force): Likewise. ++ (null_ptr_cst_p): Check for null_pointer_node; only accept (void*)0 ++ if (! pedantic). ++ * call.c (convert_harshness): Use null_ptr_cst_p. ++ * typeck.c (convert_for_assignment): Likewise. Don't produce ++ null_pointer_node. ++ ++ * error.c (args_as_string): Handle lists of actual args, too. ++ * cvt.c (null_ptr_cst): Support (void*)0 for now. ++ (build_user_type_conversion_1): Improve diagnostics. ++ (build_new_function_call): Likewise. ++ (build_object_call): Likewise. ++ (build_new_method_call): Likewise. Move call before def diagnostic... ++ (build_over_call): Here. ++ ++ * cvt.c (build_new_method_call): Don't complain about no match if ++ LOOKUP_SPECULATIVELY. ++ (build_over_call): Fix 'this' for virtual fn. ++ (build_new_method_call): Add diagnostic. ++ ++Thu Aug 1 16:45:09 1996 Jason Merrill ++ ++ * cvt.c (add_function_candidate): Expect 'this' and 'in_chrg' for ++ constructors to be passed in. ++ (build_over_call): Likewise. ++ (build_user_type_conversion_1): Pass them in. ++ (convert_like): Likewise. ++ (build_object_call): Handle overloaded conversions. ++ (build_over_call): Pass the right args to build_vfn_ref. ++ (standard_conversion): Fix pmf convs. ++ (joust): Handle comparing statics and non-statics. ++ (build_new_method_call): New fn. ++ * call.c (build_method_call): Call it if NEW_OVER. ++ ++Thu Aug 1 16:06:14 1996 Mike Stump ++ ++ * lex.c (do_identifier): Don't use %O on IDENTIFIER_OPNAME_Ps, use ++ %D instead. ++ ++Thu Aug 1 15:24:02 1996 Mike Stump ++ ++ * except.c (expand_throw): Use maybe_build_cleanup_and_delete ++ instead of just maybe_build_cleanup so that we deallocate the ++ thrown object. ++ ++Thu Aug 1 15:18:00 1996 Brendan Kehoe ++ ++ * decl2.c (finish_prevtable_vardecl): Make non-static for pt.c's use. ++ * cp-tree.h (finish_prevtable_vardecl): Add decl. ++ ++Thu Aug 1 11:53:51 1996 Bob Manson ++ ++ * pt.c (instantiate_class_template): Call complete_type. Also, if ++ we're at the end of the file and we just instantiated a template ++ class with a vtable, call finish_prevtable_vardecl. ++ ++ * error.c (dump_decl): Don't explode (or explode more gracefully ++ as appropriate) if the object being dumped has a null type. ++ (dump_expr): Likewise. ++ ++ * search.c (build_mi_matrix): Ensure that mi_size is large enough, ++ by counting the number of nodes that we'll need before allocating ++ the array. ++ (lookup_fnfields): Fix comment. ++ (breadth_first_search): Fix comment. ++ ++Wed Jul 31 09:57:05 1996 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Propagate TYPE_PACKED and ++ TYPE_ALIGN. ++ * class.c (finish_struct): Call cplus_decl_attributes here. ++ (finish_struct_1): Not here. ++ * cp-tree.h: Adjust. ++ ++ * pt.c (type_unification): New parameter STRICT. ++ (unify): If STRICT, don't allow cv addition or base deduction. ++ * call.c, class.c, cvt.c, cp-tree.h: Adjust. ++ ++Tue Jul 30 13:06:13 1996 Jason Merrill ++ ++ * search.c (get_template_base{_recursive}): New fns. ++ * pt.c (more_specialized): New fn. ++ (do_function_instantiation): Use it. ++ (unify): Handle base deduction. ++ * cvt.c (joust): Use more_specialized. ++ Don't arbitrarily choose between non-builtin candidates. ++ (build_over_call): Call require_complete_type. ++ ++ * decl.c (start_function): Statics are static even in a #pragma ++ interface file. ++ ++ * decl2.c (import_export_vtable): Disable vtable heuristic on ++ systems with ASM_OUTPUT_EXTERNAL. ++ ++ * cvt.c (compare_ics): Fix comparison of PMEM_CONV and BASE_CONV. ++ (standard_conversion): No std conv to enum type. ++ ++ * cvt.c (standard_conversion): Fix order of args to DERIVED_FROM_P ++ for ptm's. ++ ++ * cvt.c (reference_binding): Bind directly to a base subobject of ++ a class rvalue. ++ ++ * cvt.c (build_new_op): Enforce access control. ++ ++Tue Jul 30 09:22:53 1996 Bob Manson ++ ++ * typeck2.c (process_init_constructor): When scanning the ++ union for a named field, skip things that aren't FIELD_DECLs. ++ ++ * method.c (synthesize_method): Don't scan fndecl's rtl if ++ we're at the end of the file; just assume the function can't ++ be inlined. ++ ++Mon Jul 29 15:48:30 1996 Jason Merrill ++ ++ * cvt.c (build_builtin_candidate): Stick a dummy conversion in if ++ it failed. ++ ++ * cvt.c (build_user_type_conversion_1): Handle overloaded ++ conversion ops. ++ ++ * cvt.c (add_builtin_candidates): Don't consider type conversion ++ operators for the first parameter of operator=. ++ ++Mon Jul 29 15:33:55 1996 Bob Manson ++ ++ * typeck.c (complete_type): Only call layout_type if we're not ++ expanding a template. ++ ++Mon Jul 29 14:40:38 1996 Jason Merrill ++ ++ * cvt.c (compare_ics): Oops. ++ ++ * cvt.c (op_error): Oops. ++ ++ * cp-tree.def: Add RVALUE_CONV, rename EXACT_CONV to IDENTITY_CONV. ++ * cvt.c: Add IDENTITY_RANK before others. Use real_lvalue_p. ++ (build_conv): Use them. ++ (implicit_conversion): Use them. ++ (convert_like): Handle them. ++ (build_new_op): Handle builtin COND_EXPR again. ++ (add_builtin_candidates): Strip cv-quals. Fix oops. Include enums ++ in lists of types for COND_EXPR. ++ (add_builtin_candidate): Add enum candidates for COND_EXPR. ++ ++Mon Jul 29 12:05:40 1996 Bob Manson ++ ++ * typeck.c (build_modify_expr): Always attempt to build a call to ++ the assignment operator, even if we're using a default one. ++ (convert_for_initialization): Call complete_type. ++ ++Mon Jul 29 11:25:08 1996 Jason Merrill ++ ++ * cvt.c (reference_binding): A REF_BIND gets the reference type. ++ (implicit_conversion): Likewise. ++ (convert_like): Likewise. ++ (compare_ics): Likewise. ++ (compare_qual): Likewise. ++ (print_z_candidates): Handle no candidates. ++ (build_new_op): Don't handle builtin COND_EXPR for now. ++ ++Sat Jul 27 11:27:47 1996 Stan Shebs ++ ++ * cvt.c (build_builtin_candidate): Init local var in an ANSI way. ++ ++Fri Jul 26 01:07:22 1996 Jason Merrill ++ ++ * cvt.c (joust): If the candidates are the same, arbitrarily pick one. ++ ++ * cvt.c (build_builtin_candidate): Oops. ++ (build_new_op): Oops. ++ ++ * method.c (build_opfncall): Pass COND_EXPR on. ++ * cvt.c (build_builtin_candidate): Reorganize, support COND_EXPR. ++ (add_builtin_candidate{,s}): Likewise. ++ (add_builtin_candidates): Likewise. ++ (print_z_candidates, op_error, build_new_op): Likewise. ++ (type_decays_to): New fn. ++ * lex.c (init_lex): Just say ?: for COND_EXPR. ++ ++Thu Jul 25 09:33:33 1996 Jason Merrill ++ ++ * typeck.c (complete_type): Call layout_type rather than building ++ a new array type. ++ ++ * cvt.c (add_builtin_candidate): Pointer arithmetic candidates ++ only use ptrdiff_t. ++ ++Wed Jul 24 12:45:08 1996 Jason Merrill ++ ++ * cvt.c: Always compile the new overloading code (but don't use it). ++ (implicit_conversion): Add a BASE_CONV when converting to ++ the same class type. ++ (convert_like): Handle BASE_CONV. ++ ++Tue Jul 23 12:46:30 1996 Jason Merrill ++ ++ * cvt.c (build_new_op): Support {MAX,MIN}_EXPR. ++ (add_builtin_candidate): Likewise. ++ ++ NEW_OVER changes: ++ * typeck.c (build_x_function_call): Try an operator function ++ whenever we call an object of class type. ++ * method.c (build_opfncall): Pass CALL_EXPRs through. ++ * cvt.c (implicit_conversion): Do const-ref case first. ++ (add_conv_candidate, build_object_call, op_error): New fns. ++ (ptr_complete_ob, TYPE_PTROB_P): void is not an object type. ++ ({add,build}_builtin_candidate{,s}, print_z_candidates): Display ++ builtin candidates. ++ (build_new_op): Handle CALL_EXPR. Don't try to decay void. ++ Fall back on preincrement handling. Use op_error. ++ Handle warn_synth. ++ (convert_like): Pass INDIRECT_BIND. Don't try to do anything with ++ an error_mark_node. ++ (build_over_call): Handle PROMOTE_PROTOTYPES and ellipsis promotions ++ properly. ++ ++Mon Jul 22 16:21:55 1996 Bob Manson ++ ++ * pt.c (tsubst_expr): Handle CONTINUE_STMT. ++ ++Mon Jul 22 15:38:58 1996 Mike Stump ++ ++ * typeck.c (build_component_ref_1): Use build_component_ref ++ instead of open coding it here. ++ ++Mon Jul 22 12:18:54 1996 Jason Merrill ++ ++ * g++.c (main): Don't link with -lg++. ++ ++ NEW_OVER changes: ++ * cvt.c (convert_to_reference): Don't use convert_from_reference on ++ result of build_type_conversion. ++ (cp_convert): Only call build_method_call for ctors if ++ build_type_conversion failed. ++ (ptr_complete_ob): New function. ++ (TYPE_PTR{,OB,MEM}_P): New macros. ++ ({add,build}_builtin_candidate{,s}): New functions. ++ (print_z_candidates): Handle builtins. ++ (build_user_type_conversion_1): Don't use conversion fns for ++ converting to a base type. ++ (build_user_type_conversion_1): Set ICS_USER_FLAG on AMBIG_CONVs. ++ (build_user_type_conversion): Use convert_from_reference. ++ (build_new_op): New function. ++ (build_over_call): Fix handling of methods. ++ (compare_ics): Handle AMBIG_CONV properly. ++ * typeck2.c: Increment abort count. ++ * method.c (build_opfncall): Forward most requests to build_new_op. ++ * cp-tree.h (IS_OVERLOAD_TYPE): Tweak. ++ ++Fri Jul 19 17:59:29 1996 Brendan Kehoe ++ ++ * error.c (dump_expr, case CONSTRUCTOR, case CAST_EXPR): Take out ++ invalid second argument to dump_expr_list. ++ ++Fri Jul 19 14:04:05 1996 Mike Stump ++ ++ * decl.c (lookup_name_real): Make sure we do obj->X::i correctly. ++ ++Thu Jul 18 14:48:23 1996 Bob Manson ++ ++ * decl2.c (import_export_vtable): ASM_OUTPUT_EXTERNAL, not ++ ASSEMBLE_EXTERNAL. ++ ++Mon Jul 15 17:48:43 1996 Mike Stump ++ ++ * typeck2.c (process_init_constructor): New pedwarn for using { } ++ to initialize a pointer to member function. ++ * typeck.c (build_ptrmemfunc1): Avoid use of digest_init so that ++ we can avoid the new error. ++ ++Mon Jul 15 15:42:03 1996 Mike Stump ++ ++ * typeck.c (build_ptrmemfunc1): New function to hide details of ++ pointer to member functions better. ++ ++Mon Jul 15 14:23:02 1996 Mike Stump ++ ++ * init.c (resolve_offset_ref): Resolve OFFSET_REFs that are ++ methods into the actual method, as we know the implied object is ++ not used. ++ ++Mon Jul 15 13:08:29 1996 Brendan Kehoe ++ ++ * parse.y (maybecomma_warn): Only emit the pedwarn if we're not ++ inside a system header. ++ ++Fri Jul 12 16:30:05 1996 Bob Manson ++ ++ * call.c (build_method_call): Call complete_type on the ++ instance type. ++ ++Thu Jul 11 17:16:40 1996 Mike Stump ++ ++ * typeck.c (build_component_ref): Always build up an OFFSET_REF ++ for obj_ptr->func so that we can know which object to use in a ++ method call. ++ ++Wed Jul 10 19:36:37 1996 Mike Stump ++ ++ * typeck.c (build_ptrmemfunc): Remove sorry, now we can cast ++ around things. Also improve maintainability. ++ ++Wed Jul 10 18:20:11 1996 Bob Manson ++ ++ * decl.c (grokdeclarator): Check for overflow when evaluating an ++ array dimension. ++ ++Wed Jul 10 17:26:19 1996 Jason Merrill ++ ++ * cvt.c (cp_convert): Don't check for ambiguity with constructor ++ if NEW_OVER. ++ ++ * typeck.c (build_x_function_call): Pass function overload ++ questions to new overloading code if NEW_OVER. ++ * init.c (expand_aggr_init_1): Only check for type conversion ops ++ if we're doing copy-initialization (i.e. LOOKUP_ONLYCONVERTING). ++ Don't check for ambiguity with constructor if NEW_OVER. ++ * cvt.c (convert_to_reference): Dereference the result of a type ++ conversion operator. ++ (build_conv): Propagate ICS_USER_FLAG. ++ (implicit_conversion): Call instantiate_type. ++ Pass LOOKUP_ONLYCONVERTING instead of LOOKUP_NORMAL. ++ (add_function_candidate): Fix cv-quals on argtype. ++ (print_z_candidates): New function. ++ (build_new_function_call): Call it. ++ (build_user_type_conversion_1): If LOOKUP_ONLYCONVERTING, don't ++ consider non-converting constructors. ++ Call print_z_candidates. ++ Return an AMBIG_CONV for an ambiguous conversion. ++ (build_user_type_conversion): Handle AMBIG_CONV. ++ (convert_like): Fix test for building TARGET_EXPR. ++ Call instantiate_type. ++ Handle AMBIG_CONV and LVALUE_CONV. ++ (build_over_call): Handle 0 args and ellipsis. ++ * cp-tree.def: Add AMBIG_CONV. ++ ++Tue Jul 9 17:48:48 1996 Mike Stump ++ ++ * decl.c (lookup_name_real): If we find mem in obj when parsing ++ `obj->mem', make sure we return the right value. ++ ++Tue Jul 9 16:11:28 1996 Bob Manson ++ ++ * search.c (get_base_distance): Call complete_type. ++ ++Tue Jul 9 12:46:34 1996 Mike Stump ++ ++ * decl.c (store_bindings): Make static. ++ ++Mon Jul 8 16:42:31 1996 Jason Merrill ++ ++ * init.c (expand_aggr_init_1): Don't check type conversions if ++ NEW_OVER. ++ ++ * cvt.c (z_candidate): Put back template field. ++ (add_function_candidate): Set it. ++ (add_template_candidate): Likewise. ++ (joust): Use it. ++ (compare_qual): Handle references and pointers to members. ++ (compare_ics): Handle reference bindings. ++ ++ * decl.c (duplicate_decls): Propagate DECL_ONE_ONLY. ++ ++Mon Jul 8 16:18:56 1996 Bob Manson ++ ++ * call.c (compute_conversion_costs): Call complete_type. ++ ++ * tree.c (vec_binfo_member): Use comptypes instead of comparing ++ pointers, so we can handle template parameters. ++ ++Fri Jul 5 16:51:53 1996 Bob Manson ++ ++ * cvt.c (cp_convert_to_pointer): We have to call complete_type ++ here; let's make it explicit instead of a side effect of an ++ error check. ++ ++Wed Jul 3 16:29:51 1996 Jason Merrill ++ ++ * cvt.c (z_candidate): Remove template field. ++ (reference_binding): Handle binding to temporary. ++ (implicit_conversion): Likewise. ++ (add_function_candidate): Handle artificial constructor parms. ++ Handle functions with too few parms. ++ (add_template_candidate): New function. ++ (build_user_type_conversion_1): Handle constructors. ++ (convert_like): Likewise. ++ (build_over_call): Likewise. ++ (build_new_function_call): Support templates. ++ (compare_ics): Fix reference, inheritance handling. ++ ++Mon Jul 1 22:58:18 1996 Bob Manson ++ ++ * decl.c: Add signed_size_zero_node. ++ (init_decl_processing): Build it. ++ * class.c (prepare_fresh_vtable): Use it instead of size_zero_node ++ when we're trying to make a negative delta. ++ ++Mon Jul 1 17:56:19 1996 Brendan Kehoe ++ ++ Stop doing this damn index==strchr variable name confusion. ++ * class.c (add_virtual_function): Change local var INDEX to be ++ named IDX. ++ (add_method): Likewise. ++ * lex.c (print_parse_statistics): Likewise. ++ * search.c (make_memoized_table_entry): Likewise. ++ (lookup_fnfields_here): Likewise. ++ (lookup_field): Likewise. ++ (lookup_fnfields): Likewise. ++ (get_baselinks): Likewise. ++ * sig.c (build_signature_table_constructor): Likewise. ++ (build_signature_method_call): Likewise. ++ * typeck.c (build_x_array_ref): Change INDEX parm to be named IDX. ++ (get_member_function_from_ptrfunc): Likewise. ++ (build_ptrmemfunc): Change local var INDEX to be IDX. ++ (c_expand_start_case): Likewise. ++ ++Sat Jun 29 14:05:46 1996 Jason Merrill ++ ++ * cvt.c (cp_convert_to_pointer): Move user-defined type conversion ++ handling to before extraction of TYPE_PTRMEMFUNC_FN_TYPE. ++ (convert_to_reference): Use build_type_conversion to convert to ++ the reference type directly. ++ (standard_conversion): Fix void* case, non-conversions. ++ (reference_binding): Fix expr == 0 case, non-conversions. ++ (convert_like): Support REF_BIND. ++ (compare_qual): Split out from compare_ics. ++ (compare_ics): Use it, handle icses with only a qual_conv. ++ ++ * init.c (expand_vec_init): Don't crash if decl is NULL. ++ ++Fri Jun 28 11:52:51 1996 Stan Shebs ++ ++ * mpw-config.in: New file, configury for Mac MPW. ++ * mpw-make.sed: New file, makefile editing for MPW. ++ ++Thu Jun 27 15:18:30 1996 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Call repo_template_used. ++ ++ * search.c (lookup_conversions): Only lookup conversions in ++ complete types. ++ ++Thu Jun 27 12:59:53 1996 Brendan Kehoe ++ ++ * cp-tree.def: Renamed from tree.def, to avoid confusion with ++ gcc's tree.def. ++ * cp-tree.h, lex.c: Include cp-tree.def. ++ * Makefile.in (CXX_TREE_H): Reference cp-tree.def. ++ ++Wed Jun 26 18:29:47 1996 Bob Manson ++ ++ * init.c (build_vec_delete_1): Call complete_type. ++ ++Mon Jun 24 17:17:32 1996 Mike Stump ++ ++ * except.c (start_anon_func): Make sure anonymous functions are ++ never external. ++ ++Fri Jun 21 15:10:58 1996 Jason Merrill ++ ++ * decl.c (finish_function): If function_depth > 1, set nested. ++ ++ * decl2.c (grokbitfield): Revert Bob's change. ++ * class.c (finish_struct_1): Fix handling of named bitfield widths. ++ ++Thu Jun 20 23:35:38 1996 Jason Merrill ++ ++ * pt.c (add_pending_template): Handle types. ++ (lookup_template_class): With -fexternal-templates, just add the class ++ to pending_templates instead of instantiating it now. ++ * decl2.c (finish_file): Handle types in pending_templates. ++ ++Thu Jun 20 14:08:40 1996 Bob Manson ++ ++ * decl2.c (grokbitfield): Handle constant decls appropriately. ++ Give an appropriate error message now instead of spewing core ++ later. ++ ++Thu Jun 20 13:01:51 1996 Jason Merrill ++ ++ * decl2.c: Don't turn on thunks by default for now. ++ ++Wed Jun 19 11:37:04 1996 Jason Merrill ++ ++ * typeck.c (complete_type): Handle error_mark_node. ++ (common_type, OFFSET_TYPE): Handle template_type_parms. ++ ++Tue Jun 18 10:02:15 1996 Jason Merrill ++ ++ * pt.c (instantiate_decl): If at_eof, call import_export_decl ++ regardless of DECL_INLINE. ++ ++ * typeck.c (mark_addressable): Set TREE_ADDRESSABLE on CONSTRUCTORs. ++ ++ * class.c (finish_struct_bits): Copy TYPE_SIZE. ++ ++ * rtti.c (build_dynamic_cast): Support templates. ++ * tree.def: Support DYNAMIC_CAST_EXPR. ++ * pt.c (tsubst_copy): Likewise. ++ * decl2.c (build_expr_from_tree): Likewise. ++ ++Mon Jun 17 15:23:36 1996 Jason Merrill ++ ++ * typeck.c (build_static_cast): Support templates. ++ (build_const_cast): Likewise. ++ * tree.def: Support CONST/STATIC_CAST_EXPR. ++ * pt.c (tsubst_copy): Likewise. ++ * decl2.c (build_expr_from_tree): Likewise. ++ ++Sun Jun 16 12:33:57 1996 Jason Merrill ++ ++ * decl2.c (finish_vtable_vardecl): Don't trust ++ TREE_SYMBOL_REFERENCED for vtables of local classes. ++ ++Fri Jun 14 18:13:36 1996 Jason Merrill ++ ++ * pt.c (tsubst_copy): Handle operator T. ++ ++Wed Jun 12 17:52:40 1996 Brendan Kehoe ++ ++ * init.c (build_delete): Move creation of PARMS inside test of ++ TYPE_HAS_DESTRUCTOR, since it's never used outside of that block. ++ ++Tue Jun 11 15:09:18 1996 Bob Manson ++ ++ * typeck.c (build_conditional_expr): Don't assume that ++ the arguments to ?: are always pointers or records. ++ ++Tue Jun 11 13:56:23 1996 Jason Merrill ++ ++ * decl2.c (import_export_decl): Still emit static/weak/comdat ++ copies of inline template functions with -fno-implicit-templates. ++ ++Tue Jun 11 11:42:13 1996 Bob Manson ++ ++ * init.c (build_delete): Determine the complete basetype ++ path to the destructor we're calling. ++ ++Fri Jun 7 15:30:10 1996 Bob Manson ++ ++ * decl.c (build_enumerator): Always copy the INTEGER_CST used to ++ initialize the enum, because we really and truly don't know where ++ it came from. ++ (start_enum): Don't copy integer_zero_node because ++ build_enumerator will do it. ++ ++Fri Jun 7 11:11:09 1996 Jason Merrill ++ ++ * decl.c (finish_function): Do access control on base destructors. ++ ++ * pt.c (tsubst, case FUNCTION_DECL): Set up ++ IDENTIFIER_GLOBAL_VALUE for member functions so pushdecl doesn't ++ hose us. ++ ++Fri Jun 7 10:37:33 1996 Mike Stump ++ ++ * cvt.c (build_up_reference): If we have already extended the ++ lifetime of the temporary, don't try it again. ++ * typeck.c (c_expand_return): Don't try and convert the return ++ value twice when we want a reference, once is enough. ++ ++Tue Jun 4 15:41:45 1996 Jason Merrill ++ ++ * pt.c (tsubst_expr, case DECL_STMT): Don't pass ++ LOOKUP_ONLYCONVERTING at all for now. ++ ++ * search.c (add_conversions): Put the conversion function in ++ TREE_VALUE, the basetype in TREE_PURPOSE. ++ * cvt.c (build_type_conversion): Adjust. ++ * cvt.c (build_expr_type_conversion): Adjust. ++ * call.c (user_harshness): Adjust. ++ ++Mon Jun 3 15:30:52 1996 Jason Merrill ++ ++ * method.c (emit_thunk): Pretend this is a FUNCTION_DECL for the ++ backend's benefit. ++ ++Mon Jun 10 18:58:19 1996 Mike Stump ++ ++ * except.c (expand_start_catch_block): Add a dummy region, if we ++ get an error, so that we can avoid core dumping later. ++ ++Fri May 31 14:56:13 1996 Mike Stump ++ ++ * cp-tree.h (OFFSET_REF): Remove. ++ * tree.def (CP_OFFSET_REF): Rename to OFFSET_REF. ++ * expr.c (cplus_expand_expr): Cleanup callers of expand_expr. ++ * init.c (expand_aggr_init_1): Likewise. ++ (build_new): Likewise. ++ * typeck.c (expand_target_expr): Likewise. ++ ++Fri May 31 14:22:08 1996 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Don't use TREE_VALUE on a ++ TARGET_EXPR. ++ ++Wed May 29 17:04:33 1996 Mike Stump ++ ++ * cvt.c (build_up_reference): Redo how and when temporaries are ++ created. ++ * decl.c (grok_reference_init): Don't try and be smart about ++ running cleanups. ++ ++Wed May 29 16:02:08 1996 Mike Stump ++ ++ * cvt.c (build_up_reference): Add NULL_TREE to all calls to build ++ (TARGET_EXPR...), now that it has 4 arguments. ++ * tree.c (build_cplus_new): Likewise. ++ ++Thu May 23 16:40:30 1996 Jason Merrill ++ ++ * error.c (dump_expr, case CAST_EXPR): Handle T() properly. ++ ++ * pt.c (instantiate_decl): Don't call push/pop_cp_function_context. ++ * decl.c (struct saved_scope): Remove named_labels, ++ {base,member}_init_list. ++ (maybe_push_to_top_level): Don't set them. Call ++ push_cp_function_context if appropriate. ++ (pop_from_top_level): Likewise. ++ ++ * method.c (do_build_assign_ref): Remove obsolete check of ++ TYPE_HAS_ASSIGN_REF (basetype). ++ ++ * decl.c (grokfndecl): Diagnose user definition of ++ implicitly-declared methods. ++ ++Thu May 23 12:13:08 1996 Bob Manson ++ ++ * method.c (do_build_copy_constructor): Add code to give ++ meaningful error messages instead of crashing. ++ (do_build_assign_ref): Don't synthesize assignment operators for ++ classes containing reference or const members. ++ ++ * class.c (struct base_info): Remove cant_synth_copy_ctor ++ and cant_synth_asn_ref. ++ (finish_base_struct): Remove the code that tries to conditionalize ++ synthesis of copy constructors & assignment operators based on ++ access permissions. Instead, let it fail when it tries to ++ synthesize the copy constructor. This will give meaningful error ++ messages instead of silently generating code to perform a bitcopy. ++ ++Wed May 22 11:45:19 1996 Bob Manson ++ ++ * lex.c (real_yylex): Remove old-n-crufty #if 0 code for ++ determining types for constant values. ++ ++ * decl.c (struct named_label_list): Use instead of stuffing ++ random items into a TREE_LIST node. ++ (named_label_uses): Use the new struct. ++ (poplevel): Likewise. ++ (lookup_label): Likewise. ++ (define_label): Add an error message to tell the user the line ++ where the goto is located in addition to the destination of the ++ goto. ++ (init_decl_processing): Use NULL instead of NULL_TREE to initialize ++ named_label_uses. ++ (finish_function): Likewise. ++ ++ (start_decl): Complain about defining a static data member ++ in a different type from which it was declared. ++ ++Wed May 22 09:33:23 1996 Jason Merrill ++ ++ * cvt.c (build_expr_type_conversion): Adjust. ++ ++Tue May 21 11:21:56 1996 Jason Merrill ++ ++ * call.c (build_method_call): Always convert 'this' to the ++ appropriate type. ++ ++ * search.c (add_conversions): Put the conversion function in ++ TREE_VALUE, the type in TREE_PURPOSE. ++ * cvt.c (build_type_conversion): Adjust. ++ * call.c (user_harshness): Adjust. ++ ++ * method.c (emit_thunk): Call temporary_allocation and ++ permanent_allocation around the ASM_OUTPUT_MI_THUNK case, too. ++ ++ * tree.c (build_cplus_array_type): Handle tweaking of ++ TYPE_MAIN_VARIANT here. ++ * typeck.c (common_type): Not here. ++ ++ * typeck.c (complete_type): Only try to complete an array type if ++ it has a domain. ++ ++Mon May 20 14:55:59 1996 Jason Merrill ++ ++ * decl.c (grokvardecl): Call complete_type. ++ (grokdeclarator): Call complete_type for PARM_DECLs. ++ ++Fri May 17 16:41:17 1996 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Re-set ++ CLASSTYPE_GOT_SEMICOLON after calling finish_struct_1. ++ ++Fri May 17 14:56:55 1996 Mike Stump ++ ++ * cp-tree.h (cp_expand_decl_cleanup): Remove, the backend is now ++ smart enough to do it right. ++ * tree.c (cp_expand_decl_cleanup): Likewise. ++ * decl.c (cp_finish_decl): Use expand_decl_cleanup instead of ++ cp_expand_decl_cleanup. ++ (store_parm_decls): Likewise. ++ (hack_incomplete_structures): Likewise. ++ * except.c (push_eh_cleanup): Likewise. ++ ++Fri May 17 13:13:51 1996 Mike Stump ++ ++ * expr.c (expand_expr, cond UNSAVE_EXPR): Move from the C++ ++ frontend to the backend where it belongs. ++ * tree.c (unsave_expr): Likewise. ++ (unsave_expr_now): Likewise. ++ * tree.def (UNSAVE_EXPR): Likewise. ++ * cp-tree.h (unsave_expr): Likewise. ++ (unsave_expr_now): Likewise. ++ ++Fri May 17 11:02:41 1996 Mike Stump ++ ++ * init.c (emit_base_init): Make sure the partial EH cleanups live ++ on the function_obstack. ++ ++Thu May 16 15:29:33 1996 Bob Manson ++ ++ * expr.c (do_case): Don't try to dereference null TREE_TYPEs ++ when checking for pointer types. ++ ++Thu May 16 13:38:58 1996 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Remove obsolete check for ++ access declarations. ++ ++Thu May 16 13:34:15 1996 Mike Stump ++ ++ * call.c (build_overload_call): Simplify calls to ++ build_overload_call by removing last parameter. ++ (build_method_call): Likewise. ++ * cp-tree.h: Likewise. ++ * method.c (build_opfncall): Likewise. ++ * typeck.c (build_x_function_call): Likewise. ++ ++Thu May 16 13:15:43 1996 Mike Stump ++ ++ * call.c (default_parm_conversions): Factor out common code. ++ (build_method_call): Use it. ++ (build_overload_call_real): Use it. ++ ++Wed May 15 14:46:14 1996 Mike Stump ++ ++ * call.c (build_method_call): Allow implicit & on METHOD_TYPEs, ++ but pedwarn as the code is bogus. ++ * typeck.c (decay_conversion): Likewise. ++ (build_function_call_real): Use build_addr_func instead of ++ default_conversion. Don't allow pointer-to-method functions down ++ here. ++ (build_unary_op): Use real pointer-to-member functions instead of ++ fake ones. ++ (build_ptrmemfunc): Use build_addr_func instead of build_unary_op. ++ (convert_for_assignment): Removed some obsolete code. ++ * decl2.c (reparse_absdcl_as_expr): Pass current_class_ref to ++ build_x_function_call instead of current_class_ptr. Only call ++ digest_init once on an initializer, we do this just checking ++ TREE_TYPE. ++ (build_expr_from_tree): Pass current_class_ref to ++ build_x_function_call instead of current_class_ptr. ++ * init.c (build_member_call): Likewise. ++ * pase.y: Likewise. ++ * error.c (dump_expr): Handle OFFSET_REFs better. ++ * pt.c (unify): Handle pointer-to-member functions better. ++ * decl.c (finish_function): Clear out current_class_ref just like ++ we do for current_class_ptr. ++ ++ * typeck.c (get_delta_difference): Handle virtual bases better. ++ ++Tue May 14 16:37:37 1996 Jason Merrill ++ ++ * sig.c (build_signature_table_constructor): Use the delta for ++ the original basetype for this virtual function with thunks. ++ (build_signature_method_call): We still need to adjust 'this' ++ with thunks. ++ ++Tue May 14 16:27:25 1996 Mike Stump ++ ++ * call.c (build_addr_func): New routine. Used to get the `real' ++ address of a function or a method. Needed to avoid getting a ++ pointer-to-member function. ++ (build_call): New routine to build CALL_EXPRs. ++ (build_method_call): Use it. ++ * cvt.c (convert_to_aggr): Likewise. ++ * typeck.c (build_function_call_real): Likewise. ++ * sig.c (build_signature_table_constructor): Use build_addr_func. ++ * cp-tree.h (build_call, build_addr_func): Declare them. ++ ++Tue May 14 12:47:47 1996 Mike Stump ++ ++ * cp-tree.h (LOOKUP_AGGR): Remove, unused. ++ * parse.y: Remove uses of LOOKUP_AGGR. ++ ++Tue May 14 12:07:51 1996 Mike Stump ++ ++ * *.[chy]: Rename current_class_decl to current_class_ptr, and ++ C_C_D to current_class_ref. ++ ++Mon May 13 16:55:23 1996 Jason Merrill ++ ++ * call.c (convert_harshness): Tighten up pointer conversions. ++ ++Sat May 11 04:33:50 1996 Doug Evans ++ ++ * decl2.c (finish_vtable_vardecl): Surround DECL_ONE_ONLY with ifdef. ++ (finish_file): Likewise. ++ ++Fri May 10 11:09:57 1996 Jason Merrill ++ ++ * cvt.c (convert_fn_ptr): We don't use thunks for pmfs. ++ ++ * method.c (emit_thunk): Set flag_omit_frame_pointer in default ++ code. ++ ++Thu May 9 18:18:30 1996 Jason Merrill ++ ++ * decl2.c: Turn on thunks by default where supported. ++ ++Tue May 7 20:39:57 1996 Mike Stump ++ ++ * cp-tree.h (build_overload_call_maybe): Removed. ++ * call.c (build_overload_call_real): Invert meaning of last arg to ++ be require_complete. ++ (build_overload_call): Likewise. ++ * typeck.c (build_x_function_call): Use build_overload_call_real ++ instead of build_overload_call_maybe. ++ ++Mon May 6 01:23:32 1996 Jason Merrill ++ ++ * decl2.c (finish_file): Don't try to emit functions that haven't ++ been compiled. ++ ++Fri May 3 09:30:13 1996 Jason Merrill ++ ++ * decl2.c (finish_vtable_vardecl): Oops. ++ ++ * decl.c (maybe_push_to_top_level): Do save previous_class_*. ++ Also store the bindings from previous_class_values. ++ (pop_from_top_level): Restore them. ++ ++Thu May 2 21:56:49 1996 Jason Merrill ++ ++ * decl2.c (finish_vtable_vardecl): Only write out vtable if its ++ symbol has been referenced. ++ (finish_file): Re-join synthesis/vtable loop with inline emission ++ loop, disable inlining when an inline is output. ++ ++Thu May 2 17:20:02 1996 Mike Stump ++ ++ * except.c (init_exception_processing): Setup saved_in_catch. ++ (push_eh_cleanup): Reset __eh_in_catch. ++ (expand_start_catch_block): Set __eh_in_catch. ++ ++Thu May 2 16:21:17 1996 Mike Stump ++ ++ * except.c (push_eh_cleanup): Add tracking for whether or not we ++ have an active exception object. ++ (expand_builtin_throw): Use it to make sure a rethrow without an ++ exception object is caught. ++ ++Thu May 2 11:26:41 1996 Jason Merrill ++ ++ * decl.c (maybe_push_to_top_level): Clear out class-level bindings ++ cache. ++ ++Wed May 1 11:26:52 1996 Jason Merrill ++ ++ * decl2.c (finish_file): Also use sentries for vars with ++ DECL_ONE_ONLY or DECL_WEAK set (should any such happen to be ++ created). ++ ++ * lex.c (handle_cp_pragma): Disable #pragma ++ interface/implementation if SUPPORTS_ONE_ONLY > 1. ++ ++Tue Apr 30 11:25:46 1996 Jason Merrill ++ ++ * method.c (emit_thunk): Wrap default case in ++ temporary/permanent_allocation. ++ ++ * method.c (make_thunk): Use DECL_ONE_ONLY. ++ (emit_thunk): Call assemble_end_function. ++ ++Mon Apr 29 15:38:29 1996 Jason Merrill ++ ++ * decl2.c (import_export_vtable): Use DECL_ONE_ONLY. ++ (import_export_decl): Likewise. ++ (finish_prevtable_vardecl): Disable vtable hack if ++ SUPPORTS_ONE_ONLY > 1. ++ ++Mon Apr 29 14:32:47 1996 Mike Stump ++ ++ * typeck.c (build_modify_expr): PREINCREMENT_EXPR and ++ PREDECREMENT_EXPRs take two arguments, not one. ++ ++Mon Apr 29 00:27:53 1996 Jason Merrill ++ ++ * class.c (build_vtable_entry): Don't build thunks for abstract ++ virtuals. ++ ++ * lex.c (real_yylex): Fix handling of __PRETTY_FUNCTION__ like C ++ frontend. ++ ++Sat Apr 27 16:45:35 1996 Jason Merrill ++ ++ * class.c (set_rtti_entry): Use size_zero_node. ++ (build_vtable): Likewise. ++ ++Sat Apr 27 14:48:57 1996 Jason Merrill ++ ++ * class.c (finish_struct_1): Pass size_zero_node to set_rtti_entry. ++ (prepare_fresh_vtable): Likewise. ++ ++Fri Apr 26 13:14:14 1996 Jason Merrill ++ ++ * method.c (emit_thunk): Call mark_used on the target function. ++ ++ * call.c (build_method_call): Don't warn about pending templates. ++ ++Thu Apr 25 14:55:44 1996 Jason Merrill ++ ++ * decl2.c (finish_file): Fix list walking logic. ++ ++ * typeck2.c (check_for_new_type): Only warn if -pedantic. ++ ++Wed Apr 24 15:41:15 1996 Bob Manson ++ ++ * class.c (finish_struct_1): Remove old code for ++ dont_allow_type_definitions. ++ * cp-tree.h: Likewise. ++ * spew.c: Make sure cp-tree.h is included before parse.h, so the ++ definition of flagged_type_tree is found before it is used. ++ * lex.c: Likewise. ++ * parse.y: Added the ftype member to the type union, and changed a ++ number of rules to use it instead of ttype. Added calls to ++ check_for_new_type() as appropriate. ++ * typeck2.c (check_for_new_type): New function for checking ++ if a newly defined type appears in the specified tree. ++ * cp-tree.h: Add new type flagged_type_tree. Add a prototype ++ for check_for_new_type(). ++ ++Wed Apr 24 00:36:21 1996 Jason Merrill ++ ++ * decl2.c (finish_file): Only use a sentry if the decl is public. ++ ++ * pt.c (tsubst_expr, DECL_STMT): If we don't have an initializer, ++ don't pass LOOKUP_ONLYCONVERTING. ++ ++Tue Apr 23 17:18:47 1996 Bob Manson ++ ++ * typeck.c (common_type): Fix the ARRAY_TYPE case so it ++ properly keeps track of const and volatile type modifiers. ++ ++Tue Apr 23 10:52:56 1996 Jason Merrill ++ ++ * tree.c (cp_tree_equal): C++ version of simple_cst_equal. ++ * pt.c (comp_template_args): Use it. ++ ++ * rtti.c (get_tinfo_fn, build_dynamic_cast, expand_*_desc): Call ++ assemble_external for artificial function decls. ++ ++ * decl.c (cp_finish_decl): Oops. ++ ++Mon Apr 22 17:28:27 1996 Jason Merrill ++ ++ * decl2.c (import_export_decl): Put static data member templates ++ into common storage, or make them weak, depending on whether they ++ are dynamically or statically initialized. ++ (get_sentry): New function. ++ (finish_file): Do import_export_decl for static data members before ++ building the init/fini functions. Don't init/fini a variable that's ++ EXTERNAL. Use a sentry for variables in common. Fix mismatching ++ push/pop_temp_slots. ++ * decl.c (cp_finish_decl): If DECL_NOT_REALLY_EXTERN, do the ++ expand_static_init thang. ++ * method.c (get_id_2): New function. ++ ++Mon Apr 22 15:32:45 1996 Bob Manson ++ ++ * parse.y (empty_parms): Make sure we use C++-style prototypes ++ when we're declaring member functions. ++ ++Sun Apr 21 10:08:22 1996 Jason Merrill ++ ++ * Makefile.in (CONFLICTS): 16 s/r conflicts. ++ * parse.y (self_template_type): New nonterminal. ++ ++Thu Apr 18 08:56:54 1996 Jason Merrill ++ ++ * decl.c (make_typename_type): Handle getting a TYPE_DECL for a ++ name. ++ * parse.y (base_class.1): Allow 'typename foo::bar'. ++ ++ * lex.c (check_newline): Remove #pragma code that plays with the ++ input stream, since we now deal with tokens. Clear nextchar when ++ we're done. ++ (handle_cp_pragma): Use real_yylex. ++ (handle_sysv_pragma): Don't do skipline here. Only call real_yylex ++ in one place. ++ ++ * lex.c (check_for_missing_semicolon): Handle SELFNAME. ++ ++ * lex.c (handle_cp_pragma): Fix "#pragma implementation". ++ ++Wed Apr 17 16:51:33 1996 Jason Merrill ++ ++ * parse.y: New token SELFNAME for potential constructor. ++ * spew.c (yylex): Handle it. ++ * lex.c (identifier_type): Produce it. ++ ++ * parse.y (complete_type_name): In :: case, don't push class binding. ++ (complex_type_name): Likewise. ++ ++Wed Apr 17 15:02:40 1996 Mike Stump ++ ++ * typeck.c (build_reinterpret_cast): Handle pointer to member ++ functions. ++ ++Wed Apr 17 12:28:26 1996 Brendan Kehoe ++ ++ * lex.c (handle_cp_pragma): New function, with decl, doing the cc1plus ++ pragmas. ++ (check_newline): Put the vtable/unit/implementation/interface pragma ++ code into handle_cp_pragma, replacing it with a call. ++ (handle_sysv_pragma): Give int return type, and take FINPUT and TOKEN ++ args. Get the next token after handling the pragma token. ++ ++Wed Apr 17 10:28:34 1996 Jason Merrill ++ ++ * cvt.c (cp_convert_to_pointer): Avoid doing base analysis on pmfs. ++ (convert_to_pointer_force): Likewise. ++ ++ * init.c (build_new): Fix array new without -fcheck-new. ++ ++Tue Apr 16 13:44:58 1996 Jason Merrill ++ ++ * cp-tree.h, call.c, class.c, decl.c, parse.y, pt.c, rtti.c, ++ tree.c: Lose TYPE_NESTED_NAME. ++ ++ * parse.y (nested_name_specifier_1): Don't treat non-identifiers ++ as identifiers. ++ ++ * tree.def: Add VEC_INIT_EXPR. ++ * expr.c (cplus_expand_expr): Handle it. ++ * init.c (build_new): Use it instead of the RTL_EXPR nastiness and ++ the extra file-scope symbol nastiness. ++ ++Mon Apr 15 16:21:29 1996 Jason Merrill ++ ++ * method.c (make_thunk): Thunks are static. ++ (emit_thunk): Use ASM_OUTPUT_MI_THUNK if it's defined. ++ ++ * decl2.c (mark_vtable_entries): Emit thunks as needed. ++ (finish_file): Don't emit them here. ++ ++Sun Apr 14 11:34:39 1996 Jason Merrill ++ ++ * rtti.c (build_dynamic_cast): Handle null pointers. ++ (ifnonnull): New function. ++ ++Fri Apr 12 09:08:27 1996 Bob Manson ++ ++ * call.c (build_method_call): Remember the original basetype we ++ were called with. Give an error message instead of trying ++ (incorrectly) to call a non-static member function through a ++ non-inherited class. ++ ++ * search.c (expand_upcast_fixups): Mark the new fixup as ++ DECL_ARTIFICIAL. ++ ++Thu Apr 11 03:57:09 1996 Jason Merrill ++ ++ * init.c (build_new): Use a TARGET_EXPR for alloc_expr. ++ ++ * class.c (set_rtti_entry): Fix for thunks. ++ ++ * decl2.c (import_export_decl): Still emit typeinfo fns for ++ cv-variants of builtin types. ++ ++ * rtti.c (expand_class_desc): Set up base_info_type_node here. ++ (init_rtti_processing): Instead of here. ++ ++Wed Apr 10 14:17:13 1996 Jason Merrill ++ ++ * rtti.c (init_rtti_processing): Do init regardless of -frtti. ++ (build_typeid): Only complain about taking dynamic typeid without ++ -frtti. ++ ++ * decl2.c: flag_rtti defaults to 1. ++ ++ * rtti.c (get_tinfo_var): The general class case is now smaller. ++ (init_rtti_processing): Pack the latter three fields of base_info ++ into 32 bits. ++ ++Wed Apr 10 13:50:14 1996 Mike Stump ++ ++ * init.c (expand_member_init): Don't dump if name is NULL_TREE. ++ ++Wed Apr 10 12:56:02 1996 Mike Stump ++ ++ * search.c (make_memoized_table_entry): Undefer the pop, if necessary. ++ (push_memoized_context): Split out code to undefer pop_type_level to ++ (clear_memoized_cache): here. ++ (pop_memoized_context): We can only handle one layer of deferral of ++ pop_type_level so clear the cache, if there was a previous level. ++ ++Tue Apr 9 23:06:09 1996 Jason Merrill ++ ++ * rtti.c (init_rtti_processing): Build up base_info_type_node. ++ (expand_class_desc): Use one pointer to an array of base_info ++ structs, passed using a CONSTRUCTOR. ++ ++Tue Apr 9 14:20:57 1996 Mike Stump ++ ++ * class.c (build_vbase_path): Remove block extern for ++ flag_assume_nonnull_objects here. ++ (build_vfn_ref): Split out functionality into build_vtbl_ref. ++ (build_vtbl_ref): New routine. ++ (build_vtable): Set up rtti info here. ++ (add_virtual_function): Note in CLASSTYPE_RTTI the best ++ place where we can get the rtti pointers from to avoid having to ++ search around for a place. ++ (finish_base_struct): Likewise. ++ (finish_struct_1): Likewise. Never create totally new vtables ++ with totally new vtable pointers for rtti. Disable code to layout ++ vtable pointers better until we want to break binary ++ compatibility. ++ * rtti.c (build_headof_sub): New routine to convert down to a ++ sub-object that has an rtti pointer in the vtable. ++ (build_headof): Use it. Also, use build_vtbl_ref now to be more ++ maintainable. ++ (build_dynamic_cast): Make sure we have saved it, if we need to. ++ * search.c (dfs_init_vbase_pointers): Disable code that deals with ++ a more efficient vtable layout, enable later. ++ * call.c (flag_assume_nonnull_objects): Moved declaration to ++ * cp-tree.h: here. Declare build_vtbl_ref. ++ * pt.c (instantiate_class_template): Use NULL_TREE instead of 0 in ++ function calls that want a tree. ++ ++Tue Apr 9 12:10:26 1996 Jason Merrill ++ ++ * rtti.c (build_dynamic_cast): Handle downcasting to X* given ++ other X subobjects in the most derived type. Ack. ++ ++ * rtti.c (build_dynamic_cast): No need to strip cv-quals here, ++ get_typeid will do it for us. ++ (get_typeid_1): Break out call-building for expand_*_desc to use. ++ (get_typeid): Call it. ++ (expand_*_desc): Likewise. ++ * decl.c (init_decl_processing): Don't set TYPE_BUILT_IN on char * ++ and void *. ++ (init_decl_processing): Lose builtin_type_tdescs lossage. ++ * decl2.c (finish_vtable_vardecl): Remove obsolete code. ++ ++Mon Apr 8 17:23:23 1996 Bob Manson ++ ++ * pt.c (tsubst): When calling set_nested_typename, use ++ TYPE_NESTED_NAME (current_class_type) instead of ++ current_class_name. ++ ++ * decl.c (pushdecl): Likewise. ++ (pushdecl_class_level): Likewise. ++ (grokdeclarator): Use NULL_TREE instead of 0 in the call to ++ set_nested_typename. ++ ++Sun Apr 7 10:44:31 1996 Jason Merrill ++ ++ * rtti.c (synthesize_tinfo_fn): Handle arrays. ++ ++ * cp-tree.h (DECL_REALLY_EXTERN): New macro. ++ ++Sat Apr 6 13:56:27 1996 Jason Merrill ++ ++ * rtti.c (throw_bad_cast): Use entry point __throw_bad_cast. ++ (init_rtti_processing): Lose bad_cast_type. ++ (build_dynamic_cast): Use throw_bad_cast. ++ ++ * rtti.c (synthesize_tinfo_fn): Handle enums and pmfs. ++ ++ * decl2.c (finish_file): Don't synthesize artificial functions ++ that are external and not inline. ++ ++ * rtti.c (get_tinfo_fn): If at_eof, call import_export_decl. ++ ++ * decl2.c (finish_file): Handle having new inlines added to ++ saved_inlines by synthesis. ++ ++ * rtti.c (get_bad_cast_node): Don't require . ++ ++Fri Apr 5 17:02:09 1996 Jason Merrill ++ ++ RTTI rewrite to initialize nodes as needed, not require that ++ users #include , complete functionality and reduce wasted ++ space. ++ * rtti.c (init_rtti_processing): New fn. ++ (build_typeid): The vtable entry is now a function. ++ (get_tinfo_var): New fn. ++ (get_tinfo_fn): Likewise. ++ (get_typeid): Use it. ++ (build_dynamic_cast): Declare and use entry point __dynamic_cast. ++ (build_*_desc): Rename to expand_*_desc and rewrite to use entry ++ points __rtti_*. ++ (add_uninstantiated_desc, get_def_to_follow, build_t_desc): Lose. ++ (synthesize_tinfo_fn): New fn. ++ * method.c (build_t_desc_overload): Lose. ++ (build_overload_with_type): More generic. ++ * decl.c (init_decl_processing): Call init_rtti_processing. ++ * class.c (set_rtti_entry): Use get_tinfo_fn. ++ * decl2.c (mark_vtable_entries): Mark the rtti function. ++ (finish_prevtable_vardecl): Don't build_t_desc. ++ (import_export_decl): Handle tinfo functions. ++ (finish_file): Likewise. ++ * typeck.c (inline_conversion): New fn. ++ (build_function_call_real): Use it. ++ * cp-tree.h: Add decls. ++ ++ * method.c (hack_identifier): Also convert component_refs from ++ references. ++ ++ * lex.c (cons_up_default_function): Use the type, not the name, in ++ declspecs. ++ ++ * decl2.c (import_export_vtable): Fix weak vtables. ++ ++Fri Apr 5 13:30:17 1996 Bob Manson ++ ++ * search.c (get_base_distance_recursive): Fix access checks for ++ protected bases. ++ ++Fri Apr 5 11:02:06 1996 Brendan Kehoe ++ ++ * call.c (unary_complex_lvalue): Delete unneeded decl, it's in ++ cp-tree.h. ++ (convert_harshness): Add prototypes wrapped by PROTO. ++ * decl2.c (grok_function_init): Likewise. ++ (do_toplevel_using_decl): Change to void return type. ++ * class.c (build_vtable_entry): Remove decl of make_thunk. ++ (merge_overrides): Fix order of arg definitions. ++ (finish_vtbls): Likewise. ++ (fixup_vtable_deltas): Likewise. ++ (modify_all_direct_vtables): Likewise. ++ (modify_all_indirect_vtables): Likewise. ++ * search.c (get_base_distance_recursive): Likewise. ++ (get_abstract_virtuals_1): Likewise. ++ (fixup_virtual_upcast_offsets): Likewise. ++ (lookup_fnfields_1): Add prototypes wrapped by PROTO. ++ * init.c (perform_member_init): Fix order of arg definitions. ++ (expand_aggr_init_1): Add prototypes wrapped by PROTO. ++ * cp-tree.h (make_thunk): Add decl. ++ (overload_template_name, push_template_decl): Add decls. ++ (do_toplevel_using_decl): Change to void return type. ++ (vec_binfo_member): Add decl. ++ ++Thu Apr 4 13:33:10 1996 Brendan Kehoe ++ ++ * typeck.c (mark_addressable, convert_for_assignment, ++ convert_for_initialization, pointer_int_sum, pointer_diff, ++ unary_complex_lvalue): Add prototypes wrapped by PROTO. ++ (convert_sequence): #if 0 fn decl, since definition also is. ++ ++Thu Apr 4 11:00:53 1996 Mike Stump ++ ++ * rtti.c (build_dynamic_cast): Make sure we strip qualifiers on ++ cast to pointer types for type searching. ++ ++Wed Apr 3 17:10:57 1996 Brendan Kehoe ++ ++ * typeck.c (get_delta_difference): Use cp_error, not error, in the ++ case where BINFO == 0. ++ ++Wed Apr 3 12:01:02 1996 Mike Stump ++ ++ * call.c (build_method_call): Fix wording of error messages so ++ constructors come out right. ++ ++Tue Apr 2 16:06:59 1996 Bob Manson ++ ++ * decl.c (push_overloaded_decl): Don't warn about hidden ++ constructors when both the type and the function are declared ++ in a system header file. ++ ++Mon Apr 1 09:03:13 1996 Bob Manson ++ ++ * class.c (finish_struct_1): Propagate the TYPE_PACKED ++ flag for the type to the type's fields. ++ ++Sat Mar 30 12:14:33 1996 Brendan Kehoe ++ ++ * parse.y (complex_parmlist, ELLIPSES): Take out ARM-based warning. ++ ++Fri Mar 29 15:51:36 1996 Bob Manson ++ ++ * class.c (base_info, finish_base_struct): Replace ++ needs_virtual_dtor with base_has_virtual. ++ ++ (finish_struct_1): Remove the old code that tried to make default ++ destructors virtual. Use base_has_virtual when checking if we need ++ to add a vtable entry for the rtti code. ++ ++Fri Mar 29 14:02:36 1996 Jason Merrill ++ ++ * pt.c (push_template_decl): Complain about template decl with ++ inappropriate declaration. ++ ++Fri Mar 29 12:15:35 1996 Bob Manson ++ ++ * typeck.c (build_x_unary_op): Remove bogus check for taking ++ the address of a member function. ++ ++Fri Mar 29 11:56:02 1996 Jason Merrill ++ ++ * parse.y (constructor_declarator): Only push the class if ++ we are not already in the class. ++ ++Fri Mar 29 09:41:02 1996 Jeffrey A. Law ++ ++ * method.c (emit_thunk): Remove current_call_is_indirect nonsense. ++ Add additional argument to INIT_CUMULATIVE_ARGS. ++ ++Thu Mar 28 16:41:39 1996 Jason Merrill ++ ++ * decl.c (shadow_tag): Fix error about anon union with methods. ++ ++ * parse.y (self_reference): Only generate a self-reference if this ++ is a non-template class. ++ (opt.component_decl_list): Only use it if it was generated. ++ ++ * parse.y (component_decl_1): Use constructor_declarator. ++ (fn.def2): Likewise. ++ (notype_component_declarator0): Likewise. ++ ++Thu Mar 28 15:11:35 1996 Bob Manson ++ ++ * typeck.c (build_x_unary_op): Add checks for taking the address ++ of a TARGET_EXPR or of a member function, and give appropriate ++ warnings. ++ ++Thu Mar 28 14:49:26 1996 Jason Merrill ++ ++ * pt.c (process_template_parm): Allow template type parms to be ++ used as types for template const parms. ++ ++Wed Mar 27 15:51:19 1996 Mike Stump ++ ++ * init.c (expand_vec_init): Ensure the eh cleanups are on the ++ function_obstack. ++ ++Wed Mar 27 10:14:30 1996 Jason Merrill ++ ++ * decl.c (lookup_name_real): Be even more picky about the ++ ambiguous lookup warning. ++ (grokdeclarator): Tweak SCOPE_REF constructor declarators here. ++ * parse.y (constructor_declarator): Rather than here. ++ ++ * parse.y (constructor_declarator): New nonterminal. ++ (fn.def1): Use it. ++ (explicit_instantiation): Likewise. ++ ++Tue Mar 26 13:41:33 1996 Jason Merrill ++ ++ Add implicit declaration of class name at class scope. ++ * decl.c (lookup_name_real): Restrict pedwarn about ambiguous lookup. ++ * parse.y (self_reference): New nonterminal. ++ (opt.component_decl_list): Use it. ++ (fn.def1): Add nested_name_specifier type_name cases. ++ * class.c (build_self_reference): New function. ++ (finish_struct): Handle access_default later, move self-reference ++ decl to the end. ++ * pt.c (lookup_template_class): Handle getting a TYPE_DECL. ++ * cp-tree.h: Adjust. ++ ++ * pt.c (do_function_instantiation): Separate handling of member ++ functions and non-member functions properly. ++ ++Mon Mar 25 14:23:22 1996 Jason Merrill ++ ++ * pt.c (process_template_parm): Improve error for 'volatile class K'. ++ ++ * class.c (finish_struct_1): Check the right slot for destructors. ++ ++ * decl.c (start_enum): Complain about enum templates. ++ ++Mon Mar 25 13:25:31 1996 Mike Stump ++ ++ * init.c (resolve_offset_ref): Offset pointers to member data by one. ++ * typeck.c (unary_complex_lvalue): Likewise. ++ ++Mon Mar 25 13:30:42 1996 Bob Manson ++ ++ * typeck.c (c_expand_return): Check for a returned local ++ array name, similar to the check for an ADDR_EXPR. ++ ++Mon Mar 25 13:07:19 1996 Jason Merrill ++ ++ * decl.c (cp_finish_decl): Don't build cleanups for static ++ variables here. ++ ++Fri Mar 22 17:57:55 1996 Mike Stump ++ ++ * typeck.c (build_modify_expr): Fix error messages to be more ++ accurate. ++ * cp-tree.h (assop_as_string): Parallel to op_as_string, but for ++ assignment operators. ++ * error.c (assop_as_string): Likewise. Add support for `%Q' for ++ assignment operators. ++ ++Fri Mar 22 13:48:29 1996 Jason Merrill ++ ++ * decl.c (grokdeclarator): Call bad_specifiers for typedefs. Also ++ give an error if initialized. pedwarn about nested type with the ++ same name as its enclosing class. ++ ++ * pt.c (tsubst, case TYPE_DECL): Set DECL_CONTEXT. ++ ++ * typeck.c (require_complete_type): Be sure to instantiate the ++ MAIN_VARIANT of the type. ++ ++ * decl2.c (finish_file): Instantiate pending templates before ++ processing static constructors and destructors. ++ ++ * pt.c (instantiate_decl): Don't instantiate functions at toplevel ++ unless at_eof. ++ ++Fri Mar 22 09:30:17 1996 Bob Manson ++ ++ * decl2.c (delete_sanity): If error_mark_node is passed ++ in as an expression, quit while we're ahead. ++ ++ * decl.c (grokdeclarator): Give an error message if `friend' ++ is combined with any storage class specifiers. ++ ++Wed Mar 20 14:51:55 1996 Jason Merrill ++ ++ * parse.y (named_complex_class_head_sans_basetype): Don't crash on ++ definition of nonexistent nested type. ++ ++ * error.c (dump_decl, case TYPE_DECL): Fix decision for whether or ++ not to say 'typedef'. ++ ++Wed Mar 20 00:11:47 1996 Brendan Kehoe ++ ++ * cp-tree.h (struct lang_type): Make search_slot a tree, not a char*. ++ * search.c (dfs_walk, dfs_init_vbase_pointers, ++ expand_upcast_fixups): Remove cast of CLASSTYPE_SEARCH_SLOT. ++ (dfs_find_vbases): Remove cast for CLASSTYPE_SEARCH_SLOT init. ++ ++Tue Mar 19 17:56:03 1996 Jason Merrill ++ ++ * except.c (build_throw): Support minimal parse. ++ * pt.c (tsubst_copy): Support THROW_EXPR. ++ * decl2.c (build_expr_from_tree): Likewise. ++ ++ * pt.c (mangle_class_name_for_template): Always allocate ++ scratch_firstobj. ++ ++Tue Mar 19 16:34:31 1996 Bob Manson ++ ++ * cvt.c (cp_convert_to_pointer): Give an appropriate error ++ when trying to cast from an incomplete type. ++ ++Tue Mar 19 16:00:33 1996 Jason Merrill ++ ++ * pt.c (instantiate_class_template): Don't bother setting up ++ CLASSTYPE_TAGS explicitly, as the nested types will add ++ themselves. ++ ++Tue Mar 19 15:48:43 1996 Bob Manson ++ ++ * decl.c (shadow_tag): Remove old error check for usage of ++ an enum without a previous declaration. ++ (xref_tag): Add error message about usage of enums without a ++ previous declaration. ++ ++Tue Mar 19 09:21:35 1996 Jason Merrill ++ ++ * lex.c (do_identifier): Only do name consistency check if we're ++ parsing. ++ ++ * pt.c (push_template_decl): Don't crash if we get a member defn ++ that doesn't match. ++ ++ * decl.c (xref_tag_from_type): New function to do an xref without ++ always having to figure out code_type_node. ++ * cp-tree.h: Declare it. ++ * pt.c (instantiate_class_template): Use it for friend classes. ++ (lookup_template_class): Use it. ++ ++ * typeck2.c (build_functional_cast): Pull out a single parm before ++ passing it to build_c_cast. ++ ++Tue Mar 19 09:07:15 1996 Bob Manson ++ ++ * expr.c (do_case): Give an error message if a pointer is ++ given as a case value. ++ ++Mon Mar 18 21:57:54 1996 Jason Merrill ++ ++ * typeck.c (build_c_cast): Don't pull single TEMPLATE_DECL out of ++ an overload list. ++ ++ * lex.c (cons_up_default_function): Really, now, interface hackery ++ does not apply to synthesized methods. ++ ++Mon Mar 18 18:20:57 1996 Mike Stump ++ ++ * call.c (build_method_call): Ctors and dtors now have special names ++ with respect to lookups. ++ * class.c (add_method): Likewise. ++ (grow_method): Likewise. ++ (finish_struct_methods): Likewise. ++ (warn_hidden): Likewise. ++ (finish_struct_1): Likewise. ++ * cvt.c (convert_to_reference): Likewise. ++ (convert_to_aggr): Likewise. ++ (cp_convert): Likewise. ++ * decl2.c (check_classfn): Likewise. ++ * init.c (expand_member_init): Likewise. ++ (expand_default_init): Likewise. ++ (expand_aggr_init_1): Likewise. ++ (build_offset_ref): Likewise. ++ (build_new): Likewise. ++ (build_delete): Likewise. ++ * lex.c (do_inline_function_hair): Likewise. ++ * search.c (lookup_field_1): Likewise. ++ (lookup_fnfields_here): Likewise. ++ (lookup_field): Likewise. ++ (lookup_fnfields): Likewise. ++ (get_virtual_destructor): Likewise. ++ (dfs_debug_mark): Likewise. ++ (dfs_pushdecls): Likewise. ++ (dfs_compress_decls): Likewise. ++ * tree.c (layout_basetypes): Likewise. ++ * typeck.c (build_component_ref): Likewise. ++ (build_x_function_call): Likewise. ++ (build_modify_expr): Likewise. ++ (convert_for_initialization): Likewise. ++ (build_functional_cast): Likewise. ++ * cp-tree.h (CLASSTYPE_FIRST_CONVERSION): Likewise. ++ (CTOR_NAME): New. ++ (DTOR_NAME): New. ++ * decl.c (ctor_identifier): New. ++ (dtor_identifier): New. ++ (init_decl_processing): Set them. ++ ++Mon Mar 18 18:00:51 1996 Mike Stump ++ ++ * typeck.c (build_component_ref): Don't get confused by fields whose ++ context has no type name, like pointer to member functions. ++ ++Mon Mar 18 13:19:03 1996 Jason Merrill ++ ++ * decl.c (grokdeclarator): Handle typedef without declarator. ++ ++ * pt.c (tsubst): Handle SCOPE_REF in declarator. ++ ++ * parse.y (bad_parm): Catch another case of missing `typename'. ++ ++ * lex.c (yyprint): Handle TYPE_DECLs. ++ ++ * decl.c (start_function): Don't try to be clever. ++ ++ * lex.c: Lose compiler_error_with_decl. ++ * typeck2.c: Lose error_with_aggr_type. ++ (incomplete_type_error): Use cp_* instead of old functions. ++ (readonly_error): Likewise. ++ * typeck.c (convert_arguments): Likewise. ++ * search.c (lookup_nested_field): Likewise. ++ * method.c (make_thunk): Likewise. ++ * decl.c (grokparms): Likewise. ++ * cp-tree.h: Update. ++ ++ * tree.c (min_tree_cons): Call copy_to_permanent for the purpose ++ and value. ++ ++Mon Mar 18 11:25:52 1996 Bob Manson ++ ++ * method.c (build_opfncall): When deleting a pointer to an ++ array, build a new pointer to the tree past any ARRAY_TYPE ++ nodes. ++ ++Mon Mar 18 10:11:46 1996 Brendan Kehoe ++ ++ * decl.c (lookup_name_real): Initialize local var TYPE to NULL_TREE. ++ ++Fri Mar 15 11:03:57 1996 Jason Merrill ++ ++ * pt.c (instantiate_decl): Only call import_export_decl if at_eof ++ and ! DECL_INLINE. ++ ++ * decl.c (finish_function): Don't set nested based on ++ hack_decl_function_context. ++ * parse.y (function_try_block): Check for nested function. ++ (pending_inlines): Likewise. ++ ++ * decl2.c (build_expr_from_tree): If a unary op already has a ++ type, just return it. ++ ++ * decl2.c (finish_prevtable_vardecl): Use ADJUST_VTABLE_LINKAGE. ++ ++ * decl2.c (walk_vtables): vardecl_fn returns int; return 1 if it does. ++ (finish_file): Check the return value of walk_vtables. ++ (finish_prevtable_vardecl): Return int. ++ (finish_vtable_vardecl): Likewise. ++ (prune_vtable_vardecl): Likewise. ++ * lex.c (set_vardecl_interface_info): Likewise. ++ * cp-tree.h: Adjust return types. ++ ++ * class.c (delete_duplicate_fields_1): Don't complain about ++ duplicate nested types if they're the same type. ++ (finish_struct): Remove check for duplicate. ++ * decl2.c (grokfield): Don't check for typedef of anonymous type. ++ ++Thu Mar 14 10:00:19 1996 Jason Merrill ++ ++ * cp-tree.h: Lose SIGNATURE_GROKKING_TYPEDEF. ++ ++ * decl.c (grokdeclarator): Lose special handling of class-level ++ typedef. Lose SIGNATURE_GROKKING_TYPEDEF. Set ++ SIGNATURE_HAS_OPAQUE_TYPEDECLS later. ++ ++ * cvt.c (convert_pointer_to_real): Retain cv-quals in conversion. ++ ++ * pt.c (tsubst_copy): Strip cv-quals from destructor name types. ++ ++ * search.c (compute_access): Fix handling of anonymous union ++ members. ++ * class.c (finish_struct_anon): Propagate TREE_{PRIVATE,PROTECTED} ++ from anonymous unions to their members. ++ ++ * typeck.c (build_x_function_call): For static member functions, ++ hand off to build_member_call. ++ ++Wed Mar 13 14:03:34 1996 Jason Merrill ++ ++ * typeck.c (build_component_ref): Handle OFFSET_REFs. ++ ++ * init.c (expand_vec_init): Fix init == 0 case. ++ ++Tue Mar 12 14:36:02 1996 Jason Merrill ++ ++ * init.c (build_new): pedwarn about init and array new. ++ (expand_vec_init): Handle lists, use convert_for_initialization. ++ ++ * typeck.c (convert_for_initialization): Pass LOOKUP_NO_CONVERSION ++ when converting to an aggregate type. ++ * cvt.c (cp_convert): Pass it through. ++ ++ * typeck.c (build_conditional_expr): Handle user-defined ++ conversions to slightly different types. ++ ++ * decl.c (grokdeclarator): Force an array type in a parm to be ++ permanent. ++ ++ * decl2.c (do_using_directive): Sorry. ++ (do_namespace_alias): Likewise. ++ * lex.c (real_yylex): Warn about using the `namespace' keyword. ++ ++Sun Mar 10 22:26:09 1996 Jason Merrill ++ ++ * parse.y (datadef): Move call to note_list_got_semicolon up. ++ ++Fri Mar 8 11:47:26 1996 Mike Stump ++ ++ * tree.c (unsave_expr): Don't unsave, UNSAVE_EXPRs. ++ ++Fri Mar 8 11:29:06 1996 Mike Stump ++ ++ * decl.c (cp_finish_decl): The exception regions have to be ++ nested, not overlapping. We start the exception region for a ++ decl, after it has been fully built, and all temporaries for it ++ have been cleaned up. ++ ++Thu Mar 7 17:46:06 1996 Mike Stump ++ ++ * tree.c (vec_binfo_member): Don't core dump if we have no bases. ++ ++Thu Mar 7 14:11:49 1996 Jason Merrill ++ ++ * tree.def: Add RETURN_INIT. ++ * pt.c (instantiate_decl): Handle RETURN_INIT. ++ * decl.c (store_return_init): Handle minimal_parse_mode. ++ ++ * tree.c (cp_build_type_variant): Just return an error_mark_node. ++ * decl.c (make_typename_type): Don't try to get the file and line ++ of an identifier. ++ * typeck.c (comptypes): Handle TYPENAME_TYPE. ++ ++Wed Mar 6 18:47:50 1996 Per Bothner ++ ++ * decl.c (poplevel): Make sure we clear out and restore old local ++ non-VAR_DECL values by default when they go out of scope. ++ ++Wed Mar 6 09:57:36 1996 Jason Merrill ++ ++ * method.c (build_overload_value): Use DECL_ASSEMBLER_NAME in ++ referring to addresses of variables and functions. ++ ++ * error.c (dump_expr): Support SIZEOF_EXPR. ++ ++ * init.c (do_friend): Use the return value of check_classfn. ++ ++ * typeck.c (convert_arguments): Call complete_type. ++ ++ * method.c (hack_identifier): After giving an error, set value to ++ error_mark_node. ++ ++Tue Mar 5 16:00:15 1996 Jason Merrill ++ ++ * tree.c (hack_decl_function_context): Kludge around DECL_CONTEXT ++ lossage for local classes. ++ * cp-tree.h: Declare it. ++ * decl.c (lookup_name_real): Evil, painful hack for local classes. ++ (grokfndecl): Set DECL_CLASS_CONTEXT and DECL_NO_STATIC_CHAIN here. ++ Use hack_decl_function_context. ++ (grokdeclarator): Don't set DECL_NO_STATIC_CHAIN here. ++ (start_function): Use hack_decl_function_context. ++ (finish_function): Likewise. ++ * method.c (synthesize_method): Likewise. ++ * lex.c (process_next_inline): Likewise. ++ (do_pending_inlines): Likewise. ++ * decl2.c (finish_file): Unset DECL_STATIC_FUNCTION_P when we're ++ done with it. ++ ++Mon Mar 4 22:38:39 1996 Gerald Baumgartner ++ ++ * sig.c (build_signature_pointer_or_reference_type): Align ++ signature pointers/references on 8-byte boundaries so they can be ++ grabbed 2 words at a time on a SPARC. ++ ++Tue Mar 5 10:21:01 1996 Jason Merrill ++ ++ * method.c (hack_identifier): Requiring a static chain is now a ++ hard error. ++ * decl.c (grokdeclarator): Set DECL_NO_STATIC_CHAIN on nested ++ functions. ++ ++Mon Mar 4 20:03:33 1996 Jason Merrill ++ ++ * init.c (build_offset_ref): Call complete_type. ++ ++ * decl.c (pop_from_top_level): Always pop previous_class_type. ++ ++ * parse.y: Handle multiple decls in a for-init-statement. ++ * pt.c (tsubst_expr): Likewise. ++ ++ * pt.c (tsubst): Use tsubst_expr for the second operand of an ++ ARRAY_REF. ++ ++ * decl.c (maybe_push_to_top_level): Don't save previous_class_type. ++ (poplevel_class): Set it here. ++ (pop_from_top_level): Pop it here if we're returning to class scope. ++ * class.c (pushclass): Don't set it here. ++ ++ * decl.c (maybe_push_to_top_level): Save current_template_parms, ++ and clear it if !pseudo. ++ (pop_from_top_level): Restore it. ++ ++ * decl2.c (finish_file): Push the dummy each time we walk the list ++ of vtables. ++ ++ * error.c (dump_expr): Support LOOKUP_EXPR and actually do ++ something for CAST_EXPR. ++ ++Mon Feb 19 14:49:18 1996 Rusty Russell ++ ++ * cvt.c (cp_convert): Warn about implicit conversion of the ++ address of a function to bool, as it is always true. ++ ++Fri Feb 23 23:06:01 1996 Rusty Russell ++ ++ * typeck.c (c_expand_return): Fix warning for local externs returned. ++ ++Mon Mar 4 15:03:11 1996 Jason Merrill ++ ++ * tree.c (mapcar): Propagate const and volatile properly. ++ ++ * typeck.c (complete_type): Be sure to instantiate the ++ MAIN_VARIANT of the type. ++ ++ * method.c (synthesize_method): Class interface hackery does not ++ apply to synthesized methods. ++ ++Mon Mar 4 14:05:23 1996 Jason Merrill ++ ++ * pt.c (comp_template_args): Use comptypes rather than just ++ checking for TEMPLATE_TYPE_PARM equivalence. ++ ++ * typeck.c (build_x_function_call): Call complete_type before ++ checking TYPE_OVERLOADS_CALL_EXPR. ++ ++Mon Mar 4 18:48:30 1996 Manfred Hollstein ++ ++ * g++.c (main): Check also for new define ALT_LIBM. ++ ++Fri Mar 1 13:09:33 1996 Jason Merrill ++ ++ * pt.c (instantiate_class_template): If we don't have a pattern ++ yet, that's OK. ++ (coerce_template_parms): If we see a local class, bail. ++ ++ * decl.c (grok_reference_init): Make sure there's a type before ++ checking its code. ++ ++ * pt.c (do_function_instantiation): Avoid crashing on invalid decls. ++ (push_template_decl): Likewise. ++ ++ * parse.y (named_class_head): Set ++ CLASSTYPE_TEMPLATE_SPECIALIZATION here if we have basetypes. ++ ++ * decl.c (xref_tag): Diagnose redeclaration of template ++ type-parameter name. ++ ++ * error.c (dump_type): Handle anonymous template type parms. ++ ++ * pt.c (instantiate_template): Use TYPE_MAIN_DECL instead of ++ TYPE_STUB_DECL. ++ (coerce_template_parms): Likewise. ++ ++Thu Feb 29 16:26:01 1996 Mike Stump ++ ++ * class.c (instantiate_type, case {ARRAY,INDIRECT}_REF, ++ case ADDR_EXPR): Don't modify rhs if a subinstantiation fails. ++ ++Thu Feb 29 08:20:25 1996 Jason Merrill ++ ++ * pt.c (instantiate_template): Take the MAIN_VARIANT of the type ++ before trying to get its STUB_DECL. ++ (coerce_template_parms): Likewise. ++ ++ * parse.y (template_type_parm): If they didn't use 'class', ++ pretend they did after giving an error. ++ ++ * pt.c (coerce_template_parms): Diagnose use of local class. ++ ++ * decl.c (grok_reference_init): Use instantiate_type. ++ ++ * error.c (dump_expr): Handle TEMPLATE_DECLs. ++ ++ * parse.y (named_class_head): Diagnose mismatching types and tags. ++ ++ * decl.c (pushdecl): Type decls and class templates clash with ++ artificial type decls, not hide them. ++ ++ * decl.c (redeclaration_error_message): Diagnose redefinition of ++ templates properly. ++ (duplicate_decls): Diagnose disallowed overloads for template ++ functions, too. ++ ++ * decl.c (start_decl): Call complete_type before checking for a ++ destructor. ++ ++ * pt.c (tsubst): Use tsubst_expr on the elts of a VEC. ++ ++ * decl.c (xref_tag): A TEMPLATE_TYPE_PARM is a match. ++ ++Wed Feb 28 09:28:44 1996 Jason Merrill ++ ++ * decl.c (grok_op_properties): Don't check for operator++(int) in ++ a template. ++ ++ * tree.c (perm_manip): Return a copy of variable and function ++ decls with external linkage. ++ ++ * tree.def: Change some of the min tree codes to type "1". ++ * pt.c (uses_template_parms): Handle 'e's, return 1 for LOOKUP_EXPRs. ++ * method.c (build_overload_int): Emit something arbitrary for ++ anything but an INTEGER_CST if we're in a template. ++ ++ * decl.c (cp_finish_decl): Call complete_type before deciding ++ whether or not to lay out the decl. ++ ++ * lex.c (do_identifier): Check for DECL_INITIAL before using it. ++ ++Tue Feb 27 16:35:32 1996 Jason Merrill ++ ++ * typeck2.c (build_x_arrow): Call complete_type. ++ ++ * pt.c (add_pending_template): Broken out. ++ (lookup_template_class): If -fexternal-templates, call it for all ++ the methods of implemented types. ++ (instantiate_class_template): Instead of instantiating them here. ++ (instantiate_decl): Handle -fexternal-templates earlier. ++ ++Tue Feb 27 15:51:32 1996 Brendan Kehoe ++ ++ * search.c, lex.c, decl.c, class.c, cp-tree.h: Don't wrap the ++ memoized lookup stuff inside GATHER_STATISTICS. ++ ++Tue Feb 27 10:38:08 1996 Jason Merrill ++ ++ * decl.c (start_decl): Complain about array of incomplete type ++ here. ++ (grokdeclarator): Not here. ++ ++ * parse.y (template_parm): Expand full_parm inline so we can set ++ the rule's precedence. ++ ++ * pt.c (tsubst_expr): If we're in a template, just do tsubst_copy. ++ (tsubst): tsubst_expr the DECL_INITIAL of FIELD_DECLs. ++ * decl2.c (grokbitfield): Don't check for integer constant here. ++ * class.c (finish_struct_1): Check here. ++ ++ * decl.c (define_label): Make the min decl go on permanent_obstack. ++ ++ * pt.c (unify): Don't handle CONST_DECLs. ++ (uses_template_parms): Don't check DECL_INITIAL on a CONST_DECL. ++ (tsubst_copy): Likewise. ++ ++ * lex.c (do_identifier): Do pull the DECL_INITIAL out of a ++ CONST_DECL for a template parm. ++ ++Mon Feb 26 12:48:18 1996 Jason Merrill ++ ++ * decl.c (grokdeclarator): Complain about array of incomplete type ++ here. ++ (start_decl_1): Not here. ++ ++ * pt.c (tsubst): Handle pointer-to-function declarators. ++ ++ * method.c (hack_identifier): If pedantic, diagnose local class ++ methods that require a static chain. ++ ++ * decl.c (grok_op_properties): No longer static. ++ * cp-tree.h: Declare it. ++ * pt.c (tsubst): Call it for operators. ++ Use tsubst_copy for TREE_VECs. ++ ++ * parse.y (template_arg): The expr has precedence like '>'. ++ ++Fri Feb 23 14:51:52 1996 Jason Merrill ++ ++ * pt.c (coerce_template_parms): Don't coerce an expression using ++ template parms. ++ (uses_template_parms): Also check DECL_INITIAL in CONST_DECLs. ++ (tsubst): Don't use build_index_2_type if the max_value uses template ++ parms. ++ * method.c (build_overload_int): Emit something arbitrary for an ++ expression using template parms. ++ ++ * parse.y (template_close_bracket): New non-terminal to catch use ++ of '>>' instead of '> >' in template class names. ++ (template_type): Use it. ++ * Makefile.in (CONFLICTS): Causes one more r/r conflict. ++ ++ * tree.def: Add CAST_EXPR. ++ * typeck2.c (build_functional_cast): Use CAST_EXPR instead of ++ CONVERT_EXPR for minimal_parse_mode. ++ * typeck.c (build_c_cast): Likewise. ++ * pt.c (tsubst_copy): Likewise. ++ * decl2.c (build_expr_from_tree): Likewise. ++ * error.c (dump_expr): Likewise. ++ ++Fri Feb 23 10:36:46 1996 Brendan Kehoe ++ ++ * except.c (SetTerminate, SetUnexpected): Put back global vars. ++ (init_exception_processing): Put back decl/init of ++ set_unexpected_fndecl and set_terminate_fndecl, needed to get the ++ fns from libstdc++. ++ ++ * decl.c (struct binding_level): Delete ACCEPT_ANY bitfield. ++ (declare_uninstantiated_type_level, uninstantiated_type_level_p): ++ Delete unused fns. ++ * cp-tree.h (declare_uninstantiated_type_level, ++ uninstantiated_type_level_p): Delete prototypes. ++ ++Thu Feb 22 19:36:15 1996 Jason Merrill ++ ++ * pt.c (tsubst_expr): Add default return. ++ ++Thu Feb 22 16:47:24 1996 Brendan Kehoe ++ ++ * error.c (fndecl_as_string): Delete unused arg CNAME. ++ * sig.c (build_signature_table_constructor, ++ build_signature_method_call): Fix calls. ++ ++ * class.c (the_null_vtable_entry): Delete var definition. ++ (init_class_processing): Delete tree the_null_vtable_entry init. ++ * decl.c (no_print_{functions, builtins}): Declare as static. ++ (__tp_desc_type_node): #if 0 var definition. ++ (init_type_desc): #if 0 init of __tp_desc_type_node. ++ (vb_off_identifier): Move var decl into init_decl_processing. ++ (current_function_assigns_this): Declare as static. ++ (int_ftype_ptr_ptr_int, void_ftype_ptr_int_int): Delete var decls. ++ (init_decl_processing): Delete init of void_ftype_ptr_ptr_int. ++ Move decls of string_ftype_ptr_ptr and int_ftype_string_string here. ++ * decl2.c (delete_sanity): Delete definition/mod of local var ELT_SIZE. ++ * init.c (BI_header_type, BI_header_size): Declare as static. ++ * pt.c (template_classes): Delete unused var. ++ (add_pending_template): Delete decl for non-existent fn. ++ (lookup_template_class): Delete vars CODE and TAG_CODE. ++ (instantiate_template): Delete unused var TARGS. ++ * cp-tree.h (vb_off_identifier, current_function_assigns_this): ++ Delete decls. ++ (__tp_desc_type_node): #if 0 var decl. ++ (fndecl_as_string): Fix prototype. ++ ++Thu Feb 22 15:56:19 1996 Jason Merrill ++ ++ * tree.def: Add GOTO_STMT. ++ * pt.c (tsubst_expr): Support goto and labels. ++ * decl.c (define_label): Support minimal parsing. ++ * parse.y (simple_stmt): Likewise. ++ ++Thu Feb 22 15:30:12 1996 Brendan Kehoe ++ ++ * xref.c (GNU_xref_member): Only define/set var I if ++ XREF_SHORT_MEMBER_NAMES is defined, to match when it's actually ++ used. ++ (GNU_xref_end_scope): Delete unused fifth arg TRNS. ++ (GNU_xref_end): Fix call. ++ * decl.c (poplevel, poplevel_class, finish_method): Fix calls. ++ * cp-tree.h (GNU_xref_end_scope): Fix prototype. ++ ++ * tree.c (build_exception_variant): Delete unused vars I, A, T, ++ T2, and CNAME. ++ (layout_vbasetypes): Delete unused var NONVIRTUAL_VAR_SIZE. ++ (mapcar): Delete unused var CODE. ++ (build_cplus_new): Delete unused arg WITH_CLEANUP_P. ++ (break_out_cleanups): Fix call. ++ (bot_manip): Likewise. ++ * call.c (build_method_call): Likewise. ++ * cvt.c (build_up_reference, convert_to_reference, cp_convert): ++ Likewise. ++ * typeck.c (unary_complex_lvalue, build_modify_expr, ++ convert_for_initialization): Likewise. ++ * typeck2.c (build_functional_cast): Likewise. ++ * cp-tree.h (build_cplus_new): Fix prototype. ++ ++ * repo.c (open_repo_file): Delete unused var Q. ++ (repo_compile_flags, repo_template_declared, ++ repo_template_defined, repo_class_defined, repo_inline_used, ++ repo_vtable_used, repo_tinfo_used): #if 0 unused fns. ++ (repo_get_id, repo_vtable_used): Declare as static. ++ * cp-tree.h (mark_{decl,class}_instantiated, finish_repo): Add ++ prototypes. ++ ++Thu Feb 22 14:53:35 1996 Jason Merrill ++ ++ * parse.y (pending_inlines): Add function_try_block case. ++ ++ * pt.c (unify): Fix for template const parms. ++ ++Thu Feb 22 13:24:15 1996 Brendan Kehoe ++ ++ * lex.c (extract_interface_info): Delete forward decl. ++ (default_copy_constructor_body, default_assign_ref_body): Delete ++ decls for non-existent functions. ++ (synth_firstobj, inline_text_firstobjs): Delete unused vars. ++ (init_lex): Delete setting them. ++ (cons_up_default_function): Delete unused vars FUNC_BUF, ++ FUNC_LEN, and COMPLEX. Delete code setting COMPLEX. Delete old ++ #if 0'd synth code. ++ (toplevel, expression_obstack): Delete unused extern decls. ++ (tree_node_kind): Delete unused enum. ++ (tree_node_counts, tree_node_sizes): Wrap with #ifdef ++ GATHER_STATISTICS. ++ (tree_node_kind_names): Delete unused extern decl. ++ (synth_obstack): Delete unused var. ++ (init_lex): Don't set it. ++ (init_parse): Add decl before use. ++ (reduce_count): Only define #ifdef GATHER_STATISTICS && REDUCE_LENGTH. ++ (current_unit_{name, language}): Delete unused vars. ++ (check_newline): Don't bother setting them, just accept the #pragma. ++ * cp-tree.h (init_repo, peek_yylex): Add prototypes. ++ (current_unit_{name, language}): Delete decls. ++ ++ * search.c: Wrap all of the memoized functions, macros, and ++ variables inside #ifdef GATHER_STATISTICS. ++ (lookup_field, lookup_fnfields): Likewise. ++ (init_search_processing): Likewise. ++ (reinit_search_statistics): Wrap whole function. ++ * lex.c (reinit_lang_specific): Wrap call to reinit_search_statistics. ++ ++ * decl.c (finish_function): Only call pop_memoized_context if ++ GATHER_STATISTICS is defined. ++ (start_function): Likewise for push_memoized_context. ++ * class.c (pushclass, popclass): Likewise. ++ ++ * cp-tree.h (CLASSTYPE_MTABLE_ENTRY): Move definition from here... ++ * search.c (CLASSTYPE_MTABLE_ENTRY): ... to here. ++ ++ * cvt.c (cp_convert): Delete unused local var FORM. ++ * cp-tree.h (can_convert, can_convert_arg, real_lvalue_p): Add ++ prototypes. ++ ++Thu Feb 22 13:19:44 1996 Jason Merrill ++ ++ * pt.c (do_poplevel): Oops; really return what we get from ++ poplevel this time. ++ ++Thu Feb 22 11:41:44 1996 Brendan Kehoe ++ ++ * cp-tree.h (is_aggr_type): Add prototype. ++ ++ * cp-tree.h ({push,pop}_cp_function_context): Add decls. ++ * method.c ({push,pop}_cp_function_context): Delete decls. ++ * except.c (start_eh_unwinder, end_eh_unwinder): Declare as void. ++ (SetUnexpected, SetTerminate): Delete unused vars. ++ (init_exception_processing): Don't set SetUnexpected or ++ SetTerminate. Don't set SET_UNEXPECTED_FNDECL or SET_TERMINATE_FNDECL. ++ (output_exception_table_entry): Delete unused array LABEL. ++ (expand_internal_throw): Delete unused var PARAMS. ++ (expand_start_catch_block): Delete unused var CLEANUP. ++ (emit_exception_table): Delete unused var EH_NODE_DECL. ++ (expand_builtin_throw): Delete unused vars UNWIND_AND_THROW and ++ GOTO_UNWIND_AND_THROW. Don't set them. ++ (end_eh_unwinder): Add top decl. ++ (pop_rtl_from_perm): Delete unused decl of PERMANENT_OBSTACK. ++ (exception_section, push_rtl_perm, do_function_call, ++ lang_interim_eh, push_eh_cleanup, eh_outer_context, ++ expand_end_eh_spec, end_eh_unwinder): Declare as static. ++ (saved_pc, saved_throw_type, saved_throw_value, saved_cleanup, ++ throw_used): Likewise. ++ * cp-tree.h (expand_end_eh_spec): Delete prototype. ++ ++ * search.c (dfs_mark, dfs_mark_vtable_path, ++ dfs_unmark_vtable_path, dfs_mark_new_vtable, ++ dfs_unmark_new_vtable, dfs_clear_search_slot, ++ dfs_search_slot_nonempty_p, bfs_markedp, bfs_unmarkedp, ++ bfs_marked_vtable_pathp, bfs_unmarked_vtable_pathp, ++ bfs_marked_new_vtablep, bfs_unmarked_new_vtablep): #if 0 unused ++ functions. ++ (n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1, ++ n_calls_lookup_fnfields, n_calls_lookup_fnfields_1, ++ n_calls_get_base_type, n_outer_fields_searched, n_contexts_saved): ++ Only define #ifdef GATHER_STATISTICS. ++ (reinit_search_statistics): Only init some vars if GATHER_STATISTICS ++ is defined. ++ (vbase_decl): Delete var definition. ++ (init_search): Delete old decl. ++ (init_vbase_pointers): Delete building of VBASE_DECL, since it's ++ never actually used. ++ (expand_indirect_vtbls_init): Delete init of VBASE_DECL. ++ (get_base_distance_recursive): Delete unused fourth arg ++ BASETYPE_PATH. Fix call . ++ (get_base_distance): Fix call. ++ (push_class_decls): Delete unused var ID. ++ (make_memoized_table_entry): Declare as static. ++ (breadth_first_search): Declare as static. ++ (tree_has_any_destructor_p): Declare as static. ++ (pop_class_decls): Delete unused arg pop_class_decls. ++ * class.c (popclass): Fix call to pop_class_decls. ++ * cp-tree.h (make_memoized_table_entry, breadth_first_search, ++ tree_has_any_destructor_p): Delete prototypes. ++ ++ * rtti.c (build_ptmf_desc): Delete unused arg TYPE. ++ (build_t_desc): Fix call. Delete unused vars ELEMS and TT. ++ (build_dynamic_cast): Delete unused local vars TMP1 and RETVAL. ++ (build_user_desc): Delete unused var T. ++ (build_class_desc): Delete unused vars T and OFF. ++ (build_t_desc): Delete unused var NAME_STRING. ++ (build_headof): Make static. ++ (get_bad_cast_node): Likewise. ++ (get_def_to_follow): Likewise. ++ * cp-tree.h (init_type_desc): Add prototype. ++ (build_headof): Remove prototype. ++ ++Thu Feb 22 00:54:22 1996 Jason Merrill ++ ++ * pt.c (tsubst): Only look for matching decls at file scope for ++ non-member functions. ++ ++ * call.c (build_scoped_method_call): Handle scoped destructor ++ calls in templates. ++ ++ * decl.c (*_top_level): Also save previous_class_values. ++ ++ * pt.c (tsubst_expr): Support do {} while loops. ++ * parse.y (simple_stmt): Likewise. ++ * tree.def: Likewise. ++ ++ * method.c (build_overload_identifier): For a class nested in a ++ template class, don't mangle in the template parms from our ++ context. ++ ++ * lex.c, cp-tree.h: Remove support for template instantiations in ++ the pending_inlines code. ++ * pt.c: Remove dead functions and unused arguments. ++ (uses_template_parms): TYPENAME_TYPEs always use template parms. ++ * parse.y: Stop passing anything to end_template_decl. ++ * tree.c (print_lang_statistics): Only print tinst info #ifdef ++ GATHER_STATISTICS. ++ ++Wed Feb 21 16:57:33 1996 Brendan Kehoe ++ ++ * init.c (expand_recursive_init{,_1}): Delete decls. ++ (sort_member_init): Delete unused var INIT. ++ (emit_base_init): Delete unused var X. ++ (build_offset_ref): Delete unused var CNAME. ++ (sort_member_init): Delete unused var FIELDS_TO_UNMARK. ++ (emit_base_init): Delete unused local var BASE. Delete extern ++ decl of IN_CHARGE_IDENTIFIER. ++ (build_delete): Delete unused local var VIRTUAL_SIZE. ++ ++ * init.c (build_vec_delete): Delete unused third arg ELT_SIZE. ++ (build_delete): Fix call. ++ * decl2.c (delete_sanity): Likewise. ++ * cp-tree.h (build_vec_delete): Update prototype. ++ ++ * typeck.c (common_base_type): Delete unused var TMP. ++ (build_binary_op): Delete local var ARGS_SAVE. ++ (build_array_ref): Delete unused var ITYPE. ++ (c_expand_return): Delete unused var USE_TEMP. ++ ++ * typeck.c (compexcepttypes): Delete unused arg STRICT. ++ (comptypes): Fix calls. ++ * decl.c (duplicate_decls): Likewise. ++ * cp-tree.h (compexcepttypes): Delete extra arg. ++ ++ * decl2.c (check_classfn): Delete unused second arg CNAME. ++ * decl.c (start_decl, grokfndecl): Fix calls. ++ * init.c (do_friend): Likewise. ++ * cp-tree.h (check_classfn): Update prototype. ++ ++ * cp-tree.h (signature_error, import_export_vtable, ++ append_signature_fields, id_in_current_class, mark_used, ++ copy_assignment_arg_p): Add decls. ++ * decl2.c (mark_used): Delete decl. ++ ++ * class.c (n_*): Wrap with #ifdef GATHER_STATISTICS. ++ ++ * class.c (get_vtable_entry): Disable unused function. ++ (doing_hard_virtuals): Delete unused static global var. ++ (finish_struct_1): Don't init DOING_HARD_VIRTUALS. ++ (prepare_fresh_vtable): Delete unused vars PATH and RESULT. ++ (overrides): Delete unused vars RETTYPE and BASE_RETTYPE. ++ (modify_one_vtable): Delete unused var OLD_RTTI. ++ (finish_struct_anon): Delete unused vars OFFSET and X. ++ (finish_struct_bits): Delete unused var METHOD_VEC. ++ (get_basefndecls): Delete unused var PURPOSE. Delete unused ++ for-scope local variable METHODS. ++ ++ * call.c (user_harshness): Delete unused/unneeded arg PARM. ++ (ideal_candidate): Delete unused args BASETYPE and PARMS. ++ (build_method_call): Delete unused args passed into ideal_candidate. ++ (build_overload_call_real): Likewise. Delete unused var OVERLOAD_NAME. ++ * cp-tree.h (synthesize_method): Add decl. ++ ++ * decl.c (note_level_for_for): Give void return type. ++ (pushdecl_nonclass_level): Likewise. ++ (finish_function): Delete unused vars VFIELDS and ALLOCATED_THIS. ++ (poplevel): Delete unused var IMPLICIT_TRY_BLOCK. ++ (suspend_binding_level): Delete unused var LEVEL. ++ (duplicate_decls): Delete unused var CTYPE. ++ (duplicate_decls): Delete unused var PREVIOUS_C_DECL. ++ (init_decl_processing): Delete unused vars FLOAT_ENDLINK and ++ PTR_ENDLINK. ++ (grokdeclarator): Delete unused var C. ++ (grokdeclarator): Delete unused var SIZE_VARIES. ++ (grokparms): Delete unused var SAW_VOID. ++ (start_function): Delete unused var OLDDECL. ++ (cplus_expand_expr_stmt): Delete unused var ++ REMOVE_IMPLICIT_IMMEDIATELY. ++ ++ * cp-tree.h (pushdecl_nonclass_level): Fix prototype. ++ ++ * Makefile.in (CONFLICTS): Update to 12 shift/reduce. ++ ++Wed Feb 21 00:06:17 1996 Jason Merrill ++ ++ * tree.c (build_min): Set TREE_COMPLEXITY to lineno. ++ (build_min_nt): Likewise. ++ * pt.c (do_pushlevel): Emit line note. ++ (do_poplevel): Return what we get from poplevel. ++ (tsubst_expr): Set lineno from TREE_COMPLEXITY in stmt nodes. ++ * parse.y: Use do_pushlevel and do_poplevel. ++ * cp-tree.h: Declare do_poplevel. ++ ++ * cp-tree.h: Declare at_eof. ++ * decl.c (cp_finish_decl): Pass it to rest_of_decl_compilation. ++ * decl2.c (import_export_decl): Renamed from import_export_inline. ++ (finish_file): Call it to do interface handling for statics. ++ * pt.c (tsubst_copy): Call mark_used on variables and functions ++ used here. ++ ++ * decl2.c (finish_file): Don't emit statics we can't generate. ++ * pt.c (instantiate_decl): Don't set interface on instantiations ++ we can't generate. ++ ++ * cp-tree.h (struct tinst_level): Change 'classname' to 'decl'. ++ * tree.c (print_lang_statistics): Print max template depth. ++ * pt.c (push_tinst_level): Dump entire instantiation context. ++ (instantiate_class_template): Use it and pop_tinst_level. ++ (instantiate_decl): Likewise. ++ ++ * call.c class.c cp-tree.h decl.c decl2.c error.c lex.c method.c ++ pt.c ptree.c tree.def: Remove all traces of UNINSTANTIATED_P_TYPE. ++ ++Tue Feb 20 18:21:51 1996 Jason Merrill ++ ++ * call.c class.c cp-tree.h cvt.c decl.c decl2.c error.c expr.c ++ init.c lex.c method.c parse.y pt.c repo.c search.c spew.c tree.c ++ tree.def typeck.c typeck2.c xref.c: Massive, systemic changes for ++ the new template implementation. ++ ++Tue Feb 20 17:14:29 1996 Brendan Kehoe ++ ++ * decl2.c (check_cp_case_value): Use STRIP_TYPE_NOPS. ++ ++Thu Feb 15 18:44:42 1996 Mike Stump ++ ++ * decl.c (cp_finish_decl): Delay emitting the debug information for ++ a typedef that has been installed as the canonical typedef, if the ++ type has not yet been defined. ++ ++Thu Feb 15 09:39:08 1996 Jason Merrill ++ ++ * decl2.c (grokfield): Still call pop_nested_class for access decls. ++ ++Wed Feb 14 17:30:04 1996 Brendan Kehoe ++ ++ * decl.c (lookup_label): Call label_rtx. ++ ++ * decl.c (make_binding_level): New function. ++ (pushlevel, pushlevel_class): Call it instead of explicit ++ duplicate calls to xmalloc. ++ ++ * decl.c (init_decl_processing): Delete useless build_pointer_type ++ call. ++ ++ * decl.c (float_ftype_float, ldouble_ftype_ldouble): Add definitions. ++ (sizet_ftype_string): Delete variable. ++ (init_decl_processing): Add built-in functions fabsf, fabsl, ++ sqrtf, sqrtl, sinf, sin, sinl, cosf, cos, cosl. New local ++ variable strlen_ftype, used for strlen. ++ ++Wed Feb 14 16:21:25 1996 Jason Merrill ++ ++ * decl.c (push_to_top_level): Start from current_binding_level ++ again for now; the stl hacks depend on g++ being broken in this ++ way, and it'll be fixed in the template rewrite. ++ ++ * tree.def: Add USING_DECL. ++ * decl2.c (do_class_using_decl): Implement. ++ (grokfield): Pass access decls off to do_class_using_decl instead of ++ grokdeclarator. ++ * error.c (dump_decl): Handle USING_DECLs. ++ * decl.c (grokdeclarator): Remove code for handling access decls. ++ * class.c (finish_struct_1): Adjust accordingly, treat using-decls ++ as access decls for now. ++ (finish_struct): Don't check USING_DECLs for other uses of the name. ++ ++ * search.c (get_matching_virtual): Use cp_error_at. ++ ++Wed Feb 14 10:36:58 1996 Brendan Kehoe ++ ++ * typeck.c (comptypes): Default COMP_TYPE_ATTRIBUTES to 1, to ++ match c-typeck.c. ++ (self_promoting_args_p): Move the check that TYPE is non-nil ++ before trying to look at its main variant. ++ (unsigned_type, signed_type): Add checking of DI/SI/HI/QI nodes. ++ ++ * cp-tree.h (DECL_WAITING_FRIENDS, SET_DECL_WAITING_FRIENDS): ++ Delete macros. ++ * init.c (xref_friend, embrace_waiting_friends): Delete functions. ++ (do_friend): Delete call to xref_friend. ++ * class.c (finish_struct_1): Delete call to embrace_waiting_friends. ++ ++ * typeck.c (convert_sequence): #if 0 unused function. ++ ++ * cp-tree.h (DECL_IN_MEMORY_P): New macro w/ the check that used to ++ be in decl_in_memory_p. ++ (decl_in_memory_p): Delete decl. ++ * expr.c (decl_in_memory_p): Delete fn. ++ * typeck.c (mark_addressable): Use DECL_IN_MEMORY_P. ++ ++ * decl.c (cp_finish_decl): Use DECL_IN_MEMORY_P. ++ ++Tue Feb 13 12:51:21 1996 Jason Merrill ++ ++ * class.c (finish_struct_1): Check for a pure-specifier on a ++ non-virtual function here. ++ ++ * decl2.c (grok_function_init): Don't check whether the function ++ is virtual here. ++ (grokfield): Don't call check_for_override here. ++ ++ * decl.c (push_to_top_level): Start from inner_binding_level, ++ check class_shadowed in class levels. ++ ++Mon Feb 12 17:46:59 1996 Mike Stump ++ ++ * decl.c (resume_level): Ignore things that don't have names, instead ++ of core dumping. ++ ++Mon Feb 12 15:47:44 1996 Brendan Kehoe ++ ++ * decl2.c (grokfield): Set DECL_VINDEX properly for FUNCTION_DECLs. ++ ++Sat Feb 10 17:59:45 1996 Jason Merrill ++ ++ * class.c (finish_struct_1): Set DECL_VINDEX properly on a ++ synthesized dtor. ++ ++ * parse.y (complete_type_name): Bind global_scope earlier. ++ (complex_type_name): Likewise. ++ (qualified_type_name): Remove. ++ ++Thu Feb 8 15:15:14 1996 Jason Merrill ++ ++ * decl.c (grokfndecl): Move code that looks for virtuals in base ++ classes... ++ * class.c (check_for_override): ... to a new function. ++ (finish_struct_1): Call it. ++ ++ * cp-tree.h: Declare warn_sign_compare. ++ ++ * typeck.c (build_binary_op_nodefault): Check warn_sign_compare ++ rather than extra_warnings to decide whether to warn about ++ comparison of signed and unsigned. ++ ++ * decl2.c (lang_decode_option): Handle warn_sign_compare. -Wall ++ implies -Wsign-compare. -Wall doesn't imply -W. ++ ++Wed Feb 7 15:27:57 1996 Mike Stump ++ ++ * typeck.c (build_component_ref): Fix to handle anon unions in base ++ classes as well. ++ ++Wed Feb 7 14:29:12 1996 Brendan Kehoe ++ ++ * class.c (resolves_to_fixed_type_p): Delete code dealing with ++ a WITH_CLEANUP_EXPR, since we don't generate them any more. ++ * cvt.c (build_up_reference): Likewise. ++ * decl.c (grok_reference_init): Likewise. ++ (cp_finish_decl): Likewise. ++ * error.c (dump_expr): Likewise. ++ * tree.c (real_lvalue_p): Likewise. ++ (lvalue_p): Likewise. ++ (build_cplus_new): Likewise. ++ (unsave_expr_now): Likewise. ++ * typeck.c (unary_complex_lvalue, build_modify_expr, ++ c_expand_return): Likewise. ++ ++Tue Feb 6 13:39:22 1996 Brendan Kehoe ++ ++ Make the C++ front-end pay attention to attributes for structures. ++ * class.c (finish_struct): New argument ATTRIBUTES, passed down into ++ finish_struct_1. ++ (finish_struct_1): New argument ATTRIBUTES; call cplus_decl_attributes. ++ Take out old round_up_size use and setting the DECL_ALIGN possibly ++ using it. Take out setting of TYPE_ALIGN to round_up_size, which ++ can override what the attribute set. ++ * cp-tree.h (finish_struct): Update prototype. ++ * parse.y (template_instantiate_once): Pass a NULL_TREE for the ++ attributes to finish_struct. ++ (structsp): For a CLASS decl, add maybe_attribute to rule and pass that ++ value down into finish_struct. ++ * Makefile.in (CONFLICTS): Switch to 7 shift/reduce conflicts. ++ ++Tue Feb 6 13:12:15 1996 Per Bothner ++ ++ * decl.c (poplevel): Re-word dead for local handling. ++ (pushdecl): Remove useless DECL_DEAD_FOR_LOCAL test. ++ (cp_finish_decl): If is_for_scope, check for duplicates so ++ we can disable is_for_scope. Otherwise, preserve_temp_slots. ++ ++ * lex.c (do_identifier): Use global binding in preference of ++ dead for local variable. ++ ++Mon Feb 5 17:46:46 1996 Mike Stump ++ ++ * init.c (initializing_context): Handle anon union changes, the ++ context where fields of anon unions can be initialized now has to be ++ found by walking up the TYPE_CONTEXT chain. ++ ++Fri Feb 2 14:54:04 1996 Doug Evans ++ ++ * decl.c (start_decl): #ifdef out code to set DECL_COMMON ++ if ASM_OUTPUT{,_ALIGNED}_BSS is defined. ++ (obscure_complex_init): If bss is supported, always set ++ DECL_INITIAL to error_mark_node. ++ ++Thu Feb 1 16:19:56 1996 Brendan Kehoe ++ ++ * init.c (is_friend): Make sure there's a context before we see if ++ it's an aggr type. ++ ++Thu Feb 1 15:44:53 1996 Mike Stump ++ ++ * init.c (is_friend): Classes are not friendly with nested classes. ++ ++Thu Feb 1 15:27:37 1996 Doug Evans ++ ++ * lex.c (check_newline): Pass last character read to HANDLE_PRAGMA, ++ and record its result. ++ ++Thu Feb 1 09:27:01 1996 Mike Stump ++ ++ * class.c (finish_struct_anon): Switch around code to not move anon ++ union elements around, nor mess up their contexts, nor offsets, ++ instead we now build up the right number of COMPONENT_REFs for all ++ the anon unions that may be present at build_component_ref time. ++ * typeck.c (lookup_anon_field): New routine to handle field lookup ++ on fields without names. We find them, based upon their unique type ++ instead. ++ * typeck.c (build_component_ref): Allow FIELD_DECL components. ++ Handle finding components in anonymous unions, and ensure that a ++ COMPONENT_REF is built for each level as necessary. ++ ++Tue Jan 30 18:18:23 1996 Mike Stump ++ ++ * cvt.c (build_up_reference): Make the INDIRECT_BIND case come after ++ code that ensures that copy ctors are used if appropriate. ++ ++Tue Jan 30 17:35:14 1996 Brendan Kehoe ++ ++ * init.c (build_vec_delete): Only give an error if base isn't an ++ error_mark_node. ++ ++Mon Jan 29 17:09:06 1996 Mike Stump ++ ++ * spew.c (do_aggr): `new struct S;' isn't a forward declaration. ++ (yylex): If we see `new', keep slurping. ++ ++Thu Jan 25 18:31:36 1996 Mike Stump ++ ++ * class.c (finish_struct_1): Move code for handling anon unions... ++ (finish_struct_anon): to here. Fixup so that we do the offset ++ calculations right, and so that the fields are physically moved to ++ the containers's chain. ++ ++Thu Jan 25 18:27:37 1996 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Avoid trying to get an operand off an ++ identifier node. ++ ++Wed Jan 24 11:25:30 1996 Jim Wilson ++ ++ * typeck.c (pointer_int_sum): Use TYPE_PRECISION (sizetype) not ++ POINTER_SIZE to agree with expr.c. ++ ++Thu Jan 25 13:01:23 1996 Mike Stump ++ ++ * search.c (lookup_field): Don't report ambiguities if protect is 0, ++ instead return NULL_TREE. ++ ++Wed Jan 24 13:01:26 1996 Mike Stump ++ ++ * class.c (finish_struct_1): Call warn_hidden if we want warnings ++ about overloaded virtual functions. ++ (warn_hidden): New routine to warn of virtual functions that are ++ hidden by other virtual functions, that are not overridden. ++ (get_basefndecls): New routine, used by warn_hidden. ++ (mark_overriders): New routine, used by warn_hidden. ++ * search.c (get_matching_virtual): Remove old warning that just ++ isn't very useful. ++ ++Tue Jan 23 12:26:10 1996 Brendan Kehoe ++ ++ * decl.c (output_builtin_tdesc_entries): #if 0 the function definition. ++ ++ * typeck.c (null_ptr_cst_p): Delete unused fn. ++ (build_function_call_maybe): Delete unused fn. ++ ++ * expr.c (extract_init): #if 0 the code after unconditional return 0 ++ for now. ++ ++ Delete old cadillac code. ++ * edsel.c: Remove file. ++ * Make-lang.in (CXX_SRCS): Take edsel.c off the list. ++ * Makefile.in (CXX_OBJS): Delete edsel.o. ++ (edsel.o): Delete rule. ++ * cp-tree.h (flag_cadillac): Delete var decl. ++ * lang-options.h: Delete "-fcadillac" and "-fno-cadillac". ++ * decl2.c (flag_cadillac): Delete var definition. ++ (lang_decode_option): Delete handling of -fcadillac and -fno-cadillac. ++ (grokfield): Delete code depending on flag_cadillac. ++ (finish_anon_union): Likewise. ++ * class.c (finish_struct_1): Likewise. ++ (pushclass): Likewise. ++ (popclass): Likewise. ++ (push_lang_context): Likewise. ++ (pop_lang_context): Likewise. ++ * decl.c (init_decl_processing): Likewise. ++ (start_decl): Likewise. ++ (cp_finish_decl): Likewise. ++ (xref_tag): Likewise. ++ (finish_enum): Likewise. ++ (start_function): Likewise. ++ (finish_function): Likewise. ++ (finish_stmt): Likewise. ++ * lex.c (lang_init): Likewise. ++ (check_newline): Likewise. ++ ++ * lex.c (do_pending_inlines): Delete synthesized method kludge. ++ ++ Delete defunct, ancient garbage collection implementation. ++ * rtti.c: New file with the RTTI stuff from gc.c. ++ * gc.c: Removed file (moved the remaining stuff into rtti.c). ++ * Makefile.in (CXX_OBJS): Replace gc.o with rtti.o. ++ (rtti.o): New rule, replacing gc.o. ++ * Make-lang.in (CXX_SRCS): Replace gc.c with rtti.c. ++ * cp-tree.h: Delete gc-related fn decls. ++ (DECL_GC_OFFSET): Delete macro. ++ (flag_gc): Delete extern decl. ++ * decl.c (current_function_obstack_index): Delete var decl. ++ (current_function_obstack_usage): Delete var decl. ++ (start_function): Delete clearing of current_function_obstack_index ++ and current_function_obstack_usage. ++ (init_decl_processing): Delete code relying on -fgc. ++ Delete call to init_gc_processing. ++ (cp_finish_decl): Delete calls to build_static_gc_entry and ++ type_needs_gc_entry. Delete gc code setting DECL_GC_OFFSET. ++ (store_parm_decls): Delete -fgc calls to cp_expand_decl_cleanup ++ and to expand_expr of a __gc_main call. ++ (maybe_gc_cleanup): Delete var decl. ++ (finish_function): Delete call to expand_gc_prologue_and_epilogue. ++ * decl2.c (flag_gc): Delete var decl. ++ (lang_f_options): Delete offering of -fgc. ++ (lang_decode_option): Delete -fgc and -fno-gc handling. ++ (get_temp_regvar): Delete gc code. ++ * init.c (build_new): Delete gc code. ++ * lex.c (init_lex): Delete checking of flag_gc. ++ ++ * typeck.c (convert_arguments): Delete gc code. ++ (build_component_addr): Delete -fgc warning. ++ (build_modify_expr): Delete gc code. ++ ++ * decl2.c (build_push_scope): Delete fn. ++ * cp-tree.h (build_push_scope): Delete decl. ++ ++ * search.c (clear_search_slots): Delete fn. ++ * cp-tree.h (clear_search_slots): Delete decl. ++ ++ * search.c (tree_needs_constructor_p): Delete fn. ++ * cp-tree.h (tree_needs_constructor_p): Delete decl. ++ ++ * tree.c (id_cmp): Delete fn. ++ ++ * tree.c (set_fnaddr_from_vtable_entry): Delete fn. ++ * cp-tree.h (set_fnaddr_from_vtable_entry): Delete decl. ++ ++ * tree.c (decl_value_member): Delete fn. ++ * cp-tree.h (decl_value_member): Delete decl. ++ ++ * tree.c (list_hash_lookup_or_cons): Delete fn. ++ * cp-tree.h (list_hash_lookup_or_cons): Delete decl. ++ ++ * method.c (cplus_exception_name): Delete fn. ++ (EXCEPTION_NAME_{PREFIX, LENGTH}): Delete macros. ++ ++ * spew.c (shift_tokens): Delete fn. ++ ++Mon Jan 22 17:49:33 1996 Jason Merrill ++ ++ * except.c (init_exception_processing): Pass 1 to needs_pop in calls ++ to cp_finish_decl. ++ * parse.y: Likewise. ++ ++Mon Jan 22 17:34:29 1996 Brendan Kehoe ++ ++ * tree.c (build_cplus_staticfn_type): Delete function definition; ++ never used. ++ * cp-tree.h (build_cplus_staticfn_type): Delete decl. ++ ++ * tree.c (virtual_member): Delete function definition; never used. ++ * cp-tree.h (virtual_member): Delete decl. ++ ++Fri Jan 19 18:03:14 1996 Mike Stump ++ ++ * typeck.c (build_component_ref): Handle getting vbase pointers ++ out of complex multiple inheritance better. ++ ++Fri Jan 19 16:27:40 1996 Mike Stump ++ ++ * typeck.c (build_object_ref): Make sure we use the real type, not ++ any reference type. ++ ++Fri Jan 19 16:01:47 1996 Mike Stump ++ ++ * tree.c (build_exception_variant): Don't create new types if we ++ don't have to, also build new types on the right obstack. ++ ++Fri Jan 19 14:09:44 1996 Jason Merrill ++ ++ * decl.c (store_bindings): Split out from push_to_top_level. ++ (push_to_top_level): Call it for b->type_shadowed on class binding ++ levels. ++ ++Fri Jan 19 13:53:14 1996 Mike Stump ++ ++ * search.c (expand_upcast_fixups): Fix so that offsets stored in ++ vbase_offsets are always right. Fixes a problem where virtual base ++ upcasting and downcasting could be wrong during conversions on this ++ during virtual function dispatch at ctor/dtor time when dynamic ++ vtable fixups for deltas are needed. This only sounds easier than ++ it is. :-) ++ (fixup_virtual_upcast_offsets): Change to reflect new calling ++ convention for expand_upcast_fixups. ++ ++Fri Jan 19 12:23:08 1996 Brendan Kehoe ++ ++ * decl2.c (grokbitfield): Strip the NOPs from WIDTH before we ++ check that it's usable as the bitfield width. ++ ++Wed Jan 17 21:22:40 1996 Brendan Kehoe ++ ++ * decl2.c (grokfield): Call cplus_decl_attributes with the attrlist. ++ Pass a null tree to grokdeclarator for its ATTRLIST arg, since it's ++ only ever used for functions in it. ++ ++Wed Jan 17 12:10:38 1996 Jason Merrill ++ ++ * parse.y (qualified_type_name): Use the TYPE_DECL, not the type. ++ (nested_type): Likewise. ++ (nested_name_specifier): Use lastiddecl. ++ ++ * decl.c (grokdeclarator): Adjust accordingly. ++ * init.c (expand_member_init): Likewise. ++ * parse.y (base_class): Likewise. ++ * typeck2.c (build_functional_cast): Likewise. ++ ++ * typeck2.c (build_functional_cast): Fill in name after we've ++ checked for non-aggr type. ++ ++Wed Jan 17 10:18:01 1996 Mike Stump ++ ++ * decl2.c (warn_pointer_arith): Default to on. ++ ++Tue Jan 16 12:45:38 1996 Jason Merrill ++ ++ * lex.c (is_rid): New function. ++ * decl.c (grokdeclarator): Diagnose reserved words used as ++ declarator-ids. ++ ++Tue Jan 16 11:39:40 1996 Jason Merrill ++ ++ * tree.c (get_decl_list): Don't lose cv-quals. ++ ++ * decl.c (grokdeclarator): Fix SCOPE_REF handling and diagnose ++ typespecs used as declarator-ids. ++ ++Tue Jan 16 11:09:42 1996 Mike Stump ++ ++ * decl.c (poplevel): When popping a level, don't give a warning for ++ any subblocks that already exist. ++ ++Tue Jan 16 00:25:33 1996 Jason Merrill ++ ++ * typeck.c (build_object_ref): Finish what I started. ++ ++ * parse.y (qualified_type_name): Don't check TYPE_BUILT_IN. ++ ++ * decl2.c (constructor_name_full): Handle TEMPLATE_TYPE_PARMs. ++ ++ * decl.c (grokdeclarator): Also accept TEMPLATE_TYPE_PARM as a ++ scope. ++ ++Mon Jan 15 16:19:32 1996 Jason Merrill ++ ++ * decl.c (xref_tag): Handle passing a type in directly. ++ ++ * parse.y (qualified_type_name): Pull out the type. ++ (nested_type): Likewise. ++ Take types directly instead of as identifiers. ++ * call.c (build_scoped_method_call): Take types directly instead of ++ as identifiers. ++ * decl.c (xref_basetypes): Likewise. ++ * init.c (expand_member_init): Likewise. ++ (build_member_call): Likewise. ++ (build_offset_ref): Likewise. ++ * typeck2.c (build_scoped_ref): Likewise, remove bogus code. ++ * method.c (do_build_assign_ref): Likewise. ++ * decl.c (grokdeclarator): Handle a type appearing as the ++ declarator-id for constructors. ++ * method.c (do_build_copy_constructor): current_base_init_list now ++ uses the types directly, not their names. ++ * init.c (sort_base_init): Likewise. ++ (expand_member_init): Likewise. ++ * init.c (is_aggr_type): New function, like is_aggr_typedef. ++ ++Mon Jan 15 08:45:01 1996 Jeffrey A Law ++ ++ * tree.c (layout_basetypes): Call build_lang_field_decl instead ++ of build_lang_decl if first arg is a FIELD_DECL. ++ ++Thu Jan 11 14:55:07 1996 Brendan Kehoe ++ ++ * decl.c (cp_finish_decl): Only clear TREE_USED if DECL_NAME is ++ non-empty. ++ * except.c (expand_start_catch_block): Set TREE_USED to avoid ++ warnings about the catch handler. ++ ++Mon Jan 8 17:35:12 1996 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Use a COMPOUND_EXPR instead of ++ expand_target_expr. ++ ++Thu Jan 4 12:30:32 1996 Brendan Kehoe ++ ++ Fix access control to use trees rather than integers. ++ * class.c (access_{default, public, protected, private, ++ default_virtual, public_virtual, private_virtual}_node): Add ++ definitions. ++ (init_class_processing): Do creation of those nodes. ++ * cp-tree.h (access_type): Delete enum decl. ++ (access_{default, public, protected, private, default_virtual, ++ public_virtual, private_virtual}_node): Add decls. ++ (compute_access): Change return type. ++ * search.c (compute_access): Have tree return type, instead of enum. ++ (lookup_field): Declare THIS_V and NEW_V to be tree nodes. ++ * lex.c (real_yylex): Use yylval.ttype for giving the value of the ++ access_* node for each of RID_{PUBLIC, PRIVATE, PROTECTED}. ++ * parse.y (VISSPEC): Make ttype rather than itype. ++ (base_class_access_list): Likewise. ++ * *.[cy]: Change all refs of `access_public' to `access_public_node', ++ etc. ++ * call.c (build_method_call): Make ACCESS be a tree. ++ * class.c (alter_access, finish_struct_1, filter_struct): Likewise. ++ * cvt.c (convert_to_aggr): Likewise. ++ * init.c (build_offset_ref, resolve_offset_ref, build_delete): ++ Likewise. ++ * method.c (hack_identifier): Likewise. ++ * typeck.c (build_component_ref_1, build_component_ref): ): Likewise. ++ ++Thu Jan 4 11:02:20 1996 Mike Stump ++ ++ * typeck.c (pointer_int_sum, pointer_diff): Make code agree with C ++ frontend, and make it more consistent with respect to ++ warn_pointer_arith. ++ ++Tue Jan 2 00:13:38 1996 Rusty Russell ++ ++ * decl.c (pushdecl): Check for duplicate parameter names. ++ ++Wed Jan 3 09:25:48 1996 Mike Stump ++ ++ * decl.c (expand_static_init): Call assemble_external for atexit. ++ ++Wed Jan 3 07:55:19 1996 Mike Stump ++ ++ * except.c (do_unwind): Remove some generated dead code. ++ (eh_outer_context): New routine, factor out some common code from ++ expand_builtin_throw and end_eh_unwinder. Add code to do return ++ address masking for the PA. ++ (expand_builtin_throw): Use eh_outer_context instead of open coding ++ it here. ++ (end_eh_unwinder): Likewise. ++ ++Tue Jan 2 17:00:56 1996 Mike Stump ++ ++ * except.c (expand_throw): Call assemble_external for __empty, if we ++ use it. ++ ++Thu Dec 28 11:13:15 1995 Mike Stump ++ ++ * except.c (expand_builtin_throw): Use RETURN_ADDR_OFFSET instead of ++ NORMAL_RETURN_ADDR_OFFSET. ++ (end_eh_unwinder): Likewise. ++ ++Wed Dec 27 22:18:16 1995 Mike Stump ++ ++ * gc.c (build_dynamic_cast): Make sure we don't cast away const ++ when dealing with references, and make sure we handle dynamic ++ casting to a cv qualified reference. ++ ++Thu Dec 21 23:50:35 1995 Mike Stump ++ ++ * except.c (struct eh_context): New structure top hold eh context ++ information. ++ (push_eh_context): New routine. ++ (pop_eh_context): Likewise. ++ * decl.c (push_cp_function_context): Use them. ++ (pop_cp_function_context): Likewise. ++ ++Wed Dec 20 12:42:51 1995 Jason Merrill ++ ++ * decl2.c (finish_file): Also prune uninteresting functions in the ++ inline emission loop. ++ ++Wed Dec 20 02:32:07 1995 Jeffrey A Law ++ ++ * sig.c (build_signature_table_constructor): Mark functions ++ in the signature as referenced. ++ ++Tue Dec 19 22:36:56 1995 Jason Merrill ++ ++ * decl2.c (finish_file): Do all the vtable/synthesis stuff before ++ the inline emission stuff. ++ ++Mon Dec 18 15:51:33 1995 Jason Merrill ++ ++ * cp-tree.h, decl2.c (flag_weak): New flag to control the use of ++ weak symbols. ++ * lang-options.h: Add -f{no-,}weak. ++ * decl.c (init_decl_processing): If the target does not support weak ++ symbols, don't use them. ++ * decl2.c, pt.c: s/SUPPORTS_WEAK/flag_weak/. ++ ++Sun Dec 17 21:13:23 1995 Rusty Russell ++ ++ * init.c (expand_member_init): warning for base init after members. ++ ++Fri Dec 15 15:32:18 1995 Jason Merrill ++ ++ * cvt.c (build_expr_type_conversion): Don't convert to a reference ++ type. ++ ++Thu Dec 14 16:05:58 1995 Mike Stump ++ ++ * method.c (report_type_mismatch): Improve wording for volatile ++ mismatches. ++ ++Thu Dec 14 14:16:26 1995 Mike Stump ++ ++ * init.c (expand_aggr_init_1): Use expand_aggr_init_1 instead of ++ expand_assignment, as the later doesn't handle things that have ++ copy constructors well. The compiler would do bitwise copying, ++ instead of ctor calling in some cases. ++ ++Wed Dec 13 17:05:54 1995 Paul Eggert ++ ++ * g++.c (my_strerror): Return "cannot access" if errno is 0. ++ (pfatal_with_name, perror_exec): Don't assume that ++ the returned value from my_strerror contains no '%'s. ++ (concat): Remove. ++ (sys_nerror): Declare only if HAVE_STRERROR is not defined. ++ ++Wed Dec 13 16:22:38 1995 Jason Merrill ++ ++ Lose CLASSTYPE_METHODS/DECL_NEXT_METHOD chain; make ++ TYPE_METHODS/TREE_CHAIN mean what they used to. ++ * decl2.c (constructor_name_full): Refer to CLASSTYPE_METHOD_VEC ++ instead of TYPE_METHODS. ++ * decl.c (duplicate_decls): Lose references to DECL_NEXT_METHOD. ++ * tree.c (tree_copy_lang_decl_for_deferred_output): Likewise. ++ * cp-tree.h (CLASSTYPE_METHODS): Lose. ++ (CLASSTYPE_METHOD_VEC): Point to lang_spec->methods instead of ++ TYPE_METHODS. ++ (struct lang_decl): Lose next_method field. ++ (DECL_NEXT_METHOD): Lose. ++ * class.c (finish_struct_methods): Don't mess with TYPE_METHODS. ++ (finish_struct): Just use TYPE_METHODS; we don't need fn_fields ++ anymore. ++ (finish_struct_methods): Don't mess with the TREE_CHAINs in ++ fn_fields. ++ ++ * search.c (add_conversions): Don't use TREE_CHAIN to traverse method ++ vector. ++ ++ * call.c (build_method_call): Synthesize here even when not inlining. ++ * typeck.c (build_function_call_real): Likewise. ++ ++Wed Dec 13 15:02:39 1995 Ian Lance Taylor ++ ++ * cp/lex.c (check_newline): If DBX_DEBUGGING_INFO and write_symbols ++ == DBX_DEBUG, call dbxout_start_new_source_file and ++ dbxout_resume_previous_source_file when appropriate. ++ ++Tue Dec 12 20:38:55 1995 Mike Stump ++ ++ * except.c (start_anon_func): Push to the top level. ++ (end_anon_func): Pop from the top level. ++ ++Mon Dec 11 18:56:14 1995 Mike Stump ++ ++ * cp-tree.h (build_cleanup): New routine to build cleanups. ++ * decl.c (expand_static_init): Use build_cleanup to build a cleanup ++ call at ctor time and use atexit to run it later. ++ * decl2.c (build_cleanup): New routine, taken from finish_file. ++ (finish_file): Use build_cleanup instead, and don't put function ++ local statics in global dtor list. ++ ++Wed Dec 6 14:34:29 1995 Mike Stump ++ ++ * except.c (expand_throw): Ensure that we have cleanups, if we try ++ and expand cleanups. ++ ++Wed Dec 6 11:48:21 1995 Mike Stump ++ ++ * except.c (expand_throw): Add logic to manage dynamic cleanups for ++ the EH object. ++ (expand_end_catch_block): Use the magic of expand_goto, instead of ++ emit_jump so that we get the cleanup for any catch clause parameter ++ and the cleanup for the exception object. Update to reflect label ++ changes. ++ (push_eh_cleanup): New routine to register a cleanup for an ++ exception object. ++ (empty_fndecl): Used to default cleanup actions to ++ nothing. ++ (init_exception_processing): Setup empty_fndecl. Setup ++ saved_cleanup. ++ (expand_start_catch_block): Update to reflect label changes. Call ++ push_eh_object to register the cleanup for the EH object. ++ (start_anon_func): New routine to start building lambda expressions ++ from trees. ++ (end_anon_func): New routine to end them. ++ (struct labelNode): Change so that we can use tree labels, or rtx ++ labels. ++ (saved_cleanup): Object to check for dynamic cleanups for the ++ exception handling object. ++ (push_label_entry): Change so that we can use tree labels, or rtx ++ labels. ++ (pop_label_entry): Likewise. ++ (top_label_entry): Likewise. ++ (expand_start_all_catch): Use tree label instead of rtx label, so ++ that we can get the magic of expand_goto. ++ (expand_end_all_catch): Update to reflect label changes. ++ ++ * class.c (build_vfn_ref): Remove building_cleanup logic, as we now ++ use UNSAVE_EXPRs. ++ * typeck.c (get_member_function_from_ptrfunc): Remove remnants of ++ building_cleanup logic, as we now use UNSAVE_EXPRs. ++ * cp-tree.h (unsave_expr): Declare it. ++ * decl.c (building_cleanup): Remove. ++ (maybe_build_cleanup): Remove building_cleanup logic, and use ++ UNSAVE_EXPR instead. ++ ++Sun Dec 3 01:34:58 1995 Mike Stump ++ ++ * gc.c (build_t_desc): Update error message to say . ++ ++Thu Nov 30 12:30:05 1995 Brendan Kehoe ++ ++ * decl.c (pushdecl): Only warn about shadowing a local variable if ++ warn_shadow is true. ++ ++Sun Nov 26 16:06:55 1995 Rusty Russell ++ ++ * typeck.c (build_binary_op_nodefault): Added warning about ++ comparisons between different enum types with -Wall, unless ++ -fenum-int-equiv set. ++ ++Wed Nov 22 15:44:02 1995 Mike Stump ++ ++ * class.c (finish_struct_1): Skip down to the inner type in ++ multidimensional arrays. Ensures ctors will be made for types that ++ need constructing. ++ ++Wed Nov 22 14:19:22 1995 Mike Stump ++ ++ * decl.c (last_dtor_insn): New to track the last compiler generated ++ insn in a dtor. ++ (store_parm_decls): Set it. ++ (finish_function): Use it to see if the dtor is empty. Avoid doing ++ vtable setup all the time, if we can. ++ (struct cp_function): Add last_dtor_insn. ++ (push_cp_function_context): Save it. ++ (pop_cp_function_context): Restore it. ++ ++Wed Nov 22 11:52:19 1995 Paul Russell ++ ++ * typeck.c (build_unary_op): Set TREE_NO_UNUSED_WARNING to avoid ++ warnings. ++ ++Tue Nov 21 17:15:23 1995 Mike Stump ++ ++ * typeck.c (expand_target_expr): Make sure targets get put into the ++ current temp_slot_level, so that the free_temp_slots call will reuse ++ them. ++ ++Tue Nov 21 13:32:03 1995 Mike Stump ++ ++ * class.c (finish_struct_1): Delay delta fixups for virtual bases ++ until after we have done the hard virtuals, to avoid a bogus `every ++ virtual function must have a unique final overrider' for virtual ++ functions that are only overridden by hard virtuals. ++ ++Thu Nov 9 13:35:30 1995 Jason Merrill ++ ++ * pt.c (do_function_instantiation): Don't try to find a file-scope ++ template for a member function. ++ ++Tue Nov 14 06:20:35 1995 Mike Stump ++ ++ * g++.c (main): Add handling of -nodefaultlibs. ++ ++Mon Nov 13 15:45:34 1995 Mike Stump ++ ++ * cp-tree.h (INDIRECT_BIND): Add a way for the frontend to ++ distinguish between direct bindings of reference variables, and ++ indirect bindings of reference variables. ++ * cvt.c (build_up_reference): Use it. ++ * typeck.c (convert_arguments): Use it to indicate this is an ++ indirect binding. ++ * decl.c (cp_finish_decl): Ensure that we reuse stack slots as fast ++ as they are unused. ++ (expand_static_init): Likewise. ++ (cplus_expand_expr_stmt): Likewise. ++ * decl2.c (finish_file): Likewise. ++ * init.c (perform_member_init): Likewise. ++ (emit_base_init): Likewise. ++ (expand_aggr_vbase_init_1): Likewise. ++ ++Fri Nov 10 09:18:09 1995 Brendan Kehoe ++ ++ * decl.c (push_namespace): Rewrite to use build_lang_decl, so we ++ get a DECL_LANG_SPECIFIC node. ++ * cp-tree.h (lang_decl_flags): Add new member `level'. ++ (NAMESPACE_LEVEL): Don't use decl.arguments, instead use the ++ decl_flags level member. ++ ++Mon Nov 6 18:36:13 1995 Brendan Kehoe ++ ++ * call.c (build_method_call): Make sure instance has a ++ TYPE_LANG_SPECIFIC node before we dive into it. ++ ++Sat Nov 4 20:01:52 1995 Jason Molenda ++ ++ * method.c (make_thunk): Use TREE_SET_CODE to set thunk's tree code. ++ ++Thu Nov 2 17:56:57 1995 Mike Stump ++ ++ * decl.c (duplicate_decls): When smashing decls, smash staticness in ++ the usual way. ++ ++Thu Nov 2 16:44:02 1995 Mike Stump ++ ++ * decl.c (poplevel): Handle the merging of subblocks of cleanups ++ when finishing blocks that have already been created (usually due to ++ the fixup goto code). Fixes bad debugging information. ++ ++Wed Nov 1 12:33:53 1995 Jason Merrill ++ ++ * method.c (hack_identifier): Don't abort when we get a TREE_LIST ++ that's not a list of overloaded functions. ++ ++Wed Nov 1 11:38:58 1995 Brendan Kehoe ++ ++ * decl2.c (mark_vtable_entries): Check DECL_LANG_SPECIFIC on fn ++ before trying to use DECL_ABSTRACT_VIRTUAL_P. ++ ++Tue Oct 31 11:56:55 1995 Jason Merrill ++ ++ * decl2.c (mark_used): New function for hooking into setting of ++ TREE_USED on decls. ++ * call.c (build_method_call): Use it. ++ * class.c (instantiate_type): Likewise. ++ * init.c (build_offset_ref): Likewise. Don't call assemble_external ++ for all like-named functions. ++ * method.c (hack_identifier): Likewise. ++ (emit_thunk): Don't call assemble_external. ++ (make_thunk): Create thunk as a FUNCTION_DECL so that it ++ gets the right mode and ENCODE_SECTION_INFO works. ++ ++ * parse.y: Use mark_used. Pass operator names to do_identifier. ++ * lex.c (do_identifier): Handle operator names. ++ ++ * decl2.c (grokclassfn): Tweak __in_chrg attributes. ++ ++Thu Oct 26 16:45:58 1995 Brendan Kehoe ++ ++ * errfn.c: Include stdio.h. ++ (cp_sprintf): Take out decl of sprintf, and cast sprintf to errorfn*. ++ ++Wed Oct 25 18:58:41 1995 Mike Stump ++ ++ * typeck2.c (digest_init): Always convert initializers to the ++ right type. ++ ++Wed Oct 25 13:25:24 1995 Mike Stump ++ ++ * init.c (member_init_ok_or_else): Don't allow member initializers ++ for indirect members, as it is invalid. ++ ++Wed Oct 25 11:35:28 1995 Brendan Kehoe ++ ++ * decl.c (grokdeclarator): Don't allow `friend signed ()'. ++ ++Fri Oct 20 10:30:59 1995 Mike Stump ++ ++ * parse.y (for.init.statement): Catch compound statements inside for ++ initializations, if we're being pedantic. ++ ++Fri Oct 20 10:03:42 1995 Mike Stump ++ ++ * decl.c (lookup_tag): Return NULL_TREE if we don't find what we are ++ looking for. ++ ++Thu Oct 19 14:26:10 1995 Mike Stump ++ ++ * error.c (dump_expr): Don't core dump when a boolean expression is ++ used as a default argument. ++ ++Thu Oct 19 10:36:30 1995 Jason Merrill ++ ++ * class.c (finish_struct_bits): Check aggregate_value_p instead of ++ RETURN_IN_MEMORY. ++ ++Wed Oct 18 18:12:32 1995 Jason Merrill ++ ++ * class.c (finish_struct_bits): Also set TREE_ADDRESSABLE on a ++ BLKmode type that would otherwise be returned in registers. ++ ++Mon Oct 16 12:32:19 1995 Brendan Kehoe ++ ++ * g++.c (WITHLIBC): New macro. ++ (main): Declare saw_libc. Use WITHLIBC if `-lc' was used; set ++ saw_libc and pass it at the end if it was set. ++ ++Wed Oct 11 16:30:34 1995 Brendan Kehoe ++ ++ * parse.y (fn.def1): Call split_specs_attrs in ++ declmods notype_declarator case. ++ ++See ChangeLog.1 for earlier changes. +diff -NBaur gcc-3.4.4/gcc/cp/ChangeLog.3 gcc-3.4.4-new/gcc/cp/ChangeLog.3 +--- gcc-3.4.4/gcc/cp/ChangeLog.3 Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/ChangeLog.3 Thu Jan 1 00:43:21 2004 +@@ -0,0 +1,22648 @@ ++2003-12-30 Nathan Sidwell ++ ++ PR c++/13507 ++ * decl.c (duplicate_decls): Use build_type_attribute_variant to ++ merge attributes. ++ ++ PR c++/13494 ++ * tree.c (build_cplus_array_type_1): Only build a minimal array ++ type for dependent types or domains. ++ ++2003-12-29 Nathan Sidwell ++ ++ PR c++/12774 ++ * typeck.c (comp_array_types): Fold non-dependent domains for ++ ABI-1. ++ ++2003-12-29 Kriang Lerdsuwanakij ++ ++ PR c++/13289 ++ * semantics.c (finish_id_expression): Only check if the type of ++ a template argument is integral or enumeration when it is not ++ dependent. ++ ++2003-12-29 Kriang Lerdsuwanakij ++ ++ PR c++/12403 ++ * parser.c (cp_parser_template_declaration_after_export): Set up ++ template specialization scope in case of explicit specialization. ++ ++2003-12-28 Mark Mitchell ++ ++ PR c++/13081 ++ * decl.c (duplicate_decls): Preserve inline-ness when redeclaring ++ a function template. ++ ++ PR c++/12613 ++ * decl.c (reshape_init): Reject GNU colon-style designated ++ initializers in arrays. ++ ++ PR c++/13009 ++ * call.c (build_special_member_call): Do not assume that we have a ++ pointer to the complete object in an assignment operator. ++ ++2003-12-28 Roger Sayle ++ ++ PR c++/13070 ++ * decl.c (duplicate_decls): When setting the type of an anticipated ++ declaration, merge the existing type attributes. ++ ++2003-12-25 Andrew Pinski ++ ++ PR c++/13268, c++/13339 ++ * class.c (add_method): Return early when method is error_mark_node. ++ * pt.c (tsubst_friend_function): Return early when new_friend is ++ error_mark_node. ++ ++2003-12-23 Mark Mitchell ++ ++ * cp-lang.c (cp_expr_size): Return zero for empty classes. ++ ++ * cp-tree.h (warn_if_uknown_interface): Remove unused function. ++ * decl2.c (warn_if_unknown_interface): Likewise. ++ ++2003-12-23 Nathan Sidwell ++ ++ PR c++/13387 ++ * cp-lang.c (cxx_get_alias_set): Correct logic for a base type. ++ ++2003-12-22 Mark Mitchell ++ ++ * decl.c (start_function): Do not check ++ flag_alt_external_templates or flag_external_templates. ++ * decl2.c (warn_if_unknown_interface): Likewise. ++ * lex.c (extract_interface_info): Likewise. ++ * pt.c (lookup_template_class): Likewise. ++ ++ PR c++/12862 ++ * name-lookup.c (pushdecl): Look up all namespace-scope entities ++ in their corresponding namespace. ++ ++ PR c++/12397 ++ * typeck.c (finish_class_member_access_expr): Don't tree ++ IDENTIFIER_NODEs as non-dependent expressions. ++ ++2003-12-22 Andrew Pinski ++ ++ PR c++/5050 ++ * tree.c (cp_start_inlining): Remove. ++ (cp_end_inlining): Remove. ++ * cp-lang.c (LANG_HOOKS_TREE_INLINING_START_INLINING): Do not define. ++ (LANG_HOOKS_TREE_INLINING_END_INLINING): Do not define. ++ * cp-tree.h (cp_start_inlining): Do not declare. ++ (cp_end_inlining): Do not declare. ++ ++2003-12-22 Mark Mitchell ++ ++ PR c++/12479 ++ * parser.c (cp_parser_declaration_seq_opt): Only issue "extra ;" ++ pedwarn when not in a system header. ++ ++2003-12-21 Mark Mitchell ++ ++ * cp-tree.h (cp_tree_index): Remove CPTI_RECORD_TYPE, ++ CPTI_UNION_TYPE, CPTI_ENUM_TYPE. ++ (record_type_node): Remove. ++ (union_type_node): Likewise. ++ (enum_type_node): Likewise. ++ * decl.c: Remove mention of above tree nodes in comment. ++ * lex.c (cxx_init): Do not assign to record_type_node, ++ union_type_node, or enum_type_node. Simplify handling of ++ class_type_node. ++ ++ PR c++/11554 ++ * init.c (sort_mem_initializers): Add warning. ++ ++2003-12-21 Kazu Hirata ++ ++ * call.c: Fix comment formatting. ++ * class.c: Likewise. ++ * cp-tree.h: Likewise. ++ * cvt.c: Likewise. ++ * cxx-pretty-print.c: Likewise. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * error.c: Likewise. ++ * except.c: Likewise. ++ * init.c: Likewise. ++ * name-lookup.c: Likewise. ++ * parser.c: Likewise. ++ * pt.c: Likewise. ++ * rtti.c: Likewise. ++ * semantics.c: Likewise. ++ * typeck.c: Likewise. ++ * typeck2.c: Likewise. ++ ++2003-12-19 Kazu Hirata ++ ++ * cvt.c: Remove uses of "register" specifier in ++ declarations of arguments and local variables. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * expr.c: Likewise. ++ * friend.c: Likewise. ++ * lex.c: Likewise. ++ * name-lookup.c: Likewise. ++ * repo.c: Likewise. ++ * search.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ * typeck2.c: Likewise. ++ ++2003-12-19 Mark Mitchell ++ ++ PR c++/12795 ++ * name-lookup.c (pushdecl): Do not treated any functions as being ++ "nested" in C++. ++ ++2003-12-19 Jason Merrill ++ ++ PR c++/13371 ++ * typeck.c (build_modify_expr): Stabilize lhs if we're narrowing. ++ * cvt.c (convert_to_void): Don't warn about the RHS of a comma ++ being useless if TREE_NO_UNUSED_WARNING is set. ++ ++2003-12-18 Richard Henderson ++ ++ * cp-tree.h (struct lang_type_header): Remove __extension__. ++ ++2003-12-18 Jason Merrill ++ ++ PR c++/12253 ++ * init.c (build_vec_init): Initialization of an element from ++ an initializer list is also a full-expression. ++ ++ * parser.c, pt.c, semantics.c: Rename constant_expression_p ++ to integral_constant_expression_p. ++ ++2003-12-18 Kriang Lerdsuwanakij ++ ++ PR c++/13262 ++ * pt.c (instantiate_decl): Wrap push_nested_class and ++ pop_nested_class around cp_finish_decl call for static member ++ variable. ++ ++2003-12-18 Giovanni Bajo ++ ++ PR c++/9154 ++ * parser.c (cp_parser_template_argument): A type-id followed by '>>' ++ is just an user typo, and should be accepted as last resort if any ++ other parsing fails. ++ (cp_parser_enclosed_template_argument_list): If the argument list is ++ parsed correctly, but the next token is '>>', emit a diagnostic. ++ (cp_parser_next_token_ends_template_argument): Accept '>>' as ++ delimiter of template argument, it will be later detected as a typo. ++ ++2003-12-17 Kelley Cook ++ ++ * Make-lang.in: Replace cp/g++.1 with $(docobjdir)/g++.1. ++ ++2003-12-17 Mark Mitchell ++ ++ PR c++/10603 ++ PR c++/12827 ++ * parser.c (cp_parser_error): Help c_parse_error print good ++ messages if the next token is a keyword. ++ (cp_parser_parameter_declaration_list): When resynchronizing after ++ a bad parameter declaration, stop if a comma is found. ++ (cp_parser_parameter_declaration): Avoid backtracking. ++ ++2003-12-16 Mark Mitchell ++ ++ PR c++/12696 ++ * decl.c (reshape_init): Recover quickly from errors. ++ ++2003-12-16 Nathan Sidwell ++ ++ PR c++/9043 ++ C++ ABI change: Mangling array indices in templates. ++ * decl.c (compute_array_index_type): Reorganize for earlier ++ template errors. Use value_dependent_expression_p for abi-2. ++ * mangle.c (write_array_type): Check broken mangling for ++ expression indices on abi-1 ++ ++2003-12-16 Mark Mitchell ++ ++ PR c++/12696 ++ * decl.c (reshape_init): Recover quickly from errors. ++ ++ PR c++/13275 ++ * lex.c (reswords): Add "__offsetof" and "__offsetof__". ++ * parser.c (cp_parser): Add in_offsetof_p. ++ (cp_parser_new): Initialize it. ++ (cp_parser_primary_expression): Handle __offsetof__ (...). ++ (cp_parser_postfix_expression): Allow casts to pointer type and ++ uses of "->" in a constant expression if implementing offsetof. ++ (cp_parser_unary_expression): Allow the use of "&" in a constant ++ expression if implementing offsetof. ++ ++2003-12-16 Giovanni Bajo ++ ++ PR c++/2294 ++ * name-lookup.c (push_overloaded_decl): always construct an OVERLOAD ++ if the declaration comes from an using declaration. ++ ++2003-12-16 Giovanni Bajo ++ ++ * semantics.c (finish_id_expression): Refactor the code to handle ++ template parameters, and emit a more informative error message ++ when they are used within an integral constant expression. ++ ++2003-12-16 Nathan Sidwell ++ ++ PR c++/13387 ++ * class.c (finish_struct_1): Compute mode and alias set for ++ CLASSTYPE_AS_BASE. ++ * call.c (build_over_call): Use CLASSTYPE_AS_BASE for trivial ++ assignment of a class, as necessary. ++ * cp-lang.c (cxx_get_alias_set): The alias set as a base is the ++ same as for the complete type. ++ ++ PR c++/13242 ++ C++ ABI change. Mangling template parameters of reference type ++ * mangle.c (write_template_args): Remove unreachable code. ++ (write_template_arg): Look through an argument of reference type. ++ ++2003-12-16 Giovanni Bajo ++ ++ PR c++/2294 ++ * name-lookup.c (push_overloaded_decl): always construct an OVERLOAD ++ if the declaration comes from an using declaration. ++ ++2003-12-15 Mark Mitchell ++ ++ PR c++/10926 ++ * decl2.c (grokfield): Robustify. ++ ++ PR c++/11116 ++ * parser.c (cp_parser_throw_expression): Determine whether or not ++ an assignment-expression is present by doing one-token lookahead. ++ ++ PR c++/13269 ++ * parser.c (cp_parser_function_definition_after_declarator): Stop ++ scanning tokens when reaching EOF. ++ ++ PR c++/12989 ++ * typeck.c (cxx_sizeof_or_alignof_expr): Robustify. ++ ++ PR c++/13310 ++ * pt.c (dependent_template_p): Handle OVERLOADs. ++ ++2003-12-15 Mark Mitchell ++ ++ PR c++/13243 ++ PR c++/12573 ++ * parser.c (cp_parser_postfix_expression): Tighten handling of ++ integral constant expressions. ++ (cp_parser_unary_expression): Likewise. ++ * pt.c (value_dependent_expression_p): Remove handling for ++ COMPONENT_REFs. ++ ++2003-12-15 Nathan Sidwell ++ ++ * class.c (add_method): Disallow destructor for java classes. ++ * decl.c (xref_basetypes): Check java class inheritance. ++ * decl2.c (check_java_method): Skip artificial params. ++ ++ PR c++/13241 ++ C++ ABI change. Mangling of symbols in expressions. ++ * mangle.c (write_mangled_name): Add top_level flag. Rework for ++ nested and unnested mangling. Deal with abi version 1 and version ++ 2 differences. ++ (write_expression): Adjust write_mangled_name call. ++ (mangle_decl_string): Use write_mangled_name for all non-type decls. ++ ++2003-12-14 Mark Mitchell ++ ++ PR c++/10779 ++ PR c++/12160 ++ * parser.c (struct cp_parser): Add in_template_argument_list_p. ++ (cp_parser_error): Use c_parse_error. ++ (cp_parser_name_lookup_error): New function. ++ (cp_parser_new): Initialize it. ++ (cp_parser_declarator): Add parenthesized_p parameter. ++ (cp_parser_nested_name_specifier_opt): Use ++ cp_parser_name_lookup_error. ++ (cp_parser_parenthesized_expression_list): Improve comments. ++ (cp_parser_condition): Adjust call to cp_parser_declarator. ++ (cp_parser_template_parameter): Adjust call to ++ cp_parser_parameter_declaration. ++ (cp_parser_template_argument_list): Set ++ in_template_argument_list_p. ++ (cp_parser_explicit_instantiation): Adjust call to ++ cp_parser_declarator. ++ (cp_parser_simple_type_specifier): Remove unncessary code. ++ (cp_parser_using_declaration): Use cp_parser_name_lookup_error. ++ (cp_parser_init_declarator): Handle member function definitions. ++ (cp_parser_direct_declarator): Adjust call to ++ cp_parser_declarator. ++ (cp_parser_type_id): Adjust call to cp_parser_declarator. ++ (cp_parser_parameter_declaration_list): Avoid backtracking where ++ possible. ++ (cp_parser_parameter_declaration): Add parenthesized_p parameter. ++ (cp_parser_function_definition): Remove. ++ (cp_parser_member_declaration): Do not backtrack to look for ++ function definitions. ++ (cp_parser_exception_declaration): Adjust call to ++ cp_parser_declarator. ++ (cp_parser_single_declaration): Handle function definitions via ++ cp_parser_init_declarator. ++ (cp_parser_save_member_function_body): New function. ++ ++2003-12-14 Kriang Lerdsuwanakij ++ ++ PR c++/13106 ++ * decl.c (finish_function): Check if return type is dependent before ++ issuing no return statement warning. ++ ++2003-12-12 Nathan Sidwell ++ ++ PR c++/13118 ++ * cp-tree.h (lang_decl_u): Add thunk_alias member. ++ (THUNK_VIRTUAL_OFFSET): Must be a FUNCTION_DECL. ++ (THUNK_ALIAS_P): Remove. ++ (THUNK_ALIAS): Adjust. ++ * class.c (update_vtable_entry_for_fn): Get the vbase within the ++ overriding function's return type. ++ (dump_thunk): Adjust THUNK_ALIAS printing. ++ (build_vtbl_initializer): Adjust THUNK_ALIAS use. ++ * method.c (make_thunk): Revert 12881 test change. Clear ++ THUNK_ALIAS. ++ (finish_thunk): Adjust THUNK_ALIAS setting. ++ (use_thunk): Adjust THUNK_ALIAS use. ++ * semantics.c (emit_associated_thunks): Likewise. ++ ++ PR c++/13114, c++/13115 ++ * class.c (layout_empty_base): Propagate the move of an empty base ++ to offset zero. ++ ++ PR c++/12881 ++ * method.c (make_thunk): Deal with thunk aliases when searching ++ for a thunk. Robustify assertion. ++ ++2003-12-11 Nathan Sidwell ++ ++ * mangle.c (conv_type_names): Holds IDENTIFIER_NODEs only. ++ (hash_type): Use TYPE_UID of the identifier's type. ++ (compare_type): Adjust. ++ (mangle_conv_op_name_for_type): Store identifier nodes only, use ++ TYPE_UID has hash value. ++ ++2003-12-10 Mark Mitchell ++ ++ * cp-tree.h (DECL_CONV_FN_P): Check that DECL_NAME is non-NULL. ++ ++2003-12-08 Matt Austern ++ ++ PR c/13134 ++ * decl.c (duplicate_decls): Copy visibility flag when appropriate. ++ ++2003-12-09 Giovanni Bajo ++ ++ * init.c (build_new_1): Deal with an OVERLOAD set when ++ looking up for _Jv_AllocObject. ++ * except.c (build_throw): Likewise for _Jv_Throw. ++ ++2003-12-08 Jason Merrill ++ ++ PR c++/11971 ++ * tree.c (build_local_temp): Split out from build_cplus_new. ++ (force_target_expr): New fn. ++ * call.c (call_builtin_trap): Call it. Take a type parm. ++ (convert_arg_to_ellipsis): Pass it. ++ (build_x_va_arg): Use call_builtin_trap. ++ ++ PR c++/11929 ++ * call.c (magic_varargs_p): New fn. ++ (build_over_call): Do no ellipsis conversions for arguments to ++ functions with magic varargs. ++ ++ * name-lookup.c, init.c, except.c: Revert Giovanni's patch from ++ yesterday. ++ ++ Give the anonymous namespace a null DECL_NAME. ++ * cp-tree.h: Don't declare anonymous_namespace_name. ++ * decl.c: Don't define it. ++ * dump.c (cp_dump_tree): Don't check for it. ++ * cxx-pretty-print.c (pp_cxx_original_namespace_definition): Likewise. ++ * error.c (dump_decl): Likewise. ++ * name-lookup.c: Define it here. ++ (push_namespace): Put it in DECL_ASSEMBLER_NAME instead. ++ * mangle.c (write_unqualified_name): Adjust. ++ ++2003-12-07 Giovanni Bajo ++ ++ PR c++/2294 ++ * name-lookup.c (push_overloaded_decl): Always construct an ++ OVERLOAD unless the declaration is a built-in. ++ (set_namespace_binding): While binding OVERLOADs with only one ++ declaration, we still need to call supplement_binding. ++ * init.c (build_new_1): Deal with an OVERLOAD set when ++ looking up for _Jv_AllocObject. ++ * except.c (build_throw): Likewise for _Jv_Throw. ++ ++2003-12-06 Mark Mitchell ++ ++ PR c++/13323 ++ * class.c (same_signature_p): Handle conversion operators ++ correctly. ++ (check_for_override): Likewise. ++ ++2003-12-06 Kelley Cook ++ ++ * Make-lang.in (GXX_CROSS_NAME, CXX_CROSS_NAME): Delete. ++ (c++.install_common, cp/g++.1, c++.install-man): Adjust for above. ++ (c++.uninstall): Likewise. ++ ++2003-12-05 Danny Smith ++ Mark Mitchell ++ ++ PR c++/13305 ++ * parser.c (cp_parser_elaborated_type_specifier): Accept ++ attributes. ++ ++2003-12-05 Mark Mitchell ++ ++ PR c++/13314 ++ * parser.c (cp_parser_class_specifier): Match push_scope/pop_scope ++ calls. ++ (cp_parser_class_head): Likewise. ++ ++2003-12-05 Kriang Lerdsuwanakij ++ ++ PR c++/13166 ++ * parser.c (cp_parser_late_parsing_default_args): Make sure the ++ context is a class before calling push_nested_class and ++ pop_nested_class. ++ ++2003-12-03 James E Wilson ++ ++ * g++spec.c (lang_specific_driver): Delete USE_LIBUNWIND_EXCEPTIONS ++ support. ++ ++2003-12-03 Mark Mitchell ++ ++ PR c++/9127 ++ * cp-tree.h (at_namespace_scope_p): New function. ++ * parser.c (cp_parser_class_head): Handle invalid explicit ++ specializations. ++ * search.c (at_namespace_scope_p): New function. ++ ++ PR c++/13179 ++ * semantics.c (finish_handler_parms): Do not call eh_type_info for ++ types used in templates. ++ ++ PR c++/10771 ++ * parser.c (cp_parser_check_for_invalid_template_id): New ++ function. ++ (cp_parser_simple_type_specifier): Use it. ++ (cp_parser_elaborated_type_specifier): Likewise. ++ (cp_parser_class_head): Likewise. ++ ++2003-12-02 Giovanni Bajo ++ ++ PR c++/10126 ++ * pt.c (convert_nontype_argument): Handle default conversions ++ while converting a pointer to member function. ++ ++2003-12-02 Giovanni Bajo ++ ++ PR c++/12573 ++ * pt.c (value_dependent_expression_p): Handle COMPONENT_REFs by ++ looking into them recursively. ++ ++2003-12-02 Richard Henderson ++ ++ * name-lookup.h (struct cp_binding_level): Use ENUM_BITFIELD. ++ * parser.c (struct cp_token): Likewise. ++ (struct cp_parser_token_tree_map_node): Likewise. ++ * lex.c (struct resword): Move const after ENUM_BITFIELD. ++ ++2003-11-30 Mark Mitchell ++ ++ PR c++/9849 ++ * parser.c (cp_lexer_prev_token): New function. ++ (cp_parser_skip_to_closing_parenthesis): Add consume_paren ++ parameter. ++ (cp_parser_nested_name_specifier_opt): Add is_declaration ++ parameter. ++ (cp_parser_nested_name_specifier): Likewise. ++ (cp_parser_class_or_namespace_name): Likewise. ++ (cp_parser_class_name): Likewise. ++ (cp_parser_template_id): Likewise. ++ (cp_parser_template_name): Likewise. ++ (cp_parser_id_expression): Adjust calls to ++ cp_parser_nested_name_specifier_op, cp_parser_template_id, ++ cp_parser_class_name. ++ (cp_parser_unqualified_id): Likewise. ++ (cp_parser_postfix_expression): Likewise. ++ (cp_parser_pseudo_destructor_name): Likewise. ++ (cp_parser_cast_expression): Likewise. ++ (cp_parser_mem_initializer_id): Likewise. ++ (cp_parser_simple_type_specifier): Likewise. ++ (cp_parser_type_name): Likewise. ++ (cp_parser_elaborated_type_specifier): Likewise. ++ (cp_parser_qualified_namespace_specifier): Likewise. ++ (cp_parser_using_declaration): Likewise. ++ (cp_parser_using_directive): Likewise. ++ (cp_parser_ptr_operator): Likewise. ++ (cp_parser_declarator_id): Likewise. ++ (cp_parser_class_head): Likewise. ++ (cp_parser_base_specifier): Likewise. ++ (cp_parser_constructor_declarator_p): Likewise. ++ (cp_parser_direct_declarator): Fix typo in comment. ++ (cp_parser_parenthesized_expression_list): Adjust call to ++ cp_parser_skip_to_closing_parenthesis. ++ (cp_parser_selection_statement): Likewise. ++ ++2003-11-23 Kriang Lerdsuwanakij ++ ++ PR c++/12924 ++ * typeck.c (finish_class_member_access_expr): Handle TEMPLATE_ID_EXPR ++ with OVERLOAD and DECL nodes as the first operand. ++ ++2003-11-22 Kriang Lerdsuwanakij ++ ++ * pt.c (tsubst) : Remove erroneous argument to build_nt. ++ ++2003-11-22 Kriang Lerdsuwanakij ++ ++ PR c++/5369 ++ * friend.c (is_friend): Handle member function of a class ++ template as template friend. ++ (do_friend): Likewise. ++ * decl2.c (check_classfn): Add template_header_p parameter. ++ * decl.c (start_decl): Adjust check_classfn call. ++ (grokfndecl): Likewise. ++ * pt.c (is_specialization_of_friend): New function. ++ (uses_template_parms_level): Likewise. ++ (push_template_decl_real): Use uses_template_parms_level. ++ (tsubst_friend_function): Adjust check_classfn call. ++ * cp-tree.h (check_classfn): Adjust declaration. ++ (uses_template_parms_level): Add declaration. ++ (is_specialization_of_friend): Likewise. ++ ++2003-11-21 Mark Mitchell ++ ++ PR c++/12515 ++ * pt.c (build_non_dependent_expr): Handle GNU extension to ?: ++ operator. ++ ++2003-11-21 Jan Hubicka ++ ++ * parser.c (cp_parser_postfix_expression): Initialize 's' to ++ NULL_TREE. ++ ++2003-11-20 Joseph S. Myers ++ ++ * Make-lang.in (c++.extraclean): Delete. ++ ++2003-11-20 Joseph S. Myers ++ ++ * Make-lang.in (check-g++, lang_checks): Add. ++ ++2003-11-18 Kriang Lerdsuwanakij ++ ++ PR c++/12932 ++ * class.c (currently_open_derived_class): Check if ++ current_class_type is NULL_TREE. ++ * semantics.c (finish_call_expr): Check if ++ currently_open_derived_class returns NULL_TREE. ++ * cp-tree.h (DERIVED_FROM_P): Add parenthesis around PARENT ++ parameter. ++ ++2003-11-17 Jason Merrill ++ ++ * init.c (build_new_1): Preevaluate placement args. ++ * call.c (build_op_delete_call): Don't expose placement args to ++ overload resolution. ++ ++2003-11-16 Jason Merrill ++ ++ * Make-lang.in (c++.tags): Create TAGS.sub files in each directory ++ and TAGS files that include them for each front end. ++ ++2003-11-15 Bernardo Innocenti ++ ++ PR c++/2294 ++ * name-lookup.c: Revert previous patch for PR c++/2294 to prevent ++ build failure on libjava. ++ ++2003-11-14 Giovanni Bajo ++ ++ PR c++/2294 ++ * name-lookup.c (push_overloaded_decl): Always construct an OVERLOAD ++ unless the declaration is a built-in. ++ (set_namespace_binding): While binding OVERLOADs with only one ++ declaration, we still need to call supplement_binding. ++ ++2003-11-14 Mark Mitchell ++ ++ PR c++/12762 ++ * parser.c (cp_parser_enclosed_template_argument_list): New ++ function. ++ (cp_parser_template_id): Use it. ++ (cp_parser_simple_type_specifier): Recognize invalid template ++ syntax. ++ ++2003-11-14 Giovanni Bajo ++ ++ PR c++/2094 ++ * pt.c (unify): Add support for PTRMEM_CST and ++ FIELD_DECL unification. ++ ++2003-11-13 Richard Earnshaw ++ ++ * decl.c (grokfndecl): Change OK to type tree. ++ ++2003-11-12 Mark Mitchell ++ ++ * tree.c (build_target_expr_with_type): Treate VA_ARG_EXPR like ++ CONSTRUCTOR. ++ ++ * decl.c (cp_make_fname_decl): When creating a top-level ++ __FUNCTION__-like symbol, do register it with pushdecl. ++ ++ * decl.c (finish_case_label): Do not check that we are within a ++ switch statement here. ++ * parser.c (struct cp_parser): Add in_iteration_statement_p and ++ in_switch_statement_p. ++ (cp_parser_new): Initialize them. ++ (cp_parser_labeled_statement): Check validity of case labels ++ here. ++ (cp_parser_selection_statement): Set in_switch_statement_p. ++ (cp_parser_iteration_statement): Set in_iteration_statement_p. ++ (cp_parser_jump_statement): Check validity of break/continue ++ statements here. ++ ++ PR c++/12735 ++ * cp-tree.h (duplicate_decls): Return a tree. ++ * decl.c (duplicate_decls): Clarify documentation. Return ++ error_mark_node to indicate a failed redeclaration. ++ * friend.c (do_friend): Handle that case. ++ * name-lookup.c (pushdecl): Likewise. ++ ++2003-11-11 Jason Merrill ++ ++ * cp-tree.h (DECL_NAMESPACE_ASSOCIATIONS): New macro. ++ * name-lookup.c (parse_using_directive): New fn. ++ (is_associated_namespace): New fn. ++ (arg_assoc_namespace): Also check associated namespaces. ++ * name-lookup.h: Declare new fns. ++ * pt.c (maybe_process_partial_specialization): Allow ++ specialization in associated namespace. ++ * parser.c (cp_parser_using_directive): Accept attributes. Use ++ parse_using_directive. ++ ++2003-11-10 Richard Henderson ++ ++ * cvt.c (convert_to_void): Use void_zero_node after overload failure. ++ ++2003-11-10 Gabriel Dos Reis ++ ++ PR c++/12832 ++ * name-lookup.c (supplement_binding): Gracefully handle names ++ used at non-class scope prior declaration. ++ ++2003-11-06 Matt Austern ++ ++ * decl.c (duplicate_decls): copy DECL_VISIBILITY field. ++ * method.c (use_thunk): give thunk same visibility as function. ++ * optimize.c (maybe_clone_body): copy DECL_VISIBILITY field. ++ ++2003-11-05 Kriang Lerdsuwanakij ++ ++ PR c++/11616 ++ * pt.c (instantiate_pending_templates): Save and restore ++ input_location. ++ ++2003-11-05 Kriang Lerdsuwanakij ++ ++ PR c++/2019 ++ * friend.c (add_friend): Don't display previous declaration in ++ case of duplicate friend warning. ++ ++2003-11-02 Kriang Lerdsuwanakij ++ ++ PR c++/9810 ++ * call.c (build_over_call): Check access using primary template ++ if FN is a member function template. ++ ++2003-11-01 Kriang Lerdsuwanakij ++ ++ PR c++/12796 ++ * class.c (handle_using_decl): Set input_location before calling ++ error_not_base_type. ++ ++2003-10-26 Kriang Lerdsuwanakij ++ ++ PR c++/10371 ++ * semantics.c (finish_non_static_data_member): Handle when ++ both processing_template_decl and qualifying_scope are true. ++ ++2003-10-24 Kriang Lerdsuwanakij ++ ++ PR c++/11076 ++ * class.c (handle_using_decl): Swap arguments of error_not_base_type. ++ * parser.c (cp_parser_direct_declarator): Only resolve typename for ++ namespace scope declarations. ++ ++2003-10-24 Nathan Sidwell ++ ++ PR c++/12698, c++/12699, c++/12700, c++/12566 ++ * cp-tree.h (THUNK_ALIAS_P, THUNK_ALIAS): New. ++ (debug_class, debug_thunks): New. ++ * class.c (dump_class_hierarchy_1): New break out from ... ++ (dump_class_hierarchy): ... here. ++ (dump_thunk, debug_thunks, debug_class): New. ++ (update_vtable_entry_for_fn): Add ssizetype casts. Correct ++ continued search for primary binfo via virtual. ++ (build_vtbl_initializer): Follow covariant thunk alias. ++ * method.c (make_thunk): Clear DECL_THUNKS of the thunk. ++ (finish_thunk): Look for an alias of the covariant thunk and point ++ to it. ++ (use_thunk): We should never use an alias. ++ * semantics.c (emit_associated_thunks): Do not emit aliases. ++ ++ PR c++/12566 ++ * cp-tree.h (cp_fname_init): Add TYPE pointer param. ++ * decl.c (cp_fname_init): Add TYPE pointer param. Set it. Don't ++ create an ad-hoc ERROR_MARK. ++ (cp_make_fname_decl): Adjust. ++ * pt.c (tsubst_expr): Adjust. ++ ++2003-10-23 Jason Merrill ++ ++ PR c++/12726 ++ * tree.c (build_target_expr_with_type): Don't call force_rvalue ++ for CONSTRUCTORs. ++ ++2003-10-22 Kazu Hirata ++ ++ * call.c: Fix comment formatting. ++ * class.c: Likewise. ++ * cxx-pretty-print.c: Likewise. ++ * init.c: Likewise. ++ * parser.c: Likewise. ++ * pt.c: Likewise. ++ * semantics.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ * typeck2.c: Likewise. ++ ++2003-10-21 Mark Mitchell ++ ++ PR c++/11962 ++ * typeck.c (build_x_conditional_expr): Handle missing middle ++ operands in templates. ++ * mangle.c (write_expression): Issue errors about attempts to ++ mangle a non-existant middle operator to the ?: operator. ++ ++2003-10-21 Robert Bowdidge ++ * decl.c (cp_finish_decl): Remove clause intended for asm directives ++ in struct or class fields: this code is never executed. ++ ++2003-10-22 Kriang Lerdsuwanakij ++ ++ * decl.c (start_decl): Exit if push_template_decl returns ++ error_mark_node. ++ ++2003-10-20 Kazu Hirata ++ ++ * ChangeLog: Fix typos. ++ * call.c: Fix comment typos. ++ * class.c: Likewise. ++ * cp-tree.h: Likewise. ++ * cvt.c: Likewise. ++ * cxx-pretty-print.c: Likewise. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * init.c: Likewise. ++ * mangle.c: Likewise. ++ * name-lookup.c: Likewise. ++ * parser.c: Likewise. ++ * search.c: Likewise. ++ * semantics.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ ++2003-10-20 Jan Hubicka ++ ++ * decl.c (start_cleanup_fn): Set DECL_DECLARED_INLINE_P to deffer ++ the expansion. ++ ++2003-10-20 Mark Mitchell ++ ++ * Make-lang.in (c++.install-info): Remove. ++ ++2003-10-20 Jason Merrill ++ ++ * class.c (layout_class_type): Set DECL_ARTIFICIAL on padding ++ field. ++ ++2003-10-20 Kriang Lerdsuwanakij ++ ++ PR c++/9781, c++/10583, c++/11862 ++ * decl.c (cp_finish_decl): Exit immediately if decl is an ++ error_mark_node. ++ * pt.c (push_template_decl_real): Return error_mark_node for ++ invalid template declaration of variable. ++ ++2003-10-18 Kriang Lerdsuwanakij ++ ++ PR c++/12495 ++ * pt.c (lookup_template_class): Handle when current_class_type ++ is a local class. ++ ++2003-10-17 Kriang Lerdsuwanakij ++ ++ PR c++/2513 ++ * decl.c (make_typename_type): Use dependent_type_p. ++ (make_unbound_class_template): Likewise. ++ * pt.c (instantiate_class_template): Increment ++ processing_template_decl during substitution of template friend ++ function. Preincrement processing_template_decl rather than ++ postincrement. ++ (get_mostly_instantiated_function_type): Increment ++ processing_template_decl during partial substitution of function ++ type. ++ ++2003-10-15 Jan Hubicka ++ ++ PR c++/12574 ++ * decl2.c (cxx_callgraph_analyze_expr): Deal with baselink. ++ ++2003-10-14 Jason Merrill ++ ++ PR c++/11878 ++ * tree.c (build_target_expr_with_type): Call force_rvalue for ++ classes with non-trivial copy ctors. ++ ++ PR c++/11063 ++ * typeck.c (build_modify_expr): Call convert rather than abort. ++ ++2003-10-14 Gabriel Dos Reis ++ ++ Breack out decl.c (3/n) ++ * name-lookup.c: Include flags.h ++ (lookup_name_current_level): Make static. ++ (add_decl_to_level): Likewise. ++ (push_local_binding): Likewise. ++ (push_overloaded_decl): Likewise. ++ (lookup_using_namespace): Likewise. ++ (qualified_lookup_using_namespace): Likewise. ++ (lookup_type_current_level): Likewise. ++ (unqualified_namespace_lookup): Likewise. ++ (namespace_ancestor): Likewise. ++ (push_using_directive): Likewise. ++ * decl.c (pushdecl): Move to name-lookup.c. ++ (pushdecl_top_level_1): Likewise. ++ (pushdecl_top_level): Likewise. ++ (pushdecl_top_level_and_finish): Likewise. ++ (maybe_push_decl): Likewise. ++ (push_using_decl): Likewise. ++ (push_overloaded_decl): Likewise. ++ (make_anon_name): Likewise. ++ (anon_cnt): Likewise. ++ (clear_anon_tags): Likewise. ++ (maybe_inject_for_scope_var): Likewise. ++ (check_for_out_of_scope_variable): Likewise. ++ * Make-lang.in (cp/name-lookup.o): Depend on flags.h. ++ * decl.c (warn_extern_redeclared_static): Export. ++ * cp-tree.h (warn_extern_redeclared_static): Declare. ++ ++2003-10-14 Nathanael Nerode ++ ++ * Make-lang.in: Replace uses of $(target_alias) with ++ $(target_noncanonical). ++ ++2003-10-13 Volker Reichelt ++ ++ * ChangeLog: Add PR number to patch for PR c++/12370. ++ ++2003-10-13 Gabriel Dos Reis ++ ++ * name-lookup.h (cxx_scope_find_binding_for_name): Don't export. ++ (binding_for_name): Likewise. ++ (cxx_binding_clear): Move to name-lookup.c. ++ * name-lookup.c (cxx_scope_find_binding_for_name): Now static. ++ (binding_for_name): Likewise. ++ * decl2.c (is_ancestor): Move to name-lookup.c ++ (namespace_ancestor): Likewise. ++ (add_using_namespace): Likewise. ++ (ambiguous_decl): Likewise. ++ (lookup_using_namespace): Likewise. ++ (qualified_lookup_using_namespace): Likewise. ++ (set_decl_namespace): Likewise. ++ (decl_namespace): Likewise. ++ (current_decl_namespace): Likewise. ++ (push_decl_namespace): Likewise. ++ (pop_decl_namespace): Likewise. ++ (push_scope): Likewise. ++ (pop_scope): Likewise. ++ (struct arg_lookup): Likewise. ++ (arg_assoc): Likewise. ++ (arg_assoc_args): Likewise. ++ (arg_assoc_type): Likewise. ++ (add_function): Likewise. ++ (arg_assoc_namespace): Likewise. ++ (arg_assoc_class): Likewise. ++ (arg_assoc_template_arg): Likewise. ++ (do_namespace_alias): Likewise. ++ (validate_nonmember_using_decl): Likewise. ++ (do_nonmember_using_decl): Likewise. ++ (do_toplevel_using_decl): Likewise. ++ (do_local_using_decl): Likewise. ++ (do_class_using_decl): Likewise. ++ (do_using_directive): Likewise. ++ (constructor_name_full): Likewise. ++ (constructor_name): Likewise. ++ (constructor_name_p): Likewise. ++ ++2003-10-13 Gabriel Dos Reis ++ ++ Break out decl.c (2/n) ++ * name-lookup.c: Include diagnostic.h ++ (cxx_binding_free): Make static. ++ (cxx_binding_make): Likewise. ++ (binding_table_new): Likewise ++ (binding_table_free): Likewise. ++ (binding_table_insert): Likewise. ++ (binding_table_find_anon_type): Likewise. ++ (binding_table_reverse_maybe_remap): Likewise. ++ (supplement_binding): Likewise. ++ * name-lookup.h (global_scope_name): Declare extern. ++ (global_type_node): Likewise. ++ (cxx_binding_free): Don't export. ++ (cxx_binding_make): Likewise. ++ (binding_table_new): Likewise. ++ (binding_table_free): Likewise. ++ (binding_table_insert): Likewise. ++ (binding_table_find_anon_type): Likewise. ++ (binding_table_reverse_maybe_remap): Likewise. ++ * Make-lang.in (cp/name-lookup.o): Depend on $(DIAGNOSTIC_H) ++ * decl.c (lookup_namespace_name): Move to name-lookup.c ++ (select_decl): Likewise. ++ (unqualified_namespace_lookup): Likewise. ++ (lookup_qualified_name): Likewise. ++ (lookup_name_real): Likewise. ++ (lookup_name_nonclass): Likewise. ++ (lookup_function_nonclass): Likewise. ++ (lookup_name): Likewise. ++ (lookup_name_current_level): Likewise. ++ (lookup_type_current_level): Likewise. ++ (lookup_flags): Likewise. ++ (qualify_lookup): Likewise. ++ (lookup_tag): Likewise. ++ (lookup_tag_reverse): Likewise. ++ (getdecls): Likewise. ++ (storedecls): Remove. ++ (cxx_remember_type_decls): Move to name-lookup.c. ++ (global_bindings_p): Likewise. ++ (innermost_nonclass_level): Likewise. ++ (toplevel_bindings_p): Likewise. ++ (namespace_bindings_p): Likewise. ++ (kept_level_p): Likewise. ++ (innermost_scope_kind): Likewise. ++ (template_parm_scope_p): Likewise. ++ (push_binding): Likewise. ++ (push_local_binding): Likewise. ++ (add_decl_to_level): Likewise. Make extern. ++ (push_class_binding): Move to name-lookup.c. ++ (resume_level): Likewise. Rename to resume_scope. ++ (begin_scope): Move to name-lookup.c. ++ (indent): Likewise. ++ (binding_depth): Likewise. ++ (is_class_level): Likewise. ++ (cxx_scope_descriptor): Likewise. ++ (cxx_scope_debug): Likewise. ++ (namespace_scope_ht_size): Likewise. ++ (leave_scope): Likewise. ++ (pushlevel_class): Likewise. ++ (poplevel_class): Likewise. ++ (clear_identifier_class_values): Likewise. ++ (pushdecl_with_scope): Likewise. ++ (pushdecl_namespace_level): Likewise. ++ (pushdecl_class_level): Likewise. ++ (push_class_level_binding): Likewise. ++ (push_using_directive): Likewise. ++ (identifier_global_value): Likewise. ++ (keep_next_level_flag): Likewise. ++ (keep_next_level): Likewise. ++ (free_binding_level): Likewise. ++ (set_class_shadows): Likewise. ++ (maybe_push_cleanup_level): Likewise. ++ (cp_namespace_decls): Likewise. ++ (bt_print_entry): Likewise. ++ (print_binding_level): Likewise. ++ (print_other_binding_stack): Likewise. ++ (print_binding_stack): Likewise. ++ (push_namespace): Likewise. ++ (pop_namespace): Likewise. ++ (push_nested_namespace): Likewise. ++ (pop_nested_namespace): Likewise. ++ (cxx_saved_binding_make): Likewise. ++ (struct cxx_saved_binding_make): Likewise. ++ (store_bindings): Likewise. ++ (maybe_push_to_top_level): Likewise. ++ (push_to_top_level): Likewise. ++ (pop_from_top_level): Likewise. ++ (identifier_type_value): Likewise. ++ (set_identifier_type_value): Likewise. ++ (set_identifier_type_value_with_scope): Likewise. ++ (pop_everything): Likewise. ++ (pushtag): Likewise. ++ (follow_tag_typedef): Likewise. ++ (maybe_process_template_type_declaration): Likewise. ++ (pop_binding): Likewise. ++ * cp-tree.h: Move corresponding declarations to name-lookup.h ++ ++2003-10-12 Steven Bosscher ++ ++ * cvt.c (ocp_convert): Move warning to C common code. ++ ++2003-10-09 Jason Merrill ++ ++ PR c++/6392 ++ * tree.c (build_cplus_array_type): Handle all quals the same. ++ (cp_build_qualified_type_real): Look through arrays first. ++ ++ * tree.c (build_cplus_new): Use build_decl to create a VAR_DECL. ++ (build_target_expr_with_type): Likewise. ++ ++ * pt.c (instantiate_class_template): Sanity check that our ++ enclosing class has been instantiated. ++ ++2003-10-08 Giovanni Bajo ++ ++ * cp_tree.h: Added TFF_NO_FUNCTION_ARGUMENTS. ++ * error.c (dump_function_decl): Use it to skip the dump of the ++ arguments. ++ (dump_expr): When dumping a declaration found within an ++ expression, always set TFF_NO_FUNCTION_ARGUMENTS ++ in the flags. ++ ++2003-10-08 Giovanni Bajo ++ ++ PR c++/11097 ++ * pt.c (tsubst_decl): Substitute also the DECL_NAME node of ++ USING_DECL. ++ ++2003-10-06 Mark Mitchell ++ ++ PR c++/10147 ++ * call.c (initialize_reference): Tweak error message. ++ * cxx-pretty-print.h (cxx_pretty_printer_flags): Remove ++ pp_cxx_flag_qualified_id and pp_cxx_flag_global_scope. ++ * cxx-pretty-print.c (pp_cxx_id_expression): Always display ++ qualified entities using qualified names. ++ ++ PR c++/12337 ++ * init.c (build_new_1): Make sure that the expression returned is ++ not an lvalue. ++ ++ PR c++/12344, c++/12236, c++/8656 ++ * decl.c (start_function): Do not ignore attributes embedded in a ++ function declarator. ++ ++2003-10-06 Mark Mitchell ++ ++ * Make-lang.in (c++.info): Remove. ++ (c++.dvi): Remove. ++ (c++.generated-manpages): Replace with ... ++ (generated-manpages): ... this. ++ ++2003-10-03 Gabriel Dos Reis ++ ++ * decl.c (struct cp_binding_level): Move to name-lookup.h ++ (current_binding_level): Likewise. ++ (class_binding_level): Likewise. ++ * cp-tree.h (enum scope_kind): Likewise. ++ ++2003-10-03 Gabriel Dos Reis ++ ++ * name-lookup.c (binding_entry_free): Nullify name and type ++ fields. ++ ++2003-10-02 Mark Mitchell ++ ++ PR c++/12486 ++ * typeck.c (finish_class_member_access_expr): Issue diagnostic ++ on erroneous use of qualified name. ++ ++2003-09-30 Richard Henderson ++ ++ PR c++/12370 ++ * decl.c (duplicate_decls): Copy DECL_SAVED_INSNS too. ++ ++2003-09-30 Kelley Cook ++ ++ * g++spec.c: Convert to ISO C90 prototypes. ++ * parser.c: Likewise. ++ ++2003-09-30 Gabriel Dos Reis ++ ++ * decl.c (pop_binding): Don't mess with nullifying binding->scope ++ here. ++ * name-lookup.c: Re-format. ++ (cxx_binding_free): Nullify binding->scope. ++ ++2003-09-29 Jan Hubicka ++ ++ PR C++/12047 ++ * except.c (build_eh_type_type): Call mark_used on the type. ++ ++2003-09-28 Richard Henderson ++ ++ * typeck.c (c_expand_asm_operands): Take location_t, instead of ++ individual file and line. ++ ++2003-09-28 Andreas Jaeger ++ ++ * decl.c (cxx_builtin_type_decls): Convert to ISO C90 function ++ definition. ++ * init.c (push_base_cleanups): Likewise. ++ * decl2.c (finish_file): Likewise. ++ * mangle.c (init_mangle): Likewise. ++ (dump_substitution_candidates): Likewise. ++ * search.c: Likewise. ++ ++2003-09-27 Gabriel Dos Reis ++ ++ * name-lookup.h (get_global_value_if_present): New function. ++ (is_typename_at_global_scope): Likewise. ++ * except.c (do_begin_catch): Use get_global_value_if_present. ++ (do_end_catch): Likewise. ++ (do_allocate_exception): Likewise. ++ (do_free_exception): Likewise. ++ (build_throw): Likewise. ++ * parser.c (cp_parser_member_declaration): Likewise. ++ * rtti.c (throw_bad_cast): Likewise. ++ (throw_bad_typeid): Likewise. ++ * decl.c (check_tag_decl): Use is_typename_at_global_scope. ++ (grokdeclarator): Likewise. ++ * cp-tree.h (global_namespace): Move to name-lookup.h ++ * call.c (call_builtin_trap): Tidy. ++ ++2003-09-27 Kriang Lerdsuwanakij ++ ++ PR c++/11415 ++ * parser.c (cp_parser_nested_name_specifier_opt): Issue correct ++ error message when parser->scope is global_namespace. ++ ++2003-09-27 Gabriel Dos Reis ++ ++ * cp-tree.h, name-lookup.h, decl.c, decl2.c: Remove reference to ++ macros BINDING_SCOPE, BINDING_VALUE and BINDING_TYPE. ++ ++2003-09-26 Gabriel Dos Reis ++ ++ * decl.c (pop_binding_level, suspend_binding_level, ++ find_class_binding_level): Merge into leave_scope. Remove. ++ (leave_scope): New function. ++ (poplevel): Update. ++ (poplevel_class): Likewise. ++ (pop_namespace): Likewise. ++ ++2003-09-25 Kriang Lerdsuwanakij ++ ++ PR c++/5655 ++ * parser.c (cp_parser_check_access_in_redeclaration): New function. ++ (cp_parser_member_declaration): Use it. ++ (cp_parser_template_declaration_after_export): Likewise. ++ ++2003-09-22 Gabriel Dos Reis ++ ++ * cp-tree.h (scope_kind): Add new enumerator. ++ (keep_next_level): Change parameter type to bool. ++ (begin_scope): Change prototype. ++ (pushlevel): Remove declaration. ++ * decl.c (push_binding_level): Fold in begin_scope. Remove. ++ (struct cp_binding_level): Remove tag_tranparent field. Make keep ++ of bitsize one. ++ (keep_next_level_flag): Make a bool. ++ (cxx_scope_descriptor): Update scope names table ++ (make_cxx_scope): Fold in begin_scope. Remove.. ++ (namespace_scope_ht_size): New function. ++ (begin_scope): Change prototype. Return a scope. Tidy. ++ (kept_level_p): Update. ++ (pushlevel): Remove. ++ (maybe_push_cleanup_level): Simplify. ++ (poplevel): Update for sk_cleanup and keep change. ++ (print_binding_level): Likewise. ++ (initial_push_namespace_scope): Fold in begin_scope. Remove. ++ (push_namespace): Update. ++ (pushtag): Likewise. ++ (lookup_tag): Likewise. ++ (lookup_name_current_level): Likewise. ++ (lookup_type_current_level): Likewise. ++ (cxx_init_decl_processing): Likewise. ++ (start_function): Likewise. ++ (begin_function_body): Likewise. ++ (start_method): Likewise. ++ * pt.c (push_inline_template_parms_recursive): Likewise. ++ (begin_template_parm_list): Likewise. ++ (begin_specialization): Likewise. ++ * semantics.c (do_pushlevel): Likewise. ++ (begin_compound_stmt): Likewise. ++ (begin_stmt_expr): Likewise. ++ ++2003-09-21 Richard Henderson ++ ++ * class.c, cp-tree.h, decl.c, decl2.c, error.c, init.c, ++ method.c, optimize.c, pt.c, semantics.c, tree.c: Revert. ++ ++2003-09-21 Richard Henderson ++ ++ * class.c, cp-tree.h, decl.c, decl2.c, error.c, init.c, ++ method.c, optimize.c, pt.c, semantics.c, tree.c: Update for ++ DECL_SOURCE_LOCATION rename and change to const. ++ ++2003-09-20 Richard Henderson ++ ++ * decl.c, decl2.c, pt.c: Use %J in diagnostics. ++ ++2003-09-20 Kriang Lerdsuwanakij ++ ++ PR c++/157 ++ * parser.c (cp_parser_direct_declarator): Clear ++ parser->num_template_parameter_lists when parsing function ++ parameters. ++ (cp_parser_constructor_declarator_p): Likewise. ++ ++2003-09-19 Kriang Lerdsuwanakij ++ ++ PR c++/495 ++ * pt.c (tsubst_friend_class): Only use innermost template ++ arguments for the injected friend class template. ++ ++2003-09-19 Nathan Sidwell ++ ++ PR c++/12332 ++ * pt.c (instantiate_class_template): Increment ++ processing_template_decl around the tsubst of a template member ++ function. ++ ++2003-09-19 Gabriel Dos Reis ++ ++ * decl.c (cxx_scope_descriptor): Fix thinko. ++ (struct cp_binding_level): Adjust type of binding_depth field. ++ ++2003-09-18 Danny Smith ++ ++ PR c++/12320 ++ * call.c (type_passed_as): Check for incomplete type. ++ (convert_for_arg_passing): Likewise. ++ ++2003-09-18 Nathan Sidwell ++ ++ PR c++/9848 ++ * optimize.c (maybe_clone_body): Don't set MARK_USED on parameters ++ here. ++ * semantics.c (expand_body): Set it here on the remaining clones. ++ ++2003-09-18 Roger Sayle ++ ++ * lex.c (init_operators): Remove operator_name_info for FFS_EXPR. ++ * class.c (instantiate_type): Remove FFS_EXPR case. ++ ++2003-09-18 Volker Reichelt ++ ++ * ChangeLog: Fix recent commit. ++ ++2003-09-18 Volker Reichelt ++ ++ * ChangeLog: Add PR number to patch for PR c++/12316. ++ ++2003-09-18 Gabriel Dos Reis ++ ++ * error.c (dump_type): Simplify. Use pp_type_specifier_seq for ++ "C" types. ++ * cxx-pretty-print.c (pp_cxx_type_specifier_seq): Fix thinko. ++ ++2003-09-17 Richard Henderson ++ ++ * semantics.c (expand_body): Don't save/restore input_location. ++ ++2003-09-17 Mark Mitchell ++ ++ PR c++/12266 ++ * cp-tree.h (tsubst_flags_t): Add tf_conv. ++ * class.c (standard_conversion): Pass tf_conv to ++ instantiate_type. ++ (resolve_address_of_overloaded_function): Do not call mark_used ++ when just checking conversions. ++ ++ PR debug/12066 ++ * cp-lang.c (LANG_HOOKS_BUILTIN_TYPE_DECLS): Define. ++ * cp-tree.h (cxx_builtin_type_decls): Declare. ++ * decl.c (builtin_type_decls): New variables. ++ (cxx_builtin_type_decls): New function. ++ (record_builtin_type): Add to builtin_type_decls. ++ ++2003-09-17 Richard Henderson ++ ++ PR c++/12316 ++ * semantics.c (expand_or_defer_fn): Inc/dec function_depth. ++ ++2003-09-16 Kriang Lerdsuwanakij ++ ++ PR c++/7939 ++ * typeck.c (comptypes): Don't ICE when its first argument is ++ error_mark_node. ++ (compparms): Reverse the arguments of same_type_p. ++ ++2003-09-15 Nathan Sidwell ++ ++ PR c++/12184 ++ * typeck.c (convert_arguments): Return error_mark_node for an ++ incomplete parameter. Make error message more informative. ++ ++2003-09-12 Mark Mitchell ++ ++ PR c++/3907 ++ * class.c (maybe_note_name_used_in_class): Refine test for whether ++ or not we are in a class scope. ++ ++ * cp-tree.h (language_function): Remove x_expanding_p. ++ (expanding_p): Remove. ++ (doing_semantic_analysis_p): Remove. ++ (scope_kind): Add sk_function_parms, sk_class, ++ sk_namespace. ++ (innermost_scope_kind): New method. ++ * call.c (cxx_type_promotes_to): Use type_decays_to. ++ * cp-lang.c (LANG_HOOKS_PUSHLEVEL): Redefine. ++ (LANG_HOOKS_POPLEVEL): Likewise. ++ * decl.c (cp_binding_level): Remove parm_flag, template_parms_p, ++ template_spec_p, namespace_p, is_for_scope, is_try_scope, and ++ is_catch_scope. Add kind and explicit_spec_p. ++ (cxx_scope_descriptor): Use a lookup table. ++ (find_class_binding_level): Use "kind" field in binding_level, not ++ the various flags. ++ (pop_binding_level): Likewise. ++ (innermost_nonclass_level): Likewise. ++ (toplevel_bindings_p): Likewise. ++ (namespace_bindings_p): Likewise. ++ (template_parm_scope_p): Likewise. ++ (innermost_scope_kind): New method. ++ (current_tmpl_spec_kind): Use "kind" field in binding_level, not ++ the various flags. ++ (pushlevel): Remove check for doing_semantic_analysis_p. ++ (begin_scope): Simplify. ++ (add_decl_to_level): Use "kind" field in binding_level, not ++ the various flags. ++ (push_local_binding): Likewise. ++ (pop_label): Remove check for doing_semantic_analysis_p. ++ (poplevel): Use "kind" field in binding_level, not ++ the various flags. ++ (set_block): Remove check for doing_semantic_analysis_p. ++ (pushlevel_class): Use "kind" field in binding_level, not ++ the various flags. ++ (poplevel_class): Likewise. ++ (initial_push_namespace_scope): Likewise. ++ (maybe_push_to_top_level): Likewise. ++ (set_identifier_type_value_with_scope): Likewise. ++ (pop_everything): Likewise. ++ (maybe_process_template_type_declaration): Likewise. ++ (pushtag): Likewise. ++ (pushdecl): Likewise. ++ (pushdecl_with_scope): Likewise. ++ (check_previous_goto_1): Likewise. ++ (define_label): Likewise. ++ (finish_case_label): Likewise. ++ (lookup_tag): Likewise. ++ (unqualified_namespace_lookup): Likewise. ++ (lookup_name_real): Likewise. ++ (lookup_name_current_level): Likewise. ++ (lookup_type_current_level): Likewise. ++ (record_builtin_type): Likewise. ++ (cp_make_fname_decl): Likewise. ++ (maybe_inject_for_scope_var): Likewise. ++ (cp_finish_decl): Remove check for doing_semantic_analysis_p. ++ (start_function): Use begin_scope, not pushlevel. ++ (finish_function): Use "kind" field in binding_level, not ++ the various flags. ++ (start_method): Use begin_scope, not pushlevel. ++ (make_label_decl): Do not check expanding_p. ++ (save_function-data): Do not set expanding_p. ++ (cxx_push_function_context): Do not clear expanding_p. ++ * semantics.c (cxx_expand_function_start): Do not set expanding_p. ++ ++2003-09-14 Mark Mitchell ++ ++ * class.c (layout_class_type): Make DECL_MODE match TYPE_MODE for ++ an bit-field whose width exceeds that of its type. ++ ++2003-09-14 Geoffrey Keating ++ ++ * rtti.c (get_tinfo_decl): Set TREE_PUBLIC for typeinfo decls. ++ ++2003-09-14 Kazu Hirata ++ ++ * ChangeLog: Follow spelling conventions. ++ * parser.c: Likewise. ++ ++2003-09-13 Richard Henderson ++ ++ * decl2.c (finish_file): Check cgraph_assemble_pending_functions ++ during relaxation loop. ++ ++2003-09-11 David Edelsohn ++ ++ * decl2.c (var_finalized_p): Swap arms of conditional. ++ ++2003-09-10 Nathan Sidwell ++ ++ PR c++/11788 ++ * typeck.c (build_address): If it is a function, mark it used. ++ (build_unary_op): Do not lose object's side-effects when taking ++ address of static member function. ++ * class.c (resolve_address_of_overloaded_function): Use ++ tsubst_flags_t parameter. Only expect overload sets. Adjust. ++ (instantiate_type): Adjust flags passing. Do not lose object's ++ side-effects when taking address of static member function. ++ ++2003-09-11 Richard Henderson ++ ++ * semantics.c (expand_or_defer_fn): Update for new ++ cgraph_finalize_function argument. ++ ++2003-09-10 Richard Henderson ++ ++ * decl2.c (cxx_callgraph_analyze_expr): Mark argument unused. ++ ++2003-09-10 Jan Hubicka ++ ++ * decl2.c (var_finalized_p): New. ++ (maybe_emit_vtables, write_out_vars, finish_file): Use it. ++ ++2003-09-10 Richard Henderson ++ ++ * decl2.c (cxx_callgraph_analyze_expr): New, from corpse of ++ mark_member_pointers. ++ (lower_function): Remove. ++ * cp-tree.h: Update to match. ++ * cp-lang.c (LANG_HOOKS_CALLGRAPH_ANALYZE_EXPR): New. ++ (LANG_HOOKS_CALLGRAPH_LOWER_FUNCTION): Remove. ++ ++2003-09-09 Richard Henderson ++ ++ * semantics.c (expand_or_defer_fn): Update call to ++ cgraph_finalize_function. ++ ++ * semantics.c (expand_or_defer_fn): Use cgraph_finalize_function ++ always. ++ ++ * decl2.c (finish_file): Avoid out-of-bounds array reference ++ during memmove. ++ ++2003-09-09 Richard Henderson ++ ++ * decl2.c (mark_member_pointers): Rename from ++ mark_member_pointers_and_eh_handlers and don't check eh handlers. ++ ++2003-09-09 Christian Ehrhardt ++ ++ PR bootstrap/12168 ++ * method.c (use_thunk): Clear DECL_RTL of copied nodes. ++ ++2003-09-08 Mark Mitchell ++ ++ * cp-lang.c (LANG_HOOKS_REGISTER_BUILTIN_TYPE): Define to ++ c_register_builtin_type. ++ ++ PR c++/11786 ++ * decl2.c (add_function): Do not complain about seeing the same ++ non-function twice. ++ * semantics.c (perform_koenig_lookup): Improve documentation. ++ ++ PR c++/5296 ++ * pt.c (try_one_overload): Add addr_p parameter. ++ (resolve_overloaded_unification): Pass it. ++ ++2003-09-08 Richard Henderson ++ ++ * optimize.c (maybe_clone_body): Inc/dec function_depth. ++ ++2003-09-08 Richard Henderson ++ ++ * decl.c (finish_function): Clear current_function_decl. ++ * decl2.c (mark_used): Don't push/pop gc context. ++ * optimize.c (optimize_function): Likewise. ++ * tree.c (cp_cannot_inline_tree_fn): Likewise. ++ * pt.c (instantiate_decl): Inc/dec function_depth instead. ++ * semantics.c (expand_body): Update for tree_rest_of_compilation ++ nested argument. ++ ++2003-09-07 Gabriel Dos Reis ++ ++ PR c++/11762 ++ * error.c (dump_decl): Handle namespace-alias-definition. ++ * decl.c (warn_extern_redeclared_static): There is no point in ++ checking changes in storage class specifier for a namespace ++ declaration. ++ (duplicate_decls): Tidy diagnostic message. ++ * cxx-pretty-print.c (pp_cxx_left_brace): New macro. ++ (pp_cxx_right_brace): Likewise. ++ (pp_cxx_original_namespace_definition): New function. ++ (pp_cxx_namespace_alias_definition): Likewise. ++ (pp_cxx_declaration): Use them. Handle NAMESPACE_DECLs. ++ ++2003-09-07 Jan Hubicka ++ ++ * decl2.c (maybe_emit_vtables, write_out_vars, finish_file): ++ Avoid re-emitting variables in unit-at-a-time mode. ++ ++2003-09-06 Mark Mitchell ++ ++ PR c++/11867 ++ * call.c (standard_conversion): Improve comments. ++ (perform_direct_initialization): Make sure we return an expression ++ of the correct type. ++ * typeck.c (build_static_cast): Check for ambiguity and ++ accessibility when performing conversions. ++ ++2003-09-06 Gabriel Dos Reis ++ ++ * cp-tree.h (add_binding): Remove declaration. ++ * name-lookup.h (supplement_binding): Declare. ++ * decl.c (add_binding): Move to name-lookup.c. ++ (push_local_binding): Adjust. ++ (push_class_binding): Likewise. ++ (set_identifier_type_value_with_scope): Likewise. ++ * name-lookup.c (supplement_binding): Rename from add_binding. ++ Return a bool. Improve documentation. ++ (set_namespace_binding): Adjust. ++ * Make-lang.in (cp/name-lookup.o): Depend on toplev.h ++ ++2003-09-06 Nathan Sidwell ++ ++ PR c++/11794 ++ * class.c (pushclass): Push dependent using decls for nested ++ classes of templates too. ++ ++2003-09-06 Roger Sayle ++ ++ PR c++/11409 ++ * class.c (resolve_address_of_overloaded_function): When building ++ list of matching non-template function decls, ignore anticipated ++ declarations of undeclared or shadowed GCC builtins. ++ ++2003-09-06 Steven Bosscher ++ ++ PR c++/11595 ++ * decl.c (define_label): Remove unreachable timevar pop. ++ Always return the decl, even if the definition is invalid. ++ ++2003-09-06 Nathan Sidwell ++ ++ PR c++/12167 ++ * parser.c (cp_parser_late_parsing_default_args): Push & pop the ++ unparsed functions queue. ++ ++2003-09-05 Mark Mitchell ++ ++ PR c++/12163 ++ * call.c (perform_direct_initialization): Correct logic for ++ direct-initialization of a class type. ++ ++ PR c++/12146 ++ * pt.c (lookup_template_function): Robustify. ++ ++2003-09-05 Nathan Sidwell ++ ++ PR c++/11922 ++ * pt.c (tsubst_qualified_id): Make sure we get a non-type. ++ (tsubst_expr, tsubst_copy_and_build): Pass false, not zero, as ++ is_type_p to lookup_qualified_name. ++ ++ * semantics.c (finish_call_expr): Refactor some code. ++ ++ PR c++/12037 ++ * cp-tree.h (COMPOUND_EXPR_OVERLOADED): New. ++ (build_min_non_dep): Declare. ++ * tree.c (build_min): Propagate TREE_SIDE_EFFECTS. ++ (build_min_non_dep): New. ++ * cvt.c (convert_to_void): Don't explicitly copy ++ TREE_SIDE_EFFECTS, TREE_NO_UNUSED_WARNING. ++ * call.c (build_new_method_call): Use build_min_non_dep. ++ * decl2.c (grok_array_decl): Likewise. ++ (build_offset_ref_call_from_tree): Likewise. ++ * typeck.c (finish_class_member_access_expr, ++ build_x_indirect_ref, build_x_binary_op, build_x_unary_op, ++ build_x_conditional_expr, build_x_compound_expr): Likewise. ++ (build_static_cast, build_reinterpret_cast, ++ build_const_cast): Propagate TREE_SIDE_EFFECTS inside a template. ++ * typeck2.c (build_x_arrow): Use build_min_non_dep. ++ (build_functional_cast): Propagate TREE_SIDE_EFFECTS inside a ++ template. ++ * rtti.c (build_dynamic_cast_1): Set DECL_IS_PURE. ++ (build_dynamic_cast): Set TREE_SIDE_EFFECTS. ++ * pt.c (build_non_dependent_expr): Check COMPOUND_EXPR_OVERLOADED. ++ ++2003-09-04 Richard Henderson ++ ++ * decl2.c (mark_member_pointers_and_eh_handlers): Update for ++ change in cgraph_mark_needed_node arguments. ++ ++2003-09-02 Geoffrey Keating ++ ++ PR 12161 ++ * decl2.c (mark_used): Use ggc_push_context/ggc_pop_context. ++ * tree.c (cp_cannot_inline_tree_fn): Likewise. ++ ++2003-09-04 Nathan Sidwell ++ ++ * cp-tree.h (finish_sizeof, finish_alignof): Remove. ++ (expr_sizeof): Replace with ... ++ (cxx_sizeof_or_alignof_expr): ... here. ++ (cxx_sizeof_or_alignof_type): Make complain parameter a bool. ++ * parser.c (cp_parser_unary_expression): Commonize alignof and ++ sizeof handling. ++ * pt.c (tsubst_copy_and_build): Adjust alignof and sizeof ++ substitution. ++ * semantics.c (finish_sizeof, finish_alignof): Remove. ++ * typeck.c (cxx_sizeof_or_alignof_type): Complain parameter ++ becomes bool. Set TREE_READONLY. ++ (expr_sizeof): Replace with ... ++ (cxx_sizeof_or_alignof_expr): ... here. Clear TREE_SIDE_EFFECTS. ++ ++2003-09-04 Mark Mitchell ++ ++ Remove cast-as-lvalue extension. ++ * call.c (build_conditional_expr): Correct formatting. ++ (convert_like_real): Use lvalue_p, not non_cast_lvalue_p. ++ (initialize_real): Use real_lvalue_p, not real_non_cast_lvalue_p. ++ * cp-tree.h (non_cast_lvalue_p): Remove. ++ (real_non_cast_lvalue_p): Remove. ++ (non_cast_lvalue_or_else): Remove. ++ * tree.c (lvalue_p_1): Remove allow_cast_as_lvalue parameter. ++ (real_lvalue_p): Adjust call to lvalue_p_1. ++ (non_cast_lvalue_p): Remove. ++ (non_cast_lvalue_or_else): Remove. ++ (lvalue_p): Adjust call to lvalue_p_1. ++ (lvalue_or_else): Simplify. ++ * typeck.c (build_unary_op): Use lvalue_or_else, not ++ non_cast_lvalue_or_else. ++ (build_static_cast): Use real_lvalue_p, not real_non_cast_lvalue_p. ++ ++2003-09-03 DJ Delorie ++ ++ * decl.c (finish_function): Pass fndecl to aggregate_value_p. ++ ++2003-09-03 Mark Mitchell ++ ++ PR c++/12053 ++ * class.c (include_empty_classes): Correct logic for ABI version 1. ++ ++2003-09-03 Richard Henderson ++ ++ * optimize.c (optimize_function): Push/pop ggc context around ++ the call to optimize_inline_calls. ++ ++2003-09-02 Scott Brumbaugh ++ ++ PR c++/11553 ++ * parser.c (cp_parser_decl_specifier_seq): Add check for a ++ duplicate friend decl-specifier. ++ ++2003-09-02 Mark Mitchell ++ ++ PR c++/11847 ++ * pt.c (convert_nontype_argument): Correct representation of ++ REFERENCE_TYPE expressions. ++ ++ PR c++/11808 ++ * cp-tree.h (KOENIG_LOOKUP_P): New macro. ++ (finish_call_expr): Change prototype. ++ * parser.c (cp_parser_postfix_expression): Adjust call to ++ finish_call_expr. ++ * pt.c (tsubst_copy_and_build): Use KOENIG_LOOKUP_P. ++ * semantics.c (finish_call_expr): Add koenig_p parameter. ++ ++2003-09-01 Mark Mitchell ++ ++ PR c++/12114 ++ * cp-tree.h (initialize_reference): Change prototype. ++ * call.c (initialize_reference): Add cleanup parameter. ++ * decl.c (grok_reference_init): Likewise. ++ (check_initializer): Likewise. ++ (cp_finish_decl): Insert a CLEANUP_STMT if necessary. ++ (duplicate_decls): When replacing an anticipated builtin, do not ++ honor TREE_NOTHROW. ++ * typeck.c (convert_for_initialization): Correct call to ++ initialize_reference. ++ ++ PR c++/11972 ++ * pt.c (dependent_type_p_r): Pass only the innermost template ++ arguments to any_dependent_template_arguments_p. ++ ++2003-09-01 Josef Zlomek ++ ++ * error.c (dump_expr): Kill BIT_ANDTC_EXPR. ++ * lex.c (init_operators): Kill BIT_ANDTC_EXPR. ++ * pt.c (tsubst_copy): Kill BIT_ANDTC_EXPR. ++ * typeck.c (build_binary_op): Kill BIT_ANDTC_EXPR. ++ (tsubst_copy_and_build): Kill BIT_ANDTC_EXPR. ++ ++2003-08-29 Mark Mitchell ++ ++ PR c++/12093 ++ * pt.c (build_non_dependent_expr): Do not build a ++ NON_DEPENDENT_EXPR for a STRING_CST. ++ ++ PR c++/11928 ++ * search.c (add_conversions): Avoid adding two conversion ++ operators for the same type. ++ ++2003-08-29 Mark Mitchell ++ ++ PR c++/6196 ++ * pt.c (tsubst_copy_and_build): Correct handling of ++ address-of-label extension. ++ * semantics.c (finish_goto_stmt): The address of a label must go ++ through the lvalue-to-rvalue conversion. ++ ++2003-08-29 Richard Henderson ++ Jason Merrill ++ ++ * cp-lang.c (LANG_HOOKS_RTL_EXPAND_START): New. ++ (LANG_HOOKS_RTL_EXPAND_STMT): New. ++ * cp-tree.h (cxx_expand_function_start): Declare. ++ * decl.c (start_function): Use allocate_struct_function. ++ Move stmts_are_full_exprs_p assertion from expand_body. ++ Do not free_after_parsing or free_after_compilation. ++ (cxx_push_function_context): Move code to set struct function ++ data from genrtl_start_function. ++ * optimize.c (optimize_function): Don't inc/dec function_depth. ++ * semantics.c (expand_body): Use tree_rest_of_compilation. ++ (cxx_expand_function_start): Rename from genrtl_start_function, ++ omit bits done by tree_rest_of_compilation. ++ (genrtl_finish_function): Remove. ++ (clear_decl_rtl): Move to ../tree-optimize.c. ++ ++2003-08-29 Gabriel Dos Reis ++ ++ PR c++/11811 ++ * cxx-pretty-print.c (pp_cxx_canonical_template_parameter): New ++ function. ++ * cxx-pretty-print.h: Declare. ++ * error.c (dump_template_parameter): Use it. ++ (dump_type): Likewise. ++ ++2003-08-28 Mark Mitchell ++ ++ * init.c (decl_constant_value): Deal with COND_EXPR specially. ++ * call.c (build_conditional_expr): Revert previous patch. ++ ++ PR optimization/5079 ++ * call.c (build_conditional_expr): Use decl_constant_value to ++ simplify the arguments. ++ ++2003-08-26 Dan Nicolaescu ++ ++ * parser.c (struct cp_token): Use enum bitfields. ++ (CP_TOKEN_BLOCK_NUM_TOKENS): Make sure cp_token_block fits in a ++ 512B allocation unit. ++ (cp_parser_token_tree_map_node): Use enum bitfields. ++ ++2003-08-26 Nathan Sidwell ++ ++ PR c++/11871 ++ * decl.c (push_class_level_binding): Correct old_decl value from ++ my 2003-07-29 reorganization. ++ ++ * call.c (build_call): Don't set TREE_SIDE_EFFECTS here. ++ (build_new_method_call): Add goto finish. ++ * semantics.c (simplify_aggr_init_exprs_r): Don't set ++ TREE_SIDE_EFFECTS on a call. ++ ++2003-08-25 Richard Henderson ++ ++ * cxx-pretty-print.c (pp_cxx_class_name): Remove unused function. ++ ++2003-08-25 Gabriel Dos Reis ++ ++ * cxx-pretty-print.h (pp_cxx_flag_default_argument): New flag. ++ (cxx_pretty_printer): Adjust base type. ++ (pp_cxx_function_specifier): Declare. ++ * cxx-pretty-print.c (pp_cxx_whitespace): New macro. ++ (pp_cxx_left_paren): Likewise. ++ (pp_cxx_right_paren): Likewise. ++ (pp_cxx_dot): Likewise. ++ (pp_cxx_arrow): Likewise. ++ (pp_cxx_semicolon): Likewise. ++ (pp_cxx_identifier): Likewise. ++ (pp_cxx_cv_qualifier_seq): Likewise. ++ (pp_cxx_storage_class_specifier): Likewise. ++ (pp_cxx_expression_list): Likewise. ++ (pp_cxx_space_for_pointer_operator): Likewise. ++ (pp_cxx_init_declarator): Likewise. ++ (pp_cxx_call_argument_list): Likewise. ++ (pp_cxx_nonconsecutive_character): Tidy. ++ (pp_cxx_conversion_function_id): New function. ++ (pp_cxx_template_id): Likewise. ++ (pp_cxx_template_keyword_if_needed): Likewise. ++ (pp_cxx_nested_name_specifier): Likewise. ++ (pp_cxx_unqualified_id): Tidy ++ (pp_cxx_qualified_id): Handle more nodes. ++ (pp_cxx_primary_expression): Tidy. ++ (pp_cxx_postfix_expression): Likewise. ++ (pp_cxx_new_expression): Tidy. ++ (pp_cxx_delete_expression): Likewise. ++ (pp_cxx_cast_expression): New function. ++ (pp_cxx_pm_expression): Tidy. ++ (pp_cxx_conditional_expression): Likewise. ++ (pp_cxx_assignment_operator): New function. ++ (pp_cxx_assignment_expression): Tidy. ++ (pp_cxx_expression): New function. ++ (pp_cxx_function_specifier): Likewise. ++ (pp_cxx_decl_specifier_seq): Likewise. ++ (pp_cxx_simple_type_specifier): Tidy. ++ (pp_cxx_type_specifier_seq): Likewise. ++ (pp_cxx_ptr_operator): New function. ++ (pp_cxx_implicit_parameter_type): Likewise. ++ (pp_cxx_parameter_declaration): Tidy. ++ (pp_cxx_parameter_declaration_clause): New function. ++ (pp_cxx_exception_specification): Likewise. ++ (pp_cxx_direct_declarator): Tidy. ++ (pp_cxx_declarator): Likewise. ++ (pp_cxx_ctor_initializer): New function. ++ (pp_cxx_function_definition): Likewise. ++ (pp_cxx_abstract_declarator): Tidy. ++ (pp_cxx_direct_abstract_declarator): Likewise. ++ (pp_cxx_type_id): Likewise. ++ (pp_cxx_exception_declaration): New function. ++ (pp_cxx_statement): Likewise. ++ (pp_cxx_simple_declaration): Likewise. ++ (pp_cxx_template_parameter_list): Likewise. ++ (pp_cxx_template_parameter): Likewise. ++ (pp_cxx_template_declaration): Likewise. ++ (pp_cxx_explicit_specialization): Likewise. ++ (pp_cxx_explicit_instantiation): Likewise. ++ (pp_cxx_declaration): Tidy. ++ (pp_cxx_pretty_printer_init): Initialize more fields. ++ ++2003-08-25 Mark Mitchell ++ ++ PR c++/8795 ++ * cp-tree.h (build_cplus_method_type): Remove. ++ * call.c (standard_conversion): Use build_method_type_directly ++ instead of build_cplus_method_type. ++ * class.c (build_clone): Likewise. ++ (adjust_clone_args): Likewise. ++ * decl.c (build_ptrmem_type): Likewise. ++ (grokdeclarator): Likewise. ++ (check_function_type): Likewise. ++ * decl2.c (grok_method_quals): Likewise. ++ (maybe_retrofit_in_chrg): Likewise. ++ * pt.c (copy_default_args_to_explicit_spec): Likewise. ++ (tsubst_function_type): Likewise. ++ (tsubst): Likewise. ++ * tree.c (build_cplus_method_type): Remove. ++ * typeck.c (merge_types): Use build_method_type_directly. ++ ++2003-08-23 Kriang Lerdsuwanakij ++ ++ PR c++/3765 ++ * search.c (dfs_access_in_type): Fix typo in comment. ++ (dfs_accessible_queue_p): Likewise. ++ (dfs_accessible_p): Only terminate when a friend is found. ++ (accessible_p): Return immediately if access_in_type allows ++ access. ++ ++2003-08-23 Kriang Lerdsuwanakij ++ ++ PR c++/641, c++/11876 ++ * friend.c (add_friend): Add complain parameter. ++ (make_friend_class): Likewise. ++ (do_friend): Adjust add_friend call. ++ * decl.c (grokdeclarator): Adjust make_friend_class call. ++ * parser.c (cp_parser_member_declaration): Likewise. ++ (cp_parser_template_declaration_after_export): Likewise. ++ * pt.c (instantiate_class_template): Adjust make_friend_class ++ and add_friend call. ++ * cp-tree.h (make_friend_class): Adjust declaration. ++ (add_friend): Likewise. ++ ++2003-08-21 Jason Merrill ++ ++ PR c++/11283 ++ * call.c (build_conditional_expr): Ignore cv-qual differences for ++ non-class types. ++ ++2003-08-21 Mark Mitchell ++ ++ PR c++/11551 ++ * parser.c (cp_parser_id_expression): Add declarator_p parameter. ++ (cp_parser_primary_expression): Adjust call to ++ cp_parser_id_expression. ++ (cp_parser_unqualified_id): Complain about the use of ++ typedef-names in a destructor declarator. ++ (cp_parser_postfix_expression): Adjust call to ++ cp_parser_id_expression. ++ (cp_parser_type_parameter): Likewise. ++ (cp_parser_template_argument): Likewise. ++ (cp_parser_declarator_id): Likewise. ++ ++ PR c++/11919 ++ * call.c (standard_conversion): Use same_type_p, not pointer ++ equality, to compare types. ++ ++ PR c++/10762 ++ * parser.c (cp_parser_using_declaration): Check for invalid uses ++ of template-ids here... ++ * decl2.c (do_class_using_decl): ... rather than here. ++ ++2003-08-20 Mark Mitchell ++ ++ PR c++/11834 ++ * pt.c (more_specialized): Bump processing_template_decl. ++ ++2003-08-21 Jason Merrill ++ ++ PR c++/11614 ++ * decl.c (grokdeclarator): Recognize a flexible array based on the ++ type, not the form of the declarator. ++ ++2003-08-20 Jason Merrill ++ ++ * semantics.c (simplify_aggr_init_expr): Split out from ++ simplify_aggr_init_exprs_r. Convert slot address to match ++ the return type. ++ * cp-tree.h: Declare it. ++ * tree.c (cp_copy_res_decl_for_inlining): Don't clobber the ++ DECL_NAME of a user variable. ++ ++2003-08-20 Nathan Sidwell ++ ++ PR c++/11945 ++ * pt.c (build_non_dependent_expr): Look inside COND_EXPR and ++ COMPOUND_EXPR. ++ * semantics.c (finish_expr_stmt): Always convert to void. ++ * typeck.c (build_x_compound_exp): Always convert to void. ++ ++2003-08-19 Mark Mitchell ++ ++ PR c++/11684 ++ * cp-tree.h (grok_op_properties): Change prototype. ++ * decl.c (grok_op_properties): Add complain parameter. ++ (grokfndecl): Pass it. ++ * pt.c (tsubst_decl): Adjust accordingly. ++ ++ PR c++/10926 ++ * decl.c (start_method): Return immediately if push_template_decl ++ does not like the declaration. ++ * pt.c (push_template_decl_real): Disallow member template ++ destructors. ++ ++ PR c++/11036 ++ * cp-tree.h (add_binding): Add prototype. ++ * class.c (add_method): Set TYPE_HAS_DESTRUCTOR if appropriate. ++ (maybe_warn_about_overly_private_class): Use ++ CLASSTYPE_DESTRUCTORS. ++ (pushclass): Adjust call to set_identifier_type_value. ++ * decl.c (add_binding): Give it external linkage. ++ (push_local_binding): Adjust call to add_binding. ++ (push_class_binding): Likewise. ++ (set_identifier_type_value_with_scope): Change prototype. Use ++ add_binding for global bindings. ++ (set_identifier_type_value): Adjust accordingly. ++ (pushtag): Likewise. ++ (pushdecl): Use set_identifier_type_value, not ++ set_identifier_type_value_with_scope. ++ (pushdecl_namespace_level): Adjust calls to ++ SET_IDENTIFIER_TYPE_VALUE to pass a DECL. ++ (pushdecl_class_level): Likewise. ++ (lookup_tag): Use select_decl. ++ (select_decl): Improve comment. ++ (record_builtin_type): Do not call pushdecl. ++ (cxx_init_decl_processing): Do not call xref_tag for bad_alloc. ++ (cp_finish_decl): Adjust call to set_identifier_type_value. ++ (check_elaborated_type_specifier): Improve checks for invalid uses ++ of typedefs. ++ (xref_tag): Adjust call to check_elaborated_type_specifier. ++ * decl2.c (grokclassfn): Do not set TYPE_HAS_DESTRUCTOR. ++ * name-lookup.c (set_namespace_binding): Use add_binding. ++ * parser.c (cp_parser_simple_type_specifier): Return a TYPE_DECL, ++ rather than an IDENTIFIER_NODE, to represent built-in types, if ++ requested by the caller. ++ (cp_parser_postfix_expression): Adjust call. ++ (cp_parser_type_specifier): Likewise. ++ (cp_parser_elaborated_type_specifier): Adjust call to ++ check_elaborated_type_specifier. ++ * typeck2.c (build_functional_cast): Do not perform name lookups. ++ ++ PR c++/10717 ++ * decl.c (expand_static_init): Remove unnecessary code. ++ ++2003-08-19 Andrew Pinski ++ ++ PR c++/10538, PR c/5582 ++ * cp/cp-lang.c (LANG_HOOKS_DECL_UNINIT): Define. ++ ++2003-08-19 Kriang Lerdsuwanakij ++ ++ PR c++/11174 ++ * init.c (build_offset_ref): Perform access checking for ++ pointer to member correctly. ++ ++2003-08-19 Gabriel Dos Reis ++ ++ * cp-lang.c (LANG_HOOKS_INITIALIZE_DIAGNOSTICS): Fix spelling. ++ ++2003-08-18 Nathan Sidwell ++ ++ PR c++/11957 ++ * cp-tree.h (finish_stmt_expr): Add bool parameter. ++ * init.c (finish_init_stmts): Pass true to finish_stmt_expr. Don't ++ adjust the stmt_expr here. ++ (build_vec_init): Use finish_stmt_expr_expr, convert result to ++ array type. ++ * parser.c (cp_parser_primar_expression): Adjust finish_stmt_expr ++ call. ++ * pt.c (tsubst_copy): Likewise. ++ * semantics.c (finish_stmt_expr): Add parameter. ++ ++ * pt.c (instantiate_class_template): Push to class's scope before ++ tsubsting base. ++ ++2003-08-17 Jan Hubicka ++ ++ PR C++/11702 ++ * semantics.c (finish_id_expression): Mark all functions as used. ++ ++2003-08-16 Nathan Sidwell ++ ++ PR c++/11512 ++ * cvt.c (convert_to_void): Indicate which side of conditional has ++ no effects, and rhs of comma operator. Test for no sideeffect ++ expressions here and always build a convert expr. ++ * init.c (expand_default_init): Convert the init to void. ++ * typeck.c (build_x_compound_expr): Do not check for side effects ++ here. ++ (build_compound_expr): Do not convert lhs when building a ++ template. ++ ++2003-08-15 Nathan Sidwell ++ ++ * cp-tree.def (NON_DEPENDENT_EXPR): Add operand. ++ * decl2.c (build_offset_ref_call_from_tree): Use ++ build_non_dependent_expr. ++ * error.c (dump_expr) : Dump the operand. ++ * pt.c (build_non_dependent_expr): Set operand. ++ ++2003-08-14 Jan Hubicka ++ ++ * decl2.c (mark_member_pointers): Rename to... ++ (mark_member_pointers_and_eh_tinfos): ... this one; deal with eh tinfos ++ (lower_function): Update call. ++ * except.c (eh_type_info): Break out from ... ++ (build_eh_type): ... here; tinfo is already used. ++ (finish_eh_spec_block): Mark tinfos as used. ++ * semantics.c (finish_handler_params): Mark tinfo as used. ++ * cp-tree.h (eh_type_info): Declare. ++ ++2003-08-15 Nathan Sidwell ++ ++ * pt.c (instantiate_class_template): Set location before ++ substuting bases. ++ ++ * decl.c (make_typename_type): Use my_friendly_assert. ++ * pt.c (tsubst_aggr_type): Rearrange context substitution. ++ ++2003-08-14 Jan Hubicka ++ ++ * method.c (use_thunk): Expand body directly. ++ ++2003-08-12 Mark Mitchell ++ ++ PR c++/11703 ++ * call.c (type_passed_as): Use TYPE_SIZE, not TYPE_PRECISION to ++ determine whether or not to promote types. ++ (convert_for_arg_passing): Likewise. ++ * decl2.c (cp_build_parm_decl): Do not set DECL_ARG_TYPE in ++ templates. ++ * pt.c (tsubst_decl): Do not expect it to be set. ++ ++ PR c++/9512 ++ PR c++/10923 ++ * cp-tree.h (check_elaborated_type_specifier): Declare. ++ (handle_class_head): Remove. ++ (note_got_semicolon): Likewise. ++ (note_list_got_semicolon): Likewise. ++ (finish_class_definition): Likewise. ++ * decl.c (check_elaborated_type_specifier): Make it public. ++ Robustify. ++ (handle_class_head): Remove. ++ * parser.c (cp_parser_elaborated_type_specifier): Use ++ check_elaborated_type_specifier. ++ (cp_parser_class_specifier): Do not call finish_class_definition. ++ (cp_parser_class_head): Or handle_class_head. Check for ++ over-qualified names. ++ * semantics.c (finish_class_definition): Remove. ++ ++ * parser.c (cp_parser_check_for_definition_in_return_type): New ++ function. ++ (cp_parser_simple_declaration): Adjust call to ++ cp_parser_init_declarator. ++ (cp_parser_decl_specifier_seq): Change type of ++ declares_class_or_enum parameter. ++ (cp_parser_explicit_instantiation): Adjust accordingly. ++ (cp_parser_type_specifier): Change type of ++ declares_class_or_enum parameter. ++ (cp_parser_init_declarator): Add declares_class_or_enum ++ parameter. ++ (cp_parser_parameter_declaration): Adjust call to ++ cp_parser_decl_specifier_seq. ++ (cp_parser_function_definition): Likewise. ++ (cp_parser_member_declaration): Likewise. ++ (cp_parser_single_declaration): Likewise. ++ ++ * cp-tree.h (lang_type_class): Remove has_call_overloaded, ++ has_array_ref_overloaded, has_arrow_overloaded, and got_semicolon. ++ (TYPE_OVERLOADS_CALL_EXPR): Remove. ++ (TYPE_OVERLOADS_ARRAY_REF): Likewise. ++ (TYPE_OVERLOADS_ARROW): Likewise. ++ (CLASSTYPE_GOT_SEMICOLON): Likewise. ++ * class.c (check_bases): Do not set them. ++ (finish_struct_1): Likewise. ++ * decl.c (cp_finish_decl): Do not set CLASSTYPE_GOT_SEMICOLON. ++ (build_ptrmemfunc_type): Likewise. ++ (grok_op_properties): Do not set TYPE_OVERLOADS_*. ++ (start_function): Do not check CLASSTYPE_GOT_SEMICOLON. ++ * decl2.c (grokfield): Do not set CLASSTYPE_GOT_SEMICOLON. ++ * lex.c (note_got_semicolon): Remove. ++ (note_list_got_semicolon): Likewise. ++ * parser.c (cp_parser_simple_declaration): Do not call ++ note_list_got_semicolon. ++ * pt.c (list_eq): Remove. ++ (lookup_template_class): Do not set CLASSTYPE_GOT_SEMICOLON. ++ (instantiate_class_template): Do not set TYPE_OVERLOADS*. ++ (instantiate_class_template): Do not set CLASSTYPE_GOT_SEMICOLON. ++ * ptree.c (cxx_print_type): Do not print them. ++ * semantics.c (finish_member_class_template): Do not call ++ note_list_got_semicolon. ++ ++2003-08-11 Aldy Hernandez ++ ++ * call.c (standard_conversion): Opaque pointers interconvert. ++ ++ * testsuite/g++.dg/other/opaque-3.C: New. ++ ++2003-08-11 Mark Mitchell ++ ++ * typeck.c (merge_types): Handle cv-qualified pointer-to-member ++ types correctly. ++ ++2003-08-10 Mark Mitchell ++ ++ PR c++/11789 ++ * cp-tree.h (get_vbase): Remove. ++ (get_vbase_types): Remove. ++ * init.c (expand_member_init): Correct logic for looking up base ++ classes. ++ ++2003-08-10 Gabriel Dos Reis ++ ++ * error.c (dump_expr): Tidy. ++ * cxx-pretty-print.c (pp_cxx_nonconsecutive_character): New. ++ (pp_cxx_begin_template_argument_list): Likewise. ++ (pp_cxx_end_template_argument_list): Likewise. ++ (is_destructor_name): Likewise. ++ (pp_cxx_unqualified_id): Likewise. ++ (pp_cxx_qualified_id): Likewise. ++ (pp_cxx_id_expression): Likewise. ++ (pp_cxx_new_expression): Likewise. ++ (pp_cxx_delete_expression): Likewise. ++ (pp_cxx_pm_expression): Likewise. ++ (pp_cxx_type_specifier): Rework. ++ (pp_cxx_type_id): Likewise. ++ (pp_cxx_primary_expression): Likewise. ++ (pp_cxx_postfix_expression): Likewise. ++ (pp_cxx_unary_expression): Likewise. ++ (pp_cxx_multiplicative_expression): Likewise. ++ (pp_cxx_conditional_expression): Likewise. ++ (pp_cxx_assignment_expression): Likewise. ++ (pp_cxx_pretty_printer_init): Tidy. ++ ++2003-08-10 Nathan Sidwell ++ ++ * cp-tree.h (TMPL_ARGS_HAVE_MULTIPLE_LEVELS): non-NULL ++ NODE is always a TREE_VEC of nonzero size. ++ (NUM_TMPL_ARGS): NODE is always a TREE_VEC. ++ * decl2.c (arg_assoc): Template args will be a vec. ++ * error.c (dump_decl) : Call ++ dump_template_argument_list. ++ (dump_template_parms): Args will be a vec. ++ * parser.c (cp_parser_template_argument_list): Produce a ++ vector, not a list. ++ * pt.c (coerce_template_parms): Args are always vectors. ++ (mangle_class_name_for_template): Likewise. ++ (lookup_template_function): Likewise. ++ (lookup_template_class): Likewise. ++ (tsubst_template_args): Likewise. ++ (tsubst_baselink): Use tsubst_template_args. ++ (tsubst_qualified_id): Likewise. ++ (tsubst_copy) : Likewise. ++ (tsubst_copy_and_build) : Likewise. ++ (any_dependent_template_args_p): Args are always vectors. ++ * tree.c (cp_tree_equal): Add TEMPLATE_ID_EXPR case. ++ ++ PR c++/11670 ++ * call.c (convert_like_real): Add rvalue binding error message. ++ * error.c (dump_expr) : Detect when the no expr is ++ really a cast. ++ ++ PR c++/10530 ++ * pt.c (dependent_type_p_r): A dependent template-id is a class ++ type with dependent template arguments, or a bound template ++ template parameter. ++ (type_dependent_expression_p): A template function decl cannot ++ have a dependent context. ++ ++2003-08-07 Kriang Lerdsuwanakij ++ ++ PR c++/5767 ++ * parser.c (cp_parser_class_name): Return immediately when scope ++ is error_mark_node. ++ ++2003-08-07 Aldy Hernandez ++ ++ * cp/Make-lang.in (cp/call.o): Add dependency for target.h. ++ ++ * cp/call.c (standard_conversion): Support opaque types. ++ Include target.h. ++ (strip_top_quals): Use cp_build_qualified_type instead of ++ TYPE_MAIN_VARIANT. ++ ++ * cp/typeck.c (convert_for_assignment): Support opaque types. ++ ++ * testsuite/g++.dg/other/opaque-1.C: New. ++ ++ * testsuite/g++.dg/other/opaque-2.C: New. ++ ++2003-08-06 Aldy Hernandez ++ ++ * decl.c (grokparms): Use cp_build_qualified_type instead ++ TYPE_MAIN_VARIANT. ++ ++2003-08-05 Gabriel Dos Reis ++ ++ * cxx-pretty-print.h: New file. ++ * cxx-pretty-print.c: Likewise. ++ * error.c (scratch_pretty_printer): Change type. ++ (init_error): Tidy. ++ (dump_aggr_type): Likewise. ++ (dump_global_iord): Likewise. ++ (dump_expr): Likewise. ++ (dump_char): Remove. ++ * cp-lang.c (LANG_HOOKS_INITIALIZE_DIAGNOSTITCS): Define. ++ (cxx_initialize_diagnostics): New function. ++ * Make-lang.in (CXX_OBJS): Add cp/cxx-pretty-print.o ++ (CXX_PRETTY_PRINT_H): New variable. ++ (cp/cxx-pretty-print.o): New rule. ++ (cp/cp-lang.o): Update dependence. ++ (cp/error.o): Likewise. ++ ++2003-08-05 Steven Bosscher ++ ++ * cp-tree.h (struct lang_decl): Don't include c_lang_decl. ++ (DECL_DECLARED_INLINE_P): Remove. ++ * decl2.c (import_export_decl): Only look at DECL_DECLARED_INLINE_P ++ if decl is a FUNCTION_DECL. This never made sense, but now it is ++ required to avoid a tree check failure. ++ * decl.c (grokfndecl): Don't touch DID_INLINE_FUNC. ++ * optimize.c (maybe_clone_body): Likewise. ++ ++2003-08-04 Roger Sayle ++ ++ * decl.c (cxx_insert_default_attributes): Delete. ++ * cp-tree.h (cxx_insert_default_attributes): Don't prototype. ++ * cp-lang.c (LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES): Don't define. ++ ++2003-08-03 Nathan Sidwell ++ ++ PR c++/11704 ++ * pt.c (type_dependent_expression_p): Cope with COMPONENT_REF with ++ unknown type. ++ ++ PR c++/11766 ++ * typeck.c (comp_ptr_ttypes_real): Don't loop on pointers to ++ member functions. ++ ++2003-08-02 Nathan Sidwell ++ ++ PR c++/9447 ++ * cp-tree.def (USING_DECL): Document its type. ++ * class.c (pushclass): If we're entering a template, push any ++ dependent using decls it has. ++ * decl2.c (do_class_using_decl): Refactor. Type is NULL iff it is ++ a dependent scope. ++ * pt.c (tsubst_decl) : Set type. ++ (tsubst): Remove USING_DECL checks. ++ (type_dependent_expression_p): Remove USING_DECL case. ++ * semantics.c (finish_member_declaration): A USING_DECL's type ++ indicates whether it is dependent. ++ ++2003-08-02 Nathan Sidwell ++ ++ * cp-tree.h (pushclass): Remove unneeded parameter. ++ * class.c (pushclass): Remove unneeded MODIFY parm. Adjust. ++ (push_nested_class): Adjust pushclass call. ++ * pt.c (instantiate_class_template): Likewise. ++ * semantics.c (begin_class_definition): Likewise. ++ ++2003-08-01 Nathanael Nerode ++ ++ * typeck2.c (add_exception_specifier): Use 'bool' where appropriate. ++ ++2003-08-01 Mark Mitchell ++ ++ PR c++/11697 ++ * decl.c (decls_match): Don't ignore the types of template ++ classes. ++ ++ PR c++/11744 ++ * pt.c (tsubst_copy_and_build): Refine Koenig lookup logic. ++ ++2003-08-01 Kriang Lerdsuwanakij ++ ++ PR c++/8442, c++/8806 ++ * decl.c (qualify_lookup): Accept TEMPLATE_DECL if types are ++ preferred. ++ (check_elaborated_type_specifier): Add allow_template_p ++ parameter. Check tag mismatch and class template. ++ (xref_tag): Add template_header_p parameter. Add assertion ++ that name is an IDENTIFIER_NODE. Remove implicit typename ++ warning. Simplify lookup process if globalize is true. ++ (cxx_init_decl_processing): Adjust call to xref_tag. ++ (xref_tag_from_type): Likewise. ++ * decl2.c (handle_class_head): Likewise. ++ * parser.c (cp_parser_elaborated_type_specifier, ++ cp_parser_class_head): Likewise. ++ * rtti.c (init_rtti_processing, build_dynamic_cast1, ++ tinfo_base_init, emit_support_tinfos): Likewise. ++ * class.c (is_base_of_enclosing_class): Remove. ++ * pt.c (convert_template_argument): Don't accept RECORD_TYPE as ++ template template argument. ++ * cp-tree.h (xref_tag): Adjust declaration. ++ (is_base_of_enclosing_class): Remove. ++ * NEWS: Document template template argument change. ++ ++2003-08-01 Nathan Sidwell ++ ++ * parser.c (cp_parser_init_declarator, ++ cp_paser_member_declaration): Reformat. ++ * pt.c (lookup_template_class, type_unification_real, unify, ++ type_dependent_expression_p): Reformat. ++ ++ PR c++/11295 ++ * cp-tree.h (tubst_flags_t): Add tf_stmt_expr_cmpd, ++ tf_stmt_expr_body. ++ (finish_stmt_expr_expr): Declare. ++ * parser.c (cp_parser_primary_expression): Tell ++ cp_parser_compount_statement that it is a statement expression. ++ (cp_parser_statement, cp_parser_labeled_statement, ++ cp_parser_compound_statement, cp_parser_statement_seq_opt): Add ++ in_statement_expr_p parameter. ++ (cp_parser_expression_statement): Likewise. Call ++ finish_stmt_expr_expr for final expression of a statement ++ expression. ++ (cp_parser_for_init_statement, ++ cp_parser_implicitly_scoped_statement, ++ cp_parser_already_scoped_statement, cp_parser_function_definition, ++ cp_parser_try_block, cp_parser_handled): Adjust. ++ * pt.c (tsubst_copy) : Pass tf_stmt_expr. ++ (tsubst_expr): Process tf_stmt_expr and tf_stmt_exprs flags. ++ (tsubst_expr) : Check tf_stmt_exprs flag. ++ * semantics.c (finish_expr_stmt): Do not deal with statement ++ expressions. ++ (begin_stmt_expr): Clear last_expr_type. ++ (finish_stmt_expr_expr): New. ++ (finish_stmt_expr): Process the value expression. ++ ++ * typeck.c (build_compound_expr): If RHS is a TARGET_EXPR, put the ++ compound expr inside the target's initializer. ++ ++ PR c++/11525 ++ * parser.c (cp_parser_primary_expression): Do not set ++ non-constant-p merely because it is a dependent scope. ++ ++ PR c++/9447 ++ * decl2.c (do_class_using_decl): Set type to NULL_TREE. ++ * semantics.c (finish_expr_stmt): Do not convert to void in a ++ template. ++ ++2003-07-31 Nathan Sidwell ++ ++ * pt.c (coerce_template_parms): Refactor. ++ (fn_type_unification): Increment processing_template_decl when ++ tsubsting an incomplete set of explicit args. ++ ++ PR c++/11347 ++ * pt.c (instantiate_class_template): Increment ++ processing_template_decl around the tsubst of a template member ++ class. ++ (tsubst_qualified_id): Assert we do not have a dependent scope. ++ ++ * pt.c (coerce_template_template_parms, lookup_template_class, ++ can_complete_type_without_circularity, instantiate_class_template, ++ tsubst_decl, unify): Reformat. ++ ++2003-07-31 Jan Hubicka ++ ++ * decl2.c (maybe_make_one_only): Use mark_referenced. ++ * method.c (use_thunk): Likewsie. ++ ++2003-07-30 Jan Hubicka ++ ++ * class.c (build_vtable_entry_ref): Kill. ++ (build_vtbl_ref_1): Do not call build_vtable_entry_ref. ++ (build_vfn_ref): Do not call build_vtable_entry_ref. ++ * cp-lang.c (LANG_HOOKS_PREPARE_ASSEMBLE_VARIABLE): Kill. ++ * cp-tree.h (prepare_assemble_variable): Kill. ++ * cp-decl.c (prepare_assemble_variable): Kill. ++ ++2003-07-29 Geoffrey Keating ++ ++ * parser.c (cp_lexer_new_main): Use c_common_no_more_pch instead ++ of setting valid_pch by hand. ++ ++2003-07-29 Rainer Orth ++ ++ * decl.c (finish_enum): Initialize underlying_type. ++ ++2003-07-29 Nathan Sidwell ++ ++ PR c++/9447 ++ * decl.c (add_binding): Add bval local variable. ++ (push_class_level_binding): Likewise. Allow a USING_DECL to be ++ pushed. ++ * decl2.c (do_class_using_decl): The type of a using decl is ++ unknown. ++ * parser.c (cp_parser_postfix_expression): Refactor unqualified-id ++ function call lookup code. ++ * pt.c (tsubst): A USING_DECL will have unknown type. ++ (tsubst_copy_and_build): Allow a using decl. ++ (type_dependent_expression_p): A USING_DECL will make it ++ dependent. ++ * semantics.c (finish_member_declaration): Push a dependent using ++ declaration. ++ ++2003-07-28 Mark Mitchell ++ ++ PR c++/11530 ++ * parser.c (cp_parser_postfix_expression): Do not call mark_used. ++ * semantics.c (finish_id_expression): Call mark_used for all ++ declarations. ++ ++2003-07-28 Mark Mitchell ++ ++ PR c++/11667 ++ * call.c (standard_conversion): Allow all integral->enumeral ++ conversions, after marking them as bad. ++ * decl.c (finish_enum): Make sure that all enumerators are ++ properly converted to the underlying type. ++ (build_enumerator): Set DECL_CONTEXT for namespace-scope ++ enumeration types. ++ * pt.c (tsubst_copy): Adjust handling of CONST_DECLs accordingly. ++ (tsubst_enum): Tidy. ++ ++ * Make-lang.in (typeck.o): Depend on convert.h. ++ (class.o): Likewise. ++ (rtti.o): Likewise. ++ * call.c: Include convert.h. ++ (convert_arg_to_ellipsis): Use convert_to_real. ++ * class.c: Include convert.h. ++ (build_base_path): Use convert_to_integer. ++ * rtti.c: Include convert.h. ++ (build_headof): Use convert_to_integer. ++ * typeck.c: Include convert.h. ++ (decay_conversion): Use convert_to_integer. ++ (build_unary_op): Use build_nop. ++ (get_delta_difference): Use convert_to_integer. ++ (build_ptrmemfunc): Avoid unnecessary conversions. ++ ++2003-07-28 Jan Hubicka ++ ++ * decl2.c (mark_member_pointers): Verify that member pointer points to ++ the function. ++ ++2003-07-28 Nathan Sidwell ++ ++ * cp-tree.h (begin_compound_stmt): No scope arg is a bool. ++ (finish_compound_stmt): Remove no scope arg. ++ * decl.c (register_dtor_fn): Adjust begin_compound_stmt and ++ end_compound_stmt calls. ++ (expand_static_init, begin_destructor_body, begin_function_body, ++ finish_function_body): Likewise. ++ * decl2.c (start_objects, finish_objects, ++ start_static_storage_duration_function, ++ finish_static_storage_duration_function): Likewise. ++ * init.c (begin_init_stmts, finish_init_stmts, ++ construct_virtual_base, build_vec_init): Likewise. ++ * method.c (do_build_assign_ref, synthesize_method): Likewise. ++ * parser.c (cp_parser_compound_statement, ++ cp_parser_implicitly_scoped_statement, ++ cp_parser_already_scoped_statement): Likewise. ++ * pt.c (tsubst_expr): Likewise. ++ * semantics.c (begin_compound_stmt): No scope arg is a bool. ++ (finish_compound_stmt): Remove no scope arg. ++ ++ * error.c (dump_expr) : A compound expr is ++ always dyadic. ++ ++2003-07-27 Mark Mitchell ++ ++ * call.c (standard_conversion): Tweak handling of ++ pointer-to-member types. ++ * pt.c (tsubst): Correctly qualify pointers-to-data member types. ++ * typeck.c (comp_ptr_ttypes_real): Check qualifiers on ++ pointer-to-data member types. ++ ++2003-07-27 Nathan Sidwell ++ ++ * parser.c (cp_parser_type_parameter): Reformat. ++ (cp_parser_parameter_declaration): Deprecate default args where ++ not allowed. ++ ++2003-07-26 Nathan Sidwell ++ ++ * cfns.h: Rebuilt. ++ ++ * cp-tree.h (begin_init_stmts, finish_init_stmts): Remove. ++ (begin_global_stmt_expr, finish_global_stmt_expr): Remove. ++ * init.c (begin_init_stmts): Make static. Return is_global ++ value. Always call begin_stmt_expr. ++ (finish_init_stmts): Make static. Add is_global parm. Always ++ building a stmt tree. ++ (build_aggr_init): Adjust begin_init_stmts, finish_init_stmts calls. ++ (build_vec_init): Likewise. Always building a stmt tree. ++ (expand_default_init): Always building a stmt tree. ++ (get_temp_regvar): Likewise. ++ * semantics.c (begin_global_stmt_expr, ++ finish_global_stmt_expr): Remove. ++ ++2003-07-25 Nathan Sidwell ++ ++ * cp-tree.h (build_compound_expr): Take LHS & RHS args. ++ (build_x_compound_expr_from_list): Declare. ++ * typeck.c (build_x_compound_expr_from_list): New. ++ (build_x_compound_expr): Adjust. ++ (build_compound_expr): Remove unreachable code. Take two ++ parameters, adjust. ++ * decl.c (grok_reference_init): Use ++ build_x_compound_expr_from_list. ++ (expand_static_init): Adjust build_compound_expr call. ++ (cxx_maybe_build_cleanup): Likewise. ++ * init.c (perform_member_init): Use ++ build_x_compound_expr_from_list. ++ (build_new_1): Likewise. ++ (build_vec_delete): Adjust build_compound_expr calls. ++ (build_vbase_delete): Likewise. ++ * typeck2.c (store_init_value): Use ++ build_x_compound_expr_from_list. ++ (build_functional_cast): Likewise. ++ ++2003-07-25 Nathan Sidwell ++ ++ * cp-tree.h (enum tsubst_flags_t): Add tf_user. ++ * decl.c (make_typename_type): Pass it. ++ * pt.c (lookup_template_class): Use it. ++ (resolve_typename_type): Pass it. ++ * semantics.c (finish_template_type): Pass it. ++ ++2003-07-25 Nathan Sidwell ++ ++ PR c++/11617 ++ * cp-tree.h (qualified_name_lookup_error): Declare. ++ * pt.c (tsubst_qualified_id): Use qualified_name_lookup_error for ++ errors. ++ (tsubst_expr) : Likewise. ++ (tsubst_copy_and_build) : Likewise. ++ * semantics.c (qualified_name_lookup_error): New, broken out of ... ++ (finish_id_expression): ... here. Use it. ++ ++2003-07-25 Falk Hueffner ++ ++ * cfns.gperf: Add '%%' delimiter to placate gperf 3.0. ++ ++2003-07-25 Nathan Sidwell ++ ++ PR c++/11596 ++ * pt.c (maybe_fold_nontype_arg, maybe_fold_nontype_args): Remove. ++ (tsubst_template_arg): New. ++ (tsubst_template_arg_vector): Rename to ... ++ (tsubst_template_args): ... this. Accept a TREE_LIST form. Use ++ tsubst_template_arg. ++ (coerce_template_parms): Use tsubst_template_arg for default ++ value. ++ (tsubst_template_parms): Likewise. ++ (tsubst_aggr_type): Adjust. ++ (tsubst_decl): Likewise. ++ (tsubst): Use tsubst_template_arg for a DOMAIN. Adjust. ++ (tsubst_copy) : Use tsubst_template_args. ++ ++2003-07-25 Gabriel Dos Reis ++ ++ * Make-lang.in (cp/error.o): Depend on DIAGNOSTIC_H. ++ * error.c: Use the new pretty-printer framework. ++ ++2003-07-24 Per Bothner ++ ++ * decl.c (pushdecl_class_level): Don't use push_srcloc/pop_srcloc ++ which causes errors messages to incorrectly mention included files. ++ ++2003-07-24 Mark Mitchell ++ ++ * cp-tree.h (convert_to_base_statically): Declare. ++ * call.c (build_special_member_call): Convert INSTANCE to the base ++ type. ++ * class.c (convert_to_base_statically): New method. ++ * init.c (construct_virtual_base): Use it. ++ * method.c (do_build_assign_ref): Fix typo in comment. ++ ++2003-07-24 Jason Merrill ++ ++ * decl.c: Just set truthvalue_* to boolean_*. ++ ++2003-07-24 Nathan Sidwell ++ ++ * decl.c (reshape_init): Remove unreachable code. ++ ++2003-07-24 Kriang Lerdsuwanakij ++ ++ PR c++/11513 ++ * cp-tree.h (PROCESSING_REAL_TEMPLATE_DECL_P): Use current_scope. ++ ++2003-07-23 Mark Mitchell ++ ++ PR c++/11645 ++ * cp-tree.h (accessible_base_p): Declare. ++ * call.c (build_over_call): Use it. ++ * search.c (accessible_base_p): New function, split out from ... ++ (lookup_base): ... here. ++ ++ PR c++/11517 ++ * call.c (build_conditional_expr): Use perform_implicit_conversion ++ and error_operand_p. Robustify. ++ * typeck.c (build_unary_op): Use perform_implicit_conversion. ++ ++2003-07-23 Nathan Sidwell ++ ++ PR c++/10953 ++ * parser.c (cp_parser_nested_name_specifier): Reset scope on ++ failure. ++ (cp_parser_elaborated_type_specifier): Likewise. ++ ++2003-07-22 Mark Mitchell ++ ++ Eliminate use of POINTER_TYPE for pointers-to-members. ++ * call.c (standard_conversion): Rework pointer-to-member handling. ++ Add comments. ++ (add_builtin_candidate): Likewise. ++ (resolve_scoped_fn_name): Remove. ++ (build_conditional_expr): Rework pointer-to-member handling. ++ (compare_ics): Likewise. ++ * class.c (check_field_decls): Use TYPE_PTR_P. ++ * cp-lang.c (cp_var_mod_type_p): Rework pointer-to-member ++ handling. ++ * cp-tree.h (SCALAR_TYPE_P): Use TYPE_PTR_TO_MEMBER_P. ++ (TYPE_PTRMEM_P): Add comment. ++ (TYPE_PTR_P): Simplify. ++ (TYPE_PTROB_P): Correct definition. ++ (TYPE_PTR_TO_MEMBER_P): New macro. ++ (TYPE_PTRMEM_CLASS_TYPE): Adjust. ++ (TYPE_PTRMEM_POINTED_TO_TYPE): Likewise. ++ (resolved_scoped_fn_name): Remove declaration. ++ (build_offset_ref): Change prototype. ++ (resolve_offset_ref): Remove. ++ (comp_target_types): Remove. ++ * cvt.c (cp_convert_to_pointer): Rework pointer-to-member ++ handling. ++ (convert_to_reference): Use can_convert. ++ (ocp_convert): Improve error handling. Rework pointer-to-member ++ handling. ++ (perform_qualification_conversions): Rework pointer-to-member ++ handling. ++ * decl.c (build_ptrmem_type): Handle functions too. ++ (create_array_type_for_decl): Remove OFFSET_TYPE error message. ++ (grokdeclarator): Use OFFSET_TYPE for pointers to data members. ++ (grokparms): Remove OFFSET_TYPE error message. ++ * dump.c (cp_dump_tree): Rework pointer-to-member handling. ++ * error.c (dump_type_prefix): Likewise. ++ * expr.c (cplus_expand_constant): Use build_nop. ++ * init.c (build_offset_ref): Add address_p parameter. Fold in ++ necessary bits from resolve_offset_ref. ++ (resolve_offset_ref): Remove. ++ * parser.c (cp_parser_postfix_expression): Remove special case ++ code for OFFSET_TYPE. ++ * pt.c (convert_nontype_argument): Rework pointer-to-member ++ handling. ++ (convert_template_argument): Likewise. ++ (unify): Likewise. ++ (invalid_nontype_parm_type_p): Likewise. ++ (dependent_type_p_r): Likewise. ++ * rtti.c (get_tinfo_decl): Remove OFFSET_TYPE special case. ++ (target_incomplete_p_): Rework pointer-to-member ++ handling. ++ (get_pseudo_ti_init): Likewise. ++ (get_pseudo_ti_desc): Likewise. ++ * semantics.c (finish_qualified_id_expr): Adjust call to ++ build_offset_ref. Remove use of resolve_offset_ref. ++ * tree.c (pod_type_p): Use TYPE_PTR_TO_MEMBER_P. ++ * typeck.c (target_type): Use TYPE_PTRMEM_P. ++ (type_unknown_p): Remove obsolete code about the time before ++ non-dependent expressions were handled correctly. ++ (qualify_type_recursive): Remove. ++ (composite_pointer_type_r): New function. ++ (composite_pointer_type): Use it. ++ (merge_types): Remove dead comments. ++ (comp_cv_target_types): Remove. ++ (comp_target_types): Likewise. ++ (comp_target_parms): Likewise. ++ (cxx_sizeof_or_alignof_type): Remove OFFSET_TYPE error. ++ (build_indirect_ref): Use TYPE_PTR_TO_MEMBER_P. ++ (build_binary_op): Do not use of comp_target_types. ++ (pointer_diff): Remove OFFSET_TYPE case. ++ (build_unary_op): Adjust pointer-to-member handling. ++ (unary_complex_lvalue): Likewise. ++ (check_for_casting_away_constness): Add description parameter. ++ (build_static_cast): Pass it. ++ (build_reinterpret_cast): Use check_for_casting_away_constness. ++ (build_const_cast): Adjust pointer-to-member handling. ++ (build_c_cast): Likewise. ++ (convert_for_assignment): Remove OFFSET_TYPE error message. ++ (comp_ptr_ttypes_real): Adjust pointer-to-member handling. ++ (comp_ptr_ttypes_reinterpret): Remove. ++ (casts_away_constness_r): Adjust pointer-to-member handling. ++ (casts_away_constness): Liekwise. ++ (strip_all_pointer_quals): Remove. ++ * typeck2.c (digest_init): Adjust pointer-to-member handling. ++ (build_m_component_ref): Likewise. ++ ++2003-07-22 Wolfgang Bangerth ++ ++ * lex.c (unqualified_fn_lookup_error): Mention that the error ++ message needs to be kept in synch with the manual. ++ ++2003-07-22 Nathan Sidwell ++ ++ PR c++/11614 ++ * decl.c (grokdeclarator): An array member is only a flexible ++ array member if the field itself is the array. ++ ++2003-07-22 Kriang Lerdsuwanakij ++ ++ PR c++/10793 ++ * decl.c (xref_basetypes): Handle error_mark_node. ++ ++2003-07-22 Nathan Sidwell ++ ++ * cp-tree.h (enum cp_lvalue_kind): Add clk_packed. ++ * tree.c (lvalue_p_1): Set it. ++ * class.c (check_field): Don't allow non-packed non-POD fields to ++ be packed. ++ * call.c (reference_binding): Need a temporary for all bitfield ++ and packed fields. ++ (convert_like_real): Check it is ok to make a temporary here. ++ ++2003-07-21 Nathan Sidwell ++ ++ * cp-tree.h (hack_identifier): Remove. ++ * method.c (hack_identifier): Remove. ++ * semantics.c (finish_id_expression): Expand hack_identifier ++ here. Simplify. ++ ++2003-07-19 Kaveh R. Ghazi ++ ++ * call.c class.c decl.c decl2.c g++spec.c lex.c parser.c pt.c rtti.c ++ semantics.c typeck.c: Remove unnecessary casts. ++ ++2003-07-18 Nathan Sidwell ++ ++ * cp-tree.h (hack_identifier): Remove. ++ * method.c (hack_identifier): Remove. ++ * semantics.c (finish_id_expression): Expand hack_identifier ++ here. Simplify. ++ ++2003-07-18 Nathan Sidwell ++ ++ * cp-tree.h (finish_non_static_data_member): Add object param. ++ * method.c (hack_identifier): Adjust. ++ * pt.c (tsubst_copy_and_build) : Don't search ++ again for a FIELD_DECL. ++ * semantics.c (finish_non_static_data_member): Add object ++ parameter. Always save the DECL in the COMPONENT_REF. ++ * call.c (resolve_scoped_fn_name): Adjust. ++ ++2003-07-17 Zack Weinberg ++ ++ * pt.c (get_bindings): Make definition consistent with ++ forward declaration. ++ ++2003-07-17 Kriang Lerdsuwanakij ++ ++ PR c++/7809 ++ * friend.c (add_friend): Check access for member functions ++ and templates. ++ ++2003-07-17 Gabriel Dos Reis ++ ++ PR c++/10668 ++ * typeck.c (build_class_member_access_expr): Improve diagnostic. ++ ++2003-07-16 Mark Mitchell ++ ++ PR c++/11547 ++ * cp-tree.h (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P): New ++ macro. ++ (DECL_PRETTY_FUNCTION_P): Use VAR_DECL_CHECK. ++ * decl.c (duplicate_decls): Merge ++ DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P. ++ * parser.c (cp_parser_postfix_expression): Adjust call to ++ cp_parser_initializer_list and ++ cp_parser_parenthesized_expression_list. ++ (cp_parser_parenthesized_expression_list): Add non_constant_p. ++ (cp_parser_new_placement): Adjust call to ++ cp_parser_parenthesized_expression_list. ++ (cp_parser_direct_new_declarator): Likewise. ++ (cp_parser_conditional_expression): Remove. ++ (cp_parser_constant_expression): Parse an assignment-expression, ++ not a conditional-expression. ++ (cp_parser_simple_declaration): Resolve expression/declaration ++ ambiguity more quickly. ++ (cp_parser_mem_initializer): Adjust call to ++ cp_parser_parenthesized_expression_list. ++ (cp_parser_init_declarator): Keep track of whether or not the ++ initializer is a constant-expression. ++ (cp_parser_initializer): Add non_constant_p parameter. ++ (cp_parser_initializer_clause): Likewise. ++ (cp_parser_initializer_list): Likewise. ++ (cp_parser_attribute_list): Adjust call to ++ cp_parser_parenthesized_expression_list. ++ (cp_parser_functional_cast): Likewise. ++ * pt.c (tsubst_decl): Copy ++ DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P. ++ (tsubst_expr): Tweak use of DECL_PRETTY_FUNCTION_P. ++ * semantics.c (finish_id_expression): Use ++ DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P. ++ ++2003-07-16 Neil Booth ++ ++ * lang-options.h: Remove. ++ ++2003-07-16 Andrew Pinski ++ ++ PR c/10962 ++ * class.c (field_decl_cmp): Remove. ++ (resort_field_decl_cmp): Remove. ++ (resort_sorted_fields): Remove. ++ (add_fields_to_vec): Rename to ... ++ (add_fields_to_record_type): this. ++ (finish_struct_1): Change to be using ++ sorted_fields_type's fields. ++ * cp-tree.h (lang_decl): In lang_decl_u3 ++ change sorted_fields to be a pointer to ++ sorted_fields_type. ++ (resort_sorted_fields): Remove prototype. ++ * search.c (lookup_field_1): Change to be using ++ sorted_fields_type's fields. ++ ++2003-07-16 Kriang Lerdsuwanakij ++ ++ PR c++/5421 ++ * decl.c (grokdeclarator): Handle TEMPLATE_ID_EXPR if friend ++ is a member of other class. ++ * friend.c (do_friend): Don't build TEMPLATE_DECL if friend ++ is a specialization of function template. ++ ++2003-07-16 Gabriel Dos Reis ++ ++ PR c++/10903 ++ * pt.c (convert_nontype_argument): Fix thinko in diagnostic. ++ Improve. ++ ++2003-07-15 Mark Mitchell ++ ++ * cp-tree.def (LOOKUP_EXPR): Remove. ++ * cp-tree.h (cp_id_kind): Add CP_ID_KIND_UNQUALIFIED_DEPENDENT. ++ (LOOKUP_EXPR_GLOBAL): Remove. ++ (get_bindings): Remove. ++ (is_aggr_type_2): Remove. ++ * call.c (resolved_scoped_fn_name): Remove support for ++ LOOKUP_EXPR. ++ * decl.c (grokfndecl): Likewise. ++ (grokdeclarator): Likewise. ++ * error.c (dump_decl): Likewise. ++ (dump_expr): Likewise. ++ * friend.c (do_friend): Likewise. ++ * init.c (build_offset_ref): Likewise. ++ * lex.c (unqualified_fn_lookup_error): Use pedwarn. Do not create ++ LOOKUP_EXPRs ++ * mangle.c (write_expression): Remove support for LOOKUP_EXPR. ++ * parser.c (cp_parser_postfix_expression): Modify Koenig lookup ++ test. ++ * pt.c (get_bindings): Give it internal linkage. ++ (check_explicit_specialization): Remove support for LOOKUP_EXPR. ++ (lookup_template_function): Likewise. ++ (for_each_tempalte_parm_r): Likewise. ++ (tsubst_decl): Likewise. ++ (tsubst_qualified_id): Handle template template parameters. ++ (tsubst_copy): Remove support for LOOKUP_EXPR. ++ (tsubst_copy_and_build): Likewise. ++ (most_general_template): Likewise. ++ (value_dependent_expression_p): Likewise. ++ (type_dependent_expression_p): Note that IDENTIFIER_NODEs are ++ always dependent. ++ * semantics.c (perform_koenig_lookup): Do not create ++ IDENTIFIER_NODEs. ++ (finish_fname): Likewise. ++ (finish_id_expression): Likewise. ++ * tree.c (is_aggr_type_2): Remove. ++ ++2003-07-16 Gabriel Dos Reis ++ ++ PR c++/11531 ++ * typeck.c (check_return_expr): Fix thinko in diagnostic. ++ ++2003-07-15 Kriang Lerdsuwanakij ++ ++ PR c++/10108 ++ * pt.c (tsubst_decl) : Add a check for ++ error_mark_node. ++ ++2003-07-14 Mark Mitchell ++ ++ PR c++/11509 ++ * pt.c (dependent_scope_ref_p): New function. ++ (value_dependent_expression_p): Use it. ++ (type_dependent_expression_p): Likewise. ++ ++ * pt.c (tsubst_friend_function): Use reregister_specialization. ++ ++ PR c++/7019 ++ * cp-tree.h (lookup_qualified_name): Adjust prototype. ++ * decl.c (lookup_qualified_name): Add complain parameter. Adjust ++ call to is_aggr_type. ++ * parser.c (cp_parser_lookup_name): Adjust call to ++ lookup_qualified_name. ++ * pt.c (tsubst_qualified_id): Likewise. ++ (tsubst_copy_and_build): Likewise. ++ * semantics.c (finish_qualified_id_expr): Deal with erroneous ++ expressions. ++ ++2003-07-14 Gabriel Dos Reis ++ ++ PR c++/11510 ++ * call.c (op_error): Properly format REALPART_EXPR and ++ IMAGPART_EXPR. ++ * error.c (dump_expr): Likewise. ++ ++2003-07-14 Gabriel Dos Reis ++ ++ * error.c (dump_expr): Handle EMPTY_CLASS_EXPR. ++ ++2003-07-14 Gabriel Dos Reis ++ ++ PR c++/5293 ++ * call.c (initialize_reference): Improve diagnostic. ++ ++2003-07-14 Kriang Lerdsuwanakij ++ ++ PR c++/11154 ++ * pt.c (more_specialized_class): Add full_args parameter. ++ (most_specialized_class): Adjust calls to more_specialized_class. ++ * cp-tree.h (more_specialized_class): Adjust declaration. ++ ++2003-07-14 Dan Nicolaescu ++ ++ * lex.c (enum tree_node_kind): Delete. ++ ++2003-07-13 Mark Mitchell ++ ++ PR c++/11503 ++ * cp-tree.h (DECL_SELF_REFERENCE_P): New macro. ++ (SET_DECL_SELF_REFERENCE_P): Likewise. ++ * class.c (build_self_reference): Use SET_DECL_SELF_REFERENCE_P. ++ * pt.c (tsubst_decl): Copy it. ++ * search.c (lookup_base): Use DECL_SELF_REFERENCE_P. ++ ++ * pt.c (reregister_specialization): Fix thinko in previous change. ++ ++ * cp-tree.h (cp_id_kind): New type. ++ (unqualified_name_lookup_error): Change prototype. ++ (unqualified_fn_lookup_error): New function. ++ (do_identifier): Remove. ++ (do_scoped_id): Likewise. ++ (tsubst_copy_and_build): Change prototype. ++ (reregister_specialization): New function. ++ (perform_koenig_lookup): Likewise. ++ (finish_id_expression): Likewise. ++ * call.c (build_method_call): Adjust call to ++ unqualified_name_lookup_error. ++ * decl.c (duplicate_decls): Use reregister_specialization. ++ * lex.c (is_global): Remove. ++ (unqualified_name_lookup_error): Return a value. ++ (do_identifier): Remove. ++ (do_scoped_id): Likewise. ++ (identifier_typedecl_value): Remove. ++ (unqualified_fn_lookup_error): New function. ++ * parser.c (cp_parser_id_kind): Remove. ++ (cp_parser_non_constant_id_expression): Remove. ++ (cp_parser_primary_expression): Use finish_id_expression. ++ (cp_parser_class_or_namespace_name): Use cp_id_kind, not ++ cp_parser_id_kind. ++ (cp_parser_postfix_expression): Use perform_koenig_lookup. ++ (cp_parser_template_argument): Use cp_id_kind. ++ (cp_parser_fold_non_dependent_expr): Adjust call to ++ tsubst_copy_and_build. ++ * pt.c (unregister_specialization): Rename to ... ++ (reregister_specialization): This. ++ (tsubst_friend_function): Use it. ++ (maybe_fold_nontype_arg): Adjust call to tsubst_copy_and_build. ++ (tsubst_qualified_id): Likewise. ++ (tsubst_expr): Likewise. ++ (tsubst_copy_and_build): Add function_p parameter. Use ++ finish_id_expression. Introduce RECUR macro. ++ (tsubst_non_call_postfix_expression): New function. ++ (regenerate_decl_from_template): Use reregister_specialization. ++ * semantics.c (perform_koenig_lookup): New function. ++ (finish_id_expression): Likewise. ++ ++2003-07-13 Kriang Lerdsuwanakij ++ ++ * pt.c (push_access_scope_real): Remove. ++ (push_access_scope): Move code from push_access_scope_real. ++ (pop_access_scope): Don't check for TEMPLATE_DECL. ++ (instantiate_template): Defer access checking during template ++ substitution. ++ (regenerate_decl_from_template): Tidy. ++ ++2003-07-11 Nathanael Nerode ++ ++ PR c++/11437 ++ * operators.def: Add definitions for __imag__, __real__. ++ ++2003-07-11 Nathan Sidwell ++ ++ PR c++/11050 ++ * parser.c (cp_parser_expression_list): Rename to ... ++ (cp_parser_parenthesized_expression_list): ... here. Add attribute ++ parameter, parse the surounding parentheses. ++ (cp_parser_skip_to_closing_parenthesis): Add recover and or_comma ++ parameters. Return int. ++ (cp_parser_skip_to_closing_parenthesis or comma): Remove. ++ (cp_parser_postfix_expression): Adjust function call parsing. ++ (cp_parser_new_placement): Adjust. ++ (cp_parser_new_initializer): Likewise. ++ (cp_parser_cast_expression): Likewise. ++ (cp_parser_selection_statement): Likewise. ++ (cp_parser_mem_initializer): Likewise. ++ (cp_parser_asm_definition): Likewise. ++ (cp_parser_init_declarator): Likewise. ++ (cp_parser_declarator): Make ++ cdtor_or_conv_p an int ptr. ++ (cp_parser_direct_declarator): Likewise. Check for a parameter ++ list on cdtors & conv functions. ++ (cp_parser_initializer): Adjust. ++ (cp_parser_member_declaration): Adjust. ++ (cp_parser_attribute_list): Move code into ++ cp_parser_parens_expression_list. ++ (cp_parser_functional_cast): Adjust. ++ * pt.c (type_dependent_expression_p): Erroneous expressions are ++ non-dependent. ++ ++2003-07-11 Geoffrey Keating ++ ++ * decl.c (cp_finish_decl): Handle 'used' attribute. ++ ++ * cp-lang.c (c_reset_state): New dummy routine. ++ * cp-tree.h (finish_file): Move prototype to c-common.h. ++ * parser.c (c_parse_file): Rename from yyparse; don't call finish_file. ++ ++2003-07-11 Mark Mitchell ++ ++ PR c++/8327 ++ * pt.c (tsubst_qualified_id): Implement suggested resolution for ++ Core Issue 2. ++ (type_dependent_expression_p): Likewise. ++ ++2003-07-10 Mark Mitchell ++ ++ * typeck.c (build_binary_op): Do not warn about signed ++ vs. unsigned comparisons in the bodies of templates. ++ ++ PR c++/9411 ++ * parser.c (cp_parser_postfix_expression): Check dependency of ++ functions. ++ ++2003-07-09 Mark Mitchell ++ ++ PR c++/10032 ++ * decl.c (cxx_init_decl_processing): With -pedantic, pedwarns are ++ still errors. ++ ++ PR c++/10527 ++ * error.c (decl_to_string): Do not print default argument ++ expressions. ++ ++ * cp-tree.h (break_out_calls): Remove declaration. ++ * tree.c (break_out_calls): Remove. ++ * typeck.c (build_modify_expr): Avoid invalid sharing of trees. ++ ++2003-07-09 Nathan Sidwell ++ ++ PR c++ 9483 ++ * class.c (check_field_decls): Pass DECL_NAME to constructor_name_p. ++ * decl2.c (constructor_name_p): Avoid repeated constructor_name ++ calls. ++ * decl.c (grokdeclarator): Refactor ctor/dtor detection. ++ ++2003-07-09 Mark Mitchell ++ ++ * typeck.c (build_x_unary_op): Take note of the fact that ++ PREINCREMENT_EXPR and POSTINCREMENT_EXPR are binary operations on ++ trees. ++ ++ * parser.c (cp_parser_primary_expression): Preserve the form of ++ qualified expressions in templates, even if they are not ++ dependent. ++ * pt.c (convert_nontype_argument): Handle non-dependent SCOPE_REFs. ++ (tsubst_qualified_id): Likewise. ++ * search.c (accessible_p): Treat everything in the body of a ++ template as accessible. ++ ++2003-07-08 Mark Mitchell ++ ++ * cp-tree.def (NON_DEPENDENT_EXPR): New node. ++ * cp-tree.h (build_call_from_tree): Remove. ++ (build_member_call): Likewise. ++ (dependent_template_arg_p): Remove. ++ (any_dependent_template_arguments_p): New function. ++ (dependent_template_id_p): Likewise. ++ (any_type_dependent_arguments_p): Likewise. ++ (build_non_dependent_expr): Likewise. ++ (build_non_dependent_args): Likewise. ++ (build_x_compound_expr): Adjust prototype. ++ * call.c (build_new_method_call): Handle non-dependent expressions ++ correctly. ++ * decl2.c (grok_array_decl): Likewise. ++ (build_offset_ref_call_from_tree): Likewise. ++ (build_call_from_tree): Remove. ++ * error.c (dump_decl): Handle NON_DEPENDENT_EXPR. ++ (dump_expr): Likewise. ++ * init.c (build_member_call): Remove. ++ * mangle.c (write_expression): Update handling for template-ids. ++ * parser.c (cp_parser_primary_expression): Use ++ any_dependent_template_arguments_p. Update constant-expression ++ handling. ++ (cp_parser_postfix_expression): Use ++ any_type_dependent_arguments_p. Simplify call processing. ++ (cp_parser_unary_expression): Simplify. ++ (cp_parser_expression): Adjust for changes to ++ build_x_compound_expr. ++ (cp_parser_template_argument): Implement standard-conforming ++ parsing of non-type template arguments. ++ (cp_parser_direct_declarator): Use ++ cp_parser_fold_non_dependent_expr. ++ (cp_parser_fold_non_dependent_expr): New function. ++ (cp_parser_next_token_ends_template_argument_p): Likewise. ++ * pt.c (convert_template_argument): Do not call ++ maybe_fold_nontype_arg. ++ (tsubst_baselink): Likewise. ++ (tsubst_copy_and_build): Share common code. Make sizeof/alignof ++ processing work correctly for non-dependent expressions. Adjust ++ handling of COMPOUND_EXPR. Simplify call processing. ++ (value_dependent_expression_p): Deal with functional casts and ++ sizeof/alignof correctly. ++ (type_dependent_expression_p): Handle overloaded functions. ++ (any_type_dependent_arguments_p): New function. ++ (any_dependent_template_arguments_p): Likewise. ++ (dependent_template_p): Treat SCOPE_REFs as dependent. ++ (dependent_template_id_p): Simplify. ++ (build_non_dependent_expr): New function. ++ (build_non_dependent_args): Likewise. ++ * semantics.c (finish_stmt_expr): Don't make dependent ++ statement-expresions have void type. ++ (finish_call_expr): Handle non-dependent expressions ++ correctly. ++ * tree.c (lvalue_p_1): Treat NON_DEPENDENT_EXPRs as lvalues. ++ * typeck.c (cxx_sizeof_or_alignof_type): Give the expression ++ type size_t, even in templates. ++ (expr_sizeof): Likewise. ++ (finish_class_member_access_expr): Handle non-dependent expressions ++ correctly. ++ (build_x_indirect_ref): Likewise. ++ (build_x_binary_op): Likewise. ++ (build_x_unary_op): Likewise. ++ (build_x_conditional_expr): Likewise. ++ (build_x_compound_expr): Likewise. ++ * typeck2.c (build_x_arrow): Likewise. ++ ++2003-07-09 Jan Hubicka ++ ++ * cp-lang.c (LANG_HOOKS_TREE_INLINING_ESTIMATE_NUM_INSNS): New. ++ * decl.c (duplicate_decls): Use DECL_ESTIMATED_INSNS. ++ (start_function): Use DECL_ESTIMATED_INSNS. ++ * optimize.c (maybe_clone_body): Use DECL_ESTIMATED_INSNS. ++ ++ * decl2.c (maybe_emit_vtables): Fix marking vtables as needed in ++ unit-at-a-time ++ ++2003-07-08 Kriang Lerdsuwanakij ++ ++ PR c++/11030 ++ * pt.c (instantiate_class_template): Don't call xref_tag to ++ inject name when the friend class is a specialization. ++ ++2003-07-07 Mark Mitchell ++ ++ * cp-tree.h (build_scoped_method_call): Remove. ++ (lookup_qualified_name): Remove parameter. ++ (tsubst_copy_and_build): Declare. ++ (finish_qualified_object_call_expr): Remove. ++ (check_accessibility_of_qualified_id): New function. ++ (finish_qualified_id_expr): Likewise. ++ (non_reference): Likewise. ++ (build_expr_from-tree): Remove. ++ * call.c (non_reference): Remove. ++ (build_scoped_method_call): Likewise. ++ (build_method_call): Use error_operand_p. Assert that we are not ++ processing a template. ++ (standard_conversion): Use non_reference. ++ * class.c (build_vtbl_entry_ref): Likewise. ++ (build_vtbl_ref_1): Likewise. ++ * cvt.c (build_expr_type_conversion): Use non_reference. ++ * decl.c (lookup_qualified_name): Remove flags parameter. ++ (grok_op_properties): Use non_reference. ++ * decl2.c (grok_array_decl): Likewise. ++ (build_expr_from_tree): Remove. ++ (build_offset_ref_call_from_tree): Update comment. ++ * error.c (parm_to_string): Call reinit_global_formatting_buffer. ++ * except.c (prepare_eh_types): Use non_reference. ++ (can_convert_eh): Likewise. ++ * init.c (build_dtor_call): Avoid using build_method_call. ++ * mangle.c (write_template_param): Remove misleading comment. ++ * method.c (locate_copy): Use non_reference. ++ * parser.c (cp_parser_scope_through_which_access_occurs): Remove. ++ (cp_parser_primary_expression): Do not create SCOPE_REFs is ++ non-dependent contexts. ++ (cp_parser_postfix_expression): Use finish_qualified_id_expr. ++ (cp_parser_direct_declarator): Use tsubst_copy_and_build, not ++ build_expr_from_tree. ++ (cp_parser_lookup_name): Adjust call to lookup_qualified_name. ++ Use check_accessibility_of_qualified_id. ++ * pt.c (maybe_fold_nontype_arg): Use tsubst_copy_and_build, not ++ build_expr_from_tree. ++ (tsubst_baselink): New function. ++ (tsubst_qualified_id): Likewise. ++ (tsubst_copy): Use them. Remove support for METHOD_CALL_EXPR. ++ (tsubst_expr): Adjust call to lookup_qualified_name. ++ (tsubst_copy_and_build): Handle SCOPE_REFs specially. Adjust ++ handling of CALL_EXPRs. ++ (value_dependent_expression_p): Use INTEGRAL_OR_ENUMERATION_TYPE_P. ++ * rtti.c (get_tinfo_decl_dynamic): Use non_reference. ++ * search.c (check_final_overrider): Likewise. ++ * semantics.c (check_accessibility_of_qualified_id): New function. ++ (finish_qualified_object_call_expr): Remove. ++ * typeck.c (target_type): Use non_reference. ++ (cxx_sizeof_or_alignof_type): Likewise. ++ (dubious_conversion_warnings): Likewise. ++ (convert_for_initialization): Likewise. ++ (non_reference): New function. ++ ++2003-07-07 Kaveh R. Ghazi ++ ++ * decl.c (print_binding_level, print_other_binding_stack, ++ print_binding_stack): Merge uses of HOST_PTR_PRINTF with adjacent ++ stdio calls. ++ * ptree.c (cxx_print_decl, cxx_print_binding): Likewise. ++ ++2003-07-07 Andreas Jaeger ++ ++ * friend.c: Convert to ISO C90 prototypes. ++ ++ * Make-lang.in ($(srcdir)/cp/cfns.h): Use ANSI-C as output ++ language. ++ * cfns.h: Regenerate. ++ ++ * typeck.c: Convert remaining prototypes to ISO C90. ++ * search.c: Likewise. ++ ++ * decl2.c (build_expr_from_tree): Convert prototype to ISO C90. ++ * semantics.c (expand_or_defer_fn): Likewise ++ * mangle.c (discriminator_for_string_literal): Likewise. ++ * g++spec.c (lang_specific_driver): Likewise. ++ ++ * search.c (lookup_base_r): Remove unused variable. ++ ++2003-07-07 Nathan Sidwell ++ ++ * semantics.c: (genrtl_try_block) Adjust emit_line_note ++ calls. ++ ++2003-07-07 Andreas Jaeger ++ ++ * search.c (lookup_base_r): Remove unused variable. ++ ++2003-07-06 Michael Chastain ++ ++ PR debug/10055 ++ * lex.c (cxx_init): Call push_srcloc and pop_srcloc rather than ++ assigning to input_filename directly. ++ ++2003-07-06 Kazu Hirata ++ ++ * call.c: Fix comment formatting. ++ * class.c: Likewise. ++ * cp-tree.h: Likewise. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * error.c: Likewise. ++ * method.c: Likewise. ++ * name-lookup.c: Likewise. ++ * parser.c: Likewise. ++ * pt.c: Likewise. ++ * rtti.c: Likewise. ++ * search.c: Likewise. ++ * typeck.c: Likewise. ++ ++2003-07-06 Mark Mitchell ++ ++ PR c++/11345 ++ * search.c (lookup_base_r): Remove is_non_public and ++ within_current_scope parameters. Remove other dead code. ++ (lookup_base): Adjust call to lookup_base_r. ++ (adjust_result_of_qualified_name_lookup): Improve comment. ++ * semantics.c (finish_call_expr): Use maybe_dummy_object. ++ ++2003-07-06 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_HANDLE_FILENAME, ++ LANG_HOOKS_MISSING_ARGUMENT): Override. ++ ++2003-07-05 Mark Mitchell ++ ++ PR c++/11431 ++ * typeck.c (build_static_cast): Check for reference conversions ++ earlier. ++ ++2003-07-04 Mark Mitchell ++ ++ * cp-tree.h (perform_integral_promotions): Declare. ++ * call.c (build_addr_func): Use decay_conversion. ++ (convert_arg_to_ellipsis): Likewise. Remove misleading comment. ++ (convert_for_arg_passing): Use perform_integral_promotions. ++ * cvt.c (build_expr_type_conversion): Use decay_conversion. ++ (type_promotes_to): Do not return a cv-qualified type. ++ * decl.c (grok_reference_init): Fix formatting. ++ (get_atexit_node): Use decay_conversion. ++ (build_enumerator): Use perform_integral_promotions. ++ * init.c (build_vec_init): Use decay_conversion. ++ * semantics.c (finish_expr_stmt): Likewise. ++ (finish_switch_cond): Use perform_integral_promotions. ++ * typeck.c (default_conversion): Likewise. ++ (perform_integral_promotions): New function. ++ (build_indirect_ref): Use decay_conversion. ++ (build_array_ref): Use perform_integral_promotions. ++ (convert_arguments): Use decay_conversion. ++ (build_unary_op): Use perform_integral_promotions. ++ (build_c_cast): Use decay_conversion. ++ (build_modify_expr): Likewise. ++ (convert_for_initialization): Likewise. ++ * typeck2.c (build_x_arrow): Likewise. ++ ++2003-07-04 Kazu Hirata ++ ++ * call.c: Fix comment typos. ++ * class.c: Likewise. ++ * cp-tree.h: Likewise. ++ * cvt.c: Likewise. ++ * decl2.c: Likewise. ++ * decl.c: Likewise. ++ * init.c: Likewise. ++ * mangle.c: Likewise. ++ * parser.c: Likewise. ++ * pt.c: Likewise. ++ * search.c: Likewise. ++ * semantics.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ ++2003-07-04 Zack Weinberg ++ ++ * parser.c (cp_lexer_read_token): No need to handle string ++ constant concatenation. ++ ++2003-07-03 Kaveh R. Ghazi ++ ++ * cp-tree.h (GCC_DIAG_STYLE, ATTRIBUTE_GCC_CXXDIAG): Define. ++ (cp_error_at, cp_warning_at, cp_pedwarn_at): Mark with ++ ATTRIBUTE_GCC_CXXDIAG. ++ ++2003-07-03 Mark Mitchell ++ ++ * call.c (build_addr_func): Handle bound pointers-to-members. ++ (build_method_call): Do not call resolve_offset_ref. ++ (implicit_conversion): Likewise. ++ (resolve_scoped_fn_name): Use finish_non_static_data_member, not ++ resolve_offset_ref. ++ (resolve_args): Do not call resolve_offset_ref. ++ (build_conditional_expr): Likewise. ++ (build_new_method_call): Likewise. ++ * cp-tree.def (OFFSET_REF): Update documentation. ++ * cvt.c (cp_convert_to_pointer): Update handling of conversions from ++ pointers to members to pointers. ++ (ocp_convert): Do not call resolve_offset_ref. ++ (convert_to_void): Likewise. ++ (build_expr_type_conversion): Likewise. ++ * decl2.c (delete_sanity): Likewise. ++ * init.c (resolve_offset_ref): Simplify greatly. ++ (build_vec_delete): Do not call resolve_offset_ref. ++ * parser.c (cp_parser_postfix_expression): Call resolve_offset_ref ++ if appropriate. ++ (cp_parser_unary_expression): Use ++ cp_parser_simple_cast_expression. ++ (cp_parser_delete_expression): Likewise. ++ (cp_parser_cast_expression): Likewise. ++ (cp_parser_pm_expression): Use cp_parser_binary_op. ++ (cp_parser_simple_cast_expression): New function. ++ * rtti.c (build_dynamic_cast_1): Do not call resolve_offset_ref. ++ * semantics.c (finish_increment_expr): Likewise. ++ (finish_typeof): Likewise. ++ * tree.c (lvalue_p_1): Do not handle OFFSET_REF. ++ * typeck.c (require_complete_type): Do not handle OFFSET_REFs. ++ (decay_conversion): Do not call resolve_offset_ref. ++ (finish_class_member_access_expr): Likewise. ++ (convert_arguments): Likewise. ++ (build_x_binary_op): Handle DOTSTAR_EXPR. ++ (condition_conversion): Do not call resolve_offset_ref. ++ (unary_complex_lvalue): Likewise. ++ (build_static_cast): Likewise. ++ (build_reinterpret_cast): Likewise. ++ (build_const_cast): Likewise. ++ (build_c_cast): Likewise. ++ (build_modify_expr): Likewise. ++ (convert_for_assignment): Likewise. ++ (convert_for_initialization): Likewise. ++ * typeck2.c (build_x_arrow): Likewise. ++ (build_m_component_ref): Simplify. ++ ++ * call.c (build_scoped_method_call): Use convert_to_void. ++ (build_method_call): Likewise. ++ * class.c (check_field_decls): Remove dead code. ++ * cvt.c (convert_from_reference): Remove OFFSET_TYPE handling. ++ * decl2.c (grok_array_decl): Remove dead code. ++ (arg_assoc_type): Avoid relying on POINTER_TYPE over OFFSET_TYPE ++ as pointer-to-member representation. ++ * init.c (build_offset_ref): Tidy. ++ (build_vec_delete_1): Use convert_to_void. ++ * mangle.c (write_type): Avoid relying on POINTER_TYPE over OFFSET_TYPE ++ as pointer-to-member representation. ++ ++2003-07-03 Nathan Sidwell ++ ++ PR c++/9162 ++ * decl.c (grokdeclarator): Return friend decls, not ++ void_type_node. ++ * decl2.c (grokfield): Alter friend decl check. ++ * parser.c (struct cp_parser): Document default_arg chain on ++ unparsed_functions_queue. ++ (cp_parser_save_default_args): New. ++ (cp_parser_init_declarator, cp_parser_function_definition, ++ cp_parser_member_declaration): Call it. ++ (cp_parser_class_specifier): Remove unused variable. Alter ++ processing of unparsed_functions_queue. ++ ++2003-07-03 Kaveh R. Ghazi ++ ++ * class.c (add_method, check_field_decl): Fix format specifier. ++ * decl.c (duplicate_decls, pushdecl, check_goto, ++ fixup_anonymous_aggr, maybe_commonize_var, grokdeclarator, ++ start_enum): Likewise. ++ * decl2.c (ambiguous_decl): Likewise. ++ * pt.c (redeclare_class_template): Likewise. ++ ++2003-07-02 Nathan Sidwell ++ ++ PR c++/10219 ++ * pt.c (type_unification_real): Don't unify exprs of error type. ++ * tree.c (error_type): Don't die on error_type. ++ ++ PR c++/9779 ++ * decl2.c (arg_assoc_class): Don't die on NULL type. ++ * typeck.c (type_unknown_p): Don't die on untyped expressions. ++ ++2003-07-01 Mark Mitchell ++ ++ PR c++/6949 ++ * decl2.c (grokfield): Create TEMPLATE_DECLs for methods in local ++ classes. ++ ++2003-07-01 Kaveh R. Ghazi ++ ++ * error.c (locate_error): %P takes an `int', not a `tree'. ++ ++2003-07-02 Jan Hubicka ++ ++ * decl2.c (defer_fn): Set DECL_DEFER_OUTPUT. ++ (finish-file): Do not process function with DECL_DEFER_OUTPUT clear; ++ clear DECL_DEFER_OUTPUT once function is processed; avoid flags ++ massaging. ++ ++ * cp-tree.h (DECL_NEEDED_P): Support unit-at-a-time ++ (expand_or_defer_fn): Declare. ++ (lower_function): Declare. ++ * decl.c (start_cleanup_fn): Use expand_or_defer_fn. ++ * decl2.c: Include cgraph.h and varpool.h ++ (maybe_emit_vtables): Make explicit instantations as needed. ++ (mark_member_pointers, lower_function): New functions. ++ (finish_file): Do unit-at-a-time. ++ * method.c (synthesize_method): Use expand_or_defer_fn. ++ * optimize.c (maybe_clone_body): Use expand_or_defer_fn. ++ * parser.c (cp_parser_function_definition_after_decl): Use ++ expand_or_defer_fn. ++ * pt.c (instantiate_decl): Likewise. ++ * semantics.c: Include cgraph.h ++ (expand_or_defer_fn): Break out from ... ++ (expand_body): ... here; deal with unit-at-a-time. ++ * cp-lang.c (LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION, ++ LANG_HOOKS_CALLGRAPH_LOWER_FUNCTION): Define. ++ ++2003-07-01 Mark Mitchell ++ ++ * call.c (resolve_scoped_fn_name): Return error_mark_node for ++ erroneous cases. ++ ++2003-07-01 Mark Mitchell ++ ++ PR c++/11149 ++ * call.c (resolve_scoped_fn_name): Check that the qualifying scope ++ is a class type. ++ ++2003-07-01 Giovanni Bajo ++ ++ PR c++/8046 ++ * error.c (dump_decl): Handle BIT_NOT_EXPR as ++ pseudo destructor calls. ++ ++2003-07-01 Nathan Sidwell ++ ++ * cp-tree.h (define_label): Replace filename and lineno ++ arguments with a location_t. ++ * decl.c (pop_label): Adjust define_label call. ++ (define_label): Replace filename and lineno arguments with a ++ location_t. ++ * semantics.c (finish_label): Adjust define_label call. ++ ++2003-07-01 Mark Mitchell ++ ++ PR c++/9559 ++ * decl2.c (grokfield): Do not build NOP_EXPRs around the ++ error_mark_node. ++ ++2003-06-30 Neil Booth ++ ++ * Make-lang.in: Update. ++ * cp-lang.c (c_language): Define. ++ (LANG_HOOKS_INIT_OPTIONS): Use common hook. ++ * cp-tree.h (cxx_init_options): Remove. ++ * lex.c: Don't include diagnostic.h. ++ (cxx_init_options): Remove. ++ ++2003-06-30 Giovanni Bajo ++ ++ PR c++/4933 ++ * error.c (dump_expr): Support correctly the COMPOUND_EXPR ++ tree generated within a template. Use dump_expr to dump an ++ expression sizeof. ++ ++2003-06-30 Giovanni Bajo ++ ++ * mangle.c (write_expression): Exit gracefully when trying to ++ mangle a CALL_EXPR. ++ ++2003-06-30 Giovanni Bajo ++ ++ PR c++/10750 ++ * parser.c (cp_parser_primary_expression): A VAR_DECL with a ++ (value- or type-) dependent expression as DECL_INITIAL is a ++ valid constant-expression (at parser time). ++ ++2003-06-30 Giovanni Bajo ++ ++ PR c++/11106 ++ * error.c (dump_decl): Call dump_decl to dump the DECL_NAME for a ++ USING_DECL, instead of print_tree_identifier. ++ ++2003-06-29 Gabriel Dos Reis ++ ++ * cp-tree.h (language_to_string): Adjust declaration. ++ * dump.c (cp_dump_tree): Adjust usage. ++ * error.c (dump_char): Use output_formatted_scalar. Tidy. ++ (parm_to_string): Lose unused parameter. Tidy. ++ (expr_to_string): Likewise. ++ (code_to_string): Likewise. ++ (language_to_string): Likewise. ++ (op_to_string): Likewise. ++ (assop_to_string): Likewise. ++ (digit_buffer): Remove. ++ (dump_type): Format builtin vector type as __vector__. ++ ++2003-06-29 Gabriel Dos Reis ++ ++ * error.c (print_integer): Remove. ++ (dump_type_suffix): Adjust. ++ (dump_expr): Likewise. ++ ++2003-06-28 Nathan Sidwell ++ ++ * error.c (print_instantiation_partial_context): Take a ++ location_t. ++ (print_instantiation_full_context): Adjust. ++ (print_instantiation_context): Adjust. ++ ++ * cp-tree.h (cp_line_of, cp_file_of): Remove. ++ * error.c (cp_line_of, cp_file_of): Merge into ... ++ (location_of): ... here. Make static, return a location_t. ++ (cp_error_at, cp_warning_at, cp_pedwarn_at): Adjust. ++ ++2003-06-28 Nathan Sidwell ++ ++ PR c++/10784 ++ * call.c (joust): Move warn_conversion check outwards. ++ ++2003-06-27 Zack Weinberg ++ ++ * decl.c (build_typename_type) ++ * mangle.c (write_template_template_arg) ++ * parser.c (cp_parser_scope_through_which_access_occurs) ++ * pt.c (push_access_scope_real, push_access_scope, pop_access_scope) ++ * repo.c (get_base_filename) ++ * semantics.c (maybe_convert_cond): ++ Mark the definition static, matching the forward declaration. ++ ++2003-06-27 Mark Mitchell ++ ++ PR c++/10468 ++ * pt.c (tsubst): Handle qualified TYPEOF_TYPEs correctly. ++ ++2003-06-27 Mark Mitchell ++ ++ PR c++/10796 ++ * decl.c (finish_enum): Implement DR377. ++ ++ * decl.c (cp_finish_decl): Don't make variables with reference ++ type readonly while they are being initialized. ++ ++2003-06-26 Mark Mitchell ++ ++ PR c++/11332 ++ * typeck.c (build_static_cast): Avoid returning expressions with ++ reference type. ++ ++2003-06-26 Nathan Sidwell ++ ++ * call.c (build_op_delete_call): Use strip_array_call. Correct ++ error message to say 'delete' or 'delete[]'. ++ ++2003-06-26 Giovanni Bajo ++ ++ PR c++/8266 ++ * pt.c (check_explicit_specialization): When looking up a ++ template function from an identifier outside class-scope, bind ++ it to CP_DECL_CONTEXT. ++ ++2003-06-25 Mark Mitchell ++ ++ PR c++/10990 ++ * search.c (lookup_base_r): Rely on accessible_p, rather than ++ trying to emulate that logic here. ++ ++ PR c++/10931 ++ * call.c (convert_like): Pass issue_conversion_warnings. ++ (convert_like_with_context): Likewise. ++ (convert_like_real): Add issue_conversion_warnings parameter. ++ (perform_direct_initialization_if_possible): New function. ++ * cp-tree.h (perform_direct_initialization_if_possible): Declare it. ++ * typeck.c (check_for_casting_away_constness): New function. ++ (build_static_cast): Rewrite. ++ ++2003-06-24 Nathan Sidwell ++ ++ * call.c (enforce_access): Assert we get a binfo. ++ (build_op_delete_call): Pass a binfo to ++ perform_or_defer_access_check. ++ * class.c (alter_access): Likewise. ++ * decl.c (make_typename_type): Likewise. ++ (make_unbound_class_template): Likewise. ++ * lex.c (do_identifier): Likewise. ++ * method.c (hack_identifier): Likewise. ++ * parser.c (cp_parser_lookup_name): Likewise. ++ * search.c (lookup_member): Likewise. Move IDENTIFIER_CLASS_VALUE ++ test. ++ * semantics.c (finish_non_static_data_member): Likewise. ++ (perform_or_defer_access_check): Expect a binfo. ++ * typeck.c (comptypes): Expect types. ++ ++ * mangle.c (find_substitution): Don't pass a non-type to same_type_p ++ * friend.c (make_friend_class): Likewise. ++ * pt.c (check_default_tmpl_args): Likewise. ++ (lookup_template_class): Likewise. ++ ++2003-06-24 Jan Hubicka ++ ++ * method.c (thunk_labelno): Move outside ifdef block to make garbage ++ collector happy. ++ ++2003-06-24 Jan Hubicka ++ ++ * class.c (build_vtable): Make vtables. ++ * cp-tree.h (DECL_VTABLE_OR_VTT_P): New macro. ++ * decl2.c (output_vtable_inherit): Rename to ... ++ (prepare_assemble_variable): ... this one; change interface. ++ (maybe_emit_vtables): Do not call output_vtable_inherit. ++ * cp-lang.c (LANG_HOOKS_PREPARE_ASSEMBLE_VARIABLE): Define. ++ * cp-tree.h (prepare_assemble_variable): New. ++ ++2003-06-23 Andrew Pinski ++ ++ * method.c: add prototype for make_alias_for_thunk. ++ (thunk_labelno, make_alias_for_thunk): only define ++ if ASM_OUTPUT_DEF is defined. ++ ++2003-06-23 Jakub Jelinek ++ ++ * method.c (thunk_labelno): New variable. ++ (make_alias_for_thunk): New function. ++ (use_thunk): Use it if defined ASM_OUTPUT_DEF. Put the thunk ++ into the same section as the function it is calling. ++ Include gt-cp-method.h. ++ * Make-lang.in (gt-cp-method.h): Depend on s-gtype. ++ (cp/method.o): Depend on gt-cp-method.h. ++ * config-lang.in (gtfiles): Add $(srcdir)/cp/method.c. ++ ++2003-06-23 Jan Hubicka ++ ++ * decl.c (register_dtor_fn): Mark cleanup as used. ++ * decl2.c (mark_vtable_entries): Skip nops. ++ * rtti.c (get_tinfo_ptr): Mark tinfo as used. ++ (build_dynamic_cast_1): Likewise. ++ (tinfo_base_init): Likewise. ++ (emit_tinfo_decl): Likewise. ++ ++2003-06-23 Jakub Jelinek ++ ++ * mangle.c (hash_type): Val is the TREE_LIST itself, not a pointer ++ to it. ++ ++2003-06-21 Gabriel Dos Reis ++ ++ PR c++/10784 ++ * call.c (joust): Warn about choosing conversion sequence only if ++ -Wconversion. ++ ++2003-06-21 Gabriel Dos Reis ++ ++ PR c++/10864 ++ * call.c (op_error): Tidy. ++ * error.c (dump_expr): Properly format 'T()' when T is an ++ aggregate type. ++ ++2003-06-21 Gabriel Dos Reis ++ ++ PR c++/10915 ++ * decl.c (grok_op_properties): Warn possible confusing conversion ++ only if -Wconversion. ++ ++2003-06-20 Mark Mitchell ++ ++ PR c++/10749 ++ * parser.c (cp_parser_class_head): See through dependent names ++ when parsing a class-head. ++ ++ PR c++/10845 ++ * pt.c (try_class_unification): Correct handling of member class ++ templates. ++ ++2003-06-20 Nathan Sidwell ++ ++ * semantics.c (genrtl_finish_function): Adjust ++ expand_function_end call. ++ ++2003-06-19 Mark Mitchell ++ ++ PR c++/10939 ++ * pt.c (tsubst_decl): Do not try to substitute into non-dependent ++ functions. ++ (value_dependent_expression_p): Correct logic for FUNCTION_DECLs. ++ ++ PR c++/9649 ++ * cp-tree.h (pushdecl_class_level): Change prototype. ++ (push_class_level_binding): Likewise. ++ * decl.c (add_binding): Reject duplicate static data members. ++ (pushdecl_class_level): Return a value indicating whether or not ++ the binding was valid. ++ (push_class_level_binding): Likewise. ++ * semantics.c (finish_member_declaration): Don't keep invalid ++ declarations. ++ ++ PR c++/11041 ++ * call.c (initialize_reference): Do not use cp_finish_decl to emit ++ temporary variables. ++ * cp-tree.h (static_aggregates): Declare. ++ (pushdecl_top_level_and_finish): Likewise. ++ * decl.c (pushdecl_top_level_1): New function. ++ (pushdecl_top_level): Use it. ++ (pushdecl_top_level_and_finish): New function. ++ (initialize_local_var): Remove redundant code. ++ (cp_finish_decl): Remove support for RESULT_DECLs. Don't check ++ building_stmt_tree. ++ * decl.h (static_aggregates): Remove. ++ * decl2.c (get_guard): Use pushdecl_top_level_and_finish. ++ * rtti.c (get_tinfo_decl): Use pushdecl_top_level_and_finish. ++ (tinfo_base_init): Likewise. ++ ++2003-06-19 Matt Austern ++ ++ PR c++/11228 ++ * init.c (build_zero_init): Assert that number of array elements ++ is an integer constant. ++ (build_default_init) Don't use build_zero_init for arrays with ++ variable number of elements. ++ ++2003-06-19 Andreas Jaeger ++ ++ * cp-tree.h: Remove duplicated declarations. ++ ++2003-06-18 Nathanael Nerode ++ ++ * pt.c: Convert to ISO C. ++ * semantics.c: Convert to ISO C. ++ ++2003-06-18 Nathan Sidwell ++ ++ * cp-tree.h (comp_except_specs, compparms, cp_has_mutable_p, ++ at_least_as_qualified_p, more_qualified_p): Return bool. ++ * typeck.c: ANSIFY function definitions. ++ (comp_array_types): Take redeclaration bool parameter. ++ (comptypes): Rearrange STRICT handling. ++ (at_least_as_qualified_p, more_qualified_p, ++ comp_cv_qualification): Cache cv quals. ++ (compparms): Rearrange loop. ++ ++2003-06-18 Nathan Sidwell ++ ++ * cp-tree.h (COMPARE_RELAXED): Rename to ... ++ (COMPARE_DERIVED): ... here. Adjust comment. ++ (resolve_typename_type_in_current_instantiation): Remove. ++ (cp_tree_equal, comptypes): Return a bool. ++ * cvt.c (convert_to_reference): Adjust comptypes call. ++ * pt.c (template_args_equal, unify,): Adjust cp_tree_equal call. ++ (resolve_typename_type_in_current_instantiation): Remove. ++ * tree.c (cp_tree_equal): Return bool. Cope with TEMPLATE_DECLs and ++ IDENTIFIER_NODEs. Abort if undeciderable. Adjust recursive ++ calls. Refactor code. ++ * typeck.c (comp_array_types): Return bool. Lose callback. ++ parameter. Adjust cp_tree_equal calls. ++ (comptypes): Return bool. Adjust strict handling. Remove relaxed ++ enumeration and java type handling. Deal with typename types here. ++ Adjust recursive and cp_tree_equals calls. Adjust base and derived ++ checking. ++ (comp_target_types): Remove unreachable code. Adjust ++ same_or_base_type_p calls. ++ (ptr_reasonably_similar): Adjust base and derived check. ++ ++ * typeck.c (maybe_warn_about_returning_address_of_local): Remove ++ unused calculation. ++ (check_return_expr): Adjust error messages. ++ * cp-tree.def (SCOPE_REF): Correct comment. ++ ++2003-06-17 Mark Mitchell ++ ++ * mangle.c (mangle_conv_op_name_for_type): Correct sprintf format ++ string again. ++ ++2003-06-17 Robert Abeles ++ ++ * optimize.c (dump_function): Form complete flag name by ++ prefixing 'fdump-' to string returned by dump_flag_name(). ++ ++2003-06-17 Mark Mitchell ++ ++ * mangle.c (mangle_conv_op_name_for_type): Correct sprintf format ++ string. ++ ++2003-06-17 Jason Merrill ++ ++ PR c++/10929 ++ * decl.c (grokfndecl): Don't mark a function inline for ++ -finline-functions if it isn't defined. ++ ++2003-06-17 Mark Mitchell ++ ++ PR c++/10712 ++ * class.c (handle_using_decl): Robustify. ++ ++ PR c++/11105 ++ * cp-tree.h (DECL_CONV_FN_TYPE): New method. ++ * mangle.c (struct globals): Remove internal_mangling_p. ++ (write_unqualified_name): Use DECL_CONV_FN_TYPE. ++ (write_template_parm): Don't write out the level number. ++ (conv_type_names): New variable. ++ (hash_type): New function. ++ (compare_type): Likewise. ++ (mangle_conv_op_name_for_type): Don't try to mangle conversion ++ operator names. ++ * search.c (lookup_conversion_operator): New function. ++ (lookup_fnfields_1): Use it. ++ ++2003-06-17 Andreas Jaeger ++ ++ * except.c: Remove duplicate declaration of push_eh_cleanup. ++ ++ * call.c: Remove extra declaration of inhibit_warnings. ++ ++2003-06-16 Nathanael Nerode ++ ++ 2003-06-16 Jens-Michael Hoffmann ++ * mangle.c: Convert to ISO C. ++ ++2003-06-16 Kaveh R. Ghazi ++ ++ * cp/decl.c, cp/pt.c, cp/search.c, cp/tree.c: Don't use the PTR ++ macro. ++ ++2003-06-16 Nathanael Nerode ++ ++ * tree.c: Convert to ISO C. ++ ++2003-06-16 Kazu Hirata ++ ++ * cp-tree.h: Follow spelling conventions. ++ * mangle.c: Likewise. ++ * method.c: Likewise. ++ * parser.c: Likewise. ++ ++2003-06-14 Nathan Sidwell ++ ++ * decl.c (start_function): Adjust init_function_start call. ++ * method.c (use_thunk): Likewise. ++ * semantics.c (genrtl_start_function): Likewise. ++ ++2003-06-14 Neil Booth ++ ++ * Make-lang.in: Remove c-options.o. ++ ++2003-06-13 Nathanael Nerode ++ ++ * lex.c: Convert to ISO C. ++ ++ 2003-05-19 Jens-Michael Hoffmann ++ * init.c: removes use of PARAMS macro. Use ISO style function ++ declarations. (Not copyright-significant change.) ++ ++ * rtti.c: Remove PARAMS. ++ ++ * typeck2.c: Convert to ISO C. ++ ++2003-06-12 Mark Mitchell ++ ++ PR c++/10635 ++ * typeck.c (build_c_cast): Check that the destination type is ++ complete. ++ ++2003-06-11 Mark Mitchell ++ ++ PR c++/10432 ++ * cp-tree.h (finish_declarator): Remove. ++ * decl.c (cp_finish_decl): Make sure to pop_nested_class even for ++ erroneous declarations. ++ * semantics.c (finish_declarator): Remove. ++ ++2003-06-11 Roger Sayle ++ ++ * decl2.c (generate_ctor_or_dtor_function): Avoid expanding a ++ global static constructor/destructor if it will be empty, i.e. ++ either doesn't call any ctors/dtors or only calls pure or const ++ ctors/dtors. ++ ++2003-06-11 Mark Mitchell ++ ++ * mangle.c (tm_p.h): Include it. ++ * Make-lang.in (cp/mangle.o): Depend on $(TM_P_H). ++ ++ PR c++/11131 ++ * tree.c (cp_cannot_inline_fn): Check for "inline" before ++ instantiation. ++ ++2003-06-10 Jason Merrill ++ ++ PR c++/10968 ++ * pt.c (mark_decl_instantiated): Clear DECL_COMDAT. ++ ++2003-06-10 Andrew Pinski ++ ++ * decl.c (start_cleanup_fn): Move static 'counter' out, mark with GTY. ++ (start_cleanup_cnt): New. ++ ++2003-06-10 Mark Mitchell ++ ++ PR c++/11131 ++ * cp-tree.h (template_for_substitution): Declare. ++ * decl2.c (mark_used): Use it when figuring out whether or not a ++ function is inline. ++ * pt.c (template_for_substitution): Give it external linkage. ++ * tree.c (cp_cannot_inline_tree_fn): Instantiate as early as ++ possible. ++ ++2003-06-09 Zack Weinberg ++ ++ PR 8861 ++ * mangle.c (write_real_cst): New function. Implement ++ ABI-compliant mangling of floating-point literals when ++ -fabi-version>=2; provide backward compatibility with 3.3 when ++ -fabi-version=1 (with warning). Clarify commentary. ++ (write_template_arg_literal): Use write_real_cst. ++ ++2003-06-07 Andreas Jaeger ++ ++ * cp/decl.c (xref_tag): Remove undefined macro NONNESTED_CLASSES. ++ ++2003-06-07 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_DECODE_OPTON): Drop. ++ (LANG_HOOKS_HANDLE_OPTION): Override. ++ * cp-tree.h (cxx_init_options): Update. ++ * lex.c (cxx_init_options): Update. ++ ++2003-06-05 Jan Hubicka ++ ++ * Make-lang.in: Add support for stageprofile and stagefeedback ++ ++2003-06-04 J"orn Rennecke ++ ++ * decl.c (grokdeclarator): Error_mark_node in, error_mark_node out. ++ ++2003-06-04 Andreas Jaeger ++ ++ * g++spec.c (lang_specific_driver): Remove ALT_LIBM usage. ++ ++2003-06-03 Jason Merrill ++ ++ * cp/cp-tree.h (CP_AGGREGATE_TYPE_P): Accept vectors. ++ ++ * cp/decl.c (reshape_init): Handle vectors. ++ ++ * testsuite/g++.dg/init/array10.C: New. ++ ++2003-06-03 Kriang Lerdsuwanakij ++ ++ PR c++/10940 ++ * pt.c (check_explicit_specialization): Check for 'static' ++ earlier. ++ ++2003-05-31 Diego Novillo ++ ++ * class.c (dump_array): Call CONSTRUCTOR_ELTS to access ++ the operand of a CONSTRUCTOR node. ++ ++2003-05-31 Gabriel Dos Reis ++ ++ * decl.c (cp_binding_level::this_entity): Rename from this_class. ++ (cxx_scope_descriptor): New function. ++ (cxx_scope_debug): Likewise. ++ (push_binding_level): Use it. ++ (pop_binding_level): Likewise. ++ (suspend_binding_level): Likewise. ++ (resume_binding_level): Likewise. ++ (pushlevel_class): Adjust use of this_class. ++ (pushtag): Likewise. ++ (lookup_name_real): Likewise. ++ (global_scope_name): New variable. ++ (initialize_predefined_identifiers): Initialize it. ++ (push_namespace): Use it. ++ (make_cxx_scope): New function. ++ (pushlevel): Use it. ++ (pushlevel_class): Likewise. ++ (push_binding_level): Simplify. Loose the last two arguments. ++ (make_binding_level): Remove. ++ (initial_push__namespace_scope): New function. ++ (push_namespace): Use it. Simplify. ++ (cxx_init_decl_processing): Likewise. ++ (declare_namespace_level): Remove. ++ ++2003-05-31 Kriang Lerdsuwanakij ++ ++ PR c++/10956 ++ * pt.c (instantiate_decl): Don't use full template arguments if ++ we are dealing with specializations. ++ ++2003-05-29 Gabriel Dos Reis ++ ++ * decl.c (ENABLE_SCOPE_CHECKING): Rename from DEBUG_BINDING_LEVELS. ++ (binding_depth): Unconditionally define. ++ (is_class_level): Likewise. ++ (indent): Likewise. Take an indenting parameter. ++ (push_binding_level): Remove conditional definittion. ++ (pop_binding_level): Likewise. ++ (suspend_binding_level): Likewise. ++ (resume_binding_level): Likewise. ++ (pushlevel): Likewise. ++ (pushlevel_class): Likewise. ++ (poplevel_class): Likewise. ++ (pop_everything): Likewise. ++ ++2003-05-27 Gabriel Dos Reis ++ ++ * name-lookup.h (global_scope_p): New macro. ++ * decl.c (pop_binding_level): Use it. Don't refer directly to ++ global_binding_level. ++ (suspend_binding_level): Likewise. ++ (global_bindings_p): Likewise. ++ (print_other_binding_stack): Likewise. ++ (print_binding_stack): Likewise. ++ (maybe_push_to_top_level): Likewise. ++ (pushdecl_namespace_level): Likewise. ++ (cxx_init_decl_processing): Likewise. ++ (start_decl): Likewise. ++ (cp_finish_decl): Likewise. ++ (start_function): Likewise. ++ (global_binding_level): Remove. ++ ++2003-05-25 Kriang Lerdsuwanakij ++ ++ * parser.c (cp_parser_explicit_instantiation): Restore old ++ access before template instantiation. ++ ++2003-05-23 Geoffrey Keating ++ ++ * lang-specs.h: Use -o to specify preprocessor's output file. ++ Make -no-integrated-cpp work when building PCH files. ++ ++2003-05-23 Kriang Lerdsuwanakij ++ ++ PR c++/10682 ++ * pt.c (instantiate_class_template): Use DECL_ARTIFICIAL to ++ check for implicitly created typedef to an enum. ++ ++2003-05-21 Jason Merrill ++ ++ * init.c (build_vec_delete): Copy the address into a temporary ++ variable before calling build_vec_delete_1. ++ * decl2.c (delete_sanity): Don't call stabilize_reference. ++ ++2003-05-21 Nathan Sidwell ++ ++ * pt.c (register_specialization): Update the decl's location, ++ if necessary. ++ (check_explicit_specialization): Likewise. ++ ++2003-05-20 Kaveh R. Ghazi ++ ++ * error.c (dump_expr): Use HOST_WIDE_INT_PRINT_DOUBLE_HEX. ++ ++2003-05-21 Danny Smith ++ ++ PR c++/9738 ++ * decl.c (duplicate_decls): Re-invoke make_decl_rtl ++ if the old decl had instantiated DECL_RTL. ++ (Base on Richard Henderson 2003-05-13 patch to c-decl.c). ++ ++2003-05-19 Matt Austern ++ ++ * lang-options.h: Document -Wno-invalid-offsetof ++ * typeck.c (build_class_member_access_expr): Don't complain about ++ (Foo *)p->x for non-POD Foo if warn_invalid_offset is zero. ++ ++2003-05-18 Andrew Pinski ++ ++ * name-lookup.c (free_binding_entry): fix where the GTY markers are. ++ (binding_entry_make): Make entry->chain NULL after getting an entry. ++ fix the spelling of chain in a comment. ++ (binding_table_free): speed up by having temporary variable. ++ (binding_table_new): set table->chain to be NULL after allocating ++ a table. ++ (cxx_binding_make): use gcc_alloc instead of ggc_alloc_cleared and set ++ binding->previous to NULL after getting an binding for speed. ++ ++2003-05-18 Gabriel Dos Reis ++ ++ * cp-tree.h (struct lang_type_class): Replace data member tags ++ with hash-table nested_udts. ++ (CLASSTYPE_NESTED_UTDS): Rename from CLASSTYPE_TAGS. ++ * class.c (unreverse_member_declarations): Don't touch ++ CLASSTYPE_TAGS. ++ (pushclass): Use cxx_remember_type_decls. ++ * decl.c (struct cp_binding_level): Replace data member tags with ++ hash-table type_decls. ++ (pop_binding_level): Handle level->type_decls. ++ (kept_level_p): Adjust. ++ (poplevel): Remove unused local variable. ++ (bt_print_entry): New function. ++ (print_binding_level): Use it. ++ (push_namespace): Build current_binding_level->type_decls. ++ (maybe_process_template_type_declaration): Adjust. ++ (pushtag): Likewise. ++ (clear_anon_tags): Use binding_table_remove_anonymous_types. ++ (gettags): Remove. ++ (cxx_remember_type_decls): Rename from storetags. Adjust. ++ (lookup_tag): Use binding_table_find_anon_type. Tidy. ++ (lookup_tag_reverse): Use binding_table_reverse_maybe_remap. ++ (cxx_init_decl_processing): Build global_binding_level->type_decls. ++ (store_parm_decls): Remove pointless code. ++ * name-lookup.c (free_binding_entry): New variable. ++ (ENTRY_INDEX): New macro. ++ (struct binding_table_s): New datatype. ++ (binding_entry_make): New function. ++ (binding_entry_free): Likewise. ++ (binding_table_construct): Likewise. ++ (binding_table_free): Likewise. ++ (binding_table_new): Likewise. ++ (binding_table_expand): Likewise. ++ (binding_table_insert): Likewise. ++ (binding_table_find): Likewise. ++ (binding_table_find_anon_type): Likewise. ++ (binding_table_reverse_maybe_remap): Likewise. ++ (binding_table_remove_anonymous_types): Likewise. ++ (binding_table_foreach): Likewise. ++ * name-lookup.h (binding_table): New type. ++ (binding_entry): Likewise. ++ (bt_foreach_proc): Likewise. ++ (struct binding_entry_s): New datatype. ++ (SCOPE_DEFAULT_HT_SIZE): New macro. ++ (CLASS_SCOPE_HT_SIZE): Likewise. ++ (NAMESPACE_ORDINARY_HT_SIZE): Likewise. ++ (NAMESPACE_STD_HT_SIZE): Likewise. ++ (GLOBAL_SCOPE_HT_SIZE): Likewise. ++ (binding_table_new): Declare. ++ (binding_table_free): Likewise. ++ (binding_table_insert): Likewise. ++ (binding_table_find_anon_type): Likewise. ++ (binding_table_reverse_maybe_remap): Likewise. ++ (binding_table_remove_anonymous_types): Likewise. ++ (binding_table_foreach): Likewise. ++ (binding_table_find): Likewise. ++ (cxx_remember_type_decls): Likewise. ++ * pt.c (bt_instantiate_type_proc): New function. ++ (do_type_instantiation): Use it. ++ * search.c (lookup_field_r): Use binding_table_find. ++ ++2003-05-18 Kriang Lerdsuwanakij ++ ++ * semantics.c (perform_deferred_access_checks): Don't discard ++ checked access. ++ ++2003-05-17 Kaveh R. Ghazi ++ ++ * error.c (cp_error_at, cp_warning_at, cp_pedwarn_at): Eliminate ++ libiberty VA_ macros, always use stdarg. ++ * rtti.c (create_pseudo_type_info): Likewise. ++ * tree.c (build_min_nt, build_min): Likewise. ++ ++2003-05-16 Kaveh R. Ghazi ++ ++ * ptree.c (cxx_print_type, cxx_print_xnode): Use string ++ concatentation on HOST_WIDE_INT_PRINT_* format specifier to ++ collapse multiple function calls into one. ++ * tree.c (debug_binfo): Likewise. ++ ++2003-05-15 Jason Merrill ++ ++ PR c++/5388 ++ * call.c (conditional_conversion): Don't consider implicit ++ conversions if T2 is a base of T1. ++ * cp-tree.h (DERIVED_FROM_P, UNIQUELY_DERIVED_FROM_P): Make boolean. ++ (ACCESSIBLY_UNIQUELY_DERIVED_P, PUBLICLY_UNIQUELY_DERIVED_P): Likewise. ++ ++ * parser.c (cp_parser_primary_expression): Convert a static data ++ member from reference. ++ ++2003-05-15 Mark Mitchell ++ ++ * call.c (build_op_delete_call): Avoid creating unnecessary types. ++ * class.c (instantiate_type): Remove tests for tf_no_attributes. ++ * cp-tree.h (tsubst_flags_t): Remove tf_no_attributes. ++ (COMPARE_NO_ATTRIBUTES): Remove. ++ * typeck.c (comptypes): Do not check COMPARE_NO_ATTRIBUTES. ++ ++ PR c++/8385 ++ * semantics.c (finish_typeof): Refine type-dependency check. ++ ++2003-05-13 Jason Merrill ++ ++ * typeck.c (build_modify_expr): Don't always stabilize the lhs and ++ rhs. Do stabilize the lhs of a MODIFY_EXPR used on the lhs. ++ ++2003-05-11 Kriang Lerdsuwanakij ++ ++ * method.c (synthesize_method): Call push/pop_deferring_access_checks. ++ ++2003-05-11 Kriang Lerdsuwanakij ++ ++ PR c++/10230, c++/10481 ++ * semantics.c (finish_non_static_data_member): Handle when the ++ non-static member is not from a base of the current class type. ++ ++2003-05-11 Kriang Lerdsuwanakij ++ ++ PR c++/10552 ++ * pt.c (tsubst_copy): Handle TEMPLATE_DECL that is a member class ++ template and has dependent context. ++ ++2003-05-10 Kriang Lerdsuwanakij ++ ++ * pt.c (instantiate_decl): Call push/pop_deferring_access_checks. ++ ++2003-05-10 Kriang Lerdsuwanakij ++ ++ PR c++/9252 ++ * cp-tree.h (saved_scope): Remove check_access field. ++ (tsubst_flags_t): Remove tf_parsing. ++ * decl.c (maybe_push_to_top_level): Don't initialize ++ scope_chain->check_access. ++ (make_typename_type, make_unbound_class_template): Don't use ++ tf_parsing. ++ (register_dtor_fn): Use push/pop_deferring_access_checks ++ instead of scope_chain->check_access. ++ * method.c (use_thunk): Likewise. ++ * parser.c (cp_parser_explicit_instantiation ++ (cp_parser_constructor_declarator_p): Don't call ++ push/pop_deferring_access_checks here. ++ (cp_parser_template_argument, cp_parser_class_name): Don't use ++ tf_parsing. ++ (yyparse): Check flag_access_control. ++ * pt.c (instantiate_class_template): Call ++ push/pop_deferring_access_checks. ++ * semantics.c (push_deferring_access_checks): Propagate ++ dk_no_check. ++ (perform_or_defer_access_check): Make sure basetype_path is ++ a type before comparison. ++ * call.c (build_op_delete_call, build_over_call): Use ++ perform_or_defer_access_check. ++ * class.c (alter_access): Likewise. ++ * init.c (build_offset_ref): Likewise. ++ * lex.c (do_identifier): Likewise. ++ * method.c (hack_identifier): Likewise. ++ * search.c (lookup_member): Likewise. ++ * semantics.c (finish_non_static_data_member): Likewise. ++ (simplify_aggr_init_exprs_r): Use push/pop_deferring_access_checks ++ instead of flag_access_control. ++ ++2003-05-10 Kriang Lerdsuwanakij ++ ++ PR c++/9554 ++ * parser.c (cp_parser_class_name): Remove check_access parameter. ++ All caller adjusted. Update declaration. ++ (cp_parser_lookup_name): Likewise. ++ * semantics.c (push_deferring_access_checks): Change parameter type ++ to enum deferring_kind. All caller adjusted. ++ (resume_deferring_access_checks): Adjust to use new enum. ++ (stop_deferring_access_checks): Likewise. ++ (perform_or_defer_access_check): Likewise. ++ * cp-tree.h (deferring_kind): New enum. ++ (deferred_access): Adjust field type. ++ (push_deferring_access_checks): Update declaration. ++ ++2003-05-09 Kriang Lerdsuwanakij ++ ++ PR c++/10555, c++/10576 ++ * pt.c (lookup_template_class): Handle class template with ++ multiple levels of parameters when one of the levels contain ++ errors. ++ ++2003-05-08 Jason Merrill ++ ++ * init.c (build_new_1): Don't reuse a TARGET_EXPR in an ++ expression. Undo some of the recent reorg. ++ ++2003-05-07 Richard Henderson ++ ++ PR c++/10570 ++ * cfns.gperf: Comment out POSIX thread cancellation points, ++ plus abort and raise. ++ * cfns.h: Regenerate. ++ ++2003-05-07 Jason Merrill ++ ++ * call.c (build_conditional_expr): Don't assume that the folded ++ expression has result_type. ++ ++2003-05-06 Kriang Lerdsuwanakij ++ ++ * typeck.c (build_unary_op): Deal with const qualifier in ++ invalid pointer-to-member earlier. ++ ++2003-05-05 Jason Merrill ++ ++ PR c++/9537 ++ * call.c (conditional_conversion): Build an RVALUE_CONV if ++ we're just changing the cv-quals. ++ (build_conditional_expr): Don't call convert to change ++ cv-quals. ++ ++2003-05-05 Kriang Lerdsuwanakij ++ ++ PR c++/10496 ++ * typeck.c (build_unary_op): Don't output const qualifier when ++ output invalid pointer-to-member diagnostics. ++ ++2003-05-05 Kriang Lerdsuwanakij ++ ++ * decl.c: Fix typos. ++ ++2003-05-05 Kriang Lerdsuwanakij ++ ++ PR c++/4494 ++ * decl.c (start_function): Use same_type_p to check return type ++ of main. ++ ++2003-05-03 Zack Weinberg ++ ++ PR c/10604 ++ * cp/typeck.c (build_x_compound_expr): No need to check ++ extra_warnings as well as warn_unused_value. ++ ++2003-05-03 Kriang Lerdsuwanakij ++ ++ PR c++/9364, c++/10553, c++/10586 ++ * decl.c (make_typename_type): Don't crash on illegal code. ++ ++2003-05-03 Nathan Sidwell ++ ++ * class.c (finish_struct): Use location_t and input_location ++ directly. ++ * decl.c (make_label_decl): Likewise. ++ (use_label): Likewise. ++ * decl2.c (warn_if_unknown_interface): Likewise. ++ (start_static_initialization_or_destruction): Likewise. ++ (generate_ctor_or_dtor_function): Likewise. ++ (finish_file): Likewise. ++ * error.c (print_instantiation_full_context): Likewise. ++ * init.c (create_temporary_var): Likewise. ++ * method.c (synthesize_method): Likewise. ++ * parser.c (cp_token): Likewise. ++ (cp_lexer_set_source_position_from_token): Likewise. ++ (cp_lexer_get_preprocessor_token): Likewise. ++ (cp_parser_statement): Likewise. ++ * pt.c (tsubst_friend_function): Likewise. ++ (instantiate_class_template): Likewise. ++ (tsubst_decl): Likewise. ++ (tsubst): Likewise. ++ (instantiate_decl): Likewise. ++ * semantics.c (begin_class_definition): Likewise. ++ (expand_body): Likewise. ++ ++2003-05-01 Nathan Sidwell ++ ++ * class.c (finish_struct): Rename lineno to input_line. ++ * decl.c (push_binding_level, pop_binding_level, ++ suspend_binding_level, resume_binding_level, make_label_decl, ++ use_label, start_function): Likewise. ++ * decl2.c (warn_if_unknown_interface, ++ start_static_initialization_or_destruction, ++ generate_ctor_or_dtor_function, finish_file): Likewise. ++ * error.c (cp_line_of, print_instantiation_full_context, ++ print_instantiation_context): Likewise. ++ * except.c (check_handlers_1, check_handlers): Likewise. ++ * init.c (create_temporary_var): Likewise. ++ * method.c (use_thunk, synthesize_method): Likewise. ++ * parser.c (cp_lexer_set_source_position_from_token, ++ cp_lexer_get_preprocessor_token): Likewise. ++ * pt.c (push_tinst_level, pop_tinst_level, ++ tsubst_friend_function, instantiate_class_template, tsubst_decl, ++ tsubst, tsubst_expr, instantiate_decl): Likewise. ++ * semantics.c (genrtl_try_block, finish_label_stmt, ++ begin_class_definition, expand_body, ++ genrtl_finish_function): Likewise. ++ * tree.c (build_min_nt, build_min): Likewise. ++ ++2003-05-01 Mark Mitchell ++ ++ * decl2.c (comdat_linkage): Don't externalize explicit ++ instantiations. ++ ++2003-05-01 Kriang Lerdsuwanakij ++ ++ PR c++/10554 ++ * decl2.c (do_class_using_decl): Check if operand 0 of SCOPE_REF ++ is not NULL. ++ ++2003-05-01 Steven Bosscher ++ ++ * cp-tree.h (struct lang_id2): Remove. Move fields from here... ++ (struct lang_identifier): ... to here. ++ (LANG_ID_FIELD): Remove. ++ (SET_LANG_ID): Remove. ++ (IDENTIFIER_LABEL_VALUE): Adjust for new lang_identifier. ++ (SET_IDENTIFIER_LABEL_VALUE): Likewise. ++ (IDENTIFIER_IMPLICIT_DECL): Likewise. ++ (SET_IDENTIFIERL_IMPLICIT_DECL): Likewise. ++ (IDENTIFIER_ERROR_LOCUS): Likewise. ++ (SET_IDENTIFIER_ERROR_LOCUS): Likewise. ++ ++2003-05-01 Kriang Lerdsuwanakij ++ ++ PR c++/8772 ++ * pt.c (convert_template_argument): Correct diagnostic. ++ ++2003-04-30 Kriang Lerdsuwanakij ++ ++ PR c++/9432, c++/9528 ++ * decl2.c (validate_nonmember_using_decl): Handle SCOPE_REF. ++ ++2003-04-30 Garbiel Dos Reis ++ ++ * decl.c (check_previous_goto_1): Adjust prototype. ++ (check_previous_goto): Adjust use. ++ (check_switch_goto): Likewise. ++ (use_label): Adjust. ++ (check_previous_goto_1): Don't use pedwarn_with_file_and_line. ++ (struct named_label_use_list): Use location_t datatype. ++ ++2003-04-29 Mark Mitchell ++ ++ PR c++/10551 ++ * pt.c (mark_decl_instantiated): Defer all explicit instantiations ++ that have not yet been written out. ++ ++2003-04-29 Mark Mitchell ++ ++ PR c++/10549 ++ * class.c (layout_class_type): Mark overlong bitfields as having ++ the maximum size permitted by their type, after layout. ++ ++ PR c++/10527 ++ * error.c (dump_expr): Correctly handling of NEW_EXPR.4 ++ ++2003-04-29 Kriang Lerdsuwanakij ++ ++ * call.c (build_operator_new_call): Fix typo. ++ * lang-options.h: Likewise. ++ ++2003-04-29 Mark Mitchell ++ ++ PR c++/10515 ++ * cp-tree.h (lookup_field_1): Declare it. ++ * search.c (lookup_field_1): Make it public. ++ * decl.c (reshape_init): Handle designated initializers. ++ ++ * decl.c (maybe_commonize_var): Further tweak support for systems ++ without weak symbols. ++ ++2003-04-27 Mark Mitchell ++ ++ * decl.c (maybe_commonize_var): Fix thinko in last patch. ++ ++2003-04-27 Mark Mitchell ++ ++ PR c++/10506 ++ * method.c (use_thunk): Decrement immediate_size_expand. ++ ++ PR c++/10503 ++ * cp-tree.h (DECL_VAR_MARKED_P): New macro. ++ (DECL_MAYBE_TEMPLATE): Remove. ++ * class.c (fixed_type_or_null): Avoid infinite recursion. ++ ++ * decl.c (maybe_commonize_var): Make the code match the comments. ++ * pt.c (instantiate_decl): Move call to import_export_decl. ++ ++2003-04-26 Mark Mitchell ++ ++ * decl2.c (finish_file): Fix merge botch. ++ ++2003-04-25 Mark Mitchell ++ ++ * decl2.c (finish_file): Don't call import_export_decl for ++ functions that are not defined. ++ (handle_class_head): Robustify. ++ * pt.c (instantiate_decl): Do not call cp_finish_decl for ++ variables that are not defined. ++ ++2003-04-24 Sylvain Pion ++ ++ * call.c (print_z_candidates): Fix off by one error. ++ ++2003-04-24 Nathan Sidwell ++ ++ PR c++/10337 ++ * call.c (joust): Don't warn about conversion ops that are exact ++ or cv-conversions. Rearrange to avoid multiple type comparisons. ++ ++2003-04-23 Mark Mitchell ++ ++ PR c++/10471 ++ * call.c (build_cxx_call): Robustify. ++ ++2003-04-23 Neil Booth ++ ++ * Make-lang.in (lex.o): Remove mbchar.h. ++ * lex.c (MULTIBYTE_CHARS): Lose. ++ * parser.c (cp_lexer_get_preprocessor_token): CPP_OTHER handled ++ in c-lex.c. ++ ++2003-04-23 Mark Mitchell ++ ++ PR c++/9847 ++ * cp-tree.h (duplicate_tag_error): Remove. ++ * class.c (duplicate_tag_error): Remove. ++ * semantics.c (begin_class_definition): Return immediately for a ++ duplicate class definition. ++ ++ PR c++/10451 ++ * decl.c (grokdeclarator): Correct logic for "mutable" errors. ++ ++2003-04-22 Mark Mitchell ++ ++ PR c++/10446 ++ * search.c (lookup_fnfields_1): Handle empty slots in the method ++ vector. ++ ++ PR c++/10428 ++ * decl.c (check_elaborated_type_specifier): New function, split ++ out from ... ++ (xref_tag): ... here. Use the new function in more places. ++ ++ * rtti.c (throw_bad_typeid): Use build_cxx_call. ++ ++2003-04-21 Mark Mitchell ++ ++ * call.c (build_over_call): Use build_cxx_call. ++ (build_cxx_call): New method, split out of build_over_call. ++ * cp-tree.h (language_function): Add can_throw. ++ (build_cxx_call): Declare it. ++ * decl.c (finish_function): If a function does not contain any ++ calls to functions that can throw an exception, indicate that ++ fact. ++ * decl2.c (mark_used): Do not defer the instantiation of ++ functions, if the current function does not throw. ++ * optimize.c (maybe_clone_body): Copy TREE_NOTHROW to the clones. ++ * pt.c (instantiate_decl): Make sure import_export_decl is called ++ before emitting things. ++ * rtti.c (throw_bad_cast): Use build_cxx_call. ++ (build_dynamic_cast_1): Likewise. ++ * typeck.c (build_function_call): Likewise. ++ ++2003-04-21 Nathan Sidwell ++ ++ PR c++/9881 ++ * typeck.c (build_unary_op): Fold all COMPONENT_REF addr ++ expressions. Reverts my 2002-08-08 patch. ++ ++ * typeck.c (comp_ptr_ttypes_real): Swap final && operands for ++ cheaper early exit. ++ ++2003-04-20 Nathan Sidwell ++ ++ * cp/decl2.c (start_static_storage_duration_function): Take count ++ arg, don't check if it wraps round. ++ (generate_ctor_or_dtor_function): Add locus arg, use it. ++ (generate_ctor_and_dtor_functions_for_priority): Data arg is a ++ locus. ++ (finish_file): Set line numbers to past EOF for synthesized ++ functions. ++ ++2003-04-20 Nathan Sidwell ++ ++ PR c++/10405 ++ * search.c (lookup_field_1): Final scan goes backwards for ++ types, forwards for non-types. ++ ++2003-04-17 Roger Sayle ++ ++ PR c/10375 ++ * decl.c (duplicate_decls): Preserve "const", "noreturn" and ++ "nothrow" function attributes. ++ ++2003-04-17 Kriang Lerdsuwanakij ++ ++ PR c++/10347 ++ * pt.c (type_dependent_expression_p): Handle array new. ++ ++2003-04-15 Mark Mitchell ++ ++ PR c++/10381 ++ * parser.c (cp_parser_primary_expression): Reorganize logic for ++ dealing with name lookup failures. ++ ++2003-04-15 Jason Merrill ++ ++ * decl2.c (mark_used): Don't instantiate anything if ++ skip_evaluation. ++ ++2003-04-14 Ziemowit Laski ++ ++ * tree.c (build_cplus_array_type_1): Do not call ++ uses_template_parms() on a NULL index_type. ++ ++2003-04-13 Roger Sayle ++ ++ * decl.c (duplicate_decls): Preserve pure and malloc attributes. ++ ++2003-04-12 Mark Mitchell ++ ++ PR c++/10300 ++ * init.c (build_new_1): Reorganize. ++ ++2003-04-12 Zack Weinberg ++ ++ * class.c (initialize_array) ++ * decl.c (reshape_init) ++ * decl2.c (build_expr_from_tree) ++ * init.c (build_zero_init) ++ * pt.c (tsubst_copy, tsubst_copy_and_build) ++ * rtti.c (tinfo_base_init, generic_initializer, ptr_initializer) ++ (ptm_initializer, class_initializer, get_pseudo_ti_init) ++ * semantics.c (finish_compound_literal) ++ * typeck.c (build_ptrmemfunc1) ++ * typeck2.c (store_init_value, process_init_constructor) ++ (build_functional_cast): Use build_constructor. ++ ++2003-04-12 Zack Weinberg ++ ++ * call.c (print_z_candidates): Use gcc_gettext_width, not ++ strlen, to determine how much padding to use. ++ ++2003-04-10 Zack Weinberg ++ ++ * decl.c: Update all calls to shadow_warning. ++ ++2003-04-10 Mark Mitchell ++ ++ * class.c (layout_class_type): Correct handling for overlong ++ bit-fields whose width is the same as an integer type. ++ ++2003-04-06 Zack Weinberg ++ ++ * cp-tree.def: Make fourth element for all 'c' and 'x' nodes zero. ++ * cp-lang.c (cp_tree_size): New function. ++ (LANG_HOOKS_TREE_SIZE): Override. ++ ++ * cp-tree.h (SOURCE_LOCUS, SRCLOC_FILE, SRCLOC_LINE, struct ++ tree_srcloc, TS_CP_COMMON, TS_CP_SRCLOC): Kill. ++ (union lang_tree_node): Remove common and srcloc members. ++ (build_srcloc_here): Don't prototype. ++ * decl.c (cp_tree_node_structure): Kill SRCLOC case. ++ * pt.c (pending_templates): Correct comment. ++ * tree.c (build_srcloc, build_srcloc_here): Kill. ++ ++2003-04-06 Zack Weinberg ++ ++ * call.c: Include intl.h. ++ (print_z_candidate): Always use inform; get rid of errfn ++ argument. Reorganize so that all the strings get picked up ++ by xgettext. Note obligation of caller to pass first argument ++ through gettext. ++ (print_z_candidates): Update to match. Indent second and ++ successive candidates by strlen() of translated message. ++ (joust): Restructure ambiguous-conversion pedwarn so that ++ translators see a complete sentence. Update calls to ++ print_z_candidate. ++ ++ * Make-lang.in (cp/call.o): Update dependencies. ++ ++2003-04-05 Kaveh R. Ghazi ++ ++ * decl.c (set_current_binding_level): Delete, revert last change. ++ (current_binding_level): Modify to allow it as as lvalue. ++ ++2003-04-04 Kaveh R. Ghazi ++ ++ * name-lookup.c (find_binding): Pass appropriate pointer type to ++ POP_TIMEVAR_AND_RETURN. ++ ++2003-04-03 Kaveh R. Ghazi ++ ++ * Make-lang.in (cp-warn): Add $(STRICT_WARN). ++ * cp-tree.h: Don't insist on having GNUC. ++ ++2003-04-03 Jason Merrill ++ ++ * cvt.c (ocp_convert): Only abort if we try to convert an object ++ of TREE_ADDRESSABLE type. ++ ++ * class.c (build_vtable): Set DECL_ALIGN here. ++ (get_vtable_decl): Not here. ++ (layout_vtable_decl): Or here. ++ (create_vtable_ptr): Or here. ++ (layout_class_type): Or here. ++ (check_bitfield_decl): Don't mess with field alignment. ++ ++2003-04-03 Kaveh R. Ghazi ++ ++ * operators.def (DEF_SIMPLE_OPERATOR, DEF_ASSN_OPERATOR, ++ DEF_ASSN_OPERATOR): Delete spurious semi-colon. ++ * rtti.c (dfs_class_hint_mark): Likewise. ++ ++ * decl.c (push_local_name, push_class_level_binding, ++ maybe_inject_for_scope_var): Don't use POP_TIMEVAR_AND_RETURN in ++ functions returning void. ++ * decl2.c (add_using_namespace): Likewise. ++ ++ * decl.c (print_binding_level, print_other_binding_stack, ++ print_binding_stack): Cast argument of %p specifier to void*. ++ * ptree.c (cxx_print_decl): Likewise. ++ ++ * cp-tree.h (VAR_OR_FUNCTION_DECL_CHECK, ++ VAR_FUNCTION_OR_PARM_DECL_CHECK, ++ VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK, RECORD_OR_UNION_TYPE_CHECK, ++ BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK, LANG_TYPE_CLASS_CHECK, ++ LANG_TYPE_PTRMEM_CHECK, LANG_DECL_U2_CHECK): Add __extension__. ++ ++ * decl.c (set_current_binding_level): New macro. Use throughout ++ when setting the current binding level. ++ ++ * cp-tree.h (cp_lvalue_kind, base_access): Delete trailing comma ++ in enum. ++ * method.c (mangling_flags): Likewise. ++ ++ * cp-tree.h (lang_type_header): Add __extension__ and use ++ CHAR_BITFIELD for members. ++ ++2003-04-02 Geoffrey Keating ++ ++ PR other/9274 ++ * mangle.c: Include gt-cp-mangle.h. ++ (subst_identifiers): Mark with GTY. ++ * config-lang.in (gtfiles): Add cp/mangle.c. ++ * Make-lang.in: (gt-cp-mangle.h): New rule. ++ (cp/mangle.o): Depends on gt-cp-mangle.h. ++ ++2003-04-01 Andrew Pinski ++ ++ * config-lang.in (gtfiles): Add \$(srcdir)/cp/name-lookup.c ++ after \$(srcdir)/cp/name-lookup.h. ++ * name-lookup.c: (cxx_binding_make): Use ggc_alloc_clearedinstead ++ of ggc_alloc. Include gt-cp-name-lookup.h at the end of the file. ++ * Make-lang.in: (gt-cp-name-lookup.h): Is generated by gengtype. ++ (cp/name-lookup.o): Depends on gt-cp-name-lookup.h. ++ ++2003-03-31 Jason Merrill ++ ++ PR java/10145 ++ * class.c (check_field_decl): Don't set DECL_ALIGN. ++ ++2003-03-30 Mark Mitchell ++ ++ PR c++/7647 ++ * decl.c (grokdeclarator): Tidy, slightly. ++ * search.c (lookup_field_1): Add want_type parameter. ++ (lookup_field_r): Adjust call to lookup_field_1. ++ ++2003-03-30 Gabriel Dos Reis ++ ++ * Make-lang.in (cp/name-lookup.o): Add more dependencies. ++ ++2003-03-30 Gabriel Dos Reis ++ ++ * cp-tree.h (binding_for_name: Move to name-lookup.h Adjust ++ prototype. ++ (cxx_scope_find_binding_for_name): Likewise. ++ * decl.c (find_binding: Move to name-lookup.c. ++ (binding_for_name): Likewise. ++ (cxx_scope_find_binding_for_name): Likewise. ++ (BINDING_LEVEL): Remove. ++ (push_binding): Tidy. ++ (push_class_binding): Likewise. ++ (pop_binding): Likewise. ++ (poplevel): Likewise. ++ (poplevel_class): Likewise. ++ (set_identifier_type_value_with_scope): Likewise. ++ (push_overloaded_decl): Likewise. ++ (lookup_tag): Likewise. ++ (unqualified_namespace_lookup): Likewise. ++ (lookup_name_current_level): Likewise. ++ (maybe_inject_for_scope_var): Likewise. ++ (namespace_binding): Move to name-lookup.c. ++ (set_namespace_binding): Likewise. ++ * decl2.c (lookup_using_namespace): Tidy. ++ (qualified_lookup_using_namespace): Likewise. ++ (do_toplevel_using_decl): Likewise. ++ * name-lookup.c: Include "timevar.h" ++ * name-lookup.h (cxx_scope): Declare. ++ (struct cxx_binding): Lose member "has_level". Adjust "scope" ++ member declaration. ++ (BINDING_SCOPE): Adjust definition. ++ (BINDING_HAS_LEVEL_P): Remove. ++ ++2003-03-30 Gabriel Dos Reis ++ ++ * name-lookup.c: New file. ++ * name-lookup.h: Likewise.. ++ * decl.c (push_binding): Adjust use cxx_binding_make. ++ (free_bindings): Move to name-lookup.c ++ (pop_binding): Use cxx_binding_free. ++ (binding_for_name): Tidy. ++ * cp-tree.h: Include "name-lookup.h" ++ (cxx_binding_make): Move to name-lookup.h ++ (cxx_binding_clear): Likewise. ++ (struct cxx_binding): Likewise. ++ (LOCAL_BINDING_P): Likewise. ++ (INHERITED_VALUE_BINDING_P): Likewise. ++ (BINDING_SCOPE): Likewise. ++ (BINDING_HAS_LEVEL_P): Likewise. ++ (BINDING_VALUE): Likewise. ++ (BINDING_TYPE): Likewise. ++ * config-lang.in (gtfiles): Add cp/name-lookup.h ++ * Make-lang.in (cp/name-lookup.o): New rule. ++ (CXX_OBJS): Add cp/name-lookup.o ++ (CXX_TREE_H): Add cp/name-lookup.h ++ ++2003-03-28 Jason Merrill ++ ++ PR c++/10245 ++ * cvt.c (force_rvalue): New fn. ++ * call.c (build_conditional_expr): Use it. ++ * cp-tree.h: Declare it. ++ ++2003-03-28 Mike Stump ++ ++ * error.c (dump_expr): Add 0x to printed hex numbers to make ++ output match source code better. ++ ++2003-03-28 Mark Mitchell ++ ++ PR c++/10218 ++ * decl.c (grokfndecl): Return NULL_TREE for bogus out-of-class ++ definitions. ++ ++ * decl2.c (generate_ctor_or_dtor_function): Tolerate a ++ non-existant ssdf_decls array. ++ (finish_file): Call generator_ctor_or_dtor_function when there are ++ static constructors or destructors and no other static ++ initializations. ++ ++2003-03-28 Nathan Sidwell ++ ++ PR c++/10047 ++ * decl2.c (finish_file): Don't warn about explicitly instantiated ++ inline decls. ++ ++2003-03-27 Nathan Sidwell ++ ++ PR c++/10224 ++ * pt.c (lookup_template_class): Only check instantiated args if ++ they do not contain template parameters. ++ ++2003-03-27 Nathan Sidwell ++ ++ PR c++/10158 ++ * parser.c (cp_parser_function_definition): Set ++ DECL_INITIALIZED_IN_CLASS for members. ++ * pt.c (instantiate_decl): Only reduce the template args for ++ friends that are not defined in class. ++ ++2003-03-25 Jason Merrill ++ ++ * call.c (print_z_candidate): Change name of first arg to msgid. ++ (joust): Add comment for translators. ++ ++2003-03-24 Nathan Sidwell ++ ++ PR c++/9898, PR c++/383, DR 322 ++ * pt.c (maybe_adjust_types_for_deduction) : Look ++ through reference types on both PARM and ARG. ++ ++2003-03-24 Nathan Sidwell ++ ++ PR c++/10119 ++ * error.c (dump_expr) : Use dump_expr. ++ * pt.c (maybe_fold_nontype_args): New function. ++ (tsubst_copy) : Subst any template_id args. ++ : Break out folding code, call it. ++ (tsubst_copy_and_build) : Call ++ maybe_fold_nontype_args. ++ ++2003-03-24 Nathan Sidwell ++ ++ PR c++/10026 ++ * decl2.c (arg_assoc_type) : Don't die. ++ ++2003-03-23 Mark Mitchell ++ ++ PR c++/7086 ++ * typeck.c (cxx_mark_addressable): Adjust call to ++ gen_mem_addressof or put_var_into_stack. ++ ++2003-03-22 Nathan Sidwell ++ ++ PR c++/9978, c++/9708 ++ * cp-tree.h (instantiate_template): Add tsubst_flags parameter. ++ * call.c (add_template_candidate_real): Adjust ++ instantiate_template call. ++ * class.c (resolve_address_of_overloaded_function): Likewise. ++ * decl.c (build_enumerator): Set TREE_CONSTANT. ++ * pt.c (check_instantiated_args): New. ++ (push_inline_template_parms_recursive): Set TREE_CONSTANT, ++ TREE_READONLY. ++ (build_template_parm_index): Copy TREE_CONSTANT, TREE_READONLY. ++ (reduce_template_parm_level): Likewise. ++ (process_template_parm): Likewise. ++ (check_explicit_specialization): Adjust instantiate_template call. ++ (convert_template_argument): Don't check non-type argument here. ++ (lookup_template_class): Check them here. ++ (tsubst_friend_function): Adjust instantiate_template call. ++ (instantiate_template): Add tsubst_flags parameter, use it. Check ++ instantiated args. ++ ++2003-03-21 Zack Weinberg ++ ++ * decl.c: Update calls to shadow_warning. ++ ++2003-03-21 Nathan Sidwell ++ ++ PR c++/9898 ++ * error.c (dump_decl) [CONST_DECL]: Print ''. ++ (dump_expr) [CONSTRUCTOR]: Print default ctor as a function call. ++ ++2003-03-20 Mark Mitchell ++ ++ * cp/decl2.c (arg_assoc_class): Correct check for namespace-scope ++ friends. ++ * cp/pt.c (instantiate_class_template): Fix formatting. ++ ++2003-03-14 Matt Austern ++ ++ * cp-tree.h (unemitted_tinfo_decls): Declaration of a new varray. ++ (unemitted_tinfo_decl_p): Remove. ++ (emit_tinfo_decl): Change declaration to remove unused parameter. ++ * decl2.c (finish_file): Change tinfo emission to loop through ++ unemitted_tinfo_decls array instead of looping through all decls. ++ * rtti.c (unemitted_tinfo_decl_p): Declare as static, remove ++ unused second parameter. ++ (init_rtti_processing): initialize unemitted_tinfo_decls varray. ++ (get_tinfo_decls): push new tinfo decl on unemitted_tinfo_decls. ++ (emit_tinfo_decl): remove unused second parameter, add assertion ++ that decl hasn't already been emitted. ++ ++2003-03-19 Nathanael Nerode ++ ++ * dump.c (cp_dump_tree), cp-tree.h (cp_dump_tree): Change return ++ type from 'int' to 'bool'. Replace 0 and 1 with true and false in ++ return statements. ++ ++2003-03-19 Jason Merrill ++ ++ PR c++/8316, c++/9315, c++/10136 ++ * call.c (print_z_candidate): Split out from... ++ (print_z_candidiates): ...here. ++ (joust): Use it. ++ ++2003-03-17 Roger Sayle ++ ++ PR c++/10031 ++ * decl.c (duplicate_decls): Use the new type when prototyping ++ anticipated decls, even when the types match. This defines the ++ exception list for the built-in function. ++ ++2003-03-17 Jason Merrill ++ ++ PR c++/10091 ++ * typeck.c (build_class_member_access_expr): Compare ++ TYPE_MAIN_VARIANTs. ++ ++2003-03-17 Mark Mitchell ++ ++ PR c++/9639 ++ * parser.c (cp_parser_declarator_id): Clear parser->scope. ++ ++2003-03-16 Jason Merrill ++ ++ PR c++/9993 ++ * decl.c (finish_function): Only allow the NRVO to use variables ++ declared at function scope. ++ ++2003-03-17 Andreas Jaeger ++ ++ * Make-lang.in (cp/TAGS): Remove. ++ ++2003-03-16 Nathan Sidwell ++ ++ PR c++/9629 ++ * cp-tree.h (struct language_function): Add in_base_initializer. ++ (in_base_initializer): define it. ++ (expand_member_init): Remove INIT param. ++ * init.c (expand_member_init): Remove INIT param, return the member. ++ (emit_mem_initializers): Set in_base_initializer. ++ * class.c (build_base_path): Check in_base_initializer. ++ * parser.c (cp_parser_mem_initializer): Set in_base_initializer. ++ * pt.c (tsubst_initializer_list): Likewise. ++ ++2003-03-16 Gabriel Dos Reis ++ ++ * decl.c (binding_for_name): Fix initialization thinko. ++ ++2003-03-15 Gabriel Dos Reis ++ ++ Compile-time improvement: 2/n. ++ * cp-tree.h (struct cxx_binding): New datatype; ++ (struct lang_identifier): Use it. ++ (LOCAL_BINDING_P): Adjust definition. ++ (INHERITED_VALUE_BINDING_P): Likewise. ++ (BINDING_SCOPE): Likewise. ++ (BINDING_HAS_LEVEL_P): Likewise. ++ (BINDING_VALUE): Likewise. ++ (BINDING_TYPE): Likewise. ++ (IDENTIFIER_VALUE): Likewise. ++ (struct tree_binding): Remove. ++ (TS_CP_BINDING): Likewise. ++ ((union lang_tree_node): Remove field "binding". ++ (cxx_binding_clear): New macro. ++ (binding_for_name): Adjust return type. ++ (qualified_lookup_using_namespace): Adjust prototype. ++ (lookup_using_namespace): Adjust prototype. ++ (cxx_scope_find_binding_for_name): Declare. ++ * cp-tree.def: Remove CPLUS_BINDING definition. ++ * decl.c (push_binding): Adjust local variable type. ++ (add_binding): Likewise. ++ (push_class_binding): Likewise. ++ (pop_binding): Likewise. ++ (poplevel): Likewise. ++ (poplevel_class): Likewise. ++ (free_bindings): Adjust type. ++ (find_binding): Adjust return type, add a third parameter. Remove ++ non-useful assertion now that we use static typing. ++ (cxx_scope_find_binding_for_name): New function. ++ (binding_for_name): Use it. Adjust local variable type. Simplify. ++ (namespace_binding): Simplify. ++ (set_namespace_binding): Likewise. ++ (set_identifier_type_value_with_scope): Adjust local variable type. ++ (lookup_tag): Don't type-abuse of local variable 'old'. ++ (lookup_namespace_name): Likewise. Allocate binding on stack. ++ (select_decl): Adjust prototype. ++ (unqualified_namespace_lookup): Allocate binding on stack. ++ Don't type-abuse of local variable 'val'. ++ (lookup_name_real): Likewise. ++ (maybe_inject_for_scope_var): Adjust local variable type. ++ (cp_tree_node_structure): Remove CPLUS_BINDING case label. ++ (namespace_binding): Adjust logic, simplify. ++ (BINDING_LEVEL): Adjust definition. ++ (push_class_level_binding): Adjust local variable type. ++ (struct cxx_saved_binding): Adjust field 'binding' type. ++ * decl2.c (ambiguous_decl): Adjust prototype. ++ (lookup_using_namespace): Adjust local variable type. ++ (qualified_lookup_using_namespace): Catch type error and correct ++ ensueing logic error. ++ (do_nonmember_using_decl): Adjust local variable type. Allocate ++ temporary cxx_binding on stack. ++ (do_toplevel_using_decl): Adjust local variable type. ++ * ptree.c (cxx_print_cxx_binding): New function. ++ (cxx_print_identifier): Use it. ++ (cxx_print_xnode): Delete CPLUS_BINDING case label. ++ ++2003-03-15 Roger Sayle ++ ++ * tree.c (count_functions): Fix whitespace. ++ ++2003-03-15 Neil Booth ++ ++ * Make-lang.in: Update. ++ ++2003-03-15 Kriang Lerdsuwanakij ++ ++ PR c++/6440 ++ * pt.c (maybe_process_partial_specialization): Handle ++ member class template when enclosing class template is ++ explicit specialized. ++ (most_general_template): Stop looking when DECL is already ++ specialized. ++ ++2003-03-13 Jason Merrill ++ ++ PR c++/9420 ++ * search.c (lookup_conversions): Call complete_type here. ++ * call.c (implicit_conversion): Not here. ++ ++2003-03-13 Mark Mitchell ++ ++ * decl2.c (do_nonmember_using_decl): Correct handling of ++ simultaneous type/non-type bindings. ++ ++ * call.c (initialize_reference): Remove bogus assertion. ++ * decl.c (build_ptrmemfunc_type): Revert change of 2003-03-09. ++ ++2003-03-12 Andrew Lewycky ++ ++ PR c++/7050 ++ * expr.c (cxx_expand_expr): Return const0_rtx for throw ++ expressions. ++ ++2003-03-11 Mark Mitchell ++ ++ PR c++/9474 ++ * decl2.c (do_nonmember_using_decl): Do not call duplicate decls ++ to merge old and new declarations. ++ ++2003-03-12 Alexandre Oliva ++ ++ * g++.1: Remove. ++ * Make-lang.in (c++.generated-manpages): Build cp/g++.1. ++ (cp/g++.1): Build it from scratch in the build tree. ++ (c++.install-man): Depend on it. Install it from the build tree. ++ (c++.mostlyclean): Clean it. ++ ++2003-03-11 Mark Mitchell ++ ++ PR c++/9474 ++ * decl2.c (do_nonmember_using_decl): Do not call duplicate decls ++ to merge old and new declarations. ++ ++ PR c++/9924 ++ * decl2.c (do_nonmember_using_decl): Ignore anticipated builtins. ++ ++2003-03-11 Jason Merrill ++ ++ PR c++/9820 ++ * search.c (lookup_member): Fix handling of functions in a class ++ being defined. ++ ++2003-03-11 Mark Mitchell ++ ++ PR c++/8700 ++ * call.c (convert_class_to_reference): Adjust usage of ++ splice_viable. ++ (any_viable): Remove. ++ (splice_viable): Combine with any_viable. ++ (print_z_candidates): Avoid printing duplicates. ++ (build_user_type_conversion_1): Adjust usage of splice_viable. ++ (build_new_function_call): Likewise. ++ (build_operator_new_call): Likewise. ++ (build_object_call): Likewise. ++ (build_conditional_expr): Likewise. ++ (build_new_op): Likewise. ++ (build_new_method_call): Likewise. ++ (joust): Remove spurious comment. ++ * cp-tree.h (DECL_FRIENDLIST): Correct documentation. ++ * decl2.c (arg_assoc_class): Simplify. ++ * friend.c (add_friend): Likewise. ++ ++2003-03-11 Jason Merrill ++ ++ PR c++/8660 ++ * decl2.c (check_classfn): A member template only matches a ++ member template. ++ ++2003-03-11 Neil Booth ++ ++ * Make-lang.in (CXX_C_OBJS): Update. ++ * lang-specs.h: Don't define __GNUG__ here. ++ ++2003-03-10 Mark Mitchell ++ ++ * call.c (perform_overload_resolution): New function. ++ (build_new_function_call): Use it. ++ (build_operator_new_call): Likewise. ++ (add_candidates): Add explicit_targs and template_only parameters. ++ (build_new_op): Adjust accordingly. ++ * cp-tree.h (build_operator_new_call): New function. ++ (build_function_call_real): Remove. ++ (build_function_call_maybe): Likewise. ++ * init.c (build_new_1): Use build_operator_new_call. ++ * typeck.c (build_function_call_real): Rename to ... ++ (build_function_call): ... this. ++ ++2003-03-10 Devang Patel ++ ++ PR c++/9394 ++ * g++spec.c (lang_specific_driver): Use DEFAULT_WORD_SWTCH_TAKES_ARG. ++ ++2003-03-10 Jason Merrill ++ ++ PR c++/9798 ++ * decl.c (push_using_directive): Push before recursing. ++ ++ PR c++/9868, c++/9524 ++ * call.c (resolve_scoped_fn_name): Handle the case of a function ++ pointer member. ++ ++ * decl2.c (build_offset_ref_call_from_tree): Only mess with 'this' ++ argument in the pointer-to-member case. ++ ++2003-03-09 Mark Mitchell ++ ++ PR c++/9373 ++ * cp-lang.c (cxx_get_alias_set): Use alias set zero for ++ pointers to member functions. ++ ++ PR c++/8534 ++ * decl.c (build_ptrmemfunc_type): Do not allow default arguments ++ in pointer-to-member-function types. ++ ++2003-03-10 Gabriel Dos Reis ++ ++ * expr.c (cplus_expand_constant): Use C90 prototype style. ++ (cxx_expand_expr): Likewise. ++ ++2003-03-09 Kriang Lerdsuwanakij ++ ++ PR c++/9970 ++ * decl.c (duplicate_decls): Only copy DECL_THUNKS for virtual ++ functions. ++ ++2003-03-08 Geoffrey Keating ++ ++ * lang-specs.h (c++-header): Change .pch to .gch. ++ ++2003-03-08 Neil Booth ++ ++ * cp-tree.h (cxx_init): Update prototype. ++ * lex.c (cxx_init): Similarly. ++ ++2003-03-08 Mark Mitchell ++ ++ PR c++/9823 ++ * cp-tree.h (begin_mem_initializers): Remove. ++ * parser.c (cp_parser_mem_initializer_list): Inline it here. ++ Do not call finish_mem_initializers if not in a constructor. ++ (cp_parser_class_head): Fix typo in error message. ++ * semantics.c (begin_mem_initializers): Remove. ++ * testsuite/g++.dg/parser/constructor1.C: New test. ++ ++ PR c++/9809 ++ * call.c (add_function_candidate): Skip builtin fuctions that have ++ not yet been declared. ++ ++ PR c++/9982 ++ * init.c (build_new_1): Correct logic for determining whether or ++ not to use an array cookie. ++ ++ PR c++/9524 ++ * parser.c (cp_parser_postfix_expression): Call ++ finish_non_static_data_member, even when processing_template_decl. ++ ++ PR c++/9912 ++ * cp-tree.h (is_ancestor): New function. ++ (handle_class_head): Change prototype. ++ * decl2.c (is_namespace_ancestor): Rename to ... ++ (namespace_anecestor): ... this. ++ (set_decl_namespace): Adjust accordingly. ++ (handle_class_head): Remove unnecessary parameters. ++ * parser.c (cp_parser_class_head): Check that ++ nested-name-specifiers are used appropriately. ++ ++2003-03-07 Mark Mitchell ++ ++ * call.c (reference_binding): Remove REF_IS_VAR parameter. ++ (implicit_conversion): Adjust call to reference_binding. ++ (make_temporary_var_for_ref_to_type): Add TYPE parameter. ++ (initialize_reference): Adjust handling for references bound to ++ rvalues. ++ * cp-tree.h (make_temporary_var_for_ref_to_temp): Change ++ prototype. ++ (real_non_cast_lvalue_p): New method. ++ * cvt.c (build_up_reference): Adjust use of ++ make_temporary_var_for_ref_to_temp. ++ * tree.c (real_non_cast_lvalue_p): New method. ++ ++2003-03-07 Gabriel Dos Reis ++ ++ * except.c (init_exception_processing): Use C90 prototype style. ++ (cp_protect_cleanup_actions): Likewise. ++ (prepare_eh_type): Likewise. ++ (build_eh_type_type): Likewise. ++ (build_exc_ptr): Likewise. ++ (do_begin_catch): Likewise. ++ (dtor_nothrow): Likewise. ++ (do_end_catch): Likewise. ++ (push_eh_cleanup): Likewise. ++ (decl_is_java_type): Likewise. ++ (choose_personality_routine): Likewise. ++ (initialize_handler_parm): Likewise. ++ (expand_start_catch_block): Likewise. ++ (expand_end_catch_block): Likewise. ++ (begin_eh_spec_block): Likewise. ++ (finish_eh_spec_block): Likewise. ++ (do_allocate_exception): Likewise. ++ (do_free_exception): Likewise. ++ (wrap_cleanups_r): Likewise. ++ (stabilize_throw_expr): Likewise. ++ (build_throw): Likewise. ++ (complete_ptr_ref_or_void_ptr_p): Likewise. ++ (is_admissible_throw_operand): Likewise. ++ (nothrow_libfn_p): Likewise. ++ (can_convert_eh): Likewise. ++ (check_handlers_1): Likewise. ++ (check_handlers): Likewise. ++ ++2003-03-06 Mark Mitchell ++ ++ * call.c (merge_conversion_sequences): New function. ++ (build_conv): Set ICS_USER_FLAG for USER_CONVs. ++ (convert_class_to_reference): Correct handling of second ++ standard conversion sequence in a user-defined conversion ++ sequence. ++ (build_user_type_conversion_1): Use merge_conversion_sequences. ++ * cp-tree.def: Add comments for CONV nodes. ++ * rtti.c (get_tinfo_decl): Use build_address/build_nop. ++ ++2003-03-07 Gabriel Dos Reis ++ ++ * error.c (init_error): Use C90 prototype style. ++ (dump_scope): Likewise. ++ (dump_qualifiers): Likewise. ++ (dump_template_argument): Likewise. ++ (dump_template_argument_list): Likewise. ++ (dump_template_parameter): Likewise. ++ (dump_template_bindings): Likewise. ++ (dump_type): Likewise. ++ (dump_typename): Likewise. ++ (class_key_or_enum): Likewise. ++ (dump_aggr_type): Likewise. ++ (dump_type_prefix): Likewise. ++ (dump_type_suffix): Likewise. ++ (dump_global_iord): Likewise. ++ (dump_simple_decl): Likewise. ++ (dump_decl): Likewise. ++ (dump_template_decl): Likewise. ++ (dump_function_decl): Likewise. ++ (dump_parameters): Likewise. ++ (dump_exception_spec): Likewise. ++ (dump_function_name): Likewise. ++ (dump_template_parms): Likewise. ++ (dump_char): Likewise. ++ (dump_expr_list): Likewise. ++ (dump_expr): Likewise. ++ (dump_binary_op): Likewise. ++ (dump_unary_op): Likewise. ++ (type_as_string): Likewise. ++ (expr_as_string): Likewise. ++ (decl_as_string): Likewise. ++ (context_as_string): Likewise. ++ (lang_decl_name): Likewise. ++ (cp_file_of): Likewise. ++ (cp_line_of): Likewise. ++ (decl_to_string): Likewise. ++ (expr_to_string): Likewise. ++ (fndecl_to_string): Likewise. ++ (code_to_string): Likewise. ++ (language_to_string): Likewise. ++ (parm_to_string): Likewise. ++ (op_to_string): Likewise. ++ (type_to_string): Likewise. ++ (assop_to_string): Likewise. ++ (args_to_string): Likewise. ++ (cv_to_string): Likewise. ++ (cxx_print_error_function): Likewise. ++ (cp_diagnostic_starter): Likewise. ++ (cp_diagnostic_finalizer): Likewise. ++ (cp_print_error_function): Likewise. ++ (function_category): Likewise. ++ (print_instantiation_full_context): Likewise. ++ (print_instantiation_partial_context): Likewise. ++ (maybe_print_instantiation_context): Likewise. ++ (print_instantiation_context): Likewise. ++ (cp_printer): Likewise. ++ (print_integer): Likewise. ++ (print_non_consecutive_character): Likewise. ++ (locate_error): Likewise. ++ ++2003-03-06 Mark Mitchell ++ ++ PR c++/9965 ++ * call.c (reference_binding): Add ref_is_var parameter. ++ (implicit_conversion): Adjust call to reference_binding. ++ (initialize_reference): Likewise. ++ ++ PR c++/9400 ++ * decl.c (pushdecl): Don't check for shadowing of DECL_ARTIFICIAL ++ PARM_DECLs. ++ ++ PR c++/9791 ++ * class.c (get_basefndecls): Use lookup_fnfields_1. ++ ++2003-03-06 Kriang Lerdsuwanakij ++ ++ PR c++/9188 ++ * parser.c (cp_parser_type_parameter): Remove redundant `expect' ++ in error message. ++ (cp_parser_single_declaration): Likewise. ++ ++2003-03-05 Jason Merrill ++ ++ PR c++/9440 ++ * call.c (build_conditional_expr): Use convert rather than an ++ explicit NOP_EXPR. ++ ++2003-03-02 Matt Austern ++ ++ * decl.c (cp_binding_level): Add static_decls varray member. ++ (add_decl_to_level): Add static/inline namespace scope ++ declarations to static_decls array. ++ (wrapup_global_for_namespace): Pass static_decls only, instead of ++ all decls, to wrapup_global_declarations/check_global_declarations. ++ (push_namespace): Initialize static_decls for ordinary namespaces. ++ (cxx_init_decl_processing): Initialize static_decls for global ++ namespace. ++ ++2003-03-05 Mark Mitchell ++ ++ * class.c (end_of_class): Correct thinko. ++ ++2003-03-04 Nathanael Nerode ++ ++ * config-lang.in: Replace ${libstdcxx_version} by its value. ++ ++2003-03-04 Gabriel Dos Reis ++ ++ * cp-tree.h (cxx_saved_binding): Declare. ++ (struct saved_scope): Adjust type of field 'old_binding'. ++ * decl.c (cxx_saved_binding_make): New macro. ++ (struct cxx_saved_binding): Define. ++ (store_bindings): Adjust prototype. Use cxx_saved_binding to save ++ C++ bindings. ++ (maybe_push_to_top_level): Adjust local variable type. ++ (pop_from_top_level): Likewise. ++ ++2003-03-04 Tom Tromey ++ ++ * Make-lang.in (c++.tags): New target. ++ ++2003-03-04 Neil Booth ++ ++ * Make-lang.in: Update. ++ ++2003-03-03 Jason Merrill ++ ++ * decl.c (finish_enum): Do set the type in a template. Simplify. ++ * pt.c (tsubst_enum, tsubst_copy): Revert last patch. ++ ++2003-03-03 Mark Mitchell ++ ++ PR c++/9878 ++ * call.c (convert_class_to_reference): Correct conversion ++ sequences. ++ (reference_binding): Add ref_bound_directly_to_rvalue_p parameter. ++ (implicit_conversion): Adjust call to reference_binding. ++ (add_candidate): Change type of candidates parameter. ++ (add_function_candidate): Likewise. ++ (add_conv_candidate): Likewise. ++ (build_builtin_candidate): Likewise. ++ (add_builtin_candidate): Likewise. ++ (add_builtin_candidates): Likewise. ++ (add_template_candidate_real): Likewise. ++ (add_template_candidate): Likewise. ++ (add_template_conv_candidate): Likewise. ++ (build_user_type_conversion_1): Adjust accordingly. ++ (build_object_call): Likewise. ++ (build_conditional_expr): Likewise. ++ (add_candidates): Likewise. ++ (build_new_op): Likewise. ++ (convert_like_real): Use USER_CONV_CAND. Use build_nop. ++ (build_new_method_call): Adjust calls to add_function_candidate. ++ (make_temporary_var_for_ref_to_temp): New function. ++ (initialize_reference): Add decl parameter. ++ * class.c (build_rtti_vtbl_entries): Use build_address and ++ build_nop. ++ * cp-tree.h (initialize_reference): Change prototype. ++ (make_temporary_var_for_ref_to_temp): New function. ++ (build_type_conversion): Change prototype. ++ (build_address): New function. ++ (build_nop): Likewise. ++ * cvt.c (cp_convert_to_pointer): Adjust call to ++ build_type_conversion. Avoid indicating redundant NOP_EXPRs. ++ Use build_nop. ++ (convert_to_pointer_force): Use build_nop. ++ (build_up_reference): Use make_temporary_var_for_ref_to_temp. ++ (convert_to_reference): Adjust call to build_type_conversion. ++ (ocp_convert): Likewise. ++ (build_type_conversion): Remove for_sure parameter. ++ * decl.c (grok_reference_init): Use initialize_reference. ++ * typeck.c (build_address): New function. ++ (build_nop): Likewise. ++ (build_unary_op): Use them. ++ (build_ptrmemfunc): Tidy slightly. ++ (convert_for_initialization): Adjust call to ++ initialize_reference. ++ * typeck2.c (store_init_value): Remove #if 0'd code. ++ ++2003-03-03 Jason Merrill ++ ++ * decl.c (start_function): Clear DECL_NUM_STMTS. ++ ++ * class.c (get_vtable_decl): Use vtbl_type_node. ++ (build_primary_vtable): Check for it. ++ ++2003-03-02 Aldy Hernandez ++ ++ * decl.c (check_initializer): Check for vector_opaque_p. ++ ++2003-03-02 Ashif Harji ++ ++ * lang-specs.h (default_compilers): Add -no-integrated-cpp flag to ++ invoke an external cpp during compilation. ++ ++2003-03-01 Gabriel Dos Reis ++ ++ * decl.c (duplicate_decls): Convert use of warning_with_decl() to ++ that of warning(). ++ (start_decl): Likewise. ++ (start_function): Likewise. ++ ++2003-03-01 Neil Booth ++ ++ * Make-lang.in (CXX_C_OBJS): Update. ++ ++2003-02-28 Mark Mitchell ++ ++ PR c++/9892 ++ * pt.c (instantiate_decl): Clear DECL_RTL for a VAR_DECL when ++ instantiating it. ++ ++2003-02-28 Aldy Hernandez ++ ++ * parser.c (cp_parser_init_declarator): Revert opaque ++ vector_opaque_p change. ++ Do not include target.h. ++ ++2003-02-28 Mark Mitchell ++ ++ PR c++/9879 ++ * cp-tree.h (build_zero_init): Add parameter. ++ * decl.c (cp_finish_decl): Adjust call. ++ * init.c (build_zero_init): Add nelts parameter. Adjust recursive ++ calls. ++ (build_default_init): Add nelts parameter. Adjust calls to ++ build_zero_init. ++ (build_new_1): Adjust call to build_default_init. ++ * typeck2.c (process_init_constructor): Adjust call to build_zero_init. ++ ++2003-02-26 Devang Patel ++ ++ * decl.c (finish_enum): Merge two 'for' loops. Copy value node if ++ required. Postpone enum setting for template decls. ++ (build_enumerator): Delay copying value node until finish_enum ++ (). Remove #if 0'ed code. ++ * pt.c (tsubst_enum): Set TREE_TYPE and copy value node. ++ (tsubst_copy): Add check for enum type. ++ ++2003-02-25 Mark Mitchell ++ ++ PR c++/9683 ++ * decl2.c (prune_vars_needing_no_initialization): Do not throw ++ away initializations for DECL_EXTERNAL VAR_DECLs. ++ (finish_file): Adjust accordingly. ++ * pt.c (instantiate_decl): Do not defer VAR_DECLs. ++ ++2003-02-24 Gabriel Dos Reis ++ ++ * decl.c (add_binding): Time TV_NAME_LOOKUP. ++ (push_class_binding): Likewise. ++ (set_namespace_binding): Likewise. ++ ++2003-02-24 Mark Mitchell ++ ++ PR c++/9836 ++ * cp-tree.h (CLASSTYPE_PRIMARY_TEMPLATE): Do not skip from ++ specializations back to the main template. ++ * parser.c (cp_parser_diagnose_invalid_type_name):Adjust use. ++ * pt.c (resolve_typename_type): Likewise. ++ ++2003-02-24 Jeffrey D. Oldham ++ ++ PR c++/9778 ++ * pt.c (tsubst_copy_and_build): For a templated function inside a ++ scope, process template arguments. ++ ++2003-02-24 Kriang Lerdsuwanakij ++ ++ PR c++/9602 ++ * typeck2.c (abstract_virtuals_error): Don't check when ++ TYPE is still template parameter dependent. ++ ++2003-02-23 Mark Mitchell ++ ++ PR c++/5333 ++ * cp-tree.h (CLASSTYPE_PRIMARY_TEMPLATE): New macro. ++ * parser.c (cp_parser_diagnose_invalid_type_name): Use it. ++ * pt.c (instantiate_class_template): Don't try to instantiate ++ dependent types. ++ (resolve_typename_type): Use CLASSTYPE_PRIMARY_TEMPLATE. ++ ++2003-02-21 Mark Mitchell ++ ++ PR c++/9749 ++ * decl.c (grokdeclarator): Do not allow parameters with variably ++ modified types. ++ ++2003-02-21 Nathan Sidwell ++ ++ * search.c (grow_bfs_bases): Remove. Fold into ... ++ (bfs_walk): ... here, fix fencepost error. Fix merge lossage ++ in previous patch. ++ ++2003-02-20 Mark Mitchell ++ ++ PR c++/9729 ++ * mangle.c (mangle_conv_op_name_for_type): Issue an error message ++ when the G++ 3.2 ABI prevents correct compilation. ++ ++2003-02-20 Nathan Sidwell ++ ++ Change base class access representation. Share virtual base ++ binfos. ++ * cp/call.c (build_special_member_call): Remove binfo_for_vbase ++ call. ++ * cp/class.c (build_base_path): Likewise. ++ (build_primary_vtable): Adjust BINFO_NEW_VTABLE_MARKED use. ++ (build_secondary_vtable): Remove FOR_TYPE arg. Adjust. ++ (make_new_vtable): Adjust. ++ (force_canonical_binfo_r): Delete. ++ (force_canonical_binfo): Delete. ++ (mark_primary_virtual_base): Delete. ++ (dfs_unshared_virtual_bases): Delete. ++ (mark_primary_bases): Adjust. ++ (maybe_warn_about_overly_private_class): Adjust. ++ (dfs_base_derived_from): Delete. ++ (base_derived_from): Follow the inheritance chain. ++ (struct find_final_overrider_data): Add vpath member. ++ (dfs_find_final_overrider): Adjust. ++ (dfs_find_final_overrider_q, dfs_find_final_overrider_post): New. ++ (find_final_overrider): Adjust. ++ (update_vtable_entry_for_fn): Adjust. ++ (modify_all_vtables): Adjust. ++ (walk_subobject_offsets): Adjust. ++ (layout_nonempty_base_or_field): Adjust. ++ (layout_empty_base): Remove last parameter. Adjust. ++ (build_base_field): Adjust. ++ (build_base_fields): Adjust. ++ (propagate_binfo_offsets): Remove last parameter. Adjust. ++ (dfs_set_offset_for_unshared_vbases): Delete. ++ (layout_virtual_bases): Adjust. ++ (finish_struct_1): Adjust. ++ (init_class_processing): Don't init access nodes. ++ (dfs_get_primary_binfo): Delete. ++ (get_primary_binfo): Adjust. ++ (dump_class_hierarchy_r): Remove most derived arg, add IGO ++ parameter. Adjust. ++ (dump_class_hierarchy): Adjust. ++ (finish_vtbls): Adjust. ++ (get_original_base): Delete. ++ (build_vtt_inits): Adjust. ++ (dfs_build_secondary_vptr_vtt_inits): Adjust. ++ (dfs_ctor_vtable_bases_queue_p): Adjust. ++ (build_ctor_vtbl_group): Adjust. ++ (dfs_accumulate_vtbl_inits): Adjust. ++ (build_vtbl_initializer): Adjust. ++ (build_vbase_offset_vtbl_entries): Adjust. ++ (add_vcall_offset_vtbl_entries_1): Adjust. ++ * cp/cp-tree.h (CPTI_ACCESS_*): Remove. ++ (access_*_node): Remove. ++ (CANONICAL_BINFO): Delete. ++ (BINFO_UNSHARED_MARKED): Remove. ++ (BINFO_MARKED): Set LANG_FLAG_0 directly. ++ (SET_BINFO_MARKED, CLEAR_BINFO_MARKED): Delete. ++ (BINFO_VTABLE_PATH_MARKED): Set LANG_FLAG_3 directly. ++ (SET_BINFO_VTABLE_PATH_MARKED, CLEAR_BINFO_VTABLE_PATH_MARKED): ++ Delete. ++ (BINFO_NEW_VTABLE_MARKED): Set LANG_FLAG_4 directly. ++ (SET_BINFO_NEW_VTABLE_MARKED): Adjust. ++ (SET_BINFO_PUSHDECLS_MARKED, CLEAR_BINFO_PUSHDECLS_MARKED): ++ Delete. ++ (BINFO_DEPENDENT_BASE_P): New. ++ (dfs_walk, dfs_walk_real): Queue function takes derived binfo and ++ index. ++ (markedp, unmarkedp): Adjust. ++ (dfs_unmarked_real_bases_queue_p, dfs_marked_real_bases_queue_p, ++ dfs_skip_vbases, marked_vtable_pathp, unmarked_vtable_pathp, ++ find_vbase_instance, binfo_for_vbase): Delete. ++ (copied_binfo, original_binfo): Declare. ++ (finish_base_specifier): Add virtual_p arg. ++ (unshare_base_binfos): Delete. ++ (copy_base_binfos): Declare. ++ (reverse_path): Delete. ++ * cp/decl.c (xref_basetypes): Access and virtuality passed ++ differently. Don't copy direct base binfos here. Call ++ copy_base_binfos. ++ * cp/init.c (dfs_initialize_vtbl_ptrs): Adjust. ++ (initialize_vtbl_ptrs): Adjust. ++ (expand_member_init): Adjust. ++ * cp/parser.c (cp_parser_base_specifier): Adjust. ++ * cp/pt.c (instantiate_class_template): Adjust. ++ (get_template_base_recursive): Adjust. ++ * cp/rtti.c (get_pseudo_ti_init): Adjust. ++ (get_pseudo_ti_desc): Adjust. ++ * cp/tree.c (unshare_base_binfos): Rename to ... ++ (copy_base_binfos): ... here, reimplement. ++ (make_binfo): Set BINFO_DEPENDENT_BASE_P. ++ (reverse_path): Remove. ++ * cp/typeck.c (get_delta_difference): Adjust error messages. ++ * cp/semantics.c (finish_base_specifier): Add virtual arg, adjust. ++ * cp/search.c (lookup_base_r): Adjust. ++ (dynamic_cast_base_recurse): Adjust. ++ (canonical_binfo): Remove. ++ (dfs_canonical_queue): Remove. ++ (dfs_assert_unmarked_p): Remove. ++ (assert_canonical_unmarked): Remove. ++ (shared_marked_p, shared_unmarked_p): Remove. ++ (BINFO_ACCESS, SET_BINFO_ACCESS): Use TREE_PUBLIC & TREE_PRIVATE. ++ (dfs_access_in_type): Adjust. ++ (access_in_type): Adjust. ++ (dfs_accessible_queue_p): Adjust. ++ (dfs_accessible_p): Adjust. ++ (is_subobject_of_p_1, is_subobject_of_p): Remove. ++ (struct lookup_field_info): Remove from_dep_base_p field. ++ (lookup_field_queue_p): Adjust, test BINFO_DEPENDENT_BASE_P. ++ (lookup_field_r): Remove dependent base code. ++ (lookup_member): Likewise. ++ (dfs_walk, dfs_walk_real): Add access arg to queue fn. ++ (dfs_unmarked_real_bases_queue_p): Remove. ++ (dfs_marked_real_bases_queue_p): Remove. ++ (dfs_skip_vbases): Remove. ++ (dfs_get_pure_virtuals): Adjust. ++ (markedp, unmarkedp): Adjust. ++ (marked_vtable_pathp, unmarked_vtable_pathp): Remove. ++ (marked_pushdecls_p, unmarked_pushdecls_p): Adjust. ++ (dfs_unmark): Adjust. ++ (dfs_get_vbase_types):Remove. ++ (dfs_build_inheritance_graph_order): Remove. ++ (get_vbase_types): Remove ++ (dfs_find_vbase_instance): Remove. ++ (find_vbase_instance): Remove. ++ (dfs_debug_unmarkedp): Adjust. ++ (dependent_base_p): Remove. ++ (dfs_push_type_decls): Adjust. ++ (dfs_push_decls): Adjust. ++ (dfs_no_overlap_yet): Adjust. ++ (copied_binfo): New function. ++ (original_binfo): New function. ++ (binfo_for_vbase): Remove. ++ ++2003-02-18 Zack Weinberg ++ ++ * cp/search.c (grow_bfs_bases): New subroutine of bfs_walk. ++ (bfs_walk): Rewritten using circular queue of BINFO_BASETYPES ++ vectors, for speed. ++ ++2003-02-18 Mark Mitchell ++ ++ PR c++/9704 ++ * class.c (layout_class_type): In the 3.2 ABI, take into account ++ trailing bit fields when computing CLASSTYPE_SIZE_UNIT. ++ ++2003-02-18 Matt Austern ++ ++ * cp/cp-lang.c: Change lang hooks so that final_write_globals does ++ nothing for C++. ++ * cp/decl.c (wrapup_globals_for_namespace): Remove special ++ handling of global namespace. ++ ++2003-02-18 Geoffrey Keating ++ ++ * cp-tree.h (rid_to_yy): Delete. ++ (C_RID_YYCODE): Delete. ++ (finish_file): Delete redundant declaration. ++ ++2003-02-18 Jason Merrill ++ ++ PR c++/9623 ++ * decl.c (reshape_init): Don't mess with initializer labels. ++ ++ PR c++/9485 ++ * parser.c (cp_parser_postfix_expression): Set idk properly for ++ object->scope::member. ++ ++2003-02-18 Ben Elliston ++ ++ PR other/7350 ++ * decl.c (duplicate_decls): Fix typo in comment. ++ ++2003-02-17 Michael Elizabeth Chastain ++ ++ PR debug/9717 ++ * class.c (build_base_field): Mark fields for base classes with ++ DECL_IGNORED_P. ++ ++2003-02-17 Kriang Lerdsuwanakij ++ ++ PR c++/9457 ++ * pt.c (tsubst_copy_and_build) [CONSTRUCTOR]: Substitute ++ CONSTRUCTOR_ELTS only once. ++ ++2003-02-16 Kriang Lerdsuwanakij ++ ++ PR c++/9459 ++ * error.c (dump_type_prefix): Handle TYPEOF_TYPE. ++ (dump_type_suffix): Likewise. ++ ++2003-02-14 Nathan Sidwell ++ ++ * search.c: ANSIfy function declarations and definitions. ++ * cp-tree.h (lookup_field, lookup_member): Last parameter is a bool. ++ * call.c (build_method_call, resolve_scoped_fn_name, ++ build_java_interface_fn_ref): Adjust lookup_field, lookup_member ++ calls. ++ * class.c (handle_using_decl): Likewise. ++ * decl.c (make_typename_type, make_unmound_class_template, ++ start_decl, compute_array_index_type): Likewise. ++ * decl2.c (build_expr_from_tree, build_call_from_tree): Likewise. ++ * init.c (expand_member_init, build_member_call): Likewise. ++ * pt.c (tsubst_copy, tsubst_copy_and_build, do_decl_instantiation, ++ resolve_typename_type): Likewise. ++ * typeck.c (lookup_destructor, finish_class_member_access_exprm ++ build_prememfunc_access_expr): Likewise. ++ ++2003-02-13 Gabriel Dos Reis ++ ++ * decl2.c: Include "timevar.h". ++ (namespace_ancestor): Time name lookup. ++ (add_using_namespace): Likewise. ++ (lookup_using_namespace): Likewise. ++ (qualified_lookup_using_namespace): Likewise. ++ (decl_namespace): Likewise. ++ (lookup_arg_dependent): Likewise. ++ * lex.c (do_identifier): Likewise. ++ (do_scoped_id): Likewise. ++ * pt.c (lookup_template_class): Likewise. ++ ++2003-02-14 Andrew Pinski ++ ++ * decl.c: (define_label): Fix warning for return 0 instead of NULL. ++ ++2003-02-13 Gabriel Dos Reis ++ ++ * decl.c: Include "timevar.h". ++ (poplevel): Time name lookup. ++ (find_binding): Likewise. ++ (push_namespace): Likewise. ++ (pop_nested_namespace): Likewise. ++ (store_bindings): Likewise. ++ (maybe_push_to_top_level): Likewise. ++ (pop_from_top_level): Likewise. ++ (push_local_name): Likewise. ++ (pushtag): Likewise. ++ (pushdecl): Likewise. ++ (pushdecl_with_scope): Likewise. ++ (pushdecl_namespace_level): Likewise. ++ (pushdecl_top_level): Likewise. ++ (pushdecl_class_level): Likewise. ++ (push_class_level_binding): Likewise. ++ (push_using_decl): Likewise. ++ (push_using_directive): Likewise. ++ (push_overloaded_decl): Likewise. ++ (lookup_label): Likewise. ++ (define_label): Likewise. ++ (lookup_tag): Likewise. ++ (lookup_tag_reverse): Likewise. ++ (lookup_namespace_name): Likewise. ++ (select_decl): Likewise. ++ (unqualified_namespace_lookup): Likewise. ++ (lookup_name_real): Likewise. ++ (lookup_name_current_level): Likewise. ++ (lookup_type_current_level): Likewise. ++ (maybe_inject_for_scope_var): Likewise. ++ (xref_tag): Likewise. ++ ++ * Make-lang.in (cp/decl.o): Add dependency on timevar.h ++ ++2003-02-12 Phil Edwards ++ ++ * decl.c (build_enumerator): Remove unneeded test. ++ ++2003-02-09 Dan Nicolaescu ++ ++ * cp-tree.h (struct lang_type_header): Make all fields unsigned ++ char. ++ ++2003-02-03 Mark Mitchell ++ ++ PR c++/7129 ++ * call.c (z_candidate): Add args. ++ (convert_class_to_reference): Set it. ++ (implicit_conversion): Tidy. ++ (add_candidate): Add args parameter. ++ (add_function_candidate): Adjust call to add_candidate. ++ (add_conv_candidate): Likewise. ++ (build_builtin_candidate): Likewise. ++ (build_user_type_conversion_1): Eliminate wasteful tree_cons ++ usage. ++ (build_new_function_call): Likewise. ++ (build_object_call): Likewise. ++ (add_candidates): New function. ++ (build_new_op): Use it. ++ (covert_like_real): Adjust call to build_over_call. ++ (build_over_call): Remove args parameter. ++ * operators.def: Add ?=. ++ ++2003-02-01 Richard Sandiford ++ ++ * typeck.c (build_indirect_ref): Don't check flag_volatile. ++ ++2003-01-31 Kriang Lerdsuwanakij ++ ++ PR c++/8849 ++ * pt.c (resolve_overloaded_unification): Handle FUNCTION_DECL. ++ ++2003-01-31 Nathan Sidwell ++ ++ * cp-tree.h (BINFO_SUBVTT_INDEX, BINFO_VPTR_INDEX, ++ BINFO_PRIMARY_BASE_OF): Use BINFO_ELTS. ++ (BINFO_LANG_ELTS): New #define. ++ * tree.c (make_binfo): Use BINFO_LANG_ELTS. ++ ++2003-01-30 Geoffrey Keating ++ ++ * cp/Make-lang.in: Remove -Wno-error from cp/decl.o. ++ ++2003-01-30 Mark Mitchell ++ ++ * class.c (check_field_decls): Only check C_TYPE_FIELDS_READONLY ++ for class types. ++ * cp-tree.h (C_TYPE_FIELDS_READONLY): Use a lang-specific bit ++ rather than TYPE_LANG_FLAG_0. ++ (TYPE_BUILT_IN): Remove. ++ (TYPE_DEPENDENT_P): New macro. ++ (TYPE_DEPENDENT_P_VALID): Likewise. ++ (lang_type_class): Add fields_readonly. ++ * decl.c (record_builtin_type): Don't set TYPE_BUILT_IN. ++ * pt.c (dependent_type_p_r): New function, split out from ... ++ (dependent_type_p): ... here. Memoize results. ++ * search.c (dependent_base_p): Use dependent_type_p, not ++ uses_template_parms. ++ * typeck.c (build_modify_expr): Only check C_TYPE_FIELDS_READONLY ++ for class types. ++ ++2003-01-29 Mark Mitchell ++ ++ * call.c (build_field_call): Use build_new_op, not build_opfncall. ++ (prep_operand): New function. ++ (build_new_op): Use it. Remove dead code. ++ * class.c (pushclass): Change "modify" parameter type from int to ++ bool. ++ (currently_open_class): Use same_type_p, not pointer equality. ++ (push_nested_class): Adjust calls to pushclass, remove modify ++ parameter. ++ * cp-tree.h (INTEGRAL_OR_ENUMERATION_TYPE_P): New macro. ++ (pushclass): Change prototype. ++ (push_nested_class): Likewise. ++ (grokoptypename): Remove. ++ (build_opfncall): Remove. ++ (value_dependent_expression_p): Declare. ++ (resolve_typename_type): Likewise. ++ (resolve_typename_type_in_current_instantiation): Likewise. ++ (enter_scope_of): Remove. ++ (tsubst): Remove. ++ (tsubst_expr): Likewise. ++ (tsubst_copy): Likewise. ++ (tsubst_copy_and_build): Likewise. ++ * decl.c (warn_about_implicit_typename_lookup): Remove. ++ (finish_case_label): Return error_mark_node for erroneous labels. ++ (start_decl): Adjust calls to push_nested_class. ++ (grokfndecl): Call push_scope/pop_scope around call to ++ duplicate_decls. ++ (grokdeclarator): Do not call tsubst. ++ (start_function): Adjust calls to push_nested_class. ++ * decl2.c (grok_array_decl): Use build_new_op, not build_opfncall. ++ (check_classfn): Use push_scope/pop_scope around type comparisions. ++ (grokoptypename): Remove. ++ (push_sscope): Adjust call to push_nested_class. ++ * error.c (dump_type): Show cv-qualification of typename types. ++ * init.c (build_member_call): Use build_new_op, not ++ build_opfncall. ++ * method.c (build_opfncall): Remove. ++ * parser.c (cp_parser): Add allow_non_constant_expression_p and ++ non_constant_expression_p. ++ (cp_parser_constant_expression): Adjust prototype. ++ (cp_parser_resolve_typename_type): Remove. ++ (cp_parser_non_constant_expression): New function. ++ (cp_parser_non_constant_id_expression): Likewise. ++ (cp_parser_new): Set allow_non_constant_expression_p and ++ non_constant_expression_p. ++ (cp_parser_primary_expression): Reject `this' and `va_arg' in ++ constant-expressions. Note that dependent names aren't really ++ constant. ++ (cp_parser_postfix_expression): Reject conversions to non-integral ++ types in constant-expressions. Neither are increments or ++ decrements. ++ (cp_parser_unary_expression): Reject increments and decrements in ++ constant-expressions. ++ (cp_parser_direct_new_declarator): Adjust call to ++ cp_parser_constant_expression. ++ (cp_parser_cast_expression): Reject conversions to non-integral ++ types in constant-expressions. ++ (cp_parser_assignment_expression): Rejects assignments in ++ constant-expressions. ++ (cp_parser_expression): Reject commas in constant-expressions. ++ (cp_parser_labeled_statement): Adjust call to ++ cp_parser_constant_expression. ++ (cp_parser_direct_declarator): Simplify array bounds, even in ++ templates, when they are non-dependent. Use ++ resolve_typename_type, not cp_parser_resolve_typename_type. ++ (cp_parser_class_head): Use resolve_typename_type, not ++ cp_parser_resolve_typename_type. ++ (cp_parser_member_declaration): Adjust call to ++ cp_parser_constant_expression. ++ (cp_parser_constant_initializer): Likewise. ++ (cp_parser_constructor_declarator): Use resolve_typename_type, not ++ cp_parser_resolve_typename_type. ++ (cp_parser_late_parsing_default_args): Adjust call to ++ push_nested_class. ++ * pt.c (tsubst): Give it internal linkage. ++ (tsubst_expr): Likewise. ++ (tsubst_copy): Likewise. ++ (tsubst_copy_and_build): Likewise. ++ (push_access_scope_real): Likewise. ++ (tsubst_friend_class): Likewise. ++ (instantiate_class_template): Adjust call to pushclass. ++ (value_dependent_expression_p): Give it external linkage. ++ Robustify. ++ (resolve_typename_type): New function. ++ * semantics.c (finish_call_expr): Use build_new_op, not ++ build_opfncall. ++ (begin_constructor_declarator): Remove. ++ (begin_class_definition): Adjust call to pushclass. ++ (enter_scope_of): Remove. ++ * typeck.c (comptypes): Resolve typename types as appropriate. ++ (build_x_indirect_ref): Use build_new_op, not build_opfncall. ++ (build_x_compound_expr): Likewise. ++ (build_modify_expr): Likewise. ++ (build_x_modify_expr): Likewise. ++ * typeck2.c (build_x_arrow): Likewise. ++ ++2003-01-29 Fariborz Jahanian ++ ++ * pt.c (last_pending_template) Declare GTY(). ++ ++2003-01-29 Kriang Lerdsuwanakij ++ ++ PR c++/8591 ++ * parser.c (cp_parser_elaborated_type_specifier): Convert ++ TEMPLATE_DECL to TYPE_DECL only when processing template friends. ++ (cp_parser_maybe_treat_template_as_class): Remove redundant tests. ++ ++2003-01-28 Nathan Sidwell ++ ++ PR c++/9437 ++ * pt.c (unify): Don't unify '*T' with 'U C::*'. ++ ++ PR c++/3902 ++ * parser.c (cp_parser_decl_specifier_seq): Cannot have constructor ++ inside a declarator. ++ ++2003-01-27 Nathan Sidwell ++ ++ * class.c (update_vtable_entry_for_fn): Add index parameter. ++ Generate vcall thunk for covariant overriding from a virtual ++ primary base. ++ (dfs_modify_vtables): Adjust. ++ ++2003-01-25 Nathan Sidwell ++ ++ PR c++/9403 ++ * parser.c (cp_parser_class_or_namespace_name): Reject duplicate ++ template keyword. ++ (cp_parser_base_specifier): Look for and consume a ++ TEMPLATE keyword. Replace switch with array index. ++ ++ PR c++/795 ++ * semantics.c (finish_non_static_data_member): Remember the ++ field's type even in a template. ++ ++ PR c++/9415 ++ * pt.c (tsubst_copy_and_build, CALL_EXPR): BASELINK exprs are ++ already scoped. ++ ++ PR c++/8545 ++ * parser.c (cp_parser_cast_expression): Be more tentative. ++ ++2003-01-25 Kriang Lerdsuwanakij ++ ++ * cp-tree.h (flagged_type_tree_s): Remove. ++ (check_for_new_type): Likewise. ++ * typeck2.c (check_for_new_type): Likewise. ++ ++2003-01-23 Nathanael Nerode ++ ++ * dump.c: ANSIfy function declarations and definitions. ++ ++ * cp-tree.h, decl.h: Get rid of PARAMS. Again. ++ ++2003-01-22 Mark Mitchell ++ ++ PR c++/9354 ++ * init.c (build_new): Set the type of the new-expression, even ++ when processing_templte_decl. ++ ++ PR c++/9216 ++ * parser.c (cp_parser_primary_expression): Improve error message ++ for templates used in an expression context. ++ ++ PR c++/8696 ++ * parser.c (cp_parser_decl_specifier_seq): Commit to tentative ++ parse when encountering "typedef". ++ ++2003-01-22 Nathanael Nerode ++ ++ * class.c, parser.c: ANSIfy function definitions and declarations. ++ ++2003-01-22 Mark Mitchell ++ ++ PR c++/9328 ++ * error.c (dump_decl): For an OVERLOAD, just print the name of the ++ function; it doesn't make sense to try to print its type. ++ * semantics.c (finish_typeof): Issue errors about invalid uses. ++ ++ PR c++/9298 ++ * parser.c (cp_parser_consume_semicolon_at_end_of_statement): New ++ function. ++ (cp_parser_expression_statement): Use it. ++ (cp_parser_explicit_instantiation): Likewise. ++ * pt.c (do_decl_instantiation): Improve error handling logic. ++ ++2003-01-22 Mark Mitchell ++ ++ PR c++/9384 ++ * parser.c (cp_parser_using_declaration): Issue error messages ++ about name resolution failures here. ++ ++ PR c++/9388 ++ * class.c (currently_open_derived_class): Use dependent_type_p. ++ * cp-tree.h (dependent_type_p): New function. ++ (dependent_template_arg_p): Likewise. ++ (dependent_template_p): Likewise. ++ (type_dependent_expression_p): Likewise. ++ * parser.c (cp_parser_dependent_type_p): Remove. ++ (cp_parser_value_dependent_type_p): Likewise. ++ (cp_parser_type_dependent_expression_p): Likewise. ++ (cp_parser_dependent_template_arg_p): Likewise. ++ (cp_parser_dependent_template_id_p): Likewise. ++ (cp_parser_dependent_template_p): Likewise. ++ (cp_parser_diagnose_invalid_type_name): Replace ++ cp_parser_dependent_type_p with dependent_type_p, etc. ++ (cp_parser_primary_expresion): Likewise. ++ (cp_parser_nested_name_specifier_opt): Likewise. ++ (cp_parser_postfix_expression): Likewise. ++ (cp_parser_unary_expression): Likewise. ++ (cp_parser_template_name): Likewise. ++ (cp_parser_class_name): Likewise. ++ (cp_parser_lookup_name): Likewise. ++ * pt.c (dependent_type_p): New function. ++ (value_dependent_expression_p): Likewise. ++ (type_dependent_expression_p): Likewise. ++ (dependent_template_arg_p): Likewise. ++ (dependent_template_id_p): Likewise. ++ (dependent_template_p): Likewise. ++ ++ PR c++/9285 ++ PR c++/9294 ++ * parser.c (cp_parser_simple_declaration): Return quickly when ++ encountering errors. ++ ++2003-01-21 Kaveh R. Ghazi ++ ++ Make-lang.in (cp/decl.o-warn): Add -Wno-error. ++ ++2003-01-17 Jason Merrill ++ ++ PR c++/9167, c++/9358 ++ * decl.c (require_complete_types_for_parms): Also update DECL_ARG_TYPE. ++ ++2003-01-17 Jason Merrill ++ ++ PR c++/9342 ++ * call.c (build_conditional_expr): Always do lvalue-rvalue ++ conversion. ++ ++2003-01-17 Mark Mitchell ++ ++ PR c++/9294 ++ * cp-tree.def (BASELINK): Make it class 'x', not class 'e'. ++ * cp-tree.h (BASELINK_BINFO): Adjust. ++ (BASELINK_FUNCTIONS): Likewise. ++ (BASELINK_ACCESS_BINFO): Likewise. ++ (tree_baselink): New structure. ++ (cp_tree_node_structure_enum): Add TS_CP_BASELINK. ++ (lang_tree_node): Add baselink. ++ * decl.c (cp_tree_node_structure): Add BASELINK case. ++ * search.c (build_baselink): Adjust. ++ * tree.c (cp_walk_subtrees): Add BASELINK case. Remove BASELINK_P ++ test from TREE_LIST case. ++ ++ PR c++/9272 ++ * parser.c (cp_parser_constructor_declarator_p): Do not assume ++ that a constructor cannot be declared outside of its own class. ++ ++ * parser.c (cp_parser_resolve_typename_type): If the scope cannot ++ be resolved, neither can the qualified name. ++ ++ * rtti.c (get_pseudo_ti_desc): Fix thinko. ++ ++2003-01-16 Jason Merrill ++ ++ PR c++/8564 ++ * init.c (build_vec_init): Re-add maxindex parm. ++ (perform_member_init, build_aggr_init): Pass it. ++ (build_new_1): Pass it. Use an incomplete array type for full_type. ++ * typeck.c (build_modify_expr): Pass it. ++ * cp-tree.h: Adjust. ++ ++2003-01-16 Jeffrey D. Oldham ++ ++ * cp-tree.h (tsubst_copy_and_build): New declaration. ++ * pt.c (tsubst_copy): Remove 'build_expr_from_tree' from comment. ++ (tsubst_expr): Use 'tsubst_copy_and_build'. Update initial comment. ++ (tsubst_copy_and_build): New function. ++ ++2003-01-16 Mark Mitchell ++ ++ * cp-tree.h (lang_type_class): Remove is_partial_instantiation. ++ (PARTIAL_INSTANTIATION_P): Remove. ++ (IMPLICIT_TYPENAME_P): Likewise. ++ (IMPLICIT_TYPENAME_TYPE_DECL_P): Likewise. ++ (build_typename_type): Remove declaration. ++ (parmlist_is_exprlist): Likewise. ++ * decl.c (build_typename_type): Make it static, remove third ++ parameter. ++ (push_class_binding): Don't do implicit typename stuff. ++ (make_typename_type): Likewise. ++ (lookup_name_real): Likewise. ++ (grokdeclarator): Don't try to convert declarations into ++ initializations. Don't do implicit typename stuff. ++ (parmlist_is_exprlist): Remove. ++ (xref_basetypes): Simplify. ++ * decl2.c (grokfield): Don't try to convert declarations into ++ initializations. ++ (build_anon_union_vars): Do this while processing templates, too. ++ (finish_anon_union): Likewise. ++ * error.c (dump_type): Remove implicit typename handling. ++ * parser.c (cp_parser_diagnose_invalid_type_name): New method. ++ (cp_parser_primary_expression): Correct handling of names not ++ found by unqualified name lookup in templates. ++ (cp_parser_nested_name_specifier_opt): Avoid checking dependency ++ of types when possible. ++ (cp_parser_simple_declaration): Complain intelligently about some ++ invalid declarations. ++ (cp_parser_member_declaration): Likewise. ++ (cp_parser_constructor_declarator_p): Don't check when we're in a ++ function scope. ++ * pt.c (instantiate_class_template): Remove ++ PARTIAL_INSTANTIATION_P gunk. ++ * search.c (lookup_field_r): Don't build implicit typenames. ++ (marked_pushdecls_p): Don't enter dependent base types. ++ (unmarked_pushdecls_p): Likewise. ++ * semantics.c (begin_class_definition): Remove implicit typename ++ stuff. ++ ++2003-01-16 Nathan Sidwell ++ ++ PR c++/9212 ++ * parser.c (cp_parser_direct_declarator): If accepting either ++ abstract or named, the name must be an unqualified-id. ++ ++2003-01-16 Kaveh R. Ghazi ++ ++ * class.c (layout_virtual_bases): Avoid signed/unsigned warning. ++ ++2003-01-14 Kaveh R. Ghazi ++ ++ * decl2.c (check_classfn): Fix uninitialized warning. ++ (build_anon_union_vars): Likewise. ++ * pt.c (tsubst_copy): Likewise. ++ ++2003-01-14 Jeffrey D. Oldham ++ ++ Further conform g++'s __vmi_class_type_info to the C++ ABI ++ specification. ++ * rtti.c (dfs_class_hint_mark): Do not set hints not specified by ++ the specification. ++ (class_hint_flags): Likewise. ++ ++2003-01-14 Kriang Lerdsuwanakij ++ ++ * config-lang.in: Add semantics.c to gtfiles. ++ * cp-tree.h (flagged_type_tree_s): Remove lookups field. ++ (saved_scope): Likewise. ++ (type_lookups): Remove. ++ (deferred_access): New structure. ++ (type_access_control): Remove. ++ (save_type_access_control): Likewise. ++ (reset_type_access_control): Likewise. ++ (decl_type_access_control): Likewise. ++ (push_deferring_access_checks): Declare. ++ (resume_deferring_access_checks): Likewise. ++ (stop_deferring_access_checks): Likewise. ++ (pop_deferring_access_checks): Likewise. ++ (get_deferred_access_checks): Likewise. ++ (pop_to_parent_deferring_access_checks): Likewise. ++ (perform_deferred_access_checks): Likewise. ++ (perform_or_defer_access_check): Likewise. ++ * decl.c (make_typename_type): Use perform_or_defer_access_check. ++ (make_unbound_class_template): Likewise. ++ (grokdeclarator): Don't call decl_type_access_control. ++ * parser.c (cp_parser_context): Remove deferred_access_checks ++ and deferring_access_checks_p fields. ++ (cp_parser_context_new): Adjust. ++ (cp_parser): Remove access_checks_lists. ++ (cp_parser_defer_access_check): Remove. ++ (cp_parser_start_deferring_access_checks): Remove. ++ (cp_parser_stop_deferring_access_checks): Remove. ++ (cp_parser_perform_deferred_access_checks): Remove. ++ (cp_parser_nested_name_specifier_opt): Use new deferred access ++ functions. ++ (cp_parser_simple_declaration): Likewise. ++ (cp_parser_template_id): Likewise. ++ (cp_parser_function_definition): Likewise. ++ (cp_parser_class_specifier): Likewise. ++ (cp_parser_lookup_name): Likewise. ++ (cp_parser_single_declaration): Likewise. ++ (cp_parser_pre_parsed_nested_name_specifier): Likewise. ++ (cp_parser_parse_tentatively): Likewise. ++ (cp_parser_parse_definitely): Likewise. ++ (yyparse): Likewise. ++ (cp_parser_init_declarator): Remove access_checks parameter. ++ Use new deferred access functions. ++ (cp_parser_function_definition_from_specifiers_and_declarator): ++ Likewise. ++ (cp_parser_class_head): Remove deferring_access_checks_p and ++ saved_access_checks parameters. Use new deferred access functions. ++ (cp_parser_member_specification_opt): Don't call ++ reset_type_access_control. ++ * search.c (type_access_control): Remove. ++ * semantics.c: Include "gt-cp-semantics.h". ++ (deferred_type_access_control): Remove. ++ (deferred_access_stack): New variable. ++ (deferred_access_free_list): Likewise. ++ (push_deferring_access_checks): New function. ++ (resume_deferring_access_checks): Likewise. ++ (stop_deferring_access_checks): Likewise. ++ (pop_deferring_access_checks): Likewise. ++ (get_deferred_access_checks): Likewise. ++ (pop_to_parent_deferring_access_checks): Likewise. ++ (perform_deferred_access_checks): New function, adapted from ++ cp_parser_perform_deferred_access_checks. ++ (perform_or_defer_access_check): New function, adapted from ++ cp_parser_defer_access_check. ++ (current_type_lookups): Remove. ++ (deferred_type_access_control): Likewise. ++ (decl_type_access_control): Likewise. ++ (save_type_access_control): Likewise. ++ (reset_type_access_control): Likewise. ++ (begin_function_definition): Adjust. ++ (begin_class_definiton): Likewise. ++ ++2003-01-13 Jason Merrill ++ ++ PR c++/8748 ++ * class.c (build_base_path): Take the address before calling save_expr. ++ ++ * call.c (build_user_type_conversion_1): Do set ICS_BAD_FLAG if ++ all the ambiguous conversions are bad. ++ ++ * class.c (maybe_warn_about_overly_private_class): Don't stop ++ searching when we find a nonprivate method. ++ ++ * typeck.c (build_class_member_access_expr): Use unary_complex_lvalue. ++ ++2003-01-12 Mark Mitchell ++ ++ * cp-tree.h (get_arglist_len_in_bytes): Remove. ++ ++ PR c++/9264 ++ * parser.c (cp_parser_elaborated_type_specifier): Handle erroneous ++ typeame types more robustly. ++ ++2003-01-11 Phil Edwards ++ ++ * parser.c: Fix comment typos. ++ ++2003-01-10 Mark Mitchell ++ ++ PR c++/9099 ++ * parser.c (cp_parser_scope_through_which_access_occurs): Handle ++ an object_type which is not a class type. ++ ++2003-01-10 Geoffrey Keating ++ ++ * parser.c (cp_parser_late_parsing_for_member): Don't cast to void. ++ (cp_parser_late_parsing_default_args): Likewise. ++ ++2003-01-10 Nathanael Nerode ++ ++ * cfns.gperf: ANSIfy function declarations. ++ * cfns.h: Regenerate. ++ * cp-tree.h: ANSIfy function declarations. ++ ++2003-01-10 Mark Mitchell ++ ++ * cp-tree.h (reparse_absdcl_as_expr): Remove. ++ (reparse_absdcl_as_casts): Likewise. ++ (reparse_decl_as_expr): Likewise. ++ (finish_decl_parsing): Likewise. ++ * decl2.c (reparse_absdcl_as_expr): Remove. ++ (reparse_absdcl_as_casts): Likewise. ++ (repase_decl_as_expr): Likewise. ++ (finish_decl_parsing): Likewise. ++ ++ PR c++/9128 ++ PR c++/9153 ++ PR c++/9171 ++ * parser.c (cp_parser_pre_parsed_nested_name_specifier): New ++ function. ++ (cp_parser_nested_name_specifier_opt): Correct the ++ check_dependency_p false. ++ (cp_parser_postfix_expression): Fix formatting. ++ (cp_parser_decl_specifier_seq): Avoid looking for constructor ++ declarators when possible. ++ (cp_parser_template_id): Avoid performing name-lookup when ++ possible. ++ (cp_parser_class_head): Do not count specializations when counting ++ levels of templates. ++ (cp_parser_constructor_declarator_p): Return immediately if ++ there's no chance that the tokens form a constructor declarator. ++ * rtti.c (throw_bad_typeid): Add comment. Do not return an ++ expression with reference type. ++ (get_tinfo_decl_dynamic): Do not return an expression with ++ reference type. ++ (build_typeid): Add comment. Do not return an expression with ++ reference type. ++ * typeck.c (build_class_member_access_expr): Improve handling of ++ conditionals and comma-expressions as objects. ++ ++2003-01-09 Nathanael Nerode ++ ++ * cfns.gperf: ANSIfy function declarations. ++ * cfns.h: Regenerate. ++ * cp-tree.h: ANSIfy function declarations. ++ * parser.c: ANSIfy function declarations & definitions. ++ ++ * decl.c (bad_specifiers): Fix parameter order error I introduced. ++ ++2003-01-09 Geoffrey Keating ++ ++ Merge from pch-branch: ++ ++ 2003-01-09 Geoffrey Keating ++ ++ Merge to tag pch-merge-20030102: ++ ++ * semantics.c (finish_translation_unit): Don't call finish_file. ++ * parser.c: Don't include ggc.h. ++ (cp_lexer_new_main): Rename from cp_lexer_new, only create main lexer, ++ read first token here. Don't allow PCH files after the first ++ token is read. ++ (cp_lexer_new_from_tokens): Duplicate functionality from cp_lexer_new. ++ (cp_lexer_get_preprocessor_token): Allow LEXER to be NULL. ++ (cp_parser_new): Call cp_lexer_new_main before allocating GCed memory. ++ (cp_parser_late_parsing_for_member): Don't duplicate call to ++ cp_lexer_set_source_position_from_token. ++ (cp_parser_late_parsing_default_args): Likewise. ++ (yyparse): Call finish_file after clearing the_parser. ++ ++ 2002-12-11 Geoffrey Keating ++ ++ * Make-lang.in: Remove $(GGC_H) from all dependencies. ++ (CXX_TREE_H): Add $(GGC_H). ++ * class.c: Don't include ggc.h. ++ (field_decl_cmp): Make parameters be 'const void *' to match qsort. ++ (method_name_cmp): Likewise. ++ (resort_data): New variable. ++ (resort_field_decl_cmp): New. ++ (resort_method_name_cmp): New. ++ (resort_sorted_fields): New. ++ (resort_type_method_vec): New. ++ (finish_struct_methods): Delete cast. ++ (finish_struct_1): Delete cast. ++ * cp-tree.h: Include ggc.h. ++ (struct lang_type_class): Add reorder attribute to field `methods'. ++ (union lang_decl_u3): Add reorder attribute to field `sorted_fields'. ++ (resort_sorted_fields): New prototype. ++ (resort_type_method_vec): New prototype. ++ * call.c: Don't include ggc.h. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * init.c: Likewise. ++ * lex.c: Likewise. ++ * method.c: Likewise. ++ * optimize.c: Likewise. ++ * parse.y: Likewise. ++ * pt.c: Likewise. ++ * repo.c: Likewise. ++ * search.c: Likewise. ++ * semantics.c: Likewise. ++ * spew.c: Likewise. ++ * tree.c: Likewise. ++ ++ * lang-specs.h: Remove comment. ++ ++ 2002-12-03 Geoffrey Keating ++ ++ * cp-tree.h (struct operator_name_info_t): Mark for GTY machinery. ++ (operator_name_info): Mark to be saved for PCH, specify size. ++ (assignment_operator_name_info): Likewise. ++ ++ 2002-11-19 Geoffrey Keating ++ ++ * decl.c (anon_cnt): Mark to be saved for PCH. ++ ++ 2002-10-25 Geoffrey Keating ++ ++ * lex.c (init_reswords): Delete now-untrue comment. ++ Allocate ridpointers using GGC. ++ ++ 2002-10-04 Geoffrey Keating ++ ++ * cp-tree.h (union lang_decl_u2): Add tags to all fields. ++ ++ * g++spec.c (lang_specific_driver): Don't include standard ++ libraries in `added'. ++ ++ 2002-08-27 Geoffrey Keating ++ ++ * decl2.c (finish_file): Call c_common_write_pch. ++ * Make-lang.in (CXX_C_OBJS): Add c-pch.o. ++ ++ 2002-08-17 Geoffrey Keating ++ ++ * g++spec.c (lang_specific_driver): Treat .h files as C++ header ++ files when using g++. ++ * lang-specs.h: Handle compiling C++ header files. ++ ++2003-01-09 Jakub Jelinek ++ ++ * decl.c (start_decl): Only check DECL_THREAD_LOCAL for VAR_DECLs. ++ ++2003-01-09 Kriang Lerdsuwanakij ++ ++ * pt.c (push_access_scope_real): Call push_to_top_level for ++ function in namespace scope. ++ (pop_access_scope): Call pop_from_top_level for function in ++ namespace scope. ++ ++2003-01-09 Jakub Jelinek ++ ++ * decl.c (start_decl): Don't set DECL_COMMON for __thread variables. ++ ++2003-01-09 Christian Cornelssen ++ ++ * Make-lang.in (c++.install-common, c++.install-man, ++ c++.uninstall): Prepend $(DESTDIR) to destination paths in ++ all (un)installation commands. ++ (c++.install-common): Rewrite $(LN) commands to support ++ DESTDIR with "ln" as well as with "ln -s". ++ ++2003-01-08 Jason Merrill ++ ++ * parser.c (cp_parser_primary_expression): See through explicitly ++ scoped ALIAS_DECLs, too. ++ ++2003-01-08 Nathanael Nerode ++ ++ * decl.c: Remove some #if 0 code. ++ ++ * decl.c: ANSIfy function declarations. ++ ++2003-01-07 Mark Mitchell ++ ++ * parser.c (cp_parser_asm_definition): Correct handling of omitted ++ operands. ++ ++2003-01-08 Kriang Lerdsuwanakij ++ ++ PR c++/9030 ++ * decl.c (make_typename_type): Check access only when tf_error. ++ (make_unbound_class_template): Likewise. ++ * pt.c (saved_access_scope): New variable. ++ (push_access_scope_real): New function. ++ (push_access_scope): Likewise. ++ (pop_access_scope): Likewise. ++ (tsubst_default_argument): Use them. ++ (instantiate_template): Likewise. ++ (regenerate_decl_from_template): Likewise. ++ (instantiate_decl): Likewise. ++ (get_mostly_instantiated_function_type): Likewise. ++ ++2003-01-07 Nathanael Nerode ++ ++ * tree.c: Delete bogus #if 0 code. ++ ++2003-01-07 Andreas Schwab ++ ++ * class.c (layout_class_type): Don't use ++ PCC_BITFIELD_TYPE_MATTERS if not defined. ++ ++2003-01-06 Mark Mitchell ++ ++ PR c++/9165 ++ * decl2.c (build_cleanup): Mark the object as used. ++ ++ * pt.c (retrieve_local_specialization): Revert 2003-01-05 change. ++ (hash_local_specialization): New function. ++ (register_local_specialization): Revert 2003-01-05 change. ++ (instantiate_decl): Use hash_local_specialization when creating ++ the local_specializations table. ++ ++ * decl2.c (mark_used): Do not synthesize thunks. ++ ++ * class.c (layout_class_type): Correct handling of unnamed ++ bitfields wider than their types. ++ ++ PR c++/9189 ++ * parser.c (cp_parser): Remove default_arg_types. Update ++ documentation for unparsed_functions_queues. ++ (cp_parser_late_parsing_default_args): Take a FUNCTION_DECL as the ++ parameter. ++ (cp_parser_new): Don't set parser->default_arg_types. ++ (cp_parser_function_definition): Adjust usage of ++ unparsed_funtions_queues. ++ (cp_parser_class_specifier): Don't mess with ++ parser->default_arg_types. Handle default argument processing in ++ a separate phase from function body processing. ++ (cp_parser_template_declaration_after_export): Adjust usage of ++ unparsed_functions_queues. ++ (cp_parser_late_parsing_for_member): Do not handle default ++ arguments. ++ ++2003-01-06 Nathan Sidwell ++ ++ PR c++/9109 ++ * parser.c (cp_parser_declarator_kind): New enum. ++ (cp_parser_declarator): Adjust. ++ (cp_parser_direct_declarator): Adjust. Allow for either named or ++ abstract declarator. Prefer abstract, if possible. Allow ++ parenthesized function name. ++ (cp_parser_condition): Adjust cp_parser_declarator call. ++ (cp_parser_explicit_instantiation): Likewise. ++ (cp_parser_init_declarator): Likewise. ++ (cp_parser_type_id): Likewise. ++ (cp_parser_function_definition): Likewise. ++ (cp_parser_member_declaration): Likewise. ++ (cp_parser_parameter_declaration): Use cp_parser_declarator to do ++ the tentative parsing. ++ (cp_parser_exception_declaration): Likewise. ++ ++2003-01-05 Mark Mitchell ++ ++ * parser.c (cp_parser_template_parameter): Adjust call to ++ cp_parser_parameter_declaration. ++ (cp_parser_parameter_declaration_list): Likewise. ++ (cp_parser_parameter_declaration): Replace ++ greater_than_is_operator_p with template_parm_p parameter. Do not ++ cache tokens for template default arguments. ++ ++ * pt.c (retrieve_local_specialization): Use htab_find, not ++ htab_find_with_hash. ++ (register_local_specialization): Use htab_find_slot, not ++ htab_find_slot_with_hash. ++ (instantiate_decl): Pass a hash function to htab_create. ++ ++2003-01-04 Kaveh R. Ghazi ++ ++ * parser.c (cp_parser_binary_expression, ++ cp_parser_multiplicative_expression, ++ cp_parser_additive_expression, cp_parser_shift_expression, ++ cp_parser_relational_expression, cp_parser_equality_expression, ++ cp_parser_and_expression, cp_parser_exclusive_or_expression, ++ cp_parser_inclusive_or_expression, ++ cp_parser_logical_and_expression, cp_parser_logical_or_expression, ++ cp_parser_binary_expression): Const-ify. ++ ++2003-01-04 Mark Mitchell ++ ++ * method.c (use_thunk): Disable access control while building the ++ body of the thunk. ++ ++2003-01-03 Nathanael Nerode ++ ++ * cvt.c, decl.c, decl2.c: This is the C++ front end, not the C ++ front end. ++ ++2003-01-03 Matt Austern ++ ++ * cp-tree.h (struct lang_type_class): add field for key method ++ (cp_global_trees): rename dynamic_classes to keyed_classes ++ (key_method): add definition ++ * class.c (finish_struct_1): compute class's key method, and add ++ the class to keyed_classes list if there is no key method. ++ * decl.c (finish_function): add class to keyed_classes list if we ++ see a definition of the class's key method. ++ * pt.c (instantiate_class_template): add template specialization ++ of a dynamic class to keyed_classes list. ++ * decl2.c (key_method): remove ++ (finish_file): iterate only through keyed_classes list when ++ deciding whether to emit vtables, remove class from its list after ++ we do the emission. ++ ++2003-01-02 Jason Merrill ++ ++ * call.c (build_conditional_expr): Stabilize lvalues properly. ++ * cvt.c (ocp_convert): Don't build NOP_EXPRs of class type. ++ * tree.c (lvalue_p_1): Don't allow sloppy NOP_EXPRs as lvalues. ++ Don't allow CALL_EXPR or VA_ARG_EXPR, either. ++ ++ * call.c (convert_like_real): Call decl_constant_value for an ++ IDENTITY_CONV even if there are no more conversions. ++ ++ * cvt.c (build_up_reference): Don't push unnamed temps. ++ ++ * decl2.c (do_namespace_alias): Namespace aliases are DECL_EXTERNAL. ++ ++ * dump.c (cp_dump_tree): Don't try to dump class-specific fields ++ for a backend struct. ++ ++ * except.c (wrap_cleanups_r, build_throw): Make ++ MUST_NOT_THROW_EXPRs void. ++ * init.c (expand_default_init): Update to handle MUST_NOT_THROW_EXPR. ++ ++ * init.c (build_vec_delete_1): Pre-evaluate the base address. ++ ++ * init.c (get_temp_regvar): Simplify logic. ++ ++ * tree.c (cp_copy_res_decl_for_inlining): Only do debug tweaks if ++ our replacement is a decl. ++ ++ * decl.c (cp_make_fname_decl): Push the decls inside the ++ outermost scope. ++ ++2003-01-03 Nathan Sidwell ++ ++ PR c++/45, c++/3784 ++ * tree.c (cp_tree_equal, TEMPLATE_PARM_INDEX): The types must be ++ the same too. ++ ++2003-01-03 Graham Stott ++ ++ * parser.c (struct cp_parser): Add access_checks_lists field ++ (cp_parser_simple_declaration): Use. ++ (cp_parser_init_declarator): Likewise. ++ ++2003-01-02 Mark Mitchell ++ ++ * parser.c (cp_parser_declaration): Accept the __extension__ ++ keyword before the declaration. ++ ++ PR c++/2843 ++ * parser.c (cp_parser_parameter_declaration): Allow attributes to ++ appear after the declarator. ++ ++ * call.c (build_new_method_call): Fix typo in message format ++ string. ++ ++2003-01-02 Mark Mitchell ++ ++ * parser.c (cp_lexer_next_token_is): Declare it inline. ++ (cp_lexer_set_source_position_from_token): Likewise. ++ (cp_lexer_debugging_p): Likewise. ++ (cp_parser_parsing_tentatively): Likewise. ++ (cp_parser_nested_name_specifier_opt): Reduce the number of calls ++ to the cp_lexer_peek_token. ++ ++ * parser.c (cp_parser_sizeof_operand): Do not evaluate the ++ expression. ++ ++2003-01-02 Steven Bosscher ++ ++ * cp/except.c, cp/expr.c, cp/friend.c, cp/g++spec.c, ++ cp/lang-options.h, cp/lang-specs.h, cp/lex.h, cp/ptree.c, ++ cp/repo.c: Fix copyright years. ++ ++2003-01-01 Neil Booth ++ ++ * lex.c: Remove superfluous include of cpplib.h. ++ (CONSTRAINT): Define without conditions. ++ (init_cp_pragma): Use c_register_pragma. ++ ++2002-12-31 Neil Booth ++ ++ * .cvsignore: Remove. ++ ++2002-12-31 Steven Bosscher ++ ++ * call.c, class.c, cp-lang.c, cp-tree.h, cvt.c, dump.c, error.c, ++ except.c, expr.c friend.c, g++spec.c, init.c, lang-options.h, ++ lang-specs.h, lex.c, mangle.c, method.c, optimize.c, parser.c, ++ pt.c, ptree.c, repo.c, rtti.c, search.c, semantics.c, tree.c, ++ typeck.c, typeck2.c: Replace "GNU CC" with "GCC" in the ++ copyright header. ++ * lex.h: parse.y is dead, so don't mention it. Also replace the ++ copyright header with the default GNU copyright header. ++ ++2002-12-31 Mark Mitchell ++ ++ * cp-tree.h (LOOKUP_TEMPLATES_EXPECTED): Remove. ++ (lookup_name_namespace_only): Likewise. ++ (begin_only_namespace_names): Likewise. ++ (end_only_namespace_names): Likewise. ++ * decl.c (only_namespace_names): Remove. ++ (qualify_lookup): Do not check LOOKUP_TEMPLATES_EXPECTED. ++ (lookup_name_real): Do not check only_namespace_names. ++ (lookup_name_namespace_only): Remove. ++ (begin_only_namespace_names): Likewise. ++ (end_only_namespace_names): Likewise. ++ * parser.c (cp_parser_nested_name_specifier_opt): Handle erroneous ++ nested-name-specifiers more gracefully. ++ (cp_parser_class_or_namespace_name): Avoid looking up namespace ++ names when they cannot possibly appear. ++ (cp_parser_template_name): Adjust call to cp_parser_lookup_name. ++ (cp_parser_elaborated_type_specifier): Likewise. ++ (cp_parser_namespace_name): Only look for namespace names. ++ (cp_parser_lookup_name): Add is_namespace parameter. ++ (cp_parser_lookup_name_simple): Adjust call to ++ cp_parser_lookup_name. ++ ++ * parser.c (cp_parser_dependent_type_p): Fix thinko. ++ ++2002-12-31 Neil Booth ++ ++ * .cvsignore: Update. ++ ++2002-12-31 Nathan Sidwell ++ ++ * class.c (modify_vtable_entry): Remove unused variable. ++ (get_vcall_index): Always expect a non-thunk. ++ (update_vtable_entry_for_fn): Combine covariant adjustments, when ++ overriding a thunk. Pass get_vcall_index a non-thunk. ++ ++ * decl2.c (finish_file): Mark undefined inlines as extern. ++ ++2002-12-31 Mark Mitchell ++ ++ * cp-tree.def (RETURN_INIT): Remove. ++ * cp-tree.h (DECL_IN_MEMORY_P): Remove. ++ (scope_kind): Add sk_block, sk_try, sk_catch, sk_for. ++ (note_level_for_for): Remove. ++ (note_level_for_try): Likewise. ++ (note_level_for_catch): Likewise. ++ (finish_named_return_value): Likewise. ++ (do_pushlevel): Change prototype. ++ (pending_lang_change): Remove. ++ * decl.c (begin_scope): Handle sk_block, sk_try, sk_catch, ++ sk_for. ++ (note_level_for_for): Remove. ++ (note_level_for_try): Likewise. ++ (note_level_for_catch): Likewise. ++ (maybe_inject_for_scope_var): Remove use of DECL_IN_MEMORY_P. ++ * parser.c (cp_parser_context_free_list): Make it "deletable". ++ (cp_parser_template_argument): Remove misleading comment. ++ * pt.c (tsubst_expr): Remove RETURN_INIT code. ++ * semantics.c (genrtl_named_return_value): Remove. ++ (do_pushlevel): Take a scope kind as an argument. ++ (begin_if_stmt): Adjust. ++ (begin_while_stmt): Likewise. ++ (begin_for_stmt): Likewise. ++ (finish_for_init_stmt): Likewise. ++ (begin_switch_stmt): Likewise. ++ (begin_handler): Likewise. ++ (begin_compound_stmt): Likewise. ++ (finish_named_return_value): Remove. ++ (cp_expand_stmt): Remove RETURN_INIT case. ++ * tree.c (cp_statement_code_p): Remove RETURN_INIT case. ++ ++2002-12-31 Mark Mitchell ++ ++ PR c++/9112 ++ * parser.c (cp_parser_direct_declarator): Handle erroneous ++ parenthesized declarators correctly. ++ ++2002-12-31 Gabriel Dos Reis ++ ++ * cp-tree.h (pending_lang_change): Declare. ++ ++2002-12-30 Mark Mitchell ++ ++ * parser.c (cp_parser_context_free_list): New variable. ++ (cp_parser_context_new): Use it. ++ (cp_parser_error): Check return code from ++ cp_parser_simulate_error. ++ (cp_parser_simulate_error): Return a value. ++ (cp_parser_id_expression): Optimize common case. ++ (cp_parser_class_name): Likewise. ++ (cp_parser_class_specifier): Adjust call to ++ cp_parser_late_parsing_default_args. ++ (cp_parser_lookup_name): Optimize common case. ++ (cp_parser_late_parsing_for_member): Adjust call to ++ cp_parser_late_parsing_default_args. ++ (cp_parser_late_parsing_default_args): Add scope parameter. ++ (cp_parser_require): Avoid creating the error message unless it's ++ needed. ++ (cp_parser_parse_definitely): Place free'd contexts on the free ++ list. ++ ++ * parser.c (cp_parser_declaration_seq_opt): Handle pending_lang_change. ++ ++2002-12-30 David Edelsohn ++ ++ * parser.c (cp_parser_parameter_declaration_clause): Treat system ++ header as extern "C" if NO_IMPLICIT_EXTERN_C undefined. ++ ++2002-12-30 Nathanael Nerode ++ ++ * config-lang.in, Make-lang.in, operators.def, cp-tree.def: ++ GCC, not GNU CC. ++ ++2002-12-30 Mark Mitchell ++ ++ * parse.y: Remove. ++ * spew.c: Likewise. ++ * Make-lang.in (gt-cp-spew.h): Remove. ++ * cp-tree.h (do_pending_lang_change): Remove. ++ (do_identifier): Change prototype. ++ (finish_id_expr): Remove. ++ * decl.c (lookup_name_real): Remove yylex variable. ++ * decl2.c (build_expr_from_tree): Adjust call to do_identifier. ++ * lex.c (init_cpp_parse): Remove. ++ (reduce_cmp): Likewise. ++ (token_cmp): Likewise. ++ (yychar): Likewise. ++ (lastiddecl): Likewise. ++ (token_count): Likewise. ++ (reduce_count): Likewise. ++ (yyhook): Likewise. ++ (print_parse_statistics): Likewise. ++ (do_pending_lang_change): Likewise. ++ (do_identifier): Remove parsing parameter. ++ * lex.h (lastiddecl): Remove. ++ (looking_for_typename): Remove. ++ (looking_for_template): Likewise. ++ (pending_lang_change): Likewise. ++ (yylex): Likewise. ++ * semantics.c (finish_id_expr): Remove. ++ ++ * decl.c (grokdeclarator): Diagnost "extern thread" and "static ++ thread" correctly. ++ ++2002-12-30 Nathanael Nerode ++ ++ * decl.c, decl2.c, decl.h: GCC, not GNU CC. This is the C++ front ++ end, not the C front end. ++ ++2002-12-30 Nathan Sidwell ++ ++ * cp-tree.h (THUNK_TARGET): New macro. ++ (THUNK_VIRTUAL_OFFSET): For result thunks it is always a binfo. ++ (finish_thunk): Remove offset parms. ++ * class.c (find_final_overrider): Look through thunks. ++ (get_vcall_index): Use THUNK_TARGET. ++ (update_vtable_entry_for_fn): Look through thunks. Set covariant ++ fixed offset here. Adjust finish_thunk call. ++ (build_vtbl_initializer): Adjust finish_thunk calls. ++ * mangle.c (mangle_call_offset): Remove superfluous if. ++ (mangle_thunk): Adjust. ++ * method.c (make_thunk): Adjust. ++ (finish_thunk): Adjust. ++ (thunk_adjust): Remove assert. ++ (use_thunk): Use THUNK_TARGET ++ * dump1.c (cp_dump_tree): Adjust thunk dumping. ++ ++ PR c++/9054 ++ * class.c (layout_class_type): Set TYPE_CONTEXT of type for base. ++ * dump.c (cp_dump_tree, RECORD_TYPE): Deal with type for base types. ++ ++2002-12-28 Gabriel Dos Reis ++ ++ Remove traditional C constructs 4/n. ++ * decl2.c (grok_method_quals, warn_if_unknown_interface, ++ grok_x_components, cp_build_parm_decl, build_artificial_parm, ++ maybe_retrofit_in_chrg, grokclassfn, grok_array_decl, ++ delete_sanity, check_member_template, check_java_method, ++ check_classfn, finish_static_data_member_decl, grokfield, ++ grokbitfield, grokoptypename, grok_function_init, ++ cplus_decl_attributes, constructor_name, defer_fn, ++ build_anon_union_vars, finish_anon_union, coerce_new_type, ++ coerce_delete_type, comdat_linkage, maybe_make_one_only, ++ key_method, import_export_vtable, import_export_class, ++ output_vtable_inherit, import_export_decl, import_export_tinfo, ++ build_cleanup, get_guard, get_guard_bits, get_guard_cond, ++ set_guard, start_objects, finish_objects, ++ start_static_storage_duration_function, ++ finish_static_storage_duration_function, get_priority_info, ++ start_static_initialization_or_destruction, ++ finish_static_initialization_or_destruction, ++ do_static_initialization, do_static_destruction, ++ prune_vars_needing_no_initialization, write_out_vars, ++ reparse_decl_as_expr, finish_decl_parsing, namespace_ancestor, ++ add_using_namespace, merge_functions, ambiguous_decl, ++ lookup_using_namespace, lookup_using_namespace, ++ qualified_lookup_using_namespace, set_decl_namespace, ++ decl_namespace, current_decl_namespace, push_decl_namespace, ++ pop_decl_namespace, push_scope, pop_scope, add_function, ++ arg_assoc_namespace, arg_assoc_template_arg, arg_assoc, ++ lookup_arg_dependent, do_namespace_alias, ++ validate_nonmember_using_decl, do_nonmember_using_decl, ++ do_toplevel_using_decl, do_local_using_decl, ++ do_class_using_decl, do_using_directive, check_default_args, ++ mark_used, handle_class_head): Use C90 prototypings. Use booleans. ++ * parser.c (cp_parser_class_head): Use booleanss. ++ * decl.c (walk_globals, walk_vtables): Likewise. ++ * cp-tree.h (walk_globals_pred, walk_globals_fn, walk_vtables, ++ walk_globals): Change return type from 'int' to 'bool'. ++ * rtti.c (init_rtti_processing, build_headof, throw_bad_cast ++ throw_bad_typeid, get_tinfo_decl_dynamic, typeid_ok_p, ++ build_typeid, tinfo_name, get_tinfo_decl, get_tinfo_ptr, ++ get_typeid, ifnonnull, build_dynamic_cast_1, build_dynamic_cast, ++ qualifier_flags, tinfo_base_init, generic_initializer, ++ ptr_initializer, dfs_class_hint_mark, ptm_initializer, ++ dfs_class_hint_unmark, class_hint_flags, class_initializer, ++ typeinfo_in_lib_p, get_pseudo_ti_init, create_pseudo_type_info, ++ get_pseudo_ti_desc, create_tinfo_types, emit_support_tinfos, ++ unemitted_tinfo_decl_p, emit_tinfo_decl): Likewise. ++ * repo.c (repo_compile_flags, repo_template_declared, ++ repo_template_defined, repo_class_defined, repo_get_id, ++ repo_template_used, repo_vtable_used, repo_inline_used, ++ repo_tinfo_used, repo_template_instantiated, extract_string, ++ open_repo_file, afgets, init_repo, reopen_repo_file_for_write, ++ finish_repo): Likewise. ++ * ptree.c (cxx_print_decl, cxx_print_type, cxx_print_identifier, ++ cxx_print_xnode): Likewise.. ++ * cp-lang.c (ok_to_generate_alias_set_for_type, cxx_get_alias_set, ++ cxx_warn_unused_global_decl, cp_expr_size): Likewise. ++ * cxxfilt.c (demangle_it, print_demangler_list, usage, ++ standard_symbol_characters, hp_symbol_characters, main, fatal): ++ Likewise. ++ (strip_underscore): Change type from 'int' to 'bool'. ++ (main): Use boolean constants. ++ ++2002-12-28 Gabriel Dos Reis ++ ++ Remove traditional C constructs 3/n. ++ * cvt.c (cp_convert_to_pointer, convert_to_pointer_force, ++ build_up_reference, warn_ref_binding, convert_to_reference, ++ convert_from_reference, convert_lvalue, cp_convert, ocp_convert, ++ convert_to_void, convert, convert_force, build_type_conversion, ++ build_expr_type_conversion, type_promotes_to, ++ perform_qualification_conversions): Use C90 prototyping style. ++ * decl2.c (grok_array_decl): Use boolean constant. ++ (delete_sanity): Likewise. ++ * typeck.c (build_unary_op): Likewise. ++ * semantics.c (finish_switch_cond): Likewise. ++ * parser.c (cp_parser_direct_new_declarator): Likewise. ++ * init.c (build_new): Likewise. ++ ++2002-12-27 Mark Mitchell ++ ++ * Make-lang.in (po-generated): Remove parse.c. ++ (CXX_OBJS): Remove parse.o and spew.o. Add parser.o. ++ ($(srcdir)/cp/parse.h): Remove target. ++ ($(srcdir)/cp/parse.c): Likewise. ++ (gt-cp-parse.h): Likewise. ++ (gt-cp-parser.h): New target. ++ (c++.distclean): Do not remove parse.output. ++ (c++.maintainer-clean): Do not remove parse.c or parse.h. ++ (cp/spew.o): Remove target. ++ (cp/lex.o): Adjust dependencies. ++ (cp/pt.o): Likewise. ++ (cp/parse.o): Likewise. ++ (cp/TAGS): Do not mention parse.c. ++ (cp/parser.o): New target. ++ * NEWS: Mention the new parser. ++ * call.c (build_scoped_method_call): Simplify. ++ (build_method_call): Likewise. ++ (build_new_function_call): Adjust calls to add_function_candidate ++ and add_template_candidate. ++ (build_new_op): Improve handling of erroroneous operands. ++ (convert_default_arg): Remove circular argument processing. ++ (name_as_c_string): New function. ++ (build_new_method_call): Use it. ++ (perform_implicit_conversion): Use error_operand_p. ++ * class.c (finish_struct_anon): Use constructor_name_p. ++ (check_field_decls): Likewise. ++ (pop_nested_class): Use OVL_NEXT, not OVL_CHAIN. ++ (resolve_address_of_overloaded_function): Likewise. ++ (instantiate_type): Tweak pointer-to-member handling. ++ (get_primary_binfo): Remove incorrect assertion. ++ * config-lang.in (gtfiles): Add parser.c, remove parse.c. ++ * cp-tree.h (DEFARG_TOKENS): New macro. ++ (default_arg): New structure. ++ (cp_tree_node_structure_enum): Add TS_CP_DEFAULT_ARG. ++ (lang_tree_node): Add default_arg. ++ (cp_tree_index): Add CPTI_TYPE_INFO_REF_TYPE. ++ (type_info_ref_type): New macro. ++ (saved_scope): Make processing_explicit_instantiation a boolean. ++ (check_access): New field. ++ (unparsed_text): Remove. ++ (language_function): Remove unparsed_inlines. ++ (error_operand_p): New macro. ++ (lang_decl): Adjust pending_inline_info. ++ (DEFARG_POINTER): Remove. ++ (tag_types): Add typenames. ++ (lookup_ualified_name): Declare. ++ (lookup_name_real): Likewise. ++ (shadow_tag): Adjust prototype. ++ (get_scope_of_declarator): Declare it. ++ (process_next_inline): Remove it. ++ (check_for_missing_semicolon): Likewise. ++ (maybe_get_template_decl_from_type_decl): Declare it. ++ (finish_label_stmt): Adjust prototype. ++ (finish_non_static_data_meber): Declare it. ++ (finish_pseudo_destructor_call_expr): Rename to ... ++ (finish_pseudo_destructor_expr): ... this. ++ (finish_compound_literal): Declare it. ++ (begin_inline_definitions): Remove it. ++ (init_spew): Remove. ++ (peekyylex): Likewise. ++ (arbitrate_lookup): Likewise. ++ (frob_opname): Likewise. ++ (maybe_snarf_defarg): Likewise. ++ (add_defarg_fn): Likewise. ++ (do_pending_defargs): Likewise. ++ (done_pending_defargs): Likewise. ++ (unprocessed_defarg_fn): Likewise. ++ (replace_defarg): Likewise. ++ (end_input): Likewise. ++ (get_overloaded_fn): Likewise. ++ * cvt.c (convert_to_reference): Improve error handling. ++ * decl.c (lookup_name_real): Do not declare it static. ++ (maybe_push_to_top_level): Set check_access. ++ (identifier_type_value): Adjust call to lookup_name_real. ++ (lookup_qualified_name): New method. ++ (lookup_name_real): Remove special-case parsing code. ++ (lookup_name-nonclass): Adjust call to lookup_name_real. ++ (lookup_name_namespace_only): Likewise. ++ (lookup_name): Likewise. ++ (check_tag_decl): Return the type declared. ++ (shadow_tag): Likewise. ++ (register_dtor_fn): Tweak check_access. ++ (grokfndecl): Use constructor_name_p. ++ (get_scope_of_declarator): New function. ++ (grokdeclarator): Obscure tweaks for slightly different declarator ++ representations. ++ (start_method): Return error_mark_node to indicate failure. ++ (cp_tree_node_structure_enum): Use TS_CP_DEFAULT_ARG for DEFAULT_ARGs. ++ * decl2.c (constructor_name_full): Simplify. ++ (constructor_name): Use it. ++ (build_expr_from_tree): Adjust for changes to do new parser. ++ (push_scope): Improve robustness. ++ (validate_nonmember_using_decl): Process declarations, not names. ++ (do_class_using_decl): Likewise. ++ (handle_class_head): Do not mess with CLASSTYPE_DECLARED_CLASS ++ here. ++ * error.c (dump_expr): Handle IDENTIFIER_NODEs and BASELINKs. ++ * expr.c (cxx_expand_expr): Handle BASELINKs. ++ * init.c (member_init_ok_or_else): Issue more errors. ++ (build_offset_ref): Tweak handling of FUNCTION_DECLs. ++ * lex.c: Do not include parse.h. ++ (yypring): Do not declare. ++ (yylval): Likewise. ++ (make_reference_declarator): Remove error-generating code. ++ (rid_to_yy): Remove. ++ (cxx_init): Do not call init_spew. ++ (yypring): Remove. ++ (check_for_missing_semicolon): Remove. ++ * lex.h (got_scope): Remove. ++ (got_object): Remove. ++ * method.c (hack_identifier): Use finish_non_static_data_member. ++ (implicitly_declare_fn): Adjust use of constructor_name. ++ * parser.c: New file. ++ * pt.c (parse.h): Do not include it. ++ (maybe_get_template_decl_from_template): Do not declare it. ++ (finish_member_template_decl): Tweak. ++ (begin_explicit_instantiation): Adjust for ++ processing_explicit_instantiation being boolean. ++ (end_explicit_instantiation): Likewise. ++ (maybe_process_partial_specialization): Tighten specialization ++ test. ++ (retrieve_local_specialization): Adjust ue of hash table. ++ (eq_local_specializations): New function. ++ (register_local_specialization): Likewise. ++ (push_template_decl_real): Remove unnecessary test. ++ (maybe_get_template_decl_from_type_decl): Don't make it static. ++ (for_each_template_parm_r): Handle TYPEOF_TYPE. ++ (tsubst_copy): Use retrieive_local_specialization to handle ++ PARM_DECL. Adjust handling of CONST_DECLs. Handle BASELINKs. ++ Handle COMPONENT_REFs with pseudo-destructor-expressions. ++ Simplify handling of CALL_EXPR and METHOD_CALL_EXPR. ++ (tsubst_expr): Pass decls, not names, to do_local_using_decl. ++ (unify): Tweak handling of CONST_DECLs. ++ (regenerate_decl_from_template): Use push_nested_class. ++ (template_for_substitution): New funciton. ++ (instantiate_decl): Use it. Register parameters as local ++ specializations. ++ * rtti.c (init_rtti_processing): Set type_info_ref_type. ++ (build_typeid): Use it. ++ (get_typeid): Likeise. ++ * search.c (accessible_p): Use check_access, not ++ flag_access_control. ++ (adjust_result_of_qualified_name_lookup): Pay attention to the ++ context_class. ++ * semantics.c (finish_asm_stmt): Adjust error handling. ++ (finish_label_stmt): Return the statement. ++ (finish_non_static_data_member): New function. ++ (finish_class_expr): Handle BASELINKs. ++ (finish_call_expr): Handle PSEUDO_DTOR_EXPR. ++ (finish_object_call_expr): Simplify handling during templates. ++ (finish_pseudo_destructor_call_expr): Rename to ... ++ (finish_pseudo_dtor_expr): ... this. ++ (finish_compound_literal): New function. ++ (begin_inline_definitions): Remove. ++ (finish_sizeof): Remove special template handling. ++ * spew.c: Do not include parse.h. ++ * tree.c (get_overloaded_fn): Remove. ++ * typeck.c (build_class_member_access_expr): Handle ++ PSEUDO_DTOR_EXPR. Adjust handling of static member functions. ++ (lookup_destructor): New function. ++ (finish_class_member_access_expr): Use it. ++ (convert_arguments): Simplify. ++ (build_unary_op): Handle BASELINKs. ++ ++2002-12-26 Nathan Sidwell ++ ++ PR c++/4803 ++ * decl2.c (mark_used): Defer inline functions. ++ (finish_file): Merge deferred_fns loops. Check all used ++ inline functions have a definition. ++ * method.c (make_thunk): Thunks are not inline. ++ ++ PR c++/5116, c++/764 ++ * call.c (build_new_op): Make sure template class operands are ++ instantiated. ++ ++2002-12-24 Nathan Sidwell ++ ++ PR C++/7964 ++ * cp-tree.h (resolve_scoped_fn_name): Prototype. ++ * call.c (resolve_scoped_fn_name): New function. Deal with ++ more template expansion. Broken out of ... ++ * parse.y (parse_finish_call_expr): ... here. Call it. ++ * decl2.c (build_expr_from_tree, CALL_EXPR): Use ++ resolve_scoped_fn_name and build_call_from_tree. ++ ++ PR c++/9053 ++ * decl.c (duplicate_decls): Templates may be disambiguated by ++ return type. ++ ++ PR c++/8702 ++ * decl2.c (check_classfn): Use lookup_fnfield_1. List all ++ conversion operators on failure. ++ ++2002-12-23 Gabriel Dos Reis ++ ++ Remove traditional C constructs 2/n. ++ * call.c (tourney, build_field_call, equal_functions, joust, ++ compare_ics, build_over_call, build_java_interface_fn_ref, ++ convert_like_real, op_error, build_object_call, resolve_args, ++ build_vfield_ref, check_dtor_name, build_scoped_method_call, ++ build_addr_func, build_call, build_method_call, null_ptr_cst_p, ++ sufficient_parms_p, build_conv, non_reference, strip_top_quals, ++ standard_conversion, reference_related_p, ++ reference_compatible_p, convert_class_to_reference, ++ direct_reference_binding, reference_binding, ++ ,implicit_conversion, is_complete, promoted_arithmetic_type_p, ++ add_template_conv_candidate, any_viable, any_strictly_viable, ++ build_this, splice_viable, print_z_candidates, ++ build_user_type_conversion, build_new_function_call, ++ conditional_conversion, build_conditional_expr, build_new_op, ++ build_op_delete_call, enforce_access, call_builtin_trap, ++ convert_arg_to_ellipsis, build_x_va_arg, cxx_type_promotes_to, ++ convert_default_arg, type_passed_as, convert_for_arg_passing, ++ in_charge_arg_for_name, is_properly_derived_from, ++ maybe_handle_implicit_object, maybe_handle_ref_bind, ++ source_type, add_warning, can_convert, can_convert_arg, ++ perform_implicit_conversion, can_convert_arg_bad, ++ initialize_reference, add_conv_candidate, ++ add_template_candidate_real, add_template_candidate): Ansify. ++ ++2002-12-22 Nathan Sidwell ++ ++ PR c++/8572 ++ * cp-tree.h (grokoptypename): Add SCOPE parameter. ++ * decl2.c (grokoptypename): Add SCOPE parameter. tsubst the type ++ if in a template scope. ++ * parse.y (unoperator): Return the scope. ++ (operator_name): Adjust grokoptypename call. ++ ++2002-12-22 Kriang Lerdsuwanakij ++ ++ * cp-tree.h (make_unbound_class_template): Use tsubst_flags_t. ++ * decl.c (make_unbound_class_template): Adjust. Check for tf_error. ++ * pt.c (tsubst) [OFFSET_TYPE]: Check for tf_error. ++ ++2002-12-20 Kazu Hirata ++ ++ * ChangeLog: Fix a typo. ++ * class.c: Fix comment typos. ++ * cp-tree.h: Likewise. ++ ++2002-12-18 Jason Merrill ++ ++ Handle anonymous unions at the tree level. ++ C++ ABI change: Mangle anonymous unions using the name of their ++ first named field (by depth-first search). Should not cause ++ binary compatibility problems, though, as the compiler previously ++ didn't emit anything for affected unions. ++ * cp-tree.def (ALIAS_DECL): New tree code. ++ * decl2.c (build_anon_union_vars): Build ALIAS_DECLs. Return the ++ first field, not the largest. ++ (finish_anon_union): Don't mess with RTL. Do set DECL_ASSEMBLER_NAME, ++ push the decl, and write it out at namespace scope. ++ * decl.c (lookup_name_real): See through an ALIAS_DECL. ++ (pushdecl): Add namespace bindings for ALIAS_DECLs. ++ * rtti.c (unemitted_tinfo_decl_p): Don't try to look at the name ++ of a decl which doesn't have one. ++ * typeck.c (build_class_member_access_expr): Don't recurse if ++ we already have the type we want. ++ ++2002-12-18 Kriang Lerdsuwanakij ++ ++ PR c++/8099 ++ * friend.c (make_friend_class): Allow partial specialization ++ when declaration is not a template friend. ++ ++2002-12-18 Kriang Lerdsuwanakij ++ ++ PR c++/3663 ++ * pt.c (lookup_template_class): Copy TREE_PRIVATE and ++ TREE_PROTECTED to created decl nodes. ++ ++2002-12-18 Mark Mitchell ++ ++ * class.c (build_base_field): Do not set DECL_PACKED on the ++ FIELD_DECL. ++ ++2002-12-18 Gabriel Dos Reis ++ ++ * cp-tree.h (struct tree_srcloc): Use location_t. ++ (SOURCE_LOCUS): New. ++ (SRCLOC_FILE, SRCLOC_LINE): Adjust. ++ ++2002-12-17 Jason Merrill ++ ++ * decl.c (finish_function): Also complain about no return in ++ templates. ++ * semantics.c (finish_return_stmt): Also call check_return_expr in ++ templates. ++ * typeck.c (check_return_expr): In a template, just remember that we ++ saw a return. ++ ++2002-12-16 Jason Merrill ++ ++ * semantics.c (simplify_aggr_init_exprs_r): Don't change the type ++ of the CALL_EXPR. ++ ++ * semantics.c (do_pushlevel): Call pushlevel after adding the ++ SCOPE_STMT. ++ (do_poplevel): Call poplevel before adding the SCOPE_STMT. ++ * parse.y (function_body): Go back to using compstmt. ++ * decl.c (pushdecl): Skip another level to get to the parms level. ++ ++ * call.c (build_new_method_call): Use is_dummy_object to determine ++ whether or not to evaluate the object parameter to a static member ++ function. ++ ++2002-12-14 Jason Merrill ++ ++ * semantics.c (simplify_aggr_init_exprs_r): Also prepend the ++ return slot for normal functions. Set CALL_EXPR_HAS_RETURN_SLOT_ADDR. ++ * tree.c (build_cplus_new): If the type isn't TREE_ADDRESSABLE, ++ don't bother with an AGGR_INIT_EXPR. ++ (cp_copy_res_decl_for_inlining): If the type isn't TREE_ADDRESSABLE, ++ just generate a new decl normally. Take return slot parm. ++ * cp-tree.h: Adjust prototype. ++ ++2002-12-13 Gabriel Dos Reis ++ ++ PR C++/8031 ++ * cvt.c (convert_to_pointer_force): Don't try comparing against ++ erronous type. ++ ++2002-12-13 Geoffrey Keating ++ ++ * cp-tree.h: Have the multiple-include guards around ++ the entire file. ++ ++2002-12-10 David Edelsohn ++ ++ * cp/spew.c (feed_input): Change limit to last_pos and pos to cur_pos ++ for SPEW_DEBUG. ++ (snarf_method): Same. ++ (snarf_defarg): Same. ++ ++2002-12-10 Mark Mitchell ++ ++ PR c++/8372 ++ * pt.c (tsubst_copy): Handle destructor names more correctly. ++ ++2002-12-10 Matt Austern ++ ++ * cp-tree.h: get rid of needs_virtual_reinit bit. ++ ++2002-12-09 Mark Mitchell ++ ++ * NEWS: Document removal of in-class initialization extension for ++ static data members of non-arithmetic, non-enumeration type. ++ * decl.c (check_static_variable_definition): Do not allow that ++ extension. ++ * decl2.c (grokfield): Do not call digest_init when processing ++ templates. ++ ++2002-12-05 Kaveh R. Ghazi ++ ++ * error.c (dump_expr): Fix format specifier warning. ++ ++2002-12-04 Geoffrey Keating ++ ++ * class.c (finish_struct_1): Correct comment. ++ * cp-tree.c (DECL_SORTED_FIELDS): Likewise. ++ ++2002-12-04 Gabriel Dos Reis ++ ++ PR C++/8799 ++ * error.c (dump_expr): Don't ever try to dump a non-existent ++ expression. ++ ++2002-12-03 Nathan Sidwell ++ ++ Implement covariant returns. ++ * cp-tree.h (IS_AGGR_TYPE_2): Remove. ++ (struct lang_decl_flags): Add this_thunk_p flag. ++ Rename vcall_offset to virtual_offset. ++ (struct lang_decl): Rename delta to fixed_offset. ++ (DECL_THIS_THUNK_P, DECL_RESULT_THUNK_P): New #defines. ++ (SET_DECL_THUNK_P): Add THIS_ADJUSTING arg. ++ (THUNK_DELTA, THUNK_VCALL_OFFSET): Rename to ... ++ (THUNK_FIXED_OFFSET, THUNK_VIRTUAL_OFFSET): ... here. ++ (make_thunk): Add this_adjusting arg. ++ (finish_thunk): Declare. ++ (mangle_thunk): Add this_adjusting arg. ++ * class.c (get_vcall_index): Use base function for lookup. ++ (update_vtable_entry_for_fn): Generate covariant thunk. ++ (finish_struct_1): Set DECL_VINDEX to NULL for thunks. ++ (build_vtbl_initializer): Use base function for lookup. ++ Finish covariant thunk here. Adjust thunk generation. ++ * dump.c (cp_dump_tree): Simplify DECL_GLOBAL_[CD]TOR_P handling. ++ Adjust thunk dumping. ++ * mangle.c (mangle_call_offset): New function. ++ (mangle_thunk): Adjust for covariant thunks. ++ * method.c (make_thunk): Adjust. Do not set name here. ++ (finish_thunk): New function. Set name here. ++ (use_thunk): Generate covariant thunks too. ++ (thunk_adjust): New function. ++ * search.c (covariant_return_p): Remove. Fold into ... ++ (check_final_overrider): ... here. Simplify. ++ * semantics.c (emit_associated_thunks): Walk covariant thunk lists. ++ ++2002-12-03 Jason Merrill ++ ++ PR c++/8674 ++ * call.c (build_over_call): Check specifically for TARGET_EXPR ++ when eliding. ++ ++ PR c++/8461, c++/8625 ++ * call.c (convert_for_arg_passing): Don't mess with error_mark_node. ++ (cp_convert_parm_for_inlining): Remove. ++ * cp-lang.c (LANG_HOOKS_TREE_INLINING_CONVERT_PARM_FOR_INLINING): ++ Remove. ++ * cp-tree.h (ADDR_IS_INVISIREF): Remove. ++ * except.c (stabilize_throw_expr): Remove ADDR_IS_INVISIREF code. ++ ++ * call.c (build_user_type_conversion_1): Don't set ICS_BAD_FLAG on ++ an ambiguous conversion. ++ ++2002-12-03 Mark Mitchell ++ ++ PR c++/8688 ++ * decl.c (reshape_init): Handle erroneous initializers. ++ ++2002-12-02 Mark Mitchell ++ ++ PR c++/8720 ++ * spew.c (remove_last_token): Make sure that last_chunk is set ++ correctly. ++ ++ PR c++/8615 ++ * error.c (dump_expr): Handle character constants with ++ TREE_OVERFLOW set. ++ ++2002-12-02 Kriang Lerdsuwanakij ++ ++ DR 180 ++ * decl.c (grokdeclarator): Require class-key for all friend class. ++ Output the correct type and context in the error message. ++ ++2002-12-01 Mark Mitchell ++ ++ PR c++/5919 ++ * pt.c (unify): Use variably_modified_type_p to test validity of ++ template argument types. ++ ++ PR c++/8727 ++ * cp-tree.h (lang_type_class): Add typeinfo_var. ++ (CLASSTYPE_TYPEINFO_VAR): New macro. ++ * rtti.c (get_tinfo_decl): Use it. ++ ++ PR c++/8663 ++ * init.c (expand_member_init): Always get the main variant of a ++ base class. ++ ++2002-12-01 Mark Mitchell ++ ++ PR c++/8332 ++ PR c++/8493 ++ * decl.c (cxx_init_decl_processing): Use size_type_node, not ++ c_size_type_node. ++ * decl2.c (coerce_new_type): Likewise. ++ * except.c (do_allocate_exception): Likewise. ++ ++2002-11-30 Zack Weinberg ++ ++ * call.c, class.c, cp-lang.c, cvt.c, cxxfilt.c, decl.c, decl2.c, ++ dump.c, error.c, except.c, expr.c, friend.c, g++spec.c, init.c, ++ lex.c, mangle.c, method.c, optimize.c, parse.y, pt.c, ptree.c, ++ repo.c, rtti.c, search.c, semantics.c, spew.c, tree.c, typeck.c, ++ typeck2.c: Include coretypes.h and tm.h. ++ * Make-lang.in: Update dependencies. ++ ++2002-11-30 Mark Mitchell ++ ++ PR c++/8227 ++ * decl.c (layout_var_decl): Deal gracefully with erroneous types. ++ (check_initializer): Validate the type of the initialized ++ variable, even if the initializer is absent. ++ * typeck.c (cp_type_quals): Deal gracefully with erroneous types. ++ ++ PR c++/8214 ++ * typeck.c (convert_for_assignment): Do not use ++ decl_constant_value on the operand. ++ ++ PR c++/8511 ++ * pt.c (instantiate_decl): Handle template friends defined outside ++ of the class correctly. ++ ++2002-11-29 Joe Buck ++ ++ * parse.y (class_head_defn): Set CLASSTYPE_DECLARED_CLASS for ++ anonymous structs. ++ ++2002-11-29 Mark Mitchell ++ ++ * class.c (walk_subobject_offsets): Recur on binfos as well as on ++ types. ++ (layout_nonempty_base_or_field): Pass it a binfo when processing a ++ base class. ++ (layout_empty_base): Likewise. ++ (build_base_field): Likewise. ++ ++2002-11-27 Mark Mitchell ++ ++ * class.c (build_base_field): Make sure we get the canonical base ++ when descending through primary bases. ++ ++2002-11-26 Geoffrey Keating ++ ++ * decl.c (check_initializer): Don't error on initialisation of ++ a scalar with a brace-enclosed expression. ++ ++2002-11-26 Nathan Sidwell ++ ++ * cp-tree.h (DECL_LANG_FLAG_4): Document more uses. ++ (template_parms_equal): Remove prototype. ++ * typeck.c (buuld_indirect_ref): Reformat. ++ ++2002-11-25 Jason Merrill ++ ++ * init.c (build_vec_init): Use a FOR_STMT instead of an IF_STMT ++ and a DO_STMT. ++ ++2002-11-25 Mark Mitchell ++ ++ * tree.c (cp_build_qualified_type_real): Correct handling of ++ array types. ++ * class.c (walk_subobject_offsets): Fix thinko. ++ (build_base_field): Record offsets of empty bases in primary ++ virtual bases. ++ (layout_class_type): Record offsets of empty bases in fields. ++ ++ * search.c (is_subobject_of_p_1): Fix thinko. ++ (lookup_field_queue_p): Likewise. ++ ++2002-11-24 Mark Mitchell ++ ++ * class.c (layout_class_type): Reuse tail padding when laying out ++ virtual bases. ++ ++2002-11-22 Mark Mitchell ++ ++ * rtti.c (qualifier_flags): Fix thinko. ++ ++2002-11-21 Gabriel Dos Reis ++ ++ Remove traditional C constructs 1/n. ++ * cp-tree.h (init_method, set_mangled_name_for_decl, ++ build_opfncall, hack_identifier, make_thunk, use_thunk, ++ synthesize_method, implicitly_declare_fn, ++ skip_artificial_parms_for, optimize_function, calls_setjmp_p, ++ maybe_clone_body): Remove use of PARAMS. ++ ++ * method.c (do_build_assign_ref, do_build_copy_constructor, ++ synthesize_exception_spec, locate_dtor, locate_ctor, locate_copy): ++ Likewise. ++ (synthesize_method): Use 'bool' type and constants instead of ++ 'int'. ++ (locate_copy): Likewise. ++ (implicitly_declare_fn): Likewise. ++ ++ * optimize.c (calls_setjmp_r, update_cloned_parm, dump_function): ++ Remove old-style declaration. ++ (maybe_clone_body): Use 'bool' type and constants. ++ ++2002-11-21 Glen Nakamura ++ ++ PR c++/8342 ++ * typeck.c (get_member_function_from_ptrfunc): Make sure that a ++ SAVE_EXPR for instance_ptr doesn't get evaluated first inside one ++ of the branches of a COND_EXPR. ++ ++2002-11-19 Mark Mitchell ++ ++ * pt.c (for_each_template_parm): Free allocated memory. ++ * search.c (is_subobject_of_p_1): New function. ++ (is_subobject_of_p): Avoid walking virtual bases multiple times. ++ ++2002-11-19 Jason Thorpe ++ ++ * g++spec.c (lang_specific_spec_functions): New. ++ ++2002-11-15 Kazu Hirata ++ ++ * ChangeLog: Follow spelling conventions. ++ * class.c: Likewise. ++ * decl2.c: Likewise. ++ ++2002-11-14 Zack Weinberg ++ ++ * search.c (dfs_push_decls): Do not try to reorder elements ++ 3..n of method_vec if method_vec has only two elements. ++ Reverse order of two tests to avoid accessing unallocated ++ memory. ++ ++2002-11-14 Mark Mitchell ++ ++ * class.c (dfs_find_final_overrider): Adjust so that the most ++ derived object is a binfo, rather than a class type. ++ (find_final_overrider): Likewise. ++ (add_vcall_offset_vtbl_entries_1): Simplify accordingly. ++ (add_vcall_offset): Likewise. ++ ++2002-11-09 Kriang Lerdsuwanakij ++ ++ PR c++/8389 ++ * pt.c (instantiate_template): Push class scope for member ++ functions. ++ (get_mostly_instantiated_function_type): Likewise. Don't call ++ tsubst on context. Remove CONTEXTP and TPARMSP parameters. ++ * cp-tree.h (get_mostly_instantiated_function_type): Adjust. ++ * mangle.c (write_encoding, write_unqualified_name): Adjust. ++ ++2002-11-07 Mark Mitchell ++ ++ * class.c (add_vcall_offset_vtbl_entries_1): Correct ordering of ++ vcall offfsets. Split out ... ++ (add_vcall_offset): ... new function. ++ ++ PR c++/8338 ++ * pt.c (for_each_template_parm): Add htab parameter. ++ (process_partial_specialization): Adjust call. ++ (push_template_decl_real): Likewise. ++ (pair_fn_data): Add visited. ++ (for_each_template_parm_r): Avoid walking duplicates more than ++ once. ++ (uses_template_parms): Adjust call to for_each_template_parm. ++ ++2002-11-07 Mark Mitchell ++ ++ * class.c (add_implicitly_declared_members): Put implicitly ++ declared functions at the end of TYPE_METHODs when -fabi-version ++ is at least 2. ++ ++2002-11-05 Geoffrey Keating ++ ++ * decl2.c (finish_file): Correct spelling. ++ ++2002-11-03 Mark Mitchell ++ ++ * call.c (build_special_member_call): Do not try to lookup VTTs by ++ name. ++ * class.c (vtbl_init_data): Add generate_vcall_entries. ++ (get_vtable_decl): Do not look up virtual tables by name. ++ (copy_virtuals): Do not use BV_USE_VCALL_INDEX_P. ++ (set_primary_base): Do not set CLASSTYPE_RTTI. ++ (determine_primary_base): Likewise. ++ (get_matching_virtual): Remove. ++ (get_vcall_index): New function. ++ (update_vtable_entry_for_fn): Do not try to use virtual thunks ++ when they are not required. Assign vcall indices at this point. ++ (finish_struct_1): Do not set CLASSTYPE_NEEDS_VIRTUAL_REINIT. ++ Do update dynamic_classes. ++ (build_vtt): Do not add VTTs to the symbol table. ++ (build_ctor_vtbl_group): Likewise. ++ (build_vtbl_initializer): Simplify handling of vcall indices. ++ (build_vcall_offset_vtbl_entries): Pretend to build vcall offsets ++ for the most derived class. ++ (add_vcall_offset_vtbl_entries_1): But do not actually add them to ++ the vtable. ++ * cp-tree.h (dynamic_classes): New macro. ++ (lang_type_class): Remove rtti. Add vtables. Add vcall_indices. ++ (CLASSTYPE_RTTI): Remove. ++ (CLASSTYPE_NEEDS_VIRTUAL_REINIT): Remove. ++ (CLASSTYPE_VCALL_INDICES): New macro. ++ (CLASSTYPE_VTABLES): Likewise. ++ (BV_USE_VCALL_INDEX_P): Remove. ++ (build_vtable_path): Remove. ++ * decl2.c (finish_vtable_vardecl): Remove. ++ (key_method): Remove #if 0'd code. ++ (finish_vtable_vardecl): Rename to ... ++ (maybe_emit_vtables): ... this. ++ (finish_file): Use it. ++ * search.c (look_for_overrides_here): Update comment. ++ ++2002-11-01 Zack Weinberg ++ ++ PR c/7353 redux ++ * decl2.c (grokfield): Reject TYPE_DECLs with initializers. ++ ++2002-10-30 Jason Merrill ++ ++ PR c++/8186 ++ * cp-tree.h (ADDR_IS_INVISIREF): New macro. ++ * call.c (convert_for_arg_passing): Set it. ++ * except.c (stabilize_throw_expr): Recurse for such an arg. ++ ++2002-10-31 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Remove init_priority. ++ (lang_decl): Add delta. ++ (GLOBAL_INIT_PRIORITY): Remove. ++ (THUNK_DELTA): Revise definition. ++ * decl2.c (start_objects): Don't set GLOBAL_INIT_PRIORITY. ++ * dump.c (cp_dump_tree): Don't dump it. ++ ++2002-10-30 Mark Mitchell ++ ++ PR c++/8160 ++ * typeck2.c (process_init_constructor): Call complete_array_type. ++ ++ PR c++/8149 ++ * decl.c (make_typename_type): Issue errors about invalid results. ++ ++2002-10-30 Kriang Lerdsuwanakij ++ ++ Core issue 287, PR c++/7639 ++ * cp-tree.h (lang_type_class): Add decl_list field. ++ (CLASSTYPE_DECL_LIST): New macro. ++ (maybe_add_class_template_decl_list): Add declaration. ++ * class.c (duplicate_tag_error): Initialize CLASSTYPE_DECL_LIST. ++ (unreverse_member_declarations): Reverse CLASSTYPE_DECL_LIST. ++ (maybe_add_class_template_decl_list): New function. ++ (add_implicitly_declared_members): Use it. ++ * decl.c (maybe_process_template_type_declaration): Likewise. ++ (pushtag): Likewise. ++ * friend.c (add_friend): Likewise. ++ (make_friend_class): Likewise. ++ * semantics.c (finish_member_declaration): Likewise. ++ (begin_class_definition): Initialize CLASSTYPE_DECL_LIST. ++ * pt.c (instantiate_class_template): Use CLASSTYPE_DECL_LIST ++ to process members and friends in the order of declaration. ++ ++2002-10-29 Mark Mitchell ++ ++ PR c++/8287 ++ * decl.c (finish_destructor_body): Create the label to jump to ++ when returning from a destructor here. ++ (finish_function_body): Rather than here. ++ ++2002-10-25 Zack Weinberg ++ ++ PR c++/7266 ++ * decl.c (grokdeclarator): Check that TREE_OPERAND 0 of a ++ SCOPE_REF is not null before dereferencing it. ++ ++2002-10-25 Mark Mitchell ++ ++ * call.c (build_over_call): Use DECL_CONTEXT, not ++ DECL_VIRTUAL_CONTEXT. ++ * class.c (modify_vtable_entry): Don't mess with ++ DECL_VIRTUAL_CONTEXT. ++ (set_vindex): Remove. ++ (set_primary_base): Remove vfuns_p parameter. ++ (determine_primary_base): Likewise. ++ (modify_all_vtables): Likewise. ++ (layout_class_type): Likewise. Adjust calls to other functions ++ accordingly. ++ (finish_struct_1): Adjust calls to modified functions. Set ++ DECL_VINDEX here. ++ * cp-tree.h (lang_type_class): Remove vsize. ++ (CLASSTYPE_VSIZE): Remove. ++ (lang_decl): Remove thunks. ++ (DECL_THUNKS): Adjust. ++ (DECL_VIRTUAL_CONTEXT): Remove. ++ (duplicate_decls): Don't copy it. ++ * pt.c (build_template_decl): Don't set it. ++ (tsubst_decl): Likewise. ++ * typeck.c (expand_ptrmemfunc_cst): Don't use it. ++ ++ * class.c (build_vtbl_initializer): Don't use build_vtable_entry. ++ (build_vtable_entry): Remove. ++ * cp-tree.h (BINFO_VIRTUALS): Expand documentation. ++ (lang_decl): Add thunks. ++ (DECL_THUNKS): New macro. ++ * decl.c (duplicate_decls): Copy it. ++ * method.c (make_thunk): Simplify, and add thunks to DECL_THUNKS. ++ * semantics.c (emit_associated_thunks): Simplify. ++ ++2002-10-24 David Edelsohn ++ ++ PR c++/7228 ++ * cp-tree.h (CLASSTYPE_READONLY_FIELDS_NEED_INIT): Check that ++ lang_type structure exists before accessing field. ++ (SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT): New macro. ++ (CLASSTYPE_REF_FIELDS_NEED_INIT): Similar. ++ (SET_CLASSTYPE_REF_FIELDS_NEED_INIT): New macro. ++ * class.c (check_field_decls): Use new macros. ++ * typeck2.c (process_init_constructor): Remove redundant check for ++ existence of lang_type structure. ++ ++2002-10-24 Mark Mitchell ++ ++ * class.c (end_of_base): New method. ++ (end_of_class): Use it. Check indirect virtual bases. ++ ++ * class.c (check_field_decls): Fix typo. ++ ++2002-10-23 Mark Mitchell ++ ++ PR c++/8067 ++ * decl.c (maybe_inject_for_scope_var): Ignore __FUNCTION__ and ++ related variables. ++ ++ PR c++/7679 ++ * spew.c (next_token): Do not return an endless stream of ++ END_OF_SAVED_INPUT tokens. ++ (snarf_method): Add three END_OF_SAVED_INPUT tokens to the end of ++ the cached token stream. ++ (snarf_defarg): Likewise. ++ ++2002-10-23 Zack Weinberg ++ ++ * cp-lang.c (cp_var_mod_type_p): New: C++ hook for ++ variably_modified_type_p. ++ * cp-tree.h: Remove prototype of variably_modified_type_p. ++ * tree.c (variably_modified_type_p): Remove; now implemented ++ in language-independent code. ++ ++2002-10-22 Mark Mitchell ++ ++ PR c++/6579 ++ * spew.c (snarf_parenthesized_expression): New function. ++ (snarf_block): Use it. ++ ++2002-10-22 Richard Henderson ++ ++ * method.c (use_thunk): Always compute vcall_value; assert that ++ it is not zero. Use can_output_mi_thunk; use output_mi_thunk ++ for vcall thunks as well. ++ ++2002-10-21 Mark Mitchell ++ ++ * class.c (empty_base_at_nonzero_offset_p): New function. ++ (layout_nonempty_base_or_field): Do not check for conflicts when ++ laying out a virtual base using the GCC 3.2 ABI. ++ (build_base_field): Correct checking for presence of empty classes ++ at nonzero offsets when clearing CLASSTYPE_NEARLY_EMPTY_P. ++ ++ * class.c (include_empty_classes): Use normalize_rli. ++ (layout_class_type): Likewise. ++ ++ * decl.c (reshape_init): Tweak handling of character arrays. ++ ++ PR c++/8218 ++ * cp-tree.h (lang_type_class): Add contains_empty_class_p. ++ (CLASSTYPE_CONTAINS_EMPTY_CLASS_P): New macro. ++ * class.c (check_bases): Update CLASSTYPE_CONTAINS_EMPTY_CLASS_P. ++ (check_field_decls): Likewise. ++ (layout_class_type): Likewise. ++ (finish_struct_1): Initialize it. ++ (walk_subobject_offsets): Use it to prune searches. ++ ++2002-10-20 Mark Mitchell ++ ++ * method.c (use_thunk): Compute the vcall index as a HOST_WIDE_INT. ++ * optimize.c (optimize_function): Replace ASM_OUTPUT_MI_THUNK with ++ TARGET_ASM_OUTPUT_MI_THUNK in comments. ++ ++2002-10-18 Zack Weinberg ++ ++ * decl.c (start_decl): Point users of the old initialized- ++ typedef extension at __typeof__. ++ ++2002-10-18 Mark Mitchell ++ ++ * Make-lang.in (method.o): Depend on TARGET_H. ++ * method.c (target.h): Include it. ++ (use_thunk): Use target hooks. Use vcall thunks, if available. ++ ++2002-10-18 Mark Mitchell ++ ++ * class.c (base_derived_from): Make sure return value is a bool. ++ ++2002-10-18 Mark Mitchell ++ ++ * class.c (find_final_overrider_data_s): Remove overriding_fn and ++ overriding_base. ++ (dfs_base_derived_from): New function. ++ (base_derived_from): Likewise. ++ (dfs_find_final_overrider): Use base_derived_from. ++ (find_final_overrider): Adjust. ++ ++2002-10-18 Jason Merrill ++ ++ PR c++/8080 ++ * semantics.c (finish_for_cond, finish_while_cond): Don't mess ++ with condition decls in a template. ++ ++2002-10-17 Nathan Sidwell ++ ++ * class.c (add_method): Compare template parms too. ++ ++2002-10-17 Mark Mitchell ++ ++ PR c++/7584 ++ * class.c (handle_using_decl): Allow the declaration used to be ++ from an ambiguous base. ++ ++ * pt.c (convert_template_argument): Revert this change: ++ 2002-10-16 Mark Mitchell ++ * pt.c (convert_template_argument): Do not fold non-type ++ template rguments when inside a template. ++ ++ * init.c (expand_default_init): Handle brace-enclosed initializers ++ correctly. ++ ++2002-10-16 Mark Mitchell ++ ++ * mangle.c (write_expression): Correct handling of enumeration ++ constants. ++ (write_template_arg): Likewise. ++ * pt.c (convert_template_argument): Do not fold non-type template ++ arguments when inside a template. ++ ++ PR c++/7478 ++ * cvt.c (convert_to_reference): Allow references as the incoming ++ type. ++ ++2002-10-16 Mark Mitchell ++ ++ PR c++/7524 ++ * method.c (do_build_assign_ref): Use cp_build_qualified_type, not ++ build_qualified_type. ++ ++2002-10-15 Richard Henderson ++ ++ * error.c (dump_expr): Use real_to_decimal directly, and with ++ the new arguments. ++ ++2002-10-15 Mark Mitchell ++ ++ * decl.c (reshape_init): Fix typo. ++ ++ * cp-tree.h (operator_name_info_t): Add arity. ++ * lex.c (init_operators): Initialize it. ++ * mangle.c (write_conversion_operator_name): New function. ++ (write_unqualified_name): Use it. ++ (write_template_args): Accept template arguments as a TREE_LIST. ++ (write_expression): Adjust handling of qualified names to match ++ specification. ++ ++2002-10-15 Jason Merrill ++ ++ * call.c (call_builtin_trap): New fn. ++ (convert_arg_to_ellipsis): Use it. Downgrade error to warning. ++ (build_call): Don't set current_function_returns_abnormally outside ++ a function. ++ ++2002-10-14 Mark Mitchell ++ ++ * class.c (check_field_decls): Remove empty_p parameter. Instead, ++ clear CLASSTYPE_EMPTY_P. ++ (build_base_field): Likewise. ++ (build_base_fields): Likewise. ++ (check_bases_and_members): Likewise. ++ (create_vtbl_ptr): Likewise. ++ (layout_class_type): Likewise. Ensure that empty classes have ++ size zero when used as base classes in the 3.2 ABI. ++ (finish_struct_1): Initialize CLASSTYPE_EMPTY_P and ++ CLASSTYPE_NEARLY_EMPTY_P. Adjust calls to avoid passing empty_p ++ parameter. ++ (is_empty_class): Correct definition when using post-3.2 ABI. ++ * cp-tree.h (lang_type_class): Add empty_p. ++ (CLASSTYPE_EMPTY_P): New macro. ++ ++2002-10-12 Nathan Sidwell ++ ++ * init.c (build_delete): Do not apply save_expr for arrays. ++ (build_vec_delete): Likewise. ++ ++2002-10-14 Mark Mitchell ++ ++ * decl.c (layout_var_decl): Call layout_decl even for variables ++ whose type is an array with unspecified bounds. ++ ++ PR c++/7176 ++ * lex.c (do_identifier): Add another option for the parsing ++ parameter. ++ * parse.y (do_id): Use it. ++ ++2002-10-11 Gabriel Dos Reis ++ ++ PRs C++/6803, C++/7721 and C++/7803 ++ * decl.c (grokdeclarator): Gracefully handle template-name as ++ decl-specifier. ++ ++2002-10-11 Jason Molenda ++ ++ * init.c (build_field_list): Provide uses_unions_p with a default ++ value. ++ ++2002-10-11 Mark Mitchell ++ ++ PR c++/5661 ++ * cp-tree.h (variably_modified_type_p): New function. ++ (grokdeclarator) Tighten check for variably modified types as ++ fields. ++ * pt.c (convert_template_argument): Do not allow variably modified ++ types as template arguments. ++ * tree.c (variably_modified_type_p): New function. ++ ++ * NEWS: Document removal of "new X = ..." extension. ++ * class.c (initialize_array): Set TREE_HAS_CONSTRUCTOR on ++ brace-enclosed initializers. ++ * cp-tree.h (CP_AGGREGATE_TYPE_P): New macro. ++ (initialize_local_var): Remove declaration. ++ (expand_static_init): Likewise. ++ * decl.c (next_initializable_field): New function. ++ (reshape_init): Likewise. ++ (check_initializer): Use them. Build dynamic initializer for ++ aggregates here too. ++ (initialize_local_var): Simplify, and incorporate cleanup ++ insertion code as well. ++ (destroy_local_var): Remove. ++ (cp_finish_decl): Tidy. ++ (expand_static_init): Fold checks for whether or not a variable ++ needs initialization into this function. Simplify. ++ * decl2.c (do_static_initialization): Simplify. ++ * init.c (build_init): Do not set TREE_SIDE_EFFECTS when it will ++ be done for us automatically. ++ (expand_default_init): Handle brace-enclosed initializers ++ correctly. ++ (expand_aggr_init_1): Remove RTL-generation code. ++ (build_vec_init): Remove "new X = ..." support. ++ * parse.y (new_initializer): Likewise. ++ * rtti.c (get_pseudo_ti_init): Set TREE_HAS_CONSTRUCTOR on ++ brace-enclosed initializer. ++ (create_pseudo_type_info): Likewise. ++ * typeck2.c (store_init_value): Don't try to handle digest_init ++ being called more than once. ++ (digest_init): Tidy handling of brace-enclosed initializers. ++ ++2002-10-10 Kaveh R. Ghazi ++ ++ * decl.c (typename_hash): Use htab_hash_pointer. ++ ++2002-10-10 Jim Wilson ++ ++ * decl.c (duplicate_decls): Don't call decl_attributes. ++ ++2002-10-09 Zack Weinberg ++ ++ PR c/7353 ++ * decl.c (start_decl): Unconditionally issue error for ++ 'typedef foo = bar'. ++ (cp_finish_decl): Remove special case for TYPE_DECL with initializer. ++ (grokdeclarator): Remove redundant error for 'typedef foo = bar'. ++ ++2002-10-09 Kaveh R. Ghazi ++ ++ * decl2.c (prune_vtable_vardecl): Delete unused function. ++ ++2002-10-03 Mark Mitchell ++ ++ PR c++/7754 ++ * decl2.c (finish_anon_union): Do not expand anonymous unions when ++ procesing template functions. ++ * pt.c (tsubst_decl, case VAR_DECL): Try to complete the variable ++ type. Call layout_decl. ++ (tsubst_expr, case DECL_STMT): Handle anonymous unions. ++ ++2002-10-07 Richard Henderson ++ ++ * decl2.c, pt.c: Revert c++/7754 fix. ++ ++2002-10-05 Kriang Lerdsuwanakij ++ ++ PR c++/7804 ++ * error.c (dump_expr) [REAL_CST]: Output in decimal format. ++ ++2002-10-03 Mark Mitchell ++ ++ PR c++/7931 ++ * pt.c (for_each_template_parm_r): Handle BASELINKs. ++ ++ PR c++/7754 ++ * decl2.c (finish_anon_union): Do not expand anonymous unions when ++ procesing template functions. ++ * pt.c (tsubst_decl, case VAR_DECL): Try to complete the variable ++ type. Call layout_decl. ++ (tsubst_expr, case DECL_STMT): Handle anonymous unions. ++ ++2002-10-03 Mark Mitchell ++ ++ PR c++/8006 ++ * mangle.c (CLASSTYPE_TEMPLATE_ID_P): Handle instances of template ++ template parameters. ++ (globals): Add entity and need_abi_warning. ++ (decl_is_template_id): Use TYPE_TEMPLATE_INFO, not ++ CLASSTYPE_TEMPLATE_INFO. ++ (is_std_substitution): Use CLASSTYPE_TI_TEMPLATE, not ++ TYPE_TI_TEMPLATE. ++ (write_prefix): Handle typename types correctly. ++ (write_template_prefix): Handle template template parameters ++ correctly. ++ (start_mangling): Add entity parameter. ++ (finish_mangling): Warn about names whose mangling will change. ++ (mangle_decl_string): Adjust. ++ (mangle_type_string): Likewise. ++ (mangle_special_for_type): Likewise. ++ (mangle_ctor_vtbl_for_type): Likewise. ++ (mangle_thunk): Likewise. ++ (mangle_guard_variable): Likewise. ++ (mangle_ref_init_variable): Likewise. ++ ++2002-10-02 Mark Mitchell ++ ++ PR c++/7188. ++ * cp-tree.def (CTOR_INITIALIZER): Use one slot, not two. ++ * cp-tree.h (emit_base_init): Rename to .... ++ (emit_mem_initializers): ... this. ++ (expand_member_init): Change prototype. ++ * init.c (perform_member_init): Compute explicit, rather than ++ requiring it as a parameter. ++ (sort_member_init): Rename to ... ++ (sort_mem_initializers): ... this. Process bases and data members ++ together. ++ (sort_base_init): Remove. ++ (emit_base_init): Rename to ... ++ (emit_mem_initializers): ... this. ++ (expand_aggr_vbase_init_1): Remove. ++ (construct_virtual_bases): Rename to ... ++ (construct_virtual_base): ... this. ++ (expand_member_init): Rework handling of base initializers. ++ * method.c (do_build_copy_constructor): Use ++ finish_mem_initializers. ++ * parse.y (member_init): Adjust calls to expand_member_init. ++ * pt.c (tsubst_expr): Simplify CTOR_INITIALIZER case. ++ (tsubst_initializer_list): Use expand_member_init. ++ * semantics.c (finish_mem_intiailizers): Simplify. ++ ++2002-10-02 Matt Austern ++ * decl.c (walk_vtables_r): Fixed typo that caused result to ++ never get a nonzero value. ++ ++2002-10-02 Roger Sayle ++ ++ PR optimization/6627 ++ * cp-tree.h (enum ptrmemfunc_vbit_where_t): Delete definition ++ from here, and move it to tree.h. ++ * decl.c (cxx_init_decl_processing): If storing the vbit ++ in function pointers, ensure that force_align_functions_log ++ is atleast one. ++ ++2002-10-02 Matt Austern ++ ++ * class.c (check_field_decls): Changed warning about const member ++ variables so that it doesn't get issued for a class aggregate. ++ ++2002-10-01 Mark Mitchell ++ ++ * decl.c (cp_finish_decl): Make sure array types are laid out, ++ even if the array bounds are unknown. ++ ++2002-10-01 Steve Ellcey ++ ++ * class.c (build_vtbl_initializer): Change build_c_cast ++ to build1. ++ ++2002-10-01 Mark Mitchell ++ ++ * decl.c (cp_finish_decl): Make sure array types are laid out, ++ even if the array bounds are unknown. ++ ++ * decl.c (cp_finish_decl): Correct check for dynamic ++ initialization of thread-local storage. ++ ++2002-09-30 Nathan Sidwell ++ ++ * tree.c (really_overloaded_fn): TEMPLATE_ID_EXPRs are also ++ overloaded. ++ ++2002-09-30 Steve Ellcey ++ ++ * class.c (build_vtbl_initializer): Add cast. ++ (add_vcall_offset_vtbl_entries_1): ++ Use TARGET_VTABLE_DATA_ENTRY_DISTANCE for offset. ++ ++2002-09-30 Mark Mitchell ++ ++ * class.c (walk_subobject_offsets): Correct the calculation of ++ offsets for virtual bases. Correct the counting of array ++ elements. ++ (layout_nonempty_base_or_field): Simplify. Correct the ++ calculation of offsets to be propagated through the binfo ++ hierarchy. ++ (build_base_field): Avoid creating a FIELD_DECL for empty bases. ++ Add the FIELD_DECL to TYPE_FIELDS. ++ (build_base_fields): Adjust accordingly. ++ (layout_virtual_bases): Use build_base_field. ++ (end_of_class): Return a tree, not an integer. ++ (warn_about_ambiguous_direct_bases): Rename to ... ++ (warn_about_ambiguous_bases): ... this. ++ (include_empty_classes): New function. ++ (layout_class_type): Create an alternative version of the type to ++ be used when as a base class type. Do not call ++ finish_record_layout until we are done laying out the class. ++ * cp-tree.h (lang_type_class): Remove size, size_unit. Add ++ as_base. ++ (CLASSTYPE_SIZE): Reimplement. ++ (CLASSTYPE_SIZE_UNIT): Likewise. ++ (CLASSTYPE_ALIGN): Likweise. ++ (CLASSTYPE_USER_ALIGN): Likewise. ++ (CLASSTYPE_AS_BASE): New macro. ++ (DECL_INITIALIZED_P): Likewise. ++ (extract_init): Remove prototype. ++ (build_forced_zero_init): Rename to ... ++ (build_zero_init): ... this. ++ (force_store_init_value): Remove. ++ * decl.c (obscure_complex_init): Remove. ++ (duplicate_decls): Copy DECL_INITIALIZED_P. ++ (check_initializer): Do not leave junk in DECL_INITIAL. ++ (cp_finish_decl): Handle zero-initialization of entities with ++ static storage duration. ++ * expr.c (extract_init): Remove. ++ * init.c (build_forced_zero_init): Remove. ++ (build_zero_init): New function. ++ (build_default_init): Use it. ++ (build_field_list): Skip FIELD_DECLs for base subobjects. ++ (push_base_cleanups): Likewise. ++ * method.c (do_build_assign_ref): Likewise. ++ (synthesize_exception_spec): Likewise. ++ * pt.c (tsubst_decl): Clear DECL_INITIALIZED_P. ++ (regenerate_decl_from_template): To not set DECL_INITIAL for a ++ static data member whose initialization took place in its class. ++ (instantiate_decl): Do not pass an initializer to cp_finish_decl ++ in that situation. ++ * search.c (dfs_push_decls): Skip FIELD_DECLs for base subobjects. ++ (dfs_unuse_fields): Likewise. ++ * tree.c (pod_type_p): Handle error_mark_node. ++ (zero_init_p): Likewise. ++ * typeck.c (lookup_anon_field): Skip FIELD_DECLs for base ++ subobjects. ++ * typeck2.c (store_init_value): Remove #if 0'd code. ++ (force_store_init_value): Remove. ++ (process_init_constructor): Use build_zero_init. ++ ++2002-09-29 Nathan Sidwell ++ ++ PR c++/7788 ++ * rtti.c (unemitted_tinfo_decl_p): Check it has a field. ++ ++2002-09-29 Kazu Hirata ++ ++ * cp-tree.h: Fix comment typos. ++ * decl.c: Likewise. ++ * pt.c: Likewise. ++ ++2002-09-25 Mark Mitchell ++ ++ * cp/class.c (contains_empty_class_p): New method. ++ (walk_subobject_offsets): Correct computation of field offset. ++ (layout_empty_base): Correct placement of emtpy base classes. ++ (layout_class_type): Warn about ABI changes. ++ ++2002-09-23 Mark Mitchell ++ ++ * cp/class.c (layout_virtual_bases): Do not round the size of the ++ type to a multiple of the alignment before laying out virtual bases. ++ (layout_class_type): Correct handling of bit-fields that are wider ++ than their type inside unions. Round the size of the type to a ++ even number of bytes when computing the size without virtual ++ bases. ++ * cp/cp-tree.h (abi_version_at_least): New macro. ++ ++2002-09-21 Kazu Hirata ++ ++ * ChangeLog: Follow spelling conventions. ++ * ChangeLog.2: Likewise. ++ * call.c: Likewise. ++ * class.c: Likewise. ++ * cp-tree.h: Likewise. ++ * cvt.c: Likewise. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * except.c: Likewise. ++ * friend.c: Likewise. ++ * g++spec.c: Likewise. ++ * init.c: Likewise. ++ * lex.c: Likewise. ++ * mangle.c: Likewise. ++ * method.c: Likewise. ++ * operators.def: Likewise. ++ * optimize.c: Likewise. ++ * pt.c: Likewise. ++ * rtti.c: Likewise. ++ * search.c: Likewise. ++ * semantics.c: Likewise. ++ * spew.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ ++2002-09-18 Devang Patel ++ ++ * cp/cp-tree.h: New prototype for walk_vtabls(). ++ * cp/decl.c (walk_vtables_r): New function. ++ (struct cp_binding_level): Add new members, namespaces, ++ names_size and vtables. ++ (add_decl_to_level): Add decl in namespaces or vtables ++ chain, if conditions match. ++ (walk_vtables): New function. ++ (walk_namespaces_r): Travers separate namespace chain ++ for namespace decls. ++ (wrapup_globals_for_namespace): Use names_size instead ++ of list_length(). ++ * cp/decl2.c (finish_file): Use walk_vtables() instead of ++ walk_globals() to walk vtable decls. ++ ++2002-09-18 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Use assert, not internal_error. Don't ++ ICE with invalid pointers & references. ++ ++2002-09-17 Zack Weinberg ++ ++ * Make-lang.in: Remove all references to the demangler. ++ * cxxfilt.c: Moved to binutils. ++ ++2002-09-16 Nathan Sidwell ++ ++ PR c++/7718 ++ * pt.c (tsubst_decl): Remove assert. ++ ++ Remove DR 295 implementation. ++ * pt.c (check_cv_quals_for_unify): Disable function & method cases. ++ * tree.c (cp_build_qualified_type_real): Likewise. Don't warn ++ about ignoring volatile qualifiers. ++ ++ * search.c (lookup_member): Correct documentation. ++ ++2002-09-16 Geoffrey Keating ++ ++ * cp-tree.h (union lang_tree_node): Add chain_next option. ++ ++2002-09-16 Nathan Sidwell ++ ++ * parse.y (parse_finish_call_expr): Check lookup_member result. ++ ++ PR c++/7015 ++ * semantic.c (finish_asm_stmt): Fix operand/output_operands ++ thinko. ++ * typeck.c (c_expand_asm_operands): Protect from error_mark_node. ++ ++2002-09-15 Nathan Sidwell ++ ++ PR c++/7919 ++ * call.c (build_over_call): Convert this pointer for fns found by ++ using decls. ++ ++2002-09-15 Kazu Hirata ++ ++ * ChangeLog: Follow spelling conventions. ++ * ChangeLog.1: Likewise. ++ ++2002-09-14 Nathan Sidwell ++ ++ PR c++/7768 ++ * pt.c (build_template_decl): Copy DECL_DESTRUCTOR_P. ++ ++2002-09-14 Kazu Hirata ++ ++ * error.c: Fix comment formatting. ++ * except.c: Likewise. ++ * expr.c: Likewise. ++ * friend.c: Likewise. ++ * g++spec.c: Likewise. ++ * init.c: Likewise. ++ * lex.c: Likewise. ++ * mangle.c: Likewise. ++ * method.c: Likewise. ++ * optimize.c: Likewise. ++ * pt.c: Likewise. ++ * rtti.c: Likewise. ++ * search.c: Likewise. ++ * semantics.c: Likewise. ++ * spew.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ * typeck2.c: Likewise. ++ ++2002-09-13 Matt Austern ++ ++ PR C++/7828 ++ * cp/cp-tree.h, cp/tree.c: New function non_cast_lvalue_p. ++ * cp/call.c: Change call-by-const-reference mechanism to use ++ non_cast_lvalue_p when deciding whether the create a temporary. ++ We need a temporary when passing, e.g. (long) x by const ref. ++ ++2002-09-13 Nathan Sidwell ++ ++ * pt.c (unify, ARRAY_TYPE): Element type can be more qualified. ++ ++2002-09-13 Kazu Hirata ++ ++ * decl.c: Fix comment formatting. ++ * decl2.c: Likewise. ++ ++2002-09-12 Kazu Hirata ++ ++ * call.c: Fix comment formatting. ++ * class.c: Likewise. ++ * cp-lang.c: Likewise. ++ * cp-tree.h: Likewise. ++ * cvt.c: Likewise. ++ ++2002-09-11 Zack Weinberg ++ ++ * Make-lang.in: Build cp/cxxfilt.o from $(srcdir)/cp/cxxfilt.c, ++ and c++filt from cxxfilt.o + version.o + $(LIBDEPS). ++ * cxxfilt.c: New file: split from libiberty/cplus-dem.c, with ++ minor adjustments (use version_string, eliminate yet another ++ duplicate of xmalloc) ++ ++2002-09-08 Kaveh R. Ghazi ++ ++ * cp-tree.h (require_complete_eh_spec_types): Add prototype. ++ ++2002-09-05 Jason Merrill ++ ++ * typeck2.c (add_exception_specifier): Only pedwarn for an ++ incomplete type. ++ (require_complete_eh_spec_types): New fn. ++ (cxx_incomplete_type_diagnostic): Also support pedwarning. ++ * typeck.c (complete_type_or_diagnostic): Likewise. ++ * call.c (build_call): Call require_complete_eh_spec_types. ++ * rtti.c (get_pseudo_ti_desc): Give an error rather than aborting ++ on an incomplete type. ++ ++2002-09-04 Jakub Jelinek ++ ++ * decl.c (start_cleanup_fn): Clear interface_only before ++ start_function, restore it afterwards. ++ ++2002-09-02 Nathan Sidwell ++ ++ * cp-tree.h (finish_builtin_type): Remove. ++ * decl2.c (finish_builtin_type): Move to common code. ++ * decl.c (build_ptrmemfunc_type): Adjust. ++ * rtti.c (create_pseudo_type_info): Adjust. ++ (create_tinfo_types): Adjust. ++ ++2002-08-31 Jason Merrill ++ ++ * cp-lang.c (cp_expr_size): Allow initialization from a ++ CONSTRUCTOR. ++ ++2002-08-30 Richard Henderson ++ ++ PR opt/7515 ++ * tree.c: Include target.h. ++ (cp_cannot_inline_tree_fn): Don't auto-inline functions that ++ don't bind locally. ++ * Makefile.in (tree.o): Update. ++ ++2002-08-27 Mark Mitchell ++ ++ * class.c (layout_virtual_bases): Warn about bugs in G++ that ++ result in incorrect object layouts. ++ (layout_class_type): Likewise. ++ ++2002-08-24 Matt Austern ++ ++ * tree.c (lvalue_p_1): Add argument for whether casts of lvalues ++ are allowable. ++ (real_lvalue_p): Update caller. ++ (lvalue_p): Ditto. ++ (non_cast_lvalue_or_else): New. ++ * tree.h: Declare it. ++ * typeck.c (build_unary_op): Use non_cast_lvalue_or_else. ++ ++2002-08-22 Mark Mitchell ++ ++ * typeck.c (build_class_member_access_expr): Handle COMPOUND_EXPR ++ and COND_EXPR specially; fix error message output. ++ ++2002-08-22 Jason Merrill ++ ++ * pt.c (tsubst_expr): RETURN_EXPR is now RETURN_STMT_EXPR. ++ * semantics.c (nullify_returns_r): Likewise. ++ ++2002-08-17 Gabriel Dos Reis ++ ++ Fix PR/7621 ++ * typeck.c (finish_class_member_access_expr): Diagnose cases where ++ name lookup finds nothing. ++ ++2002-08-15 Jason Merrill ++ ++ * semantics.c (finish_then_clause): Remove redundant assignment. ++ (finish_if_stmt, begin_switch_stmt, finish_switch_stmt): Move the ++ extra binding level outside the if/switch statement. ++ (finish_while_cond, finish_for_cond): Rewrite complex condition ++ into the loop body. ++ ++2002-08-15 Alexandre Oliva ++ ++ * parse.y (sizeof, alignof, typeof): New non-terminals to ++ increment skip_evaluation. Replace terminals with them and ++ decrement skip_evaluation at the end of rules using them. ++ * decl2.c (mark_used): Don't assemble_external if ++ skipping evaluation. ++ ++2002-08-15 Gabriel Dos Reis ++ ++ Fix PR/7504 ++ * parse.y (parse_finish_call_expr): Handle incomplete ++ type used to name a scope. ++ ++2002-08-15 Nathan Sidwell ++ ++ PR c++/7598 ++ * typeck.c (build_unary_op): Fold offsetof idiom. Fixes ++ regression caused by my 2002-08-08 patch. ++ ++2002-08-13 Mark Mitchell ++ ++ * decl.c (pushdecl_class_level): Honor requests to bind names to ++ OVERLOADs. ++ ++2002-08-11 Kaveh R. Ghazi ++ ++ * decl2.c (build_call_from_tree): Fix uninitialized variable. ++ * parse.y (parse_finish_call_expr): Likewise. ++ * repo.c (old_args, old_dir, old_main): Const-ify. ++ ++2002-08-11 Gabriel Dos Reis ++ ++ * decl.c (duplicate_decls): Replace DECL_SOURCE_FILE ++ DECL_SOURCE_LINE with DECL_SOURCE_LOCATION. ++ * optimize.c (maybe_clone_body): Likewise. ++ * pt.c (tsubst_enum): Likewise. ++ (lookup_template_class): Likewise. ++ * tree.c (cp_copy_res_decl_for_inlining): Likewise. ++ ++2002-08-10 Neil Booth ++ ++ * lang-specs.h: Remove -ansi. ++ ++2002-08-10 Nathan Sidwell ++ ++ * tree.c (maybe_dummy_object): Replace // with /* */ ++ ++2002-08-09 Mark Mitchell ++ ++ * call.c (standard_conversion): Use build_ptrmem_type. ++ * cp-tree.h (build_ptrmem_type): New function. ++ (adjust_result_of_qualified_name_lookup): Likewise. ++ * decl.c (grokvardecl): Do not look for OFFSET_TYPEs to indicate ++ static data members. ++ (build_ptrmem_type): New function. ++ (grokdeclarator): Do not use build_offset_type when encountering a ++ qualified name. ++ * parse.y (parse_finish_call_expr): Use ++ adjust_result_of_qualified_name_lookup. ++ * search.c (adjust_result_of_qualified_name_lookup): New function. ++ * typeck.c (qualify_type_recursive): Use TYPE_PTRMEM_* rather than ++ accessing OFFSET_TYPEs directly. ++ ++2002-08-08 Mike Stump ++ ++ * call.c (add_builtin_candidate): legal -> valid, illegal -> invalid. ++ (type_decays_to): Likewise. ++ * class.c (find_final_overrider): Likewise. ++ (maybe_note_name_used_in_class): Likewise. ++ * decl.c (current_tmpl_spec_kind): Likewise. ++ (add_binding): Likewise. ++ (push_class_binding): Likewise. ++ (duplicate_decls): Likewise. ++ (layout_var_decl): Likewise. ++ (grokfndecl): Likewise. ++ (grokdeclarator): Likewise. ++ (check_default_argument): Likewise. ++ * decl2.c (handle_class_head): Likewise. ++ * error.c (dump_template_decl): Likewise. ++ * init.c (build_offset_ref): Likewise. ++ * pt.c (check_specialization_scope): Likewise. ++ (determine_specialization): Likewise. ++ (check_explicit_specialization): Likewise. ++ (maybe_check_template_type): Likewise. ++ (process_partial_specialization): Likewise. ++ (check_default_tmpl_args): Likewise. ++ (push_template_decl_real): Likewise. ++ (convert_template_argument): Likewise. ++ (try_class_unification): Likewise. ++ (get_bindings_real): Likewise. ++ (do_decl_instantiation): Likewise. ++ * semantics.c (begin_function_definition): Likewise. ++ (finish_member_declaration): Likewise. ++ (check_multiple_declarators): Likewise. ++ * typeck.c (comp_array_types): Likewise. ++ (comptypes): Likewise. ++ (expr_sizeof): Likewise. ++ (build_binary_op): Likewise. ++ (dubious_conversion_warnings): Likewise. ++ (check_return_expr): Likewise. ++ ++2002-08-08 Mark Mitchell ++ ++ * typeck.c (build_class_member_access_expr): Do not return ++ error_mark_node when no error has occurred. ++ ++2002-08-08 Nathan Sidwell ++ ++ * typeck.c (build_component_addr): Remove. ++ (build_unary_op): Just check it's not a bitfield, and then build ++ an ADDR_EXPR. ++ ++2002-08-08 Nathan Sidwell ++ ++ * class.c (convert_to_base): Correct check for error_mark_node. ++ (create_vtable_ptr): Remove unused VFUNS_P parm. ++ ++2002-08-08 Nathan Sidwell ++ ++ * cp/Make-lang.in (c++.mostlyclean): Remove coverage files. ++ ++2002-08-07 Mark Mitchell ++ ++ Rework build_component_ref. ++ * call.c (build_vfield_ref): Do not go through build_component_ref. ++ (build_field_call): Use build_class_member_access_expr. ++ (build_user_type_conversion_1): Use BASELINK_FUNCTIONS. ++ (build_object_call): Likewise. ++ * class.c (convert_to_base): New function. ++ (type_requires_array_cookie): Use BASELINK_FUNCTIONS. ++ (instantiate_type): Handle BASELINKs. ++ * cp-tree.def (BASELINK): New tree code. ++ * cp-tree.h (BASELINK_P): Reimplement. ++ (SET_BASELINK_P): Remove. ++ (BASELINK_BINFO): Reimplement. ++ (BASELINK_FUNCTIONS): Likewise. ++ (BASELINK_ACCESS_BINFO): Likewise. ++ (BASELINK_OPTYPE): Likewise. ++ (convert_to_base): New function. ++ (name_p): Likewise. ++ (build_object_ref): Remove. ++ (build_component_ref_1): Likewise. ++ (build_component_ref): Likewise. ++ (build_x_component_ref): Likewise. ++ (build_class_member_access_expr): New function. ++ (finish_class_member_access_expr): Likewise. ++ (build_ptrmemfunc_access_expr): Likewise. ++ * decl.c (grokdeclarator): Handle BASELINKs. ++ * decl2. (build_expr_from_tree): Handle COMPONENT_REFs by using ++ finish_class_member_access_expr. ++ (arg_assoc): Handle BASELINKs. ++ (do_class_using_decl): Likewise. ++ * error.c (dump_decl): Likewise. ++ (dump_expr): Use build_ptrmemfunc_access_expr. ++ * except.c (dtor_nothrow): Use CLASSTYPE_DESTRUCTORS to find ++ destructors. ++ (build_throw): Use BASELINK_FUNCTIONS. ++ * init.c (perform_member_init): Use ++ build_class_member_access_expr. ++ (build_offset_ref): Handle BASELINKs. Use ++ build_class_member_access_expr. ++ * method.c (hack_identifier): Likewise. ++ * parse.y (do_id): Use BASELINK, not TREE_LIST. ++ (primary): Remove uses of build_object_ref. ++ * pt.c (lookup_template_function): Handle BASELINKs. ++ (resolve_overloaded_unification): Likewise. ++ * search.c (build_baselink): Build a BASELINK, not a TREE_LIST. ++ (lookup_field): Use BASELINK, not TREE_LIST. ++ (lookup_fnfiels): Likewise. ++ (setup_class_bindings): Likewise. ++ * semantics.c (finish_object_call_expr): Do not use ++ build_method_call when we already know what function is being ++ called. ++ * spew.c (identifier_type): Use BASELINK, not TREE_LIST. ++ * tree.c (really_overloaded_fn): Use OVL_CHAIN for OVERLOADs, not ++ TREE_CHAIN. ++ (name_p): New function. ++ * typeck.c (build_object_ref): Remove. ++ (build_component_ref_1): Likewise. ++ (build_x_component_ref): Likewise. ++ (build_class_member_access_expr): New function. ++ (finish_class_member_access_expr): Likewise. ++ (build_ptrmemfunc_access_expr): Likewise. ++ (get_member_function_from_ptrfunc): Use ++ build_ptrmemfunc_access_expr. ++ (build_binary_op): Likewise. ++ (build_unary_op): Likewise. ++ (build_ptrmemfunc): Likewise. ++ (pfn_from_ptrmemfunc): Likewise. ++ * typeck2.c (build_m_component_ref): Adjust comment. ++ ++2002-08-07 Neil Booth ++ ++ * Make-lang.in (CXX_C_OBJS): Update. ++ * cp-lang.c (LANG_HOOKS_DECODE_OPTION): Use c_common_decode_option. ++ * cp-tree.h (cxx_decode_option): Remove. ++ * decl2.c (compare_options, lang_f_options, unsupported_options, ++ cxx_decode_option): Remove. ++ ++2002-08-06 Gabriel Dos Reis ++ ++ * typeck.c (build_x_unary_op): Handle pointer-to-member. ++ ++2002-08-05 Geoffrey Keating ++ ++ * class.c: Don't include obstack.h. ++ (popclass): ++ * decl2.c: Delete bogus comment. ++ * error.c: Don't include obstack.h. ++ * except.c: Likewise. ++ (dump_type): Correct comment. ++ * method.c: Don't include obstack.h. ++ * tree.c: Likewise. ++ ++2002-08-04 Gabriel Dos Reis ++ ++ Fix PR/2213 ++ * cvt.c (cp_convert_to_pointer): Reject conversions from integral ++ expressions to pointer-to-data-member of pointer-to-member-functions. ++ ++2002-08-04 Geoffrey Keating ++ ++ * cvt.c (ocp_convert): Delete obsolete code. ++ * parse.y (permanent_obstack): Delete declaration. ++ * pt.c (permanent_obstack): Delete declaration. ++ * repo.c (permanent_obstack): Delete declaration. ++ (open_repo_file): Use xmalloc instead of permanent_obstack. ++ (init_repo): Use xstrdup instead of permanent_obstack. ++ ++2002-08-04 Nathan Sidwell ++ ++ * cp-tree.h (VF_DERIVED_VALUE): Remove. ++ * class.c (finish_struct_1): Use VF_BINFO_VALUE not VF_DERIVED_VALUE. ++ ++2002-08-03 Nathan Sidwell ++ ++ PR 7470. ++ C++ ABI change - vfunc ordering. ++ * class.c (add_virtual_function): Remove. ++ (dfs_modify_all_vtables): Take list of all declared ++ virtuals. Assign all that are not in primary base. ++ (check_for_override): Adjust comments. ++ (create_vtable_ptr): Take single list of virtuals. Build chain ++ of declared virtuals here. ++ (layout_class_type): Take single list of virtuals. Adjust. ++ (finish_struct_1): Keep virtuals on single list. Adjust. ++ ++2002-08-02 Mark Mitchell ++ ++ * init.c (build_member_call): Use build_new_method_call, not ++ build_method_call. ++ ++2002-08-02 Krister Walfridsson ++ ++ * Make-lang.in (spew.o, lex.o, pt.o): Add path to parse.h dependencies. ++ ++2002-08-02 Mark Mitchell ++ ++ * call.c (build_method_call): Issue a more helpful error message ++ about ambiguous method names. ++ ++2002-08-02 Nathan Sidwell ++ ++ * tree.c (build_shared_int_cst): Make cache file scope, and ++ GTY it. ++ ++2002-08-02 Jason Merrill ++ ++ * cp-lang.c (LANG_HOOKS_EXPR_SIZE): Define. ++ (cp_expr_size): New fn. ++ * call.c (build_over_call): Lose empty class hackery. ++ (convert_arg_to_ellipsis): Promote non-POD warning to error. ++ * typeck.c (build_modify_expr): Don't use save_expr on an lvalue. ++ ++ * semantics.c (expand_body): Do tree optimization in the function ++ context, too. ++ ++2002-08-01 Neil Booth ++ ++ * cp-tree.h: Move all warning and flag declarations to c-common.h. ++ * decl.c: Move all warning and flag variables to c-common.c. ++ * decl2.c: Move all warning and flag variables to c-common.c. ++ * lex.c (flag_digraphs): Remove. ++ (warn_traditional): Now in c-common.c. ++ ++2002-07-31 Mark Mitchell ++ ++ * call.c (build_field_call): Do not look up the field by name. ++ (build_method_call): Simplify. ++ (struct z_candidate): Add access_path and conversion_path. Remove ++ basetype_path. ++ (convert_class_to_reference): Adjust use of ++ add_function_candidate. ++ (add_candidate): Add conversion_path argument. ++ (add_function_candidate): Use it. ++ (add_conv_dndidate): Likewise. ++ (build_builtin_candidate): Likewise. ++ (add_template_candidate_real): Add conversion_path argument. ++ (add_template_conv_candidate): Likewise. ++ (add_template_candidate): Likewise. ++ (build_user_type_conversion_1): Use it. ++ (build_new_function_call): Remove name lookup code. Adjust use of ++ add_template_candidate and add_function_candidate. ++ (build_new_op): Likewise. ++ (convert_like_real): Use build_special_member_call. ++ (build_over_call): Use cand->conversion_path. ++ (build_special_member_call): New method. ++ (build_new_method_call): Remove name lookup code. ++ * cp-tree.def (OFFSET_REF): Update documentation. ++ (TEMPLATE_ID_EXPR): Likewise. ++ * cp-tree.h (BASELINK_ACCESS_BINFO): New macro. ++ (BASELINK_OPTYPE): Likewise. ++ (build_new_method_call): Adjust prototype. ++ (build_special_member_call): New method. ++ (build_baselink): New method. ++ (build_offset_ref_call_from_tree): Likewise. ++ (build_call_from_tree): Likewise. ++ (finish_qualified_call_expr): Remove. ++ (finish_call_expr): Adjust prototype. ++ (build_x_function_call): Remove. ++ * cvt.c (ocp_convert): Use build_special_member_call. ++ * decl2.c (reparse_absdcl_as_expr): Use finish_call_expr. ++ (build_expr_from_tree): Adjust handling for TEMPLATE_ID_EXPR and ++ CALL_EXPR. ++ (build_offset_ref_call_from_tree): New function. ++ (build_call_from_tree): Likewise. ++ * init.c (expand_cleanup): Use build_special_member_call. ++ (expand_default_init): Likewise. ++ (build_member_call): Use finish_call_expr. ++ (build_new_1): Use build_special_member_call. ++ (push_base_cleanups): Likewise. ++ * method.c (do_build_assign_ref): Likewise. ++ * parse.y (template_id): Do not pass a COMPONENT_REF to ++ lookup_template_function. ++ (primary): Use parse_finish_call_epxr, not finish_call_expr. ++ (parse_finish_call_expr): New function. ++ * pt.c (lookup_template_function): Add assertions. ++ * search.c (lookup_base): Allow T to be a binfo. ++ (build_baselink): New function. ++ (lookup_member): Use it. ++ * semantics.c (finish_call_expr): Do not do name lookup. ++ (finish_object_call_expr): Remove #if 0'd code. ++ (finish_qualified_call_expr): Remove. ++ * typeck.c (build_x_function_call): Remove. ++ (build_static_case): Use build_special_member_call. ++ * typeck2.c (build_functional_cast): Likewise. ++ ++2002-07-30 Franz Sirl ++ ++ * lang-specs.h: Remove __GXX_ABI_VERSION, moved to gcc.c. ++ ++2002-07-30 Gabriel Dos Reis ++ ++ * cp-tree.h (VF_DERIVED_VALUE): Restore from previous deletion. ++ ++2002-07-30 Nathan Sidwell ++ ++ * cp-tree.h (CLASSTYPE_VFIELDS, VF_*, BV_*): Add more ++ documentation. ++ ++2002-07-29 Alan Modra ++ ++ * cp-tree.h: Comment typo fix. ++ ++2002-07-29 Richard Earnshaw ++ ++ * spew.c (space_for_token): Allocate zeroed memory for a new token ++ chunk. ++ ++2002-07-27 Roger Sayle ++ ++ * decl.c (builtin_function_1): No need to explicitly mark ++ BUILT_IN_RETURN and BUILT_IN_EH_RETURN as noreturn. ++ ++2002-07-27 Roger Sayle ++ ++ * decl2.c (cxx_decode_option): Support -fno-builtin-foo. ++ ++2002-07-26 Jason Merrill ++ ++ * call.c (build_over_call): Likewise. ++ (cp_convert_parm_for_inlining): New fn. ++ (convert_for_arg_passing): New fn. ++ (convert_default_arg, build_over_call): Use it. ++ (type_passed_as): New fn. ++ * pt.c (tsubst_decl): Use it. ++ * decl2.c (cp_build_parm_decl): New fn. ++ (build_artificial_parm): Use it. ++ (start_static_storage_duration_function): Likewise. ++ * decl.c (start_cleanup_fn, grokdeclarater): Likewise. ++ (grokparms): Don't mess with DECL_ARG_TYPE. ++ * typeck.c (convert_arguments): Use convert_for_arg_passing. ++ * cp-lang.c (LANG_HOOKS_TREE_INLINING_CONVERT_PARM_FOR_INLINING): ++ Define. ++ * cp-tree.h: Declare new fns. ++ ++2002-07-26 Neil Booth ++ ++ * cp-tree.h (flag_operator_names): Remove. ++ * decl2.c (flag_operator_names): Remove. ++ (lang_f_options): Remove operator-names. ++ * lex.c (D_OPNAME): Remove. ++ (reswords): Remove operator names. ++ (rid_to_yy): Remove operator names. ++ (init_reswords): No need to handle D_OPNAME. ++ * spew.c (read_process_identifier): There are no operator ++ names. ++ ++2002-07-26 Jason Merrill ++ ++ * dump.c (cp_dump_tree): Call c_dump_tree. ++ * Make-lang.in (CXX_C_OBJS): Add c-dump.o. ++ ++2002-07-25 Neil Booth ++ ++ * error.c (print_whitespace): Remove. ++ * g++spec.c (LIBUNWIND): Move. ++ * mangle.c (mangled_position, write_signed_number): Remove. ++ ++2002-07-25 Neil Booth ++ ++ * decl2.c (cxx_decode_option): Similarly. ++ ++2002-07-25 Gabriel Dos Reis ++ ++ * cp-tree.h (cxx_sizeof_nowarn): Now a macro. ++ (cxx_sizeof_or_alignof_type): Take a third argument. ++ (cxx_sizeof): Adjust definition. ++ (cxx_alignof): Likewise. ++ * init.c (build_delete): Use cxx_sizeof_nowarn to reflect reality. ++ * typeck.c (cxx_sizeof_or_alignof_type): Take a third argument for ++ complaining. ++ (c_sizeof_nowarn): Remove definition. ++ (build_unary_op): Use cxx_sizeof_nowarn. ++ ++2002-07-24 Geoffrey Keating ++ ++ * tree.c (cp_build_qualified_type_real): When copying ++ pointer-to-method types, unshare the record that holds ++ the cached pointer-to-member-function type. ++ ++2002-07-23 Neil Booth ++ ++ * cp-tree.h (FILE_FUNCTION_PREFIX_LEN): Remove. ++ ++2002-07-23 Gabriel Dos Reis ++ ++ Fix PR/7363: ++ * typeck.c (cxx_sizeof_or_alignof_type): New function. ++ (c_sizeof): Remove definition. ++ (expr_sizeof): Use cxx_sizeof. ++ * decl2.c (build_expr_from_tree): Use cxx_sizeof_or_alignof_type. ++ * decl.c (finish_destructor_body): Use cxx_sizeof. ++ * semantics.c (finish_alignof): Likewise. ++ (finish_alignof): Use cxx_alignof. ++ * cp-tree.h (cxx_sizeof, cxx_alignof): New macros. ++ (cxx_sizeof_or_alignof_type): Declare. ++ (my_friendly_assert): Move to ../c-common.h. ++ ++2002-07-23 Neil Booth ++ ++ * class.c, method.c, pt.c, search.c: Don't define obstack macros. ++ ++2002-07-22 Kriang Lerdsuwanakij ++ ++ PR c++/7347, c++/7348 ++ * cp-tree.h (tsubst_flags_t): Add tf_parsing. ++ * decl.c (make_typename_type): Use it. ++ (make_unbound_class_template): Likewise. ++ (lookup_name_real): Don't call type_access_control if scope is ++ template parameter dependent. ++ * parse.y (template_arg): Call make_unbound_class_template with ++ tf_parsing set. ++ (nest_name_specifier): Call make_typename_type with tf_parsing set. ++ (typename_sub0): Likewise. ++ (typename_sub1): Likewise. ++ (instantiate_decl): Push class scope. ++ * pt.c (regenerate_decl_from_template): Call pushclass and popclass ++ for both static variable and member function template. ++ (instantiate_decl) Call pushclass and popclass when tsubst'ing type ++ and arguments. ++ * search.c (type_access_control): Do type access for TEMPLATE_DECL ++ too. ++ ++2002-07-20 Roger Sayle ++ ++ * decl2.c (cxx_decode_option): Simplify -fhandle-exceptions ++ test by using positive_option. Make whitespace consistent. ++ ++2002-07-20 Gabriel Dos Reis ++ ++ * spew.c (struct unparsed_test): Replace 'filename' and 'lineno' ++ members with 'locus'. Adjust use throughout. ++ (struct feed): Likewise. ++ (alloc_unparsed_test): Change prototype, take a 'const location_t *'. ++ Adjust use. ++ (snarf_defarg): Use error(), not error_with_file_and_line(). ++ ++2002-07-19 Chris Demetriou ++ ++ * lang-specs.h (@c++): Include "%2" (cc1plus_spec) wherever ++ cpp_options is included. ++ ++2002-07-17 Kriang Lerdsuwanakij ++ ++ PR c++/2862, c++/2863 ++ * pt.c (determine_specialization): Compare the length of ++ TYPE_ARG_TYPES. Tidy. ++ ++2002-07-17 Kriang Lerdsuwanakij ++ ++ PR c++/3797 ++ * decl.c (duplicate_decls): Don't propagate inlining parameters from ++ olddecl to newdecl when newdecl is a specialization of the ++ instantiation olddecl. ++ ++2002-07-17 Kriang Lerdsuwanakij ++ ++ PR c++/4802, c++/5387 ++ * decl.c (make_typename_type): Use enforce_access. ++ ++2002-07-17 Scott Snyder ++ ++ PR c++/7320 ++ * rtti.c (get_tinfo_decl): Set DECL_COMDAT. ++ ++2002-07-12 Mark Mitchell ++ ++ * class.c (add_method): Correct handling of conversion operators. ++ ++2002-07-11 Mark Mitchell ++ ++ PR c++/7224 ++ * class.c (add_method): Simplify. ++ ++2002-07-11 Jason Merrill ++ ++ PR c++/7279 ++ * tree.c (cp_copy_res_decl_for_inlining): Also copy ++ TREE_ADDRESSABLE. ++ ++2002-07-10 Graham Stott ++ ++ * pt.c (template_parm_this_level_p, push_template_decl_real): ++ Pass depth as int pointer. ++ ++2002-07-11 Tim Josling ++ ++ Remove front end hard coding from gengtype.c. ++ ++ * config-lang.in (gtfiles): Add files needed for this front end. ++ ++2002-07-10 Mark Mitchell ++ ++ * cp-tree.h (unqualified_name_lookup_error): Declare it. ++ (begin_function_definition): Adjust prototype. ++ * lex.c (unqualified_name_lookup_error): New function, split out ++ from ... ++ (do_identifier): ... here. ++ * parse.y (parse_begin_function_definition): New function. ++ (fn.def1): Use it. ++ * semantics.c (begin_function_definition): Accept decl-specifiers ++ and attributes as separate parameters. ++ ++2002-07-10 Jason Merrill ++ ++ PR c++/6255 ++ * decl.c (lookup_name_real): Build a new TYPENAME_TYPE rather than ++ modifying the old one. ++ ++2002-07-09 Mark Mitchell ++ ++ * cp-tree.h (constructor_name_p): Declare it. ++ (check_template_template_default_arg): Likewise. ++ * class.c (handle_using_decl): Use constructor_name_p. ++ * decl.c (grokdeclarator): Likewise. ++ * decl2.c (constructor_name_p): Define it. ++ * init.c (build_member_call): Use constructor_name_p. ++ * parse.y (template_parm): Use check_template_template_default_arg. ++ * pt.c (check_explicit_specialization): Use constructor_name_p. ++ * semantics.c (check_template_template_default_arg): New function. ++ ++2002-07-08 Kriang Lerdsuwanakij ++ ++ * pt.c (can_complete_type_without_circularity): Add static to ++ function definition. ++ ++2002-07-08 Mark Mitchell ++ ++ * cp-tree.h (have_extern_spec): Declare it ++ * decl.c (have_extern_spec): Define it. ++ (start_decl): Eliminate use of used_extern_spec. ++ (start_function): Likewise. ++ * parse.y (have_extern_spec): Remove declaration. ++ (used_extern_spec): Likewise. ++ (frob_specs): Eliminate use of used_extern_spec. ++ (.hush_warning): Likewise. ++ ++2002-07-07 Mark Mitchell ++ ++ * Make-lang.in (cp/parse.o): Depend on decl.h. ++ * cp-tree.h (do_decl_instantiation): Change prototype. ++ * parse.y: Include decl.h. ++ (parse_decl_instantiation): New function. ++ (explicit_instantiation): Use it. ++ * pt.c (do_decl_instantiation): Accept a DECL, not a DECLARATOR ++ and DECLSPECS. ++ ++2002-07-07 Roger Sayle ++ ++ * error.c (dump_function_name): Use DECL_TEMPLATE_RESULT for ++ constructor and destructor tests when passed a TEMPLATE_DECL. ++ ++2002-07-05 Jason Merrill ++ ++ * cvt.c (cp_convert_to_pointer): Call force_fit_type for null ++ pointers. ++ ++ PR optimization/7145 ++ * tree.c (cp_copy_res_decl_for_inlining): Also copy DECL_INITIAL. ++ ++2002-07-05 Nathan Sidwell ++ ++ Repair damage on weak-impared targets caused by my previous patch. ++ * cp-tree.h (import_export_tinfo): Add parameter. ++ * decl2.c (import_export_tinfo): Add parameter, post adjust ++ DECL_COMDAT. ++ * rtti.c (emit_tinfo_decl): DECL_COMDAT is (nearly) always setup by ++ import_export_tinfo. ++ ++2002-07-03 Kriang Lerdsuwanakij ++ ++ PR c++/6944 ++ * init.c (build_aggr_init): Remove qualifiers of init before calling ++ build_vec_init. ++ (build_vec_init): Flatten multi-dimensional array during cleanup. ++ (build_vec_delete_1): Abort if the type of each element is array. ++ ++2002-07-03 Graham Stott ++ ++ * pt.c (instantiate_class_template): Fix typo. ++ ++2002-07-02 Kriang Lerdsuwanakij ++ ++ * typeck2.c (cxx_incomplete_type_diagnostic): Fix typo caused ++ by CVS conflict in my last patch. ++ ++2002-07-02 Kriang Lerdsuwanakij ++ ++ PR c++/6716 ++ * pt.c (can_complete_type_without_circularity): New function. ++ (instantiate_class_template): Use it. ++ * typeck2.c (cxx_incomplete_type_diagnostic): Improve error ++ message due to incomplete fields. ++ ++2002-07-01 Mark Mitchell ++ ++ PR c++/7112 ++ * mangle.c (write_expression): Add mangling for sizeof when ++ applied to a type. ++ * operators.def: Remove stale comment. ++ ++2002-06-30 Nathan Sidwell ++ ++ * cp-tree.h (CPTI_TINFO_DECL_TYPE): Replace with ... ++ (CPTI_TYPE_INFO_PTR_TYPE): ... this. ++ (tinfo_decl_type): Replace with ... ++ (type_info_ptr_type): ... this. ++ (import_export_tinfo): Declare. ++ (tinfo_decl_p): Rename to ... ++ (unemitted_tinfo_decl_p): ... this. ++ * decl2.c (import_export_decl): Break out tinfo handling into ... ++ (import_export_tinfo): ... here. New function. ++ (finish_file): Adjust. ++ * rtti.c (TINFO_REAL_NAME): New macro. ++ (init_rtti_processing): Create the tinfo types. ++ (get_tinfo_decl_dynamic): Use type_info_ptr_type, get_tinfo_ptr. ++ (get_tinfo_decl): Adjust. ++ (get_tinfo_ptr): New function. ++ (get_type_id): Use it. ++ (tinfo_base_init): Create vtable decl here, if it doesn't exist. ++ (ptr_initializer): Use get_tinfo_ptr. ++ (ptm_initializer): Likewise. ++ (synthesize_tinfo_var): Break into ... ++ (get_pseudo_ti_init): ... this. Just create the initializer. ++ (get_pseudo_ti_desc): .. and this. ++ (create_real_tinfo_var): Remove. ++ (create_pseudo_type_info): Don't create the vtable decl here. ++ (get_vmi_pseudo_type_info): Remove. ++ (create_tinfo_types): Adjust. ++ (tinfo_decl_p): Rename to ... ++ (unemitted_tinfo_decl_p): ... here. Adjust. ++ (emit_tinfo_decl): Adjust. Create the initializer. ++ ++2002-06-27 Mark Mitchell ++ ++ PR c++/6695 ++ * pt.c (tsubst_friend_class): Substitute into the context of the ++ friend before using it. ++ ++2002-06-26 Mark Mitchell ++ ++ * cp-tree.h (xref_tag): Change prototype. ++ (handle_class_head): Likewise. ++ (build_x_component_ref): Likewise. ++ * decl.c (cxx_init_decl_processing): Adjust call to xref_tag. ++ (xref_tag): Take attributes as a separate parameter. ++ (xref_tag_from_type): Adjust call to xref_tag. ++ * decl2.c (build_expr_from_tree): Adjust call to ++ build_x_component_ref. ++ (handle_class_head): Take attributes as a separate parameter. ++ * parse.y (parse_xref_tag): New function. ++ (parse_handle_class_head): Likewise. ++ (primary): Use parse_xref_tag. ++ (class_head_decl): Use parse_handle_class_head. ++ (class_head_defn): Likewise. ++ * rtti.c (init_rtti_processing): Adjust call to xref_tag. ++ (build_dynamic_cast_1): Likewise. ++ (create_pseudo_type_info): Likewise. ++ (emit_support_tinfos): Likewise. ++ * typeck.c (build_object_ref): Adjust call to ++ build_x_component_ref. ++ (build_x_component_ref): Remove protect parameter. ++ ++2002-06-25 Mark Mitchell ++ ++ * call.c (build_op_delete_call): Use BASELINK_FUNCTIONS. ++ * class.c (handle_using_decl): Likewise. ++ (instantiate_type): Likewise. ++ * cp-tree.h (BASELINK_FUNCTIONS): New macro. ++ (xref_basetypes): Change prototype. ++ (begin_mem_initializers): New function. ++ (get_overloaded_fn): Likewise. ++ * decl.c (xref_basetypes): Simplify. ++ * error.c (dump_expr): Use BASELINK_FUNCTIONS. ++ * init.c (build_offset_ref): Likewise. ++ * parse.y (base_init): Use begin_mem_initializers(). ++ (structsp): Adjust call to xref_basetypes. ++ * pt.c (determine_specialization): Use BASELINK_FUNCTIONS. ++ (instantiate_class_template): Adjust call to xref_basetypes. ++ * semantics.c (begin_mem_initializers): New function. ++ * tree.c (is_overloaded_fn): Use BASELINK_FUNCTIONS. ++ (really_overloaded_fn): Likewise. ++ (get_overloaded_fn): New function.' ++ (get_first_fn): USe BASELINK_FUNCTIONS. ++ ++2002-06-24 Mark Mitchell ++ ++ * cp-tree.h (SCALAR_TYPE_P): New macro. ++ (check_for_out_of_scope_variable): New function. ++ (at_class_scope_p): Likewise. ++ (finish_fname): Likewise. ++ * class.c (finish_struct): Use at_function_scope_p. ++ * decl.c (check_for_out_of_scope_variable): New function, split ++ out from do_identifier. ++ (finish_enum): Use at_function_scope_p. ++ * lex.c (do_identifier): Use check_for_out_of_scope_variable. ++ * parse.y (VAR_FUNC_NAME): Give it . Use finish_fname. ++ (primary): Use at_function_scope_p. ++ * search.c (at_class_scope_p): New function. ++ * semantics.c (finish_fname): Likewise. ++ (check_multiple_declarators): Use at_function_scope_p. ++ ++2002-06-23 Mark Mitchell ++ ++ * parse.y (parse_scoped_id): New function. ++ (primary): Use it. ++ * cp-tree.h (do_scoped_id): Adjust declaration. ++ * lex.c (do_scoped_id): Remove call to yylex. ++ * decl2.c (build_expr_from_tree): Adjust use of do_scoped_id. ++ * typeck2.c (add_exception_specifier): Use tree_cons, rather than ++ expanding it inline. ++ ++2002-06-23 Matt Thomas ++ ++ * decl.c (finish_function): Change "#ifdef VMS_TARGET" to ++ "#if VMS_TARGET". ++ ++2002-06-21 Kaveh R. Ghazi ++ ++ * mangle.c (integer_type_codes): Const-ify. ++ ++2002-06-20 Richard Henderson ++ ++ PR c++/6747 ++ * typeck.c (mark_addressable): Don't test TREE_ADDRESSABLE early. ++ Call put_var_into_stack. ++ ++2002-06-20 Kaveh R. Ghazi ++ ++ * spew.c (remove_last_token): Use ARRAY_SIZE in lieu of explicit ++ array size calculation. ++ ++2002-06-20 Kriang Lerdsuwanakij ++ ++ PR c++/6892 ++ * pt.c (tsubst_expr): Handle FILE_STMT. ++ ++2002-06-20 Kriang Lerdsuwanakij ++ ++ PR c++/6723 ++ * pt.c (lookup_template_class): Don't build complete argument of ++ BOUND_TEMPLATE_TEMPLATE_PARM if appeared as a default template ++ argument. ++ ++2002-06-19 Akim Demaille ++ ++ * parse.y (TYPENAME): Rename as tTYPENAME to avoid the clash with ++ decl.h's TYPENAME. ++ * spew.c, lex.c: Adjust. ++ * parse.y (explicit_instantiation): Add empty action to override ++ the default $$ = $1 where it introduces a type clash. ++ ++2002-06-14 Jason Merrill ++ ++ * semantics.c (begin_for_stmt): Push the 'for' scope before ++ adding the FOR_STMT. ++ ++ C++ ABI changes. ++ * class.c (build_base_field): Set DECL_PACKED. ++ (layout_class_type): Don't use tail padding of PODs. ++ * mangle.c (write_unqualified_name): Fix template conversion op ++ mangling. ++ ++2002-06-16 Richard Henderson ++ ++ PR opt/6793 ++ * tree.c (cp_cannot_inline_tree_fn): Don't short-circuit test ++ after template instantiation. ++ ++2002-06-16 Richard Henderson ++ ++ * cp-tree.h, decl2.c (flag_ms_extensions): Move to c-common. ++ ++2002-06-15 Gabriel Dos Reis ++ ++ * cp-tree.h (compiler_error): Remove declaration. ++ * lex.c (compiler_error): Remove definition. ++ ++2002-06-14 Steve Ellcey ++ ++ * g++spec.c (LIBUNWIND): New. ++ (lang_specific_driver): Add it if USE_UNWIND_EXCEPTIONS is set. ++ ++2002-06-13 Jessica Han ++ ++ * class.c (build_vtable): Use TARGET_VTABLE_ENTRY_ALIGN. ++ (build_vtbl_initializer): Honor TARGET_VTABLE_DATA_ENTRY_DISTANCE. ++ (build_vbase_offset_vtbl_entries): Likewise. ++ * rtti.c (build_headof): Likewise. ++ (get_tinfo_decl_dynamic): Likewise. ++ (create_pseudo_type_info): Likewise. ++ ++2002-06-12 Stan Shebs ++ ++ * mpw-config.in: Remove file, no longer used. ++ * mpw-make.sed: Ditto. ++ ++2002-06-07 Zack Weinberg ++ ++ * decl2.c: Update call to cpp_handle_option. ++ ++2002-06-07 H.J. Lu (hjl@gnu.org) ++ ++ * decl2.c (flag_use_cxa_atexit): Set to DEFAULT_USE_CXA_ATEXIT. ++ ++2002-06-06 Gabriel Dos Reis ++ ++ * error.c (cp_error_at): Fix typo. ++ ++2002-06-04 Gabriel Dos Reis ++ ++ * error.c (cp_diagnostic_starter): Adjust call. ++ (maybe_print_instantiation_context): Change prototype to take a ++ 'diagnostic_info *'. ++ (print_instantiation_full_context): Likewise. ++ (print_instantiation_partial_context): Likewise. ++ (cp_diagnostic_starter): Likewise. ++ (cp_diagnostic_finalizer): Likewise. ++ (cp_print_error_function): Likewise. ++ (cp_printer): Take a secondary parameter as a 'text_info *'. ++ Remove output_state savings. Adjust calls. ++ ++2002-06-03 Geoffrey Keating ++ ++ * pt.c (inline_parm_levels): Mark for GC. ++ ++ * mangle.c (start_mangling): Allocate G.substitutions here... ++ (init_mangle): ... rather than here. ++ (finish_mangling): Clear the varray pointer when done with it. ++ * spew.c (yylexstring): Don't use VARRAY_FREE. ++ * search.c (bfs_walk): Don't use VARRAY_FREE. ++ * decl2.c (pending_statics): Use gengtype to mark. ++ (deferred_fns): Likewise. ++ (ssdf_decls): Likewise. ++ (init_decl2): Delete. ++ * decl.c (pop_from_top_level): Don't use VARRAY_FREE. ++ (cxx_init_decl_processing): Don't call init_decl2. ++ (cxx_pop_function_context): Don't use VARRAY_FREE. ++ * cp-tree.h (struct saved_scope): No need for special marking ++ of varrays. ++ (struct language_function): Likewise. ++ (local_classes): Use gengtype to mark. ++ (init_decl2): Delete prototype. ++ * class.c (init_class_processing): Don't use ++ ggc_add_tree_varray_root. ++ (build_vtbl_initializer): Don't use VARRAY_FREE. ++ ++ * decl.c (typename_compare): Don't use same_type_p. ++ ++ * decl.c: Include hashtab.h instead of hash.h. ++ (typename_hash): Update to use htab_h. ++ (typename_compare): Likewise. ++ (typename_htab): Use gengtype to mark. ++ (build_typename_type): Update to use htab_h. ++ * Make-lang.in (cp/decl.o): Use HASHTAB_H instead of hash.h. ++ ++ * Make-lang.in (gt-cp-tree.h): New rule. ++ (cp/tree.o): Depend on gt-cp-tree.h. ++ * config-lang.in (gtfiles): Add cp/tree.c. ++ * tree.c: Include gt-cp-tree.h. ++ (list_hash_table): Use gengtype to mark. ++ (init_tree): Use gengtype to mark trees. ++ ++ * Make-lang.in (cp/decl.o): Add debug.h dependency. ++ * call.c (struct z_candidate): Use gengtype. ++ (USER_CONV_CAND): Use WRAPPER_ZC. ++ (convert_class_to_reference): Use build_zc_wrapper. ++ (build_type_conversion_1): Likewise. ++ (build_over_call): Use WRAPPER_ZC. ++ (add_warning): Use build_zc_wrapper. ++ * cp-lang.c (LANG_HOOKS_MARK_TREE): Delete. ++ * cp-tree.h (struct lang_identifier): Use gengtype. ++ (struct template_parm_index_s): Likewise. ++ (struct ptrmem_cst): Likewise. ++ (struct tree_binding): Likewise. ++ (struct tree_overload): Likewise. ++ (struct tree_srcloc): Likewise. ++ (struct tree_wrapper): Likewise. Also modify to have a pointer ++ to struct z_candidate rather than void. ++ (enum cp_tree_node_structure_enum): New. ++ (union lang_tree_node): New. ++ (cxx_mark_tree): Delete prototype. ++ (cp_tree_node_structure): New prototype. ++ (build_ptr_wrapper): Delete prototype. ++ (build_int_wrapper): Delete prototype. ++ (build_zc_wrapper): New prototype. ++ * decl.c: Include debug.h ++ (cxx_mark_tree): Delete. ++ (cp_tree_node_structure): New. ++ * tree.c (build_ptr_wrapper): Delete. ++ (build_int_wrapper): Delete. ++ (build_zc_wrapper): New. ++ ++ * cp-tree.h [! ENABLE_TREE_CHECKING] (LANG_TYPE_PTRMEM_CHECK): ++ Correct typo. Patch from k_fukui@highway.ne.jp. ++ ++ * semantics.c (current_stmt_tree): Update for change to ++ struct language_function. ++ (finish_mem_initializers): Likewise. ++ * decl.c (cxx_init_decl_processing): Don't set mark_lang_status. ++ * cp-tree.h (struct language_function): Rename from ++ cp_language_function. Change all uses. ++ (cp_function_chain): Don't need to cast. ++ ++ * class.c (duplicate_tag_error): Reset discriminator. ++ (check_bases_and_members): Update for data structure changes. ++ * cp-tree.h (struct lang_id2): Use gengtype. ++ (flagged_type_tree): Likewise. ++ (SET_LANG_ID): Use GGC on struct lang_id2. ++ (struct cp_language_function): Use gengtype. Remove field ++ 'x_vcalls_possible_p'. ++ (current_vcalls_possible_p): Delete. ++ (struct lang_type_header): New. ++ (struct lang_type_class): Rename from struct lang_type. Include ++ struct lang_type_header. ++ (struct lang_type_ptrmem): New. ++ (struct lang_type): New. ++ (LANG_TYPE_CLASS_CHECK): New. Use it in all the appropriate macros. ++ (LANG_TYPE_PTRMEM_CHECK): New. Use it in all the appropriate macros. ++ (TYPE_SET_PTRMEMFUNC_TYPE): Set discriminator, update for changes. ++ (struct lang_decl_flags): Use gengtype. Add discriminators. ++ (struct lang_decl): Use gengtype. Add and use discriminators. ++ Update the macros that reference moved fields. ++ (LANG_DECL_U2_CHECK): New function. Use it when appropriate. ++ (SET_DECL_THUNK_P): Set discriminator too. ++ (clear_inline_text_obstack): Delete prototype. ++ (finish_inline_definitions): Delete prototype. ++ (mark_pending_inlines): Delete prototype. ++ (lang_check_failed): New prototype. ++ * decl.c (struct named_label_use_list): Use gengtype. ++ (struct named_label_list): Likewise. ++ (mark_binding_level): Delete. ++ (mark_named_label_lists): Delete. ++ (push_local_name): Set discriminator on DECL_LANG_SPECIFIC. ++ (cxx_init_decl_processing): Use generated marker routine. ++ (begin_destructor_body): Delete dead set to ++ current_vcalls_possible_p. ++ (mark_lang_function): Delete. ++ (mark_cp_function_context): Delete. ++ (lang_mark_tree): Use generated marker routines. ++ * decl2.c (start_objects): Set discriminator when setting ++ GLOBAL_INIT_PRIORITY. ++ * lex.c (retrofit_lang_decl): Set discriminators. ++ (copy_lang_type): Update for changes to lang_type structure. ++ (cp_make_lang_type): Set discriminator. ++ * parse.y: Use gengtype on YYLVAL. Don't use dots in identifiers. ++ * search.c: Include ggc.h. ++ * semantics.c (anon_aggr_type_p): Use the macro, don't hand-code it. ++ (finish_inline_definitions): Delete. ++ * spew.c (struct token): Use gengtype. ++ (struct token_chunk): New. ++ (struct unparsed_text): Use gengtype. Store tokens in chunks. ++ (struct feed): Use gengtype. ++ (feed_obstack): Delete. ++ (feed): Mark as GC root. ++ (pending_inlines): Mark as GC root. ++ (pending_inlines_tail): Likewise. ++ (processing_these_inlines): Likewise. ++ (token_obstack): Make static. ++ (first_token): Likewise. ++ (init_spew): Don't initialize deleted things; use gengtype for roots. ++ (clear_inline_text_obstack): Delete. ++ (feed_input): Use GC for struct feed. Update for changes to ++ struct unparsed_text. ++ (mark_pending_inlines): Delete. ++ (next_token): Rename from add_token. Change all callers. Update ++ for changes to struct unparsed_text. ++ (space_for_token): New. ++ (remove_last_token): New. ++ (alloc_unparsed_text): New. ++ (snarf_block): Take an unparsed_text. Update for changes to struct ++ unparsed_text. ++ (snarf_method): Update for changes to struct unparsed_text. ++ (snarf_defarg): Update for changes to struct unparsed_text. ++ * tree.c (lang_check_failed): New. ++ ++ * Make-lang.in (gt-cp-call.h gt-cp-decl2.h gt-cp-parse.h ++ gt-cp-pt.h gt-cp-repo.h gt-cp-spew.h): New rules. ++ (cp/spew.o): Add dependency on gt-.h. ++ (cp/decl2.o): Add dependency on gt-.h. ++ (cp/call.o): Add dependency on gt-.h. ++ (cp/pt.o): Add dependency on gt-.h. ++ (cp/repo.o): Add dependency on gt-.h. ++ (cp/parse.o): Add dependency on gt-.h. ++ * call.c: Use gengtype for roots. ++ * config-lang.in (gtfiles): Add cp-tree.h decl.h lex.h call.c ++ decl2.c parse.y pt.c repo.c spew.c. ++ * cp-tree.h: Use gengtype for roots. ++ (struct saved_scope): Use GGC, gengtype. ++ (cp_parse_init): Delete prototype. ++ (init_pt): Delete prototype. ++ * decl.c: Use gengtype for roots. ++ (mark_saved_scope): Delete. ++ (cxx_init_decl_processing): Don't call deleted initilisation ++ routines. ++ (signed_size_zero_node): Delete, unused. ++ * decl.h: Use gengtype for roots. ++ * decl2.c: Use gengtype for roots. ++ * lex.h: Use gengtype for roots. ++ * parse.y: Use gengtype for roots. ++ (cp_parse_init): Delete. ++ * pt.c: Use gengtype for roots. ++ (init_pt): Delete. ++ * repo.c: Use gengtype for roots. ++ * spew.c: Use gengtype for roots. ++ ++ * Make-lang.in: Allow for filename changes. Add gtype-cp.h. ++ (cp/decl.o): Add dependency on gtype-cp.h. ++ * decl.c: Remove use of add_deletable_root, use GTY marker instead. ++ Include gtype-cp.h. Allow for filename changes. ++ ++ * Make-lang.in (cp/gt-decl.h): Generate using gengtype. ++ (cp/decl.o): Add cp/gt-decl.h dependency. ++ * config-lang.in (gtfiles): New. ++ * tree.h: Rename struct binding_level to struct cp_binding_level. ++ * decl.c: Rename struct binding_level to struct cp_binding_level. ++ Include cp/gt-decl.h. ++ (struct cp_binding_level): Use gengtype. ++ (make_binding_level): Use GGC on struct cp_binding_level. ++ (mark_binding_level): Use gt_ggc_m_cp_binding_level. ++ (cxx_init_decl_processing): Mark free_binding_level as ++ deletable. ++ ++ * decl.c (mark_cp_function_context): Update calling sequence. ++ ++ * decl.c (start_function): Don't free 'struct ++ cp_language_function'. ++ (pop_cp_function_context): Likewise. ++ (save_function_data): Allocate it using GC. ++ * semantics.c (genrtl_start_function): Don't free 'struct ++ cp_language_function'. ++ ++2002-05-31 Matthew Woodcraft ++ ++ * lang-specs.h: Use cpp_debug_options. ++ ++2002-05-28 Zack Weinberg ++ ++ * mangle.c, tree.c: Include real.h. ++ * Make-lang.in: Update dependency lists. ++ ++2002-05-25 Neil Booth ++ ++ * lex.c: Don't include c-lex.h. ++ * parse.y, spew.c: Don't include c-lex.h; include c-pragma.h. ++ ++2002-05-23 Neil Booth ++ ++ * spew.c (yyungetc, snarf_block): Remove indent_level handling. ++ ++2002-05-22 Richard Henderson ++ ++ * decl.c (obscure_complex_init): Check for VAR_DECL ++ before using DECL_THREAD_LOCAL. ++ ++2002-05-22 Richard Henderson ++ ++ * decl.c (check_tag_decl): Handle RID_THREAD. ++ (obscure_complex_init): Reject run-time init of tls. ++ (grokvardecl, grokdeclarator): Handle RID_THREAD. ++ * lex.c (reswords): Add __thread. ++ (rid_to_yy): Map RID_THREAD to SCSPEC. ++ ++2002-05-22 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_POST_OPTIONS): Use c_common_post_options. ++ * cp-tree.h (cxx_post_options): Kill. ++ * cp-lex.c (cxx_post_options): Kill. ++ ++2002-05-21 Richard Henderson ++ ++ * lex.c (rid_to_yy): Add RID_THREAD. ++ ++2002-05-21 Alexandre Oliva ++ ++ * init.c (build_vec_init): Test for trivial copy-assignment when ++ copy-assigning arrays. ++ ++2002-05-20 Andreas Jaeger ++ ++ * init.c (build_default_init): Remove unused variable. ++ ++2002-05-20 Alexandre Oliva ++ ++ * call.c (any_strictly_viable): New. ++ (build_new_op): Use it for COMPOUND_EXPR and ADDR_EXPRs. ++ ++2002-05-19 Kriang Lerdsuwanakij ++ ++ * error.c (dump_type) [TYPEOF_TYPE]: Fix parenthesis printing. ++ ++2002-05-19 Kriang Lerdsuwanakij ++ ++ PR c++/186, DR 259 ++ * pt.c (do_decl_instantiation): Don't complain explicit ++ instantiation after explicit specialization. ++ (do_type_instantiation): Likewise. ++ ++2002-05-19 Alexandre Oliva ++ ++ * cp-tree.h (complete_type_or_diagnostic): Changed prototype, ++ renamed from... ++ (complete_type_or_else): ... this. Redefined as macro. ++ (cxx_incomplete_type_diagnostic): Declare. ++ (cxx_incomplete_type_error): Define as macro. ++ * init.c (build_delete): Warn about incomplete types other than ++ void, and use the built-in operator delete for them. ++ * typeck.c (complete_type_or_diagnostic): Renamed from ++ complete_type_or_else. Added warn_only argument, passed to... ++ * typeck2.c (cxx_incomplete_type_diagnostic): ... this. Print ++ warnings or errors depending on new warn_only argument. Renamed ++ from... ++ (cxx_incomplete_type_error): ... this. New implementation in ++ terms of cxx_incomplete_type_diagnostic. ++ ++2002-05-18 Jason Merrill ++ ++ PR c++/6611 ++ * decl2.c (import_export_decl): If we clear ++ DECL_NOT_REALLY_EXTERN, make sure DECL_EXTERNAL is set. ++ ++2002-05-15 Kriang Lerdsuwanakij ++ ++ PR c++/6620 ++ * pt.c (verify_class_unification): Don't check if PARM is template ++ parameter dependent. Simplify. ++ (unify) [TEMPLATE_PARM_INDEX]: Handle when ARG is a template ++ parameter dependent expression. ++ ++2002-05-14 Jason Merrill ++ ++ * rtti.c (get_tinfo_decl): Don't call comdat_linkage. ++ Do set DECL_COMDAT. ++ (synthesize_tinfo_var): Take the public decl. ++ (create_real_tinfo_var): Likewise. Check DECL_COMDAT. ++ (emit_tinfo_decl): Adjust. Call import_export_decl. ++ * decl2.c (import_export_decl): Simplify tinfo decl handling. ++ ++2002-05-14 Alexandre Oliva ++ ++ * cp-tree.h (struct lang_type): Added non_zero_init. ++ (CLASSTYPE_NON_ZERO_INIT_P): New macro. ++ (zero_init_p, force_store_init_value, build_forced_zero_init): Declare. ++ * class.c (check_field_decls): Test non_zero_init. ++ * cvt.c (convert_to_pointer_force): Use cp_convert_to_pointer for ++ zero-to-NULL conversions. ++ * decl.c (obscure_complex_init): Don't reset DECL_INITIAL of a ++ type that needs zero-initialization without zeros. ++ (check_initializer_decl): Compute zero-initializer for types ++ that require a non-trivial one. ++ * init.c (build_forced_zero_init): New function. ++ (build_default_init): Use it. ++ * tree.c (zero_init_p): New function. ++ * typeck2.c (force_store_init_value): New function. ++ (process_init_constructor): Create non-trivial zero-initializers ++ for array members and class fields. ++ ++2002-05-14 Neil Booth ++ ++ * lang-specs.h: Remove redundant -lang-c++. ++ ++2002-05-13 Jason Merrill ++ ++ * class.c (build_vtbl_ref_1): Use fixed_type_or_null. ++ (fixed_type_or_null): See through reference vars. ++ (build_base_path): Vtable contents are constant. ++ * typeck.c (get_member_function_from_ptrfunc): Likewise. ++ ++2002-05-12 Jason Merrill ++ ++ * cp-lang.c (ok_to_generate_alias_set_for_type): Backend-created ++ structs are safe. ++ ++2002-05-09 Neil Booth ++ ++ * cp-tree.h (flag_ansi): Remove. ++ * decl2.c (flag_ansi): Remove. ++ (cxx_decode_option): Set flag_iso and flag_undef. ++ ++2002-05-09 Jason Merrill ++ ++ * typeck.c (get_member_function_from_ptrfunc): Reorganize. ++ Use subtraction rather than a bitmask to get the index. ++ * cvt.c (cp_convert_to_pointer): Bail on an error_mark_node. ++ ++ * pt.c (tsubst_expr) [ASM_STMT]: Copy ASM_INPUT_P. ++ ++2002-05-07 Neil Booth ++ ++ * Make-lang.in (decl2.o): Update. ++ * cp-tree.h (warn_multichar): Remove. ++ * decl2.c: Include c-common.h. ++ (warn_multichar): Remove. ++ ++2002-05-03 Jason Merrill ++ ++ * tree.c (build_cplus_array_type): Only const and volatile get ++ special handling. ++ ++ * decl.c (BOOL_TYPE_SIZE): Move default to defaults.h. ++ ++2002-04-30 Mark Mitchell ++ ++ ABI change, returning simple classes from functions. ++ * class.c (finish_struct_bits): Only mark TREE_ADDRESSABLE if ++ TYPE_HAS_TRIVIAL_INIT_REF is false or ++ TYPE_HAS_NONTRIVIAL_DESTRUCTOR is true. ++ ++2002-04-30 Jason Merrill ++ ++ PR debug/6436 ++ * decl.c (grokdeclarator): Don't override TYPE_NAME of an ++ anonymous class with a typedef if there are attributes. ++ ++2002-04-29 Paul Eggert ++ ++ * parse.y (nomods_initdcl0): Replace $3 with $$. ++ ++2002-04-29 Jakub Jelinek ++ ++ PR c++/6477 ++ * decl.c (follow_tag_typedef): Check if TYPE_NAME (original) is ++ non-NULL first. ++ ++2002-04-29 Mark Mitchell ++ ++ PR c++/6492 ++ * pt.c (tsubst_friend_class): If the friend has an explicit scope, ++ enter that scope before name lookup. ++ ++ PR c++/6486 ++ * method.c (do_build_copy_constructor): Avoid building ++ cv-qualified reference types. ++ ++2002-04-29 Nathan Sidwell ++ ++ PR c++/5719 ++ * decl.c (grok_op_properties): Assignment ops don't have to return ++ by value. operator% should. ++ ++2002-04-28 Franz Sirl ++ ++ PR c/6343 ++ * decl.c (duplicate_decls): Call merge_weak. ++ ++2002-04-26 Richard Henderson ++ ++ * parse.y (malloced_yyss, malloced_yyvs): New. ++ (yyoverflow): Re-add. Set them. ++ (free_parser_stacks): New. ++ ++2002-04-26 Mark Mitchell ++ ++ PR c++/6497 ++ * method.c (do_build_assign_ref): Pass a derivation to ++ build_method_call when calling base class assignment operators. ++ ++2002-04-26 Richard Henderson ++ ++ * parse.y (yyoverflow): Revert. ++ ++2002-04-26 Richard Henderson ++ ++ PR c/3581 ++ * parse.y (string): Remove. Update all uses to use STRING ++ instead, and not call combine_strings. ++ * rtti.c (tinfo_name): Use fix_string_type. ++ * semantics.c (finish_asm_stmt): Don't call combine_strings. ++ * spew.c (yylexstring): New. ++ (read_token): Use it. ++ ++2002-04-25 Richard Henderson ++ ++ PR c/2161 ++ * parse.y (yyoverflow): New. ++ ++2002-04-25 Jason Merrill ++ ++ PR c++/5607 ++ * search.c (check_final_overrider): No longer static. ++ * class.c (update_vtable_entry_for_fn): Call it. ++ * cp-tree.h: Adjust. ++ ++2002-04-25 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_SET_YYDEBUG): Remove. ++ * cp-tree.h (cxx_set_yydebug): Die. ++ * lex.c (YYDEBUG): Get from c-lex.h. ++ (cxx_set_yydebug): Remove. ++ * parse.y: Include c-lex.h. ++ (YYDEBUG): Get from c-lex.h. ++ ++2002-04-24 Mark Mitchell ++ ++ PR c++/6438. ++ * cvt.c (convert_to_void): Don't unconditionally make COND_EXPRs ++ void. ++ ++2002-04-24 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_COMMON_ATTRIBUTE_TABLE, ++ LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE, LANG_HOOKS_ATTRIBUTE_TABLE): ++ Redefine. ++ * cp-tree.h (cp_attribute_table): Rename. ++ * decl.c (lang_attribute_table): Remove declaration. ++ (cxx_init_decl_processing): Don't set it. ++ * tree.c (cp_attribute_table): Rename. ++ ++2002-04-24 Jason Merrill ++ ++ PR c++/6331 ++ * method.c (do_build_copy_constructor): Use cp_build_qualified_type. ++ * typeck.c (build_modify_expr): Allow arrays to differ in cv-quals. ++ The pedwarn for array assignment is now unconditional. ++ * tree.c (build_cplus_array_type_1): Still process simple array types ++ normally in templates. ++ ++ PR c++/6395 ++ * decl.c (make_rtl_for_nonlocal_decl): Don't mess with #pragma i/i ++ stuff for comdats. ++ ++2002-04-23 Jakub Jelinek ++ ++ * parse.y (check_class_key): Allow KEY to be union/enum/struct/class ++ node with attributes. ++ ++2002-2-23 David O'Brien ++ ++ * g++spec.c (MATH_LIBRARY_PROFILE, LIBSTDCXX_PROFILE): Add. ++ Use MATH_LIBRARY_PROFILE and LIBSTDCXX_PROFILE if profile flag given. ++ ++2002-04-23 Mark Mitchell ++ ++ PR c++/6256: ++ * pt.c (tsubst_friend_class): Handle templates with explicit ++ nested names. ++ ++ PR c++/6331: ++ * typeck.c (merge_types): Remember the cv-qualification of pointer ++ types when merging them. ++ ++2002-04-20 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_FUNCTION_INIT, ++ LANG_HOOKS_FUNCTION_FREE, LANG_HOOKS_FUNCTION_MARK): Redefine. ++ * cp-tree.h (cxx_push_function_context, cxx_pop_function_context, ++ cxx_mark_function_context): New. ++ * decl.c (push_cp_function_context, pop_cp_function_context, ++ mark_cp_function_context): Rename for consistency. ++ (cxx_init_decl_processing): Don't set old hooks. ++ ++2002-04-19 Neil Booth ++ ++ * call.c (convert_type_from_ellipsis): Rename, update. ++ * cp-lang.c (LANG_HOOKS_TYPE_PROMOTES_TO): Redefine. ++ * cp-tree.h (convert_type_from_ellipsis): Rename. ++ * decl.c (cxx_init_decl_processing): Don't set hook. ++ ++2002-04-18 Neil Booth ++ ++ * call.c (build_new_method_call): Update. ++ * cp-lang.c (LANG_HOOKS_INCOMPLETE_TYPE_ERROR): Redefine. ++ * cp-tree.h (cxx_incomplete_type_error): New. ++ * decl.c (grokdeclarator, grokparms): Update. ++ * decl2.c (check_classfn): Update. ++ * pt.c (tsubst): Update. ++ * typeck.c (complete_type_or_else, expr_sizeof, ++ decay_conversion): Update. ++ * typeck2.c (incomplete_type_error): Rename. ++ (add_exception_specifier): Update. ++ ++2002-04-18 Jason Merrill ++ ++ PR c++/5658 ++ * search.c (setup_class_bindings): A class template qualifies as a ++ type binding. ++ ++2002-04-17 Jakub Jelinek ++ ++ PR c++/6316 ++ * decl2.c (finish_file): Clear DECL_EXTERNAL in a separate loop ++ before expanding. ++ ++2002-04-16 Mark Mitchell ++ ++ * init.c (begin_init_stmts): Remove commented out code. ++ (finish_init_stmts): Set STMT_EXPR_NO_SCOPE. ++ * semantics.c (begin_gobal_stmt_expr): Adjust call to ++ expand_start_stmt_expr. ++ ++2002-04-15 Mark Mitchell ++ ++ * decl.c (register_dtor_fn): Pass the address of dso_handle, not ++ dso_handle itself, to __cxa_atexit. ++ ++2002-04-15 Gabriel Dos Reis ++ ++ * error.c (cxx_print_error_function): Adjust call to macros. ++ ++2002-04-14 Jakub Jelinek ++ ++ * class.c (layout_virtual_bases): Do all dsize computation on trees. ++ ++2002-04-14 Jason Merrill ++ ++ * typeck.c (get_member_function_from_ptrfunc): Don't do ++ gratuitious division and multiplication on ++ ptrmemfunc_vbit_in_delta targets. ++ ++2002-04-12 Mark Mitchell ++ ++ PR c++/5373. ++ * semantics.c (finish_expr_stmt): Remember the type of the ++ expression before any conversions are performed. ++ ++2002-04-12 Mark Mitchell ++ ++ PR c++/5189. ++ * call.c (add_template_candidate_real): Do not treat member ++ templates as copy constructors. ++ ++2002-04-12 Mark Mitchell ++ ++ * decl.c (duplicate_decls): Do not copy the RTL for a variable ++ declaration if the old variable had an incomplete type and the new ++ variable does not. ++ (complete_vars): Do not call layout_decl for completed variables. ++ ++2002-04-12 Richard Sandiford ++ ++ * decl.c (duplicate_decls): Don't try to unify an implicit typedef ++ with an explicit one. ++ (follow_tag_typedef): New. ++ (lookup_tag): Use it to extract the tag of an explicit typedef. ++ (xref_tag): Likewise. ++ ++2002-04-11 Andrew Haley ++ ++ * typeck.c (type_after_usual_arithmetic_conversions): ++ If two types have the same variant, return immediately. ++ When two floating-point operands are the same precision: ++ convert to float if one of the operands is float; ++ if neither operand is one of the standard types, return the type ++ of the first operand. ++ ++2002-04-10 Nathan Sidwell ++ ++ PR c++/5507 ++ * decl.c (make_typename_type): Remove implicit typenameness. ++ ++2002-04-09 Jason Merrill ++ ++ PR optimization/6189 ++ * semantics.c (genrtl_start_function): Don't free ++ DECL_SAVED_FUNCTION_DATA for inline functions. ++ ++ * init.c (build_member_call): For now, don't convert to ++ intermediate base if it would cause an error. ++ ++2002-04-08 Paolo Carlini ++ ++ * parse.y (namespace_qualifier, maybe_identifier, ++ begin_explicit_instantiation, end_explicit_instantiation, ++ apparent_template_type, .finish_template_type, ++ do_id, maybe_init, defarg_again, component_decl_1): ++ Add ending ';', in accordance with POSIX. ++ ++2002-04-06 Mark Mitchell ++ ++ PR c++/5571 ++ * class.c (layout_class_type): Remember incomplete static ++ variables. ++ (finish_struct_1): Call complete_vars, not ++ hack_incomplete_structures. ++ * cp-tree.h (hack_incomplete_structures): Rename to ... ++ (complete_vars): ... this. ++ (struct saved_scope): Remove incomplete. ++ (namespace_scope_incomplete): Remove. ++ * decl.c (struct binding_level): Remove incomplete. ++ (incomplete_vars): New variable. ++ (mark_binding_level): Don't mark incomplete. ++ (print_binding_level): Don't print it. ++ (mark_saved_scope): Don't mark incomplete. ++ (pushdecl): Use maybe_register_incopmlete_var. ++ (cxx_init_decl_processing): Register incomplete_vars for GC. ++ (start_decl_1): Clarify error message. ++ (hack_incomplete_vars): Remove. ++ (maybe_register_incomplete_var): New function. ++ (complete_vars): Likewise. ++ ++2002-04-06 Jason Merrill ++ ++ PR c++/4934 ++ * error.c (dump_expr) [CONVERT_EXPR]: Make sure TREE_TYPE (t) is ++ set before checking it. ++ ++ PR c++/525 ++ * init.c (build_member_call): Use build_scoped_ref. ++ (resolve_offset_ref): Likewise. ++ * call.c (build_scoped_method_call): Likewise. ++ * tree.c (maybe_dummy_object): Kludge around current_class_type being ++ wrong. ++ * typeck2.c (build_scoped_ref): Return the binfo via binfo_p parm. ++ * cp-tree.h: Adjust. ++ ++ * init.c (push_base_cleanups): Just use build_scoped_method_call. ++ ++ PR c++/6179 ++ * method.c (implicitly_declare_fn): Pass unqualified type to ++ synthesize_exception_spec. ++ ++2002-04-04 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_TRUTHVALUE_CONVERSION): Redefine. ++ * cvt.c: Update comment. ++ * init.c (expand_cleanup_for_base): Update. ++ * semantics.c (finish_parenthesized_expr): Update. ++ * typeck.c (cp_truthvalue_conversion): Update. ++ ++2002-04-04 Jason Merrill ++ ++ * semantics.c (finish_eh_cleanup): New fn. ++ * cp-tree.h: Add prototype. ++ * init.c (perform_member_init, expand_cleanup_for_base): Use ++ finish_eh_cleanup. ++ * cp-tree.def (SUBOBJECT, CTOR_STMT): Remove. ++ * cp-tree.h: Remove references. ++ * decl.c (begin_constructor_body, end_constructor_body): Likewise. ++ * dump.c (cp_dump_tree): Likewise. ++ * pt.c (tsubst_expr): Likewise. ++ * semantics.c (genrtl_ctor_stmt, genrtl_subobject): Remove. ++ (cp_expand_stmt): Remove handling of CTOR_STMT and SUBOBJECT. ++ * tree.c (cp_statement_code_p): Likewise. ++ ++ * init.c (build_new_1): Set CLEANUP_EH_ONLY on deleting cleanup. ++ ++ PR c++/5636 ++ * semantics.c (nullify_returns_r): Just set CLEANUP_EH_ONLY on ++ cleanup for nrv. ++ ++ PR c++/5104 ++ * typeck.c (comptypes) [FUNCTION_TYPE]: Don't compare exception ++ specifiers. ++ [METHOD_TYPE]: Use same code as FUNCTION_TYPE. ++ ++2002-04-03 Richard Henderson ++ ++ * cp-lang.c (cxx_warn_unused_global_decl): New. ++ (LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL): New. ++ ++2002-04-03 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_SET_DECL_ASSEMBLER_NAME): Redefine. ++ * tree.c (init_tree): Don't set hook. ++ ++2002-04-03 Roger Sayle ++ ++ PR c++/5998: ++ * decl.c (duplicate_decls): Don't mess with assembler names when ++ redeclaring builtin functions as static. ++ ++2002-04-01 Neil Booth ++ ++ * call.c (build_addr_func): Update. ++ * class.c (resolve_address_of_overloaded_function): Update. ++ * cp-lang.c (LANG_HOOKS_MARK_ADDRESSABLE): Redefine. ++ * cp-tree.h (cxx_mark_addressable): New. ++ * decl.c (register_dtor_fn, cxx_maybe_build_cleanup): Update. ++ * decl2.c (build_cleanup): Update. ++ * except.c (build_throw): Update. ++ * init.c (resolve_offset_ref): Update. ++ * pt.c (convert_nontype_argument): Update. ++ * semantics.c (finish_asm_stmt, simplify_affr_init_exprs_r): Update. ++ * typeck.c (decay_conversion, build_array_ref, build_unary_op, ++ unary_complex_lvalue): Update. ++ (mark_addressable): Rename. ++ ++2002-04-01 Roger Sayle ++ ++ PR c++/5998: ++ * decl.c (duplicate_decls): Overwrite the RTL when (and only ++ when) overwriting a built-in function. Don't use COPY_DECL_RTL, ++ but follow the SET_DECL_RTL idiom used elsewhere in the function. ++ ++2002-04-01 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_SIGNED_TYPE, LANG_HOOKS_UNSIGNED_TYPE, ++ LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE): New. ++ * decl.c (grokdeclarator): Update. ++ * mangle.c (write_integer_cst): Update. ++ * typeck.c (build_binary_op): Update. ++ ++2002-03-31 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_UNSAFE_FOR_REEVAL): Redefine. ++ * lex.c (cxx_init): Don't set hook. ++ ++2002-03-31 Neil Booth ++ ++ * Make-lang.in (error.o): Update. ++ * cp-lang.c (LANG_HOOKS_PRINT_ERROR_FUNCTION): Redefine. ++ * cp-tree.h (struct diagnostic_context): Predeclare. ++ (cxx_print_error_function): New. ++ * error.c: Include langhooks-def.h. ++ (lang_print_error_function): Rename. Update. ++ (init_error): Don't set hook. ++ ++2002-03-29 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): ++ Redefine. ++ * cvt.c (cp_convert_to_pointer, type_promotes_to): Use new hooks. ++ * decl.c (finish_enum): Similarly. ++ * error.c (dump_type): Similarly. ++ * lex.c (cxx_init): Similarly. ++ * mangle.c (write_builtin_type): Similarly. ++ * typeck.c (comptypes): Similarly. ++ ++2002-03-28 Roger Sayle ++ ++ PR c++/5998: ++ * decl.c (cxx_init_decl_processing): Re-enable built-in functions ++ in the g++ front-end. ++ (duplicate_decl): Allow redefinition of anticipated built-ins. ++ Fix inlining problem by over-writing the old DECL_RTL. ++ (lookup_namespace_name): Fail to find an identifier in the ++ specified namespace if its still anticipated. ++ (builtin_function_1): New function split out from builtin_function ++ to create a builtin in the current namespace with given context. ++ (builtin_function): Call builtin_function_1 to define the ++ appropriate builtins in both the std and global namespaces. ++ (select_decl): Don't test for anticipated decls here. ++ (unqualified_namespace_lookup): Instead ignore them whilst ++ searching through scopes and namespaces. ++ * decl2.c (do_nonmember_using_decl): If a using declaration ++ specifies an anticipated built-in function, mark it as no longer ++ anticipated in that scope. ++ (ambiguous_decl): Avoid resolving to an anticipated decl. ++ * lex.c (do_scoped_id): Fail to find an identifier in the global ++ namespace if its still anticipated. ++ ++2002-03-29 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_MAKE_TYPE): Redefine. ++ * cp-tree.h (cp_make_lang_type): Rename. ++ * lex.c (cp_make_lang_type): Rename. ++ (make_aggr_type): Update. ++ * tree.c (init_tree): Don't set make_lang_type_fn. ++ ++2002-03-29 Jakub Jelinek ++ ++ PR c++/6073 ++ * class.c (finish_struct_1): Update static field's DECL_MODE even ++ if its type is a variant of t. ++ ++2002-03-27 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES): Redefine. ++ * cp-tree.h (cxx_insert_default_attributes): New. ++ * decl.c (insert_default_attributes): Rename. ++ ++2002-03-27 Mark Mitchell ++ ++ PR c++/4884 ++ * call.c (build_op_delete_call): Allow for the fact the placement ++ may be a COMPOUND_EXPR. ++ ++2002-03-27 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_EXPAND_EXPR): Redefine. ++ * cp-tree.h (init_cplus_expand): Remove. ++ (cxx_expand_expr): New. ++ * expr.c (cplus_expand_expr): Rename cxx_expand_expr, ++ fix prototype. ++ (init_cplus_expand): Remove. ++ * lex.c (cxx_init): Don't call init_cplus_expand. ++ ++2002-03-26 Mark Mitchell ++ ++ PR c++/4884. ++ * init.c (build_new_1): Allow for the fact the result of ++ build_function_call may be a COMPOUND_EXPR. ++ ++2002-03-26 Nathan Sidwell ++ ++ PR c++/5682 ++ * cp-tree.h (BINFO_PRIMARY_P): Explain meaning better. ++ (dfs_skip_nonprimary_vbases_unmarkedp): Remove. ++ (dfs_skip_nonprimary_vbases_markedp): Remove. ++ * search.c (get_shared_vbase_if_not_primary): Remove. ++ (dfs_skip_nonprimary_vbases_unmarkedp): Remove. ++ (dfs_skip_nonprimary_vbases_markedp): Remove. ++ (dfs_unmarked_real_bases_queue_p): Just get the canonical binfo. ++ (dfs_marked_real_bases_queue_p): Likewise. ++ ++2002-03-26 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_MARK_TREE): Redefine. ++ * cp-tree.h (cxx_mark_tree): New. ++ * decl.c (lang_mark_tree): Rename cxx_mark_tree. ++ ++2002-03-25 Neil Booth ++ ++ * cp-tree.h (cxx_maybe_build_cleanup): New. ++ * decl.c (destroy_local_var, hack_incomplete_structures): Update. ++ (maybe_build_cleanup): Rename cxx_maybe_build_cleanup. ++ * tree.c (build_target_expr): Update. ++ * cp-lang.c (LANG_HOOKS_MAYBE_BUILD_CLEANUP): Redefine. ++ ++2002-03-24 Neil Booth ++ ++ * decl2.c (cxx_decode_option): Handle -E. ++ * lang-specs.h (default_compilers): Preprocess with cc1plus. ++ * lex.c (cxx_init): Exit quickly if c_common_init returns NULL. ++ ++2002-03-23 Jakub Jelinek ++ ++ PR c++/6037 ++ * decl.c (start_enum): Don't set TREE_ADDRESSABLE on TREE_LIST node. ++ ++2002-03-23 Gabriel Dos Reis ++ ++ * error.c (dump_type): Be careful about implicit typenames. ++ ++2002-03-21 Gabriel Dos Reis ++ ++ PR C++/3656 ++ * semantics.c (finish_base_specifier): Handle erronous base ++ classes. ++ ++2002-03-22 Zack Weinberg ++ ++ * error.c: Always use REAL_VALUE_TO_DECIMAL; don't test ++ REAL_IS_NOT_DOUBLE. ++ ++2002-03-22 Jeff Knaggs ++ ++ * typeck.c (get_member_function_from_ptrfunc): Scale idx down to ++ an index into the vtable_entry array regardless of ++ TARGET_PTRMEMFUNC_VBIT_LOCATION. ++ ++2002-03-21 Aldy Hernandez ++ ++ * tree.c (cp_cannot_inline_tree_fn): Same. ++ ++2002-03-21 Neil Booth ++ ++ * cp-tree.h (pushdecl, pushlevel, poplevel, set_block, ++ insert_block, getdecls, global_bindings_p): New. ++ ++2002-03-20 Nathan Sidwell ++ ++ PR c++/4361 ++ * mangle.c (struct globals) Add internal_mangling_p member. ++ (write_template_param): Do internal mangling, if needed. ++ (mangle_conv_op_name_for_type): Request internal mangling. ++ ++2002-03-20 Jason Merrill ++ ++ PR c++/2136 ++ * init.c (build_delete): Check access for a member op delete here. ++ * decl2.c (delete_sanity): Not here. ++ ++2002-03-19 Jason Merrill ++ ++ PR c++/5118 ++ * class.c (get_vfield_name): Use the constructor_name. ++ ++2002-03-20 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_DECL_PRINTABLE_NAME): Redefine. ++ * cp-tree.h (lang_printable_name): Rename. ++ * error.c (lang_decl_name): Use new hook. ++ * lex.c (cxx_init): Remove old hook. ++ * pt.c (tsubst_decl): Use new hook. ++ * tree.c (lang_printable_name): Rename. ++ ++2002-03-18 Eric Botcazou ++ ++ PR c++/3882 ++ * pt.c (tsubst_decl): Move __PRETTY_FUNCTION__ handling... ++ (tsubst_expr) [DECL_STMT]: ...here. And substitute the initializer ++ only after recording the declaration. ++ ++2002-03-18 Jason Merrill ++ ++ PR c++/2039 ++ * init.c (resolve_offset_ref): Hand off to build_component_ref. ++ ++ PR c++/4222, c++/5995 ++ * call.c (build_over_call): Fix empty class logic. ++ ++ PR c++/3870 ++ * cp-tree.h (struct saved_scope): Add last_parms field. ++ * decl.c (maybe_push_to_top_level): Save last_function_parms. ++ (pop_from_top_level): Restore it. ++ ++ PR c++/4377 ++ * mangle.c (write_expression): Strip NOP_EXPRs sooner. Also strip ++ NON_LVALUE_EXPRs. ++ ++ PR c++/4003 ++ * pt.c (tsubst_friend_function): Use decl_namespace_context. ++ ++ PR c++/3948 -- C++ ABI change, followup to 2001-12-18 patch. ++ * class.c (finish_struct_bits): Also set TREE_ADDRESSABLE for a ++ type with a nontrivial destructor. ++ ++2002-03-17 Jason Merrill ++ ++ PR c++/4460 ++ * class.c (build_base_path): Virtual base layout is fixed in ++ in-charge [cd]tors. ++ ++2002-03-17 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_PARSE_FILE): Redefine. ++ * parse.y (yyparse): Remove macro. ++ ++2002-03-17 Jason Merrill ++ ++ PR c++/5757 ++ * init.c (build_new_1): Pass the right pointer to op delete. ++ ++2002-03-16 Nathan Sidwell ++ ++ PR c++/4361 ++ * cp-tree.h (CLASSTYPE_METHOD_VEC): Document where templated ++ conversion operators go. ++ (struct lang_decl_flags): Add template_conv_p and unused ++ bitfields. ++ (DECL_TEMPLATE_CONV_FN_P): New macro. ++ * call.c (build_user_type_conversion_1): Don't check second type ++ conversion of overload set first. ++ * class.c (add_method): Make sure templated conversion operators ++ all end up on slot 2. ++ * lex.c (do_identifier): A conversion operator token might be ++ satisfied by a templated conversion operator. ++ * pt.c (check_explicit_specialization): Use ++ CLASSTYPE_FIRST_CONVERSION_SLOT. ++ (template_parm_this_level_p): New function. ++ (push_template_decl_real): Determine DECL_TEMPLATE_CONV_FN_P. ++ * search.c (lookup_fnfields_1): Template conversions will be on ++ the first slot. ++ * typeck.c (build_component_ref): Preserve the type of an ++ conversion operator name on the overload type. ++ (build_x_function_call): Retrieve the conversion operator name. ++ ++2002-03-15 Richard Henderson ++ ++ * init.c (build_new_1): Use size_binop instead of cp_build_binary_op. ++ ++2002-03-15 Mark Mitchell ++ ++ * cp-tree.h (CLEANUP_DECL): Remove. ++ (CLEANUP_EXPR): Likewise. ++ * decl.c (destroy_local_var): Simplify. ++ (maybe_build_cleanup): Tidy. ++ * dump.c (cp_dump_tree): Remove handling of CLEANUP_STMT. ++ * semantics.c (cp_expand_stmt): Likewise. ++ * cp/tree.c (cp_statement_code_p): Likewise. ++ ++2002-03-15 Jason Merrill ++ ++ PR c++/5857 ++ * decl.c (duplicate_decls): Use merge_types instead of common_type. ++ * typeck.c (common_type): Just hand off to ++ type_after_usual_arithmetic_conversions and ++ composite_pointer_type. ++ (merge_types): New fn. ++ (commonparms): Use it instead of common_type. ++ (type_after_usual_arithmetic_conversions): Also handle COMPLEX_TYPE. ++ (composite_pointer_type): Also handle attributes. ++ * cp-tree.h: Declare merge_types. ++ ++ * decl.c (make_rtl_for_nonlocal_decl): Also defer COMDAT ++ variables. ++ * decl2.c (maybe_make_one_only): Also mark the decl as needed. ++ ++2002-03-14 Richard Henderson ++ ++ * decl.c: Include c-pragma.h. ++ (start_decl, start_function): Invoke maybe_apply_pragma_weak. ++ * Make-lang.in: Update dependencies. ++ ++2002-03-14 Jakub Jelinek ++ ++ PR c++/5908 ++ * call.c (build_over_call): Set TREE_NO_UNUSED_WARNING too. ++ * cvt.c (convert_to_void): Preserve TREE_NO_UNUSED_WARNING. ++ ++2002-03-12 Richard Sandiford ++ ++ * mangle.c (write_builtin_type): Handle 128-bit integers even if ++ they are not a standard integer type. ++ ++2002-03-12 Richard Sandiford ++ ++ * cp-tree.h (init_init_processing): Remove declaration. ++ * init.c (BI_header_type, init_init_processing): Remove old ABI stuff. ++ * decl.c (cxx_init_decl_processing): Don't call init_init_processing. ++ ++2002-03-12 Kaveh R. Ghazi ++ ++ * cp-lang.c (tree_code_type, tree_code_length, tree_code_name): ++ Define. ++ * decl.c (duplicate_decls): Use TREE_CODE_LENGTH, not ++ tree_code_length. ++ * lex.c (cplus_tree_code_type, cplus_tree_code_length, ++ cplus_tree_code_name): Delete. ++ (cxx_init): Don't call add_c_tree_codes, instead set ++ lang_unsafe_for_reeval. Don't try to copy into the various ++ tree_code arrays. ++ ++2002-03-12 Nathan Sidwell ++ ++ PR c++/5659 ++ * decl.c (xref_tag): Don't set CLASSTYPE_DECLARED_CLASS here. ++ * decl2.c (handle_class_head): Set CLASSTYPE_DECLARED_CLASS for ++ definitions. ++ ++2002-03-11 Nathan Sidwell ++ ++ Revert 2001-03-26 Nathan Sidwell , ++ DR209 is now not a defect. ++ * cp-tree.h (skip_type_access_control): Remove. ++ * decl.c (grokdeclarator): Do type access control for friend ++ declarations. ++ * semantics.c (decl_type_access_control): Don't reset ++ current_type_lookups. ++ (save_type_access_control): Always save the lookups. ++ (skip_type_access_control): Remove. ++ (finish_class_definition): Don't change type_lookups. ++ ++2002-03-11 Nathan Sidwell ++ ++ Revert 2000-12-01 Nathan Sidwell , ++ It is incorrect. ++ * typeck.c (build_static_cast): Compare non-qualified types ++ with pointer to member conversions. ++ ++2002-03-11 Dan Nicolaescu ++ Daniel Berlin ++ ++ * cp-lang.c (ok_to_generate_alias_set_for_type): New function. ++ (cxx_get_alias_set): Use it. ++ ++2002-03-10 Kaveh R. Ghazi ++ ++ * cp-tree.h (stabilize_expr): Prototype. ++ ++2002-03-08 Craig Rodrigues ++ ++ * cp-tree.h (CLEAR_BINFO_MARKED): Make both parts of ++ conditional return void. ++ ++2002-03-08 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_UNSAVE): Redefine. ++ * cp-tree.h (cxx_unsave): New. ++ * tree.c (cp_unsave): Rename cxx_unsave, update prototype. ++ (init_tree): Update. ++ ++2002-03-03 Kaveh R. Ghazi ++ ++ * decl.c (cxx_init_decl_processing): Use ARRAY_SIZE in lieu of ++ explicit sizeof/sizeof. ++ * decl2.c (cxx_decode_option): Likewise. ++ * lex.c (init_reswords, REDUCE_LENGTH, TOKEN_LENGTH): Likewise. ++ ++2002-03-02 Nathan Sidwell ++ ++ PR c++/775 ++ * decl.c (lookup_tag): Only reject enum/class mismatch, not ++ class/union mismatch. ++ * parse.y (check_class_key): New function. ++ (structsp): Call it. ++ ++2002-03-01 Michael Matz ++ ++ * typeck.c (cp_pointer_int_sum): Complete inner type which is ++ used later by size_in_bytes(). ++ ++2002-03-01 Phil Edwards ++ ++ * cp-tree.h: Require __GNUC__ to be #defined. ++ (build_init): Add missing prototype. ++ ++2002-03-01 Jason Merrill ++ ++ * except.c: Don't include decl.h or obstack.h. Do include ++ tree-inline.h. ++ (build_throw): Destroy temporaries from the thrown ++ expression before calling __cxa_throw. Construct a thrown ++ temporary directly into the exception object. ++ (stabilize_throw_expr): New function. ++ (wrap_cleanups_r): New function. ++ * tree.c (stabilize_expr): New function. ++ * init.c (build_init): New function. ++ * Make-lang.in (cp/except.o): Adjust .h deps. ++ ++2002-02-28 Jason Merrill ++ ++ * search.c (lookup_base_r): Don't clear is_non_public just because ++ we found a friendly scope. ++ ++ * decl.c (finish_function): Only warn about missing return ++ statement with -Wreturn-type. ++ ++2002-02-28 Neil Booth ++ ++ * class.c (build_clone): Update. ++ * cp-lang.c (LANG_HOOKS_DUP_LANG_SPECIFIC_DECL): Redefine. ++ * cp-tree.h (cxx_dup_lang_specific_decl): New. ++ * lex.c (copy_lang_decl): Rename cxx_dup_lang_specific_decl. ++ (copy_decl): Update. ++ * method.c (make_thunk): Update. ++ ++2002-02-27 Zack Weinberg ++ ++ * decl2.c: Delete traditional-mode-related code copied from ++ the C front end but not used, or used only to permit the ++ compiler to link. ++ ++2002-02-24 Craig Rodrigues ++ ++ PR c++/4093 ++ * cp-tree.h (SET_BINFO_MARKED): Cast false part of condition ++ to void. ++ ++2002-02-22 Jakub Jelinek ++ ++ PR other/5746 ++ * semantics.c (finish_switch_cond): Don't call get_unwidened ++ if error_mark_node. ++ ++2002-02-22 Nathan Sidwell ++ ++ PR c++/2645, DR 295 ++ * cp-tree.h (tsubst_flags_t): Add tf_ignore_bad_quals, ++ tf_keep_type_decl. ++ (make_typename_type): Use tsubst_flags_t. ++ * decl.c (make_typename_type): Adjust. Return non-artificial ++ TYPE_DECLs, if required. ++ (grokdeclarator): Simplify CVR qualification handling. Allow bad ++ qualifiers on typedef types. ++ * decl2.c (handle_class_head): Adjust make_typename_type call. ++ * parse.y (nested_name_specifier): Likewise. ++ (typename_sub0): Likewise. ++ (typename_sub1): Likewise. ++ * pt.c (convert_template_argument): Adjust make_typename_type ++ return value. ++ (tsubst): Adjust cp_build_qualified_type_real calls. ++ (check_cv_quals_for_unify): Cope with allowing bad qualifications ++ on template type parms. ++ (instantiate_decl): Recheck substitutions to give warnings on bad ++ qualifications. ++ * tree.c (cp_build_qualified_type_real): Use tf_allow_bad_quals. ++ ++2002-02-21 Aldy Hernandez ++ ++ * cp/decl.c (duplicate_decls): Merge always_inline attribute. ++ ++ * cp/tree.c (cp_cannot_inline_tree_fn): Do not inline at -O0 ++ unless DECL_ALWAYS_INLINE. ++ ++2002-02-20 Jakub Jelinek ++ ++ * typeck.c (cp_pointer_int_sum): Renamed from ++ pointer_int_sum, call pointer_int_sum. ++ ++2002-02-20 Jakub Jelinek ++ ++ * decl.c (duplicate_decls): Return 0 if issued error about ++ redeclaration. ++ ++2002-02-19 Jason Merrill ++ ++ ABI change: Mangle `void (A::*)() const' as ++ M1AKFvvE, not MK1AFvvE. ++ * mangle.c (write_function_type): Write cv-quals for member ++ function type here. ++ (write_pointer_to_member_type): Not here. ++ ++2002-02-18 Jason Merrill ++ ++ * pt.c (do_type_instantiation): Don't pedwarn if in_system_header. ++ (do_decl_instantiation): Likewise. ++ ++2002-02-17 Craig Rodrigues ++ ++ PR c++/5685 ++ * decl.c (duplicate_decls): Make warning unconditional ++ if duplicate default argument declarations are present. ++ ++2002-02-17 Jakub Jelinek ++ ++ * typeck.c (build_binary_op) [BIT_XOR_EXPR]: Remove explicit ++ shortening. ++ ++2002-02-15 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Set typedef_decl for all TYPE_DECLs, ++ remove incorrect comment. Move #if 0'd code to common path. Use ++ IMPLICIT_TYPENAME_P. Simplify & reformat ARRAY_TYPE duplication. ++ ++2002-02-13 Jason Merrill ++ ++ * decl.c (builtin_function): Set TREE_THIS_VOLATILE on return fns. ++ (finish_function): Don't warn if current_function_returns_null. ++ ++ * typeck2.c (digest_init): Do handle values of vector type. ++ ++ * typeck2.c (digest_init, process_init_constructor): Treat vectors ++ like arrays. ++ ++2002-02-11 Jason Merrill ++ ++ * parse.y (reserved_declspecs): Don't handle attributes. ++ (reserved_typespecquals): Handle them here. ++ * Make-lang.in (parse.c): Adjust expected conflicts. ++ ++2002-02-08 Jakub Jelinek ++ ++ * parse.y (primary, primary_no_id): Use compstmt_or_stmtexpr ++ instead of compstmt. ++ (compstmt_or_stmtexpr): Renamed from compstmt. ++ (compstmt): In addition to compstmt_or_stmtexpr clear last_expr_type. ++ ++2002-02-07 Nathan Sidwell ++ ++ Rename instantiate_type_flags to tsubst_flags_t & expand use. ++ * cp-tree.h (instantiate_type_flags): Rename to ... ++ (tsubst_flags_t): ... here. Rename itf_complain to tf_error, ++ add tf_warning flag. ++ (instantiate_type): Adjust prototype. ++ (tsubst, tsubst_expr, tsubst_copy, lookup_template_class, ++ do_type_instantiation, cp_build_qualified_type_real): Likewise. ++ cp_build_qualified_type: Adjust. ++ * class.c (instantiate_type): Adjust parameter. Rename itf_* to ++ tf_*. ++ * call.c (standard_conversion): Rename itf_* to tf_*. ++ (reference_binding): Likewise. ++ (convert_like_real): Likewise. ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ (convert_to_reference): Likewise. ++ * decl.c (lookup_namespace_name): Use tf_* flags. ++ (make_typename_type): Likewise. ++ (grokdeclarator): Likewise. ++ * pt.c (convert_nontype_argument): Adjust COMPLAIN usage. ++ (coerce_template_template_parms, convert_template_argument, ++ coerce_template_parms, maybe_get_template_decl_from_type_decl, ++ lookup_template_class, tsubst_friend_function, tsubst_friend_class, ++ instantiate_class_template, tsubst_template_arg_vector, ++ tsubst_template_parms, tsubst_aggr_type, tsubst_default_argument, ++ tsubst_decl, tsubst_arg_types, tsubst_function_type, ++ tsubst_call_declarator_parms, tsubst, tsubst_copy, tsubst_expr, ++ instantiate_template, fn_type_unification, ++ resolve_overloaded_unification, verify_class_unification, ++ unify, get_bindings_real, do_type_instantiation, ++ regenerate_decl_from_template, instantiate_decl, ++ tsubst_initializer_list, tsubst_enum, ++ get_mostly_instantiated_function_type, ++ invalid_nontype_parm_type_p): Likewise. ++ * tree.c (cp_build_qualified_type_real): Likewise. ++ * typeck.c (build_binary_op): Rename itf_* to tf_*. ++ (build_ptrmemfunc): Likewise. ++ (convert_for_assignment): Likewise. ++ ++2002-02-07 Nathan Sidwell ++ ++ PR c++/109 ++ * decl.c (grokdeclarator): Allow friend declarations from ++ dependent types. ++ * decl2.c (handle_class_head): Don't push into template parm contexts. ++ * pt.c (push_template_decl_real): Template parm contexts are never ++ being defined. ++ ++2002-02-05 Alexandre Oliva ++ ++ * class.c: Include target.h. ++ (check_bitfield_decl): Disregard EMPTY_FIELD_BOUNDARY, ++ BITFIELDS_NBYTES_LIMITED and PCC_BITFIELD_TYPE_MATTERS for MS ++ bit-field layout. ++ * Make-lang.in: Adjust deps. ++ ++2002-02-05 Jason Merrill ++ ++ * error.c (dump_type): Be more helpful about VECTOR_TYPE. ++ ++2002-02-04 Jakub Jelinek ++ ++ * semantics.c (begin_switch_stmt): Clear SWITCH_TYPE. ++ (finish_switch_cond): Set SWITCH_TYPE. ++ ++2002-02-04 Richard Henderson ++ ++ * method.c (use_thunk): Always initialize the block tree. Reindent. ++ * semantics.c (expand_body): Emit thunks after function, not before. ++ ++2002-02-04 Jason Merrill ++ ++ * decl.c (start_function): Call cplus_decl_attributes immediately ++ after grokdeclarator. ++ ++ * decl.c (start_function): Combine DECL_RESULT handling code. ++ ++2002-02-03 Jason Merrill ++ ++ * xref.c: Remove. ++ * Make-lang.in (CXX_OBJS): Remove cp/xref.o ++ (cp/xref.o): Remove dependencies. ++ * class.c (finish_struct_1, check_methods): Don't call xref fns. ++ (finish_struct_1): Likewise. ++ * friend.c (make_friend_class): Likewise. ++ * lex.c (cxx_init, cxx_finish, extract_interface_info): Likewise. ++ * spew.c (read_process_identifier): Likewise. ++ ++2002-02-01 Jason Merrill ++ ++ PR c++/4872 ++ * decl.c (finish_function): Warn about a non-void function with ++ no return statement and no abnormal exit. ++ * cp-tree.h (struct cp_language_function): Add returns_abnormally. ++ (current_function_returns_abnormally): New macro. ++ * call.c (build_call): Set it. ++ ++ * typeck.c (build_component_ref): Always complain about offsetof ++ constructs on non-PODs. Only make it an error for members of ++ virtual bases. ++ ++ * error.c (dump_scope): Don't add TFF_DECL_SPECIFIERS. ++ (dump_function_decl): Always dump parms. ++ ++ * decl2.c (finish_static_data_member_decl): Complain about a local ++ class with a static data member. ++ ++ PR c++/4286 ++ * search.c (lookup_field_1): Don't xref a static data member ++ just because we looked it up. ++ ++2002-01-31 Jason Merrill ++ ++ * Make-lang.in (parse.c): Handle .output file. ++ ++ PR c++/3395 ++ * decl.c (xref_tag): Remember early attributes in TYPE_ATTRIBUTES, ++ not TREE_TYPE. ++ * semantics.c (finish_class_definition): Adjust. ++ ++ Allow attributes in parms and casts. ++ * parse.y (named_parm): Don't strip attrs. ++ (declmods): Remove 'attributes' production. ++ (nonempty_cv_qualifiers): Accept attributes. ++ (ATTRIBUTE): Give precedence. ++ * decl.c (groktypename): Handle attributes. ++ (grokparms): Likewise. ++ ++2002-01-29 Jakub Jelinek ++ ++ * decl2.c (cxx_decode_option): Pass 0 as last argument to ++ cpp_handle_option. ++ * lang-specs.h: Use cpp_unique_options instead of cpp_options ++ when used together with cc1_options. ++ ++2002-01-29 Nathan Sidwell ++ ++ PR c++/5132 ++ * typeck2.c (digest_init): Make sure non-array core type is ++ instantiated. ++ * decl2.c (reparse_absdcl_as_casts): Just store the type in the ++ constructor, rather than build a new one. ++ (build_expr_from_tree, CONSTRUCTOR case): Be careful with the ++ PURPOSE of constructor elts. ++ ++2002-01-23 Zack Weinberg ++ ++ * Make-lang.in (parse.c): Adjust expected number of ++ shift-reduce conflicts. ++ (decl.o): Depend on diagnostic.h. ++ * decl.c: Include diagnostic.h. ++ (grokdeclarator): Check for null pointer. ++ (finish_function): Don't abort when ++ current_binding_level->parm_flag != 1, if errors have ++ occurred; throw away the statement tree and extra binding ++ levels, and continue. ++ * lex.c (note_list_got_semicolon): Check for null pointer. ++ * method.c (hack_identifier): Just return error_mark_node if ++ value is error_mark_node. ++ * parse.y (primary: TYPEID(type_id)): No need to use ++ TYPE_MAIN_VARIANT here. ++ (handler_seq): Accept an empty list of catch clauses and ++ generate a fake handler block to avoid later crashes. ++ (ansi_raise_identifier): Accept the error token too. ++ * semantics.c (begin_class_definition, ++ finish_class_definition): Check for error_mark_node. ++ ++2002-01-23 Zack Weinberg ++ ++ * typeck2.c (friendly_abort): Delete definition. ++ * cp-tree.h (friendly_abort): Don't prototype. ++ (my_friendly_assert): Use fancy_abort. ++ ++2002-01-23 Craig Rodrigues ++ ++ * cp-tree.h (my_friendly_abort): Remove. ++ ++2002-01-23 Jakub Jelinek ++ ++ * spew.c (pending_inlines, pending_inlines_tail, ++ processing_these_inlines): Make static. ++ (mark_pending_inlines): Remove static. ++ (begin_parsing_inclass_inline): If in function, save pi ++ for GC to cp_function_chain->unparsed_inlines instead. ++ (process_next_inline): Likewise. ++ * cp-tree.h (struct cp_language_function): Add unparsed_inlines. ++ (mark_pending_inlines): Add prototype. ++ * decl.c (spew_debug): Remove unused extern. ++ (mark_lang_function): Call mark_pending_inlines. ++ ++2002-01-23 Craig Rodrigues ++ ++ * call.c, class.c, decl.c, decl2.c, error.c, expr.c, friend.c, ++ init.c, lex.c, mangle.c, method.c, pt.c, repo.c, rtti.c, search.c, ++ semantics.c, spew.c, tree.c, typeck.c, typeck2.c, xref.c: ++ Change my_fancy_abort() to abort(). ++ ++2002-01-23 Jason Merrill ++ ++ PR c++/5453 ++ * class.c (fixed_type_or_null): Fix thinko. ++ ++ PR c++/3331 ++ * init.c (resolve_offset_ref): Use build_indirect_ref. ++ ++ * decl2.c (grokclassfn): Don't set DECL_REGISTER on 'this'. ++ ++2002-01-22 Jason Merrill ++ ++ * parse.y (function_body): Suppress the block for the outermost ++ curly braces. ++ * decl.c (pushdecl): Don't try to skip it. ++ (begin_function_body): Keep the block we create, not the next one. ++ * init.c (emit_base_init): Don't mess with keep_next_level. ++ ++ * class.c (build_base_path): Tweak formatting. ++ ++2002-01-19 Nathan Sidwell ++ ++ Fix regression introduced with patch for c++/775 ++ * parse.y (class_head_defn): Check for template specializations ++ with a different class-key. ++ ++2002-01-17 Jason Merrill ++ ++ * decl.c (begin_constructor_body, begin_destructor_body): New fns. ++ (begin_function_body): Call them and keep_next_level. ++ * init.c (emit_base_init): Call keep_next_level. ++ * semantics.c (setup_vtbl_ptr): Lose. ++ * cp-tree.h (struct cp_language_function): Remove vtbls_set_up_p. ++ (vtbls_set_up_p): Lose. ++ * pt.c (tsubst_expr, CTOR_INITIALIZER): Call emit_base_init. ++ * method.c (do_build_copy_constructor): Likewise. ++ (synthesize_method): Call finish_mem_initializers. ++ * parse.y (nodecls): Likewise. ++ ++ * error.c (dump_type_suffix): Print the exception specs before ++ recursing. ++ (dump_function_decl): Here, too. ++ ++ * cp-tree.h (TMPL_PARMS_DEPTH): Cast to signed HOST_WIDE_INT. ++ ++2002-01-10 Ira Ruben ++ ++ PR c++/907 ++ * decl.c (start_method): Handle attrlist. ++ ++2002-01-10 Jakub Jelinek ++ ++ * decl2.c (max_tinst_depth): Increase default limit to 500. ++ ++2002-01-10 Graham Stott ++ ++ * spew.c (YYCHAR): Uppercase macro parameter and add ++ parenthesis. ++ (YYCODE): Likewise. ++ (NAME): Uppercase macro parameter. ++ ++2002-01-09 Graham Stott ++ ++ * decl.h (grokdeclarator): Wrap long line. ++ ++ * semantics.c (FINISH_COND): Uppercase macro paramaters and ++ add parenthesis. ++ ++2002-01-08 Graham Stott ++ ++ * xref.c (FILE_NAME_ABSOLUTE_P): Add parenthesis. ++ (PALLOC): Uppercase macro parameter and whitespace. ++ (SALLOC): Uppercase macro parameter. ++ (SFREE): Uppercase macros parameter, add parenthese and ++ whitespace. ++ (STREQL): Uppercase macro parameter and whitespace. ++ (STRNEQ): Likewise. ++ (STRLSS): Likewise. ++ (STRLEQ): Likewise. ++ (STRGTR): Likewise. ++ (STRGEQ): Likewise. ++ ++ * call.c (convert_like): Add parenthesis and wrap. ++ (convert_like_with_context): Likewise. ++ (ICS_RANK): Whitespace. ++ (NEED_TEMPORARY_P): Remove parenthesis. ++ ++ * class.c (VTT_TOP_LEVEL_P): Uppercase macro parameter and ++ whitespace. ++ (VTT_MARKED_BINFO_P): Likewise. ++ ++ * decl.c (BINDING_LEVEL): Add parenthesis. ++ (DEF_OPERATOR): Likewise. ++ ++ * mangle.c (MANGLE_TRACE): Add parenthesis. ++ (MANGLE_TRACE_TREE): Likewise. ++ (write_signed_number): Likewise. ++ (write_unsigned_number): Likewise. ++ ++ * pt.c (ccat): Uppercase macro parameter. ++ (cat): Likewise ++ ++ * search.c (SET_BINFO_ACCESS): Add parenthesis. ++ ++2002-01-07 Jason Merrill ++ ++ * decl2.c (coerce_new_type): Downgrade error for size_t mismatch ++ to pedwarn. ++ ++ PR c++/3536 ++ * method.c (make_thunk): If !flag_weak, give the thunk the ++ function's linkage. ++ (use_thunk): Here, too. ++ ++2002-01-07 Graham Stott ++ ++ * error.c: Update copyright date. ++ (print_scope_operator): Add parenthesis. ++ (print_left_paren): Likewise. ++ (print_right_paren): Likewise. ++ (print_left_bracket): Likewise. ++ (print_right_bracket): Likewise. ++ (print_template_argument_list_start): Likewise. ++ (print_template_argument_list_end): Likewise. ++ (print_non_consecutive_character): Likewise. ++ (print_tree_identifier): Likewise. ++ (print_identifier): Likewise. ++ (NEXT_CODE): Uppercase macro parameter. ++ (ident_fndecl): Delete unused. ++ (GLOBAL_THING): Likewise. ++ ++2002-01-06 Graham Stott ++ ++ * cp-tree.h (VAR_OR_FUNCTION_DECL_CHECK): Add parenthesis. ++ (VAR_FUNCTION_OR_PARM_DECL_CHECK): Likewise. ++ (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK) Likewise. ++ (RECORD_OR_UNION_TYPE_CHECK): Likewise. ++ (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK): Likewise. ++ (C_IS_RESERVED_WORD): Uppercase macro parameter. ++ (C_RID_YYCODE) Likewise. ++ (ptrmem_cst): Use rtx. ++ (LOCAL_BINDING_P): Add whitespace. ++ (INHERITED_VALUE_BINDING_P): Likewise. ++ (BINDING_SCOPE): Wrap long line. ++ (BINDING_HAS_LEVEL_P): Remove parenthesis. ++ (BINDING_VALUE): Wrap long line. ++ (BINDING_TYPE): Whitespace. ++ (IDENTIFIER_GLOBAL_VALUE): Add parenthesis. ++ (SET_IDENTIFIER_GLOBAL_VALUE): Likewise. ++ (IDENTIFIER_NAMESPACE_VALUE): Likewise. ++ (SET_IDENTIFIER_NAMESPACE_VALUE: Likewise. ++ (same_type_p): Uppercase macro parameters. ++ (same_type_ignoring_top_level_qualifiers_p): Likewise. ++ (OVL_FUNCTION): Wrap long line. ++ (OVL_CHAIN): Whitespace. ++ (OVL_CURRENT): Add parenthesis and whitespace. ++ (OVL_NEXT): Whitespace. ++ (OVL_USED): Likewise. ++ (IDENTIFIER_TYPE_VALUE): Likewise. ++ (REAL_IDENTIFIER_TYPE_VALUE): Remove parenthesis. ++ (SET_IDENTIFIER_TYPE_VALUE): Add parenthesis and whitespace. ++ (LANG_ID_FIELD): Whitespace. ++ (SET_LANG_ID(NODE,VALUE,NAME): Likewise. ++ (IDENTIFIER_LABEL_VALUE): Whitespace and wrap. ++ (SET_IDENTIFIER_LABEL_VALUE): Whitespace. ++ (IDENTIFIER_IMPLICIT_DECL): Whitespace and wrap. ++ (SET_IDENTIFIER_IMPLICIT_DECL); Whitespace. ++ (IDENTIFIER_ERROR_LOCUS): Whitespace and wrap. ++ (SET_IDENTIFIER_ERROR_LOCUS); Whitespace. ++ (IDENTIFIER_VIRTUAL_P): Likewise. ++ (IDENTIFIER_OPNAME_P): Likewise. ++ (IDENTIFIER_TYPENAME_P): Remove parenthesis. ++ (C_TYPE_FIELDS_READONLY): Uppercase macro parameters. ++ (C_SET_EXP_ORIGINAL_CODE): Likewise. ++ (TYPE_ASSEMBLER_NAME_STRING): Wrap long line. ++ (TYPE_ASSEMBLER_NAME_LENGTH): Likewise. ++ (IS_AGGR_TYPE): Uppercase macro parameter. ++ (CLASS_TYPE_P): Likewise. ++ (IS_AGGR_TYPE_CODE): Uppercase macro parameter and parenthesis. ++ (IS_AGGR_TYPE_2): Whitespace. ++ (TAGGED_TYPE_P): Uppercase macro parameter. ++ (TYPE_BUILT_IN): Whitespace. ++ (TYPE_FOR_JAVA): Likewise. ++ (FUNCTION_ARG_CHAIN): Remove parenthesis. ++ (FUNCTION_FIRST_USER_PARMTYPE): Add parenthesis. ++ (FUNCTION_FIRST_USER_PARAM): Likewise. ++ (PROMOTES_TO_AGGR_TYPE): Whitespace. ++ (DERIVED_FROM_P): Add parenthesis and wrap. ++ (UNIQUELY_DERIVED_FROM_P): Likewise. ++ (ACCESSIBLY_UNIQUELY_DERIVED_P): Likewise. ++ (PUBLICLY_UNIQUELY_DERIVED_P): Likewise. ++ (CLASSTYPE_USE_TEMPLATE): Whitespace. ++ (CLASSTYPE_INLINE_FRIENDS): Remove parenthesis. ++ (TYPE_GETS_DELETE): Add parenthesis. ++ (TYPE_HAS_CONVERSION): Add parenthesis and wrap. ++ (TYPE_HAS_ASSIGN_REF): Likewise, ++ (TYPE_HAS_CONST_ASSIGN_REF): Likewise. ++ (TYPE_HAS_INIT_REF): Likewise. ++ (TYPE_HAS_CONST_INIT_REF): Likewise. ++ (TYPE_BEING_DEFINED): Likewise. ++ (TYPE_LANG_SPECIFIC): Likewise. ++ (CLASSTYPE_RTTI): Likewise. ++ (TYPE_OVERLOADS_CALL_EXPR): Likewise. ++ (TYPE_OVERLOADS_ARRAY_REF): Likewise. ++ (TYPE_OVERLOADS_ARROW): Likewise. ++ (TYPE_USES_MULTIPLE_INHERITANCE): Likewise. ++ (TYPE_USES_VIRTUAL_BASECLASSES): Add parenthesis. ++ (CLASSTYPE_METHOD_VEC): Likewise. ++ (CLASSTYPE_MARKED_N): Likewise. ++ (CLASSTYPE_MARKED): Likewise. ++ (CLASSTYPE_MARKED2): Likewise. ++ (CLASSTYPE_MARKED3): Likewise. ++ (CLASSTYPE_MARKED4): Likewise. ++ (CLASSTYPE_MARKED5): Likewise. ++ (CLASSTYPE_MARKED6): Likewise. ++ (SET_CLASSTYPE_MARKED): Whitespace. ++ (CLEAR_CLASSTYPE_MARKED): Likewise. ++ (SET_CLASSTYPE_MARKED2): Likewise. ++ (CLEAR_CLASSTYPE_MARKED2): Likewise. ++ (SET_CLASSTYPE_MARKED3): Likewise. ++ (CLEAR_CLASSTYPE_MARKED3): Likewise. ++ (SET_CLASSTYPE_MARKED4): Likewise. ++ (CLEAR_CLASSTYPE_MARKED4): Likewise. ++ (SET_CLASSTYPE_MARKED5): Likewise. ++ (CLEAR_CLASSTYPE_MARKED5): Likewise. ++ (SET_CLASSTYPE_MARKED6): Likewise. ++ (CLEAR_CLASSTYPE_MARKED6): Likewise. ++ (CLASSTYPE_TAGS): Likewise. ++ (CLASSTYPE_VSIZE): Likewise. ++ (CLASSTYPE_VBASECLASSES): Likewise. ++ (CANONICAL_BINFO): Add parenthesis. ++ (CLASSTYPE_SIZE(NODE): Likewise. ++ (CLASSTYPE_SIZE_UNIT): Likewise. ++ (CLASSTYPE_ALIGN(NODE): Likewise. ++ (CLASSTYPE_USER_ALIGN): Likewise. ++ (TYPE_JAVA_INTERFACE): Likewise. ++ (CLASSTYPE_PURE_VIRTUALS): Likewise. ++ (CLASSTYPE_NEEDS_VIRTUAL_REINIT): Whitespace and wrap. ++ (TYPE_HAS_DEFAULT_CONSTRUCTOR): Likewise. ++ (CLASSTYPE_HAS_MUTABLE): Likewise. ++ (CLASSTYPE_FRIEND_CLASSES): Likewise. Likewise. ++ (CLASSTYPE_DECLARED_CLASS): Whitespace and wrap. ++ (CLASSTYPE_READONLY_FIELDS_NEED_INIT): Likewise. ++ (CLASSTYPE_REF_FIELDS_NEED_INIT): Likewise. ++ (CLASSTYPE_INTERFACE_ONLY): Likewise. ++ (CLASSTYPE_INTERFACE_KNOWN): Likewise. ++ (CLASSTYPE_INTERFACE_UNKNOWN): Likewise. ++ (SET_CLASSTYPE_INTERFACE_UNKNOWN_X): Likewise. ++ (SET_CLASSTYPE_INTERFACE_UNKNOWN): Likewise. ++ (SET_CLASSTYPE_INTERFACE_KNOWN): Likewise. ++ (CLASSTYPE_DEBUG_REQUESTED): Whitespace and wrap. ++ (BINFO_UNSHARED_MARKED): Whitespace. ++ (BINFO_MARKED): Whitespace and wrap. ++ (SET_BINFO_MARKED): Likewise. ++ (CLEAR_BINFO_MARKED): Likewise. ++ (BINFO_VTABLE_PATH_MARKED): Likewise. ++ (SET_BINFO_VTABLE_PATH_MARKED): Likewise. ++ (CLEAR_BINFO_VTABLE_PATH_MARKED): Likewise. ++ (BINFO_SUBVTT_INDEX): Remove parenthesis. ++ (BINFO_VPTR_INDEX): Likewise. ++ (BINFO_PRIMARY_BASE_OF): Likewise, ++ (CLASSTYPE_VFIELDS): Whitespace. ++ (VF_DERIVED_VALUE): Wrap long line. ++ (NAMESPACE_LEVEL): Whitespace. ++ (CAN_HAVE_FULL_LANG_DECL_P): Remove parenthesis. ++ (DEFARG_POINTER): Whitespace. ++ (DECL_NEEDED_P): Remove parenthesis. ++ (DECL_LANGUAGE): Whitespace. ++ (SET_DECL_LANGUAGE): Add parenthesis. ++ (DECL_CONSTRUCTOR_P): Whitespace and wrap. ++ (DECL_OVERLOADED_OPERATOR_P): Remove parenthesis. ++ (DECL_IN_AGGR_P): Whitespace. ++ (DECL_FRIEND_P): Likewise. ++ (DECL_BEFRIENDING_CLASSES): Likewise. ++ (DECL_STATIC_FUNCTION_P): Whitespace and wrap. ++ (DECL_NONCONVERTING_P): Whitespace. ++ (DECL_PURE_VIRTUAL_P): Likewise. ++ (DECL_NEEDS_FINAL_OVERRIDER_P): Likewise. ++ (DECL_PENDING_INLINE_INFO): Whitespace. ++ (DECL_SORTED_FIELDS): Likewise. ++ (DECL_DEFERRED_FN): Likewise. ++ (DECL_TEMPLATE_INFO): Likewise. ++ (CLASSTYPE_TEMPLATE_INFO): Whitespace and wrap. ++ (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO); Likewise. ++ (SET_TYPE_TEMPLATE_INFO): Add parenthesis. ++ (TMPL_ARGS_LEVEL): Likewise. ++ (SET_TMPL_ARGS_LEVEL): Likewise. ++ (INNERMOST_TEMPLATE_PARMS): Whitespace. ++ (C_TYPEDEF_EXPLICITLY_SIGNED): Uppercase macro parameter. ++ (INTEGRAL_CODE_P(CODE): Add parenthesis. ++ (CP_INTEGRAL_TYPE_P): Remove parenthesis. ++ (TYPE_HAS_CONSTRUCTOR): Whitespace. ++ (TREE_HAS_CONSTRUCTOR): Likewise. ++ (TYPE_HAS_DESTRUCTOR): Likewise. ++ (TYPE_HAS_REAL_ASSIGN_REF): Likewise. ++ (TYPE_HAS_COMPLEX_ASSIGN_REF): Likewise. ++ (TYPE_HAS_ABSTRACT_ASSIGN_REF): Likewise. ++ (TYPE_HAS_COMPLEX_INIT_REF): Likewise. ++ (TYPE_HAS_NONTRIVIAL_DESTRUCTOR): Likewise. ++ (TYPE_PTRMEMFUNC_P): Likewise. ++ (TYPE_PTRMEMFUNC_FLAG): Likewise. ++ (TYPE_GET_PTRMEMFUNC_TYPE): Likewise. ++ (TYPE_SET_PTRMEMFUNC_TYPE): Likewise. ++ (TYPE_PTRMEM_CLASS_TYPE): Remove parenthesis. ++ (TYPE_PTRMEM_POINTED_TO_TYPE): Likewise. ++ (DECL_ACCESS): Whitespace. ++ (DECL_GLOBAL_CTOR_P): Remove parenthesis. ++ (DECL_GLOBAL_DTOR_P): Likewise. ++ (GLOBAL_INIT_PRIORITY): Likewise. ++ (DECL_TEMPLATE_PARMS): Likewise. ++ (DECL_TEMPLATE_RESULT): Likewise. ++ (DECL_TEMPLATE_INSTANTIATIONS): Likewise. ++ (DECL_TEMPLATE_SPECIALIZATIONS): Likewise. ++ (DECL_IMPLICIT_TYPEDEF_P): Remove parenthesis. ++ (SET_DECL_IMPLICIT_TYPEDEF_P): Likewise. ++ (PRIMARY_TEMPLATE_P): Add parenthesis. ++ (DECL_USE_TEMPLATE): Whitespace. ++ (CLASSTYPE_IMPLICIT_INSTANTIATION): Likewise. ++ (SET_CLASSTYPE_IMPLICIT_INSTANTIATION): Likewise. ++ (CLASSTYPE_EXPLICIT_INSTANTIATION): Likewise. ++ (SET_CLASSTYPE_EXPLICIT_INSTANTIATION): Likewise. ++ (CALL_DECLARATOR_PARMS): Remove parenthesis. ++ (CALL_DECLARATOR_QUALS): Likewise. ++ (CALL_DECLARATOR_EXCEPTION_SPEC): Likewise. ++ (TEMP_NAME_P): Wrap. ++ (VFIELD_NAME_P): Likewise. ++ (B_SET): Uppercase macro parameters and add parenthesis. ++ (B_CLR): Likewise. ++ (B_TST): Likewise. ++ (LOOKUP_NAMESPACES_ONLY): Uppercase macro parameters. ++ (LOOKUP_TYPES_ONLY): Uppercase macro parameters. ++ (LOOKUP_QUALIFIERS_ONLY): Uppercase macro parameters. ++ (same_or_base_type_p): Likewise. ++ (cp_deprecated): Likewise. ++ ++2002-01-05 Richard Henderson ++ ++ * semantics.c (expand_body): Revert last change. ++ ++2002-01-04 Jason Merrill ++ ++ PR c++/4122 ++ * class.c (update_vtable_entry_for_fn): Set delta to zero for a ++ lost primary. ++ ++ * class.c (build_vtbl_initializer): Check for a lost primary ++ before calculating the vtable entry to throw away. ++ ++2002-01-02 Jason Merrill ++ ++ * semantics.c (expand_body): Call outlining_inline_function when ++ emitting an inline function out of line. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/5116, c++/764 reversion ++ * call.c (build_new_op): Revert the instantiations. They are ++ incorrect. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/5089 ++ * decl2.c (reparse_absdcl_as_casts): Don't warn about casts to void. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/3716 ++ * pt.c (tsubst_aggr_type): Move pmf handling into tsubst. ++ (tsubst, case POINTER_TYPE): Handle pmfs here. ++ (tsubst, case OFFSET_TYPE): Check it is not an offset to ++ reference. If it is offset to FUNCTION_TYPE, create a METHOD_TYPE. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/35 ++ * cp-tree.h (DECL_LANG_FLAG_0): Used for PARM_DECL too. ++ (DECL_TEMPLATE_PARM_P): A PARM_DECL might be one too. ++ * pt.c (process_template_parm): SET_DECL_TEMPLATE_PARM_P on the ++ PARM_DECL. ++ (tsubst_template_parms): Break up loop statements. ++ (tsubst_decl, case PARM_DECL): Copy DECL_TEMPLATE_PARM_P. Template ++ parm PARM_DECLs don't get promoted. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/5123 ++ * typeck.c (build_component_ref): Cope with a TEMPLATE_ID_EXPR. ++ (build_x_function_call): Cope with a COMPONENT_REF containing a ++ TEMPLATE_ID_EXPR. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/5213 ++ * pt.c (convert_template_argument): Be more careful determining ++ when RECORD_TYPE templates are or are not templates. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/775 ++ * cp-tree.h (handle_class_head): Adjust prototype. ++ * decl2.c (handle_class_head): Add DEFN_P and NEW_TYPE_P ++ parameters. Use for all class heads. ++ * parse.y (named_class_head_sans_basetype, named_class_head, ++ named_complex_class_head_sans_basetype, ++ named_class_head_sans_basetype_defn, ++ unnamed_class_head): Remove. ++ (class_head, class_head_apparent_template): Recognize class heads ++ (class_head_decl, class_head_defn): New reductions. Process class ++ heads. ++ (structsp): Adjust class definition and class declaration ++ reductions. ++ (maybe_base_class_list): Give diagnostic on empty list. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/4379 ++ * typeck.c (build_x_unary_op): Don't destroy the OFFSET_REF on a ++ single non-static member. ++ (unary_complex_lvalue): If it cannot be a pointer to member, don't ++ make it so. Check it is not pointer to reference. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/5132 ++ * decl2.c (reparse_absdcl_as_casts): Don't digest_init if we ++ are processing a template decl. ++ ++2002-01-02 Nathan Sidwell ++ ++ PR c++/5116, c++/764 ++ * call.c (build_new_op): Make sure template class operands are ++ instantiated. Simplify arglist construction. ++ ++2001-12-29 Nathan Sidwell ++ ++ * call.c (build_user_type_conversion_1): Use my_friendly_assert ++ rather than if ... abort. ++ * cvt.c (convert_to_reference): Likewise. ++ * semantics.c (setup_vtbl_ptr): Likewise. ++ * pt.c (lookup_template_class): Comment typo. ++ ++2001-12-29 Nathan Sidwell ++ ++ PR c++/5125 ++ * pt.c (push_template_decl_real): Make sure DECL has ++ DECL_LANG_SPECIFIC. ++ ++2001-12-29 Nathan Sidwell ++ ++ PR c++/335 ++ * init.c (resolve_offset_ref): Copy cv qualifiers of this pointer ++ for non-reference fields. ++ * typeck.c (require_complete_type): Use resolve_offset_ref). ++ ++2001-12-26 Nathan Sidwell ++ ++ PR c++/196 ++ * parse.y (bad_parm): Better diagnostic when given a SCOPE_REF. ++ ++2001-12-24 Nathan Sidwell ++ ++ PR c++/160 ++ * typeck.c (build_modify_expr): Remove old unreachable code & tidy ++ up. Don't stabilize_references when initializing a reference. ++ ++2001-12-23 Kaveh R. Ghazi ++ ++ * decl2.c (lang_f_options): Const-ify. ++ ++2001-12-20 Joseph S. Myers ++ ++ * config-lang.in (diff_excludes): Remove. ++ ++2001-12-19 Nathan Sidwell ++ ++ PR c++/90 ++ * typeck.c (build_function_call_real): Use original function ++ expression for errors. ++ ++2001-12-18 Jason Merrill ++ ++ PR c++/3242 ++ * class.c (add_method): Do compare 'this' quals when trying to match a ++ used function. Don't defer to another used function. ++ ++2001-12-18 Nathan Sidwell ++ ++ * pt.c (instantiate_clone): Remove, fold into ... ++ (instantiate_template): ... here. Simplify by removing mutual ++ recursion. ++ * typeck2.c (build_m_component_ref): Don't cv qualify the function ++ pointed to by a pointer to function. ++ * class.c (delete_duplicate_fields_1): Typo. ++ ++2001-12-18 Jason Merrill ++ ++ C++ ABI change: destroy value arguments in caller. ++ * semantics.c (genrtl_start_function, genrtl_finish_function): Don't ++ create an extra binding level for the parameters. ++ * decl.c (store_parm_decls): Don't do parameter cleanups. ++ ++2001-12-18 Nathan Sidwell ++ ++ * call.c (build_new_method_call): Use '%#V'. ++ * error.c (cv_to_string): Use V parameter to determine padding. ++ ++2001-12-18 Joseph S. Myers ++ ++ * call.c, decl2.c, init.c: Use "built-in" and "bit-field" ++ spellings in messages. ++ ++2001-12-17 Zack Weinberg ++ ++ * cp-tree.h: Delete #defines for cp_error, cp_warning, ++ cp_pedwarn, and cp_compiler_error. ++ * call.c, class.c, cp-tree.h, cvt.c, decl.c, decl2.c, error.c, ++ except.c, friend.c, init.c, lex.c, method.c, parse.y, pt.c, ++ rtti.c, search.c, semantics.c, spew.c, tree.c, typeck.c, ++ typeck2.c: Change calls to the above macros to use their ++ language-independent equivalents: error, warning, pedwarn, and ++ internal_error respectively. ++ ++2001-12-16 Neil Booth ++ ++ * decl2.c (finish_file): Remove back_end_hook. ++ ++2001-12-16 Joseph S. Myers ++ ++ * ChangeLog.1, ChangeLog.2, ChangeLog, NEWS, call.c, class.c, ++ cp-tree.h, decl.c, decl2.c, except.c, operators.def, optimize.c, ++ pt.c, rtti.c, semantics.c, typeck.c: Fix spelling errors. ++ ++2001-12-15 Joseph S. Myers ++ ++ * lang-options.h: Use American spelling in messages. ++ ++2001-12-13 Jason Merrill ++ ++ * Make-lang.in (parse.h): Separate rule, just depend on parse.c. ++ ++ Use cleanups to run base and member destructors. ++ * init.c (push_base_cleanups): New function, split out from... ++ (build_delete): ...here. Lose !TYPE_HAS_DESTRUCTOR code. ++ * decl.c (finish_destructor_body): Move vbase destruction code to ++ push_base_cleanups. ++ (begin_function_body, finish_function_body): New fns. ++ (finish_function): Move [cd]tor handling and call_poplevel to ++ finish_function_body. ++ (pushdecl): Skip the new level. ++ * semantics.c (genrtl_try_block): Don't call end_protect_partials. ++ (setup_vtbl_ptr): Call push_base_cleanups. ++ * method.c (synthesize_method): Call {begin,end}_function_body. ++ * pt.c (tsubst_expr): Handle COMPOUND_STMT_BODY_BLOCK. ++ * cp-tree.h: Declare new fns. ++ * parse.y (function_body, .begin_function_body): New nonterminals. ++ (fndef, pending_inline, function_try_block): Use function_body. ++ (ctor_initializer_opt, function_try_block): No longer has a value. ++ (base_init): Remove .set_base_init token. ++ (.set_base_init, compstmt_or_error): Remove. ++ * Make-lang.in (parse.c): Expect two fewer s/r conflicts. ++ ++ * optimize.c (maybe_clone_body): Fix parameter updating. ++ ++2001-12-12 Jason Merrill ++ ++ * decl.c (store_parm_decls): Remove parms_have_cleanups cruft. ++ * semantics.c (genrtl_start_function): Don't pass ++ parms_have_cleanups or push an extra binding level. ++ (genrtl_finish_function): Lose cleanup_label cruft. ++ ++ * cp-tree.h (struct cp_language_function): Remove x_ctor_label. ++ (ctor_label): Remove. ++ * semantics.c (finish_return_stmt): Lose ctor_label support. ++ * decl.c (finish_constructor_body, mark_lang_function): Likewise. ++ * typeck.c (check_return_expr): Check DECL_DESTRUCTOR_P, not ++ dtor_label. ++ ++ * call.c (build_new_method_call): Let resolves_to_fixed_type_p ++ check for [cd]tors. ++ * class.c (fixed_type_or_null, case INDIRECT_REF): Fix. ++ ++ * decl.c (finish_function): Check VMS_TARGET, not VMS. ++ ++ * decl.c (start_cleanup_fn): Remove redundant pushlevel. ++ (end_cleanup_fn): And poplevel. ++ ++ * semantics.c (setup_vtbl_ptr): Always build a CTOR_INITIALIZER ++ if we're in a template. ++ ++2001-12-12 Jakub Jelinek ++ ++ * cp-tree.h (DESTRUCTOR_DECL_PREFIX, DESTRUCTOR_NAME_P, ++ ANON_PARMNAME_FORMAT, ANON_PARMNAME_P, DESTRUCTOR_NAME_FORMAT, ++ THIS_NAME_P): Delete. ++ * spew.c (read_process_identifier): Remove DESTRUCTOR_NAME_P, ++ THIS_NAME_P and ANON_PARMNAME_P tests from warning about clash ++ with internal naming scheme. ++ * error.c (dump_decl): Remove DESTRUCTOR_NAME_P use. ++ ++2001-12-12 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Deprecated implicit typename use. ++ ++2001-12-11 Nathan Sidwell ++ ++ PR g++/51 ++ * parse.y (frob_specs): Indicate it is a language linkage which ++ contained the extern. ++ * decl.c (grokdeclarator): Allow extern language linkage with ++ other specifiers. ++ ++2001-12-10 Nathan Sidwell ++ ++ PR g++/72 ++ * decl.c (add_binding): Don't reject duplicate typedefs involving ++ template parameters. ++ ++2001-12-10 Neil Booth ++ ++ * parse.y, semantics.c: Similarly. ++ ++2001-12-09 Nathan Sidwell ++ ++ PR g++/87 ++ * cp-tree.h (DECL_COPY_CONSTRUCTOR_P): Use copy_fn_p. ++ (copy_args_p): Rename to ... ++ (copy_fn_p): ... here. ++ (grok_special_member_properties): New function. ++ (grok_op_properties): Lose VIRTUALP parameter. ++ (copy_assignment_arg_p): Remove. ++ * call.c (build_over_call): Use copy_fn_p. ++ * decl.c (grokfndecl): Reformat. Adjust call to ++ grok_op_properties. ++ (copy_args_p): Rename to ... ++ (copy_fn_p): ... here. Reject template functions. Check for pass ++ by value. ++ (grok_special_member_properties): Remember special functions. ++ (grok_ctor_properties): Don't remember them here, just check. ++ (grok_op_properties): Likewise. ++ (start_method): Call grok_special_member_properties. ++ * decl2.c (grokfield): Likewise. ++ (copy_assignment_arg_p): Remove. ++ (grok_function_init): Don't remember abstract assignment here. ++ * pt.c (instantiate_class_template): Call ++ grok_special_member_properties. ++ (tsubst_decl): Adjust grok_op_properties call. ++ ++2001-12-08 Aldy Hernandez ++ ++ * lex.c (rid_to_yy): Add RID_CHOOSE_EXPR and ++ RID_TYPES_COMPATIBLE_P. ++ ++2001-12-08 John David Anglin ++ ++ * semantics.c (simplify_aggr_init_exprs_r): Add DIRECT_BIND flag in ++ call to build_aggr_init. ++ * cp-tree.h (DIRECT_BIND): Document new use of DIRECT_BIND. ++ ++2001-12-08 Neil Booth ++ ++ * parse.y: Replace uses of the string non-terminal with STRING. ++ Don't perform string concatentaion here. ++ (string): Remove non-terminal. ++ * semantics.c (finish_asm_stmt): Don't concatenate strings here. ++ ++2001-12-05 Jason Merrill ++ ++ * cp-lang.c (LANG_HOOKS_TREE_INLINING_START_INLINING): Define. ++ (LANG_HOOKS_TREE_INLINING_END_INLINING): Define. ++ * tree.c (cp_start_inlining, cp_end_inlining): New fns. ++ * pt.c (push_tinst_level): No longer static. ++ * cp-tree.h: Declare them. ++ ++ * init.c (resolve_offset_ref): Don't check access for the base ++ conversion to access a FIELD_DECL. ++ ++ * cp-tree.h (TYPE_REFFN_P): New macro. ++ * decl.c (bad_specifiers): Check it, too. ++ ++ * rtti.c (create_pseudo_type_info): Set CLASSTYPE_INTERFACE_ONLY ++ on the __*_type_info type if we haven't seen a definition. ++ ++2001-12-05 Neil Booth ++ ++ * decl.c: Include c-common.h. ++ (shadow_warning): Move to c-common.c. ++ ++2001-12-05 Richard Kenner ++ ++ * decl.c (duplicate_decls): Don't copy DECL_NO_CHECK_MEMORY_USAGE. ++ ++2001-12-04 Nathan Sidwell ++ ++ * pt.c (end_template_parm_list): Clear TREE_CHAIN of each parm. ++ ++2001-12-04 Nathan Sidwell ++ ++ PR g++/164 ++ * init.c (sort_base_init): Allow binfos to be directly specified. ++ * method.c (do_build_copy_constructor): Explicitly convert to the ++ base instance. ++ (do_build_assign_ref): Likewise. ++ ++2001-12-03 Hans-Peter Nilsson ++ ++ * decl.c (xref_basetypes): Don't use C99 construct in tag_code ++ declaration and initialization. ++ ++2001-12-03 Neil Booth ++ ++ * typeck2.c: Remove leading capital from diagnostic messages, as ++ per GNU coding standards. ++ ++2001-12-03 Mumit Khan ++ ++ PR c++/3394 ++ * decl.c (xref_basetypes): Handle attributes between ++ 'class' and name. ++ ++2001-12-03 Nathan Sidwell ++ ++ PR g++/3381 ++ * parse.y (named_complex_class_head_sans_basetype): Add new ++ reduction. ++ * Make-lang.in (parse.c): Adjust expected conflict count. ++ ++2001-12-03 Jason Merrill ++ ++ * class.c (finish_vtbls): Fill in BINFO_VPTR_FIELD in the ++ immediate binfos for our virtual bases. ++ ++2001-12-02 Neil Booth ++ ++ * call.c (build_java_interface_fn_ref): Similarly. ++ * except.c (is_admissible_throw_operand): Similarly. ++ * init.c (build_java_class_ref): Similarly. ++ * xref.c (open_xref_file): Similarly. ++ ++2001-12-01 Neil Booth ++ ++ * class.c (finish_struct): Remove trailing periods from messages. ++ * decl.c (check_tag_decl): Similarly. ++ * lex.c (cxx_set_yydebug): Similarly. ++ * typeck2.c (friendly_abort): Similarly. ++ ++2001-11-29 Mark Mitchell ++ ++ PR c++/3048 ++ * cp-tree.h (ovl_member): Remove. ++ * decl2.c (merge_functions): Handle extern "C" functions ++ specially. ++ * tree.c (ovl_member): Remove. ++ ++2001-11-29 Mark Mitchell ++ ++ PR c++/4842 ++ * class.c (get_basefndecls): Take an IDENTIFIER_NODE, not a ++ FUNCTION_DECL, as input. ++ (mark_overriders): Remove. ++ (warn_hidden): Rework for the new ABI. ++ ++2001-11-29 Mark Mitchell ++ ++ PR c++/3471 ++ * call.c (convert_like_real): Do not build additional temporaries ++ for rvalues of class type. ++ ++2001-11-28 Nathan Sidwell ++ ++ * cp-tree.h (UNIQUELY_DERIVED_FROM_P): Use lookup base. ++ (ACCESSIBLY_UNIQUELY_DERIVED_FROM_P): Likewise. ++ (PUBLICLY_UNIQUELY_DERIVED_FROM_P: Likewise. ++ (DERIVED_FROM_P): Likewise. ++ (enum base_access): Renumber, add ba_quiet bit mask. ++ (get_binfo): Remove. ++ (get_base_distance): Remove. ++ (binfo_value): Remove. ++ (ACCESSIBLY_DERIVED_FROM_P): Remove. ++ * call.c (standard_conversion): Use lookup_base. ++ * class.c (strictly_overrides): Likewise. ++ (layout_virtual_bases): Likewise. ++ (warn_about_ambiguous_direct_bases): Likewise. ++ (is_base_of_enclosing_class): Likewise. ++ (add_vcall_offset_vtbl_entries_1): Likewise. ++ * cvt.c (build_up_reference): Adjust comment. ++ * init.c (build_member_call): Reformat. ++ * search.c (get_binfo): Remove. ++ (get_base_distance_recursive): Remove. ++ (get_base_distance): Remove. ++ (lookup_base_r): Tweak. ++ (lookup_base): Add ba_quiet control. Complete the types here. ++ (covariant_return_p): Use lookup_base. ++ * tree.c (binfo_value): Remove. ++ (maybe_dummy_object): Use lookup_base. ++ * typeck.c (build_static_cast): Use lookup_base. ++ (get_delta_difference): Likewise. ++ * typeck2.c (binfo_or_else): Use lookup_base. ++ (build_scoped_ref): Add back error_mark_check. ++ (build_m_component_ref): Use lookup_base. ++ ++2001-11-29 Joseph S. Myers ++ ++ * Make-lang.in (c++.generated-manpages): New dummy target. ++ ++2001-11-27 Richard Kenner ++ ++ * Make-lang.in (cp-lang.o): Depends on c-common.h. ++ * cp-lang.c (c-common.h): Include. ++ (LANG_HOOKS_EXPAND_CONSTANT, LANG_HOOKS_SAFE_FROM_P): New hooks. ++ * decl.c (cxx_init_decl_processing): Don't set lang_safe_from_p. ++ * expr.c (init_cplus_expand): Don't set lang_expand_constant. ++ ++2001-11-26 Neil Booth ++ ++ * decl2.c (c_language): Move to c-common.c. ++ * lex.c (cxx_post_options, cxx_init_options): Use c-common.c ++ functions. ++ (cxx_init): Update. ++ ++2001-11-26 Jason Merrill ++ ++ * call.c (joust): Remove COND_EXPR hack. ++ ++2001-11-25 Aldy Hernandez ++ ++ * search.c (lookup_base_r): Declare bk in variable declaration ++ space. ++ ++2001-11-25 Nathan Sidwell ++ ++ PR g++/3145 ++ * class.c (build_vbase_pointer): Remove. ++ (build_vbase_path): Remove. ++ (build_base_path): New function. ++ * cp-tree.h (base_access, base_kind): New enumerations. ++ (build_base_path): Declare. ++ (convert_pointer_to_real): Remove. ++ (convert_pointer_to): Remove. ++ (lookup_base): Declare. ++ (convert_pointer_to_vbase): Remove. ++ * call.c (build_scoped_method_call): Use lookup_base & ++ build_base_path instead of convert_pointer_to_real, ++ get_base_distance & get_binfo. ++ (build_over_call): Likewise. ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ (convert_to_pointer_force): Likewise. ++ (build_up_reference): Likewise. ++ (convert_pointer_to_real): Remove. ++ (convert_pointer_to): Remove. ++ * init.c (dfs_initialize_vtbl_ptrs): Use build_base_path ++ instead of convert_pointer_to_vbase & build_vbase_path. ++ (emit_base_init): Use build_base_path instead of ++ convert_pointer_to_real. ++ (expand_virtual_init): Lose unrequired conversions. ++ (resolve_offset_ref): Use lookup_base and build_base_path ++ instead of convert_pointer_to. ++ * rtti.c (build_dynamic_cast_1): Use lookup_base & ++ build_base_path instead of get_base_distance & build_vbase_path. ++ * search.c (get_vbase_1): Remove. ++ (get_vbase): Remove. ++ (convert_pointer_to_vbase): Remove. ++ (lookup_base_r): New function. ++ (lookup_base): New function. ++ * typeck.c (require_complete_type): Use lookup_base & ++ build_base_path instead of convert_pointer_to. ++ (build_component_ref): Likewise. ++ (build_x_function_call): Likewise. ++ (get_member_function_from_ptrfunc): Likewise. ++ (build_component_addr): Likewise. ++ * typeck2.c (build_scoped_ref): Likewise. ++ ++2001-11-22 Bryce McKinlay ++ ++ * cp-tree.h (CP_TYPE_QUALS): Removed. ++ * decl.c (cxx_init_decl_processing): Don't set lang_dump_tree. ++ * cp-lang.c: Set LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN and ++ LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN. ++ * dump.c (cp_dump_tree): Use void* dump_info argument to match ++ lang-hooks prototype. ++ * call.c, cp-tree.h, cvt.c, decl.c, init.c, mangle.c, method.c, pt.c, ++ rtti.c, semantics.c, tree.c, typeck.c, typeck2.c: All references to ++ CP_TYPE_QUALS changed to cp_type_quals. ++ * Make-lang.in: References to c-dump.h changed to tree-dump.h. ++ (CXX_C_OBJS): Remove c-dump.o. ++ ++2001-11-21 Mark Mitchell ++ ++ PR c++/3637 ++ * pt.c (lookup_template_class): Ensure that all specializations ++ are registered on the list corresponding to the most general ++ template. ++ ++2001-11-20 Mark Mitchell ++ ++ * call.c (non_reference): Add documentation. ++ (convert_class_to_reference): Do not strip reference types ++ from conversion operators. ++ (maybe_handle_ref_bind): Simplify. ++ (compare_ics): Correct handling of references. ++ ++2001-11-19 John Wilkinson ++ ++ * dump.c (dump_op): New function. ++ (cp_dump_tree): Dump CLASSTYPE_TEMPLATE_SPECIALIZATION. Use ++ dump_op. Dump DECL_MUTABLE, access and staticness for VAR_DECLs. ++ DECL_PURE_VIRTUAL_P, DECL_VIRTUAL_P, ++ ++2001-11-19 Mark Mitchell ++ ++ PR4629 ++ * semantics.c (finish_sizeof): Make sure that expression created ++ while processing a template do not have a type. ++ (finish_alignof): Likewise. ++ * typeck.c (c_sizeof): Likewise. ++ (expr_sizeof): Likewise. ++ ++2001-11-18 Neil Booth ++ ++ * lex.c (cxx_finish): Call c_common_finish. ++ (finish_parse): Remove. ++ ++2001-11-17 Kriang Lerdsuwanakij ++ ++ * decl.c (create_array_type_for_decl): Check if NAME is NULL_TREE ++ when displaying error message about missing array bounds. ++ ++2001-11-17 Kriang Lerdsuwanakij ++ ++ * mangle.c (write_expression): Handle CAST_EXPR, STATIC_CAST_EXPR, ++ CONST_CAST_EXPR. ++ * operators.def: Add CAST_EXPR, STATIC_CAST_EXPR, CONST_CAST_EXPR. ++ ++2001-11-16 Neil Booth ++ ++ * cp-tree.h (print_class_statistics): Restore. ++ ++2001-11-15 Jason Merrill ++ ++ * method.c (use_thunk): Don't emit debugging information for thunks. ++ ++ * parse.y: Add ... IDENTIFIER SCOPE and ... PTYPENAME SCOPE expansions. ++ * decl.c (make_typename_type): Handle getting a class template. ++ * search.c (lookup_field_r): A class template is good enough for ++ want_type. ++ ++ * call.c (convert_like_real): Only use cp_convert for the bad part. ++ (standard_conversion): Also allow bad int->enum. ++ * typeck.c (ptr_reasonably_similar): Also allow functions to ++ interconvert. Pointers to same-size integers are reasonably ++ similar. ++ ++ * cvt.c (convert_to_void): If we build a new COND_EXPR, always ++ give it void type. ++ ++2001-11-15 Nathan Sidwell ++ ++ PR g++/3154 ++ * init.c (sort_base_init): Remove unreachable code. ++ (expand_member_init): Adjust comment to reflect reality. Simplify ++ and remove unreachable code. ++ ++2001-11-15 Neil Booth ++ ++ * cp-tree.h (init_reswords, cxx_init_decl_processing): New. ++ (cxx_init): Update prototype. ++ * decl.c (init_decl_processing): Rename. Move null node init ++ to its creation time. ++ * lex.c (cxx_init_options): Update. ++ (cxx_init): Combine with old init_parse; also call ++ cxx_init_decl_processing. ++ ++2001-11-14 Richard Sandiford ++ ++ * decl.c (check_initializer): Try to complete the type of an ++ array element before checking whether it's complete. Don't ++ complain about arrays with complete element types but an ++ unknown size. ++ (cp_finish_decl): Build the hierarchical constructor before ++ calling maybe_deduce_size_from_array_init. ++ ++2001-11-14 Joseph S. Myers ++ ++ * Make-lang.in: Change all uses of $(manext) to $(man1ext). ++ ++2001-11-13 Nathan Sidwell ++ ++ PR g++/4206 ++ * parse.y (already_scoped_stmt): Remove. ++ (simple_stmt, WHILE & FOR): Use implicitly_scoped_stmt. ++ ++2001-11-12 H.J. Lu ++ ++ * cvt.c (ocp_convert): Don't warn the address of a weak ++ function is always `true'. ++ ++2001-11-09 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_PRINT_DECL, LANG_HOOKS_PRINT_TYPE, ++ LANG_HOOKS_PRINT_STATISTICS, LANG_HOOKS_PRINT_XNODE, ++ LANG_HOOKS_PRINT_IDENTIFIER, LANG_HOOKS_SET_YYDEBUG): Override. ++ * cp-tree.h (print_class_statistics): Remove. ++ (cxx_print_statistics, cxx_print_xnode, cxx_print_decl, cxx_print_type, ++ cxx_print_identifier, cxx_set_yydebug): New. ++ * lex.c (set_yydebug): Rename c_set_yydebug. ++ * ptree.c (print_lang_decl, print_lang_type, print_lang_identifier, ++ lang_print_xnode): Rename. ++ * tree.c (print_lang_statistics): Rename. ++ ++2001-11-09 Kaveh R. Ghazi ++ ++ * class.c (dump_array): Fix format specifier warning. ++ ++2001-11-09 Neil Booth ++ ++ * cp-lang.c (LANG_HOOKS_NAME): Override. ++ (struct lang_hooks): Constify. ++ * lex.c (cxx_init_options): Update. ++ (lang_identify): Remove. ++ * parse.y (language_string): Remove. ++ ++2001-11-08 Andreas Franck ++ ++ * Make-lang.in (CXX_INSTALL_NAME, GXX_CROSS_NAME, ++ DEMANGLER_CROSS_NAME): Handle program_transform_name the way ++ suggested by autoconf. ++ (GXX_TARGET_INSTALL_NAME, CXX_TARGET_INSTALL_NAME): Define. ++ (c++.install-common): Use the transformed target alias names. ++ ++2001-11-06 Neil Booth ++ ++ * Make-lang.in: Update. ++ * cp-lang.c: Include langhooks-def.h. ++ ++2001-11-04 Kriang Lerdsuwanakij ++ ++ * pt.c (tsubst_copy): Call tsubst for TYPEOF_EXPR. ++ ++2001-11-03 Kaveh R. Ghazi ++ ++ * lex.c (copy_lang_type): Add static prototype. ++ ++2001-11-02 Kriang Lerdsuwanakij ++ ++ * pt.c (unify): Handle SCOPE_REF. ++ ++2001-11-01 Jakub Jelinek ++ ++ * tree.c (cp_copy_res_decl_for_inlining): Adjust ++ DECL_ABSTRACT_ORIGIN for the return variable. ++ ++2001-10-31 Zack Weinberg ++ ++ * Make-lang.in: Replace $(INTL_TARGETS) with po-generated. ++ ++2001-10-28 Joseph S. Myers ++ ++ * ChangeLog.1, ChangeLog.2, ChangeLog, class.c, decl2.c, search.c, ++ semantics.c, spew.c: Fix spelling errors. ++ ++2001-10-27 Kriang Lerdsuwanakij ++ ++ * decl2.c (validate_nonmember_using_decl): Handle NAMESPACE_DECL. ++ ++2001-10-25 Zack Weinberg ++ ++ * cp-lang.c: Redefine LANG_HOOKS_CLEAR_BINDING_STACK to ++ pop_everything. ++ ++2001-10-23 Richard Kenner ++ ++ * cp-lang.c (cxx_get_alias_set): New function. ++ Point LANG_HOOKS_GET_ALIAS_SET to it. ++ ++2001-10-23 Kriang Lerdsuwanakij ++ ++ * cp-tree.def (UNBOUND_CLASS_TEMPLATE): New tree node. ++ * cp-tree.h (make_unbound_class_template): Prototype new function. ++ * decl.c (make_unbound_class_template): New function. ++ * decl2.c (arg_assoc_template_arg): Handle UNBOUND_CLASS_TEMPLATE. ++ * error.c (dump_type): Likewise. ++ * mangle.c (write_type): Likewise. ++ * parse.y (template_parm): Likewise. ++ (template_argument): Use make_unbound_class_template. ++ * pt.c (convert_template_argument): Handle UNBOUND_CLASS_TEMPLATE. ++ (tsubst): Likewise. ++ (tsubst_copy): Likewise. ++ (unify): Likewise. ++ * tree.c (walk_tree): Likewise. ++ * typeck.c (comptypes): Likewise. ++ ++2001-10-21 Kaveh R. Ghazi ++ ++ * xref.c (GNU_xref_member): Use safe-ctype macros and/or fold ++ extra calls into fewer ones. ++ ++2001-10-18 Alexandre Oliva ++ ++ * decl.c (duplicate_decls): Propagate DECL_UNINLINABLE. ++ Warn when merging inline with attribute noinline. ++ (start_decl, start_function): Warn if inline and attribute ++ noinline appear in the same declaration. ++ ++2001-10-16 H.J. Lu ++ ++ * cp-tree.h (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK): Defined ++ for tree checking disabled. ++ ++2001-10-16 Hans-Peter Nilsson ++ ++ * cp-tree.h (VFIELD_NAME_FORMAT) [NO_DOLLAR_IN_LABEL && ++ NO_DOT_IN_LABEL]: Adjust to match VFIELD_NAME. ++ ++2001-10-15 Richard Sandiford ++ ++ * pt.c (UNIFY_ALLOW_MAX_CORRECTION): Define. ++ (unify): Only handle MINUS_EXPR specially if the above flag is set ++ and the subtracted constant is 1. Clear the flag on recursive calls. ++ Set it when unifying the maximum value in an INTEGER_TYPE's range. ++ ++2001-10-15 Richard Sandiford ++ ++ * decl.c (bad_specifiers): Don't allow exception specifications ++ on any typedefs. ++ ++2001-10-14 Neil Booth ++ ++ * cp/lex.c (init_cp_pragma): Similarly. ++ ++2001-10-13 Kriang Lerdsuwanakij ++ ++ * pt.c (lookup_template_class): Build complete template arguments ++ for BOUND_TEMPLATE_TEMPLATE_PARM. ++ ++2001-10-12 Kriang Lerdsuwanakij ++ ++ * cp-tree.h (TYPE_BINFO): Update comment. ++ (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK): New macro. ++ (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO): Use template_info. ++ (TYPENAME_TYPE_FULLNAME): Use TYPE_FIELDS. ++ (copy_type): Prototype new function. ++ * lex.c (copy_lang_decl): Gather tree node statistics. ++ (copy_lang_type): New function. ++ (copy_type): Likewise. ++ (cp_make_lang_type): Create lang_type for ++ BOUND_TEMPLATE_TEMPLATE_PARM. Set TYPE_BINFO for TYPENAME_TYPE ++ and BOUND_TEMPLATE_TEMPLATE_PARM. ++ * pt.c (tsubst): Use copy_type instead of copy_node. ++ * search.c (lookup_field_1): Ignore TYPENAME_TYPE. ++ ++2001-10-12 Kriang Lerdsuwanakij ++ ++ * pt.c (determine_specialization): Ignore functions without ++ DECL_TEMPLATE_INFO. ++ ++2001-10-12 Nathan Sidwell ++ ++ PR g++/4476 ++ * typeck2.c (abstract_virtuals_error): Ignore incomplete classes. ++ ++2001-10-11 Jason Merrill ++ ++ * typeck2.c (store_init_value): Don't re-digest a bracketed ++ initializer. ++ ++ * class.c (finish_struct_anon): Use TYPE_ANONYMOUS_P instead of ++ ANON_AGGR_TYPE_P. ++ ++2001-10-11 Richard Henderson ++ ++ * class.c (build_vtable_entry_ref): Create a VTABLE_REF instead ++ of an asm statement. ++ (build_vtbl_ref_1): Split out from build_vtbl_ref. ++ (build_vfn_ref): Use it to handle vtable descriptors before ++ calling build_vtable_entry_ref. ++ * decl2.c (output_vtable_inherit): Use assemble_vtable_inherit. ++ ++2001-10-10 Richard Henderson ++ ++ * parse.y (asm_operand): Allow named operands. ++ * semantics.c (finish_asm_stmt): Tweek for changed location ++ of the operand constraint. ++ ++2001-10-09 Jason Merrill ++ ++ * call.c (standard_conversion): Add bad conversion between ++ integers and pointers. ++ (convert_like_real): Don't use convert_for_initialization for bad ++ conversions; complain here and use cp_convert. ++ (build_over_call): Don't handle bad conversions specially. ++ (perform_implicit_conversion): Allow bad conversions. ++ (can_convert_arg_bad): New fn. ++ * cp-tree.h: Declare it. ++ * typeck.c (convert_for_assignment): Use it. ++ (ptr_reasonably_similar): Any target type is similar to void. ++ ++2001-10-08 Alexandre Oliva ++ ++ * Make-lang.in (CXX_OBJS): Added cp-lang.o. ++ (cp/cp-lang.o): New rule. ++ * cp-tree.h: Declare hooks. ++ * tree.c: Make hooks non-static. ++ (init_tree): Don't initialize hooks here. ++ * lex.c: Likewise. Move definition of lang_hooks to... ++ * cp-lang.c: ... new file. ++ ++2001-10-08 Richard Henderson ++ ++ * cp-tree.h (struct lang_decl_flags): Remove declared_inline. ++ (DECL_DECLARED_INLINE_P): Use the bit in struct c_lang_decl. ++ ++2001-10-07 Kaveh R. Ghazi ++ ++ * class.c (build_vtable_entry_ref): Const-ify. ++ * decl.c (predefined_identifier, ++ initialize_predefined_identifiers): Likewise. ++ * init.c (build_new_1): Likewise. ++ * lex.c (cplus_tree_code_type, cplus_tree_code_length, resword): ++ Likewise. ++ ++2001-10-05 Alexandre Oliva ++ ++ * optimize.c (struct inline_data): Moved to ../tree-inline.c. ++ (INSNS_PER_STMT): Likewise. ++ (remap_decl, remap_block, copy_scopy_stmt, copy_body_r): Likewise. ++ (copy_body, initialize_inlined_parameters): Likewise. ++ (declare_return_variable, inlinable_function_p): Likewise. ++ (expand_call_inline, expand_calls_inline): Likewise. ++ (optimize_inline_calls, clone_body): Likewise. ++ * tree.c (walk_tree): Moved to ../tree-inline.c. ++ (walk_tree_without_duplicates): Likewise. ++ (copy_tree_r, remap_save_expr): Likewise. ++ ++2001-10-04 Alexandre Oliva ++ ++ * Make-lang.in (cp/decl.o, cp/tree.o): Depend on tree-inline.h. ++ (cp/pt.o, cp/semantics.o, cp/optimize.o): Likewise. ++ * cp-tree.h (lang_decl): Moved inlined_fns to tree_decl. ++ (TREE_READONLY_DECL_P, DECL_INLINED_FNS): Moved to ../tree.h. ++ (flag_inline_trees): Moved declaration to ../tree-inline.h. ++ (walk_tree): Moved declaration to ../tree-inline.h. ++ (walk_tree_without_duplicates, copy_tree_r): Likewise. ++ (remap_save_expr): Likewise. ++ * decl.c: Include tree-inline.h. ++ (lang_mark_tree): Don't mark inlined_fns. ++ * decl2.c (flag_inline_trees): Moved defn to ../tree-inline.c. ++ * optimize.c: Include tree-inline.h. ++ (optimize_inline_calls): Move declaration to ../tree.h, as ++ non-static. ++ (remap_decl): Use language-independent constructs and hooks. ++ (remap_block, copy_body_r, declare_return_variable): Likewise. ++ (inlinable_function_p): Likewise. Don't test for ++ DECL_LANG_SPECIFIC before DECL_INLINED_FNS as inlined_fns is ++ no longer language-specific. ++ (optimize_inline_calls): Likewise. Make it non-static. Moved ++ call of dump_function to... ++ (optimize_function): Here... ++ (clone_body): New function, extracted from... ++ (maybe_clone_body): ... here. Build decl_map locally and pass ++ it on to clone_body. ++ * pt.c, semantics.c: Include tree-inline.h. ++ * tree.c: Likewise. ++ (cp_walk_subtrees): New language-specific hook for tree inlining. ++ (cp_cannot_inline_tree_fn, cp_add_pending_fn_decls, ++ cp_is_overload_p, cp_auto_var_in_fn_p, ++ cp_copy_res_decl_for_inlining): Likewise. ++ (walk_tree): Move language-specific constructs into... ++ (cp_walk_subtrees): this new function. ++ (copy_tree_r): Use language-independent constructs and hooks. ++ (init_tree): Initialize tree inlining hooks. ++ (remap_save_expr): Adjust prototype so that the declaration ++ does not require the definition of splay_tree. ++ ++2001-10-03 John David Anglin ++ ++ * rtti.c (get_tinfo_decl): Call typeinfo_in_lib_p with the type used ++ to build the declaration instead of the declaration itself. ++ ++2001-10-02 Jason Merrill ++ ++ * decl2.c (cxx_decode_option): Add 'else'. ++ ++ * spew.c (end_input): No longer static. ++ * cp-tree.h: Declare it. ++ * parse.y (datadef): Add "error END_OF_SAVED_INPUT" expansion. ++ ++2001-10-02 Joseph S. Myers ++ ++ * call.c (build_over_call), typeck.c (build_function_call_real): ++ Pass type attributes to check_function_format rather than name or ++ assembler name. Don't require there to be a name or assembler ++ name to check formats. ++ ++2001-10-02 Joseph S. Myers ++ ++ * decl.c (init_decl_processing): Don't call ++ init_function_format_info. Initialize lang_attribute_table ++ earlier. ++ (builtin_function): Call decl_attributes. ++ (insert_default_attributes): New. ++ ++2001-10-01 Jason Merrill ++ ++ * decl.c (grokdeclarator): Copy array typedef handling from C ++ frontend. ++ ++ * decl.c (grokdeclarator): Copy too-large array handling from C ++ frontend. ++ ++2001-09-29 Alexandre Oliva ++ ++ * config-lang.in (target_libs): Added target-gperf, so that we ++ don't try to build it if C++ is disabled. ++ ++2001-09-23 Zack Weinberg ++ ++ * Make-lang.in (CXX_OBJS): Take out cp/errfn.o. ++ (cp/errfn.o): Delete rule. ++ (cp/error.o): Depend on flags.h. ++ * errfn.c: Delete file. ++ * cp-tree.h: Declare warn_deprecated. Remove definitions of ++ TFF_NAMESPACE_SCOPE, TFF_CLASS_SCOPE, TFF_CHASE_NAMESPACE_ALIAS, ++ and TFF_TEMPLATE_DEFAULT_ARGUMENTS. #define cp_error, cp_warning, ++ cp_pedwarn, and cp_compiler_error to error, warning, pedwarn, and ++ internal_error respectively. Make cp_deprecated into a macro. ++ Don't define cp_printer typedef or declare cp_printers. ++ * error.c: Include flags.h. ++ Delete: struct tree_formatting_info, print_function_argument_list, ++ print_declaration, print_expression, print_function_declaration, ++ print_function_parameter, print_type_id, print_cv_qualifier_seq, ++ print_type_specifier_seq, print_simple_type_specifier, ++ print_elaborated_type_specifier, print_rest_of_abstract_declarator, ++ print_parameter_declaration_clause, print_exception_specification, ++ print_nested_name_specifier, and definition of cp_printers. ++ (locate_error): New function. ++ (cp_error_at, cp_warning_at, cp_pedwarn_at): Moved here and ++ rewritten in terms of locate_error and diagnostic.c. ++ (cp_tree_printer): Rename cp_printer; wire up to *_to_string ++ instead of deleted print_* routines. Handle %C, %L, %O, %Q also. ++ (init_error): Adjust to match. ++ ++2001-09-22 Richard Kenner ++ ++ * Make-lang.in (CXX_C_OBJS): Add attribs.o. ++ ++2001-09-21 Richard Henderson ++ ++ * class.c (set_vindex): Mind TARGET_VTABLE_USES_DESCRIPTORS. ++ (build_vtbl_initializer): Likewise. ++ (build_vfn_ref): New. ++ * cp-tree.h: Declare it. ++ * call.c (build_over_call): Use it. ++ * decl2.c (mark_vtable_entries): Mark FDESC_EXPR. ++ * typeck.c (get_member_function_from_ptrfunc): Mind descriptors. ++ ++2001-09-21 J"orn Rennecke ++ ++ * decl.c (grokdeclarator): Use C syntax for attr_flags declaration. ++ ++2001-09-21 Joseph S. Myers ++ ++ Table-driven attributes. ++ * decl.c: Rename DECL_MACHINE_ATTRIBUTES to DECL_ATTRIBUTES. ++ * decl2.c (cplus_decl_attributes): Only take one attributes ++ parameter. ++ * cp-tree.c (cplus_decl_attributes): Update prototype. ++ * class.c (finish_struct), decl.c (start_decl, start_function), ++ decl2.c (grokfield), friend.c (do_friend), parse.y ++ (parse_bitfield): Update calls to cplus_decl_attributes. ++ * decl.c (grokdeclarator): Take a pointer to a single ordinary ++ attribute list. ++ * decl.h (grokdeclarator): Update prototype. ++ * decl2.c (grokfield): Take a single ordinary attribute list. ++ * friend.c (do_friend): Likewise. ++ * decl.c (shadow_tag, groktypename, start_decl, ++ start_handler_parms, grokdeclarator, grokparms, start_function, ++ start_method), decl2.c (grokfield, grokbitfield, grokoptypename), ++ parse.y (parse_field, parse_bitfield, component_decl_1), pt.c ++ (process_template_parm, do_decl_instantiation): Pass single ++ ordinary attribute lists around. ++ * decl.c (grokdeclarator): Correct handling of nested attributes. ++ Revert the patch ++ 1998-10-18 Jason Merrill ++ * decl.c (grokdeclarator): Embedded attrs bind to the right, ++ not the left. ++ . ++ * cp-tree.h (cp_valid_lang_attribute): Remove declaration ++ (cp_attribute_table): Declare. ++ * decl.c (valid_lang_attribute): Don't define. ++ (lang_attribute_table): Define. ++ (init_decl_processing): Initialize lang_attribute_table instead of ++ valid_lang_attribute. ++ * tree.c (cp_valid_lang_attribute): Remove. ++ (handle_java_interface_attribute, handle_com_interface_attribute, ++ handle_init_priority_attribute): New functions. ++ (cp_attribute_table): New array. ++ * decl2.c (import_export_class): Don't use ++ targetm.valid_type_attribute. ++ ++2001-09-15 Gabriel Dos Reis ++ ++ * Make-lang.in (cp/error.o): Depend on real.h ++ * error.c: #include "real.h" ++ ++2001-09-15 Kaveh R. Ghazi ++ ++ * mangle.c (mangle_conv_op_name_for_type): Use concat in lieu of ++ xmalloc/strcpy/strcat. ++ ++2001-09-13 Kaveh R. Ghazi ++ ++ * decl.c (warn_extern_redeclared_static, cp_make_fname_decl): ++ Const-ification. ++ * pt.c (tsubst_decl): Likewise. ++ ++2001-09-12 Kaveh R. Ghazi ++ ++ * decl2.c (lang_f_options): Const-ification. ++ * lex.c (cplus_tree_code_name): Likewise. ++ * spew.c (yyerror): Likewise. ++ ++2001-09-06 Nathan Sidwell ++ ++ PR c++/3986 ++ * class.c (force_canonical_binfo_r): Check & move an indirect ++ primary base first. ++ (force_canonical_binfo): Check that it's not already ++ canonical. ++ (mark_primary_virtual_base): Remove BINFO parameter. ++ (mark_primary_bases): Adjust, set BINFO_LOST_PRIMARY_P here. ++ ++2001-09-06 Nathan Sidwell ++ ++ Remove TYPE_NONCOPIED_PARTS. ++ * cp-tree.h (CLASSTYPE_INLINE_FRIENDS): Map onto ++ CLASSTYPE_PURE_VIRTUALS. ++ (TYPE_RAISES_EXCEPTIONS): Map onto TYPE_BINFO. ++ * class.c (duplicate_tag_error): Remove TYPE_NONCOPIED_PARTS. ++ (layout_class_type): Don't call fixup_inline_methods here ... ++ (finish_struct_1): ... call it here. ++ ++2001-09-04 Mark Mitchell ++ ++ * decl.c (duplicate_decls): Remove code deadling with ++ DECL_SAVED_INSNS. ++ * decl2.c (finish_file): Likewise. ++ * pt.c (instantiate_decl): Likewise. ++ * semantics.c (expand_body): Don't defer local functions if ++ they wouldn't be deferred for some other reason. Don't ++ generate RTL for functions that will not be emitted. ++ (genrtl_start_function): Remove code deadling with ++ DECL_SAVED_INSNS. ++ (genrtl_finish_function): Likewise. ++ ++2001-09-04 Nathan Sidwell ++ ++ PR c++/4203 ++ * call.c (build_over_call): Do not optimize any empty base ++ construction. ++ ++2001-08-31 Kriang Lerdsuwanakij ++ ++ * error.c (dump_template_decl): Output template parameters ++ together with their specifiers. ++ Output `class' prefix for template template parameter. ++ (dump_decl): Fix formatting. ++ ++2001-08-30 Kurt Garloff ++ ++ * optimize.c (inlinable_function_p): Allow only smaller single ++ functions. Halve inline limit after reaching recursive limit. ++ ++2001-08-30 Joern Rennecke ++ Jason Merrill ++ ++ * class.c (build_vtable_entry_ref): Subtract in char*, not ++ ptrdiff_t. ++ ++2001-08-23 Jason Merrill ++ ++ * tree.c (cp_build_qualified_type_real): Use get_qualified_type. ++ (build_cplus_array_type): Use cp_build_qualified_type, not ++ TYPE_MAIN_VARIANT, to get an unqualified version. ++ ++ * decl2.c (grok_alignof): Lose. ++ (build_expr_from_tree): Use expr_sizeof and c_alignof_expr. ++ * typeck.c (c_alignof): Lose. ++ * semantics.c (finish_sizeof, finish_alignof): New. ++ * parse.y: Use them. ++ * cp-tree.h: Declare them. ++ ++2001-08-22 Jason Merrill ++ ++ * pt.c (tsubst_expr): Hand off to the TREE_CHAIN of a statement. ++ Don't loop in COMPOUND_STMT, FOR_STMT or TRY_BLOCK. ++ * tree.c (cp_statement_code_p): A TAG_DEFN is a statement. ++ ++2001-08-19 Jakub Jelinek ++ ++ * typeck2.c (add_exception_specifier): Only require complete type if ++ not in processing template declaration. ++ ++2001-08-18 Kaveh R. Ghazi ++ ++ * decl.c: Cast argument to size_t, not HOST_WIDE_INT, in calls to ++ GNU_xref_start_scope and GNU_xref_end_scope. ++ ++ * tree.c (TYPE_HASH): Moved to ../tree.h. ++ ++2001-08-16 Mark Mitchell ++ ++ * cvt.c (convert_to_void): Preserve TREE_SIDE_EFFECTS ++ on COMPOUND_EXPRs. ++ ++2001-08-14 Richard Henderson ++ ++ * class.c, cp-tree.h (build_vfn_ref): Remove. ++ * call.c, rtti.c: Replace all refernces with build_vtbl_ref. ++ ++2001-08-13 Mark Mitchell ++ ++ * call.c (build_over_call): Mark COMPOUND_EXPRs generated for ++ empty class assignment as having side-effects to avoid ++ spurious warnings. ++ ++2001-08-13 Zack Weinberg ++ ++ * Make-lang.in (cp/except.o): Add libfuncs.h to dependencies. ++ * except.c: Include libfuncs.h. ++ ++2001-08-11 Gabriel Dos Reis ++ ++ * decl.c (grokdeclarator): Clarify diagnostic message. ++ ++2001-08-13 Kriang Lerdsuwanakij ++ ++ * decl2.c (do_nonmember_using_decl): Replace using directive ++ with using declaration in the error message. ++ ++2001-08-11 Kriang Lerdsuwanakij ++ ++ * pt.c (maybe_fold_nontype_arg): Use TREE_TYPE of ARG as the ++ criterion to avoid rebuilding expression tree instead of ++ processing_template_decl. ++ ++2001-08-07 Jason Merrill ++ ++ Support named return value optimization for inlines, too. ++ * decl.c (finish_function): Nullify returns here. ++ * semantics.c (genrtl_start_function): Not here. ++ (cp_expand_stmt): Don't mess with CLEANUP_STMTs. ++ (nullify_returns_r): No longer static. Just clear RETURN_EXPR. ++ Also nullify the CLEANUP_STMT for the nrv. ++ * cp-tree.h: Declare it. ++ * optimize.c (declare_return_variable): Replace the nrv with the ++ return variable. ++ * typeck.c (check_return_expr): Be more flexible on alignment check. ++ Ignore cv-quals when checking for a matching type. ++ ++2001-08-09 Richard Henderson ++ ++ * decl2.c (finish_objects): Use target hooks instead of ++ assemble_constructor and assemble_destructor. ++ ++2001-08-08 John David Anglin ++ ++ * g++spec.c (lang_specific_driver): Quote argument after `-Xlinker'. ++ ++2001-08-07 Nathan Sidwell ++ ++ PR c++/3820 ++ Stop using TYPE_NONCOPIED_PARTS. ++ * call.c (build_over_call): Be careful when copy constructing ++ or assigning to an empty class. ++ * class.c (check_bases_and_members): It has a ++ COMPLEX_ASSIGN_REF if it has a vptr. ++ (layout_class_type): Don't add empty class padding to ++ TYPE_NONCOPIED_PARTS. ++ (finish_struct_1): Don't add the VFIELD either. ++ * cp-tree.h (TYPE_HAS_TRIVIAL_INIT_REF): Mention _copy_ ++ initialization. ++ ++2001-08-07 Jason Merrill ++ ++ * tree.c (walk_tree): Walk siblings even if !walk_subtrees. ++ ++2001-08-06 Richard Henderson ++ ++ * decl2.c (finish_objects): Pass a symbol_ref and priority to ++ assemble_{constructor,destructor}. Remove priority handling. ++ ++2001-08-05 Gabriel Dos Reis ++ ++ Don't allow template-id in using-declaration. ++ * decl2.c (validate_nonmember_using_decl): Handle template-ids. ++ (do_class_using_decl): Likewise. ++ ++2001-08-04 Neil Booth ++ ++ * cp/spew.c (read_token): No need to pop buffers. ++ ++2001-08-02 Stan Shebs ++ ++ * cp-tree.h (FNADDR_FROM_VTABLE_ENTRY): Remove, no longer used. ++ (fnaddr_from_vtable_entry): Remove decl. ++ * method.c (use_thunk): Update comment. ++ ++2001-08-01 Andrew Cagney ++ ++ * repo.c (get_base_filename): Change return value to const char ++ pointer. ++ ++2001-08-02 Nathan Sidwell ++ ++ Kill -fhonor-std. ++ * NEWS: Document. ++ * cp-tree.h (flag_honor_std): Remove. ++ (CPTI_FAKE_STD): Remove. ++ (std_node): Remove comment about it being NULL. ++ (fake_std_node): Remove. ++ * decl.c (in_fake_std): Remove. ++ (walk_namespaces_r): Remove fake_std_node check. ++ (push_namespace): Remove in_fake_std code. ++ (pop_namespace): Likewise. ++ (lookup_name_real): Remove fake_std_node check. ++ (init_decl_processing): Always create std_node. Always add ++ std:: things there. ++ (builtin_function): Always put non '_' fns in std. ++ * decl2.c (flag_honor_std): Remove. ++ (lang_f_options): Remove honor-std. ++ (unsupported_options): Add honor-std. ++ (set_decl_namespace): Remove fake_std_node check. ++ (validate_nonmember_using_decl): Likewise. ++ (do_using_directive): Likewise. ++ (handle_class_head): Likewise. ++ * dump.c (cp_dump_tree): Likewise. ++ * except.c (init_exception_processing): Adjust. ++ * init.c (build_member_call): Remove fake_std_node check. ++ (build_offset_ref): Likewise. ++ * lang-options.h: Remove -fhonor-std, -fno-honor-std. ++ * rtti.c (init_rtti_processing): Adjust. ++ ++2001-07-31 Alexandre Petit-Bianco ++ ++ * tree.c (cp_tree_equal): WITH_CLEANUP_EXPR node to use its second ++ operand while calling cp_tree_equal. ++ ++2001-07-31 Nathan Sidwell ++ ++ The 3.0 ABI no longer has vbase pointer fields. ++ * cp-tree.h (VBASE_NAME, VBASE_NAME_FORMAT, VBASE_NAME_P, ++ FORMAT_VBASE_NAME): Remove. ++ * method.c (do_build_copy_constructor): Adjust. ++ (do_build_assign_ref): Adjust. ++ * search.c (lookup_field_r): Adjust. ++ * typeck.c (build_component_ref): Adjust. ++ ++ The 3.0 ABI always has a vtable pointer at the start of every ++ polymorphic class. ++ * rtti.c (build_headof_sub): Remove. ++ (build_headof): Adjust. ++ (get_tinfo_decl_dynamic): No need to check flag_rtti ++ here. Adjust. ++ (create_real_tinfo_var): Explain why we need a hidden name. ++ ++2001-07-31 Nathan Sidwell ++ ++ PR c++/3631 ++ * class.c (update_vtable_entry_for_fn): The fixed adjustment ++ of a virtual thunk should be from declaring base. ++ ++2001-07-31 Nathan Sidwell ++ ++ * class.c (dfs_ctor_vtable_bases_queue_p): Always walk into ++ the shared virtual base, so preserving inheritance graph order. ++ ++2001-07-30 Andreas Jaeger ++ ++ * decl2.c: Remove unused var global_temp_name_counter. ++ ++2001-07-28 Richard Henderson ++ ++ * method.c (pending_inlines): Remove. ++ ++2001-07-27 Nathan Sidwell ++ ++ * class.c (mark_primary_virtual_base): Don't adjust base ++ offsets here. ++ (dfs_unshared_virtual_bases): Adjust them here. ++ (mark_primary_bases): Explain why we adjust at the end. ++ ++2001-07-27 Nathan Sidwell ++ ++ * class.c (finish_struct_1): When copying the primary base's ++ VFIELD, make sure we find it is at offset zero. ++ ++2001-07-26 Kriang Lerdsuwanakij ++ ++ * pt.c (tsubst_template_parms): Call maybe_fold_nontype_arg and ++ tsubst_expr for default template arguments. ++ ++2001-07-26 Nathan Sidwell ++ ++ PR c++/3621 ++ * spew.c (yylex): Only copy the token's lineno, if it is ++ nonzero. ++ ++2001-07-26 Nathan Sidwell ++ ++ PR c++/3624 ++ * call.c (resolve_args): Simplify, call ++ convert_from_reference. ++ (build_new_op): Resolve and convert from reference ARG1 ++ earlier. Adjust ARG2 & ARG3 resolve and conversion. ++ ++2001-07-26 Nathan Sidwell ++ ++ * decl.c (last_function_parm_tags): Remove. ++ (current_function_parm_tags): Remove. ++ (init_decl_processing): Adjust. ++ (start_function): Adjust. ++ (store_parm_decls): Adjust. ++ ++ PR c++/3152 ++ * decl.c (grokdeclarator): Detect when a function typedef is ++ declaring a function, and create last_function_parms correctly. ++ ++2001-07-25 Jason Merrill ++ ++ * call.c (joust): Only prefer a non-builtin candidate to a builtin ++ one if they have the same signature. ++ ++ * cvt.c (build_up_reference): Take DECL parm. Check TREE_STATIC on ++ it rather than toplevel_bindings_p. Give it a mangled name if static. ++ (convert_to_reference): Adjust. ++ * decl2.c (get_temp_name): Lose. ++ * mangle.c (mangle_ref_init_variable): New fn. ++ (mangle_guard_variable): Strip the ref-init header. ++ * cp-tree.h: Adjust. ++ * decl.c (cp_finish_decl): Add the DECL_STMT after processing the ++ initializer. ++ (grok_reference_init): Always use DECL_INITIAL. ++ ++2001-07-25 Nathan Sidwell ++ ++ PR c++/3416 ++ * call.c (build_conditional_expr): Recheck args after ++ conversions. ++ * cp-tree.h (build_conditional_expr): Move to correct file. ++ * typeck.c (decay_conversion): Diagnose any unknown types ++ reaching here. ++ (build_binary_op): Don't do initial decay or default ++ conversions on overloaded functions. ++ (build_static_cast): Don't do a decay conversion here. ++ ++2001-07-25 Nathan Sidwell ++ ++ PR c++/3543 ++ * typeck.c (condition_conversion): Resolve an OFFSET_REF. ++ * expr.c (cplus_expand_expr): An OFFSET_REF should never get here. ++ ++2001-07-25 Nathan Sidwell ++ ++ * class.c (build_vtbl_or_vbase_field): Remove, move into ... ++ (create_vtbl_ptr): ... here. ++ ++2001-07-25 Nathan Sidwell ++ ++ * class.c (build_vbase_offset_vbtl_entries): Look for ++ non-primary base of which we are a sub vtable. ++ ++2001-07-24 Phil Edwards ++ ++ * semantics.c (finish_this_expr): Remove unused code. ++ ++2001-07-24 Nathan Sidwell ++ ++ Simplify rtti, now we've only one ABI. ++ * cp-tree.h (cp_tree_index): Remove CPTI_TINFO_DECL_ID, ++ CPTI_TINFO_VAR_ID. ++ (tinfo_decl_id, tinfo_var_id): Remove. ++ (get_typeid_1): Remove. ++ * rtti.c ++ (init_rtti_processing): Remove tinfo_decl_id & tinfo_var_id. ++ (typeid_ok_p): New function. ++ (build_type_id): Call typeid_ok_p. Don't call tinfo_from_decl. ++ (get_tinfo_decl): Remove old abi documentation. ++ (tinfo_from_decl): Remove. ++ (get_type_id): Call typeid_ok_p. Absorb get_typeid_1. ++ (get_typeid_1): Remove. ++ (get_base_offset): Remove. ++ (synthesize_tinfo_var): Absorb get_base_offset. ++ (create_real_tinfo_var): Don't use tinfo_decl_id. ++ ++2001-07-23 Graham Stott ++ ++ * cp/class.c (type_requires_array_cookie): Fix use of uninitialized ++ variable has_two_argument_delete_p. ++ ++2001-07-21 Nathan Sidwell ++ ++ Remove flag_vtable_thunk. It is always on for the 3.0 ABI. ++ * cp-tree.h (CPTI_DELTA2_IDENTIFIER): Remove. ++ (CPTI_INDEX_IDENTIFIER): Remove. ++ (CPT_PFN_OR_DELTA2_IDENTIFIER): Remove. ++ (delta2_identifier): Remove. ++ (index_identifier): Remove. ++ (pfn_or_delta2_identifier): Remove. ++ (flag_vtable_thunks): Remove. ++ (VTABLE_DELTA2_NAME): Remove. ++ (VTABLE_INDEX_NAME): Remove. ++ (FNADDR_FROM_VTABLE_ENTRY): Adjust. ++ (vfunc_ptr_type_node): Adjust. ++ (VTABLE_NAME_PREFIX): Adjust. ++ (build_vfn_ref): Lose first parameter. ++ (fixup_all_virtual_upcast_offsets): Remove. ++ * decl.c (initialize_predefined_identifiers): Remove ++ delta2_identifier, index_identifier, pfn_or_delta2_identifier. ++ (init_decl_processing): Remove no-vtable-thunk code. ++ * decl2.c (flag_vtable_thunks): Remove. ++ (mark_vtable_entries): Remove no-vtable-thunk code. ++ * error.c (dump_decl): Remove no-vtable-thunk code. ++ (dump_expr): Adjust ptr to member function code. ++ * init.c (initialize_vtable_ptrs): Remove no-vtable-thunk ++ code. ++ * rtti.c (build_headof): Remove no-vtable-thunk code. ++ (get_tinfo_decl_dynamic): Adjust build_vfn_ref call. ++ * search.c (get_base_distance): Remove expand_upcast_fixups case. ++ (virtual_context) Remove. ++ (expand_upcast_fixups): Remove. ++ (fixup_virtual_upcast_offsets): Remove. ++ (fixup_all_virtual_upcast_offsets): Remove. ++ * typeck.c (get_member_function_from_ptrfunc): Remove ++ no-vtable-thunk code. ++ * call.c (build_over_call): Adjust call to build_vfn_ref. ++ * class.c (build_vfn_ref): Lose first parameter. Remove ++ no-vtable-thunk code. ++ (build_rtti_vtbl_entries): Remove no-vtable-thunk code. ++ (build_vtable_entry): Remove no-vtable-thunk code. ++ ++2001-07-20 Nathan Sidwell ++ ++ Remove old-abi remnants. Remove comments about old abi ++ behavior. Remove references to 'new-abi' in comments. ++ * cp-tree.h: Adjust comments. ++ (vbase_offsets_in_vtable_p): Delete. ++ (vcall_offsets_in_vtable_p): Delete. ++ (vptrs_present_everywhere_p): Delete. ++ (all_overridden_vfuns_in_vtables_p): Delete. ++ (merge_primary_and_secondary_vtables_p): Delete. ++ (TYPE_CONTAINS_VPTR_P): Adjust. ++ (VTT_NAME_PREFIX): Remove. ++ (CTOR_VTBL_NAME_PREFIX): Remove. ++ (init_vbase_pointers): Remove. ++ * class.c: Adjust coments. ++ (build_vbase_pointer_fields): Delete. ++ (build_vbase_pointer): Remove old-abi code. ++ (build_secondary_vtable): Likewise. ++ (modify_all_vtables): Likewise. ++ (create_vtable_ptr): Likewise. ++ (layout_class_type): Likewise. ++ (finish_struct_1): Likewise. ++ (finish_vtbls): Likewise. ++ (dfs_finish_vtbls): Delete. ++ (build_vbase_offset_vtbl_entries): Remove old-abi code. ++ * cvt.c: Adjust comments. ++ * decl.c: Adjust comments. ++ * decl2.c: Adjust comments. ++ * init.c: Adjust comments. ++ (construct_virtual_bases): Remove old-abi code. ++ * lang-specs.h: Remove -fno-new-abi. ++ * mangle.c: Adjust comments. ++ * rtti.c: Adjust comments. ++ (get_base_offset): Remove old-abi-code. ++ * search.c: Adjust comments. ++ (dfs_init_vbase_pointers): Remove. ++ (dfs_vtable_path_unmark): Remove. ++ (init_vbase_pointers): Remove. ++ * semantics.c: Adjust comments. ++ (emit_associated_thunks): Remove old-abi code. ++ * typeck.c: Adjust comments. ++ ++2001-07-20 Daniel Berlin ++ ++ * Make-lang.in (cp/optimize.o): Depend on $(PARAMS_H), not ++ params.h. ++ ++2001-07-19 Mark Mitchell ++ ++ * class.c (finish_struct_anon): Forbid nested classes. ++ ++2001-07-19 Neil Booth ++ ++ * decl2.c: Don't include dwarfout.h and dwarf2out.h. ++ * optimize.c: Include debug.h. ++ (maybe_clone_body): Use debug hook. ++ * semantics.c: Include debug.h. ++ (expand_body): Use debug hook. ++ ++2001-07-19 Neil Booth ++ ++ * spew.c (read_token, yyerror): Remove CPP_INT, CPP_FLOAT cases. ++ ++2001-07-18 Mark Mitchell ++ ++ * class.c (type_requires_array_cookie): New function. ++ (check_methods): Don't try to figure out whether the type needs a ++ cookie here. ++ (check_bases_and_members): Set TYPE_VEC_NEW_USES_COOKIE here. ++ * cp-tree.h (TYPE_VEC_DELETE_TAKES_SIZE): Remove. ++ (TYPE_VEC_NEW_USES_COOKIE): Reimplement. ++ * pt.c (instantiate_class_template): Don't set ++ TYPE_VEC_DELETE_TAKES_SIZE. ++ * NEWS: Document ABI changes from GCC 3.0. ++ ++2001-07-18 Xavier Delacour , ++ Gerald Pfeifer ++ ++ * NEWS (Changes in GCC 3.0): Fix typo. ++ ++2001-07-13 Joseph S. Myers ++ ++ * decl2.c (cplus_decl_attributes): Take a pointer to the node to ++ which attributes are to be attached, and a flags argument. Update ++ call to decl_attributes. ++ (grokfield): Update call to decl_attributes. ++ * class.c (finish_struct): Update call to cplus_decl_attributes. ++ * cp-tree.h (cplus_decl_attributes): Update prototype. ++ * decl.c (start_decl, grokdeclarator, start_function): Update ++ calls to decl_attributes and cplus_decl_attributes. ++ * friend.c (do_friend): Update call to cplus_decl_attributes. ++ * parse.y (parse_bitfield): Update call to cplus_decl_attributes. ++ ++2001-07-12 Mark Mitchell ++ ++ * decl.c (make_rtl_for_nonlocal_decl): Set DECL_C_HARD_REGISTER ++ for `register' variables with an asm-specification. ++ ++2001-07-11 Mark Mitchell ++ ++ * semantics.c (finish_asm_stmt): Mark the output operands ++ to an asm addressable, if necessary. ++ ++2001-07-11 Ben Elliston ++ ++ * Revert this change -- there is a subtle bug. ++ ++ PR c++/80 ++ * decl.c (finish_enum): New "attributes" argument; pass it to ++ cplus_decl_attributes. Use a narrower type if the enum is packed. ++ * cp-tree.h (finish_enum): Adjust prototype. ++ * parse.y (enum_head): New non-terminal. ++ (structsp): Use it. Enums now may be preceded or followed by ++ optional attributes -- pass their chained tree to finish_enum(). ++ * pt.c (tsubst_enum): Pass NULL_TREE for the new argument. ++ ++2001-07-10 Mark Mitchell ++ ++ * pt.c (tsubst_decl): Set DECL_CONTEXT for namespace-scope ++ variables. ++ ++2001-07-10 Jason Merrill ++ ++ * semantics.c (cp_expand_stmt): Fix for null ++ current_function_return_value. ++ ++2001-07-10 Jan van Male ++ ++ * call.c (build_op_delete_call): Initialize fn. ++ (convert_like_real): Delete conditional. ++ (joust): Initialize *w and *l. ++ * class.c: Add prototype for binfo_ctor_vtable. ++ (get_primary_binfo): Initialize result. ++ * init.c (build_java_class_ref): Initialize name. ++ ++2001-07-09 Erik Rozendaal ++ ++ * typeck.c (unary_complex_lvalue): Do not duplicate the ++ argument to modify, pre-, or post-increment when used as an ++ lvalue and when the argument has side-effects. ++ ++2001-07-08 Joseph S. Myers ++ ++ * decl.c (start_decl): Don't call SET_DEFAULT_DECL_ATTRIBUTES. ++ (start_function): Don't call SET_DEFAULT_DECL_ATTRIBUTES. Call ++ cplus_decl_attributes even if attrs is NULL. ++ * friend.c (do_friend): Don't call SET_DEFAULT_DECL_ATTRIBUTES. ++ ++2001-07-08 Joseph S. Myers ++ ++ * decl.c (grokdeclarator), decl2.c (cplus_decl_attributes): Update ++ calls to decl_attributes. ++ ++2001-07-06 Ira Ruben ++ ++ * cp-tree.def (TEMPLATE_DECL): Update comment. DECL_RESULT should ++ be DECL_TEMPLATE_RESULT. ++ ++2001-07-05 Kriang Lerdsuwanakij ++ ++ * cp-tree.h (copy_template_template_parm): Rename to ... ++ (bind_template_template_parm): ... here. ++ * tree.c (copy_template_template_parm): Rename to ... ++ (bind_template_template_parm): ... here. Remove the case when ++ NEWARGS is NULL_TREE. ++ (copy_tree_r): Don't copy TEMPLATE_TEMPLATE_PARM and ++ BOUND_TEMPLATE_TEMPLATE_PARM. ++ * pt.c (lookup_template_class): Adjust. ++ ++2001-07-05 Jason Merrill ++ ++ * cvt.c (convert_lvalue): New fn. ++ * cp-tree.h: Declare it. ++ * method.c (do_build_assign_ref): Use it. ++ (do_build_copy_constructor): Convert parm to base types ++ before calling base constructors. ++ ++ * typeck.c (check_return_expr): Check DECL_ALIGN instead of ++ DECL_USER_ALIGN. Check flag_elide_constructors instead of ++ optimize. ++ * semantics.c (cp_expand_stmt): Don't destroy the named return value. ++ ++2001-07-02 Nathan Sidwell ++ ++ * optimize.c (optimize_inline_calls): New function, broken out ++ of ... ++ (optimize_function): ... here. Call it. Don't inline if it is ++ a thunk. ++ (dump_function): Print name of dump flag causing this dump. ++ * semantics.c (expand_body): Move thunk inline check to ++ optimize_function. ++ ++2001-06-29 Joseph S. Myers ++ ++ * typeck.c (COMP_TYPE_ATTRIBUTES): Don't define. ++ (comptypes): Use target.comp_type_attributes. ++ ++2001-06-29 Nathan Sidwell ++ ++ * cp-tree.h (flag_dump_class_layout): Remove unneeded declaration. ++ ++2001-06-28 Gabriel Dos Reis ++ ++ * error.c (lang_print_error_function): Add a `diagnostic_context *' ++ parameter. Tweak. ++ ++2001-06-27 Neil Booth ++ ++ * decl2.c (import_export_class): Update. ++ ++2001-06-26 Gabriel Dos Reis ++ ++ * error.c (init_error): Adjust settings. ++ ++2001-06-26 Gabriel Dos Reis ++ ++ * error.c (init_error): Adjust settings. ++ ++2001-06-19 Richard Sandiford ++ ++ * except.c (initialize_handler_parm): Expect __cxa_begin_catch to ++ return pointers to data members by reference rather than by value. ++ ++2001-06-18 Jason Merrill ++ ++ Implement the Named Return Value optimization. ++ * cp-tree.h (struct cp_language_function): Add x_return_value. ++ (current_function_return_value): Now a macro. ++ * decl.c: Don't define it. ++ (define_label, finish_case_label): Don't clear it. ++ (init_decl_processing): Don't register it with GC. ++ * semantics.c (genrtl_finish_function): Don't check it for ++ no_return_label. Copy the RTL from the return value to ++ current_function_return_value and walk, calling... ++ (nullify_returns_r): ...this new fn. ++ * typeck.c (check_return_expr): Set current_function_return_value. ++ ++2001-06-15 Jason Merrill ++ ++ * class.c (dfs_accumulate_vtbl_inits): Just point to the base we're ++ sharing a ctor vtable with. Merge code for cases 1 and 2. ++ (binfo_ctor_vtable): New fn. ++ (build_vtt_inits, dfs_build_secondary_vptr_vtt_inits): Use it. ++ ++2001-06-14 Jason Merrill ++ ++ * class.c (dfs_find_final_overrider): Fix logic. ++ ++ * class.c (update_vtable_entry_for_fn): Uncomment optimization to use ++ virtual thunk instead of non-virtual. ++ (get_matching_virtual): Uncomment. ++ ++ * pt.c (unify): Don't recurse between the POINTER_TYPE and the ++ OFFSET_TYPE. If we're adding cv-quals, the extra ones would be on ++ PARM, not ARG. ++ ++2001-06-14 Nathan Sidwell ++ ++ * class.c (dfs_accumulate_vtbl_inits): For case 2 & 3, make sure ++ we've not emerged from the hierarchy of RTTI_BINFO on reaching ++ a non-virtual base. ++ ++2001-06-13 Mark Mitchell ++ ++ * NEWS: Update release number. ++ ++2001-06-12 Nathan Sidwell ++ ++ PR c++/3130, c++/3131, c++/3132 ++ * cp-tree.h (BINFO_UNSHARED_MARKED): New #define. ++ * class.c (force_canonical_binfo_r): Move ++ BINFO_UNSHARED_MARKED, BINFO_LOST_PRIMARY_P. Don't move ++ virtual bases unless they're primary and what they're primary ++ too has been moved. ++ (dfs_unshared_virtual_bases): Use BINFO_UNSHARED_MARKED. Cope ++ with morally virtual bases. Duplicate BINFO_LOST_PRIMARY_P and ++ BINFO_PRIMARY_BASE_OF. Clear BINFO_VTABLE for all but the most ++ derived binfo. ++ (mark_primary_bases): Use BINFO_UNSHARED_MARKED. ++ (layout_nonempty_base_or_field): Add most derived type ++ parameter. Adjust. ++ (layout_empty_base): Likewise. ++ (build_base_field): Likewise. ++ (build_base_fields): Likewise. ++ (propagate_binfo_offsets): Add most derived type ++ parameter. Skip non canonical virtual bases too. ++ (dfs_set_offset_for_unshared_vbases): Don't skip primary ++ bases. Do skip canonical bases. ++ (layout_virtual_bases): Adjust. ++ (layout_class_type): Adjust. ++ (dfs_get_primary_binfo): Build list of virtual primary base ++ candidates. ++ (get_primary_binfo): Check that the shared virtual primary ++ base candidate was found first. ++ (accumulate_vtbl_inits): Don't do anything for non-vptr ++ containing binfos. For case 1 primary virtual bases, keep ++ checking that we've not emerged from the hierarchy of RTTI_BINFO. ++ ++2001-06-12 Nathan Sidwell ++ ++ PR c++/3089 ++ * class.c (dfs_accumulate_vtbl_inits): Always walk down the ++ hierarchy looking for primary bases for a ctor ++ vtable. Recursively call oneself, if we meet our primary via ++ this route and haven't met it yet via inheritance graph order. ++ ++2001-06-11 Mark Mitchell ++ ++ * lang-options.h: Emit documentation for -fno-honor-std, not ++ -fhonor-std. ++ ++2001-06-10 Alexandre Oliva ++ ++ * typeck.c (get_member_function_from_ptrfunc) [vbit_in_delta]: ++ Don't clobber delta. ++ (expand_ptrmemfunc_cst) [ptrmemfunc_vbit_in_delta]: Adjust pfn. ++ ++2001-06-10 Mark Mitchell ++ Gabriel Dos Reis ++ ++ * Make-lang.in (cp/call.o): Depend on diagnostic.h ++ (cp/typeck.o): Depend on diagnostic.h ++ (cp/typeck2.o): Depend on diagnostic.h ++ (cp/repo.o): Depend on dignostic.h ++ * typeck.c: #include diagnostic.h ++ (convert_for_initialization): Remove extern declaration for ++ warningcount and errorcount. ++ ++ * call.c: #include diagnostic.h ++ (convert_like_real): Remove extern declaration for warnincount and ++ errorcount. ++ ++ * repo.c: #include diagnostic.h ++ * typeck2.c: #include diagnostic.h ++ ++2001-06-08 Nathan Sidwell ++ ++ * decl.c (duplicate_decls): Fix DECL_TEMPLATE_RESULT thinko ++ in previous change. ++ ++2001-06-08 Nathan Sidwell ++ ++ PR c++/2929 ++ * friend.c (do_friend): Use push_decl_namespace for classes at ++ namespace scope. ++ ++2001-06-08 Nathan Sidwell ++ Jason Merrill ++ ++ PR c++/3061 ++ * class.c (build_secondary_vtable): Use assert, rather than an error ++ message. ++ (dfs_fixup_binfo_vtbls): BINFO_VTABLE might be NULL. ++ (dfs_accumulate_vtbl_inits): A lost primary virtual base may ++ be between ORIG_BINFO and RTTI_BINFO, but neither of them. ++ Don't set BINFO_VTABLE for a primary virtual base. ++ ++2001-06-07 Mark Mitchell ++ ++ * decl.c (duplicate_decls): Update source position information ++ when a template function is defined. ++ ++2001-06-07 Phil Edwards ++ ++ * lang-specs.h: Move -D_GNU_SOURCE to config/linux.h. ++ ++2001-06-07 Nathan Sidwell ++ ++ PR c++/2914 ++ * decl.c (pushtag): Don't push into a complete type's scope. ++ ++2001-06-06 Jason Merrill ++ ++ * cp-tree.h (THUNK_GENERATE_WITH_VTABLE_P): Lose. ++ (struct lang_decl_flags): Lose generate_with_vtable_p. ++ (BV_GENERATE_THUNK_WITH_VTABLE_P): Lose. ++ * class.c (copy_virtuals): Adjust. ++ * decl2.c (mark_vtable_entries): Adjust. ++ * method.c (make_thunk, build_vtable_entry): Adjust. ++ * class.c (update_vtable_entry_for_fn): Only look as far as the ++ first defining class. ++ (build_vtbl_initializer): Put nothing in the slot for a function only ++ defined in a lost primary virtual base. ++ (add_vcall_offset_vtbl_entries_1): Use the same code for ++ the lost primary case and the normal case. ++ (dfs_unshared_virtual_bases): Don't lose a non-virtual primary base. ++ (get_vfield_offset, get_derived_offset): Lose. ++ (dfs_find_final_overrider): Use look_for_overrides_here. ++ (get_matching_virtual): New fn. ++ * semantics.c (emit_associated_thunks): Check BV_USE_VCALL_INDEX_P, ++ not BV_VCALL_INDEX. ++ * search.c (look_for_overrides_here): Split out from... ++ (look_for_overrides_r): Here. ++ ++ * class.c (find_final_overrider): Return error_mark_node on error. ++ ++ * decl2.c (key_method): #if 0 accidental change. ++ ++2001-06-06 John David Anglin ++ ++ * call.c (convert_default_arg): Use INTEGRAL_TYPE_P. ++ (build_over_call): Likewise. ++ * decl.c (grokparms): Likewise. ++ * pt.c (tsubst_decl): Likewise. ++ * typeck.c (convert_arguments): Likewise. ++ ++2001-06-05 Mark Mitchell ++ ++ * semantics.c (begin_class_definition): Robustify. ++ ++ * pt.c (instantiate_decl): Tell the repository code about the ++ clones, not the cloned functions. ++ * repo.c (repo_template_used): Explicitly instantiate the cloned ++ function, not the clones. ++ ++2001-06-05 Nathan Sidwell ++ ++ * call.c (build_user_type_conversion_1): Set ICS_USER_FLAG and ++ ICS_BAD_FLAG on created conversion. ++ (compare_ics): Break out rank. ++ ++2001-06-05 Nathan Sidwell ++ ++ * decl.c (xref_tag): Remove extraneous %s on dependent name ++ lookup warning. ++ ++2001-06-05 Nathan Sidwell ++ ++ * class.c (layout_vtable_decl): Fix off by one error on ++ build_index_type. ++ (build_vtt): Likewise. ++ (build_ctor_vtbl_group): Likewise. ++ ++2001-06-05 Nathan Sidwell ++ ++ * class.c (maybe_indent_hierarchy): New function. ++ (dump_class_hierarchy_r): Add flags. Dump extra binfo ++ information, if enabled. Use maybe_indent_hierarchy. Adjust ++ output format. ++ (dump_class_hierarchy): Adjust prototype. Adjust output format. ++ (dump_array, dump_vtable, dump_vtt): New functions. ++ (finish_struct_1): Adjust hierarchy dumping. ++ (initialize_vtable): Call dump_vtable. ++ (build_vtt): Call dump_vtt. ++ (build_ctor_vtbl_group): Call dump_vtable. ++ * decl2.c (flag_dump_class_layout): Remove. ++ (cxx_decode_option): Remove dump translation unit ++ and dump class hierarchy check. Call dump_switch_p. ++ (finish_file): Adjust dumping. ++ (dump.c): Only dump base classes if not TDF_SLIM. ++ Only dump namespace members if not TDF_SLIM. ++ * optimize.c (dump_function): New function. ++ (optimize_function): Call dump_function. ++ * semantics.c (expand_body): Use dump_enabled_p. ++ ++2001-06-01 Nathan Sidwell ++ ++ PR g++/2936 ++ Part missed from first commit ++ * decl2.c (finish_anon_union): Copy context. ++ ++2001-05-30 Nathan Sidwell ++ ++ PR g++/2936 ++ * optimize.c (remap_decl): Remap anonymous aggregate members too. ++ ++2001-05-26 Nathan Sidwell ++ ++ PR g++/2823 ++ * semantics.c (expand_body): Don't optimize thunks. ++ ++2001-05-25 Sam TH ++ ++ * cp-tree.h lex.h: Fix header include guards. ++ ++2001-05-25 Mark Mitchell ++ ++ * decl.c (init_decl_processing): Tweak. ++ ++2001-05-24 Mark Mitchell ++ ++ * decl.c (duplicate_decls): Tidy. ++ (init_decl_processing): Always set flag_no_builtin. ++ ++2001-05-24 Nathan Sidwell ++ ++ PR c++/2184 ++ * decl2.c (do_local_using_decl): Push the decls, even in a ++ template. ++ ++2001-05-22 Mark Mitchell ++ ++ * optimize.c (initialize_inlined_parameters): Don't set ++ TREE_READONLY for a VAR_DECL taking the place of an inlined ++ PARM_DECL. ++ ++2001-05-22 Jason Merrill ++ ++ * class.c, cp-tree.h, rtti.c: Remove com_interface attribute support. ++ * tree.c (cp_valid_lang_attribute): Warn about use of com_interface ++ attribute. ++ ++2001-05-22 Joseph S. Myers ++ ++ * parse.y: Refer to compound literals as such, not as ++ constructor-expressions. ++ ++2001-05-21 Mark Mitchell ++ ++ * call.c (build_op_delete_call): Ignore exception-specifications ++ when looking for matching delete operators. ++ * init.c (build_new_1): Compute whether or not the allocation ++ function used is a placement allocation function or not, and ++ communicate this information to build_op_delete_call. ++ ++2001-05-21 Jason Merrill ++ ++ * class.c (build_vtable_entry_ref): Lose vtbl parm. Fix for new abi. ++ (build_vtbl_ref): Adjust. ++ (dfs_accumulate_vtbl_inits): Set TREE_CONSTANT on the vtable address. ++ * decl2.c (lang_f_options): Remove huge-objects, vtable-thunks. ++ Re-add vtable-gc. ++ (unsupported_options): Correspondingly. ++ ++ * decl2.c (maybe_make_one_only): Check flag_weak, not ++ supports_one_only(). ++ ++ * cp-tree.def (START_CATCH_STMT): Lose. ++ * dump.c (cp_dump_tree): Don't dump it. Do dump HANDLER_PARMS. ++ * tree.c (cp_statement_code_p): Don't case it. ++ * semantics.c (cp_expand_stmt): Likewise. ++ * cp-tree.h (START_CATCH_TYPE): Lose. ++ (HANDLER_TYPE): New. ++ * except.c (expand_start_catch_block): Don't start any blocks. ++ Return the type. ++ (expand_end_catch_block): Don't end any blocks. ++ * parse.y (handler): Don't pass anything from finish_handler_parms ++ to finish_handler. ++ * pt.c (tsubst_expr): Likewise. ++ * semantics.c (begin_handler): Call note_level_for_catch here. ++ (finish_handler_parms): Don't return anything. ++ (genrtl_catch_block, begin_catch_block): Lose. ++ (genrtl_handler): Call expand_start_catch here. ++ ++2001-05-18 Jason Merrill ++ ++ * class.c (build_vtable): Set DECL_ASSEMBLER_NAME for vtables here. ++ (get_vtable_decl, build_vtt): Not here. ++ ++2001-05-20 Nathan Sidwell ++ ++ PR c++/2781 ++ * optimize.c (update_cloned_parm): Copy addressability and other ++ flags. ++ ++2001-05-20 Kriang Lerdsuwanakij ++ ++ * pt.c (determine_specialization): Ignore artificial functions. ++ ++2001-05-20 Neil Booth ++ ++ * cp-tree.h (struct lang_identifier, C_RID_YYCODE): Update. ++ (C_RID_CODE): Remove. ++ * lex.c (cxx_init_options): Call set_identifier_size. Update. ++ (init_parse): Don't do it here. ++ ++2001-05-18 Diego Novillo ++ ++ * decl2.c (finish_objects): Use the original SYMBOL_REF from the ++ function declaration to avoid stripping the symbol's attributes. ++ ++2001-05-18 Nathan Sidwell ++ ++ * decl.c (pushdecl): Adjust error string. ++ (xref_tag): Adjust friend class injection warning. Remove the ++ inherited name from the class shadowed scope. ++ ++2001-05-17 Mark Mitchell ++ ++ * except.c (cp_protect_cleanup_actions): New function. ++ (init_exception_processing): Don't set protect_cleanup_actions ++ here. Do set lang_protect_cleanup_actions. ++ ++2001-05-16 Nathan Sidwell ++ ++ * spew.c (read_token): Call yyerror on all unexpected tokens. ++ ++2001-05-16 Nathan Sidwell ++ ++ * init.c (member_init_ok_or_else): Take a tree rather than ++ string for name. ++ (expand_member_init): Adjust. ++ ++2001-05-14 Nick Clifton ++ ++ * decl.c (duplicate_decls): Suppress warning about duplicate ++ decls if the first decl is a friend. ++ ++2001-05-12 Zack Weinberg ++ ++ * except.c (choose_personality_routine): Export. Add ++ explanatory comment. Take an enum languages, not a boolean. ++ (initialize_handler_parm): Adjust to match. ++ * cp-tree.h: Prototype choose_personality_routine. ++ * lex.c (handle_pragma_java_exceptions): New function. ++ (init_cp_pragma): Register #pragma GCC java_exceptions. ++ ++2001-05-12 Neil Booth ++ ++ * method.c (build_mangled_C99_name): Remove unused prototype. ++ ++2001-05-12 Alexandre Oliva ++ ++ * cp-tree.h (ptrmemfunc_vbit_where_t): Declare type. ++ * typeck.c (get_member_function_from_ptrfunc, ++ build_ptrmemfunc, expand_ptrmemfunc_cst): Take ++ TARGET_PTRMEMFUNC_VBIT_LOCATION into account. ++ ++ Reverted Geoff Keating's 2001-05-03's patch. ++ ++2001-05-11 Ira Ruben ++ ++ * cp/cp-tree.h (C_EXP_ORIGINAL_CODE): Delete; declared in c-common.h. ++ ++2001-05-11 Neil Booth ++ ++ * cp-tree.h (finish_label_expr, lookup_label): Delete. ++ * parse.y: Update for '&&'; don't issue warning here. ++ * semantics.c (finish_label_expr): Delete. ++ ++2001-05-07 Mark Mitchell ++ ++ * splay-tree.h (splay_tree_max): New function. ++ (splay_tree_min): Likewise. ++ ++2001-05-03 Geoffrey Keating ++ ++ * cp-tree.h (enum cp_tree_index): Add CPTI_PFN_VFLAG_IDENTIFIER. ++ (pfn_vflag_identifier): Define. ++ Update comment about layout of pointer functions. ++ (build_ptrmemfunc1): Update prototype. ++ (expand_ptrmemfunc_cst): Update prototype. ++ * decl.c (initialize_predefined_identifiers): Initialize ++ pfn_vflag_identifier. ++ (build_ptrmemfunc_type): When FUNCTION_BOUNDARY < 16, add ++ an extra field to the type. ++ * expr.c (cplus_expand_constant): Pass 'flag' between ++ expand_ptrmemfunc_cst and build_ptrmemfunc1. ++ * typeck.c (get_member_function_from_ptrfunc): When ++ FUNCTION_BOUNDARY < 16, look at additional field to determine ++ if a pointer-to-member is a real pointer or a vtable offset. ++ (build_ptrmemfunc1): Add new parameter to contain extra field. ++ (build_ptrmemfunc): Pass the extra field around. ++ (expand_ptrmemfunc_cst): Add new parameter to return extra field. ++ (pfn_from_ptrmemfunc): Ignore the extra field. ++ ++2001-05-03 Mark Mitchell ++ ++ * cp-tree.h (flag_inline_trees): Update documentation. ++ * decl.c (init_decl_processing): Adjust handling of ++ flag_inline_functions and flag_inline_trees to support -O3. ++ (grokfndecl): Set DECL_INLINE on all functions if that's what ++ the user requested. ++ (save_function_data): Clear DECL_INLINE in ++ current_function_cannot_inline is non-NULL. ++ * decl2.c (flag_inline_trees): Update documentation. ++ ++2001-05-03 Nathan Sidwell ++ ++ * dump.c (cp_dump_tree, USING_STMT case): New case. ++ * tree.c (cp_statement_code_p): Add USING_STMT. ++ * decl2.c (do_using_directive): Add the using directive statement. ++ ++ * tree.c (walk_tree): Reformat an if block. ++ ++2001-05-02 Mark Mitchell ++ ++ * decl.c (compute_array_index_type): Don't try to do anything with ++ the indices when processing a template. ++ ++2001-05-02 Kaveh R. Ghazi ++ ++ * call.c: NULL_PTR -> NULL. ++ * class.c: Likewise. ++ * cvt.c: Likewise. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * except.c: Likewise. ++ * init.c: Likewise. ++ * rtti.c: Likewise. ++ * search.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ * typeck2.c: Likewise. ++ ++2001-05-02 Mark Mitchell ++ ++ * decl2.c (do_using_directive): Revert previous patch. ++ ++2001-05-01 Nathan Sidwell ++ ++ * cp-tree.def (USING_STMT): New statement node. ++ * cp-tree.h (USING_STMT_NAMESPACE): New macro. ++ * decl2.c (do_using_directive): Add USING_STMT to statement ++ tree. Don't emit errors when processing template decl. ++ * pt.c (tsubst_expr, USING_STMT case): New case. ++ * semantics.c (cp_expand_stmt, USING_STMT case): New case. ++ ++2001-05-01 Nathan Sidwell ++ ++ * call.c (build_new_op): Convert args from reference here. ++ (build_conditional_expr): Don't convert here. ++ ++2001-05-01 Nathan Sidwell ++ ++ * spew.c (last_token_id): New static variable. ++ (read_token): Set it here. ++ (yyerror): Use it here. ++ ++2001-04-30 Richard Henderson ++ ++ * cvt.c: Downcase C_PROMOTING_INTEGER_TYPE_P invocations. ++ * decl.c: Likewise. ++ ++2001-04-30 Mark Mitchell ++ ++ * gxxint.texi: Remove. ++ * Make-lang.in: Remove all traces of gxxint.texi. ++ ++2001-04-30 Mark P Mitchell ++ ++ * decl2.c (start_static_initialization_or_destruction): Correct ++ logic to handle the -fno-use-cxa-atexit case. ++ ++2001-04-30 Mark Mitchell ++ ++ * optimize.c (update_cloned_parm): New function. ++ (maybe_clone_body): Use it. Update the `this' parameter too. ++ ++2001-04-29 Joseph S. Myers ++ ++ * decl2.c (unsupported_options): Add new-abi. ++ * lang-options.h: Remove no longer supported options. ++ ++2001-04-27 Nathan Sidwell ++ ++ * except.c (can_convert_eh): Don't check template parms, ++ typename types etc. ++ ++2001-04-27 Nathan Sidwell ++ ++ * optimize.c (maybe_clone_body): Copy parameter names and locations. ++ ++2001-04-27 Nathan Sidwell ++ ++ * cp-tree.h (adjust_clone_args): Prototype new function. ++ * class.c (adjust_clone_args): New function. ++ * decl.c (start_function): Call it for in charge ctors. ++ ++2001-04-26 Mark Mitchell ++ ++ * method.c (use_thunk): Make sure that thunks really are emitted ++ when requested. ++ ++2001-04-26 Nathan Sidwell ++ ++ * mangle.c (write_chars): New macro. ++ (hwint_to_ascii): New function ++ (write_number): Use it. ++ (write_integer_cst): Deal with really big numbers. ++ ++2001-04-25 Mark Mitchell ++ ++ * optimize.c (maybe_clone_body): Copy TREE_PUBLIC before emitting ++ the clone. ++ ++2001-04-25 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Set context of namespace scope ++ TYPE_DECLS. ++ ++2001-04-24 Zack Weinberg ++ ++ * cp/optimize.c: Include hashtab.h. ++ (struct inline_data): Add tree_pruner. ++ (expand_call_inline, expand_calls_inline): Use it when calling ++ walk_tree. ++ (optimize_function): Initialize and free tree_pruner. ++ ++2001-04-24 Nathan Sidwell ++ ++ Lazy __FUNCTION__ generation. ++ * cp-tree.def (FUNCTION_NAME): Remove. ++ * cp-tree.h (function_name_declared_p): Remove. ++ (cp_fname_init): Prototype. ++ * decl.c (init_decl_processing): Don't generate __FUNCTION__ et al ids, ++ don't call declare_function_name. Call start_fname_decls. ++ (cp_make_fname_decl): Adjust parameters. Generate the name. Don't ++ clobber the line number. ++ (cp_fname_init): New function. ++ (start_function): Call start_fname_decls. ++ (finish_function): Call finish_fname_decls. ++ * lex.c (reswords): Add slots for __FUNCTION__ et al. ++ (rid_to_yy): Add mappings for __FUNCTION__ et al. ++ * optimize.c (maybe_clone_body): Remove function_name_declared_p. ++ * parse.y (VAR_FUNC_NAME): New token. ++ (primary): Add VAR_FUNC_NAME. ++ * pt.c (tsubst_decl): Adjust a DECL_PRETTY_FUNCTION_P's ++ generation. ++ (tsubst, FUNCTION_NAME case): Remove. ++ (tsubst_copy, FUNCTION_NAME case): Remove. ++ (tsubst_expr, DECL_STMT case): Be careful with a ++ DECL_PRETTY_FUNCTION_P. ++ (instantiate_decl): Remove function_name_declared_p. ++ * semantics.c (begin_compound_statement): Don't call ++ declare_function_name here. ++ (setup_vtbl_ptr). Don't save & restore function_name_declared_p. ++ (finish_translation_unit): Call finish_fname_decls. ++ (expand_body): Remove function_name_declared_p. ++ * typeck2.c (digest_init): Allow any ERROR_MARK. ++ ++2001-04-24 Nathan Sidwell ++ ++ * pt.c (tsubst_decl): Use VOID_TYPE_P. ++ * semantics.c: Fix some typos. ++ ++2001-04-23 Phil Edwards ++ ++ * cp/decl2.c (flag_honor_std): Always initialize to 1. ++ ++2001-04-22 Kaveh R. Ghazi ++ ++ * xref.c (GNU_xref_file): Use concat in lieu of xmalloc/sprintf. ++ ++2001-04-23 Jason Merrill ++ ++ * except.c (build_throw): Wrap the initialization of the exception ++ object in a MUST_NOT_THROW_EXPR. ++ (do_free_exception): #if 0. ++ ++2001-04-20 Mark Mitchell ++ ++ * cp-tree.h (finish_enum): Change prototype. ++ * decl.c (finish_enum): Reorganize. ++ * parse.y (structsp): Adjust calls to finish_enum. ++ ++2001-04-20 Nathan Sidwell ++ ++ * tree.c (cp_tree_equal): Adjust final switch formatting. Add ++ 't' case. ++ ++2001-04-20 Nathan Sidwell ++ ++ * class.c (dfs_unshared_virtual_bases): Add ATTRIBUTE_UNUSED. ++ (layout_empty_base): Return at end flag. ++ (build_base_field): Likewise. ++ (build_base_fields): Likewise. ++ (layout_virtual_bases): Don't add 1 to eoc value. ++ (end_of_class): Use full size for empty bases. ++ (layout_class_type): Clear CLASSNEARLY_EMPTY_P if we appended ++ empty bases. Don't add 1 to eoc value. Only add trailing padding ++ if we're an empty class with no empty bases. ++ (dump_class_hierarchy): Dump size and alignment. ++ ++2001-04-20 Jakub Jelinek ++ ++ * call.c (maybe_handle_ref_bind): Copy ICS_USER_FLAG and ++ ICS_BAD_FLAG. ++ ++2001-04-20 Jakub Jelinek ++ ++ * search.c (lookup_field_r): If looking for type and non-TYPE_DECL ++ is found, look first if name does not match the structure name. ++ ++2001-04-19 Mark Mitchell ++ ++ * cp-tree.h (DECL_LANGUAGE): Don't assume DECL_LANG_SPECIFIC is ++ set. ++ (SET_DECL_LANGUAGE): New macro. ++ * decl.c (duplicate_decls): Use SET_DECL_LANGUAGE. ++ (pushdecl): Likewise. ++ (build_library_fn_1): Likewise. ++ (build_cp_library_fn): Likewise. ++ (grokfndecl): Likewise. ++ (grokvardecl): Mark `extern "C"' variables as having C linkage. ++ * decl2.c (grokclassfn): Use SET_DECL_LANGUAGE. ++ * lex.c (retrofit_lang_decl): Likewise. ++ * mangle.c (mangle_decl_string): Don't mangle the names of ++ variables declared with C language linkage. ++ * semantics.c (finish_member_declaration): Use SET_DECL_LANGUAGE. ++ ++2001-04-18 John David Anglin ++ ++ * semantics.c (simplify_aggr_init_exprs_r): Don't restore ++ flag_access_control from uninitialized storage. ++ ++2001-04-15 Mark Mitchell ++ ++ * cp-tree.h (TYPE_PTRMEM_CLASS_TYPE): Improve documentation. ++ * mangle.c (write_pointer_to_member_type): Fix mangling of ++ pointers to cv-qualified member function types. ++ ++ * init.c (build_delete): Create a SAVE_EXPR for the address if ++ we're going to use it more than once. ++ ++2001-04-13 Mark Mitchell ++ ++ * cp-tree.h (DELTA2_FROM_PTRMEMFUNC): Remove. ++ (expand_ptremfunc_cst): Change prototype. ++ (delta2_from_ptrmemfunc): Remove. ++ * expr.c (cplus_expand_constant): Adjust call to ++ expand_ptrmemfunc_cst. ++ * typeck.c (build_ptrmemfunc1): Simplify. ++ (build_ptrmemfunc): Make sure that casting a PTRMEM_CST still ++ results in a constant. ++ (expand_ptrmemfunc_cst): Remove idx and delta2 parameters. ++ (delta2_from_ptrmemfunc): Remove. ++ (pfn_from_ptrmemfunc): Adjust call to expand_ptrmemfunc_cst. ++ ++2001-04-12 Jason Merrill ++ ++ * cp-tree.h (decl_namespace_list): New macro. ++ (struct saved_scope): Add decl_ns_list. ++ * decl.c (mark_saved_scope): Mark it. ++ * decl2.c: Lose static decl_namespace_list. ++ (init_decl2): Don't save it. ++ ++2001-04-12 Kaveh R. Ghazi ++ ++ * cp-tree.h (warn_return_type, yylex): Delete redundant ++ declarations. ++ ++ * decl.c (current_class_depth, global_namespace): Likewise. ++ ++ * decl2.c (current_class_depth, flag_gnu_xref): Likewise ++ ++ * repo.c (flag_use_repository): Likewise. ++ ++2001-04-12 Kaveh R. Ghazi ++ ++ * cp-tree.h (pedantic, convert, global_bindings_p, insert_block, ++ set_block, pushdecl, getdecls, gettags, init_decl_processing, ++ maybe_build_cleanup, copy_lang_decl, prep_stmt, lvalue_p, ++ lvalue_or_else, print_lang_statistics, comp_target_types, ++ unsigned_type, signed_type, signed_or_unsigned_type, ++ build_function_call, mark_addressable, incomplete_type_error): ++ Delete redundant declarations. ++ ++2001-04-11 Jason Merrill ++ ++ * cp-tree.h (TYPE_LINKAGE_IDENTIFIER): New macro. ++ (TYPE_ANONYMOUS_P): New macro. ++ (TAGGED_TYPE_P): New macro. ++ * decl.c (check_tag_decl): Use TYPE_ANONYMOUS_P. ++ (grokfndecl, grokvardecl, grokdeclarator): Likewise. ++ * tree.c (no_linkage_helper): Likewise. ++ * semantics.c (begin_class_definition): Likewise. ++ * pt.c (convert_template_argument): Likewise. ++ * lex.c (check_for_missing_semicolon): Likewise. ++ ++2001-04-12 Nathan Sidwell ++ ++ * class.c (dfs_unshared_virtual_bases): New function. ++ (mark_primary_bases): Call it. ++ (check_bases): Ignore virtual bases when determining ++ nearly-emptiness. ++ ++2001-04-12 Nathan Sidwell ++ ++ * method.c (make_thunk): Clear DECL_CLONED_FUNCTION. ++ ++2001-04-11 Mark Mitchell ++ ++ * optimize.c (maybe_clone_body): Copy DECL_NUM_STMTS from the ++ cloned function to the clone. ++ ++2001-04-11 Kaveh R. Ghazi ++ ++ * Make-lang.in (cp/semantics.o): Depend on $(EXPR_H). ++ ++ * semantics.c: Include expr.h. ++ ++2001-04-11 Nathan Sidwell ++ ++ * method.c (implicitly_declare_fn): Commonize code for copy ctor ++ and assignment op. Set TREE_USED for parameter. ++ ++2001-04-10 Mark Mitchell ++ ++ * class.c (find_final_overrider_data): Add `candidates'. ++ (dfs_find_final_overrider): Don't issue error messages ++ prematurely. ++ (find_final_overrider): Issue error messages here. ++ (build_base_field): Don't warn about amgibuous direct bases here. ++ (warn_about_ambiguous_direct_bases): New function. ++ (layout_class_type): Use it. ++ ++2001-04-10 Richard Henderson ++ ++ * typeck.c (build_array_ref): Push the array reference inside ++ COMPOUND_EXPR and COND_EXPR. ++ ++2001-04-05 Mark Mitchell ++ ++ * cp-tree.h (DECL_THIS_INLINE): Rename to DECL_DECLARED_INLINE_P. ++ * decl.c (duplicate_decls): Adjust accordingly. ++ (maybe_commonize_var): Likewise. ++ (grokfndecl): Likewise. ++ (start_function): Likewise. ++ (start_method): Likewise. ++ * decl2.c (key_method): Likewise. ++ (import_export_decl): Likewise. ++ * method.c (implicitly_declare_fn): Likewise. ++ * optimize.c (maybe_clone_body): Likewise. ++ ++2001-04-05 Benjamin Kosnik ++ ++ * lang-specs.h: Add __DEPRECATED. ++ ++2001-04-05 J"orn Rennecke ++ ++ * search.c (get_dynamic_cast_base_type): When building a new ++ constant, set its type to ssizetype. ++ ++2001-04-04 Jakub Jelinek ++ ++ * optimize.c (expand_call_inline): Only add newly inlined statements ++ into inlined_stmts. ++ ++2001-04-03 Mark Mitchell ++ ++ * cp-tree.h (OPERATOR_ASSIGN_FORMAT): Remove. ++ (OPERATOR_FORMAT): Likewise. ++ (OPERATOR_TYPENAME_FORMAT): Likewise. ++ * operators.def: Remove old name-mangling information. ++ * decl.c (grok_op_properties): Adjust accordingly. ++ * lex.c (init_operators): Likewise. ++ * rtti.c (get_tinfo_decl): Issue error messages about types that ++ have variable size. ++ ++2001-04-03 Mark Mitchell ++ ++ * decl2.c (import_export_decl): Don't call import_export_class ++ when processing an inline member function. ++ * semantics.c (expand_body): Call import_export_decl before ++ emitting inline functions. ++ ++2001-03-28 Richard Henderson ++ ++ IA-64 ABI Exception Handling: ++ * cp-tree.def (EH_SPEC_BLOCK): New. ++ (MUST_NOT_THROW_EXPR): New. ++ * cp-tree.h: Update changed function declarations. ++ (CPTI_PUSH_EXCEPTION_IDENTIFIER): Remove. ++ (CPTI_CALL_UNEXPECTED): New. ++ (struct cp_language_function): Rename x_eh_spec_try_block ++ to x_eh_spec_block. ++ (EH_SPEC_STMTS, EH_SPEC_RAISES): New. ++ * decl.c (current_binding_level): If no current function ++ bindings, revert to scope_chain. ++ (initialize_predefined_identifiers): Remove __cp_push_exception. ++ (store_parm_decls): Use begin_eh_spec_block. ++ (finish_function): Use finish_eh_spec_block. ++ (mark_lang_function): Update for name changes. ++ * decl2.c (finish_file): No mark_all_runtime_matches. ++ * dump.c (cp_dump_tree): Handle new tree codes. ++ * error.c (dump_expr) [BIND_EXPR]: Fix typo. ++ * except.c (catch_language_init, catch_language): Remove. ++ (init_exception_processing): Don't set language code. ++ Initialize call_unexpected_node, protect_cleanup_actions, ++ eh_personality_libfunc, lang_eh_runtime_type. ++ (call_eh_info, push_eh_info, get_eh_info, get_eh_value): Remove. ++ (get_eh_type, get_eh_caught, get_eh_handlers): Remove. ++ (prepare_eh_type): Split out type canonicalizations ... ++ (build_eh_type_type): ... from here. ++ (build_eh_type_type_ref): Remove. ++ (mark_all_runtime_matches): Remove. ++ (build_exc_ptr): New. ++ (do_begin_catch, do_end_catch): New. ++ (do_pop_exception): Remove. ++ (build_terminate_handler): Remove. ++ (choose_personality_routine): Split out language choice from ... ++ (initialize_handler_parm): ... here. ++ Use MUST_NOT_THROW_EXPR. ++ (expand_start_catch_block): Use do_begin_catch. Simplify Java ++ exception object handling. ++ (expand_start_eh_spec, expand_end_eh_spec): Remove. ++ (expand_exception_blocks, alloc_eh_object): Remove. ++ (begin_eh_spec_block, finish_eh_spec_block): New. ++ (do_allocate_exception, do_free_exception): New. ++ (expand_throw): Merge into ... ++ (build_throw): ... here. Update for abi. ++ * expr.c (cplus_expand_expr): No expand_internal_throw. ++ Handle MUST_NOT_THROW_EXPR. ++ * pt.c (tsubst_expr): Handle EH_SPEC_BLOCK. ++ * semantics.c (*) Update for except.h name changes. ++ (genrtl_try_block): No protect_with_terminate. ++ (genrtl_eh_spec_block): New. ++ (genrtl_handler): Don't emit the goto here. ++ (cp_expand_stmt): Handle EH_SPEC_BLOCK. ++ (genrtl_finish_function): Don't expand_exception_blocks. ++ * tree.c (cp_statement_code_p): Handle EH_SPEC_BLOCK. ++ ++2001-03-28 Richard Henderson ++ ++ * decl.c (struct named_label_list): Rename eh_region to ++ in_try_scope, add in_catch_scope. ++ (struct binding_level): Rename eh_region to is_try_scope, ++ add is_catch_scope. ++ (note_level_for_try): Rename from note_level_for_eh. ++ (note_level_for_catch): New. ++ (poplevel): Copy both is_try_scope and is_catch_scope to ++ the named_label_list struct. ++ (check_previous_goto_1): Don't check for catch block via ++ DECL_ARTIFICIAL; use in_try_scope instead. ++ (check_goto): Likewise. ++ * cp-tree.h (note_level_for_try, note_level_for_catch): Declare. ++ * except.c (expand_start_catch_block): Call note_level_for_catch. ++ * semantics.c (begin_compound_stmt): Update for note_level_for_try. ++ ++2001-03-27 Richard Henderson ++ ++ * except.c: Use USING_SJLJ_EXCEPTIONS instead of ++ exceptions_via_longjmp. ++ ++2001-03-27 Phil Edwards ++ ++ * pt.c (check_default_tmpl_args): Make error messages clearer. ++ ++2001-03-26 Phil Edwards ++ ++ * error.c: Also undefine 'A' macro used for cp_printers definition. ++ ++2001-03-27 Kaveh R. Ghazi ++ ++ * Make-lang.in: Depend on $(SYSTEM_H), not system.h. ++ ++2001-03-26 Mike Yang ++ Mark Mitchell ++ ++ * dump.c (dump_access): New function. ++ (cp_dump_tree): Use it. Dump basetype information for class ++ types. ++ ++2001-03-26 Mark Mitchell ++ ++ * Makefile.in (optimize.o): Depend on params.h. ++ (duplicate_decls): Copy DECL_NUM_STMTS, not DECL_FRAME_SIZE. ++ (init_decl_processing): Set flag_no_inline when doing ++ inlining-on-trees. ++ * optimize.c: Include params.h. ++ (struct inline_data): Improve documentation of FNS. Add ++ FIRST_INLINED_FN, INLINED_STMTS, and CLONING_P. ++ (INSNS_PER_STMT): New macro. ++ (remap_block): Use CLONING_P. ++ (inlinable_function_p): Don't inline big functions. ++ (expand_call_inline): Keep track of how much inlining we've done. ++ (optimize_function): Set FIRST_INLINED_FN. ++ (maybe_clone_body): Set CLONING_P. ++ * semantics.c (simplify_aggr_init_exprs_r): Fix typing problems in ++ tree nodes. ++ (genrtl_finish_function): Clear DECL_DEFER_OUTPUT before calling ++ rest_of_compilation. Clear DECL_RTL for local variables ++ afterwards. ++ (clear_decl_rtl): New function. ++ ++2001-03-26 Nathan Sidwell ++ ++ Implement DR 209 ++ * cp-tree.h (skip_type_access_control, ++ reset_type_access_control): Prototype. ++ * decl.c (grokdeclarator): Access of friends is not checked. ++ * parse.y (component_decl_list): Reset type access control. ++ * semantics.c (decl_type_access_control): Clear ++ current_type_lookups. ++ (save_type_access_control): Don't save if not deferring. ++ (skip_type_access_control, reset_type_access_control): New ++ functions. ++ (begin_class_definition): Do type access control for basetypes. ++ Start deferred access control. ++ (finish_class_definition): Resume immediate access control if ++ this is a local class. ++ ++2001-03-25 Kaveh R. Ghazi ++ ++ * class.c (add_method): Use memcpy/memmove, not bcopy. ++ ++ * decl.c (duplicate_decls): Likewise. ++ ++2001-03-23 Jakub Jelinek ++ ++ * mangle.c (write_discriminator): Use `_0' for discriminator 1, ++ not `_'. ++ ++2001-03-23 Jakub Jelinek ++ ++ * decl.c (local_names): Define. ++ (push_local_name): New. ++ (grok_reference_init): Return init if initializing static reference ++ variable with non-constant instead of emitting it. ++ Move expand_static_init call to cp_finish_decl. ++ (layout_var_decl): Call push_local_name. ++ (maybe_commonize_var): Allow inlining functions even if they have ++ static local variables, use comdat_linkage for them if flag_weak. ++ (check_initializer): Call obscure_complex_init if ++ grok_reference_init returned nonzero. ++ (save_function_data): Clear x_local_names. ++ (pop_cp_function_context): Free x_local_names. ++ (mark_inlined_fns): Remove. ++ (mark_lang_function): Mark x_local_names. ++ (lang_mark_tree): Don't mark DECL_ACCESS for DECL_DISCRIMINATOR_P. ++ Mark inlined_fns as tree, remove call to mark_inlined_fns. ++ * class.c (alter_access): Ensure DECL_ACCESS is never set if ++ DECL_DISCRIMINATOR_P. ++ * cp-tree.h (cp_language_function): Add x_local_names. ++ (lang_decl_flags): Add discriminator into u2. ++ (lang_decl_inlined_fns): Remove. ++ (lang_decl): inlined_fns is now a TREE_VEC. ++ (DECL_DISCRIMINATOR_P, DECL_DISCRIMINATOR): Define. ++ * optimize.c (inlinable_function_p): DECL_INLINED_FNS is now a ++ TREE_VEC, not a custom structure. ++ (optimize_function): Likewise. ++ * mangle.c (discriminator_for_local_entity): Discriminate among ++ VAR_DECL local entities. ++ * search.c (dfs_access_in_type): If DECL_DISCRIMINATOR_P, DECL_ACCESS ++ is not valid. ++ ++2001-03-22 Bryce McKinlay ++ ++ Add support for Java interface method calls. ++ * cp-tree.h (struct lang_type): Add java_interface flag. ++ (TYPE_JAVA_INTERFACE): New macro. ++ * tree.c (cp_valid_lang_attribute): Handle "java_interface" attribute ++ by setting TYPE_JAVA_INTERFACE. ++ * call.c (java_iface_lookup_fn): New static. ++ (build_over_call): If calling a method declared in a ++ TYPE_JAVA_INTERFACE, call build_java_interface_fn_ref to generate the ++ expression which resolves the function address. ++ (build_java_interface_fn_ref): New function. ++ ++2001-03-22 Richard Henderson ++ ++ * Make-lang.in (cp/except.o): Don't depend on insn-flags.h. ++ * except.c: Don't include it. ++ ++2001-03-22 Gerald Pfeifer ++ based on an idea from Joe Buck ++ ++ * parse.y (bad_decl, template_arg_list_ignore, arg_list_ignore): ++ New nonterminals. ++ (data_def, component_decl): Add reductions to bad_decl. ++ ++2001-03-22 Jakub Jelinek ++ ++ * method.c (do_build_assign_ref): Don't use build_modify_expr for ++ anonymous aggregates, since they don't have assignment operator ++ method. ++ * decl.c (fixup_anonymous_aggr): Disallow ctors, dtors and copy ++ assignment operators for anonymous structure fields. ++ ++2001-03-21 Jason Merrill ++ ++ * pt.c (instantiate_decl): Abort if we see a member constant ++ instantiation that doesn't already have its initializer. ++ Downgrade explicit instantiation without definition to pedwarn. ++ ++ * cp-tree.h (DECL_TINFO_FN_P, SET_DECL_TINFO_FN_P): Remove. ++ * class.c (build_vtable_entry): Don't check DECL_TINFO_FN_P. ++ (import_export_decl): Check tinfo_decl_p, not DECL_TINFO_FN_P. ++ ++ * cp-tree.h (CLASSTYPE_VTABLE_NEEDS_WRITING): Remove. ++ (pending_vtables): Remove. ++ * decl2.c (pending_vtables): Remove. ++ (import_export_vtable): Use CLASSTYPE_INTERFACE_ONLY, not ++ CLASSTYPE_VTABLE_NEEDS_WRITING. ++ (import_export_class): Likewise. ++ (init_decl2): Don't mark pending_vtables. ++ * lex.c (handle_pragma_vtable): Just sorry. ++ * pt.c (instantiate_class_template): Don't mess with ++ CLASSTYPE_VTABLE_NEEDS_WRITING. ++ (mark_class_instantiated): Likewise. ++ * ptree.c (print_lang_type): Don't print it. ++ * semantics.c (begin_class_definition): Don't set it. ++ ++ * pt.c (template_tail): Replace with last_pending_template. ++ (maybe_templates, maybe_template_tail): Remove. ++ (add_pending_template): Adjust. ++ (instantiate_pending_templates): Adjust. ++ ++ * cp-tree.h (struct saved_scope): Remove lang_stack field. ++ (current_lang_stack): Remove. ++ * decl.c (maybe_push_to_top_level): Don't initialize it. ++ (duplicate_decls): Use current_lang_depth. ++ (xref_basetypes): Likewise. ++ * class.c (current_lang_depth): New fn. ++ (push_lang_context): Use more varray functionality. ++ (pop_lang_context): Likewise. ++ ++ * error.c (GLOBAL_THING): Always use '__'. ++ ++2001-03-21 Mark Mitchell ++ ++ * class.c (build_clone): Clear DECL_ASSEMBLER_NAME. ++ ++ * mangle.c (mangle_decl_string): Mangle the names of overloaded ++ operators, even when they have `extern "C"' linkage. ++ ++2001-03-19 Mark Mitchell ++ ++ * class.c (get_vtable_decl): Use SET_DECL_ASSEMBLER_NAME, ++ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME ++ where it's not necessary. ++ (add_method): Remove optimization involving comparison of ++ DECL_ASSEMBLER_NAME. ++ (build_vtbl_or_vbase_field): Use SET_DECL_ASSEMBLER_NAME, ++ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME ++ where it's not necessary. ++ (check_methods): Likewise. ++ (build_clone): Likewise. ++ (built_vtt): Likewise. ++ * cp-tree.h (DECL_NEEDED_P): Likewise. ++ * decl.c (pushtag): Likewise. ++ (duplicate_decls): Likewise. ++ (pushdecl): Likewise. ++ (builtin_function): Likewise. ++ (build_library_fn_1): Set DECL_LANGUAGE for library functions. ++ (build_cp_library_fn): Likewise. ++ (maybe_commonize_var): Use SET_DECL_ASSEMBLER_NAME, ++ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME ++ where it's not necessary. ++ (make_rtl_for_nonlocal_decl): Likewise. ++ (cp_finish_decl): Likewise. ++ (grokfndecl): Likewise. ++ (grokvardecl): Likewise. ++ (grokdeclarator): Likewise. ++ (start_function): Likewise. ++ (cp_missing_return_ok_p): Likewise. ++ * decl2.c (grokclassfn): Likewise. ++ (check_classfn): Likewise. ++ (finish_static_data_member_decl): Likewise. ++ (grokfield): Likewise. ++ * error.c (GLOBAL_IORD_P): Remove. ++ (dump_global_iord): Improve output. ++ (dump_decl): Avoid using DECL_ASSEMBLER_NAME. ++ * except.c (nothrow_libfn_p): Summarily reject any function not in ++ namespace-scope. ++ * init.c (build_java_class_ref): Don't explicitly set ++ DECL_ASSEMBLER_NAME after calling mangle_decl. ++ * mangle.c (mangle_decl_string): Handle extern "C" functions. ++ (mangle_decl): Set the DECL_ASSEMBLER_NAME for the decl. ++ * method.c (set_mangled_name_for_decl): Don't explicitly set ++ DECL_ASSEMBLER_NAME after calling mangle_decl. ++ (make_thunk): Explicitly set the DECL_ASSEMBLER_NAME and ++ IDENTIFIER_GLOBAL_VALUE for the thunk. ++ * pt.c (set_mangled_name_for_template_decl): Remove. ++ (check_explicit_specialization): Don't use it. ++ (looup_template_class): Don't set DECL_ASSEMBLER_NAME. ++ (tsubst_friend_function): Likewise. ++ (tsubst_decl): Likewise. ++ (regenerate_decl_from_template): Use COPY_DECL_ASSEMBLER_NAME. ++ * rtti.c (get_tinfo_decl): Use SET_DECL_ASSEMBLER_NAME, ++ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME ++ where it's not necessary. ++ (tinfo_base_init): Likewise. ++ (create_real_tinfo_var): Likewise. ++ * search.c (looup_field_1): Likewise. ++ * semantics.c (finish_named_return_value): Likewise. ++ * tree.c (init_tree): Set lang_set_decl_assembler_name. ++ ++2001-03-15 Gabriel Dos Reis ++ ++ Correct semantics restrictions checking in throw-expression. ++ * except.c (is_admissible_throw_operand): New function. ++ (build_throw): Use it. ++ ++2001-03-14 Mark Mitchell ++ ++ * decl.c (cp_make_fnname_decl): Set DECL_IGNORED_P on __FUNCTION__ ++ and its ilk. ++ ++2001-03-14 Mark Mitchell ++ ++ * class.c (build_clone): Use COPY_DECL_RTL, DECL_RTL_SET_P, etc. ++ * cp-tree.h (DECL_IN_MEMORY_P): Likewise. ++ * decl.c (duplicate_decls): Likewise. ++ (builtin_function): Likewise. ++ (build_library_fn): Likewise. ++ (build_cp_library_fn): Likewise. ++ (check_initializer): Likewise. ++ (cp_finish_decl): Likewise. ++ * decl2.c (grokfield): Likewise. ++ (grok_function_init): Remove #if 0'd code. ++ (finish_anon_union): Use COPY_DECL_RTL, DECL_RTL_SET_P, etc. ++ * friend.c (do_friend): Likewise. ++ * init.c (get_temp_regvar): Likewise. ++ * method.c (make_thunk): Likewise. ++ * pt.c (tsubst_friend_function): Likewise. ++ (tsubst_decl): Likewise. ++ (regenerate_decl_from_template): Likewise. ++ * semantics.c (genrtl_named_return_value): Likewise. ++ (expand_body): Likewise. ++ (genrtl_finish_function): Likewise. ++ * tree.c (cp_tree_equal): Likewise. ++ ++2001-03-12 Nathan Sidwell ++ ++ * call.c (convert_like_real): Add extra semantics to INNER ++ parameter. Don't convert to temporary if a user conversion ++ gives us an lvalue that we're about to bind to a reference. ++ Set INNER to indicate pending reference binding on recursive ++ calls. ++ ++2001-03-10 Neil Booth ++ ++ * cp/lex.c: Delete duplicate pending_lang_change. ++ ++2001-03-10 Neil Booth ++ ++ * cp/lex.c (handle_pragma_interface, handle_pragma_implementation): ++ Similarly. ++ * cp/repo.c (get_base_filename, open_repo_file): Similarly. ++ * cp/cp-tree.h: Remove file_name_nondirectory prototype. ++ ++2001-03-09 Zack Weinberg ++ ++ * Make-lang.in: Add dependencies on $(TM_P_H) as appropriate. ++ ++2001-03-08 Stan Shebs ++ ++ * cp-tree.h (set_identifier_local_value): Remove unused decl. ++ ++2001-03-06 Zack Weinberg ++ ++ * spew.c: Remove references to CPP_OSTRING. ++ ++2001-03-06 Andrew Haley ++ ++ * typeck.c (convert_arguments): Check that we have an fndecl. ++ ++2001-03-05 Andrew Haley ++ ++ * typeck.c (convert_arguments): Don't do ellipsis conversion for ++ __built_in_constant_p. ++ ++2001-03-02 Nathan Sidwell ++ ++ * typeck.c (build_static_cast): Allow enum to enum conversions ++ as per DR 128. ++ ++2001-03-02 Nathan Sidwell ++ ++ * class.c (check_field_decls): Pointers to member do not a ++ non-pod struct make, as per DR 148. ++ ++2001-03-02 Nathan Sidwell ++ ++ * call.c (joust): cp_pedwarn when using gnu extension concerning ++ worst conversion sequences. ++ ++2001-03-01 Zack Weinberg ++ ++ * decl.c: Replace all uses of 'boolean' with 'bool'. ++ ++2001-03-01 Zack Weinberg ++ ++ * lang-specs.h: Add zero initializer for cpp_spec field to ++ all array elements that need one. Don't put an #ifdef inside ++ the initializer list; set a default for CPLUSPLUS_CPP_SPEC and ++ use it. ++ ++2001-03-01 Nathan Sidwell ++ ++ Implement using decls inside template functions. ++ * decl2.c (validate_nonmember_using_decl): Don't special case ++ fake_std_node in the global namespace. Don't reject early when ++ processing a template. ++ (do_local_using_decl): Add to statement tree. Don't do further ++ processing when building a template. ++ * pt.c (tsubst_expr, DECL_STMT case): Deal with USING_DECLs. ++ ++2001-03-01 Nathan Sidwell ++ ++ * decl2.c (do_nonmember_using_decl): Don't complain if we find ++ same function. Do complain about ambiguating extern "C" ++ declarations. ++ ++2001-02-28 Nathan Sidwell ++ ++ Remove floating point and complex type template constant parms. ++ * pt.c (convert_nontype_argument): Remove REAL_TYPE and ++ COMPLEX_TYPE extensions. ++ (invalid_nontype_parm_type_p): Likewise. ++ ++2001-02-27 Jeffrey Oldham ++ ++ * except.c (call_eh_info): Revert "match_function"'s type. ++ ++2001-02-27 Nathan Sidwell ++ ++ Fix ctor vtable vcall offsets. ++ * class.c (struct vtbl_init_data_s): Add rtti_binfo member. ++ (build_rtt_vtbl_entries): Lose RTTI_BINFO parameter. ++ (get_matching_base): Remove. ++ (get_original_base): New function. ++ (build_vtbl_initializer): Initialize vid.rtti_binfo. ++ Use a virtual thunk for a ctor vtable with an index ++ (add_vcall_offset_vtbl_entries_1): Check if binfo has lost a ++ primary base within a constructor vtable. Only set ++ BV_VCALL_INDEX when not a constructor vtable. Adjust vcall offset ++ when primary base has been lost. ++ * cp-tree.h (BINFO_VIRTUALS): Remove ambiguity from comment. ++ ++2001-02-26 Jeffrey Oldham ++ ++ * call.c (joust): Ensure more_specialized()'s argument length ++ parameter has correct value for constructors. ++ ++2001-02-26 Nathan Sidwell ++ ++ * except.c (call_eh_info): Cleanup generation of cp_eh_info struct. ++ ++ * decl.c (mark_inlined_fns): Prototype. ++ ++2001-02-22 Mark Mitchell ++ ++ * spew.c (yylex): Correct handling of friends. ++ ++2001-02-22 Mark Mitchell ++ ++ * mangle.c (write_encoding): Pass write_function_type the ++ FUNCTION_DECL for the function being encoded. ++ (write_function_type): Pass it along to write_bare_function_type. ++ (write_bare_function_type): Pass it along to write_method_parms. ++ (write_method_parms): Don't mangle the compiler-generated ++ parameters to a constructor or destructor. ++ ++2001-02-22 Andreas Jaeger ++ ++ * optimize.c: Include toplev.h for ++ note_deferral_of_defined_inline_function prototype. ++ ++2001-02-22 Jakub Jelinek ++ ++ * cp-tree.h (struct lang_decl_inlined_fns): New. ++ (struct lang_decls): Add inlined_fns. ++ (DECL_INLINED_FNS): New macro. ++ * optimize.c (struct inline_data): Add inlined_fns. ++ (declare_return_variable): Use VARRAY_ACTIVE_SIZE macro. ++ (inlinable_function_p): Likewise, fix typo in comment, ++ function is not inlinable if it already inlined function currently ++ being optimized. ++ (expand_call_inline): Add fn to inlined_fns if necessary. ++ (optimize_function): Initialize inlined_fns. ++ Save inlined_fns into DECL_INLINED_FNS after expanding inlines. ++ * decl.c (mark_inlined_fns): New function. ++ (lang_mark_tree): Call it. ++ ++2001-02-21 Jason Merrill ++ ++ * cp-tree.h (struct lang_decl_flags): Remove uninlinable flag. ++ (DECL_UNINLINABLE): Move to middle-end. ++ ++ * class.c (clone_function_decl): Set DECL_ABSTRACT on original fn. ++ * decl.c (duplicate_decls): Preserve DECL_ABSTRACT. ++ * class.c (build_clone): Set DECL_ABSTRACT_ORIGIN for the clone. ++ * optimize.c (maybe_clone_body): Set DECL_ABSTRACT_ORIGIN for the ++ parms and outer BLOCK. note_deferral_of_defined_inline_function. ++ ++ * method.c (implicitly_declare_fn): Don't set DECL_ARTIFICIAL on ++ second parm of op=. ++ ++2001-02-19 Mark Mitchell ++ ++ * decl2.c (set_decl_namespace): Allow explicit instantiations in ++ any namespace. ++ ++2001-02-18 Kriang Lerdsuwanakij ++ ++ * optimize.c (expand_call_inline): Don't walk subtrees of type ++ nodes. ++ ++2001-02-18 Mark Mitchell ++ ++ * class.c (add_vcall_offset_vtbl_entries_1): Only add one entry ++ for a destructor. ++ ++2001-02-18 Jason Merrill ++ ++ Do put the VTT parameter in DECL_ARGUMENTS. ++ * cp-tree.h (struct cp_language_function): Add x_vtt_parm. ++ (current_vtt_parm): New macro. ++ (struct lang_decl_flags): Add has_vtt_parm_p, remove vtt_parm. ++ (DECL_HAS_VTT_PARM_P): New macro. ++ (DECL_VTT_PARM): Remove. ++ (FUNCTION_FIRST_USER_PARMTYPE, FUNCTION_FIRST_USER_PARM): New macros. ++ * decl.c (duplicate_decls): Only copy the operator code if ++ appropriate. ++ (start_function): Set current_vtt_parm. ++ (lang_mark_tree): Don't mark vtt_parm. ++ * decl2.c (maybe_retrofit_in_chrg): Do add the VTT parm to ++ DECL_ARGUMENTS. Set DECL_HAS_VTT_PARM_P. ++ * class.c (build_clone): Maybe remove the VTT parm. ++ * optimize.c (maybe_clone_body): Set up the VTT parm. ++ * pt.c (copy_default_args_to_explicit_spec): Preserve the VTT parm. ++ * call.c (build_over_call): Just allow the VTT arg. ++ * method.c (make_thunk): Don't set DECL_VTT_PARM. ++ (do_build_copy_constructor): Use FUNCTION_FIRST_USER_PARM. ++ (synthesize_method): Use FUNCTION_FIRST_USER_PARMTYPE. ++ * decl.c (grokdeclarator, copy_args_p, grok_ctor_properties): Likewise. ++ * error.c (dump_function_decl): Likewise. ++ * call.c (build_user_type_conversion_1, convert_like_real): Abort ++ if we try to call a constructor with in-charge or VTT parms. ++ * method.c (skip_artificial_parms_for): New fn. ++ * call.c (add_function_candidate, build_over_call): Call it. ++ * call.c (build_new_method_call): Use current_vtt_parm. ++ * init.c (expand_virtual_init): Likewise. ++ * class.c (same_signature_p): No longer static. ++ * cp-tree.h: Declare it. ++ * search.c (look_for_overrides_r): Use it. ++ ++2001-02-17 Mark Mitchell ++ ++ * cp-tree.h (new_abi_rtti_p): Remove. ++ (name_mangling_version): Likewise. ++ (flag_do_squangling): Likewise. ++ * class.c (build_rtti_vtbl_entries): Remove old ABI support. ++ * decl.c (grokfndecl): Likewise. ++ * decl2.c (name_mangling_version): Remove. ++ (flag_do_squangling): Likewise. ++ (lang_f_options): Remove `squangle'. ++ (unsupported_options): Add `squangle'. ++ (cxx_decode_option): Issue a warning about uses of ++ -fname-mangling-version. ++ (finish_file): Remove old ABI support. ++ * pt.c (check_explicit_specialization): Likewise. ++ (tsubst_decl): Likewise. ++ * rtti.c (init_rtti_processing): Likewise. ++ (build_headof): Likewise. ++ (get_tinfo_decl_dynamic): Likewise. ++ (tinfo_from_decl): Likewise. ++ (build_dynamic_cast_1): Likewise. ++ (synthesize_tinfo_var): Likewise. ++ * init.c (build_new): Allow enumeration types for the array-bounds ++ in a direct-new-declarator. ++ ++ * semantics.c (finish_typeof): Resolve OFFSET_REFs. ++ ++ * pt.c (check_explicit_specialization): Copy TREE_PRIVATE and ++ TREE_PROTECTED from the template being specialized. ++ ++2001-02-17 Jason Merrill ++ ++ * decl2.c (build_artificial_parm): Set TREE_READONLY. ++ ++ * decl.c (bad_specifiers): Allow throw specs on things with ++ pointer-to-function or -member-function type. ++ * init.c (build_default_init): Don't use a CONSTRUCTOR to initialize ++ a pmf. ++ ++2001-02-17 Mark Mitchell ++ ++ * call.c (check_dtor_name): Handle template names correctly. ++ ++2001-02-16 Jason Merrill ++ ++ * cp-tree.h (DECL_USE_VTT_PARM): Remove. ++ * decl2.c (maybe_retrofit_in_chrg): Don't create it. ++ * optimize.c (maybe_clone_body): Don't substitute it. ++ * call.c (build_new_method_call): Check in_chrg instead. ++ * init.c (expand_virtual_init): Likewise. ++ ++2001-02-16 Gabriel Dos Reis ++ ++ * decl.c (check_tag_decl): Make sure a typedef for an anonymous ++ class-type introduces at least a type-name. ++ ++2001-02-16 Jakub Jelinek ++ ++ * call.c (convert_like_real): Create a temporary for non-lvalue. ++ ++2001-02-16 Jeffrey Oldham ++ ++ * cp-tree.h: Fix typos in comments. ++ ++2001-02-16 Jason Merrill ++ ++ * optimize.c (remap_block): If we're compiling a clone, pass the ++ new block to insert_block. ++ ++2001-02-16 Mark Mitchell ++ ++ * semantics.c (finish_asm_stmt): Robustify. ++ ++2001-02-15 Mark Mitchell ++ ++ * pt.c (push_template_decl_real): Don't remangle the name of a ++ class template. ++ ++2001-02-15 Jim Meyering ++ ++ * Make-lang.in (c++.install-common): Depend on installdirs. ++ (c++.install-info): Likewise. ++ (c++.install-man): Likewise. ++ ++2001-02-15 Mark Mitchell ++ ++ * typeck2.c (build_m_component_ref): Robustify. ++ ++2001-02-15 Alexandre Oliva ++ ++ * friend.c (do_friend): Don't take the nested [template] class ++ into account when deciding whether to warn about the friend ++ function not referring to a template function. ++ ++2001-02-14 Jakub Jelinek ++ ++ * typeck.c (build_unary_op): Clarify error message. ++ ++2001-02-08 Aldy Hernandez ++ ++ * parse.y (component_constructor_declarator): allow optional ++ parentheses around constructor class name. ++ ++2001-02-14 Nathan Sidwell ++ ++ * cp-tree.h (setup_vtbl_ptr): Move prototype to semantics.c ++ section. ++ * init.c (emit_base_init): Remove incorrect comment about ++ virtual bases. ++ * method.c (make_thunk): Fix comment alignment. ++ ++2001-02-14 Nathan Sidwell ++ ++ Kill remnants of this is variable. ++ * cp-tree.h (flag_this_is_variable): Remove. ++ * decl2.c (flag_this_is_variable): Remove. ++ * class.c (fixed_type_or_null): Add cdtor parm. Adjust. ++ (build_vbase_path): The path is non-static, even in a cdtor. ++ (resolves_to_fixed_type_p): Add additional return value. ++ * search.c (init_vbase_pointers): Adjust. ++ * tree.c (lvalue_p_1): Adjust. ++ * typeck.c (mark_addressable): Adjust. ++ ++2001-02-14 Nathan Sidwell ++ ++ * pt.c (unify): Don't check cv quals of array types. ++ ++2001-02-14 Nathan Sidwell ++ ++ * tree.c (cp_build_qualified_type_real): Use CP_TYPE_QUALS to ++ check whether we already have the type. ++ ++2001-02-13 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_DESTRUCTORS): Fix typo in comment. ++ * call.c (build_op_delete_call): Simplify to remove duplicate ++ code. ++ * class.c (clone_function_decl): Don't build the deleting variant ++ of a non-virtual destructor. ++ * decl.c (finish_destructor_body): Don't call delete if this is a ++ non-virtual destructor. ++ * init.c (build_delete): Explicitly call `operator delete' when ++ deleting an object with a non-virtual destructor. ++ ++2001-02-13 Jason Merrill ++ ++ * lang-specs.h: Add more __EXCEPTIONS. ++ ++2001-02-12 Nathan Sidwell ++ ++ * typeck2.c (process_init_constructor): Check ++ TREE_HAS_CONSTRUCTOR before issuing missing init warning. ++ ++2001-02-12 Nathan Sidwell ++ ++ * pt.c (maybe_adjust_types_for_deduction, DEDUCE_ORDER case): ++ Remove spurious information in comment. Allow further ++ adjustments of REFERENCE_TYPE args. ++ ++2001-02-12 Nathan Sidwell ++ ++ * errfn.c (cp_deprecated): Tweak diagnostic text. ++ * parse.y (new_initializer): Deprecate initializer lists ++ extension. ++ ++2001-02-12 Mark Mitchell ++ ++ Remove old ABI support. ++ ++2001-02-11 Mark Mitchell ++ ++ * decl2.c (flag_vtable_thunks): Always set it to 1. ++ (flag_new_abi): Likewise. ++ * lang-specs.h: Remove conditional on ENABLE_NEW_GXX_ABI. ++ ++ * Makefile.in (g++spec.o): Fix typo. ++ ++2001-02-09 Jason Merrill ++ ++ * lang-specs.h: Restore definition of __EXCEPTIONS. ++ ++2001-02-08 Jason Merrill ++ ++ * search.c (shared_member_p): New function. ++ (lookup_field_r): Use it. ++ * cp-tree.h (SHARED_MEMBER_P): Remove. ++ ++ * method.c (process_overload_item): Handle template-dependent array ++ bounds. ++ * pt.c (type_unification_real): If we end up with undeduced nontype ++ parms, try again. ++ ++ * decl.c (lookup_name_real): Tweak warning to refer to decls, not ++ types. ++ ++ * typeck2.c (friendly_abort): Don't say anything if we have ++ earlier errors or sorries. ++ ++ * decl.c (check_tag_decl): Notice attempts to redefine bool and ++ wchar_t. Ignore if in_system_header. ++ ++ * decl.c (maybe_push_cleanup_level): New fn... ++ (start_decl_1): ...split out from here. ++ * cvt.c (build_up_reference): Use it. ++ * cp-tree.h: Declare it. ++ ++2001-02-07 Mark Mitchell ++ ++ * lang-specs.h: Use CPLUSPLUS_CPP_SPEC for the preprocessor ++ spec. ++ ++2001-02-06 Nathan Sidwell ++ ++ * pt.c (lookup_template_class): Make sure it's a primary ++ template or template_template_parm when called from the parser. ++ (instantiate_template_class): Add assertion. ++ ++2001-02-05 Alexandre Oliva ++ ++ * method.c (build_mangled_name) [old abi]: Protect flush_repeats() ++ from error_mark_node. ++ ++2001-02-05 Nathan Sidwell ++ ++ Fix specification and implementation bugs in V3 ABI ++ construction vtables. ++ * cp-tree.h (flag_dump_class_layout): New flag. ++ (BINFO_OVERRIDE_ALONG_VIRTUAL_PATH_P): Remove. ++ (BINFO_LOST_PRIMARY_P): New flag. ++ (SET_BINFO_NEW_VTABLE_MARKED): Adjust asserts. ++ (BINFO_PRIMARY_MARKED_P): Rename to ... ++ (BINFO_PRIMARY_P): ... here. ++ (binfo_via_virtual): New prototype. ++ * decl2.c (flag_dump_class_layout): New flag. ++ (cxx_decode_option): Set it. Adjust -fdump-translation-unit to ++ use `=' as a file name separator. ++ * init.c (dfs_initialize_vtbl_ptrs): Walk into virtual primary ++ bases. ++ (build_vtbl_address): If this is a virtual primary base, then ++ get the vtbl of what it is ultimately primary for. ++ * search.c (dfs_skip_nonprimary_vbases_unmarkedp): Adjust ++ for BINFO_PRIMARY_P. ++ (dfs_skip_nonprimary_vbases_markedp): Likewise. ++ (get_shared_vbase_if_not_primary): Likewise. ++ (dfs_get_pure_virtuals): Likewise. ++ (expand_upcast_fixups): Likewise. ++ (fixup_virtual_upcast_offsets): Likewise. ++ (dfs_find_vbase_instance): Likewise. ++ (find_vbase_instance): Likewise. ++ (binfo_from_vbase): Adjust comment to reflect reality. ++ (binfo_via_virtual): New function. ++ * class.c (VTT_TOP_LEVEL_P, VTT_MARKED_BINFO_P): New macros ++ for binfo walking during VTT construction. ++ (dfs_mark_primary_bases): Remove. ++ (force_canonical_binfo_r): New function. ++ (force_canonical_binfo): New function. ++ (mark_primary_virtual_base): New function. ++ (mark_primary_bases): Walk in inheritance graph order, use ++ mark_primary_virtual_base. ++ (determine_primary_base): Use some more intermediate variables. ++ (dfs_find_final_overrider): Don't check for overriding along a ++ virtual path. ++ (dfs_modify_vtables): Walk into primary virtual bases too. ++ (walk_subobject_offsets): Adjust for BINFO_PRIMARY_P. ++ (build_base_fields): Likewise. ++ (dfs_set_offset_for_unshared_vbases): Likewise. ++ (layout_virtual_bases): Likewise. ++ (end_of_class): Likewise. ++ (finish_struct_1): Call dump_class_hierarchy, if requested. ++ (dfs_get_primary_binfo): Use BINFO_TYPE for binfos. ++ (dump_class_hierarchy_r): Add stream parameter. Emit more information. ++ (dump_class_hierarchy): Add file parameter. Append to file, if ++ required. ++ (finish_vtbls): Adjust accumulate_vtbl_inits call. ++ Use canonical base for virtual bases. ++ (build_vtt): Add more comments. Adjust build_vtt_inits call. ++ (build_vtt_inits): Remove VIRTUAL_VTTS_P parm. ++ Only set BINFO_VPTR_INDEX on top level. Use VTT_TOP_LEVEL_P, ++ VTT_MARKED_BINFO_P for binfo walking. Use canonical vbase for ++ virtual VTTs. ++ (dfs_build_secondary_vptr_vtt_inits): Extract VTT_TOP_LEVEL_P ++ from DATA. We want virtual primary bases and all bases via virtual. ++ Only set BINFO_VPTR_INDEX for top level. Look up from a primary ++ virtual base when not a construction vtable. ++ (dfs_ctor_vtable_bases_queue_p): New DFS predicate. ++ (build_ctor_vtbl_group): Adjust accumulate_vtbl_inits call. ++ Use canonical bases when processing virtual bases. ++ (accumulate_vtbl_inits): We're interested in any base via a ++ virtual path. ++ (dfs_accumulate_vtbl_inits): If this is a primary virtual base ++ within a construction vtable, determine what is being overridden. ++ (build_vtbl_initializer): Add more comments ++ (add_vcall_offset_vtbl_entries_1): Adjust comment. ++ (build_rtti_vtbl_entries): Check if the base has lost its ++ primary. ++ ++2001-02-05 Mark Mitchell ++ ++ * Makefile.in (g++spec.o): Adjust use of DRIVER_DEFINES. ++ ++2001-02-04 Richard Kenner ++ ++ * decl.c (pushdecl): Call abort instead of fatal. ++ * except.c (decl_is_java_type): Call fatal_error instead of fatal. ++ * init.c (build_new_1): Likewise. ++ (build_java_class_ref): Call internal_error and fatal_error, not fatal. ++ * decl.c (build_typename_type): hash_table_init now returns void. ++ decl.c (init_decl_processing): Make an error non-fatal. ++ ++2001-02-04 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_INTERFACE_UNKNOWN): Fix formatting. ++ Document. ++ (CLASSTYPE_INTERFACE_KNOWN): Likewise. ++ (SET_CLASSTYPE_INTERFACE_UNKNOWN_X): Likewise. ++ (SET_CLASSTYPE_INTERFACE_UNKNOWN): Likewise. ++ (SET_CLASSTYPE_INTERFACE_KNOWN): Likewise. ++ * decl.c (maybe_commonize_var): Use the new name-mangling where ++ appropriate. ++ * decl2.c (comdat_linkage): Enhance comments. Make all ++ compiler-generated things static, if COMDAT is not available. ++ (get_tinfo_decl): Do not make typeinfo objects that belong in the ++ library COMDAT. ++ (tinfo_base_init): Use the correct mangled name for typeinfo ++ strings, and push them into the global scope. ++ (typeinfo_in_lib_p): New function. ++ (synthesize_tinfo_var): Use it. ++ (create_real_tinfo_var): Likewise. ++ ++2001-02-03 Jakub Jelinek ++ ++ * decl.c (push_class_binding): Use context_for_name_lookup instead ++ of CP_DECL_CONTEXT. ++ * search.c (context_for_name_lookup): Remove static. Check for NULL ++ context in the loop. ++ * cp-tree.h (context_for_name_lookup): Add prototype. ++ ++2001-02-02 Jakub Jelinek ++ ++ * cp-tree.h (build_expr_ptr_wrapper, can_free): Remove. ++ * tree.c (build_expr_ptr_wrapper, can_free, permanent_obstack): ++ Remove. ++ * call.c (convert_class_to_reference, build_user_type_conversion_1, ++ add_warning): Change build_expr_ptr_wrapper to build_ptr_wrapper. ++ ++2001-02-02 Mark Mitchell ++ ++ * Make-lang.in (g++spec.o): Add DRIVER_DEFINES to the list ++ of macros used when compiling g++spec.c. ++ * g++spec.c (lang_specific_driver): Link with the shared ++ libgcc by default. ++ ++2001-01-29 Joseph S. Myers ++ ++ * decl2.c (build_expr_from_tree), lex.c (make_pointer_declarator, ++ make_reference_declarator, make_call_declarator), method.c ++ (implicitly_declare_fn), parse.y (namespace_using_decl, ++ notype_unqualified_id, expr_or_declarator, new_type_id, ++ after_type_declarator, direct_after_type_declarator, ++ notype_declarator, complex_notype_declarator, ++ complex_direct_notype_declarator, qualified_id, ++ notype_qualified_id, overqualified_id, direct_new_declarator, ++ absdcl, direct_abstract_declarator, conversion_declarator), pt.c ++ (tsubst), semantics.c (begin_constructor_declarator): Use build_nt ++ instead of build_parse_node. ++ ++2001-01-28 Kaveh R. Ghazi ++ ++ * cp-tree.h (cp_tree_index): Delete CPTI_MINUS_ONE. ++ (minus_one_node): Moved to top level gcc directory. Renamed ++ to integer_minus_one_node. ++ ++ * init.c (init_init_processing): Don't set minus_one_node. ++ (build_vec_init): Use integer_minus_one_node. ++ ++ * rtti.c (get_tinfo_decl_dynamic): Likewise. ++ ++2001-01-28 Jakub Jelinek ++ ++ * optimize.c (copy_body_r): If MODIFY_EXPR has both arguments ++ identical and they would be replaced with constant, remove ++ MODIFY_EXPR from the tree. ++ ++2001-01-27 Kaveh R. Ghazi ++ ++ * Make-lang.in: Remove all dependencies on defaults.h. ++ * call.c: Don't include defaults.h. ++ * decl.c: Likewise. ++ * decl2.c: Likewise. ++ * except.c: Likewise. ++ * pt.c: Likewise. ++ * rtti.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ ++2001-01-25 Jakub Jelinek ++ ++ * mangle.c (write_mangled_name, write_encoding): Mangle overloaded ++ operators even in "C" linkage. ++ * method.c (set_mangled_name_for_decl): Likewise. ++ * decl.c (grokfndecl): Call set_mangled_name_for_decl even for ++ overloaded operators in "C" linkage. ++ ++2001-01-24 Nathan Sidwell ++ ++ * pt.c (tsubst_decl): Remove IN_DECL parameter. ++ (tsubst_arg_types): Check parameter is not void. ++ (tsubst): Adjust tsubst_decl call. ++ ++2001-01-24 Nathan Sidwell ++ ++ * call.c (add_builtin_candidate): Quote std properly, from ++ previous change. ++ ++2001-01-23 Kriang Lerdsuwanakij ++ ++ * pt.c (check_explicit_specialization): Clone constructors and ++ destructors. ++ ++2001-01-23 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Don't presume DECL_LANG_SPECIFIC ++ indicates anything special about template depth. Make sure we ++ only count the user visible template classes. ++ ++2001-01-23 Nathan Sidwell ++ ++ * call.c (build_conv): Typo in comment. ++ (add_builtin_candidate): Add more explanation. ++ Remove extra test for ENUMERAL_TYPE in {PRE,POST}INCREMENT_EXPR. ++ Allow ENUMERAL_TYPEs for relops and eqops. Add both candidates ++ when we have enumeral types. ++ (add_builtin_candidates): Add more explanation. Add ENUMERAL_TYPE ++ candidates for relops and eqops. ++ (joust): Simplify control flow. Allow a non-template user ++ function to hide a builtin. ++ ++2001-01-22 Nathan Sidwell ++ ++ * cp-tree.h (unification_kind_t): Add DEDUCE_ORDER. ++ (more_specialized): Add deduction parameter. ++ * call.c (joust): Adjust more_specialized call. ++ * pt.c (UNIFY_ALLOW_OUTER_MORE_CV_QUAL, ++ UNIFY_ALLOW_OUTER_LESS_CV_QUAL): New unify flags. ++ (get_bindings_order): Remove. ++ (get_bindings_real): Add DEDUCE parameter. ++ (maybe_adjust_types_for_deduction): Return extra unify flags. Do ++ REFERENCE_TYPE jig for DEDUCE_ORDER. ++ (type_unification_real): Deal with DEDUCE_ORDER. Use result of ++ maybe_adjust_types_for_deduction. ++ (more_specialized): Add DEDUCE parameter. Call get_bindings_real ++ directly. ++ (try_one_overload): Use result of maybe_adjust_types_for_deduction. ++ (check_cv_quals_for_unify): Use new unify qualifier flags. ++ (unify): Clear new unify qualifier flags. ++ (get_bindings_real): Add DEDUCE parameter. ++ (get_bindings): Adjust call to get_bindings_real. ++ (get_bindings_overload): Likewise. ++ (most_specialized_instantiation): Adjust call to ++ more_specialized. ++ ++2001-01-19 Jason Merrill ++ ++ * decl2.c (flag_vtable_thunks): Also depend on ENABLE_NEW_GXX_ABI. ++ ++ * decl.c (init_decl_processing): Just force -fvtable-thunks on if ++ -fnew-abi. ++ ++2001-01-19 Ute Pelkmann ++ ++ * decl2.c (arg_assoc_class): Fix double iteration logic. ++ ++2001-01-19 Jason Merrill ++ ++ * init.c (build_delete): Always call convert_force to strip cv-quals. ++ ++ * decl2.c (flag_new_abi): Depend on ENABLE_NEW_GXX_ABI. ++ * lang-specs.h: Default ABI depends on ENABLE_NEW_GXX_ABI. ++ * g++spec.c: Don't look at ENABLE_NEW_GXX_ABI. ++ ++2001-01-19 Nathan Sidwell ++ ++ * search.c (get_vbase_1): Count only virtual bases. ++ ++2001-01-19 Nathan Sidwell ++ ++ * class.c (duplicate_tag_error): Robustify flag clearing. ++ ++2001-01-19 Nathan Sidwell ++ ++ * cp-tree.h (lookup_template_class): Add complain parm. ++ * decl.c (lookup_namespace_name): Adjust call to ++ lookup_template_class. ++ (make_typename_type): Likewise. ++ * semantics.c (finish_template_type): Likewise. ++ * pt.c (lookup_template_class): Add complain parm. Adjust. ++ (tsubst_aggr_type): Pass COMPLAIN down to lookup_template_class. ++ (tsubst): Likewise. ++ ++2001-01-19 Nathan Sidwell ++ ++ * pt.c (copy_default_args_to_explicit_spec): Preserve ++ object's CV quals. Reorganize. ++ ++2001-01-18 Nathan Sidwell ++ ++ * typeck.c (build_modify_expr): Say `initialization' for ++ INIT_EXPRs. ++ * init.c (build_default_init): Convert to enumeral type, if ++ needed. ++ ++2001-01-18 Jakub Jelinek ++ ++ * parse.y (nomods_initdcl0): Properly set things up for ++ initdcl0_innards. ++ ++2001-01-18 Nathan Sidwell ++ ++ * pt.c (UNIFY_ALLOW_OUTER_LEVEL): New unify flag. ++ (type_unification_real): Set it. ++ (unify): Use it. ++ ++2001-01-18 Nathan Sidwell ++ ++ * decl.c (finish_destructor_body): Convert to vbase pointer here. ++ ++2001-01-18 Nathan Sidwell ++ ++ * semantics.c (begin_class_definition): Check we're not inside a ++ template parm list. ++ ++2001-01-18 Nathan Sidwell ++ ++ * tree.c (walk_tree, TREE_LIST): Don't walk the TREE_PURPOSE of ++ BASELINK_P. ++ ++2001-01-16 Kriang Lerdsuwanakij ++ ++ * typeck.c (build_function_call_real): Call fold on the CALL_EXPR. ++ * call.c (build_over_call): Add comment. ++ ++2001-01-16 Daniel Berlin ++ ++ * cvt.c (ocp_convert): Handle vector type conversion ++ * typeck2.c (digest_init): Handle vector type initializations ++ ++2001-01-16 Phil Edwards ++ ++ * g++spec.c: Don't add libraries needlessly if -fsyntax-only ++ was given. ++ ++2001-01-15 Nathan Sidwell ++ ++ * pt.c (check_nontype_parm): Rename to ... ++ (invalid_nontype_parm_type_p): ... here. ++ (process_template_parm): Adjust. ++ (convert_template_argument): Adjust. ++ ++2001-01-15 Nathan Sidwell ++ ++ * pt.c (check_nontype_parm): New function. ++ (process_template_parm): Use it. ++ (convert_template_argument): Use it. ++ (convert_nontype_argument, RECORD_TYPE): Assert it's a ptr to ++ member. ++ ++2001-01-14 Jeffrey Oldham ++ ++ * tree.c: Add defaults.h ++ (cp_valid_lang_attribute): Incorporate SUPPORTS_INIT_PRIORITY. ++ * Make-lang.in (cp/tree.o): Add defaults.h. ++ ++2001-01-13 Joseph S. Myers ++ ++ * Make-lang.in (CXX_C_OBJS): Add c-format.o. ++ ++2001-01-13 Joseph S. Myers ++ ++ * g++.1: Change to be ".so man1/gcc.1". ++ ++2001-01-13 Joseph S. Myers ++ ++ * Make-lang.in (c++.info, c++.install-info): Build and install g++ ++ internals info. ++ (c++.uninstall, c++.maintainer-clean): Remove g++ internals info. ++ ($(srcdir)/cp/g++int.info): New target. ++ * gxxint.texi: Add info directory entry. Use @@ in email address. ++ * .cvsignore: Update. ++ ++2001-01-12 Nathan Sidwell ++ ++ * typeck.c (build_c_cast): Do template processing earlier. ++ Always pedwarn on array casts. ++ ++2001-01-12 Nathan Sidwell ++ ++ * friend.c (make_friend_class): Make sure a templated class is ++ actually a template. ++ ++2001-01-11 Nathan Sidwell ++ ++ * decl2.c (get_guard): Set linkage from guarded decl. ++ ++2001-01-11 Nathan Sidwell ++ ++ * call.c (convert_default_arg): Check for unprocessed ++ DEFAULT_ARG. ++ * cp-tree.h (replace_defarg): Move to spew.c. ++ (maybe_snarf_defarg, add_defarg_fn, do_pending_defargs): Move to ++ spew.c, which is where they really are. ++ (done_pending_defargs): Declare. ++ (unprocessed_defarg_fn): Declare. ++ * decl.c (replace_defarg): Move to spew.c ++ * parse.y (structsp): Call done_pending_defargs. ++ * spew.c (defarg_fns): Rearrange list structure. ++ (defarg_fnsdone): New static variable. ++ (defarg_depfns): New static variable. ++ (init_spew): Adjust. ++ (add_defarg_fn): Store the type in TREE_TYPE. ++ (do_pending_defargs): Detect and deal with ordering constraints ++ and circularity. ++ (done_pending_defargs): New function. ++ (unprocessed_defarg_fn): New function. ++ (replace_defarg): Moved from decl.c. Robustify. Don't save ++ if circularity detected. ++ ++2001-01-11 Nathan Sidwell ++ ++ * pt.c (unify): Check array has a domain, before checking ++ whether it is variable sized. ++ ++2001-01-11 Nathan Sidwell ++ ++ * decl.c (grokparms): Unobfuscate and get correct diagnostic for ++ parameters with pointers to arrays of unknown bound. ++ ++2001-01-11 Nathan Sidwell ++ ++ * parse.y (template_parm_header, template_spec_header): New ++ reductions. Split out from ... ++ (template_header): ... here. Use them. ++ (template_template_parm): Use template_parm_header. ++ * semantics.c (finish_template_template_parm): Add assert. ++ ++2001-01-10 Mark Mitchell ++ ++ * mangle.c (write_builtin_type): Fix thinko. ++ ++ * pt.c (copy_default_args_to_explicit_spec_1): New function. ++ (copy_default_args_to_explicit_spec): Likewise. ++ (check_explicit_specialization): Use it. ++ ++ * class.c (finish_struct_1): Remove last argument in call to ++ make_decl_rtl; use make_function_rtl instead of make_decl_rtl. ++ * decl.c (builtin_function): Likewise. ++ (build_cp_library_fn): Likewise. ++ (check_initializer): Likewise. ++ (make_rtl_for_nonlocal_decl): Likewise. ++ (cp_finish_decl): Likewise. ++ (start_function): Likewise. ++ * decl2.c (finish_anon_union): Likewise. ++ * friend.c (do_friend): Likewise. ++ * init.c (build_java_class_ref): Likewise. ++ * method.c (make_thunk): Likewise. ++ * pt.c (tsubst_friend_function): Likewise. ++ * semantics.c (expand_body): Likewise. ++ ++2001-01-10 Mark Mitchell ++ ++ * cp-tree.h (DECL_CLONED_FUNCTION_P): Avoid wild reads by not ++ looking at DECL_CLONED_FUNCTION for non-functions. ++ ++2001-01-10 Nathan Sidwell ++ ++ * error.c (dump_template_parameter): Use parm to determine how ++ to print default value. ++ ++2001-01-10 Nathan Sidwell ++ ++ * class.c (duplicate_tag_error): Clear more flags. ++ ++2001-01-10 Nathan Sidwell ++ ++ * call.c (build_new_method_call): Use binfo_for_vbase. ++ ++2001-01-10 Joseph S. Myers ++ ++ * cp-tree.h (flag_cond_mismatch): Don't declare. ++ * decl2.c (flag_cond_mismatch): Don't define. ++ (lang_f_options): Remove cond-mismatch. ++ (unsupported_options): Add cond-mismatch. ++ ++2001-01-09 Nathan Sidwell ++ ++ * class.c (handle_using_decl): Reject using of constructor name ++ of sourcing class. Allow injecting of a method with same name as ++ nested class. Fixup error messages. ++ ++2001-01-09 Joseph S. Myers ++ ++ * decl2.c (lang_decode_option): Handle -Wformat=2. ++ ++2001-01-08 Nathan Sidwell ++ ++ * cp-tree.h (lang_decl_flags): Rename defined_in_class to ++ initialized_in_class. ++ (DECL_DEFINED_IN_CLASS_P): Rename to ... ++ (DECL_INITIALIZED_IN_CLASS_P): ... here, to reflect true meaning. ++ * decl.c (duplicate_decls): Preseve DECL_INITIALIZED_IN_CLASS_P. ++ (cp_finish_decl): Adjust for DECL_INITIALIZED_IN_CLASS_P. ++ * pt.c (check_default_tmpl_args): Adjust for ++ DECL_INITIALIZED_IN_CLASS_P. ++ (instantiate_class_template): Likewise. ++ (instantiate_decl): Check DECL_INITIALIZED_IN_CLASS_P. ++ ++ * class.c (finish_struct): Constify saved_filename. ++ ++2001-01-08 Nathan Sidwell ++ ++ * class.c (duplicate_tag_error): Adjust diagnostic. ++ (finish_struct): Locally set location to start of struct. ++ * decl.c (fixup_anonymous_aggr): Use cp_error_at. ++ ++2001-01-08 Nathan Sidwell ++ ++ * decl.c (struct binding_level): Adjust class_shadowed comments ++ to reflect reality. ++ (push_class_level_binding): Adjust comments to reflect reality. ++ Set IDENTIFIER_CLASS_VALUE when replacing an existing binding. ++ Don't set TREE_VALUE on the class_shadowed list. ++ ++2001-01-07 Alexandre Petit-Bianco ++ ++ * decl2.c (acceptable_java_type): Allow references too. ++ * init.c (build_java_class_ref): When using the new ABI, search ++ `class$' and have it mangled with `mangle_decl.' ++ * mangle.c (write_java_integer_type_codes): New function. ++ (write_builtin_type): Detect and mangle Java integer and real ++ types. ++ ++2001-01-07 Mark Mitchell ++ ++ * decl2.c (grokfield): Don't accept `asm' specifiers for ++ non-static data members. ++ ++2001-01-07 Kaveh R. Ghazi ++ ++ * expr.c (cplus_expand_expr): Don't reset `target'. ++ ++2001-01-07 Neil Booth ++ ++ * cp/decl2.c (cxx_post_options): Call cpp_post_options. ++ ++2001-01-05 Nathan Sidwell ++ ++ * parse.y (template_datadef): Check for error_mark_node. ++ ++2001-01-05 Nathan Sidwell ++ ++ * cp-tree.def (DEFAULT_ARG): Make `x' class. ++ ++2001-01-04 Joseph S. Myers ++ ++ * decl.c (SIZE_TYPE, PTRDIFF_TYPE, WCHAR_TYPE): Don't define. ++ (record_builtin_type): Make non-static. ++ (flag_short_double): Don't declare. ++ (init_decl_processing): Remove the creation of many tree nodes now ++ in c_common_nodes_and_builtins. ++ (build_void_list_node): New function. ++ * decl2.c (flag_short_double, flag_short_wchar): Don't define. ++ * cp-tree.h (flag_short_wchar): Don't declare. ++ ++2001-01-04 Mark Mitchell ++ ++ * call.c (build_conv): Don't use build1 for USER_CONV. ++ * pt.c (tsubst_copy): Or for PREINCREMENT_EXPR and similar nodes. ++ ++2001-01-03 Joseph S. Myers ++ ++ * lex.c (lang_init): Call c_common_lang_init. ++ ++2001-01-03 Nathan Sidwell ++ ++ * search.c (lookup_fnfields_here): Remove. ++ (look_for_overrides_r): Use lookup_fnfields_1. ++ Ignore functions from using declarations. ++ ++2001-01-03 Nathan Sidwell ++ ++ Implement exceptions specifiers for implicit member functions. ++ * cp-tree.h (merge_exceptions_specifiers): Declare new function. ++ * method.c (synthesize_exception_spec): New function. ++ (locate_dtor, locate_ctor, locate_copy): New functions. ++ (implicitly_declare_fn): Generate the exception spec too. ++ * search.c (check_final_overrider): Check artificial functions ++ too. ++ * typeck2.c (merge_exception_specifiers): New function. ++ ++2001-01-03 Jason Merrill ++ ++ * init.c (build_default_init): New fn. ++ (perform_member_init): Split out from here. ++ (build_new_1): Use it. Simplify initialization logic. ++ (build_vec_init): Take an array, rather than a pointer and maxindex. ++ Speed up simple initializations. Don't clean up if we're assigning. ++ * cp-tree.h: Adjust. ++ * decl2.c (do_static_initialization): Remove TREE_VEC case. ++ * parse.y (new_initializer): Return void_zero_node for (). ++ * typeck.c (build_modify_expr): Handle getting a CONSTRUCTOR. ++ * typeck2.c (digest_init): Only complain about user-written ++ CONSTRUCTORs. ++ ++2000-12-22 Mike Stump ++ ++ * decl2.c: (max_tinst_depth): Increase to 50. ++ ++2001-01-02 Mark Mitchell ++ ++ * class.c (invalidate_class_lookup_cache): Zero the ++ previous_class_values. ++ * cp-tree.h (TMPL_PARMS_DEPTH): Use TREE_INT_CST_LOW, not ++ TREE_INT_CST_HIGH. ++ (CLASSTYPE_TEMPLATE_LEVEL): Likewise. ++ * decl.c (free_bindings): New variable. ++ (push_binding): Don't create a new binding if we have one on the ++ free list. ++ (pop_binding): Put old bindings on the free list. ++ (init_decl_processing): Use size_int, not build_int_2. ++ Register free_bindings as a GC root. ++ (cp_make_fname_decl): Use size_int, not build_int_2. ++ (push_inline_template_parms_recursive): Likewise. ++ (end_template_parm_list): Likewise. ++ (for_each_template_parm): Do not use walk_tree_without_duplicates. ++ (tsubst_template_parms): Use size_int, not build_int_2. ++ (tsubst): Likewise. ++ * rtti.c (get_vmi_pseudo_type_info): Likewise. ++ ++2001-01-02 Richard Henderson ++ ++ * parse.y (asm): Set ASM_INPUT_P. ++ ++2001-01-02 Jason Merrill ++ ++ * tree.c (cp_valid_lang_attribute): Don't set CLASSTYPE_COM_INTERFACE ++ for v3 ABI. ++ ++ * typeck.c (cp_truthvalue_conversion): New fn. ++ * cvt.c (ocp_convert): Use it. ++ ++ * cp-tree.h: Lose c-common.c decls. ++ ++ * typeck.c (build_unary_op): Restore old &a.f diagnostic code. ++ * cvt.c (convert_to_void): Use type_unknown_p. ++ ++ * typeck.c (strip_all_pointer_quals): Also strip quals from ++ pointer-to-member types. ++ ++ * Make-lang.in (cp/TAGS): Use --no-globals. Ignore parse.c, and treat ++ parse.y as C. ++ ++ * call.c (build_new_method_call): Do evaluate the object parameter ++ when accessing a static member. ++ * typeck.c (build_component_ref): Likewise. ++ ++2001-01-02 Andreas Jaeger ++ ++ * decl.c (cp_missing_noreturn_ok_p): New. ++ (init_decl_processing): Set lang_missing_noreturn_ok_p. ++ ++2000-12-29 Jakub Jelinek ++ ++ * decl.c (init_decl_processing): Fix sign of wchar_type_node. ++ ++2000-12-29 Mark Mitchell ++ ++ * class.c (pushclass): Remove #if 0'd code. ++ * cp-tree.h (overload_template_name): Remove. ++ * decl.c (store_bindings): Simplify. ++ (pop_from_top_level): Likewise. ++ * pt.c (overload_template_name): Remove. ++ (instantiate_decl): Don't call push_to_top_level if it's not ++ needed. ++ ++2000-12-28 Mark Mitchell ++ ++ * pt.c (register_local_specialization): Don't return a value. ++ (lookup_template_class): Use move-to-front heuristic when looking ++ up template instantiations. ++ (instantiate_decl): Only push_to_top_level when we're actually ++ going to instantiate the template. ++ ++2000-12-29 Hans-Peter Nilsson ++ ++ * search.c (binfo_for_vtable): Return least derived class, not ++ most. Handle secondary vtables. ++ ++2000-12-22 Jason Merrill ++ ++ * pt.c (more_specialized): Don't optimize len==0. ++ (fn_type_unification): If we're adding the return type, increase len. ++ ++ * typeck.c (build_binary_op): Fix pmf comparison logic. ++ ++ * call.c (joust): Use DECL_NONSTATIC_MEMBER_FUNCTION_P, not ++ DECL_STATIC_FUNCTION_P. ++ ++ * semantics.c (genrtl_finish_function): Don't try to jump to ++ return_label unless it exists. ++ ++ In partial ordering for a call, ignore parms for which we don't have ++ a real argument. ++ * call.c (joust): Pass len to more_specialized. ++ (add_template_candidate_real): Strip 'this', pass len. ++ * pt.c (more_specialized): Pass len down. Lose explicit_args parm. ++ (get_bindings_order): New fn. Pass len down. ++ (get_bindings_real): Strip 'this', pass len. ++ (fn_type_unification): Likewise. ++ (type_unification_real): Succeed after checking 'len' args. ++ (most_specialized_instantiation): Lose explicit_args parm. ++ * class.c (resolve_address_of_overloaded_function): Strip 'this', ++ pass len. ++ ++2000-12-21 Jason Merrill ++ ++ * pt.c (tsubst_decl): A FUNCTION_DECL has DECL_RESULT, not ++ DECL_TEMPLATE_RESULT. ++ ++ * search.c (lookup_field_r): Call lookup_fnfields_1, not ++ lookup_fnfields_here. ++ ++ * parse.y (typename_sub2): Return the TYPE_DECL, not the type. ++ ++ * call.c (build_object_call): Also allow conversions that return ++ reference to pointer to function. ++ (add_conv_candidate): Handle totype being ref to ptr to fn. ++ (build_field_call): Also allow members of type reference to function. ++ Lose support for calling pointer to METHOD_TYPE fields. ++ ++ * error.c (dump_expr): Handle *_CAST_EXPR. ++ ++ * typeck2.c (build_scoped_ref): Always convert to the naming class. ++ ++ * tree.c (break_out_cleanups): Lose. ++ * cp-tree.h: Remove prototype. ++ * typeck.c (build_component_ref): Don't break_out_cleanups. ++ (build_compound_expr): Likewise. ++ * semantics.c (finish_expr_stmt): Likewise. ++ ++2000-12-20 Richard Henderson ++ ++ * cp-tree.h: Update declarations. ++ * decl.c (finish_case_label): Return the new stmt node. ++ * semantics.c (finish_goto_stmt): Likewise. ++ (finish_expr_stmt, finish_return_stmt): Likewise. ++ (finish_break_stmt, finish_continue_stmt): Likewise. ++ (finish_asm_stmt): Likewise. ++ * parse.y (already_scoped_stmt): Set STMT_LINENO. ++ (compstmt, implicitly_scoped_stmt, stmt): Likewise. ++ (simple_if, simple_stmt): Return the new stmt node. ++ (save_lineno): New. ++ ++2000-12-18 Joseph S. Myers ++ ++ * cp-tree.h: Don't declare warn_long_long. ++ ++2000-12-15 Kriang Lerdsuwanakij ++ ++ * tree.c (no_linkage_helper): Use CLASS_TYPE_P instead of ++ IS_AGGR_TYPE. ++ ++2000-12-15 Kriang Lerdsuwanakij ++ ++ * pt.c (unify): Handle when both ARG and PARM are ++ BOUND_TEMPLATE_TEMPLATE_PARM. ++ ++2000-12-15 Kriang Lerdsuwanakij ++ ++ * pt.c (reduce_template_parm_level): Set DECL_ARTIFICIAL and ++ DECL_TEMPLATE_PARM_P. ++ ++2000-12-15 Jason Merrill ++ ++ * init.c (build_new_1): Reorganize. Now with 100% fewer SAVE_EXPRs! ++ ++ * init.c (build_new_1): Don't strip quals from type. ++ ++ * decl.c (pushdecl): Don't check for linkage on a non-decl. ++ ++ * call.c (build_op_delete_call): See through ARRAY_TYPEs. ++ ++ * call.c (build_new_function_call): Lose space before paren in ++ error message. ++ (build_new_method_call): Likewise. ++ ++ * typeck2.c (build_m_component_ref): Propagate quals from datum. ++ ++2000-12-14 Kriang Lerdsuwanakij ++ ++ * pt.c (check_explicit_specialization): Propagate default ++ function arguments to explicit specializations. ++ ++2000-12-13 DJ Delorie ++ ++ * typeck.c (build_binary_op): Do signed/unsigned warnings for >? ++ and ++ ++ * error.c (dump_function_name): Don't let the user see __comp_ctor. ++ ++ Clean up copy-initialization in overloading code. ++ * call.c (build_user_type_conversion_1): Die if we are asked to ++ convert to the same or a base type. ++ (implicit_conversion): Avoid doing so. Lose reference binding code. ++ (convert_like_real): Treat BASE_CONV and RVALUE_CONV as implicit ++ direct-initialization. Also do direct-init part of copy-init. ++ (build_user_type_conversion): Don't provide context to convert_like. ++ * cvt.c (ocp_convert): build_user_type_conversion will now provide ++ the constructor call for copy-init. ++ ++ * pt.c (tsubst_decl): Call clone_function_decl here if this is an ++ instantiation of a member template. ++ (do_decl_instantiation): Not here. ++ ++2000-12-07 Nathan Sidwell ++ ++ * class.c (check_field_decls): Don't special case anonymous ++ fields in error messages. ++ (note_name_declared_in_class): Use %D on diagnostic. ++ ++ * tree.c (pod_type_p): Use strip_array_types. ++ (cp_valid_lang_attribute): Likewise. ++ * typeck.c (cp_type_quals): Strip arrays separately, to avoid ++ multiple evaluations. ++ (cp_has_mutable_p): Use strip_array_types. ++ ++2000-12-07 Nathan Sidwell ++ ++ * cp-tree.h (sufficient_parms_p): Declare new function. ++ * call.c (sufficient_parms_p): New function, broken out of ... ++ (add_function_candidate): ... here. Use it. ++ (add_conv_candidate): Use it. ++ * decl.c (grok_ctor_properties): Use it. ++ ++2000-12-07 Jakub Jelinek ++ ++ * optimize.c (copy_body_r): Set STMT_IS_FULL_EXPR_P on EXPR_STMT. ++ ++2000-12-07 Joseph S. Myers ++ ++ * decl2.c (lang_decode_option): Handle -Wformat-security. ++ ++2000-12-06 Kriang Lerdsuwanakij ++ ++ * pt.c (verify_class_unification): New function. ++ (get_class_bindings): Use it. ++ (try_class_unification): Tidy. ++ (unify): Handle when argument of a template-id is not ++ template parameter dependent. ++ (template_args_equal): Handle when TREE_CODE's do not match. ++ ++2000-12-06 Alexandre Oliva ++ ++ * lang-specs.h (c++): When invoking the stand-alone preprocessor ++ for -save-temps, pass all relevant -Defines to it, and then don't ++ pass them to cc1plus. ++ ++2000-12-05 Will Cohen ++ ++ * decl.c (finish_case_label): Cleared ++ more_cleanups_ok in surrounding function scopes. ++ (define_label): Likewise. ++ ++2000-12-05 Nathan Sidwell ++ ++ * cp-tree.h (IDENTIFIER_VIRTUAL_P): Document. ++ (get_matching_virtual): Remove. ++ (look_for_overrides): Declare new function. ++ * decl.c (grokfndecl): Don't set IDENTIFIER_VIRTUAL_P or ++ DECL_VINDEX here. ++ * class.c (check_for_override): Move base class iteration code ++ to look_for_overrides. ++ * search.c (next_baselink): Remove. ++ (get_virtuals_named_this): Remove. ++ (get_virtual_destructor): Remove. ++ (tree_has_any_destructors_p): Remove. ++ (struct gvnt_info): Remove. ++ (check_final_overrider): Remove `virtual' from error messages. ++ (get_matching_virtuals): Remove. Move functionality to ... ++ (look_for_overrides): ... here, and ... ++ (look_for_overrides_r): ... here. Set DECL_VIRTUAL_P, if found ++ to be overriding. ++ ++2000-12-05 Nathan Sidwell ++ ++ * typeck.c (get_delta_difference): If via a virtual base, ++ return zero. ++ * cvt.c (cp_convert_to_pointer): If via a virtual base, do no ++ adjustment. ++ ++2000-12-04 Richard Henderson ++ ++ * error.c (dump_tree): Use output_add_string not OB_PUTS. ++ ++2000-12-04 Jason Merrill ++ ++ * mangle.c (write_type): Mangle VECTOR_TYPE with "U8__vector". ++ (write_builtin_type): Pass intSI_type_node and the like through ++ type_for_mode. ++ * method.c (process_overload_item): Mangle VECTOR_TYPEs with 'o'. ++ Pass intSI_type_node and the like through type_for_mode. ++ * decl2.c (arg_assoc_type): Handle VECTOR_TYPE like COMPLEX_TYPE. ++ * pt.c (tsubst, unify): Likewise. ++ * tree.c (walk_tree): Likewise. ++ * error.c (dump_type): Likewise. ++ (dump_type_prefix, dump_type_suffix): Don't bother with VECTOR_TYPE. ++ ++ * Make-lang.in: Tweak top comment for emacs. ++ (cp/TAGS): Restore. ++ ++ * except.c (expand_throw): Use push_throw_library_fn for _Jv_Throw. ++ ++ * class.c (clone_function_decl): Robustify. ++ ++2000-12-04 Michael Matz ++ ++ * decl.c (store_bindings): Only search in the non modified ++ old_bindings for duplicates. ++ ++2000-12-04 Nathan Sidwell ++ ++ * error.c (dump_function_decl): Use DECL_VIRTUAL_P, not ++ TYPE_POLYMORPHIC_P. ++ ++ * typeck.c (build_static_cast): Remove unused variable. ++ ++2000-12-01 Kriang Lerdsuwanakij ++ ++ * pt.c: Fix typo in comment. ++ ++2000-12-01 Joseph S. Myers ++ ++ * decl2.c (warn_format): Remove definition. ++ (lang_decode_option): Handle -Wformat-nonliteral, ++ -Wno-format-extra-args and -Wno-format-y2k. Use set_Wformat. ++ ++2000-12-01 Joseph S. Myers ++ ++ * decl.c (WINT_TYPE, INTMAX_TYPE, UINTMAX_TYPE): Don't define. ++ (init_decl_processing): Don't create string_type_node, ++ const_string_type_node, wint_type_node, intmax_type_node, ++ uintmax_type_node, default_function_type, ptrdiff_type_node and ++ unsigned_ptrdiff_type_node. Adjust position of call to ++ c_common_nodes_and_builtins. ++ (identifier_global_value): New function. ++ ++2000-12-01 Nathan Sidwell ++ ++ * call.c (standard_conversion): Reject pointer to member ++ conversions from ambiguous, inaccessible or virtual bases. ++ * typeck.c (build_static_cast): Don't check pointers to members ++ specially. ++ ++2000-11-30 Nathan Sidwell ++ ++ * method.c (do_build_copy_constructor): Preserve cv ++ qualifications when accessing source object members. ++ (do_build_assign_ref): Likewise. Remove separate diagnostics for ++ unnamed fields. ++ ++2000-11-30 Nathan Sidwell ++ ++ * method.c (do_build_assign_ref): Construct appropriately ++ CV-qualified base reference. Don't allow const casts in base ++ conversion. ++ ++2000-11-30 Nathan Sidwell ++ ++ * call.c (build_over_call): Use VOID_TYPE_P. Don't die on ++ incomplete return type. ++ ++2000-11-28 Nathan Sidwell ++ ++ * parse.y (base_class.1): Produce a _TYPE not a _DECL. ++ * semantics.c (finish_base_specifier): Accept a _TYPE not a ++ _DECL. ++ ++2000-11-28 Nathan Sidwell ++ ++ * spew.c (yyerror): Cope if yylval.ttype is NULL. ++ ++2000-11-28 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Diagnose undefined template contexts. ++ ++2000-11-28 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Do type access control on friend ++ class. ++ ++2000-11-27 Nathan Sidwell ++ ++ * decl.c (grokfndecl): Undo COMPONENT_REF damage caused by ++ bison parser ickiness. ++ * pt.c (tsubst_friend_function): Enter namespace scope when ++ tsubsting the function name. ++ * cp-tree.h (DECL_TI_TEMPLATE): Update comment to reflect reality. ++ ++2000-11-27 Nathan Sidwell ++ ++ * cp-tree.h (binfo_from_vbase): Return the virtual base's binfo. ++ * cvt.c (cp_convert_to_pointer): Add force parameter. ++ Allow conversions via virtual base if forced. ++ (convert_to_pointer_force): Adjust call to cp_convert_to_pointer. ++ (ocp_convert): Likewise. ++ * search.c (binfo_from_vbase): Return the virtual base's binfo. ++ * typeck.c (get_delta_difference): Adjust handling of virtual ++ bases. ++ ++2000-11-26 Mark Mitchell ++ ++ * tree.c (struct list_hash): Remove. ++ (list_hash_table): Make it be an htab. ++ (struct list_proxy): New type. ++ (list_hash_eq): New function. ++ (list_hash_pieces): Renamed from ... ++ (list_hash): ... this. ++ (list_hash_lookup): Remove. ++ (list_hash_add): Remove. ++ (hash_tree_cons): Use the generic hashtable. ++ (mark_list_hash): Remove. ++ (init_tree): Create the hashtable. ++ ++2000-11-25 Joseph S. Myers ++ ++ * method.c (build_mangled_C9x_name): Rename to ++ build_mangled_C99_name. Change C9X references in comments to ++ refer to C99. ++ ++2000-11-24 Nathan Sidwell ++ ++ * parse.y (unary_expr): Move VA_ARG from here ... ++ (primary): ... to here. ++ ++2000-11-24 Nathan Sidwell ++ ++ * semantics.c (finish_id_expr): If type is error_mark, return ++ error_mark. ++ ++2000-11-23 Nathan Sidwell ++ ++ * pt.c (lookup_template_class): Simplify loop exit constructs. ++ Cope when there is no partial instantiation of a template ++ template member. ++ ++2000-11-23 J"orn Rennecke ++ ++ * Make-lang.in (g++spec.o, cxxmain.o): Depend on $(CONFIG_H). ++ ++2000-11-22 Mark Mitchell ++ ++ * mangle.c (mangle_conv_op_name_for_type): Don't use `__op' ++ prefix. ++ ++ * pt.c (do_decl_instantiate): Explicitly clone constructors and ++ destructors that haven't already been cloned. ++ ++2000-11-20 Richard Henderson ++ ++ * parse.y (yyparse_1): Rename the parser entry point. ++ ++2000-11-20 Alex Samuel ++ ++ * mangle.c (write_name): Use for names directly in ++ function scope. ++ (write_unscoped_name): Accept names directly in function scope. ++ ++2000-11-20 Nathan Sidwell ++ ++ * lex.c (rid_to_yy, RID_EXPORT): Make unique keyword. ++ * parse.y (extdef): Add EXPORT reduction. ++ * spew.c (yylex): Don't skip export here. ++ ++2000-11-19 Mark Mitchell ++ ++ * decl.c (init_decl_processing): Correct name of pure virtual ++ function under the new ABI. ++ * rtti.c (throw_bad_cast): Likewise, for bad cast function. ++ (throw_bad_typeid): Likewise for bad typeid function. ++ ++2000-11-18 Mark Mitchell ++ ++ * decl.c (grokparms): Don't even function types of `void' type, ++ either. ++ * mangle.c (write_type): Don't crash when confronted with the ++ error_mark_node. ++ ++ * decl.c (grokparms): Don't create parameters of `void' type. ++ ++2000-11-17 Zack Weinberg ++ ++ * lex.c (mark_impl_file_chain): Delete. ++ (init_parse): Remove call to ggc_add_string_root. No need to ++ ggc_strdup a string constant. Do not add impl_file_chain to GC ++ roots. ++ (handle_pragma_implementation): No need to ggc_strdup main_filename. ++ ++2000-11-17 Nathan Sidwell ++ ++ * pt.c (tsubst_expr, DECL_STMT): Instantiate decl's type. ++ ++2000-11-17 Nathan Sidwell ++ ++ * cp-tree.h (PARMLIST_ELLIPSIS_P): New macro. ++ * decl.c (grokdeclarator): Don't reject void parms here. ++ (require_complete_types_for_parms): Simplify, use ++ complete_type_or_else. ++ (grokparms): Remove bitrot. Remove funcdef parm. ++ Deal with ellipsis parm lists here. ++ * semantics.c (finish_parmlist): Don't append void_list_node ++ here. Set PARMLIST_ELLIPSIS_P. ++ ++2000-11-17 Nathan Sidwell ++ ++ * typeck2.c (incomplete_type_error): Reorganize to avoid ++ excessive diagnostics. ++ ++2000-11-16 Zack Weinberg ++ ++ * lex.c (struct impl_files, internal_filename): Constify a char *. ++ ++2000-11-16 Mark Mitchell ++ ++ * mangle.c (write_special_name_constructor): Don't generate ++ assembler junk when confronted with an old-style constructor. ++ (write_special_name_destructor): Likewise. ++ (mangle_decl_string): Do it here instead. ++ ++2000-11-16 Nathan Sidwell ++ ++ * call.c (op_error): Make error messages clearer. ++ ++2000-11-15 Mark Mitchell ++ ++ * decl.c (wrapup_globals_for_namespace): Don't mark things ++ TREE_ASM_WRITTEN when they're not. ++ ++2000-11-15 Jason Merrill ++ ++ * typeck2.c (friendly_abort): Uncount the error before handing ++ off to fancy_abort. ++ ++2000-11-15 Nathan Sidwell ++ ++ * typeck.c (lookup_anon_field): Cope with qv qualifiers. ++ ++2000-11-14 Mark Mitchell ++ ++ * class.c (build_vtbl_initializer): Fix typo in comment. ++ * typeck.c (expr_sizeof): Don't crash on errors. ++ ++2000-11-14 Jim Wilson ++ ++ * lang-specs.h: Add %2 after %(cc1_options). ++ ++2000-11-14 Richard Henderson ++ ++ * typeck.c (c_sizeof): Be strict about casting result value ++ back to c_size_type_node. ++ (expr_sizeof, c_sizeof_nowarn, c_alignof): Likewise. ++ ++2000-11-13 Joseph S. Myers ++ ++ * typeck.c (build_unary_op): Use boolean_increment from ++ c-common.c, moving the relevant code there. ++ ++2000-11-11 Jason Merrill ++ ++ * typeck.c (mark_addressable): Don't call put_var_into_stack. ++ ++ * decl.c (maybe_commonize_var): Set DECL_UNINLINABLE for statics ++ in inlines. ++ ++2000-11-10 Kaveh R. Ghazi ++ ++ * decl.c (grokdeclarator, save_function_data): Use memcpy, not bcopy. ++ * lex.c (copy_lang_decl): Likewise. ++ ++2000-11-09 Mark Mitchell ++ ++ * dump.c (cp_dump_tree): Don't dump function bodies here. ++ ++ * Make-lang.in (CXX_C_OBJS): Add c-dump.o. ++ (dump.o): Update dependency list. ++ * cp-tree.h (DECL_MAYBE_TEMPLATE): Remove. ++ (flag_dump_translation_unit): Likewise. ++ (CP_TYPE_QUALS): Adjust definition. ++ (DECL_C_BIT_FIELD): Remove. ++ (SET_DECL_C_BIT_FIELD): Likewise. ++ (CLEAR_DECL_C_BIT_FIELD): Likewise. ++ (add_maybe_template): Likewise. ++ (strip_array_types): Likewise. ++ (dump_node_to_file): Likewise. ++ (cp_dump_tree): New function. ++ * decl.c (init_decl_processing): Set lang_dump_tree. ++ * decl2.c (flag_dump_translation_unit): Remove. ++ * dump.c: Move most of it to ../c-dump.c. ++ (cp_dump_tree): New function. ++ * pt.c (add_maybe_template): Remove. ++ * typeck.c (strip_array_types): Likewise. ++ ++2000-11-07 Eric Christopher ++ ++ * decl.c (init_decl_processing): Change definition of ++ __wchar_t to wchar_t. Remove artificial declaration of ++ wchar_t. ++ * lex.c: Change instances of __wchar_t to wchar_t. ++ ++2000-11-09 Nathan Sidwell ++ ++ * lex.c (do_identifier): Don't lookup_name for operators. ++ * parse.y (operator): Save looking_for_typename. ++ (unoperator): Restore it. ++ * spew.c (frob_opname): Use nth_token for lookahead. ++ ++2000-11-08 Nathan Sidwell ++ ++ * decl.c (grok_op_properties): Always use coerce_new_type and ++ coerce_delete_type. ++ * decl2.c (coerce_new_type): Use c_size_type_node. Preserve ++ exception specification. Tidy up. ++ (coerce_delete_type): Preserve exception specification. Tidy up. ++ ++2000-11-07 Joseph S. Myers ++ ++ * class.c (duplicate_tag_error, build_vtbl_initializer), decl.c ++ (push_binding_level), error.c (cp_tree_printer), pt.c ++ (process_partial_specialization, tsubst_template_arg_vector), ++ search.c (lookup_member): Use memset () instead of bzero (). ++ ++2000-11-07 Nathan Sidwell ++ ++ * decl.c (build_ptrmemfunc_type): Allow error_mark_node. ++ ++2000-11-05 Joseph S. Myers ++ ++ * Make-lang.in (c++.distdir): Remove. ++ ++2000-11-04 Mark Mitchell ++ ++ * decl2.c (do_nonmember_using_decl): Allow `extern "C"' ++ declarations from different namespaces to be combined. ++ ++2000-11-03 Zack Weinberg ++ ++ * decl.c: Include tm_p.h. ++ ++2000-11-03 Joseph S. Myers ++ ++ * tree.c (cp_tree_equal): Use memcmp () instead of bcmp (). ++ ++2000-11-02 Joseph S. Myers ++ ++ * dump.c (dequeue_and_dump), lex.c (interface_strcmp), method.c ++ (build_overload_value), repo.c (open_repo_file), xref.c ++ (open_xref_file): Use strchr () and strrchr () instead of index () ++ and rindex (). ++ ++2000-11-01 Bernd Schmidt ++ ++ * call.c (build_over_call): Call fold on the CALL_EXPR. ++ ++2000-11-01 Gabriel Dos Reis ++ ++ * error.c (dump_template_decl): Separate template hearders with ++ space not comma. ++ ++2000-10-31 Gabriel Dos Reis ++ ++ * error.c: Move TFF_ macros into cp-tree.h. Throughout, replace ++ TS_* flags with corresponding TFF_*. Adjust prototypes of ++ functions (which used to take a tree_string_flags) to take an int. ++ ++ * cp-tree.h (enum tree_string_flags): Remove ++ (TFF_PLAIN_IDENTIFIER, TFF_NAMESPACE_SCOPE, TFF_CLASS_SCOPE, ++ TFF_CHASE_NAMESPACE_ALIAS, TFF_CHASE_TYPEDEF, TFF_DECL_SPECIFIERS, ++ TFF_CLASS_KEY_OR_ENUM, TFF_RETURN_TYPE, ++ TFF_FUNCTION_DEFAULT_ARGUMENTS, TFF_EXCEPTION_SPECIFICATION, ++ TFF_TEMPLATE_HEADER, TFF_TEMPLATE_DEFAULT_ARGUMENTS, ++ TFF_TEMPLATE_NAME, TFF_EXPR_IN_PARENS, TFF_SCOPE): New macros. ++ (type_as_string, decl_as_string, expr_as_string, ++ context_as_string): Adjust prototype. ++ ++ * class.c (dump_class_hierarchy_r): Use TFF_PLAIN_IDENTIFIER ++ instead of TS_PLAIN. ++ ++ * pt.c (mangle_class_name_for_template): Use TFF_CHASE_TYPEDEF ++ instead of TF_CHASE_TYPEDEFS. Use TFF_PLAIN_IDENTIFIER instead of ++ plain `0'. ++ ++2000-10-30 Mark Mitchell ++ ++ * cp-tree.h (DECL_EXTERNAL_LINKAGE_P): New macro. ++ (linkage_kind): New enumeration. ++ (decl_linkage): New function. ++ * decl2.c (comdat_linkage): Extend comment. ++ * error.c (dump_function_decl): Print the arguments used to ++ instantiate a template, even when not printing the type of the ++ function. ++ * pt.c (convert_nontype_argument): Use DECL_EXTERNAL_LINKAGE_P, ++ not TREE_PUBLIC, to test for external linkage. ++ * tree.c (decl_linkage): New function. ++ ++2000-10-28 Mark Mitchell ++ ++ * pt.c (instantiate_decl): Always instantiate static data members ++ initialized in-class. ++ ++2000-10-27 Zack Weinberg ++ ++ * Make-lang.in: Move all build rules here from Makefile.in, ++ adapt to new context. Wrap all rules that change the current ++ directory in parentheses. Expunge all references to $(P). ++ When one command depends on another and they're run all at ++ once, use && to separate them, not ;. Add OUTPUT_OPTION to ++ all object-file generation rules. Delete obsolete variables. ++ ++ * Makefile.in: Delete. ++ * config-lang.in: Delete outputs= line. ++ ++2000-10-26 Gabriel Dos Reis ++ ++ * error.c (dump_function_decl): Print no space between ++ `ptr-operator' the `type-specifier' of the return type. ++ (dump_type_prefix): Make sure we put space at the appropriate ++ place. ++ ++2000-10-23 Jason Merrill ++ ++ * call.c (equal_functions): Also call decls_match for extern "C" fns. ++ ++2000-10-22 Jason Merrill ++ ++ * call.c (build_conditional_expr): Use ocp_convert to force ++ rvalue conversion. ++ ++2000-10-22 Mark Mitchell ++ ++ * call.c (standard_conversion): Use RVALUE_CONVs for all ++ expressions that satisfy lvalue_p, not just those that satisfy ++ real_lvalue_p. ++ ++ * optimize.c (copy_body_r): Don't treat CALL_EXPRs specially. ++ ++ * typeck.c (c_sizeof): Return an expression of `size_t' type, ++ not one with TYPE_IS_SIZETYPE set. ++ (dubious_conversion_warnings): Remove special-case code. ++ ++2000-10-21 Geoffrey Keating ++ ++ * decl2.c (arg_assoc_type): Handle VECTOR_TYPE. ++ * error.c (dump_type): Handle VECTOR_TYPE like POINTER_TYPE. ++ (dump_type_prefix): Print vector-of-int as 'int vector'. ++ (dump_type_suffix): Handle VECTOR_TYPE like POINTER_TYPE. ++ * tree.c (walk_tree): Handle VECTOR_TYPE. ++ ++ * decl.c (init_decl_processing): Call MD_INIT_BUILTINS. ++ ++2000-10-21 Jason Merrill ++ ++ * parse.y (operator): Set got_object from got_scope. ++ Set looking_for_typename. ++ * decl.c (lookup_name_real): Clear val after setting from_obj. ++ Reorganize diagnostic. ++ ++2000-10-20 Jason Merrill ++ ++ * tree.c (walk_tree): Don't walk into default args. ++ ++ * error.c (dump_expr): Use host_integerp. ++ ++2000-10-20 David Edelsohn ++ ++ * typeck2.c (abstract_virtuals_error): Use "because" instead of ++ "since" in error message. ++ ++2000-10-20 Richard Kenner ++ ++ * typeck.c (dubious_conversion_warning): Suppress if TYPE_IS_SIZETYPE. ++ ++2000-10-20 Jeffrey Oldham ++ ++ * decl.c (revert_static_member_fn): Fixed typo. ++ ++2000-10-19 Mark Mitchell ++ ++ * class.c (subobject_offset_fn): New type. ++ (dfs_record_base_offsets): Remove. ++ (record_base_offsets): Likewise. ++ (dfs_search_base_offsets): Likewise. ++ (record_subobject_offset): New function. ++ (check_subobject_offset): Likewise. ++ (walk_subobject_offsets): Likewise. ++ (record_subobject_offsets): Likewise. ++ (layout_conflict_p): Reimplement. ++ (layout_nonempty_base_or_field): Correct handling of type ++ conflicts during layout. ++ (layout_empty_base): Likewise. ++ (build_base_field): Adjust to handle new representation of empty ++ base offset table. ++ (build_base_fields): Likewise. ++ (layout_virtual_bases): Likewise. ++ (splay_tree_compare_integer_csts): New function. ++ (layout_class_type): Use a splay_tree, rather than a varray, to ++ represent the offsets of empty bases. ++ ++ * cp-tree.h (DECL_ANTICIPATED): Don't require a FUNCTION_DECL. ++ * decl.c (select_decl): Don't return declarations that are ++ DECL_ANTICIPATED. ++ ++2000-10-18 Mark Mitchell ++ ++ * cp-tree.h (cp_tree_index): Add CPTI_FAKE_STD. ++ (fake_std_node): New macro. ++ * decl.c (in_std): Rename to ... ++ (in_fake_std): ... this. ++ (flag_no_builtin): Remove. ++ (flag_no_nonansi_builtin): Likewise. ++ (walk_namespaces_r): Use fake_std_node. ++ (push_namespace): Use std_identifier. ++ (pop_namespace): Use in_fake_std. ++ (lookup_name_real): Use fake_std_node. ++ (init_decl_processing): When -fhonor-std, create the `std' ++ namespace. Don't create a dummy fake_std_node in that case. ++ Adjust call to c_common_nodes_and_builtins. Use std_identifier. ++ (builtin_function): Put builtins whose names don't begin ++ with `_' in the std namespace. ++ * decl2.c (flag_no_builtin): Remove. ++ (flag_no_nonansi_builtin): Likewise. ++ (set_decl_namespace): Use fake_std_node. ++ (validate_nonmember_using_decl): Likewise. ++ (do_using_directive): Likewise. ++ (handle_class_head): Likewise. ++ * dump.c (dequeue_and_dump): Likewise. ++ * except.c (init_exception_processing): Use std_identifier. ++ * init.c (build_member_call): Use fake_std_node. ++ * rtti.c (init_rtti_processing): Use std_identifier. ++ ++2000-10-17 Mark Mitchell ++ ++ * cp-tree.h (back_end_hook): Remove declaration. ++ * decl2.c (back_end_hook): Remove definition. ++ ++ * dump.c (dequeue_and_dump): Dump TREE_USED. ++ ++2000-10-17 Brad Lucier ++ ++ * spew.c (snarf_defarg): Cast 2nd arg to obstack_blank to (int). ++ ++2000-10-17 Joseph S. Myers ++ ++ * decl.c (WINT_TYPE): Define. ++ (init_decl_processing): Create types unsigned_ptrdiff_type_node, ++ c_size_type_node, signed_size_type_node and wint_type_node. ++ ++2000-10-17 Joseph S. Myers ++ ++ * decl2.c (warn_missing_format_attribute): New variable. ++ (lang_decode_option): Decode -Wmissing-format-attribute. ++ ++2000-10-16 Mark Mitchell ++ ++ * typeck.c (qualify_type): Remove. ++ (composite_pointer_type): Fix handling of conversions to `cv void*'. ++ ++2000-10-14 Kaveh R. Ghazi ++ ++ * Makefile.in (parse.c, parse.h): Fix think-o in last patch. ++ ++2000-10-13 Kaveh R. Ghazi ++ ++ * Makefile.in (parse.c, parse.h): Create atomically. ++ ++2000-10-12 Mark Mitchell ++ ++ * class.c (current_obstack): Remove. ++ * decl.c (ggc_p): Remove. ++ (start_decl): Don't use decl_tree_cons. ++ (grokdeclarator): Don't use build_decl_list. ++ (start_function): Don't use decl_tree_cons. ++ (finish_function): Don't mess with obstacks. ++ * decl2.c (grok_x_components): Don't use build_decl_list. ++ * lex.c (make_call_declarator): Don't call decl_tree_cons. ++ (implicitly_declare_fn): Don't call build_decl_list. ++ * parse.y (frob_specs): Don't call build_decl_list or ++ decl_tree_cons. ++ (expr_or_declarator_intern): Don't call decl_tree_cons. ++ (primary): Don't call build_decl_list. ++ (fcast_or_absdcl): Likewise. ++ (typed_declspecs): Don't call decl_tree_cons. ++ (reserved_declspecs): Don't call build_decl_list. ++ (declmods): Likewise. ++ (reserved_typespecquals): Likewise. ++ (aggr): Likewise. ++ (new_type_id): Likewise. ++ (cv_qualifiers): Likewise. ++ (after_type_declarator_intern): Likewise. ++ (notype_declarator_intern): Likewise. ++ (absdcl_intern): Likewise. ++ (named_parm): Likewise. ++ * pt.c (most_specialized_class): Likewise. ++ * repo.c (temporary_obstack): Make it a structure, not a pointer. ++ (init_repo): Initialize it. ++ * search.c (current_obstack): Remove. ++ * typeck2.c (add_exception_specifier): Don't call build_decl_list. ++ ++2000-10-09 Richard Henderson ++ ++ * Make-lang.in (CXX_EXTRA_HEADERS): Remove. ++ (c++ language support bits for libgcc): Remove. ++ (c++.clean): Remove cplib2.txt cleanup. ++ * config-lang.in (headers, lib2funcs): Remove. ++ ++ * exception.cc, new.cc, new1.cc, new2.cc: Remove files. ++ * tinfo.cc, tinfo.h, tinfo2.cc, vec.cc: Remove files. ++ * inc/cxxabi.h, inc/exception, inc/new: Remove files. ++ * inc/new.h, inc/typeinfo: Remove files. ++ ++2000-10-08 Joseph S. Myers ++ ++ * decl.c (INTMAX_TYPE, UINTMAX_TYPE): Define if not already ++ defined. ++ (init_decl_processing): Initialize intmax_type_node and ++ uintmax_type_node. ++ ++2000-10-06 Richard Henderson ++ ++ * cp-tree.h (struct cp_language_function): Remove x_result_rtx. ++ (original_result_rtx): Remove. ++ * decl.c (save_function_data): Don't clear x_result_rtx. ++ (mark_lang_function): Don't mark it either. ++ * expr.c (fixup_result_decl): Remove. ++ * semantics.c (genrtl_named_return_value): Frob the return decl ++ before calling emit_local_var. ++ (genrtl_finish_function): Don't call fixup_result_decl. ++ Always emit the jump to return_label. ++ ++2000-10-06 Nathan Sidwell ++ ++ * pt.c (lookup_template_class): Set current access for enum. ++ (tsubst_enum): Set file & line for enum decl. ++ ++ * spew.c (yylex): Remove unused variable. ++ ++2000-10-05 Richard Henderson ++ ++ * semantics.c (genrtl_finish_function): Don't init or check ++ can_reach_end; remove noreturn and return value checks. ++ ++2000-10-05 Tom Tromey ++ ++ * init.c (build_java_class_ref): Use `build_static_name' with a ++ suffix, not a prefix, to build the class object's name. ++ ++2000-10-05 Nathan Sidwell ++ ++ * cp-tree.h (access_kind): Fix comment typo. ++ * decl2.c (grokfield): Fix diagnostic typo. ++ * semantics.c (finish_template_type): Fix comment typo. ++ (finish_qualified_object_call_expr): Likewise. ++ ++2000-10-05 Nathan Sidwell ++ ++ * pt.c (tsubst_expr, DECL_STMT case): Don't process if ++ tsubsting fails. ++ ++2000-10-05 Nathan Sidwell ++ ++ * spew.c (frob_id): New static function. ++ (frob_opname): Use it. ++ (yylex): Use it. ++ ++2000-10-01 Mark Mitchell ++ ++ * decl.c (lang_mark_false_label_stack): Remove. ++ * lex.c (cp_mang_lang_type): Use ggc_alloc_cleared. ++ ++2000-09-30 Joseph S. Myers ++ ++ * gxxint.texi: Use @email for formatting email addresses. ++ ++2000-09-29 Gabriel Dos Reis ++ ++ * error.c: Remove direct obstack manipulation. Replace with ++ output_buffer-based formatting. Adjust calls to removed macros. ++ (obstack_chunk_alloc, obstack_chunk_free): Remove. ++ (OB_INIT, OB_PUTC, OB_PUTC2, OB_PUTS, OB_PUTID, OB_PUTCP, ++ OB_FINISH, OB_PUTI, OB_END_TEMPLATE): Likewise. ++ ++2000-09-24 Mark Mitchell ++ ++ * ir.texi: Move to ../c-tree.texi. ++ ++2000-09-20 Jason Merrill ++ ++ * decl2.c (get_guard): Check DECL_FUNCTION_SCOPE_P. ++ ++2000-09-21 Andreas Jaeger ++ ++ * errfn.c: Move declaration of cp_printer and cp_printers to ... ++ * cp-tree.h: ... here. ++ ++ * error.c: Remove declaration of cp_printer. ++ ++2000-09-20 Mark Mitchell ++ ++ * tree.c (mark_local_for_remap_r): Handle CASE_LABELs. ++ ++2000-09-20 Hans-Peter Nilsson ++ ++ * except.c: Delete #if 0:d EXCEPTION_SECTION_ASM_OP-default and ++ users. ++ ++2000-09-18 Mark Mitchell ++ ++ * decl.c (start_function): Robustify. ++ ++2000-09-18 Kaveh R. Ghazi ++ ++ * cp-tree.h (check_function_format): Accept a `status' parameter. ++ ++ * call.c, typeck.c: Updates calls to `check_function_format'. ++ ++2000-09-17 Geoffrey Keating ++ ++ * decl2.c (handle_class_head): Always push some scope even ++ in the error case. ++ ++2000-09-16 Mark Mitchell ++ ++ * cp-tree.h (struct cp_language_function): Remove ++ x_scope_stmt_stack and name_declared. ++ (current_scope_stmt_stack): Remove. ++ (function_name_declared_p): New macro. ++ (struct lang_decl_flags): Use c_lang_decl as a base class. ++ (context): Remove. ++ (struct lang_decl): Replace saved_tree with context. ++ (DECL_FRIEND_CONTEXT): Adjust accordingly. ++ (SET_DECL_FRIEND_CONTEXT): Likewise. ++ (DECL_VIRTUAL_CONTEXT): Likewise. ++ (DECL_SAVED_TREE): Remove. ++ (C_DECLARED_LABEL_FLAG): Likewise. ++ (cplus_expand_expr_stmt): Don't declare. ++ (add_decl_stmt): Likewise. ++ (add_scope_stmt): Likewise. ++ * decl.c (mark_stmt_tree): Remove. ++ (case_compare): Likewise. ++ (finish_case_label): Use c_add_case_label. ++ (init_decl_processing): Set more language-specific hooks. ++ (build_enumerator): Fix typo in comment. ++ (cplus_expand_expr_stmt): Remove. ++ (mark_lang_function): Use mark_c_language_function. ++ (lang_mark_tree): Use c_mark_lang_decl. ++ * decl2.c: Change order of inclusion. ++ * except.c: Likewise. ++ * expr.c (cplus_expand_expr): Remove handling of STMT_EXPR. Fall ++ back on c_expand_expr. ++ * friend.c: Include expr.h. ++ * init.c: Change order of inclusion. ++ * Makefile.in: Update dependencies. ++ * lex.h (free_lang_decl_chain): Remove. ++ * optimize.c (maybe_clone_body): Use function_name_declared_p. ++ * pt.c (build_template_decl): Don't copy DECL_VIRTUAL_CONTEXT if ++ it doesn't exist. ++ (instantiate_decl): Use function_name_declared_p. ++ * semantics.c (lang_expand_expr_stmt): Remove. ++ (set_current_function_name_declared): Likewise. ++ (current_function_name_declared): Likewise. ++ (begin_compound_stmt): Use function_name_declared_p. ++ (add_decl_stmt): Remove. ++ (setup_vtbl_ptr): Use function_name_declared_p. ++ (add_scope_stmt): Remove. ++ (current_scope_stmt_stack): New function. ++ (cp_expand_stmt): Don't handle SCOPE_STMTs. ++ (expand_body): Use function_name_declared_p. ++ * tree.c (cp_statement_code_p): Don't include SCOPE_STMT. ++ * typeck.c: Change order of includes. ++ (convert_sequence): Remove. ++ ++2000-09-14 Joseph S. Myers ++ ++ * lex.c (reswords): Add _Complex. ++ ++2000-09-14 Richard Kenner ++ ++ * Make-lang.in (cplib2.txt): Depend on cp/Makefile. ++ ++2000-09-13 J. David Anglin ++ ++ * init.c (begin_init_stmts): Don't use // comments. ++ ++2000-09-12 Jason Merrill ++ ++ * decl.c (maybe_deduce_size_from_array_init): Set do_default for ++ all non-extern arrays. ++ ++ * decl.c (grokdeclarator): Complain about 'friend T' for implicit ++ typenames, too. Downgrade complaint to pedwarn. ++ (xref_tag): Warn about surprising behavior of 'friend struct T'. ++ * decl2.c (handle_class_head): Generate a TYPENAME_TYPE for ++ 'class This::Inherited'. ++ ++2000-09-12 Mark Mitchell ++ ++ * decl.c (finish_case_label): Given the LABEL_DECL a ++ DECL_CONTEXT. ++ ++2000-09-12 Gabriel Dos Reis ++ ++ * error.c (TFF_PLAIN_IDENTIFIER, TFF_NAMESPACE_SCOPE, ++ TFF_CLASS_SCOPE, TFF_CHASE_NAMESPACE_ALIAS, TFF_CHASE_TYPDEF, ++ TFF_DECL_SPECIFIERS, TFF_CLASS_KEY_OR_ENUM, TFF_RETURN_TYPE, ++ TFF_FUNCTION_DEFAULT_ARGUMENTS, TFF_EXCEPTION_SPECIFICATION, ++ TFF_TEMPLATE_HEADER, TFF_TEMPLATE_DEFAULT_ARGUMENTS, TFF_SCOPE): ++ New macros. ++ (sorry_for_unsupported_tree, print_scope_operator, ++ print_left_paren, print_right_paren, print_left_bracket, ++ print_right_bracket, print_whitespace): Likewise. ++ (aggr_variety): Rename to class_key_or_enum. ++ (print_type): Rename to print_type_id. ++ (print_type_specifier_seq, print_simple_type_specifier, ++ print_elaborated_type_specifier, ++ print_rest_of_abstract_declarator, ++ print_parameter_declaration_clause, print_exception_specification, ++ print_nested_name_specifier, print_template_id, ++ typedef_original_name, print_template_argument_list_start, ++ print_template_argument_list_end): New functions. ++ ++2000-09-11 Gabriel Dos Reis ++ ++ * ir.texi: Add more documentation. ++ ++2000-09-11 Mark Mitchell ++ ++ * cp-tree.h (struct saved_scope): Remove x_function_parms. ++ (current_function_parms): Don't define. ++ (struct cp_language_function): Remove parms_stored. ++ (current_function_just_assigned_this): Don't define. ++ (current_function_parms_stored): Likewise. ++ (static_ctors): Declare. ++ (static_dtors): Likewise. ++ (SF_EXPAND): Don't define. ++ (expand_start_early_try_stmts): Remove declaration. ++ (store_parm_decls): Likewise. ++ * decl.c (static_ctors): Don't declare. ++ (static_dtors): Likewise. ++ (struct binding_level): Remove this_block. ++ (poplevel): Remove dead code. ++ (set_block): Likewise. ++ (mark_binding_level): Don't mark this_block. ++ (mark_saved_scope): Don't mark x_function_parms. ++ (init_decl_processing): Don't add current_function_parms as a GC ++ root. ++ (check_function_type): Change prototype. ++ (start_function): Remove RTL-generation code. ++ (expand_start_early_try_stmts): Remove. ++ (store_parm_decls): Give it internal linkage. Remove ++ RTL-generation code. ++ (finish_function): Remove RTL-generation code. ++ * decl2.c (static_ctors): Fix formatting. ++ (static_dtors): Likewise. ++ * method.c (use_thunk): Don't call store_parm_decls. ++ (synthesize_method): Likewise. ++ * optimize.c (maybe_clone_body): Likewise. ++ * parse.y (fn.def2): Likewise. ++ (.set_base_init): Likewise. ++ (nodecls): Likewise. ++ * pt.c (instantiate_decl): Likewise. ++ * rtti.c (synthesize_tinfo_fn): Likewise. ++ * semantics.c (genrtl_try_block): Simplify. ++ (expand_body): Use genrtl_start_function and ++ genrtl_finish_function. ++ (genrtl_start_function): New function. ++ (genrtl_finish_function): Likewise. ++ ++2000-09-11 Nathan Sidwell ++ ++ * error.c (cp_tree_printer, case 'P'): Append break. ++ ++2000-09-11 Nathan Sidwell ++ ++ * cp-tree.h (frob_opname): Declare. ++ * parse.y (saved_scopes): New static variable. ++ (cp_parse_init): Adjust. ++ (do_id): If lastiddecl is NULL, do do_identifier. ++ (operator): Save scope information. ++ (unoperator): New reduction. Restore scope information. ++ (operator_name): Append unoperator. Call frob_opname. ++ * spew.c (frob_opname): Define. ++ ++2000-09-10 Zack Weinberg ++ ++ * decl.c, rtti.c: Include defaults.h if not already included. ++ Don't define the *_TYPE_SIZE macros. ++ ++2000-09-09 Mark Mitchell ++ ++ * cp-tree.h (push_switch): Change prototype. ++ (check_cp_case_value): Remove declaration. ++ (decl_constant_value): Likewise. ++ * decl.c (struct cp_switch): Add switch_stmt and cases. ++ (case_compare): New function. ++ (push_switch): Set switch_stmt. Initialize cases. ++ (pop_switch): Clean up cases. ++ (define_case_label): Rename to ... ++ (finish_case_label): ... this. Do semantic analysis for case ++ labels here. ++ (start_function): Correct comment. ++ * decl2.c (check_cp_case_value): Remove. ++ * expr.c (do_case): Remove. ++ * pt.c (tsubst_expr): Adjust call to finish_case_label. ++ * semantics.c (genrtl_do_poplevel): Remove declaration. ++ (RECHAIN_STMTS): Remove. ++ (finish_break_stmt): Use build_break_stmt. ++ (finish_continue_stmt): Use build_continue_stmt. ++ (finish_switch_cond): Adjust condition here, rater than in ++ c_expand_start_case. ++ (finish_case_label): Remove. ++ * typeck.c (c_expand_return): Remove. ++ (c_expand_start_case): Likewise. ++ ++2000-09-07 Gabriel Dos Reis ++ ++ * ir.texi: Document type nodes. ++ ++2000-09-06 Mark Mitchell ++ ++ * cp-tree.h (init_cp_semantics): Declare. ++ (genrtl_try_block): Don't declare. ++ (genrtl_handler): Likewise. ++ (genrtl_catch_block): Likewise. ++ (genrtl_ctor_stmt): Likewise. ++ (genrtl_subobject): Likewise. ++ (genrtl_do_poplevel): Likewise. ++ (genrtl_named_return_value): Likewise. ++ * lex.c (init_parse): Call init_cp_semantics. ++ * semantics.c (genrtl_try_block): Give it internal linkage. ++ (genrtl_handler): Likewise. ++ (genrtl_catch_block): Likewise. ++ (genrtl_ctor_stmt): Likewise. ++ (genrtl_subobject): Likewise. ++ (genrtl_do_poplevel): Likewise. ++ (genrtl_named_return_value): Likewise. ++ (lang_expand_stmt): Rename to ... ++ (cp_expand_stmt): ... this. Only handle C++-specific nodes. ++ (init_cp_semantics): Define. ++ ++ * decl.c (initialize_local_var): Remove RTL-generating code. ++ * semantics.c (genrtl_try_block): Fix formatting. ++ ++ Move statement-tree facilities from C++ to C front-end. ++ * cp-tree.h (cp_tree_index): Remove CPTI_VOID_ZERO. ++ (void_zero_node): Remove. ++ (stmt_tree): Likewise. ++ (scope_chain): Adjust. ++ (language_function): Rename to cp_language_function. ++ (cp_function_chain): Adjust. ++ (current_stmt_tree): Remove. ++ (last_tree): Likewise. ++ (last_expr_type): Likewise. ++ (struct lang_decl): Adjust. ++ (STMT_IS_FULL_EXPR_P): Remove. ++ (add_tree): Remove. ++ (begin_stmt_tree): Likewise. ++ (finish_stmt_tree): Likewise. ++ (walk_tree_fn): Likewise. ++ (walk_stmt_tree): Likewise. ++ * class.c (finish_struct): Replace use of add_tree with add_stmt. ++ * decl.c (mark_stmt_tree): Adjust type. ++ (init_decl_processing): Don't build void_zero_node. ++ (initialize_local_var): Adjust usage of current_stmt_tree. ++ (finish_enum): Use add_stmt, not add_tree. ++ (save_function_data): Adjust use of language_function. ++ (finish_constructor_body): Use add_stmt, not add_tree. ++ (finish_destructor_body): Likewise. ++ (push_cp_function_context): Adjust use of language_function. ++ (pop_cp_function_context): Likewise. ++ (mark_lang_function): Likewise. ++ (mark_cp_function_context): Likewise. ++ * init.c (build_aggr_init): Adjust use of current_stmt_tree. ++ (build_vec_init): Likewise. ++ * semantics.c (SET_LAST_STMT): Remove. ++ (RECHAIN_STMTS): Don't use it. ++ (stmts_are_full_exprs_p): Adjust use of current_stmt_tree. ++ (current_stmt_tree): Define. ++ (add_tree): Remove. ++ (finish_goto_stmt): Use add_stmt, not add_tree. ++ (finish_expr_stmt): Likewise. ++ (begin_if_stmt): Likewise. ++ (finish_then_clause): Likewise. ++ (begin_while_stmt): Likewise. ++ (begin_do_stmt): Likewise. ++ (finish_return_stmt): Likewise. ++ (begin_for_stmt): Likewise. ++ (finish_break_stmt): Likewise. ++ (finish_continue_stmt): Likewise. ++ (begin_switch_stmt): Likewise. ++ (finish_case_label): Likewise. ++ (begin_try_block): Likewise. ++ (begin_function_try_block): Likewise. ++ (begin_handler): Likewise. ++ (begin_catch_block): Likewise. ++ (begin_compound_stmt): Likewise. ++ (begin_asm_stmt): Likewise. ++ (finish_asm_stmt): Likewise. ++ (finish_label_stmt): Likewise. ++ (add_decl_stmt): Likewise. ++ (finish_subobject): Likewise. ++ (finish_decl_cleanup): Likewise. ++ (finish_named_return_value): Likewise. ++ (setup_vtbl_ptr): Likewise. ++ (add_scope_stmt): Likewise. ++ (finish_stmt_expr): Likewise. ++ (prune_unused_decls): Remove. ++ (begin_stmt_tree): Likewise. ++ (finish_stmt_tree): Likewise. ++ (prep_stmt): Adjust use of current_stmt_tree. ++ (lang_expand_stmt): Likewise. ++ * tree.c (statement_code_p): Remove. ++ (cp_statement_code_p): New function. ++ (walk_stmt_tree): Remove. ++ (init_tree): Set lang_statement_code_p. ++ ++2000-09-06 Zack Weinberg ++ ++ Integrated preprocessor. ++ ++ * Make-lang.in, Makefile.in: Remove all references to input.c, ++ gxx.gperf, and hash.h. Add ../c-lex.o to C_OBJS. ++ * gxx.gperf, hash.h, input.c: Delete. ++ * lang-specs.h: Pass -lang-c++ to cc1plus so cpplib is ++ initialized properly. ++ ++ * class.c (fixup_pending_inline): Take a tree, not a ++ struct pending_inline *. All callers changed. ++ (init_class_processing): Set RID_PUBLIC, RID_PRIVATE, ++ RID_PROTECTED entries in ridpointers[] array here. ++ * decl.c (duplicate_decls): Do not refer to struct ++ pending_inline. ++ (record_builtin_type, init_decl_processing): Use RID_MAX not ++ CP_RID_MAX. ++ (grokdeclarator): Use C_IS_RESERVED_WORD. ++ * decl2.c (lang_decode_option): Ignore -lang-c++ for sake of ++ cpplib. ++ (grok_x_components): Do not inspect pending_inlines chain. ++ ++ * cp-tree.h (struct lang_identifier): Add rid_code entry. ++ (C_IS_RESERVED_WORD, C_RID_CODE, C_RID_YYCODE): New. ++ (flag_no_gnu_keywords, flag_operator_names, rid_to_yy): Declare. ++ (DEFARG_LENGTH, struct pending_inline, TIME_IDENTIFIER_TIME, ++ TIME_IDENTIFIER_FILEINFO): Kill. ++ Update prototypes. ++ * lex.h: Expunge cp_rid. Rewrite RIDBIT macros to use just a ++ single 32-bit word. ++ * parse.y: Call do_pending_inlines unconditionally. ++ reinit_parse_for_method is now snarf_method. fn.defpen is no ++ longer necessary. Remove unnecessary annotation on ++ SCOPE. Do not refer to end_of_file or struct pending_inline. ++ * semantics.c (begin_inline_definitions): Call ++ do_pending_inlines unconditionally. ++ ++ * lex.c: Remove all code now shared with C front end. ++ Initialize cpplib properly if USE_CPPLIB. Put reserved words ++ into the get_identifier table. Rewrite pragma handling to ++ work with the registry. Move code to save tokens for later ++ processing to spew.c. ++ ++ * spew.c: Rewrite everything in terms of token streams instead ++ of text. Move routines here from lex.c / input.c as ++ appropriate. GC-mark trees hanging off the pending inlines ++ chain. ++ ++2000-09-06 Mark Mitchell ++ ++ * NEWS: Mention that the named return value extension has been ++ deprecated. ++ * cp-tree.h (original_result_rtx): Define. ++ (TREE_REFERENCE_EXPR): Remove. ++ (DECL_VPARENT): Likewise. ++ (pushdecl_nonclass_level): Likewise. ++ (store_return_init): Likewise. ++ (reinit_lang_specific): Likewise. ++ (genrtl_named_return_value): Change prototype. ++ * decl.c (original_result_rtx): Remove. ++ (cp_finish_decl): Don't build DECL_STMTs for RESULT_DECLs. ++ Do not generate RTL for local variables here. ++ (store_return_init): Remove. ++ * semantics.c (genrtl_named_return_value): Simplify. Fold in ++ store_return_init. ++ (finish_named_return_value): Adjust accordingly. Warn that this ++ extension is deprecated. ++ (lang_expand_stmt): Adjust call to genrtl_named_return_value. ++ ++2000-09-06 Nathan Sidwell ++ ++ * pt.c (type_unification_real): Replace switch with if. ++ (unify): Tsubst non-type parms before comparing. ++ ++2000-09-06 Nathan Sidwell ++ ++ * error.c (dump_typename): New function, broken out of ... ++ (dump_type): ... here. Use it. ++ * typeck.c (same_type_p): Use cp_tree_equal for TYPENAME_TYPE. ++ ++2000-09-06 Nathan Sidwell ++ ++ * init.c (build_offset_ref): Deal with namespace scoped ++ TEMPLATE_ID_EXPRs. ++ ++2000-09-06 Nathan Sidwell ++ ++ * class.c (resolve_address_of_overloaded_function): Add ++ explanation message. ++ * decl.c (define_case_label): Reformat explanation. ++ * decl2.c (finish_static_data_member_decl): Likewise. ++ (grokfield): Likewise. ++ * friend.c (do_friend): Likewise. ++ ++2000-09-05 Zack Weinberg ++ ++ * tree.c (walk_tree): Expose tail recursion. ++ (walk_stmt_tree): New function. ++ * cp-tree.h: Prototype walk_stmt_tree. ++ * semantics.c (prune_unused_decls): Operate on SCOPE_STMTs not ++ the BLOCKs directly. If a BLOCK has no variables after ++ pruning, discard it. ++ (finish_stmt_tree): Use walk_stmt_tree. No need to save and ++ restore the line number. ++ ++2000-09-05 Mark Mitchell ++ ++ * Makefile.in (CXX_TREE_H): Add dependency on HTAB_H. ++ (pt.o): Remove dependency on HTAB_H. ++ * cp-tree.h: Include hashtab.h. ++ (walk_tree): Change prototype. ++ (walk_tree_without_duplicates): New function. ++ * decl.c (check_default_argument): Use it. ++ * optimize.c (remap_decl): Adjust calls to walk_tree. ++ (copy_body): Likewise. ++ (expand_calls_inline): Likewise. ++ (calls_setjmp_p): Use walk_tree_without_duplicates. ++ * pt.c: Don't include hashtab.h. ++ (for_each_template_parm): Use walk_tree_without_duplicates. ++ * semantics.c (finish-stmt_tree): Likewise. ++ (expand_body): Likewise. ++ * tree.c (walk_tree): Add additional parameter. ++ (walk_tree_without_duplicates): New function. ++ (count_trees): Use it. ++ (verify_stmt_tree): Adjust call to walk_tree. ++ (find_tree): Use walk_tree_without_duplicates. ++ (no_linkage_check): Likewise. ++ (break_out_target_exprs): Adjust call to walk_tree. ++ (cp_unsave): Likewise. ++ ++2000-09-04 Kriang Lerdsuwanakij ++ ++ * cp-tree.def (BOUND_TEMPLATE_TEMPLATE_PARM): New tree code. ++ (TEMPLATE_TEMPLATE_PARM): Adjust comment. ++ * cp-tree.h (TYPE_BINFO): Adjust comment. ++ (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO): Likewise. ++ (TEMPLATE_TYPE_PARM_INDEX): Likewise. ++ (IS_AGGR_TYPE): Use BOUND_TEMPLATE_TEMPLATE_PARM instead. ++ (TYPE_TEMPLATE_INFO): Likewise. ++ (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL): Likewise. ++ * class.c (push_nested_class): Likewise. ++ * decl.c (lookup_name_real): Likewise. ++ (grokdeclarator): Likewise. ++ (grok_op_properties): Likewise. ++ (xref_tag): Likewise. ++ (xref_basetypes): Likewise. ++ * decl2.c (constructor_name_full): Likewise. ++ (arg_assoc_template_arg): Add TEMPLATE_TEMPLATE_PARM case. ++ (arg_assoc_type): Use BOUND_TEMPLATE_TEMPLATE_PARM instead. ++ * error.c (dump_type): Split TEMPLATE_TEMPLATE_PARM case. ++ (dump_type_prefix): Add BOUND_TEMPLATE_TEMPLATE_PARM. ++ (dump_type_suffix): Likewise. ++ * init.c (is_aggr_type): Use BOUND_TEMPLATE_TEMPLATE_PARM ++ instead. ++ (get_aggr_from_typedef): Likewise. ++ * mangle.c (write_type): Split TEMPLATE_TEMPLATE_PARM case. ++ (write_expression): Add BOUND_TEMPLATE_TEMPLATE_PARM. ++ (write_template_parm): Likewise. ++ (write_template_template_parm): Check tree code instead of ++ using TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO. ++ * method.c (build_overload_nested_name): Add ++ BOUND_TEMPLATE_TEMPLATE_PARM. ++ (process_overload_item): Split TEMPLATE_TEMPLATE_PARM case. ++ * parse.y (bad_parm): Add BOUND_TEMPLATE_TEMPLATE_PARM. ++ * pt.c (convert_template_argument): Check tree code instead of ++ using TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO. ++ (for_each_template_parm_r): Split TEMPLATE_TEMPLATE_PARM case. ++ (for_each_template_parm): Adjust comment. ++ (tsubst): Add BOUND_TEMPLATE_TEMPLATE_PARM. Reorganize. ++ (tsubst_copy): Add BOUND_TEMPLATE_TEMPLATE_PARM. ++ (unify): Add BOUND_TEMPLATE_TEMPLATE_PARM. Reorganize. Use ++ template_args_equal to compare template template parameter cases. ++ * ptree.c (print_lang_type): Add BOUND_TEMPLATE_TEMPLATE_PARM. ++ * search.c (lookup_field_1): Use BOUND_TEMPLATE_TEMPLATE_PARM ++ instead. ++ * tree.c (copy_template_template_parm): Decide whether to create ++ a TEMPLATE_TEMPLATE_PARM or BOUND_TEMPLATE_TEMPLATE_PARM node. ++ (walk_tree): Add BOUND_TEMPLATE_TEMPLATE_PARM. ++ (copy_tree_r): Likewise. ++ * typeck.c (comptypes): Likewise. Check tree code instead of ++ using TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO. ++ ++2000-09-04 Mark Elbrecht ++ ++ * decl.c (finish_function): Move the code for handling functions ++ marked with the constructor and destructor attributes inside the ++ expand_p block. ++ ++2000-09-04 Nathan Sidwell ++ ++ * init.c (resolve_offset_ref): Deal with TEMPLATE_ID_EXPR. ++ ++2000-09-04 Nathan Sidwell ++ ++ * pt.c (lookup_template_class): Remove abort. ++ * tree.c (get_type_decl): Allow error_mark_node. ++ ++2000-09-04 Nathan Sidwell ++ ++ * decl2.c (arg_assoc): Deal with COMPONENT_REFs inside ++ TEMPLATE_ID_EXPRs. ++ ++2000-09-03 Mark Mitchell ++ ++ * operators.def (ALIGNOF_EXPR, MAX_EXPR, MIN_EXPR): Change ++ new ABI mangling. ++ ++2000-09-01 Nathan Sidwell ++ ++ * parse.y (named_class_head): Check for TYPENAME_TYPE. Simplify ++ union tag mismatch error reporting. ++ ++2000-09-01 Nathan Sidwell ++ ++ * call.c (build_scoped_method_call): Check it is not a namespace. ++ ++2000-08-30 Jason Merrill ++ ++ * cp-tree.h (LOCAL_CLASS_P): Use decl_function_context. ++ ++ * tree.c (bot_manip): Check TREE_CONSTANT rather than ++ !TREE_SIDE_EFFECTS. Call break_out_target_exprs and ++ build_target_expr_with_type for the non-AGGR_INIT_EXPR case. ++ ++ * decl.c (start_function): Always call make_function_rtl. ++ ++2000-08-29 Zack Weinberg ++ ++ * semantics.c (prune_unused_decls): New function. ++ (finish_stmt_tree): Call it via walk_tree. ++ ++2000-08-29 Zack Weinberg ++ ++ * class.c (build_secondary_vtable): Constify a char *. ++ * decl.c (init_decl_processing): Initialize function_id_node, ++ pretty_function_id_node, and func_id_node. ++ * input.c (struct input_source): Constify 'str'. ++ (feed_input): Constify first argument. ++ * mangle.c (write_identifier): Constify argument. ++ * pt.c (mangle_class_name_for_template): Constify argument. ++ ++2000-08-29 Mark Mitchell ++ ++ * typeck.c (mark_addressable): Remove code that pokes around in ++ RTL. ++ ++2000-08-28 Jason Merrill ++ ++ * lex.c (file_name_nondirectory): Move to toplev.c. ++ ++ * cp-tree.h (LOCAL_CLASS_P): New macro. ++ * class.c (finish_struct_1): Use it. ++ ++2000-08-27 Alex Samuel ++ ++ * mangle.c (CLASSTYPE_TEMPLATE_ID_P): Remove unexplained voodoo. ++ (write_encoding): Pass another argument to write_name. ++ (write_name): Add ignore_local_scope parameter. Fix handling of ++ local names. ++ (write_nested_name): Use write_unqualified_name. ++ (write_prefix): Likewise. Skip out on FUNCTION_DECLs. ++ (write_template_prefix): Use write_unqualified_name. ++ (write_component): Remove. ++ (write_local_name): Add parameter. Use direct local entity to ++ discriminator calculation. ++ (write_class_enum_type): Pass another argument to write_name. ++ (write_template_template_arg): Likewise. ++ (make_guard_variable): Likewise. ++ ++2000-08-27 Jason Merrill ++ ++ * decl.c (pushdecl): Matching decls for local externs are found in ++ the current level. Propagate linkage information from previous ++ declarations. ++ ++2000-08-26 Gabriel Dos Reis ++ ++ * ir.texi (Expressions): Fix typo. ++ ++2000-08-25 Greg McGary ++ ++ * tree.c (init_tree): Use ARRAY_SIZE. ++ ++2000-08-25 Gabriel Dos Reis ++ ++ * error.c (cp_tree_printer): Rework. ++ ++2000-08-25 Mark Mitchell ++ ++ * Make-lang.in (CXX_LIB2FUNCS): Remove cp-demangle.o and ++ dyn-string.o. ++ (CXX_LIB2SRCS): Remove cp-demangle.c and dyn-string.c. ++ (cp-demangle.o): Remove target. ++ (dyn-string.o): Likewise. ++ ++ * decl.c (grokfndecl): Require that `main' return an `int'. ++ * mangle.c (write_encoding): Don't mangle return types for ++ conversion functions. ++ ++2000-08-25 Gabriel Dos Reis ++ ++ * error.c (tree_formatting_info): New data type. ++ (tree_being_formatted): New macro. ++ (tree_formatting_flags): Likewise. ++ (put_whitespace): Likewise. ++ (print_tree_identifier): Likewise. ++ (print_identifier): Likewise. ++ (cp_tree_printer, print_function_argument_list, print_declaration, ++ print_expression, print_function_declaration, ++ print_function_parameter, print_type, print_cv_qualifier): New ++ functions. ++ (init_error): Initialize lang_printer. ++ ++2000-08-24 Jason Merrill ++ ++ * typeck.c (build_ptrmemfunc): Just reinterpret if there's no ++ adjustment necessary. ++ ++2000-08-24 Greg McGary ++ ++ * cp-tree.h (MAIN_NAME_P): Remove macro. ++ ++2000-08-24 Gabriel Dos Reis ++ ++ * error.c (print_instantiation_context): Don't forget to flush the ++ buffer. ++ ++2000-08-23 Jason Merrill ++ ++ * typeck.c (build_ptrmemfunc): Save the input pmf. ++ ++ * method.c (process_modifiers): Use same_type_p. ++ ++2000-08-23 Mark Mitchell ++ ++ * cp-tree.h (DECL_CLONED_FUNCTION_P): Check DECL_LANG_SPECIFIC. ++ * mangle.c (write_function_type): Change prototype. ++ (write_encoding): Don't mangle return types for ++ constructors or destructors. ++ (write_type): Adjust call to write_function_type. ++ * pt.c (instantiate_template): Instantiate alternate entry points ++ when instantiating the main function. ++ ++2000-08-23 Gabriel Dos Reis ++ ++ * error.c (cp_print_error_function): Don't use embedded '\n' in ++ output_printf. ++ ++2000-08-23 Gabriel Dos Reis ++ ++ * decl.c (init_decl_processing): Remove bogus initialization. ++ * error.c (lang_print_error_function): Restore here. ++ (init_error): Initialize print_error_function. ++ ++2000-08-22 Theodore Papadopoulo ++ ++ * decl2.c (arg_assoc): Revert my 2000-08-11 change. ++ ++2000-08-22 Gabriel Dos Reis ++ ++ * Makefile.in (error.o): Depends on diagnostic.h ++ ++ * cp-tree.h (problematic_instantiation_changed, ++ record_last_problematic_instantiation, current_instantiation, ++ print_instantiation_context): Declare. ++ (maybe_print_template_context): Remove. ++ ++ * decl.c (init_decl_processing): Set print_error_function to NULL. ++ (lang_print_error_function): Remove, since we're using a new ++ machinery. ++ ++ * error.c: #include diagnostic.h ++ (function_category): New function. ++ (cp_diagnostic_starter): Likewise. ++ (cp_diagnostic_finalizer): Likewise. ++ (cp_print_error_function): Likewise. ++ (maybe_print_instantiation_context): Likewise. ++ (print_instantiation_full_context): Likewise. ++ (print_instantiation_partial_context): Likewise. ++ (print_instantiation_context): Define. ++ (init_error): Initialize diagnostic pager and finalizer. ++ ++ * pt.c (problematic_instantiation_changed): Define. ++ (record_last_problematic_instantiation): Likewise. ++ (current_instantiation): Likewise. ++ (maybe_print_template_context): Remove. ++ (print_template_context): Likewise. ++ (current_tinst_level): Make static to reflect Brendan Kehoe's ++ change of 1995-04-13. ++ (push_tinst_level): Call print_instantiation_context. ++ ++2000-08-21 Nix ++ ++ * lang-specs.h: Do not process -o or run the assembler if ++ -fsyntax-only. ++ ++2000-08-21 Joseph S. Myers ++ ++ * decl.c (flag_hosted, flag_noniso_default_format_attributes): New ++ variables. ++ * decl2.c (lang_decode_option): Disable gettext attributes for ++ -ansi. ++ ++2000-08-21 Gabriel Dos Reis ++ ++ * lex.c (lang_init_options): Default diagnostic message maximum ++ length to 80, when line-wrapping. ++ ++2000-08-20 Mark Mitchell ++ ++ * class.c (build_vtbl_initializer): Clear the entire ++ vtbl_init_data. Start keeping track of the functions for which we ++ have created vcall offsets here. ++ (dfs_build_vcall_offset_vtbl_entries): Remove. ++ (build_vcall_offset_vtbl_entries): Reimplement. ++ (add_vcall_offset_vtbl_entries_r): New function. ++ (add_vcall_offset_vtbl_entries_1): Likewise. Tweak logic for ++ computing when vcall offsets are necessary. ++ ++2000-08-18 Nathan Sidwell ++ ++ * decl.c (member_function_or_else): Use cp_error ... %T. ++ (grokdeclarator): Likewise. ++ (start_method): Likewise. ++ * friend.c (make_friend_class): Use cp_pedwarn ... %T. ++ ++2000-08-18 Nathan Sidwell ++ ++ * decl2.c (grokfield): Set CLASSTYPE_GOT_SEMICOLON on class ++ TYPE_DECLs. ++ ++2000-08-18 Nathan Sidwell ++ ++ * cp-tree.h (PTRMEM_OK_P): New macro. ++ (itf_ptrmem_ok): New enumeration value. ++ * class.c (resolve_address_of_overloaded_function): Add PTRMEM ++ argument. Diagnose implicit pointer to member. ++ (instantiate_type): Don't diagnose implicit pointer to member ++ here. Pass itf_ptrmem_ok if ok. Adjust calls to ++ resolve_address_of_overloaded_function. ++ * init.c (build_offset_ref): Set PTRMEM_OK_P. ++ (resolve_offset_ref): Don't diagnose implicit pointer to member here. ++ * semantics.c (finish_parenthesized_expr): Clear OFFSET_REFs here. ++ * typeck.c (build_x_unary_op): Calculate PTRMEM_OK_P. ++ (build_unary_op): Deal with single non-static member in ++ microsoft-land. ++ ++2000-08-18 Nathan Sidwell ++ ++ * decl2.c (arg_assoc_type): Cope with TYPENAME_TYPE. ++ ++2000-08-18 Nathan Sidwell ++ ++ * cp-tree.h (enum_name_string): Remove prototype. ++ (report_case_error): Remove prototype. ++ * cp/typeck2.c (enum_name_string): Remove. ++ (report_case_error): Remove. ++ * error.c (dump_expr): Deal with enum values directly. ++ Correctly negate integer constant. ++ ++2000-08-17 Nathan Sidwell ++ ++ * inc/cxxabi.h (__cxa_vec_new2, __cxa_vec_new3): Declare. ++ (__cxa_vec_delete2, __cxa_vec_delete3): Declare. ++ * vec.cc (__cxa_vec_new2, __cxa_vec_new3): Implement. ++ (__cxa_vec_delete2, __cxa_vec_delete3): Implement. ++ (__cxa_vec_new): Use __cxa_vec_new2. ++ (__cxa_vec_delete): Use __cxa_vec_delete2. ++ ++2000-08-17 Nathan Sidwell ++ ++ * vec.cc (__cxa_vec_new): Set "C" linkage. ++ (__cxa_vec_ctor): Likewise. ++ (__cxa_vec_cctor): Likewise. ++ (__cxa_vec_dtor): Likewise. ++ (__cxa_vec_delete): Likewise. ++ * inc/cxxabi.h (__cxa_vec_new): Set "C" linkage. ++ (__cxa_vec_ctor): Likewise. ++ (__cxa_vec_cctor): Likewise. ++ (__cxa_vec_dtor): Likewise. ++ (__cxa_vec_delete): Likewise. ++ ++2000-08-17 Nathan Sidwell ++ ++ * class.c (instantiate_type): Reinstate local variable ++ deleted in previous change. ++ ++ * cvt.c (cp_convert_to_pointer): Pass itf_complain, not ++ itf_no_attributes. ++ ++2000-08-17 Nathan Sidwell ++ ++ * cp-tree.h (instantiate_type_flags): New enumeration. ++ (instantiate_type): Change parameter. ++ * class.c (instantiate_type): Adjust prototype. Adjust. ++ * call.c (standard_conversion): Adjust instantiate_type call. ++ (reference_binding): Likewise. ++ (build_op_delete_call): Likewise. ++ (convert_like_real): Likewise. ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ (convert_to_reference): Likewise. ++ * pt.c (convert_nontype_argument): Likewise. ++ * typeck.c (build_binary_op): Likewise. ++ (build_ptrmemfunc): Likewise. ++ (convert_for_assignment): Likewise. ++ ++2000-08-17 Nathan Sidwell ++ ++ * cp-tree.h (CPTR_AGGR_TAG): New global tree node. ++ (current_aggr): Define. ++ * decl.c (grokdeclarator): Make sure a friend class is an ++ elaborated type specifier. ++ * parse.y (current_aggr): Remove static definition. ++ (cp_parse_init): Adjust. ++ (structsp): Clear and restore current_aggr. ++ (component_decl_list): Clear current_aggr. ++ ++ * error.c (dump_type, case TYPENAME_TYPE): Don't emit the ++ aggregate tag on the typename's context. ++ ++ * pt.c (tsubst_friend_class): Return error_mark_node, if ++ parms becomes NULL. ++ (instantiate_class_template): Ignore error_mark_node friend types. ++ ++2000-08-14 Nathan Sidwell ++ ++ * cvt.c (warn_ref_binding): New static function, broken out of ... ++ (convert_to_reference): ... here. Use it. ++ ++2000-08-11 Kriang Lerdsuwanakij ++ ++ * parse.y (template_arg): Add rule for template qualified with ++ global scope. ++ ++2000-08-11 Theodore Papadopoulo ++ ++ * decl2.c (add_function): Reorganize. ++ (arg_assoc): Do not consider function template decls. ++ ++2000-08-11 Jason Merrill ++ ++ * decl.c (lookup_name_real): Don't forget the TYPENAME_TYPE we're ++ looking inside. ++ ++2000-08-11 Nathan Sidwell ++ ++ * cp-tree.h (resolve_scope_to_name): Remove unused prototype. ++ (lookup_nested_tag): Likewise. ++ ++ * decl2.c (grokfield): Fix comment to reflect many types of _DECLs ++ can be produced. ++ ++2000-08-11 Nathan Sidwell ++ ++ * parse.y (named_complex_class_head_sans_basetype): Remove ++ always true if. ++ ++2000-08-11 Nathan Sidwell ++ ++ * decl2.c (build_expr_from_tree, case METHOD_CALL_EXPR): Build ++ explicit TEMPLATE_ID_EXPR args. ++ (build_expr_from_tree, case CALL_EXPR): Likewise. ++ ++2000-08-11 Nathan Sidwell ++ ++ * decl.c (check_tag_decl): Diagnose typename's which don't ++ declare anything. ++ ++2000-08-10 Nathan Sidwell ++ ++ * init.c (build_aggr_init): Reject bogus array initializers ++ early. ++ ++2000-08-09 Nathan Sidwell ++ ++ * rtti.c (build_dynamic_cast_1): Set "C" linkage for new abi ++ runtime. ++ * cp/tinfo.cc (__dynamic_cast): Likewise. ++ * cp/inc/cxxabi.h (__dynamic_cast): Likewise. ++ ++2000-08-09 Nathan Sidwell ++ ++ * cvt.c (convert_to_pointer_force): Fix error message when ++ attempting to cast from ambiguous base. ++ ++2000-08-08 Jason Merrill ++ ++ * pt.c (tsubst_aggr_type): Bail if creating the argvec fails. ++ (tsubst_template_arg_vector): Likewise. ++ ++ * decl2.c (build_anon_union_vars): Choose the largest field; don't ++ assume that one will be as large as the union. ++ ++2000-08-07 Kazu Hirata ++ ++ * cp-tree.h (CLASSTYPE_HAS_PRIMARY_BASE_P): Fix a comment typo. ++ * decl.c (pop_labels): Likewise. ++ ++2000-08-04 Jeffrey Oldham ++ ++ * inc/cxxabi.h (__pbase_type_info): Changed member names to match ++ specifications. ++ (__pointer_to_member_type_info): Likewise. ++ (__base_class_info): Likewise. ++ (__class_type_info): Likewise. ++ (__si_class_type_info): Likewise. ++ (__vmi_class_type_info): Likewise. ++ * tinfo.cc (__si_class_type_info::__do_find_public_src): ++ Changed member names to match specifications. ++ (__vmi_class_type_info::__do_find_public_src): Likewise. ++ (__si_class_type_info::__do_dyncast): Likewise. ++ (__vmi_class_type_info::__do_dyncast): Likewise. ++ (__si_class_type_info::__do_upcast): Likewise. ++ (__vmi_class_type_info::__do_upcast): Likewise. ++ * tinfo2.cc (__pbase_type_info::__do_catch): Likewise. ++ (__pbase_type_info::__pointer_catch): Likewise. ++ (__pointer_type_info::__pointer_catch): Likewise. ++ (__pointer_to_member_type_info::__pointer_catch): Likewise. ++ ++2000-08-04 Zack Weinberg ++ ++ * Make-lang.in (cc1plus): Depend on $(BACKEND), not stamp-objlist. ++ * Makefile.in: Add C_OBJS, BACKEND; delete OBJS, OBJDEPS. ++ (cc1plus): Link with $(BACKEND) and $(C_OBJS). ++ ++2000-08-04 Mark Mitchell ++ ++ * cp-tree.h (add_method): Change prototype. ++ * class.c (add_method): Remove FIELDS parameter. Add ERROR_P. ++ Don't double the size of the method vector in the error case. ++ (handle_using_decl): Adjust call to add_method. ++ (add_implicitly_declared_members): Likewise. ++ (clone_function_decl): Likewise. ++ * decl2.c (check_classfn): Likewise. ++ * semantics.c (finish_member_declaration): Likewise. ++ ++2000-08-04 Joseph S. Myers ++ ++ * decl.c (flag_isoc94): New variable. ++ ++2000-08-02 Jason Merrill ++ ++ * pt.c (do_type_instantiation): Add complain parm; don't complain ++ if called recursively. ++ * cp-tree.h, parse.y: Adjust. ++ ++2000-08-02 Zack Weinberg ++ ++ * decl2.c: Silently ignore -Wstrict-prototypes; warn about ++ -Wno-strict-prototypes. ++ ++ * g++spec.c: Adjust type of second argument to ++ lang_specific_driver, and update code as necessary. ++ ++ * cp-tree.h: Don't prototype min_precision here. ++ (my_friendly_assert): Cast expression to void. ++ * semantics.c (do_poplevel): Initialize scope_stmts. ++ ++2000-08-02 Mark Mitchell ++ ++ * cp-tree.h (DECL_NEEDED_P): Tweak. ++ ++2000-07-28 Jason Merrill ++ ++ * lang-specs.h: Use %i in rule for .ii files. ++ ++2000-07-31 Zack Weinberg ++ ++ * lang-specs.h: Rename cpp to cpp0 and/or tradcpp to tradcpp0. ++ ++2000-07-30 Mark Mitchell ++ ++ Allow indirect primary bases. ++ * cp-tree.h (struct lang_type): Remove vfield_parent. Add ++ primary_base. ++ (CLASSTYPE_VFIELD_PARENT): Remove. ++ (CLASSTYPE_PRIMARY_BINFO): Reimplement. ++ (BINFO_PRIMARY_BINFO): Remove. ++ (CLASSTYPE_HAS_PRIMARY_BASE_P): Reimplement. ++ (BINFO_VBASE_PRIMARY_P): Likewise. ++ (BINFO_PRIMARY_BASE_OF): New macro. ++ (BINFO_INDIRECT_PRIMARY_P): Likewise. ++ (get_primary_binfo): New function. ++ * decl.c (lang_mark_tree): Make lang_type::primary_base. ++ * class.c (vcall_offset_data_s): Rename to ... ++ (vtbl_init_data_s): ... this. Rename primary_p to primary_vtbl_p, ++ and add ctor_vtbl_p. ++ (get_derived_offset): Use get_primary_binfo. ++ (dfs_mark_primary_bases): Adjust handling of virtual primary ++ bases. ++ (mark_primary_bases): Likewise. ++ (set_primary_base): Take a binfo, not an integer, as a ++ representation of the primary base. ++ (indirect_primary_base_p): Remove. ++ (determine_primary_base): Adjust for indirect primary bases. ++ (dfs_find_final_overrider): Fix typo in coment. ++ (update_vtable_entry_for_fn): Use get_primary_binfo. ++ (layout_nonempty_base_or_field): Tweak. ++ (build_base_fields): Adjust for new primary base semantics. ++ (dfs_propagate_binfo_offsets): Remove. ++ (propagate_binfo_offsets): Rewrite. ++ (dfs_set_offset_for_shared_vbases): Remove. ++ (layout_virtual_bases): Don't use it. ++ (layout_class_type): Set CLASSTYPE_SIZE correctly under the new ++ ABI. ++ (finish_struct_1): Set CLASSTYPE_PRIMARY_BINFO, not ++ CLASSTYPE_VFIELD_PARENT. ++ (dfs_get_primary_binfo): New function. ++ (get_primary_binfo): Likewise. ++ (dump_class_hierarchy_r): Tweak printing of primary bases. ++ (build_vtbl_initializer): Fix typo in comments. Use ++ vtbl_init_data. ++ (build_vcall_and_vbase_vtbl_entries): Likewise. ++ (build_vbaes_offset_vtbl_entries): Likewise. ++ (dfs_build_vcall_offset_vtbl_entries): Adjust setting of ++ BV_VCALL_INDEX to handle indirect primary bases. ++ (build_vcall_offset_vtbl_entries): Use vtbl_init_data. ++ (build_rtti_vtbl_entries): Likewise. ++ * search.c (get_shared_vbase_if_not_primary): Tweak. ++ (find_vbase_instance): Likewise. ++ (binfo_for_vtable): Simplify. ++ * tree.c (unshare_base_binfos): Clear BINFO_PRIMARY_BASE_OF. ++ (make_binfo): Make it have 11 entries. ++ ++2000-07-30 Alex Samuel ++ ++ * mangle.c (DECL_TEMPLATE_ID_P): Remove. ++ (CLASSTYEP_TEMPLATE_ID_P): Check template info, and context when ++ ascertaining primaryness. ++ (G): Remove template_args. ++ (decl_is_template_id): New function. ++ (write_encoding): Use decl_is_template_id. ++ (write_name): Likewise. Handle type_decls. Get main variant of ++ type decls. ++ (write_nested_name): Likewise. ++ (write_prefix): Likewise. ++ (write_template_prefix): Likewise. ++ (write_special_name_constructor): Remove defunct production from ++ comment. ++ (write_bare_function_type): Remove comment about absent parameter. ++ (write_template_template_arg): Add missing grammar production to ++ comment. ++ ++2000-07-27 Jason Merrill ++ ++ * decl.c (duplicate_decls): If common_type produces a non-typedef ++ type for a typedef, just use the old type. ++ ++2000-07-27 Mark Mitchell ++ ++ * cp-tree.h (function_depth): Declare. ++ (verify_stmt_tree): Likewise. ++ (find_tree): Likewise. ++ * decl.c (function_depth): Give it external linkage. ++ * optimize.c (optimize_function): Increment and decrement it. ++ * tree.c (verify_stmt_tree_r): New function. ++ (verify_stmt_tree): Likewise. ++ (find_tree_r): Likewise. ++ (find_tree): Likewise. ++ ++2000-07-27 Jason Merrill ++ ++ * pt.c (for_each_template_parm_r, case RECORD_TYPE): Use ++ TYPE_PTRMEMFUNC_P. ++ * cp-tree.h (TYPE_TEMPLATE_INFO): Check for TYPE_LANG_SPECIFIC. ++ ++2000-07-26 Mark Mitchell ++ ++ * decl.c (start_cleanup_fn): Mark the function as `inline'. ++ * decl2.c (get_guard): Call cp_finish_decl, not ++ rest_of_decl_compilation, for local guards. ++ * lex.c (do_identifier): Remove unused variable. ++ ++2000-07-26 Marc Espie ++ ++ * parse.y: Add missing ';'. ++ ++2000-07-26 Mark Mitchell ++ ++ * parse.y (empty_parms): Use `()', not `(...)', when in the scope ++ of `extern "C++"'. ++ ++2000-07-25 Nathan Sidwell ++ ++ Kill strict_prototype. Backwards compatibility only for ++ non NO_IMPLICIT_EXTERN_C systems. ++ * cp-tree.h (flag_strict_prototype): Remove. ++ (strict_prototype): Remove. ++ (strict_prototypes_lang_c, strict_prototypes_lang_cplusplus): Remove. ++ * decl.c (maybe_push_to_top_level): Adjust. ++ (pop_from_top_level): Adjust. ++ (decls_match): Only allow sloppy parm matching for ancient ++ system headers. ++ (init_decl_processing): Adjust. ++ (grokdeclarator): Adjust. ++ * decl2.c (flag_strict_prototype): Remove. ++ (strict_prototype): Remove. ++ (strict_prototypes_lang_c, strict_prototypes_lang_cplusplus): Remove. ++ (lang_f_options): Remove "strict-prototype". ++ (unsupported-options): Add "strict-prototype". ++ * lex.c (do_identifier): Adjust. ++ (do_scoped_id): Adjust. ++ * parse.y (empty_parms): Adjust. ++ * class.c (push_lang_context): Adjust. ++ (pop_lang_context): Adjust. ++ * typeck.c (comp_target_parms): Adjust. ++ ++2000-07-25 Nathan Sidwell ++ ++ * decl.c (poplevel): Deal with anonymous variables at for scope. ++ (maybe_inject_for_scope_var): Likewise. ++ ++2000-07-25 Zack Weinberg ++ ++ * decl.c: Remove all signal handling code, now done in toplev.c. ++ ++2000-07-23 Mark Mitchell ++ ++ * decl.c (make_rtl_for_nonlocal_decl): Rework. ++ ++ * pt.c (lookup_template_class): Ensure that TYPE_CONTEXT is set ++ correctly. ++ ++2000-07-20 Zack Weinberg ++ ++ * cp-tree.h: Use __FUNCTION__ not __PRETTY_FUNCTION__. ++ Define my_friendly_assert and my_friendly_abort as macros ++ which may call friendly_abort. Prototype friendly abort, not ++ my_friendly_abort or my_friendly_assert. ++ * decl.c (signal_catch): Report the signal caught in the error ++ message. Call fatal directly. ++ * typeck2.c (ack, my_friendly_assert): Delete. ++ (my_friendly_abort): Rename to friendly_abort. Expect file, ++ line, and function parameters. Report the abort code, then ++ call fancy_abort. Do not mask an abort if errors have ++ already occurred. ++ ++2000-07-18 Nathan Sidwell ++ ++ * typeck.c (comp_target_parms): Remove obsolete parameter. ++ (comp_target_types): Adjust. ++ ++2000-07-17 Jason Merrill ++ ++ * typeck.c (mark_addressable): Never set TREE_USED. ++ * call.c (build_call): Don't abort on calls to library functions ++ that have been declared normally. ++ ++ * typeck.c (build_binary_op): Fix grammar in warning. ++ ++ * exception.cc (__eh_free): Fix prototype. ++ ++ * decl2.c (finish_decl_parsing): Handle TEMPLATE_ID_EXPR. ++ ++ * decl.c (pushdecl): Handle seeing an OVERLOAD in ++ IDENTIFIER_NAMESPACE_VALUE. ++ ++2000-07-16 Mark Mitchell ++ ++ * cp-tree.h (THUNK_VCALL_OFFSET): Update documentation. ++ * method.c (use_thunk): Correct handling of vcall offsets. ++ ++2000-07-14 Zack Weinberg ++ ++ * .cvsignore: parse.h and parse.c have no cp- prefix. ++ ++2000-07-13 Mark Mitchell ++ ++ * .cvsignore: New file. ++ ++2000-07-13 Zack Weinberg ++ ++ * lang-specs.h: Use the new named specs. Remove unnecessary braces. ++ ++2000-07-12 Mark Mitchell ++ ++ * Makefile.in ($(PARSE_H)): Depend directly on parse.y. ++ * parse.c: Remove. ++ * parse.h: Likewise. ++ ++2000-07-11 Mark Mitchell ++ ++ * class.c (layout_class_type): Add pointers to virtual bases after ++ base classes under the old ABI. ++ ++2000-07-10 Benjamin Chelf ++ ++ * semantics.c (finish_for_stmt): Remove call to emit_line_note. ++ (finish_continue_stmt): Likewise. ++ (begin_for_stmt): Remove call to note_level_for_for. ++ (finish_goto_stmt): Change call from build_min_nt ++ to build_stmt. ++ (finish_expr_stmt): Likewise. ++ (begin_if_stmt): Likewise. ++ (begin_while_stmt): Likewise. ++ (finish_while_stmt): Likewise. ++ (finish_return_stmt): Likewise. ++ (begin_for_stmt): Likewise. ++ (finish_for_stmt): Likewise. ++ (finish_break_stmt): Likewise. ++ (begin_switch_stmt): Likewise. ++ (finish_case_label): Likewise. ++ (genrtl_try_block): Likewise. ++ (begin_try_block): Likewise. ++ (begin_handler): Likewise. ++ (begin_compound_stmt): Likewise. ++ (finish_asm_stmt): Likewise. ++ (finish_label_stmt): Likewise. ++ (add_decl_stmt): Likewise. ++ (finish_subobject): Likewise. ++ (finish_decl_cleanup): Likewise. ++ (finish_named_return_value): Likewise. ++ (setup_vtbl_ptr): Likewise. ++ (add_scope_stmt): Likewise. ++ * decl.c (finish_constructor_body): Likewise. ++ (finish_destructor_body): Likewise. ++ * optimize.c (copy_body_r): Likewise. ++ (initialize_inlined_parameters): Likewise. ++ (declare_return_variable): Likewise. ++ (expand_call_inline): Likewise. ++ ++2000-07-10 Jakub Jelinek ++ ++ * semantics.c (expand_body): Sync interface information ++ at the end of function body expansion. ++ ++2000-07-09 Jason Merrill ++ ++ * init.c (build_new_1): Bail early if the call to new fails. ++ ++ * decl.c (compute_array_index_type): Check specifically for ++ an INTEGER_CST, not just TREE_CONSTANT. ++ ++ * decl.c (duplicate_decls): Don't call duplicate_decls on ++ the DECL_TEMPLATE_RESULT. ++ (decls_match): Return 0 if the DECL_TEMPLATE_RESULTs have different ++ codes. ++ ++ * error.c (dump_template_bindings): Don't crash if we had an ++ invalid argument list. ++ ++ * typeck.c (c_expand_start_case): Do narrowing here. ++ * semantics.c (finish_switch_cond): Not here. ++ ++2000-07-09 Hidvegi Zoli ++ ++ * parse.y (asm_clobbers): Do string concatenation. ++ ++2000-07-09 Mark Mitchell ++ ++ * decl.c (pushtag): Don't put local classes in template functions ++ on the local_classes list. ++ ++2000-07-04 Scott Snyder ++ ++ * decl2.c (get_guard): Add missing return for old ABI local ++ variable case. ++ ++2000-07-09 Mark Mitchell ++ ++ * cp-tree.h (char_type_p): New function. ++ * decl.c (init_decl_processing): Don't initialize ++ signed_wchar_type_node or unsigned_wchar_type_node. ++ (complete_array_type): Handle brace-enclosed string-constants. ++ * rtti.c (emit_support_tinfos): Remove #if 0'd code. ++ * tree.c (char_type_p): New function. ++ * typeck2.c (digest_init): Use char_type_p. ++ ++2000-07-06 Nathan Sidwell ++ ++ * pt.c (tsubst): Don't layout type, if it's error_mark. ++ ++2000-07-06 Nathan Sidwell ++ ++ * pt.c (instantiate_pending_templates): Reset template level. ++ ++2000-07-05 Jason Merrill ++ ++ * call.c (joust): Don't complain about `operator char *()' beating ++ `operator const char *() const'. ++ ++2000-07-04 scott snyder ++ Jason Merrill ++ ++ * repo.c (repo_get_id): Handle the case where a class with virtual ++ bases has a null TYPE_BINFO_VTABLE. ++ ++2000-07-04 Kevin Buhr ++ Jason Merrill ++ ++ * parse.y (member_init): Just pass in the type. ++ * init.c (expand_member_init): Handle getting a type. ++ ++2000-07-04 Martin v. Löwis ++ Jason Merrill ++ ++ * decl.c (finish_function): Warn if a function has no return ++ statement. ++ Suggested by Andrew Koenig. ++ * typeck.c (check_return_expr): Do set current_function_returns_value ++ if we got an error_mark_node. ++ ++2000-07-03 Nathan Sidwell ++ ++ * decl2.c (push_decl_namespace): Push the original namespace. ++ ++2000-07-03 Nathan Sidwell ++ ++ * pt.c (instantiate_class_template): Set CLASSTYPE_VBASECLASSES. ++ * semantics.c (begin_class_definition): Clear it. ++ ++2000-07-02 Benjamin Chelf ++ ++ * cp-tree.h (genrtl_goto_stmt): Remove declaration. ++ (genrtl_expr_stmt): Likewise. ++ (genrtl_decl_stmt): Likewise. ++ (genrtl_if_stmt): Likewise. ++ (genrtl_while_stmt): Likewise. ++ (genrtl_do_stmt): Likewise. ++ (genrtl_return_stmt): Likewise. ++ (genrtl_for_stmt): Likewise. ++ (genrtl_break_stmt): Likewise. ++ (genrtl_continue_stmt): Likewise. ++ (genrtl_scope_stmt): Likewise. ++ (genrtl_switch_stmt): Likewise. ++ (genrtl_case_label): Likewise. ++ (genrtl_begin_compound_stmt): Likewise. ++ (genrtl_finish_compound_stmt): Likewise. ++ (genrtl_compound_stmt): Likewise. ++ (genrtl_asm_stmt): Likewise. ++ ++ * init.c (begin_init_stmts): Remove call to ++ genrtl_begin_compound_stmt. ++ (finish_init_stmts): Remove call to genrtl_finish_compound_stmt. ++ ++ * semantics.c (lang_expand_stmt): Changed call to ++ genrtl_compound_stmt to ignore return value. ++ ++2000-07-02 Mark Mitchell ++ ++ * mangle.c (canonicalize_for_substitution): Return the canonical ++ variant of a type. ++ ++ * decl.c (duplicate_decls): Preserve DECL_ORIGINAL_TYPE for a ++ TYPE_DECL. ++ * typeck.c (commonparms): Remove obstack manipulations. ++ ++2000-07-01 Benjamin Chelf ++ ++ * Make-lang.in (cc1plus$(exeext)): Added c-semantics.o. ++ ++ * Makefile.in (OBJS): Added ../c-semantics.o. ++ (OBJDEPS): Likewise. ++ ++ * cp-tree.h (TREE_LANG_FLAG_?): Moved common documentation to ++ ../c-common.h. ++ (struct stmt_tree): Added comment. ++ (current_function_name_declared): Removed. ++ (stmts_are_full_exprs_p): Likewise. ++ (genrtl_do_pushlevel): Likewise. ++ (genrtl_clear_out_block): Likewise. ++ (COMPOUND_STMT_NO_SCOPE): Moved to ../c-common.h. ++ (DECL_ANON_UNION_ELEMS): Likewise. ++ (emit_local_var): Likewise. ++ (make_rtl_for_local_static): Likewise. ++ (do_case): Likewise. ++ (expand_stmt): Likewise. ++ (genrtl_decl_cleanup): Likewise. ++ (c_expand_asm_operands): Likewise. ++ (c_expand_return): Likewise. ++ (c_expand_start_case): Likewise. ++ ++ * decl.c (make_rtl_for_local_static): Moved to c-semantics.c. ++ (emit_local_var): Likewise. ++ (initialize_local_var): Change reference to ++ stmts_are_full_exprs_p to call to stmts_are_full_exprs_p(). ++ Change reference to stmts_are_full_exprs_p to ++ current_stmt_tree->stmts_are_full_exprs_p. ++ (push_cp_function_context): Likewise. ++ ++ * expect.c (expand_throw): Change reference to ++ stmts_are_full_exprs_p. ++ ++ * init.c (build_aggr_init): Change reference to ++ stmts_are_full_exprs_p. ++ (build_vec_init): Likewise. ++ ++ * optimize.c (maybe_clone_body): Change reference to ++ current_function_name_declared to ++ cp_function_chain->name_declared. ++ ++ * pt.c (instantiate_decl): Change reference to ++ current_function_name_declared to ++ cp_function_chain->name_declared. ++ ++ * semantics.c (expand_cond): Moved declaration to c-common.h. ++ (genrtl_do_pushlevel): Moved to c-semantics.c. ++ (genrtl_clear_out_block): Likewise. ++ (genrtl_goto_stmt): Likewise. ++ (genrtl_expr_stmt): Likewise. ++ (genrtl_decl_stmt): Likewise. ++ (gerntl_if_stmt): Likewise. ++ (genrtl_while_stmt): Likewise. ++ (genrtl_do_stmt): Likewise. ++ (genrtl_return_stmt): Likewise. ++ (genrtl_for_stmt): Likewise. ++ (genrtl_break_stmt): Likewise. ++ (genrtl_continue_stmt): Likewise. ++ (genrtl_scope_stmt): Likewise. ++ (genrtl_switch_stmt): Likewise. ++ (genrtl_case_label): Likewise. ++ (genrtl_begin_compound_stmt): Likewise. ++ (genrtl_finish_compound_stmt): Likewise. ++ (genrtl_compound_stmt): Likewise. ++ (genrtl_asm_stmt): Likewise. ++ (genrtl_decl_cleanup): Likewise. ++ (expand_cond): Likewise. ++ (expand_stmt): Renamed to ... ++ (lang_expand_stmt): ... this. ++ (lang_expand_expr_stmt): Initialize. ++ (set_current_function_name_declared): Likewise. ++ (stmts_are_full_exprs_p): Likewise. ++ (current_function_name_declared): Likewise. ++ (anon_aggr_type_p): Likewise. ++ (do_poplevel): Change reference to ++ stmts_are_full_exprs_p to call to stmts_are_full_exprs_p(). ++ Change reference to stmts_are_full_exprs_p to ++ current_stmt_tree->stmts_are_full_exprs_p. ++ (add_tree): Likewise. ++ (finish_expr_stmt): Likewise. ++ (prep_stmt): Likewise. ++ (lang_expand_stmt): Likewise. ++ (begin_compound_stmt): Change reference to ++ current_function_name_declared to ++ cp_function_chain->name_declared and call to ++ current_function_name_declared(). ++ (setup_vtbl_ptr): Likewise. ++ (genrtl_do_poplevel): Removed. ++ ++2000-06-30 Jason Merrill ++ ++ * init.c (init_init_processing): Go back to aligning like ++ double_type_node for old ABI. ++ (get_cookie_size): Make cookie larger if we get a type that needs ++ more alignment. ++ (build_vec_delete): Call it. ++ ++ * typeck.c (qualify_type_recursive): New fn. ++ (composite_pointer_type): Use it. ++ (build_binary_op): Use composite_pointer_type. ++ ++2000-06-24 Carlos O'Ryan ++ Jason Merrill ++ ++ * typeck.c (check_return_expr): Don't complain about returning ++ NULL from operator new if -fcheck-new. ++ * cp-tree.h: Declare flag_check_new here. ++ * init.c: Not here. ++ ++2000-06-28 Alex Samuel ++ ++ * mangle.c (find_substitution): Use same_type_p. ++ (write_encoding): Don't check for substitutions. ++ ++2000-06-30 Nathan Sidwell ++ ++ * parse.y (expr_no_comma_rangle): New non-terminal. ++ (template_parm): Use it for default parameter case. ++ (template_arg): Use it. ++ (expr_no_commas): Remove commented out undefined extensions. ++ * Makefile.in (CONFLICTS): Adjust to 33 s/r & 48 r/r. ++ * parse.h, parse.c: Rebuilt. ++ ++2000-06-30 Mark Mitchell ++ ++ * semantics.c (genrtl_asm_stmt): Don't decay input operands here. ++ (finish_asm_stmt): Do it here, instead. ++ ++ * cp-tree.h (ridpointers): Don't declare. ++ * decl.c (record_builtin_type): Use CP_RID_MAX instead of RID_MAX. ++ (record_builtin_java_type): Likewise. ++ (init_decl_processing): Likewise. ++ * lex.c: Move inclusion of lex.h. ++ (ridpointers): Don't define. ++ (init_parse): Initialize ripdointers. Use CP_RID_MAX instead of ++ RID_MAX. ++ * lex.h (enum rid): Rename to ... ++ (enum cp_rid): ... this. ++ (ridpointers): Don't declare. ++ * parse.y: Move inclusion of lex.h. ++ * parse.c: Regenerated. ++ * spew.c: Move inclusion of lex.h. ++ ++ * cp-tree.h (struct language_function): Remove temp_name_counter. ++ (temp_name_counter): Remove. ++ (get_temp_name): Change prototype. ++ (get_guard): New function. ++ (get_guard_cond): Likewise. ++ (set_guard): Likewise. ++ * cvt.c (build_up_reference): Adjust call to get_temp_name. ++ * decl.c (expand_static_init): Use get_guard and friends to ++ implement guard variables. ++ * decl2.c (get_temp_name): Assume that the variables created are ++ always static. ++ (get_sentry): Rename to ... ++ (get_guard): ... this. Implement new ABI guard variables. ++ (get_guard_bits): New function. ++ (get_guard_cond): Likewise. ++ (set_guard): Likewise. ++ (start_static_initialization_or_destruction): Use them. ++ (do_static_initialization): Replace sentry with guard throughout. ++ (do_static_destruction): Likewise. ++ * init.c (create_temporary_var): Add comment. ++ ++2000-06-28 Alex Samuel ++ ++ * mangle.c (find_substitution): Use same_type_p. ++ (write_encoding): Don't check for substitutions. ++ ++2000-06-30 Nathan Sidwell ++ ++ * parse.y (expr_no_comma_rangle): New non-terminal. ++ (template_parm): Use it for default parameter case. ++ (template_arg): Use it. ++ (expr_no_commas): Remove commented out undefined extensions. ++ * Makefile.in (CONFLICTS): Adjust to 33 s/r & 48 r/r. ++ * parse.h, parse.c: Rebuilt. ++ ++2000-06-29 Mark Mitchell ++ ++ * cp-tree.h (flag_const_strings): Remove. ++ (warn_parentheses): Likewise. ++ (warn_format): Likewise. ++ (common_type): Likewise. ++ (default_conversion): Likewise. ++ (build_binary_op): Likewise. ++ (cp_build_binary_op): New macro. ++ * call.c (build_new_op): Use cp_build_binary_op instead of ++ build_binary_op. ++ * class.c (build_vtable_entry_ref): Likewise. ++ * decl.c (expand_static_init): Likewise. ++ (compute_array_index_type): Likewise. ++ (build_enumerator): Likewise. ++ * decl2.c (delete_sanity): Likewise. ++ (start_static_initialization_or_destruction): Likewise. ++ * error.c (dump_type_suffix): Likewise. ++ * init.c (resolve_offset_ref): Likewise. ++ (build_new): Likewise. ++ (build_new_1): Likewise. ++ (build_vec_delete_1): Likewise. ++ (build_vec_init): Likewise. ++ (build_delete): Likewise. ++ * rtti.c (synthesize_tinfo_fn): Likewise. ++ (synthesize_tinfo_var): Likewise. ++ * search.c (expand_upcast_fixups): Likewise. ++ (fixup_all_virtual_upcast_offsets): Likewise. ++ * typeck.c (build_array_ref): Likewise. ++ (get_member_function_from_ptrfunc): Likewise. ++ (build_binary_op): Add parameter. ++ (pointer_int_sum): Use cp_build_binary_op. ++ (pointer_diff): Likewise. ++ (build_modify_expr): Likewise. ++ (get_delta_difference): Likewise. ++ (build_ptrmemfunc): Likewise. ++ ++2000-06-29 Nathan Sidwell ++ ++ * cp-tree.h (SET_DECL_ARTIFICIAL): Remove. ++ * decl.c (create_implicit_typedef): Adjust. ++ * decl2.c (build_artificial_parm): Adjust. ++ * method.c (implicitly_declare_fn): Adjust. ++ * pt.c (push_inline_template_parms_recursive): Adjust. ++ (process_template_parm): Adjust. ++ (overloaded_template_name): Adjust. ++ * semantics.c (finish_template_template_parm): Adjust. ++ ++2000-06-28 Mark Mitchell ++ ++ * cp-tree.h (CLEAR_BINFO_NEW_VTABLE_MARKED): Remove. ++ * class.c (update_vtable_entry_for_fn): Correct logic for deciding ++ where to emit thunks. ++ (build_vtt): Adjust call to build_vtt_inits. ++ (build_vtt_inits): Add parameter to indicate whether or not ++ sub-VTTs for virtual bases should be included. Adjust handling of ++ construction vtables. ++ (get_matching_base): New function. ++ (dfs_build_vtt_inits): Rename to ... ++ (dfs_build_secondary_vptr_vtt_inits): Adjust handling of ++ construction vtables. ++ (dfs_fixup_binfo_vtbls): Likewise. ++ (build_ctor_vtbl_groups): Build construction vtables for virtual ++ bases, too. ++ (accumulate_vtbl_inits): Tweak logic for deciding whether or not ++ to build construction vtbls. ++ (dfs_accumulate_vtbl_inits): Adjust handling of ++ construction vtables. ++ ++ * pt.c (tsubst, case TEMPLATE_TEMPLATE_PARM): Handle cv-qualified ++ types correctly. ++ ++2000-06-27 Mark Mitchell ++ ++ * decl.c (grokfndecl): Set DECL_CONTEXT for static functions too. ++ ++2000-06-26 Nathan Sidwell ++ ++ * search.c (hides): Remove. ++ (is_subobject_of_p): Add most_derived parameter. Use ++ CANONICAL_BINFO. ++ (lookup_field_queue_p): Adjust. ++ (lookup_field_r): Adjust. ++ ++2000-06-26 Nathan Sidwell ++ ++ * decl2.c (handle_class_head): Bash typedefs to the type's main ++ decl. ++ ++2000-06-25 Mark Mitchell ++ ++ * cp-tree.h (genrtl_begin_stmt_expr): Rename to ... ++ (begin_global_stmt_expr): ... this. ++ (genrtl_finish_stmt_expr): Rename to ... ++ (finish_global_stmt_expr): ... this. ++ * init.c (begin_init_stmts): Adjust calls. ++ (finish_init_stmts): Likewise. ++ * semantics.c (genrtl_begin_stmt_expr): Rename to ... ++ (begin_global_stmt_expr): ... this. ++ (genrtl_finish_stmt_expr): Rename to ... ++ (finish_global_stmt_expr): ... this. ++ ++2000-06-25 Theodore Papadopoulo ++ ++ * search.c (lookup_member): Fix typo in comment. ++ ++2000-06-24 Jason Merrill ++ ++ * decl.c (pushdecl): Don't set DECL_CONTEXT from current_namespace. ++ (push_namespace): Set DECL_CONTEXT for a new NAMESPACE_DECL. ++ ++2000-06-24 Martin v. Löwis ++ ++ * parse.y (complex_direct_notype_declarator): Support global_scope. ++ * Makefile.in: Adjust conflict count. ++ ++2000-06-23 Kriang Lerdsuwanakij ++ ++ * parse.y (template_arg): Convert TEMPLATE_DECL ++ that is a template template parameter to ++ TEMPLATE_TEMPLATE_PARM here. ++ ++ * cp-tree.def (TEMPLATE_TEMPLATE_PARM): Adjust comment. ++ * cp-tree.h (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL): New macro. ++ (copy_template_template_parm): Adjust prototype. ++ * decl.c (grokdeclarator): Remove dead code. ++ * pt.c (process_template_parm): Tidy. ++ (lookup_template_class): Construct nodes in ++ copy_template_template_parm. ++ (tsubst): Pass TEMPLATE_DECL rather than IDENTIFIER_NODE to ++ lookup_template_class. Use TYPE_TI_TEMPLATE. ++ * tree.c (copy_template_template_parm): Add NEWARGS ++ parameter. ++ (mapcar): Adjust call to copy_template_template_parm. ++ * typeck.c (comptypes): Use TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL. ++ * method.c (build_template_template_parm_names): Change error ++ code to avoid compilation warning. ++ ++ * gxxint.texi: Document template template parameter ++ name mangling. ++ ++2000-06-21 Alex Samuel ++ ++ * Make-lang.in (CXX_LIB2FUNCS): Add cp-demangle.o and dyn-string.o. ++ (CXX_LIB2SRCS): Add cp-demangle.c and dyn-string.c. ++ (cp-demangle.o): New rule. ++ (dyn-string.o): Likewise. ++ * inc/cxxabi.h (__cxa_demangle): New declaration. ++ ++2000-06-22 Mark Mitchell ++ ++ * cp-tree.h (BV_USE_VCALL_INDEX_P): New macro. ++ (BV_GENERATE_THUNK_WITH_VTABLE_P): Likewise. ++ (lang_decl_flags): Add generate_with_vtable_p. Make vcall_offset ++ a tree, not an int. ++ (THUNK_GENERATE_WITH_VTABLE_P): New macro. ++ (make_thunk): Change prototype. ++ (emit_thunk): Rename to use_thunk. ++ (mangle_thunk): Change prototype. ++ * class.c (get_derived_offset): Simplify. ++ (copy_virtuals): Clear BV_USE_VCALL_INDEX_P and ++ BV_GENERATE_THUNK_WITH_VTABLE_P. ++ (build_primary_vtable): Simplify. ++ (add_virtual_function): Use BV_FN, rather than TREE_VALUE. ++ (dfs_find_base): Remove. ++ (update_vtable_entry_for_fn): Correct bug in finding the base ++ where a virtual function was first declared. Figure out whether ++ or not to emit a vcall-thunk with the vtables in which it appears. ++ Correct logic for deciding whether to use an ordinary thunk, or a ++ vcall thunk. ++ (finish_struct_1): Remove unnecssary code. ++ (build_vtbl_initializer): Use ssize_int for the running counter of ++ negative indices. ++ (build_vtbl_initializer): Only use vcall thunks where necessary. ++ Mark thunks as needing to be emitted with their vtables, or not. ++ (build_vbase_offset_vtbl_entries): Adjust for use of ssize_int in ++ indices. Use size_binop. ++ (dfs_build_vcall_offset_vtbl_entries): Don't rely on ++ BINFO_PRIMARY_MARKED_P here. Use BV_FN consistently. Use ++ size_binop. ++ (build_rtti_vtbl_entries): Adjust call to build_vtable_entry. ++ (build_vtable_entry): Mark thunks as needing to be emitted with ++ their vtables, or not. ++ * decl.c (lang_mark_tree): Mark the vcall_offset in a thunk. ++ * decl2.c (mark_vtable_entries): Use use_thunk instead of ++ emit_thunk. ++ * dump.c (dequeue_and_dump): Remove dead code. Dump new thunk ++ information. ++ * error.c (dump_expr): Use BV_FN. ++ * mangle.c (mangle_thunk): Adjust now that vcall_offset is a tree, ++ not an int. ++ * method.c (make_thunk): Likewise. ++ (emit_thunk): Rename to use_thunk. Allow callers to decide ++ whether or not to actually emit the thunk. Adjust for changes in ++ representation of vcall offsets. ++ * search.c (dfs_get_pure_virtuals): Use BV_FN. ++ * semantics.c (emit_associated_thunks): New function. ++ (expand_body): Use it. ++ * ir.texi: Adjust descriptions of thunks. ++ ++2000-06-22 Jason Merrill ++ ++ * pt.c (tsubst_decl, case FUNCTION_DECL): Clear DECL_SAVED_TREE. ++ (tsubst_friend_function): Copy it here. ++ ++ * decl.c (grok_op_properties): Fix typo. ++ ++ * decl2.c (delete_sanity): Clarify warning, avoid failure on ++ deleting void*. ++ ++ * pt.c (check_explicit_specialization): Clarify error. ++ ++ * decl.c (pushdecl): Also pull out one of the FUNCTION_DECLs from ++ an old OVERLOAD when we're declaring a non-function. ++ (pushdecl, destroy_local_var): Check for error_mark_node. ++ (warn_extern_redeclared_static): Also bail early if ++ we're a CONST_DECL. ++ (push_overloaded_decl): Ignore an old error_mark_node. ++ ++2000-06-22 Nathan Sidwell ++ ++ * call.c (build_x_va_arg): Check if in a template decl. ++ * pt.c (tsubst_copy, case VA_ARG_EXPR): Use build_x_va_arg. ++ ++2000-06-20 Alexandre Petit-Bianco ++ ++ * class.c (push_lang_context): TYPE_NAME gets you to the Java ++ types DECLs. ++ * decl.c (check_goto): Computed gotos assumed OK. ++ ++2000-06-20 Jason Merrill ++ ++ * pt.c (tsubst_decl, case TYPE_DECL): Fix test for TYPE_DECLs ++ for which we don't need to look for instantiations. ++ ++2000-06-21 Nathan Sidwell ++ ++ * parse.y (program): Always call finish_translation_unit. ++ * parse.c, parse.h: Rebuilt. ++ ++2000-06-20 Zack Weinberg ++ ++ * method.c: Don't include hard-reg-set.h. ++ ++2000-06-20 Nathan Sidwell ++ ++ * rtti.c (get_base_offset): Cope when vbase field is in a base. ++ ++2000-06-20 Nathan Sidwell ++ ++ * call.c (build_conditional_expr): Use VOID_TYPE_P. ++ * cvt.c (cp_convert_to_pointer): Likewise. ++ (convert_to_void): Likewise. ++ * error.c (dump_expr): Likewise. ++ * except.c (complete_ptr_ref_or_void_ptr_p): Likewise. ++ * init.c (build_delete): Likewise. ++ * method.c (emit_thunk): Likewise. ++ * optmize.c (declare_return_variable): Likewise. ++ * rtti.c (get_tinfo_decl_dynamic): Likewise. ++ (get_typeid): Likewise. ++ (build_dynamic_cast_1): Likewise. ++ * typeck.c (composite_pointer_type): Likewise. ++ (common_type): Likewise. ++ (build_indirect_ref): Likewise. ++ (build_binary_op): Likewise. ++ (build_x_compound_expr): Likewise. ++ (check_return_expr): Likewise. ++ * typeck2.c (add_exception_specifier): Likewise. ++ ++ * mangle.c (write_method_parms): Use direct comparison for end ++ of parmlist. ++ ++2000-06-19 Benjamin Chelf ++ ++ * cp-tree.h (genrtl_try_block): Declare function. ++ (genrtl_handler): Likewise. ++ (genrtl_catch_block): Likewise. ++ (genrtl_ctor_stmt): Likewise. ++ (genrtl_subobject): Likewise. ++ (genrtl_decl_cleanup): Likewise. ++ (genrtl_do_poplevel): Likewise. ++ (genrtl_do_pushlevel): Likewise. ++ (genrtl_clear_out_block): Likewise. ++ (genrtl_goto_stmt): Likewise. ++ (genrtl_expr_stmt): Likewise. ++ (genrtl_decl_stmt): Likewise. ++ (genrtl_if_stmt): Likewise. ++ (genrtl_while_stmt): Likewise. ++ (genrtl_do_stmt): Likewise. ++ (genrtl_return_stmt): Likewise. ++ (genrtl_for_stmt): Likewise. ++ (genrtl_break_stmt): Likewise. ++ (genrtl_continue_stmt): Likewise. ++ (genrtl_scope_stmt): Likewise. ++ (genrtl_switch_stmt): Likewise. ++ (genrtl_case_label): Likewise. ++ (genrtl_begin_compound_stmt): Likewise. ++ (genrtl_finish_compound_stmt): Likewise. ++ (genrtl_compound_stmt): Likewise. ++ (genrtl_asm_stmt): Likewise. ++ (genrtl_named_return_value): Likewise. ++ (genrtl_begin_stmt_expr): Likewise. ++ (genrtl_finish_stmt_expr): Likewise. ++ (finish_for_stmt): Removed first argument. ++ (finish_switch_stmt): Likewise. ++ ++ * semantics.c (genrtl_try_block): Define function. ++ (genrtl_handler): Likewise. ++ (genrtl_catch_block): Likewise. ++ (genrtl_ctor_stmt): Likewise. ++ (genrtl_subobject): Likewise. ++ (genrtl_decl_cleanup): Likewise. ++ (genrtl_do_poplevel): Likewise. ++ (genrtl_do_pushlevel): Likewise. ++ (genrtl_clear_out_block): Likewise. ++ (genrtl_goto_stmt): Likewise. ++ (genrtl_expr_stmt): Likewise. ++ (genrtl_decl_stmt): Likewise. ++ (genrtl_if_stmt): Likewise. ++ (genrtl_while_stmt): Likewise. ++ (genrtl_do_stmt): Likewise. ++ (genrtl_return_stmt): Likewise. ++ (genrtl_for_stmt): Likewise. ++ (genrtl_break_stmt): Likewise. ++ (genrtl_continue_stmt): Likewise. ++ (genrtl_scope_stmt): Likewise. ++ (genrtl_switch_stmt): Likewise. ++ (genrtl_case_label): Likewise. ++ (genrtl_begin_compound_stmt): Likewise. ++ (genrtl_finish_compound_stmt): Likewise. ++ (genrtl_compound_stmt): Likewise. ++ (genrtl_asm_stmt): Likewise. ++ (genrtl_named_return_value): Likewise. ++ (genrtl_begin_stmt_expr): Likewise. ++ (genrtl_finish_stmt_expr): Likewise. ++ (finish_for_stmt): Removed first argument and generate rtl ++ specific code. ++ (finish_switch_stmt): Likewise. ++ (do_poplevel): Removed generate rtl specific code. ++ (do_pushlevel): Likewise. ++ (add_tree): Likewise. ++ (finish_goto_stmt): Likewise. ++ (finish_expr_stmt): Likewise. ++ (begin_if_stmt): Likewise. ++ (finish_if_stmt_cond): Likewise. ++ (finish_then_clause): Likewise. ++ (begin_else_clause): Likewise. ++ (finish_else_clause): Likewise. ++ (finish_if_stmt): Likewise. ++ (clear_out_block): Likewise. ++ (begin_while_stmt): Likewise. ++ (finish_while_stmt_cond): Likewise. ++ (finish_while_stmt): Likewise. ++ (begin_do_stmt): Likewise. ++ (finish_do_body): Likewise. ++ (finish_do_stmt): Likewise. ++ (finish_return_stmt): Likewise. ++ (begin_for_stmt): Likewise. ++ (finish_for_init_stmt): Likewise. ++ (finish_for_cond): Likewise. ++ (finish_for_expr): Likewise. ++ (finish_break_stmt): Likewise. ++ (finish_continue_stmt): Likewise. ++ (begin_switch_stmt): Likewise. ++ (finish_switch_cond): Likewise. ++ (finish_case_label): Likewise. ++ (begin_try_block): Likewise. ++ (begin_function_try_block): Likewise. ++ (finish_try_block): Likewise. ++ (finish_cleanup_try_block): Likewise. ++ (finish_cleanup): Likewise. ++ (finish_function_try_block): Likewise. ++ (finish_handler_sequence): Likewise. ++ (finish_function_handler_sequence): Likewise. ++ (begin_handler): Likewise. ++ (finish_handler_parms): Likewise. ++ (begin_catch_block): Likewise. ++ (finish_handler): Likewise. ++ (begin_compound_stmt): Likewise. ++ (finish_compound_stmt): Likewise. ++ (finish_asm_stmt): Likewise. ++ (finish_label_stmt): Likewise. ++ (finish_label_decl): Likewise. ++ (finish_subobject): Likewise. ++ (finish_decl_cleanup): Likewise. ++ (finish_named_return_value): Likewise. ++ (begin_stmt_expr): Likewise. ++ (finish_stmt_expr): Likewise. ++ ++ * decl.c (initialize_local_var): Changed call to finish_expr_stmt ++ to call genrtl_expr_stmt when appropriate. ++ ++ * init.c (begin_init_stmts): Changed calls to begin_stmt_expr and ++ begin_compound_expr to call genrtl_begin_stmt_expr and ++ genrtl_begin_compound_expr when appropriate. ++ (finish_init_stmts): Changed calls to finish_compound_expr and ++ finish_stmt_expr to call genrtl_finish_compound_expr and ++ genrtl_finish_stmt_expr when appropriate. ++ (expand_default_init): Changed call to finish_expr_stmt to call ++ genrtl_expr_stmt when appropriate. ++ (build_vec_init): Likewise. ++ ++ * parse.y (simple_stmt): Removed first argument from call to ++ finish_for_stmt. Removed first argument from call to ++ finish_switch_stmt. ++ ++ * parse.c: Regenerated. ++ ++ * pt.c (tsubst_expr): Removed first argument from call to ++ finish_for_stmt. Removed first argument from call to ++ finish_switch_stmt. ++ ++2000-06-16 Benjamin Chelf ++ ++ * cp-tree.h (enum cplus_tree_code): Changed __DUMMY to ++ CP_DUMMY_TREE_CODE. Remove #include "c-common.def". ++ ++ * lex.c (cplus_tree_code_type[]): Removed #include "c-common.def". ++ (cplus_tree_code_length[]): Likewise. ++ (cplus_tree_code_name[]): Likewise. ++ (init_parse): Added call to add_c_tree_codes. Changed ++ LAST_AND_UNUSED_TREE_CODE to LAST_C_TREE_CODE. ++ ++2000-06-16 Mark Mitchell ++ ++ * cp-tree.h (finish_mem_initializers): Declare. ++ (count_trees): Likewise. ++ * parse.y (base_init): Use finish_mem_initializers. ++ * semantics.c (finish_mem_initializers): New function. ++ ++ * tree.c (count_trees_r): Prototype. Use DATA parameter to store ++ the number of trees. ++ (n_trees): Remove. ++ (count_trees): Don't use it. ++ ++2000-06-15 Jason Merrill ++ ++ * tree.c (count_trees): New debugging function. ++ ++ * typeck.c (build_x_function_call): Use DECL_FUNCTION_TEMPLATE_P. ++ * init.c (build_member_call): Pull out the name of a DECL. ++ ++ * Makefile.in (semantics.o, pt.o): Depend on TIMEVAR_H. ++ * semantics.c (expand_body): Push to TV_INTEGRATION here. ++ * optimize.c (optimize_function): Not here. ++ * pt.c (instantiate_decl): Push to TV_PARSE. ++ ++2000-06-15 Mark Mitchell ++ ++ * cp-tree.h (struct language_function): Remove x_base_init_list ++ and x_member_init_list. ++ (current_base_init_list): Remove. ++ (current_member_init_list): Likewise. ++ (setup_vtbl_ptr): Change prototype. ++ (emit_base_init): Likewise. ++ (expand_member_init): Likewise. ++ (reinit_parse_for_function): Remove. ++ * decl.c (save_function_data): Don't clear x_base_init_list and ++ x_member_init_list. ++ (mark_language_function): Don't mark them. ++ * init.c (perform_member_init): Tweak comment. ++ (sort_member_init): Take the list of initializers as an argument. ++ (sort_base_init): Likewise. ++ (emit_base_init): Likewise. ++ (expand_member_init): Return the initializer. Don't use global ++ variables. ++ * lex.c (reinit_parse_for_function): Remove. ++ * method.c (build_template_parm_names): Correct substitution. ++ (do_build_copy_constructor): Don't use current_member_init_list ++ and current_base_init_list. ++ (synthesize_method): Likewise. ++ * parse.y (base_init): Split mem-initializers into ++ base-initializers and field-initializers. ++ (member_init_list): Build up the list here. ++ (member_init): Return the initializer. ++ (fn.depfn): Don't use reinit_parse_for_function. ++ * parse.c: Regenerated. ++ * pt.c (convert_nontype_argument): Don't make an ADDR_EXPR of the ++ ERROR_MARK. ++ (tsubst_expr): Don't use current_member_init_list ++ and current_base_init_list. ++ (tsubst_expr_values): Rename to ... ++ (tsubst_initializer_list): ... this. Use convert_from_reference. ++ * semantics.c (setup_vtbl_ptr): Don't use current_member_init_list ++ and current_base_init_list. ++ (begin_function_definition): Don't call reinit_parse_for_function. ++ ++ * dump.c (dequeue_and_dump): Use TREE_VEC_LENGTH with vectors. ++ ++ * error.c (dump_expr): Handle ADDR_EXPRs with REFERENCE_TYPE ++ correctly. ++ ++ * cp-tree.h (DECL_PENDING_INLINE_P): Relax checking. ++ ++2000-06-14 Benjamin Chelf ++ ++ * cp-tree.h (IF_COND): Move to c-common.h. ++ (THEN_CLAUSE): Likewise. ++ (ELSE_CLAUSE): Likewise. ++ (WHILE_COND): Likewise. ++ (WHILE_BODY): Likewise. ++ (DO_COND): Likewise. ++ (DO_BODY): Likewise. ++ (RETURN_EXPR): Likewise. ++ (EXPR_STMT_EXPR): Likewise. ++ (FOR_INIT_STMT): Likewise. ++ (FOR_COND): Likewise. ++ (FOR_EXPR): Likewise. ++ (FOR_BODY): Likewise. ++ (SWITCH_COND): Likewise. ++ (SWITCH_BODY): Likewise. ++ (CASE_LOW): Likewise. ++ (CASE_HIGH): Likewise. ++ (GOTO_DESTINATION): Likewise. ++ (COMPOUND_BODY): Likewise. ++ (ASM_CV_QUAL): Likewise. ++ (ASM_STRING): Likewise. ++ (ASM_OUTPUTS): Likewise. ++ (ASM_INPUTS): Likewise. ++ (ASM_CLOBBERS): Likewise. ++ (DECL_STMT_DECL): Likewise. ++ (STMT_EXPR_STMT): Likewise. ++ (LABEL_STMT_LABEL): Likewise. ++ (SCOPE_BEGIN_P): Likewise. ++ (SCOPE_END_P): Likewise. ++ (SCOPE_STMT_BLOCK): Likewise. ++ (SCOPE_NULLIFIED_P): Likewise. ++ (SCOPE_NO_CLEANUPS_P): Likewise. ++ (SCOPE_PARTIAL_P): Likewise. ++ (ASM_VOLATILE_P): Likewise. ++ (STMT_LINENO): Likewise. ++ (STMT_LINENO_FOR_FN_P): Likewise. ++ ++ * cp-tree.def: Removed SRCLOC, SIZEOF_EXPR, ARROW_EXPR, ++ ALIGNOF_EXPR, EXPR_STMT, COMPOUND_STMT, DECL_STMT, IF_STMT, ++ FOR_STMT, WHILE_STMT, DO_STMT, RETURN_STMT, BREAK_STMT, ++ CONTINUE_STMT, SWITCH_STMT, GOTO_STMT, LABEL_STMT, ASM_STMT, ++ SCOPE_STMT, CASE_LABEL, STMT_EXPR. ++ ++ * Makefile.in (CXX_TREE_H): Added $(srcdir)/../c-common.def. ++ ++ * Make-lang.in (CXX_SRCS): Added $(srcdir)/c-common.def. ++ (cc1plus$(exeext)): Added $(srcdir)/c-common.def. ++ ++ * lex.c (cplus_tree_code_type[]): Added '#include "c-common.def"'. ++ (cplus_tree_code_length[]): Added '#include "c-common.def"'. ++ (cplus_tree_code_name[]): Added '#include "c-common.def"'. ++ ++2000-06-14 Mark Mitchell ++ ++ * cp-tree.h (BINFO_OVERRIDE_ALONG_VIRTUAL_PATH): New macro. ++ * class.c (dfs_find_final_overrider): Set it appropriately. ++ (dfs_built_vtt_inits): Check BINFO_OVERRIDE_ALONG_VIRTUAL_PATH to ++ avoid unneeded secondary vptrs. ++ ++2000-06-13 Jakub Jelinek ++ ++ * class.c (build_secondary_vtable): Set DECL_USER_ALIGN. ++ (check_bitfield_decl, check_field_decl): Likewise. ++ (build_vtbl_or_vbase_field, build_base_field): Likewise. ++ (layout_class_type): Set DECL_USER_ALIGN resp. CLASSTYPE_USER_ALIGN. ++ * decl.c (record_unknown_type): Set TYPE_USER_ALIGN. ++ (xfer_tag, finish_enum): Likewise. ++ * decl2.c (finish_builtin_type): Likewise. ++ * init.c (init_init_processing): Likewise. ++ * pt.c (instantiate_class_template): Likewise. ++ * rtti.c (get_tinfo_decl, synthesize_tinfo_fn): Set DECL_USER_ALIGN. ++ * cp-tree.h (struct lang_type): Add user_align member. ++ (CLASSTYPE_USER_ALIGN): Define. ++ ++2000-06-13 Maciej W. Rozycki ++ ++ * Make-lang.in (c++.install-common): Install g++-cross in ++ $(gcc_tooldir)/bin as g++ and c++; g++ in $(bindir) as ++ $(target_alias)-g++ and $(target_alias)-c++. ++ ++2000-06-12 Mark Mitchell ++ ++ * class.c (vcall_offset_data_s): Add last_init and fns. ++ (overrides): Rename to same_signature_p. ++ (dfs_find_final_overrider): Adjust accordingly. ++ (mark_overriders): Likewise. ++ (warn_hidden): Likewise. ++ (build_vtbl_initializer): Reorganize machinery for building things ++ at negative offsets. ++ (build_vcall_and_vbase_vtbl_entries): Likewise. ++ (build_vbase_offset_vtbl_entries): Likewise. ++ (dfs_build_vcall_offset_vtbl_entries): Correct order of vcall ++ offset entries. Do not create two entries for functions with the ++ same signature. ++ (build_vcall_offset_vtbl_entries): Initialize vod->fns. ++ (build_rtti_vtbl_entries): Reorganize machinery for building things ++ at negative offsets. ++ ++ * optimize.c (expand_call_inline): Don't recurse into the code ++ used to initialize the parameters more than once. ++ ++2000-06-11 Mark Mitchell ++ ++ * mangle.c (NESTED_TEMPLATE_MATCH): Fix typo in comment. ++ (is_std_substitution): Don't check CLASSTYPE_USE_TEMPLATE here. ++ (find_substitution): Only use the `Sa' substitution for ++ std::allocator, not instantiations of it. ++ (write_template_prefix): Move comment. Only use a TREE_LIST to ++ represent substitutions for a member template. ++ (write_array_type): Mangle array dimensions correctly. ++ * optimize.c (maybe_clone_body): Copy more information from the ++ cloned function. ++ * pt.c (regenerate_decl_from_template): Preserve DECL_USE_TEMPLATE ++ on the regenerated declaration. ++ ++2000-06-11 Chip Salzenberg ++ Mark Mitchell ++ ++ * class.c (build_vtable): Clarify comment. ++ (build_ctor_vtbl_group): Pass the most derived type to ++ build_vtable. ++ ++2000-06-11 Kaveh R. Ghazi ++ ++ * decl2.c (compare_options): Don't needlessly cast away const-ness. ++ ++2000-06-10 Mark Mitchell ++ ++ * decl.c (add_binding): Handle duplicate declarations of external ++ variables. ++ ++2000-06-09 Chip Salzenberg ++ Mark Mitchell ++ ++ * mangle.c (write_number): Take an unsigned HOST_WIDE_INT as an ++ argument. ++ (write_signed_number): New macro. ++ (write_unsigned_number): Likewise. ++ (write_source_name): Use them. ++ (write_number): Handle signed and unsigned values. ++ (write_integer_cst): Use tree_int_cst_sgn, and use ++ write_unsigned_number or write_signed_number as appropriate. ++ (write_discriminator): Use write_unsigned_number or ++ write_signed_number as appropriate. ++ (write_template_arg_literal): Likewise. ++ (write_array_type): Use tree_low_cst. ++ (write_template_parm): Use write_unsigned_number or ++ write_signed_number as appropriate. ++ (write_substitution): Adjust call to write_number. ++ (write_type): Get the TYPE_MAIN_VARIANT before mangling it. ++ (write_expression): Handle non-type template arguments of ++ reference type correctly. ++ (mangle_thunk): Use write_signed_number. ++ ++2000-06-09 Chip Salzenberg ++ ++ * mangle.c (find_substition): Don't mangle objects with typename ++ substitutions (e.g. "cin" as "Si"). ++ ++2000-06-09 Zack Weinberg ++ ++ * call.c (add_candidate): Use ggc_alloc_cleared. ++ * decl.c (lookup_label): Likewise. ++ * lex.c (retrofit_lang_decl): Likewise. ++ ++2000-06-09 Jason Merrill ++ ++ * semantics.c (expand_body): Push to TV_EXPAND. ++ * optimize.c (optimize_function): Push to TV_INTEGRATION. ++ * decl.c (start_function): Always call announce_function. ++ ++ * tinfo2.cc: Just declare abort. ++ ++2000-06-09 Gabriel Dos Reis ++ ++ * lex.c (DEF_OPERATOR): Say `operator@' -not- `operator @' ++ whenever @ is a symbolic name. ++ ++2000-06-08 Jakub Jelinek ++ ++ * method.c (make_thunk): Clear DECL_VTT_PARM in thunk. ++ ++2000-06-07 Mark Mitchell ++ ++ * decl.c (pushdecl): Look up functions by DECL_NAME, not ++ DECL_ASSEMBLER_NAME. ++ ++2000-06-06 Mark Mitchell ++ ++ * decl2.c (c_language): Define. ++ ++2000-06-06 Gabriel Dos Reis ++ ++ * lex.c (lang_init_options): Tweak. ++ ++ * decl2.c: Remove #inclusion of diagnostic.h ++ (lang_decode_option): Move diagnostic formatting options to ++ toplevel. ++ ++ * lang-options.h: Remove documentation for diagnostic options. ++ ++ * Makefile.in (lex.o): Depends upon diagnostic.h ++ ++2000-06-06 Mark Mitchell ++ ++ * decl.c (redeclaration_error_message): If two TEMPLATE_DECLs have ++ the same DECL_RESULT, it's not a redefinition. ++ * pt.c (tsubst_decl): Remove code to handle illegal ++ specializations. ++ ++2000-06-06 Nathan Sidwell ++ ++ * exception.cc: (__eh_alloc, __eh_free): Moved to libgcc2.c ++ ++2000-06-05 Jason Merrill ++ ++ * search.c (maybe_suppress_debug_info): Don't check ++ CLASSTYPE_INTERFACE_ONLY if CLASSTYPE_INTERFACE_KNOWN isn't set. ++ ++ * pt.c (mark_decl_instantiated): Do SET_DECL_EXPLICIT_INSTANTIATION ++ here if extern_p. ++ ++ Remember instantiation context in deferred instantiations. ++ * cp-tree.h (struct tinst_level): Remove. ++ (TINST_DECL, TINST_LINE, TINST_FILE): New macros. ++ * pt.c (current_tinst_level): Now a tree. ++ (print_template_context, push_tinst_level, pop_tinst_level, ++ tinst_for_decl): Adjust. ++ (reopen_tinst_level): New fn. ++ (init_pt): Register current_tinst_level as a root. ++ (add_pending_template): Put current_tinst_level in TREE_PURPOSE ++ of the pending templates list. ++ (instantiate_pending_templates): Adjust. Call reopen_tinst_level. ++ * lex.c (extract_interface_info): Adjust. ++ * decl2.c (warn_if_unknown_interface): Adjust. ++ ++2000-06-05 Mark Mitchell ++ ++ * class.c (indirect_primary_base_p): New function. ++ (determine_primary_base): Use it. ++ ++2000-06-05 Nathan Sidwell ++ ++ Update new-abi dynamic cast algorithm. ++ * tinfo.cc (__class_type_info::__dyncast_result): Add ++ whole_details. Adjust constructor. ++ (__vmi_class_type_info::__do_dyncast): Adjust for vmi_flags. ++ Avoid unnecessary searching. ++ (__dynamic_cast): Adjust for __dyncast_result::whole_details. ++ ++2000-06-05 Richard Kenner ++ ++ * decl.c (init_decl_processing): Don't call record_component_aliases. ++ * tree.c (build_cplus_array_type_1): Likewise. ++ ++2000-06-04 Mark Mitchell ++ ++ * ir.texi: Correct typo. ++ * mangle.c (write_expression): Handle non-type template arguments ++ with reference type. ++ * method.c (build_overload_value): Likewise. ++ * pt.c (convert_nontype_argument): Explicitly represent conversion ++ to a reference with an ADDR_EXPR. ++ (unify): Always unify arguments in left-to-right order. ++ ++2000-06-03 Alex Samuel ++ Mark Mitchell ++ ++ * Make-lang.in (CXX_SRCS): Add mangle.c. ++ * Makefile.in (CXX_OBJS): Add mangle.o. ++ (mangle.o): New rule. ++ ++ * class.c (local_classes): New variable. ++ * class.c (get_vtable_name): Use mangle_vtable_for_type for new ABI. ++ (get_vtt_name): Use mangle_vtt_name for new ABI. ++ (init_class_processing): Initialize local_classes. ++ (build_ctor_vtbl_group): Use mangle_ctor_vtbl_for_type for new ABI. ++ * cp-tree.h (cp_tree_index): Add CPTI_STD_IDENTIFIER. ++ (std_identifier): New macro. ++ (DECL_VOLATILE_MEMFUNC_P): New macro. ++ (DECL_NAMESPACE_STD_P): Likewise. ++ (local_classes): Declare. ++ (get_mostly_instantiated_function_type): Declare. ++ (init_mangle): Declare. ++ (mangle_decl): Likewise. ++ (mangle_type_string): Likewise. ++ (mangle_type): Likewise. ++ (mangle_typeinfo_for_type): Likewise. ++ (mangle_typeinfo_string_for_type): Likewise. ++ (mangle_vtbl_for_type): Likewise. ++ (mangle_vtt_for_type): Likewise. ++ (mangle_ctor_vtbl_for_type): Likewise. ++ (mangle_thunk): Likewise. ++ (mangle_conv_op_name_for_type): Likewise. ++ (mangle_guard_variable): Likewise. ++ * decl.c (pushtag): Keep track of local classes. ++ (initialize_predefined_identifiers): Initialize std_identifier. ++ (init_decl_processing): Use std_identifier. ++ (start_decl): Don't treat instantiations as specializations. ++ (grokdeclarator): Likewise. ++ (grokvardecl): Call mangle_decl for new ABI. Only set mangled ++ name for fully-instantiated templates. ++ * decl2.c (grokclassfn): Use set_mangled_name_for_decl for ++ destructors with the new ABI. ++ (finish_static_data_member_decl): Use mangle_decl under the new ABI. ++ (grokfield): Use mangle_type for new ABI. ++ (grokoptypename): Use mangle_conv_op_for_type for new ABI. ++ (get_sentry): Use mangle_guard_variable for new ABI. ++ (start_static_initialization_or_destruction): Likewise. ++ * expr.c (extract_aggr_init): Remove. ++ (extract_scalar_init): Likewise. ++ (extract_init): Remove #if 0'd code. ++ * mangle.c: New function. ++ * method.c (build_mangled_name): Assert not flag_new_abi. ++ (build_static_name): Likewise. ++ (build_decl_overload_real): Likewise. ++ (build_typename_overload): Likewise. ++ (build_overload_with_type): Likewise. ++ (build_overload_name): Likewise. ++ (get_ctor_vtbl_name): Likewise. ++ (start_squangling): Likewise. ++ (get_id_2): Likewise. ++ (set_mangled_name_for_decl): Call mangle_decl for new ABI. ++ (init_method): Call init_mangle for new ABI. ++ (make_thunk): Call mangle_thunk for new ABI. ++ * operators.def: Correct new ABI manglings for the `%' operator. ++ Add `::' operator. ++ * pt.c (build_template_decl): Copy DECL_OVERLOADED_OPERATOR_P and ++ DECL_ASSIGNMENT_OPERATOR_P to the TEMPLATE_DECL. ++ (lookup_template_class): Call mangle_decl for new ABI. ++ (get_mostly_instantiated_function_type): New function. ++ (set_mangled_name_for_template_decl): Use it. ++ (tsubst_decl): Use set_mangled_name_for_decl for destructors with ++ the new ABI. Use mangle_conv_op_name_for_type for instantiated ++ conversion op names. ++ * rtti.c (tinfo_name): Call mangle_type_string for new ABI. ++ (get_tinfo_decl): Call mangle_typeinfo_for_type for new ABI. ++ (tinfo_base_init): Likewise. Mangle typeinfo string name with ++ mangle_typeinfo_string_for_type. ++ ++2000-06-03 Mark Mitchell ++ ++ * cp-tree.h (TMPL_ARGS_LEVEL): Clarify comment. ++ (INNERMOST_TEMPLATE_ARGS): New macro. ++ (innermost_args): Remove. ++ (get_innermost_template_args): New function. ++ * decl2.c (arg_assoc_class): Use INNERMOST_TEMPLATE_ARGS. ++ * error.c (dump_function_decl): Be caution when using ++ most_general_template. ++ * method.c (build_template_parm_names): Use ++ INNERMOST_TEMPLATE_ARGS. ++ * pt.c (add_to_template_args): Tidy comment ++ (get_innermost_template_args): New function. ++ (check_explicit_specialization): Clear DECL_INITIAL for a new ++ specialization. ++ (process_partial_specialization): Use INNERMOST_TEMPLATE_ARGS. ++ Tidy. ++ (push_template_decl): Always register specializations of the most ++ general template. ++ (convert_template_argument): Use INNERMOST_TEMPLATE_ARGS. ++ (coerce_template_parms): Likewise. ++ (lookup_template_class): Likewise. ++ (innermost_args): Remove. ++ (tsubst_decl): Use INNERMOST_TEMPLATE_ARGS. ++ (tsubst_decl): Handle tricky specializations. Use ++ get_innermost_template_args. ++ (instantiate_template): Simplify handling of partial ++ instantiations. ++ (get_class_bindings): Use INNERMOST_TEMPLATE_ARGS. ++ (most_general_template): Reimplement, in a more straightforward ++ manner. ++ (regenerate_decl_from_template): Tweak formatting. Use ++ TMPL_ARGS_DEPTH for clarity. ++ (set_mangled_name_for_template_decl): Use INNERMOST_ARGS. ++ ++ * dump.c (dequeue_and_dump): Dump information about thunks. ++ ++2000-06-01 Richard Henderson ++ ++ * decl.c (init_decl_processing): Set lang_get_alias_set first thing. ++ ++2000-06-01 Richard Henderson ++ ++ * decl2.c (unsupported_options): Fix typo, make const. ++ (lang_decode_option): Fix bsearch argument order. ++ ++2000-06-01 Mark Mitchell ++ ++ * init.c (resolve_offset_ref): Remove check for TREE_ADDRESSABLE ++ on FIELD_DECLs. ++ ++2000-05-31 Richard Kenner ++ ++ * cp-tree.h (c_get_alias_set): Deleted. ++ * Makefile.in (decl.o): Include ../expr.h. ++ * decl.c (expr.h): Include. ++ (init_decl_processing): Call record_component_aliases for arrays. ++ (grokdeclarator): Likewise. ++ Set TREE_ADDRESSABLE for fields that aren't bitfields. ++ * tree.c (build_cplus_array_type_1): Call record_component_aliases. ++ ++2000-05-31 Mark Mitchell ++ ++ Remove guiding declaration support. ++ * cp/cp-tree.h (flag_dump_translation_unit): Make it const. ++ (flag_guiding_decls): Remove. ++ * call.c (build_user_type_conversion_1): Remove support for ++ guiding decls. ++ (build_new_function_call): Likewise. ++ (build_new_op): Likewise. ++ (build_new_method_call): Likewise. ++ * decl.c (start_function): Likewise. ++ * friend.c (is_friend): Likewise. ++ (do_friend): Likewise. ++ * decl2.c ((flag_dump_translation_unit): Make it const. ++ (flag_guiding_decls): Remove. ++ (unsupported_options): New variable ++ (compare_options): New function. ++ (lang_decode_option): Use them. ++ ++ * decl.c (build_cp_library_fn): Set DECL_CONTEXT. ++ ++ * method.c (mangle_expression): Adjust test for legal expression ++ operators. ++ ++ * pt.c (instantiate_decl): Save and restore the local ++ specializations list. ++ ++2000-05-30 Jason Merrill ++ ++ * decl.c (grok_reference_init): Pass LOOKUP_ONLYCONVERTING. ++ ++2000-05-30 Mark Mitchell ++ ++ * call.c (add_template_candidate_real): Handle member template ++ constructors for classes with virtual bases. ++ (build_user_type_conversion_1): Use in_charge_arg_for_name. ++ (build_new_method_call): Use DECL_NONSTATIC_MEMBER_FUNCTION_P. ++ ++ * ir.texi: Update thunk documentation. ++ ++ * call.c (joust): Fix handling of overloaded builtin operators. ++ ++2000-05-30 Zack Weinberg ++ ++ * cp-tree.h (DECL_ANTICIPATED): New macro. ++ Document new use of DECL_LANG_FLAG_7. ++ * decl.c (builtin_function): Set DECL_ANTICIPATED on builtins ++ in the user namespace. ++ * lex.c (do_identifier): If the identifier's declaration has ++ DECL_ANTICIPATED on, it has not yet been declared. But do not ++ replace it with an ordinary implicit declaration. ++ ++ * tinfo2.cc: Include stdlib.h. ++ ++2000-05-29 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_ALIGN_UNIT): New macro. ++ * class.c (layout_empty_base): Use CLASSTYPE_ALIGN_UNIT, not ++ CLASSTYPE_ALIGN. ++ ++2000-05-28 Gabriel Dos Reis ++ ++ * decl2.c (lang_decode_option): Use skip_leading_substring instead ++ of plain strncmp. ++ ++2000-05-28 Alexandre Oliva ++ ++ * operators.def (?): this. Fixed. ++ ++2000-05-27 Alex Samuel ++ Mark Mitchell ++ ++ * cp-tree.h (ansi_opname): Make it a macro. ++ (ansi_assopname): Likewise. ++ (struct lang_decl_flags): Add assignment_operator_p. ++ (struct lang_decl): Add operator_code. ++ (DECL_VTT_PARM): Adjust. ++ (DECL_OVERLOADED_OPERATOR_P): Return the operator_code for an ++ overloaded operator. ++ (SET_OVERLOADED_OPERATOR_CODE): New macro. ++ (DECL_ASSIGNMENT_OPERATOR_P): New macro. ++ (DECL_ARRAY_DELETE_OPERATOR_P): Adjust. ++ (opname_tab): Remove. ++ (assignop_tab): Likewise. ++ (operator_name_info_t): New type. ++ (operator_name_info): New variable. ++ (assignment_operator_name_info): Likewise. ++ (build_cp_library_fn): Remove declaration. ++ (push_cp_library_fn): Likewise. ++ (operator_name_string): Likewise. ++ (build_decl_overload): Likewise. ++ * call.c (print_z_candidates): Simplify. ++ (build_object_call): Adjust usage of ansi_opname. Use ++ DECL_OVERLOADED_OPERATOR_P. ++ (op_error): Adjust operator name lookup. ++ (build_conditional_expr): Adjust usage of ansi_opname. ++ (build_new_op): Likewise. ++ (build_op_delete_call): Likewise. ++ (build_over_call): Likewise. ++ (joust): Use DECL_OVERLOADED_OPERATOR_P. ++ * decl.c (duplicate_decls): Copy operator_code. ++ (init_decl_processing): Adjust parameters to push_cp_library_fn. ++ (builtin_function): Adjust parameters to build_library_fn_1. ++ (build_library_fn_1): Accept an overloaded operator code. ++ (build_library_fn): Pass ERROR_MARK. ++ (build_cp_library_fn): Accept an overloaded operator code. ++ (push_cp_library_fn): Likewise. ++ (grokfndecl): Tweak. ++ (grokdeclarator): Simplify code to compute names of overloaded ++ operators. Adjust use of ansi_opname. ++ (ambi_op_p): Work on tree_codes, not identifiers. ++ (unary_op_p): Likewise. ++ (grok_op_properties): Likewise. ++ (start_function): Use DECL_OVERLOADED_OPERATOR_P. ++ (lang_mark_tree): Don't try to mark the operator_code. ++ * decl2.c (grok_function_init): Use DECL_OVERLOADED_OPERATOR_P. ++ * error.c (dump_decl): Remove special handling for operator ++ names. ++ (dump_function_name): Likewise. ++ (dump_expr): Adjust name lookup of operators. ++ (op_to_string): Simplify. ++ (assop_to_string): Likewise. ++ * init.c (build_new_1): Adjust use of ansi_opname. ++ * lex.c (opname_tab): Remove. ++ (assignop_tab): Likewise. ++ (ansi_opname): Likewise. ++ (ansi_assopname): Likewise. ++ (operator_name_string): Likewise. ++ (reinit_lang_specific): Likewise. ++ (operator_name_info): New variable. ++ (assignment_operator_name_info): Likewise. ++ (init_operators): New function. ++ (init_parse): Use it. ++ (do_identifier): Adjust use of ansi_opname. ++ * method.c (mangle_expression): Don't use ansi_opname for ++ mangling. ++ (build_decl_overload_real): Use DECL_OVERLOADED_OPERATOR_P. ++ (build_decl_overload): Remove. ++ (build_typename_overload): Use OPERATOR_TYPENAME_FORMAT directly. ++ (do_build_assign_ref): Adjust use of ansi_opname. ++ (synthesize_method): Likewise. ++ (implicitly_declare_fn): Likewise. ++ * operators.def: New file. ++ * parse.y (operator): Adjust use of ansi_opname. ++ * pt.c (tsubst_decl): Use IDENTIFIER_OPNAME_P. ++ (set_mangled_name_for_template_decl): Don't play games with ++ current_namespace. ++ (special_function_p): Adjust use of ansi_opname. ++ * typeck.c (check_return_expr): Likewise. ++ * Make-lang.in (cc1plus): Depend on operators.def. ++ * Makefile.in (lex.o): Likewise. ++ (decl.o): Likewise. ++ ++2000-05-27 Zack Weinberg ++ ++ * Make-lang.in (cplib2.ready): Eradicate. ++ ++2000-05-27 Richard Kenner ++ ++ * method.c (mangle_expression): Use TREE_CODE_LENGTH. ++ * tree.c (break_out_calls, build_min_nt): Use TREE_CODE_LENGTH. ++ (built_min, cp_tree_equal): Likewise. ++ ++2000-05-26 Mark Mitchell ++ ++ * class.c (layout_nonempty_base_or_field): Replace ++ `record_layout_info' with `record_layout_info_s'. ++ ++2000-05-26 Jason Merrill ++ ++ Fix goto checking. ++ * cp-tree.h (struct language_function): x_named_labels is now ++ a struct named_label_list*. ++ * decl.c (struct named_label_use_list): Renamed from... ++ (struct named_label_list): ...this. New struct. ++ (push_binding_level): Don't set eh_region. ++ (note_level_for_eh): New fn. ++ (pop_label): Take label and old value directly. ++ (pop_labels): Adjust for new named_labels format. ++ (lookup_label): Likewise. ++ (poplevel): Note characteristics of a binding level containing a ++ named label. Mess with named label lists earlier. ++ (mark_named_label_lists): New fn. ++ (mark_lang_function): Call it. ++ (use_label): New fn, split out from... ++ (make_label_decl): ...here. Don't call it. ++ (decl_jump_unsafe, check_previous_goto, check_previous_goto_1, ++ check_previous_gotos): New fns, split out from... ++ (define_label): ...here. ++ (check_switch_goto): New fn. ++ (define_case_label): Call it. ++ (check_goto): New fn. ++ * semantics.c (finish_goto_stmt): Call it and use_label. ++ (begin_compound_stmt): If we're a try block, call note_level_for_eh. ++ (expand_stmt): Never pass 1 as DONT_JUMP_IN to expand_end_bindings. ++ ++2000-05-26 Mark Mitchell ++ ++ * class.c (build_vtable_entry_ref): Correct usage of ++ get_vtbl_decl_for_binfo. ++ ++ * decl2.c (grokclassfn): Set DECL_LANGUAGE here. ++ * method.c (implicitly_declare_fn): Not here. ++ ++2000-05-26 Nathan Sidwell ++ ++ * cp-tree.h (CPTI_PTMD_DESC_TYPE): Rename to ... ++ (CPTI_PTMD_DESC_TYPE): ... here. ++ (ptmd_desc_type_node): Rename to ... ++ (ptm_desc_type_node): ... here. ++ * decl.c: Likewise. ++ * rtti.c (ptmd_initializer): Rename to ... ++ (ptm_initializer): ... here. ++ (sythesize_tinfo_var): Adjust. Deal with pointer to member ++ function. ++ (create_tinfo_types): Adjust. ++ ++2000-05-25 Mark Mitchell ++ ++ Finish implementation of VTTs. ++ * cp-tree.h (cp_tree_index): Add CPTI_VTT_PARM_TYPE and ++ CPTI_VTT_PARM_IDENTIFIER. ++ (vtt_parm_identifier): New macro. ++ (vtt_parm_type): Likewise. ++ (BINFO_SUBVTT_INDEX): Likewise. ++ (BINFO_VPTR_INDEX): Likewise. ++ (struct lang_decl): Add vtt_parm. ++ (DECL_VTT_PARM): New macro. ++ (DECL_USE_VTT_PARM): Likewise. ++ (DECL_NEEDS_VTT_PARM_P): Likewise. ++ (get_vtt_name): Declare. ++ (build_artificial_parm): Likewise. ++ (fixup_all_virtual_upcast_offsets): Likewise. ++ (expand_indirect_vtbls_init): Remove. ++ * call.c (build_new_method_call): Pass the vtt to subobject ++ constructors and destructors. ++ * class.c (get_vtt_name): Give it external linkage. ++ (build_clone): Handle the magic VTT parameters for clones. ++ (clone_function_decl): Fix typo in comment. ++ (build_vtt): Keep track of the indices in the VTTs where various ++ entities are stored. ++ (build_vtt_inits): Likewise. ++ (dfs_build_vtt_inits): Likewise. ++ (build_ctor_vtbl_group): Tweak type of construction vtables. ++ (dfs_accumulate_vtbl_inits): Build vtables for all bases, even ++ primary bases, when building construction vtables. ++ * decl.c (duplicate_decls): Handle DECL_VTT_PARM. ++ (initialize_predefined_identifiers): Add vtt_parm_identifier. ++ (init_decl_processing): Initialize vtt_parm_type. ++ (grokfndecl): Use DECL_OVERLOADED_OPERATOR_P. ++ (lang_mark_tree): Make vtt_parm. ++ * decl2.c (build_artificial_parm): New function. ++ (maybe_retrofit_in_chrg): Use it. Add VTT parameters. ++ (grokclassfn): Use build_artificial_parm. ++ * init.c (initialize_vtbl_ptrs): Call ++ fixup_all_virtual_upcast_offsets directly. ++ (perform_member_init): Use the complete subobject destructor for ++ member cleanups. ++ (build_vtbl_address): New function. ++ (expand_virtual_init): Handle VTTs. ++ * optimize (maybe_clone_body): Likewise. ++ * search.c (fixup_all_virtual_upcast_offsets): Give it external ++ linkage. ++ (expand_indirect_vtbls_init): Remove. ++ * semantics.c (setup_vtbl_ptr): Fix typos in comment. ++ * tree.c (make_binfo): Make them bigger. ++ ++2000-05-25 Nathan Sidwell ++ ++ * inc/cxxabi.h (__pbase_type_info): Define, based on ++ __pointer_type_info. ++ (__pointer_type_info): Derive from __pbase_type_info. Adjust. ++ (__pointer_to_member_type_info): Likewise. ++ * tinfo2.cc (__pbase_type_info::~__pbase_type_info): Implement. ++ (__pointer_to_member_type_info::__is_pointer_p): Remove. ++ (__pointer_type_info::__do_catch): Rename to ... ++ (__pbase_type_info::__do_catch): ... here. Adjust. ++ (__pbase_type_info::__pointer_catch): Implement. ++ (__pointer_type_info::__pointer_catch): Adjust. ++ (__pointer_to_member_type_info::__pointer_catch): Adjust. ++ ++2000-05-25 Nathan Sidwell ++ ++ * tinfo.h (__user_type_info::contained_virtual_p): New ++ predicate. ++ * tinfo.cc (__user_type_info::do_upcast): Fix bug with diamond ++ shaped hierarchy. ++ (__vmi_class_type_info::__do_upcast): Fix bug with NULL pointer to ++ diamond shaped hierarchy. Add early out for mixed diamond and ++ duplicate shaped hierarchy. ++ ++2000-05-24 Mark Mitchell ++ ++ * cp-tree.h (build_delete): Change prototype. ++ (build_vec_delete): Likewise. ++ * call.c (build_scoped_method_call): Use special_function_kind ++ values to indicate the kind of destruction to be done. ++ (build_method_call): Likewise. ++ * decl.c (finish_destructor_body): Likewise. ++ (maybe_build_cleanup_1): Likewise. Rename to ... ++ (maybe_build_cleanup): ... this. ++ * decl2.c (delete_sanity): Use special_function_kind ++ values to indicate the kind of destruction to be done. ++ (build_cleanup): Likewise. ++ * init.c (perform_member_init): Likewise. ++ (build_vec_delete_1): Likewise. ++ (build_dtor_call): Simplify. ++ (build_delete): Use special_function_kind ++ values to indicate the kind of destruction to be done. ++ (build_vbase_delete): Likewise. ++ (build_vec_delete): Likewise. ++ ++ * init.c (sort_member_init): Fix typo in error message generation ++ code. ++ ++2000-05-15 Donald Lindsay ++ ++ * semantics.c (begin_class_definition): make the packed ++ attribute be sensitive to the "-fpack-struct" command line flag ++ ++2000-05-24 Nathan Sidwell ++ ++ Update new-abi upcast algorithm. ++ * inc/cxxabi.h (__class_type_info::__do_upcast): Change ++ prototype and meaning of return value. ++ (__si_class_type_info::__do_upcast): Likewise. ++ (__vmi_class_type_info::__do_upcast): Likewise. ++ * tinfo.cc (__class_type_info::__upcast_result): Replace ++ whole2dst with part2dst. Adjust ctor. ++ (__class_type_info::__do_upcast): Adjust call of worker function. ++ (__class_type_info::__do_upcast): Adjust. ++ (__si_class_type_info::__do_upcast): Adjust. Use parent's ++ __do_upcast. ++ (__vmi_class_type_info::__do_upcast): Likewise. Fix private ++ virtual base in diamond hierarchy bug. ++ ++2000-05-23 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Rename mutable_flag to uninlinable ++ and bitfield to tinfo_fn_p. ++ (DECL_TINFO_FN_P): Adjust. ++ (SET_DECL_TINFO_FN_P): Likewise. ++ (DECL_MUTABLE_P): Likewise. ++ (DECL_C_BIT_FIELD): Likewise. ++ (SET_DECL_C_BIT_FIELD): Likewise. ++ (CLEAR_DECL_C_BIT_FIELD): Likewise. ++ (DECL_UNINLINABLE): Likewise. ++ * class.c (alter_access): Call retrofit_lang_decl if ncessary. ++ (handle_using_decl): Remove assertion. ++ (build_vtbl_or_vbase_field): Use build_decl, not build_lang_decl, ++ to build FIELD_DECLs. ++ (build_base_field): Likewise. ++ (layout_class_type): Likewise. ++ * decl.c (init_decl_processing): Likewise. ++ (build_ptrmemfunc_type): Likewise. ++ (grokdeclarator): Likewise. ++ * decl2.c (grok_x_components): Likewise. ++ * except.c (call_eh_info): Likewise. ++ * init.c (init_init_processing): Likewise. ++ * rtti.c (expand_class_desc): Likewise. ++ (create_pseudo_type_info): Likewise. ++ (get_vmi_pseudo_type_info): Likewise. ++ (create_tinfo_types): Likewise. ++ * ptree.c (print_lang_decl): Adjust. ++ * typeck.c (build_component_ref): Don't check DECL_LANG_SPECIFIC ++ before checking DECL_MUTABLE_P. ++ ++ * decl2.c (maybe_retrofit_in_chrg): Don't create in-charge ++ parameters for template functions. ++ * pt.c (tsubst_decl): Make sure we call maybe_retrofit_in_chrg for ++ destructors as well as constructors. ++ ++2000-05-22 Mark Mitchell ++ ++ * class.c (build_ctor_vtbl_group): Set inits. ++ * optimize.c (maybe_clone_body): Set DECL_INLINE and ++ DECL_THIS_INLINE appropriately for clones. ++ ++ * cp-tree.h (IDENTIFIER_TYPENAME_P): Use a flag, not strncmp. ++ (DECL_CONV_FN_P): Simplify. ++ (DECL_OPERATOR): Remove. ++ (language_to_string): Declare. ++ * decl.c (duplicate_decls): Fix typo in comment. ++ (grokdeclarator): Adjust use of IDENTIFIER_TYPENAME_P. ++ (grok_op_properties): Use DECL_CONV_FN_P instead of ++ IDENTIFIER_TYPENAME_P. ++ * dump.c (dequeue_and_dump): Dump the language linkage of ++ declarations. ++ * error.c (language_to_string): Give it external linkage. ++ * method.c (build_typename_overload): Set IDENTIFIER_TYPENAME_P. ++ (implicitly_declare_fn): Set DECL_LANGUAGE. ++ * pt.c (check_explicit_specialization): Use DECL_CONV_FN_P, not ++ IDENTIFIER_TYPENAME_P. ++ (tsubst_decl): Likewise. ++ (tsubst_copy): Adjust use of IDENTIFIER_TYPENAME_P. ++ * semantics.c (finish_member_declaration): Don't mark members of ++ classes declared in an extern "C" region as extern "C". ++ ++2000-05-22 Martin v. Löwis ++ ++ * decl2.c (qualified_lookup_using_namespace): Look through ++ namespace aliases. ++ ++ * decl.c (push_using_decl): Return the old decl on namespace level. ++ ++2000-05-21 Mark Mitchell ++ ++ * cp-tree.h (SET_BINFO_NEW_VTABLE_MARKED): Add sanity checks. ++ (VTT_NAME_PREFIX): New macro. ++ (CTOR_VTBL_NAME_PREFIX): Likewise. ++ (get_ctor_vtbl_name): New function. ++ * class.c (get_vtable_name): Simplify. ++ (get_vtt_name): New function. ++ (get_vtable_decl): Don't set IDENTIFIER_GLOBAL_VALUE. ++ (dfs_mark_primary_bases): Update the CLASSTYPE_VBASECLASSES list ++ when a virtual base becomes primary. ++ (finish_struct_1): Set CLASSTYPE_VFIELDS a little earlier. Build ++ VTTs. ++ (finish_vtbls): Adjust calls to accumulate_vtbl_inits to pass in ++ additional parameters. ++ (dfs_finish_vtbls): Don't clear BINFO_NEW_VTABLE_MARKED. ++ (initialize_array): New function. ++ (build_vtt): Likewise. ++ (build_vtt_inits): Likewise. ++ (dfs_build_vtt_inits): Likewise. ++ (dfs_fixup_binfo_vtbls): Likewise. ++ (build_ctor_vtbl_group): Likewise. ++ (initialize_vtable): Use initialize_array. ++ (accumulate_vtbl_inits): Reimplement to handle construction ++ vtables. ++ (dfs_accumulate_vtbl_inits): Likewise. ++ (bulid_vtbl_initializer): Adjust parameter name. ++ * method.c (build_typename_overload): Remove #if 0'd code. ++ (get_ctor_vtbl_name): New function. ++ * search.c (dfs_walk_real): Use BINFO_N_BASETYPES. ++ (init_vbase_pointers): Don't mess with the TREE_CHAIN of a binfo. ++ ++ * cp-tree.h (struct lang_type): Remove search_slot. ++ (CLASSTYPE_SEARCH_SLOT): Remove. ++ (emit_base_init): Change prototype. ++ (initialize_vtbl_ptrs): Likewise. ++ (expand_indirect_vtbls_init): Likewise. ++ (clear_search_slots): Remove. ++ * decl.c (lang_mark_tree): Don't mark search_slot. ++ * init.c (initialize_vtbl_ptrs): Simplify. ++ (emit_base_init): Likewise. ++ * search.c (struct vbase_info): Document decl_ptr. ++ (convert_pointer_to_single_level): Remove. ++ (dfs_find_vbases): Remove. ++ (dfs_init_base_pointers): Simplify. ++ (dfs_clear_vbase_slots): Remove. ++ (dfs_vtable_path_unmark): New function. ++ (init_vbase_pointers): Simplify. ++ (expand_upcast_fixups): Don't rely on CLASSTYPE_SEARCH_SLOT. ++ (expand_indirect_vtbls_init): Simplify. Don't call ++ mark_all_temps_used. ++ * semantics.c (setup_vtbl_ptr): Adjust calls to emit_base_init and ++ initialize_vtbl_ptrs. ++ ++2000-05-20 Zack Weinberg ++ ++ * except.c: Add static prototypes. ++ ++2000-05-20 H.J. Lu ++ ++ * Make-lang.in (cplib2.ready): Also depend on cc1plus$(exeext). ++ ++2000-05-19 Mark Mitchell ++ ++ Don't create a separate copy of virtual bases for the ++ CLASSTYPE_VBASECLASSES list. ++ * cp-tree.h (CLASSTYPE_VBASECLASSES): Change documentation. ++ (BINFO_FOR_VBASE): Remove. ++ (CANONICAL_BINFO): Adjust. ++ (binfo_for_vbase): New function. ++ * class.c (build_vbase_pointer_fields): Use binfo_for_vbase ++ instead of BINFO_FOR_VBASE. ++ (build_vbase_pointer): Likewise. ++ (build_secondary_vtable): Likewise. ++ (dfs_mark_primary_bases): Likewise. ++ (mark_primary_bases): Likewise. ++ (layout_nonempty_base_or_field): Likewise. ++ (dfs_set_offset_for_shared_vbases): Likewise. ++ (dfs_set_offset_for_unshared_vbases): Likewise. ++ (layout_virtual_bases): Likewise. Adjust for changes to the ++ CLASSTYPE_VBASECLASSES list. ++ (dump_class_hierarchy_r): Use binfo_for_vbase ++ instead of BINFO_FOR_VBASE. ++ (dump_class_hierarchy): Likewise. ++ (finish_vtbls): Likewise. ++ (build_vtbl_initializer): Adjust for changes to the ++ CLASSTYPE_VBASECLASSES list. ++ (build_vbase_offset_vtbl_entries): Use binfo_for_vbase. ++ * decl.c (finish_destructor_body): Adjust for changes to the ++ CLASSTYPE_VBASECLASSES list. ++ * init.c (sort_base_init): Use binfo_for_vbase. ++ (construct_virtual_bases): Adjust for changes to the ++ CLASSTYPE_VBASECLASSES list. ++ (expand_member_init): Use binfo_for_vbase. ++ (build_vbase_delete): Adjust for changes to the ++ CLASSTYPE_VBASECLASSES list. ++ * method.c (do_build_copy_constructor): Likewise. ++ * rtti.c (get_base_offset): Use binfo_for_vbase. ++ (expand_class_desc): Remove #if 0'd code. ++ * search.c (struct vbase_info): Remove vbase_types. ++ (get_base_distance): Use binfo_for_vbase. ++ (lookup_field_queue_p): Use CANONICAL_BINFO. ++ (get_shared_vbase_if_not_primary): Use binfo_for_vbase. ++ (get_pure_virtuals): Adjust for changes to the ++ CLASSTYPE_VBASECLASSES list. ++ (dfs_find_vbases): Use binfo_for_vbase. ++ (dfs_init_vbase_pointers): Likewise. ++ (init_vbase_pointers): Don't initialize vi.vbase_types. ++ (virtual_context): Use binfo_for_vbase. ++ (fixup_all_virtual_upcast_offsets): Adjust for changes to the ++ CLASSTYPE_VBASECLASSES list. ++ (expand_indirect_vtbls_init): Simplify. ++ (dfs_get_vbase_types): Don't replicate virtual bases. ++ (find_vbase_instance): Use binfo_for_vbase. ++ (binfo_for_vbase): New function. ++ * typeck.c (get_delta_difference): Use binfo_for_vbase. ++ ++2000-05-17 Mark Mitchell ++ ++ * decl2.c (finish_anon_union): Generalize error messages to handle ++ anonymous structures. ++ * init.c (perform_member_init): Remove `name' parameter. ++ (build_field_list): New function. ++ (sort_member_init): Handle anonymous union initialization order ++ correctly. Check for multiple initializations of the same union. ++ (emit_base_init): Don't look up fields by name here. ++ (expand_member_init): Record the result of name lookup for future ++ reference. ++ * typeck.c (build_component_ref): Fix formatting. ++ ++2000-05-17 Andrew Cagney ++ ++ * decl.c (pop_label): Replace warn_unused with warn_unused_label. ++ * typeck.c (build_x_compound_expr): Replace warn_unused with ++ warn_unused_value. ++ ++ * decl2.c (lang_decode_option): Update -Wall unused flags by ++ calling set_Wunused. ++ ++2000-05-16 Mark Mitchell ++ ++ * cp-treeh (BINFO_NEW_VTABLE_MARKED): Update documentation. ++ * init.c (dfs_vtable_path_unmark): Remove. ++ * search.c (marked_new_vtable_p): Likewise. ++ (unmarked_new_vtable_p): Likewise. ++ (dfs_search_slot_nonempty_p): Likewise. ++ (dfs_mark): Likewise. ++ (dfs_vtable_path_unmark): Likewise. ++ (dfs_find_vbases): Don't set BINFO_NEW_VTABLE_MARKED. ++ (dfs_int_vbase_pointers): Don't clear BINFO_VTABLE_PATH_MARKED. ++ (dfs_init_vbase_pointers): Remove special-case new ABI code. ++ (dfs_clear_vbase_slots): Don't clear BINFO_NEW_VTABLE_MARKED. ++ (init_vbase_pointers): Simplify. ++ (expand_indirect_vtbls_init): Likewise. ++ ++ * class.c (copy_virtuals): New function. ++ (build_primary_table): Use it. ++ (build_secondary_vtable): Likewise. ++ (modify_vtable_entry): Use NULL_TREE, not integer_zero_node, to ++ indicate that no vcall offset is required. ++ (add_virtual_function): Likewise. ++ (modify_all_vtables): Likewise. ++ (dfs_finish_vtbls): Adjust call to build_vtbl_initializer. ++ (dfs_accumulate_vtbl_inits): Likewise. ++ (build_vtbl_initializer): Make changes to handle construction ++ vtables. ++ (dfs_build_vcall_offset_vtbl_entries): Likewise. ++ (build_rtti_vtbl_entries): Likewise. ++ (build_vtable_entries): Handle a NULL vcall_index. ++ ++2000-05-15 Gabriel Dos Reis ++ ++ * decl2.c (lang_decode_option): Fix thinko. ++ ++2000-05-14 Jason Merrill ++ ++ * except.c (check_handlers): New fn. ++ * cp-tree.h: Declare it. ++ * semantics.c (finish_handler_sequence): Call it. ++ (finish_function_handler_sequence): Likewise. ++ (finish_handler_parms): Set TREE_TYPE on the handler. ++ * cp-tree.h (PUBLICLY_UNIQUELY_DERIVED_P): New macro. ++ * search.c (get_base_distance_recursive): If protect>1, ignore ++ special access. ++ (get_base_distance): Don't reduce watch_access. ++ ++2000-05-13 Gabriel Dos Reis ++ ++ * lex.c: #include diagnostic.h. ++ (lang_init_options): Set default prefixing rules. ++ ++ * lang-options.h: Add -fdiagnostics-show-location=. ++ ++ * decl2.c: #include diagnostic.h. ++ (lang_decode_option): Handle -fdiagnostics-show-location=. ++ ++2000-05-12 Nathan Sidwell ++ ++ * tinfo.cc: Revert my 2000-05-08 and 2000-05-07 changes. ++ * vec.cc: Revert my 2000-05-07 change. ++ ++2000-05-11 Jason Merrill ++ ++ * class.c (check_field_decls): Complain about non-static data ++ members with same name as class in class with constructor. ++ ++2000-05-10 Jason Merrill ++ ++ * decl.c (grokdeclarator): Allow non-static data members with ++ same name as class. ++ ++2000-05-09 Zack Weinberg ++ ++ * cp-tree.h: Constify tree_srcloc.filename, tinst_level.file, ++ and pending_inline.filename. Update prototypes. ++ * decl.c (define_label): Constify filename parameter. ++ * decl2.c (warn_if_unknown_interface): Constify local char *. ++ * input.c Constify input_source.filename. Don't declare ++ input_filename or lineno. Constify filename parameter to feed_input. ++ * lex.c (init_parse): Constify parameter and return value. ++ (cp_pragma_interface, cp_pragma_implementation): Constify ++ filename argument. ++ (reinit_parse_for_method, reinit_parse_for_block, ++ reinit_parse_for_expr, feed_defarg, handle_cp_pragma): ++ Constify local char *. ++ * pt.c: Don't declare lineno or input_filename. ++ (print_template_context, tsubst_friend_function, tsubst_decl, ++ tsubst, instantiate_decl): Constify local char *. ++ * semantics.c (expand_body): Constify local char *. ++ * tree.c (build_srcloc): Constify filename parameter. ++ * typeck.c (c_expand_asm_operands): Constify filename ++ parameter. ++ ++2000-05-08 Nathan Sidwell ++ ++ * tinfo.cc (__dynamic_cast): Use a reinterpret_cast. Fix ++ offsetof expansion. ++ ++2000-05-08 Branko Cibej ++ ++ * inc/cxxabi.h: Fix typos in comment. ++ (__base_class_info::__offset): Use a static_cast. ++ ++2000-05-07 Nathan Sidwell ++ ++ * inc/cxxabi.h: Use __SIZE_TYPE_ and __PTRDIFF_TYPE__ in place ++ of std::size_t and std::ptrdiff_t respectively. ++ * tinfo.cc: Likewise. ++ * vec.cc: Likewise. ++ ++2000-05-06 Richard Henderson ++ ++ * typeck.c (build_c_cast): Don't warn integer->pointer size ++ mismatch for constants. ++ ++2000-05-06 Nathan Sidwell ++ ++ * rtti.c (ptmd_initializer): Set non-public, if class is ++ incomplete. ++ ++ * inc/cxxabi.h (__dynamic_cast): Explicitly say extern "C++". ++ (__cxa_vec_new, __cxa_vec_ctor, __cxa_vec_dtor, ++ __cxa_vec_delete): Likewise. ++ * tinfo.cc (__dynamic_cast): Likewise. ++ * vec.cc (__cxa_vec_new, __cxa_vec_ctor, __cxa_vec_dtor, ++ __cxa_vec_delete): Likewise. ++ ++2000-05-04 Mark Mitchell ++ ++ * cp-tree.h (DELTA_FROM_VTABLE_ENTRY): Remove. ++ (SET_FNADDR_FROM_VTABLE_ENTRY): Likewise. ++ (lang_decl_flags): Add vcall_offset. ++ (THUNK_VCALL_OFFSET): Use it. ++ * decl.c (lang_mark_tree): Don't mark DECL_ACCESS for a thunk. ++ * method.c (make_thunk): Create the lang_decl here, not in ++ emit_thunk. ++ (emit_thunk): Make generic thunks into ordinary functions once ++ they have been fed to expand_body. ++ * semantics.c (expand_body): Set current_function_is_thunk here. ++ ++2000-05-04 Kaveh R. Ghazi ++ ++ * class.c (update_vtable_entry_for_fn): Prototype. ++ ++ * pt.c (tsubst_decl): Initialize variables `argvec', `gen_tmpl' ++ and `tmpl'. ++ ++ * search.c (dfs_build_inheritance_graph_order): Prototype. ++ ++2000-05-04 Mark Mitchell ++ ++ * cp-tree.h (special_function_kind): Add various kinds of ++ destructors. ++ (special_function_p): New function. ++ * class.c (overrides): Don't let one kind of destructor override ++ another. ++ * decl2.c (mark_used): Use DECL_NON_THUNK_FUNCTION_P when deciding ++ whether or not to instantiate a template. ++ * tree.c (special_function_p): Define. ++ ++2000-05-03 Mark Mitchell ++ ++ * cp-tree.def (THUNK_DECL): Remove. ++ * cp-tree.h (DECL_THUNK_P): New macro. ++ (DECL_NON_THUNK_FUNCTION_P): Likewise. ++ (DECL_EXTERN_C_FUNCTION_P): Likewise. ++ (SET_DECL_THUNK_P): Likewise. ++ (DELTA_FROM_VTABLE_ENTRY): Use DECL_THUNK_P. ++ (FNADDR_FROM_VTABLE_ENTRY): Likewise. ++ (DECL_MAIN_P): Use DECL_EXTERN_C_FUNCTION_P. ++ * decl.c (decls_match): Use DECL_EXTERN_C_P. ++ (duplicate_decls): Likewise. ++ (pushdecl): Likewise. Adjust thunk handling. ++ (grokfndecl): Use DECL_EXTERN_C_P. ++ * decl2.c (mark_vtable_entries): Use DECL_THUNK_P. ++ * dump.c (dequeue_and_dump): Remove THUNK_DECL handling. ++ * except.c (nothrow_libfn_p): Use DECL_EXTERN_C_P. ++ * expr.c (cplus_expand_expr): Remove THUNK_DECL handling. ++ * method.c (make_thunk): Use SET_DECL_THUNK_P. Set ++ DECL_NO_STATIC_CHAIN. ++ (emit_thunk): Don't play games with TREE_CODE on thunks. Don't ++ set DECL_DESTRUCTOR_P or DECL_CONSTRUCTOR_P on a thunk. ++ * search.c (covariant_return_p): Remove THUNK_DECL handling. ++ * ir.texi: Update. ++ ++2000-05-01 Jason Merrill ++ ++ * tree.c (walk_tree): Set lineno. ++ ++2000-05-01 Mark Mitchell ++ ++ * exception.cc: Update license notice. ++ * new.cc: Likewise. ++ * new1.cc: Likewise. ++ * new2.cc: Likewise. ++ * tinfo.cc: Likewise. ++ * tinfo2.cc: Likewise. ++ * vec.cc: Likewise. ++ * inc/cxxabi.h: Likewise. ++ * inc/exception: Likewise. ++ * inc/new: Likewise. ++ * inc/new.h: Likewise. ++ * inc/typeinfo: Likewise. ++ ++2000-05-01 Jason Merrill ++ ++ * tree.c (build_target_expr_with_type): If we already have a ++ TARGET_EXPR, just return it. ++ ++ * optimize.c (initialize_inlined_parameters): Don't generate an ++ EXPR_STMT if we can just use DECL_INITIAL. ++ * decl.c (emit_local_var): Only make the initialization a ++ full-expression if stmts_are_full_exprs_p. ++ ++2000-05-01 Mark Mitchell ++ ++ * cp-tree.h (same_type_ignoring_top_level_qualifiers_p): New ++ macro. ++ * call.c (standard_conversion): Use it. ++ (direct_reference_binding): Likewise. ++ (build_over_call): Likewise. ++ (is_properly_derived_from): Likewise. ++ (compare_ics): Likewise. ++ * class.c (resolves_to_fixed_type_p): Likewise. ++ * optimize.c (declare_return_variable): Likewise. ++ * pt.c (is_specialization_of): Likewise. ++ (unify): Likewise. ++ * typeck.c (comp_target_parms): Likeiwse. ++ (build_static_cast): Likewise. ++ (build_reinterpret_cast): Likewise. ++ (build_const_cast): Likewise. ++ (comp_ptr_ttypes_real): Likewise. ++ (comp_ptr_ttypes_const): Likewise. ++ * typeck2.c (process_init_constructor): Likewise. ++ ++2000-04-30 Scott Snyder ++ ++ * decl.c (finish_destructor_body): Use the base destructor when ++ destroying virtual bases. ++ ++2000-04-30 Mark Mitchell ++ ++ * expr.c (cplus_expand_expr): Preserve temporaries when expanding ++ STMT_EXPRs. ++ * optimize.c (struct inline_data): Add target_exprs field. ++ (declare_return_variable): When a function returns an aggregate, ++ use the variable declared in the TARGET_EXPR as the remapped ++ DECL_RESULT. ++ (expand_call_inline): Update the pending target_exprs stack. ++ (optimize_function): Initialize the stack. ++ ++ * decl2.c (finish_file): Fix typo in comment. ++ ++ * method.c (emit_thunk): Don't try to return a `void' value. ++ ++ * optimize.c (initialize_inlined_parameters): If the parameter is ++ addressable, we need to make a new VAR_DECL, even if the ++ initializer is constant. ++ ++2000-04-28 Cosmin Truta ++ ++ * decl.c (grok_op_properties): Add an extra check of argtypes. ++ ++2000-04-27 Mark Mitchell ++ ++ * optimize.c (copy_body_r): Use STRIP_TYPE_NOPS when copying ++ variables. ++ (initialize_inlined_parameters): Try to avoid creating new ++ VAR_DECLs. ++ ++2000-04-27 Alex Samuel ++ ++ * lex.c (my_get_run_time): Remove. ++ (init_filename_times): Use get_run_time instead of my_get_run_time. ++ (check_newline): Likewise. ++ (dump_time_statistics): Likewise. ++ * decl2.c (finish_file): Push and pop timevar TV_VARCONST instead ++ of computing elapsed time explicitly. ++ ++2000-04-26 Mark Mitchell ++ ++ * cp-tree.h (TREE_READONLY_DECL_P): Use DECL_P. ++ * init.c (decl_constant_value): Check TREE_READONLY_DECL_P. ++ * call.c (convert_like_real): Don't test TREE_READONLY_DECL_P ++ before calling decl_constant_value. ++ * class.c (check_bitfield_decl): Likewise. ++ * cvt.c (ocp_convert): Likewise. ++ (convert): Likewise. ++ * decl.c (compute_array_index_type): Likewise. ++ (build_enumerator): Likewise. ++ * decl2.c (check_cp_case_value): Likewise. ++ * pt.c (convert_nontype_argument): Likewise. ++ (tsubst): Likewise. ++ * typeck.c (decay_conversion): Likewise. ++ (build_compound_expr): Likewise. ++ (build_reinterpret_cast): Likewise. ++ (build_c_cast): Likewise. ++ (convert_for_assignment): Likewise. ++ ++2000-04-26 Jason Merrill ++ ++ * decl.c (finish_function): Don't play games with DECL_INLINE. ++ ++2000-04-25 Gabriel Dos Reis ++ ++ * ir.texi: Correct typo. ++ ++2000-04-25 Martin v. Löwis ++ ++ * decl.c (grokdeclarator): Reject VLAs as members. ++ ++2000-04-24 Gabriel Dos Reis ++ ++ * call.c (standard_conversion): Accept conversion between ++ COMPLEX_TYPEs. ++ ++ * cvt.c (ocp_convert): Handle conversion to COMPLEX_TYPE. ++ ++2000-04-24 Zack Weinberg ++ ++ * decl2.c (finish_file): Remove double setup for accounting ++ compile time. ++ ++2000-04-24 Robert Lipe ++ ++ * cp-tree.h (lang_type): Member `language' now ENUM_BITFIELD. ++ ++2000-04-23 Benjamin Kosnik ++ ++ * new.cc (set_new_handler): Needs to be in std::. ++ ++2000-04-23 Mark Mitchell ++ ++ * cp-tree.h (lang_decl): Remove pretty_function_p. ++ (DECL_PRETTY_FUNCTION_P): Use TREE_LANG_FLAG_0, not a bit in the ++ language-specific node. ++ * decl.c (cp_make_fname_decl): Use build_decl, not ++ build_lang_decl, to build the variables. ++ (grokvardecl): Don't call build_lang_decl for local variables in ++ templates. ++ (grokdeclarator): Don't call build_lang_decl for local type ++ declarations in templates. ++ * lex.c (retrofit_lang_decl): Use ggc_alloc_obj to allocated ++ zero'd memory, rather than calling memset. ++ * pt.c: Include hashtab.h. ++ (local_specializations): New variable. ++ (retrieve_local_specialization): Use it. ++ (register_local_specialization): Likewise. ++ (tsubst_decl): Don't assume local variables have ++ DECL_LANG_SPECIFIC. ++ (instantiate_decl): Set up local_specializations. ++ * Makefile.in (HTAB_H): New variable. ++ ++2000-04-23 Richard Henderson ++ ++ * typeck.c (c_expand_asm_operands): Restore the original ++ contents of the output list. ++ ++2000-04-22 Gabriel Dos Reis ++ ++ * ir.texi: Document complex number representation. ++ ++2000-04-20 Nathan Sidwell ++ ++ * rtti.c (init_rtti_processing): Set tinfo_var_id in new-abi. ++ (target_incomplete_p): New function. ++ (tinfo_base_init): Create comdat NTBS name variable. ++ (ptr_initializer): Add non_public parameter. Calculate it. ++ (ptmd_initializer): Likewise. ++ (synthesize_tinfo_var): Adjust. Emit incomplete class tinfo. ++ (create_real_tinfo_var): Add non_public parameter. Use it. ++ Push proxy into global namespace. ++ * inc/cxxabi.h (__pointer_type_info::incomplete_class_mask): ++ New enumeration. ++ * inc/typeinfo (type_info::before, type_info::operator==): ++ Compare __name addresses. ++ ++ * tinfo2.cc: Remove new-abi builtins comment. ++ ++2000-04-20 Jason Merrill ++ ++ * typeck.c (build_x_function_call): Resolve an OFFSET_REF. ++ ++ * call.c (joust): Exit early if we get the same function, too. ++ ++ * decl2.c (key_method): Return NULL_TREE for template classes. ++ (import_export_class): Don't need to check for template classes. ++ ++2000-04-18 Zack Weinberg ++ ++ * lex.c: Remove references to cccp.c. ++ ++2000-04-18 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Remove const_memfunc and ++ volatile_memfunc. Add destructor_attr. Adjust dummy. ++ (DECL_DESTRUCTOR_P): Use destructor_attr. ++ (DECL_CONST_MEMFUNC_P): Reimplement. ++ (DECL_VOLATILE_MEMFUNC_P): Remove. ++ * class.c (finish_struct_methods): Use CLASSTYPE_DESTRUCTORS. ++ (overrides): Use DECL_DESTRUCTOR_P. ++ (check_for_override): Likewise. ++ * decl.c (start_function): Likewise. ++ * decl2.c (grokfclassfn): Likewise. ++ (check_classfn): Likewise. ++ (grok_function_init): Likewise. ++ ++2000-04-17 Mark Mitchell ++ ++ * decl2.c (grokfield): Issue error on illegal data member ++ declaration. ++ ++2000-04-17 Mark P Mitchell ++ ++ * method.c (make_thunk): Set DECL_CONTEXT for a THUNK_DECL. ++ ++2000-04-16 Mark Mitchell ++ ++ * class.c (build_vtable_entry): Don't build thunks for type-info ++ functions. ++ ++2000-04-16 Jason Merrill ++ ++ * decl.c (decls_match): Allow a redeclaration of a builtin to ++ specify args while the builtin did not. ++ ++2000-04-15 Mark Mitchell ++ ++ * cp-tree.def (THUNK_DECL): Add to documentation. ++ * cp-tree.h (flag_huge_objects): Declare. ++ * class.c (modify_vtable_entry): Tidy. ++ (update_vtable_entry_for_fn): Split out from dfs_modify_vtables. ++ Calculate delta appropriately for the new ABI. ++ (dfs_modify_vtables): Use it. ++ (modify_all_vtables): Fix thinko in code to add overriding copies ++ of functions to primary vtables. ++ (build_clone): Fix typo in comment. ++ (clone_function_decl): Correct order of destructors in vtable. ++ (build_vbase_offset_vtbl_entries): Adjust comment. ++ (dfs_vcall_offset_queue_p): Remove. ++ (dfs_build_vcall_offset_vtbl_entries): Update BV_VCALL_INDEX. ++ (build_vcall_offset_vtbl_entries): Juse use dfs_skip_vbases. ++ (build_vtable_entry): Correct check for pure virtual functions. ++ Don't declare flag_huge_objects. ++ * decl.c (flag_huge_objects): Remove declaration. ++ * method.c (make_thunk): Tweak mangling for vcall offset thunks. ++ Use int_size_in_bytes. ++ (emit_thunk): Handle vcall offset thunks. ++ ++2000-04-15 Richard Kenner ++ ++ * decl2.c (parse_time, varconst_time): Delete declarations. ++ (finish_file): Delete LINENO declaration. ++ START_TIME and THIS_TIME now long. ++ ++2000-04-13 Nathan Sidwell ++ ++ * class.c (build_base_field): Reformat comment. ++ ++ * inc/cxxabi.h (stddef.h): Comment inclusion. ++ (__base_class_info::__offset): Comment shift. ++ ++2000-04-12 Mark Mitchell ++ ++ * cp-tree.h (IDENTIFIER_CTOR_OR_DTOR_P): New macro. ++ (cp_tree_index): Add CPTI_PUSH_EXCEPTION_IDENTIFIER. ++ (cp_push_exception_identifier): New macro. ++ (DECL_COMPLETE_DESTRUCTOR_P): New macro. ++ (DECL_BASE_DESTRUCTOR_P): Likewise. ++ (DECL_DELETING_DESTRUCTOR_P): Likewise. ++ (get_vtbl_decl_for_binfo): Fix formatting. ++ (in_charge_arg_for_name): New macro. ++ (maybe_build_cleanup_and_delete): Remove declaration. ++ * call.c (build_field_call): Use IDENTIFIER_CTOR_OR_DTOR_P. ++ (in_charge_arg_for_name): New function. ++ (build_new_method_call): Use it. Handle cloned destructors. ++ (build_clone): Don't make the base constructor virtual. ++ Automatically defer generated functions. ++ (clone_function_decl): Handle destructors, too. ++ (clone_constructors_and_destructors): Likewise. ++ (create_vtable_ptr): Don't create a vtable entry for a cloned ++ function. ++ * decl.c (predefined_identifier): Add ctor_or_dtor_p. ++ (initialize_predefined_identifiers): Update appropriately. ++ (finish_destructor_body): Simplify. ++ (maybe_build_cleanup_and_delete): Remove. ++ * except.c (expand_throw): Handle new-ABI destructors. ++ * init.c (expand_cleanup_for_base): Use base_dtor_identifier. ++ (build_dtor_call): New function. ++ (build_delete): Use it. Simplify. ++ * optimize.c (maybe_clone_body): Handle destructors. ++ * search.c (lookup_field_queue_p): Use IDENTIFIER_CTOR_OR_DTOR_P. ++ ++ * exception.cc (cleanup_fn): New typedef. ++ (CALL_CLEANUP): New macro. ++ (cp_eh_info): Use them. ++ (__cp_push_exception): Likewise. ++ (__cp_pop_exception): Likewise. ++ ++2000-04-11 Mark Mitchell ++ ++ * cp-tree.h (cp_tree_index): Add CPTI_DTOR_IDENTIFIER. ++ (complete_dtor_identifier): New macro. ++ (CLASSTYPE_FIRST_CONVERSION): Remove. ++ (CLASSTYPE_CONSTRUCTOR_SLOT): New macro. ++ (CLASSTYPE_DESTRUCTOR_SLOT): Likewise. ++ (CLASSTYPE_FIRST_CONVERSION_SLOT): Likewise. ++ (CLASSTYPE_CONSTRUCTORS): Likewise. ++ (CLASSTYPE_DESTRUCTORS): Likewise. ++ (lang_decl): Add cloned_function. ++ (DECL_COMPLETE_CONSTRUCTOR_P): New macro. ++ (DECL_BASE_CONSTRUCTOR_P): Likewise. ++ (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P): Likewise. ++ (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P): Likewise. ++ (DECL_CLONED_FUNCTION_P): Likewise. ++ (DECL_CLONED_FUNCTION): Likewise. ++ (clone_function_decl): Declare. ++ (maybe_clone_body): Likewise. ++ * call.c (build_user_type_conversion_1): Call complete object ++ constructors in the new ABI. ++ (build_new_method_call): Don't add in-charge parameters under the ++ new ABI. ++ * class.c (add_method): Use DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P, ++ DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P, CLASSTYPE_CONSTRUCTOR_SLOT, and ++ CLASSTYPE_DESTRUCTOR_SLOT. ++ (build_clone): New function. ++ (clone_function_decl): Likewise. ++ (clone_constructors_and_destructors): Likewise. ++ (check_bases_and_members): Use it. ++ * decl.c (iniitialize_predefined_identifiers): Initialize ++ complete_dtor_identifier. ++ (finish_function): Don't add extra code to a clone. ++ (lang_mark_tree): Mark cloned_function. ++ * decl2.c (mark_used): Don't bother trying to instantiate things ++ we synthesized. ++ * dump.c (dequeue_and_dump): Don't dump CP_DECL_CONTEXT twice. ++ * method.c (set_mangled_name_for_decl): Don't treat clones as ++ constructors. ++ (synthesize_method): Sythesize cloned functions, not the clones. ++ * optimize.c (inline_data): Update comment on ret_label. ++ (remap_block): Don't assume DECL_INITIAL exists. ++ (copy_body_r): Allow ret_label to be NULL. ++ (maybe_clone_body): Define. ++ * pt.c (tsubst_decl): Handle clones. ++ (instantiate_clone): New function. ++ (instantiate_template): Use it. ++ (set_mangled_name_for_template_decl): Don't treat clones as ++ constructors. ++ * search.c (lookup_fnfields_1): Use CLASSTYPE_CONSTRUCTOR_SLOT, ++ CLASSTYPE_DESTRUCTOR_SLOT, and CLASSTYPE_FIRST_CONVERSION_SLOT. ++ * semantics.c (expand_body): Clone function bodies as necessary. ++ ++ * optimize.c (remap_decl): Avoid sharing structure for arrays ++ whose size is only known at run-time. ++ * tree.c (copy_tree_r): Don't copy PARM_DECLs. ++ ++ * cp-tree.h (lang_decl_flags): Rename constructor_for_vbase_attr ++ to has_in_charge_parm_p. ++ (DECL_CONSTRUCTOR_FOR_VBASE_P): Rename to ... ++ (DECL_HAS_IN_CHARGE_PARM_P): ... this. ++ (DECL_COPY_CONSTRUCTOR_P): New macro. ++ * call.c (add_function_candidate): Use DECL_HAS_IN_CHARGE_PARM_P. ++ (build_user_type_conversion_1): Likewise. ++ (convert_like_real): Likewise. ++ (build_over_call): Likeiwse. Use DECL_COPY_CONSTRUCTOR_P. ++ * decl.c (grokdeclarator): Use DECL_HAS_IN_CHARGE_PARM_P. ++ (copy_args_p): Likewise. ++ (grok_ctor_properties): Likewise. ++ (start_function): Likewise. ++ * decl2.c (maybe_retrofit_in_charge): Likewise. Set it. ++ * error.c (dump_function_decl): Use DECL_HAS_IN_CHARGE_PARM_P. ++ * init.c (emit_base_init): Use DECL_COPY_CONSTRUCTOR_P. ++ * method.c (do_build_copy_constructor): Use ++ DECL_HAS_IN_CHARGE_PARM_P. ++ (synthesize_method): Likewise. ++ * pt.c (instantiate_template): Remove goto. ++ * tree.c (build_cplus_method_type): Remove mention of obstacks in ++ comment. ++ ++ * cp-tre.h (finish_function): Change prototype. ++ * decl.c (end_cleanup_fn): Adjust caller. ++ (finish_function): Take only one parameter. ++ * decl2.c (finish_objects): Adjust caller. ++ (finish_static_storage_duration_function): Likewise. ++ * method.c (emit_thunk): Likewise. ++ * parse.y: Likewise. ++ * parse.c: Regenerated. ++ * pt.c (instantiate_decl): Likewise. ++ * rtti.c (synthesize_tinfo_fn): Likewise. ++ * semantics.c (expand_body): Likewise. ++ ++ * cp-tree.h (copy_decl): New function. ++ * class.c (finish_struct_1): Use it. ++ * lex.c (copy_decl): Define it. ++ * pt.c (tsubst_decl): Likewise. ++ * tree.c (copy_template_template_parm): Likewise. ++ ++ * cp-tree.h (lang_type): Remove has_nonpublic_ctor and ++ has_nonpublic_assign_ref. ++ (TYPE_HAS_NONPUBLIC_CTOR): Don't declare. ++ (TYPE_HAS_NONPUBLIC_ASSIGN_REF): Likewise. ++ * class.c (finish_struct_methods): Don't set ++ TYPE_HAS_NONPUBLIC_CTOR or TYPE_HAS_NONPUBLIC_ASSIGN_REF. ++ (interface_only): Don't declare. ++ (interface_unknown): Likewise. ++ ++2000-04-11 Martin v. Löwis ++ ++ * tree.h (HAVE_TEMPLATES): Remove definition. ++ * lang-options.h (-fthis-is-variable): Remove documentation. ++ ++2000-04-10 Jason Merrill ++ ++ * class.c (instantiate_type): Handle object-relative template-id. ++ ++ * semantics.c (finish_expr_stmt): Call convert_to_void here. ++ * decl.c (cplus_expand_expr_stmt): Not here. ++ ++ * rtti.c (build_dynamic_cast_1): Call non_lvalue. ++ Initialize exprtype earlier. ++ ++ * parse.y (fn.def1): Check for defining types in return types. ++ ++ * decl.c (check_tag_decl): Notice extra fundamental types. ++ Diagnose empty decls in classes, too. ++ ++ * decl.c (grokdeclarator): Don't override an anonymous name if no ++ declarator was given. ++ ++ * cvt.c (convert_to_void): Call resolve_offset_ref. ++ ++ * typeck.c (build_x_function_call): Abort if we get an OFFSET_REF. ++ ++ * decl2.c (decl_namespace): Handle getting a type. ++ ++ * typeck.c (build_c_cast): Re-enable warning for cast between ++ pointer and integer of different size. ++ ++2000-04-10 Nathan Sidwell ++ ++ * inc/cxxabi.h (__pointer_type_info): Add restrict and ++ incomplete flags. ++ (__pointer_type_info::__pointer_catch): New virtual function. ++ (__pointer_to_member_type_info): Derive from ++ __pointer_type_info. Adjust. ++ (__pointer_to_member_type_info::__do_catch): Remove. ++ (__pointer_to_member_type_info::__is_pointer_p): Declare. ++ (__pointer_to_member_type_info::__pointer_catch): Declare. ++ * rtti.c (qualifier_flags): Add restrict flag. ++ (ptmd_initializer): Reorder members. ++ (create_tinfo_types): Expand comments. Reorder ++ ptmd_desc_type_node members. ++ * tinfo2.cc (__pointer_to_member_type_info::__is_pointer_p): ++ Implement. ++ (__pointer_type_info::__do_catch): Move specific code into ++ __pointer_catch. Call it. ++ (__pointer_type_info::__pointer_catch): Non-pointer-to-member ++ specific catch checking. Fix void conversion check. ++ (__pointer_to_member_type_info::__do_catch): Remove. ++ (__pointer_to_member_type_info::__pointer_catch): Implement. ++ ++2000-04-10 Martin v. Löwis ++ ++ * lex.c (init_parse): Remove traces of classof and headof. ++ * decl2.c (flag_operator_names): Default to 1. ++ (lang_decode_option): Do not set it for -ansi. ++ ++2000-04-09 Mark Mitchell ++ ++ * cp-tree.h (struct lang_decl): Remove main_decl_variant. ++ (DECL_MAIN_VARIANT): Remove. ++ * decl.c (duplicate_decls): Don't set it. ++ (start_function): Likewise. ++ (lang_mark_tree): Don't mark it. ++ * decl2.c (defer_fn): Don't use it. ++ * lex.c (retrofit_lang_decl): Don't set it. ++ * pt.c (tsubst_decl): Likewise. ++ * ptree.c (print_lang_decl): Don't print it. ++ * typeck.c (mark_addressable): Don't use it. ++ ++2000-04-09 Nathan Sidwell ++ ++ * vec.cc: Include and . ++ (__cxa_vec_ctor): Use __cxa_vec_dtor for cleanup. ++ (__cxa_vec_dtor): Catch dtor exceptions, and rethrow or ++ terminate. ++ (__cxa_vec_delete): Catch dtor exceptions. ++ ++2000-04-09 Nathan Sidwell ++ ++ Prepend __ to implementation defined names. ++ * inc/typeinfo (type_info): Rename _name to __name. ++ (type_info::type_info): Rename parameter. ++ (type_info::operator==, type_info::operator!=, ++ type_info::before): Likewise. ++ (type_info::is_pointer_p, type_info::is_function_p, ++ type_info::do_catch, type_info::do_upcast): Prepend __. Rename ++ parameters. ++ * inc/cxxabi.h ++ (__fundamental_type_info::__fundamental_type_info) Rename parameters. ++ (__pointer_type_info::__pointer_type_info): Likewise. ++ (__pointer_type_info::is_pointer_p, ++ __pointer_type_info::do_catch): Prepend __. Rename parameters. ++ (__array_type_info::__array_type_info): Rename parameters. ++ (__function_type_info::__function_type_info): Likewise. ++ (__function_type_info::is_function_p): Prepend __. ++ (__enum_type_info::__enum_type_info): Rename parameters. ++ (__pointer_to_member_type_info::__pointer_to_member_type_info): ++ Likewise. ++ (__pointer_to_member_type_info::do_catch): Prepend __. Rename ++ parameters. ++ (__base_class_info::is_virtual_p, is_public_p, offset): Prepend __. ++ (__class_type_info::__class_type_info): Rename parameters. ++ (__class_type_info::sub_kind): Prepend __. Adjust member names. ++ (__class_type_info::upcast_result, ++ __class_type_info::dyncast_result): Prepend __. Move definition ++ into tinfo.cc. ++ (__class_type_info::do_upcast, __class_type_info::do_catch, ++ __class_type_info::find_public_src, ++ __class_type_info::do_dyncast, ++ __class_type_info::do_find_public_src): Prepend __. Rename ++ parameters. ++ (__si_class_type_info::__si_class_type_info): Rename parameters. ++ (__si_class_type_info::do_upcast, __si_class_type_info::do_dyncast, ++ __si_class_type_info::do_find_public_src): Prepent __. Rename ++ parameters. ++ (__vmi_class_type_info::__vmi_class_type_info): Rename parameters. ++ (__vmi_class_type_info::do_upcast, __vmi_class_type_info::do_dyncast, ++ __vmi_class_type_info::do_find_public_src): Prepent __. Rename ++ parameters. ++ (__dynamic_cast): Rename parameters. ++ * tinfo.cc (type_info::is_pointer_p, type_info::is_function_p, ++ type_info::do_catch, type_info::do_upcast): Prepend __. ++ (contained_p, public_p, virtual_p, contained_public_p, ++ contained_nonpublic_p, contained_nonvirtual_p): Adjust. ++ (__class_type_info::do_catch, ++ __class_type_info::do_upcast): Prepend __. Adjust. ++ (__class_type_info::__upcast_result, ++ __class_type_info::__dyncast_result): Move from inc/cxxabi.h. ++ Adjust. ++ (__class_type_info::find_public_src): Prepend __. Adjust. ++ (__class_type_info::do_find_public_src, ++ __si_class_type_info::do_find_public_src, ++ __vmi_class_type_info::do_find_public_src): Likewise. ++ (__class_type_info::do_dyncast, ++ __si_class_type_info::do_dyncast, ++ __vmi_class_type_info::do_dyncast): Likewise. ++ (__class_type_info::do_upcast, ++ __si_class_type_info::do_upcast, ++ __vmi_class_type_info::do_upcast): Likewise. ++ (__dynamic_cast): Adjust. ++ * tinfo2.cc (__pointer_type_info::is_pointer_p): Prepend __. ++ (__function_type_info::is_function_p): Likewise. ++ (__pointer_type_info::do_catch): Likewise. Adjust. ++ (__pointer_to_member_type_info::do_catch): Likewise. Adjust. ++ (__throw_type_match_rtti_2): Adjust. ++ (__is_pointer): Adjust. ++ ++2000-04-08 Mark Mitchell ++ ++ * cp-tree.h (cp_tree_index): Add CPTI_COMPLETE_CTOR_IDENTIFIER. ++ (complete_ctor_identifier): New macro. ++ (special_function_kind): Add sfk_copy_constructor and ++ sfk_assignment_operator. ++ (LOOKUP_HAS_IN_CHARGE): Remove. ++ (cons_up_default_function): Rename to ... ++ (implicitly_declare_fn): ... this. ++ * call.c (build_new_method_call): Add in-charge parameters for ++ constructors here. ++ * class.c (add_implicitly_declared_members): Change parameter name ++ from cant_have_assignment to cant_have_const_assignment. ++ Replace calls to cons_up_default_function to implicitly_declare_fn. ++ * cvt.c (ocp_convert): Use complete_ctor_identifier. ++ * decl.c (initialize_predefined_identifiers): Initialize it. ++ (start_function): Use DECL_CONSTRUCTOR_FOR_VBASE_P instead of ++ complex expression. ++ * init.c (expand_default_init): Don't calculate the in-charge ++ parameter here. ++ (build_new_1): Likewise. ++ * lex.c (cons_up_default_function): Move to method.c. ++ * method.c (synthesize_method): Use DECL_DESTRUCTOR_P. ++ (implicitly_declare_fn): New function. ++ * typeck.c (build_static_cast): Use complete_ctor_identifier. ++ (build_modify_expr): Likewise. ++ * typeck2.c (build_functional_cast): Likewise. ++ ++ Under the new ABI, constructors don't return `this'. ++ * cp-tree.h (warn_reorder): Declare. ++ (special_function_kind): New enum. ++ (global_base_init_list): Remove declaration. ++ (emit_base_init): Don't return a value. ++ (check_base_init): Don't declare. ++ (is_aggr_typedef): Likewise. ++ * decl.c (check_special_function_return_type): New function. ++ (return_types): Remove. ++ (grokdeclarator): Use check_special_function_return_type. ++ (start_function): Don't initialize ctor_label under the new ABI. ++ (finish_construtor_body): Don't create a corresponding LABEL_STMT. ++ * init.c (begin_init_stmts): Move to top of file. ++ (finish_init_stmts): Likewise. ++ (warn_reorder): Don't declare. ++ (emit_base_init): Don't create a STMT_EXPR here. Don't return a ++ value. ++ (check_base_init): Remove. ++ (is_aggr_typedef): Likewise. ++ (build_new_1): Don't use the return value of a constructor. ++ * semantics.c (setup_vtbl_ptr): Don't use the return value ++ of emit_base_init. ++ * typeck.c (check_return_expr): Don't magically convert return ++ statements into `return this' in constructors under the new ABI. ++ ++ * cp-tree.h (cp_tree_index): Add CPTI_BASE_CTOR_IDENTIFIER, ++ CPTI_BASE_DTOR_IDENTIFIER, and CPTI_DELETING_DTOR_IDENTIFIER. ++ (base_ctor_identifier): New macro. ++ (base_dtor_identifier): Likewise. ++ (deleting_dtor_identifier): Likewise. ++ * decl.c: Don't include obstack.h. ++ (obstack_chunk_alloc): Don't define. ++ (obstack_chunk_free): Likewise. ++ (struct predefined_identifier): New type. ++ (initialize_predefined_identifiers): New function. ++ (init_decl_processing): Use it. ++ (debug_temp_inits): Remove. ++ (start_method): Don't call preserve_data. ++ (hack_incomplete_structures): Update comment. ++ * init.c (init_init_processing): Don't initialize ++ nelts_identifier. ++ (build_offset_rf): Remove dead code. ++ (build_delete): Use CLASSTYPE_N_BASECLASSES. ++ * search.c (init_search_processing): Don't initialize ++ vptr_identifier. ++ ++2000-04-08 Kaveh R. Ghazi ++ ++ * typeck.c (build_binary_op): Call `tree_expr_nonnegative_p' to elide ++ some sign_compare warnings. ++ ++2000-04-07 Nathan Sidwell ++ ++ Rename abi::__vmi_class_type_info members. ++ * inc/cxxabi.h (__vmi_class_type_info): Rename details, n_bases, ++ base_list, detail_masks members to vmi_flags, vmi_base_count, ++ vmi_bases and vmi_flags_masks respectively. ++ (__vmi_class_type_info::vmi_flags_masks): Rename ++ details_unknown_mask to flags_unknown_mask. ++ * tinfo.cc (__class_type_info::do_upcast): Adjust. ++ (__vmi_class_type_info::do_find_public_src): Adjust. ++ (__vmi_class_type_info::do_dyncast): Adjust. ++ (__vmi_class_type_info::do_upcast): Adjust. ++ ++2000-04-07 Nathan Sidwell ++ ++ * tinfo.cc (convert_to_base): New function. ++ (get_vbase_offset): Remove. Move into convert_to_base. ++ (__vmi_class_type_info::do_find_public_src): Adjust. ++ (__vmi_class_type_info::do_dyncast): Adjust. ++ (__vmi_class_type_info::do_upcast): Adjust. ++ ++2000-04-06 Jason Merrill ++ ++ * tinfo.cc (operator=): Use __builtin_strcmp. ++ * tinfo2.cc (before): Likewise. ++ ++2000-04-06 Mark Mitchell ++ ++ * cp-tree.h (lang_decl_flags): Rename saved_inline to deferred. ++ (DECL_SAVED_INLINE): Rename to ... ++ (DECL_DEFERRED_FN): ... this. ++ (in_function_p): Remove declaration. ++ (mark_inline_for_output): Rename to ... ++ (defer_fn): ... this. ++ * decl.c (finish_function): Adjust call to mark_inline_for_output. ++ (in_function_p): Remove definition. ++ * decl2.c (saved_inlines): Rename to ... ++ (deferred_fns): ... this. ++ (saved_inlines_used): Rename to ... ++ (deferred_fns_used): ... this. ++ (mark_inline_for_output): Rename to ... ++ (defer_fn): ... this. ++ (finish_file): Adjust accordingly. ++ (init_decl2): Likewise. ++ * lex.c (cons_up_default_function): Likewise. ++ * pt.c (mark_decl_instantiated): Likewise. ++ (instantiate_decl): Don't set DECL_DEFER_OUTPUT under any ++ circumstances. ++ * rtti.c (get_tinfo_decl): Adjust call to mark_inline_for_output. ++ * semantics.c (expand_body): Defer more functions. ++ ++2000-04-06 Nathan Sidwell ++ ++ * vec.cc: New file. ++ * Make-lang.in (CXX_LIB2FUNCS): Add it. ++ (vec.o): Build it. ++ * inc/cxxabi.h (__cxa_vec_new, __cxa_vec_ctor, __cxa_vec_dtor, ++ __cxa_vec_delete): Declare. ++ ++2000-04-06 Nathan Sidwell ++ ++ * rtti.c (dfs_class_hint_mark): New static function. ++ (dfs_class_hint_unmark): New static function. ++ (class_hint_flags): Use them. ++ ++2000-04-05 Benjamin Kosnik ++ ++ * decl2.c: Make flag_honor_std dependent on ENABLE_STD_NAMESPACE. ++ ++2000-04-05 Mark Mitchell ++ ++ * cp-tree.h (instantiate_decl): Change prototype. ++ * decl2.c (mark_used): Adjust call. ++ * optimize.c (inlinable_function_p): Adjust handling of templates. ++ * pt.c (do_decl_instantiation): Adjust call to instantiate_decl. ++ (do_type_instantiation): Likewise. ++ (instantiate_decl): Defer more templates. ++ (instantiate_pending_templates): Adjust logic to handle inline ++ friend functions. ++ ++ * Makefile.in (GGC_H): New variable. Use it throughout in place ++ of ggc.h. ++ ++ * call.c: Don't include obstack.h. Include ggc.h. ++ (obstack_chunk_alloc): Don't define. ++ (obstack_chunk_free): Likewise. ++ (add_candidate): Allocate the z_candidate with ggc_alloc_obj. ++ * decl.c (push_switch): Use xmalloc to allocate the cp_switch. ++ (pop_switch): Free it. ++ ++ * decl2.c (grokclassfn): Set TREE_READONLY for PARM_DECLs. ++ ++ * dump.c (dequeue_and_dump): Don't try to print the bit_position ++ if we don't have a DECL_FIELD_OFFSET. ++ ++Wed Apr 5 15:12:18 MET DST 2000 Jan Hubicka ++ ++ * optimize.c (calls_setjmp_r): Use setjmp_call_p instead of ++ special_function_p. ++ ++2000-04-04 Kaveh R. Ghazi ++ ++ * cfns.gperf (hash, libc_name_p): Prototype. ++ ++ * rtti.c (build_dynamic_cast_1): Constification. ++ ++ * search.c (dfs_debug_unmarkedp, dfs_debug_mark): Unhide prototypes. ++ ++ * semantics.c (deferred_type_access_control): Prototype. ++ ++2000-04-04 Mark Mitchell ++ ++ Correct many new ABI issues regarding vbase and vcall offset ++ layout. ++ * cp-tree.h (BINFO_VTABLE): Document. ++ (struct lang_type): Tweak formatting. ++ (BINFO_PRIMARY_BINFO): Add to documentation. ++ (CLASSTYPE_VSIZE): Fix typo in comment. ++ (CLASSTYPE_VBASECLASSES): Update documentation. ++ (BINFO_VBASE_MARKED): Remove. ++ (SET_BINFO_VBASE_MARKED): Likewise. ++ (CLEAR_BINFO_VBASE_MARKED): Likewise. ++ (BINFO_FIELDS_MARKED): Remove. ++ (SET_BINFO_FIELDS_MARKED): Likewise. ++ (CLEAR_BINFO_FIELDS_MARKED): Likewise. ++ (enum access_kind): New enumeration. ++ (num_extra_vtbl_entries): Remove declaration. ++ (size_extra_vtbl_entries): Likewise. ++ (get_vtbl_decl_for_binfo): New function. ++ (dfs_vbase_unmark): Remove declaration. ++ (mark_primary_bases): Likewise. ++ * class.c (SAME_FN): Remove. ++ (struct vcall_offset_data_s): Move definition. ++ (build_vbase_pointer): Use `build', not `build_binary_op', to ++ access the vbase pointer under the new ABI. ++ (build_vtable_entry_ref): Use get_vtbl_decl_for_binfo. ++ (build_primary_vtable): Likewise. ++ (dfs_mark_primary_bases): Move here from search.c. ++ (mark_primary_bases): Likewise. ++ (determine_primary_bases): Under the new ABI, don't make a base ++ class a primary base just because we don't yet have any virtual ++ functions. ++ (layout_vtable_decl): Use get_vtbl_decl_for_binfo. ++ (num_vfun_entries): Remove. ++ (dfs_count_virtuals): Likewise. ++ (num_extra_vtbl_entries): Likewise. ++ (size_extra_vtbl_entries): Likewise. ++ (layout_virtual_bases): Iterate in inheritance graph order under ++ the new ABI. ++ (finish_struct_1): Use TYPE_VFIELD, not CLASSTYPE_VSIZE, to ++ indicate that a vfield is present. ++ (init_class_processing): Initialize access_public_node, etc., from ++ ak_public, etc. ++ (get_vtbl_decl_for_binfo): New function. ++ (dump_class_hierarchy_r): Likewise. ++ (dump_class_hierarchy): Use it. ++ (finish_vtbls): Build the vtbls in inheritance graph order. ++ (dfs_finish_vtbls): Adjust call to build_vtbl_initializer. ++ (initialize_vtable): Use get_vtbl_decl_for_binfo. ++ (accumulate_vtbl_inits): Add comments explaining why a pre-order ++ walk is required. ++ (dfs_accumulate_vtbl_inits): Set BINFO_VTABLE to the location ++ where the vptr points, even for primary vtables. ++ (build_vtbl_initializer): Adjust handling of vbase and vcall ++ offsets. ++ (build_vcall_and_vbase_vtable_entries): New function. ++ (dfs_build_vbase_offset_vtbl_entries): Remove. ++ (build_vbase_offset_vtbl_entries): Reimplement. ++ (dfs_build_vcall_offset_vtbl_entries): Don't include virtuals that ++ were already handled in a primary base class vtable. ++ (build_vcall_offset_vtbl_entries): Adjust. ++ (build_rtti_vtbl_entries): Adjust. ++ * decl2.c (output_vtable_inherit): Use get_vtbl_decl_for_binfo. ++ * init.c (expand_virtual_init): Simplify. ++ * repo.c (repo_get_id): Use get_vtbl_decl_for_binfo. ++ * rtti.c (create_pseudo_type_info): Adjust calculation of vptr. ++ * search.c (BINFO_ACCESS): New macro. ++ (SET_BINFO_ACCESS): Likewise. ++ (dfs_access_in_type): Manipulate access_kinds, not access nodes. ++ (access_in_type): Likewise. ++ (dfs_accessible_p): Likewise. ++ (protected_accessible_p): Likewise. ++ (lookup_fnfields_1): Adjust documentation. ++ (dfs_mark_primary_bases): Move to class.c ++ (mark_primary_bases): Likewise. ++ (dfs_vbase_unmark): Remove. ++ (virtual_context): Use BINFO_FOR_VBASE. ++ (dfs_get_vbase_types): Simplify. ++ (dfs_build_inheritance_graph_order): New function. ++ (get_vbase_types): Use it. ++ * tree.c (debug_binfo): Use get_vtbl_decl_for_binfo. ++ ++ * tinfo.cc (get_vbase_offset): New function. ++ (__vmi_class_type_info::do_find_public_src): Use it. ++ (__vmi_class_type_info::do_dyncast): Likewise. ++ (__vmi_class_type_info::do_upcast): Likewise. ++ ++2000-04-03 Zack Weinberg ++ ++ * lang-specs.h: Pass -fno-show-column to the preprocessor. ++ ++2000-03-30 Nathan Sidwell ++ ++ * rtti.c (class_hint_flags): Rename flags. ++ (class_initializer): Remove flags. ++ (synthesize_tinfo_var): Combine offset and flags. Add flags ++ for __vmi_class_type_info. ++ (create_tinfo_types): Remove flags from __class_type_info and ++ __si_class_type_info. Merge flags and offset from ++ base_class_type_info. ++ * inc/cxxabi.h (__base_class_info): Merge offset and vmi_flags. ++ (__base_class_info::is_virtual_p): Adjust. ++ (__base_class_info::is_public_p): Adjust. ++ (__base_class_info::offset): New accessor. ++ (__class_type_info::details): Remove member. ++ (__class_type_info::__class_type_info): Lose details. ++ (__class_type_info::detail_masks): Remove. ++ (__si_class_type_info::__si_class_type_info): Lose details. ++ (__vmi_class_type_info::details): New member. ++ (__vmi_class_type_info::__vmi_class_type_info): Adjust. ++ (__vmi_class_type_info::detail_masks): New member. ++ * tinfo.cc (__class_type_info::do_upcast): Initialize result ++ with unknown_details_mask. ++ (__vmi_class_type_info::do_find_public_src): Adjust ++ (__vmi_class_type_info::do_dyncast): Adjust. ++ (__vmi_class_type_info::do_upcast): Set result details, if ++ needed. Adjust. ++ (__dynamic_cast): Temporarily #if out optimization. ++ ++2000-03-29 Nathan Sidwell ++ ++ * rtti.c (get_tinfo_decl): Mark used. ++ (emit_tinfo_decl): Don't optimize polymorphic type_info. Only ++ mark as dealt with, if we output it. ++ ++2000-03-28 Mark Mitchell ++ ++ * class.c: Reorganize to put virtual function table initialization ++ machinery at the end of the file. ++ ++2000-03-28 Jason Merrill ++ ++ * class.c (finish_struct): Use bitsize_zero_node. ++ * pt.c (instantiate_class_template): Likewise. ++ ++2000-03-28 Mark Mitchell ++ ++ Put RTTI entries at negative offsets in new ABI. ++ * class.c (dfs_build_vbase_offset_vtbl_entries): Put the first ++ vbase offset at index -3, not -1. ++ (build_vtabe_offset_vtbl_entries): Use unmarked_vtable_pathp, not ++ dfs_vtable_path_unmarked_real_bases_queue_p to walk bases. ++ (dfs_build_vcall_offset_vtbl_entries): Don't use skip_rtti_stuff. ++ (build_rtti_vtbl_entries): New function. ++ (set_rtti_entry): Remove. ++ (build_primary_vtable): Don't use it. ++ (build_secondary_vtable): Likewise. ++ (start_vtable): Remove. ++ (first_vfun_index): New function. ++ (set_vindex): Likewise. ++ (add_virtual_function): Don't call start_vtable. Do call ++ set_vindex. ++ (set_primary_base): Rename parameter. ++ (determine_primary_base): Likewise. ++ (num_vfun_entries): Don't use skip_rtti_stuff. ++ (num_extra_vtbl_entries): Include RTTI information. ++ (build_vtbl_initializer): Use build_rtti_vtbl_entries. ++ (skip_rtti_stuff): Remove. ++ (dfs_modify_vtables): Don't use it. ++ (modify_all_vtables): Don't use start_vtable. Do use set_vindex. ++ (layout_nonempty_base_or_field): Update size handling. ++ (create_vtable_ptr): Tweak. ++ (layout_class_type): Adjust parameter names. ++ (finish_struct_1): Simplify. ++ * cp-tree.h (CLASSTYPE_VSIZE): Tweak documentation. ++ (skip_rtti_stuff): Remove. ++ (first_vfun_index): New function. ++ (dfs_vtable_path_unmarked_real_bases_queue_p): Remove. ++ (dfs_vtable_path_marked_real_bases_queue_p): Remove. ++ (marked_vtable_pathp): Declare. ++ (unmarked_vtable_pathp): Likewise. ++ * error.c (dump_expr): Use first_vfun_index to calculate vtable ++ offsets. ++ * rtti.c (build_headof): Look for RTTI at negative offsets. ++ (get_tinfo_decl_dynamic): Likewise. ++ (tinfo_base_init): Don't take the address of the TINFO_VTABLE_DECL ++ here. ++ (create_pseudo_type_info): Do it here instead. Adjust so that ++ vptr points at first virtual function. ++ * search.c (marked_vtable_pathp): Make it global. ++ (unmarked_vtable_pathp): Likewise. ++ (dfs_vtable_path_unmarked_real_bases_queue_p): Remove. ++ (dfs_vtable_path_marked_real_bases_queue_p): Likewise. ++ (dfs_get_pure_virtuals): Don't use skip_rtti_stuff. ++ (get_pure_virtuals): Likewise. ++ (expand_upcast_fixups): Likewise. ++ * tree.c (debug_binfo): Likewise. ++ * tinfo.cc (__dynamic_cast): Look for vtable_prefix at appropriate ++ negative offset. ++ ++2000-03-26 Richard Kenner ++ ++ * class.c (check_field_decl): Fix typo. ++ (build_vtbl_or_vbase_field): Don't clear DECL_SAVED_INSNS. ++ (check_methods): Likewise. ++ (check_field_decls): Likewise. ++ Use DECL_CONTEXT, not DECL_FIELD_CONTEXT. ++ * cp-tree.h (DECL_SHADOWED_FOR_VAR, DECL_TEMPLATE_RESULT): ++ Use DECL_RESULT_FLD, not DECL_RESULT. ++ * decl.c (xref_tag): Use DECL_TEMPLATE_RESULT. ++ * lex.c (identifier_type): Likewise. ++ * pt.c (determine_specialization, lookup_template_class): Likewise. ++ (tsubst_friend_function, tsubst_decl, instantiate_template): Likewise. ++ (resolve_overloaded_unification, more_specialized): Likewise. ++ * semantics.c (finish_member_declaration): Likewise. ++ * typeck.c (build_x_function_call): Likewise. ++ ++2000-03-26 Mark Mitchell ++ ++ * class.c (layout_empty_base): Handle empty bases with non-byte ++ alignment. ++ (build_base_field): Likewise. ++ (layout_virtual_bases): Likewise. ++ ++ * class.c (finish_struct_1): Fix typo in this change: ++ ++ Sat Mar 25 09:12:10 2000 Richard Kenner ++ ++2000-03-25 Mark Mitchell ++ ++ * decl.c (grokdeclarator): Count partial specializations when ++ keeping track of how many template classes have been seen. ++ ++ * dump.c (dequeue_and_dump): Dump DECL_TEMPLATE_RESULT. ++ ++2000-03-25 Richard Kenner ++ ++ * class.c (build_vbase_pointer_fields): layout_field now place_field. ++ (get_vfield_offset): Use byte_position. ++ (set_rtti_entry): Set OFFSET to ssizetype zero. ++ (get_binfo_offset_as_int): Deleted. ++ (dfs_record_base_offsets): Use tree_low_cst. ++ (dfs_search_base_offsets): Likewise. ++ (layout_nonempty_base_or_field): Reflect changes in RLI format ++ and call byte_position. ++ (layout_empty_base): Convert offset to ssizetype. ++ (build_base_field): use rli_size_unit_so_far. ++ (dfs_propagate_binfo_offsets): Do computation in proper type. ++ (layout_virtual_bases): Pass ssizetype to propagate_binfo_offsets. ++ (layout_class_type): Reflect changes in RLI names and fields. ++ (finish_struct_1): Set DECL_FIELD_OFFSET. ++ * dump.c (dequeue_and_dump): Call bit_position. ++ * expr.c (cplus_expand_constant): Use byte_position. ++ * rtti.c (expand_class_desc): Use bitsize_one_node. ++ * typeck.c (build_component_addr): Use byte_position and don't ++ special case for zero offset. ++ ++2000-03-24 Nathan Sidwell ++ ++ * decl.c (vtype_decl_p): Use TYPE_POLYMORPHIC_P. ++ ++ * rtti.c (get_tinfo_decl): Set comdat linkage on new-abi ++ tinfo object. ++ (emit_tinfo_decl): Only emit polymorphic tinfo's when emitting ++ vtable. ++ ++2000-03-20 Theodore Papadopoulo ++ ++ * call.c (check_dtor_name, build_new_method_call): Use TYPE_P and ++ DECL_P macros. ++ * decl.c (push_class_binding, poplevel, pushtag, lookup_namespace_name, ++ make_typename_type, check_initializer, cp_finish_decl, ++ xref_tag): Likewise. ++ * decl2.c (grokfield, build_expr_from_tree, build_expr_from_tree, ++ decl_namespace, arg_assoc_template_arg, arg_assoc, ++ validate_nonmember_using_decl, do_class_using_decl): Likewise. ++ * error.c (dump_template_argument, dump_expr, cp_file_of, cp_line_of, ++ args_to_string): Likewise. ++ * friend.c (is_friend): Likewise. ++ * lex.c (note_got_semicolon, note_list_got_semicolon, ++ is_global): Likewise. ++ * method.c (build_overload_nested_name, build_overload_value, ++ build_qualified_name, build_qualified_name, hack_identifier): Likewise. ++ * parse.y (typename_sub, typename_sub1): Likewise. ++ * pt.c (push_inline_template_parms_recursive, check_template_shadow, ++ process_partial_specialization, convert_template_argument, ++ template_args_equal, add_pending_template, lookup_template_class, ++ for_each_template_parm_r, maybe_fold_nontype_arg, ++ tsubst, instantiate_template, type_unification_real, unify, ++ instantiate_pending_templates, set_mangled_name_for_template_decl): ++ Likewise. ++ * repo.c (repo_get_id, repo_template_used): Likewise. ++ * search.c (lookup_field_1): Likewise. ++ * tree.c (walk_tree, get_type_decl, cp_tree_equal, member_p): Likewise. ++ * xref.c (classname): Likewise. ++ ++2000-03-22 Mark Mitchell ++ ++ * cp-tree.h (BINFO_FOR_VBASE): Adjust documentation. ++ (CANONICAL_BINFO): New macro. ++ (BINFO_NEW_VTABLE_MARKED): Use it. ++ (SET_BINFO_NEW_VTABLE_MARKED): Likewise. ++ (CLEAR_BINFO_NEW_VTABLE_MARKED): Likewise. ++ * class.c (dfs_build_vbase_offset_vtbl_entries): Use BINFO_TYPE, ++ not TREE_TYPE. ++ (build_primary_vtable): Adjust usage of BINFO_NEW_VTABLE_MARKED. ++ (build_secondary_vtable): Likewise. ++ (dfs_finish_vtbls): Likewise. ++ (dfs_accumulate_vtbl_inits): Likewise. ++ (accumulate_vtbl_inits): New function. ++ (finish_vtbls): Make sure that virtual bases come after ++ non-virtual bases in the vtable group. ++ (record_base_offsets): Don't save and restore TREE_VIA_VIRTUAL. ++ (finish_struct_1): Adjust usage of BINFO_NEW_VTABLE_MARKED. ++ * search.c (struct vbase_info): Move definition. ++ (marked_new_vtable_p): Adjust usage of BINFO_NEW_VTABLE_MARKED. ++ (unmarked_new_vtable_p): Likewise. ++ (dfs_mark_vtable_path): Remove. ++ (dfs_mark_new_vtable): Remove. ++ (dfs_unmark_new_vtable): Likewise. ++ (dfs_clear_search_slot): Likewise. ++ (dfs_find_vbases): Adjust usage of BINFO_NEW_VTABLE_MARKED. ++ (dfs_clear_vbase_slots): Likewise. ++ (init_vbase_pointers): LIkewise. ++ ++2000-03-22 Jason Merrill ++ ++ * typeck.c (type_after_usual_arithmetic_conversions): Prefer a ++ SIZETYPE to a non-SIZETYPE. ++ ++2000-03-21 Mark Mitchell ++ ++ * class.c (layout_virtual_bases): Adjust names in conditionally ++ compiled code. ++ ++ * class.c (record_base_offsets): New function. ++ (layout_conflict_p): Likewise. ++ (layout_nonempty_base_or_field): Use it. ++ (layout_empty_base): New function. ++ (build_base_field): Use it. ++ (build_base_fields): Update comment. ++ (layout_virtual_bases): Fold in a little code form ++ layout_basetypes. Use layout_empty_base. ++ (layout_basetypes): Remove. ++ (end_of_class): New function. ++ (layout_class_type): Use it. Adjust. ++ ++ * cp-tree.h (CLASSTYPE_VBASECLASSES): Fix typo in comment. ++ (fntype_p): Remove. ++ * search.c (dfs_skip_nonprimary_vbases_unmarkedp): Fix typo in ++ comment. ++ (dfs_skip_nonprimary_vbases_markedp): Likewise. ++ * typeck.c (fntype_p): Remove. ++ ++ * cp-tree.h (TI_SPEC_INFO): Remove. ++ (CLASSTYPE_TI_SPEC_INFO): Likewise. ++ * pt.c (process_partial_specialization): Likewise. ++ ++ * class.c (build_base_field): Fix thinko in computation of binfo ++ offsets. ++ ++ * tree.c (mark_local_for_remap_p): Mark variables declared in ++ TARGET_EXPRs as well. ++ ++2000-03-21 Nathan Sidwell ++ ++ * typeck.c (require_complete_type, complete_type, ++ complete_type_or_else, c_sizeof, c_sizeof_nowarn, ++ build_array_ref, convert_arguments, pointer_diff, ++ build_x_unary_op, build_unary_op, build_c_cast, ++ build_modify_expr): Use COMPLETE_TYPE_P etc. ++ * call.c (is_complete, convert_like_real, ++ build_new_method_call): Likewise. ++ * class.c (build_vbase_pointer_fields, check_bases, ++ build_base_field, finish_struct_1, pushclass): Likewise. ++ * cvt.c (cp_convert_to_pointer, convert_to_void): Likewise. ++ * decl.c (maybe_process_template_type_declaration, pushtag, ++ pushdecl, redeclaration_error_message, start_decl, start_decl_1, ++ layout_var_decl, check_initializer, cp_finish_decl, ++ grokdeclarator, require_complete_types_for_parms, ++ grok_op_properties, xref_tag, xref_basetypes, ++ check_function_type): Likewise. ++ * decl2.c (check_classfn, reparse_absdcl_as_casts): Likewise. ++ * friend.c (do_friend): Likewise. ++ * init.c (build_offset_ref): Likewise. ++ * parse.y (structsp): Likewise. ++ * pt.c (maybe_process_partial_specialization, ++ tsubst_friend_function, instantiate_class_template, tsubst, ++ do_type_instantiation, instantiate_pending_templates): Likewise. ++ * repo.c (repo_get_id): Likewise. ++ * rtti.c (build_typeid, get_typeid, build_dynamic_cast_1, ++ synthesize_tinfo_var, emit_support_tinfos): Likewise. ++ * search.c (lookup_fnfields_1, lookup_conversions): Likewise. ++ * semantics.c (begin_class_definition): Likewise. ++ * tree.c (build_cplus_method_type): Likewise. ++ * typeck2.c (digest_init, build_functional_cast, ++ add_exception_specifier): Likewise. ++ * parse.h, parse.c: Regenerated. ++ ++2000-03-21 Nathan Sidwell ++ ++ * inc/cxxabi.h: New header file. Define new-abi entry points. ++ (__pointer_type_info::target): Rename member to ... ++ (__pointer_type_info::type): ... here. ++ (__base_class_info::type): Rename member to ... ++ (__base_class_info::base): ... here. ++ * Make-lang.in (CXX_EXTRA_HEADERS): Add cxxabi.h ++ * cp-tree.h (CPTI_ABI): New global tree enumeration. ++ (abi_node): New global tree node. ++ * decl.c (abi_node): Document. ++ (init_decl_processing): Initialize abi_node. ++ * rtti.c (build_dynamic_cast_1): Use abi_node for new-abi. ++ (get_vmi_pseudo_type_info): Likewise. ++ (create_tinfo_types): Likewise. ++ (emit_support_tinfos): Likewise. ++ * tinfo.h (cxxabi.h): Include for new-abi. ++ Move rtti class definitions to new header file. ++ * tinfo.cc (abi): Use the namespace. ++ (std): Move new abi rtti classes from here ... ++ (__cxxabiv1): ... to here. ++ * tinfo2.cc (cxxabi.h): Include for new-abi. ++ Move rtti class definitions to new header file. ++ (std): Move new abi rtti classes from here ... ++ (__cxxabiv1): ... to here. ++ * inc/typeinfo (__class_type_info): Move into __cxxabiv1 ++ namespace. ++ ++2000-03-20 Jed Wing ++ Jason Merrill ++ ++ * method.c (build_overload_int): Use host_integerp. ++ ++2000-03-20 Theodore Papadopoulo ++ ++ * init.c (build_offset_ref): Handle the case of a templated member ++ function. ++ ++2000-03-19 Martin v. Löwis ++ ++ * except.c (expand_exception_blocks): Clear catch_clauses_last. ++ ++2000-03-18 Mark Mitchell ++ ++ * cp-tree.h (CLEAR_DECL_C_BIT_FIELD): New macro. ++ * class.c (check_bitfield_decl): Turn illegal bitfields into ++ non-bitfields. ++ (dfs_propagate_binfo_offsets): Adjust for new size_binop ++ semantics. ++ (dfs_offset_for_unshared_vbases): Likewise. ++ * cvt.c (cp_convert_to_pointer): Convert NULL to a ++ pointer-to-member correctly under the new ABI. ++ * expr.c (cplus_expand_constant): Don't use cp_convert when ++ turning an offset into a pointer-to-member. ++ * init.c (resolve_offset_ref): Don't adjust pointers-to-members ++ when dereferencing them under the new ABI. ++ * typeck.c (get_member_function_from_ptrfunc): Tweak calculation ++ of pointers-to-members under the new ABI. ++ ++ * class.c (check_bitfield_decl): Remove restriction on really long ++ bitfields. ++ (layout_class_type): Implement new ABI handling of bitfields ++ longer than their types. ++ ++2000-03-18 Martin v. Löwis ++ ++ * parse.y (extdefs): Call ggc_collect. ++ * parse.c: Regenerated. ++ ++2000-03-18 Nathan Sidwell ++ ++ * class.c (build_base_field): Use TYPE_ALIGN to examine a type. ++ (note_name_declared_in_class): Use OVL_CURRENT to get at a ++ potential overload. ++ ++2000-03-17 Richard Kenner ++ ++ * class.c (build_vbase_path): Use integer_zerop. ++ (build_vtable_entry): Use tree_low_cst. ++ (get_vfield_offset): Use bit_position. ++ (dfs_modify_vtables): New variable vindex_val; `i' is HOST_WIDE_INT. ++ Use tree_low_cst. ++ (check_bitfield_decl): Set DECL_SIZE using convert. ++ (build_base_field): Set DECL_SIZE and DECL_SIZE_UNIT using size_binop. ++ (layout_virtual_bases): DSIZE is unsigned HOST_WIDE_INT. ++ Use tree_low_cst. ++ (finish_struct_1): Use bit_position. ++ (dump_class_hierarchy): Use tree_low_cst. ++ * cp-tree.h (min_precision): Add declaration. ++ * decl.c (xref_tag, xref_basetypes): Use tree_low_cst. ++ * error.c (dump_type_suffix): Use host_integerp and tree_low_cst. ++ (dump_expr): Use integer_zerop, host_integerp, and tree_low_cst. ++ * expr.c (cplus_expand_constant): Use bit_position. ++ * init.c (build_vec_init): Use host_integerp and tree_low_cst. ++ * rtti.c (get_base_offset): Use bit_position. ++ * typeck.c (build_binary_op): Use integer_zerop, compare_tree_int, ++ host_integerp, and tree_low_cst. ++ (pointer_int_sum): Use integer_zerop. ++ (build_component_addr): Use bit_position. ++ ++2000-03-17 Nathan Sidwell ++ ++ * typeck.c (require_complete_type): Don't assume size_zero_node. ++ (complete_type_or_else): Likewise. ++ ++2000-03-16 Steven Grady ++ Jason Merrill ++ ++ * rtti.c (build_dynamic_cast_1): Improve diagnostics. ++ ++2000-03-16 Nathan Sidwell ++ ++ * decl2.c (grokfield): Bail out if type is error_mark_node. ++ ++2000-03-15 Nathan Sidwell ++ ++ * tinfo2.cc (__ptr_to_member_data): Rename to ... ++ (__pointer_to_member_data): ... here. Adjust. ++ * rtti.c (create_tinfo_types): Adjust. ++ ++2000-03-15 Nathan Sidwell ++ ++ * cp-tree.h (CPTI_REF_DESC_TYPE, ref_desc_type_node): Remove. ++ * decl.c (ref_desc_type_node): Undocument. ++ * rtti.c (ptr_ref_initializer): Rename to ... ++ (ptr_initializer): ... here. Adjust comments. ++ (ptmd_initializer): Fix comment thinko. ++ (synthesize_tinfo_var): Remove REFERENCE_TYPE case. ++ (create_tinfo_types): Remove ref_desc_type_node init. ++ * tinfo2.cc (__reference_type_info): Remove. ++ ++2000-03-15 Nathan Sidwell ++ ++ * decl.c (cp_finish_decl): Remove obsolete comment. ++ ++ * typeck.c (build_ptrmemfunc1): Kill uninitialized warning. ++ ++2000-03-14 Mark Mitchell ++ ++ * cp-tree.h: Tweak documentation. ++ * class.c (build_vbase_pointer_fields): Layout the fields, too. ++ (avoid_overlap): Remove. ++ (get_binfo_offset_as_int): New function. ++ (dfs_serach_base_offsets): Likewise. ++ (layout_nonempty_base_or_field): Likewise. ++ (build_base_field): Layout fields here. Avoid placing two objects ++ of the same type at the same address, under the new ABI. ++ (build_base_fields): Adjust accordingly. ++ (create_vtable_ptr): Return the new field, but don't attach it to ++ TYPE_FIELDS. ++ (remove_base_field): Remove. ++ (remove_base_fields): Remove. ++ (layout_basetypes): Adjust accordingly. ++ (layout_class_type): Call layout_field for each field, rather than ++ just making a wholesale call to layout_type. ++ ++2000-03-14 Jeff Sturm ++ ++ * except.c (expand_throw): Fix typo in _Jv_Sjlj_Throw. ++ ++2000-03-13 Jason Merrill ++ ++ * decl.c (grokfndecl): Set TREE_NOTHROW if TYPE_NOTHROW_P. ++ ++ * except.c (dtor_nothrow): New fn. ++ (do_pop_exception): Use it. Take type parm. ++ (push_eh_cleanup): Take type parm. ++ (expand_start_catch_block): Pass it. ++ (build_eh_type_type_ref): Accept null type. ++ ++2000-03-12 Mark Mitchell ++ ++ * cp-tree.h (revert_static_member_fn): Change prototype. ++ * decl.c (grokfndecl): Adjust call to revert_static_member_fn. ++ (grok_op_properties): Likewise. ++ (start_function): Likewise. ++ (revert_static_member_fn): Simplify. ++ * pt.c (check_explicit_specialization): Adjust call to ++ revert_static_member_fn. ++ ++2000-03-11 Mark Mitchell ++ ++ * cp-tree.h (scope_kind): New type. ++ (tmpl_spec_kind): Likewise. ++ (declare_pseudo_global_level): Remove. ++ (pseudo_global_level_p): Rename to template_parm_scope_p. ++ (pushlevel): Remove declaration. ++ (begin_scope): New function. ++ (finish_scope): Likewise. ++ (current_tmpl_spec_kind): Likewise. ++ * decl.c (struct binding_level): Shorten parm_flag to 2 bits. ++ Shorten keep to 2 bits. Rename pseudo_global to template_parms_p. ++ Add template_spec_p. ++ (toplevel_bindings_p): Adjust. ++ (declare_pseudo_global_level): Remove. ++ (pseudo_global_level_p): Rename to template_parm_scope_p. ++ (current_tmpl_spec_kind): New function. ++ (begin_scope): Likewise. ++ (finish_scope): Likewise. ++ (maybe_push_to_top_level): Adjust. ++ (maybe_process_template_type_declaration): Likewise. ++ (pushtag): Likewise. ++ (pushdecl_nonclass_level): Likewise. ++ (lookup_tag): Likewise. ++ (grokfndecl): Handle member template specializations. Share ++ constructor and non-constructor code. ++ * decl2.c (check_classfn): Handle member template specializations. ++ * pt.c (begin_template_parm_list): Use begin_scope. ++ (begin_specialization): Likewise. ++ (end_specialization): Likewise. ++ (check_explicit_specialization): Use current_tmpl_spec_kind. ++ Handle member template specializations. ++ (end_template_decl): Use finish_scope. Remove call to ++ get_pending_sizes. ++ (push_template_decl_real): Remove bogus error message. ++ (tsubst_decl): Fix typo in code contained in comment. ++ (instantiate_template): Handle member template specializations. ++ (most_general_template): Likewise. ++ ++2000-03-11 Gabriel Dos Reis ++ ++ * lex.c (whitespace_cr): Compress consecutive calls to warning(). ++ (do_identifier): Ditto for error(). ++ ++ * pt.c (convert_nontype_argument): Ditto for cp_error(). ++ (convert_template_argument): Ditto for cp_pedwarn(). ++ ++2000-03-11 Jason Merrill ++ ++ * exception.cc (__check_null_eh_spec): New fn. ++ * except.c (expand_end_eh_spec): Call it if the spec is throw(). ++ ++2000-03-10 Jason Merrill ++ ++ * decl.c (push_throw_library_fn): Take the FUNCTION_TYPE. ++ * except.c (expand_end_eh_spec): Add the return type. ++ * rtti.c (throw_bad_cast): Add the parmtypes. ++ (throw_bad_typeid): Likewise. ++ ++ * semantics.c (expand_stmt): Only leave out rtl for unused ++ artificials, and set DECL_IGNORED_P on them as well. ++ * decl.c (wrapup_globals_for_namespace): Likewise. ++ ++2000-03-09 Nathan Sidwell ++ ++ * decl.c (maybe_commonize_var): Skip all artificial decls. ++ * pt.c (tsubst_decl): Don't copy TREE_ASM_WRITTEN. ++ ++2000-03-10 Jason Merrill ++ ++ * lang-options.h, decl2.c: Add -fno-enforce-eh-specs. ++ * cp-tree.h: Declare flag_enforce_eh_specs. ++ * decl.c (store_parm_decls, finish_function): Check it. ++ ++ C library functions don't throw. ++ * Makefile.in (cfns.h): New target. ++ (except.o): Depend on it. ++ * Make-lang.in (cc1plus): Depend on cfns.gperf. ++ * cfns.gperf: New file. ++ * cfns.h: Generated. ++ * except.c: Include it. ++ (nothrow_libfn_p): New fn. ++ * decl.c (grokfndecl): Use it. ++ * cp-tree.h: Declare it. ++ ++ * decl.c (push_overloaded_decl_1, auto_function, ++ define_function): Lose. ++ (build_library_fn_1): New static fn. ++ (builtin_function): Use it. ++ (get_atexit_node): Use build_library_fn_ptr. ++ (build_library_fn, build_cp_library_fn, build_library_fn_ptr, ++ build_cp_library_fn_ptr, push_library_fn, push_cp_library_fn, ++ push_void_library_fn, push_throw_library_fn): New fns. ++ * cp-tree.h: Declare them. ++ (cp_tree_index): Remove CPTI_BAD_CAST, CPTI_BAD_TYPEID. ++ (throw_bad_cast_node, throw_bad_typeid_node): Lose. ++ * except.c (init_exception_processing, call_eh_info, do_pop_exception, ++ (expand_end_eh_spec, alloc_eh_object, expand_throw): Use above fns. ++ * rtti.c (build_runtime_decl): Lose. ++ (throw_bad_cast, throw_bad_typeid, get_tinfo_decl, ++ build_dynamic_cast_1, expand_si_desc, expand_class_desc, ++ expand_ptr_desc, expand_attr_desc, expand_generic_desc): Use above fns. ++ ++ * call.c (build_call): Remove result_type parm. ++ Call mark_used on unused artificial fns. ++ * init.c, method.c, typeck.c, except.c, rtti.c: Adjust. ++ ++2000-03-09 Jason Merrill ++ ++ * call.c (build_call): Set TREE_NOTHROW on the CALL_EXPR as ++ appropriate. ++ * decl.c (define_function): Set TREE_NOTHROW on the FUNCTION_DECL. ++ * except.c (call_eh_info, alloc_eh_object, expand_throw): Set ++ TREE_NOTHROW or TREE_THIS_VOLATILE on the function as appropriate. ++ * rtti.c (build_runtime_decl, get_tinfo_decl, build_dynamic_cast_1, ++ expand_si_desc, expand_class_desc, expand_ptr_desc, expand_attr_desc, ++ expand_generic_desc): Likewise. ++ ++2000-03-08 Nathan Sidwell ++ ++ * exception.cc (__cp_pop_exception): Cleanup the original object. ++ ++2000-03-08 Nathan Sidwell ++ ++ * decl.c (grok_op_properties): Merge conversion to void warning ++ with other silly op warnings. ++ ++2000-03-08 Jason Merrill ++ ++ * typeck2.c (process_init_constructor): Set TREE_PURPOSE of ++ array CONSTRUCTOR elements. Don't use expr_tree_cons. ++ ++2000-03-08 Nathan Sidwell ++ ++ * decl.c (cp_make_fname_decl): New function. ++ (wrapup_globals_for_namespace): Don't emit unused static vars. ++ (init_decl_processing): Remove comment about use of ++ array_domain_type. Set make_fname_decl. ++ (cp_finish_decl): Remove __FUNCTION__ nadgering. ++ * semantics.c (begin_compound_stmt): Remove ++ current_function_name_declared flagging. ++ (expand_stmt): Don't emit unused local statics. ++ * typeck.c (decay_conversion): Don't treat __FUNCTION__ decls ++ specially. ++ ++2000-03-08 Nathan Sidwell ++ ++ * typeck.c (convert_for_assignment): Don't look at array ++ initializer. ++ * call.c (convert_like_real): Likewise. ++ ++2000-03-07 Jason Merrill ++ ++ Add initial support for '\uNNNN' specifier. ++ * lex.c (read_ucs): New fn. ++ (readescape, skip_white_space): Call it. ++ (is_extended_char, is_extended_char_1): New fns. ++ (utf8_extend_token): New fn, #if 0'd out. ++ (real_yylex): Treat extended chars like letters. ++ ++ * search.c (note_debug_info_needed): Walk the bases even if we ++ weren't deferring the type itself. ++ ++2000-03-07 Kaveh R. Ghazi ++ ++ * decl2.c (finish_objects): Constify a char*. ++ ++ * method.c (emit_thunk): Likewise. ++ ++2000-03-06 Nathan Sidwell ++ ++ * typeck.c (dubious_conversion_warnings): Look through ++ REFERENCE_TYPE. ++ ++2000-03-06 Richard Kenner ++ ++ * class.c (dfs_modify_vtables): I is now unsigned. ++ (check_bitfield_decl): Use tree_int_cst_sgn and compare_tree_int. ++ (build_base_field): Add casts of TREE_INT_CST_LOW to HOST_WIDE_INT. ++ * error.c (dump_expr): Cast TREE_INT_CST_HIGH to unsigned. ++ * init.c (build_vec_init): Cast TREE_INT_CST_LOW to HOST_WIDE_INT. ++ * method.c (build_overload_int): Cast TREE_INT_CST_HIGH to unsigned. ++ * typeck.c (build_binary_op, case TRUNC_DIV_EXPR): ++ Call integer_all_onesp. ++ * typeck2.c (process_init_constructor): Use compare_tree_int. ++ ++ * lang-specs.h (as): Don't call if -syntax-only. ++ ++2000-03-06 Mark Mitchell ++ ++ * expr.c (cplus_expand_expr, case STMT_EXPR): Don't set ++ RTL_EXPR_HAS_NO_SCOPE after all. ++ ++2000-03-05 Mark Mitchell ++ ++ * expr.c (cplus_expand_expr, case STMT_EXPR): Use ++ expand_start_stmt_expr and expand_end_stmt_expr directly. Set ++ RTL_EXPR_HAS_NO_SCOPE. ++ ++ * pt.c (instantiate_decl): Clear TI_PENDING_TEMPLATE_FLAG a little ++ later. ++ ++ * dump.c (dequeue_and_dump): Dump SCOPE_NO_CLEANUPS_P. ++ ++2000-03-05 Nathan Sidwell ++ ++ * call.c (convert_like): Macrofy. ++ (convert_like_with_context): New macro. ++ (convert_like_real): Renamed from convert_like. Add calling ++ context parameters, for diagnostics. Add recursive flag. Call ++ dubious_conversion_warnings for outer conversion. ++ (build_user_type_conversion): Use convert_like_with_context. ++ (build_over_call): Likewise. Don't warn about dubious ++ conversions here. Adjust convert_default_arg calls. ++ (convert_default_arg): Add context parameters for diagnostics. ++ Pass through to convert_like_with_context. ++ * cp-tree.h (convert_default_arg): Add context parameters. ++ (dubious_conversion_warnings): Prototype new function. ++ * typeck.c (convert_arguments): Adjust convert_default_arg call. ++ (dubious_conversion_warnings): New function, broken ++ out of convert_for_assignment. ++ (convert_for_assignment): Adjust. ++ ++2000-03-03 Jason Merrill ++ ++ * decl2.c (key_method): Break out from... ++ (import_export_vtable, import_export_class): ...here. ++ ++ * decl.c (finish_function): Don't mess with flag_keep_inline_functions. ++ * decl2.c (finish_vtable_vardecl): Don't check decl_function_context. ++ ++ * search.c (note_debug_info_needed, dfs_debug_mark, ++ dfs_debug_unmarkedp): Uncomment. Adjust for new scheme. ++ * decl2.c (finish_vtable_vardecl): Call note_debug_info_needed. ++ ++2000-03-03 Nathan Sidwell ++ ++ * decl.c (cp_finish_decl): Remove obsolete obstack comments, fix ++ typos. ++ ++2000-03-02 Mark Mitchell ++ ++ * cp-tree.h (TYPE_NEEDS_DESTRUCTOR): Rename to ... ++ (TYPE_HAS_NONTRIVIAL_DESTRUCTOR): ... this. ++ (TYPE_HAS_TRIVIAL_DESTRUCTOR): New macro. ++ (lang_type): Split gets_new into has_new and has_array_new. ++ (TYPE_VEC_NEW_USES_COOKIE): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR. ++ (TYPE_GETS_NEW): Split into ... ++ (TYPE_HAS_NEW_OPERATOR): ... this, and ... ++ (TYPE_HAS_ARRAY_NEW_OPERATOR): ... this. ++ (DECL_ARRAY_DELETE_OPERATOR_P): New macro ++ (build_op_new_call): Don't declare. ++ (build_new_1): Likewise. ++ * call.c (build_op_new_call): Remove. ++ * class.c (check_bases): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR ++ instead of TYPE_NEEDS_DESTRUCTOR. ++ (finish_struct_bits): Likewise. ++ (add_implicitly_declared_members): Likewise. ++ (check_field_decl): Likewise. ++ (check_methods): Set TYPE_VEC_DELETE_TAKES_SIZE here, and set it ++ correctly under the new ABI. ++ * decl.c (start_decl_1): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR ++ instead of TYPE_NEEDS_DESTRUCTOR. ++ (initialize_local_var): Likewise. ++ (destroy_local_var): Likewise. ++ (cp_finish_decl): Likewise. ++ (register_dtor_fn): Likewise. ++ (grok_op_properties): Set TYPE_HAS_NEW_OPERATOR and ++ TYPE_HAS_ARRAY_NEW_OPERATOR, not TYPE_HAS_NEW. Don't set ++ TYPE_VEC_DELETE_TAKES_SIZE here. ++ (xref_basetypes): Set TYPE_HAS_NEW_OPERATOR and ++ TYPE_HAS_ARRAY_NEW_OPERATOR, not TYPE_HAS_NEW. ++ (store_parm_decls): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR. ++ (finish_destructor_body): Likewise. ++ (maybe_build_cleanup_1): Likewise. ++ * decl2.c (do_static_destruction): Likewise. ++ * init.c (build_new_1): Make it static. ++ (perform_member_init): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR. ++ (expand_cleanup_for_base): Likewise. ++ (get_cookie_size): New function. ++ (build_new_1): Handle array-new cookies correctly under the new ++ ABI. ++ (build_vec_delete_1): Likewise. ++ (build_vec_init): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR. ++ (build_delete): Likewise. ++ (build_vec_delete): Handle array-new cookies correctly under the new ++ ABI. ++ * lex.c (do_identifier): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR. ++ * pt.c (instantiate_class_template): Set TYPE_HAS_NEW_OPERATOR and ++ TYPE_HAS_ARRAY_NEW_OPERATOR. ++ * ptree.c (print_lang_type): Check them. ++ * search.c (context_for_name_lookup): Fix typo in comment. ++ (tree_has_any_destructor_p): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR. ++ * tree.c (break_out_cleanups): Likewise. ++ (build_cplus_array_test_1): Likewise. ++ (cp_build_qualified_type_real): Likewise. ++ * typeck.c (complete_type): Likewise. ++ ++ * g++spec.c (lang_specific_driver): Add -fnew-abi at the start of ++ the command-line, not the end. ++ ++2000-03-01 Jason Merrill ++ ++ * pt.c (instantiate_decl): Clear TI_PENDING_TEMPLATE_FLAG. ++ ++2000-03-02 Tom Tromey ++ ++ * cp-tree.h (build_java_class_ref): Declare. ++ * init.c (build_java_class_ref): No longer static. ++ * except.c (expand_throw): Generate a Java-style `throw' if the ++ thrown object is a "Java" object. ++ (initialize_handler_parm): Generate a Java-style lookup of ++ exception info if the caught object is a "Java" object. ++ (catch_language, catch_language_init): New globals. ++ (decl_is_java_type): New function. ++ (expand_start_catch_block): Don't call push_eh_info() or ++ push_eh_cleanup() when handling a Java-style "catch". Pass Java ++ class reference to build_catch_block. ++ ++2000-03-02 Richard Kenner ++ ++ * typeck.c (comptypes): Treat sizetype like its language equivalent. ++ ++2000-03-01 Bernd Schmidt ++ ++ * typeck.c (maybe_warn_about_returning_address_of_local): Reorganize ++ to merge reference/pointer code and fix incorrect warnings. ++ ++2000-02-29 Jason Merrill ++ ++ * search.c (protected_accessible_p): Use context_for_name_lookup. ++ ++ * init.c (construct_virtual_bases): Fix thinko. ++ * typeck.c (expand_ptrmemfunc_cst): Fix thinko. ++ ++2000-03-01 Martin von Loewis ++ ++ * decl.c (current_function_decl): Move to toplev.c. ++ ++2000-02-29 Nathan Sidwell ++ ++ * pt.c (fn_type_unification): Unify return type, whenever ++ provided. ++ (get_bindings_real): Only pass return type when necessary. ++ Remove explicit return type check. ++ * class.c (resolve_address_of_overloaded_function): Pass desired ++ return type to fn_type_unification. ++ ++2000-02-28 Richard Kenner ++ ++ * class.c (build_vtbl_or_vbase_field, check_methods): Don't clear ++ DECL_FIELD_SIZE. ++ (check_bitfield_decl, check_field_decls): Set DECL_SIZE, not ++ DECL_FIELD_SIZE. ++ * rtti.c (expand_class_desc): Likewise. ++ * cp-tree.h (DECL_INIT_PRIORITY): Use underlying union name. ++ (THUNK_VCALL_OFFSET): Likewise. ++ (THUNK_DELTA): Reflect changes in ../tree.h. ++ ++2000-02-28 Jason Merrill ++ ++ * search.c (protected_accessible_p): Also allow the access if ++ the member is public in DERIVED. Lose TYPE parm. ++ (friend_accessible_p): Lose TYPE parm. ++ (accessible_p): Adjust. ++ ++2000-02-27 Richard Kenner ++ ++ * class.c (dfs_build_vtable_offset_vtbl_entries): Don't use size_binop ++ on things that are not sizes; ssize_binop deleted. ++ Call size_diffop when appropriate. ++ (dfs_build_vcall_offset_vtbl_entries): Likewise. ++ (build_primary_vtable, build_secondary_vtable): Likewise. ++ (dfs_set_offset_for_unshared_vbases, dfs_modify_vtables): Likewise. ++ Variable I is HOST_WIDE_INT. ++ (get_vfield_offset): Pass proper types to size_binop. ++ (size_extra_vtbl_entries, layout_virtual_bases): Likewise. ++ (finish_struct_1): Likewise. ++ (skip_rtti_stuff): Arg N is now pointer to signed. ++ (layout_class_type): Use size_zero_node. ++ * cp-tree.h (skip_rtti_stuff): Arg N is pointer to signed. ++ * cvt.c (cp_convert_to_pointer): Pass proper types to size_binop. ++ * decl.c (complete_arry_type): Pass proper types to size_binop. ++ (xref_basetypes): BINFO_OFFSET is sizetype. ++ * error.c (dump_expr): Don't use size_binop non-sizes. ++ * expr.c (cplus_expand_constant): Pass proper types to size_binop. ++ * init.c (construct_virtual_bases): Fix type error. ++ (build_vec_delete_1): Pass proper type to size_binop and don't ++ fold result. ++ * lex.c (cp_make_lang_type): BINFO_OFFSET is sizetype. ++ * rtti.c (get_base_offset): Pass proper type to size_binop. ++ * search.c (dfs_find_vbases): Fix type error. ++ (expand_upcast_fixups): Arg to skip_rtti_stuff is pointer to signed. ++ (dfs_get_vbase_types): BINFO_OFFSET is sizetype. ++ * tree.c (debug_binfo): Variable N is signed. ++ Use HOST_WIDE_INT_PRINT_DEC. ++ * typeck.c (comptypes): sizetype is same as equivalent integer type. ++ (c_sizeof, c_sizeof_nowarn, expr_sizeof): Use TYPE_SIZE_UNIT, ++ size_one_node and size_zero_node. ++ (c_alignof): Use size_one_node. ++ (build_component_addr): Pass proper types to size_binop. ++ (expand_ptrmemfunc_cst): Don't use size_binop on non-sizes. ++ ++2000-02-26 Jason Merrill ++ ++ Implement class scope using-declarations for functions. ++ * class.c (handle_using_decl): Call add_method for used functions. ++ Use IDENTIFIER_CLASS_VALUE to check for conflicts. ++ (add_method): Used functions are hidden by local functions. ++ (check_bases_and_members): Handle using-decls before finalizing ++ CLASSTYPE_METHOD_VEC. ++ * call.c (add_function_candidate): Add ctype parm; if nonzero, ++ override the type of 'this' accordingly. ++ (add_template_candidate, add_template_candidate_real): Add ctype parm. ++ (convert_class_to_reference, build_user_type_conversion_1, ++ build_new_function_call, build_object_call, build_new_op, ++ build_new_method_call): Pass ctype parm. ++ ++ * search.c (lookup_member): Put rval_binfo, not basetype_path, in ++ the baselink. ++ * call.c (convert_class_to_reference, build_user_type_conversion_1, ++ build_new_function_call, build_object_call, build_new_op, ++ build_new_method_call, build_op_delete_call): Don't get basetype_path ++ from a baselink. ++ * typeck.c (build_component_ref): Likewise. ++ * init.c (build_offset_ref): Likewise. ++ (resolve_offset_ref): Don't call enforce_access. ++ Call build_scoped_ref. ++ * typeck2.c (build_scoped_ref): Simplify. Do nothing if it ++ would cause an error or if -pedantic. ++ * class.c (alter_access): Lose binfo parm. ++ ++2000-02-26 Mark Mitchell ++ ++ * semantics.c (simplify_aggr_init_exprs_p): Don't walk into ++ types. ++ ++2000-02-25 Alfred Minarik ++ ++ * rtti.c (get_vmi_pseudo_type_info): Move __vmi_class_type_info ++ pseudo_type_info creation into the std namespace ++ ++2000-02-26 Mark Mitchell ++ ++ * cp-tree.h (DECL_NEEDED_P): Tweak to correct usage before EOF. ++ (import_export_class): Remove declaration. ++ * decl2.c (import_export_class): Make it static. ++ * dump.c (dequeue_and_dump): Handle PREDECREMENT_EXPR, ++ PREINCREMENT_EXPR, POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, ++ EXPR_WITH_FILE_LOCATION. ++ * lex.c (check_newline): Tweak filename/lineno setting. ++ * semantics.c (begin_while_stmt): Fix typo in comment. ++ ++2000-02-26 Richard Kenner ++ ++ * lang-options.h (-fmessage-length=): Add missing option. ++ ++ * Make-lang.in (CXX_SRCS): Add .h files and sort list. ++ ++2000-02-26 Zack Weinberg ++ ++ * Make-lang.in: Delete refs to LIBGCC2_DEPS. ++ ++2000-02-25 Jim Wilson ++ ++ * optimize.c (expand_call_inline): Emit the return label before ++ evaluating the return value. ++ ++2000-02-24 Mark Mitchell ++ ++ * lex.c (check_newline): Use push_srcloc and pop_srcloc, rather ++ than duplicating functionality here. ++ * optimize.c: Include input.h. ++ (expand_call_inline): Use push_srcloc and pop_srcloc. ++ * parse.y (maybe_cv_qualifier): Remove calls to emit_line_note. ++ * parse.c: Regenerated. ++ * Makefile.in (lex.o): Depend on input.h. ++ (optimize.o): Likewise. ++ ++2000-02-24 Nathan Sidwell ++ ++ * decl.c (grokdeclarator): Diagnose qualifiers on non-member ++ function type, rather than ICE. ++ ++2000-02-23 Jason Merrill ++ ++ * decl.c (grokdeclarator): Call decl_type_access_control. ++ * parse.y (parse_end_decl): Don't call decl_type_access_control if ++ decl is null. ++ ++2000-02-23 Nathan Sidwell ++ ++ * decl.c (decls_match): Remove obsolete static member nadgering. ++ ++2000-02-21 Martin v. Löwis ++ ++ * decl.c (grokdeclarator): Change ANSI to ISO. ++ * lex.c (consume_string, readescape, do_identifier): Likewise. ++ (parse_float, real_yylex): Likewise. ++ * parse.y (paren_expr_or_null, paren_cond_or_null): Likewise. ++ (unary_expr, new_initializer, cast_expr, primary, primary_no_id, ++ new_type_id, maybe_label_decls, simple_stmt, ++ for.init.statement): Likewise. ++ * pt.c (do_decl_instantiation, do_type_instantiation): Likewise. ++ * semantics.c (finish_named_return_value): Likewise. ++ * parse.c: Regenerate. ++ ++2000-02-21 Mark Mitchell ++ ++ * cp-tree.h (CPTI_VTABLE_INDEX_TYPE): New macro. ++ (CPTI_CLASS_STAR_TYPE): Remove. ++ (vtable_index_type): Likewise. ++ (class_star_type_node): Remove. ++ (TYPE_PTRMEMFUNC_FN_TYPE): Adjust for the new ABI. ++ (build_binary_op_nodefault): Remove. ++ * call.c (build_new_op): Use build_binary_op instead of ++ build_binary_op_nodefault. ++ * decl.c (init_decl_processing): Remove class_star_type_node ++ initialization. Make delta_type_node ptrdiff_type_node under the ++ new ABI. Initialize vtable_index_type. ++ (build_ptrmemfunc_type): Build different structures for the new ++ ABI. ++ (build_enumerator): Use build_binary_op instead of ++ build_binary_op_nodefault. ++ * method.c (build_overload_value): Mangle pointers-to-members ++ appropriately under the new ABI. ++ * typeck.c (build_array_ref): Use build_binary_op instead of ++ build_binary_op_nodefault. ++ (get_member_function_from_ptrfunc): Adjust for the new ABI. ++ (build_binary_op_nodefault): Rename to ... ++ (build_binary_op): ... this. Remove old version. Adjust for ++ pointer-to-member comparisons under the new ABI. ++ (build_ptrmemfunc1): Remove dead code. Adjust for the new ABI. ++ (build_ptrmemfunc): Adjust for the new ABI. ++ (expand_ptrmemfunc_cst): Likewise. ++ (delta2_from_ptrmemfunc): Assert that we're not using the new ABI. ++ (pfn_from_ptrmemfunc): Adjust for the new ABI. ++ ++2000-02-21 Gabriel Dos Reis ++ ++ * call.c (build_object_call): Compress consecutive calls to ++ cp_error. ++ (build_conditional_expr): Say 'ISO C++' not 'ANSI C++'. ++ (build_op_delete_call): Adjust message formatting. ++ ++ * class.c (check_bases): Compress consecutive calls to ++ cp_pedwarn. ++ (finish_struct_anon): Say 'ISO C++'. ++ ++ * decl.c (start_decl): Same here. ++ (grok_reference_init): Likewise. ++ (grokfndecl): Correct message formatting. ++ (grokfndecl): Improve diagnostic. ++ (check_static_variable_definition): Likewise. Say 'ISO C++' ++ (compute_array_index_type): Say 'ISO C++' ++ (create_array_type_for_decl): Compress consecutive calls to ++ cp_error. ++ (grokdeclarator): Say 'ISO C++' ++ (grok_op_properties): Likewise. ++ ++ * decl2.c (delete_sanity): Clairify diagnostic. ++ (check_member_template): Same here. ++ (grok_function_init): Use consistent terminology. ++ ++ * expr.c (do_case): Say 'ISO C++' ++ ++ * friend.c (do_friend): Compress consecutive calls to warning. ++ ++2000-02-20 Mark Mitchell ++ ++ * cp-tree.h (merge_primary_and_secondary_vtables_p): New macro. ++ * class.c (build_secondary_vtable): Reorganize. Don't create a ++ new vtable under the new ABI. ++ (layout_vtable_decl): Don't add num_extra_vtbl_entries when ++ computing the size. ++ (build_vtbl_initializer): Don't return a CONSTRUCTOR; just return ++ the initializing elements. ++ (initialize_vtable): New function. ++ (dfs_finish_vtbls): Use it. ++ (dfs_accumulate_vtbl_inits): New function. ++ (finish_vtbls): Merge primary and secondary vtables under the new ++ ABI. ++ (finish_struct_1): Remove redundant call to layout_vtable_decl. ++ * init.c (expand_virtual_init): Deal with BINFO_VTABLEs that ++ aren't VAR_DECLs. ++ ++ * class.c (build_vtable): New function, split out from ... ++ (get_vtable_decl): ... here, and ... ++ (build_secondary_vtable): ... here. ++ ++ * pt.c (tsubst_decl): Fix formatting. ++ ++2000-02-19 Richard Kenner ++ ++ * class.c (build_primary_vtable, layout_vtable_decl): Likewise. ++ (avoid_overlap, build_base_field): Likewise. ++ (build_base_field, build_base_fields, is_empty_class): ++ Test DECL_SIZE with integer_zero. ++ (layout_class_type): Set CLASSTYPE_SIZE_UNIT. ++ * cp-tree.h (struct lang_type): New field size_unit. ++ (CLASSTYPE_SIZE_UNIT): New macro. ++ * decl.c (init_decl_processing): Set DECL_SIZE_UNIT. ++ (cp_finish_decl): Delete -Wlarger-than processing. ++ * optimize.c (remap_decl): Walk DECL_SIZE_UNIT. ++ * pt.c (tsubst_decl): Set DECL_SIZE_UNIT. ++ * tree.c (make_binfo): binfo vector is one entry longer. ++ (walk_tree): Walk DECL_SIZE_UNIT. ++ ++2000-02-19 Mark Mitchell ++ ++ * class.c (dfs_build_vcall_offset_vtbl_entries): Fix typo in ++ comment. ++ (build_vtable_entry): Don't assume all vtable entries are ++ functions. ++ (build_vtbl_initializer): Adjust accordingly. ++ (get_vtable_decl): Fix formatting. ++ ++2000-02-18 Jason Merrill ++ ++ * semantics.c (deferred_type_access_control): Walk the entire ++ type_lookups list. ++ (save_type_access_control): Rename from ++ initial_deferred_type_access_control. Just remember the value. ++ (decl_type_access_control): New fn. ++ (begin_function_definition): Use deferred_type_access_control, after ++ we've started the function. Set type_lookups to error_mark_node. ++ * parse.y (frob_specs, fn.def1): Adjust. ++ (parse_decl0, parse_field, parse_field0, parse_bitfield): New fns. ++ (parse_end_decl, parse_bitfield0, parse_method): New fns. ++ (fn.def2, initdcl, initdcl0_innards, nomods_initdcl0): Use them. ++ (after_type_component_declarator0): Likewise. ++ (after_type_component_declarator): Likewise. ++ (notype_component_declarator): Likewise. ++ * cp-tree.h: Adjust. ++ ++ * decl.c (redeclaration_error_message): Allow redeclaration of ++ namespace-scope decls. ++ ++2000-02-18 Martin von Loewis ++ ++ * typeck2.c (my_friendly_abort): Use GCCBUGURL. ++ ++2000-02-17 Mark Mitchell ++ ++ * class.c (add_method): Don't set DECL_VIRTUAL_CONTEXT. ++ * decl2.c (grokclassfn): Likewise. ++ ++ * ir.texi: Document DECL_TEMPLATE_INSTANTIATIONS. ++ ++ * decl2.c (lang_decode_option): Don't set default message length ++ here. ++ * lex.c (lang_init_options): Set it here. ++ ++2000-02-16 Mark Mitchell ++ ++ Make DECL_CONTEXT mean the class in which a member function was ++ declared, even for a virtual function. ++ * cp-tree.h (DECL_CLASS_CONTEXT): Adjust. ++ (DECL_FRIEND_CONTEXT): New macro. ++ (DECL_REAL_CONTEXT): Remove. ++ (SET_DECL_FRIEND_CONTEXT): Likewise. ++ (DECL_VIRTUAL_CONTEXT): Adjust. ++ (DECL_CLASS_SCOPE_P): Use TYPE_P. ++ (add_friends): Remove. ++ (hack_decl_function_context): Likewise. ++ * call.c (build_new_function_call): Replace DECL_REAL_CONTEXT with ++ CP_DECL_CONTEXT. ++ (build_over_call): Fix indentation. Use DECL_CONTEXT ++ instead of DECL_CLASS_CONTEXT. ++ * class.c (dfs_build_vcall_offset_vtbl_entries): Likewise. ++ (add_method): Set DECL_VIRTUAL_CONTEXT, not DECL_CLASS_CONTEXT. ++ (strictly_overrides): Use DECL_CONTEXT, not DECL_CLASS_CONTEXT. ++ (build_vtbl_or_vbase_field): Don't set DECL_CLASS_CONTEXT. ++ (build_base_field): Likewise. ++ (finish_struct_1): Likewise. ++ (build_self_reference): Likewise. ++ * decl.c (push_class_binding): Use CP_DECL_CONTEXT, not ++ DECL_REAL_CONTEXT. ++ (pushtag): Use decl_function_context, not ++ hack_decl_function_context. ++ (decls_match): Use CP_DECL_CONTEXT, not DECL_REAL_CONTEXT. ++ (duplicate_decls): Use DECL_VIRTUAL_CONTEXT. ++ (pushdecl): Remove bogus code. ++ (start_decl): Use DECL_CONTEXT rather than DECL_CLASS_CONTEXT. ++ (cp_finish_decl): Use CP_DECL_CONTEXT, not DECL_REAL_CONTEXT. ++ (grokfndecl): Use DECL_CONTEXT, not DECL_CLASS_CONTEXT. ++ Use decl_function_context, nothack_decl_function_context. ++ (grokvardecl): Don't set DECL_CLASS_CONTEXT. ++ (grokdeclarator): Likewise. Use decl_function_context, not ++ hack_decl_function_context. ++ (copy_args_p): Document. Don't use DECL_CLASS_CONTEXT. ++ (start_function): Use DECL_FRIEND_CONTEXT, not ++ DECL_CLASS_CONTEXT. Use decl_function_context, not ++ hack_decl_function_context. ++ (finish_function): Use decl_function_context, not ++ hack_decl_function_context. ++ (maybe_retrofit_in_chrg): Use DECL_CONTEXT, not ++ DECL_CLASS_CONTEXT. ++ (grokclassfn): Set DECL_VIRTUAL_CONTEXT, not DECL_CONTEXT. ++ (finish_static_data_member_decl): Don't set DECL_CLASS_CONTEXT. ++ (grokfield): Likewise. ++ (finish_builtin_type): Likewise. ++ (finish_vtable_vardec): Use decl_function_context, not ++ hack_decl_function_context. ++ (import_export_decl): Use DECL_CONTEXT, not DECL_CLASS_CONTEXT. ++ (start_static_initialization_or_destruction): Likewise. ++ (finish_static_initialization_or_destruction): Likewise. ++ (mark_used): Adjust logic for deciding when to synthesize methods. ++ * dump.c (dequeue_and_dump): Use CP_DECL_CONTEXT, not ++ DECL_REAL_CONTEXT. ++ * error.c (dump_function_decl): Use DECL_CONTEXT, not ++ DECL_CLASS_CONTEXT. ++ * friend.c (is_friend): Likewise. ++ (add_friends): Remove. ++ (do_friend): Use SET_DECL_FRIEND_CONTEXT. ++ * lex.c (begin_definition_of_inclass_inline): Use ++ decl_function_context, not hack_decl_function_context. ++ (process_next_inline): Likewise. ++ (do_identifier): Use CP_DECL_CONTEXT, not DECL_REAL_CONTEXT. ++ * method.c (set_mangled_name_for_decl): Use DECL_CONTEXT, not ++ DECL_CLASSS_CONTEXT. ++ (hack_identifier): Likewise. ++ (synthesize_method): Use decl_function_context, not ++ hack_decl_function_context. ++ * pt.c (template_class_depth_real): Use CP_DECL_CONTEXT, not ++ DECL_REAL_CONTEXT. ++ (is_member_template): Use decl_function_context, not ++ hack_decl_function_context. Use DECL_CONTEXT, not ++ DECL_CLASS_CONTEXT. ++ (build_template_decl): Set DECL_VIRTUAL_CONTEXT, not ++ DECL_CLASS_CONTEXT. ++ (check_default_tmpl_args): Use CP_DECL_CONTEXT, not ++ DECL_REAL_CONTEXT. ++ (push_template_decl_real): Likewise. ++ (instantiate_class_template): Don't call add_friends. ++ (tsubst_default_argument): Use DECL_CONTEXT, not ++ DECL_REAL_CONTEXT. ++ (tsubst_decl): Set DECL_VIRTUAL_CONTEXT, not DECL_CLASS_CONTEXT. ++ Use DECL_CONTEXT, not DECL_CLASS_CONTEXT. ++ (set_meangled_name_for_template_decl): Use DECL_CONTEXT, not ++ DECL_CLASS_CONTEXT. ++ * repo.c (repo_inline_used): Likewise. ++ * search.c (current_scope): Adjust for new _CONTEXT macros. ++ (context_for_name_lookup): Use CP_DECL_CONTEXT, not ++ DECL_REAL_CONTEXT. ++ (friend_accessible_p): Use DECL_CONTEXT, not DECL_CLASS_CONTEXT. ++ (lookup_fnfields_here):Likewise. ++ (check_final_overrider): Likewise. ++ (init_vbase_pointers): Likewise. ++ (virtual_context): Likewise. ++ * semantics.c (finish_member_declaration): Just set DECL_CONTEXT. ++ (expand_body): Use decl_function_context, not ++ hack_decl_function_context. ++ * tree.c (hack_decl_function_context): Remove. ++ * typeck.c (build_x_function_call): Use DECL_CONTEXT, not ++ DECL_CLASS_CONTEXT. ++ * typeck2.c (error_not_base_type): Likewise. ++ ++2000-02-15 Jason Merrill ++ ++ * decl.c (xref_tag): Don't SET_IDENTIFIER_NAMESPACE_VALUE. ++ ++2000-02-16 Kaveh R. Ghazi ++ ++ * Make-lang.in (g++spec.o): Depend on $(GCC_H), not gcc.h. ++ ++2000-02-15 Jonathan Larmour ++ ++ * lang-specs.h: Add new __GNUC_PATCHLEVEL__ define to default spec. ++ ++2000-01-16 Gabriel Dos Reis ++ ++ * decl2.c (lang_decode_option): Enable automatic line wrapping. ++ ++2000-02-13 Jason Merrill ++ ++ * parse.y (frob_specs): Split out... ++ (parse_decl): From here. ++ (fn.def2): Call initial_deferred_type_access_control. ++ (after_type_component_declarator0): Call frob_specs. ++ (notype_component_declarator0): Likewise. ++ * search.c (friend_accessible_p): Nested classes are friends of their ++ enclosing classes. ++ ++2000-02-10 Mark Mitchell ++ ++ * ir.texi (ADDR_EXPR): Document the fact that an ADDR_EXPR can be ++ used to create an implicit temporary. ++ ++ * class.c (dfs_modify_vtables): Tweak calculation of functions to ++ override. ++ ++2000-02-08 Nathan Sidwell ++ ++ * typeck.c (strip_all_pointer_quals): Use TYPE_MAIN_VARIANT, to ++ strip array element qualifiers too. ++ ++2000-02-07 Mark Mitchell ++ ++ * decl.c (store_parm_decls): Don't build cleanups for parameters ++ while processing_template_decl. ++ ++2000-02-07 Jason Merrill ++ ++ * cp-tree.h (struct saved_scope): Add incomplete field. ++ (namespace_scope_incomplete): New macro. ++ * decl.c (pushdecl): Use it. ++ (hack_incomplete_structures): Use it. See through artificial ++ binding levels. ++ (mark_saved_scope): Mark it. ++ ++ Implement access control for nested types. ++ * search.c (type_access_control): New fn. ++ (accessible_p): Now we do perform access control for types. ++ * semantics.c (deferred_type_access_control): New fn. ++ (initial_deferred_type_access_control): New fn. ++ (begin_function_definition): Call it. Add lookups parm. ++ * decl.c (struct binding_level): Add this_class field. ++ (pushlevel_class): Set it. ++ (mark_binding_level): Mark it. ++ (lookup_name_real): Use it. Call type_access_control. ++ (mark_saved_scope): Mark lookups field. ++ * cp-tree.h (flagged_type_tree): Add lookups field. ++ (struct saved_scope): Add lookups field. ++ (type_lookups): New macro. ++ * parse.y (declmods): Now . ++ (parse_decl): Add lookups parm. Call ++ initial_deferred_type_access_control. ++ (lang_extdef): Clear type_lookups. ++ (typed_declspecs, declmods, typespec): Set lookups field. ++ (initdcl): Call deferred_type_access_control. ++ (fn.def1, fn.def2, typed_declspecs1, initdcl0_innards, nomods_initdcl0, ++ component_decl_1, named_parm): Adjust. ++ * friend.c (is_friend): Nested classes are friends of their ++ enclosing classes. ++ ++ * class.c (currently_open_derived_class): New fn. ++ * method.c (hack_identifier): Use it. ++ ++ * lex.c (do_identifier): Remove obsolete code. ++ ++ * parse.y (typed_typespecs): Propagate new_type_flag properly. ++ ++2000-02-05 Zack Weinberg ++ ++ * tinfo.h: Remove apostrophes from C++ comment (xgettext ++ thinks this file is plain C). ++ ++2000-02-05 Kaveh R. Ghazi ++ ++ * Makefile.in (call.o): Depend on $(EXPR_H). ++ ++ * call.c: Include "expr.h". ++ ++ * class.c (dump_class_hierarchy): Add prototype. ++ ++ * search.c (dfs_get_pure_virtuals): Likewise. ++ ++2000-02-1 Ulrich Drepper ++ ++ * parse.y (simple_stmt): Allow :: token in asm parameter list. ++ * parse.c: Rebuilt. ++ ++2000-01-31 Jim Wilson ++ ++ * class.c (build_vtbl_or_vbase_field): New parameter fcontext. ++ Store it in DECL_FCONTEXT. ++ (build_vbase_pointer_fields, create_vtable_ptr): Fix callers. ++ ++2000-01-31 Jason Merrill ++ ++ * tinfo.h (old abi): #include "tconfig.h". ++ * tinfo.cc (convert_to_base): Move into old abi section. ++ ++2000-01-31 Mark Mitchell ++ ++ * cp-tree.h (BINFO_VIRTUALS): Tweak documentation. ++ (CLASSTYPE_PRIMARY_BINFO): Use BINFO_PRIMARY_BINFO. ++ (BINFO_PRIMARY_BINFO): New macro. ++ (BF_DELTA): Rename to ... ++ (BV_DELTA): ... this. ++ (BF_VCALL_INDEX): Rename to ... ++ (BV_VCALL_INDEX): ... this. ++ (BF_FN): Rename to ... ++ (BV_FN): ... this. ++ * class.c (build_vbase_path): Adjust for changes to reverse_path. ++ (set_rtti_entry): Rename BF_ macros to BV_ variants. ++ (modify_vtable_entry): Simplify. ++ (add_virtual_function): Rename BF_ macros to BV_ variants. ++ (build_vtable_initializer): Likewise. ++ (get_class_offset_1): Remove. ++ (dfs_get_class_offset): Likewise. ++ (get_class_offset): Likewise. ++ (dfs_find_final_overrider): New function. ++ (find_final_overrider): Likewise. ++ (modify_one_vtable): Remove. ++ (dfs_find_base): New function. ++ (dfs_modify_vtables): Fold modify_one_vtable in here. Use ++ find_final_overrider. ++ (modify_all_vtables): Adjust. Set BV_VCALL_INDEX on new ++ virtuals. ++ (dfs_fixup_vtable_deltas): Remove. ++ (override_one_vtable): Remove. ++ (merge_overrides): Likewise. ++ (layout_virtual_bases): Make sure BINFO_OFFSET is set right for ++ unreal chilren of virtual bases. ++ (finish_struct_1): Don't use merge_overrides. Don't use ++ dfs_fixup_vtable_deltas. ++ * tree.c (reverse_path): Return a TREE_LIST, not a chain of ++ BINFOs. ++ ++2000-01-31 Herman A.J. ten Brugge ++ Jason Merrill ++ ++ * tinfo.h: Rename USItype to myint32, depend on BITS_PER_UNIT. ++ ++2000-01-31 Alfred Minarik ++ ++ * exception.cc (__throw_bad_typeid): Add missing std::. ++ ++2000-01-31 Kaveh R. Ghazi ++ ++ * cp-tree.h (make_thunk): PROTO -> PARAMS. ++ ++2000-01-31 Nathan Sidwell ++ ++ * cp-tree.h (new_abi_rtti_p): Use flag_new_abi. ++ ++ Runtime support for new-abi rtti. ++ * inc/typeinfo (type_info::operator!=): Define in class. ++ (type_info::before, type_info::name, type_info::operator==, ++ type_info::operator!=): Define new ABI implementations. ++ (type_info::is_pointer_p, type_info::is_function_p): Declare ++ new virtual functions. ++ (type_info::do_catch, type_info::do_upcast): Likewise. ++ ++ * tinfo.h (__base_class_info): Define new class. ++ (__class_type_info): Likewise. ++ (__si_class_type_info): Likewise. ++ (__vmi_class_type_info): Likewise. ++ (__dynamic_cast): Prototype. ++ ++ * tinfo.cc: Conditionalize old and new rtti mechanisms. ++ (type_info::is_pointer_p): Define new function. ++ (type_info::is_function_p): Likewise. ++ (type_info::do_catch): Likewise. ++ (type_info::do_upcast): Likewise. ++ (vtable_prefix): New structure for vtable access. ++ (adjust_pointer): Define new template function. ++ (contained_p, public_p, virtual_p, contained_public_p, ++ contained_nonpublic_p, contained_nonvirtual_p): Define new ++ functions. ++ (nonvirtual_base_type): New local variable. ++ (__class_type_info::~__class_type_info): Define. ++ (__si_class_type_info::~__si_class_type_info): Likewise. ++ (__vmi_class_type_info::~__vmi_class_type_info): Likewise. ++ (__class_type_info::do_catch): Define new function. ++ (__class_type_info::do_upcast): Likewise. ++ (__class_type_info::find_public_src): Likewise. ++ (__class_type_info::do_find_public_src): Likewise. ++ (__si_class_type_info::do_find_public_src): Likewise. ++ (__vmi_class_type_info::do_find_public_src): Likewise. ++ (__class_type_info::do_dyncast): Likewise. ++ (__si_class_type_info::do_dyncast): Likewise. ++ (__vmi_class_type_info::do_dyncast): Likewise. ++ (__class_type_info::do_upcast): Likewise. ++ (__si_class_type_info::do_upcast): Likewise. ++ (__vmi_class_type_info::do_upcast): Likewise. ++ (__dynamic_cast): Likewise. ++ ++ * tinfo2.cc (__fundamental_type_info): Define new class. ++ (__pointer_type_info): Likewise. ++ (__reference_type_info): Likewise. ++ (__array_type_info): Likewise. ++ (__function_type_info): Likewise. ++ (__enum_type_info): Likewise. ++ (__ptr_to_member_type_info): Likewise. ++ (__fundamental_type_info::~__fundamental_type_info): Define. ++ (__pointer_type_info::~__pointer_type_info): Likewise. ++ (__reference_type_info::~__reference_type_info): Likewise. ++ (__array_type_info::~__array_type_info): Likewise. ++ (__function_type_info::~__function_type_info): Likewise. ++ (__enum_type_info::~__enum_type_info): Likewise. ++ (__ptr_to_member_type_info::~__ptr_to_member_type_info): Likewise. ++ (__pointer_type_info::do_catch): Define new function. ++ (__ptr_to_member_type_info::do_catch): Define new function. ++ ++ (__throw_type_match_rtti_2): Use new ABI interface, if enabled. ++ (__is_pointer): Likewise. ++ ++ * exception.cc (__cplus_type_matcher): Deal with new-abi rtti. ++ ++2000-01-30 Mark Mitchell ++ ++ * cp/class.c (build_vtable): Rename to build_primary_vtable. ++ (prepare_fresh_vtable): Rename to build_secondary_vtable. ++ (make_new_vtable): New function. ++ (modify_vtable_entry): Handle generation of new vtables correctly. ++ (modify_one_vtable): Remove unused parameter. ++ (dfs_fixup_vtable_deltas): Likewise. ++ (override_one_vtable): Use build_secondary_vtable. ++ (finish_struct_1): Use build_primary_vtable and ++ build_secondary_vtable. ++ ++2000-01-28 Ulrich Drepper ++ ++ * cp/decl.c: Adjust variable names, comments, help strings. ++ ++2000-01-29 Nathan Sidwell ++ ++ * new2.cc (operator delete[]): Use operator delete, don't assume ++ implementation. ++ ++2000-01-29 Nathan Sidwell ++ ++ * class.c (build_vtbl_initializer): Add argument to ++ build_vtable_entry call. ++ ++2000-01-27 Mark Mitchell ++ ++ * cp-tree.def (THUNK_DECL): Discuss vcall indices. ++ * cp-tree.h (BINFO_VIRTUALS): Update documentation. ++ (BF_DELTA): New macro. ++ (BF_VCALL_INDEX): Likewise. ++ (BF_FN): Likewise. ++ (THUNK_VCALL_OFFSET): Likewise. ++ (make_thunk): Change prototype. ++ * class.c (build_vtable_entry): Integrate ++ build_vtable_entry_for_fn. Handle vcall indices. ++ (build_vtable_entry_for_fn): Remove. ++ (set_rtti_entry): Handle vcall indices. Use BF_DELTA, ++ BF_VCALL_INDEX, BF_FN. ++ (modify_vtable_entry): Integrate common code from ++ modify_one_vtable and dfs_fixup_vtable_deltas. ++ (add_virtual_function): Set BF_VCALL_INDEX. ++ (build_vtbl_initializer): Simplify. Use BF_DELTA, BF_VCALL_INDEX, ++ and BF_FN. ++ (modify_one_vtable): Simplify. ++ (dfs_fixup_vtable_deltas): Likewise. ++ (override_one_vtable): Use BF_DELTA, BF_VCALL_INDEX, BF_FN. ++ * method.c (make_thunk): Handle vcall indices. ++ ++2000-01-28 Nathan Sidwell ++ ++ Compiler side new abi rtti (not enabled). ++ * cp-tree.h (new_abi_rtti_p): New macro. ++ (emit_support_tinfos): Prototype new function. ++ (tinfo_decl_p): Likewise. ++ (emit_tinfo_decl): Likwise. ++ * rtti.c (TINFO_PSEUDO_TYPE, TINFO_VTABLE_DECL): New accessor ++ macros. ++ (doing_runtime): New local static. ++ (init_rtti_processing): Add new-abi initializer. ++ (get_tinfo_decl): Add new-abi logic. ++ (tinfo_from_decl): Likewise. ++ (build_dynamic_cast_1): Likewise. ++ (qualifier_flags): New static function. ++ (tinfo_base_init): Likewise. ++ (generic_initializer): Likewise. ++ (ptr_ref_initializer): Likewise. ++ (ptmd_initializer): Likewise. ++ (class_hint_flags): Likewise. ++ (class_initializer): Likewise. ++ (synthesize_tinfo_var): Likewise. ++ (create_real_tinfo_var): Likewise. ++ (create_pseudo_type_info): Likewise. ++ (get_vmi_pseudo_type_info): Likewise. ++ (create_tinfo_types): Likewise. ++ (emit_support_tinfos): New global function. ++ (tinfo_decl_p): New global predicate. ++ (emit_tinfo_decl): New global function. ++ * class.c (set_rtti_entry): Generalize for old and new rtti. ++ (build_vtbl_initializer): Likewise. ++ * decl2.c (finish_file): Likewise. ++ ++2000-01-27 Jim Wilson ++ ++ * optimize.c (remap_decl): Add walk_tree calls for DECL_SIZE (t) ++ and TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (t))). ++ ++2000-01-27 Mike Stump ++ ++ * decl.c (pushdecl): Fix up shadow warnings with respect to implicit ++ for scopes. ++ ++2000-01-26 Jason Merrill ++ ++ * pt.c (unify): Use fold, not maybe_fold_nontype_arg. ++ ++2000-01-26 J"orn Rennecke ++ ++ * optimize.c (calls_setjmp_r): Supply new argument ++ to special_function_p. ++ ++2000-01-26 Kaveh R. Ghazi ++ ++ * call.c: PROTO -> PARAMS. ++ * class.c: Likewise. ++ * cp-tree.h: Likewise. ++ * cvt.c: Likewise. ++ * decl.c: Likewise. ++ * decl.h: Likewise. ++ * decl2.c: Likewise. ++ * dump.c: Likewise. ++ * errfn.c: Likewise. ++ * error.c: Likewise. ++ * except.c: Likewise. ++ * expr.c: Likewise. ++ * init.c: Likewise. ++ * input.c: Likewise. ++ * lex.c: Likewise. ++ * lex.h: Likewise. ++ * method.c: Likewise. ++ * optimize.c: Likewise. ++ * parse.y: Likewise. ++ * pt.c: Likewise. ++ * repo.c: Likewise. ++ * rtti.c: Likewise. ++ * search.c: Likewise. ++ * semantics.c: Likewise. ++ * spew.c: Likewise. ++ * tree.c: Likewise. ++ * typeck.c: Likewise. ++ * typeck2.c: Likewise. ++ * xref.c: Likewise. ++ ++2000-01-25 Richard Henderson ++ ++ * typeck.c (build_binary_op_nodefault): Remove UNNE_EXPR. ++ ++2000-01-25 Mark Mitchell ++ ++ * cp-tree.h (vcall_offset_in_vtable_p): New macro. ++ * class.c (build_vbase_offset_vtbl_entries): Fix typo in commment. ++ (struct vcall_offset_data_s): New type. ++ (dfs_vcall_offset_queue_p): New function. ++ (dfs_build_vcall_offset_vtbl_entries): Likewise. ++ (build_vcall_offset_vtbl_entries): Likewise. ++ (layout_vtable_decl): Likewise. ++ (num_vfun_entries): Likewise. ++ (num_extra_vtbl_entries): Add the entries for vcall offsets. ++ (build_vtbl_initializer): Likewise. ++ (dfs_finish_vtabls): Use layout_vtable_decl. ++ (modify_one_vtables): Always duplicate vtables under the new ABI. ++ (finish_struct_1): Use layout_vtable_decl. ++ ++2000-01-25 Kaveh R. Ghazi ++ ++ * decl.c (member_function_or_else): Change third arg from a format ++ specifier to an `enum overload_flags'. Callers changed. ++ ++2000-01-25 Gabriel Dos Reis ++ ++ * typeck.c (composite_pointer_type, c_sizeof, expr_sizeof, ++ build_binary_op_nodefault, build_unary_op, build_reinterpret_cast, ++ build_const_cast, get_delta_difference, check_return_expr): Avoid ++ ANSI string concatenation usage. ++ ++2000-01-24 Mark Mitchell ++ ++ * class.c (layout_class_type): Put the fields required to make a ++ class non-empty at the end, not the beginning, of the TYPE_FIELDs ++ list. ++ ++2000-01-24 Jason Merrill ++ ++ * pt.c (maybe_fold_nontype_arg): Do nothing if we're not in a ++ template. ++ ++ * decl2.c (mark_used): Do instantiate inlines that have been ++ explicitly instantiated. ++ ++2000-01-24 Richard Henderson ++ ++ * call.c (build_over_call): Use expand_tree_builtin. ++ * typeck.c (build_function_call_real): Likewise. ++ (build_binary_op_nodefault): Handle unordered compares. ++ ++2000-01-24 Nathan Sidwell ++ ++ * cp-tree.h (CPTI_BAD_CAST, CPTI_BAD_TYPEID, CPTI_DCAST): New ++ cp_tree_index values. ++ (throw_bad_cast_node, throw_bad_typeid_node, dynamic_cast_node): ++ New global node #defines for them. ++ * rtti.c (call_void_fn): Replace with ... ++ (build_runtime_decl): ... new static function. ++ (throw_bad_cast): Use throw_bad_cast_node and build_runtime_decl. ++ (throw_bad_typeid): Use throw_bad_typeid_node and build_runtime_decl. ++ (build_dynamic_cast_1): Always produce correctly typed result. ++ Explicitly produce type_info addresses. Use dynamic_cast_node. ++ * exception.cc (__throw_bad_cast): Return `void *'. ++ (__throw_bad_typeid): Return `const type_info &'. ++ ++2000-01-24 Nathan Sidwell ++ ++ * cp-tree.h (get_vtable_decl): Prototype new function. ++ * class.c (get_vtable_decl): New function. Broken out from ... ++ (build_vtable): ... here. Use it. ++ * decl2.c (finish_vtable_vardecl): Ignore dummy vtables created ++ by get_vtable_decl. ++ ++2000-01-24 Nathan Sidwell ++ ++ * cp-tree.h (CPTI_TP_DESC_TYPE, CPTI_ACCESS_MODE_TYPE, ++ CPTI_USER_DESC_TYPE, CPTI_CLASS_DESC_TYPE, CPTI_ATTR_DESC_TYPE, ++ CPTI_PTMF_DESC_TYPE): Remove cp_tree_index enumerations. ++ (CPTI_TI_DESC_TYPE, CPTI_REF_DESC_TYPE, CPTI_ARY_DESC_TYPE, ++ CPTI_ENUM_DESC_TYPE, CPTI_CLASS_DESC_TYPE, CPTI_SI_CLASS_DESC_TYPE, ++ CPTI_VMI_CLASS_DESC_TYPE, CPTI_BASE_DESC_TYPE): New enumerations. ++ (CPTI_TINFO_FN_ID, CPTI_TINFO_FN_TYPE): Rename to ... ++ (CPTI_TINFO_DECL_ID, CPTI_TINFO_DECL_TYPE): ... here. ++ (CPTI_TINFO_VAR_ID): New enumeration. ++ (__tp_desc_type_node, __access_mode_type_node, ++ __bltn_desc_type_node, __user_desc_type_node, ++ __class_desc_type_node, __ptr_desc_type_node, ++ __attr_desc_type_node, __func_desc_type_node, ++ __ptmf_desc_type_node, __ptmd_desc_type_node): Remove #defines. ++ (ti_desc_type_node, bltn_desc_type_node, ptr_desc_type_node, ++ ref_desc_type_node, ary_desc_type_node, func_desc_type_node, ++ enum_desc_type_node, class_desc_type_node, ++ si_class_desc_type_node, vmi_class_desc_type_node, ++ ptmd_desc_type_node, base_desc_type_node): New #defines. ++ (tinfo_fn_id, tinfo_fn_type): Rename to ... ++ (tinfo_decl_id, tinfo_decl_type): ... here. Adjust. ++ (tinfo_var_id): New enumeration. ++ (DECL_TINFO_FN_P): Augment comment. ++ * decl.c (cp_global_trees): Adjust documentation. ++ * rtti.c (init_rtti_processing): Adjust for tinfo_decl_id, ++ tinfo_decl_type and tinfo_var_id. ++ (get_tinfo_decl_dynamic): Adjust for tinfo_decl_type. ++ (build_typeid): Remove unused variable. ++ (get_tinfo_var): Use tinfo_var_id. ++ (tinfo_name): New static function. ++ (get_tinfo_decl): Adjust for tinfo_decl_id and tinfo_decl_type. ++ (tinfo_from_decl): Likewise. ++ (get_base_offset): New static function, broken out of ++ expand_class_desc. ++ (expand_si_desc): Use tinfo_name. ++ (expand_class_desc): Likewise. Lose local static variable. ++ Use base_desc_type_node. Use get_base_offset. ++ (expand_ptr_desc): Use tinfo_name. ++ (expand_attr_desc): Likewise. ++ (expand_generic_desc): Likewise. ++ ++ * tinfo.cc (__GXX_ABI_VERSION): Test value and existence. ++ * tinfo.h (__GXX_ABI_VERSION): Test value and existence. ++ ++2000-01-23 Mark Mitchell ++ ++ * cp-tree.h (__eprintf): Remove declaration. ++ * tree.c (__eprintf): Remove definition. ++ ++2000-01-23 Zack Weinberg ++ Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_MARKED_N, SET_CLASSTYPE_MARKED_N, ++ CLEAR_CLASSTYPE_MARKED_N): Avoid signed vs. unsigned warnings. ++ ++2000-01-23 Brad Lucier ++ ++ * class.c (dump_class_hierarchy): Print HOST_WIDE_INT properly. ++ ++2000-01-23 Mark Mitchell ++ ++ * cp-tree.h (register_dtor_fn): New function. ++ * decl.c (destroy_local_static): Rename to ... ++ (register_dtor_fn): ... this. Give it external linkage. ++ (expand_static_init): Use it. ++ * decl2.c (do_static_initialization): Likewise, if using ++ __cxa_atexit. ++ (do_static_destruction): Check that __cxa_atexit is not in use. ++ (finish_file): Don't call do_static_destruction if using ++ __cxa_atexit. ++ ++ * typeck.c (convert_arguments): Restore two-message error ++ reporting. ++ ++2000-01-20 Nathan Sidwell ++ ++ Remap dynamic cast hint values to be consistent across ABIs. ++ * search.c (dynamic_cast_base_recurse): Remap generated value. ++ (get_dynamic_cast_base_type): Adjust documentation. ++ * tinfo.h (__user_type_info::dyncast): Likewise. ++ (__user_type_info::find_public_subobj): Remap BOFF meaning. ++ * tinfo.cc (__si_type_info::do_dyncast): Remap BOFF meaning. ++ (__class_type_info::do_dyncast): Likewise. ++ (__class_type_info::do_find_public_subobj): Likewise. ++ * tinfo2.cc (__dynamic_cast): Remap BOFF parameter. ++ ++2000-01-19 Gabriel Dos Reis ++ ++ * typeck.c (build_unary_op): Use cp_pedwarn, not pedwarn. ++ ++ * typeck2.c (incomplete_type_error): Restore previous ++ cp_error and cp_error_at call sequence. ++ ++2000-01-20 Brad Lucier ++ ++ * class.c (dump_class_hierarchy): Make format agree with argument; ++ cast pointer to unsigned long and print with %lx. ++ ++2000-01-19 Gabriel Dos Reis ++ ++ * decl2.c (lang_decode_option): Set default line-wrap length to 72. ++ ++ * typeck.c (composite_pointer_type, common_type, ++ comp_target_parms, c_sizeof, expr_sizeof, build_array_ref, ++ build_function_call_real, convert_arguments, ++ build_binary_op_nodefault, pointer_int_sum, pointer_diff, ++ build_unary_op, mark_addressable, build_compound_expr, ++ build_static_cast, build_reinterpret_cast, build_const_cast, ++ build_c_cast, build_modify_expr, get_delta_difference, ++ build_ptrmemfunc, check_return_expr): Replace 'ANSI C++' with ++ 'ISO C++'. Fusion consecutive calls to diagnostic message routines ++ into a single one. ++ * typeck2.c (readonly_error, abstract_virtuals_error, ++ process_init_constructor, check_for_new_type): Likewise. ++ ++2000-01-19 Mark Mitchell ++ ++ * tree.c (bot_manip): Set DECL_CONTEXT for newly created ++ VAR_DECLs. ++ ++2000-01-18 Nathan Sidwell ++ ++ * cp-tree.h (get_tinfo_fn_dynamic): Remove prototype. ++ (build_x_typeid): Likewise. ++ (get_tinfo_fn): Likewise. ++ (get_tinfo_fn_unused): Rename to ... ++ (get_tinfo_decl): ... here. ++ * rtti.c (build_headof): Replace logic error with assertion. ++ (get_tinfo_fn_dynamic): Rename to ... ++ (get_tinfo_decl_dynamic): ... here. Make static. Use ++ complete_type_or_else. ++ (build_x_typeid): Move into ... ++ (build_typeid): ... here. Adjust call to ++ get_tinfo_decl_dynamic. Use tinfo_from_decl. Simplify ++ throw_bad_typeid expression. ++ (get_tinfo_fn_unused): Rename to ... ++ (get_tinfo_decl): ... here. Adjust comment. ++ (get_tinfo_fn): Delete. ++ (tinfo_from_decl): New static function. ++ (get_typeid_1): Call get_tinfo_decl and tinfo_from_decl. ++ (get_typeid): Use complete_type_or_else. ++ (build_dynamic_cast_1): Adjust calls to ++ get_tinfo_decl_dynamic. Simplify throw_bad_cast expression. ++ * parse.y (primary): Adjust call to build_typeid. ++ * except.c (build_eh_type_type_ref): Adjust call to ++ get_tinfo_decl. Mark as used. ++ * class.c (set_rtti_entry): Adjust call to get_tinfo_decl. ++ * decl2.c (build_expr_from_tree): Adjust call to build_typeid. ++ * parse.c: Regenerated. ++ ++2000-01-17 Mark Mitchell ++ ++ * class.c (fixed_type_or_null): Don't clear NONNULL. Document ++ calling convention. ++ (resolves_to_fixed_type_p): Document calling convention. ++ * rtti.c (build_x_typeid): Initialize NONNULL. ++ ++ * cp-tree.h (build_shared_int_cst): New function. ++ * call.c (build_over_call): Use DECL_VIRTUAL_CONTEXT, for clarity. ++ * class.c (modify_vtable_entry): Likewise. ++ (add_virtual_function): Split out code to generated shared ++ INTEGER_CSTs to build_share_int_cst. ++ (modify_all_vtables): Handle all the overridden functions here. ++ Add overridden functions from non-primary virtual bases to the ++ primary vtable. ++ (finish_struct_1): Adjust call to modify_all_vtables. Add ++ overridden functions from non-primary bases to the vtable. ++ * tree.c (build_shared_int_cst): New function. ++ ++ * cp-tree.h (scratchalloc): Remove. ++ (build_scratch_list): Likewise. ++ * call.c (convert_class_to_reference): Replace build_scratch_list ++ and build_expr_list with build_tree_list. ++ (add_candidate): Replace scratchalloc with expralloc. Note memory ++ leak. ++ (build_user_type_conversion_1): Replace build_scratch_list ++ and build_expr_list with build_tree_list. ++ (build_new_op): Likewise. ++ (build_op_delete_call): Likewise. ++ (convert_like): Likewise. ++ * cvt.c (ocp_convert): Likewise. ++ * decl.c (start_decl): Likewise. ++ (start_function): Likewise. ++ (finish_destructor_body): Likewise. ++ (maybe_build_cleanup_1): Likewise. ++ * decl2.c (reparse_decl_as_expr): Likewise. ++ * init.c (perform_member_init): Likewise. ++ (expand_cleanup_for_base): Likewise. ++ (build_builtin_delete_call): Likewise. ++ (build_new_1): Likewise. ++ (build_delete): Likewise. ++ * method.c (do_build_assign_ref): Likewise. ++ * parse.y (already_scoped_stmt): Likewise. ++ (nontrivial_exprlist): Likewise. ++ (net_initializer): Likewise. ++ (initlist): Likewise. ++ * parse.c: Regenerated. ++ * rtti.c (build_x_typeid): Likewise. ++ (build_dynamic_cast_1): Likewise. ++ * typeck.c (build_x_compound_expr): Likewise. ++ (build_static_cast): Likewise. ++ (build_modify_expr): Likewise. ++ ++ * cp-tree.h (DECL_VINDEX): Add documentation. ++ * class.c (build_vtable_entry): Likewise. ++ (start_vtable): Add comment. ++ (add_virtual_function): Replace pending_hard_virtuals with ++ overridden_virtuals and pending_virtuals with new_virtuals. ++ Replace redundant assignments with assertions. ++ (check_for_override): Add comment. ++ (check_bases_and_members): Replace pending_hard_virtuals with ++ overridden_virtuals and pending_virtuals with new_virtuals. ++ (create_vtbl_ptr): Likewise. ++ (layout_class_type): Likewise. ++ (finish_struct_1): Likewise. Add comments. ++ ++2000-01-16 Mark Mitchell ++ ++ * class.c (finish_struct_1): Replace redundant code with ++ assertions. ++ ++ * cp-tree.h (flag_new_abi): Move. ++ (flag_use_cxa_atexit): Likewise. ++ (flag_honor_std): Likewise. ++ (flag_rtti): Likewise. ++ (vbase_offsets_in_vtable_p): Define. ++ (vptrs_present_everywhere_p): Likewise. ++ (TYPE_CONTAINS_VPTR_P): Likewise. ++ (dfs_walk_real): Declare. ++ * class.c (build_vbase_pointer_fields): Check ++ vbase_offsets_in_vtable_p. ++ (dfs_build_vbase_offset_vtbl_entries): Record the vbase indices in ++ BINFO_VPTR_FIELD. ++ (build_vbase_offset_vtbl_entries): Simplify. ++ (build_vbase_offset_vtbl_entries): Adjust. ++ (build_vbase_pointer): Add ability to look up vbase offsets in ++ vtable. ++ (start_vtable): New function. ++ (add_virtual_function): Use it. ++ (determine_primary_base): Use TYPE_CONTAINS_VPTR_P. ++ (num_extra_vtbl_entries): Use vbase_offsets_in_vtable_p. ++ (build_vtbl_initializer): Take the type of the complete object as ++ input. Use it to correctly calculate vbase offsets. ++ (dfs_finish_vtbls): Pass the complete type to ++ build_vtbl_initializer. ++ (check_bases_and_members): Use TYPE_CONTAINS_VPTR_P. ++ (create_vtable_ptr): Create a vtable even if there are no ++ new virtual functions, under the new ABI. ++ (finish_struct_1): Likewise. ++ (get_vfield_name): Use TYPE_CONTAINS_VPTR_P. ++ * decl.c (exapnd_static_init): Remove call to ++ preserve_initializer. ++ * decl2.c (mark_vtable_entries): Tweak to handle vbase offsets in ++ vtables. ++ * init.c (initialize_vtbl_ptrs): Initialize them in pre-order. ++ (expand_virtual_init): Use vbase_offsets_in_vtable_p. ++ (construct_virtual_bases): Don't initialize virtual base pointers ++ under the new ABI. ++ (build_aggr_init): Clean up comment. ++ (expand_aggr_init_1): Likewise. ++ * rtti.c (expand_class_desc): Store the virtual function table ++ index where the vbase offset lives in the offset field. ++ * search.c (dfs_walk_real): Make it global. ++ (dfs_debug_mark): Use TYPE_CONTAINS_VPTR_P. ++ * tree.c (make_binfo): Don't clear BINFO_VPTR_FIELD. ++ ++ * tinfo.h (USItype): Make it signed under the new ABI. ++ * tinfo.cc (convert_to_base): New function. Encapsulate base ++ conversion logic here. ++ (__class_type_info::do_upcast): Use it. ++ (__class_type_info::do_dyncast): Likewise. ++ (__class_type_info::do_find_public_subobj): Likewise. ++ ++ * init.c (construct_virtual_bases): Don't look up the addresses of ++ virtual bases at run-time. ++ ++ * class.c (build_vbase_pointer): Relocate. ++ (build_vbase_pointer_fields): Likewise. ++ (dfs_build_vbase_offset_vtbl_entries): Likewise. ++ (build_vbase_offset_vtbl_entries): Likewise. ++ ++ * decl.c (init_decl_processing): Complain if -fnew-abi ++ -fno-vtable-thunks is used. ++ ++ * decl2.c (lang_decode_option): Don't couple flag_honor_std to ++ flag_new_abi. ++ ++2000-01-15 Mark Mitchell ++ ++ * cp-tree.h (num_extra_vtbl_entries): New function. ++ (size_extra_vtbl_entries): Likewise. ++ (dfs_vtable_path_unmark): Likewise. ++ (dfs_vtable_path_unmarked_real_bases_queue_p): Likewise. ++ (dfs_vtable_path_marked_real_bases_queue_p): Likewise. ++ * class.c (num_extra_vtbl_entries): New function. ++ (size_extra_vtbl_entries): Likewise. ++ (dfs_build_vbase_offset_vtbl_entries): New function. ++ (build_vbase_offset_vtbl_entries): Likewise. ++ (build_vtbl_initializer): Use it. ++ (finish_struct_1): Adjust vtable sizes (using ++ num_extra_vtbl_entries). ++ * expr.c (cplus_expand_expr): Assert that the DECL_RTL for a ++ THUNK_DECL is non-NULL before expanding it. ++ * init.c (expand_virtual_init): Adjust the vtable pointer by ++ size_extra_vtbl_entries before storing it. ++ * search.c (get_shared_vase_if_not_primary): Adjust prototype. ++ Handle TREE_LIST parameters here, not in the dfs_* functions. ++ (dfs_unmarked_real_bases_queue_p): Adjust. ++ (dfs_marked_real_bases_queue_p): Likewise. ++ (dfs_vtable_path_unmarked_real_bases_queue_p): New function. ++ (dfs_vtable_path_marked_real_bases_queue_p): New function. ++ (dfs_vtable_path_unmark): Likewise. ++ ++2000-01-14 Mark Mitchell ++ ++ * optimize.c (copy_body_r): Clear the operand three of a ++ TARGET_EXPR when copying it. ++ ++2000-01-14 Martin v. Löwis ++ ++ * method.c (build_decl_overload_real): Check whether we are in :: ++ before returning __builtin_new/delete. ++ ++2000-01-13 Mark Mitchell ++ ++ * pt.c (tsubst_friend_function): Improve comment. ++ (instantiate_decl): Avoid crashing when a "nested" function is ++ instantiated from the top level. ++ ++ * dump.c (dqeueue_and_dump): Dump ++ DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION. ++ ++2000-01-13 Kaveh R. Ghazi ++ ++ * call.c: If GATHER_STATISTICS, declare `n_build_method_call'. ++ ++2000-01-13 Nathan Sidwell ++ ++ * g++spec.c (lang_specific_driver): Add -fnew-abi if ++ ENABLE_NEW_GXX_ABI defined. ++ * Make-lang.in (tinfo.o, tinfo2.o, exception.o, new.o, ++ opnew.o, opnewnt.o, opvnew.o, opvnewnt.o, opdel.o, opdelnt.o, ++ opvdel.o, opvdelnt.o): Use GXX_ABI_FLAG switch. ++ ++2000-01-12 Mark Mitchell ++ ++ * decl.c (start_cleanup_fn): Call pushdecl. ++ ++ * call.c (convert_class_to_reference): Fix typos. ++ (build_conditional_expr): Handle errors gracefully. ++ * class.c (push_nested_class): Likewise. ++ * cp-tree.h (VAR_FUNCTION_OR_PARM_DECL_CHECK): New macro. ++ (DECL_THIS_EXTERN): Use it. ++ (DECL_THIS_STATIC): Likewise. ++ * cvt.c (convert_to_void): Handle errors gracefully. ++ (build_expr_type_conversion): Likewise. ++ * decl.c (maybe_push_decl): Likewise. ++ (start_decl_1): Likewise. ++ (require_complete_types_for_parms): Likewise. ++ * parse.y (structsp): Likewise. ++ (base_class): Likewise. ++ * parse.c: Regenerated. ++ * pt.c (finish_member_template_decl): Likewise. ++ * typeck.c (decay_conversion): Likewise. ++ ++ * cp-tree.h (dfs_skip_vbases): New function. ++ (find_vbase_instance): Likewise. ++ * class.c (determine_primary_base): Allow a nearly empty base to ++ serve as a primary base class under the new ABI. ++ (get_class_offset_1): Rename to ... ++ (dfs_get_class_offset): ... this. Simplify. Don't issue error ++ messages here. ++ (get_class_offset): Use it. Issue error messages here. ++ (dfs_modify_vtables): Rely on dfs_unmarked_real_bases_queue_p to ++ find the right copies of virtual bases. ++ (fixup_vtable_deltas1): Rename to ... ++ (dfs_fixup_vtable_deltas): ... this. Adjust to handle virtual ++ bases as primary bases. ++ (fixup_vtable_deltas): Remove. ++ (override_one_vtable): Handle virtual bases as primary bases. ++ (merge_overrides): Likewise. ++ (finish_struct_1): Likewise. ++ (dump_class_hierarchy): Dump primary-ness of bases as well. ++ * search.c (mark_primary_bases): Use a pre-order traversal to ++ handle primary virtual bases. ++ (dfs_skip_vbases): New fiunction. ++ (expand_upcast_fixups): Adjust to handle primary virtual bases. ++ (fixup_virtual_upcast_offsets): Likewise. ++ (fixup_all_virtual_upcast_offsets): Likewise. ++ (dfs_find_vbase_instances): New function. ++ (find_vbase_instance): Likewise. ++ ++2000-01-11 Mumit Khan ++ ++ * lex.c (DIR_SEPARATOR): Delete macro. ++ ++2000-01-12 Gabriel Dos Reis ++ ++ * decl2.c (lang_decode_option): Handle automatic line wrapping ++ option. ++ ++2000-01-11 Mark Mitchell ++ ++ * friend.c (do_friend): Don't resolve scopes when processing ++ template declarations, even if the qualifying scope doesn't ++ involve template parameters. ++ ++2000-01-10 Mark Mitchell ++ ++ * class.c (dfs_modify_vtables_queue_p): Remove. ++ (modify_all_vtables): Use dfs_unmarked_real_bases_queue_p ++ and dfs_marked_real_bases_queue_p instead of ++ dfs_modify_vtables_queue_p. ++ ++ * class.c (build_vbase_path): Simplify. ++ (dfs_propagate_binfo_offsets): New function. ++ (propagate_binfo_offsets): Use it. ++ (remove_base_field): Simplify. ++ (dfs_set_offset_for_vbases): Remove. ++ (dfs_set_offset_for_shared_vbases): New function. ++ (dfs_set_offset_for_unshared_vbases): Likewise. ++ (layout_virtual_bases): Use them. ++ (layout_basetypes): Don't call propagate_binfo_offsets. ++ * search.c (dfs_get_vbase_types): Clone completely fresh binfos ++ for the vbases. ++ ++ * class.c (build_base_field): New function, split out from ... ++ (build_base_fields): ... here. Use it. Allocate primary bases ++ first, under the new ABI. ++ (get_vtable_entry): Remove. ++ (remove_base_field): New function, split out from ... ++ (remove_base_fields): ... here. Adjust since primary bases come ++ first under the new ABI. ++ ++ * cp-tree.h (expand_direct_vtbls_init): Remove declaration. ++ (initialize_vtbl_ptrs): New function. ++ (expand_indirect_vtbls_init): Change prototype. ++ (convert_pointer_to_vbase): Declare. ++ * init.c (expand_direct_vtbls_init): Remove. ++ (dfs_initialize_vtbl_ptrs): New function. ++ (initialize_vtbl_ptrs): Likewise. ++ (emit_base_init): Use initialize_vtbl_ptrs. ++ * search.c (convert_pointer_to_vbase): Make it global. ++ (expand_indirect_vtbls_init): Remove vtable initialization code. ++ * semantics.c (setup_vtbl_ptr): Use initialize_vtbl_ptrs. ++ ++ * class.c (dfs_finish_vtbls): New function. ++ (finish_vtbls): Use it. ++ (dump_class_hierarchy): New function. ++ ++ * cp-tree.h (BINFO_PRIMARY_MARKED_P): Change definition. ++ (BINFO_VBASE_PRIMARY_P): New macro. ++ (BINFO_VIRTUALS): Add to documentation. ++ (SET_BINFO_PRIMARY_MARKED_P): Remove. ++ (CLEAR_BINFO_PRIMARY_MARKED_P): Likewise. ++ (dfs_mark_primary_bases_queue_p): Likewise. ++ (dfs_unmarked_real_bases_queue_p): New function. ++ (dfs_marked_real_bases_queue_p): Likewise. ++ * search.c (dfs_mark_primary_bases): Adjust. ++ (mark_primary_bases): Likewise. ++ (get_shared_vbase_if_not_primary): New function. ++ (dfs_unmarked_real_bases_queue_p): Likewise. ++ (dfs_marked_real_bases_queue_p): Likewise. ++ (dfs_get_pure_virtuals): Simplify. ++ (get_pure_virtuals): Likewise. ++ ++2000-01-10 Kaveh R. Ghazi ++ ++ * lex.c: Include tm_p.h. ++ ++2000-01-07 Nathan Sidwell ++ ++ * lang-specs.h (__GXX_ABI_VERSION): New preprocessor macro. ++ ++2000-01-06 Jason Merrill ++ ++ * decl2.c (comdat_linkage): Don't set DECL_DEFER_OUTPUT. ++ * pt.c (instantiate_decl): Defer comdat templates that might not be ++ needed. ++ ++ * cp-tree.h (DECL_NEEDED_P): Also true if !DECL_COMDAT. ++ * decl2.c (finish_vtable_vardecl): Don't check !DECL_COMDAT. ++ (finish_file): Likewise. ++ ++ * decl2.c (import_export_class): Undo 12/14 change. ++ ++ * error.c (dump_decl): operator new, not operatornew. ++ ++ * class.c (field_decl_cmp): A nontype is "greater" than a type. ++ * search.c (lookup_field_1): Look for the last field with the ++ desired name. ++ ++2000-01-05 Nathan Sidwell ++ ++ * decl2.c (lookup_arg_dependent): Deal with FNS not being a ++ FUNCTION_DECL. ++ ++2000-01-05 Nathan Sidwell ++ ++ * typeck.c (build_static_cast): Don't strip target qualifiers ++ when casting from a class. ++ ++2000-01-04 Kaveh R. Ghazi ++ ++ * class.c (warn_hidden): Initialize variable `fndecl'. ++ ++2000-01-03 Ulrich Drepper ++ ++ * decl.c (flag_isoc9x): New variable to be able to use code in ++ c-common.c. For now always zero. ++ ++2000-01-03 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_VBASECLASSES): Improve documentation. ++ * class.c (layout_basetypes): Don't set BINFO_INHERITANCE_CHAIN ++ or unshare_base_binfos for virtual bases here. ++ * search.c (dfs_get_vbase_types): Do it here. ++ (get_vbase_types): Adjust. ++ ++2000-01-02 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_VFIELDS): Move definition. ++ (BINFO_PRIMARY_MARKED_P): Use flag 5. ++ (SET_BINFO_PRIMARY_MARKED_P): Likewise. ++ (CLEAR_BINFO_PRIMARY_MARKED_P): Likewise. ++ (unmark_primary_bases): Remove declaration. ++ (unmarkedp): Declare. ++ (dfs_vbase_unmark): Likewise. ++ * class.c (determine_primary_base): Return immediately if there ++ are no base classes. Call mark_primary_bases here. ++ (modify_all_direct_vtables): Remove. ++ (modify_all_indirect_vtables): Remove. ++ (dfs_modify_vtables_queue_p): New function. ++ (dfs_modify_vtables): New function. ++ (modify_all_vtables): Use them. ++ (build_base_fields): Build FIELD_DECLs for primary virtual base ++ classes. ++ (create_vtable_ptr): Don't call determine_primary_base here. ++ (dfs_mark_primary_bases_and_set_vbase_offsets): Rename to ... ++ (dfs_set_offset_for_vbases): ... this. ++ (layout_virtual_bases): Use it. ++ (layout_class_type): Call determine_primary_base here. ++ * search.c (unmarkedp): Make it global. ++ (shared_marked_p): Simplify. ++ (shared_unmarked_p): Likewise. ++ (dfs_primary_bases_queue_p): Remove. ++ (dfs_unmark_primary_bases): Likewise. ++ (unmark_primary_bases): Likewise. ++ (mark_primary_bases): Simplify. ++ (get_pure_virtuals): Don't call mark_primary_bases here. ++ (dfs_vbase_unmark): New function. ++ (get_vbase_types): Simplify. ++ ++ * class.c (struct base_info): Remove. ++ (determine_primary_base): Take has_virtual_p rather than a ++ base_info as input. Don't calculate max_has_virtual. ++ (finish_struct_bits): Remove max_has_virtual argument. ++ (create_vtable_ptr): Remove max_has_virtual_p argument. ++ (layout_virtual_bases): Remove max argument. ++ (layout_basetypes): Likewise. ++ (layout_class_type): Remove max_has_virtual_p argument. ++ (finish_struct_1): Remove max_has_virtual. ++ ++ * cp-tree.h (dfs_mark_primary_bases_queue_p): New function. ++ (layout_basetypes): Remove. ++ * class.c (propagate_binfo_offsets): Moved here from tree.c. ++ Update to handle primary virtual bases. ++ (remove_base_fields): New function, split out from ++ layout_basetypes. ++ (dfs_mark_primary_bases_and_set_vbase_offsets): New function. ++ (layout_virtual_bases): New function, split out from ++ layout_basetypes. Update to handle primary virtual bases. ++ (layout_basetypes): Moved here from tree.c. Use ++ remove_base_fields and layout_virtual_bases. ++ * search.c (dfs_mark_primary_bases_queue_p): New function. ++ (mark_primary_bases): Use it. ++ * tree.c (CEIL): Remove. ++ (propagate_binfo_offsets): Remove. ++ (layout_basetypes): Remove. ++ ++2000-01-01 Mark Mitchell ++ ++ * cp-tree.h (CLASSTYPE_N_BASECLASSES): Use BINFO_N_BASETYPES. ++ (BINFO_PRIMARY_MARKED_P): New macro. ++ (SET_BINFO_PRIMARY_MARKED_P): Likewise. ++ (CLEAR_BINFO_PRIMARY_MARKED_P): Likewise. ++ (mark_primary_bases): New function. ++ (unmark_primary_bases): Likewise. ++ * search.c (get_abstract_virtuals_1): Remove. ++ (dfs_mark_primary_bases): New function. ++ (mark_primary_bases): Likewise. ++ (dfs_unmark_primary_bases): Likewise. ++ (unmark_primary_bases): Likewise. ++ (dfs_get_pure_virtuals): Likewise. ++ ++2000-01-01 Mark Mitchell ++ ++ * cp-tree.h (skip_rtti_stuff): Adjust prototype. ++ * class.c (skip_rtti_stuff): Reorganize parameters and return value. ++ (modify_one_vtable): Adjust. ++ (fixup_vtable_deltas1): Likewise. ++ (override_one_vtable): Likewise. ++ * search.c (get_abstract_virtuals_1): Likewise. ++ (get_pure_virtuals): Likewise. ++ (expand_upcast_fixups): Likewise. ++ * tree.c (debug_binfo): Likewise. ++ ++ * class.c (build_vtable): Don't return a value. Don't rebuild ++ vtables for bases that have already been handled. ++ (prepare_fresh_vtable): Don't rebuild vtables for bases that have ++ already been handled. ++ (modify_one_vtable): Adjust accordingly. ++ (fixup_vtable_deltas1): Likewise. ++ (finish_struct_1): Likewise. ++ ++2000-01-01 Martin v. Löwis ++ ++ * call.c (build_new_method_call): Also check destructors. ++ ++See ChangeLog.2 for earlier changes. +diff -NBaur gcc-3.4.4/gcc/cp/ChangeLog.egcs gcc-3.4.4-new/gcc/cp/ChangeLog.egcs +--- gcc-3.4.4/gcc/cp/ChangeLog.egcs Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/ChangeLog.egcs Wed Dec 16 21:15:00 1998 +@@ -0,0 +1,4 @@ ++Wed Sep 10 16:39:26 1997 Jim Wilson ++ ++ * Make-lang.in (LN, LN_S): New macros, use where appropriate. ++ +diff -NBaur gcc-3.4.4/gcc/cp/Make-lang.in gcc-3.4.4-new/gcc/cp/Make-lang.in +--- gcc-3.4.4/gcc/cp/Make-lang.in Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/Make-lang.in Mon Aug 23 19:03:06 2004 +@@ -0,0 +1,271 @@ ++# Top level -*- makefile -*- fragment for GNU C++. ++# Copyright (C) 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003 ++# Free Software Foundation, Inc. ++ ++#This file is part of GCC. ++ ++#GCC is free software; you can redistribute it and/or modify ++#it under the terms of the GNU General Public License as published by ++#the Free Software Foundation; either version 2, or (at your option) ++#any later version. ++ ++#GCC is distributed in the hope that it will be useful, ++#but WITHOUT ANY WARRANTY; without even the implied warranty of ++#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++#GNU General Public License for more details. ++ ++#You should have received a copy of the GNU General Public License ++#along with GCC; see the file COPYING. If not, write to ++#the Free Software Foundation, 59 Temple Place - Suite 330, ++#Boston, MA 02111-1307, USA. ++ ++# This file provides the language dependent support in the main Makefile. ++# Each language makefile fragment must provide the following targets: ++# ++# foo.all.build, foo.all.cross, foo.start.encap, foo.rest.encap, ++# foo.install-normal, foo.install-common, foo.install-man, ++# foo.uninstall, ++# foo.mostlyclean, foo.clean, foo.distclean, ++# foo.maintainer-clean, foo.stage1, foo.stage2, foo.stage3, foo.stage4 ++# ++# where `foo' is the name of the language. ++# ++# It should also provide rules for: ++# ++# - making any compiler driver (eg: g++) ++# - the compiler proper (eg: cc1plus) ++# - define the names for selecting the language in LANGUAGES. ++ ++# Actual names to use when installing a native compiler. ++CXX_INSTALL_NAME := $(shell echo c++|sed '$(program_transform_name)') ++GXX_INSTALL_NAME := $(shell echo g++|sed '$(program_transform_name)') ++CXX_TARGET_INSTALL_NAME := $(target_noncanonical)-$(shell echo c++|sed '$(program_transform_name)') ++GXX_TARGET_INSTALL_NAME := $(target_noncanonical)-$(shell echo g++|sed '$(program_transform_name)') ++ ++# ++# Define the names for selecting c++ in LANGUAGES. ++# Note that it would be nice to move the dependency on g++ ++# into the C++ rule, but that needs a little bit of work ++# to do the right thing within all.cross. ++C++ c++: cc1plus$(exeext) ++ ++# Tell GNU make to ignore these if they exist. ++.PHONY: C++ c++ ++ ++g++spec.o: $(srcdir)/cp/g++spec.c $(SYSTEM_H) coretypes.h $(TM_H) $(GCC_H) $(CONFIG_H) ++ (SHLIB_LINK='$(SHLIB_LINK)' \ ++ SHLIB_MULTILIB='$(SHLIB_MULTILIB)'; \ ++ $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(DRIVER_DEFINES) \ ++ $(INCLUDES) $(srcdir)/cp/g++spec.c) ++ ++# Create the compiler driver for g++. ++GXX_OBJS = gcc.o g++spec.o intl.o prefix.o version.o ++g++$(exeext): $(GXX_OBJS) $(EXTRA_GCC_OBJS) $(LIBDEPS) ++ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ \ ++ $(GXX_OBJS) $(EXTRA_GCC_OBJS) $(LIBS) ++ ++# Create a version of the g++ driver which calls the cross-compiler. ++g++-cross$(exeext): g++$(exeext) ++ -rm -f g++-cross$(exeext) ++ cp g++$(exeext) g++-cross$(exeext) ++ ++# The compiler itself. ++# Shared with C front end: ++CXX_C_OBJS = attribs.o c-common.o c-format.o c-pragma.o c-semantics.o c-lex.o \ ++ c-dump.o $(CXX_TARGET_OBJS) c-pretty-print.o c-opts.o c-pch.o \ ++ c-incpath.o cppdefault.o c-ppoutput.o c-cppbuiltin.o prefix.o ++ ++# Language-specific object files. ++CXX_OBJS = cp/call.o cp/decl.o cp/expr.o cp/pt.o cp/typeck2.o \ ++ cp/class.o cp/decl2.o cp/error.o cp/lex.o cp/parser.o cp/ptree.o cp/rtti.o \ ++ cp/typeck.o cp/cvt.o cp/except.o cp/friend.o cp/init.o cp/method.o \ ++ cp/search.o cp/semantics.o cp/tree.o cp/repo.o cp/dump.o cp/optimize.o \ ++ cp/mangle.o cp/cp-lang.o cp/name-lookup.o cp/cxx-pretty-print.o ++ ++# Use strict warnings for this front end. ++cp-warn = $(STRICT_WARN) $(WERROR) ++ ++cc1plus$(exeext): $(CXX_OBJS) $(CXX_C_OBJS) $(BACKEND) \ ++ libcpp.a $(LIBDEPS) ++ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ \ ++ $(CXX_OBJS) $(CXX_C_OBJS) $(BACKEND) libcpp.a $(LIBS) ++ ++# Special build rules. ++$(srcdir)/cp/cfns.h: $(srcdir)/cp/cfns.gperf ++ gperf -o -C -E -k '1-6,$$' -j1 -D -N 'libc_name_p' -L ANSI-C \ ++ $(srcdir)/cp/cfns.gperf > $(srcdir)/cp/cfns.h ++ ++gtype-cp.h gt-cp-call.h gt-cp-decl.h gt-cp-decl2.h : s-gtype; @true ++gt-cp-pt.h gt-cp-repo.h gt-cp-parser.h gt-cp-method.h : s-gtype; @true ++gt-cp-tree.h gt-cp-mangle.h gt-cp-name-lookup.h: s-gtype; @true ++ ++# ++# Build hooks: ++ ++c++.all.build: g++$(exeext) ++c++.all.cross: g++-cross$(exeext) ++c++.start.encap: g++$(exeext) ++c++.rest.encap: ++c++.info: ++c++.srcinfo: ++c++.srcextra: ++ ++c++.tags: force ++ cd $(srcdir)/cp; etags -o TAGS.sub *.c *.h --language=none \ ++ --regex='/DEFTREECODE [(]\([A-Z_]+\)/\1/' cp-tree.def; \ ++ etags --include TAGS.sub --include ../TAGS.sub ++ ++c++.man: doc/g++.1 ++ ++c++.srcman: doc/g++.1 ++ -cp -p $^ $(srcdir)/doc ++ ++check-c++ : check-g++ ++lang_checks += check-g++ ++ ++# ++# Install hooks: ++# cc1plus is installed elsewhere as part of $(COMPILERS). ++ ++# Nothing to do here. ++c++.install-normal: ++ ++# Install the driver program as $(target)-g++ ++# and also as either g++ (if native) or $(tooldir)/bin/g++. ++c++.install-common: installdirs ++ -rm -f $(DESTDIR)$(bindir)/$(GXX_INSTALL_NAME)$(exeext) ++ -$(INSTALL_PROGRAM) g++$(exeext) $(DESTDIR)$(bindir)/$(GXX_INSTALL_NAME)$(exeext) ++ -chmod a+x $(DESTDIR)$(bindir)/$(GXX_INSTALL_NAME)$(exeext) ++ -rm -f $(DESTDIR)$(bindir)/$(CXX_INSTALL_NAME)$(exeext) ++ -( cd $(DESTDIR)$(bindir) && \ ++ $(LN) $(GXX_INSTALL_NAME)$(exeext) $(CXX_INSTALL_NAME)$(exeext) ) ++ -if [ -f cc1plus$(exeext) ] ; then \ ++ if [ -f g++-cross$(exeext) ] ; then \ ++ if [ -d $(DESTDIR)$(gcc_tooldir)/bin/. ] ; then \ ++ rm -f $(DESTDIR)$(gcc_tooldir)/bin/g++$(exeext); \ ++ $(INSTALL_PROGRAM) g++-cross$(exeext) $(DESTDIR)$(gcc_tooldir)/bin/g++$(exeext); \ ++ rm -f $(DESTDIR)$(gcc_tooldir)/bin/c++$(exeext); \ ++ ( cd $(DESTDIR)$(gcc_tooldir)/bin && \ ++ $(LN) g++$(exeext) c++$(exeext) ); \ ++ else true; fi; \ ++ else \ ++ rm -f $(DESTDIR)$(bindir)/$(GXX_TARGET_INSTALL_NAME)$(exeext); \ ++ ( cd $(DESTDIR)$(bindir) && \ ++ $(LN) $(GXX_INSTALL_NAME)$(exeext) $(GXX_TARGET_INSTALL_NAME)$(exeext) ); \ ++ rm -f $(DESTDIR)$(bindir)/$(CXX_TARGET_INSTALL_NAME)$(exeext); \ ++ ( cd $(DESTDIR)$(bindir) && \ ++ $(LN) $(CXX_INSTALL_NAME)$(exeext) $(CXX_TARGET_INSTALL_NAME)$(exeext) ); \ ++ fi ; \ ++ fi ++ ++# We can't use links because not everyone supports them, and we can't use ++# .so because Irix 6.5 doesn't support them. So just copy the manpage. ++doc/g++.1: doc/gcc.1 ++ cp doc/gcc.1 doc/g++.1 ++ ++c++.install-man: installdirs $(DESTDIR)$(man1dir)/$(GXX_INSTALL_NAME)$(man1ext) ++ ++$(DESTDIR)$(man1dir)/$(GXX_INSTALL_NAME)$(man1ext): doc/g++.1 ++ -rm -f $@ ++ -$(INSTALL_DATA) $< $@ ++ -chmod a-x $@ ++ ++c++.uninstall: ++ -rm -rf $(DESTDIR)$(bindir)/$(CXX_INSTALL_NAME)$(exeext) ++ -rm -rf $(DESTDIR)$(bindir)/$(GXX_INSTALL_NAME)$(exeext) ++ -rm -rf $(DESTDIR)$(man1dir)/$(GXX_INSTALL_NAME)$(man1ext) ++# ++# Clean hooks: ++# A lot of the ancillary files are deleted by the main makefile. ++# We just have to delete files specific to us. ++ ++c++.mostlyclean: ++ -rm -f doc/g++.1 ++ -rm -f cp/*$(objext) ++ -rm -f cp/*$(coverageexts) ++c++.clean: ++c++.distclean: ++ -rm -f cp/config.status cp/Makefile ++c++.maintainer-clean: ++# ++# Stage hooks: ++# The main makefile has already created stage?/cp. ++ ++c++.stage1: stage1-start ++ -mv cp/*$(objext) stage1/cp ++c++.stage2: stage2-start ++ -mv cp/*$(objext) stage2/cp ++c++.stage3: stage3-start ++ -mv cp/*$(objext) stage3/cp ++c++.stage4: stage4-start ++ -mv cp/*$(objext) stage4/cp ++c++.stageprofile: stageprofile-start ++ -mv cp/*$(objext) stageprofile/cp ++c++.stagefeedback: stagefeedback-start ++ -mv cp/*$(objext) stagefeedback/cp ++ ++# ++# .o: .h dependencies. ++CXX_TREE_H = $(TREE_H) cp/name-lookup.h cp/cp-tree.h c-common.h \ ++ cp/cp-tree.def c-common.def \ ++ function.h varray.h $(SYSTEM_H) coretypes.h $(CONFIG_H) $(TARGET_H) \ ++ $(GGC_H) \ ++ $(srcdir)/../include/hashtab.h $(srcdir)/../include/splay-tree.h ++ ++CXX_PRETTY_PRINT_H = cp/cxx-pretty-print.h $(C_PRETTY_PRINT_H) ++ ++cp/lex.o: cp/lex.c $(CXX_TREE_H) $(TM_H) flags.h cp/lex.h \ ++ c-pragma.h toplev.h output.h input.h cp/operators.def $(TM_P_H) ++cp/cp-lang.o: cp/cp-lang.c $(CXX_TREE_H) $(TM_H) toplev.h langhooks.h \ ++ $(LANGHOOKS_DEF_H) c-common.h $(CXX_PRETTY_PRINT_H) $(DIAGNOSTIC_H) ++cp/decl.o: cp/decl.c $(CXX_TREE_H) $(TM_H) flags.h cp/lex.h cp/decl.h stack.h \ ++ output.h $(EXPR_H) except.h toplev.h $(HASHTAB_H) $(RTL_H) \ ++ cp/operators.def $(TM_P_H) tree-inline.h diagnostic.h c-pragma.h \ ++ debug.h gt-cp-decl.h gtype-cp.h timevar.h ++cp/decl2.o: cp/decl2.c $(CXX_TREE_H) $(TM_H) flags.h cp/lex.h cp/decl.h $(EXPR_H) \ ++ output.h except.h toplev.h $(RTL_H) c-common.h gt-cp-decl2.h cgraph.h ++cp/typeck2.o: cp/typeck2.c $(CXX_TREE_H) $(TM_H) flags.h toplev.h output.h $(TM_P_H) \ ++ diagnostic.h ++cp/typeck.o: cp/typeck.c $(CXX_TREE_H) $(TM_H) flags.h $(RTL_H) $(EXPR_H) toplev.h \ ++ diagnostic.h convert.h ++cp/class.o: cp/class.c $(CXX_TREE_H) $(TM_H) flags.h toplev.h $(RTL_H) $(TARGET_H) convert.h ++cp/call.o: cp/call.c $(CXX_TREE_H) $(TM_H) flags.h toplev.h $(RTL_H) $(EXPR_H) \ ++ diagnostic.h intl.h gt-cp-call.h convert.h target.h ++cp/friend.o: cp/friend.c $(CXX_TREE_H) $(TM_H) flags.h $(RTL_H) toplev.h $(EXPR_H) ++cp/init.o: cp/init.c $(CXX_TREE_H) $(TM_H) flags.h $(RTL_H) $(EXPR_H) toplev.h \ ++ except.h ++cp/method.o: cp/method.c $(CXX_TREE_H) $(TM_H) toplev.h $(RTL_H) $(EXPR_H) \ ++ $(TM_P_H) $(TARGET_H) gt-cp-method.h ++cp/cvt.o: cp/cvt.c $(CXX_TREE_H) $(TM_H) cp/decl.h flags.h toplev.h convert.h ++cp/search.o: cp/search.c $(CXX_TREE_H) $(TM_H) stack.h flags.h toplev.h $(RTL_H) ++cp/tree.o: cp/tree.c $(CXX_TREE_H) $(TM_H) flags.h toplev.h $(RTL_H) \ ++ insn-config.h integrate.h tree-inline.h real.h gt-cp-tree.h $(TARGET_H) ++cp/ptree.o: cp/ptree.c $(CXX_TREE_H) $(TM_H) ++cp/rtti.o: cp/rtti.c $(CXX_TREE_H) $(TM_H) flags.h toplev.h convert.h ++cp/except.o: cp/except.c $(CXX_TREE_H) $(TM_H) flags.h $(RTL_H) except.h toplev.h \ ++ cp/cfns.h $(EXPR_H) libfuncs.h tree-inline.h ++cp/expr.o: cp/expr.c $(CXX_TREE_H) $(TM_H) $(RTL_H) flags.h $(EXPR_H) toplev.h \ ++ except.h $(TM_P_H) ++cp/pt.o: cp/pt.c $(CXX_TREE_H) $(TM_H) cp/decl.h cp/lex.h \ ++ toplev.h $(RTL_H) except.h tree-inline.h gt-cp-pt.h ++cp/error.o: cp/error.c $(CXX_TREE_H) $(TM_H) toplev.h $(DIAGNOSTIC_H) \ ++ flags.h real.h $(LANGHOOKS_DEF_H) $(CXX_PRETTY_PRINT_H) ++cp/repo.o: cp/repo.c $(CXX_TREE_H) $(TM_H) toplev.h diagnostic.h \ ++ gt-cp-repo.h ++cp/semantics.o: cp/semantics.c $(CXX_TREE_H) $(TM_H) cp/lex.h except.h toplev.h \ ++ flags.h debug.h output.h $(RTL_H) $(TIMEVAR_H) $(EXPR_H) \ ++ tree-inline.h cgraph.h ++cp/dump.o: cp/dump.c $(CXX_TREE_H) $(TM_H) tree-dump.h ++cp/optimize.o: cp/optimize.c $(CXX_TREE_H) $(TM_H) rtl.h integrate.h insn-config.h \ ++ input.h $(PARAMS_H) debug.h tree-inline.h ++cp/mangle.o: cp/mangle.c $(CXX_TREE_H) $(TM_H) toplev.h real.h gt-cp-mangle.h \ ++ $(TARGET_H) $(TM_P_H) ++ ++cp/parser.o: cp/parser.c $(CXX_TREE_H) $(TM_H) diagnostic.h gt-cp-parser.h output.h ++ ++cp/name-lookup.o: cp/name-lookup.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ ++ $(TM_H) $(CXX_TREE_H) timevar.h gt-cp-name-lookup.h toplev.h \ ++ $(DIAGNOSTIC_H) flags.h ++ ++cp/cxx-pretty-print.o: cp/cxx-pretty-print.c $(CXX_PRETTY_PRINT_H) \ ++ $(CONFIG_H) $(SYSTEM_H) $(TM_H) coretypes.h $(CXX_TREE_H) +diff -NBaur gcc-3.4.4/gcc/cp/NEWS gcc-3.4.4-new/gcc/cp/NEWS +--- gcc-3.4.4/gcc/cp/NEWS Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/NEWS Sat Aug 16 14:49:27 2003 +@@ -0,0 +1,401 @@ ++*** Changes in GCC 3.4: ++ ++* Changes in GCC 3.4 are described in 'gcc-3.4/changes.html' ++ ++*** Changes in GCC 3.3: ++ ++* The "new X = 3" extension has been removed; you must now use "new X(3)". ++ ++* G++ no longer allows in-class initializations of static data members ++ that do not have arithmetic or enumeration type. For example: ++ ++ struct S { ++ static const char* const p = "abc"; ++ }; ++ ++ is no longer accepted. ++ ++ Use the standards-conformant form: ++ ++ struct S { ++ static const char* const p; ++ }; ++ ++ const char* const S::p = "abc"; ++ ++ instead. ++ ++ (ISO C++ is even stricter; it does not allow in-class ++ initializations of floating-point types.) ++ ++*** Changes in GCC 3.1: ++ ++* -fhonor-std and -fno-honor-std have been removed. -fno-honor-std was ++ a workaround to allow std compliant code to work with the non-std ++ compliant libstdc++-v2. libstdc++-v3 is std compliant. ++ ++* The C++ ABI has been fixed so that `void (A::*)() const' is mangled as ++ "M1AKFvvE", rather than "MK1AFvvE" as before. This change only affects ++ pointer to cv-qualified member function types. ++ ++* The C++ ABI has been changed to correctly handle this code: ++ ++ struct A { ++ void operator delete[] (void *, size_t); ++ }; ++ ++ struct B : public A { ++ }; ++ ++ new B[10]; ++ ++ The amount of storage allocated for the array will be greater than ++ it was in 3.0, in order to store the number of elements in the ++ array, so that the correct size can be passed to `operator delete[]' ++ when the array is deleted. Previously, the value passed to ++ `operator delete[]' was unpredictable. ++ ++ This change will only affect code that declares a two-argument ++ `operator delete[]' with a second parameter of type `size_t' ++ in a base class, and does not override that definition in a ++ derived class. ++ ++* The C++ ABI has been changed so that: ++ ++ struct A { ++ void operator delete[] (void *, size_t); ++ void operator delete[] (void *); ++ }; ++ ++ does not cause unnecessary storage to be allocated when an array of ++ `A' objects is allocated. ++ ++ This change will only affect code that declares both of these ++ forms of `operator delete[]', and declared the two-argument form ++ before the one-argument form. ++ ++* The C++ ABI has been changed so that when a parameter is passed by value, ++ any cleanup for that parameter is performed in the caller, as specified ++ by the ia64 C++ ABI, rather than the called function as before. As a ++ result, classes with a non-trivial destructor but a trivial copy ++ constructor will be passed and returned by invisible reference, rather ++ than by bitwise copy as before. ++ ++* G++ now supports the "named return value optimization": for code like ++ ++ A f () { ++ A a; ++ ... ++ return a; ++ } ++ ++ G++ will allocate 'a' in the return value slot, so that the return ++ becomes a no-op. For this to work, all return statements in the function ++ must return the same variable. ++ ++*** Changes in GCC 3.0: ++ ++* Support for guiding declarations has been removed. ++ ++* G++ now supports importing member functions from base classes with a ++ using-declaration. ++ ++* G++ now enforces access control for nested types. ++ ++* In some obscure cases, functions with the same type could have the ++ same mangled name. This bug caused compiler crashes, link-time clashes, ++ and debugger crashes. Fixing this bug required breaking ABI ++ compatibility for the functions involved. The functions in questions ++ are those whose types involve non-type template arguments whose ++ mangled representations require more than one digit. ++ ++* Support for assignment to `this' has been removed. This idiom ++ was used in the very early days of C++, before users were allowed ++ to overload `operator new'; it is no longer allowed by the C++ ++ standard. ++ ++* Support for signatures, a G++ extension, have been removed. ++ ++* Certain invalid conversions that were previously accepted will now ++ be rejected. For example, assigning function pointers of one type ++ to function pointers of another type now requires a cast, whereas ++ previously g++ would sometimes accept the code even without the ++ cast. ++ ++* G++ previously allowed `sizeof (X::Y)' where Y was a non-static ++ member of X, even if the `sizeof' expression occurred outside ++ of a non-static member function of X (or one of its derived classes, ++ or a member-initializer for X or one of its derived classes.) This ++ extension has been removed. ++ ++* G++ no longer allows you to overload the conditional operator (i.e., ++ the `?:' operator.) ++ ++* The "named return value" extension: ++ ++ int f () return r { r = 3; } ++ ++ has been deprecated, and will be removed in a future version of G++. ++ ++*** Changes in GCC 2.95: ++ ++* Messages about non-conformant code that we can still handle ("pedwarns") ++ are now errors by default, rather than warnings. This can be reverted ++ with -fpermissive, and is overridden by -pedantic or -pedantic-errors. ++ ++* String constants are now of type `const char[n]', rather than `char[n]'. ++ This can be reverted with -fno-const-strings. ++ ++* References to functions are now supported. ++ ++* Lookup of class members during class definition now works in all cases. ++ ++* In overload resolution, type conversion operators are now properly ++ treated as always coming from the most derived class. ++ ++* C9x-style restricted pointers are supported, using the `__restrict' ++ keyword. ++ ++* You can now use -fno-implicit-inline-templates to suppress writing out ++ implicit instantiations of inline templates. Normally we do write them ++ out, even with -fno-implicit-templates, so that optimization doesn't ++ affect which instantiations are needed. ++ ++* -fstrict-prototype now also suppresses implicit declarations. ++ ++* Many obsolete options have been removed: -fall-virtual, -fmemoize-lookups, ++ -fsave-memoized, +e?, -fenum-int-equivalence, -fno-nonnull-objects. ++ ++* Unused virtual functions can be discarded on some targets by specifying ++ -ffunction-sections -fvtable-gc to the compiler and --gc-sections to the ++ linker. Unfortunately, this only works on Linux if you're linking ++ statically. ++ ++* Lots of bugs stomped. ++ ++*** Changes in EGCS 1.1: ++ ++* Namespaces are fully supported. The library has not yet been converted ++ to use namespace std, however, and the old std-faking code is still on by ++ default. To turn it off, you can use -fhonor-std. ++ ++* Massive template improvements: ++ + member template classes are supported. ++ + template friends are supported. ++ + template template parameters are supported. ++ + local classes in templates are supported. ++ + lots of bugs fixed. ++ ++* operator new now throws bad_alloc where appropriate. ++ ++* Exception handling is now thread safe, and supports nested exceptions and ++ placement delete. Exception handling overhead on x86 is much lower with ++ GNU as 2.9. ++ ++* protected virtual inheritance is now supported. ++ ++* Loops are optimized better; we now move the test to the end in most ++ cases, like the C frontend does. ++ ++* For class D derived from B which has a member 'int i', &D::i is now of ++ type 'int B::*' instead of 'int D::*'. ++ ++* An _experimental_ new ABI for g++ can be turned on with -fnew-abi. The ++ current features of this are more efficient allocation of base classes ++ (including the empty base optimization), and more compact mangling of C++ ++ symbol names (which can be turned on separately with -fsquangle). This ++ ABI is subject to change without notice, so don't use it for anything ++ that you don't want to rebuild with every release of the compiler. ++ ++ As with all ABI-changing flags, this flag is for experts only, as all ++ code (including the library code in libgcc and libstdc++) must be ++ compiled with the same ABI. ++ ++*** Changes in EGCS 1.0: ++ ++* A public review copy of the December 1996 Draft of the ISO/ANSI C++ ++ standard is now available. See ++ ++ http://www.cygnus.com/misc/wp/ ++ ++ for more information. ++ ++* g++ now uses a new implementation of templates. The basic idea is that ++ now templates are minimally parsed when seen and then expanded later. ++ This allows conformant early name binding and instantiation controls, ++ since instantiations no longer have to go through the parser. ++ ++ What you get: ++ ++ + Inlining of template functions works without any extra effort or ++ modifications. ++ + Instantiations of class templates and methods defined in the class ++ body are deferred until they are actually needed (unless ++ -fexternal-templates is specified). ++ + Nested types in class templates work. ++ + Static data member templates work. ++ + Member function templates are now supported. ++ + Partial specialization of class templates is now supported. ++ + Explicit specification of template parameters to function templates ++ is now supported. ++ ++ Things you may need to fix in your code: ++ ++ + Syntax errors in templates that are never instantiated will now be ++ diagnosed. ++ + Types and class templates used in templates must be declared ++ first, or the compiler will assume they are not types, and fail. ++ + Similarly, nested types of template type parameters must be tagged ++ with the 'typename' keyword, except in base lists. In many cases, ++ but not all, the compiler will tell you where you need to add ++ 'typename'. For more information, see ++ ++ http://www.cygnus.com/misc/wp/dec96pub/template.html#temp.res ++ ++ + Guiding declarations are no longer supported. Function declarations, ++ including friend declarations, do not refer to template instantiations. ++ You can restore the old behavior with -fguiding-decls until you fix ++ your code. ++ ++ Other features: ++ ++ + Default function arguments in templates will not be evaluated (or ++ checked for semantic validity) unless they are needed. Default ++ arguments in class bodies will not be parsed until the class ++ definition is complete. ++ + The -ftemplate-depth-NN flag can be used to increase the maximum ++ recursive template instantiation depth, which defaults to 17. If you ++ need to use this flag, the compiler will tell you. ++ + Explicit instantiation of template constructors and destructors is ++ now supported. For instance: ++ ++ template A::A(const A&); ++ ++ Still not supported: ++ ++ + Member class templates. ++ + Template friends. ++ ++* Exception handling support has been significantly improved and is on by ++ default. The compiler supports two mechanisms for walking back up the ++ call stack; one relies on static information about how registers are ++ saved, and causes no runtime overhead for code that does not throw ++ exceptions. The other mechanism uses setjmp and longjmp equivalents, and ++ can result in quite a bit of runtime overhead. You can determine which ++ mechanism is the default for your target by compiling a testcase that ++ uses exceptions and doing an 'nm' on the object file; if it uses __throw, ++ it's using the first mechanism. If it uses __sjthrow, it's using the ++ second. ++ ++ You can turn EH support off with -fno-exceptions. ++ ++* RTTI support has been rewritten to work properly and is now on by default. ++ This means code that uses virtual functions will have a modest space ++ overhead. You can use the -fno-rtti flag to disable RTTI support. ++ ++* On ELF systems, duplicate copies of symbols with 'initialized common' ++ linkage (such as template instantiations, vtables, and extern inlines) ++ will now be discarded by the GNU linker, so you don't need to use -frepo. ++ This support requires GNU ld from binutils 2.8 or later. ++ ++* The overload resolution code has been rewritten to conform to the latest ++ C++ Working Paper. Built-in operators are now considered as candidates ++ in operator overload resolution. Function template overloading chooses ++ the more specialized template, and handles base classes in type deduction ++ and guiding declarations properly. In this release the old code can ++ still be selected with -fno-ansi-overloading, although this is not ++ supported and will be removed in a future release. ++ ++* Standard usage syntax for the std namespace is supported; std is treated ++ as an alias for global scope. General namespaces are still not supported. ++ ++* New flags: ++ ++ + New warning -Wno-pmf-conversion (don't warn about ++ converting from a bound member function pointer to function ++ pointer). ++ ++ + A flag -Weffc++ has been added for violations of some of the style ++ guidelines in Scott Meyers' _Effective C++_ books. ++ ++ + -Woverloaded-virtual now warns if a virtual function in a base ++ class is hidden in a derived class, rather than warning about ++ virtual functions being overloaded (even if all of the inherited ++ signatures are overridden) as it did before. ++ ++ + -Wall no longer implies -W. The new warning flag, -Wsign-compare, ++ included in -Wall, warns about dangerous comparisons of signed and ++ unsigned values. Only the flag is new; it was previously part of ++ -W. ++ ++ + The new flag, -fno-weak, disables the use of weak symbols. ++ ++* Synthesized methods are now emitted in any translation units that need ++ an out-of-line copy. They are no longer affected by #pragma interface ++ or #pragma implementation. ++ ++* __FUNCTION__ and __PRETTY_FUNCTION__ are now treated as variables by the ++ parser; previously they were treated as string constants. So code like ++ `printf (__FUNCTION__ ": foo")' must be rewritten to ++ `printf ("%s: foo", __FUNCTION__)'. This is necessary for templates. ++ ++* local static variables in extern inline functions will be shared between ++ translation units. ++ ++* -fvtable-thunks is supported for all targets, and is the default for ++ Linux with glibc 2.x (also called libc 6.x). ++ ++* bool is now always the same size as another built-in type. Previously, ++ a 64-bit RISC target using a 32-bit ABI would have 32-bit pointers and a ++ 64-bit bool. This should only affect Irix 6, which was not supported in ++ 2.7.2. ++ ++* new (nothrow) is now supported. ++ ++* Synthesized destructors are no longer made virtual just because the class ++ already has virtual functions, only if they override a virtual destructor ++ in a base class. The compiler will warn if this affects your code. ++ ++* The g++ driver now only links against libstdc++, not libg++; it is ++ functionally identical to the c++ driver. ++ ++* (void *)0 is no longer considered a null pointer constant; NULL in ++ is now defined as __null, a magic constant of type (void *) ++ normally, or (size_t) with -ansi. ++ ++* The name of a class is now implicitly declared in its own scope; A::A ++ refers to A. ++ ++* Local classes are now supported. ++ ++* __attribute__ can now be attached to types as well as declarations. ++ ++* The compiler no longer emits a warning if an ellipsis is used as a ++ function's argument list. ++ ++* Definition of nested types outside of their containing class is now ++ supported. For instance: ++ ++ struct A { ++ struct B; ++ B* bp; ++ }; ++ ++ struct A::B { ++ int member; ++ }; ++ ++* On the HPPA, some classes that do not define a copy constructor ++ will be passed and returned in memory again so that functions ++ returning those types can be inlined. ++ ++*** The g++ team thanks everyone that contributed to this release, ++ but especially: ++ ++* Joe Buck , the maintainer of the g++ FAQ. ++* Brendan Kehoe , who coordinates testing of g++. ++* Jason Merrill , the g++ maintainer. ++* Mark Mitchell , who implemented member function ++ templates and explicit qualification of function templates. ++* Mike Stump , the previous g++ maintainer, who did most of ++ the exception handling work. +diff -NBaur gcc-3.4.4/gcc/cp/call.c gcc-3.4.4-new/gcc/cp/call.c +--- gcc-3.4.4/gcc/cp/call.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/call.c Mon May 2 00:26:21 2005 +@@ -0,0 +1,6262 @@ ++/* Functions related to invoking methods and overloaded functions. ++ Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, ++ 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. ++ Contributed by Michael Tiemann (tiemann@cygnus.com) and ++ modified by Brendan Kehoe (brendan@cygnus.com). ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++ ++/* High-level class interface. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "cp-tree.h" ++#include "output.h" ++#include "flags.h" ++#include "rtl.h" ++#include "toplev.h" ++#include "expr.h" ++#include "diagnostic.h" ++#include "intl.h" ++#include "target.h" ++#include "convert.h" ++ ++static struct z_candidate * tourney (struct z_candidate *); ++static int equal_functions (tree, tree); ++static int joust (struct z_candidate *, struct z_candidate *, bool); ++static int compare_ics (tree, tree); ++static tree build_over_call (struct z_candidate *, int); ++static tree build_java_interface_fn_ref (tree, tree); ++#define convert_like(CONV, EXPR) \ ++ convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \ ++ /*issue_conversion_warnings=*/true) ++#define convert_like_with_context(CONV, EXPR, FN, ARGNO) \ ++ convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \ ++ /*issue_conversion_warnings=*/true) ++static tree convert_like_real (tree, tree, tree, int, int, bool); ++static void op_error (enum tree_code, enum tree_code, tree, tree, ++ tree, const char *); ++static tree build_object_call (tree, tree); ++static tree resolve_args (tree); ++static struct z_candidate *build_user_type_conversion_1 (tree, tree, int); ++static void print_z_candidate (const char *, struct z_candidate *); ++static void print_z_candidates (struct z_candidate *); ++static tree build_this (tree); ++static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *); ++static bool any_strictly_viable (struct z_candidate *); ++static struct z_candidate *add_template_candidate ++ (struct z_candidate **, tree, tree, tree, tree, tree, ++ tree, tree, int, unification_kind_t); ++static struct z_candidate *add_template_candidate_real ++ (struct z_candidate **, tree, tree, tree, tree, tree, ++ tree, tree, int, tree, unification_kind_t); ++static struct z_candidate *add_template_conv_candidate ++ (struct z_candidate **, tree, tree, tree, tree, tree, tree); ++static void add_builtin_candidates ++ (struct z_candidate **, enum tree_code, enum tree_code, ++ tree, tree *, int); ++static void add_builtin_candidate ++ (struct z_candidate **, enum tree_code, enum tree_code, ++ tree, tree, tree, tree *, tree *, int); ++static bool is_complete (tree); ++static void build_builtin_candidate ++ (struct z_candidate **, tree, tree, tree, tree *, tree *, ++ int); ++static struct z_candidate *add_conv_candidate ++ (struct z_candidate **, tree, tree, tree, tree, tree); ++static struct z_candidate *add_function_candidate ++ (struct z_candidate **, tree, tree, tree, tree, tree, int); ++static tree implicit_conversion (tree, tree, tree, int); ++static tree standard_conversion (tree, tree, tree, int); ++static tree reference_binding (tree, tree, tree, int); ++static tree build_conv (enum tree_code, tree, tree); ++static bool is_subseq (tree, tree); ++static tree maybe_handle_ref_bind (tree *); ++static void maybe_handle_implicit_object (tree *); ++static struct z_candidate *add_candidate ++ (struct z_candidate **, tree, tree, tree, tree, tree, int); ++static tree source_type (tree); ++static void add_warning (struct z_candidate *, struct z_candidate *); ++static bool reference_related_p (tree, tree); ++static bool reference_compatible_p (tree, tree); ++static tree convert_class_to_reference (tree, tree, tree); ++static tree direct_reference_binding (tree, tree); ++static bool promoted_arithmetic_type_p (tree); ++static tree conditional_conversion (tree, tree); ++static char *name_as_c_string (tree, tree, bool *); ++static tree call_builtin_trap (void); ++static tree prep_operand (tree); ++static void add_candidates (tree, tree, tree, bool, tree, tree, ++ int, struct z_candidate **); ++static tree merge_conversion_sequences (tree, tree); ++static bool magic_varargs_p (tree); ++static tree build_temp (tree, tree, int, void (**)(const char *, ...)); ++static void check_constructor_callable (tree, tree); ++ ++tree ++build_vfield_ref (tree datum, tree type) ++{ ++ if (datum == error_mark_node) ++ return error_mark_node; ++ ++ if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE) ++ datum = convert_from_reference (datum); ++ ++ if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type) ++ && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type)) ++ datum = convert_to_base (datum, type, /*check_access=*/false); ++ ++ return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)), ++ datum, TYPE_VFIELD (type)); ++} ++ ++/* Returns nonzero iff the destructor name specified in NAME ++ (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many ++ forms... */ ++ ++bool ++check_dtor_name (tree basetype, tree name) ++{ ++ name = TREE_OPERAND (name, 0); ++ ++ /* Just accept something we've already complained about. */ ++ if (name == error_mark_node) ++ return true; ++ ++ if (TREE_CODE (name) == TYPE_DECL) ++ name = TREE_TYPE (name); ++ else if (TYPE_P (name)) ++ /* OK */; ++ else if (TREE_CODE (name) == IDENTIFIER_NODE) ++ { ++ if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype)) ++ || (TREE_CODE (basetype) == ENUMERAL_TYPE ++ && name == TYPE_IDENTIFIER (basetype))) ++ name = basetype; ++ else ++ name = get_type_value (name); ++ } ++ /* In the case of: ++ ++ template struct S { ~S(); }; ++ int i; ++ i.~S(); ++ ++ NAME will be a class template. */ ++ else if (DECL_CLASS_TEMPLATE_P (name)) ++ return false; ++ else ++ abort (); ++ ++ if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name)) ++ return true; ++ return false; ++} ++ ++/* We want the address of a function or method. We avoid creating a ++ pointer-to-member function. */ ++ ++tree ++build_addr_func (tree function) ++{ ++ tree type = TREE_TYPE (function); ++ ++ /* We have to do these by hand to avoid real pointer to member ++ functions. */ ++ if (TREE_CODE (type) == METHOD_TYPE) ++ { ++ if (TREE_CODE (function) == OFFSET_REF) ++ { ++ tree object = build_address (TREE_OPERAND (function, 0)); ++ return get_member_function_from_ptrfunc (&object, ++ TREE_OPERAND (function, 1)); ++ } ++ function = build_address (function); ++ } ++ else ++ function = decay_conversion (function); ++ ++ return function; ++} ++ ++/* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or ++ POINTER_TYPE to those. Note, pointer to member function types ++ (TYPE_PTRMEMFUNC_P) must be handled by our callers. */ ++ ++tree ++build_call (tree function, tree parms) ++{ ++ int is_constructor = 0; ++ int nothrow; ++ tree tmp; ++ tree decl; ++ tree result_type; ++ tree fntype; ++ ++ function = build_addr_func (function); ++ ++ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function))) ++ { ++ sorry ("unable to call pointer to member function here"); ++ return error_mark_node; ++ } ++ ++ fntype = TREE_TYPE (TREE_TYPE (function)); ++ result_type = TREE_TYPE (fntype); ++ ++ if (TREE_CODE (function) == ADDR_EXPR ++ && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) ++ decl = TREE_OPERAND (function, 0); ++ else ++ decl = NULL_TREE; ++ ++ /* We check both the decl and the type; a function may be known not to ++ throw without being declared throw(). */ ++ nothrow = ((decl && TREE_NOTHROW (decl)) ++ || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function)))); ++ ++ if (decl && TREE_THIS_VOLATILE (decl) && cfun) ++ current_function_returns_abnormally = 1; ++ ++ if (decl && TREE_DEPRECATED (decl)) ++ warn_deprecated_use (decl); ++ require_complete_eh_spec_types (fntype, decl); ++ ++ if (decl && DECL_CONSTRUCTOR_P (decl)) ++ is_constructor = 1; ++ ++ if (decl && ! TREE_USED (decl)) ++ { ++ /* We invoke build_call directly for several library functions. ++ These may have been declared normally if we're building libgcc, ++ so we can't just check DECL_ARTIFICIAL. */ ++ if (DECL_ARTIFICIAL (decl) ++ || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2)) ++ mark_used (decl); ++ else ++ abort (); ++ } ++ ++ /* Don't pass empty class objects by value. This is useful ++ for tags in STL, which are used to control overload resolution. ++ We don't need to handle other cases of copying empty classes. */ ++ if (! decl || ! DECL_BUILT_IN (decl)) ++ for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp)) ++ if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp))) ++ && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp)))) ++ { ++ tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp))); ++ TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t), ++ TREE_VALUE (tmp), t); ++ } ++ ++ function = build (CALL_EXPR, result_type, function, parms); ++ TREE_HAS_CONSTRUCTOR (function) = is_constructor; ++ TREE_NOTHROW (function) = nothrow; ++ ++ return function; ++} ++ ++/* Build something of the form ptr->method (args) ++ or object.method (args). This can also build ++ calls to constructors, and find friends. ++ ++ Member functions always take their class variable ++ as a pointer. ++ ++ INSTANCE is a class instance. ++ ++ NAME is the name of the method desired, usually an IDENTIFIER_NODE. ++ ++ PARMS help to figure out what that NAME really refers to. ++ ++ BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE ++ down to the real instance type to use for access checking. We need this ++ information to get protected accesses correct. ++ ++ FLAGS is the logical disjunction of zero or more LOOKUP_ ++ flags. See cp-tree.h for more info. ++ ++ If this is all OK, calls build_function_call with the resolved ++ member function. ++ ++ This function must also handle being called to perform ++ initialization, promotion/coercion of arguments, and ++ instantiation of default parameters. ++ ++ Note that NAME may refer to an instance variable name. If ++ `operator()()' is defined for the type of that field, then we return ++ that result. */ ++ ++/* New overloading code. */ ++ ++struct z_candidate GTY(()) { ++ /* The FUNCTION_DECL that will be called if this candidate is ++ selected by overload resolution. */ ++ tree fn; ++ /* The arguments to use when calling this function. */ ++ tree args; ++ /* The implicit conversion sequences for each of the arguments to ++ FN. */ ++ tree convs; ++ /* If FN is a user-defined conversion, the standard conversion ++ sequence from the type returned by FN to the desired destination ++ type. */ ++ tree second_conv; ++ int viable; ++ /* If FN is a member function, the binfo indicating the path used to ++ qualify the name of FN at the call site. This path is used to ++ determine whether or not FN is accessible if it is selected by ++ overload resolution. The DECL_CONTEXT of FN will always be a ++ (possibly improper) base of this binfo. */ ++ tree access_path; ++ /* If FN is a non-static member function, the binfo indicating the ++ subobject to which the `this' pointer should be converted if FN ++ is selected by overload resolution. The type pointed to the by ++ the `this' pointer must correspond to the most derived class ++ indicated by the CONVERSION_PATH. */ ++ tree conversion_path; ++ tree template; ++ tree warnings; ++ struct z_candidate *next; ++}; ++ ++#define IDENTITY_RANK 0 ++#define EXACT_RANK 1 ++#define PROMO_RANK 2 ++#define STD_RANK 3 ++#define PBOOL_RANK 4 ++#define USER_RANK 5 ++#define ELLIPSIS_RANK 6 ++#define BAD_RANK 7 ++ ++#define ICS_RANK(NODE) \ ++ (ICS_BAD_FLAG (NODE) ? BAD_RANK \ ++ : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \ ++ : ICS_USER_FLAG (NODE) ? USER_RANK \ ++ : ICS_STD_RANK (NODE)) ++ ++#define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE) ++ ++#define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE) ++#define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE) ++#define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE) ++#define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE) ++ ++/* In a REF_BIND or a BASE_CONV, this indicates that a temporary ++ should be created to hold the result of the conversion. */ ++#define NEED_TEMPORARY_P(NODE) TREE_LANG_FLAG_4 (NODE) ++ ++/* TRUE in an IDENTITY_CONV or BASE_CONV if the copy constructor must ++ be accessible, even though it is not being used. */ ++#define CHECK_COPY_CONSTRUCTOR_P(NODE) TREE_LANG_FLAG_5 (NODE) ++ ++#define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1)) ++#define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn) ++ ++/* Returns true iff T is a null pointer constant in the sense of ++ [conv.ptr]. */ ++ ++bool ++null_ptr_cst_p (tree t) ++{ ++ /* [conv.ptr] ++ ++ A null pointer constant is an integral constant expression ++ (_expr.const_) rvalue of integer type that evaluates to zero. */ ++ if (DECL_INTEGRAL_CONSTANT_VAR_P (t)) ++ t = decl_constant_value (t); ++ if (t == null_node ++ || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))) ++ return true; ++ return false; ++} ++ ++ ++/* Returns nonzero if PARMLIST consists of only default parms and/or ++ ellipsis. */ ++ ++bool ++sufficient_parms_p (tree parmlist) ++{ ++ for (; parmlist && parmlist != void_list_node; ++ parmlist = TREE_CHAIN (parmlist)) ++ if (!TREE_PURPOSE (parmlist)) ++ return false; ++ return true; ++} ++ ++static tree ++build_conv (enum tree_code code, tree type, tree from) ++{ ++ tree t; ++ int rank = ICS_STD_RANK (from); ++ ++ /* We can't use buildl1 here because CODE could be USER_CONV, which ++ takes two arguments. In that case, the caller is responsible for ++ filling in the second argument. */ ++ t = make_node (code); ++ TREE_TYPE (t) = type; ++ TREE_OPERAND (t, 0) = from; ++ ++ switch (code) ++ { ++ case PTR_CONV: ++ case PMEM_CONV: ++ case BASE_CONV: ++ case STD_CONV: ++ if (rank < STD_RANK) ++ rank = STD_RANK; ++ break; ++ ++ case QUAL_CONV: ++ if (rank < EXACT_RANK) ++ rank = EXACT_RANK; ++ ++ default: ++ break; ++ } ++ ICS_STD_RANK (t) = rank; ++ ICS_USER_FLAG (t) = (code == USER_CONV || ICS_USER_FLAG (from)); ++ ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from); ++ return t; ++} ++ ++tree ++strip_top_quals (tree t) ++{ ++ if (TREE_CODE (t) == ARRAY_TYPE) ++ return t; ++ return cp_build_qualified_type (t, 0); ++} ++ ++/* Returns the standard conversion path (see [conv]) from type FROM to type ++ TO, if any. For proper handling of null pointer constants, you must ++ also pass the expression EXPR to convert from. */ ++ ++static tree ++standard_conversion (tree to, tree from, tree expr, int flags) ++{ ++ enum tree_code fcode, tcode; ++ tree conv; ++ bool fromref = false; ++ ++ to = non_reference (to); ++ if (TREE_CODE (from) == REFERENCE_TYPE) ++ { ++ fromref = true; ++ from = TREE_TYPE (from); ++ } ++ to = strip_top_quals (to); ++ from = strip_top_quals (from); ++ ++ if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to)) ++ && expr && type_unknown_p (expr)) ++ { ++ expr = instantiate_type (to, expr, tf_conv); ++ if (expr == error_mark_node) ++ return NULL_TREE; ++ from = TREE_TYPE (expr); ++ } ++ ++ fcode = TREE_CODE (from); ++ tcode = TREE_CODE (to); ++ ++ conv = build1 (IDENTITY_CONV, from, expr); ++ ++ if (fcode == FUNCTION_TYPE) ++ { ++ from = build_pointer_type (from); ++ fcode = TREE_CODE (from); ++ conv = build_conv (LVALUE_CONV, from, conv); ++ } ++ else if (fcode == ARRAY_TYPE) ++ { ++ from = build_pointer_type (TREE_TYPE (from)); ++ fcode = TREE_CODE (from); ++ conv = build_conv (LVALUE_CONV, from, conv); ++ } ++ else if (fromref || (expr && lvalue_p (expr))) ++ conv = build_conv (RVALUE_CONV, from, conv); ++ ++ /* Allow conversion between `__complex__' data types. */ ++ if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE) ++ { ++ /* The standard conversion sequence to convert FROM to TO is ++ the standard conversion sequence to perform componentwise ++ conversion. */ ++ tree part_conv = standard_conversion ++ (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, flags); ++ ++ if (part_conv) ++ { ++ conv = build_conv (TREE_CODE (part_conv), to, conv); ++ ICS_STD_RANK (conv) = ICS_STD_RANK (part_conv); ++ } ++ else ++ conv = NULL_TREE; ++ ++ return conv; ++ } ++ ++ if (same_type_p (from, to)) ++ return conv; ++ ++ if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)) ++ && expr && null_ptr_cst_p (expr)) ++ conv = build_conv (STD_CONV, to, conv); ++ else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE ++ && TREE_CODE (TREE_TYPE (to)) == VECTOR_TYPE ++ && TREE_CODE (TREE_TYPE (from)) == VECTOR_TYPE ++ && ((*targetm.vector_opaque_p) (TREE_TYPE (to)) ++ || (*targetm.vector_opaque_p) (TREE_TYPE (from)))) ++ conv = build_conv (STD_CONV, to, conv); ++ else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE) ++ || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE)) ++ { ++ /* For backwards brain damage compatibility, allow interconversion of ++ pointers and integers with a pedwarn. */ ++ conv = build_conv (STD_CONV, to, conv); ++ ICS_BAD_FLAG (conv) = 1; ++ } ++ else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE) ++ { ++ /* For backwards brain damage compatibility, allow interconversion of ++ enums and integers with a pedwarn. */ ++ conv = build_conv (STD_CONV, to, conv); ++ ICS_BAD_FLAG (conv) = 1; ++ } ++ else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE) ++ || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from))) ++ { ++ tree to_pointee; ++ tree from_pointee; ++ ++ if (tcode == POINTER_TYPE ++ && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from), ++ TREE_TYPE (to))) ++ ; ++ else if (VOID_TYPE_P (TREE_TYPE (to)) ++ && !TYPE_PTRMEM_P (from) ++ && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE) ++ { ++ from = build_pointer_type ++ (cp_build_qualified_type (void_type_node, ++ cp_type_quals (TREE_TYPE (from)))); ++ conv = build_conv (PTR_CONV, from, conv); ++ } ++ else if (TYPE_PTRMEM_P (from)) ++ { ++ tree fbase = TYPE_PTRMEM_CLASS_TYPE (from); ++ tree tbase = TYPE_PTRMEM_CLASS_TYPE (to); ++ ++ if (DERIVED_FROM_P (fbase, tbase) ++ && (same_type_ignoring_top_level_qualifiers_p ++ (TYPE_PTRMEM_POINTED_TO_TYPE (from), ++ TYPE_PTRMEM_POINTED_TO_TYPE (to)))) ++ { ++ from = build_ptrmem_type (tbase, ++ TYPE_PTRMEM_POINTED_TO_TYPE (from)); ++ conv = build_conv (PMEM_CONV, from, conv); ++ } ++ else if (!same_type_p (fbase, tbase)) ++ return NULL; ++ } ++ else if (IS_AGGR_TYPE (TREE_TYPE (from)) ++ && IS_AGGR_TYPE (TREE_TYPE (to)) ++ /* [conv.ptr] ++ ++ An rvalue of type "pointer to cv D," where D is a ++ class type, can be converted to an rvalue of type ++ "pointer to cv B," where B is a base class (clause ++ _class.derived_) of D. If B is an inaccessible ++ (clause _class.access_) or ambiguous ++ (_class.member.lookup_) base class of D, a program ++ that necessitates this conversion is ill-formed. */ ++ /* Therefore, we use DERIVED_FROM_P, and not ++ ACESSIBLY_UNIQUELY_DERIVED_FROM_P, in this test. */ ++ && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from))) ++ { ++ from = ++ cp_build_qualified_type (TREE_TYPE (to), ++ cp_type_quals (TREE_TYPE (from))); ++ from = build_pointer_type (from); ++ conv = build_conv (PTR_CONV, from, conv); ++ } ++ ++ if (tcode == POINTER_TYPE) ++ { ++ to_pointee = TREE_TYPE (to); ++ from_pointee = TREE_TYPE (from); ++ } ++ else ++ { ++ to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to); ++ from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from); ++ } ++ ++ if (same_type_p (from, to)) ++ /* OK */; ++ else if (comp_ptr_ttypes (to_pointee, from_pointee)) ++ conv = build_conv (QUAL_CONV, to, conv); ++ else if (expr && string_conv_p (to, expr, 0)) ++ /* converting from string constant to char *. */ ++ conv = build_conv (QUAL_CONV, to, conv); ++ else if (ptr_reasonably_similar (to_pointee, from_pointee)) ++ { ++ conv = build_conv (PTR_CONV, to, conv); ++ ICS_BAD_FLAG (conv) = 1; ++ } ++ else ++ return 0; ++ ++ from = to; ++ } ++ else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from)) ++ { ++ tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from)); ++ tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to)); ++ tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn))); ++ tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn))); ++ ++ if (!DERIVED_FROM_P (fbase, tbase) ++ || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn)) ++ || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)), ++ TREE_CHAIN (TYPE_ARG_TYPES (tofn))) ++ || cp_type_quals (fbase) != cp_type_quals (tbase)) ++ return 0; ++ ++ from = cp_build_qualified_type (tbase, cp_type_quals (fbase)); ++ from = build_method_type_directly (from, ++ TREE_TYPE (fromfn), ++ TREE_CHAIN (TYPE_ARG_TYPES (fromfn))); ++ from = build_ptrmemfunc_type (build_pointer_type (from)); ++ conv = build_conv (PMEM_CONV, from, conv); ++ } ++ else if (tcode == BOOLEAN_TYPE) ++ { ++ /* [conv.bool] ++ ++ An rvalue of arithmetic, enumeration, pointer, or pointer to ++ member type can be converted to an rvalue of type bool. */ ++ if (ARITHMETIC_TYPE_P (from) ++ || fcode == ENUMERAL_TYPE ++ || fcode == POINTER_TYPE ++ || TYPE_PTR_TO_MEMBER_P (from)) ++ { ++ conv = build_conv (STD_CONV, to, conv); ++ if (fcode == POINTER_TYPE ++ || TYPE_PTRMEM_P (from) ++ || (TYPE_PTRMEMFUNC_P (from) ++ && ICS_STD_RANK (conv) < PBOOL_RANK)) ++ ICS_STD_RANK (conv) = PBOOL_RANK; ++ return conv; ++ } ++ ++ return NULL_TREE; ++ } ++ /* We don't check for ENUMERAL_TYPE here because there are no standard ++ conversions to enum type. */ ++ else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE ++ || tcode == REAL_TYPE) ++ { ++ if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)) ++ return 0; ++ conv = build_conv (STD_CONV, to, conv); ++ ++ /* Give this a better rank if it's a promotion. */ ++ if (same_type_p (to, type_promotes_to (from)) ++ && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK) ++ ICS_STD_RANK (conv) = PROMO_RANK; ++ } ++ else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE ++ && ((*targetm.vector_opaque_p) (from) ++ || (*targetm.vector_opaque_p) (to))) ++ return build_conv (STD_CONV, to, conv); ++ else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE) ++ && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from) ++ && is_properly_derived_from (from, to)) ++ { ++ if (TREE_CODE (conv) == RVALUE_CONV) ++ conv = TREE_OPERAND (conv, 0); ++ conv = build_conv (BASE_CONV, to, conv); ++ /* The derived-to-base conversion indicates the initialization ++ of a parameter with base type from an object of a derived ++ type. A temporary object is created to hold the result of ++ the conversion. */ ++ NEED_TEMPORARY_P (conv) = 1; ++ } ++ else ++ return 0; ++ ++ return conv; ++} ++ ++/* Returns nonzero if T1 is reference-related to T2. */ ++ ++static bool ++reference_related_p (tree t1, tree t2) ++{ ++ t1 = TYPE_MAIN_VARIANT (t1); ++ t2 = TYPE_MAIN_VARIANT (t2); ++ ++ /* [dcl.init.ref] ++ ++ Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related ++ to "cv2 T2" if T1 is the same type as T2, or T1 is a base class ++ of T2. */ ++ return (same_type_p (t1, t2) ++ || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2) ++ && DERIVED_FROM_P (t1, t2))); ++} ++ ++/* Returns nonzero if T1 is reference-compatible with T2. */ ++ ++static bool ++reference_compatible_p (tree t1, tree t2) ++{ ++ /* [dcl.init.ref] ++ ++ "cv1 T1" is reference compatible with "cv2 T2" if T1 is ++ reference-related to T2 and cv1 is the same cv-qualification as, ++ or greater cv-qualification than, cv2. */ ++ return (reference_related_p (t1, t2) ++ && at_least_as_qualified_p (t1, t2)); ++} ++ ++/* Determine whether or not the EXPR (of class type S) can be ++ converted to T as in [over.match.ref]. */ ++ ++static tree ++convert_class_to_reference (tree t, tree s, tree expr) ++{ ++ tree conversions; ++ tree arglist; ++ tree conv; ++ tree reference_type; ++ struct z_candidate *candidates; ++ struct z_candidate *cand; ++ bool any_viable_p; ++ ++ conversions = lookup_conversions (s); ++ if (!conversions) ++ return NULL_TREE; ++ ++ /* [over.match.ref] ++ ++ Assuming that "cv1 T" is the underlying type of the reference ++ being initialized, and "cv S" is the type of the initializer ++ expression, with S a class type, the candidate functions are ++ selected as follows: ++ ++ --The conversion functions of S and its base classes are ++ considered. Those that are not hidden within S and yield type ++ "reference to cv2 T2", where "cv1 T" is reference-compatible ++ (_dcl.init.ref_) with "cv2 T2", are candidate functions. ++ ++ The argument list has one argument, which is the initializer ++ expression. */ ++ ++ candidates = 0; ++ ++ /* Conceptually, we should take the address of EXPR and put it in ++ the argument list. Unfortunately, however, that can result in ++ error messages, which we should not issue now because we are just ++ trying to find a conversion operator. Therefore, we use NULL, ++ cast to the appropriate type. */ ++ arglist = build_int_2 (0, 0); ++ TREE_TYPE (arglist) = build_pointer_type (s); ++ arglist = build_tree_list (NULL_TREE, arglist); ++ ++ reference_type = build_reference_type (t); ++ ++ while (conversions) ++ { ++ tree fns = TREE_VALUE (conversions); ++ ++ for (; fns; fns = OVL_NEXT (fns)) ++ { ++ tree f = OVL_CURRENT (fns); ++ tree t2 = TREE_TYPE (TREE_TYPE (f)); ++ ++ cand = NULL; ++ ++ /* If this is a template function, try to get an exact ++ match. */ ++ if (TREE_CODE (f) == TEMPLATE_DECL) ++ { ++ cand = add_template_candidate (&candidates, ++ f, s, ++ NULL_TREE, ++ arglist, ++ reference_type, ++ TYPE_BINFO (s), ++ TREE_PURPOSE (conversions), ++ LOOKUP_NORMAL, ++ DEDUCE_CONV); ++ ++ if (cand) ++ { ++ /* Now, see if the conversion function really returns ++ an lvalue of the appropriate type. From the ++ point of view of unification, simply returning an ++ rvalue of the right type is good enough. */ ++ f = cand->fn; ++ t2 = TREE_TYPE (TREE_TYPE (f)); ++ if (TREE_CODE (t2) != REFERENCE_TYPE ++ || !reference_compatible_p (t, TREE_TYPE (t2))) ++ { ++ candidates = candidates->next; ++ cand = NULL; ++ } ++ } ++ } ++ else if (TREE_CODE (t2) == REFERENCE_TYPE ++ && reference_compatible_p (t, TREE_TYPE (t2))) ++ cand = add_function_candidate (&candidates, f, s, arglist, ++ TYPE_BINFO (s), ++ TREE_PURPOSE (conversions), ++ LOOKUP_NORMAL); ++ ++ if (cand) ++ { ++ /* Build a standard conversion sequence indicating the ++ binding from the reference type returned by the ++ function to the desired REFERENCE_TYPE. */ ++ cand->second_conv ++ = (direct_reference_binding ++ (reference_type, ++ build1 (IDENTITY_CONV, ++ TREE_TYPE (TREE_TYPE (TREE_TYPE (cand->fn))), ++ NULL_TREE))); ++ ICS_BAD_FLAG (cand->second_conv) ++ |= ICS_BAD_FLAG (TREE_VEC_ELT (cand->convs, 0)); ++ } ++ } ++ conversions = TREE_CHAIN (conversions); ++ } ++ ++ candidates = splice_viable (candidates, pedantic, &any_viable_p); ++ /* If none of the conversion functions worked out, let our caller ++ know. */ ++ if (!any_viable_p) ++ return NULL_TREE; ++ ++ cand = tourney (candidates); ++ if (!cand) ++ return NULL_TREE; ++ ++ /* Now that we know that this is the function we're going to use fix ++ the dummy first argument. */ ++ cand->args = tree_cons (NULL_TREE, ++ build_this (expr), ++ TREE_CHAIN (cand->args)); ++ ++ /* Build a user-defined conversion sequence representing the ++ conversion. */ ++ conv = build_conv (USER_CONV, ++ TREE_TYPE (TREE_TYPE (cand->fn)), ++ build1 (IDENTITY_CONV, TREE_TYPE (expr), expr)); ++ TREE_OPERAND (conv, 1) = build_zc_wrapper (cand); ++ ++ /* Merge it with the standard conversion sequence from the ++ conversion function's return type to the desired type. */ ++ cand->second_conv = merge_conversion_sequences (conv, cand->second_conv); ++ ++ if (cand->viable == -1) ++ ICS_BAD_FLAG (conv) = 1; ++ ++ return cand->second_conv; ++} ++ ++/* A reference of the indicated TYPE is being bound directly to the ++ expression represented by the implicit conversion sequence CONV. ++ Return a conversion sequence for this binding. */ ++ ++static tree ++direct_reference_binding (tree type, tree conv) ++{ ++ tree t; ++ ++ my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306); ++ my_friendly_assert (TREE_CODE (TREE_TYPE (conv)) != REFERENCE_TYPE, ++ 20030306); ++ ++ t = TREE_TYPE (type); ++ ++ /* [over.ics.rank] ++ ++ When a parameter of reference type binds directly ++ (_dcl.init.ref_) to an argument expression, the implicit ++ conversion sequence is the identity conversion, unless the ++ argument expression has a type that is a derived class of the ++ parameter type, in which case the implicit conversion sequence is ++ a derived-to-base Conversion. ++ ++ If the parameter binds directly to the result of applying a ++ conversion function to the argument expression, the implicit ++ conversion sequence is a user-defined conversion sequence ++ (_over.ics.user_), with the second standard conversion sequence ++ either an identity conversion or, if the conversion function ++ returns an entity of a type that is a derived class of the ++ parameter type, a derived-to-base conversion. */ ++ if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv))) ++ { ++ /* Represent the derived-to-base conversion. */ ++ conv = build_conv (BASE_CONV, t, conv); ++ /* We will actually be binding to the base-class subobject in ++ the derived class, so we mark this conversion appropriately. ++ That way, convert_like knows not to generate a temporary. */ ++ NEED_TEMPORARY_P (conv) = 0; ++ } ++ return build_conv (REF_BIND, type, conv); ++} ++ ++/* Returns the conversion path from type FROM to reference type TO for ++ purposes of reference binding. For lvalue binding, either pass a ++ reference type to FROM or an lvalue expression to EXPR. If the ++ reference will be bound to a temporary, NEED_TEMPORARY_P is set for ++ the conversion returned. */ ++ ++static tree ++reference_binding (tree rto, tree rfrom, tree expr, int flags) ++{ ++ tree conv = NULL_TREE; ++ tree to = TREE_TYPE (rto); ++ tree from = rfrom; ++ bool related_p; ++ bool compatible_p; ++ cp_lvalue_kind lvalue_p = clk_none; ++ ++ if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr)) ++ { ++ expr = instantiate_type (to, expr, tf_none); ++ if (expr == error_mark_node) ++ return NULL_TREE; ++ from = TREE_TYPE (expr); ++ } ++ ++ if (TREE_CODE (from) == REFERENCE_TYPE) ++ { ++ /* Anything with reference type is an lvalue. */ ++ lvalue_p = clk_ordinary; ++ from = TREE_TYPE (from); ++ } ++ else if (expr) ++ lvalue_p = real_lvalue_p (expr); ++ ++ /* Figure out whether or not the types are reference-related and ++ reference compatible. We have do do this after stripping ++ references from FROM. */ ++ related_p = reference_related_p (to, from); ++ compatible_p = reference_compatible_p (to, from); ++ ++ if (lvalue_p && compatible_p) ++ { ++ /* [dcl.init.ref] ++ ++ If the initializer expression ++ ++ -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1" ++ is reference-compatible with "cv2 T2," ++ ++ the reference is bound directly to the initializer expression ++ lvalue. */ ++ conv = build1 (IDENTITY_CONV, from, expr); ++ conv = direct_reference_binding (rto, conv); ++ if ((lvalue_p & clk_bitfield) != 0 ++ || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to))) ++ /* For the purposes of overload resolution, we ignore the fact ++ this expression is a bitfield or packed field. (In particular, ++ [over.ics.ref] says specifically that a function with a ++ non-const reference parameter is viable even if the ++ argument is a bitfield.) ++ ++ However, when we actually call the function we must create ++ a temporary to which to bind the reference. If the ++ reference is volatile, or isn't const, then we cannot make ++ a temporary, so we just issue an error when the conversion ++ actually occurs. */ ++ NEED_TEMPORARY_P (conv) = 1; ++ ++ return conv; ++ } ++ else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION)) ++ { ++ /* [dcl.init.ref] ++ ++ If the initializer expression ++ ++ -- has a class type (i.e., T2 is a class type) can be ++ implicitly converted to an lvalue of type "cv3 T3," where ++ "cv1 T1" is reference-compatible with "cv3 T3". (this ++ conversion is selected by enumerating the applicable ++ conversion functions (_over.match.ref_) and choosing the ++ best one through overload resolution. (_over.match_). ++ ++ the reference is bound to the lvalue result of the conversion ++ in the second case. */ ++ conv = convert_class_to_reference (to, from, expr); ++ if (conv) ++ return conv; ++ } ++ ++ /* From this point on, we conceptually need temporaries, even if we ++ elide them. Only the cases above are "direct bindings". */ ++ if (flags & LOOKUP_NO_TEMP_BIND) ++ return NULL_TREE; ++ ++ /* [over.ics.rank] ++ ++ When a parameter of reference type is not bound directly to an ++ argument expression, the conversion sequence is the one required ++ to convert the argument expression to the underlying type of the ++ reference according to _over.best.ics_. Conceptually, this ++ conversion sequence corresponds to copy-initializing a temporary ++ of the underlying type with the argument expression. Any ++ difference in top-level cv-qualification is subsumed by the ++ initialization itself and does not constitute a conversion. */ ++ ++ /* [dcl.init.ref] ++ ++ Otherwise, the reference shall be to a non-volatile const type. */ ++ if (!CP_TYPE_CONST_NON_VOLATILE_P (to)) ++ return NULL_TREE; ++ ++ /* [dcl.init.ref] ++ ++ If the initializer expression is an rvalue, with T2 a class type, ++ and "cv1 T1" is reference-compatible with "cv2 T2", the reference ++ is bound in one of the following ways: ++ ++ -- The reference is bound to the object represented by the rvalue ++ or to a sub-object within that object. ++ ++ -- ... ++ ++ We use the first alternative. The implicit conversion sequence ++ is supposed to be same as we would obtain by generating a ++ temporary. Fortunately, if the types are reference compatible, ++ then this is either an identity conversion or the derived-to-base ++ conversion, just as for direct binding. */ ++ if (CLASS_TYPE_P (from) && compatible_p) ++ { ++ conv = build1 (IDENTITY_CONV, from, expr); ++ conv = direct_reference_binding (rto, conv); ++ if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)) ++ CHECK_COPY_CONSTRUCTOR_P (TREE_OPERAND (conv, 0)) = 1; ++ return conv; ++ } ++ ++ /* [dcl.init.ref] ++ ++ Otherwise, a temporary of type "cv1 T1" is created and ++ initialized from the initializer expression using the rules for a ++ non-reference copy initialization. If T1 is reference-related to ++ T2, cv1 must be the same cv-qualification as, or greater ++ cv-qualification than, cv2; otherwise, the program is ill-formed. */ ++ if (related_p && !at_least_as_qualified_p (to, from)) ++ return NULL_TREE; ++ ++ conv = implicit_conversion (to, from, expr, flags); ++ if (!conv) ++ return NULL_TREE; ++ ++ conv = build_conv (REF_BIND, rto, conv); ++ /* This reference binding, unlike those above, requires the ++ creation of a temporary. */ ++ NEED_TEMPORARY_P (conv) = 1; ++ ++ return conv; ++} ++ ++/* Returns the implicit conversion sequence (see [over.ics]) from type FROM ++ to type TO. The optional expression EXPR may affect the conversion. ++ FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is ++ significant. */ ++ ++static tree ++implicit_conversion (tree to, tree from, tree expr, int flags) ++{ ++ tree conv; ++ ++ if (from == error_mark_node || to == error_mark_node ++ || expr == error_mark_node) ++ return NULL_TREE; ++ ++ if (TREE_CODE (to) == REFERENCE_TYPE) ++ conv = reference_binding (to, from, expr, flags); ++ else ++ conv = standard_conversion (to, from, expr, flags); ++ ++ if (conv) ++ return conv; ++ ++ if (expr != NULL_TREE ++ && (IS_AGGR_TYPE (from) ++ || IS_AGGR_TYPE (to)) ++ && (flags & LOOKUP_NO_CONVERSION) == 0) ++ { ++ struct z_candidate *cand; ++ ++ cand = build_user_type_conversion_1 ++ (to, expr, LOOKUP_ONLYCONVERTING); ++ if (cand) ++ conv = cand->second_conv; ++ ++ /* We used to try to bind a reference to a temporary here, but that ++ is now handled by the recursive call to this function at the end ++ of reference_binding. */ ++ return conv; ++ } ++ ++ return NULL_TREE; ++} ++ ++/* Add a new entry to the list of candidates. Used by the add_*_candidate ++ functions. */ ++ ++static struct z_candidate * ++add_candidate (struct z_candidate **candidates, ++ tree fn, tree args, tree convs, tree access_path, ++ tree conversion_path, int viable) ++{ ++ struct z_candidate *cand = ggc_alloc_cleared (sizeof (struct z_candidate)); ++ ++ cand->fn = fn; ++ cand->args = args; ++ cand->convs = convs; ++ cand->access_path = access_path; ++ cand->conversion_path = conversion_path; ++ cand->viable = viable; ++ cand->next = *candidates; ++ *candidates = cand; ++ ++ return cand; ++} ++ ++/* Create an overload candidate for the function or method FN called with ++ the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on ++ to implicit_conversion. ++ ++ CTYPE, if non-NULL, is the type we want to pretend this function ++ comes from for purposes of overload resolution. */ ++ ++static struct z_candidate * ++add_function_candidate (struct z_candidate **candidates, ++ tree fn, tree ctype, tree arglist, ++ tree access_path, tree conversion_path, ++ int flags) ++{ ++ tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn)); ++ int i, len; ++ tree convs; ++ tree parmnode, argnode; ++ tree orig_arglist; ++ int viable = 1; ++ ++ /* Built-in functions that haven't been declared don't really ++ exist. */ ++ if (DECL_ANTICIPATED (fn)) ++ return NULL; ++ ++ /* The `this', `in_chrg' and VTT arguments to constructors are not ++ considered in overload resolution. */ ++ if (DECL_CONSTRUCTOR_P (fn)) ++ { ++ parmlist = skip_artificial_parms_for (fn, parmlist); ++ orig_arglist = arglist; ++ arglist = skip_artificial_parms_for (fn, arglist); ++ } ++ else ++ orig_arglist = arglist; ++ ++ len = list_length (arglist); ++ convs = make_tree_vec (len); ++ ++ /* 13.3.2 - Viable functions [over.match.viable] ++ First, to be a viable function, a candidate function shall have enough ++ parameters to agree in number with the arguments in the list. ++ ++ We need to check this first; otherwise, checking the ICSes might cause ++ us to produce an ill-formed template instantiation. */ ++ ++ parmnode = parmlist; ++ for (i = 0; i < len; ++i) ++ { ++ if (parmnode == NULL_TREE || parmnode == void_list_node) ++ break; ++ parmnode = TREE_CHAIN (parmnode); ++ } ++ ++ if (i < len && parmnode) ++ viable = 0; ++ ++ /* Make sure there are default args for the rest of the parms. */ ++ else if (!sufficient_parms_p (parmnode)) ++ viable = 0; ++ ++ if (! viable) ++ goto out; ++ ++ /* Second, for F to be a viable function, there shall exist for each ++ argument an implicit conversion sequence that converts that argument ++ to the corresponding parameter of F. */ ++ ++ parmnode = parmlist; ++ argnode = arglist; ++ ++ for (i = 0; i < len; ++i) ++ { ++ tree arg = TREE_VALUE (argnode); ++ tree argtype = lvalue_type (arg); ++ tree t; ++ int is_this; ++ ++ if (parmnode == void_list_node) ++ break; ++ ++ is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) ++ && ! DECL_CONSTRUCTOR_P (fn)); ++ ++ if (parmnode) ++ { ++ tree parmtype = TREE_VALUE (parmnode); ++ ++ /* The type of the implicit object parameter ('this') for ++ overload resolution is not always the same as for the ++ function itself; conversion functions are considered to ++ be members of the class being converted, and functions ++ introduced by a using-declaration are considered to be ++ members of the class that uses them. ++ ++ Since build_over_call ignores the ICS for the `this' ++ parameter, we can just change the parm type. */ ++ if (ctype && is_this) ++ { ++ parmtype ++ = build_qualified_type (ctype, ++ TYPE_QUALS (TREE_TYPE (parmtype))); ++ parmtype = build_pointer_type (parmtype); ++ } ++ ++ t = implicit_conversion (parmtype, argtype, arg, flags); ++ } ++ else ++ { ++ t = build1 (IDENTITY_CONV, argtype, arg); ++ ICS_ELLIPSIS_FLAG (t) = 1; ++ } ++ ++ if (t && is_this) ++ ICS_THIS_FLAG (t) = 1; ++ ++ TREE_VEC_ELT (convs, i) = t; ++ if (! t) ++ { ++ viable = 0; ++ break; ++ } ++ ++ if (ICS_BAD_FLAG (t)) ++ viable = -1; ++ ++ if (parmnode) ++ parmnode = TREE_CHAIN (parmnode); ++ argnode = TREE_CHAIN (argnode); ++ } ++ ++ out: ++ return add_candidate (candidates, fn, orig_arglist, convs, access_path, ++ conversion_path, viable); ++} ++ ++/* Create an overload candidate for the conversion function FN which will ++ be invoked for expression OBJ, producing a pointer-to-function which ++ will in turn be called with the argument list ARGLIST, and add it to ++ CANDIDATES. FLAGS is passed on to implicit_conversion. ++ ++ Actually, we don't really care about FN; we care about the type it ++ converts to. There may be multiple conversion functions that will ++ convert to that type, and we rely on build_user_type_conversion_1 to ++ choose the best one; so when we create our candidate, we record the type ++ instead of the function. */ ++ ++static struct z_candidate * ++add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, ++ tree arglist, tree access_path, tree conversion_path) ++{ ++ tree totype = TREE_TYPE (TREE_TYPE (fn)); ++ int i, len, viable, flags; ++ tree parmlist, convs, parmnode, argnode; ++ ++ for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; ) ++ parmlist = TREE_TYPE (parmlist); ++ parmlist = TYPE_ARG_TYPES (parmlist); ++ ++ len = list_length (arglist) + 1; ++ convs = make_tree_vec (len); ++ parmnode = parmlist; ++ argnode = arglist; ++ viable = 1; ++ flags = LOOKUP_NORMAL; ++ ++ /* Don't bother looking up the same type twice. */ ++ if (*candidates && (*candidates)->fn == totype) ++ return NULL; ++ ++ for (i = 0; i < len; ++i) ++ { ++ tree arg = i == 0 ? obj : TREE_VALUE (argnode); ++ tree argtype = lvalue_type (arg); ++ tree t; ++ ++ if (i == 0) ++ t = implicit_conversion (totype, argtype, arg, flags); ++ else if (parmnode == void_list_node) ++ break; ++ else if (parmnode) ++ t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags); ++ else ++ { ++ t = build1 (IDENTITY_CONV, argtype, arg); ++ ICS_ELLIPSIS_FLAG (t) = 1; ++ } ++ ++ TREE_VEC_ELT (convs, i) = t; ++ if (! t) ++ break; ++ ++ if (ICS_BAD_FLAG (t)) ++ viable = -1; ++ ++ if (i == 0) ++ continue; ++ ++ if (parmnode) ++ parmnode = TREE_CHAIN (parmnode); ++ argnode = TREE_CHAIN (argnode); ++ } ++ ++ if (i < len) ++ viable = 0; ++ ++ if (!sufficient_parms_p (parmnode)) ++ viable = 0; ++ ++ return add_candidate (candidates, totype, arglist, convs, access_path, ++ conversion_path, viable); ++} ++ ++static void ++build_builtin_candidate (struct z_candidate **candidates, tree fnname, ++ tree type1, tree type2, tree *args, tree *argtypes, ++ int flags) ++{ ++ tree t, convs; ++ int viable = 1, i; ++ tree types[2]; ++ ++ types[0] = type1; ++ types[1] = type2; ++ ++ convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1)); ++ ++ for (i = 0; i < 2; ++i) ++ { ++ if (! args[i]) ++ break; ++ ++ t = implicit_conversion (types[i], argtypes[i], args[i], flags); ++ if (! t) ++ { ++ viable = 0; ++ /* We need something for printing the candidate. */ ++ t = build1 (IDENTITY_CONV, types[i], NULL_TREE); ++ } ++ else if (ICS_BAD_FLAG (t)) ++ viable = 0; ++ TREE_VEC_ELT (convs, i) = t; ++ } ++ ++ /* For COND_EXPR we rearranged the arguments; undo that now. */ ++ if (args[2]) ++ { ++ TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1); ++ TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0); ++ t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags); ++ if (t) ++ TREE_VEC_ELT (convs, 0) = t; ++ else ++ viable = 0; ++ } ++ ++ add_candidate (candidates, fnname, /*args=*/NULL_TREE, convs, ++ /*access_path=*/NULL_TREE, ++ /*conversion_path=*/NULL_TREE, ++ viable); ++} ++ ++static bool ++is_complete (tree t) ++{ ++ return COMPLETE_TYPE_P (complete_type (t)); ++} ++ ++/* Returns nonzero if TYPE is a promoted arithmetic type. */ ++ ++static bool ++promoted_arithmetic_type_p (tree type) ++{ ++ /* [over.built] ++ ++ In this section, the term promoted integral type is used to refer ++ to those integral types which are preserved by integral promotion ++ (including e.g. int and long but excluding e.g. char). ++ Similarly, the term promoted arithmetic type refers to promoted ++ integral types plus floating types. */ ++ return ((INTEGRAL_TYPE_P (type) ++ && same_type_p (type_promotes_to (type), type)) ++ || TREE_CODE (type) == REAL_TYPE); ++} ++ ++/* Create any builtin operator overload candidates for the operator in ++ question given the converted operand types TYPE1 and TYPE2. The other ++ args are passed through from add_builtin_candidates to ++ build_builtin_candidate. ++ ++ TYPE1 and TYPE2 may not be permissible, and we must filter them. ++ If CODE is requires candidates operands of the same type of the kind ++ of which TYPE1 and TYPE2 are, we add both candidates ++ CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */ ++ ++static void ++add_builtin_candidate (struct z_candidate **candidates, enum tree_code code, ++ enum tree_code code2, tree fnname, tree type1, ++ tree type2, tree *args, tree *argtypes, int flags) ++{ ++ switch (code) ++ { ++ case POSTINCREMENT_EXPR: ++ case POSTDECREMENT_EXPR: ++ args[1] = integer_zero_node; ++ type2 = integer_type_node; ++ break; ++ default: ++ break; ++ } ++ ++ switch (code) ++ { ++ ++/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type, ++ and VQ is either volatile or empty, there exist candidate operator ++ functions of the form ++ VQ T& operator++(VQ T&); ++ T operator++(VQ T&, int); ++ 5 For every pair T, VQ), where T is an enumeration type or an arithmetic ++ type other than bool, and VQ is either volatile or empty, there exist ++ candidate operator functions of the form ++ VQ T& operator--(VQ T&); ++ T operator--(VQ T&, int); ++ 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified ++ complete object type, and VQ is either volatile or empty, there exist ++ candidate operator functions of the form ++ T*VQ& operator++(T*VQ&); ++ T*VQ& operator--(T*VQ&); ++ T* operator++(T*VQ&, int); ++ T* operator--(T*VQ&, int); */ ++ ++ case POSTDECREMENT_EXPR: ++ case PREDECREMENT_EXPR: ++ if (TREE_CODE (type1) == BOOLEAN_TYPE) ++ return; ++ case POSTINCREMENT_EXPR: ++ case PREINCREMENT_EXPR: ++ if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1)) ++ { ++ type1 = build_reference_type (type1); ++ break; ++ } ++ return; ++ ++/* 7 For every cv-qualified or cv-unqualified complete object type T, there ++ exist candidate operator functions of the form ++ ++ T& operator*(T*); ++ ++ 8 For every function type T, there exist candidate operator functions of ++ the form ++ T& operator*(T*); */ ++ ++ case INDIRECT_REF: ++ if (TREE_CODE (type1) == POINTER_TYPE ++ && (TYPE_PTROB_P (type1) ++ || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)) ++ break; ++ return; ++ ++/* 9 For every type T, there exist candidate operator functions of the form ++ T* operator+(T*); ++ ++ 10For every promoted arithmetic type T, there exist candidate operator ++ functions of the form ++ T operator+(T); ++ T operator-(T); */ ++ ++ case CONVERT_EXPR: /* unary + */ ++ if (TREE_CODE (type1) == POINTER_TYPE) ++ break; ++ case NEGATE_EXPR: ++ if (ARITHMETIC_TYPE_P (type1)) ++ break; ++ return; ++ ++/* 11For every promoted integral type T, there exist candidate operator ++ functions of the form ++ T operator~(T); */ ++ ++ case BIT_NOT_EXPR: ++ if (INTEGRAL_TYPE_P (type1)) ++ break; ++ return; ++ ++/* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1 ++ is the same type as C2 or is a derived class of C2, T is a complete ++ object type or a function type, and CV1 and CV2 are cv-qualifier-seqs, ++ there exist candidate operator functions of the form ++ CV12 T& operator->*(CV1 C1*, CV2 T C2::*); ++ where CV12 is the union of CV1 and CV2. */ ++ ++ case MEMBER_REF: ++ if (TREE_CODE (type1) == POINTER_TYPE ++ && TYPE_PTR_TO_MEMBER_P (type2)) ++ { ++ tree c1 = TREE_TYPE (type1); ++ tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2); ++ ++ if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1) ++ && (TYPE_PTRMEMFUNC_P (type2) ++ || is_complete (TREE_TYPE (TREE_TYPE (type2))))) ++ break; ++ } ++ return; ++ ++/* 13For every pair of promoted arithmetic types L and R, there exist can- ++ didate operator functions of the form ++ LR operator*(L, R); ++ LR operator/(L, R); ++ LR operator+(L, R); ++ LR operator-(L, R); ++ bool operator<(L, R); ++ bool operator>(L, R); ++ bool operator<=(L, R); ++ bool operator>=(L, R); ++ bool operator==(L, R); ++ bool operator!=(L, R); ++ where LR is the result of the usual arithmetic conversions between ++ types L and R. ++ ++ 14For every pair of types T and I, where T is a cv-qualified or cv- ++ unqualified complete object type and I is a promoted integral type, ++ there exist candidate operator functions of the form ++ T* operator+(T*, I); ++ T& operator[](T*, I); ++ T* operator-(T*, I); ++ T* operator+(I, T*); ++ T& operator[](I, T*); ++ ++ 15For every T, where T is a pointer to complete object type, there exist ++ candidate operator functions of the form112) ++ ptrdiff_t operator-(T, T); ++ ++ 16For every pointer or enumeration type T, there exist candidate operator ++ functions of the form ++ bool operator<(T, T); ++ bool operator>(T, T); ++ bool operator<=(T, T); ++ bool operator>=(T, T); ++ bool operator==(T, T); ++ bool operator!=(T, T); ++ ++ 17For every pointer to member type T, there exist candidate operator ++ functions of the form ++ bool operator==(T, T); ++ bool operator!=(T, T); */ ++ ++ case MINUS_EXPR: ++ if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2)) ++ break; ++ if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2)) ++ { ++ type2 = ptrdiff_type_node; ++ break; ++ } ++ case MULT_EXPR: ++ case TRUNC_DIV_EXPR: ++ if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) ++ break; ++ return; ++ ++ case EQ_EXPR: ++ case NE_EXPR: ++ if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2)) ++ || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))) ++ break; ++ if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1])) ++ { ++ type2 = type1; ++ break; ++ } ++ if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0])) ++ { ++ type1 = type2; ++ break; ++ } ++ /* Fall through. */ ++ case LT_EXPR: ++ case GT_EXPR: ++ case LE_EXPR: ++ case GE_EXPR: ++ case MAX_EXPR: ++ case MIN_EXPR: ++ if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) ++ break; ++ if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2)) ++ break; ++ if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE) ++ break; ++ if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1])) ++ { ++ type2 = type1; ++ break; ++ } ++ if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2)) ++ { ++ type1 = type2; ++ break; ++ } ++ return; ++ ++ case PLUS_EXPR: ++ if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) ++ break; ++ case ARRAY_REF: ++ if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2)) ++ { ++ type1 = ptrdiff_type_node; ++ break; ++ } ++ if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2)) ++ { ++ type2 = ptrdiff_type_node; ++ break; ++ } ++ return; ++ ++/* 18For every pair of promoted integral types L and R, there exist candi- ++ date operator functions of the form ++ LR operator%(L, R); ++ LR operator&(L, R); ++ LR operator^(L, R); ++ LR operator|(L, R); ++ L operator<<(L, R); ++ L operator>>(L, R); ++ where LR is the result of the usual arithmetic conversions between ++ types L and R. */ ++ ++ case TRUNC_MOD_EXPR: ++ case BIT_AND_EXPR: ++ case BIT_IOR_EXPR: ++ case BIT_XOR_EXPR: ++ case LSHIFT_EXPR: ++ case RSHIFT_EXPR: ++ if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2)) ++ break; ++ return; ++ ++/* 19For every triple L, VQ, R), where L is an arithmetic or enumeration ++ type, VQ is either volatile or empty, and R is a promoted arithmetic ++ type, there exist candidate operator functions of the form ++ VQ L& operator=(VQ L&, R); ++ VQ L& operator*=(VQ L&, R); ++ VQ L& operator/=(VQ L&, R); ++ VQ L& operator+=(VQ L&, R); ++ VQ L& operator-=(VQ L&, R); ++ ++ 20For every pair T, VQ), where T is any type and VQ is either volatile ++ or empty, there exist candidate operator functions of the form ++ T*VQ& operator=(T*VQ&, T*); ++ ++ 21For every pair T, VQ), where T is a pointer to member type and VQ is ++ either volatile or empty, there exist candidate operator functions of ++ the form ++ VQ T& operator=(VQ T&, T); ++ ++ 22For every triple T, VQ, I), where T is a cv-qualified or cv- ++ unqualified complete object type, VQ is either volatile or empty, and ++ I is a promoted integral type, there exist candidate operator func- ++ tions of the form ++ T*VQ& operator+=(T*VQ&, I); ++ T*VQ& operator-=(T*VQ&, I); ++ ++ 23For every triple L, VQ, R), where L is an integral or enumeration ++ type, VQ is either volatile or empty, and R is a promoted integral ++ type, there exist candidate operator functions of the form ++ ++ VQ L& operator%=(VQ L&, R); ++ VQ L& operator<<=(VQ L&, R); ++ VQ L& operator>>=(VQ L&, R); ++ VQ L& operator&=(VQ L&, R); ++ VQ L& operator^=(VQ L&, R); ++ VQ L& operator|=(VQ L&, R); */ ++ ++ case MODIFY_EXPR: ++ switch (code2) ++ { ++ case PLUS_EXPR: ++ case MINUS_EXPR: ++ if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2)) ++ { ++ type2 = ptrdiff_type_node; ++ break; ++ } ++ case MULT_EXPR: ++ case TRUNC_DIV_EXPR: ++ if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) ++ break; ++ return; ++ ++ case TRUNC_MOD_EXPR: ++ case BIT_AND_EXPR: ++ case BIT_IOR_EXPR: ++ case BIT_XOR_EXPR: ++ case LSHIFT_EXPR: ++ case RSHIFT_EXPR: ++ if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2)) ++ break; ++ return; ++ ++ case NOP_EXPR: ++ if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) ++ break; ++ if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2)) ++ || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2)) ++ || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)) ++ || ((TYPE_PTRMEMFUNC_P (type1) ++ || TREE_CODE (type1) == POINTER_TYPE) ++ && null_ptr_cst_p (args[1]))) ++ { ++ type2 = type1; ++ break; ++ } ++ return; ++ ++ default: ++ abort (); ++ } ++ type1 = build_reference_type (type1); ++ break; ++ ++ case COND_EXPR: ++ /* [over.built] ++ ++ For every pair of promoted arithmetic types L and R, there ++ exist candidate operator functions of the form ++ ++ LR operator?(bool, L, R); ++ ++ where LR is the result of the usual arithmetic conversions ++ between types L and R. ++ ++ For every type T, where T is a pointer or pointer-to-member ++ type, there exist candidate operator functions of the form T ++ operator?(bool, T, T); */ ++ ++ if (promoted_arithmetic_type_p (type1) ++ && promoted_arithmetic_type_p (type2)) ++ /* That's OK. */ ++ break; ++ ++ /* Otherwise, the types should be pointers. */ ++ if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1)) ++ || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2))) ++ return; ++ ++ /* We don't check that the two types are the same; the logic ++ below will actually create two candidates; one in which both ++ parameter types are TYPE1, and one in which both parameter ++ types are TYPE2. */ ++ break; ++ ++ default: ++ abort (); ++ } ++ ++ /* If we're dealing with two pointer types or two enumeral types, ++ we need candidates for both of them. */ ++ if (type2 && !same_type_p (type1, type2) ++ && TREE_CODE (type1) == TREE_CODE (type2) ++ && (TREE_CODE (type1) == REFERENCE_TYPE ++ || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2)) ++ || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)) ++ || TYPE_PTRMEMFUNC_P (type1) ++ || IS_AGGR_TYPE (type1) ++ || TREE_CODE (type1) == ENUMERAL_TYPE)) ++ { ++ build_builtin_candidate ++ (candidates, fnname, type1, type1, args, argtypes, flags); ++ build_builtin_candidate ++ (candidates, fnname, type2, type2, args, argtypes, flags); ++ return; ++ } ++ ++ build_builtin_candidate ++ (candidates, fnname, type1, type2, args, argtypes, flags); ++} ++ ++tree ++type_decays_to (tree type) ++{ ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ return build_pointer_type (TREE_TYPE (type)); ++ if (TREE_CODE (type) == FUNCTION_TYPE) ++ return build_pointer_type (type); ++ return type; ++} ++ ++/* There are three conditions of builtin candidates: ++ ++ 1) bool-taking candidates. These are the same regardless of the input. ++ 2) pointer-pair taking candidates. These are generated for each type ++ one of the input types converts to. ++ 3) arithmetic candidates. According to the standard, we should generate ++ all of these, but I'm trying not to... ++ ++ Here we generate a superset of the possible candidates for this particular ++ case. That is a subset of the full set the standard defines, plus some ++ other cases which the standard disallows. add_builtin_candidate will ++ filter out the invalid set. */ ++ ++static void ++add_builtin_candidates (struct z_candidate **candidates, enum tree_code code, ++ enum tree_code code2, tree fnname, tree *args, ++ int flags) ++{ ++ int ref1, i; ++ int enum_p = 0; ++ tree type, argtypes[3]; ++ /* TYPES[i] is the set of possible builtin-operator parameter types ++ we will consider for the Ith argument. These are represented as ++ a TREE_LIST; the TREE_VALUE of each node is the potential ++ parameter type. */ ++ tree types[2]; ++ ++ for (i = 0; i < 3; ++i) ++ { ++ if (args[i]) ++ argtypes[i] = lvalue_type (args[i]); ++ else ++ argtypes[i] = NULL_TREE; ++ } ++ ++ switch (code) ++ { ++/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type, ++ and VQ is either volatile or empty, there exist candidate operator ++ functions of the form ++ VQ T& operator++(VQ T&); */ ++ ++ case POSTINCREMENT_EXPR: ++ case PREINCREMENT_EXPR: ++ case POSTDECREMENT_EXPR: ++ case PREDECREMENT_EXPR: ++ case MODIFY_EXPR: ++ ref1 = 1; ++ break; ++ ++/* 24There also exist candidate operator functions of the form ++ bool operator!(bool); ++ bool operator&&(bool, bool); ++ bool operator||(bool, bool); */ ++ ++ case TRUTH_NOT_EXPR: ++ build_builtin_candidate ++ (candidates, fnname, boolean_type_node, ++ NULL_TREE, args, argtypes, flags); ++ return; ++ ++ case TRUTH_ORIF_EXPR: ++ case TRUTH_ANDIF_EXPR: ++ build_builtin_candidate ++ (candidates, fnname, boolean_type_node, ++ boolean_type_node, args, argtypes, flags); ++ return; ++ ++ case ADDR_EXPR: ++ case COMPOUND_EXPR: ++ case COMPONENT_REF: ++ return; ++ ++ case COND_EXPR: ++ case EQ_EXPR: ++ case NE_EXPR: ++ case LT_EXPR: ++ case LE_EXPR: ++ case GT_EXPR: ++ case GE_EXPR: ++ enum_p = 1; ++ /* Fall through. */ ++ ++ default: ++ ref1 = 0; ++ } ++ ++ types[0] = types[1] = NULL_TREE; ++ ++ for (i = 0; i < 2; ++i) ++ { ++ if (! args[i]) ++ ; ++ else if (IS_AGGR_TYPE (argtypes[i])) ++ { ++ tree convs; ++ ++ if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR) ++ return; ++ ++ convs = lookup_conversions (argtypes[i]); ++ ++ if (code == COND_EXPR) ++ { ++ if (real_lvalue_p (args[i])) ++ types[i] = tree_cons ++ (NULL_TREE, build_reference_type (argtypes[i]), types[i]); ++ ++ types[i] = tree_cons ++ (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]); ++ } ++ ++ else if (! convs) ++ return; ++ ++ for (; convs; convs = TREE_CHAIN (convs)) ++ { ++ type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs)))); ++ ++ if (i == 0 && ref1 ++ && (TREE_CODE (type) != REFERENCE_TYPE ++ || CP_TYPE_CONST_P (TREE_TYPE (type)))) ++ continue; ++ ++ if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE) ++ types[i] = tree_cons (NULL_TREE, type, types[i]); ++ ++ type = non_reference (type); ++ if (i != 0 || ! ref1) ++ { ++ type = TYPE_MAIN_VARIANT (type_decays_to (type)); ++ if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE) ++ types[i] = tree_cons (NULL_TREE, type, types[i]); ++ if (INTEGRAL_TYPE_P (type)) ++ type = type_promotes_to (type); ++ } ++ ++ if (! value_member (type, types[i])) ++ types[i] = tree_cons (NULL_TREE, type, types[i]); ++ } ++ } ++ else ++ { ++ if (code == COND_EXPR && real_lvalue_p (args[i])) ++ types[i] = tree_cons ++ (NULL_TREE, build_reference_type (argtypes[i]), types[i]); ++ type = non_reference (argtypes[i]); ++ if (i != 0 || ! ref1) ++ { ++ type = TYPE_MAIN_VARIANT (type_decays_to (type)); ++ if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE) ++ types[i] = tree_cons (NULL_TREE, type, types[i]); ++ if (INTEGRAL_TYPE_P (type)) ++ type = type_promotes_to (type); ++ } ++ types[i] = tree_cons (NULL_TREE, type, types[i]); ++ } ++ } ++ ++ /* Run through the possible parameter types of both arguments, ++ creating candidates with those parameter types. */ ++ for (; types[0]; types[0] = TREE_CHAIN (types[0])) ++ { ++ if (types[1]) ++ for (type = types[1]; type; type = TREE_CHAIN (type)) ++ add_builtin_candidate ++ (candidates, code, code2, fnname, TREE_VALUE (types[0]), ++ TREE_VALUE (type), args, argtypes, flags); ++ else ++ add_builtin_candidate ++ (candidates, code, code2, fnname, TREE_VALUE (types[0]), ++ NULL_TREE, args, argtypes, flags); ++ } ++ ++ return; ++} ++ ++ ++/* If TMPL can be successfully instantiated as indicated by ++ EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES. ++ ++ TMPL is the template. EXPLICIT_TARGS are any explicit template ++ arguments. ARGLIST is the arguments provided at the call-site. ++ The RETURN_TYPE is the desired type for conversion operators. If ++ OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate. ++ If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for ++ add_conv_candidate. */ ++ ++static struct z_candidate* ++add_template_candidate_real (struct z_candidate **candidates, tree tmpl, ++ tree ctype, tree explicit_targs, tree arglist, ++ tree return_type, tree access_path, ++ tree conversion_path, int flags, tree obj, ++ unification_kind_t strict) ++{ ++ int ntparms = DECL_NTPARMS (tmpl); ++ tree targs = make_tree_vec (ntparms); ++ tree args_without_in_chrg = arglist; ++ struct z_candidate *cand; ++ int i; ++ tree fn; ++ ++ /* We don't do deduction on the in-charge parameter, the VTT ++ parameter or 'this'. */ ++ if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl)) ++ args_without_in_chrg = TREE_CHAIN (args_without_in_chrg); ++ ++ if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl) ++ || DECL_BASE_CONSTRUCTOR_P (tmpl)) ++ && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl))) ++ args_without_in_chrg = TREE_CHAIN (args_without_in_chrg); ++ ++ i = fn_type_unification (tmpl, explicit_targs, targs, ++ args_without_in_chrg, ++ return_type, strict, -1); ++ ++ if (i != 0) ++ return NULL; ++ ++ fn = instantiate_template (tmpl, targs, tf_none); ++ if (fn == error_mark_node) ++ return NULL; ++ ++ /* In [class.copy]: ++ ++ A member function template is never instantiated to perform the ++ copy of a class object to an object of its class type. ++ ++ It's a little unclear what this means; the standard explicitly ++ does allow a template to be used to copy a class. For example, ++ in: ++ ++ struct A { ++ A(A&); ++ template A(const T&); ++ }; ++ const A f (); ++ void g () { A a (f ()); } ++ ++ the member template will be used to make the copy. The section ++ quoted above appears in the paragraph that forbids constructors ++ whose only parameter is (a possibly cv-qualified variant of) the ++ class type, and a logical interpretation is that the intent was ++ to forbid the instantiation of member templates which would then ++ have that form. */ ++ if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2) ++ { ++ tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn); ++ if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)), ++ ctype)) ++ return NULL; ++ } ++ ++ if (obj != NULL_TREE) ++ /* Aha, this is a conversion function. */ ++ cand = add_conv_candidate (candidates, fn, obj, access_path, ++ conversion_path, arglist); ++ else ++ cand = add_function_candidate (candidates, fn, ctype, ++ arglist, access_path, ++ conversion_path, flags); ++ if (DECL_TI_TEMPLATE (fn) != tmpl) ++ /* This situation can occur if a member template of a template ++ class is specialized. Then, instantiate_template might return ++ an instantiation of the specialization, in which case the ++ DECL_TI_TEMPLATE field will point at the original ++ specialization. For example: ++ ++ template struct S { template void f(U); ++ template <> void f(int) {}; }; ++ S sd; ++ sd.f(3); ++ ++ Here, TMPL will be template S::f(U). ++ And, instantiate template will give us the specialization ++ template <> S::f(int). But, the DECL_TI_TEMPLATE field ++ for this will point at template template <> S::f(int), ++ so that we can find the definition. For the purposes of ++ overload resolution, however, we want the original TMPL. */ ++ cand->template = tree_cons (tmpl, targs, NULL_TREE); ++ else ++ cand->template = DECL_TEMPLATE_INFO (fn); ++ ++ return cand; ++} ++ ++ ++static struct z_candidate * ++add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype, ++ tree explicit_targs, tree arglist, tree return_type, ++ tree access_path, tree conversion_path, int flags, ++ unification_kind_t strict) ++{ ++ return ++ add_template_candidate_real (candidates, tmpl, ctype, ++ explicit_targs, arglist, return_type, ++ access_path, conversion_path, ++ flags, NULL_TREE, strict); ++} ++ ++ ++static struct z_candidate * ++add_template_conv_candidate (struct z_candidate **candidates, tree tmpl, ++ tree obj, tree arglist, tree return_type, ++ tree access_path, tree conversion_path) ++{ ++ return ++ add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE, ++ arglist, return_type, access_path, ++ conversion_path, 0, obj, DEDUCE_CONV); ++} ++ ++/* The CANDS are the set of candidates that were considered for ++ overload resolution. Return the set of viable candidates. If none ++ of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P ++ is true if a candidate should be considered viable only if it is ++ strictly viable. */ ++ ++static struct z_candidate* ++splice_viable (struct z_candidate *cands, ++ bool strict_p, ++ bool *any_viable_p) ++{ ++ struct z_candidate *viable; ++ struct z_candidate **last_viable; ++ struct z_candidate **cand; ++ ++ viable = NULL; ++ last_viable = &viable; ++ *any_viable_p = false; ++ ++ cand = &cands; ++ while (*cand) ++ { ++ struct z_candidate *c = *cand; ++ if (strict_p ? c->viable == 1 : c->viable) ++ { ++ *last_viable = c; ++ *cand = c->next; ++ c->next = NULL; ++ last_viable = &c->next; ++ *any_viable_p = true; ++ } ++ else ++ cand = &c->next; ++ } ++ ++ return viable ? viable : cands; ++} ++ ++static bool ++any_strictly_viable (struct z_candidate *cands) ++{ ++ for (; cands; cands = cands->next) ++ if (cands->viable == 1) ++ return true; ++ return false; ++} ++ ++/* OBJ is being used in an expression like "OBJ.f (...)". In other ++ words, it is about to become the "this" pointer for a member ++ function call. Take the address of the object. */ ++ ++static tree ++build_this (tree obj) ++{ ++ /* In a template, we are only concerned about the type of the ++ expression, so we can take a shortcut. */ ++ if (processing_template_decl) ++ return build_address (obj); ++ ++ return build_unary_op (ADDR_EXPR, obj, 0); ++} ++ ++/* Returns true iff functions are equivalent. Equivalent functions are ++ not '==' only if one is a function-local extern function or if ++ both are extern "C". */ ++ ++static inline int ++equal_functions (tree fn1, tree fn2) ++{ ++ if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2) ++ || DECL_EXTERN_C_FUNCTION_P (fn1)) ++ return decls_match (fn1, fn2); ++ return fn1 == fn2; ++} ++ ++/* Print information about one overload candidate CANDIDATE. MSGSTR ++ is the text to print before the candidate itself. ++ ++ NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected ++ to have been run through gettext by the caller. This wart makes ++ life simpler in print_z_candidates and for the translators. */ ++ ++static void ++print_z_candidate (const char *msgstr, struct z_candidate *candidate) ++{ ++ if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE) ++ { ++ if (TREE_VEC_LENGTH (candidate->convs) == 3) ++ inform ("%s %D(%T, %T, %T) ", msgstr, candidate->fn, ++ TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)), ++ TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)), ++ TREE_TYPE (TREE_VEC_ELT (candidate->convs, 2))); ++ else if (TREE_VEC_LENGTH (candidate->convs) == 2) ++ inform ("%s %D(%T, %T) ", msgstr, candidate->fn, ++ TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)), ++ TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1))); ++ else ++ inform ("%s %D(%T) ", msgstr, candidate->fn, ++ TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0))); ++ } ++ else if (TYPE_P (candidate->fn)) ++ inform ("%s %T ", msgstr, candidate->fn); ++ else if (candidate->viable == -1) ++ inform ("%J%s %+#D ", candidate->fn, msgstr, candidate->fn); ++ else ++ inform ("%J%s %+#D", candidate->fn, msgstr, candidate->fn); ++} ++ ++static void ++print_z_candidates (struct z_candidate *candidates) ++{ ++ const char *str; ++ struct z_candidate *cand1; ++ struct z_candidate **cand2; ++ ++ /* There may be duplicates in the set of candidates. We put off ++ checking this condition as long as possible, since we have no way ++ to eliminate duplicates from a set of functions in less than n^2 ++ time. Now we are about to emit an error message, so it is more ++ permissible to go slowly. */ ++ for (cand1 = candidates; cand1; cand1 = cand1->next) ++ { ++ tree fn = cand1->fn; ++ /* Skip builtin candidates and conversion functions. */ ++ if (TREE_CODE (fn) != FUNCTION_DECL) ++ continue; ++ cand2 = &cand1->next; ++ while (*cand2) ++ { ++ if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL ++ && equal_functions (fn, (*cand2)->fn)) ++ *cand2 = (*cand2)->next; ++ else ++ cand2 = &(*cand2)->next; ++ } ++ } ++ ++ if (!candidates) ++ return; ++ ++ str = _("candidates are:"); ++ print_z_candidate (str, candidates); ++ if (candidates->next) ++ { ++ /* Indent successive candidates by the width of the translation ++ of the above string. */ ++ size_t len = gcc_gettext_width (str) + 1; ++ char *spaces = alloca (len); ++ memset (spaces, ' ', len-1); ++ spaces[len - 1] = '\0'; ++ ++ candidates = candidates->next; ++ do ++ { ++ print_z_candidate (spaces, candidates); ++ candidates = candidates->next; ++ } ++ while (candidates); ++ } ++} ++ ++/* USER_SEQ is a user-defined conversion sequence, beginning with a ++ USER_CONV. STD_SEQ is the standard conversion sequence applied to ++ the result of the conversion function to convert it to the final ++ desired type. Merge the the two sequences into a single sequence, ++ and return the merged sequence. */ ++ ++static tree ++merge_conversion_sequences (tree user_seq, tree std_seq) ++{ ++ tree *t; ++ ++ my_friendly_assert (TREE_CODE (user_seq) == USER_CONV, ++ 20030306); ++ ++ /* Find the end of the second conversion sequence. */ ++ t = &(std_seq); ++ while (TREE_CODE (*t) != IDENTITY_CONV) ++ t = &TREE_OPERAND (*t, 0); ++ ++ /* Replace the identity conversion with the user conversion ++ sequence. */ ++ *t = user_seq; ++ ++ /* The entire sequence is a user-conversion sequence. */ ++ ICS_USER_FLAG (std_seq) = 1; ++ ++ return std_seq; ++} ++ ++/* Returns the best overload candidate to perform the requested ++ conversion. This function is used for three the overloading situations ++ described in [over.match.copy], [over.match.conv], and [over.match.ref]. ++ If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as ++ per [dcl.init.ref], so we ignore temporary bindings. */ ++ ++static struct z_candidate * ++build_user_type_conversion_1 (tree totype, tree expr, int flags) ++{ ++ struct z_candidate *candidates, *cand; ++ tree fromtype = TREE_TYPE (expr); ++ tree ctors = NULL_TREE, convs = NULL_TREE; ++ tree args = NULL_TREE; ++ bool any_viable_p; ++ ++ /* We represent conversion within a hierarchy using RVALUE_CONV and ++ BASE_CONV, as specified by [over.best.ics]; these become plain ++ constructor calls, as specified in [dcl.init]. */ ++ my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype) ++ || !DERIVED_FROM_P (totype, fromtype), 20011226); ++ ++ if (IS_AGGR_TYPE (totype)) ++ ctors = lookup_fnfields (TYPE_BINFO (totype), ++ complete_ctor_identifier, ++ 0); ++ ++ if (IS_AGGR_TYPE (fromtype)) ++ convs = lookup_conversions (fromtype); ++ ++ candidates = 0; ++ flags |= LOOKUP_NO_CONVERSION; ++ ++ if (ctors) ++ { ++ tree t; ++ ++ ctors = BASELINK_FUNCTIONS (ctors); ++ ++ t = build_int_2 (0, 0); ++ TREE_TYPE (t) = build_pointer_type (totype); ++ args = build_tree_list (NULL_TREE, expr); ++ /* We should never try to call the abstract or base constructor ++ from here. */ ++ my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors)) ++ && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)), ++ 20011226); ++ args = tree_cons (NULL_TREE, t, args); ++ } ++ for (; ctors; ctors = OVL_NEXT (ctors)) ++ { ++ tree ctor = OVL_CURRENT (ctors); ++ if (DECL_NONCONVERTING_P (ctor)) ++ continue; ++ ++ if (TREE_CODE (ctor) == TEMPLATE_DECL) ++ cand = add_template_candidate (&candidates, ctor, totype, ++ NULL_TREE, args, NULL_TREE, ++ TYPE_BINFO (totype), ++ TYPE_BINFO (totype), ++ flags, ++ DEDUCE_CALL); ++ else ++ cand = add_function_candidate (&candidates, ctor, totype, ++ args, TYPE_BINFO (totype), ++ TYPE_BINFO (totype), ++ flags); ++ ++ if (cand) ++ cand->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE); ++ } ++ ++ if (convs) ++ args = build_tree_list (NULL_TREE, build_this (expr)); ++ ++ for (; convs; convs = TREE_CHAIN (convs)) ++ { ++ tree fns; ++ tree conversion_path = TREE_PURPOSE (convs); ++ int convflags = LOOKUP_NO_CONVERSION; ++ ++ /* If we are called to convert to a reference type, we are trying to ++ find an lvalue binding, so don't even consider temporaries. If ++ we don't find an lvalue binding, the caller will try again to ++ look for a temporary binding. */ ++ if (TREE_CODE (totype) == REFERENCE_TYPE) ++ convflags |= LOOKUP_NO_TEMP_BIND; ++ ++ for (fns = TREE_VALUE (convs); fns; fns = OVL_NEXT (fns)) ++ { ++ tree fn = OVL_CURRENT (fns); ++ ++ /* [over.match.funcs] For conversion functions, the function ++ is considered to be a member of the class of the implicit ++ object argument for the purpose of defining the type of ++ the implicit object parameter. ++ ++ So we pass fromtype as CTYPE to add_*_candidate. */ ++ ++ if (TREE_CODE (fn) == TEMPLATE_DECL) ++ cand = add_template_candidate (&candidates, fn, fromtype, ++ NULL_TREE, ++ args, totype, ++ TYPE_BINFO (fromtype), ++ conversion_path, ++ flags, ++ DEDUCE_CONV); ++ else ++ cand = add_function_candidate (&candidates, fn, fromtype, ++ args, ++ TYPE_BINFO (fromtype), ++ conversion_path, ++ flags); ++ ++ if (cand) ++ { ++ tree ics = implicit_conversion (totype, ++ TREE_TYPE (TREE_TYPE (cand->fn)), ++ 0, convflags); ++ ++ cand->second_conv = ics; ++ ++ if (ics == NULL_TREE) ++ cand->viable = 0; ++ else if (candidates->viable == 1 && ICS_BAD_FLAG (ics)) ++ cand->viable = -1; ++ } ++ } ++ } ++ ++ candidates = splice_viable (candidates, pedantic, &any_viable_p); ++ if (!any_viable_p) ++ return 0; ++ ++ cand = tourney (candidates); ++ if (cand == 0) ++ { ++ if (flags & LOOKUP_COMPLAIN) ++ { ++ error ("conversion from `%T' to `%T' is ambiguous", ++ fromtype, totype); ++ print_z_candidates (candidates); ++ } ++ ++ cand = candidates; /* any one will do */ ++ cand->second_conv = build1 (AMBIG_CONV, totype, expr); ++ ICS_USER_FLAG (cand->second_conv) = 1; ++ if (!any_strictly_viable (candidates)) ++ ICS_BAD_FLAG (cand->second_conv) = 1; ++ /* If there are viable candidates, don't set ICS_BAD_FLAG; an ++ ambiguous conversion is no worse than another user-defined ++ conversion. */ ++ ++ return cand; ++ } ++ ++ /* Build the user conversion sequence. */ ++ convs = build_conv ++ (USER_CONV, ++ (DECL_CONSTRUCTOR_P (cand->fn) ++ ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))), ++ build1 (IDENTITY_CONV, TREE_TYPE (expr), expr)); ++ TREE_OPERAND (convs, 1) = build_zc_wrapper (cand); ++ ++ /* Combine it with the second conversion sequence. */ ++ cand->second_conv = merge_conversion_sequences (convs, ++ cand->second_conv); ++ ++ if (cand->viable == -1) ++ ICS_BAD_FLAG (cand->second_conv) = 1; ++ ++ return cand; ++} ++ ++tree ++build_user_type_conversion (tree totype, tree expr, int flags) ++{ ++ struct z_candidate *cand ++ = build_user_type_conversion_1 (totype, expr, flags); ++ ++ if (cand) ++ { ++ if (TREE_CODE (cand->second_conv) == AMBIG_CONV) ++ return error_mark_node; ++ return convert_from_reference (convert_like (cand->second_conv, expr)); ++ } ++ return NULL_TREE; ++} ++ ++/* Do any initial processing on the arguments to a function call. */ ++ ++static tree ++resolve_args (tree args) ++{ ++ tree t; ++ for (t = args; t; t = TREE_CHAIN (t)) ++ { ++ tree arg = TREE_VALUE (t); ++ ++ if (arg == error_mark_node) ++ return error_mark_node; ++ else if (VOID_TYPE_P (TREE_TYPE (arg))) ++ { ++ error ("invalid use of void expression"); ++ return error_mark_node; ++ } ++ arg = convert_from_reference (arg); ++ TREE_VALUE (t) = arg; ++ } ++ return args; ++} ++ ++/* Perform overload resolution on FN, which is called with the ARGS. ++ ++ Return the candidate function selected by overload resolution, or ++ NULL if the event that overload resolution failed. In the case ++ that overload resolution fails, *CANDIDATES will be the set of ++ candidates considered, and ANY_VIABLE_P will be set to true or ++ false to indicate whether or not any of the candidates were ++ viable. ++ ++ The ARGS should already have gone through RESOLVE_ARGS before this ++ function is called. */ ++ ++static struct z_candidate * ++perform_overload_resolution (tree fn, ++ tree args, ++ struct z_candidate **candidates, ++ bool *any_viable_p) ++{ ++ struct z_candidate *cand; ++ tree explicit_targs = NULL_TREE; ++ int template_only = 0; ++ ++ *candidates = NULL; ++ *any_viable_p = true; ++ ++ /* Check FN and ARGS. */ ++ my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL ++ || TREE_CODE (fn) == TEMPLATE_DECL ++ || TREE_CODE (fn) == OVERLOAD ++ || TREE_CODE (fn) == TEMPLATE_ID_EXPR, ++ 20020712); ++ my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST, ++ 20020712); ++ ++ if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) ++ { ++ explicit_targs = TREE_OPERAND (fn, 1); ++ fn = TREE_OPERAND (fn, 0); ++ template_only = 1; ++ } ++ ++ /* Add the various candidate functions. */ ++ add_candidates (fn, args, explicit_targs, template_only, ++ /*conversion_path=*/NULL_TREE, ++ /*access_path=*/NULL_TREE, ++ LOOKUP_NORMAL, ++ candidates); ++ ++ *candidates = splice_viable (*candidates, pedantic, any_viable_p); ++ if (!*any_viable_p) ++ return NULL; ++ ++ cand = tourney (*candidates); ++ return cand; ++} ++ ++/* Return an expression for a call to FN (a namespace-scope function, ++ or a static member function) with the ARGS. */ ++ ++tree ++build_new_function_call (tree fn, tree args) ++{ ++ struct z_candidate *candidates, *cand; ++ bool any_viable_p; ++ ++ args = resolve_args (args); ++ if (args == error_mark_node) ++ return error_mark_node; ++ ++ cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p); ++ ++ if (!cand) ++ { ++ if (!any_viable_p && candidates && ! candidates->next) ++ return build_function_call (candidates->fn, args); ++ if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) ++ fn = TREE_OPERAND (fn, 0); ++ if (!any_viable_p) ++ error ("no matching function for call to `%D(%A)'", ++ DECL_NAME (OVL_CURRENT (fn)), args); ++ else ++ error ("call of overloaded `%D(%A)' is ambiguous", ++ DECL_NAME (OVL_CURRENT (fn)), args); ++ if (candidates) ++ print_z_candidates (candidates); ++ return error_mark_node; ++ } ++ ++ return build_over_call (cand, LOOKUP_NORMAL); ++} ++ ++/* Build a call to a global operator new. FNNAME is the name of the ++ operator (either "operator new" or "operator new[]") and ARGS are ++ the arguments provided. *SIZE points to the total number of bytes ++ required by the allocation, and is updated if that is changed here. ++ *COOKIE_SIZE is non-NULL if a cookie should be used. If this ++ function determines that no cookie should be used, after all, ++ *COOKIE_SIZE is set to NULL_TREE. */ ++ ++tree ++build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size) ++{ ++ tree fns; ++ struct z_candidate *candidates; ++ struct z_candidate *cand; ++ bool any_viable_p; ++ ++ args = tree_cons (NULL_TREE, *size, args); ++ args = resolve_args (args); ++ if (args == error_mark_node) ++ return args; ++ ++ fns = lookup_function_nonclass (fnname, args); ++ ++ /* Figure out what function is being called. */ ++ cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p); ++ ++ /* If no suitable function could be found, issue an error message ++ and give up. */ ++ if (!cand) ++ { ++ if (!any_viable_p) ++ error ("no matching function for call to `%D(%A)'", ++ DECL_NAME (OVL_CURRENT (fns)), args); ++ else ++ error ("call of overloaded `%D(%A)' is ambiguous", ++ DECL_NAME (OVL_CURRENT (fns)), args); ++ if (candidates) ++ print_z_candidates (candidates); ++ return error_mark_node; ++ } ++ ++ /* If a cookie is required, add some extra space. Whether ++ or not a cookie is required cannot be determined until ++ after we know which function was called. */ ++ if (*cookie_size) ++ { ++ bool use_cookie = true; ++ if (!abi_version_at_least (2)) ++ { ++ tree placement = TREE_CHAIN (args); ++ /* In G++ 3.2, the check was implemented incorrectly; it ++ looked at the placement expression, rather than the ++ type of the function. */ ++ if (placement && !TREE_CHAIN (placement) ++ && same_type_p (TREE_TYPE (TREE_VALUE (placement)), ++ ptr_type_node)) ++ use_cookie = false; ++ } ++ else ++ { ++ tree arg_types; ++ ++ arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn)); ++ /* Skip the size_t parameter. */ ++ arg_types = TREE_CHAIN (arg_types); ++ /* Check the remaining parameters (if any). */ ++ if (arg_types ++ && TREE_CHAIN (arg_types) == void_list_node ++ && same_type_p (TREE_VALUE (arg_types), ++ ptr_type_node)) ++ use_cookie = false; ++ } ++ /* If we need a cookie, adjust the number of bytes allocated. */ ++ if (use_cookie) ++ { ++ /* Update the total size. */ ++ *size = size_binop (PLUS_EXPR, *size, *cookie_size); ++ /* Update the argument list to reflect the adjusted size. */ ++ TREE_VALUE (args) = *size; ++ } ++ else ++ *cookie_size = NULL_TREE; ++ } ++ ++ /* Build the CALL_EXPR. */ ++ return build_over_call (cand, LOOKUP_NORMAL); ++} ++ ++static tree ++build_object_call (tree obj, tree args) ++{ ++ struct z_candidate *candidates = 0, *cand; ++ tree fns, convs, mem_args = NULL_TREE; ++ tree type = TREE_TYPE (obj); ++ bool any_viable_p; ++ ++ if (TYPE_PTRMEMFUNC_P (type)) ++ { ++ /* It's no good looking for an overloaded operator() on a ++ pointer-to-member-function. */ ++ error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj); ++ return error_mark_node; ++ } ++ ++ fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1); ++ if (fns == error_mark_node) ++ return error_mark_node; ++ ++ args = resolve_args (args); ++ ++ if (args == error_mark_node) ++ return error_mark_node; ++ ++ if (fns) ++ { ++ tree base = BINFO_TYPE (BASELINK_BINFO (fns)); ++ mem_args = tree_cons (NULL_TREE, build_this (obj), args); ++ ++ for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns)) ++ { ++ tree fn = OVL_CURRENT (fns); ++ if (TREE_CODE (fn) == TEMPLATE_DECL) ++ add_template_candidate (&candidates, fn, base, NULL_TREE, ++ mem_args, NULL_TREE, ++ TYPE_BINFO (type), ++ TYPE_BINFO (type), ++ LOOKUP_NORMAL, DEDUCE_CALL); ++ else ++ add_function_candidate ++ (&candidates, fn, base, mem_args, TYPE_BINFO (type), ++ TYPE_BINFO (type), LOOKUP_NORMAL); ++ } ++ } ++ ++ convs = lookup_conversions (type); ++ ++ for (; convs; convs = TREE_CHAIN (convs)) ++ { ++ tree fns = TREE_VALUE (convs); ++ tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns))); ++ ++ if ((TREE_CODE (totype) == POINTER_TYPE ++ && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE) ++ || (TREE_CODE (totype) == REFERENCE_TYPE ++ && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE) ++ || (TREE_CODE (totype) == REFERENCE_TYPE ++ && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE ++ && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE)) ++ for (; fns; fns = OVL_NEXT (fns)) ++ { ++ tree fn = OVL_CURRENT (fns); ++ if (TREE_CODE (fn) == TEMPLATE_DECL) ++ add_template_conv_candidate ++ (&candidates, fn, obj, args, totype, ++ /*access_path=*/NULL_TREE, ++ /*conversion_path=*/NULL_TREE); ++ else ++ add_conv_candidate (&candidates, fn, obj, args, ++ /*conversion_path=*/NULL_TREE, ++ /*access_path=*/NULL_TREE); ++ } ++ } ++ ++ candidates = splice_viable (candidates, pedantic, &any_viable_p); ++ if (!any_viable_p) ++ { ++ error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args); ++ print_z_candidates (candidates); ++ return error_mark_node; ++ } ++ ++ cand = tourney (candidates); ++ if (cand == 0) ++ { ++ error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args); ++ print_z_candidates (candidates); ++ return error_mark_node; ++ } ++ ++ /* Since cand->fn will be a type, not a function, for a conversion ++ function, we must be careful not to unconditionally look at ++ DECL_NAME here. */ ++ if (TREE_CODE (cand->fn) == FUNCTION_DECL ++ && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR) ++ return build_over_call (cand, LOOKUP_NORMAL); ++ ++ obj = convert_like_with_context ++ (TREE_VEC_ELT (cand->convs, 0), obj, cand->fn, -1); ++ ++ /* FIXME */ ++ return build_function_call (obj, args); ++} ++ ++static void ++op_error (enum tree_code code, enum tree_code code2, ++ tree arg1, tree arg2, tree arg3, const char *problem) ++{ ++ const char *opname; ++ ++ if (code == MODIFY_EXPR) ++ opname = assignment_operator_name_info[code2].name; ++ else ++ opname = operator_name_info[code].name; ++ ++ switch (code) ++ { ++ case COND_EXPR: ++ error ("%s for ternary 'operator?:' in '%E ? %E : %E'", ++ problem, arg1, arg2, arg3); ++ break; ++ ++ case POSTINCREMENT_EXPR: ++ case POSTDECREMENT_EXPR: ++ error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname); ++ break; ++ ++ case ARRAY_REF: ++ error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2); ++ break; ++ ++ case REALPART_EXPR: ++ case IMAGPART_EXPR: ++ error ("%s for '%s' in '%s %E'", problem, opname, opname, arg1); ++ break; ++ ++ default: ++ if (arg2) ++ error ("%s for 'operator%s' in '%E %s %E'", ++ problem, opname, arg1, opname, arg2); ++ else ++ error ("%s for 'operator%s' in '%s%E'", ++ problem, opname, opname, arg1); ++ break; ++ } ++} ++ ++/* Return the implicit conversion sequence that could be used to ++ convert E1 to E2 in [expr.cond]. */ ++ ++static tree ++conditional_conversion (tree e1, tree e2) ++{ ++ tree t1 = non_reference (TREE_TYPE (e1)); ++ tree t2 = non_reference (TREE_TYPE (e2)); ++ tree conv; ++ bool good_base; ++ ++ /* [expr.cond] ++ ++ If E2 is an lvalue: E1 can be converted to match E2 if E1 can be ++ implicitly converted (clause _conv_) to the type "reference to ++ T2", subject to the constraint that in the conversion the ++ reference must bind directly (_dcl.init.ref_) to E1. */ ++ if (real_lvalue_p (e2)) ++ { ++ conv = implicit_conversion (build_reference_type (t2), ++ t1, ++ e1, ++ LOOKUP_NO_TEMP_BIND); ++ if (conv) ++ return conv; ++ } ++ ++ /* [expr.cond] ++ ++ If E1 and E2 have class type, and the underlying class types are ++ the same or one is a base class of the other: E1 can be converted ++ to match E2 if the class of T2 is the same type as, or a base ++ class of, the class of T1, and the cv-qualification of T2 is the ++ same cv-qualification as, or a greater cv-qualification than, the ++ cv-qualification of T1. If the conversion is applied, E1 is ++ changed to an rvalue of type T2 that still refers to the original ++ source class object (or the appropriate subobject thereof). */ ++ if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2) ++ && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2))) ++ { ++ if (good_base && at_least_as_qualified_p (t2, t1)) ++ { ++ conv = build1 (IDENTITY_CONV, t1, e1); ++ if (!same_type_p (TYPE_MAIN_VARIANT (t1), ++ TYPE_MAIN_VARIANT (t2))) ++ conv = build_conv (BASE_CONV, t2, conv); ++ else ++ conv = build_conv (RVALUE_CONV, t2, conv); ++ return conv; ++ } ++ else ++ return NULL_TREE; ++ } ++ else ++ /* [expr.cond] ++ ++ Otherwise: E1 can be converted to match E2 if E1 can be implicitly ++ converted to the type that expression E2 would have if E2 were ++ converted to an rvalue (or the type it has, if E2 is an rvalue). */ ++ return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL); ++} ++ ++/* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three ++ arguments to the conditional expression. */ ++ ++tree ++build_conditional_expr (tree arg1, tree arg2, tree arg3) ++{ ++ tree arg2_type; ++ tree arg3_type; ++ tree result; ++ tree result_type = NULL_TREE; ++ bool lvalue_p = true; ++ struct z_candidate *candidates = 0; ++ struct z_candidate *cand; ++ ++ /* As a G++ extension, the second argument to the conditional can be ++ omitted. (So that `a ? : c' is roughly equivalent to `a ? a : ++ c'.) If the second operand is omitted, make sure it is ++ calculated only once. */ ++ if (!arg2) ++ { ++ if (pedantic) ++ pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression"); ++ ++ /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */ ++ if (real_lvalue_p (arg1)) ++ arg2 = arg1 = stabilize_reference (arg1); ++ else ++ arg2 = arg1 = save_expr (arg1); ++ } ++ ++ /* [expr.cond] ++ ++ The first expr ession is implicitly converted to bool (clause ++ _conv_). */ ++ arg1 = perform_implicit_conversion (boolean_type_node, arg1); ++ ++ /* If something has already gone wrong, just pass that fact up the ++ tree. */ ++ if (error_operand_p (arg1) ++ || error_operand_p (arg2) ++ || error_operand_p (arg3)) ++ return error_mark_node; ++ ++ /* [expr.cond] ++ ++ If either the second or the third operand has type (possibly ++ cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_), ++ array-to-pointer (_conv.array_), and function-to-pointer ++ (_conv.func_) standard conversions are performed on the second ++ and third operands. */ ++ arg2_type = TREE_TYPE (arg2); ++ arg3_type = TREE_TYPE (arg3); ++ if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type)) ++ { ++ /* Do the conversions. We don't these for `void' type arguments ++ since it can't have any effect and since decay_conversion ++ does not handle that case gracefully. */ ++ if (!VOID_TYPE_P (arg2_type)) ++ arg2 = decay_conversion (arg2); ++ if (!VOID_TYPE_P (arg3_type)) ++ arg3 = decay_conversion (arg3); ++ arg2_type = TREE_TYPE (arg2); ++ arg3_type = TREE_TYPE (arg3); ++ ++ /* [expr.cond] ++ ++ One of the following shall hold: ++ ++ --The second or the third operand (but not both) is a ++ throw-expression (_except.throw_); the result is of the ++ type of the other and is an rvalue. ++ ++ --Both the second and the third operands have type void; the ++ result is of type void and is an rvalue. ++ ++ We must avoid calling force_rvalue for expressions of type ++ "void" because it will complain that their value is being ++ used. */ ++ if (TREE_CODE (arg2) == THROW_EXPR ++ && TREE_CODE (arg3) != THROW_EXPR) ++ { ++ if (!VOID_TYPE_P (arg3_type)) ++ arg3 = force_rvalue (arg3); ++ arg3_type = TREE_TYPE (arg3); ++ result_type = arg3_type; ++ } ++ else if (TREE_CODE (arg2) != THROW_EXPR ++ && TREE_CODE (arg3) == THROW_EXPR) ++ { ++ if (!VOID_TYPE_P (arg2_type)) ++ arg2 = force_rvalue (arg2); ++ arg2_type = TREE_TYPE (arg2); ++ result_type = arg2_type; ++ } ++ else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type)) ++ result_type = void_type_node; ++ else ++ { ++ error ("`%E' has type `void' and is not a throw-expression", ++ VOID_TYPE_P (arg2_type) ? arg2 : arg3); ++ return error_mark_node; ++ } ++ ++ lvalue_p = false; ++ goto valid_operands; ++ } ++ /* [expr.cond] ++ ++ Otherwise, if the second and third operand have different types, ++ and either has (possibly cv-qualified) class type, an attempt is ++ made to convert each of those operands to the type of the other. */ ++ else if (!same_type_p (arg2_type, arg3_type) ++ && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type))) ++ { ++ tree conv2 = conditional_conversion (arg2, arg3); ++ tree conv3 = conditional_conversion (arg3, arg2); ++ ++ /* [expr.cond] ++ ++ If both can be converted, or one can be converted but the ++ conversion is ambiguous, the program is ill-formed. If ++ neither can be converted, the operands are left unchanged and ++ further checking is performed as described below. If exactly ++ one conversion is possible, that conversion is applied to the ++ chosen operand and the converted operand is used in place of ++ the original operand for the remainder of this section. */ ++ if ((conv2 && !ICS_BAD_FLAG (conv2) ++ && conv3 && !ICS_BAD_FLAG (conv3)) ++ || (conv2 && TREE_CODE (conv2) == AMBIG_CONV) ++ || (conv3 && TREE_CODE (conv3) == AMBIG_CONV)) ++ { ++ error ("operands to ?: have different types"); ++ return error_mark_node; ++ } ++ else if (conv2 && !ICS_BAD_FLAG (conv2)) ++ { ++ arg2 = convert_like (conv2, arg2); ++ arg2 = convert_from_reference (arg2); ++ arg2_type = TREE_TYPE (arg2); ++ } ++ else if (conv3 && !ICS_BAD_FLAG (conv3)) ++ { ++ arg3 = convert_like (conv3, arg3); ++ arg3 = convert_from_reference (arg3); ++ arg3_type = TREE_TYPE (arg3); ++ } ++ ++ /* If, after the conversion, both operands have class type, ++ treat the cv-qualification of both operands as if it were the ++ union of the cv-qualification of the operands. ++ ++ The standard is not clear about what to do in this ++ circumstance. For example, if the first operand has type ++ "const X" and the second operand has a user-defined ++ conversion to "volatile X", what is the type of the second ++ operand after this step? Making it be "const X" (matching ++ the first operand) seems wrong, as that discards the ++ qualification without actuall performing a copy. Leaving it ++ as "volatile X" seems wrong as that will result in the ++ conditional expression failing altogether, even though, ++ according to this step, the one operand could be converted to ++ the type of the other. */ ++ if ((conv2 || conv3) ++ && CLASS_TYPE_P (arg2_type) ++ && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type)) ++ arg2_type = arg3_type = ++ cp_build_qualified_type (arg2_type, ++ TYPE_QUALS (arg2_type) ++ | TYPE_QUALS (arg3_type)); ++ } ++ ++ /* [expr.cond] ++ ++ If the second and third operands are lvalues and have the same ++ type, the result is of that type and is an lvalue. */ ++ if (real_lvalue_p (arg2) ++ && real_lvalue_p (arg3) ++ && same_type_p (arg2_type, arg3_type)) ++ { ++ result_type = arg2_type; ++ goto valid_operands; ++ } ++ ++ /* [expr.cond] ++ ++ Otherwise, the result is an rvalue. If the second and third ++ operand do not have the same type, and either has (possibly ++ cv-qualified) class type, overload resolution is used to ++ determine the conversions (if any) to be applied to the operands ++ (_over.match.oper_, _over.built_). */ ++ lvalue_p = false; ++ if (!same_type_p (arg2_type, arg3_type) ++ && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type))) ++ { ++ tree args[3]; ++ tree conv; ++ bool any_viable_p; ++ ++ /* Rearrange the arguments so that add_builtin_candidate only has ++ to know about two args. In build_builtin_candidates, the ++ arguments are unscrambled. */ ++ args[0] = arg2; ++ args[1] = arg3; ++ args[2] = arg1; ++ add_builtin_candidates (&candidates, ++ COND_EXPR, ++ NOP_EXPR, ++ ansi_opname (COND_EXPR), ++ args, ++ LOOKUP_NORMAL); ++ ++ /* [expr.cond] ++ ++ If the overload resolution fails, the program is ++ ill-formed. */ ++ candidates = splice_viable (candidates, pedantic, &any_viable_p); ++ if (!any_viable_p) ++ { ++ op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); ++ print_z_candidates (candidates); ++ return error_mark_node; ++ } ++ cand = tourney (candidates); ++ if (!cand) ++ { ++ op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); ++ print_z_candidates (candidates); ++ return error_mark_node; ++ } ++ ++ /* [expr.cond] ++ ++ Otherwise, the conversions thus determined are applied, and ++ the converted operands are used in place of the original ++ operands for the remainder of this section. */ ++ conv = TREE_VEC_ELT (cand->convs, 0); ++ arg1 = convert_like (conv, arg1); ++ conv = TREE_VEC_ELT (cand->convs, 1); ++ arg2 = convert_like (conv, arg2); ++ conv = TREE_VEC_ELT (cand->convs, 2); ++ arg3 = convert_like (conv, arg3); ++ } ++ ++ /* [expr.cond] ++ ++ Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_), ++ and function-to-pointer (_conv.func_) standard conversions are ++ performed on the second and third operands. ++ ++ We need to force the lvalue-to-rvalue conversion here for class types, ++ so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues ++ that isn't wrapped with a TARGET_EXPR plays havoc with exception ++ regions. */ ++ ++ arg2 = force_rvalue (arg2); ++ if (!CLASS_TYPE_P (arg2_type)) ++ arg2_type = TREE_TYPE (arg2); ++ ++ arg3 = force_rvalue (arg3); ++ if (!CLASS_TYPE_P (arg2_type)) ++ arg3_type = TREE_TYPE (arg3); ++ ++ if (arg2 == error_mark_node || arg3 == error_mark_node) ++ return error_mark_node; ++ ++ /* [expr.cond] ++ ++ After those conversions, one of the following shall hold: ++ ++ --The second and third operands have the same type; the result is of ++ that type. */ ++ if (same_type_p (arg2_type, arg3_type)) ++ result_type = arg2_type; ++ /* [expr.cond] ++ ++ --The second and third operands have arithmetic or enumeration ++ type; the usual arithmetic conversions are performed to bring ++ them to a common type, and the result is of that type. */ ++ else if ((ARITHMETIC_TYPE_P (arg2_type) ++ || TREE_CODE (arg2_type) == ENUMERAL_TYPE) ++ && (ARITHMETIC_TYPE_P (arg3_type) ++ || TREE_CODE (arg3_type) == ENUMERAL_TYPE)) ++ { ++ /* In this case, there is always a common type. */ ++ result_type = type_after_usual_arithmetic_conversions (arg2_type, ++ arg3_type); ++ ++ if (TREE_CODE (arg2_type) == ENUMERAL_TYPE ++ && TREE_CODE (arg3_type) == ENUMERAL_TYPE) ++ warning ("enumeral mismatch in conditional expression: `%T' vs `%T'", ++ arg2_type, arg3_type); ++ else if (extra_warnings ++ && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE ++ && !same_type_p (arg3_type, type_promotes_to (arg2_type))) ++ || (TREE_CODE (arg3_type) == ENUMERAL_TYPE ++ && !same_type_p (arg2_type, type_promotes_to (arg3_type))))) ++ warning ("enumeral and non-enumeral type in conditional expression"); ++ ++ arg2 = perform_implicit_conversion (result_type, arg2); ++ arg3 = perform_implicit_conversion (result_type, arg3); ++ } ++ /* [expr.cond] ++ ++ --The second and third operands have pointer type, or one has ++ pointer type and the other is a null pointer constant; pointer ++ conversions (_conv.ptr_) and qualification conversions ++ (_conv.qual_) are performed to bring them to their composite ++ pointer type (_expr.rel_). The result is of the composite ++ pointer type. ++ ++ --The second and third operands have pointer to member type, or ++ one has pointer to member type and the other is a null pointer ++ constant; pointer to member conversions (_conv.mem_) and ++ qualification conversions (_conv.qual_) are performed to bring ++ them to a common type, whose cv-qualification shall match the ++ cv-qualification of either the second or the third operand. ++ The result is of the common type. */ ++ else if ((null_ptr_cst_p (arg2) ++ && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type))) ++ || (null_ptr_cst_p (arg3) ++ && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type))) ++ || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type)) ++ || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type)) ++ || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type))) ++ { ++ result_type = composite_pointer_type (arg2_type, arg3_type, arg2, ++ arg3, "conditional expression"); ++ if (result_type == error_mark_node) ++ return error_mark_node; ++ arg2 = perform_implicit_conversion (result_type, arg2); ++ arg3 = perform_implicit_conversion (result_type, arg3); ++ } ++ ++ if (!result_type) ++ { ++ error ("operands to ?: have different types"); ++ return error_mark_node; ++ } ++ ++ valid_operands: ++ result = fold_if_not_in_template (build (COND_EXPR, result_type, ++ arg1, arg2, arg3)); ++ /* We can't use result_type below, as fold might have returned a ++ throw_expr. */ ++ ++ /* Expand both sides into the same slot, hopefully the target of the ++ ?: expression. We used to check for TARGET_EXPRs here, but now we ++ sometimes wrap them in NOP_EXPRs so the test would fail. */ ++ if (!lvalue_p && CLASS_TYPE_P (TREE_TYPE (result))) ++ result = get_target_expr (result); ++ ++ /* If this expression is an rvalue, but might be mistaken for an ++ lvalue, we must add a NON_LVALUE_EXPR. */ ++ if (!lvalue_p && real_lvalue_p (result)) ++ result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result); ++ ++ return result; ++} ++ ++/* OPERAND is an operand to an expression. Perform necessary steps ++ required before using it. If OPERAND is NULL_TREE, NULL_TREE is ++ returned. */ ++ ++static tree ++prep_operand (tree operand) ++{ ++ if (operand) ++ { ++ operand = convert_from_reference (operand); ++ if (CLASS_TYPE_P (TREE_TYPE (operand)) ++ && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand))) ++ /* Make sure the template type is instantiated now. */ ++ instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand))); ++ } ++ ++ return operand; ++} ++ ++/* Add each of the viable functions in FNS (a FUNCTION_DECL or ++ OVERLOAD) to the CANDIDATES, returning an updated list of ++ CANDIDATES. The ARGS are the arguments provided to the call, ++ without any implicit object parameter. The EXPLICIT_TARGS are ++ explicit template arguments provided. TEMPLATE_ONLY is true if ++ only template functions should be considered. CONVERSION_PATH, ++ ACCESS_PATH, and FLAGS are as for add_function_candidate. */ ++ ++static void ++add_candidates (tree fns, tree args, ++ tree explicit_targs, bool template_only, ++ tree conversion_path, tree access_path, ++ int flags, ++ struct z_candidate **candidates) ++{ ++ tree ctype; ++ tree non_static_args; ++ ++ ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE; ++ /* Delay creating the implicit this parameter until it is needed. */ ++ non_static_args = NULL_TREE; ++ ++ while (fns) ++ { ++ tree fn; ++ tree fn_args; ++ ++ fn = OVL_CURRENT (fns); ++ /* Figure out which set of arguments to use. */ ++ if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) ++ { ++ /* If this function is a non-static member, prepend the implicit ++ object parameter. */ ++ if (!non_static_args) ++ non_static_args = tree_cons (NULL_TREE, ++ build_this (TREE_VALUE (args)), ++ TREE_CHAIN (args)); ++ fn_args = non_static_args; ++ } ++ else ++ /* Otherwise, just use the list of arguments provided. */ ++ fn_args = args; ++ ++ if (TREE_CODE (fn) == TEMPLATE_DECL) ++ add_template_candidate (candidates, ++ fn, ++ ctype, ++ explicit_targs, ++ fn_args, ++ NULL_TREE, ++ access_path, ++ conversion_path, ++ flags, ++ DEDUCE_CALL); ++ else if (!template_only) ++ add_function_candidate (candidates, ++ fn, ++ ctype, ++ fn_args, ++ access_path, ++ conversion_path, ++ flags); ++ fns = OVL_NEXT (fns); ++ } ++} ++ ++tree ++build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, ++ bool *overloaded_p) ++{ ++ struct z_candidate *candidates = 0, *cand; ++ tree arglist, fnname; ++ tree args[3]; ++ enum tree_code code2 = NOP_EXPR; ++ tree conv; ++ bool strict_p; ++ bool any_viable_p; ++ ++ if (error_operand_p (arg1) ++ || error_operand_p (arg2) ++ || error_operand_p (arg3)) ++ return error_mark_node; ++ ++ if (code == MODIFY_EXPR) ++ { ++ code2 = TREE_CODE (arg3); ++ arg3 = NULL_TREE; ++ fnname = ansi_assopname (code2); ++ } ++ else ++ fnname = ansi_opname (code); ++ ++ arg1 = prep_operand (arg1); ++ ++ switch (code) ++ { ++ case NEW_EXPR: ++ case VEC_NEW_EXPR: ++ case VEC_DELETE_EXPR: ++ case DELETE_EXPR: ++ /* Use build_op_new_call and build_op_delete_call instead. */ ++ abort (); ++ ++ case CALL_EXPR: ++ return build_object_call (arg1, arg2); ++ ++ default: ++ break; ++ } ++ ++ arg2 = prep_operand (arg2); ++ arg3 = prep_operand (arg3); ++ ++ if (code == COND_EXPR) ++ { ++ if (arg2 == NULL_TREE ++ || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE ++ || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE ++ || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2)) ++ && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3)))) ++ goto builtin; ++ } ++ else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1)) ++ && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2)))) ++ goto builtin; ++ ++ if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR) ++ arg2 = integer_zero_node; ++ ++ arglist = NULL_TREE; ++ if (arg3) ++ arglist = tree_cons (NULL_TREE, arg3, arglist); ++ if (arg2) ++ arglist = tree_cons (NULL_TREE, arg2, arglist); ++ arglist = tree_cons (NULL_TREE, arg1, arglist); ++ ++ /* Add namespace-scope operators to the list of functions to ++ consider. */ ++ add_candidates (lookup_function_nonclass (fnname, arglist), ++ arglist, NULL_TREE, false, NULL_TREE, NULL_TREE, ++ flags, &candidates); ++ /* Add class-member operators to the candidate set. */ ++ if (CLASS_TYPE_P (TREE_TYPE (arg1))) ++ { ++ tree fns; ++ ++ fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1); ++ if (fns == error_mark_node) ++ return fns; ++ if (fns) ++ add_candidates (BASELINK_FUNCTIONS (fns), arglist, ++ NULL_TREE, false, ++ BASELINK_BINFO (fns), ++ TYPE_BINFO (TREE_TYPE (arg1)), ++ flags, &candidates); ++ } ++ ++ /* Rearrange the arguments for ?: so that add_builtin_candidate only has ++ to know about two args; a builtin candidate will always have a first ++ parameter of type bool. We'll handle that in ++ build_builtin_candidate. */ ++ if (code == COND_EXPR) ++ { ++ args[0] = arg2; ++ args[1] = arg3; ++ args[2] = arg1; ++ } ++ else ++ { ++ args[0] = arg1; ++ args[1] = arg2; ++ args[2] = NULL_TREE; ++ } ++ ++ add_builtin_candidates (&candidates, code, code2, fnname, args, flags); ++ ++ switch (code) ++ { ++ case COMPOUND_EXPR: ++ case ADDR_EXPR: ++ /* For these, the built-in candidates set is empty ++ [over.match.oper]/3. We don't want non-strict matches ++ because exact matches are always possible with built-in ++ operators. The built-in candidate set for COMPONENT_REF ++ would be empty too, but since there are no such built-in ++ operators, we accept non-strict matches for them. */ ++ strict_p = true; ++ break; ++ ++ default: ++ strict_p = pedantic; ++ break; ++ } ++ ++ candidates = splice_viable (candidates, strict_p, &any_viable_p); ++ if (!any_viable_p) ++ { ++ switch (code) ++ { ++ case POSTINCREMENT_EXPR: ++ case POSTDECREMENT_EXPR: ++ /* Look for an `operator++ (int)'. If they didn't have ++ one, then we fall back to the old way of doing things. */ ++ if (flags & LOOKUP_COMPLAIN) ++ pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead", ++ fnname, ++ operator_name_info[code].name); ++ if (code == POSTINCREMENT_EXPR) ++ code = PREINCREMENT_EXPR; ++ else ++ code = PREDECREMENT_EXPR; ++ return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE, ++ overloaded_p); ++ ++ /* The caller will deal with these. */ ++ case ADDR_EXPR: ++ case COMPOUND_EXPR: ++ case COMPONENT_REF: ++ return NULL_TREE; ++ ++ default: ++ break; ++ } ++ if (flags & LOOKUP_COMPLAIN) ++ { ++ op_error (code, code2, arg1, arg2, arg3, "no match"); ++ print_z_candidates (candidates); ++ } ++ return error_mark_node; ++ } ++ ++ cand = tourney (candidates); ++ if (cand == 0) ++ { ++ if (flags & LOOKUP_COMPLAIN) ++ { ++ op_error (code, code2, arg1, arg2, arg3, "ambiguous overload"); ++ print_z_candidates (candidates); ++ } ++ return error_mark_node; ++ } ++ ++ if (TREE_CODE (cand->fn) == FUNCTION_DECL) ++ { ++ if (overloaded_p) ++ *overloaded_p = true; ++ ++ return build_over_call (cand, LOOKUP_NORMAL); ++ } ++ ++ /* Check for comparison of different enum types. */ ++ switch (code) ++ { ++ case GT_EXPR: ++ case LT_EXPR: ++ case GE_EXPR: ++ case LE_EXPR: ++ case EQ_EXPR: ++ case NE_EXPR: ++ if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE ++ && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE ++ && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) ++ != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))) ++ { ++ warning ("comparison between `%#T' and `%#T'", ++ TREE_TYPE (arg1), TREE_TYPE (arg2)); ++ } ++ break; ++ default: ++ break; ++ } ++ ++ /* We need to strip any leading REF_BIND so that bitfields don't cause ++ errors. This should not remove any important conversions, because ++ builtins don't apply to class objects directly. */ ++ conv = TREE_VEC_ELT (cand->convs, 0); ++ if (TREE_CODE (conv) == REF_BIND) ++ conv = TREE_OPERAND (conv, 0); ++ arg1 = convert_like (conv, arg1); ++ if (arg2) ++ { ++ conv = TREE_VEC_ELT (cand->convs, 1); ++ if (TREE_CODE (conv) == REF_BIND) ++ conv = TREE_OPERAND (conv, 0); ++ arg2 = convert_like (conv, arg2); ++ } ++ if (arg3) ++ { ++ conv = TREE_VEC_ELT (cand->convs, 2); ++ if (TREE_CODE (conv) == REF_BIND) ++ conv = TREE_OPERAND (conv, 0); ++ arg3 = convert_like (conv, arg3); ++ } ++ ++builtin: ++ switch (code) ++ { ++ case MODIFY_EXPR: ++ return build_modify_expr (arg1, code2, arg2); ++ ++ case INDIRECT_REF: ++ return build_indirect_ref (arg1, "unary *"); ++ ++ case PLUS_EXPR: ++ case MINUS_EXPR: ++ case MULT_EXPR: ++ case TRUNC_DIV_EXPR: ++ case GT_EXPR: ++ case LT_EXPR: ++ case GE_EXPR: ++ case LE_EXPR: ++ case EQ_EXPR: ++ case NE_EXPR: ++ case MAX_EXPR: ++ case MIN_EXPR: ++ case LSHIFT_EXPR: ++ case RSHIFT_EXPR: ++ case TRUNC_MOD_EXPR: ++ case BIT_AND_EXPR: ++ case BIT_IOR_EXPR: ++ case BIT_XOR_EXPR: ++ case TRUTH_ANDIF_EXPR: ++ case TRUTH_ORIF_EXPR: ++ return cp_build_binary_op (code, arg1, arg2); ++ ++ case CONVERT_EXPR: ++ case NEGATE_EXPR: ++ case BIT_NOT_EXPR: ++ case TRUTH_NOT_EXPR: ++ case PREINCREMENT_EXPR: ++ case POSTINCREMENT_EXPR: ++ case PREDECREMENT_EXPR: ++ case POSTDECREMENT_EXPR: ++ case REALPART_EXPR: ++ case IMAGPART_EXPR: ++ return build_unary_op (code, arg1, candidates != 0); ++ ++ case ARRAY_REF: ++ return build_array_ref (arg1, arg2); ++ ++ case COND_EXPR: ++ return build_conditional_expr (arg1, arg2, arg3); ++ ++ case MEMBER_REF: ++ return build_m_component_ref ++ (build_indirect_ref (arg1, NULL), arg2); ++ ++ /* The caller will deal with these. */ ++ case ADDR_EXPR: ++ case COMPONENT_REF: ++ case COMPOUND_EXPR: ++ return NULL_TREE; ++ ++ default: ++ abort (); ++ return NULL_TREE; ++ } ++} ++ ++/* Build a call to operator delete. This has to be handled very specially, ++ because the restrictions on what signatures match are different from all ++ other call instances. For a normal delete, only a delete taking (void *) ++ or (void *, size_t) is accepted. For a placement delete, only an exact ++ match with the placement new is accepted. ++ ++ CODE is either DELETE_EXPR or VEC_DELETE_EXPR. ++ ADDR is the pointer to be deleted. ++ SIZE is the size of the memory block to be deleted. ++ FLAGS are the usual overloading flags. ++ PLACEMENT is the corresponding placement new call, or NULL_TREE. */ ++ ++tree ++build_op_delete_call (enum tree_code code, tree addr, tree size, ++ int flags, tree placement) ++{ ++ tree fn = NULL_TREE; ++ tree fns, fnname, argtypes, args, type; ++ int pass; ++ ++ if (addr == error_mark_node) ++ return error_mark_node; ++ ++ type = strip_array_types (TREE_TYPE (TREE_TYPE (addr))); ++ ++ fnname = ansi_opname (code); ++ ++ if (IS_AGGR_TYPE (type) && ! (flags & LOOKUP_GLOBAL)) ++ /* In [class.free] ++ ++ If the result of the lookup is ambiguous or inaccessible, or if ++ the lookup selects a placement deallocation function, the ++ program is ill-formed. ++ ++ Therefore, we ask lookup_fnfields to complain about ambiguity. */ ++ { ++ fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1); ++ if (fns == error_mark_node) ++ return error_mark_node; ++ } ++ else ++ fns = NULL_TREE; ++ ++ if (fns == NULL_TREE) ++ fns = lookup_name_nonclass (fnname); ++ ++ if (placement) ++ { ++ tree alloc_fn; ++ tree call_expr; ++ ++ /* Find the allocation function that is being called. */ ++ call_expr = placement; ++ /* Extract the function. */ ++ alloc_fn = get_callee_fndecl (call_expr); ++ my_friendly_assert (alloc_fn != NULL_TREE, 20020327); ++ /* Then the second parm type. */ ++ argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn))); ++ /* Also the second argument. */ ++ args = TREE_CHAIN (TREE_OPERAND (call_expr, 1)); ++ } ++ else ++ { ++ /* First try it without the size argument. */ ++ argtypes = void_list_node; ++ args = NULL_TREE; ++ } ++ ++ /* Strip const and volatile from addr. */ ++ addr = cp_convert (ptr_type_node, addr); ++ ++ /* We make two tries at finding a matching `operator delete'. On ++ the first pass, we look for a one-operator (or placement) ++ operator delete. If we're not doing placement delete, then on ++ the second pass we look for a two-argument delete. */ ++ for (pass = 0; pass < (placement ? 1 : 2); ++pass) ++ { ++ /* Go through the `operator delete' functions looking for one ++ with a matching type. */ ++ for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns; ++ fn; ++ fn = OVL_NEXT (fn)) ++ { ++ tree t; ++ ++ /* The first argument must be "void *". */ ++ t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn))); ++ if (!same_type_p (TREE_VALUE (t), ptr_type_node)) ++ continue; ++ t = TREE_CHAIN (t); ++ /* On the first pass, check the rest of the arguments. */ ++ if (pass == 0) ++ { ++ tree a = argtypes; ++ while (a && t) ++ { ++ if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t))) ++ break; ++ a = TREE_CHAIN (a); ++ t = TREE_CHAIN (t); ++ } ++ if (!a && !t) ++ break; ++ } ++ /* On the second pass, the second argument must be ++ "size_t". */ ++ else if (pass == 1 ++ && same_type_p (TREE_VALUE (t), sizetype) ++ && TREE_CHAIN (t) == void_list_node) ++ break; ++ } ++ ++ /* If we found a match, we're done. */ ++ if (fn) ++ break; ++ } ++ ++ /* If we have a matching function, call it. */ ++ if (fn) ++ { ++ /* Make sure we have the actual function, and not an ++ OVERLOAD. */ ++ fn = OVL_CURRENT (fn); ++ ++ /* If the FN is a member function, make sure that it is ++ accessible. */ ++ if (DECL_CLASS_SCOPE_P (fn)) ++ perform_or_defer_access_check (TYPE_BINFO (type), fn); ++ ++ if (pass == 0) ++ args = tree_cons (NULL_TREE, addr, args); ++ else ++ args = tree_cons (NULL_TREE, addr, ++ build_tree_list (NULL_TREE, size)); ++ ++ if (placement) ++ { ++ /* The placement args might not be suitable for overload ++ resolution at this point, so build the call directly. */ ++ mark_used (fn); ++ return build_cxx_call (fn, args, args); ++ } ++ else ++ return build_function_call (fn, args); ++ } ++ ++ /* If we are doing placement delete we do nothing if we don't find a ++ matching op delete. */ ++ if (placement) ++ return NULL_TREE; ++ ++ error ("no suitable `operator %s' for `%T'", ++ operator_name_info[(int)code].name, type); ++ return error_mark_node; ++} ++ ++/* If the current scope isn't allowed to access DECL along ++ BASETYPE_PATH, give an error. The most derived class in ++ BASETYPE_PATH is the one used to qualify DECL. */ ++ ++bool ++enforce_access (tree basetype_path, tree decl) ++{ ++ my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624); ++ ++ if (!accessible_p (basetype_path, decl)) ++ { ++ if (TREE_PRIVATE (decl)) ++ cp_error_at ("`%+#D' is private", decl); ++ else if (TREE_PROTECTED (decl)) ++ cp_error_at ("`%+#D' is protected", decl); ++ else ++ cp_error_at ("`%+#D' is inaccessible", decl); ++ error ("within this context"); ++ return false; ++ } ++ ++ return true; ++} ++ ++/* Check that a callable constructor to initialize a temporary of ++ TYPE from an EXPR exists. */ ++ ++static void ++check_constructor_callable (tree type, tree expr) ++{ ++ build_special_member_call (NULL_TREE, ++ complete_ctor_identifier, ++ build_tree_list (NULL_TREE, expr), ++ TYPE_BINFO (type), ++ LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING ++ | LOOKUP_NO_CONVERSION ++ | LOOKUP_CONSTRUCTOR_CALLABLE); ++} ++ ++/* Initialize a temporary of type TYPE with EXPR. The FLAGS are a ++ bitwise or of LOOKUP_* values. If any errors are warnings are ++ generated, set *DIAGNOSTIC_FN to "error" or "warning", ++ respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN ++ to NULL. */ ++ ++static tree ++build_temp (tree expr, tree type, int flags, ++ void (**diagnostic_fn)(const char *, ...)) ++{ ++ int savew, savee; ++ ++ savew = warningcount, savee = errorcount; ++ expr = build_special_member_call (NULL_TREE, ++ complete_ctor_identifier, ++ build_tree_list (NULL_TREE, expr), ++ TYPE_BINFO (type), ++ flags); ++ if (warningcount > savew) ++ *diagnostic_fn = warning; ++ else if (errorcount > savee) ++ *diagnostic_fn = error; ++ else ++ *diagnostic_fn = NULL; ++ return expr; ++} ++ ++ ++/* Perform the conversions in CONVS on the expression EXPR. FN and ++ ARGNUM are used for diagnostics. ARGNUM is zero based, -1 ++ indicates the `this' argument of a method. INNER is nonzero when ++ being called to continue a conversion chain. It is negative when a ++ reference binding will be applied, positive otherwise. If ++ ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious ++ conversions will be emitted if appropriate. */ ++ ++static tree ++convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner, ++ bool issue_conversion_warnings) ++{ ++ tree totype = TREE_TYPE (convs); ++ void (*diagnostic_fn)(const char *, ...); ++ ++ if (ICS_BAD_FLAG (convs) ++ && TREE_CODE (convs) != USER_CONV ++ && TREE_CODE (convs) != AMBIG_CONV ++ && TREE_CODE (convs) != REF_BIND) ++ { ++ tree t = convs; ++ for (; t; t = TREE_OPERAND (t, 0)) ++ { ++ if (TREE_CODE (t) == USER_CONV || !ICS_BAD_FLAG (t)) ++ { ++ expr = convert_like_real (t, expr, fn, argnum, 1, ++ /*issue_conversion_warnings=*/false); ++ break; ++ } ++ else if (TREE_CODE (t) == AMBIG_CONV) ++ return convert_like_real (t, expr, fn, argnum, 1, ++ /*issue_conversion_warnings=*/false); ++ else if (TREE_CODE (t) == IDENTITY_CONV) ++ break; ++ } ++ pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype); ++ if (fn) ++ pedwarn (" initializing argument %P of `%D'", argnum, fn); ++ return cp_convert (totype, expr); ++ } ++ ++ if (issue_conversion_warnings) ++ expr = dubious_conversion_warnings ++ (totype, expr, "converting", fn, argnum); ++ switch (TREE_CODE (convs)) ++ { ++ case USER_CONV: ++ { ++ struct z_candidate *cand = USER_CONV_CAND (convs); ++ tree convfn = cand->fn; ++ tree args; ++ ++ if (DECL_CONSTRUCTOR_P (convfn)) ++ { ++ tree t = build_int_2 (0, 0); ++ TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn)); ++ ++ args = build_tree_list (NULL_TREE, expr); ++ if (DECL_HAS_IN_CHARGE_PARM_P (convfn) ++ || DECL_HAS_VTT_PARM_P (convfn)) ++ /* We should never try to call the abstract or base constructor ++ from here. */ ++ abort (); ++ args = tree_cons (NULL_TREE, t, args); ++ } ++ else ++ args = build_this (expr); ++ expr = build_over_call (cand, LOOKUP_NORMAL); ++ ++ /* If this is a constructor or a function returning an aggr type, ++ we need to build up a TARGET_EXPR. */ ++ if (DECL_CONSTRUCTOR_P (convfn)) ++ expr = build_cplus_new (totype, expr); ++ ++ /* The result of the call is then used to direct-initialize the object ++ that is the destination of the copy-initialization. [dcl.init] ++ ++ Note that this step is not reflected in the conversion sequence; ++ it affects the semantics when we actually perform the ++ conversion, but is not considered during overload resolution. ++ ++ If the target is a class, that means call a ctor. */ ++ if (IS_AGGR_TYPE (totype) ++ && (inner >= 0 || !lvalue_p (expr))) ++ { ++ expr = (build_temp ++ (expr, totype, ++ /* Core issue 84, now a DR, says that we don't ++ allow UDCs for these args (which deliberately ++ breaks copy-init of an auto_ptr from an ++ auto_ptr). */ ++ LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION, ++ &diagnostic_fn)); ++ ++ if (diagnostic_fn) ++ { ++ if (fn) ++ diagnostic_fn ++ (" initializing argument %P of `%D' from result of `%D'", ++ argnum, fn, convfn); ++ else ++ diagnostic_fn ++ (" initializing temporary from result of `%D'", convfn); ++ } ++ expr = build_cplus_new (totype, expr); ++ } ++ return expr; ++ } ++ case IDENTITY_CONV: ++ if (type_unknown_p (expr)) ++ expr = instantiate_type (totype, expr, tf_error | tf_warning); ++ /* Convert a non-array constant variable to its underlying ++ value, unless we are about to bind it to a reference, in ++ which case we need to leave it as an lvalue. */ ++ if (inner >= 0 ++ && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) ++ expr = decl_constant_value (expr); ++ if (CHECK_COPY_CONSTRUCTOR_P (convs)) ++ check_constructor_callable (totype, expr); ++ ++ return expr; ++ case AMBIG_CONV: ++ /* Call build_user_type_conversion again for the error. */ ++ return build_user_type_conversion ++ (totype, TREE_OPERAND (convs, 0), LOOKUP_NORMAL); ++ ++ default: ++ break; ++ }; ++ ++ expr = convert_like_real (TREE_OPERAND (convs, 0), expr, fn, argnum, ++ TREE_CODE (convs) == REF_BIND ? -1 : 1, ++ /*issue_conversion_warnings=*/false); ++ if (expr == error_mark_node) ++ return error_mark_node; ++ ++ switch (TREE_CODE (convs)) ++ { ++ case RVALUE_CONV: ++ if (! IS_AGGR_TYPE (totype)) ++ return expr; ++ /* Else fall through. */ ++ case BASE_CONV: ++ if (TREE_CODE (convs) == BASE_CONV && !NEED_TEMPORARY_P (convs)) ++ { ++ /* We are going to bind a reference directly to a base-class ++ subobject of EXPR. */ ++ if (CHECK_COPY_CONSTRUCTOR_P (convs)) ++ check_constructor_callable (TREE_TYPE (expr), expr); ++ /* Build an expression for `*((base*) &expr)'. */ ++ expr = build_unary_op (ADDR_EXPR, expr, 0); ++ expr = perform_implicit_conversion (build_pointer_type (totype), ++ expr); ++ expr = build_indirect_ref (expr, "implicit conversion"); ++ return expr; ++ } ++ ++ /* Copy-initialization where the cv-unqualified version of the source ++ type is the same class as, or a derived class of, the class of the ++ destination [is treated as direct-initialization]. [dcl.init] */ ++ expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING, ++ &diagnostic_fn); ++ if (diagnostic_fn && fn) ++ diagnostic_fn (" initializing argument %P of `%D'", argnum, fn); ++ return build_cplus_new (totype, expr); ++ ++ case REF_BIND: ++ { ++ tree ref_type = totype; ++ ++ /* If necessary, create a temporary. */ ++ if (NEED_TEMPORARY_P (convs) || !lvalue_p (expr)) ++ { ++ tree type = TREE_TYPE (TREE_OPERAND (convs, 0)); ++ ++ if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))) ++ { ++ /* If the reference is volatile or non-const, we ++ cannot create a temporary. */ ++ cp_lvalue_kind lvalue = real_lvalue_p (expr); ++ ++ if (lvalue & clk_bitfield) ++ error ("cannot bind bitfield `%E' to `%T'", ++ expr, ref_type); ++ else if (lvalue & clk_packed) ++ error ("cannot bind packed field `%E' to `%T'", ++ expr, ref_type); ++ else ++ error ("cannot bind rvalue `%E' to `%T'", expr, ref_type); ++ return error_mark_node; ++ } ++ expr = build_target_expr_with_type (expr, type); ++ } ++ ++ /* Take the address of the thing to which we will bind the ++ reference. */ ++ expr = build_unary_op (ADDR_EXPR, expr, 1); ++ if (expr == error_mark_node) ++ return error_mark_node; ++ ++ /* Convert it to a pointer to the type referred to by the ++ reference. This will adjust the pointer if a derived to ++ base conversion is being performed. */ ++ expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)), ++ expr); ++ /* Convert the pointer to the desired reference type. */ ++ return build_nop (ref_type, expr); ++ } ++ ++ case LVALUE_CONV: ++ return decay_conversion (expr); ++ ++ case QUAL_CONV: ++ /* Warn about deprecated conversion if appropriate. */ ++ string_conv_p (totype, expr, 1); ++ break; ++ ++ default: ++ break; ++ } ++ return ocp_convert (totype, expr, CONV_IMPLICIT, ++ LOOKUP_NORMAL|LOOKUP_NO_CONVERSION); ++} ++ ++/* Build a call to __builtin_trap. */ ++ ++static tree ++call_builtin_trap (void) ++{ ++ tree fn = IDENTIFIER_GLOBAL_VALUE (get_identifier ("__builtin_trap")); ++ ++ my_friendly_assert (fn != NULL, 20030927); ++ fn = build_call (fn, NULL_TREE); ++ return fn; ++} ++ ++/* ARG is being passed to a varargs function. Perform any conversions ++ required. Return the converted value. */ ++ ++tree ++convert_arg_to_ellipsis (tree arg) ++{ ++ /* [expr.call] ++ ++ The lvalue-to-rvalue, array-to-pointer, and function-to-pointer ++ standard conversions are performed. */ ++ arg = decay_conversion (arg); ++ /* [expr.call] ++ ++ If the argument has integral or enumeration type that is subject ++ to the integral promotions (_conv.prom_), or a floating point ++ type that is subject to the floating point promotion ++ (_conv.fpprom_), the value of the argument is converted to the ++ promoted type before the call. */ ++ if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE ++ && (TYPE_PRECISION (TREE_TYPE (arg)) ++ < TYPE_PRECISION (double_type_node))) ++ arg = convert_to_real (double_type_node, arg); ++ else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg))) ++ arg = perform_integral_promotions (arg); ++ ++ arg = require_complete_type (arg); ++ ++ if (arg != error_mark_node ++ && !pod_type_p (TREE_TYPE (arg))) ++ { ++ /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn ++ here and do a bitwise copy, but now cp_expr_size will abort if we ++ try to do that. ++ If the call appears in the context of a sizeof expression, ++ there is no need to emit a warning, since the expression won't be ++ evaluated. We keep the builtin_trap just as a safety check. */ ++ if (!skip_evaluation) ++ warning ("cannot pass objects of non-POD type `%#T' through `...'; " ++ "call will abort at runtime", TREE_TYPE (arg)); ++ arg = call_builtin_trap (); ++ arg = build (COMPOUND_EXPR, integer_type_node, arg, ++ integer_zero_node); ++ } ++ ++ return arg; ++} ++ ++/* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */ ++ ++tree ++build_x_va_arg (tree expr, tree type) ++{ ++ if (processing_template_decl) ++ return build_min (VA_ARG_EXPR, type, expr); ++ ++ type = complete_type_or_else (type, NULL_TREE); ++ ++ if (expr == error_mark_node || !type) ++ return error_mark_node; ++ ++ if (! pod_type_p (type)) ++ { ++ /* Undefined behavior [expr.call] 5.2.2/7. */ ++ warning ("cannot receive objects of non-POD type `%#T' through `...'; \ ++call will abort at runtime", ++ type); ++ expr = convert (build_pointer_type (type), null_node); ++ expr = build (COMPOUND_EXPR, TREE_TYPE (expr), ++ call_builtin_trap (), expr); ++ expr = build_indirect_ref (expr, NULL); ++ return expr; ++ } ++ ++ return build_va_arg (expr, type); ++} ++ ++/* TYPE has been given to va_arg. Apply the default conversions which ++ would have happened when passed via ellipsis. Return the promoted ++ type, or the passed type if there is no change. */ ++ ++tree ++cxx_type_promotes_to (tree type) ++{ ++ tree promote; ++ ++ /* Perform the array-to-pointer and function-to-pointer ++ conversions. */ ++ type = type_decays_to (type); ++ ++ promote = type_promotes_to (type); ++ if (same_type_p (type, promote)) ++ promote = type; ++ ++ return promote; ++} ++ ++/* ARG is a default argument expression being passed to a parameter of ++ the indicated TYPE, which is a parameter to FN. Do any required ++ conversions. Return the converted value. */ ++ ++tree ++convert_default_arg (tree type, tree arg, tree fn, int parmnum) ++{ ++ /* If the ARG is an unparsed default argument expression, the ++ conversion cannot be performed. */ ++ if (TREE_CODE (arg) == DEFAULT_ARG) ++ { ++ error ("the default argument for parameter %d of `%D' has " ++ "not yet been parsed", ++ parmnum, fn); ++ return error_mark_node; ++ } ++ ++ if (fn && DECL_TEMPLATE_INFO (fn)) ++ arg = tsubst_default_argument (fn, type, arg); ++ ++ arg = break_out_target_exprs (arg); ++ ++ if (TREE_CODE (arg) == CONSTRUCTOR) ++ { ++ arg = digest_init (type, arg, 0); ++ arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL, ++ "default argument", fn, parmnum); ++ } ++ else ++ { ++ /* This could get clobbered by the following call. */ ++ if (TREE_HAS_CONSTRUCTOR (arg)) ++ arg = copy_node (arg); ++ ++ arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL, ++ "default argument", fn, parmnum); ++ arg = convert_for_arg_passing (type, arg); ++ } ++ ++ return arg; ++} ++ ++/* Returns the type which will really be used for passing an argument of ++ type TYPE. */ ++ ++tree ++type_passed_as (tree type) ++{ ++ /* Pass classes with copy ctors by invisible reference. */ ++ if (TREE_ADDRESSABLE (type)) ++ type = build_reference_type (type); ++ else if (PROMOTE_PROTOTYPES ++ && INTEGRAL_TYPE_P (type) ++ && COMPLETE_TYPE_P (type) ++ && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), ++ TYPE_SIZE (integer_type_node))) ++ type = integer_type_node; ++ ++ return type; ++} ++ ++/* Actually perform the appropriate conversion. */ ++ ++tree ++convert_for_arg_passing (tree type, tree val) ++{ ++ if (val == error_mark_node) ++ ; ++ /* Pass classes with copy ctors by invisible reference. */ ++ else if (TREE_ADDRESSABLE (type)) ++ val = build1 (ADDR_EXPR, build_reference_type (type), val); ++ else if (PROMOTE_PROTOTYPES ++ && INTEGRAL_TYPE_P (type) ++ && COMPLETE_TYPE_P (type) ++ && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), ++ TYPE_SIZE (integer_type_node))) ++ val = perform_integral_promotions (val); ++ return val; ++} ++ ++/* Returns true iff FN is a function with magic varargs, i.e. ones for ++ which no conversions at all should be done. This is true for some ++ builtins which don't act like normal functions. */ ++ ++static bool ++magic_varargs_p (tree fn) ++{ ++ if (DECL_BUILT_IN (fn)) ++ switch (DECL_FUNCTION_CODE (fn)) ++ { ++ case BUILT_IN_CLASSIFY_TYPE: ++ case BUILT_IN_CONSTANT_P: ++ case BUILT_IN_NEXT_ARG: ++ case BUILT_IN_STDARG_START: ++ case BUILT_IN_VA_START: ++ return true; ++ ++ default:; ++ } ++ ++ return false; ++} ++ ++/* Subroutine of the various build_*_call functions. Overload resolution ++ has chosen a winning candidate CAND; build up a CALL_EXPR accordingly. ++ ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a ++ bitmask of various LOOKUP_* flags which apply to the call itself. */ ++ ++static tree ++build_over_call (struct z_candidate *cand, int flags) ++{ ++ tree fn = cand->fn; ++ tree args = cand->args; ++ tree convs = cand->convs; ++ tree converted_args = NULL_TREE; ++ tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn)); ++ tree conv, arg, val; ++ int i = 0; ++ int is_method = 0; ++ ++ /* In a template, there is no need to perform all of the work that ++ is normally done. We are only interested in the type of the call ++ expression, i.e., the return type of the function. Any semantic ++ errors will be deferred until the template is instantiated. */ ++ if (processing_template_decl) ++ { ++ tree expr; ++ tree return_type; ++ return_type = TREE_TYPE (TREE_TYPE (fn)); ++ expr = build (CALL_EXPR, return_type, fn, args); ++ if (TREE_THIS_VOLATILE (fn) && cfun) ++ current_function_returns_abnormally = 1; ++ if (!VOID_TYPE_P (return_type)) ++ require_complete_type (return_type); ++ return convert_from_reference (expr); ++ } ++ ++ /* Give any warnings we noticed during overload resolution. */ ++ if (cand->warnings) ++ for (val = cand->warnings; val; val = TREE_CHAIN (val)) ++ joust (cand, WRAPPER_ZC (TREE_VALUE (val)), 1); ++ ++ if (DECL_FUNCTION_MEMBER_P (fn)) ++ { ++ /* If FN is a template function, two cases must be considered. ++ For example: ++ ++ struct A { ++ protected: ++ template void f(); ++ }; ++ template struct B { ++ protected: ++ void g(); ++ }; ++ struct C : A, B { ++ using A::f; // #1 ++ using B::g; // #2 ++ }; ++ ++ In case #1 where `A::f' is a member template, DECL_ACCESS is ++ recorded in the primary template but not in its specialization. ++ We check access of FN using its primary template. ++ ++ In case #2, where `B::g' has a DECL_TEMPLATE_INFO simply ++ because it is a member of class template B, DECL_ACCESS is ++ recorded in the specialization `B::g'. We cannot use its ++ primary template because `B::g' and `B::g' may have ++ different access. */ ++ if (DECL_TEMPLATE_INFO (fn) ++ && is_member_template (DECL_TI_TEMPLATE (fn))) ++ perform_or_defer_access_check (cand->access_path, ++ DECL_TI_TEMPLATE (fn)); ++ else ++ perform_or_defer_access_check (cand->access_path, fn); ++ } ++ ++ if (args && TREE_CODE (args) != TREE_LIST) ++ args = build_tree_list (NULL_TREE, args); ++ arg = args; ++ ++ /* The implicit parameters to a constructor are not considered by overload ++ resolution, and must be of the proper type. */ ++ if (DECL_CONSTRUCTOR_P (fn)) ++ { ++ converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args); ++ arg = TREE_CHAIN (arg); ++ parm = TREE_CHAIN (parm); ++ if (DECL_HAS_IN_CHARGE_PARM_P (fn)) ++ /* We should never try to call the abstract constructor. */ ++ abort (); ++ if (DECL_HAS_VTT_PARM_P (fn)) ++ { ++ converted_args = tree_cons ++ (NULL_TREE, TREE_VALUE (arg), converted_args); ++ arg = TREE_CHAIN (arg); ++ parm = TREE_CHAIN (parm); ++ } ++ } ++ /* Bypass access control for 'this' parameter. */ ++ else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) ++ { ++ tree parmtype = TREE_VALUE (parm); ++ tree argtype = TREE_TYPE (TREE_VALUE (arg)); ++ tree converted_arg; ++ tree base_binfo; ++ ++ if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i))) ++ pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers", ++ TREE_TYPE (argtype), fn); ++ ++ /* [class.mfct.nonstatic]: If a nonstatic member function of a class ++ X is called for an object that is not of type X, or of a type ++ derived from X, the behavior is undefined. ++ ++ So we can assume that anything passed as 'this' is non-null, and ++ optimize accordingly. */ ++ my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811); ++ /* Convert to the base in which the function was declared. */ ++ my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730); ++ converted_arg = build_base_path (PLUS_EXPR, ++ TREE_VALUE (arg), ++ cand->conversion_path, ++ 1); ++ /* Check that the base class is accessible. */ ++ if (!accessible_base_p (TREE_TYPE (argtype), ++ BINFO_TYPE (cand->conversion_path))) ++ error ("`%T' is not an accessible base of `%T'", ++ BINFO_TYPE (cand->conversion_path), ++ TREE_TYPE (argtype)); ++ /* If fn was found by a using declaration, the conversion path ++ will be to the derived class, not the base declaring fn. We ++ must convert from derived to base. */ ++ base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)), ++ TREE_TYPE (parmtype), ba_ignore, NULL); ++ converted_arg = build_base_path (PLUS_EXPR, converted_arg, ++ base_binfo, 1); ++ ++ converted_args = tree_cons (NULL_TREE, converted_arg, converted_args); ++ parm = TREE_CHAIN (parm); ++ arg = TREE_CHAIN (arg); ++ ++i; ++ is_method = 1; ++ } ++ ++ for (; arg && parm; ++ parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i) ++ { ++ tree type = TREE_VALUE (parm); ++ ++ conv = TREE_VEC_ELT (convs, i); ++ val = convert_like_with_context ++ (conv, TREE_VALUE (arg), fn, i - is_method); ++ ++ val = convert_for_arg_passing (type, val); ++ converted_args = tree_cons (NULL_TREE, val, converted_args); ++ } ++ ++ /* Default arguments */ ++ for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++) ++ converted_args ++ = tree_cons (NULL_TREE, ++ convert_default_arg (TREE_VALUE (parm), ++ TREE_PURPOSE (parm), ++ fn, i - is_method), ++ converted_args); ++ ++ /* Ellipsis */ ++ for (; arg; arg = TREE_CHAIN (arg)) ++ { ++ tree a = TREE_VALUE (arg); ++ if (magic_varargs_p (fn)) ++ /* Do no conversions for magic varargs. */; ++ else ++ a = convert_arg_to_ellipsis (a); ++ converted_args = tree_cons (NULL_TREE, a, converted_args); ++ } ++ ++ converted_args = nreverse (converted_args); ++ ++ if (warn_format) ++ check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)), ++ converted_args); ++ ++ /* Avoid actually calling copy constructors and copy assignment operators, ++ if possible. */ ++ ++ if (! flag_elide_constructors) ++ /* Do things the hard way. */; ++ else if (TREE_VEC_LENGTH (convs) == 1 ++ && DECL_COPY_CONSTRUCTOR_P (fn)) ++ { ++ tree targ; ++ arg = skip_artificial_parms_for (fn, converted_args); ++ arg = TREE_VALUE (arg); ++ ++ /* Pull out the real argument, disregarding const-correctness. */ ++ targ = arg; ++ while (TREE_CODE (targ) == NOP_EXPR ++ || TREE_CODE (targ) == NON_LVALUE_EXPR ++ || TREE_CODE (targ) == CONVERT_EXPR) ++ targ = TREE_OPERAND (targ, 0); ++ if (TREE_CODE (targ) == ADDR_EXPR) ++ { ++ targ = TREE_OPERAND (targ, 0); ++ if (!same_type_ignoring_top_level_qualifiers_p ++ (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ))) ++ targ = NULL_TREE; ++ } ++ else ++ targ = NULL_TREE; ++ ++ if (targ) ++ arg = targ; ++ else ++ arg = build_indirect_ref (arg, 0); ++ ++ /* [class.copy]: the copy constructor is implicitly defined even if ++ the implementation elided its use. */ ++ if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn))) ++ mark_used (fn); ++ ++ /* If we're creating a temp and we already have one, don't create a ++ new one. If we're not creating a temp but we get one, use ++ INIT_EXPR to collapse the temp into our target. Otherwise, if the ++ ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a ++ temp or an INIT_EXPR otherwise. */ ++ if (integer_zerop (TREE_VALUE (args))) ++ { ++ if (TREE_CODE (arg) == TARGET_EXPR) ++ return arg; ++ else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))) ++ return build_target_expr_with_type (arg, DECL_CONTEXT (fn)); ++ } ++ else if (TREE_CODE (arg) == TARGET_EXPR ++ || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))) ++ { ++ tree to = stabilize_reference ++ (build_indirect_ref (TREE_VALUE (args), 0)); ++ ++ val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg); ++ return val; ++ } ++ } ++ else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR ++ && copy_fn_p (fn) ++ && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn))) ++ { ++ tree to = stabilize_reference ++ (build_indirect_ref (TREE_VALUE (converted_args), 0)); ++ tree type = TREE_TYPE (to); ++ tree as_base = CLASSTYPE_AS_BASE (type); ++ ++ arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0); ++ if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base))) ++ val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg); ++ else ++ { ++ /* We must only copy the non-tail padding parts. Use ++ CLASSTYPE_AS_BASE for the bitwise copy. */ ++ tree to_ptr, arg_ptr, to_as_base, arg_as_base, base_ptr_type; ++ tree save_to; ++ ++ to_ptr = save_expr (build_unary_op (ADDR_EXPR, to, 0)); ++ arg_ptr = build_unary_op (ADDR_EXPR, arg, 0); ++ ++ base_ptr_type = build_pointer_type (as_base); ++ to_as_base = build_nop (base_ptr_type, to_ptr); ++ to_as_base = build_indirect_ref (to_as_base, 0); ++ arg_as_base = build_nop (base_ptr_type, arg_ptr); ++ arg_as_base = build_indirect_ref (arg_as_base, 0); ++ ++ save_to = build_indirect_ref (to_ptr, 0); ++ ++ val = build (MODIFY_EXPR, as_base, to_as_base, arg_as_base); ++ val = convert_to_void (val, NULL); ++ val = build (COMPOUND_EXPR, type, val, save_to); ++ TREE_NO_UNUSED_WARNING (val) = 1; ++ } ++ ++ return val; ++ } ++ ++ mark_used (fn); ++ ++ if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0) ++ { ++ tree t, *p = &TREE_VALUE (converted_args); ++ tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)), ++ DECL_CONTEXT (fn), ++ ba_any, NULL); ++ my_friendly_assert (binfo && binfo != error_mark_node, 20010730); ++ ++ *p = build_base_path (PLUS_EXPR, *p, binfo, 1); ++ if (TREE_SIDE_EFFECTS (*p)) ++ *p = save_expr (*p); ++ t = build_pointer_type (TREE_TYPE (fn)); ++ if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn))) ++ fn = build_java_interface_fn_ref (fn, *p); ++ else ++ fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn)); ++ TREE_TYPE (fn) = t; ++ } ++ else if (DECL_INLINE (fn)) ++ fn = inline_conversion (fn); ++ else ++ fn = build_addr_func (fn); ++ ++ return build_cxx_call (fn, args, converted_args); ++} ++ ++/* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS ++ gives the original form of the arguments. This function performs ++ no overload resolution, conversion, or other high-level ++ operations. */ ++ ++tree ++build_cxx_call(tree fn, tree args, tree converted_args) ++{ ++ tree fndecl; ++ ++ /* Recognize certain built-in functions so we can make tree-codes ++ other than CALL_EXPR. We do this when it enables fold-const.c ++ to do something useful. */ ++ if (TREE_CODE (fn) == ADDR_EXPR ++ && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL ++ && DECL_BUILT_IN (TREE_OPERAND (fn, 0))) ++ { ++ tree exp; ++ exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args); ++ if (exp) ++ return exp; ++ } ++ ++ fn = build_call (fn, converted_args); ++ ++ /* If this call might throw an exception, note that fact. */ ++ fndecl = get_callee_fndecl (fn); ++ if ((!fndecl || !TREE_NOTHROW (fndecl)) ++ && at_function_scope_p () ++ && cfun) ++ cp_function_chain->can_throw = 1; ++ ++ /* Some built-in function calls will be evaluated at compile-time in ++ fold (). */ ++ fn = fold (fn); ++ ++ if (VOID_TYPE_P (TREE_TYPE (fn))) ++ return fn; ++ ++ fn = require_complete_type (fn); ++ if (fn == error_mark_node) ++ return error_mark_node; ++ ++ if (IS_AGGR_TYPE (TREE_TYPE (fn))) ++ fn = build_cplus_new (TREE_TYPE (fn), fn); ++ return convert_from_reference (fn); ++} ++ ++static GTY(()) tree java_iface_lookup_fn; ++ ++/* Make an expression which yields the address of the Java interface ++ method FN. This is achieved by generating a call to libjava's ++ _Jv_LookupInterfaceMethodIdx(). */ ++ ++static tree ++build_java_interface_fn_ref (tree fn, tree instance) ++{ ++ tree lookup_args, lookup_fn, method, idx; ++ tree klass_ref, iface, iface_ref; ++ int i; ++ ++ if (!java_iface_lookup_fn) ++ { ++ tree endlink = build_void_list_node (); ++ tree t = tree_cons (NULL_TREE, ptr_type_node, ++ tree_cons (NULL_TREE, ptr_type_node, ++ tree_cons (NULL_TREE, java_int_type_node, ++ endlink))); ++ java_iface_lookup_fn ++ = builtin_function ("_Jv_LookupInterfaceMethodIdx", ++ build_function_type (ptr_type_node, t), ++ 0, NOT_BUILT_IN, NULL, NULL_TREE); ++ } ++ ++ /* Look up the pointer to the runtime java.lang.Class object for `instance'. ++ This is the first entry in the vtable. */ ++ klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0), ++ integer_zero_node); ++ ++ /* Get the java.lang.Class pointer for the interface being called. */ ++ iface = DECL_CONTEXT (fn); ++ iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false); ++ if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL ++ || DECL_CONTEXT (iface_ref) != iface) ++ { ++ error ("could not find class$ field in java interface type `%T'", ++ iface); ++ return error_mark_node; ++ } ++ iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref); ++ ++ /* Determine the itable index of FN. */ ++ i = 1; ++ for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method)) ++ { ++ if (!DECL_VIRTUAL_P (method)) ++ continue; ++ if (fn == method) ++ break; ++ i++; ++ } ++ idx = build_int_2 (i, 0); ++ ++ lookup_args = tree_cons (NULL_TREE, klass_ref, ++ tree_cons (NULL_TREE, iface_ref, ++ build_tree_list (NULL_TREE, idx))); ++ lookup_fn = build1 (ADDR_EXPR, ++ build_pointer_type (TREE_TYPE (java_iface_lookup_fn)), ++ java_iface_lookup_fn); ++ return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE); ++} ++ ++/* Returns the value to use for the in-charge parameter when making a ++ call to a function with the indicated NAME. */ ++ ++tree ++in_charge_arg_for_name (tree name) ++{ ++ if (name == base_ctor_identifier ++ || name == base_dtor_identifier) ++ return integer_zero_node; ++ else if (name == complete_ctor_identifier) ++ return integer_one_node; ++ else if (name == complete_dtor_identifier) ++ return integer_two_node; ++ else if (name == deleting_dtor_identifier) ++ return integer_three_node; ++ ++ /* This function should only be called with one of the names listed ++ above. */ ++ abort (); ++ return NULL_TREE; ++} ++ ++/* Build a call to a constructor, destructor, or an assignment ++ operator for INSTANCE, an expression with class type. NAME ++ indicates the special member function to call; ARGS are the ++ arguments. BINFO indicates the base of INSTANCE that is to be ++ passed as the `this' parameter to the member function called. ++ ++ FLAGS are the LOOKUP_* flags to use when processing the call. ++ ++ If NAME indicates a complete object constructor, INSTANCE may be ++ NULL_TREE. In this case, the caller will call build_cplus_new to ++ store the newly constructed object into a VAR_DECL. */ ++ ++tree ++build_special_member_call (tree instance, tree name, tree args, ++ tree binfo, int flags) ++{ ++ tree fns; ++ /* The type of the subobject to be constructed or destroyed. */ ++ tree class_type; ++ ++ my_friendly_assert (name == complete_ctor_identifier ++ || name == base_ctor_identifier ++ || name == complete_dtor_identifier ++ || name == base_dtor_identifier ++ || name == deleting_dtor_identifier ++ || name == ansi_assopname (NOP_EXPR), ++ 20020712); ++ my_friendly_assert (binfo != NULL_TREE, 20020712); ++ ++ class_type = BINFO_TYPE (binfo); ++ ++ /* Handle the special case where INSTANCE is NULL_TREE. */ ++ if (name == complete_ctor_identifier && !instance) ++ { ++ instance = build_int_2 (0, 0); ++ TREE_TYPE (instance) = build_pointer_type (class_type); ++ instance = build1 (INDIRECT_REF, class_type, instance); ++ } ++ else ++ { ++ if (name == complete_dtor_identifier ++ || name == base_dtor_identifier ++ || name == deleting_dtor_identifier) ++ my_friendly_assert (args == NULL_TREE, 20020712); ++ ++ /* Convert to the base class, if necessary. */ ++ if (!same_type_ignoring_top_level_qualifiers_p ++ (TREE_TYPE (instance), BINFO_TYPE (binfo))) ++ { ++ if (name != ansi_assopname (NOP_EXPR)) ++ /* For constructors and destructors, either the base is ++ non-virtual, or it is virtual but we are doing the ++ conversion from a constructor or destructor for the ++ complete object. In either case, we can convert ++ statically. */ ++ instance = convert_to_base_statically (instance, binfo); ++ else ++ /* However, for assignment operators, we must convert ++ dynamically if the base is virtual. */ ++ instance = build_base_path (PLUS_EXPR, instance, ++ binfo, /*nonnull=*/1); ++ } ++ } ++ ++ my_friendly_assert (instance != NULL_TREE, 20020712); ++ ++ /* Resolve the name. */ ++ if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE)) ++ return error_mark_node; ++ ++ fns = lookup_fnfields (binfo, name, 1); ++ ++ /* When making a call to a constructor or destructor for a subobject ++ that uses virtual base classes, pass down a pointer to a VTT for ++ the subobject. */ ++ if ((name == base_ctor_identifier ++ || name == base_dtor_identifier) ++ && TYPE_USES_VIRTUAL_BASECLASSES (class_type)) ++ { ++ tree vtt; ++ tree sub_vtt; ++ ++ /* If the current function is a complete object constructor ++ or destructor, then we fetch the VTT directly. ++ Otherwise, we look it up using the VTT we were given. */ ++ vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type)); ++ vtt = decay_conversion (vtt); ++ vtt = build (COND_EXPR, TREE_TYPE (vtt), ++ build (EQ_EXPR, boolean_type_node, ++ current_in_charge_parm, integer_zero_node), ++ current_vtt_parm, ++ vtt); ++ my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110); ++ sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt, ++ BINFO_SUBVTT_INDEX (binfo)); ++ ++ args = tree_cons (NULL_TREE, sub_vtt, args); ++ } ++ ++ return build_new_method_call (instance, fns, args, ++ TYPE_BINFO (BINFO_TYPE (binfo)), ++ flags); ++} ++ ++/* Return the NAME, as a C string. The NAME indicates a function that ++ is a member of TYPE. *FREE_P is set to true if the caller must ++ free the memory returned. ++ ++ Rather than go through all of this, we should simply set the names ++ of constructors and destructors appropriately, and dispense with ++ ctor_identifier, dtor_identifier, etc. */ ++ ++static char * ++name_as_c_string (tree name, tree type, bool *free_p) ++{ ++ char *pretty_name; ++ ++ /* Assume that we will not allocate memory. */ ++ *free_p = false; ++ /* Constructors and destructors are special. */ ++ if (IDENTIFIER_CTOR_OR_DTOR_P (name)) ++ { ++ pretty_name ++ = (char *) IDENTIFIER_POINTER (constructor_name (type)); ++ /* For a destructor, add the '~'. */ ++ if (name == complete_dtor_identifier ++ || name == base_dtor_identifier ++ || name == deleting_dtor_identifier) ++ { ++ pretty_name = concat ("~", pretty_name, NULL); ++ /* Remember that we need to free the memory allocated. */ ++ *free_p = true; ++ } ++ } ++ else if (IDENTIFIER_TYPENAME_P (name)) ++ { ++ pretty_name = concat ("operator ", ++ type_as_string (TREE_TYPE (name), ++ TFF_PLAIN_IDENTIFIER), ++ NULL); ++ /* Remember that we need to free the memory allocated. */ ++ *free_p = true; ++ } ++ else ++ pretty_name = (char *) IDENTIFIER_POINTER (name); ++ ++ return pretty_name; ++} ++ ++/* Build a call to "INSTANCE.FN (ARGS)". */ ++ ++tree ++build_new_method_call (tree instance, tree fns, tree args, ++ tree conversion_path, int flags) ++{ ++ struct z_candidate *candidates = 0, *cand; ++ tree explicit_targs = NULL_TREE; ++ tree basetype = NULL_TREE; ++ tree access_binfo; ++ tree optype; ++ tree mem_args = NULL_TREE, instance_ptr; ++ tree name; ++ tree user_args; ++ tree call; ++ tree fn; ++ tree class_type; ++ int template_only = 0; ++ bool any_viable_p; ++ tree orig_instance; ++ tree orig_fns; ++ tree orig_args; ++ ++ my_friendly_assert (instance != NULL_TREE, 20020729); ++ ++ if (error_operand_p (instance) ++ || error_operand_p (fns) ++ || args == error_mark_node) ++ return error_mark_node; ++ ++ orig_instance = instance; ++ orig_fns = fns; ++ orig_args = args; ++ ++ if (processing_template_decl) ++ { ++ instance = build_non_dependent_expr (instance); ++ if (!BASELINK_P (fns) ++ && TREE_CODE (fns) != PSEUDO_DTOR_EXPR ++ && TREE_TYPE (fns) != unknown_type_node) ++ fns = build_non_dependent_expr (fns); ++ args = build_non_dependent_args (orig_args); ++ } ++ ++ /* Process the argument list. */ ++ user_args = args; ++ args = resolve_args (args); ++ if (args == error_mark_node) ++ return error_mark_node; ++ ++ if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE) ++ instance = convert_from_reference (instance); ++ basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance)); ++ instance_ptr = build_this (instance); ++ ++ if (!BASELINK_P (fns)) ++ { ++ error ("call to non-function `%D'", fns); ++ return error_mark_node; ++ } ++ ++ if (!conversion_path) ++ conversion_path = BASELINK_BINFO (fns); ++ access_binfo = BASELINK_ACCESS_BINFO (fns); ++ optype = BASELINK_OPTYPE (fns); ++ fns = BASELINK_FUNCTIONS (fns); ++ ++ if (TREE_CODE (fns) == TEMPLATE_ID_EXPR) ++ { ++ explicit_targs = TREE_OPERAND (fns, 1); ++ fns = TREE_OPERAND (fns, 0); ++ template_only = 1; ++ } ++ ++ my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL ++ || TREE_CODE (fns) == TEMPLATE_DECL ++ || TREE_CODE (fns) == OVERLOAD, ++ 20020712); ++ ++ /* XXX this should be handled before we get here. */ ++ if (! IS_AGGR_TYPE (basetype)) ++ { ++ if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node) ++ error ("request for member `%D' in `%E', which is of non-aggregate type `%T'", ++ fns, instance, basetype); ++ ++ return error_mark_node; ++ } ++ ++ fn = get_first_fn (fns); ++ name = DECL_NAME (fn); ++ ++ if (IDENTIFIER_CTOR_OR_DTOR_P (name)) ++ { ++ /* Callers should explicitly indicate whether they want to construct ++ the complete object or just the part without virtual bases. */ ++ my_friendly_assert (name != ctor_identifier, 20000408); ++ /* Similarly for destructors. */ ++ my_friendly_assert (name != dtor_identifier, 20000408); ++ } ++ ++ /* It's OK to call destructors on cv-qualified objects. Therefore, ++ convert the INSTANCE_PTR to the unqualified type, if necessary. */ ++ if (DECL_DESTRUCTOR_P (fn)) ++ { ++ tree type = build_pointer_type (basetype); ++ if (!same_type_p (type, TREE_TYPE (instance_ptr))) ++ instance_ptr = build_nop (type, instance_ptr); ++ } ++ ++ class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE); ++ mem_args = tree_cons (NULL_TREE, instance_ptr, args); ++ ++ for (fn = fns; fn; fn = OVL_NEXT (fn)) ++ { ++ tree t = OVL_CURRENT (fn); ++ tree this_arglist; ++ ++ /* We can end up here for copy-init of same or base class. */ ++ if ((flags & LOOKUP_ONLYCONVERTING) ++ && DECL_NONCONVERTING_P (t)) ++ continue; ++ ++ if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t)) ++ this_arglist = mem_args; ++ else ++ this_arglist = args; ++ ++ if (TREE_CODE (t) == TEMPLATE_DECL) ++ /* A member template. */ ++ add_template_candidate (&candidates, t, ++ class_type, ++ explicit_targs, ++ this_arglist, optype, ++ access_binfo, ++ conversion_path, ++ flags, ++ DEDUCE_CALL); ++ else if (! template_only) ++ add_function_candidate (&candidates, t, ++ class_type, ++ this_arglist, ++ access_binfo, ++ conversion_path, ++ flags); ++ } ++ ++ candidates = splice_viable (candidates, pedantic, &any_viable_p); ++ if (!any_viable_p) ++ { ++ /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */ ++ if (flags & LOOKUP_SPECULATIVELY) ++ return NULL_TREE; ++ if (!COMPLETE_TYPE_P (basetype)) ++ cxx_incomplete_type_error (instance_ptr, basetype); ++ else ++ { ++ char *pretty_name; ++ bool free_p; ++ ++ pretty_name = name_as_c_string (name, basetype, &free_p); ++ error ("no matching function for call to `%T::%s(%A)%#V'", ++ basetype, pretty_name, user_args, ++ TREE_TYPE (TREE_TYPE (instance_ptr))); ++ if (free_p) ++ free (pretty_name); ++ } ++ print_z_candidates (candidates); ++ return error_mark_node; ++ } ++ ++ cand = tourney (candidates); ++ if (cand == 0) ++ { ++ char *pretty_name; ++ bool free_p; ++ ++ pretty_name = name_as_c_string (name, basetype, &free_p); ++ error ("call of overloaded `%s(%A)' is ambiguous", pretty_name, ++ user_args); ++ print_z_candidates (candidates); ++ if (free_p) ++ free (pretty_name); ++ return error_mark_node; ++ } ++ ++ if (DECL_PURE_VIRTUAL_P (cand->fn) ++ && instance == current_class_ref ++ && (DECL_CONSTRUCTOR_P (current_function_decl) ++ || DECL_DESTRUCTOR_P (current_function_decl)) ++ && ! (flags & LOOKUP_NONVIRTUAL) ++ && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype))) ++ error ((DECL_CONSTRUCTOR_P (current_function_decl) ? ++ "abstract virtual `%#D' called from constructor" ++ : "abstract virtual `%#D' called from destructor"), ++ cand->fn); ++ if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE ++ && is_dummy_object (instance_ptr)) ++ { ++ error ("cannot call member function `%D' without object", cand->fn); ++ return error_mark_node; ++ } ++ ++ if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL) ++ && resolves_to_fixed_type_p (instance, 0)) ++ flags |= LOOKUP_NONVIRTUAL; ++ ++ if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE) ++ call = build_over_call (cand, flags); ++ else ++ { ++ call = build_over_call (cand, flags); ++ /* In an expression of the form `a->f()' where `f' turns out to ++ be a static member function, `a' is none-the-less evaluated. */ ++ if (!is_dummy_object (instance_ptr) && TREE_SIDE_EFFECTS (instance)) ++ call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call); ++ } ++ ++ if (processing_template_decl && call != error_mark_node) ++ return build_min_non_dep ++ (CALL_EXPR, call, ++ build_min_nt (COMPONENT_REF, orig_instance, orig_fns), ++ orig_args); ++ return call; ++} ++ ++/* Returns true iff standard conversion sequence ICS1 is a proper ++ subsequence of ICS2. */ ++ ++static bool ++is_subseq (tree ics1, tree ics2) ++{ ++ /* We can assume that a conversion of the same code ++ between the same types indicates a subsequence since we only get ++ here if the types we are converting from are the same. */ ++ ++ while (TREE_CODE (ics1) == RVALUE_CONV ++ || TREE_CODE (ics1) == LVALUE_CONV) ++ ics1 = TREE_OPERAND (ics1, 0); ++ ++ while (1) ++ { ++ while (TREE_CODE (ics2) == RVALUE_CONV ++ || TREE_CODE (ics2) == LVALUE_CONV) ++ ics2 = TREE_OPERAND (ics2, 0); ++ ++ if (TREE_CODE (ics2) == USER_CONV ++ || TREE_CODE (ics2) == AMBIG_CONV ++ || TREE_CODE (ics2) == IDENTITY_CONV) ++ /* At this point, ICS1 cannot be a proper subsequence of ++ ICS2. We can get a USER_CONV when we are comparing the ++ second standard conversion sequence of two user conversion ++ sequences. */ ++ return false; ++ ++ ics2 = TREE_OPERAND (ics2, 0); ++ ++ if (TREE_CODE (ics2) == TREE_CODE (ics1) ++ && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1)) ++ && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)), ++ TREE_TYPE (TREE_OPERAND (ics1, 0)))) ++ return true; ++ } ++} ++ ++/* Returns nonzero iff DERIVED is derived from BASE. The inputs may ++ be any _TYPE nodes. */ ++ ++bool ++is_properly_derived_from (tree derived, tree base) ++{ ++ if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived)) ++ || !IS_AGGR_TYPE_CODE (TREE_CODE (base))) ++ return false; ++ ++ /* We only allow proper derivation here. The DERIVED_FROM_P macro ++ considers every class derived from itself. */ ++ return (!same_type_ignoring_top_level_qualifiers_p (derived, base) ++ && DERIVED_FROM_P (base, derived)); ++} ++ ++/* We build the ICS for an implicit object parameter as a pointer ++ conversion sequence. However, such a sequence should be compared ++ as if it were a reference conversion sequence. If ICS is the ++ implicit conversion sequence for an implicit object parameter, ++ modify it accordingly. */ ++ ++static void ++maybe_handle_implicit_object (tree *ics) ++{ ++ if (ICS_THIS_FLAG (*ics)) ++ { ++ /* [over.match.funcs] ++ ++ For non-static member functions, the type of the ++ implicit object parameter is "reference to cv X" ++ where X is the class of which the function is a ++ member and cv is the cv-qualification on the member ++ function declaration. */ ++ tree t = *ics; ++ tree reference_type; ++ ++ /* The `this' parameter is a pointer to a class type. Make the ++ implicit conversion talk about a reference to that same class ++ type. */ ++ reference_type = TREE_TYPE (TREE_TYPE (*ics)); ++ reference_type = build_reference_type (reference_type); ++ ++ if (TREE_CODE (t) == QUAL_CONV) ++ t = TREE_OPERAND (t, 0); ++ if (TREE_CODE (t) == PTR_CONV) ++ t = TREE_OPERAND (t, 0); ++ t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE); ++ t = direct_reference_binding (reference_type, t); ++ *ics = t; ++ } ++} ++ ++/* If *ICS is a REF_BIND set *ICS to the remainder of the conversion, ++ and return the type to which the reference refers. Otherwise, ++ leave *ICS unchanged and return NULL_TREE. */ ++ ++static tree ++maybe_handle_ref_bind (tree *ics) ++{ ++ if (TREE_CODE (*ics) == REF_BIND) ++ { ++ tree old_ics = *ics; ++ tree type = TREE_TYPE (TREE_TYPE (old_ics)); ++ *ics = TREE_OPERAND (old_ics, 0); ++ ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics); ++ ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics); ++ return type; ++ } ++ ++ return NULL_TREE; ++} ++ ++/* Compare two implicit conversion sequences according to the rules set out in ++ [over.ics.rank]. Return values: ++ ++ 1: ics1 is better than ics2 ++ -1: ics2 is better than ics1 ++ 0: ics1 and ics2 are indistinguishable */ ++ ++static int ++compare_ics (tree ics1, tree ics2) ++{ ++ tree from_type1; ++ tree from_type2; ++ tree to_type1; ++ tree to_type2; ++ tree deref_from_type1 = NULL_TREE; ++ tree deref_from_type2 = NULL_TREE; ++ tree deref_to_type1 = NULL_TREE; ++ tree deref_to_type2 = NULL_TREE; ++ int rank1, rank2; ++ ++ /* REF_BINDING is nonzero if the result of the conversion sequence ++ is a reference type. In that case TARGET_TYPE is the ++ type referred to by the reference. */ ++ tree target_type1; ++ tree target_type2; ++ ++ /* Handle implicit object parameters. */ ++ maybe_handle_implicit_object (&ics1); ++ maybe_handle_implicit_object (&ics2); ++ ++ /* Handle reference parameters. */ ++ target_type1 = maybe_handle_ref_bind (&ics1); ++ target_type2 = maybe_handle_ref_bind (&ics2); ++ ++ /* [over.ics.rank] ++ ++ When comparing the basic forms of implicit conversion sequences (as ++ defined in _over.best.ics_) ++ ++ --a standard conversion sequence (_over.ics.scs_) is a better ++ conversion sequence than a user-defined conversion sequence ++ or an ellipsis conversion sequence, and ++ ++ --a user-defined conversion sequence (_over.ics.user_) is a ++ better conversion sequence than an ellipsis conversion sequence ++ (_over.ics.ellipsis_). */ ++ rank1 = ICS_RANK (ics1); ++ rank2 = ICS_RANK (ics2); ++ ++ if (rank1 > rank2) ++ return -1; ++ else if (rank1 < rank2) ++ return 1; ++ ++ if (rank1 == BAD_RANK) ++ { ++ /* XXX Isn't this an extension? */ ++ /* Both ICS are bad. We try to make a decision based on what ++ would have happened if they'd been good. */ ++ if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2) ++ || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2)) ++ return -1; ++ else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2) ++ || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2)) ++ return 1; ++ ++ /* We couldn't make up our minds; try to figure it out below. */ ++ } ++ ++ if (ICS_ELLIPSIS_FLAG (ics1)) ++ /* Both conversions are ellipsis conversions. */ ++ return 0; ++ ++ /* User-defined conversion sequence U1 is a better conversion sequence ++ than another user-defined conversion sequence U2 if they contain the ++ same user-defined conversion operator or constructor and if the sec- ++ ond standard conversion sequence of U1 is better than the second ++ standard conversion sequence of U2. */ ++ ++ if (ICS_USER_FLAG (ics1)) ++ { ++ tree t1, t2; ++ ++ for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0)) ++ if (TREE_CODE (t1) == AMBIG_CONV) ++ return 0; ++ for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0)) ++ if (TREE_CODE (t2) == AMBIG_CONV) ++ return 0; ++ ++ if (USER_CONV_FN (t1) != USER_CONV_FN (t2)) ++ return 0; ++ ++ /* We can just fall through here, after setting up ++ FROM_TYPE1 and FROM_TYPE2. */ ++ from_type1 = TREE_TYPE (t1); ++ from_type2 = TREE_TYPE (t2); ++ } ++ else ++ { ++ /* We're dealing with two standard conversion sequences. ++ ++ [over.ics.rank] ++ ++ Standard conversion sequence S1 is a better conversion ++ sequence than standard conversion sequence S2 if ++ ++ --S1 is a proper subsequence of S2 (comparing the conversion ++ sequences in the canonical form defined by _over.ics.scs_, ++ excluding any Lvalue Transformation; the identity ++ conversion sequence is considered to be a subsequence of ++ any non-identity conversion sequence */ ++ ++ from_type1 = ics1; ++ while (TREE_CODE (from_type1) != IDENTITY_CONV) ++ from_type1 = TREE_OPERAND (from_type1, 0); ++ from_type1 = TREE_TYPE (from_type1); ++ ++ from_type2 = ics2; ++ while (TREE_CODE (from_type2) != IDENTITY_CONV) ++ from_type2 = TREE_OPERAND (from_type2, 0); ++ from_type2 = TREE_TYPE (from_type2); ++ } ++ ++ if (same_type_p (from_type1, from_type2)) ++ { ++ if (is_subseq (ics1, ics2)) ++ return 1; ++ if (is_subseq (ics2, ics1)) ++ return -1; ++ } ++ /* Otherwise, one sequence cannot be a subsequence of the other; they ++ don't start with the same type. This can happen when comparing the ++ second standard conversion sequence in two user-defined conversion ++ sequences. */ ++ ++ /* [over.ics.rank] ++ ++ Or, if not that, ++ ++ --the rank of S1 is better than the rank of S2 (by the rules ++ defined below): ++ ++ Standard conversion sequences are ordered by their ranks: an Exact ++ Match is a better conversion than a Promotion, which is a better ++ conversion than a Conversion. ++ ++ Two conversion sequences with the same rank are indistinguishable ++ unless one of the following rules applies: ++ ++ --A conversion that is not a conversion of a pointer, or pointer ++ to member, to bool is better than another conversion that is such ++ a conversion. ++ ++ The ICS_STD_RANK automatically handles the pointer-to-bool rule, ++ so that we do not have to check it explicitly. */ ++ if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2)) ++ return 1; ++ else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1)) ++ return -1; ++ ++ to_type1 = TREE_TYPE (ics1); ++ to_type2 = TREE_TYPE (ics2); ++ ++ if (TYPE_PTR_P (from_type1) ++ && TYPE_PTR_P (from_type2) ++ && TYPE_PTR_P (to_type1) ++ && TYPE_PTR_P (to_type2)) ++ { ++ deref_from_type1 = TREE_TYPE (from_type1); ++ deref_from_type2 = TREE_TYPE (from_type2); ++ deref_to_type1 = TREE_TYPE (to_type1); ++ deref_to_type2 = TREE_TYPE (to_type2); ++ } ++ /* The rules for pointers to members A::* are just like the rules ++ for pointers A*, except opposite: if B is derived from A then ++ A::* converts to B::*, not vice versa. For that reason, we ++ switch the from_ and to_ variables here. */ ++ else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2) ++ && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2)) ++ || (TYPE_PTRMEMFUNC_P (from_type1) ++ && TYPE_PTRMEMFUNC_P (from_type2) ++ && TYPE_PTRMEMFUNC_P (to_type1) ++ && TYPE_PTRMEMFUNC_P (to_type2))) ++ { ++ deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1); ++ deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2); ++ deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1); ++ deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2); ++ } ++ ++ if (deref_from_type1 != NULL_TREE ++ && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1)) ++ && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2))) ++ { ++ /* This was one of the pointer or pointer-like conversions. ++ ++ [over.ics.rank] ++ ++ --If class B is derived directly or indirectly from class A, ++ conversion of B* to A* is better than conversion of B* to ++ void*, and conversion of A* to void* is better than ++ conversion of B* to void*. */ ++ if (TREE_CODE (deref_to_type1) == VOID_TYPE ++ && TREE_CODE (deref_to_type2) == VOID_TYPE) ++ { ++ if (is_properly_derived_from (deref_from_type1, ++ deref_from_type2)) ++ return -1; ++ else if (is_properly_derived_from (deref_from_type2, ++ deref_from_type1)) ++ return 1; ++ } ++ else if (TREE_CODE (deref_to_type1) == VOID_TYPE ++ || TREE_CODE (deref_to_type2) == VOID_TYPE) ++ { ++ if (same_type_p (deref_from_type1, deref_from_type2)) ++ { ++ if (TREE_CODE (deref_to_type2) == VOID_TYPE) ++ { ++ if (is_properly_derived_from (deref_from_type1, ++ deref_to_type1)) ++ return 1; ++ } ++ /* We know that DEREF_TO_TYPE1 is `void' here. */ ++ else if (is_properly_derived_from (deref_from_type1, ++ deref_to_type2)) ++ return -1; ++ } ++ } ++ else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1)) ++ && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2))) ++ { ++ /* [over.ics.rank] ++ ++ --If class B is derived directly or indirectly from class A ++ and class C is derived directly or indirectly from B, ++ ++ --conversion of C* to B* is better than conversion of C* to ++ A*, ++ ++ --conversion of B* to A* is better than conversion of C* to ++ A* */ ++ if (same_type_p (deref_from_type1, deref_from_type2)) ++ { ++ if (is_properly_derived_from (deref_to_type1, ++ deref_to_type2)) ++ return 1; ++ else if (is_properly_derived_from (deref_to_type2, ++ deref_to_type1)) ++ return -1; ++ } ++ else if (same_type_p (deref_to_type1, deref_to_type2)) ++ { ++ if (is_properly_derived_from (deref_from_type2, ++ deref_from_type1)) ++ return 1; ++ else if (is_properly_derived_from (deref_from_type1, ++ deref_from_type2)) ++ return -1; ++ } ++ } ++ } ++ else if (CLASS_TYPE_P (non_reference (from_type1)) ++ && same_type_p (from_type1, from_type2)) ++ { ++ tree from = non_reference (from_type1); ++ ++ /* [over.ics.rank] ++ ++ --binding of an expression of type C to a reference of type ++ B& is better than binding an expression of type C to a ++ reference of type A& ++ ++ --conversion of C to B is better than conversion of C to A, */ ++ if (is_properly_derived_from (from, to_type1) ++ && is_properly_derived_from (from, to_type2)) ++ { ++ if (is_properly_derived_from (to_type1, to_type2)) ++ return 1; ++ else if (is_properly_derived_from (to_type2, to_type1)) ++ return -1; ++ } ++ } ++ else if (CLASS_TYPE_P (non_reference (to_type1)) ++ && same_type_p (to_type1, to_type2)) ++ { ++ tree to = non_reference (to_type1); ++ ++ /* [over.ics.rank] ++ ++ --binding of an expression of type B to a reference of type ++ A& is better than binding an expression of type C to a ++ reference of type A&, ++ ++ --onversion of B to A is better than conversion of C to A */ ++ if (is_properly_derived_from (from_type1, to) ++ && is_properly_derived_from (from_type2, to)) ++ { ++ if (is_properly_derived_from (from_type2, from_type1)) ++ return 1; ++ else if (is_properly_derived_from (from_type1, from_type2)) ++ return -1; ++ } ++ } ++ ++ /* [over.ics.rank] ++ ++ --S1 and S2 differ only in their qualification conversion and yield ++ similar types T1 and T2 (_conv.qual_), respectively, and the cv- ++ qualification signature of type T1 is a proper subset of the cv- ++ qualification signature of type T2 */ ++ if (TREE_CODE (ics1) == QUAL_CONV ++ && TREE_CODE (ics2) == QUAL_CONV ++ && same_type_p (from_type1, from_type2)) ++ return comp_cv_qual_signature (to_type1, to_type2); ++ ++ /* [over.ics.rank] ++ ++ --S1 and S2 are reference bindings (_dcl.init.ref_), and the ++ types to which the references refer are the same type except for ++ top-level cv-qualifiers, and the type to which the reference ++ initialized by S2 refers is more cv-qualified than the type to ++ which the reference initialized by S1 refers */ ++ ++ if (target_type1 && target_type2 ++ && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2)) ++ return comp_cv_qualification (target_type2, target_type1); ++ ++ /* Neither conversion sequence is better than the other. */ ++ return 0; ++} ++ ++/* The source type for this standard conversion sequence. */ ++ ++static tree ++source_type (tree t) ++{ ++ for (;; t = TREE_OPERAND (t, 0)) ++ { ++ if (TREE_CODE (t) == USER_CONV ++ || TREE_CODE (t) == AMBIG_CONV ++ || TREE_CODE (t) == IDENTITY_CONV) ++ return TREE_TYPE (t); ++ } ++ abort (); ++} ++ ++/* Note a warning about preferring WINNER to LOSER. We do this by storing ++ a pointer to LOSER and re-running joust to produce the warning if WINNER ++ is actually used. */ ++ ++static void ++add_warning (struct z_candidate *winner, struct z_candidate *loser) ++{ ++ winner->warnings = tree_cons (NULL_TREE, ++ build_zc_wrapper (loser), ++ winner->warnings); ++} ++ ++/* Compare two candidates for overloading as described in ++ [over.match.best]. Return values: ++ ++ 1: cand1 is better than cand2 ++ -1: cand2 is better than cand1 ++ 0: cand1 and cand2 are indistinguishable */ ++ ++static int ++joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn) ++{ ++ int winner = 0; ++ int i, off1 = 0, off2 = 0, len; ++ ++ /* Candidates that involve bad conversions are always worse than those ++ that don't. */ ++ if (cand1->viable > cand2->viable) ++ return 1; ++ if (cand1->viable < cand2->viable) ++ return -1; ++ ++ /* If we have two pseudo-candidates for conversions to the same type, ++ or two candidates for the same function, arbitrarily pick one. */ ++ if (cand1->fn == cand2->fn ++ && (TYPE_P (cand1->fn) || DECL_P (cand1->fn))) ++ return 1; ++ ++ /* a viable function F1 ++ is defined to be a better function than another viable function F2 if ++ for all arguments i, ICSi(F1) is not a worse conversion sequence than ++ ICSi(F2), and then */ ++ ++ /* for some argument j, ICSj(F1) is a better conversion sequence than ++ ICSj(F2) */ ++ ++ /* For comparing static and non-static member functions, we ignore ++ the implicit object parameter of the non-static function. The ++ standard says to pretend that the static function has an object ++ parm, but that won't work with operator overloading. */ ++ len = TREE_VEC_LENGTH (cand1->convs); ++ if (len != TREE_VEC_LENGTH (cand2->convs)) ++ { ++ if (DECL_STATIC_FUNCTION_P (cand1->fn) ++ && ! DECL_STATIC_FUNCTION_P (cand2->fn)) ++ off2 = 1; ++ else if (! DECL_STATIC_FUNCTION_P (cand1->fn) ++ && DECL_STATIC_FUNCTION_P (cand2->fn)) ++ { ++ off1 = 1; ++ --len; ++ } ++ else ++ abort (); ++ } ++ ++ for (i = 0; i < len; ++i) ++ { ++ tree t1 = TREE_VEC_ELT (cand1->convs, i+off1); ++ tree t2 = TREE_VEC_ELT (cand2->convs, i+off2); ++ int comp = compare_ics (t1, t2); ++ ++ if (comp != 0) ++ { ++ if (warn_sign_promo ++ && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK ++ && TREE_CODE (t1) == STD_CONV ++ && TREE_CODE (t2) == STD_CONV ++ && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE ++ && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE ++ && (TYPE_PRECISION (TREE_TYPE (t1)) ++ == TYPE_PRECISION (TREE_TYPE (t2))) ++ && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0))) ++ || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0))) ++ == ENUMERAL_TYPE))) ++ { ++ tree type = TREE_TYPE (TREE_OPERAND (t1, 0)); ++ tree type1, type2; ++ struct z_candidate *w, *l; ++ if (comp > 0) ++ type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2), ++ w = cand1, l = cand2; ++ else ++ type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1), ++ w = cand2, l = cand1; ++ ++ if (warn) ++ { ++ warning ("passing `%T' chooses `%T' over `%T'", ++ type, type1, type2); ++ warning (" in call to `%D'", w->fn); ++ } ++ else ++ add_warning (w, l); ++ } ++ ++ if (winner && comp != winner) ++ { ++ winner = 0; ++ goto tweak; ++ } ++ winner = comp; ++ } ++ } ++ ++ /* warn about confusing overload resolution for user-defined conversions, ++ either between a constructor and a conversion op, or between two ++ conversion ops. */ ++ if (winner && warn_conversion && cand1->second_conv ++ && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn)) ++ && winner != compare_ics (cand1->second_conv, cand2->second_conv)) ++ { ++ struct z_candidate *w, *l; ++ bool give_warning = false; ++ ++ if (winner == 1) ++ w = cand1, l = cand2; ++ else ++ w = cand2, l = cand1; ++ ++ /* We don't want to complain about `X::operator T1 ()' ++ beating `X::operator T2 () const', when T2 is a no less ++ cv-qualified version of T1. */ ++ if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn) ++ && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn)) ++ { ++ tree t = TREE_TYPE (TREE_TYPE (l->fn)); ++ tree f = TREE_TYPE (TREE_TYPE (w->fn)); ++ ++ if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t)) ++ { ++ t = TREE_TYPE (t); ++ f = TREE_TYPE (f); ++ } ++ if (!comp_ptr_ttypes (t, f)) ++ give_warning = true; ++ } ++ else ++ give_warning = true; ++ ++ if (!give_warning) ++ /*NOP*/; ++ else if (warn) ++ { ++ tree source = source_type (TREE_VEC_ELT (w->convs, 0)); ++ if (! DECL_CONSTRUCTOR_P (w->fn)) ++ source = TREE_TYPE (source); ++ warning ("choosing `%D' over `%D'", w->fn, l->fn); ++ warning (" for conversion from `%T' to `%T'", ++ source, TREE_TYPE (w->second_conv)); ++ warning (" because conversion sequence for the argument is better"); ++ } ++ else ++ add_warning (w, l); ++ } ++ ++ if (winner) ++ return winner; ++ ++ /* or, if not that, ++ F1 is a non-template function and F2 is a template function ++ specialization. */ ++ ++ if (! cand1->template && cand2->template) ++ return 1; ++ else if (cand1->template && ! cand2->template) ++ return -1; ++ ++ /* or, if not that, ++ F1 and F2 are template functions and the function template for F1 is ++ more specialized than the template for F2 according to the partial ++ ordering rules. */ ++ ++ if (cand1->template && cand2->template) ++ { ++ winner = more_specialized ++ (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template), ++ DEDUCE_ORDER, ++ /* Tell the deduction code how many real function arguments ++ we saw, not counting the implicit 'this' argument. But, ++ add_function_candidate() suppresses the "this" argument ++ for constructors. ++ ++ [temp.func.order]: The presence of unused ellipsis and default ++ arguments has no effect on the partial ordering of function ++ templates. */ ++ TREE_VEC_LENGTH (cand1->convs) ++ - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn) ++ - DECL_CONSTRUCTOR_P (cand1->fn))); ++ if (winner) ++ return winner; ++ } ++ ++ /* or, if not that, ++ the context is an initialization by user-defined conversion (see ++ _dcl.init_ and _over.match.user_) and the standard conversion ++ sequence from the return type of F1 to the destination type (i.e., ++ the type of the entity being initialized) is a better conversion ++ sequence than the standard conversion sequence from the return type ++ of F2 to the destination type. */ ++ ++ if (cand1->second_conv) ++ { ++ winner = compare_ics (cand1->second_conv, cand2->second_conv); ++ if (winner) ++ return winner; ++ } ++ ++ /* Check whether we can discard a builtin candidate, either because we ++ have two identical ones or matching builtin and non-builtin candidates. ++ ++ (Pedantically in the latter case the builtin which matched the user ++ function should not be added to the overload set, but we spot it here. ++ ++ [over.match.oper] ++ ... the builtin candidates include ... ++ - do not have the same parameter type list as any non-template ++ non-member candidate. */ ++ ++ if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE ++ || TREE_CODE (cand2->fn) == IDENTIFIER_NODE) ++ { ++ for (i = 0; i < len; ++i) ++ if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)), ++ TREE_TYPE (TREE_VEC_ELT (cand2->convs, i)))) ++ break; ++ if (i == TREE_VEC_LENGTH (cand1->convs)) ++ { ++ if (cand1->fn == cand2->fn) ++ /* Two built-in candidates; arbitrarily pick one. */ ++ return 1; ++ else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE) ++ /* cand1 is built-in; prefer cand2. */ ++ return -1; ++ else ++ /* cand2 is built-in; prefer cand1. */ ++ return 1; ++ } ++ } ++ ++ /* If the two functions are the same (this can happen with declarations ++ in multiple scopes and arg-dependent lookup), arbitrarily choose one. */ ++ if (DECL_P (cand1->fn) && DECL_P (cand2->fn) ++ && equal_functions (cand1->fn, cand2->fn)) ++ return 1; ++ ++tweak: ++ ++ /* Extension: If the worst conversion for one candidate is worse than the ++ worst conversion for the other, take the first. */ ++ if (!pedantic) ++ { ++ int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK; ++ struct z_candidate *w = 0, *l = 0; ++ ++ for (i = 0; i < len; ++i) ++ { ++ if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1) ++ rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)); ++ if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2) ++ rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)); ++ } ++ if (rank1 < rank2) ++ winner = 1, w = cand1, l = cand2; ++ if (rank1 > rank2) ++ winner = -1, w = cand2, l = cand1; ++ if (winner) ++ { ++ if (warn) ++ { ++ pedwarn ("\ ++ISO C++ says that these are ambiguous, even \ ++though the worst conversion for the first is better than \ ++the worst conversion for the second:"); ++ print_z_candidate (_("candidate 1:"), w); ++ print_z_candidate (_("candidate 2:"), l); ++ } ++ else ++ add_warning (w, l); ++ return winner; ++ } ++ } ++ ++ my_friendly_assert (!winner, 20010121); ++ return 0; ++} ++ ++/* Given a list of candidates for overloading, find the best one, if any. ++ This algorithm has a worst case of O(2n) (winner is last), and a best ++ case of O(n/2) (totally ambiguous); much better than a sorting ++ algorithm. */ ++ ++static struct z_candidate * ++tourney (struct z_candidate *candidates) ++{ ++ struct z_candidate *champ = candidates, *challenger; ++ int fate; ++ int champ_compared_to_predecessor = 0; ++ ++ /* Walk through the list once, comparing each current champ to the next ++ candidate, knocking out a candidate or two with each comparison. */ ++ ++ for (challenger = champ->next; challenger; ) ++ { ++ fate = joust (champ, challenger, 0); ++ if (fate == 1) ++ challenger = challenger->next; ++ else ++ { ++ if (fate == 0) ++ { ++ champ = challenger->next; ++ if (champ == 0) ++ return 0; ++ champ_compared_to_predecessor = 0; ++ } ++ else ++ { ++ champ = challenger; ++ champ_compared_to_predecessor = 1; ++ } ++ ++ challenger = champ->next; ++ } ++ } ++ ++ /* Make sure the champ is better than all the candidates it hasn't yet ++ been compared to. */ ++ ++ for (challenger = candidates; ++ challenger != champ ++ && !(champ_compared_to_predecessor && challenger->next == champ); ++ challenger = challenger->next) ++ { ++ fate = joust (champ, challenger, 0); ++ if (fate != 1) ++ return 0; ++ } ++ ++ return champ; ++} ++ ++/* Returns nonzero if things of type FROM can be converted to TO. */ ++ ++bool ++can_convert (tree to, tree from) ++{ ++ return can_convert_arg (to, from, NULL_TREE); ++} ++ ++/* Returns nonzero if ARG (of type FROM) can be converted to TO. */ ++ ++bool ++can_convert_arg (tree to, tree from, tree arg) ++{ ++ tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL); ++ return (t && ! ICS_BAD_FLAG (t)); ++} ++ ++/* Like can_convert_arg, but allows dubious conversions as well. */ ++ ++bool ++can_convert_arg_bad (tree to, tree from, tree arg) ++{ ++ return implicit_conversion (to, from, arg, LOOKUP_NORMAL) != 0; ++} ++ ++/* Convert EXPR to TYPE. Return the converted expression. ++ ++ Note that we allow bad conversions here because by the time we get to ++ this point we are committed to doing the conversion. If we end up ++ doing a bad conversion, convert_like will complain. */ ++ ++tree ++perform_implicit_conversion (tree type, tree expr) ++{ ++ tree conv; ++ ++ if (error_operand_p (expr)) ++ return error_mark_node; ++ conv = implicit_conversion (type, TREE_TYPE (expr), expr, ++ LOOKUP_NORMAL); ++ if (!conv) ++ { ++ error ("could not convert `%E' to `%T'", expr, type); ++ return error_mark_node; ++ } ++ ++ return convert_like (conv, expr); ++} ++ ++/* Convert EXPR to TYPE (as a direct-initialization) if that is ++ permitted. If the conversion is valid, the converted expression is ++ returned. Otherwise, NULL_TREE is returned, except in the case ++ that TYPE is a class type; in that case, an error is issued. */ ++ ++tree ++perform_direct_initialization_if_possible (tree type, tree expr) ++{ ++ tree conv; ++ ++ if (type == error_mark_node || error_operand_p (expr)) ++ return error_mark_node; ++ /* [dcl.init] ++ ++ If the destination type is a (possibly cv-qualified) class type: ++ ++ -- If the initialization is direct-initialization ..., ++ constructors are considered. ... If no constructor applies, or ++ the overload resolution is ambiguous, the initialization is ++ ill-formed. */ ++ if (CLASS_TYPE_P (type)) ++ { ++ expr = build_special_member_call (NULL_TREE, complete_ctor_identifier, ++ build_tree_list (NULL_TREE, expr), ++ TYPE_BINFO (type), ++ LOOKUP_NORMAL); ++ return build_cplus_new (type, expr); ++ } ++ conv = implicit_conversion (type, TREE_TYPE (expr), expr, ++ LOOKUP_NORMAL); ++ if (!conv || ICS_BAD_FLAG (conv)) ++ return NULL_TREE; ++ return convert_like_real (conv, expr, NULL_TREE, 0, 0, ++ /*issue_conversion_warnings=*/false); ++} ++ ++/* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference ++ is being bound to a temporary. Create and return a new VAR_DECL ++ with the indicated TYPE; this variable will store the value to ++ which the reference is bound. */ ++ ++tree ++make_temporary_var_for_ref_to_temp (tree decl, tree type) ++{ ++ tree var; ++ ++ /* Create the variable. */ ++ var = build_decl (VAR_DECL, NULL_TREE, type); ++ DECL_ARTIFICIAL (var) = 1; ++ TREE_USED (var) = 1; ++ ++ /* Register the variable. */ ++ if (TREE_STATIC (decl)) ++ { ++ /* Namespace-scope or local static; give it a mangled name. */ ++ tree name; ++ ++ TREE_STATIC (var) = 1; ++ name = mangle_ref_init_variable (decl); ++ DECL_NAME (var) = name; ++ SET_DECL_ASSEMBLER_NAME (var, name); ++ var = pushdecl_top_level (var); ++ } ++ else ++ { ++ /* Create a new cleanup level if necessary. */ ++ maybe_push_cleanup_level (type); ++ /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */ ++ DECL_CONTEXT (var) = current_function_decl; ++ } ++ ++ return var; ++} ++ ++/* Convert EXPR to the indicated reference TYPE, in a way suitable for ++ initializing a variable of that TYPE. If DECL is non-NULL, it is ++ the VAR_DECL being initialized with the EXPR. (In that case, the ++ type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must ++ also be non-NULL, and with *CLEANUP initialized to NULL. Upon ++ return, if *CLEANUP is no longer NULL, it will be a CLEANUP_STMT ++ that should be inserted after the returned expression is used to ++ initialize DECL. ++ ++ Return the converted expression. */ ++ ++tree ++initialize_reference (tree type, tree expr, tree decl, tree *cleanup) ++{ ++ tree conv; ++ ++ if (type == error_mark_node || error_operand_p (expr)) ++ return error_mark_node; ++ ++ conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL); ++ if (!conv || ICS_BAD_FLAG (conv)) ++ { ++ if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST) ++ && !real_lvalue_p (expr)) ++ error ("invalid initialization of non-const reference of " ++ "type '%T' from a temporary of type '%T'", ++ type, TREE_TYPE (expr)); ++ else ++ error ("invalid initialization of reference of type " ++ "'%T' from expression of type '%T'", type, ++ TREE_TYPE (expr)); ++ return error_mark_node; ++ } ++ ++ /* If DECL is non-NULL, then this special rule applies: ++ ++ [class.temporary] ++ ++ The temporary to which the reference is bound or the temporary ++ that is the complete object to which the reference is bound ++ persists for the lifetime of the reference. ++ ++ The temporaries created during the evaluation of the expression ++ initializing the reference, except the temporary to which the ++ reference is bound, are destroyed at the end of the ++ full-expression in which they are created. ++ ++ In that case, we store the converted expression into a new ++ VAR_DECL in a new scope. ++ ++ However, we want to be careful not to create temporaries when ++ they are not required. For example, given: ++ ++ struct B {}; ++ struct D : public B {}; ++ D f(); ++ const B& b = f(); ++ ++ there is no need to copy the return value from "f"; we can just ++ extend its lifetime. Similarly, given: ++ ++ struct S {}; ++ struct T { operator S(); }; ++ T t; ++ const S& s = t; ++ ++ we can extend the lifetime of the return value of the conversion ++ operator. */ ++ my_friendly_assert (TREE_CODE (conv) == REF_BIND, 20030302); ++ if (decl) ++ { ++ tree var; ++ tree base_conv_type; ++ ++ /* Skip over the REF_BIND. */ ++ conv = TREE_OPERAND (conv, 0); ++ /* If the next conversion is a BASE_CONV, skip that too -- but ++ remember that the conversion was required. */ ++ if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv)) ++ { ++ if (CHECK_COPY_CONSTRUCTOR_P (conv)) ++ check_constructor_callable (TREE_TYPE (expr), expr); ++ base_conv_type = TREE_TYPE (conv); ++ conv = TREE_OPERAND (conv, 0); ++ } ++ else ++ base_conv_type = NULL_TREE; ++ /* Perform the remainder of the conversion. */ ++ expr = convert_like_real (conv, expr, ++ /*fn=*/NULL_TREE, /*argnum=*/0, ++ /*inner=*/-1, ++ /*issue_conversion_warnings=*/true); ++ if (error_operand_p (expr)) ++ return error_mark_node; ++ if (!real_lvalue_p (expr)) ++ { ++ tree init; ++ tree type; ++ ++ /* Create the temporary variable. */ ++ type = TREE_TYPE (expr); ++ var = make_temporary_var_for_ref_to_temp (decl, type); ++ layout_decl (var, 0); ++ /* If the rvalue is the result of a function call it will be ++ a TARGET_EXPR. If it is some other construct (such as a ++ member access expression where the underlying object is ++ itself the result of a function call), turn it into a ++ TARGET_EXPR here. It is important that EXPR be a ++ TARGET_EXPR below since otherwise the INIT_EXPR will ++ attempt to make a bitwise copy of EXPR to intialize ++ VAR. */ ++ if (TREE_CODE (expr) != TARGET_EXPR) ++ expr = get_target_expr (expr); ++ /* Create the INIT_EXPR that will initialize the temporary ++ variable. */ ++ init = build (INIT_EXPR, type, var, expr); ++ if (at_function_scope_p ()) ++ { ++ add_decl_stmt (var); ++ *cleanup = cxx_maybe_build_cleanup (var); ++ if (*cleanup) ++ /* We must be careful to destroy the temporary only ++ after its initialization has taken place. If the ++ initialization throws an exception, then the ++ destructor should not be run. We cannot simply ++ transform INIT into something like: ++ ++ (INIT, ({ CLEANUP_STMT; })) ++ ++ because emit_local_var always treats the ++ initializer as a full-expression. Thus, the ++ destructor would run too early; it would run at the ++ end of initializing the reference variable, rather ++ than at the end of the block enclosing the ++ reference variable. ++ ++ The solution is to pass back a CLEANUP_STMT which ++ the caller is responsible for attaching to the ++ statement tree. */ ++ *cleanup = build_stmt (CLEANUP_STMT, var, *cleanup); ++ } ++ else ++ { ++ rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof); ++ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) ++ static_aggregates = tree_cons (NULL_TREE, var, ++ static_aggregates); ++ } ++ /* Use its address to initialize the reference variable. */ ++ expr = build_address (var); ++ expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr); ++ } ++ else ++ /* Take the address of EXPR. */ ++ expr = build_unary_op (ADDR_EXPR, expr, 0); ++ /* If a BASE_CONV was required, perform it now. */ ++ if (base_conv_type) ++ expr = (perform_implicit_conversion ++ (build_pointer_type (base_conv_type), expr)); ++ return build_nop (type, expr); ++ } ++ ++ /* Perform the conversion. */ ++ return convert_like (conv, expr); ++} ++ ++#include "gt-cp-call.h" +diff -NBaur gcc-3.4.4/gcc/cp/cfns.gperf gcc-3.4.4-new/gcc/cp/cfns.gperf +--- gcc-3.4.4/gcc/cp/cfns.gperf Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cfns.gperf Fri Jul 25 14:57:43 2003 +@@ -0,0 +1,230 @@ ++%{ ++#ifdef __GNUC__ ++__inline ++#endif ++static unsigned int hash (const char *, unsigned int); ++#ifdef __GNUC__ ++__inline ++#endif ++const char * libc_name_p (const char *, unsigned int); ++%} ++%% ++# The standard C library functions, for feeding to gperf; the result is used ++# by nothrow_libfn_p. ++# ++# [lib.res.on.exception.handling]: None of the functions from the ++# Standard C library shall report an error by throwing an ++# exception, unless it calls a program-supplied function that ++# throws an exception. ++# ++# Specific functions are commented out for the reason noted in each case. ++# ++# abort -- synchronous exception from SIGABRT handler ++abs ++acos ++asctime ++asin ++atan ++atan2 ++atexit ++atof ++atoi ++atol ++#bsearch -- calls user function which may throw exception ++btowc ++calloc ++ceil ++clearerr ++clock ++cos ++cosh ++ctime ++difftime ++div ++exit ++exp ++fabs ++#fclose -- POSIX thread cancellation point ++feof ++ferror ++#fflush -- POSIX thread cancellation point ++#fgetc -- POSIX thread cancellation point ++#fgetpos -- POSIX thread cancellation point ++#fgets -- POSIX thread cancellation point ++#fgetwc -- POSIX thread cancellation point ++#fgetws -- POSIX thread cancellation point ++floor ++fmod ++#fopen -- POSIX thread cancellation point ++#fprintf -- POSIX thread cancellation point ++#fputc -- POSIX thread cancellation point ++#fputs -- POSIX thread cancellation point ++#fputwc -- POSIX thread cancellation point ++#fputws -- POSIX thread cancellation point ++#fread -- POSIX thread cancellation point ++free ++#freopen -- POSIX thread cancellation point ++frexp ++#fscanf -- POSIX thread cancellation point ++fseek ++#fsetpos -- POSIX thread cancellation point ++#ftell -- POSIX thread cancellation point ++fwide ++#fwprintf -- POSIX thread cancellation point ++#fwrite -- POSIX thread cancellation point ++#fwscanf -- POSIX thread cancellation point ++#getc -- POSIX thread cancellation point ++#getchar -- POSIX thread cancellation point ++getenv ++#gets -- POSIX thread cancellation point ++#getwc -- POSIX thread cancellation point ++#getwchar -- POSIX thread cancellation point ++gmtime ++isalnum ++isalpha ++iscntrl ++isdigit ++isgraph ++islower ++isprint ++ispunct ++isspace ++isupper ++iswalnum ++iswalpha ++iswcntrl ++iswctype ++iswdigit ++iswgraph ++iswlower ++iswprint ++iswpunct ++iswspace ++iswupper ++iswxdigit ++isxdigit ++labs ++ldexp ++ldiv ++localeconv ++localtime ++log ++log10 ++longjmp ++malloc ++mblen ++mbrlen ++mbrtowc ++mbsinit ++mbsrtowcs ++mbstowcs ++mbtowc ++memchr ++memcmp ++memcpy ++memmove ++memset ++mktime ++modf ++#perror -- POSIX thread cancellation point ++pow ++#printf -- POSIX thread cancellation point ++#putc -- POSIX thread cancellation point ++#putchar -- POSIX thread cancellation point ++#puts -- POSIX thread cancellation point ++#putwc -- POSIX thread cancellation point ++#putwchar -- POSIX thread cancellation point ++#qsort -- calls user function which may throw exception ++#raise -- synchronous exception from signal handler ++rand ++realloc ++#remove -- POSIX thread cancellation point ++#rename -- POSIX thread cancellation point ++#rewind -- POSIX thread cancellation point ++#scanf -- POSIX thread cancellation point ++setbuf ++setlocale ++setvbuf ++signal ++sin ++sinh ++sprintf ++sqrt ++srand ++sscanf ++strcat ++strchr ++strcmp ++strcoll ++strcpy ++strcspn ++#strerror -- POSIX thread cancellation point ++strftime ++strlen ++strncat ++strncmp ++strncpy ++strpbrk ++strrchr ++strspn ++strstr ++strtod ++strtok ++strtol ++strtoul ++strxfrm ++swprintf ++swscanf ++#system -- POSIX thread cancellation point ++tan ++tanh ++time ++#tmpfile -- POSIX thread cancellation point ++#tmpnam -- POSIX thread cancellation point ++tolower ++toupper ++towctrans ++towlower ++towupper ++#ungetc -- POSIX thread cancellation point ++#ungetwc -- POSIX thread cancellation point ++#vfprintf -- POSIX thread cancellation point ++#vfwprintf -- POSIX thread cancellation point ++#vprintf -- POSIX thread cancellation point ++vsprintf ++vswprintf ++#vwprintf -- POSIX thread cancellation point ++wcrtomb ++wcscat ++wcschr ++wcscmp ++wcscoll ++wcscpy ++wcscspn ++wcsftime ++wcslen ++wcsncat ++wcsncmp ++wcsncpy ++wcspbrk ++wcsrchr ++wcsrtombs ++wcsspn ++wcsstr ++wcstod ++wcstok ++wcstol ++wcstombs ++wcstoul ++wcsxfrm ++wctob ++wctomb ++wctrans ++wctype ++wmemchr ++wmemcmp ++wmemcpy ++wmemmove ++wmemset ++#wprintf -- POSIX thread cancellation point ++#wscanf -- POSIX thread cancellation point +diff -NBaur gcc-3.4.4/gcc/cp/cfns.h gcc-3.4.4-new/gcc/cp/cfns.h +--- gcc-3.4.4/gcc/cp/cfns.h Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cfns.h Sat Jul 26 20:31:30 2003 +@@ -0,0 +1,345 @@ ++/* ANSI-C code produced by gperf version 3.0.1 */ ++/* Command-line: gperf -o -C -E -k '1-6,$' -j1 -D -N libc_name_p -L ANSI-C ../../gcc/gcc/cp/cfns.gperf */ ++ ++#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ ++ && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ ++ && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ ++ && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ ++ && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ ++ && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ ++ && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ ++ && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ ++ && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ ++ && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ ++ && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ ++ && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ ++ && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ ++ && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ ++ && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ ++ && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ ++ && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ ++ && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ ++ && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ ++ && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ ++ && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ ++ && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ ++ && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) ++/* The character set is not based on ISO-646. */ ++#error "gperf generated tables don't work with this execution character set. Please report a bug to ." ++#endif ++ ++#line 1 "../../gcc/gcc/cp/cfns.gperf" ++ ++#ifdef __GNUC__ ++__inline ++#endif ++static unsigned int hash (const char *, unsigned int); ++#ifdef __GNUC__ ++__inline ++#endif ++const char * libc_name_p (const char *, unsigned int); ++/* maximum key range = 391, duplicates = 0 */ ++ ++#ifdef __GNUC__ ++__inline ++#else ++#ifdef __cplusplus ++inline ++#endif ++#endif ++static unsigned int ++hash (register const char *str, register unsigned int len) ++{ ++ static const unsigned short asso_values[] = ++ { ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 0, 0, ++ 1, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 28, 90, 0, ++ 95, 0, 51, 93, 114, 26, 109, 124, 5, 1, ++ 6, 13, 37, 128, 3, 0, 0, 49, 38, 0, ++ 104, 45, 0, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, ++ 400, 400, 400, 400, 400, 400, 400 ++ }; ++ register int hval = len; ++ ++ switch (hval) ++ { ++ default: ++ hval += asso_values[(unsigned char)str[5]+1]; ++ /*FALLTHROUGH*/ ++ case 5: ++ hval += asso_values[(unsigned char)str[4]]; ++ /*FALLTHROUGH*/ ++ case 4: ++ hval += asso_values[(unsigned char)str[3]]; ++ /*FALLTHROUGH*/ ++ case 3: ++ hval += asso_values[(unsigned char)str[2]]; ++ /*FALLTHROUGH*/ ++ case 2: ++ hval += asso_values[(unsigned char)str[1]]; ++ /*FALLTHROUGH*/ ++ case 1: ++ hval += asso_values[(unsigned char)str[0]]; ++ break; ++ } ++ return hval + asso_values[(unsigned char)str[len - 1]]; ++} ++ ++#ifdef __GNUC__ ++__inline ++#endif ++const char * ++libc_name_p (register const char *str, register unsigned int len) ++{ ++ enum ++ { ++ TOTAL_KEYWORDS = 156, ++ MIN_WORD_LENGTH = 3, ++ MAX_WORD_LENGTH = 10, ++ MIN_HASH_VALUE = 9, ++ MAX_HASH_VALUE = 399 ++ }; ++ ++ static const char * const wordlist[] = ++ { ++ "wcsstr", ++ "strstr", ++ "cos", ++ "towctrans", ++ "memmove", ++ "wcstol", ++ "wcscoll", ++ "wcstombs", ++ "strtol", ++ "strcoll", ++ "wcslen", ++ "time", ++ "ctime", ++ "strlen", ++ "iswctype", ++ "wmemchr", ++ "wcsrchr", ++ "ceil", ++ "sin", ++ "strrchr", ++ "tan", ++ "iscntrl", ++ "acos", ++ "wmemmove", ++ "wcsrtombs", ++ "wctrans", ++ "wmemcmp", ++ "pow", ++ "atol", ++ "wcsncmp", ++ "memset", ++ "free", ++ "strncmp", ++ "wmemset", ++ "wcsspn", ++ "wcstoul", ++ "strspn", ++ "strtoul", ++ "asctime", ++ "atan2", ++ "asin", ++ "atan", ++ "ferror", ++ "iswalnum", ++ "wcscat", ++ "realloc", ++ "strcat", ++ "wcscpy", ++ "memcpy", ++ "strcpy", ++ "tolower", ++ "floor", ++ "iswcntrl", ++ "atoi", ++ "clearerr", ++ "swscanf", ++ "wcsncat", ++ "islower", ++ "strncat", ++ "btowc", ++ "localtime", ++ "wctomb", ++ "isalnum", ++ "isprint", ++ "mblen", ++ "wcstod", ++ "log10", ++ "strtod", ++ "wcrtomb", ++ "abs", ++ "setlocale", ++ "wcschr", ++ "mbrlen", ++ "memchr", ++ "strchr", ++ "labs", ++ "iswpunct", ++ "exit", ++ "sqrt", ++ "swprintf", ++ "wctype", ++ "mbsrtowcs", ++ "wcscspn", ++ "getenv", ++ "strcspn", ++ "towlower", ++ "atof", ++ "wcstok", ++ "localeconv", ++ "strtok", ++ "calloc", ++ "malloc", ++ "isalpha", ++ "iswlower", ++ "iswspace", ++ "wcsxfrm", ++ "signal", ++ "strxfrm", ++ "wcsftime", ++ "feof", ++ "strftime", ++ "wcscmp", ++ "fabs", ++ "memcmp", ++ "strcmp", ++ "vsprintf", ++ "fwide", ++ "gmtime", ++ "sprintf", ++ "exp", ++ "wmemcpy", ++ "iswprint", ++ "sscanf", ++ "wcsncpy", ++ "strncpy", ++ "isspace", ++ "toupper", ++ "wctob", ++ "div", ++ "mbtowc", ++ "ldiv", ++ "log", ++ "mktime", ++ "isupper", ++ "atexit", ++ "modf", ++ "mbstowcs", ++ "mbrtowc", ++ "ispunct", ++ "iswalpha", ++ "setvbuf", ++ "rand", ++ "srand", ++ "frexp", ++ "towupper", ++ "mbsinit", ++ "cosh", ++ "vswprintf", ++ "iswupper", ++ "wcspbrk", ++ "fmod", ++ "strpbrk", ++ "sinh", ++ "tanh", ++ "iswdigit", ++ "clock", ++ "longjmp", ++ "ldexp", ++ "setbuf", ++ "fseek", ++ "iswgraph", ++ "difftime", ++ "iswxdigit", ++ "isdigit", ++ "isxdigit", ++ "isgraph" ++ }; ++ ++ static const short lookup[] = ++ { ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, ++ -1, -1, 1, -1, -1, -1, 2, -1, -1, -1, ++ -1, -1, 3, 4, -1, 5, 6, 7, 8, 9, ++ 10, 11, 12, 13, 14, -1, -1, -1, 15, 16, ++ 17, 18, 19, 20, 21, 22, -1, -1, 23, 24, ++ -1, 25, 26, 27, -1, 28, 29, 30, 31, 32, ++ 33, -1, 34, 35, -1, 36, 37, 38, -1, 39, ++ 40, -1, 41, -1, -1, -1, -1, -1, -1, 42, ++ -1, 43, -1, 44, -1, 45, 46, -1, 47, -1, ++ 48, 49, 50, 51, 52, -1, -1, 53, 54, 55, ++ -1, -1, -1, 56, -1, 57, 58, -1, 59, 60, ++ 61, 62, 63, 64, 65, -1, 66, 67, -1, 68, ++ -1, 69, 70, 71, 72, 73, 74, 75, -1, -1, ++ -1, -1, -1, 76, 77, 78, -1, -1, 79, 80, ++ 81, 82, -1, 83, 84, -1, 85, 86, 87, -1, ++ 88, 89, 90, 91, -1, -1, -1, 92, -1, 93, ++ -1, 94, -1, 95, -1, 96, 97, -1, 98, -1, ++ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, ++ -1, 109, 110, 111, 112, -1, 113, -1, -1, 114, ++ -1, -1, -1, 115, -1, -1, -1, 116, 117, -1, ++ 118, -1, -1, -1, -1, 119, 120, 121, -1, 122, ++ 123, -1, -1, 124, -1, 125, 126, -1, 127, -1, ++ 128, -1, -1, 129, 130, -1, -1, -1, -1, -1, ++ -1, 131, 132, -1, -1, -1, -1, 133, 134, 135, ++ -1, -1, -1, -1, -1, 136, -1, 137, -1, -1, ++ -1, 138, -1, -1, -1, -1, -1, -1, 139, 140, ++ -1, 141, -1, -1, 142, -1, 143, -1, -1, 144, ++ -1, 145, -1, -1, -1, -1, 146, -1, -1, -1, ++ -1, -1, -1, 147, -1, -1, -1, -1, -1, 148, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 149, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 150, -1, -1, -1, -1, -1, ++ 151, -1, -1, 152, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 153, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, 154, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 155 ++ }; ++ ++ if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) ++ { ++ register int key = hash (str, len); ++ ++ if (key <= MAX_HASH_VALUE && key >= 0) ++ { ++ register int index = lookup[key]; ++ ++ if (index >= 0) ++ { ++ register const char *s = wordlist[index]; ++ ++ if (*str == *s && !strcmp (str + 1, s + 1)) ++ return s; ++ } ++ } ++ } ++ return 0; ++} +diff -NBaur gcc-3.4.4/gcc/cp/class.c gcc-3.4.4-new/gcc/cp/class.c +--- gcc-3.4.4/gcc/cp/class.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/class.c Mon May 9 12:47:53 2005 +@@ -0,0 +1,7903 @@ ++/* Functions related to building classes and their related objects. ++ Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, ++ 1999, 2000, 2001, 2002, 2003, 2004, 2005 ++ Free Software Foundation, Inc. ++ Contributed by Michael Tiemann (tiemann@cygnus.com) ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++ ++/* High-level class interface. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "cp-tree.h" ++#include "flags.h" ++#include "rtl.h" ++#include "output.h" ++#include "toplev.h" ++#include "lex.h" ++#include "target.h" ++#include "convert.h" ++ ++/* The number of nested classes being processed. If we are not in the ++ scope of any class, this is zero. */ ++ ++int current_class_depth; ++ ++/* In order to deal with nested classes, we keep a stack of classes. ++ The topmost entry is the innermost class, and is the entry at index ++ CURRENT_CLASS_DEPTH */ ++ ++typedef struct class_stack_node { ++ /* The name of the class. */ ++ tree name; ++ ++ /* The _TYPE node for the class. */ ++ tree type; ++ ++ /* The access specifier pending for new declarations in the scope of ++ this class. */ ++ tree access; ++ ++ /* If were defining TYPE, the names used in this class. */ ++ splay_tree names_used; ++}* class_stack_node_t; ++ ++typedef struct vtbl_init_data_s ++{ ++ /* The base for which we're building initializers. */ ++ tree binfo; ++ /* The type of the most-derived type. */ ++ tree derived; ++ /* The binfo for the dynamic type. This will be TYPE_BINFO (derived), ++ unless ctor_vtbl_p is true. */ ++ tree rtti_binfo; ++ /* The negative-index vtable initializers built up so far. These ++ are in order from least negative index to most negative index. */ ++ tree inits; ++ /* The last (i.e., most negative) entry in INITS. */ ++ tree* last_init; ++ /* The binfo for the virtual base for which we're building ++ vcall offset initializers. */ ++ tree vbase; ++ /* The functions in vbase for which we have already provided vcall ++ offsets. */ ++ varray_type fns; ++ /* The vtable index of the next vcall or vbase offset. */ ++ tree index; ++ /* Nonzero if we are building the initializer for the primary ++ vtable. */ ++ int primary_vtbl_p; ++ /* Nonzero if we are building the initializer for a construction ++ vtable. */ ++ int ctor_vtbl_p; ++ /* True when adding vcall offset entries to the vtable. False when ++ merely computing the indices. */ ++ bool generate_vcall_entries; ++} vtbl_init_data; ++ ++/* The type of a function passed to walk_subobject_offsets. */ ++typedef int (*subobject_offset_fn) (tree, tree, splay_tree); ++ ++/* The stack itself. This is a dynamically resized array. The ++ number of elements allocated is CURRENT_CLASS_STACK_SIZE. */ ++static int current_class_stack_size; ++static class_stack_node_t current_class_stack; ++ ++/* An array of all local classes present in this translation unit, in ++ declaration order. */ ++varray_type local_classes; ++ ++static tree get_vfield_name (tree); ++static void finish_struct_anon (tree); ++static tree get_vtable_name (tree); ++static tree get_basefndecls (tree, tree); ++static int build_primary_vtable (tree, tree); ++static int build_secondary_vtable (tree); ++static void finish_vtbls (tree); ++static void modify_vtable_entry (tree, tree, tree, tree, tree *); ++static void finish_struct_bits (tree); ++static int alter_access (tree, tree, tree); ++static void handle_using_decl (tree, tree); ++static void check_for_override (tree, tree); ++static tree dfs_modify_vtables (tree, void *); ++static tree modify_all_vtables (tree, tree); ++static void determine_primary_base (tree); ++static void finish_struct_methods (tree); ++static void maybe_warn_about_overly_private_class (tree); ++static int method_name_cmp (const void *, const void *); ++static int resort_method_name_cmp (const void *, const void *); ++static void add_implicitly_declared_members (tree, int, int, int); ++static tree fixed_type_or_null (tree, int *, int *); ++static tree resolve_address_of_overloaded_function (tree, tree, tsubst_flags_t, ++ bool, tree); ++static tree build_vtbl_ref_1 (tree, tree); ++static tree build_vtbl_initializer (tree, tree, tree, tree, int *); ++static int count_fields (tree); ++static int add_fields_to_record_type (tree, struct sorted_fields_type*, int); ++static void check_bitfield_decl (tree); ++static void check_field_decl (tree, tree, int *, int *, int *, int *); ++static void check_field_decls (tree, tree *, int *, int *, int *); ++static tree *build_base_field (record_layout_info, tree, splay_tree, tree *); ++static void build_base_fields (record_layout_info, splay_tree, tree *); ++static void check_methods (tree); ++static void remove_zero_width_bit_fields (tree); ++static void check_bases (tree, int *, int *, int *); ++static void check_bases_and_members (tree); ++static tree create_vtable_ptr (tree, tree *); ++static void include_empty_classes (record_layout_info); ++static void layout_class_type (tree, tree *); ++static void fixup_pending_inline (tree); ++static void fixup_inline_methods (tree); ++static void set_primary_base (tree, tree); ++static void propagate_binfo_offsets (tree, tree); ++static void layout_virtual_bases (record_layout_info, splay_tree); ++static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *); ++static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *); ++static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *); ++static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *); ++static void add_vcall_offset (tree, tree, vtbl_init_data *); ++static void layout_vtable_decl (tree, int); ++static tree dfs_find_final_overrider (tree, void *); ++static tree dfs_find_final_overrider_post (tree, void *); ++static tree dfs_find_final_overrider_q (tree, int, void *); ++static tree find_final_overrider (tree, tree, tree); ++static int make_new_vtable (tree, tree); ++static int maybe_indent_hierarchy (FILE *, int, int); ++static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int); ++static void dump_class_hierarchy (tree); ++static void dump_class_hierarchy_1 (FILE *, int, tree); ++static void dump_array (FILE *, tree); ++static void dump_vtable (tree, tree, tree); ++static void dump_vtt (tree, tree); ++static void dump_thunk (FILE *, int, tree); ++static tree build_vtable (tree, tree, tree); ++static void initialize_vtable (tree, tree); ++static void initialize_array (tree, tree); ++static void layout_nonempty_base_or_field (record_layout_info, ++ tree, tree, splay_tree); ++static tree end_of_class (tree, int); ++static bool layout_empty_base (tree, tree, splay_tree); ++static void accumulate_vtbl_inits (tree, tree, tree, tree, tree); ++static tree dfs_accumulate_vtbl_inits (tree, tree, tree, tree, ++ tree); ++static void build_rtti_vtbl_entries (tree, vtbl_init_data *); ++static void build_vcall_and_vbase_vtbl_entries (tree, ++ vtbl_init_data *); ++static void mark_primary_bases (tree); ++static void clone_constructors_and_destructors (tree); ++static tree build_clone (tree, tree); ++static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned); ++static tree copy_virtuals (tree); ++static void build_ctor_vtbl_group (tree, tree); ++static void build_vtt (tree); ++static tree binfo_ctor_vtable (tree); ++static tree *build_vtt_inits (tree, tree, tree *, tree *); ++static tree dfs_build_secondary_vptr_vtt_inits (tree, void *); ++static tree dfs_ctor_vtable_bases_queue_p (tree, int, void *data); ++static tree dfs_fixup_binfo_vtbls (tree, void *); ++static int record_subobject_offset (tree, tree, splay_tree); ++static int check_subobject_offset (tree, tree, splay_tree); ++static int walk_subobject_offsets (tree, subobject_offset_fn, ++ tree, splay_tree, tree, int); ++static void record_subobject_offsets (tree, tree, splay_tree, int); ++static int layout_conflict_p (tree, tree, splay_tree, int); ++static int splay_tree_compare_integer_csts (splay_tree_key k1, ++ splay_tree_key k2); ++static void warn_about_ambiguous_bases (tree); ++static bool type_requires_array_cookie (tree); ++static bool contains_empty_class_p (tree); ++static bool base_derived_from (tree, tree); ++static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree); ++static tree end_of_base (tree); ++static tree get_vcall_index (tree, tree); ++ ++/* Macros for dfs walking during vtt construction. See ++ dfs_ctor_vtable_bases_queue_p, dfs_build_secondary_vptr_vtt_inits ++ and dfs_fixup_binfo_vtbls. */ ++#define VTT_TOP_LEVEL_P(NODE) TREE_UNSIGNED (NODE) ++#define VTT_MARKED_BINFO_P(NODE) TREE_USED (NODE) ++ ++/* Variables shared between class.c and call.c. */ ++ ++#ifdef GATHER_STATISTICS ++int n_vtables = 0; ++int n_vtable_entries = 0; ++int n_vtable_searches = 0; ++int n_vtable_elems = 0; ++int n_convert_harshness = 0; ++int n_compute_conversion_costs = 0; ++int n_inner_fields_searched = 0; ++#endif ++ ++/* Convert to or from a base subobject. EXPR is an expression of type ++ `A' or `A*', an expression of type `B' or `B*' is returned. To ++ convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for ++ the B base instance within A. To convert base A to derived B, CODE ++ is MINUS_EXPR and BINFO is the binfo for the A instance within B. ++ In this latter case, A must not be a morally virtual base of B. ++ NONNULL is true if EXPR is known to be non-NULL (this is only ++ needed when EXPR is of pointer type). CV qualifiers are preserved ++ from EXPR. */ ++ ++tree ++build_base_path (enum tree_code code, ++ tree expr, ++ tree binfo, ++ int nonnull) ++{ ++ tree v_binfo = NULL_TREE; ++ tree d_binfo = NULL_TREE; ++ tree probe; ++ tree offset; ++ tree target_type; ++ tree null_test = NULL; ++ tree ptr_target_type; ++ int fixed_type_p; ++ int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE; ++ ++ if (expr == error_mark_node || binfo == error_mark_node || !binfo) ++ return error_mark_node; ++ ++ for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe)) ++ { ++ d_binfo = probe; ++ if (!v_binfo && TREE_VIA_VIRTUAL (probe)) ++ v_binfo = probe; ++ } ++ ++ probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr)); ++ if (want_pointer) ++ probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe)); ++ ++ my_friendly_assert (code == MINUS_EXPR ++ ? same_type_p (BINFO_TYPE (binfo), probe) ++ : code == PLUS_EXPR ++ ? same_type_p (BINFO_TYPE (d_binfo), probe) ++ : false, 20010723); ++ ++ if (code == MINUS_EXPR && v_binfo) ++ { ++ error ("cannot convert from base `%T' to derived type `%T' via virtual base `%T'", ++ BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo)); ++ return error_mark_node; ++ } ++ ++ if (!want_pointer) ++ /* This must happen before the call to save_expr. */ ++ expr = build_unary_op (ADDR_EXPR, expr, 0); ++ ++ fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull); ++ if (fixed_type_p <= 0 && TREE_SIDE_EFFECTS (expr)) ++ expr = save_expr (expr); ++ ++ if (want_pointer && !nonnull) ++ null_test = build (EQ_EXPR, boolean_type_node, expr, integer_zero_node); ++ ++ offset = BINFO_OFFSET (binfo); ++ ++ if (v_binfo && fixed_type_p <= 0) ++ { ++ /* Going via virtual base V_BINFO. We need the static offset ++ from V_BINFO to BINFO, and the dynamic offset from D_BINFO to ++ V_BINFO. That offset is an entry in D_BINFO's vtable. */ ++ tree v_offset; ++ ++ if (fixed_type_p < 0 && in_base_initializer) ++ { ++ /* In a base member initializer, we cannot rely on ++ the vtable being set up. We have to use the vtt_parm. */ ++ tree derived = BINFO_INHERITANCE_CHAIN (v_binfo); ++ ++ v_offset = build (PLUS_EXPR, TREE_TYPE (current_vtt_parm), ++ current_vtt_parm, BINFO_VPTR_INDEX (derived)); ++ ++ v_offset = build1 (INDIRECT_REF, ++ TREE_TYPE (TYPE_VFIELD (BINFO_TYPE (derived))), ++ v_offset); ++ ++ } ++ else ++ v_offset = build_vfield_ref (build_indirect_ref (expr, NULL), ++ TREE_TYPE (TREE_TYPE (expr))); ++ ++ v_offset = build (PLUS_EXPR, TREE_TYPE (v_offset), ++ v_offset, BINFO_VPTR_FIELD (v_binfo)); ++ v_offset = build1 (NOP_EXPR, ++ build_pointer_type (ptrdiff_type_node), ++ v_offset); ++ v_offset = build_indirect_ref (v_offset, NULL); ++ ++ offset = convert_to_integer (ptrdiff_type_node, ++ size_diffop (offset, ++ BINFO_OFFSET (v_binfo))); ++ ++ if (!integer_zerop (offset)) ++ v_offset = build (code, ptrdiff_type_node, v_offset, offset); ++ ++ if (fixed_type_p < 0) ++ /* Negative fixed_type_p means this is a constructor or destructor; ++ virtual base layout is fixed in in-charge [cd]tors, but not in ++ base [cd]tors. */ ++ offset = build (COND_EXPR, ptrdiff_type_node, ++ build (EQ_EXPR, boolean_type_node, ++ current_in_charge_parm, integer_zero_node), ++ v_offset, ++ BINFO_OFFSET (binfo)); ++ else ++ offset = v_offset; ++ } ++ ++ target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo); ++ ++ target_type = cp_build_qualified_type ++ (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr)))); ++ ptr_target_type = build_pointer_type (target_type); ++ if (want_pointer) ++ target_type = ptr_target_type; ++ ++ expr = build1 (NOP_EXPR, ptr_target_type, expr); ++ ++ if (!integer_zerop (offset)) ++ expr = build (code, ptr_target_type, expr, offset); ++ else ++ null_test = NULL; ++ ++ if (!want_pointer) ++ expr = build_indirect_ref (expr, NULL); ++ ++ if (null_test) ++ expr = build (COND_EXPR, target_type, null_test, ++ build1 (NOP_EXPR, target_type, integer_zero_node), ++ expr); ++ ++ return expr; ++} ++ ++/* Convert OBJECT to the base TYPE. If CHECK_ACCESS is true, an error ++ message is emitted if TYPE is inaccessible. OBJECT is assumed to ++ be non-NULL. */ ++ ++tree ++convert_to_base (tree object, tree type, bool check_access) ++{ ++ tree binfo; ++ ++ binfo = lookup_base (TREE_TYPE (object), type, ++ check_access ? ba_check : ba_ignore, ++ NULL); ++ if (!binfo || binfo == error_mark_node) ++ return error_mark_node; ++ ++ return build_base_path (PLUS_EXPR, object, binfo, /*nonnull=*/1); ++} ++ ++/* EXPR is an expression with class type. BASE is a base class (a ++ BINFO) of that class type. Returns EXPR, converted to the BASE ++ type. This function assumes that EXPR is the most derived class; ++ therefore virtual bases can be found at their static offsets. */ ++ ++tree ++convert_to_base_statically (tree expr, tree base) ++{ ++ tree expr_type; ++ ++ expr_type = TREE_TYPE (expr); ++ if (!same_type_p (expr_type, BINFO_TYPE (base))) ++ { ++ tree pointer_type; ++ ++ pointer_type = build_pointer_type (expr_type); ++ expr = build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1); ++ if (!integer_zerop (BINFO_OFFSET (base))) ++ expr = build (PLUS_EXPR, pointer_type, expr, ++ build_nop (pointer_type, BINFO_OFFSET (base))); ++ expr = build_nop (build_pointer_type (BINFO_TYPE (base)), expr); ++ expr = build1 (INDIRECT_REF, BINFO_TYPE (base), expr); ++ } ++ ++ return expr; ++} ++ ++ ++/* Given an object INSTANCE, return an expression which yields the ++ vtable element corresponding to INDEX. There are many special ++ cases for INSTANCE which we take care of here, mainly to avoid ++ creating extra tree nodes when we don't have to. */ ++ ++static tree ++build_vtbl_ref_1 (tree instance, tree idx) ++{ ++ tree aref; ++ tree vtbl = NULL_TREE; ++ ++ /* Try to figure out what a reference refers to, and ++ access its virtual function table directly. */ ++ ++ int cdtorp = 0; ++ tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp); ++ ++ tree basetype = non_reference (TREE_TYPE (instance)); ++ ++ if (fixed_type && !cdtorp) ++ { ++ tree binfo = lookup_base (fixed_type, basetype, ++ ba_ignore|ba_quiet, NULL); ++ if (binfo) ++ vtbl = BINFO_VTABLE (binfo); ++ } ++ ++ if (!vtbl) ++ vtbl = build_vfield_ref (instance, basetype); ++ ++ assemble_external (vtbl); ++ ++ aref = build_array_ref (vtbl, idx); ++ ++ return aref; ++} ++ ++tree ++build_vtbl_ref (tree instance, tree idx) ++{ ++ tree aref = build_vtbl_ref_1 (instance, idx); ++ ++ return aref; ++} ++ ++/* Given an object INSTANCE, return an expression which yields a ++ function pointer corresponding to vtable element INDEX. */ ++ ++tree ++build_vfn_ref (tree instance, tree idx) ++{ ++ tree aref = build_vtbl_ref_1 (instance, idx); ++ ++ /* When using function descriptors, the address of the ++ vtable entry is treated as a function pointer. */ ++ if (TARGET_VTABLE_USES_DESCRIPTORS) ++ aref = build1 (NOP_EXPR, TREE_TYPE (aref), ++ build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1)); ++ ++ return aref; ++} ++ ++/* Return the name of the virtual function table (as an IDENTIFIER_NODE) ++ for the given TYPE. */ ++ ++static tree ++get_vtable_name (tree type) ++{ ++ return mangle_vtbl_for_type (type); ++} ++ ++/* Return an IDENTIFIER_NODE for the name of the virtual table table ++ for TYPE. */ ++ ++tree ++get_vtt_name (tree type) ++{ ++ return mangle_vtt_for_type (type); ++} ++ ++/* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE. ++ (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.) ++ Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */ ++ ++static tree ++build_vtable (tree class_type, tree name, tree vtable_type) ++{ ++ tree decl; ++ ++ decl = build_lang_decl (VAR_DECL, name, vtable_type); ++ /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME ++ now to avoid confusion in mangle_decl. */ ++ SET_DECL_ASSEMBLER_NAME (decl, name); ++ DECL_CONTEXT (decl) = class_type; ++ DECL_ARTIFICIAL (decl) = 1; ++ TREE_STATIC (decl) = 1; ++ TREE_READONLY (decl) = 1; ++ DECL_VIRTUAL_P (decl) = 1; ++ DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN; ++ DECL_VTABLE_OR_VTT_P (decl) = 1; ++ ++ /* At one time the vtable info was grabbed 2 words at a time. This ++ fails on sparc unless you have 8-byte alignment. (tiemann) */ ++ DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node), ++ DECL_ALIGN (decl)); ++ ++ import_export_vtable (decl, class_type, 0); ++ ++ return decl; ++} ++ ++/* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic, ++ or even complete. If this does not exist, create it. If COMPLETE is ++ nonzero, then complete the definition of it -- that will render it ++ impossible to actually build the vtable, but is useful to get at those ++ which are known to exist in the runtime. */ ++ ++tree ++get_vtable_decl (tree type, int complete) ++{ ++ tree decl; ++ ++ if (CLASSTYPE_VTABLES (type)) ++ return CLASSTYPE_VTABLES (type); ++ ++ decl = build_vtable (type, get_vtable_name (type), vtbl_type_node); ++ CLASSTYPE_VTABLES (type) = decl; ++ ++ if (complete) ++ { ++ DECL_EXTERNAL (decl) = 1; ++ cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0); ++ } ++ ++ return decl; ++} ++ ++/* Returns a copy of the BINFO_VIRTUALS list in BINFO. The ++ BV_VCALL_INDEX for each entry is cleared. */ ++ ++static tree ++copy_virtuals (tree binfo) ++{ ++ tree copies; ++ tree t; ++ ++ copies = copy_list (BINFO_VIRTUALS (binfo)); ++ for (t = copies; t; t = TREE_CHAIN (t)) ++ BV_VCALL_INDEX (t) = NULL_TREE; ++ ++ return copies; ++} ++ ++/* Build the primary virtual function table for TYPE. If BINFO is ++ non-NULL, build the vtable starting with the initial approximation ++ that it is the same as the one which is the head of the association ++ list. Returns a nonzero value if a new vtable is actually ++ created. */ ++ ++static int ++build_primary_vtable (tree binfo, tree type) ++{ ++ tree decl; ++ tree virtuals; ++ ++ decl = get_vtable_decl (type, /*complete=*/0); ++ ++ if (binfo) ++ { ++ if (BINFO_NEW_VTABLE_MARKED (binfo)) ++ /* We have already created a vtable for this base, so there's ++ no need to do it again. */ ++ return 0; ++ ++ virtuals = copy_virtuals (binfo); ++ TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo)); ++ DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl)); ++ DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl)); ++ } ++ else ++ { ++ my_friendly_assert (TREE_TYPE (decl) == vtbl_type_node, 20000118); ++ virtuals = NULL_TREE; ++ } ++ ++#ifdef GATHER_STATISTICS ++ n_vtables += 1; ++ n_vtable_elems += list_length (virtuals); ++#endif ++ ++ /* Initialize the association list for this type, based ++ on our first approximation. */ ++ TYPE_BINFO_VTABLE (type) = decl; ++ TYPE_BINFO_VIRTUALS (type) = virtuals; ++ SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type)); ++ return 1; ++} ++ ++/* Give BINFO a new virtual function table which is initialized ++ with a skeleton-copy of its original initialization. The only ++ entry that changes is the `delta' entry, so we can really ++ share a lot of structure. ++ ++ FOR_TYPE is the most derived type which caused this table to ++ be needed. ++ ++ Returns nonzero if we haven't met BINFO before. ++ ++ The order in which vtables are built (by calling this function) for ++ an object must remain the same, otherwise a binary incompatibility ++ can result. */ ++ ++static int ++build_secondary_vtable (tree binfo) ++{ ++ if (BINFO_NEW_VTABLE_MARKED (binfo)) ++ /* We already created a vtable for this base. There's no need to ++ do it again. */ ++ return 0; ++ ++ /* Remember that we've created a vtable for this BINFO, so that we ++ don't try to do so again. */ ++ SET_BINFO_NEW_VTABLE_MARKED (binfo); ++ ++ /* Make fresh virtual list, so we can smash it later. */ ++ BINFO_VIRTUALS (binfo) = copy_virtuals (binfo); ++ ++ /* Secondary vtables are laid out as part of the same structure as ++ the primary vtable. */ ++ BINFO_VTABLE (binfo) = NULL_TREE; ++ return 1; ++} ++ ++/* Create a new vtable for BINFO which is the hierarchy dominated by ++ T. Return nonzero if we actually created a new vtable. */ ++ ++static int ++make_new_vtable (tree t, tree binfo) ++{ ++ if (binfo == TYPE_BINFO (t)) ++ /* In this case, it is *type*'s vtable we are modifying. We start ++ with the approximation that its vtable is that of the ++ immediate base class. */ ++ /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo, ++ since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now. */ ++ return build_primary_vtable (TYPE_BINFO (DECL_CONTEXT (TYPE_VFIELD (t))), ++ t); ++ else ++ /* This is our very own copy of `basetype' to play with. Later, ++ we will fill in all the virtual functions that override the ++ virtual functions in these base classes which are not defined ++ by the current type. */ ++ return build_secondary_vtable (binfo); ++} ++ ++/* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO ++ (which is in the hierarchy dominated by T) list FNDECL as its ++ BV_FN. DELTA is the required constant adjustment from the `this' ++ pointer where the vtable entry appears to the `this' required when ++ the function is actually called. */ ++ ++static void ++modify_vtable_entry (tree t, ++ tree binfo, ++ tree fndecl, ++ tree delta, ++ tree *virtuals) ++{ ++ tree v; ++ ++ v = *virtuals; ++ ++ if (fndecl != BV_FN (v) ++ || !tree_int_cst_equal (delta, BV_DELTA (v))) ++ { ++ /* We need a new vtable for BINFO. */ ++ if (make_new_vtable (t, binfo)) ++ { ++ /* If we really did make a new vtable, we also made a copy ++ of the BINFO_VIRTUALS list. Now, we have to find the ++ corresponding entry in that list. */ ++ *virtuals = BINFO_VIRTUALS (binfo); ++ while (BV_FN (*virtuals) != BV_FN (v)) ++ *virtuals = TREE_CHAIN (*virtuals); ++ v = *virtuals; ++ } ++ ++ BV_DELTA (v) = delta; ++ BV_VCALL_INDEX (v) = NULL_TREE; ++ BV_FN (v) = fndecl; ++ } ++} ++ ++ ++/* Add method METHOD to class TYPE. If ERROR_P is true, we are adding ++ the method after the class has already been defined because a ++ declaration for it was seen. (Even though that is erroneous, we ++ add the method for improved error recovery.) */ ++ ++void ++add_method (tree type, tree method, int error_p) ++{ ++ int using; ++ int len; ++ int slot; ++ tree method_vec; ++ int template_conv_p; ++ ++ if (method == error_mark_node) ++ return; ++ ++ using = (DECL_CONTEXT (method) != type); ++ template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL ++ && DECL_TEMPLATE_CONV_FN_P (method)); ++ ++ if (!CLASSTYPE_METHOD_VEC (type)) ++ /* Make a new method vector. We start with 8 entries. We must ++ allocate at least two (for constructors and destructors), and ++ we're going to end up with an assignment operator at some point ++ as well. ++ ++ We could use a TREE_LIST for now, and convert it to a TREE_VEC ++ in finish_struct, but we would probably waste more memory ++ making the links in the list than we would by over-allocating ++ the size of the vector here. Furthermore, we would complicate ++ all the code that expects this to be a vector. */ ++ CLASSTYPE_METHOD_VEC (type) = make_tree_vec (8); ++ ++ method_vec = CLASSTYPE_METHOD_VEC (type); ++ len = TREE_VEC_LENGTH (method_vec); ++ ++ /* Constructors and destructors go in special slots. */ ++ if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method)) ++ slot = CLASSTYPE_CONSTRUCTOR_SLOT; ++ else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method)) ++ { ++ slot = CLASSTYPE_DESTRUCTOR_SLOT; ++ TYPE_HAS_DESTRUCTOR (type) = 1; ++ ++ if (TYPE_FOR_JAVA (type)) ++ error (DECL_ARTIFICIAL (method) ++ ? "Java class '%T' cannot have an implicit non-trivial destructor" ++ : "Java class '%T' cannot have a destructor", ++ DECL_CONTEXT (method)); ++ } ++ else ++ { ++ int have_template_convs_p = 0; ++ ++ /* See if we already have an entry with this name. */ ++ for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; slot < len; ++slot) ++ { ++ tree m = TREE_VEC_ELT (method_vec, slot); ++ ++ if (!m) ++ break; ++ m = OVL_CURRENT (m); ++ ++ if (template_conv_p) ++ { ++ have_template_convs_p = (TREE_CODE (m) == TEMPLATE_DECL ++ && DECL_TEMPLATE_CONV_FN_P (m)); ++ ++ /* If we need to move things up, see if there's ++ space. */ ++ if (!have_template_convs_p) ++ { ++ slot = len - 1; ++ if (TREE_VEC_ELT (method_vec, slot)) ++ slot++; ++ } ++ break; ++ } ++ if (DECL_NAME (m) == DECL_NAME (method)) ++ break; ++ } ++ ++ if (slot == len) ++ { ++ /* We need a bigger method vector. */ ++ int new_len; ++ tree new_vec; ++ ++ /* In the non-error case, we are processing a class ++ definition. Double the size of the vector to give room ++ for new methods. */ ++ if (!error_p) ++ new_len = 2 * len; ++ /* In the error case, the vector is already complete. We ++ don't expect many errors, and the rest of the front-end ++ will get confused if there are empty slots in the vector. */ ++ else ++ new_len = len + 1; ++ ++ new_vec = make_tree_vec (new_len); ++ memcpy (&TREE_VEC_ELT (new_vec, 0), &TREE_VEC_ELT (method_vec, 0), ++ len * sizeof (tree)); ++ len = new_len; ++ method_vec = CLASSTYPE_METHOD_VEC (type) = new_vec; ++ } ++ ++ if (DECL_CONV_FN_P (method) && !TREE_VEC_ELT (method_vec, slot)) ++ { ++ /* Type conversion operators have to come before ordinary ++ methods; add_conversions depends on this to speed up ++ looking for conversion operators. So, if necessary, we ++ slide some of the vector elements up. In theory, this ++ makes this algorithm O(N^2) but we don't expect many ++ conversion operators. */ ++ if (template_conv_p) ++ slot = CLASSTYPE_FIRST_CONVERSION_SLOT; ++ else ++ for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; slot < len; ++slot) ++ { ++ tree fn = TREE_VEC_ELT (method_vec, slot); ++ ++ if (!fn) ++ /* There are no more entries in the vector, so we ++ can insert the new conversion operator here. */ ++ break; ++ ++ if (!DECL_CONV_FN_P (OVL_CURRENT (fn))) ++ /* We can insert the new function right at the ++ SLOTth position. */ ++ break; ++ } ++ ++ if (template_conv_p && have_template_convs_p) ++ /*OK*/; ++ else if (!TREE_VEC_ELT (method_vec, slot)) ++ /* There is nothing in the Ith slot, so we can avoid ++ moving anything. */ ++ ; ++ else ++ { ++ /* We know the last slot in the vector is empty ++ because we know that at this point there's room ++ for a new function. */ ++ memmove (&TREE_VEC_ELT (method_vec, slot + 1), ++ &TREE_VEC_ELT (method_vec, slot), ++ (len - slot - 1) * sizeof (tree)); ++ TREE_VEC_ELT (method_vec, slot) = NULL_TREE; ++ } ++ } ++ } ++ ++ if (processing_template_decl) ++ /* TYPE is a template class. Don't issue any errors now; wait ++ until instantiation time to complain. */ ++ ; ++ else ++ { ++ tree fns; ++ ++ /* Check to see if we've already got this method. */ ++ for (fns = TREE_VEC_ELT (method_vec, slot); ++ fns; ++ fns = OVL_NEXT (fns)) ++ { ++ tree fn = OVL_CURRENT (fns); ++ tree parms1; ++ tree parms2; ++ bool same = 1; ++ ++ if (TREE_CODE (fn) != TREE_CODE (method)) ++ continue; ++ ++ /* [over.load] Member function declarations with the ++ same name and the same parameter types cannot be ++ overloaded if any of them is a static member ++ function declaration. ++ ++ [namespace.udecl] When a using-declaration brings names ++ from a base class into a derived class scope, member ++ functions in the derived class override and/or hide member ++ functions with the same name and parameter types in a base ++ class (rather than conflicting). */ ++ parms1 = TYPE_ARG_TYPES (TREE_TYPE (fn)); ++ parms2 = TYPE_ARG_TYPES (TREE_TYPE (method)); ++ ++ /* Compare the quals on the 'this' parm. Don't compare ++ the whole types, as used functions are treated as ++ coming from the using class in overload resolution. */ ++ if (! DECL_STATIC_FUNCTION_P (fn) ++ && ! DECL_STATIC_FUNCTION_P (method) ++ && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1))) ++ != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2))))) ++ same = 0; ++ ++ /* For templates, the template parms must be identical. */ ++ if (TREE_CODE (fn) == TEMPLATE_DECL ++ && !comp_template_parms (DECL_TEMPLATE_PARMS (fn), ++ DECL_TEMPLATE_PARMS (method))) ++ same = 0; ++ ++ if (! DECL_STATIC_FUNCTION_P (fn)) ++ parms1 = TREE_CHAIN (parms1); ++ if (! DECL_STATIC_FUNCTION_P (method)) ++ parms2 = TREE_CHAIN (parms2); ++ ++ if (same && compparms (parms1, parms2) ++ && (!DECL_CONV_FN_P (fn) ++ || same_type_p (TREE_TYPE (TREE_TYPE (fn)), ++ TREE_TYPE (TREE_TYPE (method))))) ++ { ++ if (using && DECL_CONTEXT (fn) == type) ++ /* Defer to the local function. */ ++ return; ++ else ++ { ++ cp_error_at ("`%#D' and `%#D' cannot be overloaded", ++ method, fn); ++ ++ /* We don't call duplicate_decls here to merge ++ the declarations because that will confuse ++ things if the methods have inline ++ definitions. In particular, we will crash ++ while processing the definitions. */ ++ return; ++ } ++ } ++ } ++ } ++ ++ /* Actually insert the new method. */ ++ TREE_VEC_ELT (method_vec, slot) ++ = build_overload (method, TREE_VEC_ELT (method_vec, slot)); ++ ++ /* Add the new binding. */ ++ if (!DECL_CONSTRUCTOR_P (method) ++ && !DECL_DESTRUCTOR_P (method)) ++ push_class_level_binding (DECL_NAME (method), ++ TREE_VEC_ELT (method_vec, slot)); ++} ++ ++/* Subroutines of finish_struct. */ ++ ++/* Change the access of FDECL to ACCESS in T. Return 1 if change was ++ legit, otherwise return 0. */ ++ ++static int ++alter_access (tree t, tree fdecl, tree access) ++{ ++ tree elem; ++ ++ if (!DECL_LANG_SPECIFIC (fdecl)) ++ retrofit_lang_decl (fdecl); ++ ++ my_friendly_assert (!DECL_DISCRIMINATOR_P (fdecl), 20030624); ++ ++ elem = purpose_member (t, DECL_ACCESS (fdecl)); ++ if (elem) ++ { ++ if (TREE_VALUE (elem) != access) ++ { ++ if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL) ++ cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl)); ++ else ++ error ("conflicting access specifications for field `%s', ignored", ++ IDENTIFIER_POINTER (DECL_NAME (fdecl))); ++ } ++ else ++ { ++ /* They're changing the access to the same thing they changed ++ it to before. That's OK. */ ++ ; ++ } ++ } ++ else ++ { ++ perform_or_defer_access_check (TYPE_BINFO (t), fdecl); ++ DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl)); ++ return 1; ++ } ++ return 0; ++} ++ ++/* Process the USING_DECL, which is a member of T. */ ++ ++static void ++handle_using_decl (tree using_decl, tree t) ++{ ++ tree ctype = DECL_INITIAL (using_decl); ++ tree name = DECL_NAME (using_decl); ++ tree access ++ = TREE_PRIVATE (using_decl) ? access_private_node ++ : TREE_PROTECTED (using_decl) ? access_protected_node ++ : access_public_node; ++ tree fdecl, binfo; ++ tree flist = NULL_TREE; ++ tree old_value; ++ ++ if (ctype == error_mark_node) ++ return; ++ ++ binfo = lookup_base (t, ctype, ba_any, NULL); ++ if (! binfo) ++ { ++ location_t saved_loc = input_location; ++ ++ input_location = DECL_SOURCE_LOCATION (using_decl); ++ error_not_base_type (ctype, t); ++ input_location = saved_loc; ++ return; ++ } ++ ++ if (constructor_name_p (name, ctype)) ++ { ++ cp_error_at ("`%D' names constructor", using_decl); ++ return; ++ } ++ if (constructor_name_p (name, t)) ++ { ++ cp_error_at ("`%D' invalid in `%T'", using_decl, t); ++ return; ++ } ++ ++ fdecl = lookup_member (binfo, name, 0, false); ++ ++ if (!fdecl) ++ { ++ cp_error_at ("no members matching `%D' in `%#T'", using_decl, ctype); ++ return; ++ } ++ ++ if (BASELINK_P (fdecl)) ++ /* Ignore base type this came from. */ ++ fdecl = BASELINK_FUNCTIONS (fdecl); ++ ++ old_value = IDENTIFIER_CLASS_VALUE (name); ++ if (old_value) ++ { ++ if (is_overloaded_fn (old_value)) ++ old_value = OVL_CURRENT (old_value); ++ ++ if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t) ++ /* OK */; ++ else ++ old_value = NULL_TREE; ++ } ++ ++ if (is_overloaded_fn (fdecl)) ++ flist = fdecl; ++ ++ if (! old_value) ++ ; ++ else if (is_overloaded_fn (old_value)) ++ { ++ if (flist) ++ /* It's OK to use functions from a base when there are functions with ++ the same name already present in the current class. */; ++ else ++ { ++ cp_error_at ("`%D' invalid in `%#T'", using_decl, t); ++ cp_error_at (" because of local method `%#D' with same name", ++ OVL_CURRENT (old_value)); ++ return; ++ } ++ } ++ else if (!DECL_ARTIFICIAL (old_value)) ++ { ++ cp_error_at ("`%D' invalid in `%#T'", using_decl, t); ++ cp_error_at (" because of local member `%#D' with same name", old_value); ++ return; ++ } ++ ++ /* Make type T see field decl FDECL with access ACCESS. */ ++ if (flist) ++ for (; flist; flist = OVL_NEXT (flist)) ++ { ++ add_method (t, OVL_CURRENT (flist), /*error_p=*/0); ++ alter_access (t, OVL_CURRENT (flist), access); ++ } ++ else ++ alter_access (t, fdecl, access); ++} ++ ++/* Run through the base clases of T, updating ++ CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and ++ NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of ++ the bases. */ ++ ++static void ++check_bases (tree t, ++ int* cant_have_default_ctor_p, ++ int* cant_have_const_ctor_p, ++ int* no_const_asn_ref_p) ++{ ++ int n_baseclasses; ++ int i; ++ int seen_non_virtual_nearly_empty_base_p; ++ tree binfos; ++ ++ binfos = TYPE_BINFO_BASETYPES (t); ++ n_baseclasses = CLASSTYPE_N_BASECLASSES (t); ++ seen_non_virtual_nearly_empty_base_p = 0; ++ ++ /* An aggregate cannot have baseclasses. */ ++ CLASSTYPE_NON_AGGREGATE (t) |= (n_baseclasses != 0); ++ ++ for (i = 0; i < n_baseclasses; ++i) ++ { ++ tree base_binfo; ++ tree basetype; ++ ++ /* Figure out what base we're looking at. */ ++ base_binfo = TREE_VEC_ELT (binfos, i); ++ basetype = TREE_TYPE (base_binfo); ++ ++ /* If the type of basetype is incomplete, then we already ++ complained about that fact (and we should have fixed it up as ++ well). */ ++ if (!COMPLETE_TYPE_P (basetype)) ++ { ++ int j; ++ /* The base type is of incomplete type. It is ++ probably best to pretend that it does not ++ exist. */ ++ if (i == n_baseclasses-1) ++ TREE_VEC_ELT (binfos, i) = NULL_TREE; ++ TREE_VEC_LENGTH (binfos) -= 1; ++ n_baseclasses -= 1; ++ for (j = i; j+1 < n_baseclasses; j++) ++ TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1); ++ continue; ++ } ++ ++ /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P ++ here because the case of virtual functions but non-virtual ++ dtor is handled in finish_struct_1. */ ++ if (warn_ecpp && ! TYPE_POLYMORPHIC_P (basetype) ++ && TYPE_HAS_DESTRUCTOR (basetype)) ++ warning ("base class `%#T' has a non-virtual destructor", ++ basetype); ++ ++ /* If the base class doesn't have copy constructors or ++ assignment operators that take const references, then the ++ derived class cannot have such a member automatically ++ generated. */ ++ if (! TYPE_HAS_CONST_INIT_REF (basetype)) ++ *cant_have_const_ctor_p = 1; ++ if (TYPE_HAS_ASSIGN_REF (basetype) ++ && !TYPE_HAS_CONST_ASSIGN_REF (basetype)) ++ *no_const_asn_ref_p = 1; ++ /* Similarly, if the base class doesn't have a default ++ constructor, then the derived class won't have an ++ automatically generated default constructor. */ ++ if (TYPE_HAS_CONSTRUCTOR (basetype) ++ && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype)) ++ { ++ *cant_have_default_ctor_p = 1; ++ if (! TYPE_HAS_CONSTRUCTOR (t)) ++ pedwarn ("base `%T' with only non-default constructor in class without a constructor", ++ basetype); ++ } ++ ++ if (TREE_VIA_VIRTUAL (base_binfo)) ++ /* A virtual base does not effect nearly emptiness. */ ++ ; ++ else if (CLASSTYPE_NEARLY_EMPTY_P (basetype)) ++ { ++ if (seen_non_virtual_nearly_empty_base_p) ++ /* And if there is more than one nearly empty base, then the ++ derived class is not nearly empty either. */ ++ CLASSTYPE_NEARLY_EMPTY_P (t) = 0; ++ else ++ /* Remember we've seen one. */ ++ seen_non_virtual_nearly_empty_base_p = 1; ++ } ++ else if (!is_empty_class (basetype)) ++ /* If the base class is not empty or nearly empty, then this ++ class cannot be nearly empty. */ ++ CLASSTYPE_NEARLY_EMPTY_P (t) = 0; ++ ++ /* A lot of properties from the bases also apply to the derived ++ class. */ ++ TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype); ++ TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) ++ |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype); ++ TYPE_HAS_COMPLEX_ASSIGN_REF (t) ++ |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype); ++ TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype); ++ TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype); ++ CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) ++ |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype); ++ } ++} ++ ++/* Set BINFO_PRIMARY_BASE_OF for all binfos in the hierarchy ++ dominated by TYPE that are primary bases. */ ++ ++static void ++mark_primary_bases (tree type) ++{ ++ tree binfo; ++ ++ /* Walk the bases in inheritance graph order. */ ++ for (binfo = TYPE_BINFO (type); binfo; binfo = TREE_CHAIN (binfo)) ++ { ++ tree base_binfo = get_primary_binfo (binfo); ++ ++ if (!base_binfo) ++ /* Not a dynamic base. */; ++ else if (BINFO_PRIMARY_P (base_binfo)) ++ BINFO_LOST_PRIMARY_P (binfo) = 1; ++ else ++ { ++ BINFO_PRIMARY_BASE_OF (base_binfo) = binfo; ++ /* A virtual binfo might have been copied from within ++ another hierarchy. As we're about to use it as a primary ++ base, make sure the offsets match. */ ++ if (TREE_VIA_VIRTUAL (base_binfo)) ++ { ++ tree delta = size_diffop (convert (ssizetype, ++ BINFO_OFFSET (binfo)), ++ convert (ssizetype, ++ BINFO_OFFSET (base_binfo))); ++ ++ propagate_binfo_offsets (base_binfo, delta); ++ } ++ } ++ } ++} ++ ++/* Make the BINFO the primary base of T. */ ++ ++static void ++set_primary_base (tree t, tree binfo) ++{ ++ tree basetype; ++ ++ CLASSTYPE_PRIMARY_BINFO (t) = binfo; ++ basetype = BINFO_TYPE (binfo); ++ TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype); ++ TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype); ++ TYPE_VFIELD (t) = TYPE_VFIELD (basetype); ++} ++ ++/* Determine the primary class for T. */ ++ ++static void ++determine_primary_base (tree t) ++{ ++ int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t); ++ tree vbases; ++ tree type_binfo; ++ ++ /* If there are no baseclasses, there is certainly no primary base. */ ++ if (n_baseclasses == 0) ++ return; ++ ++ type_binfo = TYPE_BINFO (t); ++ ++ for (i = 0; i < n_baseclasses; i++) ++ { ++ tree base_binfo = BINFO_BASETYPE (type_binfo, i); ++ tree basetype = BINFO_TYPE (base_binfo); ++ ++ if (TYPE_CONTAINS_VPTR_P (basetype)) ++ { ++ /* We prefer a non-virtual base, although a virtual one will ++ do. */ ++ if (TREE_VIA_VIRTUAL (base_binfo)) ++ continue; ++ ++ if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) ++ { ++ set_primary_base (t, base_binfo); ++ CLASSTYPE_VFIELDS (t) = copy_list (CLASSTYPE_VFIELDS (basetype)); ++ } ++ else ++ { ++ tree vfields; ++ ++ /* Only add unique vfields, and flatten them out as we go. */ ++ for (vfields = CLASSTYPE_VFIELDS (basetype); ++ vfields; ++ vfields = TREE_CHAIN (vfields)) ++ if (VF_BINFO_VALUE (vfields) == NULL_TREE ++ || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields))) ++ CLASSTYPE_VFIELDS (t) ++ = tree_cons (base_binfo, ++ VF_BASETYPE_VALUE (vfields), ++ CLASSTYPE_VFIELDS (t)); ++ } ++ } ++ } ++ ++ if (!TYPE_VFIELD (t)) ++ CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE; ++ ++ /* Find the indirect primary bases - those virtual bases which are primary ++ bases of something else in this hierarchy. */ ++ for (vbases = CLASSTYPE_VBASECLASSES (t); ++ vbases; ++ vbases = TREE_CHAIN (vbases)) ++ { ++ tree vbase_binfo = TREE_VALUE (vbases); ++ ++ /* See if this virtual base is an indirect primary base. To be so, ++ it must be a primary base within the hierarchy of one of our ++ direct bases. */ ++ for (i = 0; i < n_baseclasses; ++i) ++ { ++ tree basetype = TYPE_BINFO_BASETYPE (t, i); ++ tree v; ++ ++ for (v = CLASSTYPE_VBASECLASSES (basetype); ++ v; ++ v = TREE_CHAIN (v)) ++ { ++ tree base_vbase = TREE_VALUE (v); ++ ++ if (BINFO_PRIMARY_P (base_vbase) ++ && same_type_p (BINFO_TYPE (base_vbase), ++ BINFO_TYPE (vbase_binfo))) ++ { ++ BINFO_INDIRECT_PRIMARY_P (vbase_binfo) = 1; ++ break; ++ } ++ } ++ ++ /* If we've discovered that this virtual base is an indirect ++ primary base, then we can move on to the next virtual ++ base. */ ++ if (BINFO_INDIRECT_PRIMARY_P (vbase_binfo)) ++ break; ++ } ++ } ++ ++ /* A "nearly-empty" virtual base class can be the primary base ++ class, if no non-virtual polymorphic base can be found. */ ++ if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) ++ { ++ /* If not NULL, this is the best primary base candidate we have ++ found so far. */ ++ tree candidate = NULL_TREE; ++ tree base_binfo; ++ ++ /* Loop over the baseclasses. */ ++ for (base_binfo = TYPE_BINFO (t); ++ base_binfo; ++ base_binfo = TREE_CHAIN (base_binfo)) ++ { ++ tree basetype = BINFO_TYPE (base_binfo); ++ ++ if (TREE_VIA_VIRTUAL (base_binfo) ++ && CLASSTYPE_NEARLY_EMPTY_P (basetype)) ++ { ++ /* If this is not an indirect primary base, then it's ++ definitely our primary base. */ ++ if (!BINFO_INDIRECT_PRIMARY_P (base_binfo)) ++ { ++ candidate = base_binfo; ++ break; ++ } ++ ++ /* If this is an indirect primary base, it still could be ++ our primary base -- unless we later find there's another ++ nearly-empty virtual base that isn't an indirect ++ primary base. */ ++ if (!candidate) ++ candidate = base_binfo; ++ } ++ } ++ ++ /* If we've got a primary base, use it. */ ++ if (candidate) ++ { ++ set_primary_base (t, candidate); ++ CLASSTYPE_VFIELDS (t) ++ = copy_list (CLASSTYPE_VFIELDS (BINFO_TYPE (candidate))); ++ } ++ } ++ ++ /* Mark the primary base classes at this point. */ ++ mark_primary_bases (t); ++} ++ ++/* Set memoizing fields and bits of T (and its variants) for later ++ use. */ ++ ++static void ++finish_struct_bits (tree t) ++{ ++ int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t); ++ ++ /* Fix up variants (if any). */ ++ tree variants = TYPE_NEXT_VARIANT (t); ++ while (variants) ++ { ++ /* These fields are in the _TYPE part of the node, not in ++ the TYPE_LANG_SPECIFIC component, so they are not shared. */ ++ TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t); ++ TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t); ++ TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t); ++ TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants) ++ = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t); ++ ++ TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (variants) ++ = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t); ++ TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t); ++ TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t); ++ /* Copy whatever these are holding today. */ ++ TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t); ++ TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t); ++ TYPE_FIELDS (variants) = TYPE_FIELDS (t); ++ TYPE_SIZE (variants) = TYPE_SIZE (t); ++ TYPE_SIZE_UNIT (variants) = TYPE_SIZE_UNIT (t); ++ variants = TYPE_NEXT_VARIANT (variants); ++ } ++ ++ if (n_baseclasses && TYPE_POLYMORPHIC_P (t)) ++ /* For a class w/o baseclasses, `finish_struct' has set ++ CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by ++ definition). Similarly for a class whose base classes do not ++ have vtables. When neither of these is true, we might have ++ removed abstract virtuals (by providing a definition), added ++ some (by declaring new ones), or redeclared ones from a base ++ class. We need to recalculate what's really an abstract virtual ++ at this point (by looking in the vtables). */ ++ get_pure_virtuals (t); ++ ++ if (n_baseclasses) ++ { ++ /* Notice whether this class has type conversion functions defined. */ ++ tree binfo = TYPE_BINFO (t); ++ tree binfos = BINFO_BASETYPES (binfo); ++ tree basetype; ++ ++ for (i = n_baseclasses-1; i >= 0; i--) ++ { ++ basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i)); ++ ++ TYPE_HAS_CONVERSION (t) |= TYPE_HAS_CONVERSION (basetype); ++ } ++ } ++ ++ /* If this type has a copy constructor or a destructor, force its mode to ++ be BLKmode, and force its TREE_ADDRESSABLE bit to be nonzero. This ++ will cause it to be passed by invisible reference and prevent it from ++ being returned in a register. */ ++ if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)) ++ { ++ tree variants; ++ DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode; ++ for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants)) ++ { ++ TYPE_MODE (variants) = BLKmode; ++ TREE_ADDRESSABLE (variants) = 1; ++ } ++ } ++} ++ ++/* Issue warnings about T having private constructors, but no friends, ++ and so forth. ++ ++ HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or ++ static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any ++ non-private static member functions. */ ++ ++static void ++maybe_warn_about_overly_private_class (tree t) ++{ ++ int has_member_fn = 0; ++ int has_nonprivate_method = 0; ++ tree fn; ++ ++ if (!warn_ctor_dtor_privacy ++ /* If the class has friends, those entities might create and ++ access instances, so we should not warn. */ ++ || (CLASSTYPE_FRIEND_CLASSES (t) ++ || DECL_FRIENDLIST (TYPE_MAIN_DECL (t))) ++ /* We will have warned when the template was declared; there's ++ no need to warn on every instantiation. */ ++ || CLASSTYPE_TEMPLATE_INSTANTIATION (t)) ++ /* There's no reason to even consider warning about this ++ class. */ ++ return; ++ ++ /* We only issue one warning, if more than one applies, because ++ otherwise, on code like: ++ ++ class A { ++ // Oops - forgot `public:' ++ A(); ++ A(const A&); ++ ~A(); ++ }; ++ ++ we warn several times about essentially the same problem. */ ++ ++ /* Check to see if all (non-constructor, non-destructor) member ++ functions are private. (Since there are no friends or ++ non-private statics, we can't ever call any of the private member ++ functions.) */ ++ for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn)) ++ /* We're not interested in compiler-generated methods; they don't ++ provide any way to call private members. */ ++ if (!DECL_ARTIFICIAL (fn)) ++ { ++ if (!TREE_PRIVATE (fn)) ++ { ++ if (DECL_STATIC_FUNCTION_P (fn)) ++ /* A non-private static member function is just like a ++ friend; it can create and invoke private member ++ functions, and be accessed without a class ++ instance. */ ++ return; ++ ++ has_nonprivate_method = 1; ++ /* Keep searching for a static member function. */ ++ } ++ else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn)) ++ has_member_fn = 1; ++ } ++ ++ if (!has_nonprivate_method && has_member_fn) ++ { ++ /* There are no non-private methods, and there's at least one ++ private member function that isn't a constructor or ++ destructor. (If all the private members are ++ constructors/destructors we want to use the code below that ++ issues error messages specifically referring to ++ constructors/destructors.) */ ++ int i; ++ tree binfo = TYPE_BINFO (t); ++ ++ for (i = 0; i < BINFO_N_BASETYPES (binfo); i++) ++ if (BINFO_BASEACCESS (binfo, i) != access_private_node) ++ { ++ has_nonprivate_method = 1; ++ break; ++ } ++ if (!has_nonprivate_method) ++ { ++ warning ("all member functions in class `%T' are private", t); ++ return; ++ } ++ } ++ ++ /* Even if some of the member functions are non-private, the class ++ won't be useful for much if all the constructors or destructors ++ are private: such an object can never be created or destroyed. */ ++ if (TYPE_HAS_DESTRUCTOR (t) ++ && TREE_PRIVATE (CLASSTYPE_DESTRUCTORS (t))) ++ { ++ warning ("`%#T' only defines a private destructor and has no friends", ++ t); ++ return; ++ } ++ ++ if (TYPE_HAS_CONSTRUCTOR (t)) ++ { ++ int nonprivate_ctor = 0; ++ ++ /* If a non-template class does not define a copy ++ constructor, one is defined for it, enabling it to avoid ++ this warning. For a template class, this does not ++ happen, and so we would normally get a warning on: ++ ++ template class C { private: C(); }; ++ ++ To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All ++ complete non-template or fully instantiated classes have this ++ flag set. */ ++ if (!TYPE_HAS_INIT_REF (t)) ++ nonprivate_ctor = 1; ++ else ++ for (fn = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0); ++ fn; ++ fn = OVL_NEXT (fn)) ++ { ++ tree ctor = OVL_CURRENT (fn); ++ /* Ideally, we wouldn't count copy constructors (or, in ++ fact, any constructor that takes an argument of the ++ class type as a parameter) because such things cannot ++ be used to construct an instance of the class unless ++ you already have one. But, for now at least, we're ++ more generous. */ ++ if (! TREE_PRIVATE (ctor)) ++ { ++ nonprivate_ctor = 1; ++ break; ++ } ++ } ++ ++ if (nonprivate_ctor == 0) ++ { ++ warning ("`%#T' only defines private constructors and has no friends", ++ t); ++ return; ++ } ++ } ++} ++ ++static struct { ++ gt_pointer_operator new_value; ++ void *cookie; ++} resort_data; ++ ++/* Comparison function to compare two TYPE_METHOD_VEC entries by name. */ ++ ++static int ++method_name_cmp (const void* m1_p, const void* m2_p) ++{ ++ const tree *const m1 = m1_p; ++ const tree *const m2 = m2_p; ++ ++ if (*m1 == NULL_TREE && *m2 == NULL_TREE) ++ return 0; ++ if (*m1 == NULL_TREE) ++ return -1; ++ if (*m2 == NULL_TREE) ++ return 1; ++ if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2))) ++ return -1; ++ return 1; ++} ++ ++/* This routine compares two fields like method_name_cmp but using the ++ pointer operator in resort_field_decl_data. */ ++ ++static int ++resort_method_name_cmp (const void* m1_p, const void* m2_p) ++{ ++ const tree *const m1 = m1_p; ++ const tree *const m2 = m2_p; ++ if (*m1 == NULL_TREE && *m2 == NULL_TREE) ++ return 0; ++ if (*m1 == NULL_TREE) ++ return -1; ++ if (*m2 == NULL_TREE) ++ return 1; ++ { ++ tree d1 = DECL_NAME (OVL_CURRENT (*m1)); ++ tree d2 = DECL_NAME (OVL_CURRENT (*m2)); ++ resort_data.new_value (&d1, resort_data.cookie); ++ resort_data.new_value (&d2, resort_data.cookie); ++ if (d1 < d2) ++ return -1; ++ } ++ return 1; ++} ++ ++/* Resort TYPE_METHOD_VEC because pointers have been reordered. */ ++ ++void ++resort_type_method_vec (void* obj, ++ void* orig_obj ATTRIBUTE_UNUSED , ++ gt_pointer_operator new_value, ++ void* cookie) ++{ ++ tree method_vec = obj; ++ int len = TREE_VEC_LENGTH (method_vec); ++ int slot; ++ ++ /* The type conversion ops have to live at the front of the vec, so we ++ can't sort them. */ ++ for (slot = 2; slot < len; ++slot) ++ { ++ tree fn = TREE_VEC_ELT (method_vec, slot); ++ ++ if (!DECL_CONV_FN_P (OVL_CURRENT (fn))) ++ break; ++ } ++ if (len - slot > 1) ++ { ++ resort_data.new_value = new_value; ++ resort_data.cookie = cookie; ++ qsort (&TREE_VEC_ELT (method_vec, slot), len - slot, sizeof (tree), ++ resort_method_name_cmp); ++ } ++} ++ ++/* Warn about duplicate methods in fn_fields. Also compact method ++ lists so that lookup can be made faster. ++ ++ Data Structure: List of method lists. The outer list is a ++ TREE_LIST, whose TREE_PURPOSE field is the field name and the ++ TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs. TREE_CHAIN ++ links the entire list of methods for TYPE_METHODS. Friends are ++ chained in the same way as member functions (? TREE_CHAIN or ++ DECL_CHAIN), but they live in the TREE_TYPE field of the outer ++ list. That allows them to be quickly deleted, and requires no ++ extra storage. ++ ++ Sort methods that are not special (i.e., constructors, destructors, ++ and type conversion operators) so that we can find them faster in ++ search. */ ++ ++static void ++finish_struct_methods (tree t) ++{ ++ tree fn_fields; ++ tree method_vec; ++ int slot, len; ++ ++ if (!TYPE_METHODS (t)) ++ { ++ /* Clear these for safety; perhaps some parsing error could set ++ these incorrectly. */ ++ TYPE_HAS_CONSTRUCTOR (t) = 0; ++ TYPE_HAS_DESTRUCTOR (t) = 0; ++ CLASSTYPE_METHOD_VEC (t) = NULL_TREE; ++ return; ++ } ++ ++ method_vec = CLASSTYPE_METHOD_VEC (t); ++ my_friendly_assert (method_vec != NULL_TREE, 19991215); ++ len = TREE_VEC_LENGTH (method_vec); ++ ++ /* First fill in entry 0 with the constructors, entry 1 with destructors, ++ and the next few with type conversion operators (if any). */ ++ for (fn_fields = TYPE_METHODS (t); fn_fields; ++ fn_fields = TREE_CHAIN (fn_fields)) ++ /* Clear out this flag. */ ++ DECL_IN_AGGR_P (fn_fields) = 0; ++ ++ if (TYPE_HAS_DESTRUCTOR (t) && !CLASSTYPE_DESTRUCTORS (t)) ++ /* We thought there was a destructor, but there wasn't. Some ++ parse errors cause this anomalous situation. */ ++ TYPE_HAS_DESTRUCTOR (t) = 0; ++ ++ /* Issue warnings about private constructors and such. If there are ++ no methods, then some public defaults are generated. */ ++ maybe_warn_about_overly_private_class (t); ++ ++ /* Now sort the methods. */ ++ while (len > 2 && TREE_VEC_ELT (method_vec, len-1) == NULL_TREE) ++ len--; ++ TREE_VEC_LENGTH (method_vec) = len; ++ ++ /* The type conversion ops have to live at the front of the vec, so we ++ can't sort them. */ ++ for (slot = 2; slot < len; ++slot) ++ { ++ tree fn = TREE_VEC_ELT (method_vec, slot); ++ ++ if (!DECL_CONV_FN_P (OVL_CURRENT (fn))) ++ break; ++ } ++ if (len - slot > 1) ++ qsort (&TREE_VEC_ELT (method_vec, slot), len-slot, sizeof (tree), ++ method_name_cmp); ++} ++ ++/* Make BINFO's vtable have N entries, including RTTI entries, ++ vbase and vcall offsets, etc. Set its type and call the backend ++ to lay it out. */ ++ ++static void ++layout_vtable_decl (tree binfo, int n) ++{ ++ tree atype; ++ tree vtable; ++ ++ atype = build_cplus_array_type (vtable_entry_type, ++ build_index_type (size_int (n - 1))); ++ layout_type (atype); ++ ++ /* We may have to grow the vtable. */ ++ vtable = get_vtbl_decl_for_binfo (binfo); ++ if (!same_type_p (TREE_TYPE (vtable), atype)) ++ { ++ TREE_TYPE (vtable) = atype; ++ DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE; ++ layout_decl (vtable, 0); ++ } ++} ++ ++/* True iff FNDECL and BASE_FNDECL (both non-static member functions) ++ have the same signature. */ ++ ++int ++same_signature_p (tree fndecl, tree base_fndecl) ++{ ++ /* One destructor overrides another if they are the same kind of ++ destructor. */ ++ if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl) ++ && special_function_p (base_fndecl) == special_function_p (fndecl)) ++ return 1; ++ /* But a non-destructor never overrides a destructor, nor vice ++ versa, nor do different kinds of destructors override ++ one-another. For example, a complete object destructor does not ++ override a deleting destructor. */ ++ if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl)) ++ return 0; ++ ++ if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl) ++ || (DECL_CONV_FN_P (fndecl) ++ && DECL_CONV_FN_P (base_fndecl) ++ && same_type_p (DECL_CONV_FN_TYPE (fndecl), ++ DECL_CONV_FN_TYPE (base_fndecl)))) ++ { ++ tree types, base_types; ++ types = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); ++ base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl)); ++ if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types))) ++ == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types)))) ++ && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types))) ++ return 1; ++ } ++ return 0; ++} ++ ++/* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a ++ subobject. */ ++ ++static bool ++base_derived_from (tree derived, tree base) ++{ ++ tree probe; ++ ++ for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe)) ++ { ++ if (probe == derived) ++ return true; ++ else if (TREE_VIA_VIRTUAL (probe)) ++ /* If we meet a virtual base, we can't follow the inheritance ++ any more. See if the complete type of DERIVED contains ++ such a virtual base. */ ++ return purpose_member (BINFO_TYPE (probe), ++ CLASSTYPE_VBASECLASSES (BINFO_TYPE (derived))) ++ != NULL_TREE; ++ } ++ return false; ++} ++ ++typedef struct count_depth_data { ++ /* The depth of the current subobject, with "1" as the depth of the ++ most derived object in the hierarchy. */ ++ size_t depth; ++ /* The maximum depth found so far. */ ++ size_t max_depth; ++} count_depth_data; ++ ++/* Called from find_final_overrider via dfs_walk. */ ++ ++static tree ++dfs_depth_post (tree binfo ATTRIBUTE_UNUSED, void *data) ++{ ++ count_depth_data *cd = (count_depth_data *) data; ++ if (cd->depth > cd->max_depth) ++ cd->max_depth = cd->depth; ++ cd->depth--; ++ return NULL_TREE; ++} ++ ++/* Called from find_final_overrider via dfs_walk. */ ++ ++static tree ++dfs_depth_q (tree derived, int i, void *data) ++{ ++ count_depth_data *cd = (count_depth_data *) data; ++ cd->depth++; ++ return BINFO_BASETYPE (derived, i); ++} ++ ++typedef struct find_final_overrider_data_s { ++ /* The function for which we are trying to find a final overrider. */ ++ tree fn; ++ /* The base class in which the function was declared. */ ++ tree declaring_base; ++ /* The most derived class in the hierarchy. */ ++ tree most_derived_type; ++ /* The candidate overriders. */ ++ tree candidates; ++ /* Each entry in this array is the next-most-derived class for a ++ virtual base class along the current path. */ ++ tree *vpath_list; ++ /* A pointer one past the top of the VPATH_LIST. */ ++ tree *vpath; ++} find_final_overrider_data; ++ ++/* Add the overrider along the current path to FFOD->CANDIDATES. ++ Returns true if an overrider was found; false otherwise. */ ++ ++static bool ++dfs_find_final_overrider_1 (tree binfo, ++ tree *vpath, ++ find_final_overrider_data *ffod) ++{ ++ tree method; ++ ++ /* If BINFO is not the most derived type, try a more derived class. ++ A definition there will overrider a definition here. */ ++ if (!same_type_p (BINFO_TYPE (binfo), ffod->most_derived_type)) ++ { ++ tree derived; ++ ++ if (TREE_VIA_VIRTUAL (binfo)) ++ derived = *--vpath; ++ else ++ derived = BINFO_INHERITANCE_CHAIN (binfo); ++ if (dfs_find_final_overrider_1 (derived, vpath, ffod)) ++ return true; ++ } ++ ++ method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn); ++ if (method) ++ { ++ tree *candidate = &ffod->candidates; ++ ++ /* Remove any candidates overridden by this new function. */ ++ while (*candidate) ++ { ++ /* If *CANDIDATE overrides METHOD, then METHOD ++ cannot override anything else on the list. */ ++ if (base_derived_from (TREE_VALUE (*candidate), binfo)) ++ return true; ++ /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */ ++ if (base_derived_from (binfo, TREE_VALUE (*candidate))) ++ *candidate = TREE_CHAIN (*candidate); ++ else ++ candidate = &TREE_CHAIN (*candidate); ++ } ++ ++ /* Add the new function. */ ++ ffod->candidates = tree_cons (method, binfo, ffod->candidates); ++ return true; ++ } ++ ++ return false; ++} ++ ++/* Called from find_final_overrider via dfs_walk. */ ++ ++static tree ++dfs_find_final_overrider (tree binfo, void* data) ++{ ++ find_final_overrider_data *ffod = (find_final_overrider_data *) data; ++ ++ if (binfo == ffod->declaring_base) ++ dfs_find_final_overrider_1 (binfo, ffod->vpath, ffod); ++ ++ return NULL_TREE; ++} ++ ++static tree ++dfs_find_final_overrider_q (tree derived, int ix, void *data) ++{ ++ tree binfo = BINFO_BASETYPE (derived, ix); ++ find_final_overrider_data *ffod = (find_final_overrider_data *) data; ++ ++ if (TREE_VIA_VIRTUAL (binfo)) ++ *ffod->vpath++ = derived; ++ ++ return binfo; ++} ++ ++static tree ++dfs_find_final_overrider_post (tree binfo, void *data) ++{ ++ find_final_overrider_data *ffod = (find_final_overrider_data *) data; ++ ++ if (TREE_VIA_VIRTUAL (binfo)) ++ ffod->vpath--; ++ ++ return NULL_TREE; ++} ++ ++/* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for ++ FN and whose TREE_VALUE is the binfo for the base where the ++ overriding occurs. BINFO (in the hierarchy dominated by the binfo ++ DERIVED) is the base object in which FN is declared. */ ++ ++static tree ++find_final_overrider (tree derived, tree binfo, tree fn) ++{ ++ find_final_overrider_data ffod; ++ count_depth_data cd; ++ ++ /* Getting this right is a little tricky. This is valid: ++ ++ struct S { virtual void f (); }; ++ struct T { virtual void f (); }; ++ struct U : public S, public T { }; ++ ++ even though calling `f' in `U' is ambiguous. But, ++ ++ struct R { virtual void f(); }; ++ struct S : virtual public R { virtual void f (); }; ++ struct T : virtual public R { virtual void f (); }; ++ struct U : public S, public T { }; ++ ++ is not -- there's no way to decide whether to put `S::f' or ++ `T::f' in the vtable for `R'. ++ ++ The solution is to look at all paths to BINFO. If we find ++ different overriders along any two, then there is a problem. */ ++ if (DECL_THUNK_P (fn)) ++ fn = THUNK_TARGET (fn); ++ ++ /* Determine the depth of the hierarchy. */ ++ cd.depth = 0; ++ cd.max_depth = 0; ++ dfs_walk (derived, dfs_depth_post, dfs_depth_q, &cd); ++ ++ ffod.fn = fn; ++ ffod.declaring_base = binfo; ++ ffod.most_derived_type = BINFO_TYPE (derived); ++ ffod.candidates = NULL_TREE; ++ ffod.vpath_list = (tree *) xcalloc (cd.max_depth, sizeof (tree)); ++ ffod.vpath = ffod.vpath_list; ++ ++ dfs_walk_real (derived, ++ dfs_find_final_overrider, ++ dfs_find_final_overrider_post, ++ dfs_find_final_overrider_q, ++ &ffod); ++ ++ free (ffod.vpath_list); ++ ++ /* If there was no winner, issue an error message. */ ++ if (!ffod.candidates || TREE_CHAIN (ffod.candidates)) ++ { ++ error ("no unique final overrider for `%D' in `%T'", fn, ++ BINFO_TYPE (derived)); ++ return error_mark_node; ++ } ++ ++ return ffod.candidates; ++} ++ ++/* Return the index of the vcall offset for FN when TYPE is used as a ++ virtual base. */ ++ ++static tree ++get_vcall_index (tree fn, tree type) ++{ ++ tree v; ++ ++ for (v = CLASSTYPE_VCALL_INDICES (type); v; v = TREE_CHAIN (v)) ++ if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (TREE_PURPOSE (v))) ++ || same_signature_p (fn, TREE_PURPOSE (v))) ++ break; ++ ++ /* There should always be an appropriate index. */ ++ my_friendly_assert (v, 20021103); ++ ++ return TREE_VALUE (v); ++} ++ ++/* Update an entry in the vtable for BINFO, which is in the hierarchy ++ dominated by T. FN has been overridden in BINFO; VIRTUALS points to the ++ corresponding position in the BINFO_VIRTUALS list. */ ++ ++static void ++update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals, ++ unsigned ix) ++{ ++ tree b; ++ tree overrider; ++ tree delta; ++ tree virtual_base; ++ tree first_defn; ++ tree overrider_fn, overrider_target; ++ tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn; ++ tree over_return, base_return; ++ bool lost = false; ++ ++ /* Find the nearest primary base (possibly binfo itself) which defines ++ this function; this is the class the caller will convert to when ++ calling FN through BINFO. */ ++ for (b = binfo; ; b = get_primary_binfo (b)) ++ { ++ my_friendly_assert (b, 20021227); ++ if (look_for_overrides_here (BINFO_TYPE (b), target_fn)) ++ break; ++ ++ /* The nearest definition is from a lost primary. */ ++ if (BINFO_LOST_PRIMARY_P (b)) ++ lost = true; ++ } ++ first_defn = b; ++ ++ /* Find the final overrider. */ ++ overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn); ++ if (overrider == error_mark_node) ++ return; ++ overrider_target = overrider_fn = TREE_PURPOSE (overrider); ++ ++ /* Check for adjusting covariant return types. */ ++ over_return = TREE_TYPE (TREE_TYPE (overrider_target)); ++ base_return = TREE_TYPE (TREE_TYPE (target_fn)); ++ ++ if (POINTER_TYPE_P (over_return) ++ && TREE_CODE (over_return) == TREE_CODE (base_return) ++ && CLASS_TYPE_P (TREE_TYPE (over_return)) ++ && CLASS_TYPE_P (TREE_TYPE (base_return))) ++ { ++ /* If FN is a covariant thunk, we must figure out the adjustment ++ to the final base FN was converting to. As OVERRIDER_TARGET might ++ also be converting to the return type of FN, we have to ++ combine the two conversions here. */ ++ tree fixed_offset, virtual_offset; ++ ++ over_return = TREE_TYPE (over_return); ++ base_return = TREE_TYPE (base_return); ++ ++ if (DECL_THUNK_P (fn)) ++ { ++ my_friendly_assert (DECL_RESULT_THUNK_P (fn), 20031211); ++ fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn)); ++ virtual_offset = THUNK_VIRTUAL_OFFSET (fn); ++ } ++ else ++ fixed_offset = virtual_offset = NULL_TREE; ++ ++ if (virtual_offset) ++ /* Find the equivalent binfo within the return type of the ++ overriding function. We will want the vbase offset from ++ there. */ ++ virtual_offset = ++ TREE_VALUE (purpose_member ++ (BINFO_TYPE (virtual_offset), ++ CLASSTYPE_VBASECLASSES (over_return))); ++ else if (!same_type_ignoring_top_level_qualifiers_p ++ (over_return, base_return)) ++ { ++ /* There was no existing virtual thunk (which takes ++ precedence). So find the binfo of the base function's ++ return type within the overriding function's return type. ++ We cannot call lookup base here, because we're inside a ++ dfs_walk, and will therefore clobber the BINFO_MARKED ++ flags. Fortunately we know the covariancy is valid (it ++ has already been checked), so we can just iterate along ++ the binfos, which have been chained in inheritance graph ++ order. Of course it is lame that we have to repeat the ++ search here anyway -- we should really be caching pieces ++ of the vtable and avoiding this repeated work. */ ++ tree thunk_binfo, base_binfo; ++ ++ /* Find the base binfo within the overriding function's ++ return type. We will always find a thunk_binfo, except ++ when the covariancy is invalid (which we will have ++ already diagnosed). */ ++ for (base_binfo = TYPE_BINFO (base_return), ++ thunk_binfo = TYPE_BINFO (over_return); ++ thunk_binfo; ++ thunk_binfo = TREE_CHAIN (thunk_binfo)) ++ if (same_type_p (BINFO_TYPE (thunk_binfo), ++ BINFO_TYPE (base_binfo))) ++ break; ++ ++ /* See if virtual inheritance is involved. */ ++ for (virtual_offset = thunk_binfo; ++ virtual_offset; ++ virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset)) ++ if (TREE_VIA_VIRTUAL (virtual_offset)) ++ break; ++ ++ if (virtual_offset ++ || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo))) ++ { ++ tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo)); ++ ++ if (virtual_offset) ++ { ++ /* We convert via virtual base. Adjust the fixed ++ offset to be from there. */ ++ offset = size_diffop ++ (offset, convert ++ (ssizetype, BINFO_OFFSET (virtual_offset))); ++ } ++ if (fixed_offset) ++ /* There was an existing fixed offset, this must be ++ from the base just converted to, and the base the ++ FN was thunking to. */ ++ fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset); ++ else ++ fixed_offset = offset; ++ } ++ } ++ ++ if (fixed_offset || virtual_offset) ++ /* Replace the overriding function with a covariant thunk. We ++ will emit the overriding function in its own slot as ++ well. */ ++ overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0, ++ fixed_offset, virtual_offset); ++ } ++ else ++ my_friendly_assert (!DECL_THUNK_P (fn), 20021231); ++ ++ /* Assume that we will produce a thunk that convert all the way to ++ the final overrider, and not to an intermediate virtual base. */ ++ virtual_base = NULL_TREE; ++ ++ /* See if we can convert to an intermediate virtual base first, and then ++ use the vcall offset located there to finish the conversion. */ ++ for (; b; b = BINFO_INHERITANCE_CHAIN (b)) ++ { ++ /* If we find the final overrider, then we can stop ++ walking. */ ++ if (same_type_p (BINFO_TYPE (b), ++ BINFO_TYPE (TREE_VALUE (overrider)))) ++ break; ++ ++ /* If we find a virtual base, and we haven't yet found the ++ overrider, then there is a virtual base between the ++ declaring base (first_defn) and the final overrider. */ ++ if (TREE_VIA_VIRTUAL (b)) ++ { ++ virtual_base = b; ++ break; ++ } ++ } ++ ++ if (overrider_fn != overrider_target && !virtual_base) ++ { ++ /* The ABI specifies that a covariant thunk includes a mangling ++ for a this pointer adjustment. This-adjusting thunks that ++ override a function from a virtual base have a vcall ++ adjustment. When the virtual base in question is a primary ++ virtual base, we know the adjustments are zero, (and in the ++ non-covariant case, we would not use the thunk). ++ Unfortunately we didn't notice this could happen, when ++ designing the ABI and so never mandated that such a covariant ++ thunk should be emitted. Because we must use the ABI mandated ++ name, we must continue searching from the binfo where we ++ found the most recent definition of the function, towards the ++ primary binfo which first introduced the function into the ++ vtable. If that enters a virtual base, we must use a vcall ++ this-adjusting thunk. Bleah! */ ++ tree probe = first_defn; ++ ++ while ((probe = get_primary_binfo (probe)) ++ && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix) ++ if (TREE_VIA_VIRTUAL (probe)) ++ virtual_base = probe; ++ ++ if (virtual_base) ++ /* Even if we find a virtual base, the correct delta is ++ between the overrider and the binfo we're building a vtable ++ for. */ ++ goto virtual_covariant; ++ } ++ ++ /* Compute the constant adjustment to the `this' pointer. The ++ `this' pointer, when this function is called, will point at BINFO ++ (or one of its primary bases, which are at the same offset). */ ++ if (virtual_base) ++ /* The `this' pointer needs to be adjusted from the declaration to ++ the nearest virtual base. */ ++ delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)), ++ convert (ssizetype, BINFO_OFFSET (first_defn))); ++ else if (lost) ++ /* If the nearest definition is in a lost primary, we don't need an ++ entry in our vtable. Except possibly in a constructor vtable, ++ if we happen to get our primary back. In that case, the offset ++ will be zero, as it will be a primary base. */ ++ delta = size_zero_node; ++ else ++ /* The `this' pointer needs to be adjusted from pointing to ++ BINFO to pointing at the base where the final overrider ++ appears. */ ++ virtual_covariant: ++ delta = size_diffop (convert (ssizetype, ++ BINFO_OFFSET (TREE_VALUE (overrider))), ++ convert (ssizetype, BINFO_OFFSET (binfo))); ++ ++ modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals); ++ ++ if (virtual_base) ++ BV_VCALL_INDEX (*virtuals) ++ = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base)); ++} ++ ++/* Called from modify_all_vtables via dfs_walk. */ ++ ++static tree ++dfs_modify_vtables (tree binfo, void* data) ++{ ++ if (/* There's no need to modify the vtable for a non-virtual ++ primary base; we're not going to use that vtable anyhow. ++ We do still need to do this for virtual primary bases, as they ++ could become non-primary in a construction vtable. */ ++ (!BINFO_PRIMARY_P (binfo) || TREE_VIA_VIRTUAL (binfo)) ++ /* Similarly, a base without a vtable needs no modification. */ ++ && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo))) ++ { ++ tree t = (tree) data; ++ tree virtuals; ++ tree old_virtuals; ++ unsigned ix; ++ ++ make_new_vtable (t, binfo); ++ ++ /* Now, go through each of the virtual functions in the virtual ++ function table for BINFO. Find the final overrider, and ++ update the BINFO_VIRTUALS list appropriately. */ ++ for (ix = 0, virtuals = BINFO_VIRTUALS (binfo), ++ old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo))); ++ virtuals; ++ ix++, virtuals = TREE_CHAIN (virtuals), ++ old_virtuals = TREE_CHAIN (old_virtuals)) ++ update_vtable_entry_for_fn (t, ++ binfo, ++ BV_FN (old_virtuals), ++ &virtuals, ix); ++ } ++ ++ BINFO_MARKED (binfo) = 1; ++ ++ return NULL_TREE; ++} ++ ++/* Update all of the primary and secondary vtables for T. Create new ++ vtables as required, and initialize their RTTI information. Each ++ of the functions in VIRTUALS is declared in T and may override a ++ virtual function from a base class; find and modify the appropriate ++ entries to point to the overriding functions. Returns a list, in ++ declaration order, of the virtual functions that are declared in T, ++ but do not appear in the primary base class vtable, and which ++ should therefore be appended to the end of the vtable for T. */ ++ ++static tree ++modify_all_vtables (tree t, tree virtuals) ++{ ++ tree binfo = TYPE_BINFO (t); ++ tree *fnsp; ++ ++ /* Update all of the vtables. */ ++ dfs_walk (binfo, dfs_modify_vtables, unmarkedp, t); ++ dfs_walk (binfo, dfs_unmark, markedp, t); ++ ++ /* Add virtual functions not already in our primary vtable. These ++ will be both those introduced by this class, and those overridden ++ from secondary bases. It does not include virtuals merely ++ inherited from secondary bases. */ ++ for (fnsp = &virtuals; *fnsp; ) ++ { ++ tree fn = TREE_VALUE (*fnsp); ++ ++ if (!value_member (fn, BINFO_VIRTUALS (binfo)) ++ || DECL_VINDEX (fn) == error_mark_node) ++ { ++ /* We don't need to adjust the `this' pointer when ++ calling this function. */ ++ BV_DELTA (*fnsp) = integer_zero_node; ++ BV_VCALL_INDEX (*fnsp) = NULL_TREE; ++ ++ /* This is a function not already in our vtable. Keep it. */ ++ fnsp = &TREE_CHAIN (*fnsp); ++ } ++ else ++ /* We've already got an entry for this function. Skip it. */ ++ *fnsp = TREE_CHAIN (*fnsp); ++ } ++ ++ return virtuals; ++} ++ ++/* Get the base virtual function declarations in T that have the ++ indicated NAME. */ ++ ++static tree ++get_basefndecls (tree name, tree t) ++{ ++ tree methods; ++ tree base_fndecls = NULL_TREE; ++ int n_baseclasses = CLASSTYPE_N_BASECLASSES (t); ++ int i; ++ ++ /* Find virtual functions in T with the indicated NAME. */ ++ i = lookup_fnfields_1 (t, name); ++ if (i != -1) ++ for (methods = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), i); ++ methods; ++ methods = OVL_NEXT (methods)) ++ { ++ tree method = OVL_CURRENT (methods); ++ ++ if (TREE_CODE (method) == FUNCTION_DECL ++ && DECL_VINDEX (method)) ++ base_fndecls = tree_cons (NULL_TREE, method, base_fndecls); ++ } ++ ++ if (base_fndecls) ++ return base_fndecls; ++ ++ for (i = 0; i < n_baseclasses; i++) ++ { ++ tree basetype = TYPE_BINFO_BASETYPE (t, i); ++ base_fndecls = chainon (get_basefndecls (name, basetype), ++ base_fndecls); ++ } ++ ++ return base_fndecls; ++} ++ ++/* If this declaration supersedes the declaration of ++ a method declared virtual in the base class, then ++ mark this field as being virtual as well. */ ++ ++static void ++check_for_override (tree decl, tree ctype) ++{ ++ if (TREE_CODE (decl) == TEMPLATE_DECL) ++ /* In [temp.mem] we have: ++ ++ A specialization of a member function template does not ++ override a virtual function from a base class. */ ++ return; ++ if ((DECL_DESTRUCTOR_P (decl) ++ || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) ++ || DECL_CONV_FN_P (decl)) ++ && look_for_overrides (ctype, decl) ++ && !DECL_STATIC_FUNCTION_P (decl)) ++ /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor ++ the error_mark_node so that we know it is an overriding ++ function. */ ++ DECL_VINDEX (decl) = decl; ++ ++ if (DECL_VIRTUAL_P (decl)) ++ { ++ if (!DECL_VINDEX (decl)) ++ DECL_VINDEX (decl) = error_mark_node; ++ IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1; ++ } ++} ++ ++/* Warn about hidden virtual functions that are not overridden in t. ++ We know that constructors and destructors don't apply. */ ++ ++void ++warn_hidden (tree t) ++{ ++ tree method_vec = CLASSTYPE_METHOD_VEC (t); ++ int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0; ++ int i; ++ ++ /* We go through each separately named virtual function. */ ++ for (i = 2; i < n_methods && TREE_VEC_ELT (method_vec, i); ++i) ++ { ++ tree fns; ++ tree name; ++ tree fndecl; ++ tree base_fndecls; ++ int j; ++ ++ /* All functions in this slot in the CLASSTYPE_METHOD_VEC will ++ have the same name. Figure out what name that is. */ ++ name = DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i))); ++ /* There are no possibly hidden functions yet. */ ++ base_fndecls = NULL_TREE; ++ /* Iterate through all of the base classes looking for possibly ++ hidden functions. */ ++ for (j = 0; j < CLASSTYPE_N_BASECLASSES (t); j++) ++ { ++ tree basetype = TYPE_BINFO_BASETYPE (t, j); ++ base_fndecls = chainon (get_basefndecls (name, basetype), ++ base_fndecls); ++ } ++ ++ /* If there are no functions to hide, continue. */ ++ if (!base_fndecls) ++ continue; ++ ++ /* Remove any overridden functions. */ ++ for (fns = TREE_VEC_ELT (method_vec, i); fns; fns = OVL_NEXT (fns)) ++ { ++ fndecl = OVL_CURRENT (fns); ++ if (DECL_VINDEX (fndecl)) ++ { ++ tree *prev = &base_fndecls; ++ ++ while (*prev) ++ /* If the method from the base class has the same ++ signature as the method from the derived class, it ++ has been overridden. */ ++ if (same_signature_p (fndecl, TREE_VALUE (*prev))) ++ *prev = TREE_CHAIN (*prev); ++ else ++ prev = &TREE_CHAIN (*prev); ++ } ++ } ++ ++ /* Now give a warning for all base functions without overriders, ++ as they are hidden. */ ++ while (base_fndecls) ++ { ++ /* Here we know it is a hider, and no overrider exists. */ ++ cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls)); ++ cp_warning_at (" by `%D'", ++ OVL_CURRENT (TREE_VEC_ELT (method_vec, i))); ++ base_fndecls = TREE_CHAIN (base_fndecls); ++ } ++ } ++} ++ ++/* Check for things that are invalid. There are probably plenty of other ++ things we should check for also. */ ++ ++static void ++finish_struct_anon (tree t) ++{ ++ tree field; ++ ++ for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) ++ { ++ if (TREE_STATIC (field)) ++ continue; ++ if (TREE_CODE (field) != FIELD_DECL) ++ continue; ++ ++ if (DECL_NAME (field) == NULL_TREE ++ && ANON_AGGR_TYPE_P (TREE_TYPE (field))) ++ { ++ tree elt = TYPE_FIELDS (TREE_TYPE (field)); ++ for (; elt; elt = TREE_CHAIN (elt)) ++ { ++ /* We're generally only interested in entities the user ++ declared, but we also find nested classes by noticing ++ the TYPE_DECL that we create implicitly. You're ++ allowed to put one anonymous union inside another, ++ though, so we explicitly tolerate that. We use ++ TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that ++ we also allow unnamed types used for defining fields. */ ++ if (DECL_ARTIFICIAL (elt) ++ && (!DECL_IMPLICIT_TYPEDEF_P (elt) ++ || TYPE_ANONYMOUS_P (TREE_TYPE (elt)))) ++ continue; ++ ++ if (TREE_CODE (elt) != FIELD_DECL) ++ { ++ cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members", ++ elt); ++ continue; ++ } ++ ++ if (TREE_PRIVATE (elt)) ++ cp_pedwarn_at ("private member `%#D' in anonymous union", ++ elt); ++ else if (TREE_PROTECTED (elt)) ++ cp_pedwarn_at ("protected member `%#D' in anonymous union", ++ elt); ++ ++ TREE_PRIVATE (elt) = TREE_PRIVATE (field); ++ TREE_PROTECTED (elt) = TREE_PROTECTED (field); ++ } ++ } ++ } ++} ++ ++/* Add T to CLASSTYPE_DECL_LIST of current_class_type which ++ will be used later during class template instantiation. ++ When FRIEND_P is zero, T can be a static member data (VAR_DECL), ++ a non-static member data (FIELD_DECL), a member function ++ (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE), ++ a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL) ++ When FRIEND_P is nonzero, T is either a friend class ++ (RECORD_TYPE, TEMPLATE_DECL) or a friend function ++ (FUNCTION_DECL, TEMPLATE_DECL). */ ++ ++void ++maybe_add_class_template_decl_list (tree type, tree t, int friend_p) ++{ ++ /* Save some memory by not creating TREE_LIST if TYPE is not template. */ ++ if (CLASSTYPE_TEMPLATE_INFO (type)) ++ CLASSTYPE_DECL_LIST (type) ++ = tree_cons (friend_p ? NULL_TREE : type, ++ t, CLASSTYPE_DECL_LIST (type)); ++} ++ ++/* Create default constructors, assignment operators, and so forth for ++ the type indicated by T, if they are needed. ++ CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and ++ CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the ++ class cannot have a default constructor, copy constructor taking a ++ const reference argument, or an assignment operator taking a const ++ reference, respectively. If a virtual destructor is created, its ++ DECL is returned; otherwise the return value is NULL_TREE. */ ++ ++static void ++add_implicitly_declared_members (tree t, ++ int cant_have_default_ctor, ++ int cant_have_const_cctor, ++ int cant_have_const_assignment) ++{ ++ tree default_fn; ++ tree implicit_fns = NULL_TREE; ++ tree virtual_dtor = NULL_TREE; ++ tree *f; ++ ++ ++adding_implicit_members; ++ ++ /* Destructor. */ ++ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t)) ++ { ++ default_fn = implicitly_declare_fn (sfk_destructor, t, /*const_p=*/0); ++ check_for_override (default_fn, t); ++ ++ /* If we couldn't make it work, then pretend we didn't need it. */ ++ if (default_fn == void_type_node) ++ TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 0; ++ else ++ { ++ TREE_CHAIN (default_fn) = implicit_fns; ++ implicit_fns = default_fn; ++ ++ if (DECL_VINDEX (default_fn)) ++ virtual_dtor = default_fn; ++ } ++ } ++ else ++ /* Any non-implicit destructor is non-trivial. */ ++ TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t); ++ ++ /* Default constructor. */ ++ if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor) ++ { ++ default_fn = implicitly_declare_fn (sfk_constructor, t, /*const_p=*/0); ++ TREE_CHAIN (default_fn) = implicit_fns; ++ implicit_fns = default_fn; ++ } ++ ++ /* Copy constructor. */ ++ if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t)) ++ { ++ /* ARM 12.18: You get either X(X&) or X(const X&), but ++ not both. --Chip */ ++ default_fn ++ = implicitly_declare_fn (sfk_copy_constructor, t, ++ /*const_p=*/!cant_have_const_cctor); ++ TREE_CHAIN (default_fn) = implicit_fns; ++ implicit_fns = default_fn; ++ } ++ ++ /* Assignment operator. */ ++ if (! TYPE_HAS_ASSIGN_REF (t) && ! TYPE_FOR_JAVA (t)) ++ { ++ default_fn ++ = implicitly_declare_fn (sfk_assignment_operator, t, ++ /*const_p=*/!cant_have_const_assignment); ++ TREE_CHAIN (default_fn) = implicit_fns; ++ implicit_fns = default_fn; ++ } ++ ++ /* Now, hook all of the new functions on to TYPE_METHODS, ++ and add them to the CLASSTYPE_METHOD_VEC. */ ++ for (f = &implicit_fns; *f; f = &TREE_CHAIN (*f)) ++ { ++ add_method (t, *f, /*error_p=*/0); ++ maybe_add_class_template_decl_list (current_class_type, *f, /*friend_p=*/0); ++ } ++ if (abi_version_at_least (2)) ++ /* G++ 3.2 put the implicit destructor at the *beginning* of the ++ list, which cause the destructor to be emitted in an incorrect ++ location in the vtable. */ ++ TYPE_METHODS (t) = chainon (TYPE_METHODS (t), implicit_fns); ++ else ++ { ++ if (warn_abi && virtual_dtor) ++ warning ("vtable layout for class `%T' may not be ABI-compliant " ++ "and may change in a future version of GCC due to implicit " ++ "virtual destructor", ++ t); ++ *f = TYPE_METHODS (t); ++ TYPE_METHODS (t) = implicit_fns; ++ } ++ ++ --adding_implicit_members; ++} ++ ++/* Subroutine of finish_struct_1. Recursively count the number of fields ++ in TYPE, including anonymous union members. */ ++ ++static int ++count_fields (tree fields) ++{ ++ tree x; ++ int n_fields = 0; ++ for (x = fields; x; x = TREE_CHAIN (x)) ++ { ++ if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x))) ++ n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x))); ++ else ++ n_fields += 1; ++ } ++ return n_fields; ++} ++ ++/* Subroutine of finish_struct_1. Recursively add all the fields in the ++ TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */ ++ ++static int ++add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx) ++{ ++ tree x; ++ for (x = fields; x; x = TREE_CHAIN (x)) ++ { ++ if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x))) ++ idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx); ++ else ++ field_vec->elts[idx++] = x; ++ } ++ return idx; ++} ++ ++/* FIELD is a bit-field. We are finishing the processing for its ++ enclosing type. Issue any appropriate messages and set appropriate ++ flags. */ ++ ++static void ++check_bitfield_decl (tree field) ++{ ++ tree type = TREE_TYPE (field); ++ tree w = NULL_TREE; ++ ++ /* Detect invalid bit-field type. */ ++ if (DECL_INITIAL (field) ++ && ! INTEGRAL_TYPE_P (TREE_TYPE (field))) ++ { ++ cp_error_at ("bit-field `%#D' with non-integral type", field); ++ w = error_mark_node; ++ } ++ ++ /* Detect and ignore out of range field width. */ ++ if (DECL_INITIAL (field)) ++ { ++ w = DECL_INITIAL (field); ++ ++ /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */ ++ STRIP_NOPS (w); ++ ++ /* detect invalid field size. */ ++ if (TREE_CODE (w) == CONST_DECL) ++ w = DECL_INITIAL (w); ++ else ++ w = decl_constant_value (w); ++ ++ if (TREE_CODE (w) != INTEGER_CST) ++ { ++ cp_error_at ("bit-field `%D' width not an integer constant", ++ field); ++ w = error_mark_node; ++ } ++ else if (tree_int_cst_sgn (w) < 0) ++ { ++ cp_error_at ("negative width in bit-field `%D'", field); ++ w = error_mark_node; ++ } ++ else if (integer_zerop (w) && DECL_NAME (field) != 0) ++ { ++ cp_error_at ("zero width for bit-field `%D'", field); ++ w = error_mark_node; ++ } ++ else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0 ++ && TREE_CODE (type) != ENUMERAL_TYPE ++ && TREE_CODE (type) != BOOLEAN_TYPE) ++ cp_warning_at ("width of `%D' exceeds its type", field); ++ else if (TREE_CODE (type) == ENUMERAL_TYPE ++ && (0 > compare_tree_int (w, ++ min_precision (TYPE_MIN_VALUE (type), ++ TREE_UNSIGNED (type))) ++ || 0 > compare_tree_int (w, ++ min_precision ++ (TYPE_MAX_VALUE (type), ++ TREE_UNSIGNED (type))))) ++ cp_warning_at ("`%D' is too small to hold all values of `%#T'", ++ field, type); ++ } ++ ++ /* Remove the bit-field width indicator so that the rest of the ++ compiler does not treat that value as an initializer. */ ++ DECL_INITIAL (field) = NULL_TREE; ++ ++ if (w != error_mark_node) ++ { ++ DECL_SIZE (field) = convert (bitsizetype, w); ++ DECL_BIT_FIELD (field) = 1; ++ } ++ else ++ { ++ /* Non-bit-fields are aligned for their type. */ ++ DECL_BIT_FIELD (field) = 0; ++ CLEAR_DECL_C_BIT_FIELD (field); ++ } ++} ++ ++/* FIELD is a non bit-field. We are finishing the processing for its ++ enclosing type T. Issue any appropriate messages and set appropriate ++ flags. */ ++ ++static void ++check_field_decl (tree field, ++ tree t, ++ int* cant_have_const_ctor, ++ int* cant_have_default_ctor, ++ int* no_const_asn_ref, ++ int* any_default_members) ++{ ++ tree type = strip_array_types (TREE_TYPE (field)); ++ ++ /* An anonymous union cannot contain any fields which would change ++ the settings of CANT_HAVE_CONST_CTOR and friends. */ ++ if (ANON_UNION_TYPE_P (type)) ++ ; ++ /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous ++ structs. So, we recurse through their fields here. */ ++ else if (ANON_AGGR_TYPE_P (type)) ++ { ++ tree fields; ++ ++ for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields)) ++ if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field)) ++ check_field_decl (fields, t, cant_have_const_ctor, ++ cant_have_default_ctor, no_const_asn_ref, ++ any_default_members); ++ } ++ /* Check members with class type for constructors, destructors, ++ etc. */ ++ else if (CLASS_TYPE_P (type)) ++ { ++ /* Never let anything with uninheritable virtuals ++ make it through without complaint. */ ++ abstract_virtuals_error (field, type); ++ ++ if (TREE_CODE (t) == UNION_TYPE) ++ { ++ if (TYPE_NEEDS_CONSTRUCTING (type)) ++ cp_error_at ("member `%#D' with constructor not allowed in union", ++ field); ++ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) ++ cp_error_at ("member `%#D' with destructor not allowed in union", ++ field); ++ if (TYPE_HAS_COMPLEX_ASSIGN_REF (type)) ++ cp_error_at ("member `%#D' with copy assignment operator not allowed in union", ++ field); ++ } ++ else ++ { ++ TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type); ++ TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) ++ |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type); ++ TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type); ++ TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type); ++ } ++ ++ if (!TYPE_HAS_CONST_INIT_REF (type)) ++ *cant_have_const_ctor = 1; ++ ++ if (!TYPE_HAS_CONST_ASSIGN_REF (type)) ++ *no_const_asn_ref = 1; ++ ++ if (TYPE_HAS_CONSTRUCTOR (type) ++ && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) ++ *cant_have_default_ctor = 1; ++ } ++ if (DECL_INITIAL (field) != NULL_TREE) ++ { ++ /* `build_class_init_list' does not recognize ++ non-FIELD_DECLs. */ ++ if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0) ++ error ("multiple fields in union `%T' initialized", t); ++ *any_default_members = 1; ++ } ++} ++ ++/* Check the data members (both static and non-static), class-scoped ++ typedefs, etc., appearing in the declaration of T. Issue ++ appropriate diagnostics. Sets ACCESS_DECLS to a list (in ++ declaration order) of access declarations; each TREE_VALUE in this ++ list is a USING_DECL. ++ ++ In addition, set the following flags: ++ ++ EMPTY_P ++ The class is empty, i.e., contains no non-static data members. ++ ++ CANT_HAVE_DEFAULT_CTOR_P ++ This class cannot have an implicitly generated default ++ constructor. ++ ++ CANT_HAVE_CONST_CTOR_P ++ This class cannot have an implicitly generated copy constructor ++ taking a const reference. ++ ++ CANT_HAVE_CONST_ASN_REF ++ This class cannot have an implicitly generated assignment ++ operator taking a const reference. ++ ++ All of these flags should be initialized before calling this ++ function. ++ ++ Returns a pointer to the end of the TYPE_FIELDs chain; additional ++ fields can be added by adding to this chain. */ ++ ++static void ++check_field_decls (tree t, tree *access_decls, ++ int *cant_have_default_ctor_p, ++ int *cant_have_const_ctor_p, ++ int *no_const_asn_ref_p) ++{ ++ tree *field; ++ tree *next; ++ int has_pointers; ++ int any_default_members; ++ ++ /* Assume there are no access declarations. */ ++ *access_decls = NULL_TREE; ++ /* Assume this class has no pointer members. */ ++ has_pointers = 0; ++ /* Assume none of the members of this class have default ++ initializations. */ ++ any_default_members = 0; ++ ++ for (field = &TYPE_FIELDS (t); *field; field = next) ++ { ++ tree x = *field; ++ tree type = TREE_TYPE (x); ++ ++ next = &TREE_CHAIN (x); ++ ++ if (TREE_CODE (x) == FIELD_DECL) ++ { ++ if (TYPE_PACKED (t)) ++ { ++ if (!pod_type_p (TREE_TYPE (x)) && !TYPE_PACKED (TREE_TYPE (x))) ++ cp_warning_at ++ ("ignoring packed attribute on unpacked non-POD field `%#D'", ++ x); ++ else ++ DECL_PACKED (x) = 1; ++ } ++ ++ if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x))) ++ /* We don't treat zero-width bitfields as making a class ++ non-empty. */ ++ ; ++ else ++ { ++ tree element_type; ++ ++ /* The class is non-empty. */ ++ CLASSTYPE_EMPTY_P (t) = 0; ++ /* The class is not even nearly empty. */ ++ CLASSTYPE_NEARLY_EMPTY_P (t) = 0; ++ /* If one of the data members contains an empty class, ++ so does T. */ ++ element_type = strip_array_types (type); ++ if (CLASS_TYPE_P (element_type) ++ && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type)) ++ CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1; ++ } ++ } ++ ++ if (TREE_CODE (x) == USING_DECL) ++ { ++ /* Prune the access declaration from the list of fields. */ ++ *field = TREE_CHAIN (x); ++ ++ /* Save the access declarations for our caller. */ ++ *access_decls = tree_cons (NULL_TREE, x, *access_decls); ++ ++ /* Since we've reset *FIELD there's no reason to skip to the ++ next field. */ ++ next = field; ++ continue; ++ } ++ ++ if (TREE_CODE (x) == TYPE_DECL ++ || TREE_CODE (x) == TEMPLATE_DECL) ++ continue; ++ ++ /* If we've gotten this far, it's a data member, possibly static, ++ or an enumerator. */ ++ DECL_CONTEXT (x) = t; ++ ++ /* When this goes into scope, it will be a non-local reference. */ ++ DECL_NONLOCAL (x) = 1; ++ ++ if (TREE_CODE (t) == UNION_TYPE) ++ { ++ /* [class.union] ++ ++ If a union contains a static data member, or a member of ++ reference type, the program is ill-formed. */ ++ if (TREE_CODE (x) == VAR_DECL) ++ { ++ cp_error_at ("`%D' may not be static because it is a member of a union", x); ++ continue; ++ } ++ if (TREE_CODE (type) == REFERENCE_TYPE) ++ { ++ cp_error_at ("`%D' may not have reference type `%T' because it is a member of a union", ++ x, type); ++ continue; ++ } ++ } ++ ++ /* ``A local class cannot have static data members.'' ARM 9.4 */ ++ if (current_function_decl && TREE_STATIC (x)) ++ cp_error_at ("field `%D' in local class cannot be static", x); ++ ++ /* Perform error checking that did not get done in ++ grokdeclarator. */ ++ if (TREE_CODE (type) == FUNCTION_TYPE) ++ { ++ cp_error_at ("field `%D' invalidly declared function type", ++ x); ++ type = build_pointer_type (type); ++ TREE_TYPE (x) = type; ++ } ++ else if (TREE_CODE (type) == METHOD_TYPE) ++ { ++ cp_error_at ("field `%D' invalidly declared method type", x); ++ type = build_pointer_type (type); ++ TREE_TYPE (x) = type; ++ } ++ ++ if (type == error_mark_node) ++ continue; ++ ++ if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL) ++ continue; ++ ++ /* Now it can only be a FIELD_DECL. */ ++ ++ if (TREE_PRIVATE (x) || TREE_PROTECTED (x)) ++ CLASSTYPE_NON_AGGREGATE (t) = 1; ++ ++ /* If this is of reference type, check if it needs an init. ++ Also do a little ANSI jig if necessary. */ ++ if (TREE_CODE (type) == REFERENCE_TYPE) ++ { ++ CLASSTYPE_NON_POD_P (t) = 1; ++ if (DECL_INITIAL (x) == NULL_TREE) ++ SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1); ++ ++ /* ARM $12.6.2: [A member initializer list] (or, for an ++ aggregate, initialization by a brace-enclosed list) is the ++ only way to initialize nonstatic const and reference ++ members. */ ++ *cant_have_default_ctor_p = 1; ++ TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1; ++ ++ if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t) ++ && extra_warnings) ++ cp_warning_at ("non-static reference `%#D' in class without a constructor", x); ++ } ++ ++ type = strip_array_types (type); ++ ++ if (TYPE_PTR_P (type)) ++ has_pointers = 1; ++ ++ if (CLASS_TYPE_P (type)) ++ { ++ if (CLASSTYPE_REF_FIELDS_NEED_INIT (type)) ++ SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1); ++ if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type)) ++ SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1); ++ } ++ ++ if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type)) ++ CLASSTYPE_HAS_MUTABLE (t) = 1; ++ ++ if (! pod_type_p (type)) ++ /* DR 148 now allows pointers to members (which are POD themselves), ++ to be allowed in POD structs. */ ++ CLASSTYPE_NON_POD_P (t) = 1; ++ ++ if (! zero_init_p (type)) ++ CLASSTYPE_NON_ZERO_INIT_P (t) = 1; ++ ++ /* If any field is const, the structure type is pseudo-const. */ ++ if (CP_TYPE_CONST_P (type)) ++ { ++ C_TYPE_FIELDS_READONLY (t) = 1; ++ if (DECL_INITIAL (x) == NULL_TREE) ++ SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1); ++ ++ /* ARM $12.6.2: [A member initializer list] (or, for an ++ aggregate, initialization by a brace-enclosed list) is the ++ only way to initialize nonstatic const and reference ++ members. */ ++ *cant_have_default_ctor_p = 1; ++ TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1; ++ ++ if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t) ++ && extra_warnings) ++ cp_warning_at ("non-static const member `%#D' in class without a constructor", x); ++ } ++ /* A field that is pseudo-const makes the structure likewise. */ ++ else if (CLASS_TYPE_P (type)) ++ { ++ C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type); ++ SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, ++ CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) ++ | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type)); ++ } ++ ++ /* Core issue 80: A nonstatic data member is required to have a ++ different name from the class iff the class has a ++ user-defined constructor. */ ++ if (constructor_name_p (DECL_NAME (x), t) && TYPE_HAS_CONSTRUCTOR (t)) ++ cp_pedwarn_at ("field `%#D' with same name as class", x); ++ ++ /* We set DECL_C_BIT_FIELD in grokbitfield. ++ If the type and width are valid, we'll also set DECL_BIT_FIELD. */ ++ if (DECL_C_BIT_FIELD (x)) ++ check_bitfield_decl (x); ++ else ++ check_field_decl (x, t, ++ cant_have_const_ctor_p, ++ cant_have_default_ctor_p, ++ no_const_asn_ref_p, ++ &any_default_members); ++ } ++ ++ /* Effective C++ rule 11. */ ++ if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t) ++ && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t))) ++ { ++ warning ("`%#T' has pointer data members", t); ++ ++ if (! TYPE_HAS_INIT_REF (t)) ++ { ++ warning (" but does not override `%T(const %T&)'", t, t); ++ if (! TYPE_HAS_ASSIGN_REF (t)) ++ warning (" or `operator=(const %T&)'", t); ++ } ++ else if (! TYPE_HAS_ASSIGN_REF (t)) ++ warning (" but does not override `operator=(const %T&)'", t); ++ } ++ ++ ++ /* Check anonymous struct/anonymous union fields. */ ++ finish_struct_anon (t); ++ ++ /* We've built up the list of access declarations in reverse order. ++ Fix that now. */ ++ *access_decls = nreverse (*access_decls); ++} ++ ++/* If TYPE is an empty class type, records its OFFSET in the table of ++ OFFSETS. */ ++ ++static int ++record_subobject_offset (tree type, tree offset, splay_tree offsets) ++{ ++ splay_tree_node n; ++ ++ if (!is_empty_class (type)) ++ return 0; ++ ++ /* Record the location of this empty object in OFFSETS. */ ++ n = splay_tree_lookup (offsets, (splay_tree_key) offset); ++ if (!n) ++ n = splay_tree_insert (offsets, ++ (splay_tree_key) offset, ++ (splay_tree_value) NULL_TREE); ++ n->value = ((splay_tree_value) ++ tree_cons (NULL_TREE, ++ type, ++ (tree) n->value)); ++ ++ return 0; ++} ++ ++/* Returns nonzero if TYPE is an empty class type and there is ++ already an entry in OFFSETS for the same TYPE as the same OFFSET. */ ++ ++static int ++check_subobject_offset (tree type, tree offset, splay_tree offsets) ++{ ++ splay_tree_node n; ++ tree t; ++ ++ if (!is_empty_class (type)) ++ return 0; ++ ++ /* Record the location of this empty object in OFFSETS. */ ++ n = splay_tree_lookup (offsets, (splay_tree_key) offset); ++ if (!n) ++ return 0; ++ ++ for (t = (tree) n->value; t; t = TREE_CHAIN (t)) ++ if (same_type_p (TREE_VALUE (t), type)) ++ return 1; ++ ++ return 0; ++} ++ ++/* Walk through all the subobjects of TYPE (located at OFFSET). Call ++ F for every subobject, passing it the type, offset, and table of ++ OFFSETS. If VBASES_P is one, then virtual non-primary bases should ++ be traversed. ++ ++ If MAX_OFFSET is non-NULL, then subobjects with an offset greater ++ than MAX_OFFSET will not be walked. ++ ++ If F returns a nonzero value, the traversal ceases, and that value ++ is returned. Otherwise, returns zero. */ ++ ++static int ++walk_subobject_offsets (tree type, ++ subobject_offset_fn f, ++ tree offset, ++ splay_tree offsets, ++ tree max_offset, ++ int vbases_p) ++{ ++ int r = 0; ++ tree type_binfo = NULL_TREE; ++ ++ /* If this OFFSET is bigger than the MAX_OFFSET, then we should ++ stop. */ ++ if (max_offset && INT_CST_LT (max_offset, offset)) ++ return 0; ++ ++ if (!TYPE_P (type)) ++ { ++ if (abi_version_at_least (2)) ++ type_binfo = type; ++ type = BINFO_TYPE (type); ++ } ++ ++ if (CLASS_TYPE_P (type)) ++ { ++ tree field; ++ tree binfo; ++ int i; ++ ++ /* Avoid recursing into objects that are not interesting. */ ++ if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type)) ++ return 0; ++ ++ /* Record the location of TYPE. */ ++ r = (*f) (type, offset, offsets); ++ if (r) ++ return r; ++ ++ /* Iterate through the direct base classes of TYPE. */ ++ if (!type_binfo) ++ type_binfo = TYPE_BINFO (type); ++ for (i = 0; i < BINFO_N_BASETYPES (type_binfo); ++i) ++ { ++ tree binfo_offset; ++ ++ binfo = BINFO_BASETYPE (type_binfo, i); ++ ++ if (abi_version_at_least (2) ++ && TREE_VIA_VIRTUAL (binfo)) ++ continue; ++ ++ if (!vbases_p ++ && TREE_VIA_VIRTUAL (binfo) ++ && !BINFO_PRIMARY_P (binfo)) ++ continue; ++ ++ if (!abi_version_at_least (2)) ++ binfo_offset = size_binop (PLUS_EXPR, ++ offset, ++ BINFO_OFFSET (binfo)); ++ else ++ { ++ tree orig_binfo; ++ /* We cannot rely on BINFO_OFFSET being set for the base ++ class yet, but the offsets for direct non-virtual ++ bases can be calculated by going back to the TYPE. */ ++ orig_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i); ++ binfo_offset = size_binop (PLUS_EXPR, ++ offset, ++ BINFO_OFFSET (orig_binfo)); ++ } ++ ++ r = walk_subobject_offsets (binfo, ++ f, ++ binfo_offset, ++ offsets, ++ max_offset, ++ (abi_version_at_least (2) ++ ? /*vbases_p=*/0 : vbases_p)); ++ if (r) ++ return r; ++ } ++ ++ if (abi_version_at_least (2)) ++ { ++ tree vbase; ++ ++ /* Iterate through the virtual base classes of TYPE. In G++ ++ 3.2, we included virtual bases in the direct base class ++ loop above, which results in incorrect results; the ++ correct offsets for virtual bases are only known when ++ working with the most derived type. */ ++ if (vbases_p) ++ for (vbase = CLASSTYPE_VBASECLASSES (type); ++ vbase; ++ vbase = TREE_CHAIN (vbase)) ++ { ++ binfo = TREE_VALUE (vbase); ++ r = walk_subobject_offsets (binfo, ++ f, ++ size_binop (PLUS_EXPR, ++ offset, ++ BINFO_OFFSET (binfo)), ++ offsets, ++ max_offset, ++ /*vbases_p=*/0); ++ if (r) ++ return r; ++ } ++ else ++ { ++ /* We still have to walk the primary base, if it is ++ virtual. (If it is non-virtual, then it was walked ++ above.) */ ++ vbase = get_primary_binfo (type_binfo); ++ if (vbase && TREE_VIA_VIRTUAL (vbase) ++ && BINFO_PRIMARY_BASE_OF (vbase) == type_binfo) ++ { ++ r = (walk_subobject_offsets ++ (vbase, f, offset, ++ offsets, max_offset, /*vbases_p=*/0)); ++ if (r) ++ return r; ++ } ++ } ++ } ++ ++ /* Iterate through the fields of TYPE. */ ++ for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) ++ if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field)) ++ { ++ tree field_offset; ++ ++ if (abi_version_at_least (2)) ++ field_offset = byte_position (field); ++ else ++ /* In G++ 3.2, DECL_FIELD_OFFSET was used. */ ++ field_offset = DECL_FIELD_OFFSET (field); ++ ++ r = walk_subobject_offsets (TREE_TYPE (field), ++ f, ++ size_binop (PLUS_EXPR, ++ offset, ++ field_offset), ++ offsets, ++ max_offset, ++ /*vbases_p=*/1); ++ if (r) ++ return r; ++ } ++ } ++ else if (TREE_CODE (type) == ARRAY_TYPE) ++ { ++ tree element_type = strip_array_types (type); ++ tree domain = TYPE_DOMAIN (type); ++ tree index; ++ ++ /* Avoid recursing into objects that are not interesting. */ ++ if (!CLASS_TYPE_P (element_type) ++ || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type)) ++ return 0; ++ ++ /* Step through each of the elements in the array. */ ++ for (index = size_zero_node; ++ /* G++ 3.2 had an off-by-one error here. */ ++ (abi_version_at_least (2) ++ ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index) ++ : INT_CST_LT (index, TYPE_MAX_VALUE (domain))); ++ index = size_binop (PLUS_EXPR, index, size_one_node)) ++ { ++ r = walk_subobject_offsets (TREE_TYPE (type), ++ f, ++ offset, ++ offsets, ++ max_offset, ++ /*vbases_p=*/1); ++ if (r) ++ return r; ++ offset = size_binop (PLUS_EXPR, offset, ++ TYPE_SIZE_UNIT (TREE_TYPE (type))); ++ /* If this new OFFSET is bigger than the MAX_OFFSET, then ++ there's no point in iterating through the remaining ++ elements of the array. */ ++ if (max_offset && INT_CST_LT (max_offset, offset)) ++ break; ++ } ++ } ++ ++ return 0; ++} ++ ++/* Record all of the empty subobjects of TYPE (located at OFFSET) in ++ OFFSETS. If VBASES_P is nonzero, virtual bases of TYPE are ++ examined. */ ++ ++static void ++record_subobject_offsets (tree type, ++ tree offset, ++ splay_tree offsets, ++ int vbases_p) ++{ ++ walk_subobject_offsets (type, record_subobject_offset, offset, ++ offsets, /*max_offset=*/NULL_TREE, vbases_p); ++} ++ ++/* Returns nonzero if any of the empty subobjects of TYPE (located at ++ OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero, ++ virtual bases of TYPE are examined. */ ++ ++static int ++layout_conflict_p (tree type, ++ tree offset, ++ splay_tree offsets, ++ int vbases_p) ++{ ++ splay_tree_node max_node; ++ ++ /* Get the node in OFFSETS that indicates the maximum offset where ++ an empty subobject is located. */ ++ max_node = splay_tree_max (offsets); ++ /* If there aren't any empty subobjects, then there's no point in ++ performing this check. */ ++ if (!max_node) ++ return 0; ++ ++ return walk_subobject_offsets (type, check_subobject_offset, offset, ++ offsets, (tree) (max_node->key), ++ vbases_p); ++} ++ ++/* DECL is a FIELD_DECL corresponding either to a base subobject of a ++ non-static data member of the type indicated by RLI. BINFO is the ++ binfo corresponding to the base subobject, OFFSETS maps offsets to ++ types already located at those offsets. This function determines ++ the position of the DECL. */ ++ ++static void ++layout_nonempty_base_or_field (record_layout_info rli, ++ tree decl, ++ tree binfo, ++ splay_tree offsets) ++{ ++ tree offset = NULL_TREE; ++ bool field_p; ++ tree type; ++ ++ if (binfo) ++ { ++ /* For the purposes of determining layout conflicts, we want to ++ use the class type of BINFO; TREE_TYPE (DECL) will be the ++ CLASSTYPE_AS_BASE version, which does not contain entries for ++ zero-sized bases. */ ++ type = TREE_TYPE (binfo); ++ field_p = false; ++ } ++ else ++ { ++ type = TREE_TYPE (decl); ++ field_p = true; ++ } ++ ++ /* Try to place the field. It may take more than one try if we have ++ a hard time placing the field without putting two objects of the ++ same type at the same address. */ ++ while (1) ++ { ++ struct record_layout_info_s old_rli = *rli; ++ ++ /* Place this field. */ ++ place_field (rli, decl); ++ offset = byte_position (decl); ++ ++ /* We have to check to see whether or not there is already ++ something of the same type at the offset we're about to use. ++ For example, consider: ++ ++ struct S {}; ++ struct T : public S { int i; }; ++ struct U : public S, public T {}; ++ ++ Here, we put S at offset zero in U. Then, we can't put T at ++ offset zero -- its S component would be at the same address ++ as the S we already allocated. So, we have to skip ahead. ++ Since all data members, including those whose type is an ++ empty class, have nonzero size, any overlap can happen only ++ with a direct or indirect base-class -- it can't happen with ++ a data member. */ ++ /* In a union, overlap is permitted; all members are placed at ++ offset zero. */ ++ if (TREE_CODE (rli->t) == UNION_TYPE) ++ break; ++ /* G++ 3.2 did not check for overlaps when placing a non-empty ++ virtual base. */ ++ if (!abi_version_at_least (2) && binfo && TREE_VIA_VIRTUAL (binfo)) ++ break; ++ if (layout_conflict_p (field_p ? type : binfo, offset, ++ offsets, field_p)) ++ { ++ /* Strip off the size allocated to this field. That puts us ++ at the first place we could have put the field with ++ proper alignment. */ ++ *rli = old_rli; ++ ++ /* Bump up by the alignment required for the type. */ ++ rli->bitpos ++ = size_binop (PLUS_EXPR, rli->bitpos, ++ bitsize_int (binfo ++ ? CLASSTYPE_ALIGN (type) ++ : TYPE_ALIGN (type))); ++ normalize_rli (rli); ++ } ++ else ++ /* There was no conflict. We're done laying out this field. */ ++ break; ++ } ++ ++ /* Now that we know where it will be placed, update its ++ BINFO_OFFSET. */ ++ if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo))) ++ /* Indirect virtual bases may have a nonzero BINFO_OFFSET at ++ this point because their BINFO_OFFSET is copied from another ++ hierarchy. Therefore, we may not need to add the entire ++ OFFSET. */ ++ propagate_binfo_offsets (binfo, ++ size_diffop (convert (ssizetype, offset), ++ convert (ssizetype, ++ BINFO_OFFSET (binfo)))); ++} ++ ++/* Returns true if TYPE is empty and OFFSET is nonzero. */ ++ ++static int ++empty_base_at_nonzero_offset_p (tree type, ++ tree offset, ++ splay_tree offsets ATTRIBUTE_UNUSED) ++{ ++ return is_empty_class (type) && !integer_zerop (offset); ++} ++ ++/* Layout the empty base BINFO. EOC indicates the byte currently just ++ past the end of the class, and should be correctly aligned for a ++ class of the type indicated by BINFO; OFFSETS gives the offsets of ++ the empty bases allocated so far. T is the most derived ++ type. Return nonzero iff we added it at the end. */ ++ ++static bool ++layout_empty_base (tree binfo, tree eoc, splay_tree offsets) ++{ ++ tree alignment; ++ tree basetype = BINFO_TYPE (binfo); ++ bool atend = false; ++ ++ /* This routine should only be used for empty classes. */ ++ my_friendly_assert (is_empty_class (basetype), 20000321); ++ alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype)); ++ ++ if (!integer_zerop (BINFO_OFFSET (binfo))) ++ { ++ if (abi_version_at_least (2)) ++ propagate_binfo_offsets ++ (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo))); ++ else if (warn_abi) ++ warning ("offset of empty base `%T' may not be ABI-compliant and may" ++ "change in a future version of GCC", ++ BINFO_TYPE (binfo)); ++ } ++ ++ /* This is an empty base class. We first try to put it at offset ++ zero. */ ++ if (layout_conflict_p (binfo, ++ BINFO_OFFSET (binfo), ++ offsets, ++ /*vbases_p=*/0)) ++ { ++ /* That didn't work. Now, we move forward from the next ++ available spot in the class. */ ++ atend = true; ++ propagate_binfo_offsets (binfo, convert (ssizetype, eoc)); ++ while (1) ++ { ++ if (!layout_conflict_p (binfo, ++ BINFO_OFFSET (binfo), ++ offsets, ++ /*vbases_p=*/0)) ++ /* We finally found a spot where there's no overlap. */ ++ break; ++ ++ /* There's overlap here, too. Bump along to the next spot. */ ++ propagate_binfo_offsets (binfo, alignment); ++ } ++ } ++ return atend; ++} ++ ++/* Layout the the base given by BINFO in the class indicated by RLI. ++ *BASE_ALIGN is a running maximum of the alignments of ++ any base class. OFFSETS gives the location of empty base ++ subobjects. T is the most derived type. Return nonzero if the new ++ object cannot be nearly-empty. A new FIELD_DECL is inserted at ++ *NEXT_FIELD, unless BINFO is for an empty base class. ++ ++ Returns the location at which the next field should be inserted. */ ++ ++static tree * ++build_base_field (record_layout_info rli, tree binfo, ++ splay_tree offsets, tree *next_field) ++{ ++ tree t = rli->t; ++ tree basetype = BINFO_TYPE (binfo); ++ ++ if (!COMPLETE_TYPE_P (basetype)) ++ /* This error is now reported in xref_tag, thus giving better ++ location information. */ ++ return next_field; ++ ++ /* Place the base class. */ ++ if (!is_empty_class (basetype)) ++ { ++ tree decl; ++ ++ /* The containing class is non-empty because it has a non-empty ++ base class. */ ++ CLASSTYPE_EMPTY_P (t) = 0; ++ ++ /* Create the FIELD_DECL. */ ++ decl = build_decl (FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype)); ++ DECL_ARTIFICIAL (decl) = 1; ++ DECL_FIELD_CONTEXT (decl) = t; ++ DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype); ++ DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype); ++ DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype); ++ DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype); ++ DECL_IGNORED_P (decl) = 1; ++ ++ /* Try to place the field. It may take more than one try if we ++ have a hard time placing the field without putting two ++ objects of the same type at the same address. */ ++ layout_nonempty_base_or_field (rli, decl, binfo, offsets); ++ /* Add the new FIELD_DECL to the list of fields for T. */ ++ TREE_CHAIN (decl) = *next_field; ++ *next_field = decl; ++ next_field = &TREE_CHAIN (decl); ++ } ++ else ++ { ++ tree eoc; ++ bool atend; ++ ++ /* On some platforms (ARM), even empty classes will not be ++ byte-aligned. */ ++ eoc = round_up (rli_size_unit_so_far (rli), ++ CLASSTYPE_ALIGN_UNIT (basetype)); ++ atend = layout_empty_base (binfo, eoc, offsets); ++ /* A nearly-empty class "has no proper base class that is empty, ++ not morally virtual, and at an offset other than zero." */ ++ if (!TREE_VIA_VIRTUAL (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t)) ++ { ++ if (atend) ++ CLASSTYPE_NEARLY_EMPTY_P (t) = 0; ++ /* The check above (used in G++ 3.2) is insufficient because ++ an empty class placed at offset zero might itself have an ++ empty base at a nonzero offset. */ ++ else if (walk_subobject_offsets (basetype, ++ empty_base_at_nonzero_offset_p, ++ size_zero_node, ++ /*offsets=*/NULL, ++ /*max_offset=*/NULL_TREE, ++ /*vbases_p=*/true)) ++ { ++ if (abi_version_at_least (2)) ++ CLASSTYPE_NEARLY_EMPTY_P (t) = 0; ++ else if (warn_abi) ++ warning ("class `%T' will be considered nearly empty in a " ++ "future version of GCC", t); ++ } ++ } ++ ++ /* We do not create a FIELD_DECL for empty base classes because ++ it might overlap some other field. We want to be able to ++ create CONSTRUCTORs for the class by iterating over the ++ FIELD_DECLs, and the back end does not handle overlapping ++ FIELD_DECLs. */ ++ ++ /* An empty virtual base causes a class to be non-empty ++ -- but in that case we do not need to clear CLASSTYPE_EMPTY_P ++ here because that was already done when the virtual table ++ pointer was created. */ ++ } ++ ++ /* Record the offsets of BINFO and its base subobjects. */ ++ record_subobject_offsets (binfo, ++ BINFO_OFFSET (binfo), ++ offsets, ++ /*vbases_p=*/0); ++ ++ return next_field; ++} ++ ++/* Layout all of the non-virtual base classes. Record empty ++ subobjects in OFFSETS. T is the most derived type. Return nonzero ++ if the type cannot be nearly empty. The fields created ++ corresponding to the base classes will be inserted at ++ *NEXT_FIELD. */ ++ ++static void ++build_base_fields (record_layout_info rli, ++ splay_tree offsets, tree *next_field) ++{ ++ /* Chain to hold all the new FIELD_DECLs which stand in for base class ++ subobjects. */ ++ tree t = rli->t; ++ int n_baseclasses = CLASSTYPE_N_BASECLASSES (t); ++ int i; ++ ++ /* The primary base class is always allocated first. */ ++ if (CLASSTYPE_HAS_PRIMARY_BASE_P (t)) ++ next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t), ++ offsets, next_field); ++ ++ /* Now allocate the rest of the bases. */ ++ for (i = 0; i < n_baseclasses; ++i) ++ { ++ tree base_binfo; ++ ++ base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i); ++ ++ /* The primary base was already allocated above, so we don't ++ need to allocate it again here. */ ++ if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t)) ++ continue; ++ ++ /* Virtual bases are added at the end (a primary virtual base ++ will have already been added). */ ++ if (TREE_VIA_VIRTUAL (base_binfo)) ++ continue; ++ ++ next_field = build_base_field (rli, base_binfo, ++ offsets, next_field); ++ } ++} ++ ++/* Go through the TYPE_METHODS of T issuing any appropriate ++ diagnostics, figuring out which methods override which other ++ methods, and so forth. */ ++ ++static void ++check_methods (tree t) ++{ ++ tree x; ++ ++ for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x)) ++ { ++ /* If this was an evil function, don't keep it in class. */ ++ if (DECL_ASSEMBLER_NAME_SET_P (x) ++ && IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x))) ++ continue; ++ ++ check_for_override (x, t); ++ if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x)) ++ cp_error_at ("initializer specified for non-virtual method `%D'", x); ++ ++ /* The name of the field is the original field name ++ Save this in auxiliary field for later overloading. */ ++ if (DECL_VINDEX (x)) ++ { ++ TYPE_POLYMORPHIC_P (t) = 1; ++ if (DECL_PURE_VIRTUAL_P (x)) ++ CLASSTYPE_PURE_VIRTUALS (t) ++ = tree_cons (NULL_TREE, x, CLASSTYPE_PURE_VIRTUALS (t)); ++ } ++ } ++} ++ ++/* FN is a constructor or destructor. Clone the declaration to create ++ a specialized in-charge or not-in-charge version, as indicated by ++ NAME. */ ++ ++static tree ++build_clone (tree fn, tree name) ++{ ++ tree parms; ++ tree clone; ++ ++ /* Copy the function. */ ++ clone = copy_decl (fn); ++ /* Remember where this function came from. */ ++ DECL_CLONED_FUNCTION (clone) = fn; ++ DECL_ABSTRACT_ORIGIN (clone) = fn; ++ /* Reset the function name. */ ++ DECL_NAME (clone) = name; ++ SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE); ++ /* There's no pending inline data for this function. */ ++ DECL_PENDING_INLINE_INFO (clone) = NULL; ++ DECL_PENDING_INLINE_P (clone) = 0; ++ /* And it hasn't yet been deferred. */ ++ DECL_DEFERRED_FN (clone) = 0; ++ ++ /* The base-class destructor is not virtual. */ ++ if (name == base_dtor_identifier) ++ { ++ DECL_VIRTUAL_P (clone) = 0; ++ if (TREE_CODE (clone) != TEMPLATE_DECL) ++ DECL_VINDEX (clone) = NULL_TREE; ++ } ++ ++ /* If there was an in-charge parameter, drop it from the function ++ type. */ ++ if (DECL_HAS_IN_CHARGE_PARM_P (clone)) ++ { ++ tree basetype; ++ tree parmtypes; ++ tree exceptions; ++ ++ exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone)); ++ basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone)); ++ parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone)); ++ /* Skip the `this' parameter. */ ++ parmtypes = TREE_CHAIN (parmtypes); ++ /* Skip the in-charge parameter. */ ++ parmtypes = TREE_CHAIN (parmtypes); ++ /* And the VTT parm, in a complete [cd]tor. */ ++ if (DECL_HAS_VTT_PARM_P (fn) ++ && ! DECL_NEEDS_VTT_PARM_P (clone)) ++ parmtypes = TREE_CHAIN (parmtypes); ++ /* If this is subobject constructor or destructor, add the vtt ++ parameter. */ ++ TREE_TYPE (clone) ++ = build_method_type_directly (basetype, ++ TREE_TYPE (TREE_TYPE (clone)), ++ parmtypes); ++ if (exceptions) ++ TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), ++ exceptions); ++ TREE_TYPE (clone) ++ = cp_build_type_attribute_variant (TREE_TYPE (clone), ++ TYPE_ATTRIBUTES (TREE_TYPE (fn))); ++ } ++ ++ /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL ++ aren't function parameters; those are the template parameters. */ ++ if (TREE_CODE (clone) != TEMPLATE_DECL) ++ { ++ DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone)); ++ /* Remove the in-charge parameter. */ ++ if (DECL_HAS_IN_CHARGE_PARM_P (clone)) ++ { ++ TREE_CHAIN (DECL_ARGUMENTS (clone)) ++ = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone))); ++ DECL_HAS_IN_CHARGE_PARM_P (clone) = 0; ++ } ++ /* And the VTT parm, in a complete [cd]tor. */ ++ if (DECL_HAS_VTT_PARM_P (fn)) ++ { ++ if (DECL_NEEDS_VTT_PARM_P (clone)) ++ DECL_HAS_VTT_PARM_P (clone) = 1; ++ else ++ { ++ TREE_CHAIN (DECL_ARGUMENTS (clone)) ++ = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone))); ++ DECL_HAS_VTT_PARM_P (clone) = 0; ++ } ++ } ++ ++ for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms)) ++ { ++ DECL_CONTEXT (parms) = clone; ++ cxx_dup_lang_specific_decl (parms); ++ } ++ } ++ ++ /* Create the RTL for this function. */ ++ SET_DECL_RTL (clone, NULL_RTX); ++ rest_of_decl_compilation (clone, NULL, /*top_level=*/1, at_eof); ++ ++ /* Make it easy to find the CLONE given the FN. */ ++ TREE_CHAIN (clone) = TREE_CHAIN (fn); ++ TREE_CHAIN (fn) = clone; ++ ++ /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */ ++ if (TREE_CODE (clone) == TEMPLATE_DECL) ++ { ++ tree result; ++ ++ DECL_TEMPLATE_RESULT (clone) ++ = build_clone (DECL_TEMPLATE_RESULT (clone), name); ++ result = DECL_TEMPLATE_RESULT (clone); ++ DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result)); ++ DECL_TI_TEMPLATE (result) = clone; ++ } ++ else if (DECL_DEFERRED_FN (fn)) ++ defer_fn (clone); ++ ++ return clone; ++} ++ ++/* Produce declarations for all appropriate clones of FN. If ++ UPDATE_METHOD_VEC_P is nonzero, the clones are added to the ++ CLASTYPE_METHOD_VEC as well. */ ++ ++void ++clone_function_decl (tree fn, int update_method_vec_p) ++{ ++ tree clone; ++ ++ /* Avoid inappropriate cloning. */ ++ if (TREE_CHAIN (fn) ++ && DECL_CLONED_FUNCTION (TREE_CHAIN (fn))) ++ return; ++ ++ if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)) ++ { ++ /* For each constructor, we need two variants: an in-charge version ++ and a not-in-charge version. */ ++ clone = build_clone (fn, complete_ctor_identifier); ++ if (update_method_vec_p) ++ add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0); ++ clone = build_clone (fn, base_ctor_identifier); ++ if (update_method_vec_p) ++ add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0); ++ } ++ else ++ { ++ my_friendly_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn), 20000411); ++ ++ /* For each destructor, we need three variants: an in-charge ++ version, a not-in-charge version, and an in-charge deleting ++ version. We clone the deleting version first because that ++ means it will go second on the TYPE_METHODS list -- and that ++ corresponds to the correct layout order in the virtual ++ function table. ++ ++ For a non-virtual destructor, we do not build a deleting ++ destructor. */ ++ if (DECL_VIRTUAL_P (fn)) ++ { ++ clone = build_clone (fn, deleting_dtor_identifier); ++ if (update_method_vec_p) ++ add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0); ++ } ++ clone = build_clone (fn, complete_dtor_identifier); ++ if (update_method_vec_p) ++ add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0); ++ clone = build_clone (fn, base_dtor_identifier); ++ if (update_method_vec_p) ++ add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0); ++ } ++ ++ /* Note that this is an abstract function that is never emitted. */ ++ DECL_ABSTRACT (fn) = 1; ++} ++ ++/* DECL is an in charge constructor, which is being defined. This will ++ have had an in class declaration, from whence clones were ++ declared. An out-of-class definition can specify additional default ++ arguments. As it is the clones that are involved in overload ++ resolution, we must propagate the information from the DECL to its ++ clones. */ ++ ++void ++adjust_clone_args (tree decl) ++{ ++ tree clone; ++ ++ for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION (clone); ++ clone = TREE_CHAIN (clone)) ++ { ++ tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone)); ++ tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl)); ++ tree decl_parms, clone_parms; ++ ++ clone_parms = orig_clone_parms; ++ ++ /* Skip the 'this' parameter. */ ++ orig_clone_parms = TREE_CHAIN (orig_clone_parms); ++ orig_decl_parms = TREE_CHAIN (orig_decl_parms); ++ ++ if (DECL_HAS_IN_CHARGE_PARM_P (decl)) ++ orig_decl_parms = TREE_CHAIN (orig_decl_parms); ++ if (DECL_HAS_VTT_PARM_P (decl)) ++ orig_decl_parms = TREE_CHAIN (orig_decl_parms); ++ ++ clone_parms = orig_clone_parms; ++ if (DECL_HAS_VTT_PARM_P (clone)) ++ clone_parms = TREE_CHAIN (clone_parms); ++ ++ for (decl_parms = orig_decl_parms; decl_parms; ++ decl_parms = TREE_CHAIN (decl_parms), ++ clone_parms = TREE_CHAIN (clone_parms)) ++ { ++ my_friendly_assert (same_type_p (TREE_TYPE (decl_parms), ++ TREE_TYPE (clone_parms)), 20010424); ++ ++ if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms)) ++ { ++ /* A default parameter has been added. Adjust the ++ clone's parameters. */ ++ tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone)); ++ tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone)); ++ tree type; ++ ++ clone_parms = orig_decl_parms; ++ ++ if (DECL_HAS_VTT_PARM_P (clone)) ++ { ++ clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms), ++ TREE_VALUE (orig_clone_parms), ++ clone_parms); ++ TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms); ++ } ++ type = build_method_type_directly (basetype, ++ TREE_TYPE (TREE_TYPE (clone)), ++ clone_parms); ++ if (exceptions) ++ type = build_exception_variant (type, exceptions); ++ TREE_TYPE (clone) = type; ++ ++ clone_parms = NULL_TREE; ++ break; ++ } ++ } ++ my_friendly_assert (!clone_parms, 20010424); ++ } ++} ++ ++/* For each of the constructors and destructors in T, create an ++ in-charge and not-in-charge variant. */ ++ ++static void ++clone_constructors_and_destructors (tree t) ++{ ++ tree fns; ++ ++ /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail ++ out now. */ ++ if (!CLASSTYPE_METHOD_VEC (t)) ++ return; ++ ++ for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) ++ clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1); ++ for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns)) ++ clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1); ++} ++ ++/* Remove all zero-width bit-fields from T. */ ++ ++static void ++remove_zero_width_bit_fields (tree t) ++{ ++ tree *fieldsp; ++ ++ fieldsp = &TYPE_FIELDS (t); ++ while (*fieldsp) ++ { ++ if (TREE_CODE (*fieldsp) == FIELD_DECL ++ && DECL_C_BIT_FIELD (*fieldsp) ++ && DECL_INITIAL (*fieldsp)) ++ *fieldsp = TREE_CHAIN (*fieldsp); ++ else ++ fieldsp = &TREE_CHAIN (*fieldsp); ++ } ++} ++ ++/* Returns TRUE iff we need a cookie when dynamically allocating an ++ array whose elements have the indicated class TYPE. */ ++ ++static bool ++type_requires_array_cookie (tree type) ++{ ++ tree fns; ++ bool has_two_argument_delete_p = false; ++ ++ my_friendly_assert (CLASS_TYPE_P (type), 20010712); ++ ++ /* If there's a non-trivial destructor, we need a cookie. In order ++ to iterate through the array calling the destructor for each ++ element, we'll have to know how many elements there are. */ ++ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) ++ return true; ++ ++ /* If the usual deallocation function is a two-argument whose second ++ argument is of type `size_t', then we have to pass the size of ++ the array to the deallocation function, so we will need to store ++ a cookie. */ ++ fns = lookup_fnfields (TYPE_BINFO (type), ++ ansi_opname (VEC_DELETE_EXPR), ++ /*protect=*/0); ++ /* If there are no `operator []' members, or the lookup is ++ ambiguous, then we don't need a cookie. */ ++ if (!fns || fns == error_mark_node) ++ return false; ++ /* Loop through all of the functions. */ ++ for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns)) ++ { ++ tree fn; ++ tree second_parm; ++ ++ /* Select the current function. */ ++ fn = OVL_CURRENT (fns); ++ /* See if this function is a one-argument delete function. If ++ it is, then it will be the usual deallocation function. */ ++ second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn))); ++ if (second_parm == void_list_node) ++ return false; ++ /* Otherwise, if we have a two-argument function and the second ++ argument is `size_t', it will be the usual deallocation ++ function -- unless there is one-argument function, too. */ ++ if (TREE_CHAIN (second_parm) == void_list_node ++ && same_type_p (TREE_VALUE (second_parm), sizetype)) ++ has_two_argument_delete_p = true; ++ } ++ ++ return has_two_argument_delete_p; ++} ++ ++/* Check the validity of the bases and members declared in T. Add any ++ implicitly-generated functions (like copy-constructors and ++ assignment operators). Compute various flag bits (like ++ CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++ ++ level: i.e., independently of the ABI in use. */ ++ ++static void ++check_bases_and_members (tree t) ++{ ++ /* Nonzero if we are not allowed to generate a default constructor ++ for this case. */ ++ int cant_have_default_ctor; ++ /* Nonzero if the implicitly generated copy constructor should take ++ a non-const reference argument. */ ++ int cant_have_const_ctor; ++ /* Nonzero if the the implicitly generated assignment operator ++ should take a non-const reference argument. */ ++ int no_const_asn_ref; ++ tree access_decls; ++ ++ /* By default, we use const reference arguments and generate default ++ constructors. */ ++ cant_have_default_ctor = 0; ++ cant_have_const_ctor = 0; ++ no_const_asn_ref = 0; ++ ++ /* Check all the base-classes. */ ++ check_bases (t, &cant_have_default_ctor, &cant_have_const_ctor, ++ &no_const_asn_ref); ++ ++ /* Check all the data member declarations. */ ++ check_field_decls (t, &access_decls, ++ &cant_have_default_ctor, ++ &cant_have_const_ctor, ++ &no_const_asn_ref); ++ ++ /* Check all the method declarations. */ ++ check_methods (t); ++ ++ /* A nearly-empty class has to be vptr-containing; a nearly empty ++ class contains just a vptr. */ ++ if (!TYPE_CONTAINS_VPTR_P (t)) ++ CLASSTYPE_NEARLY_EMPTY_P (t) = 0; ++ ++ /* Do some bookkeeping that will guide the generation of implicitly ++ declared member functions. */ ++ TYPE_HAS_COMPLEX_INIT_REF (t) ++ |= (TYPE_HAS_INIT_REF (t) ++ || TYPE_USES_VIRTUAL_BASECLASSES (t) ++ || TYPE_POLYMORPHIC_P (t)); ++ TYPE_NEEDS_CONSTRUCTING (t) ++ |= (TYPE_HAS_CONSTRUCTOR (t) ++ || TYPE_USES_VIRTUAL_BASECLASSES (t) ++ || TYPE_POLYMORPHIC_P (t)); ++ CLASSTYPE_NON_AGGREGATE (t) |= (TYPE_HAS_CONSTRUCTOR (t) ++ || TYPE_POLYMORPHIC_P (t)); ++ CLASSTYPE_NON_POD_P (t) ++ |= (CLASSTYPE_NON_AGGREGATE (t) || TYPE_HAS_DESTRUCTOR (t) ++ || TYPE_HAS_ASSIGN_REF (t)); ++ TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t); ++ TYPE_HAS_COMPLEX_ASSIGN_REF (t) ++ |= TYPE_HAS_ASSIGN_REF (t) || TYPE_CONTAINS_VPTR_P (t); ++ ++ /* Synthesize any needed methods. Note that methods will be synthesized ++ for anonymous unions; grok_x_components undoes that. */ ++ add_implicitly_declared_members (t, cant_have_default_ctor, ++ cant_have_const_ctor, ++ no_const_asn_ref); ++ ++ /* Create the in-charge and not-in-charge variants of constructors ++ and destructors. */ ++ clone_constructors_and_destructors (t); ++ ++ /* Process the using-declarations. */ ++ for (; access_decls; access_decls = TREE_CHAIN (access_decls)) ++ handle_using_decl (TREE_VALUE (access_decls), t); ++ ++ /* Build and sort the CLASSTYPE_METHOD_VEC. */ ++ finish_struct_methods (t); ++ ++ /* Figure out whether or not we will need a cookie when dynamically ++ allocating an array of this type. */ ++ TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie ++ = type_requires_array_cookie (t); ++} ++ ++/* If T needs a pointer to its virtual function table, set TYPE_VFIELD ++ accordingly. If a new vfield was created (because T doesn't have a ++ primary base class), then the newly created field is returned. It ++ is not added to the TYPE_FIELDS list; it is the caller's ++ responsibility to do that. Accumulate declared virtual functions ++ on VIRTUALS_P. */ ++ ++static tree ++create_vtable_ptr (tree t, tree* virtuals_p) ++{ ++ tree fn; ++ ++ /* Collect the virtual functions declared in T. */ ++ for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn)) ++ if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn) ++ && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST) ++ { ++ tree new_virtual = make_node (TREE_LIST); ++ ++ BV_FN (new_virtual) = fn; ++ BV_DELTA (new_virtual) = integer_zero_node; ++ ++ TREE_CHAIN (new_virtual) = *virtuals_p; ++ *virtuals_p = new_virtual; ++ } ++ ++ /* If we couldn't find an appropriate base class, create a new field ++ here. Even if there weren't any new virtual functions, we might need a ++ new virtual function table if we're supposed to include vptrs in ++ all classes that need them. */ ++ if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t))) ++ { ++ /* We build this decl with vtbl_ptr_type_node, which is a ++ `vtable_entry_type*'. It might seem more precise to use ++ `vtable_entry_type (*)[N]' where N is the number of firtual ++ functions. However, that would require the vtable pointer in ++ base classes to have a different type than the vtable pointer ++ in derived classes. We could make that happen, but that ++ still wouldn't solve all the problems. In particular, the ++ type-based alias analysis code would decide that assignments ++ to the base class vtable pointer can't alias assignments to ++ the derived class vtable pointer, since they have different ++ types. Thus, in a derived class destructor, where the base ++ class constructor was inlined, we could generate bad code for ++ setting up the vtable pointer. ++ ++ Therefore, we use one type for all vtable pointers. We still ++ use a type-correct type; it's just doesn't indicate the array ++ bounds. That's better than using `void*' or some such; it's ++ cleaner, and it let's the alias analysis code know that these ++ stores cannot alias stores to void*! */ ++ tree field; ++ ++ field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node); ++ SET_DECL_ASSEMBLER_NAME (field, get_identifier (VFIELD_BASE)); ++ DECL_VIRTUAL_P (field) = 1; ++ DECL_ARTIFICIAL (field) = 1; ++ DECL_FIELD_CONTEXT (field) = t; ++ DECL_FCONTEXT (field) = t; ++ ++ TYPE_VFIELD (t) = field; ++ ++ /* This class is non-empty. */ ++ CLASSTYPE_EMPTY_P (t) = 0; ++ ++ if (CLASSTYPE_N_BASECLASSES (t)) ++ /* If there were any baseclasses, they can't possibly be at ++ offset zero any more, because that's where the vtable ++ pointer is. So, converting to a base class is going to ++ take work. */ ++ TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t) = 1; ++ ++ return field; ++ } ++ ++ return NULL_TREE; ++} ++ ++/* Fixup the inline function given by INFO now that the class is ++ complete. */ ++ ++static void ++fixup_pending_inline (tree fn) ++{ ++ if (DECL_PENDING_INLINE_INFO (fn)) ++ { ++ tree args = DECL_ARGUMENTS (fn); ++ while (args) ++ { ++ DECL_CONTEXT (args) = fn; ++ args = TREE_CHAIN (args); ++ } ++ } ++} ++ ++/* Fixup the inline methods and friends in TYPE now that TYPE is ++ complete. */ ++ ++static void ++fixup_inline_methods (tree type) ++{ ++ tree method = TYPE_METHODS (type); ++ ++ if (method && TREE_CODE (method) == TREE_VEC) ++ { ++ if (TREE_VEC_ELT (method, 1)) ++ method = TREE_VEC_ELT (method, 1); ++ else if (TREE_VEC_ELT (method, 0)) ++ method = TREE_VEC_ELT (method, 0); ++ else ++ method = TREE_VEC_ELT (method, 2); ++ } ++ ++ /* Do inline member functions. */ ++ for (; method; method = TREE_CHAIN (method)) ++ fixup_pending_inline (method); ++ ++ /* Do friends. */ ++ for (method = CLASSTYPE_INLINE_FRIENDS (type); ++ method; ++ method = TREE_CHAIN (method)) ++ fixup_pending_inline (TREE_VALUE (method)); ++ CLASSTYPE_INLINE_FRIENDS (type) = NULL_TREE; ++} ++ ++/* Add OFFSET to all base types of BINFO which is a base in the ++ hierarchy dominated by T. ++ ++ OFFSET, which is a type offset, is number of bytes. */ ++ ++static void ++propagate_binfo_offsets (tree binfo, tree offset) ++{ ++ int i; ++ tree primary_binfo; ++ ++ /* Update BINFO's offset. */ ++ BINFO_OFFSET (binfo) ++ = convert (sizetype, ++ size_binop (PLUS_EXPR, ++ convert (ssizetype, BINFO_OFFSET (binfo)), ++ offset)); ++ ++ /* Find the primary base class. */ ++ primary_binfo = get_primary_binfo (binfo); ++ ++ /* Scan all of the bases, pushing the BINFO_OFFSET adjust ++ downwards. */ ++ for (i = -1; i < BINFO_N_BASETYPES (binfo); ++i) ++ { ++ tree base_binfo; ++ ++ /* On the first time through the loop, do the primary base. ++ Because the primary base need not be an immediate base, we ++ must handle the primary base specially. */ ++ if (i == -1) ++ { ++ if (!primary_binfo) ++ continue; ++ ++ base_binfo = primary_binfo; ++ } ++ else ++ { ++ base_binfo = BINFO_BASETYPE (binfo, i); ++ /* Don't do the primary base twice. */ ++ if (base_binfo == primary_binfo) ++ continue; ++ } ++ ++ /* Skip virtual bases that aren't our canonical primary base. */ ++ if (TREE_VIA_VIRTUAL (base_binfo) ++ && BINFO_PRIMARY_BASE_OF (base_binfo) != binfo) ++ continue; ++ ++ propagate_binfo_offsets (base_binfo, offset); ++ } ++} ++ ++/* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update ++ TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of ++ empty subobjects of T. */ ++ ++static void ++layout_virtual_bases (record_layout_info rli, splay_tree offsets) ++{ ++ tree vbase; ++ tree t = rli->t; ++ bool first_vbase = true; ++ tree *next_field; ++ ++ if (CLASSTYPE_N_BASECLASSES (t) == 0) ++ return; ++ ++ if (!abi_version_at_least(2)) ++ { ++ /* In G++ 3.2, we incorrectly rounded the size before laying out ++ the virtual bases. */ ++ finish_record_layout (rli, /*free_p=*/false); ++#ifdef STRUCTURE_SIZE_BOUNDARY ++ /* Packed structures don't need to have minimum size. */ ++ if (! TYPE_PACKED (t)) ++ TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY); ++#endif ++ rli->offset = TYPE_SIZE_UNIT (t); ++ rli->bitpos = bitsize_zero_node; ++ rli->record_align = TYPE_ALIGN (t); ++ } ++ ++ /* Find the last field. The artificial fields created for virtual ++ bases will go after the last extant field to date. */ ++ next_field = &TYPE_FIELDS (t); ++ while (*next_field) ++ next_field = &TREE_CHAIN (*next_field); ++ ++ /* Go through the virtual bases, allocating space for each virtual ++ base that is not already a primary base class. These are ++ allocated in inheritance graph order. */ ++ for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase)) ++ { ++ if (!TREE_VIA_VIRTUAL (vbase)) ++ continue; ++ ++ if (!BINFO_PRIMARY_P (vbase)) ++ { ++ tree basetype = TREE_TYPE (vbase); ++ ++ /* This virtual base is not a primary base of any class in the ++ hierarchy, so we have to add space for it. */ ++ next_field = build_base_field (rli, vbase, ++ offsets, next_field); ++ ++ /* If the first virtual base might have been placed at a ++ lower address, had we started from CLASSTYPE_SIZE, rather ++ than TYPE_SIZE, issue a warning. There can be both false ++ positives and false negatives from this warning in rare ++ cases; to deal with all the possibilities would probably ++ require performing both layout algorithms and comparing ++ the results which is not particularly tractable. */ ++ if (warn_abi ++ && first_vbase ++ && (tree_int_cst_lt ++ (size_binop (CEIL_DIV_EXPR, ++ round_up (CLASSTYPE_SIZE (t), ++ CLASSTYPE_ALIGN (basetype)), ++ bitsize_unit_node), ++ BINFO_OFFSET (vbase)))) ++ warning ("offset of virtual base `%T' is not ABI-compliant and may change in a future version of GCC", ++ basetype); ++ ++ first_vbase = false; ++ } ++ } ++} ++ ++/* Returns the offset of the byte just past the end of the base class ++ BINFO. */ ++ ++static tree ++end_of_base (tree binfo) ++{ ++ tree size; ++ ++ if (is_empty_class (BINFO_TYPE (binfo))) ++ /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to ++ allocate some space for it. It cannot have virtual bases, so ++ TYPE_SIZE_UNIT is fine. */ ++ size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo)); ++ else ++ size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo)); ++ ++ return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size); ++} ++ ++/* Returns the offset of the byte just past the end of the base class ++ with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then ++ only non-virtual bases are included. */ ++ ++static tree ++end_of_class (tree t, int include_virtuals_p) ++{ ++ tree result = size_zero_node; ++ tree binfo; ++ tree offset; ++ int i; ++ ++ for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i) ++ { ++ binfo = BINFO_BASETYPE (TYPE_BINFO (t), i); ++ ++ if (!include_virtuals_p ++ && TREE_VIA_VIRTUAL (binfo) ++ && BINFO_PRIMARY_BASE_OF (binfo) != TYPE_BINFO (t)) ++ continue; ++ ++ offset = end_of_base (binfo); ++ if (INT_CST_LT_UNSIGNED (result, offset)) ++ result = offset; ++ } ++ ++ /* G++ 3.2 did not check indirect virtual bases. */ ++ if (abi_version_at_least (2) && include_virtuals_p) ++ for (binfo = CLASSTYPE_VBASECLASSES (t); ++ binfo; ++ binfo = TREE_CHAIN (binfo)) ++ { ++ offset = end_of_base (TREE_VALUE (binfo)); ++ if (INT_CST_LT_UNSIGNED (result, offset)) ++ result = offset; ++ } ++ ++ return result; ++} ++ ++/* Warn about bases of T that are inaccessible because they are ++ ambiguous. For example: ++ ++ struct S {}; ++ struct T : public S {}; ++ struct U : public S, public T {}; ++ ++ Here, `(S*) new U' is not allowed because there are two `S' ++ subobjects of U. */ ++ ++static void ++warn_about_ambiguous_bases (tree t) ++{ ++ int i; ++ tree vbases; ++ tree basetype; ++ ++ /* Check direct bases. */ ++ for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i) ++ { ++ basetype = TYPE_BINFO_BASETYPE (t, i); ++ ++ if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL)) ++ warning ("direct base `%T' inaccessible in `%T' due to ambiguity", ++ basetype, t); ++ } ++ ++ /* Check for ambiguous virtual bases. */ ++ if (extra_warnings) ++ for (vbases = CLASSTYPE_VBASECLASSES (t); ++ vbases; ++ vbases = TREE_CHAIN (vbases)) ++ { ++ basetype = BINFO_TYPE (TREE_VALUE (vbases)); ++ ++ if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL)) ++ warning ("virtual base `%T' inaccessible in `%T' due to ambiguity", ++ basetype, t); ++ } ++} ++ ++/* Compare two INTEGER_CSTs K1 and K2. */ ++ ++static int ++splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2) ++{ ++ return tree_int_cst_compare ((tree) k1, (tree) k2); ++} ++ ++/* Increase the size indicated in RLI to account for empty classes ++ that are "off the end" of the class. */ ++ ++static void ++include_empty_classes (record_layout_info rli) ++{ ++ tree eoc; ++ tree rli_size; ++ ++ /* It might be the case that we grew the class to allocate a ++ zero-sized base class. That won't be reflected in RLI, yet, ++ because we are willing to overlay multiple bases at the same ++ offset. However, now we need to make sure that RLI is big enough ++ to reflect the entire class. */ ++ eoc = end_of_class (rli->t, ++ CLASSTYPE_AS_BASE (rli->t) != NULL_TREE); ++ rli_size = rli_size_unit_so_far (rli); ++ if (TREE_CODE (rli_size) == INTEGER_CST ++ && INT_CST_LT_UNSIGNED (rli_size, eoc)) ++ { ++ if (!abi_version_at_least (2)) ++ /* In version 1 of the ABI, the size of a class that ends with ++ a bitfield was not rounded up to a whole multiple of a ++ byte. Because rli_size_unit_so_far returns only the number ++ of fully allocated bytes, any extra bits were not included ++ in the size. */ ++ rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT); ++ else ++ /* The size should have been rounded to a whole byte. */ ++ my_friendly_assert (tree_int_cst_equal (rli->bitpos, ++ round_down (rli->bitpos, ++ BITS_PER_UNIT)), ++ 20030903); ++ rli->bitpos ++ = size_binop (PLUS_EXPR, ++ rli->bitpos, ++ size_binop (MULT_EXPR, ++ convert (bitsizetype, ++ size_binop (MINUS_EXPR, ++ eoc, rli_size)), ++ bitsize_int (BITS_PER_UNIT))); ++ normalize_rli (rli); ++ } ++} ++ ++/* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate ++ BINFO_OFFSETs for all of the base-classes. Position the vtable ++ pointer. Accumulate declared virtual functions on VIRTUALS_P. */ ++ ++static void ++layout_class_type (tree t, tree *virtuals_p) ++{ ++ tree non_static_data_members; ++ tree field; ++ tree vptr; ++ record_layout_info rli; ++ /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of ++ types that appear at that offset. */ ++ splay_tree empty_base_offsets; ++ /* True if the last field layed out was a bit-field. */ ++ bool last_field_was_bitfield = false; ++ /* The location at which the next field should be inserted. */ ++ tree *next_field; ++ /* T, as a base class. */ ++ tree base_t; ++ ++ /* Keep track of the first non-static data member. */ ++ non_static_data_members = TYPE_FIELDS (t); ++ ++ /* Start laying out the record. */ ++ rli = start_record_layout (t); ++ ++ /* If possible, we reuse the virtual function table pointer from one ++ of our base classes. */ ++ determine_primary_base (t); ++ ++ /* Create a pointer to our virtual function table. */ ++ vptr = create_vtable_ptr (t, virtuals_p); ++ ++ /* The vptr is always the first thing in the class. */ ++ if (vptr) ++ { ++ TREE_CHAIN (vptr) = TYPE_FIELDS (t); ++ TYPE_FIELDS (t) = vptr; ++ next_field = &TREE_CHAIN (vptr); ++ place_field (rli, vptr); ++ } ++ else ++ next_field = &TYPE_FIELDS (t); ++ ++ /* Build FIELD_DECLs for all of the non-virtual base-types. */ ++ empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts, ++ NULL, NULL); ++ build_base_fields (rli, empty_base_offsets, next_field); ++ ++ /* Layout the non-static data members. */ ++ for (field = non_static_data_members; field; field = TREE_CHAIN (field)) ++ { ++ tree type; ++ tree padding; ++ ++ /* We still pass things that aren't non-static data members to ++ the back-end, in case it wants to do something with them. */ ++ if (TREE_CODE (field) != FIELD_DECL) ++ { ++ place_field (rli, field); ++ /* If the static data member has incomplete type, keep track ++ of it so that it can be completed later. (The handling ++ of pending statics in finish_record_layout is ++ insufficient; consider: ++ ++ struct S1; ++ struct S2 { static S1 s1; }; ++ ++ At this point, finish_record_layout will be called, but ++ S1 is still incomplete.) */ ++ if (TREE_CODE (field) == VAR_DECL) ++ maybe_register_incomplete_var (field); ++ continue; ++ } ++ ++ type = TREE_TYPE (field); ++ ++ padding = NULL_TREE; ++ ++ /* If this field is a bit-field whose width is greater than its ++ type, then there are some special rules for allocating ++ it. */ ++ if (DECL_C_BIT_FIELD (field) ++ && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field))) ++ { ++ integer_type_kind itk; ++ tree integer_type; ++ bool was_unnamed_p = false; ++ /* We must allocate the bits as if suitably aligned for the ++ longest integer type that fits in this many bits. type ++ of the field. Then, we are supposed to use the left over ++ bits as additional padding. */ ++ for (itk = itk_char; itk != itk_none; ++itk) ++ if (INT_CST_LT (DECL_SIZE (field), ++ TYPE_SIZE (integer_types[itk]))) ++ break; ++ ++ /* ITK now indicates a type that is too large for the ++ field. We have to back up by one to find the largest ++ type that fits. */ ++ integer_type = integer_types[itk - 1]; ++ ++ /* Figure out how much additional padding is required. GCC ++ 3.2 always created a padding field, even if it had zero ++ width. */ ++ if (!abi_version_at_least (2) ++ || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field))) ++ { ++ if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE) ++ /* In a union, the padding field must have the full width ++ of the bit-field; all fields start at offset zero. */ ++ padding = DECL_SIZE (field); ++ else ++ { ++ if (warn_abi && TREE_CODE (t) == UNION_TYPE) ++ warning ("size assigned to `%T' may not be " ++ "ABI-compliant and may change in a future " ++ "version of GCC", ++ t); ++ padding = size_binop (MINUS_EXPR, DECL_SIZE (field), ++ TYPE_SIZE (integer_type)); ++ } ++ } ++#ifdef PCC_BITFIELD_TYPE_MATTERS ++ /* An unnamed bitfield does not normally affect the ++ alignment of the containing class on a target where ++ PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not ++ make any exceptions for unnamed bitfields when the ++ bitfields are longer than their types. Therefore, we ++ temporarily give the field a name. */ ++ if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field)) ++ { ++ was_unnamed_p = true; ++ DECL_NAME (field) = make_anon_name (); ++ } ++#endif ++ DECL_SIZE (field) = TYPE_SIZE (integer_type); ++ DECL_ALIGN (field) = TYPE_ALIGN (integer_type); ++ DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type); ++ layout_nonempty_base_or_field (rli, field, NULL_TREE, ++ empty_base_offsets); ++ if (was_unnamed_p) ++ DECL_NAME (field) = NULL_TREE; ++ /* Now that layout has been performed, set the size of the ++ field to the size of its declared type; the rest of the ++ field is effectively invisible. */ ++ DECL_SIZE (field) = TYPE_SIZE (type); ++ /* We must also reset the DECL_MODE of the field. */ ++ if (abi_version_at_least (2)) ++ DECL_MODE (field) = TYPE_MODE (type); ++ else if (warn_abi ++ && DECL_MODE (field) != TYPE_MODE (type)) ++ /* Versions of G++ before G++ 3.4 did not reset the ++ DECL_MODE. */ ++ warning ("the offset of `%D' may not be ABI-compliant and may " ++ "change in a future version of GCC", field); ++ } ++ else ++ layout_nonempty_base_or_field (rli, field, NULL_TREE, ++ empty_base_offsets); ++ ++ /* Remember the location of any empty classes in FIELD. */ ++ if (abi_version_at_least (2)) ++ record_subobject_offsets (TREE_TYPE (field), ++ byte_position(field), ++ empty_base_offsets, ++ /*vbases_p=*/1); ++ ++ /* If a bit-field does not immediately follow another bit-field, ++ and yet it starts in the middle of a byte, we have failed to ++ comply with the ABI. */ ++ if (warn_abi ++ && DECL_C_BIT_FIELD (field) ++ && !last_field_was_bitfield ++ && !integer_zerop (size_binop (TRUNC_MOD_EXPR, ++ DECL_FIELD_BIT_OFFSET (field), ++ bitsize_unit_node))) ++ cp_warning_at ("offset of `%D' is not ABI-compliant and may change in a future version of GCC", ++ field); ++ ++ /* G++ used to use DECL_FIELD_OFFSET as if it were the byte ++ offset of the field. */ ++ if (warn_abi ++ && !tree_int_cst_equal (DECL_FIELD_OFFSET (field), ++ byte_position (field)) ++ && contains_empty_class_p (TREE_TYPE (field))) ++ cp_warning_at ("`%D' contains empty classes which may cause base " ++ "classes to be placed at different locations in a " ++ "future version of GCC", ++ field); ++ ++ /* If we needed additional padding after this field, add it ++ now. */ ++ if (padding) ++ { ++ tree padding_field; ++ ++ padding_field = build_decl (FIELD_DECL, ++ NULL_TREE, ++ char_type_node); ++ DECL_BIT_FIELD (padding_field) = 1; ++ DECL_SIZE (padding_field) = padding; ++ DECL_CONTEXT (padding_field) = t; ++ DECL_ARTIFICIAL (padding_field) = 1; ++ layout_nonempty_base_or_field (rli, padding_field, ++ NULL_TREE, ++ empty_base_offsets); ++ } ++ ++ last_field_was_bitfield = DECL_C_BIT_FIELD (field); ++ } ++ ++ if (abi_version_at_least (2) && !integer_zerop (rli->bitpos)) ++ { ++ /* Make sure that we are on a byte boundary so that the size of ++ the class without virtual bases will always be a round number ++ of bytes. */ ++ rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT); ++ normalize_rli (rli); ++ } ++ ++ /* G++ 3.2 does not allow virtual bases to be overlaid with tail ++ padding. */ ++ if (!abi_version_at_least (2)) ++ include_empty_classes(rli); ++ ++ /* Delete all zero-width bit-fields from the list of fields. Now ++ that the type is laid out they are no longer important. */ ++ remove_zero_width_bit_fields (t); ++ ++ /* Create the version of T used for virtual bases. We do not use ++ make_aggr_type for this version; this is an artificial type. For ++ a POD type, we just reuse T. */ ++ if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t)) ++ { ++ base_t = make_node (TREE_CODE (t)); ++ ++ /* Set the size and alignment for the new type. In G++ 3.2, all ++ empty classes were considered to have size zero when used as ++ base classes. */ ++ if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t)) ++ { ++ TYPE_SIZE (base_t) = bitsize_zero_node; ++ TYPE_SIZE_UNIT (base_t) = size_zero_node; ++ if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli))) ++ warning ("layout of classes derived from empty class `%T' " ++ "may change in a future version of GCC", ++ t); ++ } ++ else ++ { ++ tree eoc; ++ ++ /* If the ABI version is not at least two, and the last ++ field was a bit-field, RLI may not be on a byte ++ boundary. In particular, rli_size_unit_so_far might ++ indicate the last complete byte, while rli_size_so_far ++ indicates the total number of bits used. Therefore, ++ rli_size_so_far, rather than rli_size_unit_so_far, is ++ used to compute TYPE_SIZE_UNIT. */ ++ eoc = end_of_class (t, /*include_virtuals_p=*/0); ++ TYPE_SIZE_UNIT (base_t) ++ = size_binop (MAX_EXPR, ++ convert (sizetype, ++ size_binop (CEIL_DIV_EXPR, ++ rli_size_so_far (rli), ++ bitsize_int (BITS_PER_UNIT))), ++ eoc); ++ TYPE_SIZE (base_t) ++ = size_binop (MAX_EXPR, ++ rli_size_so_far (rli), ++ size_binop (MULT_EXPR, ++ convert (bitsizetype, eoc), ++ bitsize_int (BITS_PER_UNIT))); ++ } ++ TYPE_ALIGN (base_t) = rli->record_align; ++ TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t); ++ ++ /* Copy the fields from T. */ ++ next_field = &TYPE_FIELDS (base_t); ++ for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) ++ if (TREE_CODE (field) == FIELD_DECL) ++ { ++ *next_field = build_decl (FIELD_DECL, ++ DECL_NAME (field), ++ TREE_TYPE (field)); ++ DECL_CONTEXT (*next_field) = base_t; ++ DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field); ++ DECL_FIELD_BIT_OFFSET (*next_field) ++ = DECL_FIELD_BIT_OFFSET (field); ++ DECL_SIZE (*next_field) = DECL_SIZE (field); ++ DECL_MODE (*next_field) = DECL_MODE (field); ++ next_field = &TREE_CHAIN (*next_field); ++ } ++ ++ /* Record the base version of the type. */ ++ CLASSTYPE_AS_BASE (t) = base_t; ++ TYPE_CONTEXT (base_t) = t; ++ } ++ else ++ CLASSTYPE_AS_BASE (t) = t; ++ ++ /* Every empty class contains an empty class. */ ++ if (CLASSTYPE_EMPTY_P (t)) ++ CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1; ++ ++ /* Set the TYPE_DECL for this type to contain the right ++ value for DECL_OFFSET, so that we can use it as part ++ of a COMPONENT_REF for multiple inheritance. */ ++ layout_decl (TYPE_MAIN_DECL (t), 0); ++ ++ /* Now fix up any virtual base class types that we left lying ++ around. We must get these done before we try to lay out the ++ virtual function table. As a side-effect, this will remove the ++ base subobject fields. */ ++ layout_virtual_bases (rli, empty_base_offsets); ++ ++ /* Make sure that empty classes are reflected in RLI at this ++ point. */ ++ include_empty_classes(rli); ++ ++ /* Make sure not to create any structures with zero size. */ ++ if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t)) ++ place_field (rli, ++ build_decl (FIELD_DECL, NULL_TREE, char_type_node)); ++ ++ /* Let the back-end lay out the type. */ ++ finish_record_layout (rli, /*free_p=*/true); ++ ++ /* Warn about bases that can't be talked about due to ambiguity. */ ++ warn_about_ambiguous_bases (t); ++ ++ /* Clean up. */ ++ splay_tree_delete (empty_base_offsets); ++} ++ ++/* Returns the virtual function with which the vtable for TYPE is ++ emitted, or NULL_TREE if that heuristic is not applicable to TYPE. */ ++ ++static tree ++key_method (tree type) ++{ ++ tree method; ++ ++ if (TYPE_FOR_JAVA (type) ++ || processing_template_decl ++ || CLASSTYPE_TEMPLATE_INSTANTIATION (type) ++ || CLASSTYPE_INTERFACE_KNOWN (type)) ++ return NULL_TREE; ++ ++ for (method = TYPE_METHODS (type); method != NULL_TREE; ++ method = TREE_CHAIN (method)) ++ if (DECL_VINDEX (method) != NULL_TREE ++ && ! DECL_DECLARED_INLINE_P (method) ++ && ! DECL_PURE_VIRTUAL_P (method)) ++ return method; ++ ++ return NULL_TREE; ++} ++ ++/* Perform processing required when the definition of T (a class type) ++ is complete. */ ++ ++void ++finish_struct_1 (tree t) ++{ ++ tree x; ++ /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */ ++ tree virtuals = NULL_TREE; ++ int n_fields = 0; ++ tree vfield; ++ ++ if (COMPLETE_TYPE_P (t)) ++ { ++ if (IS_AGGR_TYPE (t)) ++ error ("redefinition of `%#T'", t); ++ else ++ abort (); ++ popclass (); ++ return; ++ } ++ ++ /* If this type was previously laid out as a forward reference, ++ make sure we lay it out again. */ ++ TYPE_SIZE (t) = NULL_TREE; ++ CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE; ++ ++ fixup_inline_methods (t); ++ ++ /* Make assumptions about the class; we'll reset the flags if ++ necessary. */ ++ CLASSTYPE_EMPTY_P (t) = 1; ++ CLASSTYPE_NEARLY_EMPTY_P (t) = 1; ++ CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0; ++ ++ /* Do end-of-class semantic processing: checking the validity of the ++ bases and members and add implicitly generated methods. */ ++ check_bases_and_members (t); ++ ++ /* Find the key method. */ ++ if (TYPE_CONTAINS_VPTR_P (t)) ++ { ++ CLASSTYPE_KEY_METHOD (t) = key_method (t); ++ ++ /* If a polymorphic class has no key method, we may emit the vtable ++ in every translation unit where the class definition appears. */ ++ if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE) ++ keyed_classes = tree_cons (NULL_TREE, t, keyed_classes); ++ } ++ ++ /* Layout the class itself. */ ++ layout_class_type (t, &virtuals); ++ if (CLASSTYPE_AS_BASE (t) != t) ++ /* We use the base type for trivial assignments, and hence it ++ needs a mode. */ ++ compute_record_mode (CLASSTYPE_AS_BASE (t)); ++ ++ /* Make sure that we get our own copy of the vfield FIELD_DECL. */ ++ vfield = TYPE_VFIELD (t); ++ if (vfield && CLASSTYPE_HAS_PRIMARY_BASE_P (t)) ++ { ++ tree primary = CLASSTYPE_PRIMARY_BINFO (t); ++ ++ my_friendly_assert (same_type_p (DECL_FIELD_CONTEXT (vfield), ++ BINFO_TYPE (primary)), ++ 20010726); ++ /* The vtable better be at the start. */ ++ my_friendly_assert (integer_zerop (DECL_FIELD_OFFSET (vfield)), ++ 20010726); ++ my_friendly_assert (integer_zerop (BINFO_OFFSET (primary)), ++ 20010726); ++ ++ vfield = copy_decl (vfield); ++ DECL_FIELD_CONTEXT (vfield) = t; ++ TYPE_VFIELD (t) = vfield; ++ } ++ else ++ my_friendly_assert (!vfield || DECL_FIELD_CONTEXT (vfield) == t, 20010726); ++ ++ virtuals = modify_all_vtables (t, nreverse (virtuals)); ++ ++ /* If we created a new vtbl pointer for this class, add it to the ++ list. */ ++ if (TYPE_VFIELD (t) && !CLASSTYPE_HAS_PRIMARY_BASE_P (t)) ++ CLASSTYPE_VFIELDS (t) ++ = chainon (CLASSTYPE_VFIELDS (t), build_tree_list (NULL_TREE, t)); ++ ++ /* If necessary, create the primary vtable for this class. */ ++ if (virtuals || TYPE_CONTAINS_VPTR_P (t)) ++ { ++ /* We must enter these virtuals into the table. */ ++ if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) ++ build_primary_vtable (NULL_TREE, t); ++ else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t))) ++ /* Here we know enough to change the type of our virtual ++ function table, but we will wait until later this function. */ ++ build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t); ++ } ++ ++ if (TYPE_CONTAINS_VPTR_P (t)) ++ { ++ int vindex; ++ tree fn; ++ ++ if (TYPE_BINFO_VTABLE (t)) ++ my_friendly_assert (DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)), ++ 20000116); ++ if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) ++ my_friendly_assert (TYPE_BINFO_VIRTUALS (t) == NULL_TREE, ++ 20000116); ++ ++ /* Add entries for virtual functions introduced by this class. */ ++ TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t), virtuals); ++ ++ /* Set DECL_VINDEX for all functions declared in this class. */ ++ for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t)); ++ fn; ++ fn = TREE_CHAIN (fn), ++ vindex += (TARGET_VTABLE_USES_DESCRIPTORS ++ ? TARGET_VTABLE_USES_DESCRIPTORS : 1)) ++ { ++ tree fndecl = BV_FN (fn); ++ ++ if (DECL_THUNK_P (fndecl)) ++ /* A thunk. We should never be calling this entry directly ++ from this vtable -- we'd use the entry for the non ++ thunk base function. */ ++ DECL_VINDEX (fndecl) = NULL_TREE; ++ else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST) ++ DECL_VINDEX (fndecl) = build_shared_int_cst (vindex); ++ } ++ } ++ ++ finish_struct_bits (t); ++ ++ /* Complete the rtl for any static member objects of the type we're ++ working on. */ ++ for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x)) ++ if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x) ++ && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t)) ++ DECL_MODE (x) = TYPE_MODE (t); ++ ++ /* Done with FIELDS...now decide whether to sort these for ++ faster lookups later. ++ ++ We use a small number because most searches fail (succeeding ++ ultimately as the search bores through the inheritance ++ hierarchy), and we want this failure to occur quickly. */ ++ ++ n_fields = count_fields (TYPE_FIELDS (t)); ++ if (n_fields > 7) ++ { ++ struct sorted_fields_type *field_vec = ggc_alloc (sizeof (struct sorted_fields_type) ++ + n_fields * sizeof (tree)); ++ field_vec->len = n_fields; ++ add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0); ++ qsort (field_vec->elts, n_fields, sizeof (tree), ++ field_decl_cmp); ++ if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t))) ++ retrofit_lang_decl (TYPE_MAIN_DECL (t)); ++ DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec; ++ } ++ ++ if (TYPE_HAS_CONSTRUCTOR (t)) ++ { ++ tree vfields = CLASSTYPE_VFIELDS (t); ++ ++ for (vfields = CLASSTYPE_VFIELDS (t); ++ vfields; vfields = TREE_CHAIN (vfields)) ++ /* Mark the fact that constructor for T could affect anybody ++ inheriting from T who wants to initialize vtables for ++ VFIELDS's type. */ ++ if (VF_BINFO_VALUE (vfields)) ++ TREE_ADDRESSABLE (vfields) = 1; ++ } ++ ++ /* Make the rtl for any new vtables we have created, and unmark ++ the base types we marked. */ ++ finish_vtbls (t); ++ ++ /* Build the VTT for T. */ ++ build_vtt (t); ++ ++ if (warn_nonvdtor && TYPE_POLYMORPHIC_P (t) && TYPE_HAS_DESTRUCTOR (t) ++ && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 1)) == NULL_TREE) ++ warning ("`%#T' has virtual functions but non-virtual destructor", t); ++ ++ complete_vars (t); ++ ++ if (warn_overloaded_virtual) ++ warn_hidden (t); ++ ++ maybe_suppress_debug_info (t); ++ ++ dump_class_hierarchy (t); ++ ++ /* Finish debugging output for this type. */ ++ rest_of_type_compilation (t, ! LOCAL_CLASS_P (t)); ++} ++ ++/* When T was built up, the member declarations were added in reverse ++ order. Rearrange them to declaration order. */ ++ ++void ++unreverse_member_declarations (tree t) ++{ ++ tree next; ++ tree prev; ++ tree x; ++ ++ /* The following lists are all in reverse order. Put them in ++ declaration order now. */ ++ TYPE_METHODS (t) = nreverse (TYPE_METHODS (t)); ++ CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t)); ++ ++ /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in ++ reverse order, so we can't just use nreverse. */ ++ prev = NULL_TREE; ++ for (x = TYPE_FIELDS (t); ++ x && TREE_CODE (x) != TYPE_DECL; ++ x = next) ++ { ++ next = TREE_CHAIN (x); ++ TREE_CHAIN (x) = prev; ++ prev = x; ++ } ++ if (prev) ++ { ++ TREE_CHAIN (TYPE_FIELDS (t)) = x; ++ if (prev) ++ TYPE_FIELDS (t) = prev; ++ } ++} ++ ++tree ++finish_struct (tree t, tree attributes) ++{ ++ location_t saved_loc = input_location; ++ ++ /* Now that we've got all the field declarations, reverse everything ++ as necessary. */ ++ unreverse_member_declarations (t); ++ ++ cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE); ++ ++ /* Nadger the current location so that diagnostics point to the start of ++ the struct, not the end. */ ++ input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t)); ++ ++ if (processing_template_decl) ++ { ++ finish_struct_methods (t); ++ TYPE_SIZE (t) = bitsize_zero_node; ++ TYPE_SIZE_UNIT (t) = size_zero_node; ++ } ++ else ++ finish_struct_1 (t); ++ ++ input_location = saved_loc; ++ ++ TYPE_BEING_DEFINED (t) = 0; ++ ++ if (current_class_type) ++ popclass (); ++ else ++ error ("trying to finish struct, but kicked out due to previous parse errors"); ++ ++ if (processing_template_decl && at_function_scope_p ()) ++ add_stmt (build_min (TAG_DEFN, t)); ++ ++ return t; ++} ++ ++/* Return the dynamic type of INSTANCE, if known. ++ Used to determine whether the virtual function table is needed ++ or not. ++ ++ *NONNULL is set iff INSTANCE can be known to be nonnull, regardless ++ of our knowledge of its type. *NONNULL should be initialized ++ before this function is called. */ ++ ++static tree ++fixed_type_or_null (tree instance, int* nonnull, int* cdtorp) ++{ ++ switch (TREE_CODE (instance)) ++ { ++ case INDIRECT_REF: ++ if (POINTER_TYPE_P (TREE_TYPE (instance))) ++ return NULL_TREE; ++ else ++ return fixed_type_or_null (TREE_OPERAND (instance, 0), ++ nonnull, cdtorp); ++ ++ case CALL_EXPR: ++ /* This is a call to a constructor, hence it's never zero. */ ++ if (TREE_HAS_CONSTRUCTOR (instance)) ++ { ++ if (nonnull) ++ *nonnull = 1; ++ return TREE_TYPE (instance); ++ } ++ return NULL_TREE; ++ ++ case SAVE_EXPR: ++ /* This is a call to a constructor, hence it's never zero. */ ++ if (TREE_HAS_CONSTRUCTOR (instance)) ++ { ++ if (nonnull) ++ *nonnull = 1; ++ return TREE_TYPE (instance); ++ } ++ return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); ++ ++ case RTL_EXPR: ++ return NULL_TREE; ++ ++ case PLUS_EXPR: ++ case MINUS_EXPR: ++ if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR) ++ return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); ++ if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST) ++ /* Propagate nonnull. */ ++ return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); ++ return NULL_TREE; ++ ++ case NOP_EXPR: ++ case CONVERT_EXPR: ++ return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); ++ ++ case ADDR_EXPR: ++ if (nonnull) ++ *nonnull = 1; ++ return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); ++ ++ case COMPONENT_REF: ++ return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp); ++ ++ case VAR_DECL: ++ case FIELD_DECL: ++ if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE ++ && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance)))) ++ { ++ if (nonnull) ++ *nonnull = 1; ++ return TREE_TYPE (TREE_TYPE (instance)); ++ } ++ /* fall through... */ ++ case TARGET_EXPR: ++ case PARM_DECL: ++ case RESULT_DECL: ++ if (IS_AGGR_TYPE (TREE_TYPE (instance))) ++ { ++ if (nonnull) ++ *nonnull = 1; ++ return TREE_TYPE (instance); ++ } ++ else if (instance == current_class_ptr) ++ { ++ if (nonnull) ++ *nonnull = 1; ++ ++ /* if we're in a ctor or dtor, we know our type. */ ++ if (DECL_LANG_SPECIFIC (current_function_decl) ++ && (DECL_CONSTRUCTOR_P (current_function_decl) ++ || DECL_DESTRUCTOR_P (current_function_decl))) ++ { ++ if (cdtorp) ++ *cdtorp = 1; ++ return TREE_TYPE (TREE_TYPE (instance)); ++ } ++ } ++ else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE) ++ { ++ /* Reference variables should be references to objects. */ ++ if (nonnull) ++ *nonnull = 1; ++ ++ /* DECL_VAR_MARKED_P is used to prevent recursion; a ++ variable's initializer may refer to the variable ++ itself. */ ++ if (TREE_CODE (instance) == VAR_DECL ++ && DECL_INITIAL (instance) ++ && !DECL_VAR_MARKED_P (instance)) ++ { ++ tree type; ++ DECL_VAR_MARKED_P (instance) = 1; ++ type = fixed_type_or_null (DECL_INITIAL (instance), ++ nonnull, cdtorp); ++ DECL_VAR_MARKED_P (instance) = 0; ++ return type; ++ } ++ } ++ return NULL_TREE; ++ ++ default: ++ return NULL_TREE; ++ } ++} ++ ++/* Return nonzero if the dynamic type of INSTANCE is known, and ++ equivalent to the static type. We also handle the case where ++ INSTANCE is really a pointer. Return negative if this is a ++ ctor/dtor. There the dynamic type is known, but this might not be ++ the most derived base of the original object, and hence virtual ++ bases may not be layed out according to this type. ++ ++ Used to determine whether the virtual function table is needed ++ or not. ++ ++ *NONNULL is set iff INSTANCE can be known to be nonnull, regardless ++ of our knowledge of its type. *NONNULL should be initialized ++ before this function is called. */ ++ ++int ++resolves_to_fixed_type_p (tree instance, int* nonnull) ++{ ++ tree t = TREE_TYPE (instance); ++ int cdtorp = 0; ++ ++ tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp); ++ if (fixed == NULL_TREE) ++ return 0; ++ if (POINTER_TYPE_P (t)) ++ t = TREE_TYPE (t); ++ if (!same_type_ignoring_top_level_qualifiers_p (t, fixed)) ++ return 0; ++ return cdtorp ? -1 : 1; ++} ++ ++ ++void ++init_class_processing (void) ++{ ++ current_class_depth = 0; ++ current_class_stack_size = 10; ++ current_class_stack ++ = xmalloc (current_class_stack_size * sizeof (struct class_stack_node)); ++ VARRAY_TREE_INIT (local_classes, 8, "local_classes"); ++ ++ ridpointers[(int) RID_PUBLIC] = access_public_node; ++ ridpointers[(int) RID_PRIVATE] = access_private_node; ++ ridpointers[(int) RID_PROTECTED] = access_protected_node; ++} ++ ++/* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as ++ appropriate for TYPE. ++ ++ So that we may avoid calls to lookup_name, we cache the _TYPE ++ nodes of local TYPE_DECLs in the TREE_TYPE field of the name. ++ ++ For multiple inheritance, we perform a two-pass depth-first search ++ of the type lattice. The first pass performs a pre-order search, ++ marking types after the type has had its fields installed in ++ the appropriate IDENTIFIER_CLASS_VALUE slot. The second pass merely ++ unmarks the marked types. If a field or member function name ++ appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of ++ that name becomes `error_mark_node'. */ ++ ++void ++pushclass (tree type) ++{ ++ type = TYPE_MAIN_VARIANT (type); ++ ++ /* Make sure there is enough room for the new entry on the stack. */ ++ if (current_class_depth + 1 >= current_class_stack_size) ++ { ++ current_class_stack_size *= 2; ++ current_class_stack ++ = xrealloc (current_class_stack, ++ current_class_stack_size ++ * sizeof (struct class_stack_node)); ++ } ++ ++ /* Insert a new entry on the class stack. */ ++ current_class_stack[current_class_depth].name = current_class_name; ++ current_class_stack[current_class_depth].type = current_class_type; ++ current_class_stack[current_class_depth].access = current_access_specifier; ++ current_class_stack[current_class_depth].names_used = 0; ++ current_class_depth++; ++ ++ /* Now set up the new type. */ ++ current_class_name = TYPE_NAME (type); ++ if (TREE_CODE (current_class_name) == TYPE_DECL) ++ current_class_name = DECL_NAME (current_class_name); ++ current_class_type = type; ++ ++ /* By default, things in classes are private, while things in ++ structures or unions are public. */ ++ current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type) ++ ? access_private_node ++ : access_public_node); ++ ++ if (previous_class_type != NULL_TREE ++ && (type != previous_class_type ++ || !COMPLETE_TYPE_P (previous_class_type)) ++ && current_class_depth == 1) ++ { ++ /* Forcibly remove any old class remnants. */ ++ invalidate_class_lookup_cache (); ++ } ++ ++ /* If we're about to enter a nested class, clear ++ IDENTIFIER_CLASS_VALUE for the enclosing classes. */ ++ if (current_class_depth > 1) ++ clear_identifier_class_values (); ++ ++ pushlevel_class (); ++ ++ if (type != previous_class_type || current_class_depth > 1) ++ { ++ push_class_decls (type); ++ if (CLASSTYPE_TEMPLATE_INFO (type) && !CLASSTYPE_USE_TEMPLATE (type)) ++ { ++ /* If we are entering the scope of a template declaration (not a ++ specialization), we need to push all the using decls with ++ dependent scope too. */ ++ tree fields; ++ ++ for (fields = TYPE_FIELDS (type); ++ fields; fields = TREE_CHAIN (fields)) ++ if (TREE_CODE (fields) == USING_DECL && !TREE_TYPE (fields)) ++ pushdecl_class_level (fields); ++ } ++ } ++ else ++ { ++ tree item; ++ ++ /* We are re-entering the same class we just left, so we don't ++ have to search the whole inheritance matrix to find all the ++ decls to bind again. Instead, we install the cached ++ class_shadowed list, and walk through it binding names and ++ setting up IDENTIFIER_TYPE_VALUEs. */ ++ set_class_shadows (previous_class_values); ++ for (item = previous_class_values; item; item = TREE_CHAIN (item)) ++ { ++ tree id = TREE_PURPOSE (item); ++ tree decl = TREE_TYPE (item); ++ ++ push_class_binding (id, decl); ++ if (TREE_CODE (decl) == TYPE_DECL) ++ set_identifier_type_value (id, decl); ++ } ++ unuse_fields (type); ++ } ++ ++ cxx_remember_type_decls (CLASSTYPE_NESTED_UTDS (type)); ++} ++ ++/* When we exit a toplevel class scope, we save the ++ IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we ++ reenter the class. Here, we've entered some other class, so we ++ must invalidate our cache. */ ++ ++void ++invalidate_class_lookup_cache (void) ++{ ++ tree t; ++ ++ /* The IDENTIFIER_CLASS_VALUEs are no longer valid. */ ++ for (t = previous_class_values; t; t = TREE_CHAIN (t)) ++ IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE; ++ ++ previous_class_values = NULL_TREE; ++ previous_class_type = NULL_TREE; ++} ++ ++/* Get out of the current class scope. If we were in a class scope ++ previously, that is the one popped to. */ ++ ++void ++popclass (void) ++{ ++ poplevel_class (); ++ pop_class_decls (); ++ ++ current_class_depth--; ++ current_class_name = current_class_stack[current_class_depth].name; ++ current_class_type = current_class_stack[current_class_depth].type; ++ current_access_specifier = current_class_stack[current_class_depth].access; ++ if (current_class_stack[current_class_depth].names_used) ++ splay_tree_delete (current_class_stack[current_class_depth].names_used); ++} ++ ++/* Returns 1 if current_class_type is either T or a nested type of T. ++ We start looking from 1 because entry 0 is from global scope, and has ++ no type. */ ++ ++int ++currently_open_class (tree t) ++{ ++ int i; ++ if (current_class_type && same_type_p (t, current_class_type)) ++ return 1; ++ for (i = 1; i < current_class_depth; ++i) ++ if (current_class_stack[i].type ++ && same_type_p (current_class_stack [i].type, t)) ++ return 1; ++ return 0; ++} ++ ++/* If either current_class_type or one of its enclosing classes are derived ++ from T, return the appropriate type. Used to determine how we found ++ something via unqualified lookup. */ ++ ++tree ++currently_open_derived_class (tree t) ++{ ++ int i; ++ ++ /* The bases of a dependent type are unknown. */ ++ if (dependent_type_p (t)) ++ return NULL_TREE; ++ ++ if (!current_class_type) ++ return NULL_TREE; ++ ++ if (DERIVED_FROM_P (t, current_class_type)) ++ return current_class_type; ++ ++ for (i = current_class_depth - 1; i > 0; --i) ++ if (DERIVED_FROM_P (t, current_class_stack[i].type)) ++ return current_class_stack[i].type; ++ ++ return NULL_TREE; ++} ++ ++/* When entering a class scope, all enclosing class scopes' names with ++ static meaning (static variables, static functions, types and ++ enumerators) have to be visible. This recursive function calls ++ pushclass for all enclosing class contexts until global or a local ++ scope is reached. TYPE is the enclosed class. */ ++ ++void ++push_nested_class (tree type) ++{ ++ tree context; ++ ++ /* A namespace might be passed in error cases, like A::B:C. */ ++ if (type == NULL_TREE ++ || type == error_mark_node ++ || TREE_CODE (type) == NAMESPACE_DECL ++ || ! IS_AGGR_TYPE (type) ++ || TREE_CODE (type) == TEMPLATE_TYPE_PARM ++ || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM) ++ return; ++ ++ context = DECL_CONTEXT (TYPE_MAIN_DECL (type)); ++ ++ if (context && CLASS_TYPE_P (context)) ++ push_nested_class (context); ++ pushclass (type); ++} ++ ++/* Undoes a push_nested_class call. */ ++ ++void ++pop_nested_class (void) ++{ ++ tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type)); ++ ++ popclass (); ++ if (context && CLASS_TYPE_P (context)) ++ pop_nested_class (); ++} ++ ++/* Returns the number of extern "LANG" blocks we are nested within. */ ++ ++int ++current_lang_depth (void) ++{ ++ return VARRAY_ACTIVE_SIZE (current_lang_base); ++} ++ ++/* Set global variables CURRENT_LANG_NAME to appropriate value ++ so that behavior of name-mangling machinery is correct. */ ++ ++void ++push_lang_context (tree name) ++{ ++ VARRAY_PUSH_TREE (current_lang_base, current_lang_name); ++ ++ if (name == lang_name_cplusplus) ++ { ++ current_lang_name = name; ++ } ++ else if (name == lang_name_java) ++ { ++ current_lang_name = name; ++ /* DECL_IGNORED_P is initially set for these types, to avoid clutter. ++ (See record_builtin_java_type in decl.c.) However, that causes ++ incorrect debug entries if these types are actually used. ++ So we re-enable debug output after extern "Java". */ ++ DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0; ++ DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0; ++ DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0; ++ DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0; ++ DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0; ++ DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0; ++ DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0; ++ DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0; ++ } ++ else if (name == lang_name_c) ++ { ++ current_lang_name = name; ++ } ++ else ++ error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name)); ++} ++ ++/* Get out of the current language scope. */ ++ ++void ++pop_lang_context (void) ++{ ++ current_lang_name = VARRAY_TOP_TREE (current_lang_base); ++ VARRAY_POP (current_lang_base); ++} ++ ++/* Type instantiation routines. */ ++ ++/* Given an OVERLOAD and a TARGET_TYPE, return the function that ++ matches the TARGET_TYPE. If there is no satisfactory match, return ++ error_mark_node, and issue a error & warning messages under control ++ of FLAGS. Permit pointers to member function if FLAGS permits. If ++ TEMPLATE_ONLY, the name of the overloaded function was a ++ template-id, and EXPLICIT_TARGS are the explicitly provided ++ template arguments. */ ++ ++static tree ++resolve_address_of_overloaded_function (tree target_type, ++ tree overload, ++ tsubst_flags_t flags, ++ bool template_only, ++ tree explicit_targs) ++{ ++ /* Here's what the standard says: ++ ++ [over.over] ++ ++ If the name is a function template, template argument deduction ++ is done, and if the argument deduction succeeds, the deduced ++ arguments are used to generate a single template function, which ++ is added to the set of overloaded functions considered. ++ ++ Non-member functions and static member functions match targets of ++ type "pointer-to-function" or "reference-to-function." Nonstatic ++ member functions match targets of type "pointer-to-member ++ function;" the function type of the pointer to member is used to ++ select the member function from the set of overloaded member ++ functions. If a nonstatic member function is selected, the ++ reference to the overloaded function name is required to have the ++ form of a pointer to member as described in 5.3.1. ++ ++ If more than one function is selected, any template functions in ++ the set are eliminated if the set also contains a non-template ++ function, and any given template function is eliminated if the ++ set contains a second template function that is more specialized ++ than the first according to the partial ordering rules 14.5.5.2. ++ After such eliminations, if any, there shall remain exactly one ++ selected function. */ ++ ++ int is_ptrmem = 0; ++ int is_reference = 0; ++ /* We store the matches in a TREE_LIST rooted here. The functions ++ are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy ++ interoperability with most_specialized_instantiation. */ ++ tree matches = NULL_TREE; ++ tree fn; ++ ++ /* By the time we get here, we should be seeing only real ++ pointer-to-member types, not the internal POINTER_TYPE to ++ METHOD_TYPE representation. */ ++ my_friendly_assert (!(TREE_CODE (target_type) == POINTER_TYPE ++ && (TREE_CODE (TREE_TYPE (target_type)) ++ == METHOD_TYPE)), 0); ++ ++ my_friendly_assert (is_overloaded_fn (overload), 20030910); ++ ++ /* Check that the TARGET_TYPE is reasonable. */ ++ if (TYPE_PTRFN_P (target_type)) ++ /* This is OK. */; ++ else if (TYPE_PTRMEMFUNC_P (target_type)) ++ /* This is OK, too. */ ++ is_ptrmem = 1; ++ else if (TREE_CODE (target_type) == FUNCTION_TYPE) ++ { ++ /* This is OK, too. This comes from a conversion to reference ++ type. */ ++ target_type = build_reference_type (target_type); ++ is_reference = 1; ++ } ++ else ++ { ++ if (flags & tf_error) ++ error ("\ ++cannot resolve overloaded function `%D' based on conversion to type `%T'", ++ DECL_NAME (OVL_FUNCTION (overload)), target_type); ++ return error_mark_node; ++ } ++ ++ /* If we can find a non-template function that matches, we can just ++ use it. There's no point in generating template instantiations ++ if we're just going to throw them out anyhow. But, of course, we ++ can only do this when we don't *need* a template function. */ ++ if (!template_only) ++ { ++ tree fns; ++ ++ for (fns = overload; fns; fns = OVL_NEXT (fns)) ++ { ++ tree fn = OVL_CURRENT (fns); ++ tree fntype; ++ ++ if (TREE_CODE (fn) == TEMPLATE_DECL) ++ /* We're not looking for templates just yet. */ ++ continue; ++ ++ if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) ++ != is_ptrmem) ++ /* We're looking for a non-static member, and this isn't ++ one, or vice versa. */ ++ continue; ++ ++ /* Ignore anticipated decls of undeclared builtins. */ ++ if (DECL_ANTICIPATED (fn)) ++ continue; ++ ++ /* See if there's a match. */ ++ fntype = TREE_TYPE (fn); ++ if (is_ptrmem) ++ fntype = build_ptrmemfunc_type (build_pointer_type (fntype)); ++ else if (!is_reference) ++ fntype = build_pointer_type (fntype); ++ ++ if (can_convert_arg (target_type, fntype, fn)) ++ matches = tree_cons (fn, NULL_TREE, matches); ++ } ++ } ++ ++ /* Now, if we've already got a match (or matches), there's no need ++ to proceed to the template functions. But, if we don't have a ++ match we need to look at them, too. */ ++ if (!matches) ++ { ++ tree target_fn_type; ++ tree target_arg_types; ++ tree target_ret_type; ++ tree fns; ++ ++ if (is_ptrmem) ++ target_fn_type ++ = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type)); ++ else ++ target_fn_type = TREE_TYPE (target_type); ++ target_arg_types = TYPE_ARG_TYPES (target_fn_type); ++ target_ret_type = TREE_TYPE (target_fn_type); ++ ++ /* Never do unification on the 'this' parameter. */ ++ if (TREE_CODE (target_fn_type) == METHOD_TYPE) ++ target_arg_types = TREE_CHAIN (target_arg_types); ++ ++ for (fns = overload; fns; fns = OVL_NEXT (fns)) ++ { ++ tree fn = OVL_CURRENT (fns); ++ tree instantiation; ++ tree instantiation_type; ++ tree targs; ++ ++ if (TREE_CODE (fn) != TEMPLATE_DECL) ++ /* We're only looking for templates. */ ++ continue; ++ ++ if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) ++ != is_ptrmem) ++ /* We're not looking for a non-static member, and this is ++ one, or vice versa. */ ++ continue; ++ ++ /* Try to do argument deduction. */ ++ targs = make_tree_vec (DECL_NTPARMS (fn)); ++ if (fn_type_unification (fn, explicit_targs, targs, ++ target_arg_types, target_ret_type, ++ DEDUCE_EXACT, -1) != 0) ++ /* Argument deduction failed. */ ++ continue; ++ ++ /* Instantiate the template. */ ++ instantiation = instantiate_template (fn, targs, flags); ++ if (instantiation == error_mark_node) ++ /* Instantiation failed. */ ++ continue; ++ ++ /* See if there's a match. */ ++ instantiation_type = TREE_TYPE (instantiation); ++ if (is_ptrmem) ++ instantiation_type = ++ build_ptrmemfunc_type (build_pointer_type (instantiation_type)); ++ else if (!is_reference) ++ instantiation_type = build_pointer_type (instantiation_type); ++ if (can_convert_arg (target_type, instantiation_type, instantiation)) ++ matches = tree_cons (instantiation, fn, matches); ++ } ++ ++ /* Now, remove all but the most specialized of the matches. */ ++ if (matches) ++ { ++ tree match = most_specialized_instantiation (matches); ++ ++ if (match != error_mark_node) ++ matches = tree_cons (match, NULL_TREE, NULL_TREE); ++ } ++ } ++ ++ /* Now we should have exactly one function in MATCHES. */ ++ if (matches == NULL_TREE) ++ { ++ /* There were *no* matches. */ ++ if (flags & tf_error) ++ { ++ error ("no matches converting function `%D' to type `%#T'", ++ DECL_NAME (OVL_FUNCTION (overload)), ++ target_type); ++ ++ /* print_candidates expects a chain with the functions in ++ TREE_VALUE slots, so we cons one up here (we're losing anyway, ++ so why be clever?). */ ++ for (; overload; overload = OVL_NEXT (overload)) ++ matches = tree_cons (NULL_TREE, OVL_CURRENT (overload), ++ matches); ++ ++ print_candidates (matches); ++ } ++ return error_mark_node; ++ } ++ else if (TREE_CHAIN (matches)) ++ { ++ /* There were too many matches. */ ++ ++ if (flags & tf_error) ++ { ++ tree match; ++ ++ error ("converting overloaded function `%D' to type `%#T' is ambiguous", ++ DECL_NAME (OVL_FUNCTION (overload)), ++ target_type); ++ ++ /* Since print_candidates expects the functions in the ++ TREE_VALUE slot, we flip them here. */ ++ for (match = matches; match; match = TREE_CHAIN (match)) ++ TREE_VALUE (match) = TREE_PURPOSE (match); ++ ++ print_candidates (matches); ++ } ++ ++ return error_mark_node; ++ } ++ ++ /* Good, exactly one match. Now, convert it to the correct type. */ ++ fn = TREE_PURPOSE (matches); ++ ++ if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) ++ && !(flags & tf_ptrmem_ok) && !flag_ms_extensions) ++ { ++ static int explained; ++ ++ if (!(flags & tf_error)) ++ return error_mark_node; ++ ++ pedwarn ("assuming pointer to member `%D'", fn); ++ if (!explained) ++ { ++ pedwarn ("(a pointer to member can only be formed with `&%E')", fn); ++ explained = 1; ++ } ++ } ++ ++ /* If we're doing overload resolution purely for the purpose of ++ determining conversion sequences, we should not consider the ++ function used. If this conversion sequence is selected, the ++ function will be marked as used at this point. */ ++ if (!(flags & tf_conv)) ++ mark_used (fn); ++ ++ if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type)) ++ return build_unary_op (ADDR_EXPR, fn, 0); ++ else ++ { ++ /* The target must be a REFERENCE_TYPE. Above, build_unary_op ++ will mark the function as addressed, but here we must do it ++ explicitly. */ ++ cxx_mark_addressable (fn); ++ ++ return fn; ++ } ++} ++ ++/* This function will instantiate the type of the expression given in ++ RHS to match the type of LHSTYPE. If errors exist, then return ++ error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then ++ we complain on errors. If we are not complaining, never modify rhs, ++ as overload resolution wants to try many possible instantiations, in ++ the hope that at least one will work. ++ ++ For non-recursive calls, LHSTYPE should be a function, pointer to ++ function, or a pointer to member function. */ ++ ++tree ++instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags) ++{ ++ tsubst_flags_t flags_in = flags; ++ ++ flags &= ~tf_ptrmem_ok; ++ ++ if (TREE_CODE (lhstype) == UNKNOWN_TYPE) ++ { ++ if (flags & tf_error) ++ error ("not enough type information"); ++ return error_mark_node; ++ } ++ ++ if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs))) ++ { ++ if (same_type_p (lhstype, TREE_TYPE (rhs))) ++ return rhs; ++ if (flag_ms_extensions ++ && TYPE_PTRMEMFUNC_P (lhstype) ++ && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs))) ++ /* Microsoft allows `A::f' to be resolved to a ++ pointer-to-member. */ ++ ; ++ else ++ { ++ if (flags & tf_error) ++ error ("argument of type `%T' does not match `%T'", ++ TREE_TYPE (rhs), lhstype); ++ return error_mark_node; ++ } ++ } ++ ++ if (TREE_CODE (rhs) == BASELINK) ++ rhs = BASELINK_FUNCTIONS (rhs); ++ ++ /* We don't overwrite rhs if it is an overloaded function. ++ Copying it would destroy the tree link. */ ++ if (TREE_CODE (rhs) != OVERLOAD) ++ rhs = copy_node (rhs); ++ ++ /* This should really only be used when attempting to distinguish ++ what sort of a pointer to function we have. For now, any ++ arithmetic operation which is not supported on pointers ++ is rejected as an error. */ ++ ++ switch (TREE_CODE (rhs)) ++ { ++ case TYPE_EXPR: ++ case CONVERT_EXPR: ++ case SAVE_EXPR: ++ case CONSTRUCTOR: ++ case BUFFER_REF: ++ abort (); ++ return error_mark_node; ++ ++ case INDIRECT_REF: ++ case ARRAY_REF: ++ { ++ tree new_rhs; ++ ++ new_rhs = instantiate_type (build_pointer_type (lhstype), ++ TREE_OPERAND (rhs, 0), flags); ++ if (new_rhs == error_mark_node) ++ return error_mark_node; ++ ++ TREE_TYPE (rhs) = lhstype; ++ TREE_OPERAND (rhs, 0) = new_rhs; ++ return rhs; ++ } ++ ++ case NOP_EXPR: ++ rhs = copy_node (TREE_OPERAND (rhs, 0)); ++ TREE_TYPE (rhs) = unknown_type_node; ++ return instantiate_type (lhstype, rhs, flags); ++ ++ case COMPONENT_REF: ++ { ++ tree addr = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags); ++ ++ if (addr != error_mark_node ++ && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0))) ++ /* Do not lose object's side effects. */ ++ addr = build (COMPOUND_EXPR, TREE_TYPE (addr), ++ TREE_OPERAND (rhs, 0), addr); ++ return addr; ++ } ++ ++ case OFFSET_REF: ++ rhs = TREE_OPERAND (rhs, 1); ++ if (BASELINK_P (rhs)) ++ return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in); ++ ++ /* This can happen if we are forming a pointer-to-member for a ++ member template. */ ++ my_friendly_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR, 0); ++ ++ /* Fall through. */ ++ ++ case TEMPLATE_ID_EXPR: ++ { ++ tree fns = TREE_OPERAND (rhs, 0); ++ tree args = TREE_OPERAND (rhs, 1); ++ ++ return ++ resolve_address_of_overloaded_function (lhstype, fns, flags_in, ++ /*template_only=*/true, ++ args); ++ } ++ ++ case OVERLOAD: ++ case FUNCTION_DECL: ++ return ++ resolve_address_of_overloaded_function (lhstype, rhs, flags_in, ++ /*template_only=*/false, ++ /*explicit_targs=*/NULL_TREE); ++ ++ case TREE_LIST: ++ /* Now we should have a baselink. */ ++ my_friendly_assert (BASELINK_P (rhs), 990412); ++ ++ return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags); ++ ++ case CALL_EXPR: ++ /* This is too hard for now. */ ++ abort (); ++ return error_mark_node; ++ ++ case PLUS_EXPR: ++ case MINUS_EXPR: ++ case COMPOUND_EXPR: ++ TREE_OPERAND (rhs, 0) ++ = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags); ++ if (TREE_OPERAND (rhs, 0) == error_mark_node) ++ return error_mark_node; ++ TREE_OPERAND (rhs, 1) ++ = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags); ++ if (TREE_OPERAND (rhs, 1) == error_mark_node) ++ return error_mark_node; ++ ++ TREE_TYPE (rhs) = lhstype; ++ return rhs; ++ ++ case MULT_EXPR: ++ case TRUNC_DIV_EXPR: ++ case FLOOR_DIV_EXPR: ++ case CEIL_DIV_EXPR: ++ case ROUND_DIV_EXPR: ++ case RDIV_EXPR: ++ case TRUNC_MOD_EXPR: ++ case FLOOR_MOD_EXPR: ++ case CEIL_MOD_EXPR: ++ case ROUND_MOD_EXPR: ++ case FIX_ROUND_EXPR: ++ case FIX_FLOOR_EXPR: ++ case FIX_CEIL_EXPR: ++ case FIX_TRUNC_EXPR: ++ case FLOAT_EXPR: ++ case NEGATE_EXPR: ++ case ABS_EXPR: ++ case MAX_EXPR: ++ case MIN_EXPR: ++ ++ case BIT_AND_EXPR: ++ case BIT_IOR_EXPR: ++ case BIT_XOR_EXPR: ++ case LSHIFT_EXPR: ++ case RSHIFT_EXPR: ++ case LROTATE_EXPR: ++ case RROTATE_EXPR: ++ ++ case PREINCREMENT_EXPR: ++ case PREDECREMENT_EXPR: ++ case POSTINCREMENT_EXPR: ++ case POSTDECREMENT_EXPR: ++ if (flags & tf_error) ++ error ("invalid operation on uninstantiated type"); ++ return error_mark_node; ++ ++ case TRUTH_AND_EXPR: ++ case TRUTH_OR_EXPR: ++ case TRUTH_XOR_EXPR: ++ case LT_EXPR: ++ case LE_EXPR: ++ case GT_EXPR: ++ case GE_EXPR: ++ case EQ_EXPR: ++ case NE_EXPR: ++ case TRUTH_ANDIF_EXPR: ++ case TRUTH_ORIF_EXPR: ++ case TRUTH_NOT_EXPR: ++ if (flags & tf_error) ++ error ("not enough type information"); ++ return error_mark_node; ++ ++ case COND_EXPR: ++ if (type_unknown_p (TREE_OPERAND (rhs, 0))) ++ { ++ if (flags & tf_error) ++ error ("not enough type information"); ++ return error_mark_node; ++ } ++ TREE_OPERAND (rhs, 1) ++ = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags); ++ if (TREE_OPERAND (rhs, 1) == error_mark_node) ++ return error_mark_node; ++ TREE_OPERAND (rhs, 2) ++ = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags); ++ if (TREE_OPERAND (rhs, 2) == error_mark_node) ++ return error_mark_node; ++ ++ TREE_TYPE (rhs) = lhstype; ++ return rhs; ++ ++ case MODIFY_EXPR: ++ TREE_OPERAND (rhs, 1) ++ = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags); ++ if (TREE_OPERAND (rhs, 1) == error_mark_node) ++ return error_mark_node; ++ ++ TREE_TYPE (rhs) = lhstype; ++ return rhs; ++ ++ case ADDR_EXPR: ++ { ++ if (PTRMEM_OK_P (rhs)) ++ flags |= tf_ptrmem_ok; ++ ++ return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags); ++ } ++ case ENTRY_VALUE_EXPR: ++ abort (); ++ return error_mark_node; ++ ++ case ERROR_MARK: ++ return error_mark_node; ++ ++ default: ++ abort (); ++ return error_mark_node; ++ } ++} ++ ++/* Return the name of the virtual function pointer field ++ (as an IDENTIFIER_NODE) for the given TYPE. Note that ++ this may have to look back through base types to find the ++ ultimate field name. (For single inheritance, these could ++ all be the same name. Who knows for multiple inheritance). */ ++ ++static tree ++get_vfield_name (tree type) ++{ ++ tree binfo = TYPE_BINFO (type); ++ char *buf; ++ ++ while (BINFO_BASETYPES (binfo) ++ && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0))) ++ && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0))) ++ binfo = BINFO_BASETYPE (binfo, 0); ++ ++ type = BINFO_TYPE (binfo); ++ buf = alloca (sizeof (VFIELD_NAME_FORMAT) + TYPE_NAME_LENGTH (type) + 2); ++ sprintf (buf, VFIELD_NAME_FORMAT, ++ IDENTIFIER_POINTER (constructor_name (type))); ++ return get_identifier (buf); ++} ++ ++void ++print_class_statistics (void) ++{ ++#ifdef GATHER_STATISTICS ++ fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness); ++ fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs); ++ if (n_vtables) ++ { ++ fprintf (stderr, "vtables = %d; vtable searches = %d\n", ++ n_vtables, n_vtable_searches); ++ fprintf (stderr, "vtable entries = %d; vtable elems = %d\n", ++ n_vtable_entries, n_vtable_elems); ++ } ++#endif ++} ++ ++/* Build a dummy reference to ourselves so Derived::Base (and A::A) works, ++ according to [class]: ++ The class-name is also inserted ++ into the scope of the class itself. For purposes of access checking, ++ the inserted class name is treated as if it were a public member name. */ ++ ++void ++build_self_reference (void) ++{ ++ tree name = constructor_name (current_class_type); ++ tree value = build_lang_decl (TYPE_DECL, name, current_class_type); ++ tree saved_cas; ++ ++ DECL_NONLOCAL (value) = 1; ++ DECL_CONTEXT (value) = current_class_type; ++ DECL_ARTIFICIAL (value) = 1; ++ SET_DECL_SELF_REFERENCE_P (value); ++ ++ if (processing_template_decl) ++ value = push_template_decl (value); ++ ++ saved_cas = current_access_specifier; ++ current_access_specifier = access_public_node; ++ finish_member_declaration (value); ++ current_access_specifier = saved_cas; ++} ++ ++/* Returns 1 if TYPE contains only padding bytes. */ ++ ++int ++is_empty_class (tree type) ++{ ++ if (type == error_mark_node) ++ return 0; ++ ++ if (! IS_AGGR_TYPE (type)) ++ return 0; ++ ++ /* In G++ 3.2, whether or not a class was empty was determined by ++ looking at its size. */ ++ if (abi_version_at_least (2)) ++ return CLASSTYPE_EMPTY_P (type); ++ else ++ return integer_zerop (CLASSTYPE_SIZE (type)); ++} ++ ++/* Returns true if TYPE contains an empty class. */ ++ ++static bool ++contains_empty_class_p (tree type) ++{ ++ if (is_empty_class (type)) ++ return true; ++ if (CLASS_TYPE_P (type)) ++ { ++ tree field; ++ int i; ++ ++ for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i) ++ if (contains_empty_class_p (TYPE_BINFO_BASETYPE (type, i))) ++ return true; ++ for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) ++ if (TREE_CODE (field) == FIELD_DECL ++ && !DECL_ARTIFICIAL (field) ++ && is_empty_class (TREE_TYPE (field))) ++ return true; ++ } ++ else if (TREE_CODE (type) == ARRAY_TYPE) ++ return contains_empty_class_p (TREE_TYPE (type)); ++ return false; ++} ++ ++/* Find the enclosing class of the given NODE. NODE can be a *_DECL or ++ a *_TYPE node. NODE can also be a local class. */ ++ ++tree ++get_enclosing_class (tree type) ++{ ++ tree node = type; ++ ++ while (node && TREE_CODE (node) != NAMESPACE_DECL) ++ { ++ switch (TREE_CODE_CLASS (TREE_CODE (node))) ++ { ++ case 'd': ++ node = DECL_CONTEXT (node); ++ break; ++ ++ case 't': ++ if (node != type) ++ return node; ++ node = TYPE_CONTEXT (node); ++ break; ++ ++ default: ++ abort (); ++ } ++ } ++ return NULL_TREE; ++} ++ ++/* Note that NAME was looked up while the current class was being ++ defined and that the result of that lookup was DECL. */ ++ ++void ++maybe_note_name_used_in_class (tree name, tree decl) ++{ ++ splay_tree names_used; ++ ++ /* If we're not defining a class, there's nothing to do. */ ++ if (innermost_scope_kind() != sk_class) ++ return; ++ ++ /* If there's already a binding for this NAME, then we don't have ++ anything to worry about. */ ++ if (IDENTIFIER_CLASS_VALUE (name)) ++ return; ++ ++ if (!current_class_stack[current_class_depth - 1].names_used) ++ current_class_stack[current_class_depth - 1].names_used ++ = splay_tree_new (splay_tree_compare_pointers, 0, 0); ++ names_used = current_class_stack[current_class_depth - 1].names_used; ++ ++ splay_tree_insert (names_used, ++ (splay_tree_key) name, ++ (splay_tree_value) decl); ++} ++ ++/* Note that NAME was declared (as DECL) in the current class. Check ++ to see that the declaration is valid. */ ++ ++void ++note_name_declared_in_class (tree name, tree decl) ++{ ++ splay_tree names_used; ++ splay_tree_node n; ++ ++ /* Look to see if we ever used this name. */ ++ names_used ++ = current_class_stack[current_class_depth - 1].names_used; ++ if (!names_used) ++ return; ++ ++ n = splay_tree_lookup (names_used, (splay_tree_key) name); ++ if (n) ++ { ++ /* [basic.scope.class] ++ ++ A name N used in a class S shall refer to the same declaration ++ in its context and when re-evaluated in the completed scope of ++ S. */ ++ error ("declaration of `%#D'", decl); ++ cp_error_at ("changes meaning of `%D' from `%+#D'", ++ DECL_NAME (OVL_CURRENT (decl)), ++ (tree) n->value); ++ } ++} ++ ++/* Returns the VAR_DECL for the complete vtable associated with BINFO. ++ Secondary vtables are merged with primary vtables; this function ++ will return the VAR_DECL for the primary vtable. */ ++ ++tree ++get_vtbl_decl_for_binfo (tree binfo) ++{ ++ tree decl; ++ ++ decl = BINFO_VTABLE (binfo); ++ if (decl && TREE_CODE (decl) == PLUS_EXPR) ++ { ++ my_friendly_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR, ++ 2000403); ++ decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0); ++ } ++ if (decl) ++ my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20000403); ++ return decl; ++} ++ ++ ++/* Returns the binfo for the primary base of BINFO. If the resulting ++ BINFO is a virtual base, and it is inherited elsewhere in the ++ hierarchy, then the returned binfo might not be the primary base of ++ BINFO in the complete object. Check BINFO_PRIMARY_P or ++ BINFO_LOST_PRIMARY_P to be sure. */ ++ ++tree ++get_primary_binfo (tree binfo) ++{ ++ tree primary_base; ++ tree result; ++ ++ primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo)); ++ if (!primary_base) ++ return NULL_TREE; ++ ++ result = copied_binfo (primary_base, binfo); ++ return result; ++} ++ ++/* If INDENTED_P is zero, indent to INDENT. Return nonzero. */ ++ ++static int ++maybe_indent_hierarchy (FILE * stream, int indent, int indented_p) ++{ ++ if (!indented_p) ++ fprintf (stream, "%*s", indent, ""); ++ return 1; ++} ++ ++/* Dump the offsets of all the bases rooted at BINFO to STREAM. ++ INDENT should be zero when called from the top level; it is ++ incremented recursively. IGO indicates the next expected BINFO in ++ inheritance graph ordering. */ ++ ++static tree ++dump_class_hierarchy_r (FILE *stream, ++ int flags, ++ tree binfo, ++ tree igo, ++ int indent) ++{ ++ int indented = 0; ++ tree base_binfos; ++ ++ indented = maybe_indent_hierarchy (stream, indent, 0); ++ fprintf (stream, "%s (0x%lx) ", ++ type_as_string (binfo, TFF_PLAIN_IDENTIFIER), ++ (unsigned long) binfo); ++ if (binfo != igo) ++ { ++ fprintf (stream, "alternative-path\n"); ++ return igo; ++ } ++ igo = TREE_CHAIN (binfo); ++ ++ fprintf (stream, HOST_WIDE_INT_PRINT_DEC, ++ tree_low_cst (BINFO_OFFSET (binfo), 0)); ++ if (is_empty_class (BINFO_TYPE (binfo))) ++ fprintf (stream, " empty"); ++ else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo))) ++ fprintf (stream, " nearly-empty"); ++ if (TREE_VIA_VIRTUAL (binfo)) ++ fprintf (stream, " virtual"); ++ fprintf (stream, "\n"); ++ ++ indented = 0; ++ if (BINFO_PRIMARY_BASE_OF (binfo)) ++ { ++ indented = maybe_indent_hierarchy (stream, indent + 3, indented); ++ fprintf (stream, " primary-for %s (0x%lx)", ++ type_as_string (BINFO_PRIMARY_BASE_OF (binfo), ++ TFF_PLAIN_IDENTIFIER), ++ (unsigned long)BINFO_PRIMARY_BASE_OF (binfo)); ++ } ++ if (BINFO_LOST_PRIMARY_P (binfo)) ++ { ++ indented = maybe_indent_hierarchy (stream, indent + 3, indented); ++ fprintf (stream, " lost-primary"); ++ } ++ if (indented) ++ fprintf (stream, "\n"); ++ ++ if (!(flags & TDF_SLIM)) ++ { ++ int indented = 0; ++ ++ if (BINFO_SUBVTT_INDEX (binfo)) ++ { ++ indented = maybe_indent_hierarchy (stream, indent + 3, indented); ++ fprintf (stream, " subvttidx=%s", ++ expr_as_string (BINFO_SUBVTT_INDEX (binfo), ++ TFF_PLAIN_IDENTIFIER)); ++ } ++ if (BINFO_VPTR_INDEX (binfo)) ++ { ++ indented = maybe_indent_hierarchy (stream, indent + 3, indented); ++ fprintf (stream, " vptridx=%s", ++ expr_as_string (BINFO_VPTR_INDEX (binfo), ++ TFF_PLAIN_IDENTIFIER)); ++ } ++ if (BINFO_VPTR_FIELD (binfo)) ++ { ++ indented = maybe_indent_hierarchy (stream, indent + 3, indented); ++ fprintf (stream, " vbaseoffset=%s", ++ expr_as_string (BINFO_VPTR_FIELD (binfo), ++ TFF_PLAIN_IDENTIFIER)); ++ } ++ if (BINFO_VTABLE (binfo)) ++ { ++ indented = maybe_indent_hierarchy (stream, indent + 3, indented); ++ fprintf (stream, " vptr=%s", ++ expr_as_string (BINFO_VTABLE (binfo), ++ TFF_PLAIN_IDENTIFIER)); ++ } ++ ++ if (indented) ++ fprintf (stream, "\n"); ++ } ++ ++ base_binfos = BINFO_BASETYPES (binfo); ++ if (base_binfos) ++ { ++ int ix, n; ++ ++ n = TREE_VEC_LENGTH (base_binfos); ++ for (ix = 0; ix != n; ix++) ++ { ++ tree base_binfo = TREE_VEC_ELT (base_binfos, ix); ++ ++ igo = dump_class_hierarchy_r (stream, flags, base_binfo, ++ igo, indent + 2); ++ } ++ } ++ ++ return igo; ++} ++ ++/* Dump the BINFO hierarchy for T. */ ++ ++static void ++dump_class_hierarchy_1 (FILE *stream, int flags, tree t) ++{ ++ fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER)); ++ fprintf (stream, " size=%lu align=%lu\n", ++ (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT), ++ (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT)); ++ fprintf (stream, " base size=%lu base align=%lu\n", ++ (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0) ++ / BITS_PER_UNIT), ++ (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t)) ++ / BITS_PER_UNIT)); ++ dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0); ++ fprintf (stream, "\n"); ++} ++ ++/* Debug interface to hierarchy dumping. */ ++ ++extern void ++debug_class (tree t) ++{ ++ dump_class_hierarchy_1 (stderr, TDF_SLIM, t); ++} ++ ++static void ++dump_class_hierarchy (tree t) ++{ ++ int flags; ++ FILE *stream = dump_begin (TDI_class, &flags); ++ ++ if (stream) ++ { ++ dump_class_hierarchy_1 (stream, flags, t); ++ dump_end (TDI_class, stream); ++ } ++} ++ ++static void ++dump_array (FILE * stream, tree decl) ++{ ++ tree inits; ++ int ix; ++ HOST_WIDE_INT elt; ++ tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl))); ++ ++ elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0) ++ / BITS_PER_UNIT); ++ fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER)); ++ fprintf (stream, " %s entries", ++ expr_as_string (size_binop (PLUS_EXPR, size, size_one_node), ++ TFF_PLAIN_IDENTIFIER)); ++ fprintf (stream, "\n"); ++ ++ for (ix = 0, inits = CONSTRUCTOR_ELTS (DECL_INITIAL (decl)); ++ inits; ix++, inits = TREE_CHAIN (inits)) ++ fprintf (stream, "%-4ld %s\n", (long)(ix * elt), ++ expr_as_string (TREE_VALUE (inits), TFF_PLAIN_IDENTIFIER)); ++} ++ ++static void ++dump_vtable (tree t, tree binfo, tree vtable) ++{ ++ int flags; ++ FILE *stream = dump_begin (TDI_class, &flags); ++ ++ if (!stream) ++ return; ++ ++ if (!(flags & TDF_SLIM)) ++ { ++ int ctor_vtbl_p = TYPE_BINFO (t) != binfo; ++ ++ fprintf (stream, "%s for %s", ++ ctor_vtbl_p ? "Construction vtable" : "Vtable", ++ type_as_string (binfo, TFF_PLAIN_IDENTIFIER)); ++ if (ctor_vtbl_p) ++ { ++ if (!TREE_VIA_VIRTUAL (binfo)) ++ fprintf (stream, " (0x%lx instance)", (unsigned long)binfo); ++ fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER)); ++ } ++ fprintf (stream, "\n"); ++ dump_array (stream, vtable); ++ fprintf (stream, "\n"); ++ } ++ ++ dump_end (TDI_class, stream); ++} ++ ++static void ++dump_vtt (tree t, tree vtt) ++{ ++ int flags; ++ FILE *stream = dump_begin (TDI_class, &flags); ++ ++ if (!stream) ++ return; ++ ++ if (!(flags & TDF_SLIM)) ++ { ++ fprintf (stream, "VTT for %s\n", ++ type_as_string (t, TFF_PLAIN_IDENTIFIER)); ++ dump_array (stream, vtt); ++ fprintf (stream, "\n"); ++ } ++ ++ dump_end (TDI_class, stream); ++} ++ ++/* Dump a function or thunk and its thunkees. */ ++ ++static void ++dump_thunk (FILE *stream, int indent, tree thunk) ++{ ++ static const char spaces[] = " "; ++ tree name = DECL_NAME (thunk); ++ tree thunks; ++ ++ fprintf (stream, "%.*s%p %s %s", indent, spaces, ++ (void *)thunk, ++ !DECL_THUNK_P (thunk) ? "function" ++ : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk", ++ name ? IDENTIFIER_POINTER (name) : ""); ++ if (DECL_THUNK_P (thunk)) ++ { ++ HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk); ++ tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk); ++ ++ fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust); ++ if (!virtual_adjust) ++ /*NOP*/; ++ else if (DECL_THIS_THUNK_P (thunk)) ++ fprintf (stream, " vcall=" HOST_WIDE_INT_PRINT_DEC, ++ tree_low_cst (virtual_adjust, 0)); ++ else ++ fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)", ++ tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0), ++ type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE)); ++ if (THUNK_ALIAS (thunk)) ++ fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk)); ++ } ++ fprintf (stream, "\n"); ++ for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks)) ++ dump_thunk (stream, indent + 2, thunks); ++} ++ ++/* Dump the thunks for FN. */ ++ ++extern void ++debug_thunks (tree fn) ++{ ++ dump_thunk (stderr, 0, fn); ++} ++ ++/* Virtual function table initialization. */ ++ ++/* Create all the necessary vtables for T and its base classes. */ ++ ++static void ++finish_vtbls (tree t) ++{ ++ tree list; ++ tree vbase; ++ ++ /* We lay out the primary and secondary vtables in one contiguous ++ vtable. The primary vtable is first, followed by the non-virtual ++ secondary vtables in inheritance graph order. */ ++ list = build_tree_list (TYPE_BINFO_VTABLE (t), NULL_TREE); ++ accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), ++ TYPE_BINFO (t), t, list); ++ ++ /* Then come the virtual bases, also in inheritance graph order. */ ++ for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase)) ++ { ++ if (!TREE_VIA_VIRTUAL (vbase)) ++ continue; ++ accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list); ++ } ++ ++ if (TYPE_BINFO_VTABLE (t)) ++ initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list)); ++} ++ ++/* Initialize the vtable for BINFO with the INITS. */ ++ ++static void ++initialize_vtable (tree binfo, tree inits) ++{ ++ tree decl; ++ ++ layout_vtable_decl (binfo, list_length (inits)); ++ decl = get_vtbl_decl_for_binfo (binfo); ++ initialize_array (decl, inits); ++ dump_vtable (BINFO_TYPE (binfo), binfo, decl); ++} ++ ++/* Initialize DECL (a declaration for a namespace-scope array) with ++ the INITS. */ ++ ++static void ++initialize_array (tree decl, tree inits) ++{ ++ tree context; ++ ++ context = DECL_CONTEXT (decl); ++ DECL_CONTEXT (decl) = NULL_TREE; ++ DECL_INITIAL (decl) = build_constructor (NULL_TREE, inits); ++ TREE_HAS_CONSTRUCTOR (DECL_INITIAL (decl)) = 1; ++ cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0); ++ DECL_CONTEXT (decl) = context; ++} ++ ++/* Build the VTT (virtual table table) for T. ++ A class requires a VTT if it has virtual bases. ++ ++ This holds ++ 1 - primary virtual pointer for complete object T ++ 2 - secondary VTTs for each direct non-virtual base of T which requires a ++ VTT ++ 3 - secondary virtual pointers for each direct or indirect base of T which ++ has virtual bases or is reachable via a virtual path from T. ++ 4 - secondary VTTs for each direct or indirect virtual base of T. ++ ++ Secondary VTTs look like complete object VTTs without part 4. */ ++ ++static void ++build_vtt (tree t) ++{ ++ tree inits; ++ tree type; ++ tree vtt; ++ tree index; ++ ++ /* Build up the initializers for the VTT. */ ++ inits = NULL_TREE; ++ index = size_zero_node; ++ build_vtt_inits (TYPE_BINFO (t), t, &inits, &index); ++ ++ /* If we didn't need a VTT, we're done. */ ++ if (!inits) ++ return; ++ ++ /* Figure out the type of the VTT. */ ++ type = build_index_type (size_int (list_length (inits) - 1)); ++ type = build_cplus_array_type (const_ptr_type_node, type); ++ ++ /* Now, build the VTT object itself. */ ++ vtt = build_vtable (t, get_vtt_name (t), type); ++ initialize_array (vtt, inits); ++ /* Add the VTT to the vtables list. */ ++ TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t)); ++ TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt; ++ ++ dump_vtt (t, vtt); ++} ++ ++/* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with ++ PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo, ++ and CHAIN the vtable pointer for this binfo after construction is ++ complete. VALUE can also be another BINFO, in which case we recurse. */ ++ ++static tree ++binfo_ctor_vtable (tree binfo) ++{ ++ tree vt; ++ ++ while (1) ++ { ++ vt = BINFO_VTABLE (binfo); ++ if (TREE_CODE (vt) == TREE_LIST) ++ vt = TREE_VALUE (vt); ++ if (TREE_CODE (vt) == TREE_VEC) ++ binfo = vt; ++ else ++ break; ++ } ++ ++ return vt; ++} ++ ++/* Recursively build the VTT-initializer for BINFO (which is in the ++ hierarchy dominated by T). INITS points to the end of the initializer ++ list to date. INDEX is the VTT index where the next element will be ++ replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e. ++ not a subvtt for some base of T). When that is so, we emit the sub-VTTs ++ for virtual bases of T. When it is not so, we build the constructor ++ vtables for the BINFO-in-T variant. */ ++ ++static tree * ++build_vtt_inits (tree binfo, tree t, tree* inits, tree* index) ++{ ++ int i; ++ tree b; ++ tree init; ++ tree secondary_vptrs; ++ int top_level_p = same_type_p (TREE_TYPE (binfo), t); ++ ++ /* We only need VTTs for subobjects with virtual bases. */ ++ if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))) ++ return inits; ++ ++ /* We need to use a construction vtable if this is not the primary ++ VTT. */ ++ if (!top_level_p) ++ { ++ build_ctor_vtbl_group (binfo, t); ++ ++ /* Record the offset in the VTT where this sub-VTT can be found. */ ++ BINFO_SUBVTT_INDEX (binfo) = *index; ++ } ++ ++ /* Add the address of the primary vtable for the complete object. */ ++ init = binfo_ctor_vtable (binfo); ++ *inits = build_tree_list (NULL_TREE, init); ++ inits = &TREE_CHAIN (*inits); ++ if (top_level_p) ++ { ++ my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129); ++ BINFO_VPTR_INDEX (binfo) = *index; ++ } ++ *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node)); ++ ++ /* Recursively add the secondary VTTs for non-virtual bases. */ ++ for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i) ++ { ++ b = BINFO_BASETYPE (binfo, i); ++ if (!TREE_VIA_VIRTUAL (b)) ++ inits = build_vtt_inits (BINFO_BASETYPE (binfo, i), t, ++ inits, index); ++ } ++ ++ /* Add secondary virtual pointers for all subobjects of BINFO with ++ either virtual bases or reachable along a virtual path, except ++ subobjects that are non-virtual primary bases. */ ++ secondary_vptrs = tree_cons (t, NULL_TREE, BINFO_TYPE (binfo)); ++ TREE_TYPE (secondary_vptrs) = *index; ++ VTT_TOP_LEVEL_P (secondary_vptrs) = top_level_p; ++ VTT_MARKED_BINFO_P (secondary_vptrs) = 0; ++ ++ dfs_walk_real (binfo, ++ dfs_build_secondary_vptr_vtt_inits, ++ NULL, ++ dfs_ctor_vtable_bases_queue_p, ++ secondary_vptrs); ++ VTT_MARKED_BINFO_P (secondary_vptrs) = 1; ++ dfs_walk (binfo, dfs_unmark, dfs_ctor_vtable_bases_queue_p, ++ secondary_vptrs); ++ ++ *index = TREE_TYPE (secondary_vptrs); ++ ++ /* The secondary vptrs come back in reverse order. After we reverse ++ them, and add the INITS, the last init will be the first element ++ of the chain. */ ++ secondary_vptrs = TREE_VALUE (secondary_vptrs); ++ if (secondary_vptrs) ++ { ++ *inits = nreverse (secondary_vptrs); ++ inits = &TREE_CHAIN (secondary_vptrs); ++ my_friendly_assert (*inits == NULL_TREE, 20000517); ++ } ++ ++ /* Add the secondary VTTs for virtual bases. */ ++ if (top_level_p) ++ for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b)) ++ { ++ if (!TREE_VIA_VIRTUAL (b)) ++ continue; ++ ++ inits = build_vtt_inits (b, t, inits, index); ++ } ++ ++ if (!top_level_p) ++ { ++ tree data = tree_cons (t, binfo, NULL_TREE); ++ VTT_TOP_LEVEL_P (data) = 0; ++ VTT_MARKED_BINFO_P (data) = 0; ++ ++ dfs_walk (binfo, dfs_fixup_binfo_vtbls, ++ dfs_ctor_vtable_bases_queue_p, ++ data); ++ } ++ ++ return inits; ++} ++ ++/* Called from build_vtt_inits via dfs_walk. BINFO is the binfo ++ for the base in most derived. DATA is a TREE_LIST who's ++ TREE_CHAIN is the type of the base being ++ constructed whilst this secondary vptr is live. The TREE_UNSIGNED ++ flag of DATA indicates that this is a constructor vtable. The ++ TREE_TOP_LEVEL flag indicates that this is the primary VTT. */ ++ ++static tree ++dfs_build_secondary_vptr_vtt_inits (tree binfo, void* data) ++{ ++ tree l; ++ tree t; ++ tree init; ++ tree index; ++ int top_level_p; ++ ++ l = (tree) data; ++ t = TREE_CHAIN (l); ++ top_level_p = VTT_TOP_LEVEL_P (l); ++ ++ BINFO_MARKED (binfo) = 1; ++ ++ /* We don't care about bases that don't have vtables. */ ++ if (!TYPE_VFIELD (BINFO_TYPE (binfo))) ++ return NULL_TREE; ++ ++ /* We're only interested in proper subobjects of T. */ ++ if (same_type_p (BINFO_TYPE (binfo), t)) ++ return NULL_TREE; ++ ++ /* We're not interested in non-virtual primary bases. */ ++ if (!TREE_VIA_VIRTUAL (binfo) && BINFO_PRIMARY_P (binfo)) ++ return NULL_TREE; ++ ++ /* If BINFO has virtual bases or is reachable via a virtual path ++ from T, it'll have a secondary vptr. */ ++ if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)) ++ && !binfo_via_virtual (binfo, t)) ++ return NULL_TREE; ++ ++ /* Record the index where this secondary vptr can be found. */ ++ index = TREE_TYPE (l); ++ if (top_level_p) ++ { ++ my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129); ++ BINFO_VPTR_INDEX (binfo) = index; ++ } ++ TREE_TYPE (l) = size_binop (PLUS_EXPR, index, ++ TYPE_SIZE_UNIT (ptr_type_node)); ++ ++ /* Add the initializer for the secondary vptr itself. */ ++ if (top_level_p && TREE_VIA_VIRTUAL (binfo)) ++ { ++ /* It's a primary virtual base, and this is not the construction ++ vtable. Find the base this is primary of in the inheritance graph, ++ and use that base's vtable now. */ ++ while (BINFO_PRIMARY_BASE_OF (binfo)) ++ binfo = BINFO_PRIMARY_BASE_OF (binfo); ++ } ++ init = binfo_ctor_vtable (binfo); ++ TREE_VALUE (l) = tree_cons (NULL_TREE, init, TREE_VALUE (l)); ++ ++ return NULL_TREE; ++} ++ ++/* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST, ++ VTT_MARKED_BINFO_P indicates whether marked or unmarked bases ++ should be walked. TREE_PURPOSE is the TREE_TYPE that dominates the ++ hierarchy. */ ++ ++static tree ++dfs_ctor_vtable_bases_queue_p (tree derived, int ix, ++ void* data) ++{ ++ tree binfo = BINFO_BASETYPE (derived, ix); ++ ++ if (!BINFO_MARKED (binfo) == VTT_MARKED_BINFO_P ((tree) data)) ++ return NULL_TREE; ++ return binfo; ++} ++ ++/* Called from build_vtt_inits via dfs_walk. After building constructor ++ vtables and generating the sub-vtt from them, we need to restore the ++ BINFO_VTABLES that were scribbled on. DATA is a TREE_LIST whose ++ TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated. */ ++ ++static tree ++dfs_fixup_binfo_vtbls (tree binfo, void* data) ++{ ++ BINFO_MARKED (binfo) = 0; ++ ++ /* We don't care about bases that don't have vtables. */ ++ if (!TYPE_VFIELD (BINFO_TYPE (binfo))) ++ return NULL_TREE; ++ ++ /* If we scribbled the construction vtable vptr into BINFO, clear it ++ out now. */ ++ if (BINFO_VTABLE (binfo) ++ && TREE_CODE (BINFO_VTABLE (binfo)) == TREE_LIST ++ && (TREE_PURPOSE (BINFO_VTABLE (binfo)) ++ == TREE_VALUE ((tree) data))) ++ BINFO_VTABLE (binfo) = TREE_CHAIN (BINFO_VTABLE (binfo)); ++ ++ return NULL_TREE; ++} ++ ++/* Build the construction vtable group for BINFO which is in the ++ hierarchy dominated by T. */ ++ ++static void ++build_ctor_vtbl_group (tree binfo, tree t) ++{ ++ tree list; ++ tree type; ++ tree vtbl; ++ tree inits; ++ tree id; ++ tree vbase; ++ ++ /* See if we've already created this construction vtable group. */ ++ id = mangle_ctor_vtbl_for_type (t, binfo); ++ if (IDENTIFIER_GLOBAL_VALUE (id)) ++ return; ++ ++ my_friendly_assert (!same_type_p (BINFO_TYPE (binfo), t), 20010124); ++ /* Build a version of VTBL (with the wrong type) for use in ++ constructing the addresses of secondary vtables in the ++ construction vtable group. */ ++ vtbl = build_vtable (t, id, ptr_type_node); ++ list = build_tree_list (vtbl, NULL_TREE); ++ accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)), ++ binfo, t, list); ++ ++ /* Add the vtables for each of our virtual bases using the vbase in T ++ binfo. */ ++ for (vbase = TYPE_BINFO (BINFO_TYPE (binfo)); ++ vbase; ++ vbase = TREE_CHAIN (vbase)) ++ { ++ tree b; ++ ++ if (!TREE_VIA_VIRTUAL (vbase)) ++ continue; ++ b = copied_binfo (vbase, binfo); ++ ++ accumulate_vtbl_inits (b, vbase, binfo, t, list); ++ } ++ inits = TREE_VALUE (list); ++ ++ /* Figure out the type of the construction vtable. */ ++ type = build_index_type (size_int (list_length (inits) - 1)); ++ type = build_cplus_array_type (vtable_entry_type, type); ++ TREE_TYPE (vtbl) = type; ++ ++ /* Initialize the construction vtable. */ ++ CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl); ++ initialize_array (vtbl, inits); ++ dump_vtable (t, binfo, vtbl); ++} ++ ++/* Add the vtbl initializers for BINFO (and its bases other than ++ non-virtual primaries) to the list of INITS. BINFO is in the ++ hierarchy dominated by T. RTTI_BINFO is the binfo within T of ++ the constructor the vtbl inits should be accumulated for. (If this ++ is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).) ++ ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO). ++ BINFO is the active base equivalent of ORIG_BINFO in the inheritance ++ graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE, ++ but are not necessarily the same in terms of layout. */ ++ ++static void ++accumulate_vtbl_inits (tree binfo, ++ tree orig_binfo, ++ tree rtti_binfo, ++ tree t, ++ tree inits) ++{ ++ int i; ++ int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t); ++ ++ my_friendly_assert (same_type_p (BINFO_TYPE (binfo), ++ BINFO_TYPE (orig_binfo)), ++ 20000517); ++ ++ /* If it doesn't have a vptr, we don't do anything. */ ++ if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) ++ return; ++ ++ /* If we're building a construction vtable, we're not interested in ++ subobjects that don't require construction vtables. */ ++ if (ctor_vtbl_p ++ && !TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)) ++ && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo))) ++ return; ++ ++ /* Build the initializers for the BINFO-in-T vtable. */ ++ TREE_VALUE (inits) ++ = chainon (TREE_VALUE (inits), ++ dfs_accumulate_vtbl_inits (binfo, orig_binfo, ++ rtti_binfo, t, inits)); ++ ++ /* Walk the BINFO and its bases. We walk in preorder so that as we ++ initialize each vtable we can figure out at what offset the ++ secondary vtable lies from the primary vtable. We can't use ++ dfs_walk here because we need to iterate through bases of BINFO ++ and RTTI_BINFO simultaneously. */ ++ for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i) ++ { ++ tree base_binfo = BINFO_BASETYPE (binfo, i); ++ ++ /* Skip virtual bases. */ ++ if (TREE_VIA_VIRTUAL (base_binfo)) ++ continue; ++ accumulate_vtbl_inits (base_binfo, ++ BINFO_BASETYPE (orig_binfo, i), ++ rtti_binfo, t, ++ inits); ++ } ++} ++ ++/* Called from accumulate_vtbl_inits. Returns the initializers for ++ the BINFO vtable. */ ++ ++static tree ++dfs_accumulate_vtbl_inits (tree binfo, ++ tree orig_binfo, ++ tree rtti_binfo, ++ tree t, ++ tree l) ++{ ++ tree inits = NULL_TREE; ++ tree vtbl = NULL_TREE; ++ int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t); ++ ++ if (ctor_vtbl_p ++ && TREE_VIA_VIRTUAL (orig_binfo) && BINFO_PRIMARY_P (orig_binfo)) ++ { ++ /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a ++ primary virtual base. If it is not the same primary in ++ the hierarchy of T, we'll need to generate a ctor vtable ++ for it, to place at its location in T. If it is the same ++ primary, we still need a VTT entry for the vtable, but it ++ should point to the ctor vtable for the base it is a ++ primary for within the sub-hierarchy of RTTI_BINFO. ++ ++ There are three possible cases: ++ ++ 1) We are in the same place. ++ 2) We are a primary base within a lost primary virtual base of ++ RTTI_BINFO. ++ 3) We are primary to something not a base of RTTI_BINFO. */ ++ ++ tree b = BINFO_PRIMARY_BASE_OF (binfo); ++ tree last = NULL_TREE; ++ ++ /* First, look through the bases we are primary to for RTTI_BINFO ++ or a virtual base. */ ++ for (; b; b = BINFO_PRIMARY_BASE_OF (b)) ++ { ++ last = b; ++ if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo) ++ break; ++ } ++ /* If we run out of primary links, keep looking down our ++ inheritance chain; we might be an indirect primary. */ ++ if (b == NULL_TREE) ++ for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b)) ++ if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo) ++ break; ++ ++ /* If we found RTTI_BINFO, this is case 1. If we found a virtual ++ base B and it is a base of RTTI_BINFO, this is case 2. In ++ either case, we share our vtable with LAST, i.e. the ++ derived-most base within B of which we are a primary. */ ++ if (b == rtti_binfo ++ || (b && purpose_member (BINFO_TYPE (b), ++ CLASSTYPE_VBASECLASSES (BINFO_TYPE (rtti_binfo))))) ++ /* Just set our BINFO_VTABLE to point to LAST, as we may not have ++ set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in ++ binfo_ctor_vtable after everything's been set up. */ ++ vtbl = last; ++ ++ /* Otherwise, this is case 3 and we get our own. */ ++ } ++ else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo)) ++ return inits; ++ ++ if (!vtbl) ++ { ++ tree index; ++ int non_fn_entries; ++ ++ /* Compute the initializer for this vtable. */ ++ inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo, ++ &non_fn_entries); ++ ++ /* Figure out the position to which the VPTR should point. */ ++ vtbl = TREE_PURPOSE (l); ++ vtbl = build1 (ADDR_EXPR, ++ vtbl_ptr_type_node, ++ vtbl); ++ TREE_CONSTANT (vtbl) = 1; ++ index = size_binop (PLUS_EXPR, ++ size_int (non_fn_entries), ++ size_int (list_length (TREE_VALUE (l)))); ++ index = size_binop (MULT_EXPR, ++ TYPE_SIZE_UNIT (vtable_entry_type), ++ index); ++ vtbl = build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index); ++ TREE_CONSTANT (vtbl) = 1; ++ } ++ ++ if (ctor_vtbl_p) ++ /* For a construction vtable, we can't overwrite BINFO_VTABLE. ++ So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will ++ straighten this out. */ ++ BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo)); ++ else if (BINFO_PRIMARY_P (binfo) && TREE_VIA_VIRTUAL (binfo)) ++ inits = NULL_TREE; ++ else ++ /* For an ordinary vtable, set BINFO_VTABLE. */ ++ BINFO_VTABLE (binfo) = vtbl; ++ ++ return inits; ++} ++ ++/* Construct the initializer for BINFO's virtual function table. BINFO ++ is part of the hierarchy dominated by T. If we're building a ++ construction vtable, the ORIG_BINFO is the binfo we should use to ++ find the actual function pointers to put in the vtable - but they ++ can be overridden on the path to most-derived in the graph that ++ ORIG_BINFO belongs. Otherwise, ++ ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the ++ BINFO that should be indicated by the RTTI information in the ++ vtable; it will be a base class of T, rather than T itself, if we ++ are building a construction vtable. ++ ++ The value returned is a TREE_LIST suitable for wrapping in a ++ CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If ++ NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the ++ number of non-function entries in the vtable. ++ ++ It might seem that this function should never be called with a ++ BINFO for which BINFO_PRIMARY_P holds, the vtable for such a ++ base is always subsumed by a derived class vtable. However, when ++ we are building construction vtables, we do build vtables for ++ primary bases; we need these while the primary base is being ++ constructed. */ ++ ++static tree ++build_vtbl_initializer (tree binfo, ++ tree orig_binfo, ++ tree t, ++ tree rtti_binfo, ++ int* non_fn_entries_p) ++{ ++ tree v, b; ++ tree vfun_inits; ++ tree vbase; ++ vtbl_init_data vid; ++ ++ /* Initialize VID. */ ++ memset (&vid, 0, sizeof (vid)); ++ vid.binfo = binfo; ++ vid.derived = t; ++ vid.rtti_binfo = rtti_binfo; ++ vid.last_init = &vid.inits; ++ vid.primary_vtbl_p = (binfo == TYPE_BINFO (t)); ++ vid.ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t); ++ vid.generate_vcall_entries = true; ++ /* The first vbase or vcall offset is at index -3 in the vtable. */ ++ vid.index = ssize_int (-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE); ++ ++ /* Add entries to the vtable for RTTI. */ ++ build_rtti_vtbl_entries (binfo, &vid); ++ ++ /* Create an array for keeping track of the functions we've ++ processed. When we see multiple functions with the same ++ signature, we share the vcall offsets. */ ++ VARRAY_TREE_INIT (vid.fns, 32, "fns"); ++ /* Add the vcall and vbase offset entries. */ ++ build_vcall_and_vbase_vtbl_entries (binfo, &vid); ++ /* Clear BINFO_VTABLE_PATH_MARKED; it's set by ++ build_vbase_offset_vtbl_entries. */ ++ for (vbase = CLASSTYPE_VBASECLASSES (t); ++ vbase; ++ vbase = TREE_CHAIN (vbase)) ++ BINFO_VTABLE_PATH_MARKED (TREE_VALUE (vbase)) = 0; ++ ++ /* If the target requires padding between data entries, add that now. */ ++ if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1) ++ { ++ tree cur, *prev; ++ ++ for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur)) ++ { ++ tree add = cur; ++ int i; ++ ++ for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i) ++ add = tree_cons (NULL_TREE, ++ build1 (NOP_EXPR, vtable_entry_type, ++ null_pointer_node), ++ add); ++ *prev = add; ++ } ++ } ++ ++ if (non_fn_entries_p) ++ *non_fn_entries_p = list_length (vid.inits); ++ ++ /* Go through all the ordinary virtual functions, building up ++ initializers. */ ++ vfun_inits = NULL_TREE; ++ for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v)) ++ { ++ tree delta; ++ tree vcall_index; ++ tree fn, fn_original; ++ tree init = NULL_TREE; ++ ++ fn = BV_FN (v); ++ fn_original = fn; ++ if (DECL_THUNK_P (fn)) ++ { ++ if (!DECL_NAME (fn)) ++ finish_thunk (fn); ++ if (THUNK_ALIAS (fn)) ++ { ++ fn = THUNK_ALIAS (fn); ++ BV_FN (v) = fn; ++ } ++ fn_original = THUNK_TARGET (fn); ++ } ++ ++ /* If the only definition of this function signature along our ++ primary base chain is from a lost primary, this vtable slot will ++ never be used, so just zero it out. This is important to avoid ++ requiring extra thunks which cannot be generated with the function. ++ ++ We first check this in update_vtable_entry_for_fn, so we handle ++ restored primary bases properly; we also need to do it here so we ++ zero out unused slots in ctor vtables, rather than filling themff ++ with erroneous values (though harmless, apart from relocation ++ costs). */ ++ for (b = binfo; ; b = get_primary_binfo (b)) ++ { ++ /* We found a defn before a lost primary; go ahead as normal. */ ++ if (look_for_overrides_here (BINFO_TYPE (b), fn_original)) ++ break; ++ ++ /* The nearest definition is from a lost primary; clear the ++ slot. */ ++ if (BINFO_LOST_PRIMARY_P (b)) ++ { ++ init = size_zero_node; ++ break; ++ } ++ } ++ ++ if (! init) ++ { ++ /* Pull the offset for `this', and the function to call, out of ++ the list. */ ++ delta = BV_DELTA (v); ++ vcall_index = BV_VCALL_INDEX (v); ++ ++ my_friendly_assert (TREE_CODE (delta) == INTEGER_CST, 19990727); ++ my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 19990727); ++ ++ /* You can't call an abstract virtual function; it's abstract. ++ So, we replace these functions with __pure_virtual. */ ++ if (DECL_PURE_VIRTUAL_P (fn_original)) ++ fn = abort_fndecl; ++ else if (!integer_zerop (delta) || vcall_index) ++ { ++ fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index); ++ if (!DECL_NAME (fn)) ++ finish_thunk (fn); ++ } ++ /* Take the address of the function, considering it to be of an ++ appropriate generic type. */ ++ init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn); ++ /* The address of a function can't change. */ ++ TREE_CONSTANT (init) = 1; ++ } ++ ++ /* And add it to the chain of initializers. */ ++ if (TARGET_VTABLE_USES_DESCRIPTORS) ++ { ++ int i; ++ if (init == size_zero_node) ++ for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i) ++ vfun_inits = tree_cons (NULL_TREE, init, vfun_inits); ++ else ++ for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i) ++ { ++ tree fdesc = build (FDESC_EXPR, vfunc_ptr_type_node, ++ TREE_OPERAND (init, 0), ++ build_int_2 (i, 0)); ++ TREE_CONSTANT (fdesc) = 1; ++ ++ vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits); ++ } ++ } ++ else ++ vfun_inits = tree_cons (NULL_TREE, init, vfun_inits); ++ } ++ ++ /* The initializers for virtual functions were built up in reverse ++ order; straighten them out now. */ ++ vfun_inits = nreverse (vfun_inits); ++ ++ /* The negative offset initializers are also in reverse order. */ ++ vid.inits = nreverse (vid.inits); ++ ++ /* Chain the two together. */ ++ return chainon (vid.inits, vfun_inits); ++} ++ ++/* Adds to vid->inits the initializers for the vbase and vcall ++ offsets in BINFO, which is in the hierarchy dominated by T. */ ++ ++static void ++build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid) ++{ ++ tree b; ++ ++ /* If this is a derived class, we must first create entries ++ corresponding to the primary base class. */ ++ b = get_primary_binfo (binfo); ++ if (b) ++ build_vcall_and_vbase_vtbl_entries (b, vid); ++ ++ /* Add the vbase entries for this base. */ ++ build_vbase_offset_vtbl_entries (binfo, vid); ++ /* Add the vcall entries for this base. */ ++ build_vcall_offset_vtbl_entries (binfo, vid); ++} ++ ++/* Returns the initializers for the vbase offset entries in the vtable ++ for BINFO (which is part of the class hierarchy dominated by T), in ++ reverse order. VBASE_OFFSET_INDEX gives the vtable index ++ where the next vbase offset will go. */ ++ ++static void ++build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid) ++{ ++ tree vbase; ++ tree t; ++ tree non_primary_binfo; ++ ++ /* If there are no virtual baseclasses, then there is nothing to ++ do. */ ++ if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))) ++ return; ++ ++ t = vid->derived; ++ ++ /* We might be a primary base class. Go up the inheritance hierarchy ++ until we find the most derived class of which we are a primary base: ++ it is the offset of that which we need to use. */ ++ non_primary_binfo = binfo; ++ while (BINFO_INHERITANCE_CHAIN (non_primary_binfo)) ++ { ++ tree b; ++ ++ /* If we have reached a virtual base, then it must be a primary ++ base (possibly multi-level) of vid->binfo, or we wouldn't ++ have called build_vcall_and_vbase_vtbl_entries for it. But it ++ might be a lost primary, so just skip down to vid->binfo. */ ++ if (TREE_VIA_VIRTUAL (non_primary_binfo)) ++ { ++ non_primary_binfo = vid->binfo; ++ break; ++ } ++ ++ b = BINFO_INHERITANCE_CHAIN (non_primary_binfo); ++ if (get_primary_binfo (b) != non_primary_binfo) ++ break; ++ non_primary_binfo = b; ++ } ++ ++ /* Go through the virtual bases, adding the offsets. */ ++ for (vbase = TYPE_BINFO (BINFO_TYPE (binfo)); ++ vbase; ++ vbase = TREE_CHAIN (vbase)) ++ { ++ tree b; ++ tree delta; ++ ++ if (!TREE_VIA_VIRTUAL (vbase)) ++ continue; ++ ++ /* Find the instance of this virtual base in the complete ++ object. */ ++ b = copied_binfo (vbase, binfo); ++ ++ /* If we've already got an offset for this virtual base, we ++ don't need another one. */ ++ if (BINFO_VTABLE_PATH_MARKED (b)) ++ continue; ++ BINFO_VTABLE_PATH_MARKED (b) = 1; ++ ++ /* Figure out where we can find this vbase offset. */ ++ delta = size_binop (MULT_EXPR, ++ vid->index, ++ convert (ssizetype, ++ TYPE_SIZE_UNIT (vtable_entry_type))); ++ if (vid->primary_vtbl_p) ++ BINFO_VPTR_FIELD (b) = delta; ++ ++ if (binfo != TYPE_BINFO (t)) ++ { ++ /* The vbase offset had better be the same. */ ++ my_friendly_assert (tree_int_cst_equal (delta, ++ BINFO_VPTR_FIELD (vbase)), ++ 20030202); ++ } ++ ++ /* The next vbase will come at a more negative offset. */ ++ vid->index = size_binop (MINUS_EXPR, vid->index, ++ ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE)); ++ ++ /* The initializer is the delta from BINFO to this virtual base. ++ The vbase offsets go in reverse inheritance-graph order, and ++ we are walking in inheritance graph order so these end up in ++ the right order. */ ++ delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo)); ++ ++ *vid->last_init ++ = build_tree_list (NULL_TREE, ++ fold (build1 (NOP_EXPR, ++ vtable_entry_type, ++ delta))); ++ vid->last_init = &TREE_CHAIN (*vid->last_init); ++ } ++} ++ ++/* Adds the initializers for the vcall offset entries in the vtable ++ for BINFO (which is part of the class hierarchy dominated by VID->DERIVED) ++ to VID->INITS. */ ++ ++static void ++build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid) ++{ ++ /* We only need these entries if this base is a virtual base. We ++ compute the indices -- but do not add to the vtable -- when ++ building the main vtable for a class. */ ++ if (TREE_VIA_VIRTUAL (binfo) || binfo == TYPE_BINFO (vid->derived)) ++ { ++ /* We need a vcall offset for each of the virtual functions in this ++ vtable. For example: ++ ++ class A { virtual void f (); }; ++ class B1 : virtual public A { virtual void f (); }; ++ class B2 : virtual public A { virtual void f (); }; ++ class C: public B1, public B2 { virtual void f (); }; ++ ++ A C object has a primary base of B1, which has a primary base of A. A ++ C also has a secondary base of B2, which no longer has a primary base ++ of A. So the B2-in-C construction vtable needs a secondary vtable for ++ A, which will adjust the A* to a B2* to call f. We have no way of ++ knowing what (or even whether) this offset will be when we define B2, ++ so we store this "vcall offset" in the A sub-vtable and look it up in ++ a "virtual thunk" for B2::f. ++ ++ We need entries for all the functions in our primary vtable and ++ in our non-virtual bases' secondary vtables. */ ++ vid->vbase = binfo; ++ /* If we are just computing the vcall indices -- but do not need ++ the actual entries -- not that. */ ++ if (!TREE_VIA_VIRTUAL (binfo)) ++ vid->generate_vcall_entries = false; ++ /* Now, walk through the non-virtual bases, adding vcall offsets. */ ++ add_vcall_offset_vtbl_entries_r (binfo, vid); ++ } ++} ++ ++/* Build vcall offsets, starting with those for BINFO. */ ++ ++static void ++add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid) ++{ ++ int i; ++ tree primary_binfo; ++ ++ /* Don't walk into virtual bases -- except, of course, for the ++ virtual base for which we are building vcall offsets. Any ++ primary virtual base will have already had its offsets generated ++ through the recursion in build_vcall_and_vbase_vtbl_entries. */ ++ if (TREE_VIA_VIRTUAL (binfo) && vid->vbase != binfo) ++ return; ++ ++ /* If BINFO has a primary base, process it first. */ ++ primary_binfo = get_primary_binfo (binfo); ++ if (primary_binfo) ++ add_vcall_offset_vtbl_entries_r (primary_binfo, vid); ++ ++ /* Add BINFO itself to the list. */ ++ add_vcall_offset_vtbl_entries_1 (binfo, vid); ++ ++ /* Scan the non-primary bases of BINFO. */ ++ for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i) ++ { ++ tree base_binfo; ++ ++ base_binfo = BINFO_BASETYPE (binfo, i); ++ if (base_binfo != primary_binfo) ++ add_vcall_offset_vtbl_entries_r (base_binfo, vid); ++ } ++} ++ ++/* Called from build_vcall_offset_vtbl_entries_r. */ ++ ++static void ++add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid) ++{ ++ /* Make entries for the rest of the virtuals. */ ++ if (abi_version_at_least (2)) ++ { ++ tree orig_fn; ++ ++ /* The ABI requires that the methods be processed in declaration ++ order. G++ 3.2 used the order in the vtable. */ ++ for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo)); ++ orig_fn; ++ orig_fn = TREE_CHAIN (orig_fn)) ++ if (DECL_VINDEX (orig_fn)) ++ add_vcall_offset (orig_fn, binfo, vid); ++ } ++ else ++ { ++ tree derived_virtuals; ++ tree base_virtuals; ++ tree orig_virtuals; ++ /* If BINFO is a primary base, the most derived class which has ++ BINFO as a primary base; otherwise, just BINFO. */ ++ tree non_primary_binfo; ++ ++ /* We might be a primary base class. Go up the inheritance hierarchy ++ until we find the most derived class of which we are a primary base: ++ it is the BINFO_VIRTUALS there that we need to consider. */ ++ non_primary_binfo = binfo; ++ while (BINFO_INHERITANCE_CHAIN (non_primary_binfo)) ++ { ++ tree b; ++ ++ /* If we have reached a virtual base, then it must be vid->vbase, ++ because we ignore other virtual bases in ++ add_vcall_offset_vtbl_entries_r. In turn, it must be a primary ++ base (possibly multi-level) of vid->binfo, or we wouldn't ++ have called build_vcall_and_vbase_vtbl_entries for it. But it ++ might be a lost primary, so just skip down to vid->binfo. */ ++ if (TREE_VIA_VIRTUAL (non_primary_binfo)) ++ { ++ if (non_primary_binfo != vid->vbase) ++ abort (); ++ non_primary_binfo = vid->binfo; ++ break; ++ } ++ ++ b = BINFO_INHERITANCE_CHAIN (non_primary_binfo); ++ if (get_primary_binfo (b) != non_primary_binfo) ++ break; ++ non_primary_binfo = b; ++ } ++ ++ if (vid->ctor_vtbl_p) ++ /* For a ctor vtable we need the equivalent binfo within the hierarchy ++ where rtti_binfo is the most derived type. */ ++ non_primary_binfo ++ = original_binfo (non_primary_binfo, vid->rtti_binfo); ++ ++ for (base_virtuals = BINFO_VIRTUALS (binfo), ++ derived_virtuals = BINFO_VIRTUALS (non_primary_binfo), ++ orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo))); ++ base_virtuals; ++ base_virtuals = TREE_CHAIN (base_virtuals), ++ derived_virtuals = TREE_CHAIN (derived_virtuals), ++ orig_virtuals = TREE_CHAIN (orig_virtuals)) ++ { ++ tree orig_fn; ++ ++ /* Find the declaration that originally caused this function to ++ be present in BINFO_TYPE (binfo). */ ++ orig_fn = BV_FN (orig_virtuals); ++ ++ /* When processing BINFO, we only want to generate vcall slots for ++ function slots introduced in BINFO. So don't try to generate ++ one if the function isn't even defined in BINFO. */ ++ if (!same_type_p (DECL_CONTEXT (orig_fn), BINFO_TYPE (binfo))) ++ continue; ++ ++ add_vcall_offset (orig_fn, binfo, vid); ++ } ++ } ++} ++ ++/* Add a vcall offset entry for ORIG_FN to the vtable. */ ++ ++static void ++add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid) ++{ ++ size_t i; ++ tree vcall_offset; ++ ++ /* If there is already an entry for a function with the same ++ signature as FN, then we do not need a second vcall offset. ++ Check the list of functions already present in the derived ++ class vtable. */ ++ for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i) ++ { ++ tree derived_entry; ++ ++ derived_entry = VARRAY_TREE (vid->fns, i); ++ if (same_signature_p (derived_entry, orig_fn) ++ /* We only use one vcall offset for virtual destructors, ++ even though there are two virtual table entries. */ ++ || (DECL_DESTRUCTOR_P (derived_entry) ++ && DECL_DESTRUCTOR_P (orig_fn))) ++ return; ++ } ++ ++ /* If we are building these vcall offsets as part of building ++ the vtable for the most derived class, remember the vcall ++ offset. */ ++ if (vid->binfo == TYPE_BINFO (vid->derived)) ++ CLASSTYPE_VCALL_INDICES (vid->derived) ++ = tree_cons (orig_fn, vid->index, ++ CLASSTYPE_VCALL_INDICES (vid->derived)); ++ ++ /* The next vcall offset will be found at a more negative ++ offset. */ ++ vid->index = size_binop (MINUS_EXPR, vid->index, ++ ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE)); ++ ++ /* Keep track of this function. */ ++ VARRAY_PUSH_TREE (vid->fns, orig_fn); ++ ++ if (vid->generate_vcall_entries) ++ { ++ tree base; ++ tree fn; ++ ++ /* Find the overriding function. */ ++ fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn); ++ if (fn == error_mark_node) ++ vcall_offset = build1 (NOP_EXPR, vtable_entry_type, ++ integer_zero_node); ++ else ++ { ++ base = TREE_VALUE (fn); ++ ++ /* The vbase we're working on is a primary base of ++ vid->binfo. But it might be a lost primary, so its ++ BINFO_OFFSET might be wrong, so we just use the ++ BINFO_OFFSET from vid->binfo. */ ++ vcall_offset = size_diffop (BINFO_OFFSET (base), ++ BINFO_OFFSET (vid->binfo)); ++ vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type, ++ vcall_offset)); ++ } ++ /* Add the initializer to the vtable. */ ++ *vid->last_init = build_tree_list (NULL_TREE, vcall_offset); ++ vid->last_init = &TREE_CHAIN (*vid->last_init); ++ } ++} ++ ++/* Return vtbl initializers for the RTTI entries corresponding to the ++ BINFO's vtable. The RTTI entries should indicate the object given ++ by VID->rtti_binfo. */ ++ ++static void ++build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid) ++{ ++ tree b; ++ tree t; ++ tree basetype; ++ tree offset; ++ tree decl; ++ tree init; ++ ++ basetype = BINFO_TYPE (binfo); ++ t = BINFO_TYPE (vid->rtti_binfo); ++ ++ /* To find the complete object, we will first convert to our most ++ primary base, and then add the offset in the vtbl to that value. */ ++ b = binfo; ++ while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b)) ++ && !BINFO_LOST_PRIMARY_P (b)) ++ { ++ tree primary_base; ++ ++ primary_base = get_primary_binfo (b); ++ my_friendly_assert (BINFO_PRIMARY_BASE_OF (primary_base) == b, 20010127); ++ b = primary_base; ++ } ++ offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b)); ++ ++ /* The second entry is the address of the typeinfo object. */ ++ if (flag_rtti) ++ decl = build_address (get_tinfo_decl (t)); ++ else ++ decl = integer_zero_node; ++ ++ /* Convert the declaration to a type that can be stored in the ++ vtable. */ ++ init = build_nop (vfunc_ptr_type_node, decl); ++ *vid->last_init = build_tree_list (NULL_TREE, init); ++ vid->last_init = &TREE_CHAIN (*vid->last_init); ++ ++ /* Add the offset-to-top entry. It comes earlier in the vtable that ++ the the typeinfo entry. Convert the offset to look like a ++ function pointer, so that we can put it in the vtable. */ ++ init = build_nop (vfunc_ptr_type_node, offset); ++ *vid->last_init = build_tree_list (NULL_TREE, init); ++ vid->last_init = &TREE_CHAIN (*vid->last_init); ++} +diff -NBaur gcc-3.4.4/gcc/cp/config-lang.in gcc-3.4.4-new/gcc/cp/config-lang.in +--- gcc-3.4.4/gcc/cp/config-lang.in Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/config-lang.in Mon Jun 23 21:52:12 2003 +@@ -0,0 +1,37 @@ ++# Top level configure fragment for GNU C++. ++# Copyright (C) 1994, 1995, 1997, 1998, 2000, 2001, 2002 ++# Free Software Foundation, Inc. ++ ++#This file is part of GCC. ++ ++#GCC is free software; you can redistribute it and/or modify ++#it under the terms of the GNU General Public License as published by ++#the Free Software Foundation; either version 2, or (at your option) ++#any later version. ++ ++#GCC is distributed in the hope that it will be useful, ++#but WITHOUT ANY WARRANTY; without even the implied warranty of ++#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++#GNU General Public License for more details. ++ ++#You should have received a copy of the GNU General Public License ++#along with GCC; see the file COPYING. If not, write to ++#the Free Software Foundation, 59 Temple Place - Suite 330, ++#Boston, MA 02111-1307, USA. ++ ++# Configure looks for the existence of this file to auto-config each language. ++# We define several parameters used by configure: ++# ++# language - name of language as it would appear in $(LANGUAGES) ++# compilers - value to add to $(COMPILERS) ++# stagestuff - files to add to $(STAGESTUFF) ++ ++language="c++" ++ ++compilers="cc1plus\$(exeext)" ++ ++stagestuff="g++\$(exeext) g++-cross\$(exeext) cc1plus\$(exeext)" ++ ++target_libs="target-libstdc++-v3 target-gperf" ++ ++gtfiles="\$(srcdir)/cp/mangle.c \$(srcdir)/cp/name-lookup.h \$(srcdir)/cp/name-lookup.c \$(srcdir)/cp/cp-tree.h \$(srcdir)/cp/decl.h \$(srcdir)/cp/lex.h \$(srcdir)/cp/call.c \$(srcdir)/cp/decl.c \$(srcdir)/cp/decl2.c \$(srcdir)/cp/pt.c \$(srcdir)/cp/repo.c \$(srcdir)/cp/semantics.c \$(srcdir)/cp/tree.c \$(srcdir)/cp/parser.c \$(srcdir)/cp/method.c \$(srcdir)/c-common.c \$(srcdir)/c-common.h \$(srcdir)/c-pragma.c" +diff -NBaur gcc-3.4.4/gcc/cp/cp-lang.c gcc-3.4.4-new/gcc/cp/cp-lang.c +--- gcc-3.4.4/gcc/cp/cp-lang.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cp-lang.c Tue Dec 23 16:53:47 2003 +@@ -0,0 +1,414 @@ ++/* Language-dependent hooks for C++. ++ Copyright 2001, 2002 Free Software Foundation, Inc. ++ Contributed by Alexandre Oliva ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "cp-tree.h" ++#include "c-common.h" ++#include "toplev.h" ++#include "langhooks.h" ++#include "langhooks-def.h" ++#include "diagnostic.h" ++#include "cxx-pretty-print.h" ++ ++enum c_language_kind c_language = clk_cxx; ++ ++static HOST_WIDE_INT cxx_get_alias_set (tree); ++static bool ok_to_generate_alias_set_for_type (tree); ++static bool cxx_warn_unused_global_decl (tree); ++static tree cp_expr_size (tree); ++static size_t cp_tree_size (enum tree_code); ++static bool cp_var_mod_type_p (tree); ++static void cxx_initialize_diagnostics (diagnostic_context *); ++ ++#undef LANG_HOOKS_NAME ++#define LANG_HOOKS_NAME "GNU C++" ++#undef LANG_HOOKS_TREE_SIZE ++#define LANG_HOOKS_TREE_SIZE cp_tree_size ++#undef LANG_HOOKS_INIT ++#define LANG_HOOKS_INIT cxx_init ++#undef LANG_HOOKS_FINISH ++#define LANG_HOOKS_FINISH cxx_finish ++#undef LANG_HOOKS_CLEAR_BINDING_STACK ++#define LANG_HOOKS_CLEAR_BINDING_STACK pop_everything ++#undef LANG_HOOKS_INIT_OPTIONS ++#define LANG_HOOKS_INIT_OPTIONS c_common_init_options ++#undef LANG_HOOKS_INITIALIZE_DIAGNOSTICS ++#define LANG_HOOKS_INITIALIZE_DIAGNOSTICS cxx_initialize_diagnostics ++#undef LANG_HOOKS_HANDLE_OPTION ++#define LANG_HOOKS_HANDLE_OPTION c_common_handle_option ++#undef LANG_HOOKS_HANDLE_FILENAME ++#define LANG_HOOKS_HANDLE_FILENAME c_common_handle_filename ++#undef LANG_HOOKS_MISSING_ARGUMENT ++#define LANG_HOOKS_MISSING_ARGUMENT c_common_missing_argument ++#undef LANG_HOOKS_POST_OPTIONS ++#define LANG_HOOKS_POST_OPTIONS c_common_post_options ++#undef LANG_HOOKS_GET_ALIAS_SET ++#define LANG_HOOKS_GET_ALIAS_SET cxx_get_alias_set ++#undef LANG_HOOKS_EXPAND_CONSTANT ++#define LANG_HOOKS_EXPAND_CONSTANT cplus_expand_constant ++#undef LANG_HOOKS_EXPAND_EXPR ++#define LANG_HOOKS_EXPAND_EXPR cxx_expand_expr ++#undef LANG_HOOKS_SAFE_FROM_P ++#define LANG_HOOKS_SAFE_FROM_P c_safe_from_p ++#undef LANG_HOOKS_PARSE_FILE ++#define LANG_HOOKS_PARSE_FILE c_common_parse_file ++#undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL ++#define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL cxx_dup_lang_specific_decl ++#undef LANG_HOOKS_UNSAVE_EXPR_NOW ++#define LANG_HOOKS_UNSAVE_EXPR_NOW cxx_unsave_expr_now ++#undef LANG_HOOKS_MAYBE_BUILD_CLEANUP ++#define LANG_HOOKS_MAYBE_BUILD_CLEANUP cxx_maybe_build_cleanup ++#undef LANG_HOOKS_TRUTHVALUE_CONVERSION ++#define LANG_HOOKS_TRUTHVALUE_CONVERSION c_common_truthvalue_conversion ++#undef LANG_HOOKS_UNSAFE_FOR_REEVAL ++#define LANG_HOOKS_UNSAFE_FOR_REEVAL c_common_unsafe_for_reeval ++#undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME ++#define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME mangle_decl ++#undef LANG_HOOKS_MARK_ADDRESSABLE ++#define LANG_HOOKS_MARK_ADDRESSABLE cxx_mark_addressable ++#undef LANG_HOOKS_PRINT_STATISTICS ++#define LANG_HOOKS_PRINT_STATISTICS cxx_print_statistics ++#undef LANG_HOOKS_PRINT_XNODE ++#define LANG_HOOKS_PRINT_XNODE cxx_print_xnode ++#undef LANG_HOOKS_PRINT_DECL ++#define LANG_HOOKS_PRINT_DECL cxx_print_decl ++#undef LANG_HOOKS_PRINT_TYPE ++#define LANG_HOOKS_PRINT_TYPE cxx_print_type ++#undef LANG_HOOKS_PRINT_IDENTIFIER ++#define LANG_HOOKS_PRINT_IDENTIFIER cxx_print_identifier ++#undef LANG_HOOKS_DECL_PRINTABLE_NAME ++#define LANG_HOOKS_DECL_PRINTABLE_NAME cxx_printable_name ++#undef LANG_HOOKS_PRINT_ERROR_FUNCTION ++#define LANG_HOOKS_PRINT_ERROR_FUNCTION cxx_print_error_function ++#undef LANG_HOOKS_BUILTIN_TYPE_DECLS ++#define LANG_HOOKS_BUILTIN_TYPE_DECLS cxx_builtin_type_decls ++#undef LANG_HOOKS_PUSHLEVEL ++#define LANG_HOOKS_PUSHLEVEL lhd_do_nothing_i ++#undef LANG_HOOKS_POPLEVEL ++#define LANG_HOOKS_POPLEVEL lhd_do_nothing_iii_return_null_tree ++#undef LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL ++#define LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL cxx_warn_unused_global_decl ++#undef LANG_HOOKS_WRITE_GLOBALS ++#define LANG_HOOKS_WRITE_GLOBALS lhd_do_nothing ++#undef LANG_HOOKS_DECL_UNINIT ++#define LANG_HOOKS_DECL_UNINIT c_decl_uninit ++ ++ ++#undef LANG_HOOKS_FUNCTION_INIT ++#define LANG_HOOKS_FUNCTION_INIT cxx_push_function_context ++#undef LANG_HOOKS_FUNCTION_FINAL ++#define LANG_HOOKS_FUNCTION_FINAL cxx_pop_function_context ++ ++#undef LANG_HOOKS_RTL_EXPAND_START ++#define LANG_HOOKS_RTL_EXPAND_START cxx_expand_function_start ++#undef LANG_HOOKS_RTL_EXPAND_STMT ++#define LANG_HOOKS_RTL_EXPAND_STMT expand_stmt ++ ++/* Attribute hooks. */ ++#undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE ++#define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE c_common_attribute_table ++#undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE ++#define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE c_common_format_attribute_table ++#undef LANG_HOOKS_ATTRIBUTE_TABLE ++#define LANG_HOOKS_ATTRIBUTE_TABLE cxx_attribute_table ++ ++#undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES ++#define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES \ ++ cp_walk_subtrees ++#undef LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN ++#define LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN \ ++ cp_cannot_inline_tree_fn ++#undef LANG_HOOKS_TREE_INLINING_ADD_PENDING_FN_DECLS ++#define LANG_HOOKS_TREE_INLINING_ADD_PENDING_FN_DECLS \ ++ cp_add_pending_fn_decls ++#undef LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P ++#define LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P \ ++ cp_is_overload_p ++#undef LANG_HOOKS_TREE_INLINING_AUTO_VAR_IN_FN_P ++#define LANG_HOOKS_TREE_INLINING_AUTO_VAR_IN_FN_P \ ++ cp_auto_var_in_fn_p ++#undef LANG_HOOKS_TREE_INLINING_COPY_RES_DECL_FOR_INLINING ++#define LANG_HOOKS_TREE_INLINING_COPY_RES_DECL_FOR_INLINING \ ++ cp_copy_res_decl_for_inlining ++#undef LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P ++#define LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P anon_aggr_type_p ++#undef LANG_HOOKS_TREE_INLINING_VAR_MOD_TYPE_P ++#define LANG_HOOKS_TREE_INLINING_VAR_MOD_TYPE_P cp_var_mod_type_p ++#undef LANG_HOOKS_TREE_INLINING_ESTIMATE_NUM_INSNS ++#define LANG_HOOKS_TREE_INLINING_ESTIMATE_NUM_INSNS c_estimate_num_insns ++#undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN ++#define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN cp_dump_tree ++#undef LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN ++#define LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN cp_type_quals ++#undef LANG_HOOKS_EXPR_SIZE ++#define LANG_HOOKS_EXPR_SIZE cp_expr_size ++ ++#undef LANG_HOOKS_CALLGRAPH_ANALYZE_EXPR ++#define LANG_HOOKS_CALLGRAPH_ANALYZE_EXPR cxx_callgraph_analyze_expr ++#undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION ++#define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION expand_body ++ ++#undef LANG_HOOKS_MAKE_TYPE ++#define LANG_HOOKS_MAKE_TYPE cxx_make_type ++#undef LANG_HOOKS_TYPE_FOR_MODE ++#define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode ++#undef LANG_HOOKS_TYPE_FOR_SIZE ++#define LANG_HOOKS_TYPE_FOR_SIZE c_common_type_for_size ++#undef LANG_HOOKS_SIGNED_TYPE ++#define LANG_HOOKS_SIGNED_TYPE c_common_signed_type ++#undef LANG_HOOKS_UNSIGNED_TYPE ++#define LANG_HOOKS_UNSIGNED_TYPE c_common_unsigned_type ++#undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE ++#define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE c_common_signed_or_unsigned_type ++#undef LANG_HOOKS_INCOMPLETE_TYPE_ERROR ++#define LANG_HOOKS_INCOMPLETE_TYPE_ERROR cxx_incomplete_type_error ++#undef LANG_HOOKS_TYPE_PROMOTES_TO ++#define LANG_HOOKS_TYPE_PROMOTES_TO cxx_type_promotes_to ++#undef LANG_HOOKS_REGISTER_BUILTIN_TYPE ++#define LANG_HOOKS_REGISTER_BUILTIN_TYPE c_register_builtin_type ++ ++/* Each front end provides its own hooks, for toplev.c. */ ++const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; ++ ++/* Tree code classes. */ ++ ++#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE, ++ ++const char tree_code_type[] = { ++#include "tree.def" ++ 'x', ++#include "c-common.def" ++ 'x', ++#include "cp-tree.def" ++}; ++#undef DEFTREECODE ++ ++/* Table indexed by tree code giving number of expression ++ operands beyond the fixed part of the node structure. ++ Not used for types or decls. */ ++ ++#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH, ++ ++const unsigned char tree_code_length[] = { ++#include "tree.def" ++ 0, ++#include "c-common.def" ++ 0, ++#include "cp-tree.def" ++}; ++#undef DEFTREECODE ++ ++/* Names of tree components. ++ Used for printing out the tree and error messages. */ ++#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME, ++ ++const char *const tree_code_name[] = { ++#include "tree.def" ++ "@@dummy", ++#include "c-common.def" ++ "@@dummy", ++#include "cp-tree.def" ++}; ++#undef DEFTREECODE ++ ++/* Check if a C++ type is safe for aliasing. ++ Return TRUE if T safe for aliasing FALSE otherwise. */ ++ ++static bool ++ok_to_generate_alias_set_for_type (tree t) ++{ ++ if (TYPE_PTRMEMFUNC_P (t)) ++ return true; ++ if (AGGREGATE_TYPE_P (t)) ++ { ++ if ((TREE_CODE (t) == RECORD_TYPE) || (TREE_CODE (t) == UNION_TYPE)) ++ { ++ tree fields; ++ /* Backend-created structs are safe. */ ++ if (! CLASS_TYPE_P (t)) ++ return true; ++ /* PODs are safe. */ ++ if (! CLASSTYPE_NON_POD_P(t)) ++ return true; ++ /* Classes with virtual baseclasses are not. */ ++ if (TYPE_USES_VIRTUAL_BASECLASSES (t)) ++ return false; ++ /* Recursively check the base classes. */ ++ if (TYPE_BINFO (t) != NULL && TYPE_BINFO_BASETYPES (t) != NULL) ++ { ++ int i; ++ for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (t)); i++) ++ { ++ tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), i); ++ if (!ok_to_generate_alias_set_for_type (BINFO_TYPE (binfo))) ++ return false; ++ } ++ } ++ /* Check all the fields. */ ++ for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields)) ++ { ++ if (TREE_CODE (fields) != FIELD_DECL) ++ continue; ++ if (! ok_to_generate_alias_set_for_type (TREE_TYPE (fields))) ++ return false; ++ } ++ return true; ++ } ++ else if (TREE_CODE (t) == ARRAY_TYPE) ++ return ok_to_generate_alias_set_for_type (TREE_TYPE (t)); ++ else ++ /* This should never happen, we dealt with all the aggregate ++ types that can appear in C++ above. */ ++ abort (); ++ } ++ else ++ return true; ++} ++ ++/* Special routine to get the alias set for C++. */ ++ ++static HOST_WIDE_INT ++cxx_get_alias_set (tree t) ++{ ++ if (TREE_CODE (t) == RECORD_TYPE ++ && TYPE_CONTEXT (t) && CLASS_TYPE_P (TYPE_CONTEXT (t)) ++ && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t) ++ /* The base variant of a type must be in the same alias set as the ++ complete type. */ ++ return get_alias_set (TYPE_CONTEXT (t)); ++ ++ if (/* It's not yet safe to use alias sets for some classes in C++. */ ++ !ok_to_generate_alias_set_for_type (t) ++ /* Nor is it safe to use alias sets for pointers-to-member ++ functions, due to the fact that there may be more than one ++ RECORD_TYPE type corresponding to the same pointer-to-member ++ type. */ ++ || TYPE_PTRMEMFUNC_P (t)) ++ return 0; ++ ++ return c_common_get_alias_set (t); ++} ++ ++/* Called from check_global_declarations. */ ++ ++static bool ++cxx_warn_unused_global_decl (tree decl) ++{ ++ if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) ++ return false; ++ if (DECL_IN_SYSTEM_HEADER (decl)) ++ return false; ++ ++ /* Const variables take the place of #defines in C++. */ ++ if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl)) ++ return false; ++ ++ return true; ++} ++ ++/* Langhook for expr_size: Tell the backend that the value of an expression ++ of non-POD class type does not include any tail padding; a derived class ++ might have allocated something there. */ ++ ++static tree ++cp_expr_size (tree exp) ++{ ++ if (CLASS_TYPE_P (TREE_TYPE (exp))) ++ { ++ /* The backend should not be interested in the size of an expression ++ of a type with both of these set; all copies of such types must go ++ through a constructor or assignment op. */ ++ if (TYPE_HAS_COMPLEX_INIT_REF (TREE_TYPE (exp)) ++ && TYPE_HAS_COMPLEX_ASSIGN_REF (TREE_TYPE (exp)) ++ /* But storing a CONSTRUCTOR isn't a copy. */ ++ && TREE_CODE (exp) != CONSTRUCTOR) ++ abort (); ++ /* This would be wrong for a type with virtual bases, but they are ++ caught by the abort above. */ ++ return (is_empty_class (TREE_TYPE (exp)) ++ ? size_zero_node ++ : CLASSTYPE_SIZE_UNIT (TREE_TYPE (exp))); ++ } ++ else ++ /* Use the default code. */ ++ return lhd_expr_size (exp); ++} ++ ++/* Langhook for tree_size: determine size of our 'x' and 'c' nodes. */ ++static size_t ++cp_tree_size (enum tree_code code) ++{ ++ switch (code) ++ { ++ case PTRMEM_CST: return sizeof (struct ptrmem_cst); ++ case BASELINK: return sizeof (struct tree_baselink); ++ case TEMPLATE_PARM_INDEX: return sizeof (template_parm_index); ++ case DEFAULT_ARG: return sizeof (struct tree_default_arg); ++ case OVERLOAD: return sizeof (struct tree_overload); ++ case WRAPPER: return sizeof (struct tree_wrapper); ++ default: ++ abort (); ++ } ++ /* NOTREACHED */ ++} ++ ++/* Returns true if T is a variably modified type, in the sense of C99. ++ This routine needs only check cases that cannot be handled by the ++ language-independent logic in tree-inline.c. */ ++ ++static bool ++cp_var_mod_type_p (tree type) ++{ ++ /* If TYPE is a pointer-to-member, it is variably modified if either ++ the class or the member are variably modified. */ ++ if (TYPE_PTR_TO_MEMBER_P (type)) ++ return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type)) ++ || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))); ++ ++ /* All other types are not variably modified. */ ++ return false; ++} ++ ++/* Stub routine to tell people that this doesn't work yet. */ ++void ++c_reset_state (void) ++{ ++ sorry ("inter-module optimisations not implemented yet"); ++} ++ ++/* Construct a C++-aware pretty-printer for CONTEXT. It is assumed ++ that CONTEXT->printer is an already constructed basic pretty_printer. */ ++static void ++cxx_initialize_diagnostics (diagnostic_context *context) ++{ ++ pretty_printer *base = context->printer; ++ cxx_pretty_printer *pp = xmalloc (sizeof (cxx_pretty_printer)); ++ memcpy (pp_base (pp), base, sizeof (pretty_printer)); ++ pp_cxx_pretty_printer_init (pp); ++ context->printer = (pretty_printer *) pp; ++ ++ /* It is safe to free this object because it was previously malloc()'d. */ ++ free (base); ++} +diff -NBaur gcc-3.4.4/gcc/cp/cp-tree.def gcc-3.4.4-new/gcc/cp/cp-tree.def +--- gcc-3.4.4/gcc/cp/cp-tree.def Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cp-tree.def Fri Aug 15 13:15:56 2003 +@@ -0,0 +1,288 @@ ++/* This file contains the definitions and documentation for the ++ additional tree codes used in the GNU C++ compiler (see tree.def ++ for the standard codes). ++ Copyright (C) 1987, 1988, 1990, 1993, 1997, 1998, 2003, ++ 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. ++ Hacked by Michael Tiemann (tiemann@cygnus.com) ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++ ++/* An OFFSET_REF is used in two situations: ++ ++ 1. An expression of the form `A::m' where `A' is a class and `m' is ++ a non-static member. In this case, operand 0 will be a TYPE ++ (corresponding to `A') and operand 1 will be a FIELD_DECL, ++ BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m'). ++ ++ The expression is a pointer-to-member if its address is taken, ++ but simply denotes a member of the object if its address isnot ++ taken. In the latter case, resolve_offset_ref is used to ++ convert it to a representation of the member referred to by the ++ OFFSET_REF. ++ ++ This form is only used during the parsing phase; once semantic ++ analysis has taken place they are eliminated. ++ ++ 2. An expression of the form `x.*p'. In this case, operand 0 will ++ be an expression corresponding to `x' and operand 1 will be an ++ expression with pointer-to-member type. */ ++DEFTREECODE (OFFSET_REF, "offset_ref", 'r', 2) ++ ++/* A pointer-to-member constant. For a pointer-to-member constant ++ `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the ++ PTRMEM_CST_MEMBER is the _DECL for `Y'. */ ++DEFTREECODE (PTRMEM_CST, "ptrmem_cst", 'c', 0) ++ ++/* For NEW_EXPR, operand 0 is the placement list. ++ Operand 1 is the new-declarator. ++ Operand 2 is the initializer. */ ++DEFTREECODE (NEW_EXPR, "nw_expr", 'e', 3) ++DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", 'e', 3) ++ ++/* For DELETE_EXPR, operand 0 is the store to be destroyed. ++ Operand 1 is the value to pass to the destroying function ++ saying whether the store should be deallocated as well. */ ++DEFTREECODE (DELETE_EXPR, "dl_expr", 'e', 2) ++DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", 'e', 2) ++ ++/* Value is reference to particular overloaded class method. ++ Operand 0 is the class, operand 1 is the field ++ The COMPLEXITY field holds the class level (usually 0). */ ++DEFTREECODE (SCOPE_REF, "scope_ref", 'r', 2) ++ ++/* When composing an object with a member, this is the result. ++ Operand 0 is the object. Operand 1 is the member (usually ++ a dereferenced pointer to member). */ ++DEFTREECODE (MEMBER_REF, "member_ref", 'r', 2) ++ ++/* Type conversion operator in C++. TREE_TYPE is type that this ++ operator converts to. Operand is expression to be converted. */ ++DEFTREECODE (TYPE_EXPR, "type_expr", 'e', 1) ++ ++/* For AGGR_INIT_EXPR, operand 0 is function which performs initialization, ++ operand 1 is argument list to initialization function, ++ and operand 2 is the slot which was allocated for this expression. */ ++DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", 'e', 3) ++ ++/* A throw expression. operand 0 is the expression, if there was one, ++ else it is NULL_TREE. */ ++DEFTREECODE (THROW_EXPR, "throw_expr", 'e', 1) ++ ++/* An empty class object. The TREE_TYPE gives the class type. We use ++ these to avoid actually creating instances of the empty classes. */ ++DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", 'e', 0) ++ ++/* A DECL which is really just a placeholder for an expression. Used to ++ implement non-class scope anonymous unions. */ ++DEFTREECODE (ALIAS_DECL, "alias_decl", 'd', 0) ++ ++/* A reference to a member function or member functions from a base ++ class. BASELINK_FUNCTIONS gives the FUNCTION_DECL, ++ TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the ++ functions. BASELINK_BINFO gives the base from which the functions ++ come, i.e., the base to which the `this' pointer must be converted ++ before the functions are called. BASELINK_ACCESS_BINFO gives the ++ base used to name the functions. ++ ++ A BASELINK is an expression; the TREE_TYPE of the BASELINK gives ++ the type of the expression. This type is either a FUNCTION_TYPE, ++ METHOD_TYPE, or `unknown_type_node' indicating that the function is ++ overloaded. */ ++DEFTREECODE (BASELINK, "baselink", 'x', 0) ++ ++/* Template definition. The following fields have the specified uses, ++ although there are other macros in cp-tree.h that should be used for ++ accessing this data. ++ DECL_ARGUMENTS template parm vector ++ DECL_TEMPLATE_INFO template text &c ++ DECL_VINDEX list of instantiations already produced; ++ only done for functions so far ++ For class template: ++ DECL_INITIAL associated templates (methods &c) ++ DECL_TEMPLATE_RESULT null ++ For non-class templates: ++ TREE_TYPE type of object to be constructed ++ DECL_TEMPLATE_RESULT decl for object to be created ++ (e.g., FUNCTION_DECL with tmpl parms used) ++ */ ++DEFTREECODE (TEMPLATE_DECL, "template_decl", 'd', 0) ++ ++/* Index into a template parameter list. The TEMPLATE_PARM_IDX gives ++ the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL ++ gives the level (from 1) of the parameter. ++ ++ Here's an example: ++ ++ template // Index 0, Level 1. ++ struct S ++ { ++ template // Index 1, Level 2. ++ void f(); ++ }; ++ ++ The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended ++ from this one. The first descendant will have the same IDX, but ++ its LEVEL will be one less. The TREE_CHAIN field is used to chain ++ together the descendants. The TEMPLATE_PARM_DECL is the ++ declaration of this parameter, either a TYPE_DECL or CONST_DECL. ++ The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant ++ parent, i.e., the LEVEL that the parameter originally had when it ++ was declared. For example, if we instantiate S, we will have: ++ ++ struct S ++ { ++ template // Index 1, Level 1, Orig Level 2 ++ void f(); ++ }; ++ ++ The LEVEL is the level of the parameter when we are worrying about ++ the types of things; the ORIG_LEVEL is the level when we are ++ worrying about instantiating things. */ ++DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", 'x', 0) ++ ++/* Index into a template parameter list. This parameter must be a type. ++ The TYPE_FIELDS value will be a TEMPLATE_PARM_INDEX. */ ++DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", 't', 0) ++ ++/* Index into a template parameter list for template template parameters. ++ This parameter must be a type. The TYPE_FIELDS value will be a ++ TEMPLATE_PARM_INDEX. ++ ++ It is used without template arguments like TT in C, ++ TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE ++ and TYPE_NAME is a TEMPLATE_DECL. */ ++DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", 't', 0) ++ ++/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments ++ like TT. ++ In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the ++ template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */ ++DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", 't', 0) ++ ++/* A type designated by `typename T::t'. TYPE_CONTEXT is `T', ++ TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via ++ template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR. ++ If TREE_TYPE is present, this type was generated by the implicit ++ typename extension, and the TREE_TYPE is a _TYPE from a baseclass ++ of `T'. */ ++DEFTREECODE (TYPENAME_TYPE, "typename_type", 't', 0) ++ ++/* For template template argument of the form `T::template C'. ++ TYPE_CONTEXT is `T', the template parameter dependent object. ++ TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template. */ ++DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", 't', 0) ++ ++/* A type designated by `__typeof (expr)'. TYPE_FIELDS is the ++ expression in question. */ ++DEFTREECODE (TYPEOF_TYPE, "typeof_type", 't', 0) ++ ++/* A using declaration. DECL_INITIAL contains the specified scope. ++ This is not an alias, but is later expanded into multiple aliases. ++ The decl will have a NULL_TYPE iff the scope is a dependent scope, ++ otherwise it will have a void type. */ ++DEFTREECODE (USING_DECL, "using_decl", 'd', 0) ++ ++/* A using directive. The operand is USING_STMT_NAMESPACE. */ ++DEFTREECODE (USING_STMT, "using_directive", 'e', 1) ++ ++/* An un-parsed default argument. Looks like an IDENTIFIER_NODE. */ ++DEFTREECODE (DEFAULT_ARG, "default_arg", 'x', 0) ++ ++/* A template-id, like foo. The first operand is the template. ++ The second is NULL if there are no explicit arguments, or a ++ TREE_VEC of arguments. The template will be a FUNCTION_DECL, ++ TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a ++ member template, the template may be an IDENTIFIER_NODE. */ ++DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", 'e', 2) ++ ++/* A list-like node for chaining overloading candidates. TREE_TYPE is ++ the original name, and the parameter is the FUNCTION_DECL. */ ++DEFTREECODE (OVERLOAD, "overload", 'x', 0) ++ ++/* A generic wrapper for something not tree that we want to include in ++ tree structure. */ ++DEFTREECODE (WRAPPER, "wrapper", 'x', 0) ++ ++/* A whole bunch of tree codes for the initial, superficial parsing of ++ templates. */ ++DEFTREECODE (MODOP_EXPR, "modop_expr", 'e', 3) ++DEFTREECODE (CAST_EXPR, "cast_expr", '1', 1) ++DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", '1', 1) ++DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", '1', 1) ++DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", '1', 1) ++DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", '1', 1) ++DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", 'e', 2) ++DEFTREECODE (TYPEID_EXPR, "typeid_expr", 'e', 1) ++DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3) ++ ++/* A placeholder for an expression that is not type-dependent, but ++ does occur in a template. When an expression that is not ++ type-dependent appears in a larger expression, we must compute the ++ type of that larger expression. That computation would normally ++ modify the original expression, which would change the mangling of ++ that expression if it appeared in a template argument list. In ++ that situation, we create a NON_DEPENDENT_EXPR to take the place of ++ the original expression. The expression is the only operand -- it ++ is only needed for diagnostics. */ ++DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", 'e', 1) ++ ++/* CTOR_INITIALIZER is a placeholder in template code for a call to ++ setup_vtbl_pointer (and appears in all functions, not just ctors). */ ++DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", 'e', 1) ++DEFTREECODE (TRY_BLOCK, "try_block", 'e', 2) ++DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", 'e', 2) ++/* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is ++ CATCH_ALL_TYPE, then the handler catches all types. The declaration of ++ the catch variable is in HANDLER_PARMS, and the body block in ++ HANDLER_BODY. */ ++DEFTREECODE (HANDLER, "handler", 'e', 2) ++ ++/* A MUST_NOT_THROW_EXPR wraps an expression that may not ++ throw, and must call terminate if it does. */ ++DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", 'e', 1) ++ ++DEFTREECODE (TAG_DEFN, "tag_defn", 'e', 0) ++ ++/* The following codes are used to represent implicit conversion ++ sequences, in the sense of [over.best.ics]. The conversion ++ sequences are connected through their first operands, with the ++ first conversion to be performed at the end of the chain. ++ ++ The innermost conversion (i.e, the one at the end of the chain) is ++ always an IDENTITY_CONV, corresponding to the identity conversion. */ ++ ++DEFTREECODE (IDENTITY_CONV, "identity_conv", 'e', 1) ++DEFTREECODE (LVALUE_CONV, "lvalue_conv", 'e', 1) ++DEFTREECODE (QUAL_CONV, "qual_conv", 'e', 1) ++DEFTREECODE (STD_CONV, "std_conv", 'e', 1) ++DEFTREECODE (PTR_CONV, "ptr_conv", 'e', 1) ++DEFTREECODE (PMEM_CONV, "pmem_conv", 'e', 1) ++DEFTREECODE (BASE_CONV, "base_conv", 'e', 1) ++DEFTREECODE (REF_BIND, "ref_bind", 'e', 1) ++DEFTREECODE (USER_CONV, "user_conv", 'e', 2) ++DEFTREECODE (AMBIG_CONV, "ambig_conv", 'e', 1) ++DEFTREECODE (RVALUE_CONV, "rvalue_conv", 'e', 1) ++ ++/* ++Local variables: ++mode:c ++End: ++*/ +diff -NBaur gcc-3.4.4/gcc/cp/cp-tree.h gcc-3.4.4-new/gcc/cp/cp-tree.h +--- gcc-3.4.4/gcc/cp/cp-tree.h Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cp-tree.h Mon May 9 12:47:57 2005 +@@ -0,0 +1,4329 @@ ++/* Definitions for C++ parsing and type checking. ++ Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, ++ 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. ++ Contributed by Michael Tiemann (tiemann@cygnus.com) ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++#ifndef GCC_CP_TREE_H ++#define GCC_CP_TREE_H ++ ++#include "ggc.h" ++#include "function.h" ++#include "hashtab.h" ++#include "splay-tree.h" ++#include "varray.h" ++ ++#include "c-common.h" ++#include "name-lookup.h" ++ ++struct diagnostic_context; ++ ++/* Usage of TREE_LANG_FLAG_?: ++ 0: BINFO_MARKED (BINFO nodes). ++ IDENTIFIER_MARKED (IDENTIFIER_NODEs) ++ NEW_EXPR_USE_GLOBAL (in NEW_EXPR). ++ DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR). ++ COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR). ++ TREE_INDIRECT_USING (in NAMESPACE_DECL). ++ ICS_USER_FLAG (in _CONV) ++ CLEANUP_P (in TRY_BLOCK) ++ AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR) ++ PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF) ++ PARMLIST_ELLIPSIS_P (in PARMLIST) ++ DECL_PRETTY_FUNCTION_P (in VAR_DECL) ++ KOENIG_LOOKUP_P (in CALL_EXPR) ++ 1: IDENTIFIER_VIRTUAL_P. ++ TI_PENDING_TEMPLATE_FLAG. ++ TEMPLATE_PARMS_FOR_INLINE. ++ DELETE_EXPR_USE_VEC (in DELETE_EXPR). ++ (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out). ++ TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (in _TYPE). ++ ICS_ELLIPSIS_FLAG (in _CONV) ++ BINFO_DEPENDENT_BASE_P (in BINFO) ++ DECL_INITIALIZED_P (in VAR_DECL) ++ 2: IDENTIFIER_OPNAME_P. ++ TYPE_POLYMORPHIC_P (in _TYPE) ++ ICS_THIS_FLAG (in _CONV) ++ BINFO_LOST_PRIMARY_P (in BINFO) ++ TREE_PARMLIST (in TREE_LIST) ++ DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL) ++ 3: TYPE_USES_VIRTUAL_BASECLASSES (in a class TYPE). ++ BINFO_VTABLE_PATH_MARKED. ++ BINFO_PUSHDECLS_MARKED. ++ (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out). ++ ICS_BAD_FLAG (in _CONV) ++ FN_TRY_BLOCK_P (in TRY_BLOCK) ++ IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE) ++ 4: BINFO_NEW_VTABLE_MARKED. ++ TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR, ++ or FIELD_DECL). ++ NEED_TEMPORARY_P (in REF_BIND, BASE_CONV) ++ IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE) ++ 5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE) ++ DECL_VTABLE_OR_VTT_P (in VAR_DECL) ++ 6: For future expansion ++ ++ Usage of TYPE_LANG_FLAG_?: ++ 0: TYPE_DEPENDENT_P ++ 1: TYPE_HAS_CONSTRUCTOR. ++ 2: TYPE_HAS_DESTRUCTOR. ++ 3: TYPE_FOR_JAVA. ++ 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR ++ 5: IS_AGGR_TYPE. ++ 6: TYPE_DEPENDENT_P_VALID ++ ++ Usage of DECL_LANG_FLAG_?: ++ 0: DECL_ERROR_REPORTED (in VAR_DECL). ++ DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL) ++ DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL) ++ DECL_MUTABLE_P (in FIELD_DECL) ++ 1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL). ++ DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL) ++ 2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL). ++ DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL) ++ 3: DECL_IN_AGGR_P. ++ 4: DECL_C_BIT_FIELD (in a FIELD_DECL) ++ DECL_VAR_MARKED_P (in a VAR_DECL) ++ DECL_SELF_REFERENCE_P (in a TYPE_DECL) ++ 5: DECL_INTERFACE_KNOWN. ++ 6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL). ++ 7: DECL_DEAD_FOR_LOCAL (in VAR_DECL). ++ DECL_THUNK_P (in a member FUNCTION_DECL) ++ ++ Usage of language-independent fields in a language-dependent manner: ++ ++ TREE_USED ++ This field is BINFO_INDIRECT_PRIMARY_P in a BINFO. ++ ++ TYPE_ALIAS_SET ++ This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so ++ forth as a substitute for the mark bits provided in `lang_type'. ++ At present, only the six low-order bits are used. ++ ++ TYPE_BINFO ++ For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO. ++ For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS ++ ++ BINFO_VIRTUALS ++ For a binfo, this is a TREE_LIST. There is an entry for each ++ virtual function declared either in BINFO or its direct and ++ indirect primary bases. ++ ++ The BV_DELTA of each node gives the amount by which to adjust the ++ `this' pointer when calling the function. If the method is an ++ overridden version of a base class method, then it is assumed ++ that, prior to adjustment, the this pointer points to an object ++ of the base class. ++ ++ The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable ++ index of the vcall offset for this entry. ++ ++ The BV_FN is the declaration for the virtual function itself. ++ ++ BINFO_VTABLE ++ This is an expression with POINTER_TYPE that gives the value ++ to which the vptr should be initialized. Use get_vtbl_decl_for_binfo ++ to extract the VAR_DECL for the complete vtable. ++ ++ DECL_ARGUMENTS ++ For a VAR_DECL this is DECL_ANON_UNION_ELEMS. ++ ++ DECL_VINDEX ++ This field is NULL for a non-virtual function. For a virtual ++ function, it is eventually set to an INTEGER_CST indicating the ++ index in the vtable at which this function can be found. When ++ a virtual function is declared, but before it is known what ++ function is overridden, this field is the error_mark_node. ++ ++ Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is ++ the virtual function this one overrides, and whose TREE_CHAIN is ++ the old DECL_VINDEX. */ ++ ++/* Language-specific tree checkers. */ ++ ++#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) ++ ++#define VAR_OR_FUNCTION_DECL_CHECK(NODE) __extension__ \ ++({ const tree __t = (NODE); \ ++ enum tree_code const __c = TREE_CODE(__t); \ ++ if (__c != VAR_DECL && __c != FUNCTION_DECL) \ ++ tree_check_failed (__t, VAR_DECL, __FILE__, __LINE__, \ ++ __FUNCTION__); \ ++ __t; }) ++ ++#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) __extension__ \ ++({ const tree __t = (NODE); \ ++ enum tree_code const __c = TREE_CODE(__t); \ ++ if (__c != VAR_DECL \ ++ && __c != FUNCTION_DECL \ ++ && __c != PARM_DECL) \ ++ tree_check_failed (__t, VAR_DECL, __FILE__, __LINE__, \ ++ __FUNCTION__); \ ++ __t; }) ++ ++#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) __extension__ \ ++({ const tree __t = (NODE); \ ++ enum tree_code const __c = TREE_CODE(__t); \ ++ if (__c != VAR_DECL \ ++ && __c != FUNCTION_DECL \ ++ && __c != TYPE_DECL \ ++ && __c != TEMPLATE_DECL) \ ++ tree_check_failed (__t, VAR_DECL, __FILE__, __LINE__, \ ++ __FUNCTION__); \ ++ __t; }) ++ ++#define RECORD_OR_UNION_TYPE_CHECK(NODE) __extension__ \ ++({ const tree __t = (NODE); \ ++ enum tree_code const __c = TREE_CODE(__t); \ ++ if (__c != RECORD_TYPE && __c != UNION_TYPE) \ ++ tree_check_failed (__t, RECORD_TYPE, __FILE__, __LINE__, \ ++ __FUNCTION__); \ ++ __t; }) ++ ++#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) __extension__ \ ++({ const tree __t = (NODE); \ ++ enum tree_code const __c = TREE_CODE(__t); \ ++ if (__c != BOUND_TEMPLATE_TEMPLATE_PARM) \ ++ tree_check_failed (__t, BOUND_TEMPLATE_TEMPLATE_PARM, \ ++ __FILE__, __LINE__, __FUNCTION__); \ ++ __t; }) ++ ++#else /* not ENABLE_TREE_CHECKING, or not gcc */ ++ ++#define VAR_OR_FUNCTION_DECL_CHECK(NODE) (NODE) ++#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) (NODE) ++#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) (NODE) ++#define RECORD_OR_UNION_TYPE_CHECK(NODE) (NODE) ++#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) (NODE) ++ ++#endif ++ ++ ++/* Language-dependent contents of an identifier. */ ++ ++struct lang_identifier GTY(()) ++{ ++ struct c_common_identifier c_common; ++ cxx_binding *namespace_bindings; ++ cxx_binding *bindings; ++ tree class_value; ++ tree class_template_info; ++ tree label_value; ++ tree implicit_decl; ++ tree error_locus; ++}; ++ ++/* In an IDENTIFIER_NODE, nonzero if this identifier is actually a ++ keyword. C_RID_CODE (node) is then the RID_* value of the keyword, ++ and C_RID_YYCODE is the token number wanted by Yacc. */ ++ ++#define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID) ++ ++#define LANG_IDENTIFIER_CAST(NODE) \ ++ ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE)) ++ ++typedef struct template_parm_index_s GTY(()) ++{ ++ struct tree_common common; ++ HOST_WIDE_INT index; ++ HOST_WIDE_INT level; ++ HOST_WIDE_INT orig_level; ++ tree decl; ++} template_parm_index; ++ ++struct ptrmem_cst GTY(()) ++{ ++ struct tree_common common; ++ /* This isn't used, but the middle-end expects all constants to have ++ this field. */ ++ rtx rtl; ++ tree member; ++}; ++typedef struct ptrmem_cst * ptrmem_cst_t; ++ ++#define IDENTIFIER_GLOBAL_VALUE(NODE) \ ++ namespace_binding ((NODE), global_namespace) ++#define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \ ++ set_namespace_binding ((NODE), global_namespace, (VAL)) ++#define IDENTIFIER_NAMESPACE_VALUE(NODE) \ ++ namespace_binding ((NODE), current_namespace) ++#define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \ ++ set_namespace_binding ((NODE), current_namespace, (VAL)) ++ ++#define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE)) ++ ++/* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual ++ sense of `same'. */ ++#define same_type_p(TYPE1, TYPE2) \ ++ comptypes ((TYPE1), (TYPE2), COMPARE_STRICT) ++ ++/* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring ++ top-level qualifiers. */ ++#define same_type_ignoring_top_level_qualifiers_p(TYPE1, TYPE2) \ ++ same_type_p (TYPE_MAIN_VARIANT (TYPE1), TYPE_MAIN_VARIANT (TYPE2)) ++ ++/* Nonzero if we are presently building a statement tree, rather ++ than expanding each statement as we encounter it. */ ++#define building_stmt_tree() (last_tree != NULL_TREE) ++ ++/* Returns nonzero iff NODE is a declaration for the global function ++ `main'. */ ++#define DECL_MAIN_P(NODE) \ ++ (DECL_EXTERN_C_FUNCTION_P (NODE) \ ++ && DECL_NAME (NODE) != NULL_TREE \ ++ && MAIN_NAME_P (DECL_NAME (NODE))) ++ ++/* The overloaded FUNCTION_DECL. */ ++#define OVL_FUNCTION(NODE) \ ++ (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function) ++#define OVL_CHAIN(NODE) TREE_CHAIN (NODE) ++/* Polymorphic access to FUNCTION and CHAIN. */ ++#define OVL_CURRENT(NODE) \ ++ ((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE)) ++#define OVL_NEXT(NODE) \ ++ ((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE) ++/* If set, this was imported in a using declaration. ++ This is not to confuse with being used somewhere, which ++ is not important for this node. */ ++#define OVL_USED(NODE) TREE_USED (NODE) ++ ++struct tree_overload GTY(()) ++{ ++ struct tree_common common; ++ tree function; ++}; ++ ++/* Returns true iff NODE is a BASELINK. */ ++#define BASELINK_P(NODE) \ ++ (TREE_CODE (NODE) == BASELINK) ++/* The BINFO indicating the base from which the BASELINK_FUNCTIONS came. */ ++#define BASELINK_BINFO(NODE) \ ++ (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo) ++/* The functions referred to by the BASELINK; either a FUNCTION_DECL, ++ a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. */ ++#define BASELINK_FUNCTIONS(NODE) \ ++ (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions) ++/* The BINFO in which the search for the functions indicated by this baselink ++ began. This base is used to determine the accessibility of functions ++ selected by overload resolution. */ ++#define BASELINK_ACCESS_BINFO(NODE) \ ++ (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo) ++/* For a type-conversion operator, the BASELINK_OPTYPE indicates the type ++ to which the conversion should occur. This value is important if ++ the BASELINK_FUNCTIONS include a template conversion operator -- ++ the BASELINK_OPTYPE can be used to determine what type the user ++ requested. */ ++#define BASELINK_OPTYPE(NODE) \ ++ (TREE_CHAIN (BASELINK_CHECK (NODE))) ++ ++struct tree_baselink GTY(()) ++{ ++ struct tree_common common; ++ tree binfo; ++ tree functions; ++ tree access_binfo; ++}; ++ ++#define WRAPPER_ZC(NODE) (((struct tree_wrapper*)WRAPPER_CHECK (NODE))->z_c) ++ ++struct tree_wrapper GTY(()) ++{ ++ struct tree_common common; ++ struct z_candidate *z_c; ++}; ++ ++/* The different kinds of ids that we ecounter. */ ++ ++typedef enum cp_id_kind ++{ ++ /* Not an id at all. */ ++ CP_ID_KIND_NONE, ++ /* An unqualified-id that is not a template-id. */ ++ CP_ID_KIND_UNQUALIFIED, ++ /* An unqualified-id that is a dependent name. */ ++ CP_ID_KIND_UNQUALIFIED_DEPENDENT, ++ /* An unqualified template-id. */ ++ CP_ID_KIND_TEMPLATE_ID, ++ /* A qualified-id. */ ++ CP_ID_KIND_QUALIFIED ++} cp_id_kind; ++ ++/* Macros for access to language-specific slots in an identifier. */ ++ ++#define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ ++ (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings) ++#define IDENTIFIER_TEMPLATE(NODE) \ ++ (LANG_IDENTIFIER_CAST (NODE)->class_template_info) ++ ++/* The IDENTIFIER_BINDING is the innermost cxx_binding for the ++ identifier. It's PREVIOUS is the next outermost binding. Each ++ VALUE field is a DECL for the associated declaration. Thus, ++ name lookup consists simply of pulling off the node at the front ++ of the list (modulo oddities for looking up the names of types, ++ and such.) You can use SCOPE field to determine the scope ++ that bound the name. */ ++#define IDENTIFIER_BINDING(NODE) \ ++ (LANG_IDENTIFIER_CAST (NODE)->bindings) ++ ++/* The IDENTIFIER_VALUE is the value of the IDENTIFIER_BINDING, or ++ NULL_TREE if there is no binding. */ ++#define IDENTIFIER_VALUE(NODE) \ ++ (IDENTIFIER_BINDING (NODE) ? IDENTIFIER_BINDING (NODE)->value : NULL) ++ ++/* If IDENTIFIER_CLASS_VALUE is set, then NODE is bound in the current ++ class, and IDENTIFIER_CLASS_VALUE is the value binding. This is ++ just a pointer to the VALUE field of one of the bindings in the ++ IDENTIFIER_BINDINGs list, so any time that this is non-NULL so is ++ IDENTIFIER_BINDING. */ ++#define IDENTIFIER_CLASS_VALUE(NODE) \ ++ (LANG_IDENTIFIER_CAST (NODE)->class_value) ++ ++/* TREE_TYPE only indicates on local and class scope the current ++ type. For namespace scope, the presence of a type in any namespace ++ is indicated with global_type_node, and the real type behind must ++ be found through lookup. */ ++#define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE) ++#define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE) ++#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE)) ++#define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0) ++ ++#define IDENTIFIER_LABEL_VALUE(NODE) \ ++ (LANG_IDENTIFIER_CAST (NODE)->label_value) ++#define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \ ++ IDENTIFIER_LABEL_VALUE (NODE) = (VALUE) ++ ++#define IDENTIFIER_IMPLICIT_DECL(NODE) \ ++ (LANG_IDENTIFIER_CAST (NODE)->implicit_decl) ++#define SET_IDENTIFIER_IMPLICIT_DECL(NODE, VALUE) \ ++ IDENTIFIER_IMPLICIT_DECL (NODE) = (VALUE) ++ ++#define IDENTIFIER_ERROR_LOCUS(NODE) \ ++ (LANG_IDENTIFIER_CAST (NODE)->error_locus) ++#define SET_IDENTIFIER_ERROR_LOCUS(NODE, VALUE) \ ++ IDENTIFIER_ERROR_LOCUS (NODE) = (VALUE) ++ ++/* Nonzero if this identifier is used as a virtual function name somewhere ++ (optimizes searches). */ ++#define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE) ++ ++/* Nonzero if this identifier is the prefix for a mangled C++ operator ++ name. */ ++#define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE) ++ ++/* Nonzero if this identifier is the name of a type-conversion ++ operator. */ ++#define IDENTIFIER_TYPENAME_P(NODE) \ ++ TREE_LANG_FLAG_4 (NODE) ++ ++/* Nonzero if this identifier is the name of a constructor or ++ destructor. */ ++#define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \ ++ TREE_LANG_FLAG_3 (NODE) ++ ++/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */ ++#define C_TYPE_FIELDS_READONLY(TYPE) \ ++ (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly) ++ ++/* Store a value in that field. */ ++#define C_SET_EXP_ORIGINAL_CODE(EXP, CODE) \ ++ (TREE_COMPLEXITY (EXP) = (int)(CODE)) ++ ++/* The tokens stored in the default argument. */ ++ ++#define DEFARG_TOKENS(NODE) \ ++ (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens) ++ ++struct tree_default_arg GTY (()) ++{ ++ struct tree_common common; ++ struct cp_token_cache *tokens; ++}; ++ ++enum cp_tree_node_structure_enum { ++ TS_CP_GENERIC, ++ TS_CP_IDENTIFIER, ++ TS_CP_TPI, ++ TS_CP_PTRMEM, ++ TS_CP_BINDING, ++ TS_CP_OVERLOAD, ++ TS_CP_BASELINK, ++ TS_CP_WRAPPER, ++ TS_CP_DEFAULT_ARG, ++ LAST_TS_CP_ENUM ++}; ++ ++/* The resulting tree type. */ ++union lang_tree_node GTY((desc ("cp_tree_node_structure (&%h)"), ++ chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)"))) ++{ ++ union tree_node GTY ((tag ("TS_CP_GENERIC"), ++ desc ("tree_node_structure (&%h)"))) generic; ++ struct template_parm_index_s GTY ((tag ("TS_CP_TPI"))) tpi; ++ struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem; ++ struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload; ++ struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink; ++ struct tree_wrapper GTY ((tag ("TS_CP_WRAPPER"))) wrapper; ++ struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg; ++ struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier; ++}; ++ ++ ++enum cp_tree_index ++{ ++ CPTI_JAVA_BYTE_TYPE, ++ CPTI_JAVA_SHORT_TYPE, ++ CPTI_JAVA_INT_TYPE, ++ CPTI_JAVA_LONG_TYPE, ++ CPTI_JAVA_FLOAT_TYPE, ++ CPTI_JAVA_DOUBLE_TYPE, ++ CPTI_JAVA_CHAR_TYPE, ++ CPTI_JAVA_BOOLEAN_TYPE, ++ ++ CPTI_WCHAR_DECL, ++ CPTI_VTABLE_ENTRY_TYPE, ++ CPTI_DELTA_TYPE, ++ CPTI_VTABLE_INDEX_TYPE, ++ CPTI_CLEANUP_TYPE, ++ CPTI_VTT_PARM_TYPE, ++ ++ CPTI_TI_DESC_TYPE, ++ CPTI_BLTN_DESC_TYPE, ++ CPTI_PTR_DESC_TYPE, ++ CPTI_ARY_DESC_TYPE, ++ CPTI_FUNC_DESC_TYPE, ++ CPTI_ENUM_DESC_TYPE, ++ CPTI_CLASS_DESC_TYPE, ++ CPTI_SI_CLASS_DESC_TYPE, ++ CPTI_VMI_CLASS_DESC_TYPE, ++ CPTI_PTM_DESC_TYPE, ++ CPTI_BASE_DESC_TYPE, ++ ++ CPTI_CLASS_TYPE, ++ CPTI_UNKNOWN_TYPE, ++ CPTI_VTBL_TYPE, ++ CPTI_VTBL_PTR_TYPE, ++ CPTI_STD, ++ CPTI_ABI, ++ CPTI_TYPE_INFO_TYPE, ++ CPTI_TYPE_INFO_PTR_TYPE, ++ CPTI_TYPE_INFO_REF_TYPE, ++ CPTI_ABORT_FNDECL, ++ CPTI_GLOBAL_DELETE_FNDECL, ++ CPTI_AGGR_TAG, ++ ++ CPTI_CTOR_IDENTIFIER, ++ CPTI_COMPLETE_CTOR_IDENTIFIER, ++ CPTI_BASE_CTOR_IDENTIFIER, ++ CPTI_DTOR_IDENTIFIER, ++ CPTI_COMPLETE_DTOR_IDENTIFIER, ++ CPTI_BASE_DTOR_IDENTIFIER, ++ CPTI_DELETING_DTOR_IDENTIFIER, ++ CPTI_DELTA_IDENTIFIER, ++ CPTI_IN_CHARGE_IDENTIFIER, ++ CPTI_VTT_PARM_IDENTIFIER, ++ CPTI_NELTS_IDENTIFIER, ++ CPTI_THIS_IDENTIFIER, ++ CPTI_PFN_IDENTIFIER, ++ CPTI_VPTR_IDENTIFIER, ++ CPTI_STD_IDENTIFIER, ++ ++ CPTI_LANG_NAME_C, ++ CPTI_LANG_NAME_CPLUSPLUS, ++ CPTI_LANG_NAME_JAVA, ++ ++ CPTI_EMPTY_EXCEPT_SPEC, ++ CPTI_NULL, ++ CPTI_JCLASS, ++ CPTI_TERMINATE, ++ CPTI_CALL_UNEXPECTED, ++ CPTI_ATEXIT, ++ CPTI_DSO_HANDLE, ++ CPTI_DCAST, ++ ++ CPTI_KEYED_CLASSES, ++ ++ CPTI_MAX ++}; ++ ++extern GTY(()) tree cp_global_trees[CPTI_MAX]; ++ ++#define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE] ++#define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE] ++#define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE] ++#define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE] ++#define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE] ++#define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE] ++#define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE] ++#define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE] ++ ++#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL] ++#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE] ++/* The type used to represent an offset by which to adjust the `this' ++ pointer in pointer-to-member types. */ ++#define delta_type_node cp_global_trees[CPTI_DELTA_TYPE] ++/* The type used to represent an index into the vtable. */ ++#define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE] ++ ++#define ti_desc_type_node cp_global_trees[CPTI_TI_DESC_TYPE] ++#define bltn_desc_type_node cp_global_trees[CPTI_BLTN_DESC_TYPE] ++#define ptr_desc_type_node cp_global_trees[CPTI_PTR_DESC_TYPE] ++#define ary_desc_type_node cp_global_trees[CPTI_ARY_DESC_TYPE] ++#define func_desc_type_node cp_global_trees[CPTI_FUNC_DESC_TYPE] ++#define enum_desc_type_node cp_global_trees[CPTI_ENUM_DESC_TYPE] ++#define class_desc_type_node cp_global_trees[CPTI_CLASS_DESC_TYPE] ++#define si_class_desc_type_node cp_global_trees[CPTI_SI_CLASS_DESC_TYPE] ++#define vmi_class_desc_type_node cp_global_trees[CPTI_VMI_CLASS_DESC_TYPE] ++#define ptm_desc_type_node cp_global_trees[CPTI_PTM_DESC_TYPE] ++#define base_desc_type_node cp_global_trees[CPTI_BASE_DESC_TYPE] ++ ++#define class_type_node cp_global_trees[CPTI_CLASS_TYPE] ++#define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE] ++#define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE] ++#define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE] ++#define std_node cp_global_trees[CPTI_STD] ++#define abi_node cp_global_trees[CPTI_ABI] ++#define type_info_type_node cp_global_trees[CPTI_TYPE_INFO_TYPE] ++#define type_info_ptr_type cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE] ++#define type_info_ref_type cp_global_trees[CPTI_TYPE_INFO_REF_TYPE] ++#define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL] ++#define global_delete_fndecl cp_global_trees[CPTI_GLOBAL_DELETE_FNDECL] ++#define current_aggr cp_global_trees[CPTI_AGGR_TAG] ++ ++/* We cache these tree nodes so as to call get_identifier less ++ frequently. */ ++ ++/* The name of a constructor that takes an in-charge parameter to ++ decide whether or not to construct virtual base classes. */ ++#define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER] ++/* The name of a constructor that constructs virtual base classes. */ ++#define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER] ++/* The name of a constructor that does not construct virtual base classes. */ ++#define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER] ++/* The name of a destructor that takes an in-charge parameter to ++ decide whether or not to destroy virtual base classes and whether ++ or not to delete the object. */ ++#define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER] ++/* The name of a destructor that destroys virtual base classes. */ ++#define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER] ++/* The name of a destructor that does not destroy virtual base ++ classes. */ ++#define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER] ++/* The name of a destructor that destroys virtual base classes, and ++ then deletes the entire object. */ ++#define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER] ++#define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER] ++#define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER] ++/* The name of the parameter that contains a pointer to the VTT to use ++ for this subobject constructor or destructor. */ ++#define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER] ++#define nelts_identifier cp_global_trees[CPTI_NELTS_IDENTIFIER] ++#define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER] ++#define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER] ++#define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER] ++/* The name of the std namespace. */ ++#define std_identifier cp_global_trees[CPTI_STD_IDENTIFIER] ++#define lang_name_c cp_global_trees[CPTI_LANG_NAME_C] ++#define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS] ++#define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA] ++ ++/* Exception specifier used for throw(). */ ++#define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC] ++ ++/* The node for `__null'. */ ++#define null_node cp_global_trees[CPTI_NULL] ++ ++/* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */ ++#define jclass_node cp_global_trees[CPTI_JCLASS] ++ ++/* The declaration for `std::terminate'. */ ++#define terminate_node cp_global_trees[CPTI_TERMINATE] ++ ++/* The declaration for "__cxa_call_unexpected". */ ++#define call_unexpected_node cp_global_trees[CPTI_CALL_UNEXPECTED] ++ ++/* A pointer to `std::atexit'. */ ++#define atexit_node cp_global_trees[CPTI_ATEXIT] ++ ++/* A pointer to `__dso_handle'. */ ++#define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE] ++ ++/* The declaration of the dynamic_cast runtime. */ ++#define dynamic_cast_node cp_global_trees[CPTI_DCAST] ++ ++/* The type of a destructor. */ ++#define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE] ++ ++/* The type of the vtt parameter passed to subobject constructors and ++ destructors. */ ++#define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE] ++ ++/* A TREE_LIST of the dynamic classes whose vtables may have to be ++ emitted in this translation unit. */ ++ ++#define keyed_classes cp_global_trees[CPTI_KEYED_CLASSES] ++ ++/* Node to indicate default access. This must be distinct from the ++ access nodes in tree.h. */ ++ ++#define access_default_node null_node ++ ++/* Global state. */ ++ ++struct saved_scope GTY(()) ++{ ++ cxx_saved_binding *old_bindings; ++ tree old_namespace; ++ tree decl_ns_list; ++ tree class_name; ++ tree class_type; ++ tree access_specifier; ++ tree function_decl; ++ varray_type lang_base; ++ tree lang_name; ++ tree template_parms; ++ tree x_previous_class_type; ++ tree x_previous_class_values; ++ tree x_saved_tree; ++ ++ HOST_WIDE_INT x_processing_template_decl; ++ int x_processing_specialization; ++ bool x_processing_explicit_instantiation; ++ int need_pop_function_context; ++ ++ struct stmt_tree_s x_stmt_tree; ++ ++ struct cp_binding_level *class_bindings; ++ struct cp_binding_level *bindings; ++ ++ struct saved_scope *prev; ++}; ++ ++/* The current open namespace. */ ++ ++#define current_namespace scope_chain->old_namespace ++ ++/* The stack for namespaces of current declarations. */ ++ ++#define decl_namespace_list scope_chain->decl_ns_list ++ ++/* IDENTIFIER_NODE: name of current class */ ++ ++#define current_class_name scope_chain->class_name ++ ++/* _TYPE: the type of the current class */ ++ ++#define current_class_type scope_chain->class_type ++ ++/* When parsing a class definition, the access specifier most recently ++ given by the user, or, if no access specifier was given, the ++ default value appropriate for the kind of class (i.e., struct, ++ class, or union). */ ++ ++#define current_access_specifier scope_chain->access_specifier ++ ++/* Pointer to the top of the language name stack. */ ++ ++#define current_lang_base scope_chain->lang_base ++#define current_lang_name scope_chain->lang_name ++ ++/* Parsing a function declarator leaves a list of parameter names ++ or a chain or parameter decls here. */ ++ ++#define current_template_parms scope_chain->template_parms ++ ++#define processing_template_decl scope_chain->x_processing_template_decl ++#define processing_specialization scope_chain->x_processing_specialization ++#define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation ++ ++/* _TYPE: the previous type that was a class */ ++ ++#define previous_class_type scope_chain->x_previous_class_type ++ ++/* This is a copy of the class_shadowed list of the previous class ++ binding contour when at global scope. It's used to reset ++ IDENTIFIER_CLASS_VALUEs when entering another class scope (i.e. a ++ cache miss). */ ++ ++#define previous_class_values scope_chain->x_previous_class_values ++ ++/* A list of private types mentioned, for deferred access checking. */ ++ ++extern GTY(()) struct saved_scope *scope_chain; ++ ++/* Global state pertinent to the current function. */ ++ ++struct language_function GTY(()) ++{ ++ struct c_language_function base; ++ ++ tree x_dtor_label; ++ tree x_current_class_ptr; ++ tree x_current_class_ref; ++ tree x_eh_spec_block; ++ tree x_in_charge_parm; ++ tree x_vtt_parm; ++ tree x_return_value; ++ ++ int returns_value; ++ int returns_null; ++ int returns_abnormally; ++ int in_function_try_handler; ++ int in_base_initializer; ++ ++ /* True if this function can throw an exception. */ ++ BOOL_BITFIELD can_throw : 1; ++ ++ struct named_label_use_list *x_named_label_uses; ++ struct named_label_list *x_named_labels; ++ struct cp_binding_level *bindings; ++ varray_type x_local_names; ++ ++ const char *cannot_inline; ++}; ++ ++/* The current C++-specific per-function global variables. */ ++ ++#define cp_function_chain (cfun->language) ++ ++/* In a destructor, the point at which all derived class destroying ++ has been done, just before any base class destroying will be done. */ ++ ++#define dtor_label cp_function_chain->x_dtor_label ++ ++/* When we're processing a member function, current_class_ptr is the ++ PARM_DECL for the `this' pointer. The current_class_ref is an ++ expression for `*this'. */ ++ ++#define current_class_ptr \ ++ (cfun ? cp_function_chain->x_current_class_ptr : NULL_TREE) ++#define current_class_ref \ ++ (cfun ? cp_function_chain->x_current_class_ref : NULL_TREE) ++ ++/* The EH_SPEC_BLOCK for the exception-specifiers for the current ++ function, if any. */ ++ ++#define current_eh_spec_block cp_function_chain->x_eh_spec_block ++ ++/* The `__in_chrg' parameter for the current function. Only used for ++ constructors and destructors. */ ++ ++#define current_in_charge_parm cp_function_chain->x_in_charge_parm ++ ++/* The `__vtt_parm' parameter for the current function. Only used for ++ constructors and destructors. */ ++ ++#define current_vtt_parm cp_function_chain->x_vtt_parm ++ ++/* Set to 0 at beginning of a function definition, set to 1 if ++ a return statement that specifies a return value is seen. */ ++ ++#define current_function_returns_value cp_function_chain->returns_value ++ ++/* Set to 0 at beginning of a function definition, set to 1 if ++ a return statement with no argument is seen. */ ++ ++#define current_function_returns_null cp_function_chain->returns_null ++ ++/* Set to 0 at beginning of a function definition, set to 1 if ++ a call to a noreturn function is seen. */ ++ ++#define current_function_returns_abnormally \ ++ cp_function_chain->returns_abnormally ++ ++/* Nonzero if we are processing a base initializer. Zero elsewhere. */ ++#define in_base_initializer cp_function_chain->in_base_initializer ++ ++#define in_function_try_handler cp_function_chain->in_function_try_handler ++ ++/* Expression always returned from function, or error_mark_node ++ otherwise, for use by the automatic named return value optimization. */ ++ ++#define current_function_return_value \ ++ (cp_function_chain->x_return_value) ++ ++/* True if NAME is the IDENTIFIER_NODE for an overloaded "operator ++ new" or "operator delete". */ ++#define NEW_DELETE_OPNAME_P(NAME) \ ++ ((NAME) == ansi_opname (NEW_EXPR) \ ++ || (NAME) == ansi_opname (VEC_NEW_EXPR) \ ++ || (NAME) == ansi_opname (DELETE_EXPR) \ ++ || (NAME) == ansi_opname (VEC_DELETE_EXPR)) ++ ++#define ansi_opname(CODE) \ ++ (operator_name_info[(int) (CODE)].identifier) ++#define ansi_assopname(CODE) \ ++ (assignment_operator_name_info[(int) (CODE)].identifier) ++ ++/* True if NODE is an erroneous expression. */ ++ ++#define error_operand_p(NODE) \ ++ ((NODE) == error_mark_node \ ++ || ((NODE) && TREE_TYPE ((NODE)) == error_mark_node)) ++ ++/* INTERFACE_ONLY nonzero means that we are in an "interface" ++ section of the compiler. INTERFACE_UNKNOWN nonzero means ++ we cannot trust the value of INTERFACE_ONLY. If INTERFACE_UNKNOWN ++ is zero and INTERFACE_ONLY is zero, it means that we are responsible ++ for exporting definitions that others might need. */ ++extern int interface_only, interface_unknown; ++ ++/* C++ language-specific tree codes. */ ++#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM, ++enum cplus_tree_code { ++ CP_DUMMY_TREE_CODE = LAST_C_TREE_CODE, ++#include "cp-tree.def" ++ LAST_CPLUS_TREE_CODE ++}; ++#undef DEFTREECODE ++ ++#define cp_stmt_codes \ ++ CTOR_INITIALIZER, TRY_BLOCK, HANDLER, \ ++ EH_SPEC_BLOCK, USING_STMT, TAG_DEFN ++ ++enum languages { lang_c, lang_cplusplus, lang_java }; ++ ++/* Macros to make error reporting functions' lives easier. */ ++#define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE))) ++#define TYPE_LINKAGE_IDENTIFIER(NODE) \ ++ (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE))) ++#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE))) ++#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE))) ++ ++#define TYPE_ASSEMBLER_NAME_STRING(NODE) \ ++ (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE)))) ++#define TYPE_ASSEMBLER_NAME_LENGTH(NODE) \ ++ (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE)))) ++ ++/* Nonzero if NODE has no name for linkage purposes. */ ++#define TYPE_ANONYMOUS_P(NODE) \ ++ (TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE))) ++ ++/* The _DECL for this _TYPE. */ ++#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE))) ++ ++/* Nonzero if T is a class (or struct or union) type. Also nonzero ++ for template type parameters, typename types, and instantiated ++ template template parameters. Despite its name, ++ this macro has nothing to do with the definition of aggregate given ++ in the standard. Think of this macro as MAYBE_CLASS_TYPE_P. */ ++#define IS_AGGR_TYPE(T) \ ++ (TREE_CODE (T) == TEMPLATE_TYPE_PARM \ ++ || TREE_CODE (T) == TYPENAME_TYPE \ ++ || TREE_CODE (T) == TYPEOF_TYPE \ ++ || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \ ++ || TYPE_LANG_FLAG_5 (T)) ++ ++/* Set IS_AGGR_TYPE for T to VAL. T must be a class, struct, or ++ union type. */ ++#define SET_IS_AGGR_TYPE(T, VAL) \ ++ (TYPE_LANG_FLAG_5 (T) = (VAL)) ++ ++/* Nonzero if T is a class type. Zero for template type parameters, ++ typename types, and so forth. */ ++#define CLASS_TYPE_P(T) \ ++ (IS_AGGR_TYPE_CODE (TREE_CODE (T)) && IS_AGGR_TYPE (T)) ++ ++#define IS_AGGR_TYPE_CODE(T) ((T) == RECORD_TYPE || (T) == UNION_TYPE) ++#define TAGGED_TYPE_P(T) \ ++ (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE) ++#define IS_OVERLOAD_TYPE(T) TAGGED_TYPE_P (T) ++ ++/* True if this a "Java" type, defined in 'extern "Java"'. */ ++#define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE) ++ ++/* True if this type is dependent. This predicate is only valid if ++ TYPE_DEPENDENT_P_VALID is true. */ ++#define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE) ++ ++/* True if dependent_type_p has been called for this type, with the ++ result that TYPE_DEPENDENT_P is valid. */ ++#define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE) ++ ++/* Nonzero if this type is const-qualified. */ ++#define CP_TYPE_CONST_P(NODE) \ ++ ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0) ++ ++/* Nonzero if this type is volatile-qualified. */ ++#define CP_TYPE_VOLATILE_P(NODE) \ ++ ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0) ++ ++/* Nonzero if this type is restrict-qualified. */ ++#define CP_TYPE_RESTRICT_P(NODE) \ ++ ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0) ++ ++/* Nonzero if this type is const-qualified, but not ++ volatile-qualified. Other qualifiers are ignored. This macro is ++ used to test whether or not it is OK to bind an rvalue to a ++ reference. */ ++#define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \ ++ ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \ ++ == TYPE_QUAL_CONST) ++ ++#define FUNCTION_ARG_CHAIN(NODE) \ ++ TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE))) ++ ++/* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES ++ which refers to a user-written parameter. */ ++#define FUNCTION_FIRST_USER_PARMTYPE(NODE) \ ++ skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE))) ++ ++/* Similarly, but for DECL_ARGUMENTS. */ ++#define FUNCTION_FIRST_USER_PARM(NODE) \ ++ skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE)) ++ ++#define PROMOTES_TO_AGGR_TYPE(NODE, CODE) \ ++ (((CODE) == TREE_CODE (NODE) \ ++ && IS_AGGR_TYPE (TREE_TYPE (NODE))) \ ++ || IS_AGGR_TYPE (NODE)) ++ ++/* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and ++ ambiguity issues. */ ++#define DERIVED_FROM_P(PARENT, TYPE) \ ++ (lookup_base ((TYPE), (PARENT), ba_any, NULL) != NULL_TREE) ++/* Nonzero iff TYPE is uniquely derived from PARENT. Ignores ++ accessibility. */ ++#define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) \ ++ (lookup_base ((TYPE), (PARENT), ba_ignore | ba_quiet, NULL) != NULL_TREE) ++/* Nonzero iff TYPE is accessible in the current scope and uniquely ++ derived from PARENT. */ ++#define ACCESSIBLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \ ++ (lookup_base ((TYPE), (PARENT), ba_check | ba_quiet, NULL) != NULL_TREE) ++/* Nonzero iff TYPE is publicly & uniquely derived from PARENT. */ ++#define PUBLICLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \ ++ (lookup_base ((TYPE), (PARENT), ba_not_special | ba_quiet, NULL) \ ++ != NULL_TREE) ++ ++/* This is a few header flags for 'struct lang_type'. Actually, ++ all but the first are used only for lang_type_class; they ++ are put in this structure to save space. */ ++struct lang_type_header GTY(()) ++{ ++ BOOL_BITFIELD is_lang_type_class : 1; ++ ++ BOOL_BITFIELD has_type_conversion : 1; ++ BOOL_BITFIELD has_init_ref : 1; ++ BOOL_BITFIELD has_default_ctor : 1; ++ BOOL_BITFIELD uses_multiple_inheritance : 1; ++ BOOL_BITFIELD const_needs_init : 1; ++ BOOL_BITFIELD ref_needs_init : 1; ++ BOOL_BITFIELD has_const_assign_ref : 1; ++}; ++ ++/* This structure provides additional information above and beyond ++ what is provide in the ordinary tree_type. In the past, we used it ++ for the types of class types, template parameters types, typename ++ types, and so forth. However, there can be many (tens to hundreds ++ of thousands) of template parameter types in a compilation, and ++ there's no need for this additional information in that case. ++ Therefore, we now use this data structure only for class types. ++ ++ In the past, it was thought that there would be relatively few ++ class types. However, in the presence of heavy use of templates, ++ many (i.e., thousands) of classes can easily be generated. ++ Therefore, we should endeavor to keep the size of this structure to ++ a minimum. */ ++struct lang_type_class GTY(()) ++{ ++ struct lang_type_header h; ++ ++ unsigned char align; ++ ++ unsigned has_mutable : 1; ++ unsigned com_interface : 1; ++ unsigned non_pod_class : 1; ++ unsigned nearly_empty_p : 1; ++ unsigned user_align : 1; ++ unsigned has_assign_ref : 1; ++ unsigned has_new : 1; ++ unsigned has_array_new : 1; ++ ++ unsigned gets_delete : 2; ++ unsigned interface_only : 1; ++ unsigned interface_unknown : 1; ++ unsigned contains_empty_class_p : 1; ++ unsigned anon_aggr : 1; ++ unsigned non_zero_init : 1; ++ unsigned empty_p : 1; ++ ++ unsigned marks: 6; ++ unsigned vec_new_uses_cookie : 1; ++ unsigned declared_class : 1; ++ ++ unsigned being_defined : 1; ++ unsigned redefined : 1; ++ unsigned debug_requested : 1; ++ unsigned use_template : 2; ++ unsigned fields_readonly : 1; ++ unsigned ptrmemfunc_flag : 1; ++ unsigned was_anonymous : 1; ++ ++ unsigned has_real_assign_ref : 1; ++ unsigned has_const_init_ref : 1; ++ unsigned has_complex_init_ref : 1; ++ unsigned has_complex_assign_ref : 1; ++ unsigned has_abstract_assign_ref : 1; ++ unsigned non_aggregate : 1; ++ unsigned java_interface : 1; ++ ++ /* When adding a flag here, consider whether or not it ought to ++ apply to a template instance if it applies to the template. If ++ so, make sure to copy it in instantiate_class_template! */ ++ ++ /* There are some bits left to fill out a 32-bit word. Keep track ++ of this by updating the size of this bitfield whenever you add or ++ remove a flag. */ ++ unsigned dummy : 9; ++ ++ tree primary_base; ++ tree vfields; ++ tree vcall_indices; ++ tree vtables; ++ tree typeinfo_var; ++ tree vbases; ++ binding_table nested_udts; ++ tree as_base; ++ tree pure_virtuals; ++ tree friend_classes; ++ tree GTY ((reorder ("resort_type_method_vec"))) methods; ++ tree key_method; ++ tree decl_list; ++ tree template_info; ++ tree befriending_classes; ++}; ++ ++struct lang_type_ptrmem GTY(()) ++{ ++ struct lang_type_header h; ++ tree record; ++}; ++ ++struct lang_type GTY(()) ++{ ++ union lang_type_u ++ { ++ struct lang_type_header GTY((tag ("2"))) h; ++ struct lang_type_class GTY((tag ("1"))) c; ++ struct lang_type_ptrmem GTY((tag ("0"))) ptrmem; ++ } GTY((desc ("%h.h.is_lang_type_class"))) u; ++}; ++ ++#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) ++ ++#define LANG_TYPE_CLASS_CHECK(NODE) __extension__ \ ++({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ ++ if (! lt->u.h.is_lang_type_class) \ ++ lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ ++ <->u.c; }) ++ ++#define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__ \ ++({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ ++ if (lt->u.h.is_lang_type_class) \ ++ lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ ++ <->u.ptrmem; }) ++ ++#else ++ ++#define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c) ++#define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem) ++ ++#endif /* ENABLE_TREE_CHECKING */ ++ ++/* Indicates whether or not (and how) a template was expanded for this class. ++ 0=no information yet/non-template class ++ 1=implicit template instantiation ++ 2=explicit template specialization ++ 3=explicit template instantiation */ ++#define CLASSTYPE_USE_TEMPLATE(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->use_template) ++ ++/* Fields used for storing information before the class is defined. ++ After the class is defined, these fields hold other information. */ ++ ++/* List of friends which were defined inline in this class definition. */ ++#define CLASSTYPE_INLINE_FRIENDS(NODE) CLASSTYPE_PURE_VIRTUALS (NODE) ++ ++/* Nonzero for _CLASSTYPE means that operator delete is defined. */ ++#define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete) ++#define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1) ++ ++/* Nonzero if `new NODE[x]' should cause the allocation of extra ++ storage to indicate how many array elements are in use. */ ++#define TYPE_VEC_NEW_USES_COOKIE(NODE) \ ++ (CLASS_TYPE_P (NODE) \ ++ && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie) ++ ++/* Nonzero means that this _CLASSTYPE node defines ways of converting ++ itself to other types. */ ++#define TYPE_HAS_CONVERSION(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion) ++ ++/* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */ ++#define TYPE_HAS_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_assign_ref) ++#define TYPE_HAS_CONST_ASSIGN_REF(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_assign_ref) ++ ++/* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */ ++#define TYPE_HAS_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_init_ref) ++#define TYPE_HAS_CONST_INIT_REF(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->has_const_init_ref) ++ ++/* Nonzero if this class defines an overloaded operator new. (An ++ operator new [] doesn't count.) */ ++#define TYPE_HAS_NEW_OPERATOR(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->has_new) ++ ++/* Nonzero if this class defines an overloaded operator new[]. */ ++#define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new) ++ ++/* Nonzero means that this type is being defined. I.e., the left brace ++ starting the definition of this type has been seen. */ ++#define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined) ++/* Nonzero means that this type has been redefined. In this case, if ++ convenient, don't reprocess any methods that appear in its redefinition. */ ++#define TYPE_REDEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->redefined) ++ ++/* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses ++ multiple inheritance. If this is 0 for the root of a type ++ hierarchy, then we can use more efficient search techniques. */ ++#define TYPE_USES_MULTIPLE_INHERITANCE(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->h.uses_multiple_inheritance) ++ ++/* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses ++ virtual base classes. If this is 0 for the root of a type ++ hierarchy, then we can use more efficient search techniques. */ ++#define TYPE_USES_VIRTUAL_BASECLASSES(NODE) (TREE_LANG_FLAG_3 (NODE)) ++ ++/* The member function with which the vtable will be emitted: ++ the first noninline non-pure-virtual member function. NULL_TREE ++ if there is no key function or if this is a class template */ ++#define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method) ++ ++/* Vector member functions defined in this class. Each element is ++ either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD. All ++ functions with the same name end up in the same slot. The first ++ two elements are for constructors, and destructors, respectively. ++ All template conversion operators to innermost template dependent ++ types are overloaded on the next slot, if they exist. Note, the ++ names for these functions will not all be the same. The ++ non-template conversion operators & templated conversions to ++ non-innermost template types are next, followed by ordinary member ++ functions. There may be empty entries at the end of the vector. ++ The conversion operators are unsorted. The ordinary member ++ functions are sorted, once the class is complete. */ ++#define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods) ++ ++/* For class templates, this is a TREE_LIST of all member data, ++ functions, types, and friends in the order of declaration. ++ The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend, ++ and the RECORD_TYPE for the class template otherwise. */ ++#define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list) ++ ++/* The slot in the CLASSTYPE_METHOD_VEC where constructors go. */ ++#define CLASSTYPE_CONSTRUCTOR_SLOT 0 ++ ++/* The slot in the CLASSTYPE_METHOD_VEC where destructors go. */ ++#define CLASSTYPE_DESTRUCTOR_SLOT 1 ++ ++/* The first slot in the CLASSTYPE_METHOD_VEC where conversion ++ operators can appear. */ ++#define CLASSTYPE_FIRST_CONVERSION_SLOT 2 ++ ++/* A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These ++ are the constructors that take an in-charge parameter. */ ++#define CLASSTYPE_CONSTRUCTORS(NODE) \ ++ (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT)) ++ ++/* A FUNCTION_DECL for the destructor for NODE. These are the ++ destructors that take an in-charge parameter. */ ++#define CLASSTYPE_DESTRUCTORS(NODE) \ ++ (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT)) ++ ++/* Mark bits for depth-first and breath-first searches. */ ++ ++/* Get the value of the Nth mark bit. */ ++#define CLASSTYPE_MARKED_N(NODE, N) \ ++ (((CLASS_TYPE_P (NODE) ? LANG_TYPE_CLASS_CHECK (NODE)->marks \ ++ : ((unsigned) TYPE_ALIAS_SET (NODE))) & (1 << (N))) != 0) ++ ++/* Set the Nth mark bit. */ ++#define SET_CLASSTYPE_MARKED_N(NODE, N) \ ++ (CLASS_TYPE_P (NODE) \ ++ ? (void) (LANG_TYPE_CLASS_CHECK (NODE)->marks |= (1 << (N))) \ ++ : (void) (TYPE_ALIAS_SET (NODE) |= (1 << (N)))) ++ ++/* Clear the Nth mark bit. */ ++#define CLEAR_CLASSTYPE_MARKED_N(NODE, N) \ ++ (CLASS_TYPE_P (NODE) \ ++ ? (void) (LANG_TYPE_CLASS_CHECK (NODE)->marks &= ~(1 << (N))) \ ++ : (void) (TYPE_ALIAS_SET (NODE) &= ~(1 << (N)))) ++ ++/* Get the value of the mark bits. */ ++#define CLASSTYPE_MARKED(NODE) CLASSTYPE_MARKED_N (NODE, 0) ++#define CLASSTYPE_MARKED2(NODE) CLASSTYPE_MARKED_N (NODE, 1) ++#define CLASSTYPE_MARKED3(NODE) CLASSTYPE_MARKED_N (NODE, 2) ++#define CLASSTYPE_MARKED4(NODE) CLASSTYPE_MARKED_N (NODE, 3) ++#define CLASSTYPE_MARKED5(NODE) CLASSTYPE_MARKED_N (NODE, 4) ++#define CLASSTYPE_MARKED6(NODE) CLASSTYPE_MARKED_N (NODE, 5) ++ ++/* Macros to modify the above flags */ ++#define SET_CLASSTYPE_MARKED(NODE) SET_CLASSTYPE_MARKED_N (NODE, 0) ++#define CLEAR_CLASSTYPE_MARKED(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 0) ++#define SET_CLASSTYPE_MARKED2(NODE) SET_CLASSTYPE_MARKED_N (NODE, 1) ++#define CLEAR_CLASSTYPE_MARKED2(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 1) ++#define SET_CLASSTYPE_MARKED3(NODE) SET_CLASSTYPE_MARKED_N (NODE, 2) ++#define CLEAR_CLASSTYPE_MARKED3(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 2) ++#define SET_CLASSTYPE_MARKED4(NODE) SET_CLASSTYPE_MARKED_N (NODE, 3) ++#define CLEAR_CLASSTYPE_MARKED4(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 3) ++#define SET_CLASSTYPE_MARKED5(NODE) SET_CLASSTYPE_MARKED_N (NODE, 4) ++#define CLEAR_CLASSTYPE_MARKED5(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 4) ++#define SET_CLASSTYPE_MARKED6(NODE) SET_CLASSTYPE_MARKED_N (NODE, 5) ++#define CLEAR_CLASSTYPE_MARKED6(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 5) ++ ++/* A dictionary of the nested user-defined-types (class-types, or enums) ++ found within this class. This table includes nested member class ++ templates. */ ++#define CLASSTYPE_NESTED_UTDS(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts) ++ ++/* Nonzero if NODE has a primary base class, i.e., a base class with ++ which it shares the virtual function table pointer. */ ++#define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \ ++ (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE) ++ ++/* If non-NULL, this is the binfo for the primary base class, i.e., ++ the base class which contains the virtual function table pointer ++ for this class. */ ++#define CLASSTYPE_PRIMARY_BINFO(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->primary_base) ++ ++/* A chain of BINFOs for the direct and indirect virtual base classes ++ that this type uses in a post-order depth-first left-to-right ++ order. (In other words, these bases appear in the order that they ++ should be initialized.) */ ++#define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases) ++ ++/* Number of direct baseclasses of NODE. */ ++#define CLASSTYPE_N_BASECLASSES(NODE) \ ++ (BINFO_N_BASETYPES (TYPE_BINFO (NODE))) ++ ++/* The type corresponding to NODE when NODE is used as a base class, ++ i.e., NODE without virtual base classes. */ ++ ++#define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base) ++ ++/* These are the size and alignment of the type without its virtual ++ base classes, for when we use this type as a base itself. */ ++#define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE)) ++#define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE)) ++#define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE)) ++#define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE)) ++ ++/* The alignment of NODE, without its virtual bases, in bytes. */ ++#define CLASSTYPE_ALIGN_UNIT(NODE) \ ++ (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT) ++ ++/* True if this a Java interface type, declared with ++ '__attribute__ ((java_interface))'. */ ++#define TYPE_JAVA_INTERFACE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->java_interface) ++ ++/* A cons list of virtual functions which cannot be inherited by ++ derived classes. When deriving from this type, the derived ++ class must provide its own definition for each of these functions. */ ++#define CLASSTYPE_PURE_VIRTUALS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals) ++ ++/* Nonzero means that this type has an X() constructor. */ ++#define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor) ++ ++/* Nonzero means that this type contains a mutable member. */ ++#define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable) ++#define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE)) ++ ++/* Nonzero means that this class type is a non-POD class. */ ++#define CLASSTYPE_NON_POD_P(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class) ++ ++/* Nonzero means that this class contains pod types whose default ++ initialization is not a zero initialization (namely, pointers to ++ data members). */ ++#define CLASSTYPE_NON_ZERO_INIT_P(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init) ++ ++/* Nonzero if this class is "empty" in the sense of the C++ ABI. */ ++#define CLASSTYPE_EMPTY_P(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->empty_p) ++ ++/* Nonzero if this class is "nearly empty", i.e., contains only a ++ virtual function table pointer. */ ++#define CLASSTYPE_NEARLY_EMPTY_P(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p) ++ ++/* Nonzero if this class contains an empty subobject. */ ++#define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p) ++ ++/* A list of class types of which this type is a friend. The ++ TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the ++ case of a template friend. */ ++#define CLASSTYPE_FRIEND_CLASSES(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes) ++ ++/* A list of the classes which grant friendship to this class. */ ++#define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes) ++ ++/* Say whether this node was declared as a "class" or a "struct". */ ++#define CLASSTYPE_DECLARED_CLASS(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->declared_class) ++ ++/* Nonzero if this class has const members ++ which have no specified initialization. */ ++#define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \ ++ (TYPE_LANG_SPECIFIC (NODE) \ ++ ? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0) ++#define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE)) ++ ++/* Nonzero if this class has ref members ++ which have no specified initialization. */ ++#define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \ ++ (TYPE_LANG_SPECIFIC (NODE) \ ++ ? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0) ++#define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE)) ++ ++/* Nonzero if this class is included from a header file which employs ++ `#pragma interface', and it is not included in its implementation file. */ ++#define CLASSTYPE_INTERFACE_ONLY(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->interface_only) ++ ++/* True if we have already determined whether or not vtables, VTTs, ++ typeinfo, and other similar per-class data should be emitted in ++ this translation unit. This flag does not indicate whether or not ++ these items should be emitted; it only indicates that we know one ++ way or the other. */ ++#define CLASSTYPE_INTERFACE_KNOWN(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0) ++/* The opposite of CLASSTYPE_INTERFANCE_KNOWN. */ ++#define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown) ++ ++#define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X)) ++#define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1) ++#define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0) ++ ++/* Nonzero if a _DECL node requires us to output debug info for this class. */ ++#define CLASSTYPE_DEBUG_REQUESTED(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested) ++ ++/* Additional macros for inheritance information. */ ++ ++/* The BINFO_INHERITANCE_CHAIN is used opposite to the description in ++ gcc/tree.h. In particular if D is non-virtually derived from B ++ then the BINFO for B (in D) will have a BINFO_INHERITANCE_CHAIN ++ pointing to D. If D is virtually derived, its ++ BINFO_INHERITANCE_CHAIN will point to the most derived binfo. In ++ tree.h, this pointer is described as pointing in other ++ direction. The binfos of virtual bases are shared. */ ++ ++/* Nonzero means marked by DFS or BFS search. */ ++#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0 (NODE) ++ ++/* Nonzero means that this class is on a path leading to a new vtable. */ ++#define BINFO_VTABLE_PATH_MARKED(NODE) TREE_LANG_FLAG_3 (NODE) ++ ++/* Nonzero means B (a BINFO) has its own vtable. Any copies will not ++ have this flag set. */ ++#define BINFO_NEW_VTABLE_MARKED(B) (TREE_LANG_FLAG_4 (B)) ++ ++/* Any subobject that needs a new vtable must have a vptr and must not ++ be a non-virtual primary base (since it would then use the vtable from a ++ derived class and never become non-primary.) */ ++#define SET_BINFO_NEW_VTABLE_MARKED(B) \ ++ (BINFO_NEW_VTABLE_MARKED (B) = 1, \ ++ my_friendly_assert (!BINFO_PRIMARY_P (B) \ ++ || TREE_VIA_VIRTUAL (B), 20000517), \ ++ my_friendly_assert (CLASSTYPE_VFIELDS (BINFO_TYPE (B)) != NULL_TREE, \ ++ 20000517)) ++ ++/* Nonzero means this class has done dfs_pushdecls. */ ++#define BINFO_PUSHDECLS_MARKED(NODE) BINFO_VTABLE_PATH_MARKED (NODE) ++ ++/* Nonzero if this BINFO is a primary base class. Note, this can be ++ set for non-canonical virtual bases. For a virtual primary base ++ you might also need to check whether it is canonical. */ ++ ++#define BINFO_PRIMARY_P(NODE) \ ++ (BINFO_PRIMARY_BASE_OF (NODE) != NULL_TREE) ++ ++/* The index in the VTT where this subobject's sub-VTT can be found. ++ NULL_TREE if there is no sub-VTT. */ ++#define BINFO_SUBVTT_INDEX(NODE) TREE_VEC_ELT (NODE, BINFO_ELTS + 0) ++ ++/* The index in the VTT where the vptr for this subobject can be ++ found. NULL_TREE if there is no secondary vptr in the VTT. */ ++#define BINFO_VPTR_INDEX(NODE) TREE_VEC_ELT (NODE, BINFO_ELTS + 1) ++ ++/* The binfo of which NODE is a primary base. (This is different from ++ BINFO_INHERITANCE_CHAIN for virtual base because a virtual base is ++ sometimes a primary base for a class for which it is not an ++ immediate base.) */ ++#define BINFO_PRIMARY_BASE_OF(NODE) TREE_VEC_ELT (NODE, BINFO_ELTS + 2) ++ ++/* C++ binfos have 3 additional entries. */ ++ ++#define BINFO_LANG_ELTS (BINFO_ELTS + 3) ++ ++/* Nonzero if this binfo is for a dependent base - one that should not ++ be searched. */ ++#define BINFO_DEPENDENT_BASE_P(NODE) TREE_LANG_FLAG_1(NODE) ++ ++/* Nonzero if this binfo has lost its primary base binfo (because that ++ is a nearly-empty virtual base that has been taken by some other ++ base in the complete hierarchy. */ ++#define BINFO_LOST_PRIMARY_P(NODE) TREE_LANG_FLAG_2 (NODE) ++ ++/* Nonzero if this binfo is an indirect primary base, i.e. a virtual ++ base that is a primary base of some of other class in the ++ hierarchy. */ ++#define BINFO_INDIRECT_PRIMARY_P(NODE) TREE_USED (NODE) ++ ++/* Used by various search routines. */ ++#define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE) ++ ++/* A TREE_LIST of the vcall indices associated with the class NODE. ++ The TREE_PURPOSE of each node is a FUNCTION_DECL for a virtual ++ function. The TREE_VALUE is the index into the virtual table where ++ the vcall offset for that function is stored, when NODE is a ++ virtual base. */ ++#define CLASSTYPE_VCALL_INDICES(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices) ++ ++/* The various vtables for the class NODE. The primary vtable will be ++ first, followed by the construction vtables and VTT, if any. */ ++#define CLASSTYPE_VTABLES(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->vtables) ++ ++/* The std::type_info variable representing this class, or NULL if no ++ such variable has been created. This field is only set for the ++ TYPE_MAIN_VARIANT of the class. */ ++#define CLASSTYPE_TYPEINFO_VAR(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var) ++ ++/* Accessor macros for the vfield slots in structures. */ ++ ++/* List of virtual table fields that this type contains (both the primary ++ and secondaries). The TREE_VALUE is the class type where the vtable ++ field was introduced. For a vtable field inherited from the primary ++ base, or introduced by this class, the TREE_PURPOSE is NULL. For ++ other vtable fields (those from non-primary bases), the ++ TREE_PURPOSE is the BINFO of the base through which the vtable was ++ inherited. */ ++#define CLASSTYPE_VFIELDS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vfields) ++ ++/* Get the BINFO that introduced this vtable into the hierarchy (will ++ be NULL for those created at this level, or from a primary ++ hierarchy). */ ++#define VF_BINFO_VALUE(NODE) TREE_PURPOSE (NODE) ++ ++/* Get the TYPE that introduced this vtable into the hierarchy (always ++ non-NULL). */ ++#define VF_BASETYPE_VALUE(NODE) TREE_VALUE (NODE) ++ ++/* Accessor macros for the BINFO_VIRTUALS list. */ ++ ++/* The number of bytes by which to adjust the `this' pointer when ++ calling this virtual function. Subtract this value from the this ++ pointer. Always non-NULL, might be constant zero though. */ ++#define BV_DELTA(NODE) (TREE_PURPOSE (NODE)) ++ ++/* If non-NULL, the vtable index at which to find the vcall offset ++ when calling this virtual function. Add the value at that vtable ++ index to the this pointer. */ ++#define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE)) ++ ++/* The function to call. */ ++#define BV_FN(NODE) (TREE_VALUE (NODE)) ++ ++ ++/* Nonzero for TREE_LIST node means that this list of things ++ is a list of parameters, as opposed to a list of expressions. */ ++#define TREE_PARMLIST(NODE) (TREE_LANG_FLAG_2 (NODE)) ++ ++/* Nonzero for a parmlist means that this parmlist ended in ... */ ++#define PARMLIST_ELLIPSIS_P(NODE) TREE_LANG_FLAG_0 (NODE) ++ ++/* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that ++ this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE ++ will be NULL_TREE to indicate a throw specification of `()', or ++ no exceptions allowed. */ ++#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_BINFO (NODE) ++ ++/* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'. */ ++#define TYPE_NOTHROW_P(NODE) \ ++ (TYPE_RAISES_EXCEPTIONS (NODE) \ ++ && TREE_VALUE (TYPE_RAISES_EXCEPTIONS (NODE)) == NULL_TREE) ++ ++/* The binding level associated with the namespace. */ ++#define NAMESPACE_LEVEL(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.u.level) ++ ++ ++/* If a DECL has DECL_LANG_SPECIFIC, it is either a lang_decl_flags or ++ a lang_decl (which has lang_decl_flags as its initial prefix). ++ This macro is nonzero for tree nodes whose DECL_LANG_SPECIFIC is ++ the full lang_decl, and not just lang_decl_flags. */ ++#define CAN_HAVE_FULL_LANG_DECL_P(NODE) \ ++ (!(TREE_CODE (NODE) == VAR_DECL \ ++ || TREE_CODE (NODE) == CONST_DECL \ ++ || TREE_CODE (NODE) == FIELD_DECL \ ++ || TREE_CODE (NODE) == USING_DECL)) ++ ++struct lang_decl_flags GTY(()) ++{ ++ ENUM_BITFIELD(languages) language : 8; ++ ++ unsigned operator_attr : 1; ++ unsigned constructor_attr : 1; ++ unsigned destructor_attr : 1; ++ unsigned friend_attr : 1; ++ unsigned static_function : 1; ++ unsigned pure_virtual : 1; ++ unsigned has_in_charge_parm_p : 1; ++ unsigned has_vtt_parm_p : 1; ++ ++ unsigned deferred : 1; ++ unsigned use_template : 2; ++ unsigned nonconverting : 1; ++ unsigned not_really_extern : 1; ++ unsigned needs_final_overrider : 1; ++ unsigned initialized_in_class : 1; ++ unsigned assignment_operator_p : 1; ++ ++ unsigned global_ctor_p : 1; ++ unsigned global_dtor_p : 1; ++ unsigned anticipated_p : 1; ++ unsigned template_conv_p : 1; ++ unsigned u1sel : 1; ++ unsigned u2sel : 1; ++ unsigned can_be_full : 1; ++ unsigned this_thunk_p : 1; ++ ++ union lang_decl_u { ++ /* In a FUNCTION_DECL for which DECL_THUNK_P does not hold, ++ VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is ++ DECL_TEMPLATE_INFO. */ ++ tree GTY ((tag ("0"))) template_info; ++ ++ /* In a NAMESPACE_DECL, this is NAMESPACE_LEVEL. */ ++ struct cp_binding_level * GTY ((tag ("1"))) level; ++ ++ /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is ++ THUNK_ALIAS. */ ++ tree GTY ((tag ("2"))) thunk_alias; ++ } GTY ((desc ("%1.u1sel"))) u; ++ ++ union lang_decl_u2 { ++ /* This is DECL_ACCESS. */ ++ tree GTY ((tag ("0"))) access; ++ ++ /* For VAR_DECL in function, this is DECL_DISCRIMINATOR. */ ++ int GTY ((tag ("1"))) discriminator; ++ ++ /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is ++ THUNK_VIRTUAL_OFFSET. */ ++ tree GTY((tag ("2"))) virtual_offset; ++ } GTY ((desc ("%1.u2sel"))) u2; ++}; ++ ++/* sorted_fields is sorted based on a pointer, so we need to be able ++ to resort it if pointers get rearranged. */ ++ ++struct lang_decl GTY(()) ++{ ++ struct lang_decl_flags decl_flags; ++ ++ union lang_decl_u4 ++ { ++ struct full_lang_decl ++ { ++ /* For a non-thunk function decl, this is a tree list of ++ friendly classes. For a thunk function decl, it is the ++ thunked to function decl. */ ++ tree befriending_classes; ++ ++ /* For a non-virtual FUNCTION_DECL, this is ++ DECL_FRIEND_CONTEXT. For a virtual FUNCTION_DECL for which ++ DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both ++ this pointer and result pointer adjusting thunks are ++ chained here. This pointer thunks to return pointer thunks ++ will be chained on the return pointer thunk. */ ++ tree context; ++ ++ /* In a FUNCTION_DECL, this is DECL_CLONED_FUNCTION. */ ++ tree cloned_function; ++ ++ /* In a FUNCTION_DECL for which THUNK_P holds, this is ++ THUNK_FIXED_OFFSET. */ ++ HOST_WIDE_INT fixed_offset; ++ ++ /* In an overloaded operator, this is the value of ++ DECL_OVERLOADED_OPERATOR_P. */ ++ enum tree_code operator_code; ++ ++ unsigned u3sel : 1; ++ unsigned pending_inline_p : 1; ++ ++ union lang_decl_u3 ++ { ++ struct sorted_fields_type * GTY ((tag ("0"), reorder ("resort_sorted_fields"))) ++ sorted_fields; ++ struct cp_token_cache * GTY ((tag ("2"))) pending_inline_info; ++ struct language_function * GTY ((tag ("1"))) ++ saved_language_function; ++ } GTY ((desc ("%1.u3sel + %1.pending_inline_p"))) u; ++ } GTY ((tag ("1"))) f; ++ } GTY ((desc ("%1.decl_flags.can_be_full"))) u; ++}; ++ ++#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) ++ ++#define LANG_DECL_U2_CHECK(NODE, TF) __extension__ \ ++({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ ++ if (lt->decl_flags.u2sel != TF) \ ++ lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ ++ <->decl_flags.u2; }) ++ ++#else ++ ++#define LANG_DECL_U2_CHECK(NODE, TF) \ ++ (&DECL_LANG_SPECIFIC (NODE)->decl_flags.u2) ++ ++#endif /* ENABLE_TREE_CHECKING */ ++ ++/* DECL_NEEDED_P holds of a declaration when we need to emit its ++ definition. This is true when the back-end tells us that ++ the symbol has been referenced in the generated code. If, however, ++ we are not generating code, then it is also true when a symbol has ++ just been used somewhere, even if it's not really needed. We need ++ anything that isn't comdat, but we don't know for sure whether or ++ not something is comdat until end-of-file. */ ++#define DECL_NEEDED_P(DECL) \ ++ ((at_eof && TREE_PUBLIC (DECL) && !DECL_COMDAT (DECL)) \ ++ || (DECL_ASSEMBLER_NAME_SET_P (DECL) \ ++ && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (DECL))) \ ++ || (((flag_syntax_only || flag_unit_at_a_time) && TREE_USED (DECL)))) ++ ++/* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the ++ declaration. Some entities (like a member function in a local ++ class, or a local variable) do not have linkage at all, and this ++ macro should not be used in those cases. ++ ++ Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was ++ created by language-independent code, and has C linkage. Most ++ VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but ++ we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. */ ++#define DECL_LANGUAGE(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE) \ ++ ? DECL_LANG_SPECIFIC (NODE)->decl_flags.language \ ++ : (TREE_CODE (NODE) == FUNCTION_DECL \ ++ ? lang_c : lang_cplusplus)) ++ ++/* Set the language linkage for NODE to LANGUAGE. */ ++#define SET_DECL_LANGUAGE(NODE, LANGUAGE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.language = (LANGUAGE)) ++ ++/* For FUNCTION_DECLs: nonzero means that this function is a constructor. */ ++#define DECL_CONSTRUCTOR_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.constructor_attr) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete ++ object. */ ++#define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \ ++ (DECL_CONSTRUCTOR_P (NODE) \ ++ && DECL_NAME (NODE) == complete_ctor_identifier) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base ++ object. */ ++#define DECL_BASE_CONSTRUCTOR_P(NODE) \ ++ (DECL_CONSTRUCTOR_P (NODE) \ ++ && DECL_NAME (NODE) == base_ctor_identifier) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the ++ specialized in-charge constructor or the specialized not-in-charge ++ constructor. */ ++#define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \ ++ (DECL_CONSTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE)) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. */ ++#define DECL_COPY_CONSTRUCTOR_P(NODE) \ ++ (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0) ++ ++/* Nonzero if NODE is a destructor. */ ++#define DECL_DESTRUCTOR_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.destructor_attr) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the ++ specialized in-charge constructor, in-charge deleting constructor, ++ or the the base destructor. */ ++#define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \ ++ (DECL_DESTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE)) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete ++ object. */ ++#define DECL_COMPLETE_DESTRUCTOR_P(NODE) \ ++ (DECL_DESTRUCTOR_P (NODE) \ ++ && DECL_NAME (NODE) == complete_dtor_identifier) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base ++ object. */ ++#define DECL_BASE_DESTRUCTOR_P(NODE) \ ++ (DECL_DESTRUCTOR_P (NODE) \ ++ && DECL_NAME (NODE) == base_dtor_identifier) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete ++ object that deletes the object after it has been destroyed. */ ++#define DECL_DELETING_DESTRUCTOR_P(NODE) \ ++ (DECL_DESTRUCTOR_P (NODE) \ ++ && DECL_NAME (NODE) == deleting_dtor_identifier) ++ ++/* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or ++ destructor. */ ++#define DECL_CLONED_FUNCTION_P(NODE) \ ++ ((TREE_CODE (NODE) == FUNCTION_DECL \ ++ || TREE_CODE (NODE) == TEMPLATE_DECL) \ ++ && DECL_LANG_SPECIFIC (NODE) \ ++ && DECL_CLONED_FUNCTION (NODE) != NULL_TREE) ++ ++/* If DECL_CLONED_FUNCTION_P holds, this is the function that was ++ cloned. */ ++#define DECL_CLONED_FUNCTION(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.cloned_function) ++ ++/* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. */ ++#define DECL_DISCRIMINATOR_P(NODE) \ ++ (TREE_CODE (NODE) == VAR_DECL \ ++ && DECL_FUNCTION_SCOPE_P (NODE)) ++ ++/* Discriminator for name mangling. */ ++#define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator) ++ ++/* Nonzero if the VTT parm has been added to NODE. */ ++#define DECL_HAS_VTT_PARM_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.has_vtt_parm_p) ++ ++/* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is ++ required. */ ++#define DECL_NEEDS_VTT_PARM_P(NODE) \ ++ (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (NODE)) \ ++ && (DECL_BASE_CONSTRUCTOR_P (NODE) \ ++ || DECL_BASE_DESTRUCTOR_P (NODE))) ++ ++/* Nonzero if NODE is a user-defined conversion operator. */ ++#define DECL_CONV_FN_P(NODE) \ ++ (DECL_NAME (NODE) && IDENTIFIER_TYPENAME_P (DECL_NAME (NODE))) ++ ++/* If FN is a conversion operator, the type to which it converts. ++ Otherwise, NULL_TREE. */ ++#define DECL_CONV_FN_TYPE(FN) \ ++ (DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE) ++ ++/* Nonzero if NODE, which is a TEMPLATE_DECL, is a template ++ conversion operator to a type dependent on the innermost template ++ args. */ ++#define DECL_TEMPLATE_CONV_FN_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.template_conv_p) ++ ++/* Set the overloaded operator code for NODE to CODE. */ ++#define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.operator_code = (CODE)) ++ ++/* If NODE is an overloaded operator, then this returns the TREE_CODE ++ associated with the overloaded operator. ++ DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine ++ whether or not NODE is an assignment operator. If NODE is not an ++ overloaded operator, ERROR_MARK is returned. Since the numerical ++ value of ERROR_MARK is zero, this macro can be used as a predicate ++ to test whether or not NODE is an overloaded operator. */ ++#define DECL_OVERLOADED_OPERATOR_P(NODE) \ ++ (IDENTIFIER_OPNAME_P (DECL_NAME (NODE)) \ ++ ? DECL_LANG_SPECIFIC (NODE)->u.f.operator_code : ERROR_MARK) ++ ++/* Nonzero if NODE is an assignment operator. */ ++#define DECL_ASSIGNMENT_OPERATOR_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.assignment_operator_p) ++ ++/* For FUNCTION_DECLs: nonzero means that this function is a ++ constructor or a destructor with an extra in-charge parameter to ++ control whether or not virtual bases are constructed. */ ++#define DECL_HAS_IN_CHARGE_PARM_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.has_in_charge_parm_p) ++ ++/* Nonzero if NODE is an overloaded `operator delete[]' function. */ ++#define DECL_ARRAY_DELETE_OPERATOR_P(NODE) \ ++ (DECL_OVERLOADED_OPERATOR_P (NODE) == VEC_DELETE_EXPR) ++ ++/* Nonzero for _DECL means that this decl appears in (or will appear ++ in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for ++ detecting circularity in case members are multiply defined. In the ++ case of a VAR_DECL, it is also used to determine how program storage ++ should be allocated. */ ++#define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE)) ++ ++/* Nonzero for a VAR_DECL means that the variable's initialization has ++ been processed. */ ++#define DECL_INITIALIZED_P(NODE) \ ++ (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE))) ++ ++/* Nonzero for a VAR_DECL that was initialized with a ++ constant-expression. */ ++#define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \ ++ (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE))) ++ ++/* Nonzero for a VAR_DECL that can be used in an integral constant ++ expression. ++ ++ [expr.const] ++ ++ An integral constant-expression can only involve ... const ++ variables of static or enumeration types initialized with ++ constant expressions ... ++ ++ The standard does not require that the expression be non-volatile. ++ G++ implements the proposed correction in DR 457. */ ++#define DECL_INTEGRAL_CONSTANT_VAR_P(NODE) \ ++ (TREE_CODE (NODE) == VAR_DECL \ ++ && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (NODE)) \ ++ && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (NODE)) \ ++ && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (NODE)) ++ ++/* Nonzero if the DECL was initialized in the class definition itself, ++ rather than outside the class. This is used for both static member ++ VAR_DECLS, and FUNTION_DECLS that are defined in the class. */ ++#define DECL_INITIALIZED_IN_CLASS_P(DECL) \ ++ (DECL_LANG_SPECIFIC (DECL)->decl_flags.initialized_in_class) ++ ++/* Nonzero for FUNCTION_DECL means that this decl is just a ++ friend declaration, and should not be added to the list of ++ member functions for this class. */ ++#define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.friend_attr) ++ ++/* A TREE_LIST of the types which have befriended this FUNCTION_DECL. */ ++#define DECL_BEFRIENDING_CLASSES(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.befriending_classes) ++ ++/* Nonzero for FUNCTION_DECL means that this decl is a static ++ member function. */ ++#define DECL_STATIC_FUNCTION_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.static_function) ++ ++/* Nonzero for FUNCTION_DECL means that this decl is a non-static ++ member function. */ ++#define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \ ++ (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE) ++ ++/* Nonzero for FUNCTION_DECL means that this decl is a member function ++ (static or non-static). */ ++#define DECL_FUNCTION_MEMBER_P(NODE) \ ++ (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE)) ++ ++/* Nonzero for FUNCTION_DECL means that this member function ++ has `this' as const X *const. */ ++#define DECL_CONST_MEMFUNC_P(NODE) \ ++ (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ ++ && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \ ++ (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) ++ ++/* Nonzero for FUNCTION_DECL means that this member function ++ has `this' as volatile X *const. */ ++#define DECL_VOLATILE_MEMFUNC_P(NODE) \ ++ (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ ++ && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \ ++ (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) ++ ++/* Nonzero for a DECL means that this member is a non-static member. */ ++#define DECL_NONSTATIC_MEMBER_P(NODE) \ ++ ((TREE_CODE (NODE) == FUNCTION_DECL \ ++ && DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)) \ ++ || TREE_CODE (NODE) == FIELD_DECL) ++ ++/* Nonzero for _DECL means that this member object type ++ is mutable. */ ++#define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE)) ++ ++/* Nonzero for _DECL means that this constructor is a non-converting ++ constructor. */ ++#define DECL_NONCONVERTING_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.nonconverting) ++ ++/* Nonzero for FUNCTION_DECL means that this member function is a pure ++ virtual function. */ ++#define DECL_PURE_VIRTUAL_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.pure_virtual) ++ ++/* Nonzero for FUNCTION_DECL means that this member function ++ must be overridden by derived classes. */ ++#define DECL_NEEDS_FINAL_OVERRIDER_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.needs_final_overrider) ++ ++/* The thunks associated with NODE, a FUNCTION_DECL. */ ++#define DECL_THUNKS(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.context) ++ ++/* Nonzero if NODE is a thunk, rather than an ordinary function. */ ++#define DECL_THUNK_P(NODE) \ ++ (TREE_CODE (NODE) == FUNCTION_DECL \ ++ && DECL_LANG_FLAG_7 (NODE)) ++ ++/* Nonzero if NODE is a this pointer adjusting thunk. */ ++#define DECL_THIS_THUNK_P(NODE) \ ++ (DECL_THUNK_P (NODE) && DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p) ++ ++/* Nonzero if NODE is a result pointer adjusting thunk. */ ++#define DECL_RESULT_THUNK_P(NODE) \ ++ (DECL_THUNK_P (NODE) && !DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p) ++ ++/* Nonzero if NODE is a FUNCTION_DECL, but not a thunk. */ ++#define DECL_NON_THUNK_FUNCTION_P(NODE) \ ++ (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE)) ++ ++/* Nonzero if NODE is `extern "C"'. */ ++#define DECL_EXTERN_C_P(NODE) \ ++ (DECL_LANGUAGE (NODE) == lang_c) ++ ++/* Nonzero if NODE is an `extern "C"' function. */ ++#define DECL_EXTERN_C_FUNCTION_P(NODE) \ ++ (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE)) ++ ++/* Set DECL_THUNK_P for node. */ ++#define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \ ++ (DECL_LANG_FLAG_7 (NODE) = 1, \ ++ DECL_LANG_SPECIFIC (NODE)->u.f.u3sel = 1, \ ++ DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p = (THIS_ADJUSTING)) ++ ++/* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a ++ template function. */ ++#define DECL_PRETTY_FUNCTION_P(NODE) \ ++ (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))) ++ ++/* The _TYPE context in which this _DECL appears. This field holds the ++ class where a virtual function instance is actually defined. */ ++#define DECL_CLASS_CONTEXT(NODE) \ ++ (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE) ++ ++/* For a non-member friend function, the class (if any) in which this ++ friend was defined. For example, given: ++ ++ struct S { friend void f (); }; ++ ++ the DECL_FRIEND_CONTEXT for `f' will be `S'. */ ++#define DECL_FRIEND_CONTEXT(NODE) \ ++ ((DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE)) \ ++ ? DECL_LANG_SPECIFIC (NODE)->u.f.context \ ++ : NULL_TREE) ++ ++/* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. */ ++#define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.context = (CONTEXT)) ++ ++/* NULL_TREE in DECL_CONTEXT represents the global namespace. */ ++#define CP_DECL_CONTEXT(NODE) \ ++ (DECL_CONTEXT (NODE) ? DECL_CONTEXT (NODE) : global_namespace) ++#define FROB_CONTEXT(NODE) ((NODE) == global_namespace ? NULL_TREE : (NODE)) ++ ++/* 1 iff NODE has namespace scope, including the global namespace. */ ++#define DECL_NAMESPACE_SCOPE_P(NODE) \ ++ (!DECL_TEMPLATE_PARM_P (NODE) \ ++ && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL) ++ ++/* 1 iff NODE is a class member. */ ++#define DECL_CLASS_SCOPE_P(NODE) \ ++ (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE))) ++ ++/* 1 iff NODE is function-local. */ ++#define DECL_FUNCTION_SCOPE_P(NODE) \ ++ (DECL_CONTEXT (NODE) \ ++ && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL) ++ ++/* 1 iff VAR_DECL node NODE is virtual table or VTT. */ ++#define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE)) ++ ++/* 1 iff NODE is function-local, but for types. */ ++#define LOCAL_CLASS_P(NODE) \ ++ (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE) ++ ++/* For a NAMESPACE_DECL: the list of using namespace directives ++ The PURPOSE is the used namespace, the value is the namespace ++ that is the common ancestor. */ ++#define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE)) ++ ++/* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users ++ of a namespace, to record the transitive closure of using namespace. */ ++#define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE)) ++ ++/* In a NAMESPACE_DECL, the list of namespaces which have associated ++ themselves with this one. */ ++#define DECL_NAMESPACE_ASSOCIATIONS(NODE) \ ++ (NAMESPACE_DECL_CHECK (NODE)->decl.saved_tree) ++ ++/* In a NAMESPACE_DECL, points to the original namespace if this is ++ a namespace alias. */ ++#define DECL_NAMESPACE_ALIAS(NODE) \ ++ DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE)) ++#define ORIGINAL_NAMESPACE(NODE) \ ++ (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE)) ++ ++/* Nonzero if NODE is the std namespace. */ ++#define DECL_NAMESPACE_STD_P(NODE) \ ++ (TREE_CODE (NODE) == NAMESPACE_DECL \ ++ && CP_DECL_CONTEXT (NODE) == global_namespace \ ++ && DECL_NAME (NODE) == std_identifier) ++ ++/* In a non-local VAR_DECL with static storage duration, this is the ++ initialization priority. If this value is zero, the NODE will be ++ initialized at the DEFAULT_INIT_PRIORITY. */ ++#define DECL_INIT_PRIORITY(NODE) (VAR_DECL_CHECK (NODE)->decl.u2.i) ++ ++/* In a TREE_LIST concatenating using directives, indicate indirect ++ directives */ ++#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->common.lang_flag_0) ++ ++/* In a VAR_DECL for a variable declared in a for statement, ++ this is the shadowed (local) variable. */ ++#define DECL_SHADOWED_FOR_VAR(NODE) DECL_RESULT_FLD(VAR_DECL_CHECK (NODE)) ++ ++/* In a FUNCTION_DECL, this is nonzero if this function was defined in ++ the class definition. We have saved away the text of the function, ++ but have not yet processed it. */ ++#define DECL_PENDING_INLINE_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.pending_inline_p) ++ ++/* If DECL_PENDING_INLINE_P holds, this is the saved text of the ++ function. */ ++#define DECL_PENDING_INLINE_INFO(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.u.pending_inline_info) ++ ++/* For a TYPE_DECL: if this structure has many fields, we'll sort them ++ and put them into a TREE_VEC. */ ++#define DECL_SORTED_FIELDS(NODE) \ ++ (DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE))->u.f.u.sorted_fields) ++ ++/* True if on the deferred_fns (see decl2.c) list. */ ++#define DECL_DEFERRED_FN(DECL) \ ++ (DECL_LANG_SPECIFIC (DECL)->decl_flags.deferred) ++ ++/* For a VAR_DECL, FUNCTION_DECL, TYPE_DECL or TEMPLATE_DECL: ++ template-specific information. */ ++#define DECL_TEMPLATE_INFO(NODE) \ ++ (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK (NODE)) \ ++ ->decl_flags.u.template_info) ++ ++/* For a VAR_DECL, indicates that the variable has been processed. ++ This flag is set and unset throughout the code; it is always ++ used for a temporary purpose. */ ++#define DECL_VAR_MARKED_P(NODE) \ ++ (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))) ++ ++/* Template information for a RECORD_TYPE or UNION_TYPE. */ ++#define CLASSTYPE_TEMPLATE_INFO(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_TYPE_CHECK (NODE))->template_info) ++ ++/* Template information for an ENUMERAL_TYPE. Although an enumeration may ++ not be a primary template, it may be declared within the scope of a ++ primary template and the enumeration constants may depend on ++ non-type template parameters. */ ++#define ENUM_TEMPLATE_INFO(NODE) (TYPE_BINFO (ENUMERAL_TYPE_CHECK (NODE))) ++ ++/* Template information for a template template parameter. */ ++#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \ ++ ->template_info) ++ ++/* Template information for an ENUMERAL_, RECORD_, or UNION_TYPE. */ ++#define TYPE_TEMPLATE_INFO(NODE) \ ++ (TREE_CODE (NODE) == ENUMERAL_TYPE \ ++ ? ENUM_TEMPLATE_INFO (NODE) : \ ++ (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \ ++ ? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE) : \ ++ (TYPE_LANG_SPECIFIC (NODE) \ ++ ? CLASSTYPE_TEMPLATE_INFO (NODE) \ ++ : NULL_TREE))) ++ ++/* Set the template information for an ENUMERAL_, RECORD_, or ++ UNION_TYPE to VAL. */ ++#define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \ ++ (TREE_CODE (NODE) == ENUMERAL_TYPE \ ++ ? (ENUM_TEMPLATE_INFO (NODE) = (VAL)) \ ++ : (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL))) ++ ++#define TI_TEMPLATE(NODE) (TREE_PURPOSE (NODE)) ++#define TI_ARGS(NODE) (TREE_VALUE (NODE)) ++#define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE) ++ ++/* We use TREE_VECs to hold template arguments. If there is only one ++ level of template arguments, then the TREE_VEC contains the ++ arguments directly. If there is more than one level of template ++ arguments, then each entry in the TREE_VEC is itself a TREE_VEC, ++ containing the template arguments for a single level. The first ++ entry in the outer TREE_VEC is the outermost level of template ++ parameters; the last is the innermost. ++ ++ It is incorrect to ever form a template argument vector containing ++ only one level of arguments, but which is a TREE_VEC containing as ++ its only entry the TREE_VEC for that level. */ ++ ++/* Nonzero if the template arguments is actually a vector of vectors, ++ rather than just a vector. */ ++#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ ++ (NODE && TREE_VEC_ELT (NODE, 0) \ ++ && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) ++ ++/* The depth of a template argument vector. When called directly by ++ the parser, we use a TREE_LIST rather than a TREE_VEC to represent ++ template arguments. In fact, we may even see NULL_TREE if there ++ are no template arguments. In both of those cases, there is only ++ one level of template arguments. */ ++#define TMPL_ARGS_DEPTH(NODE) \ ++ (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1) ++ ++/* The LEVELth level of the template ARGS. The outermost level of ++ args is level 1, not level 0. */ ++#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \ ++ (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \ ++ ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS)) ++ ++/* Set the LEVELth level of the template ARGS to VAL. This macro does ++ not work with single-level argument vectors. */ ++#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \ ++ (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL)) ++ ++/* Accesses the IDXth parameter in the LEVELth level of the ARGS. */ ++#define TMPL_ARG(ARGS, LEVEL, IDX) \ ++ (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX)) ++ ++/* Set the IDXth element in the LEVELth level of ARGS to VAL. This ++ macro does not work with single-level argument vectors. */ ++#define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \ ++ (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL)) ++ ++/* Given a single level of template arguments in NODE, return the ++ number of arguments. */ ++#define NUM_TMPL_ARGS(NODE) \ ++ (TREE_VEC_LENGTH (NODE)) ++ ++/* Returns the innermost level of template arguments in ARGS. */ ++#define INNERMOST_TEMPLATE_ARGS(NODE) \ ++ (get_innermost_template_args ((NODE), 1)) ++ ++/* The number of levels of template parameters given by NODE. */ ++#define TMPL_PARMS_DEPTH(NODE) \ ++ ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE))) ++ ++/* The TEMPLATE_DECL instantiated or specialized by NODE. This ++ TEMPLATE_DECL will be the immediate parent, not the most general ++ template. For example, in: ++ ++ template struct S { template void f(U); } ++ ++ the FUNCTION_DECL for S::f will have, as its ++ DECL_TI_TEMPLATE, `template S::f'. ++ ++ As a special case, for a member friend template of a template ++ class, this value will not be a TEMPLATE_DECL, but rather an ++ IDENTIFIER_NODE or OVERLOAD indicating the name of the template and ++ any explicit template arguments provided. For example, in: ++ ++ template struct S { friend void f(int, double); } ++ ++ the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the ++ DECL_TI_ARGS will be {int}. */ ++#define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE)) ++ ++/* The template arguments used to obtain this decl from the most ++ general form of DECL_TI_TEMPLATE. For the example given for ++ DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These ++ are always the full set of arguments required to instantiate this ++ declaration from the most general template specialized here. */ ++#define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE)) ++#define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE)) ++#define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE)) ++#define ENUM_TI_TEMPLATE(NODE) \ ++ TI_TEMPLATE (ENUM_TEMPLATE_INFO (NODE)) ++#define ENUM_TI_ARGS(NODE) \ ++ TI_ARGS (ENUM_TEMPLATE_INFO (NODE)) ++ ++/* For a template instantiation TYPE, returns the TYPE corresponding ++ to the primary template. Otherwise returns TYPE itself. */ ++#define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \ ++ ((CLASSTYPE_USE_TEMPLATE ((TYPE)) && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \ ++ ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \ ++ (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \ ++ : (TYPE)) ++ ++/* Like DECL_TI_TEMPLATE, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */ ++#define TYPE_TI_TEMPLATE(NODE) \ ++ (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE))) ++ ++/* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */ ++#define TYPE_TI_ARGS(NODE) \ ++ (TI_ARGS (TYPE_TEMPLATE_INFO (NODE))) ++ ++#define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE) ++ ++/* Nonzero if the NODE corresponds to the template parameters for a ++ member template, whose inline definition is being processed after ++ the class definition is complete. */ ++#define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE) ++ ++/* In a FUNCTION_DECL, the saved language-specific per-function data. */ ++#define DECL_SAVED_FUNCTION_DATA(NODE) \ ++ (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE)) \ ++ ->u.f.u.saved_language_function) ++ ++#define NEW_EXPR_USE_GLOBAL(NODE) TREE_LANG_FLAG_0 (NODE) ++#define DELETE_EXPR_USE_GLOBAL(NODE) TREE_LANG_FLAG_0 (NODE) ++#define DELETE_EXPR_USE_VEC(NODE) TREE_LANG_FLAG_1 (NODE) ++ ++/* Indicates that this is a non-dependent COMPOUND_EXPR which will ++ resolve to a function call. */ ++#define COMPOUND_EXPR_OVERLOADED(NODE) TREE_LANG_FLAG_0 (NODE) ++ ++/* In a CALL_EXPR appearing in a template, true if Koenig lookup ++ should be performed at instantiation time. */ ++#define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0(NODE) ++ ++/* Nonzero if this AGGR_INIT_EXPR provides for initialization via a ++ constructor call, rather than an ordinary function call. */ ++#define AGGR_INIT_VIA_CTOR_P(NODE) \ ++ TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE)) ++ ++/* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a ++ TEMPLATE_DECL. This macro determines whether or not a given class ++ type is really a template type, as opposed to an instantiation or ++ specialization of one. */ ++#define CLASSTYPE_IS_TEMPLATE(NODE) \ ++ (CLASSTYPE_TEMPLATE_INFO (NODE) \ ++ && !CLASSTYPE_USE_TEMPLATE (NODE) \ ++ && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))) ++ ++/* The name used by the user to name the typename type. Typically, ++ this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the ++ corresponding TYPE_DECL. However, this may also be a ++ TEMPLATE_ID_EXPR if we had something like `typename X::Y'. */ ++#define TYPENAME_TYPE_FULLNAME(NODE) (TYPE_FIELDS (NODE)) ++ ++/* Nonzero in INTEGER_CST means that this int is negative by dint of ++ using a twos-complement negated operand. */ ++#define TREE_NEGATED_INT(NODE) TREE_LANG_FLAG_0 (INTEGER_CST_CHECK (NODE)) ++ ++/* Nonzero in any kind of _TYPE where conversions to base-classes may ++ involve pointer arithmetic. If this is zero, then converting to ++ a base-class never requires changing the value of the pointer. */ ++#define TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P(NODE) (TREE_LANG_FLAG_1 (NODE)) ++ ++/* [class.virtual] ++ ++ A class that declares or inherits a virtual function is called a ++ polymorphic class. */ ++#define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE)) ++ ++/* Nonzero if this class has a virtual function table pointer. */ ++#define TYPE_CONTAINS_VPTR_P(NODE) \ ++ (TYPE_POLYMORPHIC_P (NODE) \ ++ || TYPE_USES_VIRTUAL_BASECLASSES (NODE)) ++ ++/* This flag is true of a local VAR_DECL if it was declared in a for ++ statement, but we are no longer in the scope of the for. */ ++#define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE)) ++ ++/* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL ++ if we already emitted a warning about using it. */ ++#define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)) ++ ++/* Nonzero if NODE is a FUNCTION_DECL (for a function with global ++ scope) declared in a local scope. */ ++#define DECL_LOCAL_FUNCTION_P(NODE) \ ++ DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE)) ++ ++/* Nonzero if NODE is a FUNCTION_DECL for a built-in function, and we have ++ not yet seen a prototype for that function. */ ++#define DECL_ANTICIPATED(NODE) \ ++ (DECL_LANG_SPECIFIC (DECL_CHECK (NODE))->decl_flags.anticipated_p) ++ ++/* Record whether a typedef for type `int' was actually `signed int'. */ ++#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP) ++ ++/* Returns nonzero if DECL has external linkage, as specified by the ++ language standard. (This predicate may hold even when the ++ corresponding entity is not actually given external linkage in the ++ object file; see decl_linkage for details.) */ ++#define DECL_EXTERNAL_LINKAGE_P(DECL) \ ++ (decl_linkage (DECL) == lk_external) ++ ++#define INTEGRAL_CODE_P(CODE) \ ++ ((CODE) == INTEGER_TYPE || (CODE) == ENUMERAL_TYPE || (CODE) == BOOLEAN_TYPE) ++ ++/* [basic.fundamental] ++ ++ Types bool, char, wchar_t, and the signed and unsigned integer types ++ are collectively called integral types. ++ ++ Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration ++ types as well, which is incorrect in C++. */ ++#define CP_INTEGRAL_TYPE_P(TYPE) \ ++ (TREE_CODE (TYPE) == BOOLEAN_TYPE \ ++ || TREE_CODE (TYPE) == INTEGER_TYPE) ++ ++/* Returns true if TYPE is an integral or enumeration name. */ ++#define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \ ++ (CP_INTEGRAL_TYPE_P (TYPE) || TREE_CODE (TYPE) == ENUMERAL_TYPE) ++ ++/* [basic.fundamental] ++ ++ Integral and floating types are collectively called arithmetic ++ types. */ ++#define ARITHMETIC_TYPE_P(TYPE) \ ++ (CP_INTEGRAL_TYPE_P (TYPE) || TREE_CODE (TYPE) == REAL_TYPE) ++ ++/* [basic.types] ++ ++ Arithmetic types, enumeration types, pointer types, and ++ pointer-to-member types, are collectively called scalar types. */ ++#define SCALAR_TYPE_P(TYPE) \ ++ (ARITHMETIC_TYPE_P (TYPE) \ ++ || TREE_CODE (TYPE) == ENUMERAL_TYPE \ ++ || TYPE_PTR_P (TYPE) \ ++ || TYPE_PTR_TO_MEMBER_P (TYPE)) ++ ++/* [dcl.init.aggr] ++ ++ An aggregate is an array or a class with no user-declared ++ constructors, no private or protected non-static data members, no ++ base classes, and no virtual functions. ++ ++ As an extension, we also treat vectors as aggregates. */ ++#define CP_AGGREGATE_TYPE_P(TYPE) \ ++ (TREE_CODE (TYPE) == ARRAY_TYPE \ ++ || TREE_CODE (TYPE) == VECTOR_TYPE \ ++ || (CLASS_TYPE_P (TYPE) \ ++ && !CLASSTYPE_NON_AGGREGATE (TYPE))) ++ ++/* Nonzero for a class type means that the class type has a ++ user-declared constructor. */ ++#define TYPE_HAS_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE)) ++ ++/* When appearing in an INDIRECT_REF, it means that the tree structure ++ underneath is actually a call to a constructor. This is needed ++ when the constructor must initialize local storage (which can ++ be automatically destroyed), rather than allowing it to allocate ++ space from the heap. ++ ++ When appearing in a SAVE_EXPR, it means that underneath ++ is a call to a constructor. ++ ++ When appearing in a CONSTRUCTOR, it means that it was ++ a GNU C constructor expression. ++ ++ When appearing in a FIELD_DECL, it means that this field ++ has been duly initialized in its constructor. */ ++#define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE)) ++ ++#define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \ ++ && CONSTRUCTOR_ELTS (NODE) == NULL_TREE \ ++ && ! TREE_HAS_CONSTRUCTOR (NODE)) ++ ++/* Nonzero for _TYPE means that the _TYPE defines a destructor. */ ++#define TYPE_HAS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_2 (NODE)) ++ ++/* Nonzero means that an object of this type can not be initialized using ++ an initializer list. */ ++#define CLASSTYPE_NON_AGGREGATE(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate) ++#define TYPE_NON_AGGREGATE_CLASS(NODE) \ ++ (IS_AGGR_TYPE (NODE) && CLASSTYPE_NON_AGGREGATE (NODE)) ++ ++/* Nonzero if there is a user-defined X::op=(x&) for this class. */ ++#define TYPE_HAS_REAL_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_real_assign_ref) ++#define TYPE_HAS_COMPLEX_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_assign_ref) ++#define TYPE_HAS_ABSTRACT_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_abstract_assign_ref) ++#define TYPE_HAS_COMPLEX_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_init_ref) ++ ++/* Nonzero if TYPE has a trivial destructor. From [class.dtor]: ++ ++ A destructor is trivial if it is an implicitly declared ++ destructor and if: ++ ++ - all of the direct base classes of its class have trivial ++ destructors, ++ ++ - for all of the non-static data members of its class that are ++ of class type (or array thereof), each such class has a ++ trivial destructor. */ ++#define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \ ++ (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE)) ++ ++/* Nonzero for _TYPE node means that this type does not have a trivial ++ destructor. Therefore, destroying an object of this type will ++ involve a call to a destructor. This can apply to objects of ++ ARRAY_TYPE is the type of the elements needs a destructor. */ ++#define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \ ++ (TYPE_LANG_FLAG_4 (NODE)) ++ ++/* Nonzero for class type means that copy initialization of this type can use ++ a bitwise copy. */ ++#define TYPE_HAS_TRIVIAL_INIT_REF(NODE) \ ++ (TYPE_HAS_INIT_REF (NODE) && ! TYPE_HAS_COMPLEX_INIT_REF (NODE)) ++ ++/* Nonzero for class type means that assignment of this type can use ++ a bitwise copy. */ ++#define TYPE_HAS_TRIVIAL_ASSIGN_REF(NODE) \ ++ (TYPE_HAS_ASSIGN_REF (NODE) && ! TYPE_HAS_COMPLEX_ASSIGN_REF (NODE)) ++ ++/* Returns true if NODE is a pointer-to-data-member. */ ++#define TYPE_PTRMEM_P(NODE) \ ++ (TREE_CODE (NODE) == OFFSET_TYPE) ++#define TYPE_PTR_P(NODE) \ ++ (TREE_CODE (NODE) == POINTER_TYPE) ++#define TYPE_PTROB_P(NODE) \ ++ (TYPE_PTR_P (NODE) \ ++ && TREE_CODE (TREE_TYPE (NODE)) != FUNCTION_TYPE \ ++ && TREE_CODE (TREE_TYPE (NODE)) != METHOD_TYPE \ ++ && TREE_CODE (TREE_TYPE (NODE)) != VOID_TYPE) ++#define TYPE_PTROBV_P(NODE) \ ++ (TYPE_PTR_P (NODE) && TREE_CODE (TREE_TYPE (NODE)) != FUNCTION_TYPE) ++#define TYPE_PTRFN_P(NODE) \ ++ (TREE_CODE (NODE) == POINTER_TYPE \ ++ && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) ++#define TYPE_REFFN_P(NODE) \ ++ (TREE_CODE (NODE) == REFERENCE_TYPE \ ++ && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) ++ ++/* Nonzero for _TYPE node means that this type is a pointer to member ++ function type. */ ++#define TYPE_PTRMEMFUNC_P(NODE) \ ++ (TREE_CODE (NODE) == RECORD_TYPE \ ++ && TYPE_LANG_SPECIFIC (NODE) \ ++ && TYPE_PTRMEMFUNC_FLAG (NODE)) ++ ++#define TYPE_PTRMEMFUNC_FLAG(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->ptrmemfunc_flag) ++ ++/* Returns true if NODE is a pointer-to-member. */ ++#define TYPE_PTR_TO_MEMBER_P(NODE) \ ++ (TYPE_PTRMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE)) ++ ++/* Indicates when overload resolution may resolve to a pointer to ++ member function. [expr.unary.op]/3 */ ++#define PTRMEM_OK_P(NODE) TREE_LANG_FLAG_0 (NODE) ++ ++/* Get the POINTER_TYPE to the METHOD_TYPE associated with this ++ pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true, ++ before using this macro. */ ++#define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \ ++ (TREE_TYPE (TYPE_FIELDS (NODE))) ++ ++/* Returns `A' for a type like `int (A::*)(double)' */ ++#define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \ ++ TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) ++ ++/* These are use to manipulate the canonical RECORD_TYPE from the ++ hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */ ++#define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \ ++ (TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL) ++#define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) \ ++ do { \ ++ if (TYPE_LANG_SPECIFIC (NODE) == NULL) \ ++ { \ ++ TYPE_LANG_SPECIFIC (NODE) = \ ++ ggc_alloc_cleared (sizeof (struct lang_type_ptrmem)); \ ++ TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0; \ ++ } \ ++ TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE); \ ++ } while (0) ++/* Returns the pfn field from a TYPE_PTRMEMFUNC_P. */ ++#define PFN_FROM_PTRMEMFUNC(NODE) pfn_from_ptrmemfunc ((NODE)) ++ ++/* For a pointer-to-member type of the form `T X::*', this is `X'. ++ For a type like `void (X::*)() const', this type is `X', not `const ++ X'. To get at the `const X' you have to look at the ++ TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have ++ type `const X*'. */ ++#define TYPE_PTRMEM_CLASS_TYPE(NODE) \ ++ (TYPE_PTRMEM_P (NODE) \ ++ ? TYPE_OFFSET_BASETYPE (NODE) \ ++ : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE)) ++ ++/* For a pointer-to-member type of the form `T X::*', this is `T'. */ ++#define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \ ++ (TYPE_PTRMEM_P (NODE) \ ++ ? TREE_TYPE (NODE) \ ++ : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) ++ ++/* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for ++ `X'. */ ++#define PTRMEM_CST_CLASS(NODE) \ ++ TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE))) ++ ++/* For a pointer-to-member constant `X::Y' this is the _DECL for ++ `Y'. */ ++#define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member) ++ ++/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was ++ specified in its declaration. This can also be set for an ++ erroneously declared PARM_DECL. */ ++#define DECL_THIS_EXTERN(NODE) \ ++ DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) ++ ++/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was ++ specified in its declaration. This can also be set for an ++ erroneously declared PARM_DECL. */ ++#define DECL_THIS_STATIC(NODE) \ ++ DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) ++ ++/* Nonzero if TYPE is an anonymous union or struct type. We have to use a ++ flag for this because "A union for which objects or pointers are ++ declared is not an anonymous union" [class.union]. */ ++#define ANON_AGGR_TYPE_P(NODE) \ ++ (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr) ++#define SET_ANON_AGGR_TYPE_P(NODE) \ ++ (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1) ++ ++/* Nonzero if TYPE is an anonymous union type. */ ++#define ANON_UNION_TYPE_P(NODE) \ ++ (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE)) ++ ++#define UNKNOWN_TYPE LANG_TYPE ++ ++/* Define fields and accessors for nodes representing declared names. */ ++ ++#define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous) ++ ++/* C++: all of these are overloaded! These apply only to TYPE_DECLs. */ ++ ++/* The format of each node in the DECL_FRIENDLIST is as follows: ++ ++ The TREE_PURPOSE will be the name of a function, i.e., an ++ IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose ++ TREE_VALUEs are friends with the given name. */ ++#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE)) ++#define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST)) ++#define FRIEND_DECLS(LIST) (TREE_VALUE (LIST)) ++ ++/* The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of ++ each node is a type; the TREE_VALUE is the access granted for this ++ DECL in that type. The DECL_ACCESS is set by access declarations. ++ For example, if a member that would normally be public in a ++ derived class is made protected, then the derived class and the ++ protected_access_node will appear in the DECL_ACCESS for the node. */ ++#define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access) ++ ++/* Nonzero if the FUNCTION_DECL is a global constructor. */ ++#define DECL_GLOBAL_CTOR_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.global_ctor_p) ++ ++/* Nonzero if the FUNCTION_DECL is a global destructor. */ ++#define DECL_GLOBAL_DTOR_P(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.global_dtor_p) ++ ++/* Accessor macros for C++ template decl nodes. */ ++ ++/* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node ++ is a INT_CST whose TREE_INT_CST_LOW indicates the level of the ++ template parameters, with 1 being the outermost set of template ++ parameters. The TREE_VALUE is a vector, whose elements are the ++ template parameters at each level. Each element in the vector is a ++ TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a ++ non-type parameter), or a TYPE_DECL (if the parameter is a type ++ parameter). The TREE_PURPOSE is the default value, if any. The ++ TEMPLATE_PARM_INDEX for the parameter is available as the ++ DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a ++ TYPE_DECL). */ ++#define DECL_TEMPLATE_PARMS(NODE) DECL_ARGUMENTS (NODE) ++#define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \ ++ INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE)) ++#define DECL_NTPARMS(NODE) \ ++ TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE)) ++/* For function, method, class-data templates. */ ++#define DECL_TEMPLATE_RESULT(NODE) DECL_RESULT_FLD (NODE) ++/* For a static member variable template, the ++ DECL_TEMPLATE_INSTANTIATIONS list contains the explicitly and ++ implicitly generated instantiations of the variable. There are no ++ partial instantiations of static member variables, so all of these ++ will be full instantiations. ++ ++ For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds ++ all instantiations and specializations of the class type, including ++ partial instantiations and partial specializations. ++ ++ In both cases, the TREE_PURPOSE of each node contains the arguments ++ used; the TREE_VALUE contains the generated variable. The template ++ arguments are always complete. For example, given: ++ ++ template struct S1 { ++ template struct S2 {}; ++ template struct S2 {}; ++ }; ++ ++ the record for the partial specialization will contain, as its ++ argument list, { {T}, {U*} }, and will be on the ++ DECL_TEMPLATE_INSTANTIATIONS list for `template template ++ struct S1::S2'. ++ ++ This list is not used for function templates. */ ++#define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX (NODE) ++/* For a function template, the DECL_TEMPLATE_SPECIALIZATIONS lists ++ contains all instantiations and specializations of the function, ++ including partial instantiations. For a partial instantiation ++ which is a specialization, this list holds only full ++ specializations of the template that are instantiations of the ++ partial instantiation. For example, given: ++ ++ template struct S { ++ template void f(U); ++ template <> void f(T); ++ }; ++ ++ the `S::f(int)' function will appear on the ++ DECL_TEMPLATE_SPECIALIZATIONS list for both `template ++ template void S::f(U)' and `template void ++ S::f(T)'. In the latter case, however, it will have only the ++ innermost set of arguments (T, in this case). The DECL_TI_TEMPLATE ++ for the function declaration will point at the specialization, not ++ the fully general template. ++ ++ For a class template, this list contains the partial ++ specializations of this template. (Full specializations are not ++ recorded on this list.) The TREE_PURPOSE holds the innermost ++ arguments used in the partial specialization (e.g., for `template ++ struct S' this will be `T*'.) The TREE_VALUE ++ holds the innermost template parameters for the specialization ++ (e.g., `T' in the example above.) The TREE_TYPE is the _TYPE node ++ for the partial specialization. ++ ++ This list is not used for static variable templates. */ ++#define DECL_TEMPLATE_SPECIALIZATIONS(NODE) DECL_SIZE (NODE) ++ ++/* Nonzero for a DECL which is actually a template parameter. */ ++#define DECL_TEMPLATE_PARM_P(NODE) \ ++ (DECL_LANG_FLAG_0 (NODE) \ ++ && (TREE_CODE (NODE) == CONST_DECL \ ++ || TREE_CODE (NODE) == PARM_DECL \ ++ || TREE_CODE (NODE) == TYPE_DECL \ ++ || TREE_CODE (NODE) == TEMPLATE_DECL)) ++ ++/* Mark NODE as a template parameter. */ ++#define SET_DECL_TEMPLATE_PARM_P(NODE) \ ++ (DECL_LANG_FLAG_0 (NODE) = 1) ++ ++/* Nonzero if NODE is a template template parameter. */ ++#define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \ ++ (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE)) ++ ++/* Nonzero if NODE is a TEMPLATE_DECL representing an ++ UNBOUND_CLASS_TEMPLATE tree node. */ ++#define DECL_UNBOUND_CLASS_TEMPLATE_P(NODE) \ ++ (TREE_CODE (NODE) == TEMPLATE_DECL && !DECL_TEMPLATE_RESULT (NODE)) ++ ++#define DECL_FUNCTION_TEMPLATE_P(NODE) \ ++ (TREE_CODE (NODE) == TEMPLATE_DECL \ ++ && !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \ ++ && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL) ++ ++/* Nonzero for a DECL that represents a template class. */ ++#define DECL_CLASS_TEMPLATE_P(NODE) \ ++ (TREE_CODE (NODE) == TEMPLATE_DECL \ ++ && !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \ ++ && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL \ ++ && !DECL_TEMPLATE_TEMPLATE_PARM_P (NODE)) ++ ++/* Nonzero if NODE which declares a type. */ ++#define DECL_DECLARES_TYPE_P(NODE) \ ++ (TREE_CODE (NODE) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (NODE)) ++ ++/* Nonzero if NODE is the typedef implicitly generated for a type when ++ the type is declared. In C++, `struct S {};' is roughly ++ equivalent to `struct S {}; typedef struct S S;' in C. ++ DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this ++ example. In C++, there is a second implicit typedef for each ++ class, in the scope of `S' itself, so that you can say `S::S'. ++ DECL_SELF_REFERENCE_P will hold for that second typedef. */ ++#define DECL_IMPLICIT_TYPEDEF_P(NODE) \ ++ (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE)) ++#define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \ ++ (DECL_LANG_FLAG_2 (NODE) = 1) ++#define DECL_SELF_REFERENCE_P(NODE) \ ++ (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE)) ++#define SET_DECL_SELF_REFERENCE_P(NODE) \ ++ (DECL_LANG_FLAG_4 (NODE) = 1) ++ ++/* A `primary' template is one that has its own template header. A ++ member function of a class template is a template, but not primary. ++ A member template is primary. Friend templates are primary, too. */ ++ ++/* Returns the primary template corresponding to these parameters. */ ++#define DECL_PRIMARY_TEMPLATE(NODE) \ ++ (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE))) ++ ++/* Returns nonzero if NODE is a primary template. */ ++#define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE)) ++ ++#define CLASSTYPE_TEMPLATE_LEVEL(NODE) \ ++ (TREE_INT_CST_LOW (TREE_PURPOSE (CLASSTYPE_TI_TEMPLATE (NODE)))) ++ ++/* Indicates whether or not (and how) a template was expanded for this ++ FUNCTION_DECL or VAR_DECL. ++ 0=normal declaration, e.g. int min (int, int); ++ 1=implicit template instantiation ++ 2=explicit template specialization, e.g. int min (int, int); ++ 3=explicit template instantiation, e.g. template int min (int, int); */ ++#define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.use_template) ++ ++#define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1) ++#define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \ ++ (CLASSTYPE_USE_TEMPLATE (NODE) & 1) ++ ++#define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2) ++#define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2) ++#define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ ++ (CLASSTYPE_USE_TEMPLATE (NODE) == 2) ++#define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ ++ (CLASSTYPE_USE_TEMPLATE (NODE) = 2) ++ ++#define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1) ++#define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1) ++#define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ ++ (CLASSTYPE_USE_TEMPLATE (NODE) == 1) ++#define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ ++ (CLASSTYPE_USE_TEMPLATE (NODE) = 1) ++ ++#define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3) ++#define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3) ++#define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ ++ (CLASSTYPE_USE_TEMPLATE (NODE) == 3) ++#define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ ++ (CLASSTYPE_USE_TEMPLATE (NODE) = 3) ++ ++/* Nonzero if DECL is a friend function which is an instantiation ++ from the point of view of the compiler, but not from the point of ++ view of the language. For example given: ++ template struct S { friend void f(T) {}; }; ++ the declaration of `void f(int)' generated when S is ++ instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be ++ a DECL_FRIEND_PSUEDO_TEMPLATE_INSTANTIATION. */ ++#define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \ ++ (DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL)) ++ ++/* Nonzero iff we are currently processing a declaration for an ++ entity with its own template parameter list, and which is not a ++ full specialization. */ ++#define PROCESSING_REAL_TEMPLATE_DECL_P() \ ++ (processing_template_decl > template_class_depth (current_scope ())) ++ ++/* Nonzero if this VAR_DECL or FUNCTION_DECL has already been ++ instantiated, i.e. its definition has been generated from the ++ pattern given in the the template. */ ++#define DECL_TEMPLATE_INSTANTIATED(NODE) \ ++ DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE)) ++ ++/* We know what we're doing with this decl now. */ ++#define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE) ++ ++/* DECL_EXTERNAL must be set on a decl until the decl is actually emitted, ++ so that assemble_external will work properly. So we have this flag to ++ tell us whether the decl is really not external. */ ++#define DECL_NOT_REALLY_EXTERN(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->decl_flags.not_really_extern) ++ ++#define DECL_REALLY_EXTERN(NODE) \ ++ (DECL_EXTERNAL (NODE) && ! DECL_NOT_REALLY_EXTERN (NODE)) ++ ++/* A thunk is a stub function. ++ ++ A thunk is an alternate entry point for an ordinary FUNCTION_DECL. ++ The address of the ordinary FUNCTION_DECL is given by the ++ DECL_INITIAL, which is always an ADDR_EXPR whose operand is a ++ FUNCTION_DECL. The job of the thunk is to either adjust the this ++ pointer before transferring control to the FUNCTION_DECL, or call ++ FUNCTION_DECL and then adjust the result value. Note, the result ++ pointer adjusting thunk must perform a call to the thunked ++ function, (or be implemented via passing some invisible parameter ++ to the thunked function, which is modified to perform the ++ adjustment just before returning). ++ ++ A thunk may perform either, or both, of the following operations: ++ ++ o Adjust the this or result pointer by a constant offset. ++ o Adjust the this or result pointer by looking up a vcall or vbase offset ++ in the vtable. ++ ++ A this pointer adjusting thunk converts from a base to a derived ++ class, and hence adds the offsets. A result pointer adjusting thunk ++ converts from a derived class to a base, and hence subtracts the ++ offsets. If both operations are performed, then the constant ++ adjustment is performed first for this pointer adjustment and last ++ for the result pointer adjustment. ++ ++ The constant adjustment is given by THUNK_FIXED_OFFSET. If the ++ vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is ++ used. For this pointer adjusting thunks, it is the vcall offset ++ into the vtable. For result pointer adjusting thunks it is the ++ binfo of the virtual base to convert to. Use that binfo's vbase ++ offset. ++ ++ It is possible to have equivalent covariant thunks. These are ++ distinct virtual covariant thunks whose vbase offsets happen to ++ have the same value. THUNK_ALIAS is used to pick one as the ++ canonical thunk, which will get all the this pointer adjusting ++ thunks attached to it. */ ++ ++/* An integer indicating how many bytes should be subtracted from the ++ this or result pointer when this function is called. */ ++#define THUNK_FIXED_OFFSET(DECL) \ ++ (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL))->u.f.fixed_offset) ++ ++/* A tree indicating how to perform the virtual adjustment. For a this ++ adjusting thunk it is the number of bytes to be added to the vtable ++ to find the vcall offset. For a result adjusting thunk, it is the ++ binfo of the relevant virtual base. If NULL, then there is no ++ virtual adjust. (The vptr is always located at offset zero from ++ the this or result pointer.) (If the covariant type is within the ++ class hierarchy being laid out, the vbase index is not yet known ++ at the point we need to create the thunks, hence the need to use ++ binfos.) */ ++ ++#define THUNK_VIRTUAL_OFFSET(DECL) \ ++ (LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->virtual_offset) ++ ++/* A thunk which is equivalent to another thunk. */ ++#define THUNK_ALIAS(DECL) \ ++ (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->decl_flags.u.thunk_alias) ++ ++/* For thunk NODE, this is the FUNCTION_DECL thunked to. It is ++ possible for the target to be a thunk too. */ ++#define THUNK_TARGET(NODE) \ ++ (DECL_LANG_SPECIFIC (NODE)->u.f.befriending_classes) ++ ++/* These macros provide convenient access to the various _STMT nodes ++ created when parsing template declarations. */ ++#define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0) ++#define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1) ++ ++#define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0) ++#define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1) ++ ++#define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0) ++ ++/* Nonzero if this try block is a function try block. */ ++#define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE)) ++#define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0) ++#define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1) ++#define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE)) ++ ++/* The parameters for a call-declarator. */ ++#define CALL_DECLARATOR_PARMS(NODE) \ ++ (TREE_PURPOSE (TREE_OPERAND (NODE, 1))) ++ ++/* The cv-qualifiers for a call-declarator. */ ++#define CALL_DECLARATOR_QUALS(NODE) \ ++ (TREE_VALUE (TREE_OPERAND (NODE, 1))) ++ ++/* The exception-specification for a call-declarator. */ ++#define CALL_DECLARATOR_EXCEPTION_SPEC(NODE) \ ++ (TREE_TYPE (NODE)) ++ ++/* An enumeration of the kind of tags that C++ accepts. */ ++enum tag_types { ++ none_type = 0, /* Not a tag type. */ ++ record_type, /* "struct" types. */ ++ class_type, /* "class" types. */ ++ union_type, /* "union" types. */ ++ enum_type, /* "enum" types. */ ++ typename_type /* "typename" types. */ ++}; ++ ++/* The various kinds of lvalues we distinguish. */ ++typedef enum cp_lvalue_kind { ++ clk_none = 0, /* Things that are not an lvalue. */ ++ clk_ordinary = 1, /* An ordinary lvalue. */ ++ clk_class = 2, /* An rvalue of class-type. */ ++ clk_bitfield = 4, /* An lvalue for a bit-field. */ ++ clk_packed = 8 /* An lvalue for a packed field. */ ++} cp_lvalue_kind; ++ ++/* Various kinds of template specialization, instantiation, etc. */ ++typedef enum tmpl_spec_kind { ++ tsk_none, /* Not a template at all. */ ++ tsk_invalid_member_spec, /* An explicit member template ++ specialization, but the enclosing ++ classes have not all been explicitly ++ specialized. */ ++ tsk_invalid_expl_inst, /* An explicit instantiation containing ++ template parameter lists. */ ++ tsk_excessive_parms, /* A template declaration with too many ++ template parameter lists. */ ++ tsk_insufficient_parms, /* A template declaration with too few ++ parameter lists. */ ++ tsk_template, /* A template declaration. */ ++ tsk_expl_spec, /* An explicit specialization. */ ++ tsk_expl_inst /* An explicit instantiation. */ ++} tmpl_spec_kind; ++ ++/* The various kinds of access. BINFO_ACCESS depends on these being ++ two bit quantities. The numerical values are important; they are ++ used to initialize RTTI data structures, so changing them changes ++ the ABI. */ ++typedef enum access_kind { ++ ak_none = 0, /* Inaccessible. */ ++ ak_public = 1, /* Accessible, as a `public' thing. */ ++ ak_protected = 2, /* Accessible, as a `protected' thing. */ ++ ak_private = 3 /* Accessible, as a `private' thing. */ ++} access_kind; ++ ++/* The various kinds of special functions. If you add to this list, ++ you should update special_function_p as well. */ ++typedef enum special_function_kind { ++ sfk_none = 0, /* Not a special function. This enumeral ++ must have value zero; see ++ special_function_p. */ ++ sfk_constructor, /* A constructor. */ ++ sfk_copy_constructor, /* A copy constructor. */ ++ sfk_assignment_operator, /* An assignment operator. */ ++ sfk_destructor, /* A destructor. */ ++ sfk_complete_destructor, /* A destructor for complete objects. */ ++ sfk_base_destructor, /* A destructor for base subobjects. */ ++ sfk_deleting_destructor, /* A destructor for complete objects that ++ deletes the object after it has been ++ destroyed. */ ++ sfk_conversion /* A conversion operator. */ ++} special_function_kind; ++ ++/* The various kinds of linkage. From [basic.link], ++ ++ A name is said to have linkage when it might denote the same ++ object, reference, function, type, template, namespace or value ++ as a name introduced in another scope: ++ ++ -- When a name has external linkage, the entity it denotes can ++ be referred to from scopes of other translation units or from ++ other scopes of the same translation unit. ++ ++ -- When a name has internal linkage, the entity it denotes can ++ be referred to by names from other scopes in the same ++ translation unit. ++ ++ -- When a name has no linkage, the entity it denotes cannot be ++ referred to by names from other scopes. */ ++ ++typedef enum linkage_kind { ++ lk_none, /* No linkage. */ ++ lk_internal, /* Internal linkage. */ ++ lk_external /* External linkage. */ ++} linkage_kind; ++ ++/* Bitmask flags to control type substitution. */ ++typedef enum tsubst_flags_t { ++ tf_none = 0, /* nothing special */ ++ tf_error = 1 << 0, /* give error messages */ ++ tf_warning = 1 << 1, /* give warnings too */ ++ tf_ignore_bad_quals = 1 << 2, /* ignore bad cvr qualifiers */ ++ tf_keep_type_decl = 1 << 3, /* retain typedef type decls ++ (make_typename_type use) */ ++ tf_ptrmem_ok = 1 << 4, /* pointers to member ok (internal ++ instantiate_type use) */ ++ tf_user = 1 << 5, /* found template must be a user template ++ (lookup_template_class use) */ ++ tf_stmt_expr_cmpd = 1 << 6, /* tsubsting the compound statement of ++ a statement expr. */ ++ tf_stmt_expr_body = 1 << 7, /* tsubsting the statements in the ++ body of the compound statement of a ++ statement expr. */ ++ tf_conv = 1 << 8 /* We are determining what kind of ++ conversion might be permissible, ++ not actually performing the ++ conversion. */ ++} tsubst_flags_t; ++ ++/* The kind of checking we can do looking in a class hierarchy. */ ++typedef enum base_access { ++ ba_any = 0, /* Do not check access, allow an ambiguous base, ++ prefer a non-virtual base */ ++ ba_ignore = 1, /* Do not check access */ ++ ba_check = 2, /* Check access */ ++ ba_not_special = 3, /* Do not consider special privilege ++ current_class_type might give. */ ++ ba_quiet = 4 /* Do not issue error messages (bit mask). */ ++} base_access; ++ ++/* The various kinds of access check during parsing. */ ++typedef enum deferring_kind { ++ dk_no_deferred = 0, /* Check access immediately */ ++ dk_deferred = 1, /* Deferred check */ ++ dk_no_check = 2 /* No access check */ ++} deferring_kind; ++ ++/* The kind of base we can find, looking in a class hierarchy. ++ Values <0 indicate we failed. */ ++typedef enum base_kind { ++ bk_inaccessible = -3, /* The base is inaccessible */ ++ bk_ambig = -2, /* The base is ambiguous */ ++ bk_not_base = -1, /* It is not a base */ ++ bk_same_type = 0, /* It is the same type */ ++ bk_proper_base = 1, /* It is a proper base */ ++ bk_via_virtual = 2 /* It is a proper base, but via a virtual ++ path. This might not be the canonical ++ binfo. */ ++} base_kind; ++ ++/* Set by add_implicitly_declared_members() to keep those members from ++ being flagged as deprecated or reported as using deprecated ++ types. */ ++extern int adding_implicit_members; ++ ++/* in decl{2}.c */ ++/* A node that is a list (length 1) of error_mark_nodes. */ ++extern GTY(()) tree error_mark_list; ++ ++/* Node for "pointer to (virtual) function". ++ This may be distinct from ptr_type_node so gdb can distinguish them. */ ++#define vfunc_ptr_type_node vtable_entry_type ++ ++ ++/* For building calls to `delete'. */ ++extern GTY(()) tree integer_two_node; ++extern GTY(()) tree integer_three_node; ++ ++/* The number of function bodies which we are currently processing. ++ (Zero if we are at namespace scope, one inside the body of a ++ function, two inside the body of a function in a local class, etc.) */ ++extern int function_depth; ++ ++typedef struct deferred_access GTY(()) ++{ ++ /* A TREE_LIST representing name-lookups for which we have deferred ++ checking access controls. We cannot check the accessibility of ++ names used in a decl-specifier-seq until we know what is being ++ declared because code like: ++ ++ class A { ++ class B {}; ++ B* f(); ++ } ++ ++ A::B* A::f() { return 0; } ++ ++ is valid, even though `A::B' is not generally accessible. ++ ++ The TREE_PURPOSE of each node is the scope used to qualify the ++ name being looked up; the TREE_VALUE is the DECL to which the ++ name was resolved. */ ++ tree deferred_access_checks; ++ /* The current mode of access checks. */ ++ enum deferring_kind deferring_access_checks_kind; ++ /* The next deferred access data in stack or linked-list. */ ++ struct deferred_access *next; ++} deferred_access; ++ ++/* in pt.c */ ++ ++/* These values are used for the `STRICT' parameter to type_unification and ++ fn_type_unification. Their meanings are described with the ++ documentation for fn_type_unification. */ ++ ++typedef enum unification_kind_t { ++ DEDUCE_CALL, ++ DEDUCE_CONV, ++ DEDUCE_EXACT, ++ DEDUCE_ORDER ++} unification_kind_t; ++ ++/* Macros for operating on a template instantiation level node, represented ++ by an EXPR_WITH_FILE_LOCATION. */ ++ ++#define TINST_DECL(NODE) EXPR_WFL_NODE (NODE) ++#define TINST_LINE(NODE) EXPR_WFL_LINENO (NODE) ++#define TINST_FILE(NODE) EXPR_WFL_FILENAME (NODE) ++ ++/* in class.c */ ++ ++extern int current_class_depth; ++ ++/* An array of all local classes present in this translation unit, in ++ declaration order. */ ++extern GTY(()) varray_type local_classes; ++ ++/* Here's where we control how name mangling takes place. */ ++ ++/* Cannot use '$' up front, because this confuses gdb ++ (names beginning with '$' are gdb-local identifiers). ++ ++ Note that all forms in which the '$' is significant are long enough ++ for direct indexing (meaning that if we know there is a '$' ++ at a particular location, we can index into the string at ++ any other location that provides distinguishing characters). */ ++ ++/* Define NO_DOLLAR_IN_LABEL in your favorite tm file if your assembler ++ doesn't allow '$' in symbol names. */ ++#ifndef NO_DOLLAR_IN_LABEL ++ ++#define JOINER '$' ++ ++#define VPTR_NAME "$v" ++#define THROW_NAME "$eh_throw" ++#define AUTO_VTABLE_NAME "__vtbl$me__" ++#define AUTO_TEMP_NAME "_$tmp_" ++#define AUTO_TEMP_FORMAT "_$tmp_%d" ++#define VTABLE_BASE "$vb" ++#define VTABLE_NAME_PREFIX "__vt_" ++#define VFIELD_BASE "$vf" ++#define VFIELD_NAME "_vptr$" ++#define VFIELD_NAME_FORMAT "_vptr$%s" ++#define STATIC_NAME_FORMAT "_%s$%s" ++#define ANON_AGGRNAME_FORMAT "$_%d" ++ ++#else /* NO_DOLLAR_IN_LABEL */ ++ ++#ifndef NO_DOT_IN_LABEL ++ ++#define JOINER '.' ++ ++#define VPTR_NAME ".v" ++#define THROW_NAME ".eh_throw" ++#define AUTO_VTABLE_NAME "__vtbl.me__" ++#define AUTO_TEMP_NAME "_.tmp_" ++#define AUTO_TEMP_FORMAT "_.tmp_%d" ++#define VTABLE_BASE ".vb" ++#define VTABLE_NAME_PREFIX "__vt_" ++#define VFIELD_BASE ".vf" ++#define VFIELD_NAME "_vptr." ++#define VFIELD_NAME_FORMAT "_vptr.%s" ++#define STATIC_NAME_FORMAT "_%s.%s" ++ ++#define ANON_AGGRNAME_FORMAT "._%d" ++ ++#else /* NO_DOT_IN_LABEL */ ++ ++#define VPTR_NAME "__vptr" ++#define VPTR_NAME_P(ID_NODE) \ ++ (!strncmp (IDENTIFIER_POINTER (ID_NODE), VPTR_NAME, sizeof (VPTR_NAME) - 1)) ++#define THROW_NAME "__eh_throw" ++#define IN_CHARGE_NAME "__in_chrg" ++#define AUTO_VTABLE_NAME "__vtbl_me__" ++#define AUTO_TEMP_NAME "__tmp_" ++#define TEMP_NAME_P(ID_NODE) \ ++ (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \ ++ sizeof (AUTO_TEMP_NAME) - 1)) ++#define AUTO_TEMP_FORMAT "__tmp_%d" ++#define VTABLE_BASE "__vtb" ++#define VTABLE_NAME "__vt_" ++#define VTABLE_NAME_PREFIX "__vt_" ++#define VTABLE_NAME_P(ID_NODE) \ ++ (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \ ++ sizeof (VTABLE_NAME) - 1)) ++#define VFIELD_BASE "__vfb" ++#define VFIELD_NAME "__vptr_" ++#define VFIELD_NAME_P(ID_NODE) \ ++ (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \ ++ sizeof (VFIELD_NAME) - 1)) ++#define VFIELD_NAME_FORMAT "__vptr_%s" ++#define STATIC_NAME_FORMAT "__static_%s_%s" ++ ++#define ANON_AGGRNAME_PREFIX "__anon_" ++#define ANON_AGGRNAME_P(ID_NODE) \ ++ (!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \ ++ sizeof (ANON_AGGRNAME_PREFIX) - 1)) ++#define ANON_AGGRNAME_FORMAT "__anon_%d" ++ ++#endif /* NO_DOT_IN_LABEL */ ++#endif /* NO_DOLLAR_IN_LABEL */ ++ ++#define THIS_NAME "this" ++#define CTOR_NAME "__ct" ++#define DTOR_NAME "__dt" ++ ++#define IN_CHARGE_NAME "__in_chrg" ++ ++#define VTBL_PTR_TYPE "__vtbl_ptr_type" ++#define VTABLE_DELTA_NAME "__delta" ++#define VTABLE_PFN_NAME "__pfn" ++ ++#define EXCEPTION_CLEANUP_NAME "exception cleanup" ++ ++#if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) ++ ++#define VPTR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ ++ && IDENTIFIER_POINTER (ID_NODE)[1] == 'v') ++ ++#define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \ ++ && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \ ++ && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER) ++ ++#define TEMP_NAME_P(ID_NODE) \ ++ (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1)) ++#define VFIELD_NAME_P(ID_NODE) \ ++ (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1)) ++ ++/* For anonymous aggregate types, we need some sort of name to ++ hold on to. In practice, this should not appear, but it should ++ not be harmful if it does. */ ++#define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ ++ && IDENTIFIER_POINTER (ID_NODE)[1] == '_') ++#endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */ ++ ++/* Returns nonzero iff NODE is a declaration for the global function ++ `main'. */ ++#define DECL_MAIN_P(NODE) \ ++ (DECL_EXTERN_C_FUNCTION_P (NODE) \ ++ && DECL_NAME (NODE) != NULL_TREE \ ++ && MAIN_NAME_P (DECL_NAME (NODE))) ++ ++ ++/* Nonzero if we're done parsing and into end-of-file activities. */ ++ ++extern int at_eof; ++ ++/* A list of namespace-scope objects which have constructors or ++ destructors which reside in the global scope. The decl is stored ++ in the TREE_VALUE slot and the initializer is stored in the ++ TREE_PURPOSE slot. */ ++extern GTY(()) tree static_aggregates; ++ ++/* Functions called along with real static constructors and destructors. */ ++ ++extern GTY(()) tree static_ctors; ++extern GTY(()) tree static_dtors; ++ ++enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG }; ++ ++/* Some macros for char-based bitfields. */ ++#define B_SET(A,X) ((A)[(X)>>3] |= (1 << ((X)&7))) ++#define B_CLR(A,X) ((A)[(X)>>3] &= ~(1 << ((X)&7))) ++#define B_TST(A,X) ((A)[(X)>>3] & (1 << ((X)&7))) ++ ++/* These are uses as bits in flags passed to build_new_method_call ++ to control its error reporting behavior. ++ ++ LOOKUP_PROTECT means flag access violations. ++ LOOKUP_COMPLAIN mean complain if no suitable member function ++ matching the arguments is found. ++ LOOKUP_NORMAL is just a combination of these two. ++ LOOKUP_NONVIRTUAL means make a direct call to the member function found ++ LOOKUP_GLOBAL means search through the space of overloaded functions, ++ as well as the space of member functions. ++ LOOKUP_ONLYCONVERTING means that non-conversion constructors are not tried. ++ DIRECT_BIND means that if a temporary is created, it should be created so ++ that it lives as long as the current variable bindings; otherwise it ++ only lives until the end of the complete-expression. It also forces ++ direct-initialization in cases where other parts of the compiler have ++ already generated a temporary, such as reference initialization and the ++ catch parameter. ++ LOOKUP_SPECULATIVELY means return NULL_TREE if we cannot find what we are ++ after. Note, LOOKUP_COMPLAIN is checked and error messages printed ++ before LOOKUP_SPECULATIVELY is checked. ++ LOOKUP_NO_CONVERSION means that user-defined conversions are not ++ permitted. Built-in conversions are permitted. ++ LOOKUP_DESTRUCTOR means explicit call to destructor. ++ LOOKUP_NO_TEMP_BIND means temporaries will not be bound to references. ++ ++ These are used in global lookup to support elaborated types and ++ qualifiers. ++ ++ LOOKUP_PREFER_TYPES means not to accept objects, and possibly namespaces. ++ LOOKUP_PREFER_NAMESPACES means not to accept objects, and possibly types. ++ LOOKUP_PREFER_BOTH means class-or-namespace-name. */ ++ ++#define LOOKUP_PROTECT (1 << 0) ++#define LOOKUP_COMPLAIN (1 << 1) ++#define LOOKUP_NORMAL (LOOKUP_PROTECT | LOOKUP_COMPLAIN) ++#define LOOKUP_NONVIRTUAL (1 << 2) ++#define LOOKUP_GLOBAL (1 << 3) ++#define LOOKUP_SPECULATIVELY (1 << 4) ++#define LOOKUP_ONLYCONVERTING (1 << 5) ++#define DIRECT_BIND (1 << 6) ++#define LOOKUP_NO_CONVERSION (1 << 7) ++#define LOOKUP_DESTRUCTOR (1 << 8) ++#define LOOKUP_NO_TEMP_BIND (1 << 9) ++#define LOOKUP_PREFER_TYPES (1 << 10) ++#define LOOKUP_PREFER_NAMESPACES (1 << 11) ++#define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES) ++#define LOOKUP_CONSTRUCTOR_CALLABLE (1 << 12) ++ ++#define LOOKUP_NAMESPACES_ONLY(F) \ ++ (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES)) ++#define LOOKUP_TYPES_ONLY(F) \ ++ (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES)) ++#define LOOKUP_QUALIFIERS_ONLY(F) ((F) & LOOKUP_PREFER_BOTH) ++ ++ ++/* These flags are used by the conversion code. ++ CONV_IMPLICIT : Perform implicit conversions (standard and user-defined). ++ CONV_STATIC : Perform the explicit conversions for static_cast. ++ CONV_CONST : Perform the explicit conversions for const_cast. ++ CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast. ++ CONV_PRIVATE : Perform upcasts to private bases. ++ CONV_FORCE_TEMP : Require a new temporary when converting to the same ++ aggregate type. */ ++ ++#define CONV_IMPLICIT 1 ++#define CONV_STATIC 2 ++#define CONV_CONST 4 ++#define CONV_REINTERPRET 8 ++#define CONV_PRIVATE 16 ++/* #define CONV_NONCONVERTING 32 */ ++#define CONV_FORCE_TEMP 64 ++#define CONV_STATIC_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_FORCE_TEMP) ++#define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ ++ | CONV_REINTERPRET) ++#define CONV_C_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ ++ | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP) ++ ++/* Used by build_expr_type_conversion to indicate which types are ++ acceptable as arguments to the expression under consideration. */ ++ ++#define WANT_INT 1 /* integer types, including bool */ ++#define WANT_FLOAT 2 /* floating point types */ ++#define WANT_ENUM 4 /* enumerated types */ ++#define WANT_POINTER 8 /* pointer types */ ++#define WANT_NULL 16 /* null pointer constant */ ++#define WANT_ARITH (WANT_INT | WANT_FLOAT) ++ ++/* Used with comptypes, and related functions, to guide type ++ comparison. */ ++ ++#define COMPARE_STRICT 0 /* Just check if the types are the ++ same. */ ++#define COMPARE_BASE 1 /* Check to see if the second type is ++ derived from the first. */ ++#define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in ++ reverse. */ ++#define COMPARE_REDECLARATION 4 /* The comparison is being done when ++ another declaration of an existing ++ entity is seen. */ ++ ++/* Used with push_overloaded_decl. */ ++#define PUSH_GLOBAL 0 /* Push the DECL into namespace scope, ++ regardless of the current scope. */ ++#define PUSH_LOCAL 1 /* Push the DECL into the current ++ scope. */ ++#define PUSH_USING 2 /* We are pushing this DECL as the ++ result of a using declaration. */ ++ ++/* Used with start function. */ ++#define SF_DEFAULT 0 /* No flags. */ ++#define SF_PRE_PARSED 1 /* The function declaration has ++ already been parsed. */ ++#define SF_INCLASS_INLINE 2 /* The function is an inline, defined ++ in the class body. */ ++ ++/* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2 ++ is derived from TYPE1, or if TYPE2 is a pointer (reference) to a ++ class derived from the type pointed to (referred to) by TYPE1. */ ++#define same_or_base_type_p(TYPE1, TYPE2) \ ++ comptypes ((TYPE1), (TYPE2), COMPARE_BASE) ++ ++/* These macros are used to access a TEMPLATE_PARM_INDEX. */ ++#define TEMPLATE_PARM_INDEX_CAST(NODE) \ ++ ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE)) ++#define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index) ++#define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level) ++#define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE)) ++#define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level) ++#define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl) ++ ++/* These macros are for accessing the fields of TEMPLATE_TYPE_PARM, ++ TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */ ++#define TEMPLATE_TYPE_PARM_INDEX(NODE) (TYPE_FIELDS (NODE)) ++#define TEMPLATE_TYPE_IDX(NODE) \ ++ (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE))) ++#define TEMPLATE_TYPE_LEVEL(NODE) \ ++ (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) ++#define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \ ++ (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) ++#define TEMPLATE_TYPE_DECL(NODE) \ ++ (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE))) ++ ++/* These constants can used as bit flags in the process of tree formatting. ++ ++ TFF_PLAIN_IDENTIFIER: unqualified part of a name. ++ TFF_SCOPE: include the class and namespace scope of the name. ++ TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name. ++ TFF_DECL_SPECIFIERS: print decl-specifiers. ++ TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with ++ a class-key (resp. `enum'). ++ TFF_RETURN_TYPE: include function return type. ++ TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values. ++ TFF_EXCEPTION_SPECIFICATION: show function exception specification. ++ TFF_TEMPLATE_HEADER: show the template<...> header in a ++ template-declaration. ++ TFF_TEMPLATE_NAME: show only template-name. ++ TFF_EXPR_IN_PARENS: parenthesize expressions. ++ TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments. */ ++ ++#define TFF_PLAIN_IDENTIFIER (0) ++#define TFF_SCOPE (1) ++#define TFF_CHASE_TYPEDEF (1 << 1) ++#define TFF_DECL_SPECIFIERS (1 << 2) ++#define TFF_CLASS_KEY_OR_ENUM (1 << 3) ++#define TFF_RETURN_TYPE (1 << 4) ++#define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5) ++#define TFF_EXCEPTION_SPECIFICATION (1 << 6) ++#define TFF_TEMPLATE_HEADER (1 << 7) ++#define TFF_TEMPLATE_NAME (1 << 8) ++#define TFF_EXPR_IN_PARENS (1 << 9) ++#define TFF_NO_FUNCTION_ARGUMENTS (1 << 10) ++ ++/* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM ++ node. */ ++#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \ ++ ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \ ++ ? TYPE_TI_TEMPLATE (NODE) \ ++ : TYPE_NAME (NODE)) ++ ++/* in lex.c */ ++ ++extern void init_reswords (void); ++ ++/* Indexed by TREE_CODE, these tables give C-looking names to ++ operators represented by TREE_CODES. For example, ++ opname_tab[(int) MINUS_EXPR] == "-". */ ++extern const char **opname_tab, **assignop_tab; ++ ++typedef struct operator_name_info_t GTY(()) ++{ ++ /* The IDENTIFIER_NODE for the operator. */ ++ tree identifier; ++ /* The name of the operator. */ ++ const char *name; ++ /* The mangled name of the operator. */ ++ const char *mangled_name; ++ /* The arity of the operator. */ ++ int arity; ++} operator_name_info_t; ++ ++/* A mapping from tree codes to operator name information. */ ++extern GTY(()) operator_name_info_t operator_name_info ++ [(int) LAST_CPLUS_TREE_CODE]; ++/* Similar, but for assignment operators. */ ++extern GTY(()) operator_name_info_t assignment_operator_name_info ++ [(int) LAST_CPLUS_TREE_CODE]; ++ ++/* in call.c */ ++extern bool check_dtor_name (tree, tree); ++ ++extern tree build_vfield_ref (tree, tree); ++extern tree build_conditional_expr (tree, tree, tree); ++extern tree build_addr_func (tree); ++extern tree build_call (tree, tree); ++extern bool null_ptr_cst_p (tree); ++extern bool sufficient_parms_p (tree); ++extern tree type_decays_to (tree); ++extern tree build_user_type_conversion (tree, tree, int); ++extern tree build_new_function_call (tree, tree); ++extern tree build_operator_new_call (tree, tree, tree *, tree *); ++extern tree build_new_method_call (tree, tree, tree, tree, int); ++extern tree build_special_member_call (tree, tree, tree, tree, int); ++extern tree build_new_op (enum tree_code, int, tree, tree, tree, bool *); ++extern tree build_op_delete_call (enum tree_code, tree, tree, int, tree); ++extern bool can_convert (tree, tree); ++extern bool can_convert_arg (tree, tree, tree); ++extern bool can_convert_arg_bad (tree, tree, tree); ++extern bool enforce_access (tree, tree); ++extern tree convert_default_arg (tree, tree, tree, int); ++extern tree convert_arg_to_ellipsis (tree); ++extern tree build_x_va_arg (tree, tree); ++extern tree cxx_type_promotes_to (tree); ++extern tree type_passed_as (tree); ++extern tree convert_for_arg_passing (tree, tree); ++extern tree cp_convert_parm_for_inlining (tree, tree, tree); ++extern bool is_properly_derived_from (tree, tree); ++extern tree initialize_reference (tree, tree, tree, tree *); ++extern tree make_temporary_var_for_ref_to_temp (tree, tree); ++extern tree strip_top_quals (tree); ++extern tree perform_implicit_conversion (tree, tree); ++extern tree perform_direct_initialization_if_possible (tree, tree); ++extern tree in_charge_arg_for_name (tree); ++extern tree build_cxx_call (tree, tree, tree); ++ ++/* in class.c */ ++extern tree build_base_path (enum tree_code, tree, tree, int); ++extern tree convert_to_base (tree, tree, bool); ++extern tree convert_to_base_statically (tree, tree); ++extern tree build_vtbl_ref (tree, tree); ++extern tree build_vfn_ref (tree, tree); ++extern tree get_vtable_decl (tree, int); ++extern void resort_type_method_vec ++ (void *, void *, gt_pointer_operator, void *); ++extern void add_method (tree, tree, int); ++extern int currently_open_class (tree); ++extern tree currently_open_derived_class (tree); ++extern tree finish_struct (tree, tree); ++extern void finish_struct_1 (tree); ++extern int resolves_to_fixed_type_p (tree, int *); ++extern void init_class_processing (void); ++extern int is_empty_class (tree); ++extern void pushclass (tree); ++extern void popclass (void); ++extern void push_nested_class (tree); ++extern void pop_nested_class (void); ++extern int current_lang_depth (void); ++extern void push_lang_context (tree); ++extern void pop_lang_context (void); ++extern tree instantiate_type (tree, tree, tsubst_flags_t); ++extern void print_class_statistics (void); ++extern void cxx_print_statistics (void); ++extern void cxx_print_xnode (FILE *, tree, int); ++extern void cxx_print_decl (FILE *, tree, int); ++extern void cxx_print_type (FILE *, tree, int); ++extern void cxx_print_identifier (FILE *, tree, int); ++extern void cxx_print_error_function (struct diagnostic_context *, ++ const char *); ++extern void build_self_reference (void); ++extern int same_signature_p (tree, tree); ++extern void warn_hidden (tree); ++extern void maybe_add_class_template_decl_list (tree, tree, int); ++extern tree get_enclosing_class (tree); ++extern void unreverse_member_declarations (tree); ++extern void invalidate_class_lookup_cache (void); ++extern void maybe_note_name_used_in_class (tree, tree); ++extern void note_name_declared_in_class (tree, tree); ++extern tree get_vtbl_decl_for_binfo (tree); ++extern tree get_vtt_name (tree); ++extern tree get_primary_binfo (tree); ++extern void debug_class (tree); ++extern void debug_thunks (tree); ++ ++/* in cvt.c */ ++extern tree convert_to_reference (tree, tree, int, int, tree); ++extern tree convert_from_reference (tree); ++extern tree convert_lvalue (tree, tree); ++extern tree force_rvalue (tree); ++extern tree ocp_convert (tree, tree, int, int); ++extern tree cp_convert (tree, tree); ++extern tree convert_to_void (tree, const char */*implicit context*/); ++extern tree convert_force (tree, tree, int); ++extern tree build_type_conversion (tree, tree); ++extern tree build_expr_type_conversion (int, tree, bool); ++extern tree type_promotes_to (tree); ++extern tree perform_qualification_conversions (tree, tree); ++extern void clone_function_decl (tree, int); ++extern void adjust_clone_args (tree); ++ ++/* decl.c */ ++extern void insert_block (tree); ++extern void set_block (tree); ++extern tree pushdecl (tree); ++extern void cxx_init_decl_processing (void); ++enum cp_tree_node_structure_enum cp_tree_node_structure ++ (union lang_tree_node *); ++extern bool cxx_mark_addressable (tree); ++extern void cxx_push_function_context (struct function *); ++extern void cxx_pop_function_context (struct function *); ++extern void cxx_mark_function_context (struct function *); ++extern void maybe_push_cleanup_level (tree); ++extern void finish_scope (void); ++extern void delete_block (tree); ++extern void add_block_current_level (tree); ++extern void push_switch (tree); ++extern void pop_switch (void); ++extern void pushtag (tree, tree, int); ++extern tree make_anon_name (void); ++extern void clear_anon_tags (void); ++extern int decls_match (tree, tree); ++extern tree duplicate_decls (tree, tree); ++extern tree pushdecl_top_level (tree); ++extern tree pushdecl_top_level_and_finish (tree, tree); ++extern tree push_using_decl (tree, tree); ++extern tree implicitly_declare (tree); ++extern tree declare_local_label (tree); ++extern tree define_label (location_t, tree); ++extern void check_goto (tree); ++extern void define_case_label (void); ++extern tree make_typename_type (tree, tree, tsubst_flags_t); ++extern tree make_unbound_class_template (tree, tree, tsubst_flags_t); ++extern tree check_for_out_of_scope_variable (tree); ++extern tree build_library_fn (tree, tree); ++extern tree build_library_fn_ptr (const char *, tree); ++extern tree build_cp_library_fn_ptr (const char *, tree); ++extern tree push_library_fn (tree, tree); ++extern tree push_void_library_fn (tree, tree); ++extern tree push_throw_library_fn (tree, tree); ++extern int init_type_desc (void); ++extern tree check_tag_decl (tree); ++extern tree shadow_tag (tree); ++extern tree groktypename (tree); ++extern tree start_decl (tree, tree, int, tree, tree); ++extern void start_decl_1 (tree); ++extern void cp_finish_decl (tree, tree, tree, int); ++extern void finish_decl (tree, tree, tree); ++extern void maybe_inject_for_scope_var (tree); ++extern tree start_handler_parms (tree, tree); ++extern int complete_array_type (tree, tree, int); ++extern tree build_ptrmemfunc_type (tree); ++extern tree build_ptrmem_type (tree, tree); ++/* the grokdeclarator prototype is in decl.h */ ++extern int copy_fn_p (tree); ++extern tree get_scope_of_declarator (tree); ++extern void grok_special_member_properties (tree); ++extern int grok_ctor_properties (tree, tree); ++extern bool grok_op_properties (tree, int, bool); ++extern tree xref_tag (enum tag_types, tree, bool, bool); ++extern tree xref_tag_from_type (tree, tree, int); ++extern void xref_basetypes (tree, tree); ++extern tree start_enum (tree); ++extern void finish_enum (tree); ++extern void build_enumerator (tree, tree, tree); ++extern int start_function (tree, tree, tree, int); ++extern tree begin_function_body (void); ++extern void finish_function_body (tree); ++extern tree finish_function (int); ++extern tree start_method (tree, tree, tree); ++extern tree finish_method (tree); ++extern void maybe_register_incomplete_var (tree); ++extern void complete_vars (tree); ++extern void finish_stmt (void); ++extern void print_other_binding_stack (struct cp_binding_level *); ++extern void revert_static_member_fn (tree); ++extern void fixup_anonymous_aggr (tree); ++extern int check_static_variable_definition (tree, tree); ++extern tree compute_array_index_type (tree, tree); ++extern tree check_default_argument (tree, tree); ++extern int vtable_decl_p (tree, void *); ++extern int vtype_decl_p (tree, void *); ++extern int sigtable_decl_p (tree, void *); ++typedef bool (*walk_globals_pred) (tree, void *); ++typedef bool (*walk_globals_fn) (tree *, void *); ++extern bool walk_globals (walk_globals_pred, walk_globals_fn, void *); ++extern bool walk_vtables (walk_globals_pred, walk_globals_fn, void *); ++typedef int (*walk_namespaces_fn) (tree, void *); ++extern int walk_namespaces (walk_namespaces_fn, ++ void *); ++extern int wrapup_globals_for_namespace (tree, void *); ++extern tree create_implicit_typedef (tree, tree); ++extern tree maybe_push_decl (tree); ++extern tree force_target_expr (tree, tree); ++extern tree build_target_expr_with_type (tree, tree); ++extern int local_variable_p (tree); ++extern int nonstatic_local_decl_p (tree); ++extern tree declare_global_var (tree, tree); ++extern void register_dtor_fn (tree); ++extern tmpl_spec_kind current_tmpl_spec_kind (int); ++extern tree cp_fname_init (const char *, tree *); ++extern tree check_elaborated_type_specifier (enum tag_types, tree, bool); ++extern tree cxx_builtin_type_decls (void); ++extern void warn_extern_redeclared_static (tree, tree); ++extern tree check_var_type (tree, tree); ++ ++extern bool have_extern_spec; ++ ++/* in decl2.c */ ++extern bool check_java_method (tree); ++extern int grok_method_quals (tree, tree, tree); ++extern void grok_x_components (tree); ++extern void maybe_retrofit_in_chrg (tree); ++extern void maybe_make_one_only (tree); ++extern void grokclassfn (tree, tree, enum overload_flags, tree); ++extern tree grok_array_decl (tree, tree); ++extern tree delete_sanity (tree, tree, bool, int); ++extern tree check_classfn (tree, tree, bool); ++extern void check_member_template (tree); ++extern tree grokfield (tree, tree, tree, tree, tree); ++extern tree grokbitfield (tree, tree, tree); ++extern tree groktypefield (tree, tree); ++extern void cplus_decl_attributes (tree *, tree, int); ++extern void defer_fn (tree); ++extern void finish_anon_union (tree); ++extern tree finish_table (tree, tree, tree, int); ++extern tree coerce_new_type (tree); ++extern tree coerce_delete_type (tree); ++extern void comdat_linkage (tree); ++extern void import_export_vtable (tree, tree, int); ++extern void import_export_decl (tree); ++extern void import_export_tinfo (tree, tree, bool); ++extern tree build_cleanup (tree); ++extern tree build_offset_ref_call_from_tree (tree, tree); ++extern void check_default_args (tree); ++extern void mark_used (tree); ++extern void finish_static_data_member_decl (tree, tree, tree, int); ++extern tree cp_build_parm_decl (tree, tree); ++extern tree build_artificial_parm (tree, tree); ++extern tree get_guard (tree); ++extern tree get_guard_cond (tree); ++extern tree set_guard (tree); ++extern tree cxx_callgraph_analyze_expr (tree *, int *, tree); ++ ++/* XXX Not i18n clean. */ ++#define cp_deprecated(STR) \ ++ do { \ ++ if (warn_deprecated) \ ++ warning ("%s is deprecated, please see the documentation for details", \ ++ (STR)); \ ++ } while (0) ++ ++/* in error.c */ ++extern void init_error (void); ++extern const char *type_as_string (tree, int); ++extern const char *decl_as_string (tree, int); ++extern const char *expr_as_string (tree, int); ++extern const char *context_as_string (tree, int); ++extern const char *lang_decl_name (tree, int); ++extern const char *language_to_string (enum languages); ++extern void print_instantiation_context (void); ++ ++/* in except.c */ ++extern void init_exception_processing (void); ++extern tree expand_start_catch_block (tree); ++extern void expand_end_catch_block (void); ++extern void expand_builtin_throw (void); ++extern void expand_eh_spec_block (tree); ++extern void expand_exception_blocks (void); ++extern tree build_exc_ptr (void); ++extern tree build_throw (tree); ++extern void mark_all_runtime_matches (void); ++extern int nothrow_libfn_p (tree); ++extern void check_handlers (tree); ++extern void choose_personality_routine (enum languages); ++extern tree eh_type_info (tree); ++ ++/* in expr.c */ ++extern rtx cxx_expand_expr (tree, rtx, ++ enum machine_mode, ++ int, rtx *); ++extern tree cplus_expand_constant (tree); ++ ++/* friend.c */ ++extern int is_friend (tree, tree); ++extern void make_friend_class (tree, tree, bool); ++extern void add_friend (tree, tree, bool); ++extern tree do_friend (tree, tree, tree, tree, enum overload_flags, tree, int); ++ ++/* in init.c */ ++extern tree expand_member_init (tree); ++extern void emit_mem_initializers (tree); ++extern tree build_aggr_init (tree, tree, int); ++extern tree build_init (tree, tree, int); ++extern int is_aggr_type (tree, int); ++extern tree get_aggr_from_typedef (tree, int); ++extern tree get_type_value (tree); ++extern tree build_zero_init (tree, tree, bool); ++extern tree build_offset_ref (tree, tree, bool); ++extern tree build_new (tree, tree, tree, int); ++extern tree build_vec_init (tree, tree, tree, int); ++extern tree build_x_delete (tree, int, tree); ++extern tree build_delete (tree, tree, special_function_kind, int, int); ++extern void push_base_cleanups (void); ++extern tree build_vbase_delete (tree, tree); ++extern tree build_vec_delete (tree, tree, special_function_kind, int); ++extern tree create_temporary_var (tree); ++extern void initialize_vtbl_ptrs (tree); ++extern tree build_java_class_ref (tree); ++ ++/* in input.c */ ++ ++/* in lex.c */ ++extern void cxx_dup_lang_specific_decl (tree); ++extern tree make_pointer_declarator (tree, tree); ++extern tree make_reference_declarator (tree, tree); ++extern tree make_call_declarator (tree, tree, tree, tree); ++extern void set_quals_and_spec (tree, tree, tree); ++extern void print_parse_statistics (void); ++extern void do_pending_inlines (void); ++extern void yyungetc (int, int); ++extern void snarf_method (tree); ++ ++extern void see_typename (void); ++extern tree unqualified_name_lookup_error (tree); ++extern tree unqualified_fn_lookup_error (tree); ++extern tree build_lang_decl (enum tree_code, tree, tree); ++extern void retrofit_lang_decl (tree); ++extern tree copy_decl (tree); ++extern tree copy_type (tree); ++extern tree cxx_make_type (enum tree_code); ++extern tree make_aggr_type (enum tree_code); ++extern void yyerror (const char *); ++extern void yyhook (int); ++extern int cp_type_qual_from_rid (tree); ++extern bool cxx_init (void); ++extern void cxx_finish (void); ++ ++/* in method.c */ ++extern void init_method (void); ++extern void set_mangled_name_for_decl (tree); ++extern tree make_thunk (tree, bool, tree, tree); ++extern void finish_thunk (tree); ++extern void use_thunk (tree, bool); ++extern void synthesize_method (tree); ++extern tree implicitly_declare_fn (special_function_kind, tree, bool); ++extern tree skip_artificial_parms_for (tree, tree); ++ ++/* In optimize.c */ ++extern void optimize_function (tree); ++extern bool calls_setjmp_p (tree); ++extern bool maybe_clone_body (tree); ++ ++/* in pt.c */ ++extern void check_template_shadow (tree); ++extern tree get_innermost_template_args (tree, int); ++extern void maybe_begin_member_template_processing (tree); ++extern void maybe_end_member_template_processing (void); ++extern tree finish_member_template_decl (tree); ++extern void begin_template_parm_list (void); ++extern void begin_specialization (void); ++extern void reset_specialization (void); ++extern void end_specialization (void); ++extern void begin_explicit_instantiation (void); ++extern void end_explicit_instantiation (void); ++extern tree check_explicit_specialization (tree, tree, int, int); ++extern tree process_template_parm (tree, tree); ++extern tree end_template_parm_list (tree); ++extern void end_template_decl (void); ++extern tree current_template_args (void); ++extern tree push_template_decl (tree); ++extern tree push_template_decl_real (tree, int); ++extern void redeclare_class_template (tree, tree); ++extern tree lookup_template_class (tree, tree, tree, tree, int, tsubst_flags_t); ++extern tree lookup_template_function (tree, tree); ++extern int uses_template_parms (tree); ++extern int uses_template_parms_level (tree, int); ++extern tree instantiate_class_template (tree); ++extern tree instantiate_template (tree, tree, tsubst_flags_t); ++extern int fn_type_unification (tree, tree, tree, tree, tree, unification_kind_t, int); ++extern tree tinst_for_decl (void); ++extern void mark_decl_instantiated (tree, int); ++extern int more_specialized (tree, tree, int, int); ++extern void mark_class_instantiated (tree, int); ++extern void do_decl_instantiation (tree, tree); ++extern void do_type_instantiation (tree, tree, tsubst_flags_t); ++extern tree instantiate_decl (tree, int); ++extern int push_tinst_level (tree); ++extern void pop_tinst_level (void); ++extern int more_specialized_class (tree, tree, tree); ++extern int is_member_template (tree); ++extern int comp_template_parms (tree, tree); ++extern int template_class_depth (tree); ++extern int is_specialization_of (tree, tree); ++extern bool is_specialization_of_friend (tree, tree); ++extern int comp_template_args (tree, tree); ++extern void maybe_process_partial_specialization (tree); ++extern tree most_specialized_instantiation (tree); ++extern void print_candidates (tree); ++extern int instantiate_pending_templates (void); ++extern tree tsubst_default_argument (tree, tree, tree); ++extern tree tsubst_copy_and_build (tree, tree, tsubst_flags_t, tree, bool); ++extern tree most_general_template (tree); ++extern tree get_mostly_instantiated_function_type (tree); ++extern int problematic_instantiation_changed (void); ++extern void record_last_problematic_instantiation (void); ++extern tree current_instantiation (void); ++extern tree maybe_get_template_decl_from_type_decl (tree); ++extern int processing_template_parmlist; ++extern bool dependent_type_p (tree); ++extern bool any_dependent_template_arguments_p (tree); ++extern bool dependent_template_p (tree); ++extern bool dependent_template_id_p (tree, tree); ++extern bool type_dependent_expression_p (tree); ++extern bool any_type_dependent_arguments_p (tree); ++extern bool value_dependent_expression_p (tree); ++extern tree resolve_typename_type (tree, bool); ++extern tree template_for_substitution (tree); ++extern tree build_non_dependent_expr (tree); ++extern tree build_non_dependent_args (tree); ++extern bool reregister_specialization (tree, tree, tree); ++extern tree fold_non_dependent_expr (tree); ++ ++/* in repo.c */ ++extern void repo_template_used (tree); ++extern void repo_template_instantiated (tree, bool); ++extern void init_repo (const char *); ++extern void finish_repo (void); ++ ++/* in rtti.c */ ++/* A varray of all tinfo decls that haven't been emitted yet. */ ++extern GTY(()) varray_type unemitted_tinfo_decls; ++ ++extern void init_rtti_processing (void); ++extern tree build_typeid (tree); ++extern tree get_tinfo_decl (tree); ++extern tree get_typeid (tree); ++extern tree build_dynamic_cast (tree, tree); ++extern void emit_support_tinfos (void); ++extern bool emit_tinfo_decl (tree); ++ ++/* in search.c */ ++extern bool accessible_base_p (tree, tree); ++extern tree lookup_base (tree, tree, base_access, base_kind *); ++extern int types_overlap_p (tree, tree); ++extern tree get_dynamic_cast_base_type (tree, tree); ++extern int accessible_p (tree, tree); ++extern tree lookup_field_1 (tree, tree, bool); ++extern tree lookup_field (tree, tree, int, bool); ++extern int lookup_fnfields_1 (tree, tree); ++extern tree lookup_fnfields (tree, tree, int); ++extern tree lookup_member (tree, tree, int, bool); ++extern int look_for_overrides (tree, tree); ++extern void get_pure_virtuals (tree); ++extern void maybe_suppress_debug_info (tree); ++extern void note_debug_info_needed (tree); ++extern void push_class_decls (tree); ++extern void pop_class_decls (void); ++extern void unuse_fields (tree); ++extern void print_search_statistics (void); ++extern void init_search_processing (void); ++extern void reinit_search_statistics (void); ++extern tree current_scope (void); ++extern int at_function_scope_p (void); ++extern bool at_class_scope_p (void); ++extern bool at_namespace_scope_p (void); ++extern tree context_for_name_lookup (tree); ++extern tree lookup_conversions (tree); ++extern tree binfo_for_vtable (tree); ++extern tree binfo_from_vbase (tree); ++extern tree look_for_overrides_here (tree, tree); ++extern int check_final_overrider (tree, tree); ++extern tree dfs_walk (tree, ++ tree (*) (tree, void *), ++ tree (*) (tree, int, void *), ++ void *); ++extern tree dfs_walk_real (tree, ++ tree (*) (tree, void *), ++ tree (*) (tree, void *), ++ tree (*) (tree, int, void *), ++ void *); ++extern tree dfs_unmark (tree, void *); ++extern tree markedp (tree, int, void *); ++extern tree unmarkedp (tree, int, void *); ++extern tree binfo_via_virtual (tree, tree); ++extern tree build_baselink (tree, tree, tree, tree); ++extern tree adjust_result_of_qualified_name_lookup ++ (tree, tree, tree); ++extern tree copied_binfo (tree, tree); ++extern tree original_binfo (tree, tree); ++extern int shared_member_p (tree); ++ ++/* in semantics.c */ ++extern void push_deferring_access_checks (deferring_kind); ++extern void resume_deferring_access_checks (void); ++extern void stop_deferring_access_checks (void); ++extern void pop_deferring_access_checks (void); ++extern tree get_deferred_access_checks (void); ++extern void pop_to_parent_deferring_access_checks (void); ++extern void perform_deferred_access_checks (void); ++extern void perform_or_defer_access_check (tree, tree); ++extern void init_cp_semantics (void); ++extern tree finish_expr_stmt (tree); ++extern tree begin_if_stmt (void); ++extern void finish_if_stmt_cond (tree, tree); ++extern tree finish_then_clause (tree); ++extern void begin_else_clause (void); ++extern void finish_else_clause (tree); ++extern void finish_if_stmt (void); ++extern tree begin_while_stmt (void); ++extern void finish_while_stmt_cond (tree, tree); ++extern void finish_while_stmt (tree); ++extern tree begin_do_stmt (void); ++extern void finish_do_body (tree); ++extern void finish_do_stmt (tree, tree); ++extern tree finish_return_stmt (tree); ++extern tree begin_for_stmt (void); ++extern void finish_for_init_stmt (tree); ++extern void finish_for_cond (tree, tree); ++extern void finish_for_expr (tree, tree); ++extern void finish_for_stmt (tree); ++extern tree finish_break_stmt (void); ++extern tree finish_continue_stmt (void); ++extern tree begin_switch_stmt (void); ++extern void finish_switch_cond (tree, tree); ++extern void finish_switch_stmt (tree); ++extern tree finish_case_label (tree, tree); ++extern tree finish_goto_stmt (tree); ++extern tree begin_try_block (void); ++extern void finish_try_block (tree); ++extern tree begin_eh_spec_block (void); ++extern void finish_eh_spec_block (tree, tree); ++extern void finish_handler_sequence (tree); ++extern tree begin_function_try_block (void); ++extern void finish_function_try_block (tree); ++extern void finish_function_handler_sequence (tree); ++extern void finish_cleanup_try_block (tree); ++extern tree begin_handler (void); ++extern void finish_handler_parms (tree, tree); ++extern void begin_catch_block (tree); ++extern void finish_handler (tree); ++extern void finish_cleanup (tree, tree); ++extern tree begin_compound_stmt (bool); ++extern tree finish_compound_stmt (tree); ++extern tree finish_asm_stmt (tree, tree, tree, tree, tree); ++extern tree finish_label_stmt (tree); ++extern void finish_label_decl (tree); ++extern void finish_subobject (tree); ++extern tree finish_parenthesized_expr (tree); ++extern tree finish_non_static_data_member (tree, tree, tree); ++extern tree begin_stmt_expr (void); ++extern tree finish_stmt_expr_expr (tree); ++extern tree finish_stmt_expr (tree, bool); ++extern tree perform_koenig_lookup (tree, tree); ++extern tree finish_call_expr (tree, tree, bool, bool); ++extern tree finish_increment_expr (tree, enum tree_code); ++extern tree finish_this_expr (void); ++extern tree finish_pseudo_destructor_expr (tree, tree, tree); ++extern tree finish_unary_op_expr (enum tree_code, tree); ++extern tree finish_compound_literal (tree, tree); ++extern tree finish_fname (tree); ++extern int begin_function_definition (tree, tree, tree); ++extern void finish_translation_unit (void); ++extern tree finish_template_type_parm (tree, tree); ++extern tree finish_template_template_parm (tree, tree); ++extern tree finish_parmlist (tree, int); ++extern tree begin_class_definition (tree); ++extern void finish_default_args (void); ++extern tree finish_member_class_template (tree); ++extern void finish_template_decl (tree); ++extern tree finish_template_type (tree, tree, int); ++extern tree finish_base_specifier (tree, tree, bool); ++extern void finish_member_declaration (tree); ++extern void check_multiple_declarators (void); ++extern void qualified_name_lookup_error (tree, tree); ++extern tree finish_id_expression (tree, tree, tree, ++ cp_id_kind *, tree *, ++ bool, bool, bool *, ++ const char **); ++extern tree finish_typeof (tree); ++extern void finish_decl_cleanup (tree, tree); ++extern void finish_eh_cleanup (tree); ++extern void expand_body (tree); ++extern void cxx_expand_function_start (void); ++extern tree nullify_returns_r (tree *, int *, void *); ++extern void do_pushlevel (scope_kind); ++extern tree do_poplevel (void); ++extern void finish_mem_initializers (tree); ++extern void setup_vtbl_ptr (tree, tree); ++extern void clear_out_block (void); ++extern tree check_template_template_default_arg (tree); ++extern void expand_or_defer_fn (tree); ++extern void check_accessibility_of_qualified_id (tree, tree, tree); ++extern tree finish_qualified_id_expr (tree, tree, bool, bool); ++extern void simplify_aggr_init_expr (tree *); ++ ++/* in tree.c */ ++extern void lang_check_failed (const char *, int, ++ const char *); ++extern tree stabilize_expr (tree, tree *); ++extern void stabilize_call (tree, tree *); ++extern bool stabilize_init (tree, tree *); ++extern tree cxx_unsave_expr_now (tree); ++extern tree cxx_maybe_build_cleanup (tree); ++extern void init_tree (void); ++extern int pod_type_p (tree); ++extern int zero_init_p (tree); ++extern tree canonical_type_variant (tree); ++extern tree copy_base_binfos (tree, tree, tree); ++extern int member_p (tree); ++extern cp_lvalue_kind real_lvalue_p (tree); ++extern tree build_min (enum tree_code, tree, ...); ++extern tree build_min_nt (enum tree_code, ...); ++extern tree build_min_non_dep (enum tree_code, tree, ...); ++extern tree build_cplus_new (tree, tree); ++extern tree get_target_expr (tree); ++extern tree build_cplus_staticfn_type (tree, tree, tree); ++extern tree build_cplus_array_type (tree, tree); ++extern tree hash_tree_cons (tree, tree, tree); ++extern tree hash_tree_chain (tree, tree); ++extern tree hash_chainon (tree, tree); ++extern tree make_binfo (tree, tree, tree, tree); ++extern int count_functions (tree); ++extern int is_overloaded_fn (tree); ++extern tree get_first_fn (tree); ++extern int bound_pmf_p (tree); ++extern tree ovl_cons (tree, tree); ++extern tree build_overload (tree, tree); ++extern tree function_arg_chain (tree); ++extern int promotes_to_aggr_type (tree, enum tree_code); ++extern const char *cxx_printable_name (tree, int); ++extern tree build_exception_variant (tree, tree); ++extern tree bind_template_template_parm (tree, tree); ++extern tree array_type_nelts_total (tree); ++extern tree array_type_nelts_top (tree); ++extern tree break_out_target_exprs (tree); ++extern tree get_type_decl (tree); ++extern tree vec_binfo_member (tree, tree); ++extern tree decl_namespace_context (tree); ++extern tree lvalue_type (tree); ++extern tree error_type (tree); ++extern tree build_zc_wrapper (struct z_candidate *); ++extern int varargs_function_p (tree); ++extern int really_overloaded_fn (tree); ++extern bool cp_tree_equal (tree, tree); ++extern tree no_linkage_check (tree); ++extern void debug_binfo (tree); ++extern tree build_dummy_object (tree); ++extern tree maybe_dummy_object (tree, tree *); ++extern int is_dummy_object (tree); ++extern const struct attribute_spec cxx_attribute_table[]; ++extern tree make_ptrmem_cst (tree, tree); ++extern tree cp_build_type_attribute_variant (tree, tree); ++extern tree cp_build_qualified_type_real (tree, int, tsubst_flags_t); ++#define cp_build_qualified_type(TYPE, QUALS) \ ++ cp_build_qualified_type_real ((TYPE), (QUALS), tf_error | tf_warning) ++extern tree build_shared_int_cst (int); ++extern special_function_kind special_function_p (tree); ++extern bool name_p (tree); ++extern int count_trees (tree); ++extern int char_type_p (tree); ++extern void verify_stmt_tree (tree); ++extern tree find_tree (tree, tree); ++extern linkage_kind decl_linkage (tree); ++extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn, ++ void*, void*); ++extern int cp_cannot_inline_tree_fn (tree*); ++extern tree cp_add_pending_fn_decls (void*,tree); ++extern int cp_is_overload_p (tree); ++extern int cp_auto_var_in_fn_p (tree,tree); ++extern tree fold_if_not_in_template (tree); ++extern tree cp_copy_res_decl_for_inlining (tree, tree, tree, void*, ++ int*, tree); ++ ++/* in typeck.c */ ++extern int string_conv_p (tree, tree, int); ++extern tree cp_truthvalue_conversion (tree); ++extern tree condition_conversion (tree); ++extern tree target_type (tree); ++extern tree require_complete_type (tree); ++extern tree complete_type (tree); ++extern tree complete_type_or_diagnostic (tree, tree, int); ++#define complete_type_or_else(T,V) (complete_type_or_diagnostic ((T), (V), 0)) ++extern int type_unknown_p (tree); ++extern tree commonparms (tree, tree); ++extern tree original_type (tree); ++extern bool comp_except_specs (tree, tree, bool); ++extern bool comptypes (tree, tree, int); ++extern bool compparms (tree, tree); ++extern int comp_cv_qualification (tree, tree); ++extern int comp_cv_qual_signature (tree, tree); ++extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code); ++extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool); ++#define cxx_sizeof_nowarn(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, false) ++extern tree inline_conversion (tree); ++extern tree decay_conversion (tree); ++extern tree perform_integral_promotions (tree); ++extern tree build_class_member_access_expr (tree, tree, tree, bool); ++extern tree finish_class_member_access_expr (tree, tree); ++extern tree build_x_indirect_ref (tree, const char *); ++extern tree build_indirect_ref (tree, const char *); ++extern tree build_array_ref (tree, tree); ++extern tree get_member_function_from_ptrfunc (tree *, tree); ++extern tree convert_arguments (tree, tree, tree, int); ++extern tree build_x_binary_op (enum tree_code, tree, tree, ++ bool *); ++extern tree build_x_unary_op (enum tree_code, tree); ++extern tree unary_complex_lvalue (enum tree_code, tree); ++extern tree build_x_conditional_expr (tree, tree, tree); ++extern tree build_x_compound_expr_from_list (tree, const char *); ++extern tree build_x_compound_expr (tree, tree); ++extern tree build_compound_expr (tree, tree); ++extern tree build_static_cast (tree, tree); ++extern tree build_reinterpret_cast (tree, tree); ++extern tree build_const_cast (tree, tree); ++extern tree build_c_cast (tree, tree); ++extern tree build_x_modify_expr (tree, enum tree_code, tree); ++extern tree build_modify_expr (tree, enum tree_code, tree); ++extern tree dubious_conversion_warnings (tree, tree, const char *, tree, int); ++extern tree convert_for_initialization (tree, tree, tree, int, const char *, tree, int); ++extern int comp_ptr_ttypes (tree, tree); ++extern int ptr_reasonably_similar (tree, tree); ++extern tree build_ptrmemfunc (tree, tree, int); ++extern int cp_type_quals (tree); ++extern bool cp_has_mutable_p (tree); ++extern bool at_least_as_qualified_p (tree, tree); ++extern bool more_qualified_p (tree, tree); ++extern tree build_ptrmemfunc1 (tree, tree, tree); ++extern void expand_ptrmemfunc_cst (tree, tree *, tree *); ++extern tree pfn_from_ptrmemfunc (tree); ++extern tree type_after_usual_arithmetic_conversions (tree, tree); ++extern tree composite_pointer_type (tree, tree, tree, tree, ++ const char*); ++extern tree merge_types (tree, tree); ++extern tree check_return_expr (tree); ++#define cp_build_binary_op(code, arg1, arg2) \ ++ build_binary_op(code, arg1, arg2, 1) ++#define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true) ++#define cxx_alignof(T) cxx_sizeof_or_alignof_type (T, ALIGNOF_EXPR, true) ++extern tree build_ptrmemfunc_access_expr (tree, tree); ++extern tree build_address (tree); ++extern tree build_nop (tree, tree); ++extern tree non_reference (tree); ++extern tree lookup_anon_field (tree, tree); ++extern bool invalid_nonstatic_memfn_p (tree); ++ ++/* in typeck2.c */ ++extern void require_complete_eh_spec_types (tree, tree); ++extern void cxx_incomplete_type_diagnostic (tree, tree, int); ++#undef cxx_incomplete_type_error ++extern void cxx_incomplete_type_error (tree, tree); ++#define cxx_incomplete_type_error(V,T) \ ++ (cxx_incomplete_type_diagnostic ((V), (T), 0)) ++extern tree error_not_base_type (tree, tree); ++extern tree binfo_or_else (tree, tree); ++extern void readonly_error (tree, const char *, int); ++extern int abstract_virtuals_error (tree, tree); ++ ++extern tree store_init_value (tree, tree); ++extern tree digest_init (tree, tree, tree *); ++extern tree build_scoped_ref (tree, tree, tree *); ++extern tree build_x_arrow (tree); ++extern tree build_m_component_ref (tree, tree); ++extern tree build_functional_cast (tree, tree); ++extern tree add_exception_specifier (tree, tree, int); ++extern tree merge_exception_specifiers (tree, tree); ++ ++/* in mangle.c */ ++extern void init_mangle (void); ++extern void mangle_decl (tree); ++extern const char *mangle_type_string (tree); ++extern tree mangle_type (tree); ++extern tree mangle_typeinfo_for_type (tree); ++extern tree mangle_typeinfo_string_for_type (tree); ++extern tree mangle_vtbl_for_type (tree); ++extern tree mangle_vtt_for_type (tree); ++extern tree mangle_ctor_vtbl_for_type (tree, tree); ++extern tree mangle_thunk (tree, int, tree, tree); ++extern tree mangle_conv_op_name_for_type (tree); ++extern tree mangle_guard_variable (tree); ++extern tree mangle_ref_init_variable (tree); ++ ++/* in dump.c */ ++extern bool cp_dump_tree (void *, tree); ++ ++/* -- end of C++ */ ++ ++/* In order for the format checking to accept the C++ frontend ++ diagnostic framework extensions, you must include this file before ++ toplev.h, not after. */ ++#define GCC_DIAG_STYLE __gcc_cxxdiag__ ++#if GCC_VERSION >= 3004 ++#define ATTRIBUTE_GCC_CXXDIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m) ++#else ++#define ATTRIBUTE_GCC_CXXDIAG(m, n) ATTRIBUTE_NONNULL(m) ++#endif ++ ++extern void cp_error_at (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1, 2); ++extern void cp_warning_at (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1, 2); ++extern void cp_pedwarn_at (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1, 2); ++ ++#endif /* ! GCC_CP_TREE_H */ +diff -NBaur gcc-3.4.4/gcc/cp/cvt.c gcc-3.4.4-new/gcc/cp/cvt.c +--- gcc-3.4.4/gcc/cp/cvt.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cvt.c Wed Feb 9 02:21:27 2005 +@@ -0,0 +1,1182 @@ ++/* Language-level data type conversion for GNU C++. ++ Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, ++ 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. ++ Hacked by Michael Tiemann (tiemann@cygnus.com) ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++ ++/* This file contains the functions for converting C++ expressions ++ to different data types. The only entry point is `convert'. ++ Every language front end must have a `convert' function ++ but what kind of conversions it does will depend on the language. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "flags.h" ++#include "cp-tree.h" ++#include "convert.h" ++#include "toplev.h" ++#include "decl.h" ++ ++static tree cp_convert_to_pointer (tree, tree, bool); ++static tree convert_to_pointer_force (tree, tree); ++static tree build_up_reference (tree, tree, int, tree); ++static void warn_ref_binding (tree, tree, tree); ++ ++/* Change of width--truncation and extension of integers or reals-- ++ is represented with NOP_EXPR. Proper functioning of many things ++ assumes that no other conversions can be NOP_EXPRs. ++ ++ Conversion between integer and pointer is represented with CONVERT_EXPR. ++ Converting integer to real uses FLOAT_EXPR ++ and real to integer uses FIX_TRUNC_EXPR. ++ ++ Here is a list of all the functions that assume that widening and ++ narrowing is always done with a NOP_EXPR: ++ In convert.c, convert_to_integer. ++ In c-typeck.c, build_binary_op_nodefault (boolean ops), ++ and c_common_truthvalue_conversion. ++ In expr.c: expand_expr, for operands of a MULT_EXPR. ++ In fold-const.c: fold. ++ In tree.c: get_narrower and get_unwidened. ++ ++ C++: in multiple-inheritance, converting between pointers may involve ++ adjusting them by a delta stored within the class definition. */ ++ ++/* Subroutines of `convert'. */ ++ ++/* if converting pointer to pointer ++ if dealing with classes, check for derived->base or vice versa ++ else if dealing with method pointers, delegate ++ else convert blindly ++ else if converting class, pass off to build_type_conversion ++ else try C-style pointer conversion. If FORCE is true then allow ++ conversions via virtual bases (these are permitted by reinterpret_cast, ++ but not static_cast). */ ++ ++static tree ++cp_convert_to_pointer (tree type, tree expr, bool force) ++{ ++ tree intype = TREE_TYPE (expr); ++ enum tree_code form; ++ tree rval; ++ ++ if (IS_AGGR_TYPE (intype)) ++ { ++ intype = complete_type (intype); ++ if (!COMPLETE_TYPE_P (intype)) ++ { ++ error ("can't convert from incomplete type `%T' to `%T'", ++ intype, type); ++ return error_mark_node; ++ } ++ ++ rval = build_type_conversion (type, expr); ++ if (rval) ++ { ++ if (rval == error_mark_node) ++ error ("conversion of `%E' from `%T' to `%T' is ambiguous", ++ expr, intype, type); ++ return rval; ++ } ++ } ++ ++ /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */ ++ if (TREE_CODE (type) == POINTER_TYPE ++ && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE ++ || VOID_TYPE_P (TREE_TYPE (type)))) ++ { ++ /* Allow an implicit this pointer for pointer to member ++ functions. */ ++ if (TYPE_PTRMEMFUNC_P (intype)) ++ { ++ if (pedantic || warn_pmf2ptr) ++ pedwarn ("converting from `%T' to `%T'", intype, type); ++ if (TREE_CODE (expr) == PTRMEM_CST) ++ expr = build_address (PTRMEM_CST_MEMBER (expr)); ++ else ++ { ++ tree decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), ++ 0); ++ decl = build_address (decl); ++ expr = get_member_function_from_ptrfunc (&decl, expr); ++ } ++ } ++ else if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE) ++ { ++ if (pedantic || warn_pmf2ptr) ++ pedwarn ("converting from `%T' to `%T'", intype, type); ++ expr = build_addr_func (expr); ++ } ++ if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE) ++ return build_nop (type, expr); ++ intype = TREE_TYPE (expr); ++ } ++ ++ if (expr == error_mark_node) ++ return error_mark_node; ++ ++ form = TREE_CODE (intype); ++ ++ if (POINTER_TYPE_P (intype)) ++ { ++ intype = TYPE_MAIN_VARIANT (intype); ++ ++ if (TYPE_MAIN_VARIANT (type) != intype ++ && TREE_CODE (type) == POINTER_TYPE ++ && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE ++ && IS_AGGR_TYPE (TREE_TYPE (type)) ++ && IS_AGGR_TYPE (TREE_TYPE (intype)) ++ && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) ++ { ++ enum tree_code code = PLUS_EXPR; ++ tree binfo; ++ tree intype_class; ++ tree type_class; ++ bool same_p; ++ ++ intype_class = TREE_TYPE (intype); ++ type_class = TREE_TYPE (type); ++ ++ same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class), ++ TYPE_MAIN_VARIANT (type_class)); ++ binfo = NULL_TREE; ++ /* Try derived to base conversion. */ ++ if (!same_p) ++ binfo = lookup_base (intype_class, type_class, ba_check, NULL); ++ if (!same_p && !binfo) ++ { ++ /* Try base to derived conversion. */ ++ binfo = lookup_base (type_class, intype_class, ba_check, NULL); ++ code = MINUS_EXPR; ++ } ++ if (binfo == error_mark_node) ++ return error_mark_node; ++ if (binfo || same_p) ++ { ++ if (binfo) ++ expr = build_base_path (code, expr, binfo, 0); ++ /* Add any qualifier conversions. */ ++ return build_nop (type, expr); ++ } ++ } ++ ++ if (TYPE_PTRMEMFUNC_P (type)) ++ { ++ error ("cannot convert `%E' from type `%T' to type `%T'", ++ expr, intype, type); ++ return error_mark_node; ++ } ++ ++ return build_nop (type, expr); ++ } ++ else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) ++ { ++ tree b1; ++ tree b2; ++ tree binfo; ++ enum tree_code code = PLUS_EXPR; ++ base_kind bk; ++ ++ b1 = TYPE_PTRMEM_CLASS_TYPE (type); ++ b2 = TYPE_PTRMEM_CLASS_TYPE (intype); ++ binfo = lookup_base (b1, b2, ba_check, &bk); ++ if (!binfo) ++ { ++ binfo = lookup_base (b2, b1, ba_check, &bk); ++ code = MINUS_EXPR; ++ } ++ if (binfo == error_mark_node) ++ return error_mark_node; ++ ++ if (bk == bk_via_virtual) ++ { ++ if (force) ++ warning ("pointer to member cast from `%T' to `%T' is via virtual base", ++ intype, type); ++ else ++ { ++ error ("pointer to member cast from `%T' to `%T' is via virtual base", ++ intype, type); ++ return error_mark_node; ++ } ++ /* This is a reinterpret cast, whose result is unspecified. ++ We choose to do nothing. */ ++ return build1 (NOP_EXPR, type, expr); ++ } ++ ++ if (TREE_CODE (expr) == PTRMEM_CST) ++ expr = cplus_expand_constant (expr); ++ ++ if (binfo && !integer_zerop (BINFO_OFFSET (binfo))) ++ expr = size_binop (code, ++ build_nop (sizetype, expr), ++ BINFO_OFFSET (binfo)); ++ return build_nop (type, expr); ++ } ++ else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)) ++ return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0); ++ else if (TYPE_PTRMEMFUNC_P (intype)) ++ { ++ if (!warn_pmf2ptr) ++ { ++ if (TREE_CODE (expr) == PTRMEM_CST) ++ return cp_convert_to_pointer (type, ++ PTRMEM_CST_MEMBER (expr), ++ force); ++ else if (TREE_CODE (expr) == OFFSET_REF) ++ { ++ tree object = TREE_OPERAND (expr, 0); ++ return get_member_function_from_ptrfunc (&object, ++ TREE_OPERAND (expr, 1)); ++ } ++ } ++ error ("cannot convert `%E' from type `%T' to type `%T'", ++ expr, intype, type); ++ return error_mark_node; ++ } ++ ++ if (integer_zerop (expr)) ++ { ++ if (TYPE_PTRMEMFUNC_P (type)) ++ return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0); ++ ++ if (TYPE_PTRMEM_P (type)) ++ /* A NULL pointer-to-member is represented by -1, not by ++ zero. */ ++ expr = build_int_2 (-1, -1); ++ else ++ expr = build_int_2 (0, 0); ++ TREE_TYPE (expr) = type; ++ /* Fix up the representation of -1 if appropriate. */ ++ force_fit_type (expr, 0); ++ return expr; ++ } ++ else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form)) ++ { ++ error ("invalid conversion from '%T' to '%T'", intype, type); ++ return error_mark_node; ++ } ++ ++ if (INTEGRAL_CODE_P (form)) ++ { ++ if (TYPE_PRECISION (intype) == POINTER_SIZE) ++ return build1 (CONVERT_EXPR, type, expr); ++ expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr); ++ /* Modes may be different but sizes should be the same. */ ++ if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))) ++ != GET_MODE_SIZE (TYPE_MODE (type))) ++ /* There is supposed to be some integral type ++ that is the same width as a pointer. */ ++ abort (); ++ return convert_to_pointer (type, expr); ++ } ++ ++ if (type_unknown_p (expr)) ++ return instantiate_type (type, expr, tf_error | tf_warning); ++ ++ error ("cannot convert `%E' from type `%T' to type `%T'", ++ expr, intype, type); ++ return error_mark_node; ++} ++ ++/* Like convert, except permit conversions to take place which ++ are not normally allowed due to access restrictions ++ (such as conversion from sub-type to private super-type). */ ++ ++static tree ++convert_to_pointer_force (tree type, tree expr) ++{ ++ tree intype = TREE_TYPE (expr); ++ enum tree_code form = TREE_CODE (intype); ++ ++ if (form == POINTER_TYPE) ++ { ++ intype = TYPE_MAIN_VARIANT (intype); ++ ++ if (TYPE_MAIN_VARIANT (type) != intype ++ && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE ++ && IS_AGGR_TYPE (TREE_TYPE (type)) ++ && IS_AGGR_TYPE (TREE_TYPE (intype)) ++ && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) ++ { ++ enum tree_code code = PLUS_EXPR; ++ tree binfo; ++ ++ binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type), ++ ba_ignore, NULL); ++ if (!binfo) ++ { ++ binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype), ++ ba_ignore, NULL); ++ code = MINUS_EXPR; ++ } ++ if (binfo == error_mark_node) ++ return error_mark_node; ++ if (binfo) ++ { ++ expr = build_base_path (code, expr, binfo, 0); ++ if (expr == error_mark_node) ++ return error_mark_node; ++ /* Add any qualifier conversions. */ ++ if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)), ++ TREE_TYPE (type))) ++ expr = build_nop (type, expr); ++ return expr; ++ } ++ } ++ } ++ ++ return cp_convert_to_pointer (type, expr, true); ++} ++ ++/* We are passing something to a function which requires a reference. ++ The type we are interested in is in TYPE. The initial ++ value we have to begin with is in ARG. ++ ++ FLAGS controls how we manage access checking. ++ DIRECT_BIND in FLAGS controls how any temporaries are generated. ++ If DIRECT_BIND is set, DECL is the reference we're binding to. */ ++ ++static tree ++build_up_reference (tree type, tree arg, int flags, tree decl) ++{ ++ tree rval; ++ tree argtype = TREE_TYPE (arg); ++ tree target_type = TREE_TYPE (type); ++ ++ my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187); ++ ++ if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg)) ++ { ++ /* Create a new temporary variable. We can't just use a TARGET_EXPR ++ here because it needs to live as long as DECL. */ ++ tree targ = arg; ++ ++ arg = make_temporary_var_for_ref_to_temp (decl, TREE_TYPE (arg)); ++ ++ /* Process the initializer for the declaration. */ ++ DECL_INITIAL (arg) = targ; ++ cp_finish_decl (arg, targ, NULL_TREE, ++ LOOKUP_ONLYCONVERTING|DIRECT_BIND); ++ } ++ else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg)) ++ return get_target_expr (arg); ++ ++ /* If we had a way to wrap this up, and say, if we ever needed its ++ address, transform all occurrences of the register, into a memory ++ reference we could win better. */ ++ rval = build_unary_op (ADDR_EXPR, arg, 1); ++ if (rval == error_mark_node) ++ return error_mark_node; ++ ++ if ((flags & LOOKUP_PROTECT) ++ && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type) ++ && IS_AGGR_TYPE (argtype) ++ && IS_AGGR_TYPE (target_type)) ++ { ++ /* We go through lookup_base for the access control. */ ++ tree binfo = lookup_base (argtype, target_type, ba_check, NULL); ++ if (binfo == error_mark_node) ++ return error_mark_node; ++ if (binfo == NULL_TREE) ++ return error_not_base_type (target_type, argtype); ++ rval = build_base_path (PLUS_EXPR, rval, binfo, 1); ++ } ++ else ++ rval ++ = convert_to_pointer_force (build_pointer_type (target_type), rval); ++ return build_nop (type, rval); ++} ++ ++/* Subroutine of convert_to_reference. REFTYPE is the target reference type. ++ INTYPE is the original rvalue type and DECL is an optional _DECL node ++ for diagnostics. ++ ++ [dcl.init.ref] says that if an rvalue is used to ++ initialize a reference, then the reference must be to a ++ non-volatile const type. */ ++ ++static void ++warn_ref_binding (tree reftype, tree intype, tree decl) ++{ ++ tree ttl = TREE_TYPE (reftype); ++ ++ if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl)) ++ { ++ const char *msg; ++ ++ if (CP_TYPE_VOLATILE_P (ttl) && decl) ++ msg = "initialization of volatile reference type `%#T' from rvalue of type `%T'"; ++ else if (CP_TYPE_VOLATILE_P (ttl)) ++ msg = "conversion to volatile reference type `%#T' from rvalue of type `%T'"; ++ else if (decl) ++ msg = "initialization of non-const reference type `%#T' from rvalue of type `%T'"; ++ else ++ msg = "conversion to non-const reference type `%#T' from rvalue of type `%T'"; ++ ++ pedwarn (msg, reftype, intype); ++ } ++} ++ ++/* For C++: Only need to do one-level references, but cannot ++ get tripped up on signed/unsigned differences. ++ ++ DECL is either NULL_TREE or the _DECL node for a reference that is being ++ initialized. It can be error_mark_node if we don't know the _DECL but ++ we know it's an initialization. */ ++ ++tree ++convert_to_reference (tree reftype, tree expr, int convtype, ++ int flags, tree decl) ++{ ++ tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype)); ++ tree intype; ++ tree rval = NULL_TREE; ++ tree rval_as_conversion = NULL_TREE; ++ bool can_convert_intype_to_type; ++ ++ if (TREE_CODE (type) == FUNCTION_TYPE ++ && TREE_TYPE (expr) == unknown_type_node) ++ expr = instantiate_type (type, expr, ++ (flags & LOOKUP_COMPLAIN) ++ ? tf_error | tf_warning : tf_none); ++ else ++ expr = convert_from_reference (expr); ++ ++ if (expr == error_mark_node) ++ return error_mark_node; ++ ++ intype = TREE_TYPE (expr); ++ ++ my_friendly_assert (TREE_CODE (intype) != REFERENCE_TYPE, 364); ++ ++ intype = TYPE_MAIN_VARIANT (intype); ++ ++ can_convert_intype_to_type = can_convert (type, intype); ++ if (!can_convert_intype_to_type ++ && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype) ++ && ! (flags & LOOKUP_NO_CONVERSION)) ++ { ++ /* Look for a user-defined conversion to lvalue that we can use. */ ++ ++ rval_as_conversion ++ = build_type_conversion (reftype, expr); ++ ++ if (rval_as_conversion && rval_as_conversion != error_mark_node ++ && real_lvalue_p (rval_as_conversion)) ++ { ++ expr = rval_as_conversion; ++ rval_as_conversion = NULL_TREE; ++ intype = type; ++ can_convert_intype_to_type = 1; ++ } ++ } ++ ++ if (((convtype & CONV_STATIC) && can_convert (intype, type)) ++ || ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type)) ++ { ++ if (flags & LOOKUP_COMPLAIN) ++ { ++ tree ttl = TREE_TYPE (reftype); ++ tree ttr = lvalue_type (expr); ++ ++ if (! real_lvalue_p (expr)) ++ warn_ref_binding (reftype, intype, decl); ++ ++ if (! (convtype & CONV_CONST) ++ && !at_least_as_qualified_p (ttl, ttr)) ++ pedwarn ("conversion from `%T' to `%T' discards qualifiers", ++ ttr, reftype); ++ } ++ ++ return build_up_reference (reftype, expr, flags, decl); ++ } ++ else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr)) ++ { ++ /* When casting an lvalue to a reference type, just convert into ++ a pointer to the new type and deference it. This is allowed ++ by San Diego WP section 5.2.9 paragraph 12, though perhaps it ++ should be done directly (jason). (int &)ri ---> *(int*)&ri */ ++ ++ /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they ++ meant. */ ++ if (TREE_CODE (intype) == POINTER_TYPE ++ && (comptypes (TREE_TYPE (intype), type, ++ COMPARE_BASE | COMPARE_DERIVED))) ++ warning ("casting `%T' to `%T' does not dereference pointer", ++ intype, reftype); ++ ++ rval = build_unary_op (ADDR_EXPR, expr, 0); ++ if (rval != error_mark_node) ++ rval = convert_force (build_pointer_type (TREE_TYPE (reftype)), ++ rval, 0); ++ if (rval != error_mark_node) ++ rval = build1 (NOP_EXPR, reftype, rval); ++ } ++ else ++ { ++ rval = convert_for_initialization (NULL_TREE, type, expr, flags, ++ "converting", 0, 0); ++ if (rval == NULL_TREE || rval == error_mark_node) ++ return rval; ++ warn_ref_binding (reftype, intype, decl); ++ rval = build_up_reference (reftype, rval, flags, decl); ++ } ++ ++ if (rval) ++ { ++ /* If we found a way to convert earlier, then use it. */ ++ return rval; ++ } ++ ++ if (flags & LOOKUP_COMPLAIN) ++ error ("cannot convert type `%T' to type `%T'", intype, reftype); ++ ++ if (flags & LOOKUP_SPECULATIVELY) ++ return NULL_TREE; ++ ++ return error_mark_node; ++} ++ ++/* We are using a reference VAL for its value. Bash that reference all the ++ way down to its lowest form. */ ++ ++tree ++convert_from_reference (tree val) ++{ ++ if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE) ++ return build_indirect_ref (val, NULL); ++ return val; ++} ++ ++/* Implicitly convert the lvalue EXPR to another lvalue of type TOTYPE, ++ preserving cv-qualification. */ ++ ++tree ++convert_lvalue (tree totype, tree expr) ++{ ++ totype = cp_build_qualified_type (totype, TYPE_QUALS (TREE_TYPE (expr))); ++ totype = build_reference_type (totype); ++ expr = convert_to_reference (totype, expr, CONV_IMPLICIT, LOOKUP_NORMAL, ++ NULL_TREE); ++ return convert_from_reference (expr); ++} ++ ++/* Really perform an lvalue-to-rvalue conversion, including copying an ++ argument of class type into a temporary. */ ++ ++tree ++force_rvalue (tree expr) ++{ ++ if (IS_AGGR_TYPE (TREE_TYPE (expr)) && TREE_CODE (expr) != TARGET_EXPR) ++ expr = ocp_convert (TREE_TYPE (expr), expr, ++ CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL); ++ else ++ expr = decay_conversion (expr); ++ ++ return expr; ++} ++ ++/* C++ conversions, preference to static cast conversions. */ ++ ++tree ++cp_convert (tree type, tree expr) ++{ ++ return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL); ++} ++ ++/* Conversion... ++ ++ FLAGS indicates how we should behave. */ ++ ++tree ++ocp_convert (tree type, tree expr, int convtype, int flags) ++{ ++ tree e = expr; ++ enum tree_code code = TREE_CODE (type); ++ ++ if (error_operand_p (e) || type == error_mark_node) ++ return error_mark_node; ++ ++ complete_type (type); ++ complete_type (TREE_TYPE (expr)); ++ ++ e = decl_constant_value (e); ++ ++ if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP) ++ /* Some internal structures (vtable_entry_type, sigtbl_ptr_type) ++ don't go through finish_struct, so they don't have the synthesized ++ constructors. So don't force a temporary. */ ++ && TYPE_HAS_CONSTRUCTOR (type)) ++ /* We need a new temporary; don't take this shortcut. */; ++ else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e))) ++ { ++ if (same_type_p (type, TREE_TYPE (e))) ++ /* The call to fold will not always remove the NOP_EXPR as ++ might be expected, since if one of the types is a typedef; ++ the comparison in fold is just equality of pointers, not a ++ call to comptypes. We don't call fold in this case because ++ that can result in infinite recursion; fold will call ++ convert, which will call ocp_convert, etc. */ ++ return e; ++ /* For complex data types, we need to perform componentwise ++ conversion. */ ++ else if (TREE_CODE (type) == COMPLEX_TYPE) ++ return fold (convert_to_complex (type, e)); ++ else if (TREE_CODE (e) == TARGET_EXPR) ++ { ++ /* Don't build a NOP_EXPR of class type. Instead, change the ++ type of the temporary. Only allow this for cv-qual changes, ++ though. */ ++ if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (e)), ++ TYPE_MAIN_VARIANT (type))) ++ abort (); ++ TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type; ++ return e; ++ } ++ else if (TREE_ADDRESSABLE (type)) ++ /* We shouldn't be treating objects of ADDRESSABLE type as rvalues. */ ++ abort (); ++ else ++ return fold (build1 (NOP_EXPR, type, e)); ++ } ++ ++ if (code == VOID_TYPE && (convtype & CONV_STATIC)) ++ { ++ e = convert_to_void (e, /*implicit=*/NULL); ++ return e; ++ } ++ ++ if (INTEGRAL_CODE_P (code)) ++ { ++ tree intype = TREE_TYPE (e); ++ /* enum = enum, enum = int, enum = float, (enum)pointer are all ++ errors. */ ++ if (TREE_CODE (type) == ENUMERAL_TYPE ++ && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC)) ++ || (TREE_CODE (intype) == POINTER_TYPE))) ++ { ++ pedwarn ("conversion from `%#T' to `%#T'", intype, type); ++ ++ if (flag_pedantic_errors) ++ return error_mark_node; ++ } ++ if (IS_AGGR_TYPE (intype)) ++ { ++ tree rval; ++ rval = build_type_conversion (type, e); ++ if (rval) ++ return rval; ++ if (flags & LOOKUP_COMPLAIN) ++ error ("`%#T' used where a `%T' was expected", intype, type); ++ if (flags & LOOKUP_SPECULATIVELY) ++ return NULL_TREE; ++ return error_mark_node; ++ } ++ if (code == BOOLEAN_TYPE) ++ return cp_truthvalue_conversion (e); ++ ++ return fold (convert_to_integer (type, e)); ++ } ++ if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type)) ++ return fold (cp_convert_to_pointer (type, e, false)); ++ if (code == VECTOR_TYPE) ++ return fold (convert_to_vector (type, e)); ++ if (code == REAL_TYPE || code == COMPLEX_TYPE) ++ { ++ if (IS_AGGR_TYPE (TREE_TYPE (e))) ++ { ++ tree rval; ++ rval = build_type_conversion (type, e); ++ if (rval) ++ return rval; ++ else ++ if (flags & LOOKUP_COMPLAIN) ++ error ("`%#T' used where a floating point value was expected", ++ TREE_TYPE (e)); ++ } ++ if (code == REAL_TYPE) ++ return fold (convert_to_real (type, e)); ++ else if (code == COMPLEX_TYPE) ++ return fold (convert_to_complex (type, e)); ++ } ++ ++ /* New C++ semantics: since assignment is now based on ++ memberwise copying, if the rhs type is derived from the ++ lhs type, then we may still do a conversion. */ ++ if (IS_AGGR_TYPE_CODE (code)) ++ { ++ tree dtype = TREE_TYPE (e); ++ tree ctor = NULL_TREE; ++ ++ dtype = TYPE_MAIN_VARIANT (dtype); ++ ++ /* Conversion between aggregate types. New C++ semantics allow ++ objects of derived type to be cast to objects of base type. ++ Old semantics only allowed this between pointers. ++ ++ There may be some ambiguity between using a constructor ++ vs. using a type conversion operator when both apply. */ ++ ++ ctor = e; ++ ++ if (abstract_virtuals_error (NULL_TREE, type)) ++ return error_mark_node; ++ ++ if ((flags & LOOKUP_ONLYCONVERTING) ++ && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype))) ++ /* For copy-initialization, first we create a temp of the proper type ++ with a user-defined conversion sequence, then we direct-initialize ++ the target with the temp (see [dcl.init]). */ ++ ctor = build_user_type_conversion (type, ctor, flags); ++ else ++ ctor = build_special_member_call (NULL_TREE, ++ complete_ctor_identifier, ++ build_tree_list (NULL_TREE, ctor), ++ TYPE_BINFO (type), flags); ++ if (ctor) ++ return build_cplus_new (type, ctor); ++ } ++ ++ if (flags & LOOKUP_COMPLAIN) ++ error ("conversion from `%T' to non-scalar type `%T' requested", ++ TREE_TYPE (expr), type); ++ if (flags & LOOKUP_SPECULATIVELY) ++ return NULL_TREE; ++ return error_mark_node; ++} ++ ++/* When an expression is used in a void context, its value is discarded and ++ no lvalue-rvalue and similar conversions happen [expr.static.cast/4, ++ stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type ++ in a void context. The C++ standard does not define what an `access' to an ++ object is, but there is reason to believe that it is the lvalue to rvalue ++ conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it ++ accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8 ++ indicates that volatile semantics should be the same between C and C++ ++ where ever possible. C leaves it implementation defined as to what ++ constitutes an access to a volatile. So, we interpret `*vp' as a read of ++ the volatile object `vp' points to, unless that is an incomplete type. For ++ volatile references we do not do this interpretation, because that would ++ make it impossible to ignore the reference return value from functions. We ++ issue warnings in the confusing cases. ++ ++ IMPLICIT is tells us the context of an implicit void conversion. */ ++ ++tree ++convert_to_void (tree expr, const char *implicit) ++{ ++ if (expr == error_mark_node ++ || TREE_TYPE (expr) == error_mark_node) ++ return error_mark_node; ++ if (!TREE_TYPE (expr)) ++ return expr; ++ if (invalid_nonstatic_memfn_p (expr)) ++ return error_mark_node; ++ if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR) ++ { ++ error ("pseudo-destructor is not called"); ++ return error_mark_node; ++ } ++ if (VOID_TYPE_P (TREE_TYPE (expr))) ++ return expr; ++ switch (TREE_CODE (expr)) ++ { ++ case COND_EXPR: ++ { ++ /* The two parts of a cond expr might be separate lvalues. */ ++ tree op1 = TREE_OPERAND (expr,1); ++ tree op2 = TREE_OPERAND (expr,2); ++ tree new_op1 = convert_to_void ++ (op1, (implicit && !TREE_SIDE_EFFECTS (op2) ++ ? "second operand of conditional" : NULL)); ++ tree new_op2 = convert_to_void ++ (op2, (implicit && !TREE_SIDE_EFFECTS (op1) ++ ? "third operand of conditional" : NULL)); ++ ++ expr = build (COND_EXPR, TREE_TYPE (new_op1), ++ TREE_OPERAND (expr, 0), new_op1, new_op2); ++ break; ++ } ++ ++ case COMPOUND_EXPR: ++ { ++ /* The second part of a compound expr contains the value. */ ++ tree op1 = TREE_OPERAND (expr,1); ++ tree new_op1 = convert_to_void ++ (op1, (implicit && !TREE_NO_UNUSED_WARNING (expr) ++ ? "right-hand operand of comma" : NULL)); ++ ++ if (new_op1 != op1) ++ { ++ tree t = build (COMPOUND_EXPR, TREE_TYPE (new_op1), ++ TREE_OPERAND (expr, 0), new_op1); ++ expr = t; ++ } ++ ++ break; ++ } ++ ++ case NON_LVALUE_EXPR: ++ case NOP_EXPR: ++ /* These have already decayed to rvalue. */ ++ break; ++ ++ case CALL_EXPR: /* We have a special meaning for volatile void fn(). */ ++ break; ++ ++ case INDIRECT_REF: ++ { ++ tree type = TREE_TYPE (expr); ++ int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) ++ == REFERENCE_TYPE; ++ int is_volatile = TYPE_VOLATILE (type); ++ int is_complete = COMPLETE_TYPE_P (complete_type (type)); ++ ++ if (is_volatile && !is_complete) ++ warning ("object of incomplete type `%T' will not be accessed in %s", ++ type, implicit ? implicit : "void context"); ++ else if (is_reference && is_volatile) ++ warning ("object of type `%T' will not be accessed in %s", ++ TREE_TYPE (TREE_OPERAND (expr, 0)), ++ implicit ? implicit : "void context"); ++ if (is_reference || !is_volatile || !is_complete) ++ expr = TREE_OPERAND (expr, 0); ++ ++ break; ++ } ++ ++ case VAR_DECL: ++ { ++ /* External variables might be incomplete. */ ++ tree type = TREE_TYPE (expr); ++ int is_complete = COMPLETE_TYPE_P (complete_type (type)); ++ ++ if (TYPE_VOLATILE (type) && !is_complete) ++ warning ("object `%E' of incomplete type `%T' will not be accessed in %s", ++ expr, type, implicit ? implicit : "void context"); ++ break; ++ } ++ ++ default:; ++ } ++ { ++ tree probe = expr; ++ ++ if (TREE_CODE (probe) == ADDR_EXPR) ++ probe = TREE_OPERAND (expr, 0); ++ if (type_unknown_p (probe)) ++ { ++ /* [over.over] enumerates the places where we can take the address ++ of an overloaded function, and this is not one of them. */ ++ pedwarn ("%s cannot resolve address of overloaded function", ++ implicit ? implicit : "void cast"); ++ expr = void_zero_node; ++ } ++ else if (implicit && probe == expr && is_overloaded_fn (probe)) ++ /* Only warn when there is no &. */ ++ warning ("%s is a reference, not call, to function `%E'", ++ implicit, expr); ++ } ++ ++ if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr))) ++ { ++ if (implicit && !TREE_SIDE_EFFECTS (expr) && warn_unused_value) ++ warning ("%s has no effect", implicit); ++ expr = build1 (CONVERT_EXPR, void_type_node, expr); ++ } ++ return expr; ++} ++ ++/* Create an expression whose value is that of EXPR, ++ converted to type TYPE. The TREE_TYPE of the value ++ is always TYPE. This function implements all reasonable ++ conversions; callers should filter out those that are ++ not permitted by the language being compiled. ++ ++ Most of this routine is from build_reinterpret_cast. ++ ++ The backend cannot call cp_convert (what was convert) because ++ conversions to/from basetypes may involve memory references ++ (vbases) and adding or subtracting small values (multiple ++ inheritance), but it calls convert from the constant folding code ++ on subtrees of already built trees after it has ripped them apart. ++ ++ Also, if we ever support range variables, we'll probably also have to ++ do a little bit more work. */ ++ ++tree ++convert (tree type, tree expr) ++{ ++ tree intype; ++ ++ if (type == error_mark_node || expr == error_mark_node) ++ return error_mark_node; ++ ++ intype = TREE_TYPE (expr); ++ ++ if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype)) ++ { ++ expr = decl_constant_value (expr); ++ return fold (build1 (NOP_EXPR, type, expr)); ++ } ++ ++ return ocp_convert (type, expr, CONV_OLD_CONVERT, ++ LOOKUP_NORMAL|LOOKUP_NO_CONVERSION); ++} ++ ++/* Like cp_convert, except permit conversions to take place which ++ are not normally allowed due to access restrictions ++ (such as conversion from sub-type to private super-type). */ ++ ++tree ++convert_force (tree type, tree expr, int convtype) ++{ ++ tree e = expr; ++ enum tree_code code = TREE_CODE (type); ++ ++ if (code == REFERENCE_TYPE) ++ return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN, ++ NULL_TREE)); ++ else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE) ++ e = convert_from_reference (e); ++ ++ if (code == POINTER_TYPE) ++ return fold (convert_to_pointer_force (type, e)); ++ ++ /* From typeck.c convert_for_assignment */ ++ if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR ++ && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE ++ && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE) ++ || integer_zerop (e) ++ || TYPE_PTRMEMFUNC_P (TREE_TYPE (e))) ++ && TYPE_PTRMEMFUNC_P (type)) ++ { ++ /* compatible pointer to member functions. */ ++ return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1); ++ } ++ ++ return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL); ++} ++ ++/* Convert an aggregate EXPR to type XTYPE. If a conversion ++ exists, return the attempted conversion. This may ++ return ERROR_MARK_NODE if the conversion is not ++ allowed (references private members, etc). ++ If no conversion exists, NULL_TREE is returned. ++ ++ FIXME: Ambiguity checking is wrong. Should choose one by the implicit ++ object parameter, or by the second standard conversion sequence if ++ that doesn't do it. This will probably wait for an overloading rewrite. ++ (jason 8/9/95) */ ++ ++tree ++build_type_conversion (tree xtype, tree expr) ++{ ++ /* C++: check to see if we can convert this aggregate type ++ into the required type. */ ++ return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL); ++} ++ ++/* Convert the given EXPR to one of a group of types suitable for use in an ++ expression. DESIRES is a combination of various WANT_* flags (q.v.) ++ which indicates which types are suitable. If COMPLAIN is true, complain ++ about ambiguity; otherwise, the caller will deal with it. */ ++ ++tree ++build_expr_type_conversion (int desires, tree expr, bool complain) ++{ ++ tree basetype = TREE_TYPE (expr); ++ tree conv = NULL_TREE; ++ tree winner = NULL_TREE; ++ ++ if (expr == null_node ++ && (desires & WANT_INT) ++ && !(desires & WANT_NULL)) ++ warning ("converting NULL to non-pointer type"); ++ ++ expr = convert_from_reference (expr); ++ basetype = TREE_TYPE (expr); ++ ++ if (basetype == error_mark_node) ++ return error_mark_node; ++ ++ if (! IS_AGGR_TYPE (basetype)) ++ switch (TREE_CODE (basetype)) ++ { ++ case INTEGER_TYPE: ++ if ((desires & WANT_NULL) && null_ptr_cst_p (expr)) ++ return expr; ++ /* else fall through... */ ++ ++ case BOOLEAN_TYPE: ++ return (desires & WANT_INT) ? expr : NULL_TREE; ++ case ENUMERAL_TYPE: ++ return (desires & WANT_ENUM) ? expr : NULL_TREE; ++ case REAL_TYPE: ++ return (desires & WANT_FLOAT) ? expr : NULL_TREE; ++ case POINTER_TYPE: ++ return (desires & WANT_POINTER) ? expr : NULL_TREE; ++ ++ case FUNCTION_TYPE: ++ case ARRAY_TYPE: ++ return (desires & WANT_POINTER) ? decay_conversion (expr) ++ : NULL_TREE; ++ default: ++ return NULL_TREE; ++ } ++ ++ /* The code for conversions from class type is currently only used for ++ delete expressions. Other expressions are handled by build_new_op. */ ++ if (!complete_type_or_else (basetype, expr)) ++ return error_mark_node; ++ if (!TYPE_HAS_CONVERSION (basetype)) ++ return NULL_TREE; ++ ++ for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv)) ++ { ++ int win = 0; ++ tree candidate; ++ tree cand = TREE_VALUE (conv); ++ ++ if (winner && winner == cand) ++ continue; ++ ++ candidate = non_reference (TREE_TYPE (TREE_TYPE (cand))); ++ ++ switch (TREE_CODE (candidate)) ++ { ++ case BOOLEAN_TYPE: ++ case INTEGER_TYPE: ++ win = (desires & WANT_INT); break; ++ case ENUMERAL_TYPE: ++ win = (desires & WANT_ENUM); break; ++ case REAL_TYPE: ++ win = (desires & WANT_FLOAT); break; ++ case POINTER_TYPE: ++ win = (desires & WANT_POINTER); break; ++ ++ default: ++ break; ++ } ++ ++ if (win) ++ { ++ if (winner) ++ { ++ if (complain) ++ { ++ error ("ambiguous default type conversion from `%T'", ++ basetype); ++ error (" candidate conversions include `%D' and `%D'", ++ winner, cand); ++ } ++ return error_mark_node; ++ } ++ else ++ winner = cand; ++ } ++ } ++ ++ if (winner) ++ { ++ tree type = non_reference (TREE_TYPE (TREE_TYPE (winner))); ++ return build_user_type_conversion (type, expr, LOOKUP_NORMAL); ++ } ++ ++ return NULL_TREE; ++} ++ ++/* Implements integral promotion (4.1) and float->double promotion. */ ++ ++tree ++type_promotes_to (tree type) ++{ ++ if (type == error_mark_node) ++ return error_mark_node; ++ ++ type = TYPE_MAIN_VARIANT (type); ++ ++ /* bool always promotes to int (not unsigned), even if it's the same ++ size. */ ++ if (type == boolean_type_node) ++ type = integer_type_node; ++ ++ /* Normally convert enums to int, but convert wide enums to something ++ wider. */ ++ else if (TREE_CODE (type) == ENUMERAL_TYPE ++ || type == wchar_type_node) ++ { ++ int precision = MAX (TYPE_PRECISION (type), ++ TYPE_PRECISION (integer_type_node)); ++ tree totype = c_common_type_for_size (precision, 0); ++ if (TREE_UNSIGNED (type) ++ && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype)) ++ type = c_common_type_for_size (precision, 1); ++ else ++ type = totype; ++ } ++ else if (c_promoting_integer_type_p (type)) ++ { ++ /* Retain unsignedness if really not getting bigger. */ ++ if (TREE_UNSIGNED (type) ++ && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) ++ type = unsigned_type_node; ++ else ++ type = integer_type_node; ++ } ++ else if (type == float_type_node) ++ type = double_type_node; ++ ++ return type; ++} ++ ++/* The routines below this point are carefully written to conform to ++ the standard. They use the same terminology, and follow the rules ++ closely. Although they are used only in pt.c at the moment, they ++ should presumably be used everywhere in the future. */ ++ ++/* Attempt to perform qualification conversions on EXPR to convert it ++ to TYPE. Return the resulting expression, or error_mark_node if ++ the conversion was impossible. */ ++ ++tree ++perform_qualification_conversions (tree type, tree expr) ++{ ++ tree expr_type; ++ ++ expr_type = TREE_TYPE (expr); ++ ++ if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type) ++ && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type))) ++ return build_nop (type, expr); ++ else if (TYPE_PTR_TO_MEMBER_P (type) ++ && TYPE_PTR_TO_MEMBER_P (expr_type) ++ && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type), ++ TYPE_PTRMEM_CLASS_TYPE (expr_type)) ++ && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type), ++ TYPE_PTRMEM_POINTED_TO_TYPE (expr_type))) ++ return build_nop (type, expr); ++ else ++ return error_mark_node; ++} +diff -NBaur gcc-3.4.4/gcc/cp/cxx-pretty-print.c gcc-3.4.4-new/gcc/cp/cxx-pretty-print.c +--- gcc-3.4.4/gcc/cp/cxx-pretty-print.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cxx-pretty-print.c Wed Jul 28 15:55:06 2004 +@@ -0,0 +1,1741 @@ ++/* Implementation of subroutines for the GNU C++ pretty-printer. ++ Copyright (C) 2003 Free Software Foundation, Inc. ++ Contributed by Gabriel Dos Reis ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify it under ++the terms of the GNU General Public License as published by the Free ++Software Foundation; either version 2, or (at your option) any later ++version. ++ ++GCC is distributed in the hope that it will be useful, but WITHOUT ANY ++WARRANTY; without even the implied warranty of MERCHANTABILITY or ++FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to the Free ++Software Foundation, 59 Temple Place - Suite 330, Boston, MA ++02111-1307, USA. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "real.h" ++#include "cxx-pretty-print.h" ++#include "cp-tree.h" ++#include "toplev.h" ++ ++static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree); ++static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree); ++static void pp_cxx_qualified_id (cxx_pretty_printer *, tree); ++static void pp_cxx_assignment_expression (cxx_pretty_printer *, tree); ++static void pp_cxx_expression (cxx_pretty_printer *, tree); ++static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree); ++static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree); ++static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree); ++static void pp_cxx_type_id (cxx_pretty_printer *, tree); ++static void pp_cxx_direct_abstract_declarator (cxx_pretty_printer *, tree); ++static void pp_cxx_declarator (cxx_pretty_printer *, tree); ++static void pp_cxx_abstract_declarator (cxx_pretty_printer *, tree); ++static void pp_cxx_template_parameter (cxx_pretty_printer *, tree); ++ ++#define pp_cxx_whitespace(PP) pp_c_whitespace (pp_c_base (PP)) ++#define pp_cxx_left_paren(PP) pp_c_left_paren (pp_c_base (PP)) ++#define pp_cxx_right_paren(PP) pp_c_right_paren (pp_c_base (PP)) ++#define pp_cxx_left_brace(PP) pp_c_left_brace (pp_c_base (PP)) ++#define pp_cxx_right_brace(PP) pp_c_right_brace (pp_c_base (PP)) ++#define pp_cxx_dot(PP) pp_c_dot (pp_c_base (PP)) ++#define pp_cxx_arrow(PP) pp_c_arrow (pp_c_base (PP)) ++#define pp_cxx_semicolon(PP) pp_c_semicolon (pp_c_base (PP)) ++ ++static inline void ++pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c) ++{ ++ const char *p = pp_last_position_in_text (pp); ++ ++ if (p != NULL && *p == c) ++ pp_cxx_whitespace (pp); ++ pp_character (pp, c); ++ pp_base (pp)->padding = pp_none; ++} ++ ++#define pp_cxx_begin_template_argument_list(PP) \ ++ pp_cxx_nonconsecutive_character (PP, '<') ++#define pp_cxx_end_template_argument_list(PP) \ ++ pp_cxx_nonconsecutive_character (PP, '>') ++ ++#define pp_cxx_identifier(PP, ID) pp_c_identifier (pp_c_base (PP), ID) ++#define pp_cxx_tree_identifier(PP, T) pp_c_tree_identifier (pp_c_base (PP), T) ++ ++#define pp_cxx_cv_qualifier_seq(PP, T) \ ++ pp_c_type_qualifier_list (pp_c_base (PP), T) ++#define pp_cxx_storage_class_specifier(PP, T) \ ++ pp_c_storage_class_specifier (pp_c_base (PP), T) ++#define pp_cxx_expression_list(PP, T) \ ++ pp_c_expression_list (pp_c_base (PP), T) ++#define pp_cxx_space_for_pointer_operator(PP, T) \ ++ pp_c_space_for_pointer_operator (pp_c_base (PP), T) ++#define pp_cxx_init_declarator(PP, T) \ ++ pp_c_init_declarator (pp_c_base (PP), T) ++#define pp_cxx_call_argument_list(PP, T) \ ++ pp_c_call_argument_list (pp_c_base (PP), T) ++ ++static void ++pp_cxx_colon_colon (cxx_pretty_printer *pp) ++{ ++ pp_colon_colon (pp); ++ pp_base (pp)->padding = pp_none; ++} ++ ++ ++/* Expressions. */ ++ ++static inline bool ++is_destructor_name (tree name) ++{ ++ return name == complete_dtor_identifier ++ || name == base_dtor_identifier ++ || name == deleting_dtor_identifier; ++} ++ ++/* conversion-function-id: ++ operator conversion-type-id ++ ++ conversion-type-id: ++ type-specifier-seq conversion-declarator(opt) ++ ++ conversion-declarator: ++ ptr-operator conversion-declarator(opt) */ ++static inline void ++pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t) ++{ ++ pp_cxx_identifier (pp, "operator"); ++ pp_cxx_type_specifier_seq (pp, TREE_TYPE (t)); ++} ++ ++static inline void ++pp_cxx_template_id (cxx_pretty_printer *pp, tree t) ++{ ++ pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0)); ++ pp_cxx_begin_template_argument_list (pp); ++ pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1)); ++ pp_cxx_end_template_argument_list (pp); ++} ++ ++/* unqualified-id: ++ identifier ++ operator-function-id ++ conversion-function-id ++ ~ class-name ++ template-id */ ++static void ++pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t) ++{ ++ enum tree_code code = TREE_CODE (t); ++ switch (code) ++ { ++ case RESULT_DECL: ++ pp_cxx_identifier (pp, ""); ++ break; ++ ++ case OVERLOAD: ++ t = OVL_CURRENT (t); ++ case VAR_DECL: ++ case PARM_DECL: ++ case CONST_DECL: ++ case TYPE_DECL: ++ case FUNCTION_DECL: ++ case NAMESPACE_DECL: ++ case FIELD_DECL: ++ case LABEL_DECL: ++ case USING_DECL: ++ case TEMPLATE_DECL: ++ t = DECL_NAME (t); ++ ++ case IDENTIFIER_NODE: ++ if (t == NULL) ++ pp_cxx_identifier (pp, ""); ++ else if (IDENTIFIER_TYPENAME_P (t)) ++ pp_cxx_conversion_function_id (pp, t); ++ else ++ { ++ if (is_destructor_name (t)) ++ { ++ pp_complement (pp); ++ /* FIXME: Why is this necessary? */ ++ if (TREE_TYPE (t)) ++ t = constructor_name (TREE_TYPE (t)); ++ } ++ pp_cxx_tree_identifier (pp, t); ++ } ++ break; ++ ++ case TEMPLATE_ID_EXPR: ++ pp_cxx_template_id (pp, t); ++ break; ++ ++ case BASELINK: ++ pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t)); ++ break; ++ ++ case RECORD_TYPE: ++ case UNION_TYPE: ++ case ENUMERAL_TYPE: ++ pp_cxx_unqualified_id (pp, TYPE_NAME (t)); ++ break; ++ ++ case TEMPLATE_TYPE_PARM: ++ t = TYPE_FIELDS (t); ++ case TEMPLATE_PARM_INDEX: ++ pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t)); ++ break; ++ ++ default: ++ pp_unsupported_tree (pp, t); ++ break; ++ } ++} ++ ++static inline void ++pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t) ++{ ++ if (TREE_CODE (t) == TEMPLATE_ID_EXPR ++ && TYPE_P (scope) && dependent_type_p (scope)) ++ pp_cxx_identifier (pp, "template"); ++} ++ ++/* nested-name-specifier: ++ class-or-namespace-name :: nested-name-specifier(opt) ++ class-or-namespace-name :: template nested-name-specifier */ ++static void ++pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t) ++{ ++ if (t != NULL && t != pp->enclosing_scope) ++ { ++ tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t); ++ pp_cxx_nested_name_specifier (pp, scope); ++ pp_cxx_template_keyword_if_needed (pp, scope, t); ++ pp_cxx_unqualified_id (pp, t); ++ pp_cxx_colon_colon (pp); ++ } ++} ++ ++/* qualified-id: ++ nested-name-specifier template(opt) unqualified-id */ ++static void ++pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case PTRMEM_CST: ++ pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t)); ++ pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t)); ++ break; ++ ++ case OVERLOAD: ++ t = OVL_CURRENT (t); ++ case FUNCTION_DECL: ++ if (DECL_FUNCTION_MEMBER_P (t)) ++ pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t)); ++ pp_cxx_unqualified_id ++ (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t); ++ break; ++ ++ case OFFSET_REF: ++ case SCOPE_REF: ++ pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0)); ++ pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1)); ++ break; ++ ++ default: ++ { ++ tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t); ++ if (scope != pp->enclosing_scope) ++ { ++ pp_cxx_nested_name_specifier (pp, scope); ++ pp_cxx_template_keyword_if_needed (pp, scope, t); ++ } ++ pp_cxx_unqualified_id (pp, t); ++ } ++ break; ++ } ++} ++ ++/* id-expression: ++ unqualified-id ++ qualified-id */ ++static inline void ++pp_cxx_id_expression (cxx_pretty_printer *pp, tree t) ++{ ++ if (TREE_CODE (t) == OVERLOAD) ++ t = OVL_CURRENT (t); ++ if (DECL_P (t) && DECL_CONTEXT (t)) ++ pp_cxx_qualified_id (pp, t); ++ else ++ pp_cxx_unqualified_id (pp, t); ++} ++ ++/* primary-expression: ++ literal ++ this ++ :: identifier ++ :: operator-function-id ++ :: qualifier-id ++ ( expression ) ++ id-expression */ ++static void ++pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case STRING_CST: ++ case INTEGER_CST: ++ case REAL_CST: ++ pp_c_constant (pp_c_base (pp), t); ++ break; ++ ++ case BASELINK: ++ t = BASELINK_FUNCTIONS (t); ++ case VAR_DECL: ++ case PARM_DECL: ++ case FIELD_DECL: ++ case FUNCTION_DECL: ++ case OVERLOAD: ++ case CONST_DECL: ++ case TEMPLATE_DECL: ++ pp_cxx_id_expression (pp, t); ++ break; ++ ++ case RESULT_DECL: ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_PARM_INDEX: ++ pp_cxx_unqualified_id (pp, t); ++ break; ++ ++ default: ++ pp_c_primary_expression (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* postfix-expression: ++ primary-expression ++ postfix-expression [ expression ] ++ postfix-expression ( expression-list(opt) ) ++ simple-type-specifier ( expression-list(opt) ) ++ typename ::(opt) nested-name-specifier identifier ( expression-list(opt) ) ++ typename ::(opt) nested-name-specifier template(opt) ++ template-id ( expression-list(opt) ) ++ postfix-expression . template(opt) ::(opt) id-expression ++ postfix-expression -> template(opt) ::(opt) id-expression ++ postfix-expression . pseudo-destructor-name ++ postfix-expression -> pseudo-destructor-name ++ postfix-expression ++ ++ postfix-expression -- ++ dynamic_cast < type-id > ( expression ) ++ static_cast < type-id > ( expression ) ++ reinterpret_cast < type-id > ( expression ) ++ const_cast < type-id > ( expression ) ++ typeid ( expression ) ++ typeif ( type-id ) */ ++ ++static void ++pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t) ++{ ++ enum tree_code code = TREE_CODE (t); ++ ++ switch (code) ++ { ++ case AGGR_INIT_EXPR: ++ case CALL_EXPR: ++ { ++ tree fun = TREE_OPERAND (t, 0); ++ tree args = TREE_OPERAND (t, 1); ++ tree saved_scope = pp->enclosing_scope; ++ ++ if (TREE_CODE (fun) == ADDR_EXPR) ++ fun = TREE_OPERAND (fun, 0); ++ ++ /* In templates, where there is no way to tell whether a given ++ call uses an actual member function. So the parser builds ++ FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until ++ instantiation time. */ ++ if (TREE_CODE (fun) != FUNCTION_DECL) ++ ; ++ else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)) ++ { ++ tree object = code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t) ++ ? TREE_OPERAND (t, 2) ++ : TREE_VALUE (args); ++ ++ while (TREE_CODE (object) == NOP_EXPR) ++ object = TREE_OPERAND (object, 0); ++ ++ if (TREE_CODE (object) == ADDR_EXPR) ++ object = TREE_OPERAND (object, 0); ++ ++ if (TREE_CODE (TREE_TYPE (object)) != POINTER_TYPE) ++ { ++ pp_cxx_postfix_expression (pp, object); ++ pp_cxx_dot (pp); ++ } ++ else ++ { ++ pp_cxx_postfix_expression (pp, object); ++ pp_cxx_arrow (pp); ++ } ++ args = TREE_CHAIN (args); ++ pp->enclosing_scope = strip_pointer_operator (TREE_TYPE (object)); ++ } ++ ++ pp_cxx_postfix_expression (pp, fun); ++ pp->enclosing_scope = saved_scope; ++ pp_cxx_call_argument_list (pp, args); ++ } ++ if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t)) ++ { ++ pp_separate_with (pp, ','); ++ pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 2)); ++ } ++ break; ++ ++ case BASELINK: ++ case VAR_DECL: ++ case PARM_DECL: ++ case FIELD_DECL: ++ case FUNCTION_DECL: ++ case OVERLOAD: ++ case CONST_DECL: ++ case TEMPLATE_DECL: ++ case RESULT_DECL: ++ pp_cxx_primary_expression (pp, t); ++ break; ++ ++ case DYNAMIC_CAST_EXPR: ++ case STATIC_CAST_EXPR: ++ case REINTERPRET_CAST_EXPR: ++ case CONST_CAST_EXPR: ++ if (code == DYNAMIC_CAST_EXPR) ++ pp_identifier (pp, "dynamic_cast"); ++ else if (code == STATIC_CAST_EXPR) ++ pp_identifier (pp, "static_cast"); ++ else if (code == REINTERPRET_CAST_EXPR) ++ pp_identifier (pp, "reinterpret_cast"); ++ else ++ pp_identifier (pp, "const_cast"); ++ pp_cxx_begin_template_argument_list (pp); ++ pp_cxx_type_id (pp, TREE_TYPE (t)); ++ pp_cxx_end_template_argument_list (pp); ++ pp_left_paren (pp); ++ pp_cxx_expression (pp, TREE_OPERAND (t, 0)); ++ pp_right_paren (pp); ++ break; ++ ++ case EMPTY_CLASS_EXPR: ++ pp_cxx_type_id (pp, TREE_TYPE (t)); ++ pp_left_paren (pp); ++ pp_right_paren (pp); ++ break; ++ ++ case TYPEID_EXPR: ++ t = TREE_OPERAND (t, 0); ++ pp_cxx_identifier (pp, "typeid"); ++ pp_left_paren (pp); ++ if (TYPE_P (t)) ++ pp_cxx_type_id (pp, t); ++ else ++ pp_cxx_expression (pp, t); ++ pp_right_paren (pp); ++ break; ++ ++ case PSEUDO_DTOR_EXPR: ++ pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0)); ++ pp_cxx_dot (pp); ++ pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1)); ++ pp_cxx_colon_colon (pp); ++ pp_complement (pp); ++ pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2)); ++ break; ++ ++ default: ++ pp_c_postfix_expression (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* new-expression: ++ ::(opt) new new-placement(opt) new-type-id new-initializer(opt) ++ ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt) ++ ++ new-placement: ++ ( expression-list ) ++ ++ new-type-id: ++ type-specifier-seq new-declarator(opt) ++ ++ new-declarator: ++ ptr-operator new-declarator(opt) ++ direct-new-declarator ++ ++ direct-new-declarator ++ [ expression ] ++ direct-new-declarator [ constant-expression ] ++ ++ new-initializer: ++ ( expression-list(opt) ) */ ++static void ++pp_cxx_new_expression (cxx_pretty_printer *pp, tree t) ++{ ++ enum tree_code code = TREE_CODE (t); ++ switch (code) ++ { ++ case NEW_EXPR: ++ case VEC_NEW_EXPR: ++ if (NEW_EXPR_USE_GLOBAL (t)) ++ pp_cxx_colon_colon (pp); ++ pp_cxx_identifier (pp, "new"); ++ if (TREE_OPERAND (t, 0)) ++ { ++ pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0)); ++ pp_space (pp); ++ } ++ /* FIXME: array-types are built with one more element. */ ++ pp_cxx_type_id (pp, TREE_OPERAND (t, 1)); ++ if (TREE_OPERAND (t, 2)) ++ { ++ pp_left_paren (pp); ++ t = TREE_OPERAND (t, 2); ++ if (TREE_CODE (t) == TREE_LIST) ++ pp_c_expression_list (pp_c_base (pp), t); ++ else if (t == void_zero_node) ++ ; /* OK, empty initializer list. */ ++ else ++ pp_cxx_expression (pp, t); ++ pp_right_paren (pp); ++ } ++ break; ++ ++ default: ++ pp_unsupported_tree (pp, t); ++ } ++} ++ ++/* delete-expression: ++ ::(opt) delete cast-expression ++ ::(opt) delete [ ] cast-expression */ ++static void ++pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t) ++{ ++ enum tree_code code = TREE_CODE (t); ++ switch (code) ++ { ++ case DELETE_EXPR: ++ case VEC_DELETE_EXPR: ++ if (DELETE_EXPR_USE_GLOBAL (t)) ++ pp_cxx_colon_colon (pp); ++ pp_cxx_identifier (pp, "delete"); ++ if (code == VEC_DELETE_EXPR) ++ { ++ pp_left_bracket (pp); ++ pp_right_bracket (pp); ++ } ++ pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0)); ++ break; ++ ++ default: ++ pp_unsupported_tree (pp, t); ++ } ++} ++ ++/* unary-expression: ++ postfix-expression ++ ++ cast-expression ++ -- cast-expression ++ unary-operator cast-expression ++ sizeof unary-expression ++ sizeof ( type-id ) ++ new-expression ++ delete-expression ++ ++ unary-operator: one of ++ * & + - ! ++ ++ GNU extensions: ++ __alignof__ unary-expression ++ __alignof__ ( type-id ) */ ++static void ++pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t) ++{ ++ enum tree_code code = TREE_CODE (t); ++ switch (code) ++ { ++ case NEW_EXPR: ++ case VEC_NEW_EXPR: ++ pp_cxx_new_expression (pp, t); ++ break; ++ ++ case DELETE_EXPR: ++ case VEC_DELETE_EXPR: ++ pp_cxx_delete_expression (pp, t); ++ break; ++ ++ default: ++ pp_c_unary_expression (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* cast-expression: ++ unary-expression ++ ( type-id ) cast-expression */ ++static void ++pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case CAST_EXPR: ++ pp_cxx_type_id (pp, TREE_TYPE (t)); ++ pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0)); ++ break; ++ ++ default: ++ pp_c_cast_expression (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* pm-expression: ++ cast-expression ++ pm-expression .* cast-expression ++ pm-expression ->* cast-expression */ ++static void ++pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ /* Handle unfortunate OFFESET_REF overloading here. */ ++ case OFFSET_REF: ++ if (TYPE_P (TREE_OPERAND (t, 0))) ++ { ++ pp_cxx_qualified_id (pp, t); ++ break; ++ } ++ /* Else fall through. */ ++ case MEMBER_REF: ++ case DOTSTAR_EXPR: ++ pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0)); ++ pp_cxx_dot (pp); ++ pp_star(pp); ++ pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1)); ++ break; ++ ++ ++ default: ++ pp_cxx_cast_expression (pp, t); ++ break; ++ } ++} ++ ++/* multiplicative-expression: ++ pm-expression ++ multiplicative-expression * pm-expression ++ multiplicative-expression / pm-expression ++ multiplicative-expression % pm-expression */ ++static void ++pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e) ++{ ++ enum tree_code code = TREE_CODE (e); ++ switch (code) ++ { ++ case MULT_EXPR: ++ case TRUNC_DIV_EXPR: ++ case TRUNC_MOD_EXPR: ++ pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0)); ++ pp_space (pp); ++ if (code == MULT_EXPR) ++ pp_star (pp); ++ else if (code == TRUNC_DIV_EXPR) ++ pp_slash (pp); ++ else ++ pp_modulo (pp); ++ pp_space (pp); ++ pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1)); ++ break; ++ ++ default: ++ pp_cxx_pm_expression (pp, e); ++ break; ++ } ++} ++ ++/* conditional-expression: ++ logical-or-expression ++ logical-or-expression ? expression : assignment-expression */ ++static void ++pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e) ++{ ++ if (TREE_CODE (e) == COND_EXPR) ++ { ++ pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0)); ++ pp_space (pp); ++ pp_question (pp); ++ pp_space (pp); ++ pp_cxx_expression (pp, TREE_OPERAND (e, 1)); ++ pp_space (pp); ++ pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2)); ++ } ++ else ++ pp_c_logical_or_expression (pp_c_base (pp), e); ++} ++ ++static void ++pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t) ++{ ++ const char *op; ++ ++ switch (TREE_CODE (t)) ++ { ++ case NOP_EXPR: ++ op = "="; ++ break; ++ ++ case PLUS_EXPR: ++ op = "+="; ++ break; ++ ++ case MINUS_EXPR: ++ op = "-="; ++ break; ++ ++ case TRUNC_DIV_EXPR: ++ op = "/="; ++ break; ++ ++ case TRUNC_MOD_EXPR: ++ op = "%="; ++ break; ++ ++ default: ++ op = tree_code_name[TREE_CODE (t)]; ++ break; ++ } ++ ++ pp_cxx_identifier (pp, op); ++} ++ ++ ++/* assignment-expression: ++ conditional-expression ++ logical-or-expression assignment-operator assignment-expression ++ throw-expression ++ ++ throw-expression: ++ throw assignment-expression(opt) ++ ++ assignment-operator: one of ++ = *= /= %= += -= >>= <<= &= ^= |= */ ++static void ++pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e) ++{ ++ switch (TREE_CODE (e)) ++ { ++ case MODIFY_EXPR: ++ case INIT_EXPR: ++ pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0)); ++ pp_space (pp); ++ pp_equal (pp); ++ pp_space (pp); ++ pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1)); ++ break; ++ ++ case THROW_EXPR: ++ pp_cxx_identifier (pp, "throw"); ++ if (TREE_OPERAND (e, 0)) ++ pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0)); ++ break; ++ ++ case MODOP_EXPR: ++ pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0)); ++ pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1)); ++ pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2)); ++ break; ++ ++ default: ++ pp_cxx_conditional_expression (pp, e); ++ break; ++ } ++} ++ ++static void ++pp_cxx_expression (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case STRING_CST: ++ case INTEGER_CST: ++ case REAL_CST: ++ pp_c_constant (pp_c_base (pp), t); ++ break; ++ ++ case RESULT_DECL: ++ pp_cxx_unqualified_id (pp, t); ++ break; ++ ++#if 0 ++ case OFFSET_REF: ++#endif ++ case SCOPE_REF: ++ case PTRMEM_CST: ++ pp_cxx_qualified_id (pp, t); ++ break; ++ ++ case OVERLOAD: ++ t = OVL_CURRENT (t); ++ case VAR_DECL: ++ case PARM_DECL: ++ case FIELD_DECL: ++ case CONST_DECL: ++ case FUNCTION_DECL: ++ case BASELINK: ++ case TEMPLATE_DECL: ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_PARM_INDEX: ++ pp_cxx_primary_expression (pp, t); ++ break; ++ ++ case CALL_EXPR: ++ case DYNAMIC_CAST_EXPR: ++ case STATIC_CAST_EXPR: ++ case REINTERPRET_CAST_EXPR: ++ case CONST_CAST_EXPR: ++#if 0 ++ case MEMBER_REF: ++#endif ++ case EMPTY_CLASS_EXPR: ++ case TYPEID_EXPR: ++ case PSEUDO_DTOR_EXPR: ++ case AGGR_INIT_EXPR: ++ pp_cxx_postfix_expression (pp, t); ++ break; ++ ++ case NEW_EXPR: ++ case VEC_NEW_EXPR: ++ pp_cxx_new_expression (pp, t); ++ break; ++ ++ case DELETE_EXPR: ++ case VEC_DELETE_EXPR: ++ pp_cxx_delete_expression (pp, t); ++ break; ++ ++ case CAST_EXPR: ++ pp_cxx_cast_expression (pp, t); ++ break; ++ ++ case OFFSET_REF: ++ case MEMBER_REF: ++ case DOTSTAR_EXPR: ++ pp_cxx_pm_expression (pp, t); ++ break; ++ ++ case MULT_EXPR: ++ case TRUNC_DIV_EXPR: ++ case TRUNC_MOD_EXPR: ++ pp_cxx_multiplicative_expression (pp, t); ++ break; ++ ++ case COND_EXPR: ++ pp_cxx_conditional_expression (pp, t); ++ break; ++ ++ case MODIFY_EXPR: ++ case INIT_EXPR: ++ case THROW_EXPR: ++ case MODOP_EXPR: ++ pp_cxx_assignment_expression (pp, t); ++ break; ++ ++ default: ++ pp_c_expression (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++ ++/* Declarations. */ ++ ++/* function-specifier: ++ inline ++ virtual ++ explicit */ ++static void ++pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case FUNCTION_DECL: ++ if (DECL_VIRTUAL_P (t)) ++ pp_cxx_identifier (pp, "virtual"); ++ else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t)) ++ pp_cxx_identifier (pp, "explicit"); ++ else ++ pp_c_function_specifier (pp_c_base (pp), t); ++ ++ default: ++ break; ++ } ++} ++ ++/* decl-specifier-seq: ++ decl-specifier-seq(opt) decl-specifier ++ ++ decl-specifier: ++ storage-class-specifier ++ type-specifier ++ function-specifier ++ friend ++ typedef */ ++static void ++pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case VAR_DECL: ++ case PARM_DECL: ++ case CONST_DECL: ++ case FIELD_DECL: ++ pp_cxx_storage_class_specifier (pp, t); ++ pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t)); ++ break; ++ ++ case TYPE_DECL: ++ pp_cxx_identifier (pp, "typedef"); ++ pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t)); ++ break; ++ ++ case RECORD_TYPE: ++ if (TYPE_PTRMEMFUNC_P (t)) ++ { ++ tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t); ++ pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm))); ++ pp_cxx_whitespace (pp); ++ pp_cxx_ptr_operator (pp, t); ++ } ++ break; ++ ++ case FUNCTION_DECL: ++ /* Constructors don't have return types. And conversion functions ++ do not have a type-specifier in their return types. */ ++ if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t)) ++ pp_cxx_function_specifier (pp, t); ++ else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t)) ++ pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t))); ++ else ++ default: ++ pp_c_declaration_specifiers (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* simple-type-specifier: ++ ::(opt) nested-name-specifier(opt) type-name ++ ::(opt) nested-name-specifier(opt) template(opt) template-id ++ char ++ wchar_t ++ bool ++ short ++ int ++ long ++ signed ++ unsigned ++ float ++ double ++ void */ ++static void ++pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case RECORD_TYPE: ++ case UNION_TYPE: ++ case ENUMERAL_TYPE: ++ pp_cxx_qualified_id (pp, t); ++ break; ++ ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_PARM_INDEX: ++ pp_cxx_unqualified_id (pp, t); ++ break; ++ ++ case TYPENAME_TYPE: ++ pp_cxx_identifier (pp, "typename"); ++ pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t)); ++ pp_cxx_unqualified_id (pp, TYPE_NAME (t)); ++ break; ++ ++ default: ++ pp_c_type_specifier (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* type-specifier-seq: ++ type-specifier type-specifier-seq(opt) ++ ++ type-specifier: ++ simple-type-specifier ++ class-specifier ++ enum-specifier ++ elaborated-type-specifier ++ cv-qualifier */ ++ ++static void ++pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case TEMPLATE_DECL: ++ case TEMPLATE_TYPE_PARM: ++ case TYPE_DECL: ++ case BOUND_TEMPLATE_TEMPLATE_PARM: ++ pp_c_type_qualifier_list (pp_c_base (pp), t); ++ pp_cxx_simple_type_specifier (pp, t); ++ break; ++ ++ case METHOD_TYPE: ++ pp_cxx_type_specifier_seq (pp, TREE_TYPE (t)); ++ pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t)); ++ pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t)); ++ break; ++ ++ default: ++ if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t))) ++ pp_c_specifier_qualifier_list (pp_c_base (pp), t); ++ } ++} ++ ++/* ptr-operator: ++ * cv-qualifier-seq(opt) ++ & ++ ::(opt) nested-name-specifier * cv-qualifier-seq(opt) */ ++ ++static void ++pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t) ++{ ++ if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL) ++ t = TREE_TYPE (t); ++ switch (TREE_CODE (t)) ++ { ++ case REFERENCE_TYPE: ++ case POINTER_TYPE: ++ if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE ++ || TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t))) ++ pp_cxx_ptr_operator (pp, TREE_TYPE (t)); ++ if (TREE_CODE (t) == POINTER_TYPE) ++ { ++ pp_star (pp); ++ pp_cxx_cv_qualifier_seq (pp, t); ++ } ++ else ++ pp_ampersand (pp); ++ break; ++ ++ case RECORD_TYPE: ++ if (TYPE_PTRMEMFUNC_P (t)) ++ { ++ pp_cxx_left_paren (pp); ++ pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t)); ++ pp_star (pp); ++ break; ++ } ++ case OFFSET_TYPE: ++ if (TYPE_PTR_TO_MEMBER_P (t)) ++ { ++ pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t)); ++ pp_star (pp); ++ pp_cxx_cv_qualifier_seq (pp, t); ++ break; ++ } ++ /* else fall through. */ ++ ++ default: ++ pp_unsupported_tree (pp, t); ++ break; ++ } ++} ++ ++static inline tree ++pp_cxx_implicit_parameter_type (tree mf) ++{ ++ return TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (mf)))); ++} ++ ++/* ++ parameter-declaration: ++ decl-specifier-seq declarator ++ decl-specifier-seq declarator = assignment-expression ++ decl-specifier-seq abstract-declarator(opt) ++ decl-specifier-seq abstract-declarator(opt) assignment-expression */ ++static inline void ++pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t) ++{ ++ pp_cxx_decl_specifier_seq (pp, t); ++ if (TYPE_P (t)) ++ pp_cxx_abstract_declarator (pp, t); ++ else ++ pp_cxx_declarator (pp, t); ++} ++ ++/* parameter-declaration-clause: ++ parameter-declaration-list(opt) ...(opt) ++ parameter-declaration-list , ... ++ ++ parameter-declaration-list: ++ parameter-declaration ++ parameter-declaration-list , parameter-declaration */ ++static void ++pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t) ++{ ++ tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t); ++ tree types = TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t); ++ const bool abstract = args == NULL ++ || pp_c_base (pp)->flags & pp_c_flag_abstract; ++ bool first = true; ++ ++ /* Skip artificial parameter for nonstatic member functions. */ ++ if (TREE_CODE (t) == METHOD_TYPE) ++ types = TREE_CHAIN (types); ++ ++ pp_cxx_left_paren (pp); ++ for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types)) ++ { ++ if (!first) ++ pp_separate_with (pp, ','); ++ first = false; ++ pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args); ++ if (!abstract && pp_c_base (pp)->flags & pp_cxx_flag_default_argument) ++ { ++ pp_cxx_whitespace (pp); ++ pp_equal (pp); ++ pp_cxx_whitespace (pp); ++ pp_cxx_assignment_expression (pp, TREE_PURPOSE (types)); ++ } ++ } ++ pp_cxx_right_paren (pp); ++} ++ ++/* exception-specification: ++ throw ( type-id-list(opt) ) ++ ++ type-id-list ++ type-id ++ type-id-list , type-id */ ++static void ++pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t) ++{ ++ tree ex_spec = TYPE_RAISES_EXCEPTIONS (t); ++ ++ if (!TYPE_NOTHROW_P (t) && ex_spec == NULL) ++ return; ++ pp_cxx_identifier (pp, "throw"); ++ pp_cxx_left_paren (pp); ++ for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec)) ++ { ++ pp_cxx_type_id (pp, TREE_VALUE (ex_spec)); ++ if (TREE_CHAIN (ex_spec)) ++ pp_separate_with (pp, ','); ++ } ++ pp_cxx_right_paren (pp); ++} ++ ++/* direct-declarator: ++ declarator-id ++ direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt) ++ exception-specification(opt) ++ direct-declaration [ constant-expression(opt) ] ++ ( declarator ) */ ++static void ++pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case VAR_DECL: ++ case PARM_DECL: ++ case CONST_DECL: ++ case FIELD_DECL: ++ if (DECL_NAME (t)) ++ { ++ pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t)); ++ pp_cxx_id_expression (pp, DECL_NAME (t)); ++ } ++ pp_cxx_abstract_declarator (pp, TREE_TYPE (t)); ++ break; ++ ++ case FUNCTION_DECL: ++ pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t))); ++ pp_cxx_id_expression (pp, t); ++ pp_cxx_parameter_declaration_clause (pp, t); ++ ++ if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t)) ++ { ++ pp_base (pp)->padding = pp_before; ++ pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t)); ++ } ++ ++ pp_cxx_exception_specification (pp, TREE_TYPE (t)); ++ break; ++ ++ case TYPENAME_TYPE: ++ case TEMPLATE_DECL: ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_PARM_INDEX: ++ break; ++ ++ default: ++ pp_c_direct_declarator (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* declarator: ++ direct-declarator ++ ptr-operator declarator */ ++static void ++pp_cxx_declarator (cxx_pretty_printer *pp, tree t) ++{ ++ pp_cxx_direct_declarator (pp, t); ++} ++ ++/* ctor-initializer: ++ : mem-initializer-list ++ ++ mem-initializer-list: ++ mem-initializer ++ mem-initializer , mem-initializer-list ++ ++ mem-initializer: ++ mem-initializer-id ( expression-list(opt) ) ++ ++ mem-initializer-id: ++ ::(opt) nested-name-specifier(opt) class-name ++ identifier */ ++static void ++pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t) ++{ ++ t = TREE_OPERAND (t, 0); ++ pp_cxx_whitespace (pp); ++ pp_colon (pp); ++ pp_cxx_whitespace (pp); ++ for (; t; t = TREE_CHAIN (t)) ++ { ++ pp_cxx_primary_expression (pp, TREE_PURPOSE (t)); ++ pp_cxx_call_argument_list (pp, TREE_VALUE (t)); ++ if (TREE_CHAIN (t)) ++ pp_separate_with (pp, ','); ++ } ++} ++ ++/* function-definition: ++ decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body ++ decl-specifier-seq(opt) declarator function-try-block */ ++ ++void ++pp_cxx_function_definition (cxx_pretty_printer *pp, tree t) ++{ ++ tree saved_scope = pp->enclosing_scope; ++ pp_cxx_decl_specifier_seq (pp, t); ++ pp_cxx_declarator (pp, t); ++ pp_needs_newline (pp) = true; ++ pp->enclosing_scope = DECL_CONTEXT (t); ++ if (DECL_SAVED_TREE (t)) ++ { ++ tree body = DECL_SAVED_TREE (t); ++ if (TREE_CODE (body) == COMPOUND_STMT ++ && TREE_CODE (COMPOUND_BODY (body)) == CTOR_INITIALIZER) ++ { ++ body = COMPOUND_BODY (body); ++ pp_cxx_ctor_initializer (pp, body); ++ body = TREE_CHAIN (body); ++ } ++ pp_cxx_statement (pp, body); ++ } ++ else ++ { ++ pp_cxx_semicolon (pp); ++ pp_needs_newline (pp) = true; ++ } ++ pp_flush (pp); ++ pp->enclosing_scope = saved_scope; ++} ++ ++/* abstract-declarator: ++ ptr-operator abstract-declarator(opt) ++ direct-abstract-declarator */ ++static void ++pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t) ++{ ++ if (TYPE_PTRMEM_P (t) || TYPE_PTRMEMFUNC_P (t)) ++ pp_cxx_right_paren (pp); ++ else if (POINTER_TYPE_P (t)) ++ { ++ if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE ++ || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE) ++ pp_cxx_right_paren (pp); ++ t = TREE_TYPE (t); ++ } ++ pp_cxx_direct_abstract_declarator (pp, t); ++} ++ ++/* direct-abstract-declarator: ++ direct-abstract-declarator(opt) ( parameter-declaration-clause ) ++ cv-qualifier-seq(opt) exception-specification(opt) ++ direct-abstract-declarator(opt) [ constant-expression(opt) ] ++ ( abstract-declarator ) */ ++static void ++pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case REFERENCE_TYPE: ++ pp_cxx_abstract_declarator (pp, t); ++ break; ++ ++ case RECORD_TYPE: ++ if (TYPE_PTRMEMFUNC_P (t)) ++ pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t)); ++ break; ++ ++ case METHOD_TYPE: ++ case FUNCTION_TYPE: ++ pp_cxx_parameter_declaration_clause (pp, t); ++ pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t)); ++ if (TREE_CODE (t) == METHOD_TYPE) ++ { ++ pp_base (pp)->padding = pp_before; ++ pp_cxx_cv_qualifier_seq ++ (pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t)))); ++ } ++ pp_cxx_exception_specification (pp, t); ++ break; ++ ++ case TYPENAME_TYPE: ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_TEMPLATE_PARM: ++ case BOUND_TEMPLATE_TEMPLATE_PARM: ++ case UNBOUND_CLASS_TEMPLATE: ++ break; ++ ++ default: ++ pp_c_direct_abstract_declarator (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* type-id: ++ type-specifier-seq abstract-declarator(opt) */ ++static void ++pp_cxx_type_id (cxx_pretty_printer *pp, tree t) ++{ ++ pp_flags saved_flags = pp_c_base (pp)->flags; ++ pp_c_base (pp)->flags |= pp_c_flag_abstract; ++ ++ switch (TREE_CODE (t)) ++ { ++ case TYPE_DECL: ++ case UNION_TYPE: ++ case RECORD_TYPE: ++ case ENUMERAL_TYPE: ++ case TYPENAME_TYPE: ++ case BOUND_TEMPLATE_TEMPLATE_PARM: ++ case UNBOUND_CLASS_TEMPLATE: ++ case TEMPLATE_TEMPLATE_PARM: ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_PARM_INDEX: ++ case TEMPLATE_DECL: ++ case TYPEOF_TYPE: ++ case TEMPLATE_ID_EXPR: ++ /* FIXME: Should be pp_cxx_type_specifier_seq. */ ++ pp_cxx_type_specifier_seq (pp, t); ++ pp_cxx_declarator (pp, t); ++ break; ++ ++ default: ++ pp_c_type_id (pp_c_base (pp), t); ++ break; ++ } ++ ++ pp_c_base (pp)->flags = saved_flags; ++} ++ ++/* template-argument-list: ++ template-argument ++ template-argument-list, template-argument ++ ++ template-argument: ++ assignment-expression ++ type-id ++ template-name */ ++static void ++pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t) ++{ ++ int i; ++ if (t == NULL) ++ return; ++ for (i = 0; i < TREE_VEC_LENGTH (t); ++i) ++ { ++ tree arg = TREE_VEC_ELT (t, i); ++ if (i != 0) ++ pp_separate_with (pp, ','); ++ if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL ++ && TYPE_P (DECL_TEMPLATE_RESULT (arg)))) ++ pp_cxx_type_id (pp, arg); ++ else ++ pp_cxx_expression (pp, arg); ++ } ++} ++ ++ ++static void ++pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t) ++{ ++ t = DECL_STMT_DECL (t); ++ pp_cxx_type_specifier_seq (pp, t); ++ if (TYPE_P (t)) ++ pp_cxx_abstract_declarator (pp, t); ++ else ++ pp_cxx_declarator (pp, t); ++} ++ ++/* Statements. */ ++ ++void ++pp_cxx_statement (cxx_pretty_printer *pp, tree t) ++{ ++ switch (TREE_CODE (t)) ++ { ++ case USING_STMT: ++ pp_cxx_identifier (pp, "using"); ++ pp_cxx_identifier (pp, "namespace"); ++ pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t)); ++ break; ++ ++ case USING_DECL: ++ pp_cxx_identifier (pp, "using"); ++ pp_cxx_nested_name_specifier (pp, DECL_INITIAL (t)); ++ pp_cxx_unqualified_id (pp, DECL_NAME (t)); ++ break; ++ ++ case EH_SPEC_BLOCK: ++ break; ++ ++ /* try-block: ++ try compound-statement handler-seq */ ++ case TRY_BLOCK: ++ pp_maybe_newline_and_indent (pp, 0); ++ pp_cxx_identifier (pp, "try"); ++ pp_newline_and_indent (pp, 3); ++ pp_cxx_statement (pp, TRY_STMTS (t)); ++ pp_newline_and_indent (pp, -3); ++ if (CLEANUP_P (t)) ++ ; ++ else ++ pp_cxx_statement (pp, TRY_HANDLERS (t)); ++ break; ++ ++ /* ++ handler-seq: ++ handler handler-seq(opt) ++ ++ handler: ++ catch ( exception-declaration ) compound-statement ++ ++ exception-declaration: ++ type-specifier-seq declarator ++ type-specifier-seq abstract-declarator ++ ... */ ++ case HANDLER: ++ pp_cxx_identifier (pp, "catch"); ++ pp_cxx_left_paren (pp); ++ pp_cxx_exception_declaration (pp, HANDLER_PARMS (t)); ++ pp_cxx_right_paren (pp); ++ pp_indentation (pp) += 3; ++ pp_needs_newline (pp) = true; ++ pp_cxx_statement (pp, HANDLER_BODY (t)); ++ pp_indentation (pp) -= 3; ++ pp_needs_newline (pp) = true; ++ break; ++ ++ default: ++ pp_c_statement (pp_c_base (pp), t); ++ break; ++ } ++} ++ ++/* original-namespace-definition: ++ namespace identifier { namespace-body } ++ ++ As an edge case, we also handle unnamed namespace definition here. */ ++ ++static void ++pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t) ++{ ++ pp_cxx_identifier (pp, "namespace"); ++ if (DECL_NAME (t)) ++ pp_cxx_unqualified_id (pp, t); ++ pp_cxx_whitespace (pp); ++ pp_cxx_left_brace (pp); ++ /* We do not print the namespace-body. */ ++ pp_cxx_whitespace (pp); ++ pp_cxx_right_brace (pp); ++} ++ ++/* namespace-alias: ++ identifier ++ ++ namespace-alias-definition: ++ namespace identifier = qualified-namespace-specifier ; ++ ++ qualified-namespace-specifier: ++ ::(opt) nested-name-specifier(opt) namespace-name */ ++ ++static void ++pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t) ++{ ++ pp_cxx_identifier (pp, "namespace"); ++ pp_cxx_unqualified_id (pp, t); ++ pp_cxx_whitespace (pp); ++ pp_equal (pp); ++ pp_cxx_whitespace (pp); ++ pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t)); ++ pp_cxx_semicolon (pp); ++} ++ ++/* simple-declaration: ++ decl-specifier-seq(opt) init-declarator-list(opt) */ ++static void ++pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t) ++{ ++ pp_cxx_decl_specifier_seq (pp, t); ++ pp_cxx_init_declarator (pp, t); ++ pp_cxx_semicolon (pp); ++ pp_needs_newline (pp) = true; ++} ++ ++/* ++ template-parameter-list: ++ template-parameter ++ template-parameter-list , template-parameter */ ++ ++static inline void ++pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t) ++{ ++ const int n = TREE_VEC_LENGTH (t); ++ int i; ++ for (i = 0; i < n; ++i) ++ { ++ if (i) ++ pp_separate_with (pp, ','); ++ pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i)); ++ } ++} ++ ++/* template-parameter: ++ type-parameter ++ parameter-declaration ++ ++ type-parameter: ++ class identifier(opt) ++ class identifier(op) = type-id ++ typename identifier(opt) ++ typename identifier(opt) = type-id ++ template < template-parameter-list > class identifier(opt) ++ template < template-parameter-list > class identifier(opt) = template-name ++*/ ++static void ++pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t) ++{ ++ tree parameter = TREE_VALUE (t); ++ switch (TREE_CODE (parameter)) ++ { ++ case TYPE_DECL: ++ pp_cxx_identifier (pp, "class"); ++ if (DECL_NAME (parameter)) ++ pp_cxx_tree_identifier (pp, DECL_NAME (parameter)); ++ /* FIXME: Chech if we should print also default argument. */ ++ break; ++ ++ case PARM_DECL: ++ pp_cxx_parameter_declaration (pp, parameter); ++ break; ++ ++ case TEMPLATE_DECL: ++ break; ++ ++ default: ++ pp_unsupported_tree (pp, t); ++ break; ++ } ++} ++ ++/* Pretty-print a template parameter in the canonical form ++ "template-parameter--". */ ++ ++void ++pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm) ++{ ++ const enum tree_code code = TREE_CODE (parm); ++ ++ /* Brings type template parameters to the canonical forms. */ ++ if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM ++ || code == BOUND_TEMPLATE_TEMPLATE_PARM) ++ parm = TEMPLATE_TYPE_PARM_INDEX (parm); ++ ++ pp_cxx_begin_template_argument_list (pp); ++ pp_cxx_identifier (pp, "template-parameter-"); ++ pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm)); ++ pp_minus (pp); ++ pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1); ++ pp_cxx_end_template_argument_list (pp); ++} ++ ++/* ++ template-declaration: ++ export(opt) template < template-parameter-list > declaration */ ++static void ++pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t) ++{ ++ tree tmpl = most_general_template (t); ++ tree level; ++ int i = 0; ++ ++ pp_maybe_newline_and_indent (pp, 0); ++ for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level)) ++ { ++ pp_cxx_identifier (pp, "template"); ++ pp_cxx_begin_template_argument_list (pp); ++ pp_cxx_template_parameter_list (pp, TREE_VALUE (level)); ++ pp_cxx_end_template_argument_list (pp); ++ pp_newline_and_indent (pp, 3); ++ i += 3; ++ } ++ if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t)) ++ pp_cxx_function_definition (pp, t); ++ else ++ pp_cxx_simple_declaration (pp, t); ++} ++ ++static void ++pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t) ++{ ++ pp_unsupported_tree (pp, t); ++} ++ ++static void ++pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t) ++{ ++ pp_unsupported_tree (pp, t); ++} ++ ++/* ++ declaration: ++ block-declaration ++ function-definition ++ template-declaration ++ explicit-instantiation ++ explicit-specialization ++ linkage-specification ++ namespace-definition ++ ++ block-declaration: ++ simple-declaration ++ asm-definition ++ namespace-alias-definition ++ using-declaration ++ using-directive */ ++void ++pp_cxx_declaration (cxx_pretty_printer *pp, tree t) ++{ ++ if (!DECL_LANG_SPECIFIC (t)) ++ pp_cxx_simple_declaration (pp, t); ++ else if (DECL_USE_TEMPLATE (t)) ++ switch (DECL_USE_TEMPLATE (t)) ++ { ++ case 1: ++ pp_cxx_template_declaration (pp, t); ++ break; ++ ++ case 2: ++ pp_cxx_explicit_specialization (pp, t); ++ break; ++ ++ case 3: ++ pp_cxx_explicit_instantiation (pp, t); ++ break; ++ ++ default: ++ break; ++ } ++ else switch (TREE_CODE (t)) ++ { ++ case VAR_DECL: ++ case TYPE_DECL: ++ pp_cxx_simple_declaration (pp, t); ++ break; ++ ++ case FUNCTION_DECL: ++ if (DECL_SAVED_TREE (t)) ++ pp_cxx_function_definition (pp, t); ++ else ++ pp_cxx_simple_declaration (pp, t); ++ break; ++ ++ case NAMESPACE_DECL: ++ if (DECL_NAMESPACE_ALIAS (t)) ++ pp_cxx_namespace_alias_definition (pp, t); ++ else ++ pp_cxx_original_namespace_definition (pp, t); ++ break; ++ ++ default: ++ pp_unsupported_tree (pp, t); ++ break; ++ } ++} ++ ++ ++typedef c_pretty_print_fn pp_fun; ++ ++void ++pp_cxx_pretty_printer_init (cxx_pretty_printer *pp) ++{ ++ pp_c_pretty_printer_init (pp_c_base (pp)); ++ pp_set_line_maximum_length (pp, 0); ++ ++ pp->c_base.declaration = (pp_fun) pp_cxx_declaration; ++ pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq; ++ pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier; ++ pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq; ++ pp->c_base.declarator = (pp_fun) pp_cxx_declarator; ++ pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator; ++ pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause; ++ pp->c_base.type_id = (pp_fun) pp_cxx_type_id; ++ pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator; ++ pp->c_base.direct_abstract_declarator = ++ (pp_fun) pp_cxx_direct_abstract_declarator; ++ pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier; ++ ++ /* pp->c_base.statement = (pp_fun) pp_cxx_statement; */ ++ ++ pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression; ++ pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression; ++ pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression; ++ pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression; ++ pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression; ++ pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression; ++ pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression; ++ pp->c_base.expression = (pp_fun) pp_cxx_expression; ++ pp->enclosing_scope = global_namespace; ++} +diff -NBaur gcc-3.4.4/gcc/cp/cxx-pretty-print.h gcc-3.4.4-new/gcc/cp/cxx-pretty-print.h +--- gcc-3.4.4/gcc/cp/cxx-pretty-print.h Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/cxx-pretty-print.h Tue Oct 7 08:07:02 2003 +@@ -0,0 +1,52 @@ ++/* Interface for the GNU C++ pretty-printer. ++ Copyright (C) 2003 Free Software Foundation, Inc. ++ Contributed by Gabriel Dos Reis ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify it under ++the terms of the GNU General Public License as published by the Free ++Software Foundation; either version 2, or (at your option) any later ++version. ++ ++GCC is distributed in the hope that it will be useful, but WITHOUT ANY ++WARRANTY; without even the implied warranty of MERCHANTABILITY or ++FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to the Free ++Software Foundation, 59 Temple Place - Suite 330, Boston, MA ++02111-1307, USA. */ ++ ++#ifndef GCC_CXX_PRETTY_PRINT_H ++#define GCC_CXX_PRETTY_PRINT_H ++ ++#include "c-pretty-print.h" ++ ++#undef pp_c_base ++#define pp_c_base(PP) (&(PP)->c_base) ++ ++typedef enum ++{ ++ /* Ask for an qualified-id. */ ++ pp_cxx_flag_default_argument = 1 << pp_c_flag_last_bit ++ ++} cxx_pretty_printer_flags; ++ ++typedef struct ++{ ++ c_pretty_printer c_base; ++ /* This is the enclosing scope of the entity being pretty-printed. */ ++ tree enclosing_scope; ++} cxx_pretty_printer; ++ ++void pp_cxx_pretty_printer_init (cxx_pretty_printer *); ++ ++void pp_cxx_declaration (cxx_pretty_printer *, tree); ++void pp_cxx_function_definition (cxx_pretty_printer *, tree); ++void pp_cxx_canonical_template_parameter (cxx_pretty_printer *, tree); ++void pp_cxx_statement (cxx_pretty_printer *, tree); ++ ++ ++#endif /* GCC_CXX_PRETTY_PRINT_H */ +diff -NBaur gcc-3.4.4/gcc/cp/decl.c gcc-3.4.4-new/gcc/cp/decl.c +--- gcc-3.4.4/gcc/cp/decl.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/decl.c Sat Mar 19 14:00:45 2005 +@@ -0,0 +1,11350 @@ ++/* Process declarations and variables for C++ compiler. ++ Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, ++ 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. ++ Contributed by Michael Tiemann (tiemann@cygnus.com) ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++ ++/* Process declarations and symbol lookup for C++ front end. ++ Also constructs types; the standard scalar types at initialization, ++ and structure, union, array and enum types when they are declared. */ ++ ++/* ??? not all decl nodes are given the most useful possible ++ line numbers. For example, the CONST_DECLs for enum values. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "rtl.h" ++#include "expr.h" ++#include "flags.h" ++#include "cp-tree.h" ++#include "tree-inline.h" ++#include "decl.h" ++#include "lex.h" ++#include "output.h" ++#include "except.h" ++#include "toplev.h" ++#include "hashtab.h" ++#include "tm_p.h" ++#include "target.h" ++#include "c-common.h" ++#include "c-pragma.h" ++#include "diagnostic.h" ++#include "debug.h" ++#include "timevar.h" ++ ++static tree grokparms (tree, tree *); ++static const char *redeclaration_error_message (tree, tree); ++ ++static int decl_jump_unsafe (tree); ++static void require_complete_types_for_parms (tree); ++static int ambi_op_p (enum tree_code); ++static int unary_op_p (enum tree_code); ++static void push_local_name (tree); ++static tree grok_reference_init (tree, tree, tree, tree *); ++static tree grokfndecl (tree, tree, tree, tree, tree, int, ++ enum overload_flags, tree, ++ tree, int, int, int, int, int, int, tree); ++static tree grokvardecl (tree, tree, RID_BIT_TYPE *, int, int, tree); ++static void record_unknown_type (tree, const char *); ++static tree builtin_function_1 (const char *, tree, tree, int, ++ enum built_in_class, const char *, ++ tree); ++static tree build_library_fn_1 (tree, enum tree_code, tree); ++static int member_function_or_else (tree, tree, enum overload_flags); ++static void bad_specifiers (tree, const char *, int, int, int, int, ++ int); ++static void check_for_uninitialized_const_var (tree); ++static hashval_t typename_hash (const void *); ++static int typename_compare (const void *, const void *); ++static tree local_variable_p_walkfn (tree *, int *, void *); ++static tree record_builtin_java_type (const char *, int); ++static const char *tag_name (enum tag_types code); ++static int walk_namespaces_r (tree, walk_namespaces_fn, void *); ++static int walk_globals_r (tree, void*); ++static int walk_vtables_r (tree, void*); ++static tree make_label_decl (tree, int); ++static void use_label (tree); ++static void check_previous_goto_1 (tree, struct cp_binding_level *, tree, ++ const location_t *); ++static void check_previous_goto (struct named_label_use_list *); ++static void check_switch_goto (struct cp_binding_level *); ++static void check_previous_gotos (tree); ++static void pop_label (tree, tree); ++static void pop_labels (tree); ++static void maybe_deduce_size_from_array_init (tree, tree); ++static void layout_var_decl (tree); ++static void maybe_commonize_var (tree); ++static tree check_initializer (tree, tree, int, tree *); ++static void make_rtl_for_nonlocal_decl (tree, tree, const char *); ++static void save_function_data (tree); ++static void check_function_type (tree, tree); ++static void begin_constructor_body (void); ++static void finish_constructor_body (void); ++static void begin_destructor_body (void); ++static void finish_destructor_body (void); ++static tree create_array_type_for_decl (tree, tree, tree); ++static tree get_atexit_node (void); ++static tree get_dso_handle_node (void); ++static tree start_cleanup_fn (void); ++static void end_cleanup_fn (void); ++static tree cp_make_fname_decl (tree, int); ++static void initialize_predefined_identifiers (void); ++static tree check_special_function_return_type ++ (special_function_kind, tree, tree); ++static tree push_cp_library_fn (enum tree_code, tree); ++static tree build_cp_library_fn (tree, enum tree_code, tree); ++static void store_parm_decls (tree); ++static int cp_missing_noreturn_ok_p (tree); ++static void initialize_local_var (tree, tree); ++static void expand_static_init (tree, tree); ++static tree next_initializable_field (tree); ++static tree reshape_init (tree, tree *); ++static bool reshape_init_array (tree, tree, tree *, tree); ++static tree build_typename_type (tree, tree, tree); ++ ++/* Erroneous argument lists can use this *IFF* they do not modify it. */ ++tree error_mark_list; ++ ++/* The following symbols are subsumed in the cp_global_trees array, and ++ listed here individually for documentation purposes. ++ ++ C++ extensions ++ tree wchar_decl_node; ++ ++ tree vtable_entry_type; ++ tree delta_type_node; ++ tree __t_desc_type_node; ++ tree ti_desc_type_node; ++ tree bltn_desc_type_node, ptr_desc_type_node; ++ tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node; ++ tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node; ++ tree ptm_desc_type_node; ++ tree base_desc_type_node; ++ ++ tree class_type_node; ++ tree unknown_type_node; ++ ++ Array type `vtable_entry_type[]' ++ ++ tree vtbl_type_node; ++ tree vtbl_ptr_type_node; ++ ++ Namespaces, ++ ++ tree std_node; ++ tree abi_node; ++ ++ A FUNCTION_DECL which can call `abort'. Not necessarily the ++ one that the user will declare, but sufficient to be called ++ by routines that want to abort the program. ++ ++ tree abort_fndecl; ++ ++ The FUNCTION_DECL for the default `::operator delete'. ++ ++ tree global_delete_fndecl; ++ ++ Used by RTTI ++ tree type_info_type_node, tinfo_decl_id, tinfo_decl_type; ++ tree tinfo_var_id; ++ ++*/ ++ ++tree cp_global_trees[CPTI_MAX]; ++ ++/* Indicates that there is a type value in some namespace, although ++ that is not necessarily in scope at the moment. */ ++ ++tree global_type_node; ++ ++/* The node that holds the "name" of the global scope. */ ++tree global_scope_name; ++ ++/* Used only for jumps to as-yet undefined labels, since jumps to ++ defined labels can have their validity checked immediately. */ ++ ++struct named_label_use_list GTY(()) ++{ ++ struct cp_binding_level *binding_level; ++ tree names_in_scope; ++ tree label_decl; ++ location_t o_goto_locus; ++ struct named_label_use_list *next; ++}; ++ ++#define named_label_uses cp_function_chain->x_named_label_uses ++ ++#define local_names cp_function_chain->x_local_names ++ ++/* A list of objects which have constructors or destructors ++ which reside in the global scope. The decl is stored in ++ the TREE_VALUE slot and the initializer is stored ++ in the TREE_PURPOSE slot. */ ++tree static_aggregates; ++ ++/* -- end of C++ */ ++ ++/* A node for the integer constants 2, and 3. */ ++ ++tree integer_two_node, integer_three_node; ++ ++/* A list of all LABEL_DECLs in the function that have names. Here so ++ we can clear out their names' definitions at the end of the ++ function, and so we can check the validity of jumps to these labels. */ ++ ++struct named_label_list GTY(()) ++{ ++ struct cp_binding_level *binding_level; ++ tree names_in_scope; ++ tree old_value; ++ tree label_decl; ++ tree bad_decls; ++ struct named_label_list *next; ++ unsigned int in_try_scope : 1; ++ unsigned int in_catch_scope : 1; ++}; ++ ++#define named_labels cp_function_chain->x_named_labels ++ ++/* The number of function bodies which we are currently processing. ++ (Zero if we are at namespace scope, one inside the body of a ++ function, two inside the body of a function in a local class, etc.) */ ++int function_depth; ++ ++/* States indicating how grokdeclarator() should handle declspecs marked ++ with __attribute__((deprecated)). An object declared as ++ __attribute__((deprecated)) suppresses warnings of uses of other ++ deprecated items. */ ++ ++enum deprecated_states { ++ DEPRECATED_NORMAL, ++ DEPRECATED_SUPPRESS ++}; ++ ++static enum deprecated_states deprecated_state = DEPRECATED_NORMAL; ++ ++/* Set by add_implicitly_declared_members() to keep those members from ++ being flagged as deprecated or reported as using deprecated ++ types. */ ++int adding_implicit_members = 0; ++ ++/* True if a declaration with an `extern' linkage specifier is being ++ processed. */ ++bool have_extern_spec; ++ ++ ++/* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or ++ UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the ++ time the VAR_DECL was declared, the type was incomplete. */ ++ ++static GTY(()) tree incomplete_vars; ++ ++/* Returns the kind of template specialization we are currently ++ processing, given that it's declaration contained N_CLASS_SCOPES ++ explicit scope qualifications. */ ++ ++tmpl_spec_kind ++current_tmpl_spec_kind (int n_class_scopes) ++{ ++ int n_template_parm_scopes = 0; ++ int seen_specialization_p = 0; ++ int innermost_specialization_p = 0; ++ struct cp_binding_level *b; ++ ++ /* Scan through the template parameter scopes. */ ++ for (b = current_binding_level; ++ b->kind == sk_template_parms; ++ b = b->level_chain) ++ { ++ /* If we see a specialization scope inside a parameter scope, ++ then something is wrong. That corresponds to a declaration ++ like: ++ ++ template template <> ... ++ ++ which is always invalid since [temp.expl.spec] forbids the ++ specialization of a class member template if the enclosing ++ class templates are not explicitly specialized as well. */ ++ if (b->explicit_spec_p) ++ { ++ if (n_template_parm_scopes == 0) ++ innermost_specialization_p = 1; ++ else ++ seen_specialization_p = 1; ++ } ++ else if (seen_specialization_p == 1) ++ return tsk_invalid_member_spec; ++ ++ ++n_template_parm_scopes; ++ } ++ ++ /* Handle explicit instantiations. */ ++ if (processing_explicit_instantiation) ++ { ++ if (n_template_parm_scopes != 0) ++ /* We've seen a template parameter list during an explicit ++ instantiation. For example: ++ ++ template template void f(int); ++ ++ This is erroneous. */ ++ return tsk_invalid_expl_inst; ++ else ++ return tsk_expl_inst; ++ } ++ ++ if (n_template_parm_scopes < n_class_scopes) ++ /* We've not seen enough template headers to match all the ++ specialized classes present. For example: ++ ++ template void R::S::f(int); ++ ++ This is invalid; there needs to be one set of template ++ parameters for each class. */ ++ return tsk_insufficient_parms; ++ else if (n_template_parm_scopes == n_class_scopes) ++ /* We're processing a non-template declaration (even though it may ++ be a member of a template class.) For example: ++ ++ template void S::f(int); ++ ++ The `class T' maches the `S', leaving no template headers ++ corresponding to the `f'. */ ++ return tsk_none; ++ else if (n_template_parm_scopes > n_class_scopes + 1) ++ /* We've got too many template headers. For example: ++ ++ template <> template void f (T); ++ ++ There need to be more enclosing classes. */ ++ return tsk_excessive_parms; ++ else ++ /* This must be a template. It's of the form: ++ ++ template template void S::f(U); ++ ++ This is a specialization if the innermost level was a ++ specialization; otherwise it's just a definition of the ++ template. */ ++ return innermost_specialization_p ? tsk_expl_spec : tsk_template; ++} ++ ++/* Exit the current scope. */ ++ ++void ++finish_scope (void) ++{ ++ poplevel (0, 0, 0); ++} ++ ++/* When a label goes out of scope, check to see if that label was used ++ in a valid manner, and issue any appropriate warnings or errors. */ ++ ++static void ++pop_label (tree label, tree old_value) ++{ ++ if (!processing_template_decl) ++ { ++ if (DECL_INITIAL (label) == NULL_TREE) ++ { ++ location_t location; ++ ++ cp_error_at ("label `%D' used but not defined", label); ++ location.file = input_filename; ++ location.line = 0; ++ /* Avoid crashing later. */ ++ define_label (location, DECL_NAME (label)); ++ } ++ else if (warn_unused_label && !TREE_USED (label)) ++ cp_warning_at ("label `%D' defined but not used", label); ++ } ++ ++ SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value); ++} ++ ++/* At the end of a function, all labels declared within the function ++ go out of scope. BLOCK is the top-level block for the ++ function. */ ++ ++static void ++pop_labels (tree block) ++{ ++ struct named_label_list *link; ++ ++ /* Clear out the definitions of all label names, since their scopes ++ end here. */ ++ for (link = named_labels; link; link = link->next) ++ { ++ pop_label (link->label_decl, link->old_value); ++ /* Put the labels into the "variables" of the top-level block, ++ so debugger can see them. */ ++ TREE_CHAIN (link->label_decl) = BLOCK_VARS (block); ++ BLOCK_VARS (block) = link->label_decl; ++ } ++ ++ named_labels = NULL; ++} ++ ++/* Exit a binding level. ++ Pop the level off, and restore the state of the identifier-decl mappings ++ that were in effect when this level was entered. ++ ++ If KEEP == 1, this level had explicit declarations, so ++ and create a "block" (a BLOCK node) for the level ++ to record its declarations and subblocks for symbol table output. ++ ++ If FUNCTIONBODY is nonzero, this level is the body of a function, ++ so create a block as if KEEP were set and also clear out all ++ label names. ++ ++ If REVERSE is nonzero, reverse the order of decls before putting ++ them into the BLOCK. */ ++ ++tree ++poplevel (int keep, int reverse, int functionbody) ++{ ++ tree link; ++ /* The chain of decls was accumulated in reverse order. ++ Put it into forward order, just for cleanliness. */ ++ tree decls; ++ int tmp = functionbody; ++ int real_functionbody; ++ tree subblocks; ++ tree block = NULL_TREE; ++ tree decl; ++ int leaving_for_scope; ++ scope_kind kind; ++ ++ timevar_push (TV_NAME_LOOKUP); ++ ++ my_friendly_assert (current_binding_level->kind != sk_class, 19990916); ++ ++ real_functionbody = (current_binding_level->kind == sk_cleanup ++ ? ((functionbody = 0), tmp) : functionbody); ++ subblocks = functionbody >= 0 ? current_binding_level->blocks : 0; ++ ++ my_friendly_assert (!current_binding_level->class_shadowed, ++ 19990414); ++ ++ /* We used to use KEEP == 2 to indicate that the new block should go ++ at the beginning of the list of blocks at this binding level, ++ rather than the end. This hack is no longer used. */ ++ my_friendly_assert (keep == 0 || keep == 1, 0); ++ ++ if (current_binding_level->keep) ++ keep = 1; ++ ++ /* Any uses of undefined labels, and any defined labels, now operate ++ under constraints of next binding contour. */ ++ if (cfun && !functionbody) ++ { ++ struct cp_binding_level *level_chain; ++ level_chain = current_binding_level->level_chain; ++ if (level_chain) ++ { ++ struct named_label_use_list *uses; ++ struct named_label_list *labels; ++ for (labels = named_labels; labels; labels = labels->next) ++ if (labels->binding_level == current_binding_level) ++ { ++ tree decl; ++ if (current_binding_level->kind == sk_try) ++ labels->in_try_scope = 1; ++ if (current_binding_level->kind == sk_catch) ++ labels->in_catch_scope = 1; ++ for (decl = labels->names_in_scope; decl; ++ decl = TREE_CHAIN (decl)) ++ if (decl_jump_unsafe (decl)) ++ labels->bad_decls = tree_cons (NULL_TREE, decl, ++ labels->bad_decls); ++ labels->binding_level = level_chain; ++ labels->names_in_scope = level_chain->names; ++ } ++ ++ for (uses = named_label_uses; uses; uses = uses->next) ++ if (uses->binding_level == current_binding_level) ++ { ++ uses->binding_level = level_chain; ++ uses->names_in_scope = level_chain->names; ++ } ++ } ++ } ++ ++ /* Get the decls in the order they were written. ++ Usually current_binding_level->names is in reverse order. ++ But parameter decls were previously put in forward order. */ ++ ++ if (reverse) ++ current_binding_level->names ++ = decls = nreverse (current_binding_level->names); ++ else ++ decls = current_binding_level->names; ++ ++ /* Output any nested inline functions within this block ++ if they weren't already output. */ ++ for (decl = decls; decl; decl = TREE_CHAIN (decl)) ++ if (TREE_CODE (decl) == FUNCTION_DECL ++ && ! TREE_ASM_WRITTEN (decl) ++ && DECL_INITIAL (decl) != NULL_TREE ++ && TREE_ADDRESSABLE (decl) ++ && decl_function_context (decl) == current_function_decl) ++ { ++ /* If this decl was copied from a file-scope decl ++ on account of a block-scope extern decl, ++ propagate TREE_ADDRESSABLE to the file-scope decl. */ ++ if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE) ++ TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1; ++ else ++ { ++ push_function_context (); ++ output_inline_function (decl); ++ pop_function_context (); ++ } ++ } ++ ++ /* When not in function-at-a-time mode, expand_end_bindings will ++ warn about unused variables. But, in function-at-a-time mode ++ expand_end_bindings is not passed the list of variables in the ++ current scope, and therefore no warning is emitted. So, we ++ explicitly warn here. */ ++ if (!processing_template_decl) ++ warn_about_unused_variables (getdecls ()); ++ ++ /* If there were any declarations or structure tags in that level, ++ or if this level is a function body, ++ create a BLOCK to record them for the life of this function. */ ++ block = NULL_TREE; ++ if (keep == 1 || functionbody) ++ block = make_node (BLOCK); ++ if (block != NULL_TREE) ++ { ++ BLOCK_VARS (block) = decls; ++ BLOCK_SUBBLOCKS (block) = subblocks; ++ } ++ ++ /* In each subblock, record that this is its superior. */ ++ if (keep >= 0) ++ for (link = subblocks; link; link = TREE_CHAIN (link)) ++ BLOCK_SUPERCONTEXT (link) = block; ++ ++ /* We still support the old for-scope rules, whereby the variables ++ in a for-init statement were in scope after the for-statement ++ ended. We only use the new rules if flag_new_for_scope is ++ nonzero. */ ++ leaving_for_scope ++ = current_binding_level->kind == sk_for && flag_new_for_scope == 1; ++ ++ /* Remove declarations for all the DECLs in this level. */ ++ for (link = decls; link; link = TREE_CHAIN (link)) ++ { ++ if (leaving_for_scope && TREE_CODE (link) == VAR_DECL ++ && DECL_NAME (link)) ++ { ++ cxx_binding *outer_binding ++ = IDENTIFIER_BINDING (DECL_NAME (link))->previous; ++ tree ns_binding; ++ ++ if (!outer_binding) ++ ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link)); ++ else ++ ns_binding = NULL_TREE; ++ ++ if (outer_binding ++ && outer_binding->scope == current_binding_level->level_chain) ++ /* We have something like: ++ ++ int i; ++ for (int i; ;); ++ ++ and we are leaving the `for' scope. There's no reason to ++ keep the binding of the inner `i' in this case. */ ++ pop_binding (DECL_NAME (link), link); ++ else if ((outer_binding ++ && (TREE_CODE (outer_binding->value) == TYPE_DECL)) ++ || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL)) ++ /* Here, we have something like: ++ ++ typedef int I; ++ ++ void f () { ++ for (int I; ;); ++ } ++ ++ We must pop the for-scope binding so we know what's a ++ type and what isn't. */ ++ pop_binding (DECL_NAME (link), link); ++ else ++ { ++ /* Mark this VAR_DECL as dead so that we can tell we left it ++ there only for backward compatibility. */ ++ DECL_DEAD_FOR_LOCAL (link) = 1; ++ ++ /* Keep track of what should have happened when we ++ popped the binding. */ ++ if (outer_binding && outer_binding->value) ++ DECL_SHADOWED_FOR_VAR (link) = outer_binding->value; ++ ++ /* Add it to the list of dead variables in the next ++ outermost binding to that we can remove these when we ++ leave that binding. */ ++ current_binding_level->level_chain->dead_vars_from_for ++ = tree_cons (NULL_TREE, link, ++ current_binding_level->level_chain-> ++ dead_vars_from_for); ++ ++ /* Although we don't pop the cxx_binding, we do clear ++ its SCOPE since the scope is going away now. */ ++ IDENTIFIER_BINDING (DECL_NAME (link))->scope = NULL; ++ } ++ } ++ else ++ { ++ /* Remove the binding. */ ++ decl = link; ++ if (TREE_CODE (decl) == TREE_LIST) ++ decl = TREE_VALUE (decl); ++ if (DECL_P (decl)) ++ pop_binding (DECL_NAME (decl), decl); ++ else if (TREE_CODE (decl) == OVERLOAD) ++ pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl); ++ else ++ abort (); ++ } ++ } ++ ++ /* Remove declarations for any `for' variables from inner scopes ++ that we kept around. */ ++ for (link = current_binding_level->dead_vars_from_for; ++ link; link = TREE_CHAIN (link)) ++ pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link)); ++ ++ /* Restore the IDENTIFIER_TYPE_VALUEs. */ ++ for (link = current_binding_level->type_shadowed; ++ link; link = TREE_CHAIN (link)) ++ SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link)); ++ ++ /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */ ++ for (link = current_binding_level->shadowed_labels; ++ link; ++ link = TREE_CHAIN (link)) ++ pop_label (TREE_VALUE (link), TREE_PURPOSE (link)); ++ ++ /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs ++ list if a `using' declaration put them there. The debugging ++ back-ends won't understand OVERLOAD, so we remove them here. ++ Because the BLOCK_VARS are (temporarily) shared with ++ CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have ++ popped all the bindings. */ ++ if (block) ++ { ++ tree* d; ++ ++ for (d = &BLOCK_VARS (block); *d; ) ++ { ++ if (TREE_CODE (*d) == TREE_LIST) ++ *d = TREE_CHAIN (*d); ++ else ++ d = &TREE_CHAIN (*d); ++ } ++ } ++ ++ /* If the level being exited is the top level of a function, ++ check over all the labels. */ ++ if (functionbody) ++ { ++ /* Since this is the top level block of a function, the vars are ++ the function's parameters. Don't leave them in the BLOCK ++ because they are found in the FUNCTION_DECL instead. */ ++ BLOCK_VARS (block) = 0; ++ pop_labels (block); ++ } ++ ++ kind = current_binding_level->kind; ++ ++ leave_scope (); ++ if (functionbody) ++ DECL_INITIAL (current_function_decl) = block; ++ else if (block) ++ current_binding_level->blocks ++ = chainon (current_binding_level->blocks, block); ++ ++ /* If we did not make a block for the level just exited, ++ any blocks made for inner levels ++ (since they cannot be recorded as subblocks in that level) ++ must be carried forward so they will later become subblocks ++ of something else. */ ++ else if (subblocks) ++ current_binding_level->blocks ++ = chainon (current_binding_level->blocks, subblocks); ++ ++ /* Each and every BLOCK node created here in `poplevel' is important ++ (e.g. for proper debugging information) so if we created one ++ earlier, mark it as "used". */ ++ if (block) ++ TREE_USED (block) = 1; ++ ++ /* Take care of compiler's internal binding structures. */ ++ if (kind == sk_cleanup) ++ { ++ tree scope_stmts; ++ ++ scope_stmts ++ = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1); ++ if (block) ++ { ++ SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block; ++ SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block; ++ } ++ ++ block = poplevel (keep, reverse, functionbody); ++ } ++ ++ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block); ++} ++ ++/* Delete the node BLOCK from the current binding level. ++ This is used for the block inside a stmt expr ({...}) ++ so that the block can be reinserted where appropriate. */ ++ ++void ++delete_block (tree block) ++{ ++ tree t; ++ if (current_binding_level->blocks == block) ++ current_binding_level->blocks = TREE_CHAIN (block); ++ for (t = current_binding_level->blocks; t;) ++ { ++ if (TREE_CHAIN (t) == block) ++ TREE_CHAIN (t) = TREE_CHAIN (block); ++ else ++ t = TREE_CHAIN (t); ++ } ++ TREE_CHAIN (block) = NULL_TREE; ++ /* Clear TREE_USED which is always set by poplevel. ++ The flag is set again if insert_block is called. */ ++ TREE_USED (block) = 0; ++} ++ ++/* Insert BLOCK at the end of the list of subblocks of the ++ current binding level. This is used when a BIND_EXPR is expanded, ++ to handle the BLOCK node inside the BIND_EXPR. */ ++ ++void ++insert_block (tree block) ++{ ++ TREE_USED (block) = 1; ++ current_binding_level->blocks ++ = chainon (current_binding_level->blocks, block); ++} ++ ++/* Set the BLOCK node for the innermost scope ++ (the one we are currently in). */ ++ ++void ++set_block (tree block ATTRIBUTE_UNUSED ) ++{ ++ /* The RTL expansion machinery requires us to provide this callback, ++ but it is not applicable in function-at-a-time mode. */ ++} ++ ++/* Returns nonzero if T is a virtual function table. */ ++ ++int ++vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED ) ++{ ++ return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t)); ++} ++ ++/* Returns nonzero if T is a TYPE_DECL for a type with virtual ++ functions. */ ++ ++int ++vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED ) ++{ ++ return (TREE_CODE (t) == TYPE_DECL ++ && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE ++ && TYPE_POLYMORPHIC_P (TREE_TYPE (t))); ++} ++ ++struct walk_globals_data { ++ walk_globals_pred p; ++ walk_globals_fn f; ++ void *data; ++}; ++ ++/* Walk the vtable declarations in NAMESPACE. Whenever one is found ++ for which P returns nonzero, call F with its address. If any call ++ to F returns a nonzero value, return a nonzero value. */ ++ ++static int ++walk_vtables_r (tree namespace, void* data) ++{ ++ struct walk_globals_data* wgd = (struct walk_globals_data *) data; ++ walk_globals_fn f = wgd->f; ++ void *d = wgd->data; ++ tree decl = NAMESPACE_LEVEL (namespace)->vtables; ++ int result = 0; ++ ++ for (; decl ; decl = TREE_CHAIN (decl)) ++ result |= (*f) (&decl, d); ++ ++ return result; ++} ++ ++/* Walk the vtable declarations. Whenever one is found for which P ++ returns nonzero, call F with its address. If any call to F ++ returns a nonzero value, return a nonzero value. */ ++bool ++walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data) ++{ ++ struct walk_globals_data wgd; ++ wgd.p = p; ++ wgd.f = f; ++ wgd.data = data; ++ ++ return walk_namespaces (walk_vtables_r, &wgd); ++} ++ ++/* Walk all the namespaces contained NAMESPACE, including NAMESPACE ++ itself, calling F for each. The DATA is passed to F as well. */ ++ ++static int ++walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data) ++{ ++ int result = 0; ++ tree current = NAMESPACE_LEVEL (namespace)->namespaces; ++ ++ result |= (*f) (namespace, data); ++ ++ for (; current; current = TREE_CHAIN (current)) ++ result |= walk_namespaces_r (current, f, data); ++ ++ return result; ++} ++ ++/* Walk all the namespaces, calling F for each. The DATA is passed to ++ F as well. */ ++ ++int ++walk_namespaces (walk_namespaces_fn f, void* data) ++{ ++ return walk_namespaces_r (global_namespace, f, data); ++} ++ ++/* Walk the global declarations in NAMESPACE. Whenever one is found ++ for which P returns nonzero, call F with its address. If any call ++ to F returns a nonzero value, return a nonzero value. */ ++ ++static int ++walk_globals_r (tree namespace, void* data) ++{ ++ struct walk_globals_data* wgd = (struct walk_globals_data *) data; ++ walk_globals_pred p = wgd->p; ++ walk_globals_fn f = wgd->f; ++ void *d = wgd->data; ++ tree *t; ++ int result = 0; ++ ++ t = &NAMESPACE_LEVEL (namespace)->names; ++ ++ while (*t) ++ { ++ tree glbl = *t; ++ ++ if ((*p) (glbl, d)) ++ result |= (*f) (t, d); ++ ++ /* If F changed *T, then *T still points at the next item to ++ examine. */ ++ if (*t == glbl) ++ t = &TREE_CHAIN (*t); ++ } ++ ++ return result; ++} ++ ++/* Walk the global declarations. Whenever one is found for which P ++ returns true, call F with its address. If any call to F ++ returns true, return true. */ ++ ++bool ++walk_globals (walk_globals_pred p, walk_globals_fn f, void *data) ++{ ++ struct walk_globals_data wgd; ++ wgd.p = p; ++ wgd.f = f; ++ wgd.data = data; ++ ++ return walk_namespaces (walk_globals_r, &wgd); ++} ++ ++/* Call wrapup_globals_declarations for the globals in NAMESPACE. If ++ DATA is non-NULL, this is the last time we will call ++ wrapup_global_declarations for this NAMESPACE. */ ++ ++int ++wrapup_globals_for_namespace (tree namespace, void* data) ++{ ++ struct cp_binding_level *level = NAMESPACE_LEVEL (namespace); ++ varray_type statics = level->static_decls; ++ tree *vec = &VARRAY_TREE (statics, 0); ++ int len = VARRAY_ACTIVE_SIZE (statics); ++ int last_time = (data != 0); ++ ++ if (last_time) ++ { ++ check_global_declarations (vec, len); ++ return 0; ++ } ++ ++ /* Write out any globals that need to be output. */ ++ return wrapup_global_declarations (vec, len); ++} ++ ++ ++/* In C++, you don't have to write `struct S' to refer to `S'; you ++ can just use `S'. We accomplish this by creating a TYPE_DECL as ++ if the user had written `typedef struct S S'. Create and return ++ the TYPE_DECL for TYPE. */ ++ ++tree ++create_implicit_typedef (tree name, tree type) ++{ ++ tree decl; ++ ++ decl = build_decl (TYPE_DECL, name, type); ++ DECL_ARTIFICIAL (decl) = 1; ++ /* There are other implicit type declarations, like the one *within* ++ a class that allows you to write `S::S'. We must distinguish ++ amongst these. */ ++ SET_DECL_IMPLICIT_TYPEDEF_P (decl); ++ TYPE_NAME (type) = decl; ++ ++ return decl; ++} ++ ++/* Remember a local name for name-mangling purposes. */ ++ ++static void ++push_local_name (tree decl) ++{ ++ size_t i, nelts; ++ tree t, name; ++ ++ timevar_push (TV_NAME_LOOKUP); ++ if (!local_names) ++ VARRAY_TREE_INIT (local_names, 8, "local_names"); ++ ++ name = DECL_NAME (decl); ++ ++ nelts = VARRAY_ACTIVE_SIZE (local_names); ++ for (i = 0; i < nelts; i++) ++ { ++ t = VARRAY_TREE (local_names, i); ++ if (DECL_NAME (t) == name) ++ { ++ if (!DECL_LANG_SPECIFIC (decl)) ++ retrofit_lang_decl (decl); ++ DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1; ++ if (DECL_LANG_SPECIFIC (t)) ++ DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1; ++ else ++ DECL_DISCRIMINATOR (decl) = 1; ++ ++ VARRAY_TREE (local_names, i) = decl; ++ timevar_pop (TV_NAME_LOOKUP); ++ return; ++ } ++ } ++ ++ VARRAY_PUSH_TREE (local_names, decl); ++ timevar_pop (TV_NAME_LOOKUP); ++} ++ ++/* Subroutine of duplicate_decls: return truthvalue of whether ++ or not types of these decls match. ++ ++ For C++, we must compare the parameter list so that `int' can match ++ `int&' in a parameter position, but `int&' is not confused with ++ `const int&'. */ ++ ++int ++decls_match (tree newdecl, tree olddecl) ++{ ++ int types_match; ++ ++ if (newdecl == olddecl) ++ return 1; ++ ++ if (TREE_CODE (newdecl) != TREE_CODE (olddecl)) ++ /* If the two DECLs are not even the same kind of thing, we're not ++ interested in their types. */ ++ return 0; ++ ++ if (TREE_CODE (newdecl) == FUNCTION_DECL) ++ { ++ tree f1 = TREE_TYPE (newdecl); ++ tree f2 = TREE_TYPE (olddecl); ++ tree p1 = TYPE_ARG_TYPES (f1); ++ tree p2 = TYPE_ARG_TYPES (f2); ++ ++ if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl) ++ && ! (DECL_EXTERN_C_P (newdecl) ++ && DECL_EXTERN_C_P (olddecl))) ++ return 0; ++ ++ if (TREE_CODE (f1) != TREE_CODE (f2)) ++ return 0; ++ ++ if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2))) ++ { ++ if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl) ++ && (DECL_BUILT_IN (olddecl) ++#ifndef NO_IMPLICIT_EXTERN_C ++ || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl)) ++ || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl)) ++#endif ++ )) ++ { ++ types_match = self_promoting_args_p (p1); ++ if (p1 == void_list_node) ++ TREE_TYPE (newdecl) = TREE_TYPE (olddecl); ++ } ++#ifndef NO_IMPLICIT_EXTERN_C ++ else if (p1 == NULL_TREE ++ && (DECL_EXTERN_C_P (olddecl) ++ && DECL_IN_SYSTEM_HEADER (olddecl) ++ && !DECL_CLASS_SCOPE_P (olddecl)) ++ && (DECL_EXTERN_C_P (newdecl) ++ && DECL_IN_SYSTEM_HEADER (newdecl) ++ && !DECL_CLASS_SCOPE_P (newdecl))) ++ { ++ types_match = self_promoting_args_p (p2); ++ TREE_TYPE (newdecl) = TREE_TYPE (olddecl); ++ } ++#endif ++ else ++ types_match = compparms (p1, p2); ++ } ++ else ++ types_match = 0; ++ } ++ else if (TREE_CODE (newdecl) == TEMPLATE_DECL) ++ { ++ if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) ++ != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))) ++ return 0; ++ ++ if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), ++ DECL_TEMPLATE_PARMS (olddecl))) ++ return 0; ++ ++ if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) ++ types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)), ++ TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))); ++ else ++ types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl), ++ DECL_TEMPLATE_RESULT (newdecl)); ++ } ++ else ++ { ++ /* Need to check scope for variable declaration (VAR_DECL). ++ For typedef (TYPE_DECL), scope is ignored. */ ++ if (TREE_CODE (newdecl) == VAR_DECL ++ && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)) ++ return 0; ++ ++ if (TREE_TYPE (newdecl) == error_mark_node) ++ types_match = TREE_TYPE (olddecl) == error_mark_node; ++ else if (TREE_TYPE (olddecl) == NULL_TREE) ++ types_match = TREE_TYPE (newdecl) == NULL_TREE; ++ else if (TREE_TYPE (newdecl) == NULL_TREE) ++ types_match = 0; ++ else ++ types_match = comptypes (TREE_TYPE (newdecl), ++ TREE_TYPE (olddecl), ++ COMPARE_REDECLARATION); ++ } ++ ++ return types_match; ++} ++ ++/* If NEWDECL is `static' and an `extern' was seen previously, ++ warn about it. OLDDECL is the previous declaration. ++ ++ Note that this does not apply to the C++ case of declaring ++ a variable `extern const' and then later `const'. ++ ++ Don't complain about built-in functions, since they are beyond ++ the user's control. */ ++ ++void ++warn_extern_redeclared_static (tree newdecl, tree olddecl) ++{ ++ static const char *const explicit_extern_static_warning ++ = "`%D' was declared `extern' and later `static'"; ++ static const char *const implicit_extern_static_warning ++ = "`%D' was declared implicitly `extern' and later `static'"; ++ ++ tree name; ++ ++ if (TREE_CODE (newdecl) == TYPE_DECL ++ || TREE_CODE (newdecl) == TEMPLATE_DECL ++ || TREE_CODE (newdecl) == CONST_DECL ++ || TREE_CODE (newdecl) == NAMESPACE_DECL) ++ return; ++ ++ /* Don't get confused by static member functions; that's a different ++ use of `static'. */ ++ if (TREE_CODE (newdecl) == FUNCTION_DECL ++ && DECL_STATIC_FUNCTION_P (newdecl)) ++ return; ++ ++ /* If the old declaration was `static', or the new one isn't, then ++ then everything is OK. */ ++ if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl)) ++ return; ++ ++ /* It's OK to declare a builtin function as `static'. */ ++ if (TREE_CODE (olddecl) == FUNCTION_DECL ++ && DECL_ARTIFICIAL (olddecl)) ++ return; ++ ++ name = DECL_ASSEMBLER_NAME (newdecl); ++ pedwarn (IDENTIFIER_IMPLICIT_DECL (name) ++ ? implicit_extern_static_warning ++ : explicit_extern_static_warning, newdecl); ++ cp_pedwarn_at ("previous declaration of `%D'", olddecl); ++} ++ ++/* If NEWDECL is a redeclaration of OLDDECL, merge the declarations. ++ If the redeclaration is invalid, a diagnostic is issued, and the ++ error_mark_node is returned. Otherwise, OLDDECL is returned. ++ ++ If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is ++ returned. */ ++ ++tree ++duplicate_decls (tree newdecl, tree olddecl) ++{ ++ unsigned olddecl_uid = DECL_UID (olddecl); ++ int olddecl_friend = 0, types_match = 0; ++ int new_defines_function = 0; ++ ++ if (newdecl == olddecl) ++ return olddecl; ++ ++ types_match = decls_match (newdecl, olddecl); ++ ++ /* If either the type of the new decl or the type of the old decl is an ++ error_mark_node, then that implies that we have already issued an ++ error (earlier) for some bogus type specification, and in that case, ++ it is rather pointless to harass the user with yet more error message ++ about the same declaration, so just pretend the types match here. */ ++ if (TREE_TYPE (newdecl) == error_mark_node ++ || TREE_TYPE (olddecl) == error_mark_node) ++ types_match = 1; ++ ++ if (DECL_P (olddecl) ++ && TREE_CODE (newdecl) == FUNCTION_DECL ++ && TREE_CODE (olddecl) == FUNCTION_DECL ++ && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl))) ++ { ++ if (DECL_DECLARED_INLINE_P (newdecl) ++ && DECL_UNINLINABLE (newdecl) ++ && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) ++ /* Already warned elsewhere. */; ++ else if (DECL_DECLARED_INLINE_P (olddecl) ++ && DECL_UNINLINABLE (olddecl) ++ && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) ++ /* Already warned. */; ++ else if (DECL_DECLARED_INLINE_P (newdecl) ++ && DECL_UNINLINABLE (olddecl) ++ && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) ++ { ++ warning ("%Jfunction '%D' redeclared as inline", newdecl, newdecl); ++ warning ("%Jprevious declaration of '%D' with attribute noinline", ++ olddecl, olddecl); ++ } ++ else if (DECL_DECLARED_INLINE_P (olddecl) ++ && DECL_UNINLINABLE (newdecl) ++ && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) ++ { ++ warning ("%Jfunction '%D' redeclared with attribute noinline", ++ newdecl, newdecl); ++ warning ("%Jprevious declaration of '%D' was inline", ++ olddecl, olddecl); ++ } ++ } ++ ++ /* Check for redeclaration and other discrepancies. */ ++ if (TREE_CODE (olddecl) == FUNCTION_DECL ++ && DECL_ARTIFICIAL (olddecl)) ++ { ++ if (TREE_CODE (newdecl) != FUNCTION_DECL) ++ { ++ /* Avoid warnings redeclaring anticipated built-ins. */ ++ if (DECL_ANTICIPATED (olddecl)) ++ return NULL_TREE; ++ ++ /* If you declare a built-in or predefined function name as static, ++ the old definition is overridden, but optionally warn this was a ++ bad choice of name. */ ++ if (! TREE_PUBLIC (newdecl)) ++ { ++ if (warn_shadow) ++ warning ("shadowing %s function `%#D'", ++ DECL_BUILT_IN (olddecl) ? "built-in" : "library", ++ olddecl); ++ /* Discard the old built-in function. */ ++ return NULL_TREE; ++ } ++ /* If the built-in is not ansi, then programs can override ++ it even globally without an error. */ ++ else if (! DECL_BUILT_IN (olddecl)) ++ warning ("library function `%#D' redeclared as non-function `%#D'", ++ olddecl, newdecl); ++ else ++ { ++ error ("declaration of `%#D'", newdecl); ++ error ("conflicts with built-in declaration `%#D'", ++ olddecl); ++ } ++ return NULL_TREE; ++ } ++ else if (!types_match) ++ { ++ /* Avoid warnings redeclaring anticipated built-ins. */ ++ if (DECL_ANTICIPATED (olddecl)) ++ ; /* Do nothing yet. */ ++ else if ((DECL_EXTERN_C_P (newdecl) ++ && DECL_EXTERN_C_P (olddecl)) ++ || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), ++ TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) ++ { ++ /* A near match; override the builtin. */ ++ ++ if (TREE_PUBLIC (newdecl)) ++ { ++ warning ("new declaration `%#D'", newdecl); ++ warning ("ambiguates built-in declaration `%#D'", ++ olddecl); ++ } ++ else if (warn_shadow) ++ warning ("shadowing %s function `%#D'", ++ DECL_BUILT_IN (olddecl) ? "built-in" : "library", ++ olddecl); ++ } ++ else ++ /* Discard the old built-in function. */ ++ return NULL_TREE; ++ ++ /* Replace the old RTL to avoid problems with inlining. */ ++ SET_DECL_RTL (olddecl, DECL_RTL (newdecl)); ++ } ++ /* Even if the types match, prefer the new declarations type ++ for anticipated built-ins, for exception lists, etc... */ ++ else if (DECL_ANTICIPATED (olddecl)) ++ { ++ tree type = TREE_TYPE (newdecl); ++ tree attribs = (*targetm.merge_type_attributes) ++ (TREE_TYPE (olddecl), type); ++ ++ type = cp_build_type_attribute_variant (type, attribs); ++ TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type; ++ } ++ ++ /* Whether or not the builtin can throw exceptions has no ++ bearing on this declarator. */ ++ TREE_NOTHROW (olddecl) = 0; ++ ++ if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl)) ++ { ++ /* If a builtin function is redeclared as `static', merge ++ the declarations, but make the original one static. */ ++ DECL_THIS_STATIC (olddecl) = 1; ++ TREE_PUBLIC (olddecl) = 0; ++ ++ /* Make the old declaration consistent with the new one so ++ that all remnants of the builtin-ness of this function ++ will be banished. */ ++ SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); ++ SET_DECL_RTL (olddecl, DECL_RTL (newdecl)); ++ } ++ } ++ else if (TREE_CODE (olddecl) != TREE_CODE (newdecl)) ++ { ++ if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl) ++ && TREE_CODE (newdecl) != TYPE_DECL ++ && ! (TREE_CODE (newdecl) == TEMPLATE_DECL ++ && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)) ++ || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl) ++ && TREE_CODE (olddecl) != TYPE_DECL ++ && ! (TREE_CODE (olddecl) == TEMPLATE_DECL ++ && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) ++ == TYPE_DECL)))) ++ { ++ /* We do nothing special here, because C++ does such nasty ++ things with TYPE_DECLs. Instead, just let the TYPE_DECL ++ get shadowed, and know that if we need to find a TYPE_DECL ++ for a given name, we can look in the IDENTIFIER_TYPE_VALUE ++ slot of the identifier. */ ++ return NULL_TREE; ++ } ++ ++ if ((TREE_CODE (newdecl) == FUNCTION_DECL ++ && DECL_FUNCTION_TEMPLATE_P (olddecl)) ++ || (TREE_CODE (olddecl) == FUNCTION_DECL ++ && DECL_FUNCTION_TEMPLATE_P (newdecl))) ++ return NULL_TREE; ++ ++ error ("`%#D' redeclared as different kind of symbol", newdecl); ++ if (TREE_CODE (olddecl) == TREE_LIST) ++ olddecl = TREE_VALUE (olddecl); ++ cp_error_at ("previous declaration of `%#D'", olddecl); ++ ++ /* New decl is completely inconsistent with the old one => ++ tell caller to replace the old one. */ ++ ++ return NULL_TREE; ++ } ++ else if (!types_match) ++ { ++ if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)) ++ /* These are certainly not duplicate declarations; they're ++ from different scopes. */ ++ return NULL_TREE; ++ ++ if (TREE_CODE (newdecl) == TEMPLATE_DECL) ++ { ++ /* The name of a class template may not be declared to refer to ++ any other template, class, function, object, namespace, value, ++ or type in the same scope. */ ++ if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL ++ || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) ++ { ++ error ("declaration of template `%#D'", newdecl); ++ cp_error_at ("conflicts with previous declaration `%#D'", ++ olddecl); ++ } ++ else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL ++ && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL ++ && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))), ++ TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)))) ++ && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), ++ DECL_TEMPLATE_PARMS (olddecl)) ++ /* Template functions can be disambiguated by ++ return type. */ ++ && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)), ++ TREE_TYPE (TREE_TYPE (olddecl)))) ++ { ++ error ("new declaration `%#D'", newdecl); ++ cp_error_at ("ambiguates old declaration `%#D'", olddecl); ++ } ++ return NULL_TREE; ++ } ++ if (TREE_CODE (newdecl) == FUNCTION_DECL) ++ { ++ if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl)) ++ { ++ error ("declaration of C function `%#D' conflicts with", ++ newdecl); ++ cp_error_at ("previous declaration `%#D' here", olddecl); ++ } ++ else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), ++ TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) ++ { ++ error ("new declaration `%#D'", newdecl); ++ cp_error_at ("ambiguates old declaration `%#D'", olddecl); ++ } ++ else ++ return NULL_TREE; ++ } ++ ++ /* Already complained about this, so don't do so again. */ ++ else if (current_class_type == NULL_TREE ++ || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type) ++ { ++ error ("conflicting declaration '%#D'", newdecl); ++ cp_error_at ("'%D' has a previous declaration as `%#D'", ++ olddecl, olddecl); ++ return NULL_TREE; ++ } ++ } ++ else if (TREE_CODE (newdecl) == FUNCTION_DECL ++ && ((DECL_TEMPLATE_SPECIALIZATION (olddecl) ++ && (!DECL_TEMPLATE_INFO (newdecl) ++ || (DECL_TI_TEMPLATE (newdecl) ++ != DECL_TI_TEMPLATE (olddecl)))) ++ || (DECL_TEMPLATE_SPECIALIZATION (newdecl) ++ && (!DECL_TEMPLATE_INFO (olddecl) ++ || (DECL_TI_TEMPLATE (olddecl) ++ != DECL_TI_TEMPLATE (newdecl)))))) ++ /* It's OK to have a template specialization and a non-template ++ with the same type, or to have specializations of two ++ different templates with the same type. Note that if one is a ++ specialization, and the other is an instantiation of the same ++ template, that we do not exit at this point. That situation ++ can occur if we instantiate a template class, and then ++ specialize one of its methods. This situation is valid, but ++ the declarations must be merged in the usual way. */ ++ return NULL_TREE; ++ else if (TREE_CODE (newdecl) == FUNCTION_DECL ++ && ((DECL_TEMPLATE_INSTANTIATION (olddecl) ++ && !DECL_USE_TEMPLATE (newdecl)) ++ || (DECL_TEMPLATE_INSTANTIATION (newdecl) ++ && !DECL_USE_TEMPLATE (olddecl)))) ++ /* One of the declarations is a template instantiation, and the ++ other is not a template at all. That's OK. */ ++ return NULL_TREE; ++ else if (TREE_CODE (newdecl) == NAMESPACE_DECL) ++ { ++ /* In [namespace.alias] we have: ++ ++ In a declarative region, a namespace-alias-definition can be ++ used to redefine a namespace-alias declared in that declarative ++ region to refer only to the namespace to which it already ++ refers. ++ ++ Therefore, if we encounter a second alias directive for the same ++ alias, we can just ignore the second directive. */ ++ if (DECL_NAMESPACE_ALIAS (newdecl) ++ && (DECL_NAMESPACE_ALIAS (newdecl) ++ == DECL_NAMESPACE_ALIAS (olddecl))) ++ return olddecl; ++ /* [namespace.alias] ++ ++ A namespace-name or namespace-alias shall not be declared as ++ the name of any other entity in the same declarative region. ++ A namespace-name defined at global scope shall not be ++ declared as the name of any other entity in any glogal scope ++ of the program. */ ++ error ("declaration of `namespace %D' conflicts with", newdecl); ++ cp_error_at ("previous declaration of `namespace %D' here", olddecl); ++ return error_mark_node; ++ } ++ else ++ { ++ const char *errmsg = redeclaration_error_message (newdecl, olddecl); ++ if (errmsg) ++ { ++ error (errmsg, newdecl); ++ if (DECL_NAME (olddecl) != NULL_TREE) ++ cp_error_at ((DECL_INITIAL (olddecl) ++ && namespace_bindings_p ()) ++ ? "`%#D' previously defined here" ++ : "`%#D' previously declared here", olddecl); ++ return error_mark_node; ++ } ++ else if (TREE_CODE (olddecl) == FUNCTION_DECL ++ && DECL_INITIAL (olddecl) != NULL_TREE ++ && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE ++ && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE) ++ { ++ /* Prototype decl follows defn w/o prototype. */ ++ cp_warning_at ("prototype for `%#D'", newdecl); ++ warning ("%Jfollows non-prototype definition here", olddecl); ++ } ++ else if (TREE_CODE (olddecl) == FUNCTION_DECL ++ && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)) ++ { ++ /* extern "C" int foo (); ++ int foo () { bar (); } ++ is OK. */ ++ if (current_lang_depth () == 0) ++ SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); ++ else ++ { ++ cp_error_at ("previous declaration of `%#D' with %L linkage", ++ olddecl, DECL_LANGUAGE (olddecl)); ++ error ("conflicts with new declaration with %L linkage", ++ DECL_LANGUAGE (newdecl)); ++ } ++ } ++ ++ if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl)) ++ ; ++ else if (TREE_CODE (olddecl) == FUNCTION_DECL) ++ { ++ tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); ++ tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)); ++ int i = 1; ++ ++ if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE) ++ t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2); ++ ++ for (; t1 && t1 != void_list_node; ++ t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++) ++ if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2)) ++ { ++ if (1 == simple_cst_equal (TREE_PURPOSE (t1), ++ TREE_PURPOSE (t2))) ++ { ++ pedwarn ("default argument given for parameter %d of `%#D'", ++ i, newdecl); ++ cp_pedwarn_at ("after previous specification in `%#D'", ++ olddecl); ++ } ++ else ++ { ++ error ("default argument given for parameter %d of `%#D'", ++ i, newdecl); ++ cp_error_at ("after previous specification in `%#D'", ++ olddecl); ++ } ++ } ++ ++ if (DECL_DECLARED_INLINE_P (newdecl) ++ && ! DECL_DECLARED_INLINE_P (olddecl) ++ && TREE_ADDRESSABLE (olddecl) && warn_inline) ++ { ++ warning ("`%#D' was used before it was declared inline", newdecl); ++ warning ("%Jprevious non-inline declaration here", olddecl); ++ } ++ } ++ } ++ ++ /* Do not merge an implicit typedef with an explicit one. In: ++ ++ class A; ++ ... ++ typedef class A A __attribute__ ((foo)); ++ ++ the attribute should apply only to the typedef. */ ++ if (TREE_CODE (olddecl) == TYPE_DECL ++ && (DECL_IMPLICIT_TYPEDEF_P (olddecl) ++ || DECL_IMPLICIT_TYPEDEF_P (newdecl))) ++ return NULL_TREE; ++ ++ /* If new decl is `static' and an `extern' was seen previously, ++ warn about it. */ ++ warn_extern_redeclared_static (newdecl, olddecl); ++ ++ /* We have committed to returning 1 at this point. */ ++ if (TREE_CODE (newdecl) == FUNCTION_DECL) ++ { ++ /* Now that functions must hold information normally held ++ by field decls, there is extra work to do so that ++ declaration information does not get destroyed during ++ definition. */ ++ if (DECL_VINDEX (olddecl)) ++ DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl); ++ if (DECL_CONTEXT (olddecl)) ++ DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl); ++ DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl); ++ DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl); ++ DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl); ++ DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl); ++ DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl); ++ DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl); ++ if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK) ++ SET_OVERLOADED_OPERATOR_CODE ++ (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl)); ++ new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE; ++ ++ /* Optionally warn about more than one declaration for the same ++ name, but don't warn about a function declaration followed by a ++ definition. */ ++ if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl) ++ && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE) ++ /* Don't warn about extern decl followed by definition. */ ++ && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)) ++ /* Don't warn about friends, let add_friend take care of it. */ ++ && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl))) ++ { ++ warning ("redundant redeclaration of `%D' in same scope", newdecl); ++ cp_warning_at ("previous declaration of `%D'", olddecl); ++ } ++ } ++ ++ /* Deal with C++: must preserve virtual function table size. */ ++ if (TREE_CODE (olddecl) == TYPE_DECL) ++ { ++ tree newtype = TREE_TYPE (newdecl); ++ tree oldtype = TREE_TYPE (olddecl); ++ ++ if (newtype != error_mark_node && oldtype != error_mark_node ++ && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype)) ++ CLASSTYPE_FRIEND_CLASSES (newtype) ++ = CLASSTYPE_FRIEND_CLASSES (oldtype); ++ ++ DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl); ++ } ++ ++ /* Copy all the DECL_... slots specified in the new decl ++ except for any that we copy here from the old type. */ ++ DECL_ATTRIBUTES (newdecl) ++ = (*targetm.merge_decl_attributes) (olddecl, newdecl); ++ ++ if (TREE_CODE (newdecl) == TEMPLATE_DECL) ++ { ++ TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)); ++ DECL_TEMPLATE_SPECIALIZATIONS (olddecl) ++ = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl), ++ DECL_TEMPLATE_SPECIALIZATIONS (newdecl)); ++ ++ /* If the new declaration is a definition, update the file and ++ line information on the declaration. */ ++ if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE ++ && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE) ++ { ++ DECL_SOURCE_LOCATION (olddecl) ++ = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl)) ++ = DECL_SOURCE_LOCATION (newdecl); ++ if (DECL_FUNCTION_TEMPLATE_P (newdecl)) ++ DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl)) ++ = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl)); ++ } ++ ++ if (DECL_FUNCTION_TEMPLATE_P (newdecl)) ++ { ++ DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl)) ++ |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl)); ++ DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl)) ++ |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl)); ++ } ++ ++ return olddecl; ++ } ++ ++ if (types_match) ++ { ++ /* Automatically handles default parameters. */ ++ tree oldtype = TREE_TYPE (olddecl); ++ tree newtype; ++ ++ /* Merge the data types specified in the two decls. */ ++ newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl)); ++ ++ /* If merge_types produces a non-typedef type, just use the old type. */ ++ if (TREE_CODE (newdecl) == TYPE_DECL ++ && newtype == DECL_ORIGINAL_TYPE (newdecl)) ++ newtype = oldtype; ++ ++ if (TREE_CODE (newdecl) == VAR_DECL) ++ { ++ DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl); ++ DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl); ++ DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl) ++ |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl); ++ } ++ ++ /* Do this after calling `merge_types' so that default ++ parameters don't confuse us. */ ++ else if (TREE_CODE (newdecl) == FUNCTION_DECL ++ && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)) ++ != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)))) ++ { ++ TREE_TYPE (newdecl) = build_exception_variant (newtype, ++ TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))); ++ TREE_TYPE (olddecl) = build_exception_variant (newtype, ++ TYPE_RAISES_EXCEPTIONS (oldtype)); ++ ++ if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl)) ++ && DECL_SOURCE_LINE (olddecl) != 0 ++ && flag_exceptions ++ && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)), ++ TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1)) ++ { ++ error ("declaration of `%F' throws different exceptions", ++ newdecl); ++ cp_error_at ("than previous declaration `%F'", olddecl); ++ } ++ } ++ TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype; ++ ++ /* Lay the type out, unless already done. */ ++ if (! same_type_p (newtype, oldtype) ++ && TREE_TYPE (newdecl) != error_mark_node ++ && !(processing_template_decl && uses_template_parms (newdecl))) ++ layout_type (TREE_TYPE (newdecl)); ++ ++ if ((TREE_CODE (newdecl) == VAR_DECL ++ || TREE_CODE (newdecl) == PARM_DECL ++ || TREE_CODE (newdecl) == RESULT_DECL ++ || TREE_CODE (newdecl) == FIELD_DECL ++ || TREE_CODE (newdecl) == TYPE_DECL) ++ && !(processing_template_decl && uses_template_parms (newdecl))) ++ layout_decl (newdecl, 0); ++ ++ /* Merge the type qualifiers. */ ++ if (TREE_READONLY (newdecl)) ++ TREE_READONLY (olddecl) = 1; ++ if (TREE_THIS_VOLATILE (newdecl)) ++ TREE_THIS_VOLATILE (olddecl) = 1; ++ ++ /* Merge the initialization information. */ ++ if (DECL_INITIAL (newdecl) == NULL_TREE ++ && DECL_INITIAL (olddecl) != NULL_TREE) ++ { ++ DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); ++ DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl); ++ if (CAN_HAVE_FULL_LANG_DECL_P (newdecl) ++ && DECL_LANG_SPECIFIC (newdecl) ++ && DECL_LANG_SPECIFIC (olddecl)) ++ { ++ DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl); ++ DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl); ++ } ++ } ++ ++ /* Merge the section attribute. ++ We want to issue an error if the sections conflict but that must be ++ done later in decl_attributes since we are called before attributes ++ are assigned. */ ++ if (DECL_SECTION_NAME (newdecl) == NULL_TREE) ++ DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl); ++ ++ if (TREE_CODE (newdecl) == FUNCTION_DECL) ++ { ++ DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl) ++ |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl); ++ DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl); ++ TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); ++ TREE_READONLY (newdecl) |= TREE_READONLY (olddecl); ++ TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl); ++ DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl); ++ DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl); ++ /* Keep the old RTL. */ ++ COPY_DECL_RTL (olddecl, newdecl); ++ } ++ else if (TREE_CODE (newdecl) == VAR_DECL ++ && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl))) ++ { ++ /* Keep the old RTL. We cannot keep the old RTL if the old ++ declaration was for an incomplete object and the new ++ declaration is not since many attributes of the RTL will ++ change. */ ++ COPY_DECL_RTL (olddecl, newdecl); ++ } ++ } ++ /* If cannot merge, then use the new type and qualifiers, ++ and don't preserve the old rtl. */ ++ else ++ { ++ /* Clean out any memory we had of the old declaration. */ ++ tree oldstatic = value_member (olddecl, static_aggregates); ++ if (oldstatic) ++ TREE_VALUE (oldstatic) = error_mark_node; ++ ++ TREE_TYPE (olddecl) = TREE_TYPE (newdecl); ++ TREE_READONLY (olddecl) = TREE_READONLY (newdecl); ++ TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl); ++ TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl); ++ } ++ ++ /* Merge the storage class information. */ ++ merge_weak (newdecl, olddecl); ++ ++ DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl); ++ DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl); ++ TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl); ++ TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl); ++ if (! DECL_EXTERNAL (olddecl)) ++ DECL_EXTERNAL (newdecl) = 0; ++ ++ if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl)) ++ { ++ DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl); ++ DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl); ++ DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl); ++ DECL_TEMPLATE_INSTANTIATED (newdecl) ++ |= DECL_TEMPLATE_INSTANTIATED (olddecl); ++ /* Don't really know how much of the language-specific ++ values we should copy from old to new. */ ++ DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl); ++ DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 = ++ DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2; ++ DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl); ++ DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl); ++ DECL_INITIALIZED_IN_CLASS_P (newdecl) ++ |= DECL_INITIALIZED_IN_CLASS_P (olddecl); ++ olddecl_friend = DECL_FRIEND_P (olddecl); ++ ++ /* Only functions have DECL_BEFRIENDING_CLASSES. */ ++ if (TREE_CODE (newdecl) == FUNCTION_DECL ++ || DECL_FUNCTION_TEMPLATE_P (newdecl)) ++ { ++ DECL_BEFRIENDING_CLASSES (newdecl) ++ = chainon (DECL_BEFRIENDING_CLASSES (newdecl), ++ DECL_BEFRIENDING_CLASSES (olddecl)); ++ /* DECL_THUNKS is only valid for virtual functions, ++ otherwise it is a DECL_FRIEND_CONTEXT. */ ++ if (DECL_VIRTUAL_P (newdecl)) ++ DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl); ++ } ++ } ++ ++ if (TREE_CODE (newdecl) == FUNCTION_DECL) ++ { ++ if (DECL_TEMPLATE_INSTANTIATION (olddecl) ++ && !DECL_TEMPLATE_INSTANTIATION (newdecl)) ++ { ++ /* If newdecl is not a specialization, then it is not a ++ template-related function at all. And that means that we ++ should have exited above, returning 0. */ ++ my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl), ++ 0); ++ ++ if (TREE_USED (olddecl)) ++ /* From [temp.expl.spec]: ++ ++ If a template, a member template or the member of a class ++ template is explicitly specialized then that ++ specialization shall be declared before the first use of ++ that specialization that would cause an implicit ++ instantiation to take place, in every translation unit in ++ which such a use occurs. */ ++ error ("explicit specialization of %D after first use", ++ olddecl); ++ ++ SET_DECL_TEMPLATE_SPECIALIZATION (olddecl); ++ ++ /* [temp.expl.spec/14] We don't inline explicit specialization ++ just because the primary template says so. */ ++ } ++ else ++ { ++ if (DECL_PENDING_INLINE_INFO (newdecl) == 0) ++ DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl); ++ ++ DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl); ++ ++ /* If either decl says `inline', this fn is inline, unless ++ its definition was passed already. */ ++ if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE) ++ DECL_INLINE (olddecl) = 1; ++ DECL_INLINE (newdecl) = DECL_INLINE (olddecl); ++ ++ DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl) ++ = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)); ++ } ++ ++ /* Preserve abstractness on cloned [cd]tors. */ ++ DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl); ++ ++ if (! types_match) ++ { ++ SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); ++ COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl); ++ SET_DECL_RTL (olddecl, DECL_RTL (newdecl)); ++ } ++ if (! types_match || new_defines_function) ++ { ++ /* These need to be copied so that the names are available. ++ Note that if the types do match, we'll preserve inline ++ info and other bits, but if not, we won't. */ ++ DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl); ++ DECL_RESULT (olddecl) = DECL_RESULT (newdecl); ++ } ++ if (new_defines_function) ++ /* If defining a function declared with other language ++ linkage, use the previously declared language linkage. */ ++ SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); ++ else if (types_match) ++ { ++ /* If redeclaring a builtin function, and not a definition, ++ it stays built in. */ ++ if (DECL_BUILT_IN (olddecl)) ++ { ++ DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl); ++ DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl); ++ /* If we're keeping the built-in definition, keep the rtl, ++ regardless of declaration matches. */ ++ SET_DECL_RTL (newdecl, DECL_RTL (olddecl)); ++ } ++ ++ DECL_RESULT (newdecl) = DECL_RESULT (olddecl); ++ /* Don't clear out the arguments if we're redefining a function. */ ++ if (DECL_ARGUMENTS (olddecl)) ++ DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl); ++ } ++ } ++ else if (TREE_CODE (newdecl) == NAMESPACE_DECL) ++ NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl); ++ ++ /* Now preserve various other info from the definition. */ ++ TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl); ++ TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl); ++ DECL_COMMON (newdecl) = DECL_COMMON (olddecl); ++ COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl); ++ ++ /* If either declaration has a nondefault visibility, use it. */ ++ if (DECL_VISIBILITY (olddecl) != VISIBILITY_DEFAULT) ++ { ++ if (DECL_VISIBILITY (newdecl) != VISIBILITY_DEFAULT ++ && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl)) ++ { ++ warning ("%J'%D': visibility attribute ignored because it", ++ newdecl, newdecl); ++ warning ("%Jconflicts with previous declaration here", olddecl); ++ } ++ DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl); ++ } ++ ++ if (TREE_CODE (newdecl) == FUNCTION_DECL) ++ { ++ int function_size; ++ ++ function_size = sizeof (struct tree_decl); ++ ++ memcpy ((char *) olddecl + sizeof (struct tree_common), ++ (char *) newdecl + sizeof (struct tree_common), ++ function_size - sizeof (struct tree_common)); ++ ++ if (DECL_TEMPLATE_INSTANTIATION (newdecl)) ++ /* If newdecl is a template instantiation, it is possible that ++ the following sequence of events has occurred: ++ ++ o A friend function was declared in a class template. The ++ class template was instantiated. ++ ++ o The instantiation of the friend declaration was ++ recorded on the instantiation list, and is newdecl. ++ ++ o Later, however, instantiate_class_template called pushdecl ++ on the newdecl to perform name injection. But, pushdecl in ++ turn called duplicate_decls when it discovered that another ++ declaration of a global function with the same name already ++ existed. ++ ++ o Here, in duplicate_decls, we decided to clobber newdecl. ++ ++ If we're going to do that, we'd better make sure that ++ olddecl, and not newdecl, is on the list of ++ instantiations so that if we try to do the instantiation ++ again we won't get the clobbered declaration. */ ++ reregister_specialization (newdecl, ++ DECL_TI_TEMPLATE (newdecl), ++ olddecl); ++ } ++ else ++ { ++ memcpy ((char *) olddecl + sizeof (struct tree_common), ++ (char *) newdecl + sizeof (struct tree_common), ++ sizeof (struct tree_decl) - sizeof (struct tree_common) ++ + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *)); ++ } ++ ++ DECL_UID (olddecl) = olddecl_uid; ++ if (olddecl_friend) ++ DECL_FRIEND_P (olddecl) = 1; ++ ++ /* NEWDECL contains the merged attribute lists. ++ Update OLDDECL to be the same. */ ++ DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl); ++ ++ /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl ++ so that encode_section_info has a chance to look at the new decl ++ flags and attributes. */ ++ if (DECL_RTL_SET_P (olddecl) ++ && (TREE_CODE (olddecl) == FUNCTION_DECL ++ || (TREE_CODE (olddecl) == VAR_DECL ++ && TREE_STATIC (olddecl)))) ++ make_decl_rtl (olddecl, NULL); ++ ++ return olddecl; ++} ++ ++/* Generate an implicit declaration for identifier FUNCTIONID ++ as a function of type int (). Print a warning if appropriate. */ ++ ++tree ++implicitly_declare (tree functionid) ++{ ++ tree decl; ++ ++ /* We used to reuse an old implicit decl here, ++ but this loses with inline functions because it can clobber ++ the saved decl chains. */ ++ decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type); ++ ++ DECL_EXTERNAL (decl) = 1; ++ TREE_PUBLIC (decl) = 1; ++ ++ /* ISO standard says implicit declarations are in the innermost block. ++ So we record the decl in the standard fashion. */ ++ pushdecl (decl); ++ rest_of_decl_compilation (decl, NULL, 0, 0); ++ ++ if (warn_implicit ++ /* Only one warning per identifier. */ ++ && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE) ++ { ++ pedwarn ("implicit declaration of function `%#D'", decl); ++ } ++ ++ SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl); ++ ++ return decl; ++} ++ ++/* Return zero if the declaration NEWDECL is valid ++ when the declaration OLDDECL (assumed to be for the same name) ++ has already been seen. ++ Otherwise return an error message format string with a %s ++ where the identifier should go. */ ++ ++static const char * ++redeclaration_error_message (tree newdecl, tree olddecl) ++{ ++ if (TREE_CODE (newdecl) == TYPE_DECL) ++ { ++ /* Because C++ can put things into name space for free, ++ constructs like "typedef struct foo { ... } foo" ++ would look like an erroneous redeclaration. */ ++ if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl))) ++ return 0; ++ else ++ return "redefinition of `%#D'"; ++ } ++ else if (TREE_CODE (newdecl) == FUNCTION_DECL) ++ { ++ /* If this is a pure function, its olddecl will actually be ++ the original initialization to `0' (which we force to call ++ abort()). Don't complain about redefinition in this case. */ ++ if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)) ++ return 0; ++ ++ /* If both functions come from different namespaces, this is not ++ a redeclaration - this is a conflict with a used function. */ ++ if (DECL_NAMESPACE_SCOPE_P (olddecl) ++ && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl) ++ && ! decls_match (olddecl, newdecl)) ++ return "`%D' conflicts with used function"; ++ ++ /* We'll complain about linkage mismatches in ++ warn_extern_redeclared_static. */ ++ ++ /* Defining the same name twice is no good. */ ++ if (DECL_INITIAL (olddecl) != NULL_TREE ++ && DECL_INITIAL (newdecl) != NULL_TREE) ++ { ++ if (DECL_NAME (olddecl) == NULL_TREE) ++ return "`%#D' not declared in class"; ++ else ++ return "redefinition of `%#D'"; ++ } ++ return 0; ++ } ++ else if (TREE_CODE (newdecl) == TEMPLATE_DECL) ++ { ++ tree nt, ot; ++ ++ if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) ++ { ++ if (COMPLETE_TYPE_P (TREE_TYPE (newdecl)) ++ && COMPLETE_TYPE_P (TREE_TYPE (olddecl))) ++ return "redefinition of `%#D'"; ++ return NULL; ++ } ++ ++ if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL ++ || (DECL_TEMPLATE_RESULT (newdecl) ++ == DECL_TEMPLATE_RESULT (olddecl))) ++ return NULL; ++ ++ nt = DECL_TEMPLATE_RESULT (newdecl); ++ if (DECL_TEMPLATE_INFO (nt)) ++ nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt)); ++ ot = DECL_TEMPLATE_RESULT (olddecl); ++ if (DECL_TEMPLATE_INFO (ot)) ++ ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot)); ++ if (DECL_INITIAL (nt) && DECL_INITIAL (ot)) ++ return "redefinition of `%#D'"; ++ ++ return NULL; ++ } ++ else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl)) ++ { ++ /* Objects declared at top level: */ ++ /* If at least one is a reference, it's ok. */ ++ if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl)) ++ return 0; ++ /* Reject two definitions. */ ++ return "redefinition of `%#D'"; ++ } ++ else ++ { ++ /* Objects declared with block scope: */ ++ /* Reject two definitions, and reject a definition ++ together with an external reference. */ ++ if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))) ++ return "redeclaration of `%#D'"; ++ return 0; ++ } ++} ++ ++/* Create a new label, named ID. */ ++ ++static tree ++make_label_decl (tree id, int local_p) ++{ ++ tree decl; ++ ++ decl = build_decl (LABEL_DECL, id, void_type_node); ++ ++ DECL_CONTEXT (decl) = current_function_decl; ++ DECL_MODE (decl) = VOIDmode; ++ C_DECLARED_LABEL_FLAG (decl) = local_p; ++ ++ /* Say where one reference is to the label, for the sake of the ++ error if it is not defined. */ ++ DECL_SOURCE_LOCATION (decl) = input_location; ++ ++ /* Record the fact that this identifier is bound to this label. */ ++ SET_IDENTIFIER_LABEL_VALUE (id, decl); ++ ++ return decl; ++} ++ ++/* Record this label on the list of used labels so that we can check ++ at the end of the function to see whether or not the label was ++ actually defined, and so we can check when the label is defined whether ++ this use is valid. */ ++ ++static void ++use_label (tree decl) ++{ ++ if (named_label_uses == NULL ++ || named_label_uses->names_in_scope != current_binding_level->names ++ || named_label_uses->label_decl != decl) ++ { ++ struct named_label_use_list *new_ent; ++ new_ent = ggc_alloc (sizeof (struct named_label_use_list)); ++ new_ent->label_decl = decl; ++ new_ent->names_in_scope = current_binding_level->names; ++ new_ent->binding_level = current_binding_level; ++ new_ent->o_goto_locus = input_location; ++ new_ent->next = named_label_uses; ++ named_label_uses = new_ent; ++ } ++} ++ ++/* Look for a label named ID in the current function. If one cannot ++ be found, create one. (We keep track of used, but undefined, ++ labels, and complain about them at the end of a function.) */ ++ ++tree ++lookup_label (tree id) ++{ ++ tree decl; ++ struct named_label_list *ent; ++ ++ timevar_push (TV_NAME_LOOKUP); ++ /* You can't use labels at global scope. */ ++ if (current_function_decl == NULL_TREE) ++ { ++ error ("label `%s' referenced outside of any function", ++ IDENTIFIER_POINTER (id)); ++ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); ++ } ++ ++ /* See if we've already got this label. */ ++ decl = IDENTIFIER_LABEL_VALUE (id); ++ if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl) ++ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); ++ ++ /* Record this label on the list of labels used in this function. ++ We do this before calling make_label_decl so that we get the ++ IDENTIFIER_LABEL_VALUE before the new label is declared. */ ++ ent = ggc_alloc_cleared (sizeof (struct named_label_list)); ++ ent->old_value = IDENTIFIER_LABEL_VALUE (id); ++ ent->next = named_labels; ++ named_labels = ent; ++ ++ /* We need a new label. */ ++ decl = make_label_decl (id, /*local_p=*/0); ++ ++ /* Now fill in the information we didn't have before. */ ++ ent->label_decl = decl; ++ ++ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); ++} ++ ++/* Declare a local label named ID. */ ++ ++tree ++declare_local_label (tree id) ++{ ++ tree decl; ++ ++ /* Add a new entry to the SHADOWED_LABELS list so that when we leave ++ this scope we can restore the old value of ++ IDENTIFIER_TYPE_VALUE. */ ++ current_binding_level->shadowed_labels ++ = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE, ++ current_binding_level->shadowed_labels); ++ /* Look for the label. */ ++ decl = make_label_decl (id, /*local_p=*/1); ++ /* Now fill in the information we didn't have before. */ ++ TREE_VALUE (current_binding_level->shadowed_labels) = decl; ++ ++ return decl; ++} ++ ++/* Returns nonzero if it is ill-formed to jump past the declaration of ++ DECL. Returns 2 if it's also a real problem. */ ++ ++static int ++decl_jump_unsafe (tree decl) ++{ ++ if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)) ++ return 0; ++ ++ if (DECL_INITIAL (decl) == NULL_TREE ++ && pod_type_p (TREE_TYPE (decl))) ++ return 0; ++ ++ /* This is really only important if we're crossing an initialization. ++ The POD stuff is just pedantry; why should it matter if the class ++ contains a field of pointer to member type? */ ++ if (DECL_INITIAL (decl) ++ || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))) ++ return 2; ++ return 1; ++} ++ ++/* Check that a single previously seen jump to a newly defined label ++ is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for ++ the jump context; NAMES are the names in scope in LEVEL at the jump ++ context; FILE and LINE are the source position of the jump or 0. */ ++ ++static void ++check_previous_goto_1 (tree decl, ++ struct cp_binding_level* level, ++ tree names, const location_t *locus) ++{ ++ int identified = 0; ++ int saw_eh = 0; ++ struct cp_binding_level *b = current_binding_level; ++ for (; b; b = b->level_chain) ++ { ++ tree new_decls = b->names; ++ tree old_decls = (b == level ? names : NULL_TREE); ++ for (; new_decls != old_decls; ++ new_decls = TREE_CHAIN (new_decls)) ++ { ++ int problem = decl_jump_unsafe (new_decls); ++ if (! problem) ++ continue; ++ ++ if (! identified) ++ { ++ if (decl) ++ pedwarn ("jump to label `%D'", decl); ++ else ++ pedwarn ("jump to case label"); ++ ++ if (locus) ++ pedwarn ("%H from here", locus); ++ identified = 1; ++ } ++ ++ if (problem > 1) ++ cp_error_at (" crosses initialization of `%#D'", ++ new_decls); ++ else ++ cp_pedwarn_at (" enters scope of non-POD `%#D'", ++ new_decls); ++ } ++ ++ if (b == level) ++ break; ++ if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh) ++ { ++ if (! identified) ++ { ++ if (decl) ++ pedwarn ("jump to label `%D'", decl); ++ else ++ pedwarn ("jump to case label"); ++ ++ if (locus) ++ pedwarn ("%H from here", locus); ++ identified = 1; ++ } ++ if (b->kind == sk_try) ++ error (" enters try block"); ++ else ++ error (" enters catch block"); ++ saw_eh = 1; ++ } ++ } ++} ++ ++static void ++check_previous_goto (struct named_label_use_list* use) ++{ ++ check_previous_goto_1 (use->label_decl, use->binding_level, ++ use->names_in_scope, &use->o_goto_locus); ++} ++ ++static void ++check_switch_goto (struct cp_binding_level* level) ++{ ++ check_previous_goto_1 (NULL_TREE, level, level->names, NULL); ++} ++ ++/* Check that any previously seen jumps to a newly defined label DECL ++ are OK. Called by define_label. */ ++ ++static void ++check_previous_gotos (tree decl) ++{ ++ struct named_label_use_list **usep; ++ ++ if (! TREE_USED (decl)) ++ return; ++ ++ for (usep = &named_label_uses; *usep; ) ++ { ++ struct named_label_use_list *use = *usep; ++ if (use->label_decl == decl) ++ { ++ check_previous_goto (use); ++ *usep = use->next; ++ } ++ else ++ usep = &(use->next); ++ } ++} ++ ++/* Check that a new jump to a label DECL is OK. Called by ++ finish_goto_stmt. */ ++ ++void ++check_goto (tree decl) ++{ ++ int identified = 0; ++ tree bad; ++ struct named_label_list *lab; ++ ++ /* We can't know where a computed goto is jumping. So we assume ++ that it's OK. */ ++ if (! DECL_P (decl)) ++ return; ++ ++ /* If the label hasn't been defined yet, defer checking. */ ++ if (! DECL_INITIAL (decl)) ++ { ++ use_label (decl); ++ return; ++ } ++ ++ for (lab = named_labels; lab; lab = lab->next) ++ if (decl == lab->label_decl) ++ break; ++ ++ /* If the label is not on named_labels it's a gcc local label, so ++ it must be in an outer scope, so jumping to it is always OK. */ ++ if (lab == 0) ++ return; ++ ++ if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls) ++ && !identified) ++ { ++ cp_pedwarn_at ("jump to label `%D'", decl); ++ pedwarn (" from here"); ++ identified = 1; ++ } ++ ++ for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad)) ++ { ++ tree b = TREE_VALUE (bad); ++ int u = decl_jump_unsafe (b); ++ ++ if (u > 1 && DECL_ARTIFICIAL (b)) ++ /* Can't skip init of __exception_info. */ ++ error ("%J enters catch block", b); ++ else if (u > 1) ++ cp_error_at (" skips initialization of `%#D'", b); ++ else ++ cp_pedwarn_at (" enters scope of non-POD `%#D'", b); ++ } ++ ++ if (lab->in_try_scope) ++ error (" enters try block"); ++ else if (lab->in_catch_scope) ++ error (" enters catch block"); ++} ++ ++/* Define a label, specifying the location in the source file. ++ Return the LABEL_DECL node for the label. */ ++ ++tree ++define_label (location_t location, tree name) ++{ ++ tree decl = lookup_label (name); ++ struct named_label_list *ent; ++ struct cp_binding_level *p; ++ ++ timevar_push (TV_NAME_LOOKUP); ++ for (ent = named_labels; ent; ent = ent->next) ++ if (ent->label_decl == decl) ++ break; ++ ++ /* After labels, make any new cleanups in the function go into their ++ own new (temporary) binding contour. */ ++ for (p = current_binding_level; ++ p->kind != sk_function_parms; ++ p = p->level_chain) ++ p->more_cleanups_ok = 0; ++ ++ if (name == get_identifier ("wchar_t")) ++ pedwarn ("label named wchar_t"); ++ ++ if (DECL_INITIAL (decl) != NULL_TREE) ++ error ("duplicate label `%D'", decl); ++ else ++ { ++ /* Mark label as having been defined. */ ++ DECL_INITIAL (decl) = error_mark_node; ++ /* Say where in the source. */ ++ DECL_SOURCE_LOCATION (decl) = location; ++ if (ent) ++ { ++ ent->names_in_scope = current_binding_level->names; ++ ent->binding_level = current_binding_level; ++ } ++ check_previous_gotos (decl); ++ } ++ ++ timevar_pop (TV_NAME_LOOKUP); ++ return decl; ++} ++ ++struct cp_switch ++{ ++ struct cp_binding_level *level; ++ struct cp_switch *next; ++ /* The SWITCH_STMT being built. */ ++ tree switch_stmt; ++ /* A splay-tree mapping the low element of a case range to the high ++ element, or NULL_TREE if there is no high element. Used to ++ determine whether or not a new case label duplicates an old case ++ label. We need a tree, rather than simply a hash table, because ++ of the GNU case range extension. */ ++ splay_tree cases; ++}; ++ ++/* A stack of the currently active switch statements. The innermost ++ switch statement is on the top of the stack. There is no need to ++ mark the stack for garbage collection because it is only active ++ during the processing of the body of a function, and we never ++ collect at that point. */ ++ ++static struct cp_switch *switch_stack; ++ ++/* Called right after a switch-statement condition is parsed. ++ SWITCH_STMT is the switch statement being parsed. */ ++ ++void ++push_switch (tree switch_stmt) ++{ ++ struct cp_switch *p = xmalloc (sizeof (struct cp_switch)); ++ p->level = current_binding_level; ++ p->next = switch_stack; ++ p->switch_stmt = switch_stmt; ++ p->cases = splay_tree_new (case_compare, NULL, NULL); ++ switch_stack = p; ++} ++ ++void ++pop_switch (void) ++{ ++ struct cp_switch *cs; ++ ++ cs = switch_stack; ++ splay_tree_delete (cs->cases); ++ switch_stack = switch_stack->next; ++ free (cs); ++} ++ ++/* Note that we've seen a definition of a case label, and complain if this ++ is a bad place for one. */ ++ ++tree ++finish_case_label (tree low_value, tree high_value) ++{ ++ tree cond, r; ++ struct cp_binding_level *p; ++ ++ if (processing_template_decl) ++ { ++ tree label; ++ ++ /* For templates, just add the case label; we'll do semantic ++ analysis at instantiation-time. */ ++ label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); ++ return add_stmt (build_case_label (low_value, high_value, label)); ++ } ++ ++ /* Find the condition on which this switch statement depends. */ ++ cond = SWITCH_COND (switch_stack->switch_stmt); ++ if (cond && TREE_CODE (cond) == TREE_LIST) ++ cond = TREE_VALUE (cond); ++ ++ r = c_add_case_label (switch_stack->cases, cond, low_value, high_value); ++ ++ check_switch_goto (switch_stack->level); ++ ++ /* After labels, make any new cleanups in the function go into their ++ own new (temporary) binding contour. */ ++ for (p = current_binding_level; ++ p->kind != sk_function_parms; ++ p = p->level_chain) ++ p->more_cleanups_ok = 0; ++ ++ return r; ++} ++ ++/* Hash a TYPENAME_TYPE. K is really of type `tree'. */ ++ ++static hashval_t ++typename_hash (const void* k) ++{ ++ hashval_t hash; ++ tree t = (tree) k; ++ ++ hash = (htab_hash_pointer (TYPE_CONTEXT (t)) ++ ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t)))); ++ ++ return hash; ++} ++ ++/* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */ ++ ++static int ++typename_compare (const void * k1, const void * k2) ++{ ++ tree t1; ++ tree t2; ++ tree d1; ++ tree d2; ++ ++ t1 = (tree) k1; ++ t2 = (tree) k2; ++ d1 = TYPE_NAME (t1); ++ d2 = TYPE_NAME (t2); ++ ++ return (DECL_NAME (d1) == DECL_NAME (d2) ++ && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2) ++ && ((TREE_TYPE (t1) != NULL_TREE) ++ == (TREE_TYPE (t2) != NULL_TREE)) ++ && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)) ++ && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2)); ++} ++ ++/* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is ++ the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE ++ is non-NULL, this type is being created by the implicit typename ++ extension, and BASE_TYPE is a type named `t' in some base class of ++ `T' which depends on template parameters. ++ ++ Returns the new TYPENAME_TYPE. */ ++ ++static GTY ((param_is (union tree_node))) htab_t typename_htab; ++ ++static tree ++build_typename_type (tree context, tree name, tree fullname) ++{ ++ tree t; ++ tree d; ++ void **e; ++ ++ if (typename_htab == NULL) ++ { ++ typename_htab = htab_create_ggc (61, &typename_hash, ++ &typename_compare, NULL); ++ } ++ ++ /* Build the TYPENAME_TYPE. */ ++ t = make_aggr_type (TYPENAME_TYPE); ++ TYPE_CONTEXT (t) = FROB_CONTEXT (context); ++ TYPENAME_TYPE_FULLNAME (t) = fullname; ++ ++ /* Build the corresponding TYPE_DECL. */ ++ d = build_decl (TYPE_DECL, name, t); ++ TYPE_NAME (TREE_TYPE (d)) = d; ++ TYPE_STUB_DECL (TREE_TYPE (d)) = d; ++ DECL_CONTEXT (d) = FROB_CONTEXT (context); ++ DECL_ARTIFICIAL (d) = 1; ++ ++ /* See if we already have this type. */ ++ e = htab_find_slot (typename_htab, t, INSERT); ++ if (*e) ++ t = (tree) *e; ++ else ++ *e = t; ++ ++ return t; ++} ++ ++/* Resolve `typename CONTEXT::NAME'. Returns an appropriate type, ++ unless an error occurs, in which case error_mark_node is returned. ++ If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is ++ set, we return that, rather than the _TYPE it corresponds to, in ++ other cases we look through the type decl. If TF_ERROR is set, ++ complain about errors, otherwise be quiet. */ ++ ++tree ++make_typename_type (tree context, tree name, tsubst_flags_t complain) ++{ ++ tree fullname; ++ ++ if (name == error_mark_node ++ || context == NULL_TREE ++ || context == error_mark_node) ++ return error_mark_node; ++ ++ if (TYPE_P (name)) ++ { ++ if (!(TYPE_LANG_SPECIFIC (name) ++ && (CLASSTYPE_IS_TEMPLATE (name) ++ || CLASSTYPE_USE_TEMPLATE (name)))) ++ name = TYPE_IDENTIFIER (name); ++ else ++ /* Create a TEMPLATE_ID_EXPR for the type. */ ++ name = build_nt (TEMPLATE_ID_EXPR, ++ CLASSTYPE_TI_TEMPLATE (name), ++ CLASSTYPE_TI_ARGS (name)); ++ } ++ else if (TREE_CODE (name) == TYPE_DECL) ++ name = DECL_NAME (name); ++ ++ fullname = name; ++ ++ if (TREE_CODE (name) == TEMPLATE_ID_EXPR) ++ { ++ name = TREE_OPERAND (name, 0); ++ if (TREE_CODE (name) == TEMPLATE_DECL) ++ name = TREE_OPERAND (fullname, 0) = DECL_NAME (name); ++ } ++ if (TREE_CODE (name) == TEMPLATE_DECL) ++ { ++ error ("`%D' used without template parameters", name); ++ return error_mark_node; ++ } ++ my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030802); ++ ++ if (TREE_CODE (context) == NAMESPACE_DECL) ++ { ++ /* We can get here from typename_sub0 in the explicit_template_type ++ expansion. Just fail. */ ++ if (complain & tf_error) ++ error ("no class template named `%#T' in `%#T'", ++ name, context); ++ return error_mark_node; ++ } ++ ++ if (!dependent_type_p (context) ++ || currently_open_class (context)) ++ { ++ if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR) ++ { ++ tree tmpl = NULL_TREE; ++ if (IS_AGGR_TYPE (context)) ++ tmpl = lookup_field (context, name, 0, false); ++ if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) ++ { ++ if (complain & tf_error) ++ error ("no class template named `%#T' in `%#T'", ++ name, context); ++ return error_mark_node; ++ } ++ ++ if (complain & tf_error) ++ perform_or_defer_access_check (TYPE_BINFO (context), tmpl); ++ ++ return lookup_template_class (tmpl, ++ TREE_OPERAND (fullname, 1), ++ NULL_TREE, context, ++ /*entering_scope=*/0, ++ tf_error | tf_warning | tf_user); ++ } ++ else ++ { ++ tree t; ++ ++ if (!IS_AGGR_TYPE (context)) ++ { ++ if (complain & tf_error) ++ error ("no type named `%#T' in `%#T'", name, context); ++ return error_mark_node; ++ } ++ ++ t = lookup_field (context, name, 0, true); ++ if (t) ++ { ++ if (TREE_CODE (t) != TYPE_DECL) ++ { ++ if (complain & tf_error) ++ error ("no type named `%#T' in `%#T'", name, context); ++ return error_mark_node; ++ } ++ ++ if (complain & tf_error) ++ perform_or_defer_access_check (TYPE_BINFO (context), t); ++ ++ if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl)) ++ t = TREE_TYPE (t); ++ ++ return t; ++ } ++ } ++ } ++ ++ /* If the CONTEXT is not a template type, then either the field is ++ there now or its never going to be. */ ++ if (!dependent_type_p (context)) ++ { ++ if (complain & tf_error) ++ error ("no type named `%#T' in `%#T'", name, context); ++ return error_mark_node; ++ } ++ ++ return build_typename_type (context, name, fullname); ++} ++ ++/* Resolve `CONTEXT::template NAME'. Returns an appropriate type, ++ unless an error occurs, in which case error_mark_node is returned. ++ If we locate a TYPE_DECL, we return that, rather than the _TYPE it ++ corresponds to. If COMPLAIN zero, don't complain about any errors ++ that occur. */ ++ ++tree ++make_unbound_class_template (tree context, tree name, tsubst_flags_t complain) ++{ ++ tree t; ++ tree d; ++ ++ if (TYPE_P (name)) ++ name = TYPE_IDENTIFIER (name); ++ else if (DECL_P (name)) ++ name = DECL_NAME (name); ++ if (TREE_CODE (name) != IDENTIFIER_NODE) ++ abort (); ++ ++ if (!dependent_type_p (context) ++ || currently_open_class (context)) ++ { ++ tree tmpl = NULL_TREE; ++ ++ if (IS_AGGR_TYPE (context)) ++ tmpl = lookup_field (context, name, 0, false); ++ ++ if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) ++ { ++ if (complain & tf_error) ++ error ("no class template named `%#T' in `%#T'", name, context); ++ return error_mark_node; ++ } ++ ++ if (complain & tf_error) ++ perform_or_defer_access_check (TYPE_BINFO (context), tmpl); ++ ++ return tmpl; ++ } ++ ++ /* Build the UNBOUND_CLASS_TEMPLATE. */ ++ t = make_aggr_type (UNBOUND_CLASS_TEMPLATE); ++ TYPE_CONTEXT (t) = FROB_CONTEXT (context); ++ TREE_TYPE (t) = NULL_TREE; ++ ++ /* Build the corresponding TEMPLATE_DECL. */ ++ d = build_decl (TEMPLATE_DECL, name, t); ++ TYPE_NAME (TREE_TYPE (d)) = d; ++ TYPE_STUB_DECL (TREE_TYPE (d)) = d; ++ DECL_CONTEXT (d) = FROB_CONTEXT (context); ++ DECL_ARTIFICIAL (d) = 1; ++ ++ return t; ++} ++ ++ ++ ++/* A chain of TYPE_DECLs for the builtin types. */ ++ ++static GTY(()) tree builtin_type_decls; ++ ++/* Return a chain of TYPE_DECLs for the builtin types. */ ++ ++tree ++cxx_builtin_type_decls (void) ++{ ++ return builtin_type_decls; ++} ++ ++/* Push the declarations of builtin types into the namespace. ++ RID_INDEX is the index of the builtin type in the array ++ RID_POINTERS. NAME is the name used when looking up the builtin ++ type. TYPE is the _TYPE node for the builtin type. */ ++ ++void ++record_builtin_type (enum rid rid_index, ++ const char* name, ++ tree type) ++{ ++ tree rname = NULL_TREE, tname = NULL_TREE; ++ tree tdecl = NULL_TREE; ++ ++ if ((int) rid_index < (int) RID_MAX) ++ rname = ridpointers[(int) rid_index]; ++ if (name) ++ tname = get_identifier (name); ++ ++ /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be ++ eliminated. Built-in types should not be looked up name; their ++ names are keywords that the parser can recognize. However, there ++ is code in c-common.c that uses identifier_global_value to look ++ up built-in types by name. */ ++ if (tname) ++ { ++ tdecl = build_decl (TYPE_DECL, tname, type); ++ DECL_ARTIFICIAL (tdecl) = 1; ++ SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl); ++ } ++ if (rname) ++ { ++ if (!tdecl) ++ { ++ tdecl = build_decl (TYPE_DECL, rname, type); ++ DECL_ARTIFICIAL (tdecl) = 1; ++ } ++ SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl); ++ } ++ ++ if (!TYPE_NAME (type)) ++ TYPE_NAME (type) = tdecl; ++ ++ if (tdecl) ++ { ++ TREE_CHAIN (tdecl) = builtin_type_decls; ++ builtin_type_decls = tdecl; ++ } ++} ++ ++/* Record one of the standard Java types. ++ * Declare it as having the given NAME. ++ * If SIZE > 0, it is the size of one of the integral types; ++ * otherwise it is the negative of the size of one of the other types. */ ++ ++static tree ++record_builtin_java_type (const char* name, int size) ++{ ++ tree type, decl; ++ if (size > 0) ++ type = make_signed_type (size); ++ else if (size > -32) ++ { /* "__java_char" or ""__java_boolean". */ ++ type = make_unsigned_type (-size); ++ /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/ ++ } ++ else ++ { /* "__java_float" or ""__java_double". */ ++ type = make_node (REAL_TYPE); ++ TYPE_PRECISION (type) = - size; ++ layout_type (type); ++ } ++ record_builtin_type (RID_MAX, name, type); ++ decl = TYPE_NAME (type); ++ ++ /* Suppress generate debug symbol entries for these types, ++ since for normal C++ they are just clutter. ++ However, push_lang_context undoes this if extern "Java" is seen. */ ++ DECL_IGNORED_P (decl) = 1; ++ ++ TYPE_FOR_JAVA (type) = 1; ++ return type; ++} ++ ++/* Push a type into the namespace so that the back-ends ignore it. */ ++ ++static void ++record_unknown_type (tree type, const char* name) ++{ ++ tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type)); ++ /* Make sure the "unknown type" typedecl gets ignored for debug info. */ ++ DECL_IGNORED_P (decl) = 1; ++ TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; ++ TYPE_SIZE (type) = TYPE_SIZE (void_type_node); ++ TYPE_ALIGN (type) = 1; ++ TYPE_USER_ALIGN (type) = 0; ++ TYPE_MODE (type) = TYPE_MODE (void_type_node); ++} ++ ++/* An string for which we should create an IDENTIFIER_NODE at ++ startup. */ ++ ++typedef struct predefined_identifier ++{ ++ /* The name of the identifier. */ ++ const char *const name; ++ /* The place where the IDENTIFIER_NODE should be stored. */ ++ tree *const node; ++ /* Nonzero if this is the name of a constructor or destructor. */ ++ const int ctor_or_dtor_p; ++} predefined_identifier; ++ ++/* Create all the predefined identifiers. */ ++ ++static void ++initialize_predefined_identifiers (void) ++{ ++ const predefined_identifier *pid; ++ ++ /* A table of identifiers to create at startup. */ ++ static const predefined_identifier predefined_identifiers[] = { ++ { "C++", &lang_name_cplusplus, 0 }, ++ { "C", &lang_name_c, 0 }, ++ { "Java", &lang_name_java, 0 }, ++ { CTOR_NAME, &ctor_identifier, 1 }, ++ { "__base_ctor", &base_ctor_identifier, 1 }, ++ { "__comp_ctor", &complete_ctor_identifier, 1 }, ++ { DTOR_NAME, &dtor_identifier, 1 }, ++ { "__comp_dtor", &complete_dtor_identifier, 1 }, ++ { "__base_dtor", &base_dtor_identifier, 1 }, ++ { "__deleting_dtor", &deleting_dtor_identifier, 1 }, ++ { IN_CHARGE_NAME, &in_charge_identifier, 0 }, ++ { "nelts", &nelts_identifier, 0 }, ++ { THIS_NAME, &this_identifier, 0 }, ++ { VTABLE_DELTA_NAME, &delta_identifier, 0 }, ++ { VTABLE_PFN_NAME, &pfn_identifier, 0 }, ++ { "_vptr", &vptr_identifier, 0 }, ++ { "__vtt_parm", &vtt_parm_identifier, 0 }, ++ { "::", &global_scope_name, 0 }, ++ { "std", &std_identifier, 0 }, ++ { NULL, NULL, 0 } ++ }; ++ ++ for (pid = predefined_identifiers; pid->name; ++pid) ++ { ++ *pid->node = get_identifier (pid->name); ++ if (pid->ctor_or_dtor_p) ++ IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1; ++ } ++} ++ ++/* Create the predefined scalar types of C, ++ and some nodes representing standard constants (0, 1, (void *)0). ++ Initialize the global binding level. ++ Make definitions for built-in primitive functions. */ ++ ++void ++cxx_init_decl_processing (void) ++{ ++ tree void_ftype; ++ tree void_ftype_ptr; ++ ++ /* Create all the identifiers we need. */ ++ initialize_predefined_identifiers (); ++ ++ /* Fill in back-end hooks. */ ++ lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p; ++ ++ /* Create the global variables. */ ++ push_to_top_level (); ++ ++ current_function_decl = NULL_TREE; ++ current_binding_level = NULL; ++ /* Enter the global namespace. */ ++ my_friendly_assert (global_namespace == NULL_TREE, 375); ++ global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name, ++ void_type_node); ++ begin_scope (sk_namespace, global_namespace); ++ ++ current_lang_name = NULL_TREE; ++ ++ /* Adjust various flags based on command-line settings. */ ++ if (!flag_permissive) ++ flag_pedantic_errors = 1; ++ if (!flag_no_inline) ++ { ++ flag_inline_trees = 1; ++ flag_no_inline = 1; ++ } ++ if (flag_inline_functions) ++ { ++ flag_inline_trees = 2; ++ flag_inline_functions = 0; ++ } ++ ++ /* Force minimum function alignment if using the least significant ++ bit of function pointers to store the virtual bit. */ ++ if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn ++ && force_align_functions_log < 1) ++ force_align_functions_log = 1; ++ ++ /* Initially, C. */ ++ current_lang_name = lang_name_c; ++ ++ build_common_tree_nodes (flag_signed_char); ++ ++ error_mark_list = build_tree_list (error_mark_node, error_mark_node); ++ TREE_TYPE (error_mark_list) = error_mark_node; ++ ++ /* Create the `std' namespace. */ ++ push_namespace (std_identifier); ++ std_node = current_namespace; ++ pop_namespace (); ++ ++ c_common_nodes_and_builtins (); ++ ++ java_byte_type_node = record_builtin_java_type ("__java_byte", 8); ++ java_short_type_node = record_builtin_java_type ("__java_short", 16); ++ java_int_type_node = record_builtin_java_type ("__java_int", 32); ++ java_long_type_node = record_builtin_java_type ("__java_long", 64); ++ java_float_type_node = record_builtin_java_type ("__java_float", -32); ++ java_double_type_node = record_builtin_java_type ("__java_double", -64); ++ java_char_type_node = record_builtin_java_type ("__java_char", -16); ++ java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1); ++ ++ integer_two_node = build_int_2 (2, 0); ++ TREE_TYPE (integer_two_node) = integer_type_node; ++ integer_three_node = build_int_2 (3, 0); ++ TREE_TYPE (integer_three_node) = integer_type_node; ++ ++ record_builtin_type (RID_BOOL, "bool", boolean_type_node); ++ truthvalue_type_node = boolean_type_node; ++ truthvalue_false_node = boolean_false_node; ++ truthvalue_true_node = boolean_true_node; ++ ++ empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE); ++ ++#if 0 ++ record_builtin_type (RID_MAX, NULL, string_type_node); ++#endif ++ ++ delta_type_node = ptrdiff_type_node; ++ vtable_index_type = ptrdiff_type_node; ++ ++ vtt_parm_type = build_pointer_type (const_ptr_type_node); ++ void_ftype = build_function_type (void_type_node, void_list_node); ++ void_ftype_ptr = build_function_type (void_type_node, ++ tree_cons (NULL_TREE, ++ ptr_type_node, ++ void_list_node)); ++ void_ftype_ptr ++ = build_exception_variant (void_ftype_ptr, empty_except_spec); ++ ++ /* C++ extensions */ ++ ++ unknown_type_node = make_node (UNKNOWN_TYPE); ++ record_unknown_type (unknown_type_node, "unknown type"); ++ ++ /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */ ++ TREE_TYPE (unknown_type_node) = unknown_type_node; ++ ++ /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same ++ result. */ ++ TYPE_POINTER_TO (unknown_type_node) = unknown_type_node; ++ TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node; ++ ++ { ++ /* Make sure we get a unique function type, so we can give ++ its pointer type a name. (This wins for gdb.) */ ++ tree vfunc_type = make_node (FUNCTION_TYPE); ++ TREE_TYPE (vfunc_type) = integer_type_node; ++ TYPE_ARG_TYPES (vfunc_type) = NULL_TREE; ++ layout_type (vfunc_type); ++ ++ vtable_entry_type = build_pointer_type (vfunc_type); ++ } ++ record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type); ++ ++ vtbl_type_node ++ = build_cplus_array_type (vtable_entry_type, NULL_TREE); ++ layout_type (vtbl_type_node); ++ vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST); ++ record_builtin_type (RID_MAX, NULL, vtbl_type_node); ++ vtbl_ptr_type_node = build_pointer_type (vtable_entry_type); ++ layout_type (vtbl_ptr_type_node); ++ record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node); ++ ++ push_namespace (get_identifier ("__cxxabiv1")); ++ abi_node = current_namespace; ++ pop_namespace (); ++ ++ global_type_node = make_node (LANG_TYPE); ++ record_unknown_type (global_type_node, "global type"); ++ ++ /* Now, C++. */ ++ current_lang_name = lang_name_cplusplus; ++ ++ { ++ tree bad_alloc_id; ++ tree bad_alloc_type_node; ++ tree bad_alloc_decl; ++ tree newtype, deltype; ++ tree ptr_ftype_sizetype; ++ ++ push_namespace (std_identifier); ++ bad_alloc_id = get_identifier ("bad_alloc"); ++ bad_alloc_type_node = make_aggr_type (RECORD_TYPE); ++ TYPE_CONTEXT (bad_alloc_type_node) = current_namespace; ++ bad_alloc_decl ++ = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node); ++ DECL_CONTEXT (bad_alloc_decl) = current_namespace; ++ TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl; ++ pop_namespace (); ++ ++ ptr_ftype_sizetype ++ = build_function_type (ptr_type_node, ++ tree_cons (NULL_TREE, ++ size_type_node, ++ void_list_node)); ++ newtype = build_exception_variant ++ (ptr_ftype_sizetype, add_exception_specifier ++ (NULL_TREE, bad_alloc_type_node, -1)); ++ deltype = build_exception_variant (void_ftype_ptr, empty_except_spec); ++ push_cp_library_fn (NEW_EXPR, newtype); ++ push_cp_library_fn (VEC_NEW_EXPR, newtype); ++ global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype); ++ push_cp_library_fn (VEC_DELETE_EXPR, deltype); ++ } ++ ++ abort_fndecl ++ = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype); ++ ++ /* Perform other language dependent initializations. */ ++ init_class_processing (); ++ init_search_processing (); ++ init_rtti_processing (); ++ ++ if (flag_exceptions) ++ init_exception_processing (); ++ ++ if (! supports_one_only ()) ++ flag_weak = 0; ++ ++ make_fname_decl = cp_make_fname_decl; ++ start_fname_decls (); ++ ++ /* Show we use EH for cleanups. */ ++ using_eh_for_cleanups (); ++ ++ /* Maintain consistency. Perhaps we should just complain if they ++ say -fwritable-strings? */ ++ if (flag_writable_strings) ++ flag_const_strings = 0; ++} ++ ++/* Generate an initializer for a function naming variable from ++ NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is ++ filled in with the type of the init. */ ++ ++tree ++cp_fname_init (const char* name, tree *type_p) ++{ ++ tree domain = NULL_TREE; ++ tree type; ++ tree init = NULL_TREE; ++ size_t length = 0; ++ ++ if (name) ++ { ++ length = strlen (name); ++ domain = build_index_type (size_int (length)); ++ init = build_string (length + 1, name); ++ } ++ ++ type = build_qualified_type (char_type_node, TYPE_QUAL_CONST); ++ type = build_cplus_array_type (type, domain); ++ ++ *type_p = type; ++ ++ if (init) ++ TREE_TYPE (init) = type; ++ else ++ init = error_mark_node; ++ ++ return init; ++} ++ ++/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the ++ decl, NAME is the initialization string and TYPE_DEP indicates whether ++ NAME depended on the type of the function. We make use of that to detect ++ __PRETTY_FUNCTION__ inside a template fn. This is being done ++ lazily at the point of first use, so we musn't push the decl now. */ ++ ++static tree ++cp_make_fname_decl (tree id, int type_dep) ++{ ++ const char *const name = (type_dep && processing_template_decl ++ ? NULL : fname_as_string (type_dep)); ++ tree type; ++ tree init = cp_fname_init (name, &type); ++ tree decl = build_decl (VAR_DECL, id, type); ++ ++ /* As we're using pushdecl_with_scope, we must set the context. */ ++ DECL_CONTEXT (decl) = current_function_decl; ++ DECL_PRETTY_FUNCTION_P (decl) = type_dep; ++ ++ TREE_STATIC (decl) = 1; ++ TREE_READONLY (decl) = 1; ++ DECL_ARTIFICIAL (decl) = 1; ++ DECL_INITIAL (decl) = init; ++ ++ TREE_USED (decl) = 1; ++ ++ if (current_function_decl) ++ { ++ struct cp_binding_level *b = current_binding_level; ++ while (b->level_chain->kind != sk_function_parms) ++ b = b->level_chain; ++ pushdecl_with_scope (decl, b); ++ cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING); ++ } ++ else ++ pushdecl_top_level_and_finish (decl, init); ++ ++ return decl; ++} ++ ++/* Make a definition for a builtin function named NAME in the current ++ namespace, whose data type is TYPE and whose context is CONTEXT. ++ TYPE should be a function type with argument types. ++ ++ CLASS and CODE tell later passes how to compile calls to this function. ++ See tree.h for possible values. ++ ++ If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, ++ the name to be called if we can't opencode the function. ++ If ATTRS is nonzero, use that for the function's attribute ++ list. */ ++ ++static tree ++builtin_function_1 (const char* name, ++ tree type, ++ tree context, ++ int code, ++ enum built_in_class class, ++ const char* libname, ++ tree attrs) ++{ ++ tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type); ++ DECL_BUILT_IN_CLASS (decl) = class; ++ DECL_FUNCTION_CODE (decl) = code; ++ DECL_CONTEXT (decl) = context; ++ ++ pushdecl (decl); ++ ++ /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME, ++ we cannot change DECL_ASSEMBLER_NAME until we have installed this ++ function in the namespace. */ ++ if (libname) ++ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname)); ++ make_decl_rtl (decl, NULL); ++ ++ /* Warn if a function in the namespace for users ++ is used without an occasion to consider it declared. */ ++ if (name[0] != '_' || name[1] != '_') ++ DECL_ANTICIPATED (decl) = 1; ++ ++ /* Possibly apply some default attributes to this built-in function. */ ++ if (attrs) ++ decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); ++ else ++ decl_attributes (&decl, NULL_TREE, 0); ++ ++ return decl; ++} ++ ++/* Entry point for the benefit of c_common_nodes_and_builtins. ++ ++ Make a definition for a builtin function named NAME and whose data type ++ is TYPE. TYPE should be a function type with argument types. This ++ function places the anticipated declaration in the global namespace ++ and additionally in the std namespace if appropriate. ++ ++ CLASS and CODE tell later passes how to compile calls to this function. ++ See tree.h for possible values. ++ ++ If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, ++ the name to be called if we can't opencode the function. ++ ++ If ATTRS is nonzero, use that for the function's attribute ++ list. */ ++ ++tree ++builtin_function (const char* name, ++ tree type, ++ int code, ++ enum built_in_class class, ++ const char* libname, ++ tree attrs) ++{ ++ /* All builtins that don't begin with an '_' should additionally ++ go in the 'std' namespace. */ ++ if (name[0] != '_') ++ { ++ push_namespace (std_identifier); ++ builtin_function_1 (name, type, std_node, code, class, libname, attrs); ++ pop_namespace (); ++ } ++ ++ return builtin_function_1 (name, type, NULL_TREE, code, ++ class, libname, attrs); ++} ++ ++/* Generate a FUNCTION_DECL with the typical flags for a runtime library ++ function. Not called directly. */ ++ ++static tree ++build_library_fn_1 (tree name, enum tree_code operator_code, tree type) ++{ ++ tree fn = build_lang_decl (FUNCTION_DECL, name, type); ++ DECL_EXTERNAL (fn) = 1; ++ TREE_PUBLIC (fn) = 1; ++ DECL_ARTIFICIAL (fn) = 1; ++ TREE_NOTHROW (fn) = 1; ++ SET_OVERLOADED_OPERATOR_CODE (fn, operator_code); ++ SET_DECL_LANGUAGE (fn, lang_c); ++ return fn; ++} ++ ++/* Returns the _DECL for a library function with C linkage. ++ We assume that such functions never throw; if this is incorrect, ++ callers should unset TREE_NOTHROW. */ ++ ++tree ++build_library_fn (tree name, tree type) ++{ ++ return build_library_fn_1 (name, ERROR_MARK, type); ++} ++ ++/* Returns the _DECL for a library function with C++ linkage. */ ++ ++static tree ++build_cp_library_fn (tree name, enum tree_code operator_code, tree type) ++{ ++ tree fn = build_library_fn_1 (name, operator_code, type); ++ TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type); ++ DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace); ++ SET_DECL_LANGUAGE (fn, lang_cplusplus); ++ set_mangled_name_for_decl (fn); ++ return fn; ++} ++ ++/* Like build_library_fn, but takes a C string instead of an ++ IDENTIFIER_NODE. */ ++ ++tree ++build_library_fn_ptr (const char* name, tree type) ++{ ++ return build_library_fn (get_identifier (name), type); ++} ++ ++/* Like build_cp_library_fn, but takes a C string instead of an ++ IDENTIFIER_NODE. */ ++ ++tree ++build_cp_library_fn_ptr (const char* name, tree type) ++{ ++ return build_cp_library_fn (get_identifier (name), ERROR_MARK, type); ++} ++ ++/* Like build_library_fn, but also pushes the function so that we will ++ be able to find it via IDENTIFIER_GLOBAL_VALUE. */ ++ ++tree ++push_library_fn (tree name, tree type) ++{ ++ tree fn = build_library_fn (name, type); ++ pushdecl_top_level (fn); ++ return fn; ++} ++ ++/* Like build_cp_library_fn, but also pushes the function so that it ++ will be found by normal lookup. */ ++ ++static tree ++push_cp_library_fn (enum tree_code operator_code, tree type) ++{ ++ tree fn = build_cp_library_fn (ansi_opname (operator_code), ++ operator_code, ++ type); ++ pushdecl (fn); ++ return fn; ++} ++ ++/* Like push_library_fn, but takes a TREE_LIST of parm types rather than ++ a FUNCTION_TYPE. */ ++ ++tree ++push_void_library_fn (tree name, tree parmtypes) ++{ ++ tree type = build_function_type (void_type_node, parmtypes); ++ return push_library_fn (name, type); ++} ++ ++/* Like push_library_fn, but also note that this function throws ++ and does not return. Used for __throw_foo and the like. */ ++ ++tree ++push_throw_library_fn (tree name, tree type) ++{ ++ tree fn = push_library_fn (name, type); ++ TREE_THIS_VOLATILE (fn) = 1; ++ TREE_NOTHROW (fn) = 0; ++ return fn; ++} ++ ++/* When we call finish_struct for an anonymous union, we create ++ default copy constructors and such. But, an anonymous union ++ shouldn't have such things; this function undoes the damage to the ++ anonymous union type T. ++ ++ (The reason that we create the synthesized methods is that we don't ++ distinguish `union { int i; }' from `typedef union { int i; } U'. ++ The first is an anonymous union; the second is just an ordinary ++ union type.) */ ++ ++void ++fixup_anonymous_aggr (tree t) ++{ ++ tree *q; ++ ++ /* Wipe out memory of synthesized methods. */ ++ TYPE_HAS_CONSTRUCTOR (t) = 0; ++ TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0; ++ TYPE_HAS_INIT_REF (t) = 0; ++ TYPE_HAS_CONST_INIT_REF (t) = 0; ++ TYPE_HAS_ASSIGN_REF (t) = 0; ++ TYPE_HAS_CONST_ASSIGN_REF (t) = 0; ++ ++ /* Splice the implicitly generated functions out of the TYPE_METHODS ++ list. */ ++ q = &TYPE_METHODS (t); ++ while (*q) ++ { ++ if (DECL_ARTIFICIAL (*q)) ++ *q = TREE_CHAIN (*q); ++ else ++ q = &TREE_CHAIN (*q); ++ } ++ ++ /* ISO C++ 9.5.3. Anonymous unions may not have function members. */ ++ if (TYPE_METHODS (t)) ++ error ("%Jan anonymous union cannot have function members", ++ TYPE_MAIN_DECL (t)); ++ ++ /* Anonymous aggregates cannot have fields with ctors, dtors or complex ++ assignment operators (because they cannot have these methods themselves). ++ For anonymous unions this is already checked because they are not allowed ++ in any union, otherwise we have to check it. */ ++ if (TREE_CODE (t) != UNION_TYPE) ++ { ++ tree field, type; ++ ++ for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) ++ if (TREE_CODE (field) == FIELD_DECL) ++ { ++ type = TREE_TYPE (field); ++ if (CLASS_TYPE_P (type)) ++ { ++ if (TYPE_NEEDS_CONSTRUCTING (type)) ++ cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate", ++ field); ++ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) ++ cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate", ++ field); ++ if (TYPE_HAS_COMPLEX_ASSIGN_REF (type)) ++ cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate", ++ field); ++ } ++ } ++ } ++} ++ ++/* Make sure that a declaration with no declarator is well-formed, i.e. ++ just declares a tagged type or anonymous union. ++ ++ Returns the type declared; or NULL_TREE if none. */ ++ ++tree ++check_tag_decl (tree declspecs) ++{ ++ int found_type = 0; ++ int saw_friend = 0; ++ int saw_typedef = 0; ++ tree ob_modifier = NULL_TREE; ++ tree link; ++ /* If a class, struct, or enum type is declared by the DECLSPECS ++ (i.e, if a class-specifier, enum-specifier, or non-typename ++ elaborated-type-specifier appears in the DECLSPECS), ++ DECLARED_TYPE is set to the corresponding type. */ ++ tree declared_type = NULL_TREE; ++ bool error_p = false; ++ ++ for (link = declspecs; link; link = TREE_CHAIN (link)) ++ { ++ tree value = TREE_VALUE (link); ++ ++ if (TYPE_P (value) || TREE_CODE (value) == TYPE_DECL ++ || (TREE_CODE (value) == IDENTIFIER_NODE ++ && is_typename_at_global_scope (value))) ++ { ++ ++found_type; ++ ++ if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE) ++ { ++ if (! in_system_header) ++ pedwarn ("redeclaration of C++ built-in type `%T'", value); ++ return NULL_TREE; ++ } ++ ++ if (TYPE_P (value) ++ && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value)) ++ || TREE_CODE (value) == ENUMERAL_TYPE)) ++ { ++ my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261); ++ declared_type = value; ++ } ++ } ++ else if (value == ridpointers[(int) RID_TYPEDEF]) ++ saw_typedef = 1; ++ else if (value == ridpointers[(int) RID_FRIEND]) ++ { ++ if (current_class_type == NULL_TREE ++ || current_scope () != current_class_type) ++ ob_modifier = value; ++ else ++ saw_friend = 1; ++ } ++ else if (value == ridpointers[(int) RID_STATIC] ++ || value == ridpointers[(int) RID_EXTERN] ++ || value == ridpointers[(int) RID_AUTO] ++ || value == ridpointers[(int) RID_REGISTER] ++ || value == ridpointers[(int) RID_INLINE] ++ || value == ridpointers[(int) RID_VIRTUAL] ++ || value == ridpointers[(int) RID_CONST] ++ || value == ridpointers[(int) RID_VOLATILE] ++ || value == ridpointers[(int) RID_EXPLICIT] ++ || value == ridpointers[(int) RID_THREAD]) ++ ob_modifier = value; ++ else if (value == error_mark_node) ++ error_p = true; ++ } ++ ++ if (found_type > 1) ++ error ("multiple types in one declaration"); ++ ++ if (declared_type == NULL_TREE && ! saw_friend && !error_p) ++ pedwarn ("declaration does not declare anything"); ++ /* Check for an anonymous union. */ ++ else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type)) ++ && TYPE_ANONYMOUS_P (declared_type)) ++ { ++ /* 7/3 In a simple-declaration, the optional init-declarator-list ++ can be omitted only when declaring a class (clause 9) or ++ enumeration (7.2), that is, when the decl-specifier-seq contains ++ either a class-specifier, an elaborated-type-specifier with ++ a class-key (9.1), or an enum-specifier. In these cases and ++ whenever a class-specifier or enum-specifier is present in the ++ decl-specifier-seq, the identifiers in these specifiers are among ++ the names being declared by the declaration (as class-name, ++ enum-names, or enumerators, depending on the syntax). In such ++ cases, and except for the declaration of an unnamed bit-field (9.6), ++ the decl-specifier-seq shall introduce one or more names into the ++ program, or shall redeclare a name introduced by a previous ++ declaration. [Example: ++ enum { }; // ill-formed ++ typedef class { }; // ill-formed ++ --end example] */ ++ if (saw_typedef) ++ { ++ error ("missing type-name in typedef-declaration"); ++ return NULL_TREE; ++ } ++ /* Anonymous unions are objects, so they can have specifiers. */; ++ SET_ANON_AGGR_TYPE_P (declared_type); ++ ++ if (TREE_CODE (declared_type) != UNION_TYPE && pedantic ++ && !in_system_header) ++ pedwarn ("ISO C++ prohibits anonymous structs"); ++ } ++ ++ else if (ob_modifier) ++ { ++ if (ob_modifier == ridpointers[(int) RID_INLINE] ++ || ob_modifier == ridpointers[(int) RID_VIRTUAL]) ++ error ("`%D' can only be specified for functions", ob_modifier); ++ else if (ob_modifier == ridpointers[(int) RID_FRIEND]) ++ error ("`%D' can only be specified inside a class", ob_modifier); ++ else if (ob_modifier == ridpointers[(int) RID_EXPLICIT]) ++ error ("`%D' can only be specified for constructors", ++ ob_modifier); ++ else ++ error ("`%D' can only be specified for objects and functions", ++ ob_modifier); ++ } ++ ++ return declared_type; ++} ++ ++/* Called when a declaration is seen that contains no names to declare. ++ If its type is a reference to a structure, union or enum inherited ++ from a containing scope, shadow that tag name for the current scope ++ with a forward reference. ++ If its type defines a new named structure or union ++ or defines an enum, it is valid but we need not do anything here. ++ Otherwise, it is an error. ++ ++ C++: may have to grok the declspecs to learn about static, ++ complain for anonymous unions. ++ ++ Returns the TYPE declared -- or NULL_TREE if none. */ ++ ++tree ++shadow_tag (tree declspecs) ++{ ++ tree t = check_tag_decl (declspecs); ++ ++ if (!t) ++ return NULL_TREE; ++ ++ maybe_process_partial_specialization (t); ++ ++ /* This is where the variables in an anonymous union are ++ declared. An anonymous union declaration looks like: ++ union { ... } ; ++ because there is no declarator after the union, the parser ++ sends that declaration here. */ ++ if (ANON_AGGR_TYPE_P (t)) ++ { ++ fixup_anonymous_aggr (t); ++ ++ if (TYPE_FIELDS (t)) ++ { ++ tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0, ++ NULL); ++ finish_anon_union (decl); ++ } ++ } ++ ++ return t; ++} ++ ++/* Decode a "typename", such as "int **", returning a ..._TYPE node. */ ++ ++tree ++groktypename (tree typename) ++{ ++ tree specs, attrs; ++ tree type; ++ if (TREE_CODE (typename) != TREE_LIST) ++ return typename; ++ split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs); ++ type = grokdeclarator (TREE_VALUE (typename), specs, ++ TYPENAME, 0, &attrs); ++ if (attrs) ++ cplus_decl_attributes (&type, attrs, 0); ++ return type; ++} ++ ++/* Decode a declarator in an ordinary declaration or data definition. ++ This is called as soon as the type information and variable name ++ have been parsed, before parsing the initializer if any. ++ Here we create the ..._DECL node, fill in its type, ++ and put it on the list of decls for the current context. ++ The ..._DECL node is returned as the value. ++ ++ Exception: for arrays where the length is not specified, ++ the type is left null, to be filled in by `cp_finish_decl'. ++ ++ Function definitions do not come here; they go to start_function ++ instead. However, external and forward declarations of functions ++ do go through here. Structure field declarations are done by ++ grokfield and not through here. */ ++ ++tree ++start_decl (tree declarator, ++ tree declspecs, ++ int initialized, ++ tree attributes, ++ tree prefix_attributes) ++{ ++ tree decl; ++ tree type, tem; ++ tree context; ++ ++ /* This should only be done once on the top most decl. */ ++ if (have_extern_spec) ++ { ++ declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), ++ declspecs); ++ have_extern_spec = false; ++ } ++ ++ /* An object declared as __attribute__((deprecated)) suppresses ++ warnings of uses of other deprecated items. */ ++ if (lookup_attribute ("deprecated", attributes)) ++ deprecated_state = DEPRECATED_SUPPRESS; ++ ++ attributes = chainon (attributes, prefix_attributes); ++ ++ decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, ++ &attributes); ++ ++ deprecated_state = DEPRECATED_NORMAL; ++ ++ if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE) ++ return error_mark_node; ++ ++ type = TREE_TYPE (decl); ++ ++ if (type == error_mark_node) ++ return error_mark_node; ++ ++ context = DECL_CONTEXT (decl); ++ ++ if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL ++ && context != current_namespace && TREE_CODE (decl) == VAR_DECL) ++ { ++ /* When parsing the initializer, lookup should use the object's ++ namespace. */ ++ push_decl_namespace (context); ++ } ++ ++ /* We are only interested in class contexts, later. */ ++ if (context && TREE_CODE (context) == NAMESPACE_DECL) ++ context = NULL_TREE; ++ ++ if (initialized) ++ /* Is it valid for this decl to have an initializer at all? ++ If not, set INITIALIZED to zero, which will indirectly ++ tell `cp_finish_decl' to ignore the initializer once it is parsed. */ ++ switch (TREE_CODE (decl)) ++ { ++ case TYPE_DECL: ++ error ("typedef `%D' is initialized (use __typeof__ instead)", decl); ++ initialized = 0; ++ break; ++ ++ case FUNCTION_DECL: ++ error ("function `%#D' is initialized like a variable", decl); ++ initialized = 0; ++ break; ++ ++ default: ++ break; ++ } ++ ++ if (initialized) ++ { ++ if (! toplevel_bindings_p () ++ && DECL_EXTERNAL (decl)) ++ warning ("declaration of `%#D' has `extern' and is initialized", ++ decl); ++ DECL_EXTERNAL (decl) = 0; ++ if (toplevel_bindings_p ()) ++ TREE_STATIC (decl) = 1; ++ ++ /* Tell `pushdecl' this is an initialized decl ++ even though we don't yet have the initializer expression. ++ Also tell `cp_finish_decl' it may store the real initializer. */ ++ DECL_INITIAL (decl) = error_mark_node; ++ } ++ ++ /* Set attributes here so if duplicate decl, will have proper attributes. */ ++ cplus_decl_attributes (&decl, attributes, 0); ++ ++ /* If #pragma weak was used, mark the decl weak now. */ ++ if (global_scope_p (current_binding_level)) ++ maybe_apply_pragma_weak (decl); ++ ++ if (TREE_CODE (decl) == FUNCTION_DECL ++ && DECL_DECLARED_INLINE_P (decl) ++ && DECL_UNINLINABLE (decl) ++ && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl))) ++ warning ("%Jinline function '%D' given attribute noinline", decl, decl); ++ ++ if (context && COMPLETE_TYPE_P (complete_type (context))) ++ { ++ push_nested_class (context); ++ ++ if (TREE_CODE (decl) == VAR_DECL) ++ { ++ tree field = lookup_field (context, DECL_NAME (decl), 0, false); ++ if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL) ++ error ("`%#D' is not a static member of `%#T'", decl, context); ++ else ++ { ++ if (DECL_CONTEXT (field) != context) ++ { ++ if (!same_type_p (DECL_CONTEXT (field), context)) ++ pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'", ++ DECL_CONTEXT (field), DECL_NAME (decl), ++ context, DECL_NAME (decl)); ++ DECL_CONTEXT (decl) = DECL_CONTEXT (field); ++ } ++ /* Static data member are tricky; an in-class initialization ++ still doesn't provide a definition, so the in-class ++ declaration will have DECL_EXTERNAL set, but will have an ++ initialization. Thus, duplicate_decls won't warn ++ about this situation, and so we check here. */ ++ if (DECL_INITIAL (decl) && DECL_INITIAL (field)) ++ error ("duplicate initialization of %D", decl); ++ if (duplicate_decls (decl, field)) ++ decl = field; ++ } ++ } ++ else ++ { ++ tree field = check_classfn (context, decl, ++ processing_template_decl ++ > template_class_depth (context)); ++ if (field && duplicate_decls (decl, field)) ++ decl = field; ++ } ++ ++ /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */ ++ DECL_IN_AGGR_P (decl) = 0; ++ if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) ++ || CLASSTYPE_TEMPLATE_INSTANTIATION (context)) ++ { ++ SET_DECL_TEMPLATE_SPECIALIZATION (decl); ++ /* [temp.expl.spec] An explicit specialization of a static data ++ member of a template is a definition if the declaration ++ includes an initializer; otherwise, it is a declaration. ++ ++ We check for processing_specialization so this only applies ++ to the new specialization syntax. */ ++ if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization) ++ DECL_EXTERNAL (decl) = 1; ++ } ++ ++ if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)) ++ pedwarn ("declaration of `%#D' outside of class is not definition", ++ decl); ++ } ++ ++ /* Enter this declaration into the symbol table. */ ++ tem = maybe_push_decl (decl); ++ ++ if (processing_template_decl) ++ tem = push_template_decl (tem); ++ if (tem == error_mark_node) ++ return error_mark_node; ++ ++#if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS) ++ /* Tell the back-end to use or not use .common as appropriate. If we say ++ -fconserve-space, we want this to save .data space, at the expense of ++ wrong semantics. If we say -fno-conserve-space, we want this to ++ produce errors about redefs; to do this we force variables into the ++ data segment. */ ++ DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL ++ || !DECL_THREAD_LOCAL (tem)) ++ && (flag_conserve_space || ! TREE_PUBLIC (tem))); ++#endif ++ ++ if (! processing_template_decl) ++ start_decl_1 (tem); ++ ++ return tem; ++} ++ ++void ++start_decl_1 (tree decl) ++{ ++ tree type = TREE_TYPE (decl); ++ int initialized = (DECL_INITIAL (decl) != NULL_TREE); ++ ++ if (type == error_mark_node) ++ return; ++ ++ if (initialized) ++ /* Is it valid for this decl to have an initializer at all? ++ If not, set INITIALIZED to zero, which will indirectly ++ tell `cp_finish_decl' to ignore the initializer once it is parsed. */ ++ { ++ /* Don't allow initializations for incomplete types except for ++ arrays which might be completed by the initialization. */ ++ if (COMPLETE_TYPE_P (complete_type (type))) ++ ; /* A complete type is ok. */ ++ else if (TREE_CODE (type) != ARRAY_TYPE) ++ { ++ error ("variable `%#D' has initializer but incomplete type", ++ decl); ++ initialized = 0; ++ type = TREE_TYPE (decl) = error_mark_node; ++ } ++ else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) ++ { ++ if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)) ++ error ("elements of array `%#D' have incomplete type", decl); ++ /* else we already gave an error in start_decl. */ ++ initialized = 0; ++ } ++ } ++ ++ if (!initialized ++ && TREE_CODE (decl) != TYPE_DECL ++ && TREE_CODE (decl) != TEMPLATE_DECL ++ && type != error_mark_node ++ && IS_AGGR_TYPE (type) ++ && ! DECL_EXTERNAL (decl)) ++ { ++ if ((! processing_template_decl || ! uses_template_parms (type)) ++ && !COMPLETE_TYPE_P (complete_type (type))) ++ { ++ error ("aggregate `%#D' has incomplete type and cannot be defined", ++ decl); ++ /* Change the type so that assemble_variable will give ++ DECL an rtl we can live with: (mem (const_int 0)). */ ++ type = TREE_TYPE (decl) = error_mark_node; ++ } ++ else ++ { ++ /* If any base type in the hierarchy of TYPE needs a constructor, ++ then we set initialized to 1. This way any nodes which are ++ created for the purposes of initializing this aggregate ++ will live as long as it does. This is necessary for global ++ aggregates which do not have their initializers processed until ++ the end of the file. */ ++ initialized = TYPE_NEEDS_CONSTRUCTING (type); ++ } ++ } ++ ++ if (! initialized) ++ DECL_INITIAL (decl) = NULL_TREE; ++ ++ /* Create a new scope to hold this declaration if necessary. ++ Whether or not a new scope is necessary cannot be determined ++ until after the type has been completed; if the type is a ++ specialization of a class template it is not until after ++ instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR ++ will be set correctly. */ ++ maybe_push_cleanup_level (type); ++} ++ ++/* Handle initialization of references. DECL, TYPE, and INIT have the ++ same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry, ++ but will be set to a new CLEANUP_STMT if a temporary is created ++ that must be destroyed subsequently. ++ ++ Returns an initializer expression to use to initialize DECL, or ++ NULL if the initialization can be performed statically. ++ ++ Quotes on semantics can be found in ARM 8.4.3. */ ++ ++static tree ++grok_reference_init (tree decl, tree type, tree init, tree *cleanup) ++{ ++ tree tmp; ++ ++ if (init == NULL_TREE) ++ { ++ if ((DECL_LANG_SPECIFIC (decl) == 0 ++ || DECL_IN_AGGR_P (decl) == 0) ++ && ! DECL_THIS_EXTERN (decl)) ++ error ("`%D' declared as reference but not initialized", decl); ++ return NULL_TREE; ++ } ++ ++ if (TREE_CODE (init) == CONSTRUCTOR) ++ { ++ error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl); ++ return NULL_TREE; ++ } ++ ++ if (TREE_CODE (init) == TREE_LIST) ++ init = build_x_compound_expr_from_list (init, "initializer"); ++ ++ if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE) ++ init = convert_from_reference (init); ++ ++ if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE ++ && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE) ++ /* Note: default conversion is only called in very special cases. */ ++ init = decay_conversion (init); ++ ++ /* Convert INIT to the reference type TYPE. This may involve the ++ creation of a temporary, whose lifetime must be the same as that ++ of the reference. If so, a DECL_STMT for the temporary will be ++ added just after the DECL_STMT for DECL. That's why we don't set ++ DECL_INITIAL for local references (instead assigning to them ++ explicitly); we need to allow the temporary to be initialized ++ first. */ ++ tmp = initialize_reference (type, init, decl, cleanup); ++ ++ if (tmp == error_mark_node) ++ return NULL_TREE; ++ else if (tmp == NULL_TREE) ++ { ++ error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init)); ++ return NULL_TREE; ++ } ++ ++ if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp)) ++ return tmp; ++ ++ DECL_INITIAL (decl) = tmp; ++ ++ return NULL_TREE; ++} ++ ++/* When parsing `int a[] = {1, 2};' we don't know the size of the ++ array until we finish parsing the initializer. If that's the ++ situation we're in, update DECL accordingly. */ ++ ++static void ++maybe_deduce_size_from_array_init (tree decl, tree init) ++{ ++ tree type = TREE_TYPE (decl); ++ ++ if (TREE_CODE (type) == ARRAY_TYPE ++ && TYPE_DOMAIN (type) == NULL_TREE ++ && TREE_CODE (decl) != TYPE_DECL) ++ { ++ /* do_default is really a C-ism to deal with tentative definitions. ++ But let's leave it here to ease the eventual merge. */ ++ int do_default = !DECL_EXTERNAL (decl); ++ tree initializer = init ? init : DECL_INITIAL (decl); ++ int failure = complete_array_type (type, initializer, do_default); ++ ++ if (failure == 1) ++ error ("initializer fails to determine size of `%D'", decl); ++ ++ if (failure == 2) ++ { ++ if (do_default) ++ error ("array size missing in `%D'", decl); ++ /* If a `static' var's size isn't known, make it extern as ++ well as static, so it does not get allocated. If it's not ++ `static', then don't mark it extern; finish_incomplete_decl ++ will give it a default size and it will get allocated. */ ++ else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl)) ++ DECL_EXTERNAL (decl) = 1; ++ } ++ ++ if (pedantic && TYPE_DOMAIN (type) != NULL_TREE ++ && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), ++ integer_zero_node)) ++ error ("zero-size array `%D'", decl); ++ ++ layout_decl (decl, 0); ++ } ++} ++ ++/* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue ++ any appropriate error messages regarding the layout. */ ++ ++static void ++layout_var_decl (tree decl) ++{ ++ tree type = TREE_TYPE (decl); ++#if 0 ++ tree ttype = target_type (type); ++#endif ++ ++ /* If we haven't already layed out this declaration, do so now. ++ Note that we must not call complete type for an external object ++ because it's type might involve templates that we are not ++ supposed to instantiate yet. (And it's perfectly valid to say ++ `extern X x' for some incomplete type `X'.) */ ++ if (!DECL_EXTERNAL (decl)) ++ complete_type (type); ++ if (!DECL_SIZE (decl) ++ && TREE_TYPE (decl) != error_mark_node ++ && (COMPLETE_TYPE_P (type) ++ || (TREE_CODE (type) == ARRAY_TYPE ++ && !TYPE_DOMAIN (type) ++ && COMPLETE_TYPE_P (TREE_TYPE (type))))) ++ layout_decl (decl, 0); ++ ++ if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE) ++ { ++ /* An automatic variable with an incomplete type: that is an error. ++ Don't talk about array types here, since we took care of that ++ message in grokdeclarator. */ ++ error ("storage size of `%D' isn't known", decl); ++ TREE_TYPE (decl) = error_mark_node; ++ } ++#if 0 ++ /* Keep this code around in case we later want to control debug info ++ based on whether a type is "used". (jason 1999-11-11) */ ++ ++ else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype)) ++ /* Let debugger know it should output info for this type. */ ++ note_debug_info_needed (ttype); ++ ++ if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl)) ++ note_debug_info_needed (DECL_CONTEXT (decl)); ++#endif ++ ++ if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl)) ++ && DECL_SIZE (decl) != NULL_TREE ++ && ! TREE_CONSTANT (DECL_SIZE (decl))) ++ { ++ if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST) ++ constant_expression_warning (DECL_SIZE (decl)); ++ else ++ error ("storage size of `%D' isn't constant", decl); ++ } ++ ++ if (TREE_STATIC (decl) ++ && !DECL_ARTIFICIAL (decl) ++ && current_function_decl ++ && DECL_CONTEXT (decl) == current_function_decl) ++ push_local_name (decl); ++} ++ ++/* If a local static variable is declared in an inline function, or if ++ we have a weak definition, we must endeavor to create only one ++ instance of the variable at link-time. */ ++ ++static void ++maybe_commonize_var (tree decl) ++{ ++ /* Static data in a function with comdat linkage also has comdat ++ linkage. */ ++ if (TREE_STATIC (decl) ++ /* Don't mess with __FUNCTION__. */ ++ && ! DECL_ARTIFICIAL (decl) ++ && DECL_FUNCTION_SCOPE_P (decl) ++ /* Unfortunately, import_export_decl has not always been called ++ before the function is processed, so we cannot simply check ++ DECL_COMDAT. */ ++ && (DECL_COMDAT (DECL_CONTEXT (decl)) ++ || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl)) ++ || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl))) ++ && TREE_PUBLIC (DECL_CONTEXT (decl))))) ++ { ++ if (flag_weak) ++ { ++ /* With weak symbols, we simply make the variable COMDAT; ++ that will cause copies in multiple translations units to ++ be merged. */ ++ comdat_linkage (decl); ++ } ++ else ++ { ++ if (DECL_INITIAL (decl) == NULL_TREE ++ || DECL_INITIAL (decl) == error_mark_node) ++ { ++ /* Without weak symbols, we can use COMMON to merge ++ uninitialized variables. */ ++ TREE_PUBLIC (decl) = 1; ++ DECL_COMMON (decl) = 1; ++ } ++ else ++ { ++ /* While for initialized variables, we must use internal ++ linkage -- which means that multiple copies will not ++ be merged. */ ++ TREE_PUBLIC (decl) = 0; ++ DECL_COMMON (decl) = 0; ++ cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl); ++ warning ("%J you can work around this by removing the initializer", ++ decl); ++ } ++ } ++ } ++ else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl)) ++ /* Set it up again; we might have set DECL_INITIAL since the last ++ time. */ ++ comdat_linkage (decl); ++} ++ ++/* Issue an error message if DECL is an uninitialized const variable. */ ++ ++static void ++check_for_uninitialized_const_var (tree decl) ++{ ++ tree type = TREE_TYPE (decl); ++ ++ /* ``Unless explicitly declared extern, a const object does not have ++ external linkage and must be initialized. ($8.4; $12.1)'' ARM ++ 7.1.6 */ ++ if (TREE_CODE (decl) == VAR_DECL ++ && TREE_CODE (type) != REFERENCE_TYPE ++ && CP_TYPE_CONST_P (type) ++ && !TYPE_NEEDS_CONSTRUCTING (type) ++ && !DECL_INITIAL (decl)) ++ error ("uninitialized const `%D'", decl); ++} ++ ++/* FIELD is a FIELD_DECL or NULL. In the former case, the value ++ returned is the next FIELD_DECL (possibly FIELD itself) that can be ++ initialized. If there are no more such fields, the return value ++ will be NULL. */ ++ ++static tree ++next_initializable_field (tree field) ++{ ++ while (field ++ && (TREE_CODE (field) != FIELD_DECL ++ || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field)) ++ || DECL_ARTIFICIAL (field))) ++ field = TREE_CHAIN (field); ++ ++ return field; ++} ++ ++/* Subroutine of reshape_init. Reshape the constructor for an array. INITP ++ is the pointer to the old constructor list (to the CONSTRUCTOR_ELTS of ++ the CONSTRUCTOR we are processing), while NEW_INIT is the CONSTRUCTOR we ++ are building. ++ ELT_TYPE is the element type of the array. MAX_INDEX is an INTEGER_CST ++ representing the size of the array minus one (the maximum index), or ++ NULL_TREE if the array was declared without specifying the size. */ ++ ++static bool ++reshape_init_array (tree elt_type, tree max_index, ++ tree *initp, tree new_init) ++{ ++ bool sized_array_p = (max_index != NULL_TREE); ++ unsigned HOST_WIDE_INT max_index_cst = 0; ++ unsigned HOST_WIDE_INT index; ++ ++ if (sized_array_p) ++ { ++ if (host_integerp (max_index, 1)) ++ max_index_cst = tree_low_cst (max_index, 1); ++ /* sizetype is sign extended, not zero extended. */ ++ else ++ max_index_cst = tree_low_cst (convert (size_type_node, max_index), 1); ++ } ++ ++ /* Loop until there are no more initializers. */ ++ for (index = 0; ++ *initp && (!sized_array_p || index <= max_index_cst); ++ ++index) ++ { ++ tree element_init; ++ tree designated_index; ++ ++ element_init = reshape_init (elt_type, initp); ++ if (element_init == error_mark_node) ++ return false; ++ TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init); ++ CONSTRUCTOR_ELTS (new_init) = element_init; ++ designated_index = TREE_PURPOSE (element_init); ++ if (designated_index) ++ { ++ /* Handle array designated initializers (GNU extension). */ ++ if (TREE_CODE (designated_index) == IDENTIFIER_NODE) ++ { ++ error ("name `%D' used in a GNU-style designated " ++ "initializer for an array", designated_index); ++ TREE_PURPOSE (element_init) = NULL_TREE; ++ } ++ else ++ abort (); ++ } ++ } ++ ++ return true; ++} ++ ++/* Undo the brace-elision allowed by [dcl.init.aggr] in a ++ brace-enclosed aggregate initializer. ++ ++ *INITP is one of a list of initializers describing a brace-enclosed ++ initializer for an entity of the indicated aggregate TYPE. It may ++ not presently match the shape of the TYPE; for example: ++ ++ struct S { int a; int b; }; ++ struct S a[] = { 1, 2, 3, 4 }; ++ ++ Here *INITP will point to TREE_LIST of four elements, rather than a ++ list of two elements, each itself a list of two elements. This ++ routine transforms INIT from the former form into the latter. The ++ revised initializer is returned. */ ++ ++static tree ++reshape_init (tree type, tree *initp) ++{ ++ tree inits; ++ tree old_init; ++ tree old_init_value; ++ tree new_init; ++ bool brace_enclosed_p; ++ bool string_init_p; ++ ++ old_init = *initp; ++ old_init_value = (TREE_CODE (*initp) == TREE_LIST ++ ? TREE_VALUE (*initp) : old_init); ++ ++ my_friendly_assert (old_init_value, 20030723); ++ ++ /* If the initializer is brace-enclosed, pull initializers from the ++ enclosed elements. Advance past the brace-enclosed initializer ++ now. */ ++ if (TREE_CODE (old_init_value) == CONSTRUCTOR ++ && TREE_TYPE (old_init_value) == NULL_TREE ++ && TREE_HAS_CONSTRUCTOR (old_init_value)) ++ { ++ *initp = TREE_CHAIN (old_init); ++ TREE_CHAIN (old_init) = NULL_TREE; ++ inits = CONSTRUCTOR_ELTS (old_init_value); ++ initp = &inits; ++ brace_enclosed_p = true; ++ } ++ else ++ { ++ inits = NULL_TREE; ++ brace_enclosed_p = false; ++ } ++ ++ /* A non-aggregate type is always initialized with a single ++ initializer. */ ++ if (!CP_AGGREGATE_TYPE_P (type)) ++ { ++ *initp = TREE_CHAIN (old_init); ++ TREE_CHAIN (old_init) = NULL_TREE; ++ /* It is invalid to initialize a non-aggregate type with a ++ brace-enclosed initializer. */ ++ if (brace_enclosed_p) ++ { ++ error ("brace-enclosed initializer used to initialize `%T'", ++ type); ++ if (TREE_CODE (old_init) == TREE_LIST) ++ TREE_VALUE (old_init) = error_mark_node; ++ else ++ old_init = error_mark_node; ++ } ++ ++ return old_init; ++ } ++ ++ /* [dcl.init.aggr] ++ ++ All implicit type conversions (clause _conv_) are considered when ++ initializing the aggregate member with an initializer from an ++ initializer-list. If the initializer can initialize a member, ++ the member is initialized. Otherwise, if the member is itself a ++ non-empty subaggregate, brace elision is assumed and the ++ initializer is considered for the initialization of the first ++ member of the subaggregate. */ ++ if (!brace_enclosed_p ++ && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value)) ++ { ++ *initp = TREE_CHAIN (old_init); ++ TREE_CHAIN (old_init) = NULL_TREE; ++ return old_init; ++ } ++ ++ string_init_p = false; ++ if (TREE_CODE (old_init_value) == STRING_CST ++ && TREE_CODE (type) == ARRAY_TYPE ++ && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))) ++ { ++ /* [dcl.init.string] ++ ++ A char array (whether plain char, signed char, or unsigned char) ++ can be initialized by a string-literal (optionally enclosed in ++ braces); a wchar_t array can be initialized by a wide ++ string-literal (optionally enclosed in braces). */ ++ new_init = old_init; ++ /* Move past the initializer. */ ++ *initp = TREE_CHAIN (old_init); ++ TREE_CHAIN (old_init) = NULL_TREE; ++ string_init_p = true; ++ } ++ else ++ { ++ /* Build a CONSTRUCTOR to hold the contents of the aggregate. */ ++ new_init = build_constructor (type, NULL_TREE); ++ TREE_HAS_CONSTRUCTOR (new_init) = 1; ++ ++ if (CLASS_TYPE_P (type)) ++ { ++ tree field; ++ ++ field = next_initializable_field (TYPE_FIELDS (type)); ++ ++ if (!field) ++ { ++ /* [dcl.init.aggr] ++ ++ An initializer for an aggregate member that is an ++ empty class shall have the form of an empty ++ initializer-list {}. */ ++ if (!brace_enclosed_p) ++ { ++ error ("initializer for `%T' must be brace-enclosed", ++ type); ++ return error_mark_node; ++ } ++ } ++ else ++ { ++ /* Loop through the initializable fields, gathering ++ initializers. */ ++ while (*initp) ++ { ++ tree field_init; ++ ++ /* Handle designated initializers, as an extension. */ ++ if (TREE_PURPOSE (*initp)) ++ { ++ if (pedantic) ++ pedwarn ("ISO C++ does not allow designated initializers"); ++ field = lookup_field_1 (type, TREE_PURPOSE (*initp), ++ /*want_type=*/false); ++ if (!field || TREE_CODE (field) != FIELD_DECL) ++ error ("`%T' has no non-static data member named `%D'", ++ type, TREE_PURPOSE (*initp)); ++ } ++ if (!field) ++ break; ++ ++ field_init = reshape_init (TREE_TYPE (field), initp); ++ if (field_init == error_mark_node) ++ return error_mark_node; ++ TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init); ++ CONSTRUCTOR_ELTS (new_init) = field_init; ++ /* [dcl.init.aggr] ++ ++ When a union is initialized with a brace-enclosed ++ initializer, the braces shall only contain an ++ initializer for the first member of the union. */ ++ if (TREE_CODE (type) == UNION_TYPE) ++ break; ++ field = next_initializable_field (TREE_CHAIN (field)); ++ } ++ } ++ } ++ else if ((TREE_CODE (type) == ARRAY_TYPE)|| (TREE_CODE (type) == VECTOR_TYPE)) ++ { ++ tree max_index; ++ ++ /* If the bound of the array is known, take no more initializers ++ than are allowed. */ ++ max_index = ((TYPE_DOMAIN (type) && (TREE_CODE (type) == ARRAY_TYPE)) ++ ? array_type_nelts (type) : NULL_TREE); ++ if (!reshape_init_array (TREE_TYPE (type), max_index, ++ initp, new_init)) ++ return error_mark_node; ++ } ++ else ++ abort (); ++ ++ /* The initializers were placed in reverse order in the ++ CONSTRUCTOR. */ ++ CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init)); ++ ++ if (TREE_CODE (old_init) == TREE_LIST) ++ new_init = build_tree_list (TREE_PURPOSE (old_init), new_init); ++ } ++ ++ /* If there are more initializers than necessary, issue a ++ diagnostic. */ ++ if (*initp) ++ { ++ if (brace_enclosed_p) ++ error ("too many initializers for `%T'", type); ++ else if (warn_missing_braces && !string_init_p) ++ warning ("missing braces around initializer"); ++ } ++ ++ return new_init; ++} ++ ++/* Verify INIT (the initializer for DECL), and record the ++ initialization in DECL_INITIAL, if appropriate. CLEANUP is as for ++ grok_reference_init. ++ ++ If the return value is non-NULL, it is an expression that must be ++ evaluated dynamically to initialize DECL. */ ++ ++static tree ++check_initializer (tree decl, tree init, int flags, tree *cleanup) ++{ ++ tree type = TREE_TYPE (decl); ++ tree init_code = NULL; ++ ++ /* If `start_decl' didn't like having an initialization, ignore it now. */ ++ if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE) ++ init = NULL_TREE; ++ ++ /* If an initializer is present, DECL_INITIAL has been ++ error_mark_node, to indicate that an as-of-yet unevaluated ++ initialization will occur. From now on, DECL_INITIAL reflects ++ the static initialization -- if any -- of DECL. */ ++ DECL_INITIAL (decl) = NULL_TREE; ++ ++ /* Things that are going to be initialized need to have complete ++ type. */ ++ TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl)); ++ ++ if (type == error_mark_node) ++ /* We will have already complained. */ ++ init = NULL_TREE; ++ else if (init && COMPLETE_TYPE_P (type) ++ && !TREE_CONSTANT (TYPE_SIZE (type))) ++ { ++ error ("variable-sized object `%D' may not be initialized", decl); ++ init = NULL_TREE; ++ } ++ else if (TREE_CODE (type) == ARRAY_TYPE ++ && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) ++ { ++ error ("elements of array `%#D' have incomplete type", decl); ++ init = NULL_TREE; ++ } ++ else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type)) ++ { ++ error ("`%D' has incomplete type", decl); ++ TREE_TYPE (decl) = error_mark_node; ++ init = NULL_TREE; ++ } ++ ++ if (TREE_CODE (decl) == CONST_DECL) ++ { ++ my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148); ++ ++ DECL_INITIAL (decl) = init; ++ ++ my_friendly_assert (init != NULL_TREE, 149); ++ init = NULL_TREE; ++ } ++ else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE) ++ init = grok_reference_init (decl, type, init, cleanup); ++ else if (init) ++ { ++ if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init)) ++ { ++ /* [dcl.init] paragraph 13, ++ If T is a scalar type, then a declaration of the form ++ T x = { a }; ++ is equivalent to ++ T x = a; ++ ++ reshape_init will complain about the extra braces, ++ and doesn't do anything useful in the case where TYPE is ++ scalar, so just don't call it. */ ++ if (CP_AGGREGATE_TYPE_P (type)) ++ init = reshape_init (type, &init); ++ ++ if ((*targetm.vector_opaque_p) (type)) ++ { ++ error ("opaque vector types cannot be initialized"); ++ init = error_mark_node; ++ } ++ } ++ ++ /* If DECL has an array type without a specific bound, deduce the ++ array size from the initializer. */ ++ maybe_deduce_size_from_array_init (decl, init); ++ type = TREE_TYPE (decl); ++ if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init)) ++ TREE_TYPE (init) = type; ++ ++ if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type)) ++ { ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ goto initialize_aggr; ++ else if (TREE_CODE (init) == CONSTRUCTOR ++ && TREE_HAS_CONSTRUCTOR (init)) ++ { ++ if (TYPE_NON_AGGREGATE_CLASS (type)) ++ { ++ error ("`%D' must be initialized by constructor, not by `{...}'", ++ decl); ++ init = error_mark_node; ++ } ++ else ++ goto dont_use_constructor; ++ } ++ else ++ { ++ int saved_stmts_are_full_exprs_p; ++ ++ initialize_aggr: ++ saved_stmts_are_full_exprs_p = 0; ++ if (building_stmt_tree ()) ++ { ++ saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); ++ current_stmt_tree ()->stmts_are_full_exprs_p = 1; ++ } ++ init = build_aggr_init (decl, init, flags); ++ if (building_stmt_tree ()) ++ current_stmt_tree ()->stmts_are_full_exprs_p = ++ saved_stmts_are_full_exprs_p; ++ return init; ++ } ++ } ++ else ++ { ++ dont_use_constructor: ++ if (TREE_CODE (init) != TREE_VEC) ++ { ++ init_code = store_init_value (decl, init); ++ init = NULL; ++ } ++ } ++ } ++ else if (DECL_EXTERNAL (decl)) ++ ; ++ else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type)) ++ goto initialize_aggr; ++ else if (IS_AGGR_TYPE (type)) ++ { ++ tree core_type = strip_array_types (type); ++ ++ if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)) ++ error ("structure `%D' with uninitialized const members", decl); ++ if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)) ++ error ("structure `%D' with uninitialized reference members", ++ decl); ++ ++ check_for_uninitialized_const_var (decl); ++ } ++ else ++ check_for_uninitialized_const_var (decl); ++ ++ if (init && init != error_mark_node) ++ init_code = build (INIT_EXPR, type, decl, init); ++ ++ return init_code; ++} ++ ++/* If DECL is not a local variable, give it RTL. */ ++ ++static void ++make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec) ++{ ++ int toplev = toplevel_bindings_p (); ++ int defer_p; ++ ++ /* Handle non-variables up front. */ ++ if (TREE_CODE (decl) != VAR_DECL) ++ { ++ rest_of_decl_compilation (decl, asmspec, toplev, at_eof); ++ return; ++ } ++ ++ /* If we see a class member here, it should be a static data ++ member. */ ++ if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl)) ++ { ++ my_friendly_assert (TREE_STATIC (decl), 19990828); ++ /* An in-class declaration of a static data member should be ++ external; it is only a declaration, and not a definition. */ ++ if (init == NULL_TREE) ++ my_friendly_assert (DECL_EXTERNAL (decl), 20000723); ++ } ++ ++ /* Set the DECL_ASSEMBLER_NAME for the variable. */ ++ if (asmspec) ++ { ++ change_decl_assembler_name (decl, get_identifier (asmspec)); ++ /* The `register' keyword, when used together with an ++ asm-specification, indicates that the variable should be ++ placed in a particular register. */ ++ if (DECL_REGISTER (decl)) ++ DECL_C_HARD_REGISTER (decl) = 1; ++ } ++ ++ /* We don't create any RTL for local variables. */ ++ if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl)) ++ return; ++ ++ /* We defer emission of local statics until the corresponding ++ DECL_STMT is expanded. */ ++ defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl); ++ ++ /* We try to defer namespace-scope static constants so that they are ++ not emitted into the object file unnecessarily. */ ++ if (!DECL_VIRTUAL_P (decl) ++ && TREE_READONLY (decl) ++ && DECL_INITIAL (decl) != NULL_TREE ++ && DECL_INITIAL (decl) != error_mark_node ++ && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)) ++ && toplev ++ && !TREE_PUBLIC (decl)) ++ { ++ /* Fool with the linkage of static consts according to #pragma ++ interface. */ ++ if (!interface_unknown && !TREE_PUBLIC (decl)) ++ { ++ TREE_PUBLIC (decl) = 1; ++ DECL_EXTERNAL (decl) = interface_only; ++ } ++ ++ defer_p = 1; ++ } ++ /* Likewise for template instantiations. */ ++ else if (DECL_COMDAT (decl)) ++ defer_p = 1; ++ ++ /* If we're deferring the variable, we only need to make RTL if ++ there's an ASMSPEC. Otherwise, we'll lazily create it later when ++ we need it. (There's no way to lazily create RTL for things that ++ have assembly specs because the information about the specifier ++ isn't stored in the tree, yet) */ ++ if (defer_p && asmspec) ++ make_decl_rtl (decl, asmspec); ++ /* If we're not deferring, go ahead and assemble the variable. */ ++ else if (!defer_p) ++ rest_of_decl_compilation (decl, asmspec, toplev, at_eof); ++} ++ ++/* Generate code to initialize DECL (a local variable). */ ++ ++static void ++initialize_local_var (tree decl, tree init) ++{ ++ tree type = TREE_TYPE (decl); ++ tree cleanup; ++ ++ my_friendly_assert (TREE_CODE (decl) == VAR_DECL ++ || TREE_CODE (decl) == RESULT_DECL, ++ 20021010); ++ my_friendly_assert (!TREE_STATIC (decl), 20021010); ++ ++ if (DECL_SIZE (decl) == NULL_TREE) ++ { ++ /* If we used it already as memory, it must stay in memory. */ ++ DECL_INITIAL (decl) = NULL_TREE; ++ TREE_ADDRESSABLE (decl) = TREE_USED (decl); ++ } ++ ++ if (DECL_SIZE (decl) && type != error_mark_node) ++ { ++ int already_used; ++ ++ /* Compute and store the initial value. */ ++ already_used = TREE_USED (decl) || TREE_USED (type); ++ ++ /* Perform the initialization. */ ++ if (init) ++ { ++ int saved_stmts_are_full_exprs_p; ++ ++ my_friendly_assert (building_stmt_tree (), 20000906); ++ saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); ++ current_stmt_tree ()->stmts_are_full_exprs_p = 1; ++ finish_expr_stmt (init); ++ current_stmt_tree ()->stmts_are_full_exprs_p = ++ saved_stmts_are_full_exprs_p; ++ } ++ ++ /* Set this to 0 so we can tell whether an aggregate which was ++ initialized was ever used. Don't do this if it has a ++ destructor, so we don't complain about the 'resource ++ allocation is initialization' idiom. Now set ++ attribute((unused)) on types so decls of that type will be ++ marked used. (see TREE_USED, above.) */ ++ if (TYPE_NEEDS_CONSTRUCTING (type) ++ && ! already_used ++ && TYPE_HAS_TRIVIAL_DESTRUCTOR (type) ++ && DECL_NAME (decl)) ++ TREE_USED (decl) = 0; ++ else if (already_used) ++ TREE_USED (decl) = 1; ++ } ++ ++ /* Generate a cleanup, if necessary. */ ++ cleanup = cxx_maybe_build_cleanup (decl); ++ if (DECL_SIZE (decl) && cleanup) ++ finish_decl_cleanup (decl, cleanup); ++} ++ ++/* Finish processing of a declaration; ++ install its line number and initial value. ++ If the length of an array type is not known before, ++ it must be determined now, from the initial value, or it is an error. ++ ++ INIT holds the value of an initializer that should be allowed to escape ++ the normal rules. ++ ++ FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0 ++ if the (init) syntax was used. */ ++ ++void ++cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags) ++{ ++ tree type; ++ tree ttype = NULL_TREE; ++ tree cleanup; ++ const char *asmspec = NULL; ++ int was_readonly = 0; ++ bool var_definition_p = false; ++ ++ if (decl == error_mark_node) ++ return; ++ else if (! decl) ++ { ++ if (init) ++ error ("assignment (not initialization) in declaration"); ++ return; ++ } ++ ++ my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619); ++ ++ /* Assume no cleanup is required. */ ++ cleanup = NULL_TREE; ++ ++ /* If a name was specified, get the string. */ ++ if (global_scope_p (current_binding_level)) ++ asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree); ++ if (asmspec_tree) ++ asmspec = TREE_STRING_POINTER (asmspec_tree); ++ ++ if (init && TREE_CODE (init) == NAMESPACE_DECL) ++ { ++ error ("cannot initialize `%D' to namespace `%D'", ++ decl, init); ++ init = NULL_TREE; ++ } ++ ++ if (current_class_type ++ && CP_DECL_CONTEXT (decl) == current_class_type ++ && TYPE_BEING_DEFINED (current_class_type) ++ && (DECL_INITIAL (decl) || init)) ++ DECL_INITIALIZED_IN_CLASS_P (decl) = 1; ++ ++ if (TREE_CODE (decl) == VAR_DECL ++ && DECL_CONTEXT (decl) ++ && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL ++ && DECL_CONTEXT (decl) != current_namespace ++ && init) ++ { ++ /* Leave the namespace of the object. */ ++ pop_decl_namespace (); ++ } ++ ++ type = TREE_TYPE (decl); ++ ++ if (type == error_mark_node) ++ goto finish_end0; ++ ++ if (TYPE_HAS_MUTABLE_P (type)) ++ TREE_READONLY (decl) = 0; ++ ++ if (processing_template_decl) ++ { ++ /* Add this declaration to the statement-tree. */ ++ if (at_function_scope_p ()) ++ add_decl_stmt (decl); ++ ++ if (init && DECL_INITIAL (decl)) ++ DECL_INITIAL (decl) = init; ++ if (TREE_CODE (decl) == VAR_DECL ++ && !DECL_PRETTY_FUNCTION_P (decl) ++ && !dependent_type_p (TREE_TYPE (decl))) ++ maybe_deduce_size_from_array_init (decl, init); ++ goto finish_end0; ++ } ++ ++ /* Parameters are handled by store_parm_decls, not cp_finish_decl. */ ++ my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828); ++ ++ /* Take care of TYPE_DECLs up front. */ ++ if (TREE_CODE (decl) == TYPE_DECL) ++ { ++ if (type != error_mark_node ++ && IS_AGGR_TYPE (type) && DECL_NAME (decl)) ++ { ++ if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type) ++ warning ("shadowing previous type declaration of `%#D'", decl); ++ set_identifier_type_value (DECL_NAME (decl), decl); ++ } ++ ++ /* If we have installed this as the canonical typedef for this ++ type, and that type has not been defined yet, delay emitting ++ the debug information for it, as we will emit it later. */ ++ if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl ++ && !COMPLETE_TYPE_P (TREE_TYPE (decl))) ++ TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; ++ ++ rest_of_decl_compilation (decl, NULL, ++ DECL_CONTEXT (decl) == NULL_TREE, at_eof); ++ goto finish_end; ++ } ++ ++ if (TREE_CODE (decl) != FUNCTION_DECL) ++ ttype = target_type (type); ++ ++ ++ /* Currently, GNU C++ puts constants in text space, making them ++ impossible to initialize. In the future, one would hope for ++ an operating system which understood the difference between ++ initialization and the running of a program. */ ++ if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)) ++ { ++ was_readonly = 1; ++ if (TYPE_NEEDS_CONSTRUCTING (type) ++ || TREE_CODE (type) == REFERENCE_TYPE) ++ TREE_READONLY (decl) = 0; ++ } ++ ++ if (TREE_CODE (decl) == VAR_DECL) ++ { ++ /* Only PODs can have thread-local storage. Other types may require ++ various kinds of non-trivial initialization. */ ++ if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl))) ++ error ("`%D' cannot be thread-local because it has non-POD type `%T'", ++ decl, TREE_TYPE (decl)); ++ /* Convert the initializer to the type of DECL, if we have not ++ already initialized DECL. */ ++ if (!DECL_INITIALIZED_P (decl) ++ /* If !DECL_EXTERNAL then DECL is being defined. In the ++ case of a static data member initialized inside the ++ class-specifier, there can be an initializer even if DECL ++ is *not* defined. */ ++ && (!DECL_EXTERNAL (decl) || init)) ++ { ++ init = check_initializer (decl, init, flags, &cleanup); ++ /* Thread-local storage cannot be dynamically initialized. */ ++ if (DECL_THREAD_LOCAL (decl) && init) ++ { ++ error ("`%D' is thread-local and so cannot be dynamically " ++ "initialized", decl); ++ init = NULL_TREE; ++ } ++ /* Handle: ++ ++ [dcl.init] ++ ++ The memory occupied by any object of static storage ++ duration is zero-initialized at program startup before ++ any other initialization takes place. ++ ++ We cannot create an appropriate initializer until after ++ the type of DECL is finalized. If DECL_INITIAL is set, ++ then the DECL is statically initialized, and any ++ necessary zero-initialization has already been performed. */ ++ if (TREE_STATIC (decl) && !DECL_INITIAL (decl)) ++ DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl), ++ /*nelts=*/NULL_TREE, ++ /*static_storage_p=*/true); ++ /* Remember that the initialization for this variable has ++ taken place. */ ++ DECL_INITIALIZED_P (decl) = 1; ++ /* This declaration is the definition of this variable, ++ unless we are initializing a static data member within ++ the class specifier. */ ++ if (!DECL_EXTERNAL (decl)) ++ var_definition_p = true; ++ } ++ /* If the variable has an array type, lay out the type, even if ++ there is no initializer. It is valid to index through the ++ array, and we must get TYPE_ALIGN set correctly on the array ++ type. */ ++ else if (TREE_CODE (type) == ARRAY_TYPE) ++ layout_type (type); ++ } ++ ++ /* Add this declaration to the statement-tree. This needs to happen ++ after the call to check_initializer so that the DECL_STMT for a ++ reference temp is added before the DECL_STMT for the reference itself. */ ++ if (at_function_scope_p ()) ++ add_decl_stmt (decl); ++ ++ if (TREE_CODE (decl) == VAR_DECL) ++ layout_var_decl (decl); ++ ++ /* Output the assembler code and/or RTL code for variables and functions, ++ unless the type is an undefined structure or union. ++ If not, it will get done when the type is completed. */ ++ if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL) ++ { ++ if (TREE_CODE (decl) == VAR_DECL) ++ maybe_commonize_var (decl); ++ ++ make_rtl_for_nonlocal_decl (decl, init, asmspec); ++ ++ if (TREE_CODE (type) == FUNCTION_TYPE ++ || TREE_CODE (type) == METHOD_TYPE) ++ abstract_virtuals_error (decl, ++ strip_array_types (TREE_TYPE (type))); ++ else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE) ++ { ++ /* If it's either a pointer or an array type, strip through all ++ of them but the last one. If the last is an array type, issue ++ an error if the element type is abstract. */ ++ while (POINTER_TYPE_P (TREE_TYPE (type)) ++ || TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE) ++ type = TREE_TYPE (type); ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ abstract_virtuals_error (decl, TREE_TYPE (type)); ++ } ++ else ++ abstract_virtuals_error (decl, type); ++ ++ if (TREE_CODE (decl) == FUNCTION_DECL ++ || TREE_TYPE (decl) == error_mark_node) ++ /* No initialization required. */ ++ ; ++ else if (DECL_EXTERNAL (decl) ++ && ! (DECL_LANG_SPECIFIC (decl) ++ && DECL_NOT_REALLY_EXTERN (decl))) ++ { ++ if (init) ++ DECL_INITIAL (decl) = init; ++ } ++ else ++ { ++ /* A variable definition. */ ++ if (DECL_FUNCTION_SCOPE_P (decl)) ++ { ++ /* This is a local declaration. */ ++ maybe_inject_for_scope_var (decl); ++ /* Initialize the local variable. */ ++ if (processing_template_decl) ++ { ++ if (init || DECL_INITIAL (decl) == error_mark_node) ++ DECL_INITIAL (decl) = init; ++ } ++ else if (!TREE_STATIC (decl)) ++ initialize_local_var (decl, init); ++ } ++ ++ /* If a variable is defined, and then a subsequent ++ definintion with external linkage is encountered, we will ++ get here twice for the same variable. We want to avoid ++ calling expand_static_init more than once. For variables ++ that are not static data members, we can call ++ expand_static_init only when we actually process the ++ initializer. It is not legal to redeclare a static data ++ member, so this issue does not arise in that case. */ ++ if (var_definition_p && TREE_STATIC (decl)) ++ expand_static_init (decl, init); ++ } ++ finish_end0: ++ ++ /* Undo call to `pushclass' that was done in `start_decl' ++ due to initialization of qualified member variable. ++ I.e., Foo::x = 10; */ ++ { ++ tree context = CP_DECL_CONTEXT (decl); ++ if (context ++ && TYPE_P (context) ++ && (TREE_CODE (decl) == VAR_DECL ++ /* We also have a pushclass done that we need to undo here ++ if we're at top level and declare a method. */ ++ || TREE_CODE (decl) == FUNCTION_DECL) ++ /* If size hasn't been set, we're still defining it, ++ and therefore inside the class body; don't pop ++ the binding level.. */ ++ && COMPLETE_TYPE_P (context) ++ && context == current_class_type) ++ pop_nested_class (); ++ } ++ } ++ ++ /* If a CLEANUP_STMT was created to destroy a temporary bound to a ++ reference, insert it in the statement-tree now. */ ++ if (cleanup) ++ add_stmt (cleanup); ++ ++ finish_end: ++ ++ if (was_readonly) ++ TREE_READONLY (decl) = 1; ++ ++ /* If this was marked 'used', be sure it will be output. */ ++ if (lookup_attribute ("used", DECL_ATTRIBUTES (decl))) ++ mark_referenced (DECL_ASSEMBLER_NAME (decl)); ++} ++ ++/* This is here for a midend callback from c-common.c. */ ++ ++void ++finish_decl (tree decl, tree init, tree asmspec_tree) ++{ ++ cp_finish_decl (decl, init, asmspec_tree, 0); ++} ++ ++/* Returns a declaration for a VAR_DECL as if: ++ ++ extern "C" TYPE NAME; ++ ++ had been seen. Used to create compiler-generated global ++ variables. */ ++ ++tree ++declare_global_var (tree name, tree type) ++{ ++ tree decl; ++ ++ push_to_top_level (); ++ decl = build_decl (VAR_DECL, name, type); ++ TREE_PUBLIC (decl) = 1; ++ DECL_EXTERNAL (decl) = 1; ++ DECL_ARTIFICIAL (decl) = 1; ++ pushdecl (decl); ++ cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0); ++ pop_from_top_level (); ++ ++ return decl; ++} ++ ++/* Returns a pointer to the `atexit' function. Note that if ++ FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new ++ `__cxa_atexit' function specified in the IA64 C++ ABI. */ ++ ++static tree ++get_atexit_node (void) ++{ ++ tree atexit_fndecl; ++ tree arg_types; ++ tree fn_type; ++ tree fn_ptr_type; ++ const char *name; ++ ++ if (atexit_node) ++ return atexit_node; ++ ++ if (flag_use_cxa_atexit) ++ { ++ /* The declaration for `__cxa_atexit' is: ++ ++ int __cxa_atexit (void (*)(void *), void *, void *) ++ ++ We build up the argument types and then then function type ++ itself. */ ++ ++ /* First, build the pointer-to-function type for the first ++ argument. */ ++ arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); ++ fn_type = build_function_type (void_type_node, arg_types); ++ fn_ptr_type = build_pointer_type (fn_type); ++ /* Then, build the rest of the argument types. */ ++ arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); ++ arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types); ++ arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types); ++ /* And the final __cxa_atexit type. */ ++ fn_type = build_function_type (integer_type_node, arg_types); ++ fn_ptr_type = build_pointer_type (fn_type); ++ name = "__cxa_atexit"; ++ } ++ else ++ { ++ /* The declaration for `atexit' is: ++ ++ int atexit (void (*)()); ++ ++ We build up the argument types and then then function type ++ itself. */ ++ fn_type = build_function_type (void_type_node, void_list_node); ++ fn_ptr_type = build_pointer_type (fn_type); ++ arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node); ++ /* Build the final atexit type. */ ++ fn_type = build_function_type (integer_type_node, arg_types); ++ name = "atexit"; ++ } ++ ++ /* Now, build the function declaration. */ ++ push_lang_context (lang_name_c); ++ atexit_fndecl = build_library_fn_ptr (name, fn_type); ++ mark_used (atexit_fndecl); ++ pop_lang_context (); ++ atexit_node = decay_conversion (atexit_fndecl); ++ ++ return atexit_node; ++} ++ ++/* Returns the __dso_handle VAR_DECL. */ ++ ++static tree ++get_dso_handle_node (void) ++{ ++ if (dso_handle_node) ++ return dso_handle_node; ++ ++ /* Declare the variable. */ ++ dso_handle_node = declare_global_var (get_identifier ("__dso_handle"), ++ ptr_type_node); ++ ++ return dso_handle_node; ++} ++ ++/* Begin a new function with internal linkage whose job will be simply ++ to destroy some particular variable. */ ++ ++static GTY(()) int start_cleanup_cnt; ++ ++static tree ++start_cleanup_fn (void) ++{ ++ int old_interface_only = interface_only; ++ int old_interface_unknown = interface_unknown; ++ char name[32]; ++ tree parmtypes; ++ tree fntype; ++ tree fndecl; ++ ++ push_to_top_level (); ++ ++ /* No need to mangle this. */ ++ push_lang_context (lang_name_c); ++ ++ interface_only = 0; ++ interface_unknown = 1; ++ ++ /* Build the parameter-types. */ ++ parmtypes = void_list_node; ++ /* Functions passed to __cxa_atexit take an additional parameter. ++ We'll just ignore it. After we implement the new calling ++ convention for destructors, we can eliminate the use of ++ additional cleanup functions entirely in the -fnew-abi case. */ ++ if (flag_use_cxa_atexit) ++ parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes); ++ /* Build the function type itself. */ ++ fntype = build_function_type (void_type_node, parmtypes); ++ /* Build the name of the function. */ ++ sprintf (name, "__tcf_%d", start_cleanup_cnt++); ++ /* Build the function declaration. */ ++ fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype); ++ /* It's a function with internal linkage, generated by the ++ compiler. */ ++ TREE_PUBLIC (fndecl) = 0; ++ DECL_ARTIFICIAL (fndecl) = 1; ++ /* Make the function `inline' so that it is only emitted if it is ++ actually needed. It is unlikely that it will be inlined, since ++ it is only called via a function pointer, but we avoid unnecessary ++ emissions this way. */ ++ DECL_INLINE (fndecl) = 1; ++ DECL_DECLARED_INLINE_P (fndecl) = 1; ++ DECL_INTERFACE_KNOWN (fndecl) = 1; ++ /* Build the parameter. */ ++ if (flag_use_cxa_atexit) ++ { ++ tree parmdecl; ++ ++ parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node); ++ DECL_CONTEXT (parmdecl) = fndecl; ++ TREE_USED (parmdecl) = 1; ++ DECL_ARGUMENTS (fndecl) = parmdecl; ++ } ++ ++ pushdecl (fndecl); ++ start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED); ++ ++ interface_unknown = old_interface_unknown; ++ interface_only = old_interface_only; ++ ++ pop_lang_context (); ++ ++ return current_function_decl; ++} ++ ++/* Finish the cleanup function begun by start_cleanup_fn. */ ++ ++static void ++end_cleanup_fn (void) ++{ ++ expand_or_defer_fn (finish_function (0)); ++ ++ pop_from_top_level (); ++} ++ ++/* Generate code to handle the destruction of DECL, an object with ++ static storage duration. */ ++ ++void ++register_dtor_fn (tree decl) ++{ ++ tree cleanup; ++ tree compound_stmt; ++ tree args; ++ tree fcall; ++ ++ if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) ++ return; ++ ++ /* Call build_cleanup before we enter the anonymous function so that ++ any access checks will be done relative to the current scope, ++ rather than the scope of the anonymous function. */ ++ build_cleanup (decl); ++ ++ /* Now start the function. */ ++ cleanup = start_cleanup_fn (); ++ ++ /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer ++ to the original function, rather than the anonymous one. That ++ will make the back-end think that nested functions are in use, ++ which causes confusion. */ ++ ++ push_deferring_access_checks (dk_no_check); ++ fcall = build_cleanup (decl); ++ pop_deferring_access_checks (); ++ ++ /* Create the body of the anonymous function. */ ++ compound_stmt = begin_compound_stmt (/*has_no_scope=*/false); ++ finish_expr_stmt (fcall); ++ finish_compound_stmt (compound_stmt); ++ end_cleanup_fn (); ++ ++ /* Call atexit with the cleanup function. */ ++ cxx_mark_addressable (cleanup); ++ mark_used (cleanup); ++ cleanup = build_unary_op (ADDR_EXPR, cleanup, 0); ++ if (flag_use_cxa_atexit) ++ { ++ args = tree_cons (NULL_TREE, ++ build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0), ++ NULL_TREE); ++ args = tree_cons (NULL_TREE, null_pointer_node, args); ++ args = tree_cons (NULL_TREE, cleanup, args); ++ } ++ else ++ args = tree_cons (NULL_TREE, cleanup, NULL_TREE); ++ finish_expr_stmt (build_function_call (get_atexit_node (), args)); ++} ++ ++/* DECL is a VAR_DECL with static storage duration. INIT, if present, ++ is its initializer. Generate code to handle the construction ++ and destruction of DECL. */ ++ ++static void ++expand_static_init (tree decl, tree init) ++{ ++ my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010); ++ my_friendly_assert (TREE_STATIC (decl), 20021010); ++ ++ /* Some variables require no initialization. */ ++ if (!init ++ && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)) ++ && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) ++ return; ++ ++ if (! toplevel_bindings_p ()) ++ { ++ /* Emit code to perform this initialization but once. */ ++ tree if_stmt; ++ tree then_clause; ++ tree assignment; ++ tree guard; ++ tree guard_init; ++ ++ /* Emit code to perform this initialization but once. This code ++ looks like: ++ ++ static int guard = 0; ++ if (!guard) { ++ // Do initialization. ++ guard = 1; ++ // Register variable for destruction at end of program. ++ } ++ ++ Note that the `temp' variable is only set to 1 *after* the ++ initialization is complete. This ensures that an exception, ++ thrown during the construction, will cause the variable to ++ reinitialized when we pass through this code again, as per: ++ ++ [stmt.dcl] ++ ++ If the initialization exits by throwing an exception, the ++ initialization is not complete, so it will be tried again ++ the next time control enters the declaration. ++ ++ In theory, this process should be thread-safe, too; multiple ++ threads should not be able to initialize the variable more ++ than once. We don't yet attempt to ensure thread-safety. */ ++ ++ /* Create the guard variable. */ ++ guard = get_guard (decl); ++ ++ /* Begin the conditional initialization. */ ++ if_stmt = begin_if_stmt (); ++ finish_if_stmt_cond (get_guard_cond (guard), if_stmt); ++ then_clause = begin_compound_stmt (/*has_no_scope=*/false); ++ ++ /* Do the initialization itself. */ ++ assignment = init ? init : NULL_TREE; ++ ++ /* Once the assignment is complete, set TEMP to 1. Since the ++ construction of the static object is complete at this point, ++ we want to make sure TEMP is set to 1 even if a temporary ++ constructed during the initialization throws an exception ++ when it is destroyed. So, we combine the initialization and ++ the assignment to TEMP into a single expression, ensuring ++ that when we call finish_expr_stmt the cleanups will not be ++ run until after TEMP is set to 1. */ ++ guard_init = set_guard (guard); ++ if (assignment) ++ assignment = build_compound_expr (assignment, guard_init); ++ else ++ assignment = guard_init; ++ finish_expr_stmt (assignment); ++ ++ /* Use atexit to register a function for destroying this static ++ variable. */ ++ register_dtor_fn (decl); ++ ++ finish_compound_stmt (then_clause); ++ finish_then_clause (if_stmt); ++ finish_if_stmt (); ++ } ++ else ++ static_aggregates = tree_cons (init, decl, static_aggregates); ++} ++ ++/* Finish the declaration of a catch-parameter. */ ++ ++tree ++start_handler_parms (tree declspecs, tree declarator) ++{ ++ tree decl; ++ if (declspecs) ++ { ++ decl = grokdeclarator (declarator, declspecs, CATCHPARM, ++ 1, NULL); ++ if (decl == NULL_TREE) ++ error ("invalid catch parameter"); ++ } ++ else ++ decl = NULL_TREE; ++ ++ return decl; ++} ++ ++ ++/* Make TYPE a complete type based on INITIAL_VALUE. ++ Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, ++ 2 if there was no information (in which case assume 0 if DO_DEFAULT). */ ++ ++int ++complete_array_type (tree type, tree initial_value, int do_default) ++{ ++ tree maxindex = NULL_TREE; ++ int value = 0; ++ ++ if (initial_value) ++ { ++ /* An array of character type can be initialized from a ++ brace-enclosed string constant. */ ++ if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))) ++ && TREE_CODE (initial_value) == CONSTRUCTOR ++ && CONSTRUCTOR_ELTS (initial_value) ++ && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value))) ++ == STRING_CST) ++ && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE) ++ initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)); ++ ++ /* Note MAXINDEX is really the maximum index, one less than the ++ size. */ ++ if (TREE_CODE (initial_value) == STRING_CST) ++ { ++ int eltsize ++ = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value))); ++ maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value) ++ / eltsize) - 1, 0); ++ } ++ else if (TREE_CODE (initial_value) == CONSTRUCTOR) ++ { ++ tree elts = CONSTRUCTOR_ELTS (initial_value); ++ ++ maxindex = ssize_int (-1); ++ for (; elts; elts = TREE_CHAIN (elts)) ++ { ++ if (TREE_PURPOSE (elts)) ++ maxindex = TREE_PURPOSE (elts); ++ else ++ maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1)); ++ } ++ maxindex = copy_node (maxindex); ++ } ++ else ++ { ++ /* Make an error message unless that happened already. */ ++ if (initial_value != error_mark_node) ++ value = 1; ++ else ++ initial_value = NULL_TREE; ++ ++ /* Prevent further error messages. */ ++ maxindex = build_int_2 (0, 0); ++ } ++ } ++ ++ if (!maxindex) ++ { ++ if (do_default) ++ maxindex = build_int_2 (0, 0); ++ value = 2; ++ } ++ ++ if (maxindex) ++ { ++ tree itype; ++ tree domain; ++ ++ domain = build_index_type (maxindex); ++ TYPE_DOMAIN (type) = domain; ++ ++ if (! TREE_TYPE (maxindex)) ++ TREE_TYPE (maxindex) = domain; ++ if (initial_value) ++ itype = TREE_TYPE (initial_value); ++ else ++ itype = NULL; ++ if (itype && !TYPE_DOMAIN (itype)) ++ TYPE_DOMAIN (itype) = domain; ++ /* The type of the main variant should never be used for arrays ++ of different sizes. It should only ever be completed with the ++ size of the array. */ ++ if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type))) ++ TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain; ++ } ++ ++ /* Lay out the type now that we can get the real answer. */ ++ ++ layout_type (type); ++ ++ return value; ++} ++ ++/* Return zero if something is declared to be a member of type ++ CTYPE when in the context of CUR_TYPE. STRING is the error ++ message to print in that case. Otherwise, quietly return 1. */ ++ ++static int ++member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags) ++{ ++ if (ctype && ctype != cur_type) ++ { ++ if (flags == DTOR_FLAG) ++ error ("destructor for alien class `%T' cannot be a member", ++ ctype); ++ else ++ error ("constructor for alien class `%T' cannot be a member", ++ ctype); ++ return 0; ++ } ++ return 1; ++} ++ ++/* Subroutine of `grokdeclarator'. */ ++ ++/* Generate errors possibly applicable for a given set of specifiers. ++ This is for ARM $7.1.2. */ ++ ++static void ++bad_specifiers (tree object, ++ const char* type, ++ int virtualp, ++ int quals, ++ int inlinep, ++ int friendp, ++ int raises) ++{ ++ if (virtualp) ++ error ("`%D' declared as a `virtual' %s", object, type); ++ if (inlinep) ++ error ("`%D' declared as an `inline' %s", object, type); ++ if (quals) ++ error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration", ++ object, type); ++ if (friendp) ++ cp_error_at ("`%D' declared as a friend", object); ++ if (raises ++ && (TREE_CODE (object) == TYPE_DECL ++ || (!TYPE_PTRFN_P (TREE_TYPE (object)) ++ && !TYPE_REFFN_P (TREE_TYPE (object)) ++ && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object))))) ++ cp_error_at ("`%D' declared with an exception specification", object); ++} ++ ++/* CTYPE is class type, or null if non-class. ++ TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE ++ or METHOD_TYPE. ++ DECLARATOR is the function's name. ++ PARMS is a chain of PARM_DECLs for the function. ++ VIRTUALP is truthvalue of whether the function is virtual or not. ++ FLAGS are to be passed through to `grokclassfn'. ++ QUALS are qualifiers indicating whether the function is `const' ++ or `volatile'. ++ RAISES is a list of exceptions that this function can raise. ++ CHECK is 1 if we must find this method in CTYPE, 0 if we should ++ not look, and -1 if we should not call `grokclassfn' at all. ++ ++ Returns `NULL_TREE' if something goes wrong, after issuing ++ applicable error messages. */ ++ ++static tree ++grokfndecl (tree ctype, ++ tree type, ++ tree declarator, ++ tree parms, ++ tree orig_declarator, ++ int virtualp, ++ enum overload_flags flags, ++ tree quals, ++ tree raises, ++ int check, ++ int friendp, ++ int publicp, ++ int inlinep, ++ int funcdef_flag, ++ int template_count, ++ tree in_namespace) ++{ ++ tree decl; ++ int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE; ++ int has_default_arg = 0; ++ tree t; ++ ++ if (raises) ++ type = build_exception_variant (type, raises); ++ ++ decl = build_lang_decl (FUNCTION_DECL, declarator, type); ++ DECL_ARGUMENTS (decl) = parms; ++ /* Propagate volatile out from type to decl. */ ++ if (TYPE_VOLATILE (type)) ++ TREE_THIS_VOLATILE (decl) = 1; ++ ++ /* If this decl has namespace scope, set that up. */ ++ if (in_namespace) ++ set_decl_namespace (decl, in_namespace, friendp); ++ else if (!ctype) ++ DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); ++ ++ /* `main' and builtins have implicit 'C' linkage. */ ++ if ((MAIN_NAME_P (declarator) ++ || (IDENTIFIER_LENGTH (declarator) > 10 ++ && IDENTIFIER_POINTER (declarator)[0] == '_' ++ && IDENTIFIER_POINTER (declarator)[1] == '_' ++ && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0)) ++ && current_lang_name == lang_name_cplusplus ++ && ctype == NULL_TREE ++ /* NULL_TREE means global namespace. */ ++ && DECL_CONTEXT (decl) == NULL_TREE) ++ SET_DECL_LANGUAGE (decl, lang_c); ++ ++ /* Should probably propagate const out from type to decl I bet (mrs). */ ++ if (staticp) ++ { ++ DECL_STATIC_FUNCTION_P (decl) = 1; ++ DECL_CONTEXT (decl) = ctype; ++ } ++ ++ if (ctype) ++ DECL_CONTEXT (decl) = ctype; ++ ++ if (ctype == NULL_TREE && DECL_MAIN_P (decl)) ++ { ++ if (processing_template_decl) ++ error ("cannot declare `::main' to be a template"); ++ if (inlinep) ++ error ("cannot declare `::main' to be inline"); ++ if (!publicp) ++ error ("cannot declare `::main' to be static"); ++ if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)), ++ integer_type_node)) ++ error ("`main' must return `int'"); ++ inlinep = 0; ++ publicp = 1; ++ } ++ ++ /* Members of anonymous types and local classes have no linkage; make ++ them internal. */ ++ /* FIXME what if it gets a name from typedef? */ ++ if (ctype && (TYPE_ANONYMOUS_P (ctype) ++ || decl_function_context (TYPE_MAIN_DECL (ctype)))) ++ publicp = 0; ++ ++ if (publicp) ++ { ++ /* [basic.link]: A name with no linkage (notably, the name of a class ++ or enumeration declared in a local scope) shall not be used to ++ declare an entity with linkage. ++ ++ Only check this for public decls for now. See core 319, 389. */ ++ t = no_linkage_check (TREE_TYPE (decl)); ++ if (t) ++ { ++ if (TYPE_ANONYMOUS_P (t)) ++ { ++ if (DECL_EXTERN_C_P (decl)) ++ /* Allow this; it's pretty common in C. */; ++ else ++ { ++ pedwarn ("non-local function `%#D' uses anonymous type", ++ decl); ++ if (DECL_ORIGINAL_TYPE (TYPE_NAME (t))) ++ cp_pedwarn_at ("\ ++`%#D' does not refer to the unqualified type, so it is not used for linkage", ++ TYPE_NAME (t)); ++ } ++ } ++ else ++ pedwarn ("non-local function `%#D' uses local type `%T'", ++ decl, t); ++ } ++ } ++ ++ TREE_PUBLIC (decl) = publicp; ++ if (! publicp) ++ { ++ DECL_INTERFACE_KNOWN (decl) = 1; ++ DECL_NOT_REALLY_EXTERN (decl) = 1; ++ } ++ ++ /* If the declaration was declared inline, mark it as such. */ ++ if (inlinep) ++ DECL_DECLARED_INLINE_P (decl) = 1; ++ /* We inline functions that are explicitly declared inline, or, when ++ the user explicitly asks us to, all functions. */ ++ if (DECL_DECLARED_INLINE_P (decl) ++ || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag)) ++ DECL_INLINE (decl) = 1; ++ ++ DECL_EXTERNAL (decl) = 1; ++ if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE) ++ { ++ error ("%smember function `%D' cannot have `%T' method qualifier", ++ (ctype ? "static " : "non-"), decl, TREE_VALUE (quals)); ++ quals = NULL_TREE; ++ } ++ ++ if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))) ++ grok_op_properties (decl, friendp, /*complain=*/true); ++ ++ if (ctype && decl_function_context (decl)) ++ DECL_NO_STATIC_CHAIN (decl) = 1; ++ ++ for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t)) ++ if (TREE_PURPOSE (t) ++ && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG) ++ { ++ has_default_arg = 1; ++ break; ++ } ++ ++ if (friendp ++ && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR) ++ { ++ if (funcdef_flag) ++ error ++ ("defining explicit specialization `%D' in friend declaration", ++ orig_declarator); ++ else ++ { ++ tree fns = TREE_OPERAND (orig_declarator, 0); ++ tree args = TREE_OPERAND (orig_declarator, 1); ++ ++ if (PROCESSING_REAL_TEMPLATE_DECL_P ()) ++ { ++ /* Something like `template friend void f()'. */ ++ error ("invalid use of template-id `%D' in declaration of primary template", ++ orig_declarator); ++ return NULL_TREE; ++ } ++ ++ ++ /* A friend declaration of the form friend void f<>(). Record ++ the information in the TEMPLATE_ID_EXPR. */ ++ SET_DECL_IMPLICIT_INSTANTIATION (decl); ++ ++ if (TREE_CODE (fns) == COMPONENT_REF) ++ { ++ /* Due to bison parser ickiness, we will have already looked ++ up an operator_name or PFUNCNAME within the current class ++ (see template_id in parse.y). If the current class contains ++ such a name, we'll get a COMPONENT_REF here. Undo that. */ ++ ++ my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0)) ++ == current_class_type, 20001120); ++ fns = TREE_OPERAND (fns, 1); ++ } ++ my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE ++ || TREE_CODE (fns) == OVERLOAD, 20001120); ++ DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE); ++ ++ if (has_default_arg) ++ { ++ error ("default arguments are not allowed in declaration of friend template specialization `%D'", ++ decl); ++ return NULL_TREE; ++ } ++ ++ if (inlinep) ++ { ++ error ("`inline' is not allowed in declaration of friend template specialization `%D'", ++ decl); ++ return NULL_TREE; ++ } ++ } ++ } ++ ++ if (funcdef_flag) ++ /* Make the init_value nonzero so pushdecl knows this is not ++ tentative. error_mark_node is replaced later with the BLOCK. */ ++ DECL_INITIAL (decl) = error_mark_node; ++ ++ if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl)) ++ TREE_NOTHROW (decl) = 1; ++ ++ /* Caller will do the rest of this. */ ++ if (check < 0) ++ return decl; ++ ++ if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype)) ++ DECL_CONSTRUCTOR_P (decl) = 1; ++ ++ /* Function gets the ugly name, field gets the nice one. This call ++ may change the type of the function (because of default ++ parameters)! */ ++ if (ctype != NULL_TREE) ++ grokclassfn (ctype, decl, flags, quals); ++ ++ decl = check_explicit_specialization (orig_declarator, decl, ++ template_count, ++ 2 * (funcdef_flag != 0) + ++ 4 * (friendp != 0)); ++ if (decl == error_mark_node) ++ return NULL_TREE; ++ ++ if (ctype != NULL_TREE ++ && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl)) ++ && check) ++ { ++ tree old_decl; ++ ++ old_decl = check_classfn (ctype, decl, ++ processing_template_decl ++ > template_class_depth (ctype)); ++ ++ if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL) ++ /* Because grokfndecl is always supposed to return a ++ FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT ++ here. We depend on our callers to figure out that its ++ really a template that's being returned. */ ++ old_decl = DECL_TEMPLATE_RESULT (old_decl); ++ ++ if (old_decl && DECL_STATIC_FUNCTION_P (old_decl) ++ && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) ++ /* Remove the `this' parm added by grokclassfn. ++ XXX Isn't this done in start_function, too? */ ++ revert_static_member_fn (decl); ++ if (old_decl && DECL_ARTIFICIAL (old_decl)) ++ error ("definition of implicitly-declared `%D'", old_decl); ++ ++ if (old_decl) ++ { ++ tree ok; ++ bool pop_p; ++ ++ /* Since we've smashed OLD_DECL to its ++ DECL_TEMPLATE_RESULT, we must do the same to DECL. */ ++ if (TREE_CODE (decl) == TEMPLATE_DECL) ++ decl = DECL_TEMPLATE_RESULT (decl); ++ ++ /* Attempt to merge the declarations. This can fail, in ++ the case of some invalid specialization declarations. */ ++ pop_p = push_scope (ctype); ++ ok = duplicate_decls (decl, old_decl); ++ if (pop_p) ++ pop_scope (ctype); ++ if (!ok) ++ { ++ error ("no `%#D' member function declared in class `%T'", ++ decl, ctype); ++ return NULL_TREE; ++ } ++ return old_decl; ++ } ++ } ++ ++ if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl)) ++ return NULL_TREE; ++ ++ if (ctype == NULL_TREE || check) ++ return decl; ++ ++ if (virtualp) ++ DECL_VIRTUAL_P (decl) = 1; ++ ++ return decl; ++} ++ ++/* Create a VAR_DECL named NAME with the indicated TYPE. ++ ++ If SCOPE is non-NULL, it is the class type or namespace containing ++ the variable. If SCOPE is NULL, the variable should is created in ++ the innermost enclosings scope. */ ++ ++static tree ++grokvardecl (tree type, ++ tree name, ++ RID_BIT_TYPE * specbits_in, ++ int initialized, ++ int constp, ++ tree scope) ++{ ++ tree decl; ++ RID_BIT_TYPE specbits; ++ ++ my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE, ++ 20020808); ++ ++ specbits = *specbits_in; ++ ++ /* Compute the scope in which to place the variable. */ ++ if (!scope) ++ { ++ /* An explicit "extern" specifier indicates a namespace-scope ++ variable. */ ++ if (RIDBIT_SETP (RID_EXTERN, specbits)) ++ scope = current_namespace; ++ else if (!at_function_scope_p ()) ++ { ++ scope = current_scope (); ++ if (!scope) ++ scope = current_namespace; ++ } ++ } ++ ++ if (scope ++ && (/* If the variable is a namespace-scope variable declared in a ++ template, we need DECL_LANG_SPECIFIC. */ ++ (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl) ++ /* Similarly for namespace-scope variables with language linkage ++ other than C++. */ ++ || (TREE_CODE (scope) == NAMESPACE_DECL ++ && current_lang_name != lang_name_cplusplus) ++ /* Similarly for static data members. */ ++ || TYPE_P (scope))) ++ decl = build_lang_decl (VAR_DECL, name, type); ++ else ++ decl = build_decl (VAR_DECL, name, type); ++ ++ if (scope && TREE_CODE (scope) == NAMESPACE_DECL) ++ set_decl_namespace (decl, scope, 0); ++ else ++ DECL_CONTEXT (decl) = scope; ++ ++ if (name && scope && current_lang_name != lang_name_c) ++ /* We can't mangle lazily here because we don't have any ++ way to recover whether or not a variable was `extern ++ "C"' later. */ ++ mangle_decl (decl); ++ ++ if (RIDBIT_SETP (RID_EXTERN, specbits)) ++ { ++ DECL_THIS_EXTERN (decl) = 1; ++ DECL_EXTERNAL (decl) = !initialized; ++ } ++ ++ /* In class context, static means one per class, ++ public access, and static storage. */ ++ if (DECL_CLASS_SCOPE_P (decl)) ++ { ++ TREE_PUBLIC (decl) = 1; ++ TREE_STATIC (decl) = 1; ++ DECL_EXTERNAL (decl) = 0; ++ } ++ /* At top level, either `static' or no s.c. makes a definition ++ (perhaps tentative), and absence of `static' makes it public. */ ++ else if (toplevel_bindings_p ()) ++ { ++ TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits) ++ && (DECL_THIS_EXTERN (decl) || ! constp)); ++ TREE_STATIC (decl) = ! DECL_EXTERNAL (decl); ++ } ++ /* Not at top level, only `static' makes a static definition. */ ++ else ++ { ++ TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits); ++ TREE_PUBLIC (decl) = DECL_EXTERNAL (decl); ++ } ++ ++ if (RIDBIT_SETP (RID_THREAD, specbits)) ++ { ++ if (targetm.have_tls) ++ DECL_THREAD_LOCAL (decl) = 1; ++ else ++ /* A mere warning is sure to result in improper semantics ++ at runtime. Don't bother to allow this to compile. */ ++ error ("thread-local storage not supported for this target"); ++ } ++ ++ if (TREE_PUBLIC (decl)) ++ { ++ /* [basic.link]: A name with no linkage (notably, the name of a class ++ or enumeration declared in a local scope) shall not be used to ++ declare an entity with linkage. ++ ++ Only check this for public decls for now. */ ++ tree t = no_linkage_check (TREE_TYPE (decl)); ++ if (t) ++ { ++ if (TYPE_ANONYMOUS_P (t)) ++ /* Ignore for now; `enum { foo } e' is pretty common. */; ++ else ++ pedwarn ("non-local variable `%#D' uses local type `%T'", ++ decl, t); ++ } ++ } ++ ++ return decl; ++} ++ ++/* Create and return a canonical pointer to member function type, for ++ TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */ ++ ++tree ++build_ptrmemfunc_type (tree type) ++{ ++ tree field, fields; ++ tree t; ++ tree unqualified_variant = NULL_TREE; ++ ++ if (type == error_mark_node) ++ return type; ++ ++ /* If a canonical type already exists for this type, use it. We use ++ this method instead of type_hash_canon, because it only does a ++ simple equality check on the list of field members. */ ++ ++ if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type))) ++ return t; ++ ++ /* Make sure that we always have the unqualified pointer-to-member ++ type first. */ ++ if (cp_type_quals (type) != TYPE_UNQUALIFIED) ++ unqualified_variant ++ = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type)); ++ ++ t = make_aggr_type (RECORD_TYPE); ++ /* Let the front-end know this is a pointer to member function... */ ++ TYPE_PTRMEMFUNC_FLAG (t) = 1; ++ /* ... and not really an aggregate. */ ++ SET_IS_AGGR_TYPE (t, 0); ++ ++ field = build_decl (FIELD_DECL, pfn_identifier, type); ++ fields = field; ++ ++ field = build_decl (FIELD_DECL, delta_identifier, delta_type_node); ++ TREE_CHAIN (field) = fields; ++ fields = field; ++ ++ finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node); ++ ++ /* Zap out the name so that the back-end will give us the debugging ++ information for this anonymous RECORD_TYPE. */ ++ TYPE_NAME (t) = NULL_TREE; ++ ++ /* If this is not the unqualified form of this pointer-to-member ++ type, set the TYPE_MAIN_VARIANT for this type to be the ++ unqualified type. Since they are actually RECORD_TYPEs that are ++ not variants of each other, we must do this manually. */ ++ if (cp_type_quals (type) != TYPE_UNQUALIFIED) ++ { ++ t = build_qualified_type (t, cp_type_quals (type)); ++ TYPE_MAIN_VARIANT (t) = unqualified_variant; ++ TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant); ++ TYPE_NEXT_VARIANT (unqualified_variant) = t; ++ } ++ ++ /* Cache this pointer-to-member type so that we can find it again ++ later. */ ++ TYPE_SET_PTRMEMFUNC_TYPE (type, t); ++ ++ return t; ++} ++ ++/* Create and return a pointer to data member type. */ ++ ++tree ++build_ptrmem_type (tree class_type, tree member_type) ++{ ++ if (TREE_CODE (member_type) == METHOD_TYPE) ++ { ++ tree arg_types; ++ ++ arg_types = TYPE_ARG_TYPES (member_type); ++ class_type = (cp_build_qualified_type ++ (class_type, ++ cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types))))); ++ member_type ++ = build_method_type_directly (class_type, ++ TREE_TYPE (member_type), ++ TREE_CHAIN (arg_types)); ++ return build_ptrmemfunc_type (build_pointer_type (member_type)); ++ } ++ else ++ { ++ my_friendly_assert (TREE_CODE (member_type) != FUNCTION_TYPE, ++ 20030716); ++ return build_offset_type (class_type, member_type); ++ } ++} ++ ++/* DECL is a VAR_DECL defined in-class, whose TYPE is also given. ++ Check to see that the definition is valid. Issue appropriate error ++ messages. Return 1 if the definition is particularly bad, or 0 ++ otherwise. */ ++ ++int ++check_static_variable_definition (tree decl, tree type) ++{ ++ /* Motion 10 at San Diego: If a static const integral data member is ++ initialized with an integral constant expression, the initializer ++ may appear either in the declaration (within the class), or in ++ the definition, but not both. If it appears in the class, the ++ member is a member constant. The file-scope definition is always ++ required. */ ++ if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE) ++ { ++ error ("invalid in-class initialization of static data member of non-integral type `%T'", ++ type); ++ /* If we just return the declaration, crashes will sometimes ++ occur. We therefore return void_type_node, as if this was a ++ friend declaration, to cause callers to completely ignore ++ this declaration. */ ++ return 1; ++ } ++ else if (!CP_TYPE_CONST_P (type)) ++ error ("ISO C++ forbids in-class initialization of non-const static member `%D'", ++ decl); ++ else if (pedantic && !INTEGRAL_TYPE_P (type)) ++ pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type); ++ ++ return 0; ++} ++ ++/* Given the SIZE (i.e., number of elements) in an array, compute an ++ appropriate index type for the array. If non-NULL, NAME is the ++ name of the thing being declared. */ ++ ++tree ++compute_array_index_type (tree name, tree size) ++{ ++ tree type = TREE_TYPE (size); ++ tree itype; ++ ++ /* The array bound must be an integer type. */ ++ if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type)) ++ { ++ if (name) ++ error ("size of array `%D' has non-integral type `%T'", name, type); ++ else ++ error ("size of array has non-integral type `%T'", type); ++ size = integer_one_node; ++ type = TREE_TYPE (size); ++ } ++ ++ if (abi_version_at_least (2) ++ /* We should only handle value dependent expressions specially. */ ++ ? value_dependent_expression_p (size) ++ /* But for abi-1, we handled all instances in templates. This ++ effects the manglings produced. */ ++ : processing_template_decl) ++ return build_index_type (build_min (MINUS_EXPR, sizetype, ++ size, integer_one_node)); ++ ++ /* The size might be the result of a cast. */ ++ STRIP_TYPE_NOPS (size); ++ ++ /* It might be a const variable or enumeration constant. */ ++ size = decl_constant_value (size); ++ ++ /* Normally, the array-bound will be a constant. */ ++ if (TREE_CODE (size) == INTEGER_CST) ++ { ++ /* Check to see if the array bound overflowed. Make that an ++ error, no matter how generous we're being. */ ++ int old_flag_pedantic_errors = flag_pedantic_errors; ++ int old_pedantic = pedantic; ++ pedantic = flag_pedantic_errors = 1; ++ constant_expression_warning (size); ++ pedantic = old_pedantic; ++ flag_pedantic_errors = old_flag_pedantic_errors; ++ ++ /* An array must have a positive number of elements. */ ++ if (INT_CST_LT (size, integer_zero_node)) ++ { ++ if (name) ++ error ("size of array `%D' is negative", name); ++ else ++ error ("size of array is negative"); ++ size = integer_one_node; ++ } ++ /* As an extension we allow zero-sized arrays. We always allow ++ them in system headers because glibc uses them. */ ++ else if (integer_zerop (size) && pedantic && !in_system_header) ++ { ++ if (name) ++ pedwarn ("ISO C++ forbids zero-size array `%D'", name); ++ else ++ pedwarn ("ISO C++ forbids zero-size array"); ++ } ++ } ++ else if (TREE_CONSTANT (size)) ++ { ++ /* `(int) &fn' is not a valid array bound. */ ++ if (name) ++ error ("size of array `%D' is not an integral constant-expression", ++ name); ++ else ++ error ("size of array is not an integral constant-expression"); ++ } ++ else if (pedantic) ++ { ++ if (name) ++ pedwarn ("ISO C++ forbids variable-size array `%D'", name); ++ else ++ pedwarn ("ISO C++ forbids variable-size array"); ++ } ++ ++ if (processing_template_decl && !TREE_CONSTANT (size)) ++ /* A variable sized array. */ ++ itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node); ++ else ++ { ++ /* Compute the index of the largest element in the array. It is ++ one less than the number of elements in the array. */ ++ itype ++ = fold (cp_build_binary_op (MINUS_EXPR, ++ cp_convert (ssizetype, size), ++ cp_convert (ssizetype, integer_one_node))); ++ if (!TREE_CONSTANT (itype)) ++ /* A variable sized array. */ ++ itype = variable_size (itype); ++ /* Make sure that there was no overflow when creating to a signed ++ index type. (For example, on a 32-bit machine, an array with ++ size 2^32 - 1 is too big.) */ ++ else if (TREE_OVERFLOW (itype)) ++ { ++ error ("overflow in array dimension"); ++ TREE_OVERFLOW (itype) = 0; ++ } ++ } ++ ++ /* Create and return the appropriate index type. */ ++ return build_index_type (itype); ++} ++ ++/* Returns the scope (if any) in which the entity declared by ++ DECLARATOR will be located. If the entity was declared with an ++ unqualified name, NULL_TREE is returned. */ ++ ++tree ++get_scope_of_declarator (tree declarator) ++{ ++ if (!declarator) ++ return NULL_TREE; ++ ++ switch (TREE_CODE (declarator)) ++ { ++ case CALL_EXPR: ++ case ARRAY_REF: ++ case INDIRECT_REF: ++ case ADDR_EXPR: ++ /* For any of these, the main declarator is the first operand. */ ++ return get_scope_of_declarator (TREE_OPERAND ++ (declarator, 0)); ++ ++ case SCOPE_REF: ++ /* For a pointer-to-member, continue descending. */ ++ if (TREE_CODE (TREE_OPERAND (declarator, 1)) ++ == INDIRECT_REF) ++ return get_scope_of_declarator (TREE_OPERAND ++ (declarator, 1)); ++ /* Otherwise, if the declarator-id is a SCOPE_REF, the scope in ++ which the declaration occurs is the first operand. */ ++ return TREE_OPERAND (declarator, 0); ++ ++ case TREE_LIST: ++ /* Attributes to be applied. The declarator is TREE_VALUE. */ ++ return get_scope_of_declarator (TREE_VALUE (declarator)); ++ ++ default: ++ /* Otherwise, we have a declarator-id which is not a qualified ++ name; the entity will be declared in the current scope. */ ++ return NULL_TREE; ++ } ++} ++ ++/* Returns an ARRAY_TYPE for an array with SIZE elements of the ++ indicated TYPE. If non-NULL, NAME is the NAME of the declaration ++ with this type. */ ++ ++static tree ++create_array_type_for_decl (tree name, tree type, tree size) ++{ ++ tree itype = NULL_TREE; ++ const char* error_msg; ++ ++ /* If things have already gone awry, bail now. */ ++ if (type == error_mark_node || size == error_mark_node) ++ return error_mark_node; ++ ++ /* Assume that everything will go OK. */ ++ error_msg = NULL; ++ ++ /* There are some types which cannot be array elements. */ ++ switch (TREE_CODE (type)) ++ { ++ case VOID_TYPE: ++ error_msg = "array of void"; ++ break; ++ ++ case FUNCTION_TYPE: ++ error_msg = "array of functions"; ++ break; ++ ++ case REFERENCE_TYPE: ++ error_msg = "array of references"; ++ break; ++ ++ case METHOD_TYPE: ++ error_msg = "array of function members"; ++ break; ++ ++ default: ++ break; ++ } ++ ++ /* If something went wrong, issue an error-message and return. */ ++ if (error_msg) ++ { ++ if (name) ++ error ("declaration of `%D' as %s", name, error_msg); ++ else ++ error ("creating %s", error_msg); ++ ++ return error_mark_node; ++ } ++ ++ /* [dcl.array] ++ ++ The constant expressions that specify the bounds of the arrays ++ can be omitted only for the first member of the sequence. */ ++ if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)) ++ { ++ if (name) ++ error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first", ++ name); ++ else ++ error ("multidimensional array must have bounds for all dimensions except the first"); ++ ++ return error_mark_node; ++ } ++ ++ /* Figure out the index type for the array. */ ++ if (size) ++ itype = compute_array_index_type (name, size); ++ ++ return build_cplus_array_type (type, itype); ++} ++ ++/* Check that it's OK to declare a function with the indicated TYPE. ++ SFK indicates the kind of special function (if any) that this ++ function is. OPTYPE is the type given in a conversion operator ++ declaration. Returns the actual return type of the function; that ++ may be different than TYPE if an error occurs, or for certain ++ special functions. */ ++ ++static tree ++check_special_function_return_type (special_function_kind sfk, ++ tree type, ++ tree optype) ++{ ++ switch (sfk) ++ { ++ case sfk_constructor: ++ if (type) ++ error ("return type specification for constructor invalid"); ++ ++ type = void_type_node; ++ break; ++ ++ case sfk_destructor: ++ if (type) ++ error ("return type specification for destructor invalid"); ++ type = void_type_node; ++ break; ++ ++ case sfk_conversion: ++ if (type && !same_type_p (type, optype)) ++ error ("operator `%T' declared to return `%T'", optype, type); ++ else if (type) ++ pedwarn ("return type specified for `operator %T'", optype); ++ type = optype; ++ break; ++ ++ default: ++ abort (); ++ break; ++ } ++ ++ return type; ++} ++ ++/* A variable or data member (whose unqualified name is IDENTIFIER) ++ has been declared with the indicated TYPE. If the TYPE is not ++ acceptable, issue an error message and return a type to use for ++ error-recovery purposes. */ ++ ++tree ++check_var_type (tree identifier, tree type) ++{ ++ if (VOID_TYPE_P (type)) ++ { ++ if (!identifier) ++ error ("unnamed variable or field declared void"); ++ else if (TREE_CODE (identifier) == IDENTIFIER_NODE) ++ { ++ if (IDENTIFIER_OPNAME_P (identifier)) ++ abort (); ++ error ("variable or field `%E' declared void", identifier); ++ } ++ else ++ error ("variable or field declared void"); ++ type = integer_type_node; ++ } ++ ++ return type; ++} ++ ++/* Given declspecs and a declarator (abstract or otherwise), determine ++ the name and type of the object declared and construct a DECL node ++ for it. ++ ++ DECLSPECS is a chain of tree_list nodes whose value fields ++ are the storage classes and type specifiers. ++ ++ DECL_CONTEXT says which syntactic context this declaration is in: ++ NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL. ++ FUNCDEF for a function definition. Like NORMAL but a few different ++ error messages in each case. Return value may be zero meaning ++ this definition is too screwy to try to parse. ++ MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to ++ handle member functions (which have FIELD context). ++ Return value may be zero meaning this definition is too screwy to ++ try to parse. ++ PARM for a parameter declaration (either within a function prototype ++ or before a function body). Make a PARM_DECL, or return void_type_node. ++ CATCHPARM for a parameter declaration before a catch clause. ++ TYPENAME if for a typename (in a cast or sizeof). ++ Don't make a DECL node; just return the ..._TYPE node. ++ FIELD for a struct or union field; make a FIELD_DECL. ++ BITFIELD for a field with specified width. ++ INITIALIZED is 1 if the decl has an initializer. ++ ++ ATTRLIST is a pointer to the list of attributes, which may be NULL ++ if there are none; *ATTRLIST may be modified if attributes from inside ++ the declarator should be applied to the declaration. ++ ++ When this function is called, scoping variables (such as ++ CURRENT_CLASS_TYPE) should reflect the scope in which the ++ declaration occurs, not the scope in which the new declaration will ++ be placed. For example, on: ++ ++ void S::f() { ... } ++ ++ when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE ++ should not be `S'. */ ++ ++tree ++grokdeclarator (tree declarator, ++ tree declspecs, ++ enum decl_context decl_context, ++ int initialized, ++ tree* attrlist) ++{ ++ RID_BIT_TYPE specbits; ++ int nclasses = 0; ++ tree spec; ++ tree type = NULL_TREE; ++ int longlong = 0; ++ int type_quals; ++ int virtualp, explicitp, friendp, inlinep, staticp; ++ int explicit_int = 0; ++ int explicit_char = 0; ++ int defaulted_int = 0; ++ int extern_langp = 0; ++ tree dependant_name = NULL_TREE; ++ ++ tree typedef_decl = NULL_TREE; ++ const char *name; ++ tree typedef_type = NULL_TREE; ++ int funcdef_flag = 0; ++ enum tree_code innermost_code = ERROR_MARK; ++ int bitfield = 0; ++#if 0 ++ /* See the code below that used this. */ ++ tree decl_attr = NULL_TREE; ++#endif ++ ++ /* Keep track of what sort of function is being processed ++ so that we can warn about default return values, or explicit ++ return values which do not match prescribed defaults. */ ++ special_function_kind sfk = sfk_none; ++ ++ tree dname = NULL_TREE; ++ tree ctype = current_class_type; ++ tree ctor_return_type = NULL_TREE; ++ enum overload_flags flags = NO_SPECIAL; ++ tree quals = NULL_TREE; ++ tree raises = NULL_TREE; ++ int template_count = 0; ++ tree in_namespace = NULL_TREE; ++ tree returned_attrs = NULL_TREE; ++ tree scope = NULL_TREE; ++ tree parms = NULL_TREE; ++ ++ RIDBIT_RESET_ALL (specbits); ++ if (decl_context == FUNCDEF) ++ funcdef_flag = 1, decl_context = NORMAL; ++ else if (decl_context == MEMFUNCDEF) ++ funcdef_flag = -1, decl_context = FIELD; ++ else if (decl_context == BITFIELD) ++ bitfield = 1, decl_context = FIELD; ++ ++ /* Look inside a declarator for the name being declared ++ and get it as a string, for an error message. */ ++ { ++ tree *next = &declarator; ++ tree decl; ++ name = NULL; ++ ++ while (next && *next) ++ { ++ decl = *next; ++ switch (TREE_CODE (decl)) ++ { ++ case TREE_LIST: ++ /* For attributes. */ ++ next = &TREE_VALUE (decl); ++ break; ++ ++ case COND_EXPR: ++ ctype = NULL_TREE; ++ next = &TREE_OPERAND (decl, 0); ++ break; ++ ++ case BIT_NOT_EXPR: /* For C++ destructors! */ ++ { ++ tree name = TREE_OPERAND (decl, 0); ++ tree rename = NULL_TREE; ++ ++ my_friendly_assert (flags == NO_SPECIAL, 152); ++ flags = DTOR_FLAG; ++ sfk = sfk_destructor; ++ if (TYPE_P (name)) ++ TREE_OPERAND (decl, 0) = name = constructor_name (name); ++ my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153); ++ if (ctype == NULL_TREE) ++ { ++ if (current_class_type == NULL_TREE) ++ { ++ error ("destructors must be member functions"); ++ flags = NO_SPECIAL; ++ } ++ else ++ { ++ tree t = constructor_name (current_class_type); ++ if (t != name) ++ rename = t; ++ } ++ } ++ else ++ { ++ tree t = constructor_name (ctype); ++ if (t != name) ++ rename = t; ++ } ++ ++ if (rename) ++ { ++ error ("destructor `%T' must match class name `%T'", ++ name, rename); ++ TREE_OPERAND (decl, 0) = rename; ++ } ++ next = &name; ++ } ++ break; ++ ++ case ADDR_EXPR: /* C++ reference declaration */ ++ /* Fall through. */ ++ case ARRAY_REF: ++ case INDIRECT_REF: ++ ctype = NULL_TREE; ++ innermost_code = TREE_CODE (decl); ++ next = &TREE_OPERAND (decl, 0); ++ break; ++ ++ case CALL_EXPR: ++ innermost_code = TREE_CODE (decl); ++ if (decl_context == FIELD && ctype == NULL_TREE) ++ ctype = current_class_type; ++ if (ctype ++ && TREE_OPERAND (decl, 0) ++ && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL ++ && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)), ++ ctype))) ++ TREE_OPERAND (decl, 0) = constructor_name (ctype); ++ next = &TREE_OPERAND (decl, 0); ++ decl = *next; ++ if (ctype != NULL_TREE ++ && decl != NULL_TREE && flags != DTOR_FLAG ++ && constructor_name_p (decl, ctype)) ++ { ++ sfk = sfk_constructor; ++ ctor_return_type = ctype; ++ } ++ ctype = NULL_TREE; ++ break; ++ ++ case TEMPLATE_ID_EXPR: ++ { ++ tree fns = TREE_OPERAND (decl, 0); ++ ++ dname = fns; ++ if (TREE_CODE (dname) == COMPONENT_REF) ++ dname = TREE_OPERAND (dname, 1); ++ if (TREE_CODE (dname) != IDENTIFIER_NODE) ++ { ++ my_friendly_assert (is_overloaded_fn (dname), ++ 19990331); ++ dname = DECL_NAME (get_first_fn (dname)); ++ } ++ } ++ /* Fall through. */ ++ ++ case IDENTIFIER_NODE: ++ if (TREE_CODE (decl) == IDENTIFIER_NODE) ++ dname = decl; ++ ++ next = 0; ++ ++ if (C_IS_RESERVED_WORD (dname)) ++ { ++ error ("declarator-id missing; using reserved word `%D'", ++ dname); ++ name = IDENTIFIER_POINTER (dname); ++ } ++ else if (!IDENTIFIER_TYPENAME_P (dname)) ++ name = IDENTIFIER_POINTER (dname); ++ else ++ { ++ my_friendly_assert (flags == NO_SPECIAL, 154); ++ flags = TYPENAME_FLAG; ++ ctor_return_type = TREE_TYPE (dname); ++ sfk = sfk_conversion; ++ if (is_typename_at_global_scope (dname)) ++ name = IDENTIFIER_POINTER (dname); ++ else ++ name = ""; ++ } ++ break; ++ ++ /* C++ extension */ ++ case SCOPE_REF: ++ { ++ /* Perform error checking, and decide on a ctype. */ ++ tree cname = TREE_OPERAND (decl, 0); ++ if (cname == NULL_TREE) ++ ctype = NULL_TREE; ++ else if (TREE_CODE (cname) == NAMESPACE_DECL) ++ { ++ ctype = NULL_TREE; ++ in_namespace = TREE_OPERAND (decl, 0); ++ } ++ else if (! is_aggr_type (cname, 1)) ++ ctype = NULL_TREE; ++ /* Must test TREE_OPERAND (decl, 1), in case user gives ++ us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */ ++ else if (TREE_OPERAND (decl, 1) ++ && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF) ++ ctype = cname; ++ else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM ++ || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM) ++ { ++ /* This might be declaring a member of a template ++ parm to be a friend. */ ++ ctype = cname; ++ dependant_name = TREE_OPERAND (decl, 1); ++ } ++ else if (ctype == NULL_TREE) ++ ctype = cname; ++ else if (TREE_COMPLEXITY (decl) == current_class_depth) ++ ; ++ else ++ { ++ if (! UNIQUELY_DERIVED_FROM_P (cname, ctype)) ++ { ++ error ("type `%T' is not derived from type `%T'", ++ cname, ctype); ++ ctype = NULL_TREE; ++ } ++ else ++ ctype = cname; ++ } ++ ++ /* It is valid to write: ++ ++ class C { void f(); }; ++ typedef C D; ++ void D::f(); ++ ++ The standard is not clear about whether `typedef const C D' is ++ legal; as of 2002-09-15 the committee is considering ++ that question. EDG 3.0 allows that syntax. ++ Therefore, we do as well. */ ++ if (ctype) ++ ctype = TYPE_MAIN_VARIANT (ctype); ++ /* Update the declarator so that when we process it ++ again the correct type is present. */ ++ TREE_OPERAND (decl, 0) = ctype; ++ ++ if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL ++ && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)), ++ ctype)) ++ TREE_OPERAND (decl, 1) = constructor_name (ctype); ++ next = &TREE_OPERAND (decl, 1); ++ decl = *next; ++ if (ctype) ++ { ++ tree name = decl; ++ ++ if (TREE_CODE (name) == BIT_NOT_EXPR) ++ name = TREE_OPERAND (name, 0); ++ ++ if (!constructor_name_p (decl, ctype)) ++ ; ++ else if (decl == name) ++ { ++ sfk = sfk_constructor; ++ ctor_return_type = ctype; ++ } ++ else ++ { ++ sfk = sfk_destructor; ++ ctor_return_type = ctype; ++ flags = DTOR_FLAG; ++ TREE_OPERAND (decl, 0) = constructor_name (ctype); ++ next = &TREE_OPERAND (decl, 0); ++ } ++ } ++ } ++ break; ++ ++ case ERROR_MARK: ++ next = 0; ++ break; ++ ++ case TYPE_DECL: ++ /* Parse error puts this typespec where ++ a declarator should go. */ ++ error ("`%T' specified as declarator-id", DECL_NAME (decl)); ++ if (TREE_TYPE (decl) == current_class_type) ++ error (" perhaps you want `%T' for a constructor", ++ current_class_name); ++ dname = DECL_NAME (decl); ++ name = IDENTIFIER_POINTER (dname); ++ ++ /* Avoid giving two errors for this. */ ++ IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE; ++ ++ declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs); ++ *next = dname; ++ next = 0; ++ break; ++ ++ case BASELINK: ++ next = &BASELINK_FUNCTIONS (decl); ++ break; ++ ++ case TEMPLATE_DECL: ++ /* Sometimes, we see a template-name used as part of a ++ decl-specifier like in ++ std::allocator alloc; ++ Handle that gracefully. */ ++ error ("invalid use of template-name '%E' in a declarator", decl); ++ return error_mark_node; ++ break; ++ ++ default: ++ my_friendly_assert (0, 20020917); ++ } ++ } ++ } ++ ++ /* A function definition's declarator must have the form of ++ a function declarator. */ ++ ++ if (funcdef_flag && innermost_code != CALL_EXPR) ++ return 0; ++ ++ if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG) ++ && innermost_code != CALL_EXPR ++ && ! (ctype && declspecs == NULL_TREE)) ++ { ++ error ("declaration of `%D' as non-function", dname); ++ return void_type_node; ++ } ++ ++ /* Anything declared one level down from the top level ++ must be one of the parameters of a function ++ (because the body is at least two levels down). */ ++ ++ /* This heuristic cannot be applied to C++ nodes! Fixed, however, ++ by not allowing C++ class definitions to specify their parameters ++ with xdecls (must be spec.d in the parmlist). ++ ++ Since we now wait to push a class scope until we are sure that ++ we are in a legitimate method context, we must set oldcname ++ explicitly (since current_class_name is not yet alive). ++ ++ We also want to avoid calling this a PARM if it is in a namespace. */ ++ ++ if (decl_context == NORMAL && !toplevel_bindings_p ()) ++ { ++ struct cp_binding_level *b = current_binding_level; ++ current_binding_level = b->level_chain; ++ if (current_binding_level != 0 && toplevel_bindings_p ()) ++ decl_context = PARM; ++ current_binding_level = b; ++ } ++ ++ if (name == NULL) ++ name = decl_context == PARM ? "parameter" : "type name"; ++ ++ /* Look through the decl specs and record which ones appear. ++ Some typespecs are defined as built-in typenames. ++ Others, the ones that are modifiers of other types, ++ are represented by bits in SPECBITS: set the bits for ++ the modifiers that appear. Storage class keywords are also in SPECBITS. ++ ++ If there is a typedef name or a type, store the type in TYPE. ++ This includes builtin typedefs such as `int'. ++ ++ Set EXPLICIT_INT if the type is `int' or `char' and did not ++ come from a user typedef. ++ ++ Set LONGLONG if `long' is mentioned twice. ++ ++ For C++, constructors and destructors have their own fast treatment. */ ++ ++ for (spec = declspecs; spec; spec = TREE_CHAIN (spec)) ++ { ++ int i; ++ tree id; ++ ++ /* Certain parse errors slip through. For example, ++ `int class;' is not caught by the parser. Try ++ weakly to recover here. */ ++ if (TREE_CODE (spec) != TREE_LIST) ++ return 0; ++ ++ id = TREE_VALUE (spec); ++ ++ /* If the entire declaration is itself tagged as deprecated then ++ suppress reports of deprecated items. */ ++ if (!adding_implicit_members && id && TREE_DEPRECATED (id)) ++ { ++ if (deprecated_state != DEPRECATED_SUPPRESS) ++ warn_deprecated_use (id); ++ } ++ ++ if (TREE_CODE (id) == IDENTIFIER_NODE) ++ { ++ if (id == ridpointers[(int) RID_INT] ++ || id == ridpointers[(int) RID_CHAR] ++ || id == ridpointers[(int) RID_BOOL] ++ || id == ridpointers[(int) RID_WCHAR]) ++ { ++ if (type) ++ { ++ if (id == ridpointers[(int) RID_BOOL]) ++ error ("`bool' is now a keyword"); ++ else ++ error ("extraneous `%T' ignored", id); ++ } ++ else ++ { ++ if (id == ridpointers[(int) RID_INT]) ++ explicit_int = 1; ++ else if (id == ridpointers[(int) RID_CHAR]) ++ explicit_char = 1; ++ type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id)); ++ } ++ goto found; ++ } ++ /* C++ aggregate types. */ ++ if (IDENTIFIER_HAS_TYPE_VALUE (id)) ++ { ++ if (type) ++ error ("multiple declarations `%T' and `%T'", type, id); ++ else ++ type = IDENTIFIER_TYPE_VALUE (id); ++ goto found; ++ } ++ ++ for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++) ++ { ++ if (ridpointers[i] == id) ++ { ++ if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits)) ++ { ++ if (pedantic && ! in_system_header && warn_long_long) ++ pedwarn ("ISO C++ does not support `long long'"); ++ if (longlong) ++ error ("`long long long' is too long for GCC"); ++ else ++ longlong = 1; ++ } ++ else if (RIDBIT_SETP (i, specbits)) ++ pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id)); ++ ++ /* Diagnose "__thread extern" or "__thread static". */ ++ if (RIDBIT_SETP (RID_THREAD, specbits)) ++ { ++ if (i == (int)RID_EXTERN) ++ error ("`__thread' before `extern'"); ++ else if (i == (int)RID_STATIC) ++ error ("`__thread' before `static'"); ++ } ++ ++ if (i == (int)RID_EXTERN ++ && TREE_PURPOSE (spec) == error_mark_node) ++ /* This extern was part of a language linkage. */ ++ extern_langp = 1; ++ ++ RIDBIT_SET (i, specbits); ++ goto found; ++ } ++ } ++ } ++ else if (TREE_CODE (id) == TYPE_DECL) ++ { ++ if (type) ++ error ("multiple declarations `%T' and `%T'", type, ++ TREE_TYPE (id)); ++ else ++ { ++ type = TREE_TYPE (id); ++ TREE_VALUE (spec) = type; ++ typedef_decl = id; ++ } ++ goto found; ++ } ++ if (type) ++ error ("two or more data types in declaration of `%s'", name); ++ else if (TREE_CODE (id) == IDENTIFIER_NODE) ++ { ++ tree t = lookup_name (id, 1); ++ if (!t || TREE_CODE (t) != TYPE_DECL) ++ error ("`%s' fails to be a typedef or built in type", ++ IDENTIFIER_POINTER (id)); ++ else ++ { ++ type = TREE_TYPE (t); ++ typedef_decl = t; ++ } ++ } ++ else if (id != error_mark_node) ++ /* Can't change CLASS nodes into RECORD nodes here! */ ++ type = id; ++ ++ found: ; ++ } ++ ++#if 0 ++ /* See the code below that used this. */ ++ if (typedef_decl) ++ decl_attr = DECL_ATTRIBUTES (typedef_decl); ++#endif ++ typedef_type = type; ++ ++ /* No type at all: default to `int', and set DEFAULTED_INT ++ because it was not a user-defined typedef. */ ++ ++ if (type == NULL_TREE ++ && (RIDBIT_SETP (RID_SIGNED, specbits) ++ || RIDBIT_SETP (RID_UNSIGNED, specbits) ++ || RIDBIT_SETP (RID_LONG, specbits) ++ || RIDBIT_SETP (RID_SHORT, specbits))) ++ { ++ /* These imply 'int'. */ ++ type = integer_type_node; ++ defaulted_int = 1; ++ } ++ ++ if (sfk != sfk_none) ++ type = check_special_function_return_type (sfk, type, ++ ctor_return_type); ++ else if (type == NULL_TREE) ++ { ++ int is_main; ++ ++ explicit_int = -1; ++ ++ /* We handle `main' specially here, because 'main () { }' is so ++ common. With no options, it is allowed. With -Wreturn-type, ++ it is a warning. It is only an error with -pedantic-errors. */ ++ is_main = (funcdef_flag ++ && dname && MAIN_NAME_P (dname) ++ && ctype == NULL_TREE ++ && in_namespace == NULL_TREE ++ && current_namespace == global_namespace); ++ ++ if (in_system_header || flag_ms_extensions) ++ /* Allow it, sigh. */; ++ else if (pedantic || ! is_main) ++ pedwarn ("ISO C++ forbids declaration of `%s' with no type", ++ name); ++ else if (warn_return_type) ++ warning ("ISO C++ forbids declaration of `%s' with no type", ++ name); ++ ++ type = integer_type_node; ++ } ++ ++ ctype = NULL_TREE; ++ ++ /* Now process the modifiers that were specified ++ and check for invalid combinations. */ ++ ++ /* Long double is a special combination. */ ++ ++ if (RIDBIT_SETP (RID_LONG, specbits) ++ && TYPE_MAIN_VARIANT (type) == double_type_node) ++ { ++ RIDBIT_RESET (RID_LONG, specbits); ++ type = build_qualified_type (long_double_type_node, ++ cp_type_quals (type)); ++ } ++ ++ /* Check all other uses of type modifiers. */ ++ ++ if (RIDBIT_SETP (RID_UNSIGNED, specbits) ++ || RIDBIT_SETP (RID_SIGNED, specbits) ++ || RIDBIT_SETP (RID_LONG, specbits) ++ || RIDBIT_SETP (RID_SHORT, specbits)) ++ { ++ int ok = 0; ++ ++ if (TREE_CODE (type) == REAL_TYPE) ++ error ("short, signed or unsigned invalid for `%s'", name); ++ else if (TREE_CODE (type) != INTEGER_TYPE) ++ error ("long, short, signed or unsigned invalid for `%s'", name); ++ else if (RIDBIT_SETP (RID_LONG, specbits) ++ && RIDBIT_SETP (RID_SHORT, specbits)) ++ error ("long and short specified together for `%s'", name); ++ else if ((RIDBIT_SETP (RID_LONG, specbits) ++ || RIDBIT_SETP (RID_SHORT, specbits)) ++ && explicit_char) ++ error ("long or short specified with char for `%s'", name); ++ else if ((RIDBIT_SETP (RID_LONG, specbits) ++ || RIDBIT_SETP (RID_SHORT, specbits)) ++ && TREE_CODE (type) == REAL_TYPE) ++ error ("long or short specified with floating type for `%s'", name); ++ else if (RIDBIT_SETP (RID_SIGNED, specbits) ++ && RIDBIT_SETP (RID_UNSIGNED, specbits)) ++ error ("signed and unsigned given together for `%s'", name); ++ else ++ { ++ ok = 1; ++ if (!explicit_int && !defaulted_int && !explicit_char && pedantic) ++ { ++ pedwarn ("long, short, signed or unsigned used invalidly for `%s'", ++ name); ++ if (flag_pedantic_errors) ++ ok = 0; ++ } ++ } ++ ++ /* Discard the type modifiers if they are invalid. */ ++ if (! ok) ++ { ++ RIDBIT_RESET (RID_UNSIGNED, specbits); ++ RIDBIT_RESET (RID_SIGNED, specbits); ++ RIDBIT_RESET (RID_LONG, specbits); ++ RIDBIT_RESET (RID_SHORT, specbits); ++ longlong = 0; ++ } ++ } ++ ++ if (RIDBIT_SETP (RID_COMPLEX, specbits) ++ && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE) ++ { ++ error ("complex invalid for `%s'", name); ++ RIDBIT_RESET (RID_COMPLEX, specbits); ++ } ++ ++ /* Decide whether an integer type is signed or not. ++ Optionally treat bitfields as signed by default. */ ++ if (RIDBIT_SETP (RID_UNSIGNED, specbits) ++ /* [class.bit] ++ ++ It is implementation-defined whether a plain (neither ++ explicitly signed or unsigned) char, short, int, or long ++ bit-field is signed or unsigned. ++ ++ Naturally, we extend this to long long as well. Note that ++ this does not include wchar_t. */ ++ || (bitfield && !flag_signed_bitfields ++ && RIDBIT_NOTSETP (RID_SIGNED, specbits) ++ /* A typedef for plain `int' without `signed' can be ++ controlled just like plain `int', but a typedef for ++ `signed int' cannot be so controlled. */ ++ && !(typedef_decl ++ && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)) ++ && (TREE_CODE (type) == INTEGER_TYPE ++ || TREE_CODE (type) == CHAR_TYPE) ++ && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node))) ++ { ++ if (longlong) ++ type = long_long_unsigned_type_node; ++ else if (RIDBIT_SETP (RID_LONG, specbits)) ++ type = long_unsigned_type_node; ++ else if (RIDBIT_SETP (RID_SHORT, specbits)) ++ type = short_unsigned_type_node; ++ else if (type == char_type_node) ++ type = unsigned_char_type_node; ++ else if (typedef_decl) ++ type = c_common_unsigned_type (type); ++ else ++ type = unsigned_type_node; ++ } ++ else if (RIDBIT_SETP (RID_SIGNED, specbits) ++ && type == char_type_node) ++ type = signed_char_type_node; ++ else if (longlong) ++ type = long_long_integer_type_node; ++ else if (RIDBIT_SETP (RID_LONG, specbits)) ++ type = long_integer_type_node; ++ else if (RIDBIT_SETP (RID_SHORT, specbits)) ++ type = short_integer_type_node; ++ ++ if (RIDBIT_SETP (RID_COMPLEX, specbits)) ++ { ++ /* If we just have "complex", it is equivalent to ++ "complex double", but if any modifiers at all are specified it is ++ the complex form of TYPE. E.g, "complex short" is ++ "complex short int". */ ++ ++ if (defaulted_int && ! longlong ++ && ! (RIDBIT_SETP (RID_LONG, specbits) ++ || RIDBIT_SETP (RID_SHORT, specbits) ++ || RIDBIT_SETP (RID_SIGNED, specbits) ++ || RIDBIT_SETP (RID_UNSIGNED, specbits))) ++ type = complex_double_type_node; ++ else if (type == integer_type_node) ++ type = complex_integer_type_node; ++ else if (type == float_type_node) ++ type = complex_float_type_node; ++ else if (type == double_type_node) ++ type = complex_double_type_node; ++ else if (type == long_double_type_node) ++ type = complex_long_double_type_node; ++ else ++ type = build_complex_type (type); ++ } ++ ++ type_quals = TYPE_UNQUALIFIED; ++ if (RIDBIT_SETP (RID_CONST, specbits)) ++ type_quals |= TYPE_QUAL_CONST; ++ if (RIDBIT_SETP (RID_VOLATILE, specbits)) ++ type_quals |= TYPE_QUAL_VOLATILE; ++ if (RIDBIT_SETP (RID_RESTRICT, specbits)) ++ type_quals |= TYPE_QUAL_RESTRICT; ++ if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED) ++ error ("qualifiers are not allowed on declaration of `operator %T'", ++ ctor_return_type); ++ ++ type_quals |= cp_type_quals (type); ++ type = cp_build_qualified_type_real ++ (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl) ++ ? tf_ignore_bad_quals : 0) | tf_error | tf_warning)); ++ /* We might have ignored or rejected some of the qualifiers. */ ++ type_quals = cp_type_quals (type); ++ ++ staticp = 0; ++ inlinep = !! RIDBIT_SETP (RID_INLINE, specbits); ++ virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits); ++ RIDBIT_RESET (RID_VIRTUAL, specbits); ++ explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0; ++ RIDBIT_RESET (RID_EXPLICIT, specbits); ++ ++ if (RIDBIT_SETP (RID_STATIC, specbits)) ++ staticp = 1 + (decl_context == FIELD); ++ ++ if (virtualp && staticp == 2) ++ { ++ error ("member `%D' cannot be declared both virtual and static", ++ dname); ++ staticp = 0; ++ } ++ friendp = RIDBIT_SETP (RID_FRIEND, specbits); ++ RIDBIT_RESET (RID_FRIEND, specbits); ++ ++ if (dependant_name && !friendp) ++ { ++ error ("`%T::%D' is not a valid declarator", ctype, dependant_name); ++ return void_type_node; ++ } ++ ++ /* Warn if two storage classes are given. Default to `auto'. */ ++ ++ if (RIDBIT_ANY_SET (specbits)) ++ { ++ if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++; ++ if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++; ++ if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++; ++ if (decl_context == PARM && nclasses > 0) ++ error ("storage class specifiers invalid in parameter declarations"); ++ if (RIDBIT_SETP (RID_TYPEDEF, specbits)) ++ { ++ if (decl_context == PARM) ++ error ("typedef declaration invalid in parameter declaration"); ++ nclasses++; ++ } ++ if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++; ++ if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++; ++ if (!nclasses && !friendp && extern_langp) ++ nclasses++; ++ } ++ ++ /* Give error if `virtual' is used outside of class declaration. */ ++ if (virtualp ++ && (current_class_name == NULL_TREE || decl_context != FIELD)) ++ { ++ error ("virtual outside class declaration"); ++ virtualp = 0; ++ } ++ ++ /* Static anonymous unions are dealt with here. */ ++ if (staticp && decl_context == TYPENAME ++ && TREE_CODE (declspecs) == TREE_LIST ++ && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs))) ++ decl_context = FIELD; ++ ++ /* Warn about storage classes that are invalid for certain ++ kinds of declarations (parameters, typenames, etc.). */ ++ ++ /* "static __thread" and "extern __thread" are allowed. */ ++ if (nclasses == 2 ++ && RIDBIT_SETP (RID_THREAD, specbits) ++ && (RIDBIT_SETP (RID_EXTERN, specbits) ++ || RIDBIT_SETP (RID_STATIC, specbits))) ++ nclasses = 1; ++ ++ if (nclasses > 1) ++ error ("multiple storage classes in declaration of `%s'", name); ++ else if (decl_context != NORMAL && nclasses > 0) ++ { ++ if ((decl_context == PARM || decl_context == CATCHPARM) ++ && (RIDBIT_SETP (RID_REGISTER, specbits) ++ || RIDBIT_SETP (RID_AUTO, specbits))) ++ ; ++ else if (RIDBIT_SETP (RID_TYPEDEF, specbits)) ++ ; ++ else if (decl_context == FIELD ++ /* C++ allows static class elements. */ ++ && RIDBIT_SETP (RID_STATIC, specbits)) ++ /* C++ also allows inlines and signed and unsigned elements, ++ but in those cases we don't come in here. */ ++ ; ++ else ++ { ++ if (decl_context == FIELD) ++ { ++ tree tmp = NULL_TREE; ++ int op = 0; ++ ++ if (declarator) ++ { ++ /* Avoid trying to get an operand off an identifier node. */ ++ if (TREE_CODE (declarator) == IDENTIFIER_NODE) ++ tmp = declarator; ++ else ++ tmp = TREE_OPERAND (declarator, 0); ++ op = IDENTIFIER_OPNAME_P (tmp); ++ if (IDENTIFIER_TYPENAME_P (tmp)) ++ { ++ if (is_typename_at_global_scope (tmp)) ++ name = IDENTIFIER_POINTER (tmp); ++ else ++ name = ""; ++ } ++ } ++ error ("storage class specified for %s `%s'", ++ op ? "member operator" : "field", ++ name); ++ } ++ else ++ { ++ if (decl_context == PARM || decl_context == CATCHPARM) ++ error ("storage class specified for parameter `%s'", name); ++ else ++ error ("storage class specified for typename"); ++ } ++ RIDBIT_RESET (RID_REGISTER, specbits); ++ RIDBIT_RESET (RID_AUTO, specbits); ++ RIDBIT_RESET (RID_EXTERN, specbits); ++ RIDBIT_RESET (RID_THREAD, specbits); ++ } ++ } ++ else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag) ++ { ++ if (toplevel_bindings_p ()) ++ { ++ /* It's common practice (and completely valid) to have a const ++ be initialized and declared extern. */ ++ if (!(type_quals & TYPE_QUAL_CONST)) ++ warning ("`%s' initialized and declared `extern'", name); ++ } ++ else ++ error ("`%s' has both `extern' and initializer", name); ++ } ++ else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag ++ && ! toplevel_bindings_p ()) ++ error ("nested function `%s' declared `extern'", name); ++ else if (toplevel_bindings_p ()) ++ { ++ if (RIDBIT_SETP (RID_AUTO, specbits)) ++ error ("top-level declaration of `%s' specifies `auto'", name); ++ } ++ else if (RIDBIT_SETP (RID_THREAD, specbits) ++ && !RIDBIT_SETP (RID_EXTERN, specbits) ++ && !RIDBIT_SETP (RID_STATIC, specbits)) ++ { ++ error ("function-scope `%s' implicitly auto and declared `__thread'", ++ name); ++ RIDBIT_RESET (RID_THREAD, specbits); ++ } ++ ++ if (nclasses > 0 && friendp) ++ error ("storage class specifiers invalid in friend function declarations"); ++ ++ scope = get_scope_of_declarator (declarator); ++ ++ /* Now figure out the structure of the declarator proper. ++ Descend through it, creating more complex types, until we reach ++ the declared identifier (or NULL_TREE, in an abstract declarator). */ ++ ++ while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE ++ && TREE_CODE (declarator) != TEMPLATE_ID_EXPR) ++ { ++ /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]), ++ an INDIRECT_REF (for *...), ++ a CALL_EXPR (for ...(...)), ++ an identifier (for the name being declared) ++ or a null pointer (for the place in an absolute declarator ++ where the name was omitted). ++ For the last two cases, we have just exited the loop. ++ ++ For C++ it could also be ++ a SCOPE_REF (for class :: ...). In this case, we have converted ++ sensible names to types, and those are the values we use to ++ qualify the member name. ++ an ADDR_EXPR (for &...), ++ a BIT_NOT_EXPR (for destructors) ++ ++ At this point, TYPE is the type of elements of an array, ++ or for a function to return, or for a pointer to point to. ++ After this sequence of ifs, TYPE is the type of the ++ array or function or pointer, and DECLARATOR has had its ++ outermost layer removed. */ ++ ++ if (type == error_mark_node) ++ { ++ if (declarator == error_mark_node) ++ return error_mark_node; ++ else if (TREE_CODE (declarator) == SCOPE_REF) ++ declarator = TREE_OPERAND (declarator, 1); ++ else ++ declarator = TREE_OPERAND (declarator, 0); ++ continue; ++ } ++ if (quals != NULL_TREE ++ && (declarator == NULL_TREE ++ || TREE_CODE (declarator) != SCOPE_REF)) ++ { ++ if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE) ++ ctype = TYPE_METHOD_BASETYPE (type); ++ if (ctype != NULL_TREE) ++ { ++ tree dummy = build_decl (TYPE_DECL, NULL_TREE, type); ++ grok_method_quals (ctype, dummy, quals); ++ type = TREE_TYPE (dummy); ++ quals = NULL_TREE; ++ } ++ } ++ ++ switch (TREE_CODE (declarator)) ++ { ++ case TREE_LIST: ++ { ++ /* We encode a declarator with embedded attributes using ++ a TREE_LIST. */ ++ tree attrs = TREE_PURPOSE (declarator); ++ tree inner_decl; ++ int attr_flags; ++ ++ declarator = TREE_VALUE (declarator); ++ inner_decl = declarator; ++ while (inner_decl != NULL_TREE ++ && TREE_CODE (inner_decl) == TREE_LIST) ++ inner_decl = TREE_VALUE (inner_decl); ++ attr_flags = 0; ++ if (inner_decl == NULL_TREE ++ || TREE_CODE (inner_decl) == IDENTIFIER_NODE) ++ attr_flags |= (int) ATTR_FLAG_DECL_NEXT; ++ if (TREE_CODE (inner_decl) == CALL_EXPR) ++ attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT; ++ if (TREE_CODE (inner_decl) == ARRAY_REF) ++ attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT; ++ returned_attrs = decl_attributes (&type, ++ chainon (returned_attrs, attrs), ++ attr_flags); ++ } ++ break; ++ ++ case ARRAY_REF: ++ { ++ tree size = TREE_OPERAND (declarator, 1); ++ declarator = TREE_OPERAND (declarator, 0); ++ ++ type = create_array_type_for_decl (dname, type, size); ++ ++ ctype = NULL_TREE; ++ } ++ break; ++ ++ case CALL_EXPR: ++ { ++ tree arg_types; ++ int funcdecl_p; ++ tree inner_parms = CALL_DECLARATOR_PARMS (declarator); ++ tree inner_decl = TREE_OPERAND (declarator, 0); ++ ++ /* Declaring a function type. ++ Make sure we have a valid type for the function to return. */ ++ ++ /* We now know that the TYPE_QUALS don't apply to the ++ decl, but to its return type. */ ++ type_quals = TYPE_UNQUALIFIED; ++ ++ /* Warn about some types functions can't return. */ ++ ++ if (TREE_CODE (type) == FUNCTION_TYPE) ++ { ++ error ("`%s' declared as function returning a function", name); ++ type = integer_type_node; ++ } ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ { ++ error ("`%s' declared as function returning an array", name); ++ type = integer_type_node; ++ } ++ ++ if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF) ++ inner_decl = TREE_OPERAND (inner_decl, 1); ++ ++ if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR) ++ inner_decl = dname; ++ ++ /* Pick up type qualifiers which should be applied to `this'. */ ++ quals = CALL_DECLARATOR_QUALS (declarator); ++ ++ /* Pick up the exception specifications. */ ++ raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator); ++ ++ /* Say it's a definition only for the CALL_EXPR ++ closest to the identifier. */ ++ funcdecl_p ++ = inner_decl ++ && (TREE_CODE (inner_decl) == IDENTIFIER_NODE ++ || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR ++ || TREE_CODE (inner_decl) == BIT_NOT_EXPR); ++ ++ if (ctype == NULL_TREE ++ && decl_context == FIELD ++ && funcdecl_p ++ && (friendp == 0 || dname == current_class_name)) ++ ctype = current_class_type; ++ ++ if (ctype && sfk == sfk_conversion) ++ TYPE_HAS_CONVERSION (ctype) = 1; ++ if (ctype && constructor_name_p (dname, ctype)) ++ { ++ /* We are within a class's scope. If our declarator name ++ is the same as the class name, and we are defining ++ a function, then it is a constructor/destructor, and ++ therefore returns a void type. */ ++ ++ if (flags == DTOR_FLAG) ++ { ++ /* ISO C++ 12.4/2. A destructor may not be ++ declared const or volatile. A destructor may ++ not be static. */ ++ if (staticp == 2) ++ error ("destructor cannot be static member function"); ++ if (quals) ++ { ++ error ("destructors may not be `%s'", ++ IDENTIFIER_POINTER (TREE_VALUE (quals))); ++ quals = NULL_TREE; ++ } ++ if (decl_context == FIELD) ++ { ++ if (! member_function_or_else (ctype, ++ current_class_type, ++ flags)) ++ return void_type_node; ++ } ++ } ++ else /* It's a constructor. */ ++ { ++ if (explicitp == 1) ++ explicitp = 2; ++ /* ISO C++ 12.1. A constructor may not be ++ declared const or volatile. A constructor may ++ not be virtual. A constructor may not be ++ static. */ ++ if (staticp == 2) ++ error ("constructor cannot be static member function"); ++ if (virtualp) ++ { ++ pedwarn ("constructors cannot be declared virtual"); ++ virtualp = 0; ++ } ++ if (quals) ++ { ++ error ("constructors may not be `%s'", ++ IDENTIFIER_POINTER (TREE_VALUE (quals))); ++ quals = NULL_TREE; ++ } ++ { ++ RID_BIT_TYPE tmp_bits; ++ memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE)); ++ RIDBIT_RESET (RID_INLINE, tmp_bits); ++ RIDBIT_RESET (RID_STATIC, tmp_bits); ++ if (RIDBIT_ANY_SET (tmp_bits)) ++ error ("return value type specifier for constructor ignored"); ++ } ++ if (decl_context == FIELD) ++ { ++ if (! member_function_or_else (ctype, ++ current_class_type, ++ flags)) ++ return void_type_node; ++ TYPE_HAS_CONSTRUCTOR (ctype) = 1; ++ if (sfk != sfk_constructor) ++ return NULL_TREE; ++ } ++ } ++ if (decl_context == FIELD) ++ staticp = 0; ++ } ++ else if (friendp) ++ { ++ if (initialized) ++ error ("can't initialize friend function `%s'", name); ++ if (virtualp) ++ { ++ /* Cannot be both friend and virtual. */ ++ error ("virtual functions cannot be friends"); ++ RIDBIT_RESET (RID_FRIEND, specbits); ++ friendp = 0; ++ } ++ if (decl_context == NORMAL) ++ error ("friend declaration not in class definition"); ++ if (current_function_decl && funcdef_flag) ++ error ("can't define friend function `%s' in a local class definition", ++ name); ++ } ++ ++ /* Construct the function type and go to the next ++ inner layer of declarator. */ ++ ++ declarator = TREE_OPERAND (declarator, 0); ++ ++ arg_types = grokparms (inner_parms, &parms); ++ ++ if (declarator && flags == DTOR_FLAG) ++ { ++ /* A destructor declared in the body of a class will ++ be represented as a BIT_NOT_EXPR. But, we just ++ want the underlying IDENTIFIER. */ ++ if (TREE_CODE (declarator) == BIT_NOT_EXPR) ++ declarator = TREE_OPERAND (declarator, 0); ++ ++ if (arg_types != void_list_node) ++ { ++ error ("destructors may not have parameters"); ++ arg_types = void_list_node; ++ parms = NULL_TREE; ++ } ++ } ++ ++ /* ANSI says that `const int foo ();' ++ does not make the function foo const. */ ++ type = build_function_type (type, arg_types); ++ } ++ break; ++ ++ case ADDR_EXPR: ++ case INDIRECT_REF: ++ /* Filter out pointers-to-references and references-to-references. ++ We can get these if a TYPE_DECL is used. */ ++ ++ if (TREE_CODE (type) == REFERENCE_TYPE) ++ { ++ error (TREE_CODE (declarator) == ADDR_EXPR ++ ? "cannot declare reference to `%#T'" ++ : "cannot declare pointer to `%#T'", type); ++ type = TREE_TYPE (type); ++ } ++ else if (VOID_TYPE_P (type) ++ && (ctype || TREE_CODE (declarator) == ADDR_EXPR)) ++ error (ctype ? "cannot declare pointer to `%#T' member" ++ : "cannot declare reference to `%#T'", type); ++ ++ /* Merge any constancy or volatility into the target type ++ for the pointer. */ ++ ++ /* We now know that the TYPE_QUALS don't apply to the decl, ++ but to the target of the pointer. */ ++ type_quals = TYPE_UNQUALIFIED; ++ ++ if (TREE_CODE (declarator) == ADDR_EXPR) ++ { ++ if (!VOID_TYPE_P (type)) ++ type = build_reference_type (type); ++ } ++ else if (TREE_CODE (type) == METHOD_TYPE) ++ type = build_ptrmemfunc_type (build_pointer_type (type)); ++ else if (ctype) ++ type = build_ptrmem_type (ctype, type); ++ else ++ type = build_pointer_type (type); ++ ++ /* Process a list of type modifier keywords (such as ++ const or volatile) that were given inside the `*' or `&'. */ ++ ++ if (TREE_TYPE (declarator)) ++ { ++ tree typemodlist; ++ int erred = 0; ++ int constp = 0; ++ int volatilep = 0; ++ int restrictp = 0; ++ ++ for (typemodlist = TREE_TYPE (declarator); typemodlist; ++ typemodlist = TREE_CHAIN (typemodlist)) ++ { ++ tree qualifier = TREE_VALUE (typemodlist); ++ ++ if (qualifier == ridpointers[(int) RID_CONST]) ++ { ++ constp++; ++ type_quals |= TYPE_QUAL_CONST; ++ } ++ else if (qualifier == ridpointers[(int) RID_VOLATILE]) ++ { ++ volatilep++; ++ type_quals |= TYPE_QUAL_VOLATILE; ++ } ++ else if (qualifier == ridpointers[(int) RID_RESTRICT]) ++ { ++ restrictp++; ++ type_quals |= TYPE_QUAL_RESTRICT; ++ } ++ else if (!erred) ++ { ++ erred = 1; ++ error ("invalid type modifier within pointer declarator"); ++ } ++ } ++ if (constp > 1) ++ pedwarn ("duplicate `const'"); ++ if (volatilep > 1) ++ pedwarn ("duplicate `volatile'"); ++ if (restrictp > 1) ++ pedwarn ("duplicate `restrict'"); ++ type = cp_build_qualified_type (type, type_quals); ++ type_quals = cp_type_quals (type); ++ } ++ declarator = TREE_OPERAND (declarator, 0); ++ ctype = NULL_TREE; ++ break; ++ ++ case SCOPE_REF: ++ { ++ /* We have converted type names to NULL_TREE if the ++ name was bogus, or to a _TYPE node, if not. ++ ++ The variable CTYPE holds the type we will ultimately ++ resolve to. The code here just needs to build ++ up appropriate member types. */ ++ tree sname = TREE_OPERAND (declarator, 1); ++ tree t; ++ ++ /* Destructors can have their visibilities changed as well. */ ++ if (TREE_CODE (sname) == BIT_NOT_EXPR) ++ sname = TREE_OPERAND (sname, 0); ++ ++ if (TREE_OPERAND (declarator, 0) == NULL_TREE) ++ { ++ /* We had a reference to a global decl, or ++ perhaps we were given a non-aggregate typedef, ++ in which case we cleared this out, and should just ++ keep going as though it wasn't there. */ ++ declarator = sname; ++ continue; ++ } ++ ctype = TREE_OPERAND (declarator, 0); ++ ++ t = ctype; ++ if (TREE_CODE (TREE_OPERAND (declarator, 1)) != INDIRECT_REF) ++ while (t != NULL_TREE && CLASS_TYPE_P (t)) ++ { ++ /* You're supposed to have one `template <...>' ++ for every template class, but you don't need one ++ for a full specialization. For example: ++ ++ template struct S{}; ++ template <> struct S { void f(); }; ++ void S::f () {} ++ ++ is correct; there shouldn't be a `template <>' for ++ the definition of `S::f'. */ ++ if (CLASSTYPE_TEMPLATE_INFO (t) ++ && (CLASSTYPE_TEMPLATE_INSTANTIATION (t) ++ || uses_template_parms (CLASSTYPE_TI_ARGS (t))) ++ && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))) ++ template_count += 1; ++ ++ t = TYPE_MAIN_DECL (t); ++ t = DECL_CONTEXT (t); ++ } ++ ++ if (sname == NULL_TREE) ++ goto done_scoping; ++ ++ if (TREE_CODE (sname) == IDENTIFIER_NODE) ++ { ++ /* This is the `standard' use of the scoping operator: ++ basetype :: member . */ ++ ++ if (ctype == current_class_type) ++ { ++ /* class A { ++ void A::f (); ++ }; ++ ++ Is this ill-formed? */ ++ ++ if (pedantic) ++ pedwarn ("extra qualification `%T::' on member `%s' ignored", ++ ctype, name); ++ } ++ else if (TREE_CODE (type) == FUNCTION_TYPE) ++ { ++ if (NEW_DELETE_OPNAME_P (sname)) ++ /* Overloaded operator new and operator delete ++ are always static functions. */ ++ ; ++ else if (current_class_type == NULL_TREE || friendp) ++ type ++ = build_method_type_directly (ctype, ++ TREE_TYPE (type), ++ TYPE_ARG_TYPES (type)); ++ else ++ { ++ error ("cannot declare member function `%T::%s' within `%T'", ++ ctype, name, current_class_type); ++ return error_mark_node; ++ } ++ } ++ else if (RIDBIT_SETP (RID_TYPEDEF, specbits) ++ || COMPLETE_TYPE_P (complete_type (ctype))) ++ { ++ /* Have to move this code elsewhere in this function. ++ this code is used for i.e., typedef int A::M; M *pm; ++ ++ It is? How? jason 10/2/94 */ ++ ++ if (current_class_type) ++ { ++ error ("cannot declare member `%T::%s' within `%T'", ++ ctype, name, current_class_type); ++ return void_type_node; ++ } ++ } ++ else ++ { ++ cxx_incomplete_type_error (NULL_TREE, ctype); ++ return error_mark_node; ++ } ++ ++ declarator = sname; ++ } ++ else if (TREE_CODE (sname) == SCOPE_REF) ++ abort (); ++ else ++ { ++ done_scoping: ++ declarator = TREE_OPERAND (declarator, 1); ++ if (declarator && TREE_CODE (declarator) == CALL_EXPR) ++ /* In this case, we will deal with it later. */ ++ ; ++ else if (TREE_CODE (type) == FUNCTION_TYPE) ++ type = build_method_type_directly (ctype, ++ TREE_TYPE (type), ++ TYPE_ARG_TYPES (type)); ++ } ++ } ++ break; ++ ++ case BIT_NOT_EXPR: ++ declarator = TREE_OPERAND (declarator, 0); ++ break; ++ ++ case BASELINK: ++ declarator = BASELINK_FUNCTIONS (declarator); ++ break; ++ ++ case RECORD_TYPE: ++ case UNION_TYPE: ++ case ENUMERAL_TYPE: ++ declarator = NULL_TREE; ++ break; ++ ++ case ERROR_MARK: ++ declarator = NULL_TREE; ++ break; ++ ++ default: ++ abort (); ++ } ++ } ++ ++ if (returned_attrs) ++ { ++ if (attrlist) ++ *attrlist = chainon (returned_attrs, *attrlist); ++ else ++ attrlist = &returned_attrs; ++ } ++ ++ /* Now TYPE has the actual type. */ ++ ++ /* Did array size calculations overflow? */ ++ ++ if (TREE_CODE (type) == ARRAY_TYPE ++ && COMPLETE_TYPE_P (type) ++ && TREE_OVERFLOW (TYPE_SIZE (type))) ++ { ++ error ("size of array `%s' is too large", name); ++ /* If we proceed with the array type as it is, we'll eventually ++ crash in tree_low_cst(). */ ++ type = error_mark_node; ++ } ++ ++ if ((decl_context == FIELD || decl_context == PARM) ++ && !processing_template_decl ++ && variably_modified_type_p (type)) ++ { ++ if (decl_context == FIELD) ++ error ("data member may not have variably modified type `%T'", type); ++ else ++ error ("parameter may not have variably modified type `%T'", type); ++ type = error_mark_node; ++ } ++ ++ if (explicitp == 1 || (explicitp && friendp)) ++ { ++ /* [dcl.fct.spec] The explicit specifier shall only be used in ++ declarations of constructors within a class definition. */ ++ error ("only declarations of constructors can be `explicit'"); ++ explicitp = 0; ++ } ++ ++ if (RIDBIT_SETP (RID_MUTABLE, specbits)) ++ { ++ if (decl_context != FIELD || friendp) ++ { ++ error ("non-member `%s' cannot be declared `mutable'", name); ++ RIDBIT_RESET (RID_MUTABLE, specbits); ++ } ++ else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits)) ++ { ++ error ("non-object member `%s' cannot be declared `mutable'", name); ++ RIDBIT_RESET (RID_MUTABLE, specbits); ++ } ++ else if (TREE_CODE (type) == FUNCTION_TYPE ++ || TREE_CODE (type) == METHOD_TYPE) ++ { ++ error ("function `%s' cannot be declared `mutable'", name); ++ RIDBIT_RESET (RID_MUTABLE, specbits); ++ } ++ else if (staticp) ++ { ++ error ("static `%s' cannot be declared `mutable'", name); ++ RIDBIT_RESET (RID_MUTABLE, specbits); ++ } ++ else if (type_quals & TYPE_QUAL_CONST) ++ { ++ error ("const `%s' cannot be declared `mutable'", name); ++ RIDBIT_RESET (RID_MUTABLE, specbits); ++ } ++ } ++ ++ if (declarator == NULL_TREE ++ || TREE_CODE (declarator) == IDENTIFIER_NODE ++ || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR ++ && (TREE_CODE (type) == FUNCTION_TYPE ++ || TREE_CODE (type) == METHOD_TYPE))) ++ /* OK */; ++ else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) ++ { ++ error ("template-id `%D' used as a declarator", declarator); ++ declarator = dname; ++ } ++ else ++ /* Unexpected declarator format. */ ++ abort (); ++ ++ /* If this is declaring a typedef name, return a TYPE_DECL. */ ++ ++ if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME) ++ { ++ tree decl; ++ ++ /* Note that the grammar rejects storage classes ++ in typenames, fields or parameters. */ ++ if (current_lang_name == lang_name_java) ++ TYPE_FOR_JAVA (type) = 1; ++ ++ if (decl_context == FIELD) ++ { ++ if (constructor_name_p (declarator, current_class_type)) ++ pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class", ++ declarator); ++ decl = build_lang_decl (TYPE_DECL, declarator, type); ++ } ++ else ++ { ++ decl = build_decl (TYPE_DECL, declarator, type); ++ if (in_namespace || ctype) ++ error ("%Jtypedef name may not be a nested-name-specifier", decl); ++ if (!current_function_decl) ++ DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); ++ } ++ ++ /* If the user declares "typedef struct {...} foo" then the ++ struct will have an anonymous name. Fill that name in now. ++ Nothing can refer to it, so nothing needs know about the name ++ change. */ ++ if (type != error_mark_node ++ && declarator ++ && TYPE_NAME (type) ++ && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL ++ && TYPE_ANONYMOUS_P (type) ++ /* Don't do this if there are attributes. */ ++ && (!attrlist || !*attrlist) ++ && cp_type_quals (type) == TYPE_UNQUALIFIED) ++ { ++ tree oldname = TYPE_NAME (type); ++ tree t; ++ ++ /* Replace the anonymous name with the real name everywhere. */ ++ lookup_tag_reverse (type, declarator); ++ for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) ++ if (TYPE_NAME (t) == oldname) ++ TYPE_NAME (t) = decl; ++ ++ if (TYPE_LANG_SPECIFIC (type)) ++ TYPE_WAS_ANONYMOUS (type) = 1; ++ ++ /* If this is a typedef within a template class, the nested ++ type is a (non-primary) template. The name for the ++ template needs updating as well. */ ++ if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type)) ++ DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)) ++ = TYPE_IDENTIFIER (type); ++ ++ /* FIXME remangle member functions; member functions of a ++ type with external linkage have external linkage. */ ++ } ++ ++ if (quals) ++ { ++ if (ctype == NULL_TREE) ++ { ++ if (TREE_CODE (type) != METHOD_TYPE) ++ error ("%Jinvalid type qualifier for non-member function type", ++ decl); ++ else ++ ctype = TYPE_METHOD_BASETYPE (type); ++ } ++ if (ctype != NULL_TREE) ++ grok_method_quals (ctype, decl, quals); ++ } ++ ++ if (RIDBIT_SETP (RID_SIGNED, specbits) ++ || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))) ++ C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1; ++ ++ bad_specifiers (decl, "type", virtualp, quals != NULL_TREE, ++ inlinep, friendp, raises != NULL_TREE); ++ ++ return decl; ++ } ++ ++ /* Detect the case of an array type of unspecified size ++ which came, as such, direct from a typedef name. ++ We must copy the type, so that the array's domain can be ++ individually set by the object's initializer. */ ++ ++ if (type && typedef_type ++ && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type) ++ && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)) ++ type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE); ++ ++ /* Detect where we're using a typedef of function type to declare a ++ function. PARMS will not be set, so we must create it now. */ ++ ++ if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE) ++ { ++ tree decls = NULL_TREE; ++ tree args; ++ ++ for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args)) ++ { ++ tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args)); ++ ++ TREE_CHAIN (decl) = decls; ++ decls = decl; ++ } ++ ++ parms = nreverse (decls); ++ } ++ ++ /* If this is a type name (such as, in a cast or sizeof), ++ compute the type and return it now. */ ++ ++ if (decl_context == TYPENAME) ++ { ++ /* Note that the grammar rejects storage classes ++ in typenames, fields or parameters. */ ++ if (type_quals != TYPE_UNQUALIFIED) ++ type_quals = TYPE_UNQUALIFIED; ++ ++ /* Special case: "friend class foo" looks like a TYPENAME context. */ ++ if (friendp) ++ { ++ if (type_quals != TYPE_UNQUALIFIED) ++ { ++ error ("type qualifiers specified for friend class declaration"); ++ type_quals = TYPE_UNQUALIFIED; ++ } ++ if (inlinep) ++ { ++ error ("`inline' specified for friend class declaration"); ++ inlinep = 0; ++ } ++ ++ if (!current_aggr) ++ { ++ /* Don't allow friend declaration without a class-key. */ ++ if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) ++ pedwarn ("template parameters cannot be friends"); ++ else if (TREE_CODE (type) == TYPENAME_TYPE) ++ pedwarn ("friend declaration requires class-key, " ++ "i.e. `friend class %T::%D'", ++ TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type)); ++ else ++ pedwarn ("friend declaration requires class-key, " ++ "i.e. `friend %#T'", ++ type); ++ } ++ ++ /* Only try to do this stuff if we didn't already give up. */ ++ if (type != integer_type_node) ++ { ++ /* A friendly class? */ ++ if (current_class_type) ++ make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type), ++ /*complain=*/true); ++ else ++ error ("trying to make class `%T' a friend of global scope", ++ type); ++ ++ type = void_type_node; ++ } ++ } ++ else if (quals) ++ { ++ if (ctype == NULL_TREE) ++ { ++ if (TREE_CODE (type) != METHOD_TYPE) ++ error ("invalid qualifiers on non-member function type"); ++ else ++ ctype = TYPE_METHOD_BASETYPE (type); ++ } ++ if (ctype) ++ { ++ tree dummy = build_decl (TYPE_DECL, declarator, type); ++ grok_method_quals (ctype, dummy, quals); ++ type = TREE_TYPE (dummy); ++ } ++ } ++ ++ return type; ++ } ++ else if (declarator == NULL_TREE && decl_context != PARM ++ && decl_context != CATCHPARM ++ && TREE_CODE (type) != UNION_TYPE ++ && ! bitfield) ++ { ++ error ("abstract declarator `%T' used as declaration", type); ++ return error_mark_node; ++ } ++ ++ /* Only functions may be declared using an operator-function-id. */ ++ if (declarator ++ && TREE_CODE (declarator) == IDENTIFIER_NODE ++ && IDENTIFIER_OPNAME_P (declarator) ++ && TREE_CODE (type) != FUNCTION_TYPE ++ && TREE_CODE (type) != METHOD_TYPE) ++ { ++ error ("declaration of `%D' as non-function", declarator); ++ return error_mark_node; ++ } ++ ++ /* We don't check parameter types here because we can emit a better ++ error message later. */ ++ if (decl_context != PARM) ++ type = check_var_type (declarator, type); ++ ++ /* Now create the decl, which may be a VAR_DECL, a PARM_DECL ++ or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */ ++ ++ if (decl_context == PARM || decl_context == CATCHPARM) ++ { ++ if (ctype || in_namespace) ++ error ("cannot use `::' in parameter declaration"); ++ ++ /* A parameter declared as an array of T is really a pointer to T. ++ One declared as a function is really a pointer to a function. ++ One declared as a member is really a pointer to member. */ ++ ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ { ++ /* Transfer const-ness of array into that of type pointed to. */ ++ type = build_pointer_type (TREE_TYPE (type)); ++ type_quals = TYPE_UNQUALIFIED; ++ } ++ else if (TREE_CODE (type) == FUNCTION_TYPE) ++ type = build_pointer_type (type); ++ } ++ ++ { ++ tree decl; ++ ++ if (decl_context == PARM) ++ { ++ decl = cp_build_parm_decl (declarator, type); ++ ++ bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE, ++ inlinep, friendp, raises != NULL_TREE); ++ } ++ else if (decl_context == FIELD) ++ { ++ /* The C99 flexible array extension. */ ++ if (!staticp && TREE_CODE (type) == ARRAY_TYPE ++ && TYPE_DOMAIN (type) == NULL_TREE) ++ { ++ tree itype = compute_array_index_type (dname, integer_zero_node); ++ type = build_cplus_array_type (TREE_TYPE (type), itype); ++ } ++ ++ if (type == error_mark_node) ++ { ++ /* Happens when declaring arrays of sizes which ++ are error_mark_node, for example. */ ++ decl = NULL_TREE; ++ } ++ else if (in_namespace && !friendp) ++ { ++ /* Something like struct S { int N::j; }; */ ++ error ("invalid use of `::'"); ++ decl = NULL_TREE; ++ } ++ else if (TREE_CODE (type) == FUNCTION_TYPE) ++ { ++ int publicp = 0; ++ tree function_context; ++ ++ /* We catch the others as conflicts with the builtin ++ typedefs. */ ++ if (friendp && declarator == ridpointers[(int) RID_SIGNED]) ++ { ++ error ("function `%D' cannot be declared friend", ++ declarator); ++ friendp = 0; ++ } ++ ++ if (friendp == 0) ++ { ++ if (ctype == NULL_TREE) ++ ctype = current_class_type; ++ ++ if (ctype == NULL_TREE) ++ { ++ error ("can't make `%D' into a method -- not in a class", ++ declarator); ++ return void_type_node; ++ } ++ ++ /* ``A union may [ ... ] not [ have ] virtual functions.'' ++ ARM 9.5 */ ++ if (virtualp && TREE_CODE (ctype) == UNION_TYPE) ++ { ++ error ("function `%D' declared virtual inside a union", ++ declarator); ++ return void_type_node; ++ } ++ ++ if (NEW_DELETE_OPNAME_P (declarator)) ++ { ++ if (virtualp) ++ { ++ error ("`%D' cannot be declared virtual, since it is always static", ++ declarator); ++ virtualp = 0; ++ } ++ } ++ else if (staticp < 2) ++ type = build_method_type_directly (ctype, ++ TREE_TYPE (type), ++ TYPE_ARG_TYPES (type)); ++ } ++ ++ /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */ ++ function_context = (ctype != NULL_TREE) ? ++ decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE; ++ publicp = (! friendp || ! staticp) ++ && function_context == NULL_TREE; ++ decl = grokfndecl (ctype, type, ++ TREE_CODE (declarator) != TEMPLATE_ID_EXPR ++ ? declarator : dname, ++ parms, ++ declarator, ++ virtualp, flags, quals, raises, ++ friendp ? -1 : 0, friendp, publicp, inlinep, ++ funcdef_flag, template_count, in_namespace); ++ if (decl == NULL_TREE) ++ return decl; ++#if 0 ++ /* This clobbers the attrs stored in `decl' from `attrlist'. */ ++ /* The decl and setting of decl_attr is also turned off. */ ++ decl = build_decl_attribute_variant (decl, decl_attr); ++#endif ++ ++ /* [class.conv.ctor] ++ ++ A constructor declared without the function-specifier ++ explicit that can be called with a single parameter ++ specifies a conversion from the type of its first ++ parameter to the type of its class. Such a constructor ++ is called a converting constructor. */ ++ if (explicitp == 2) ++ DECL_NONCONVERTING_P (decl) = 1; ++ else if (DECL_CONSTRUCTOR_P (decl)) ++ { ++ /* The constructor can be called with exactly one ++ parameter if there is at least one parameter, and ++ any subsequent parameters have default arguments. ++ Ignore any compiler-added parms. */ ++ tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl); ++ ++ if (arg_types == void_list_node ++ || (arg_types ++ && TREE_CHAIN (arg_types) ++ && TREE_CHAIN (arg_types) != void_list_node ++ && !TREE_PURPOSE (TREE_CHAIN (arg_types)))) ++ DECL_NONCONVERTING_P (decl) = 1; ++ } ++ } ++ else if (TREE_CODE (type) == METHOD_TYPE) ++ { ++ /* We only get here for friend declarations of ++ members of other classes. */ ++ /* All method decls are public, so tell grokfndecl to set ++ TREE_PUBLIC, also. */ ++ decl = grokfndecl (ctype, type, ++ TREE_CODE (declarator) != TEMPLATE_ID_EXPR ++ ? declarator : dname, ++ parms, ++ declarator, ++ virtualp, flags, quals, raises, ++ friendp ? -1 : 0, friendp, 1, 0, funcdef_flag, ++ template_count, in_namespace); ++ if (decl == NULL_TREE) ++ return NULL_TREE; ++ } ++ else if (!staticp && !dependent_type_p (type) ++ && !COMPLETE_TYPE_P (complete_type (type)) ++ && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0)) ++ { ++ if (declarator) ++ error ("field `%D' has incomplete type", declarator); ++ else ++ error ("name `%T' has incomplete type", type); ++ ++ /* If we're instantiating a template, tell them which ++ instantiation made the field's type be incomplete. */ ++ if (current_class_type ++ && TYPE_NAME (current_class_type) ++ && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type)) ++ && declspecs && TREE_VALUE (declspecs) ++ && TREE_TYPE (TREE_VALUE (declspecs)) == type) ++ error (" in instantiation of template `%T'", ++ current_class_type); ++ ++ type = error_mark_node; ++ decl = NULL_TREE; ++ } ++ else ++ { ++ if (friendp) ++ { ++ error ("`%s' is neither function nor member function; cannot be declared friend", ++ IDENTIFIER_POINTER (declarator)); ++ friendp = 0; ++ } ++ decl = NULL_TREE; ++ } ++ ++ if (friendp) ++ { ++ /* Friends are treated specially. */ ++ if (ctype == current_class_type) ++ warning ("member functions are implicitly friends of their class"); ++ else if (decl && DECL_NAME (decl)) ++ { ++ if (template_class_depth (current_class_type) == 0) ++ { ++ decl = check_explicit_specialization ++ (declarator, decl, template_count, ++ 2 * (funcdef_flag != 0) + 4); ++ if (decl == error_mark_node) ++ return error_mark_node; ++ } ++ ++ decl = do_friend (ctype, declarator, decl, ++ *attrlist, flags, quals, funcdef_flag); ++ return decl; ++ } ++ else ++ return void_type_node; ++ } ++ ++ /* Structure field. It may not be a function, except for C++. */ ++ ++ if (decl == NULL_TREE) ++ { ++ if (initialized) ++ { ++ if (!staticp) ++ { ++ /* An attempt is being made to initialize a non-static ++ member. But, from [class.mem]: ++ ++ 4 A member-declarator can contain a ++ constant-initializer only if it declares a static ++ member (_class.static_) of integral or enumeration ++ type, see _class.static.data_. ++ ++ This used to be relatively common practice, but ++ the rest of the compiler does not correctly ++ handle the initialization unless the member is ++ static so we make it static below. */ ++ pedwarn ("ISO C++ forbids initialization of member `%D'", ++ declarator); ++ pedwarn ("making `%D' static", declarator); ++ staticp = 1; ++ } ++ ++ if (uses_template_parms (type)) ++ /* We'll check at instantiation time. */ ++ ; ++ else if (check_static_variable_definition (declarator, ++ type)) ++ /* If we just return the declaration, crashes ++ will sometimes occur. We therefore return ++ void_type_node, as if this was a friend ++ declaration, to cause callers to completely ++ ignore this declaration. */ ++ return void_type_node; ++ } ++ ++ if (staticp) ++ { ++ /* C++ allows static class members. All other work ++ for this is done by grokfield. */ ++ decl = build_lang_decl (VAR_DECL, declarator, type); ++ TREE_STATIC (decl) = 1; ++ /* In class context, 'static' means public access. */ ++ TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1; ++ } ++ else ++ { ++ decl = build_decl (FIELD_DECL, declarator, type); ++ DECL_NONADDRESSABLE_P (decl) = bitfield; ++ if (RIDBIT_SETP (RID_MUTABLE, specbits)) ++ { ++ DECL_MUTABLE_P (decl) = 1; ++ RIDBIT_RESET (RID_MUTABLE, specbits); ++ } ++ } ++ ++ bad_specifiers (decl, "field", virtualp, quals != NULL_TREE, ++ inlinep, friendp, raises != NULL_TREE); ++ } ++ } ++ else if (TREE_CODE (type) == FUNCTION_TYPE ++ || TREE_CODE (type) == METHOD_TYPE) ++ { ++ tree original_name; ++ int publicp = 0; ++ ++ if (! declarator) ++ return NULL_TREE; ++ ++ if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) ++ original_name = dname; ++ else ++ original_name = declarator; ++ ++ if (RIDBIT_SETP (RID_AUTO, specbits)) ++ error ("storage class `auto' invalid for function `%s'", name); ++ else if (RIDBIT_SETP (RID_REGISTER, specbits)) ++ error ("storage class `register' invalid for function `%s'", name); ++ else if (RIDBIT_SETP (RID_THREAD, specbits)) ++ error ("storage class `__thread' invalid for function `%s'", name); ++ ++ /* Function declaration not at top level. ++ Storage classes other than `extern' are not allowed ++ and `extern' makes no difference. */ ++ if (! toplevel_bindings_p () ++ && (RIDBIT_SETP (RID_STATIC, specbits) ++ || RIDBIT_SETP (RID_INLINE, specbits)) ++ && pedantic) ++ { ++ if (RIDBIT_SETP (RID_STATIC, specbits)) ++ pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name); ++ else ++ pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name); ++ } ++ ++ if (ctype == NULL_TREE) ++ { ++ if (virtualp) ++ { ++ error ("virtual non-class function `%s'", name); ++ virtualp = 0; ++ } ++ } ++ else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2 ++ && !NEW_DELETE_OPNAME_P (original_name)) ++ type = build_method_type_directly (ctype, ++ TREE_TYPE (type), ++ TYPE_ARG_TYPES (type)); ++ ++ /* Record presence of `static'. */ ++ publicp = (ctype != NULL_TREE ++ || RIDBIT_SETP (RID_EXTERN, specbits) ++ || !RIDBIT_SETP (RID_STATIC, specbits)); ++ ++ decl = grokfndecl (ctype, type, original_name, parms, declarator, ++ virtualp, flags, quals, raises, ++ 1, friendp, ++ publicp, inlinep, funcdef_flag, ++ template_count, in_namespace); ++ if (decl == NULL_TREE) ++ return NULL_TREE; ++ ++ if (staticp == 1) ++ { ++ int invalid_static = 0; ++ ++ /* Don't allow a static member function in a class, and forbid ++ declaring main to be static. */ ++ if (TREE_CODE (type) == METHOD_TYPE) ++ { ++ pedwarn ("cannot declare member function `%D' to have static linkage", decl); ++ invalid_static = 1; ++ } ++ else if (current_function_decl) ++ { ++ /* FIXME need arm citation */ ++ error ("cannot declare static function inside another function"); ++ invalid_static = 1; ++ } ++ ++ if (invalid_static) ++ { ++ staticp = 0; ++ RIDBIT_RESET (RID_STATIC, specbits); ++ } ++ } ++ } ++ else ++ { ++ /* It's a variable. */ ++ ++ /* An uninitialized decl with `extern' is a reference. */ ++ decl = grokvardecl (type, declarator, &specbits, ++ initialized, ++ (type_quals & TYPE_QUAL_CONST) != 0, ++ ctype ? ctype : in_namespace); ++ bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE, ++ inlinep, friendp, raises != NULL_TREE); ++ ++ if (ctype) ++ { ++ DECL_CONTEXT (decl) = ctype; ++ if (staticp == 1) ++ { ++ pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member"); ++ staticp = 0; ++ RIDBIT_RESET (RID_STATIC, specbits); ++ } ++ if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl)) ++ { ++ error ("static member `%D' declared `register'", decl); ++ RIDBIT_RESET (RID_REGISTER, specbits); ++ } ++ if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic) ++ { ++ pedwarn ("cannot explicitly declare member `%#D' to have extern linkage", ++ decl); ++ RIDBIT_RESET (RID_EXTERN, specbits); ++ } ++ } ++ } ++ ++ my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927); ++ ++ /* Record `register' declaration for warnings on & ++ and in case doing stupid register allocation. */ ++ ++ if (RIDBIT_SETP (RID_REGISTER, specbits)) ++ DECL_REGISTER (decl) = 1; ++ ++ if (RIDBIT_SETP (RID_EXTERN, specbits)) ++ DECL_THIS_EXTERN (decl) = 1; ++ ++ if (RIDBIT_SETP (RID_STATIC, specbits)) ++ DECL_THIS_STATIC (decl) = 1; ++ ++ /* Record constancy and volatility. There's no need to do this ++ when processing a template; we'll do this for the instantiated ++ declaration based on the type of DECL. */ ++ if (!processing_template_decl) ++ c_apply_type_quals_to_decl (type_quals, decl); ++ ++ return decl; ++ } ++} ++ ++/* Subroutine of start_function. Ensure that each of the parameter ++ types (as listed in PARMS) is complete, as is required for a ++ function definition. */ ++ ++static void ++require_complete_types_for_parms (tree parms) ++{ ++ for (; parms; parms = TREE_CHAIN (parms)) ++ { ++ if (VOID_TYPE_P (TREE_TYPE (parms))) ++ /* grokparms will have already issued an error. */ ++ TREE_TYPE (parms) = error_mark_node; ++ else if (complete_type_or_else (TREE_TYPE (parms), parms)) ++ { ++ layout_decl (parms, 0); ++ DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms)); ++ } ++ } ++} ++ ++/* Returns nonzero if T is a local variable. */ ++ ++int ++local_variable_p (tree t) ++{ ++ if ((TREE_CODE (t) == VAR_DECL ++ /* A VAR_DECL with a context that is a _TYPE is a static data ++ member. */ ++ && !TYPE_P (CP_DECL_CONTEXT (t)) ++ /* Any other non-local variable must be at namespace scope. */ ++ && !DECL_NAMESPACE_SCOPE_P (t)) ++ || (TREE_CODE (t) == PARM_DECL)) ++ return 1; ++ ++ return 0; ++} ++ ++/* Returns nonzero if T is an automatic local variable or a label. ++ (These are the declarations that need to be remapped when the code ++ containing them is duplicated.) */ ++ ++int ++nonstatic_local_decl_p (tree t) ++{ ++ return ((local_variable_p (t) && !TREE_STATIC (t)) ++ || TREE_CODE (t) == LABEL_DECL ++ || TREE_CODE (t) == RESULT_DECL); ++} ++ ++/* Like local_variable_p, but suitable for use as a tree-walking ++ function. */ ++ ++static tree ++local_variable_p_walkfn (tree* tp, ++ int* walk_subtrees ATTRIBUTE_UNUSED , ++ void* data ATTRIBUTE_UNUSED ) ++{ ++ return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp)) ++ ? *tp : NULL_TREE); ++} ++ ++/* Check that ARG, which is a default-argument expression for a ++ parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if ++ something goes wrong. DECL may also be a _TYPE node, rather than a ++ DECL, if there is no DECL available. */ ++ ++tree ++check_default_argument (tree decl, tree arg) ++{ ++ tree var; ++ tree decl_type; ++ ++ if (TREE_CODE (arg) == DEFAULT_ARG) ++ /* We get a DEFAULT_ARG when looking at an in-class declaration ++ with a default argument. Ignore the argument for now; we'll ++ deal with it after the class is complete. */ ++ return arg; ++ ++ if (processing_template_decl || uses_template_parms (arg)) ++ /* We don't do anything checking until instantiation-time. Note ++ that there may be uninstantiated arguments even for an ++ instantiated function, since default arguments are not ++ instantiated until they are needed. */ ++ return arg; ++ ++ if (TYPE_P (decl)) ++ { ++ decl_type = decl; ++ decl = NULL_TREE; ++ } ++ else ++ decl_type = TREE_TYPE (decl); ++ ++ if (arg == error_mark_node ++ || decl == error_mark_node ++ || TREE_TYPE (arg) == error_mark_node ++ || decl_type == error_mark_node) ++ /* Something already went wrong. There's no need to check ++ further. */ ++ return error_mark_node; ++ ++ /* [dcl.fct.default] ++ ++ A default argument expression is implicitly converted to the ++ parameter type. */ ++ if (!TREE_TYPE (arg) ++ || !can_convert_arg (decl_type, TREE_TYPE (arg), arg)) ++ { ++ if (decl) ++ error ("default argument for `%#D' has type `%T'", ++ decl, TREE_TYPE (arg)); ++ else ++ error ("default argument for parameter of type `%T' has type `%T'", ++ decl_type, TREE_TYPE (arg)); ++ ++ return error_mark_node; ++ } ++ ++ /* [dcl.fct.default] ++ ++ Local variables shall not be used in default argument ++ expressions. ++ ++ The keyword `this' shall not be used in a default argument of a ++ member function. */ ++ var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn, ++ NULL); ++ if (var) ++ { ++ error ("default argument `%E' uses local variable `%D'", ++ arg, var); ++ return error_mark_node; ++ } ++ ++ /* All is well. */ ++ return arg; ++} ++ ++/* Decode the list of parameter types for a function type. ++ Given the list of things declared inside the parens, ++ return a list of types. ++ ++ We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P ++ flag. If unset, we append void_list_node. A parmlist declared ++ as `(void)' is accepted as the empty parmlist. ++ ++ *PARMS is set to the chain of PARM_DECLs created. */ ++ ++static tree ++grokparms (tree first_parm, tree *parms) ++{ ++ tree result = NULL_TREE; ++ tree decls = NULL_TREE; ++ int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm); ++ tree parm, chain; ++ int any_error = 0; ++ ++ my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115); ++ ++ for (parm = first_parm; parm != NULL_TREE; parm = chain) ++ { ++ tree type = NULL_TREE; ++ tree decl = TREE_VALUE (parm); ++ tree init = TREE_PURPOSE (parm); ++ tree specs, attrs; ++ ++ chain = TREE_CHAIN (parm); ++ /* @@ weak defense against parse errors. */ ++ if (TREE_CODE (decl) != VOID_TYPE ++ && TREE_CODE (decl) != TREE_LIST) ++ { ++ /* Give various messages as the need arises. */ ++ if (TREE_CODE (decl) == STRING_CST) ++ error ("invalid string constant `%E'", decl); ++ else if (TREE_CODE (decl) == INTEGER_CST) ++ error ("invalid integer constant in parameter list, did you forget to give parameter name?"); ++ continue; ++ } ++ ++ if (parm == void_list_node) ++ break; ++ ++ split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs); ++ decl = grokdeclarator (TREE_VALUE (decl), specs, ++ PARM, init != NULL_TREE, &attrs); ++ if (! decl || TREE_TYPE (decl) == error_mark_node) ++ continue; ++ ++ if (attrs) ++ cplus_decl_attributes (&decl, attrs, 0); ++ ++ type = TREE_TYPE (decl); ++ if (VOID_TYPE_P (type)) ++ { ++ if (same_type_p (type, void_type_node) ++ && !DECL_NAME (decl) && !result && !chain && !ellipsis) ++ /* this is a parmlist of `(void)', which is ok. */ ++ break; ++ cxx_incomplete_type_error (decl, type); ++ /* It's not a good idea to actually create parameters of ++ type `void'; other parts of the compiler assume that a ++ void type terminates the parameter list. */ ++ type = error_mark_node; ++ TREE_TYPE (decl) = error_mark_node; ++ } ++ ++ if (type != error_mark_node) ++ { ++ /* Top-level qualifiers on the parameters are ++ ignored for function types. */ ++ type = cp_build_qualified_type (type, 0); ++ if (TREE_CODE (type) == METHOD_TYPE) ++ { ++ error ("parameter `%D' invalidly declared method type", decl); ++ type = build_pointer_type (type); ++ TREE_TYPE (decl) = type; ++ } ++ else if (abstract_virtuals_error (decl, type)) ++ any_error = 1; /* Seems like a good idea. */ ++ else if (POINTER_TYPE_P (type)) ++ { ++ /* [dcl.fct]/6, parameter types cannot contain pointers ++ (references) to arrays of unknown bound. */ ++ tree t = TREE_TYPE (type); ++ int ptr = TYPE_PTR_P (type); ++ ++ while (1) ++ { ++ if (TYPE_PTR_P (t)) ++ ptr = 1; ++ else if (TREE_CODE (t) != ARRAY_TYPE) ++ break; ++ else if (!TYPE_DOMAIN (t)) ++ break; ++ t = TREE_TYPE (t); ++ } ++ if (TREE_CODE (t) == ARRAY_TYPE) ++ error ("parameter `%D' includes %s to array of unknown bound `%T'", ++ decl, ptr ? "pointer" : "reference", t); ++ } ++ ++ if (!any_error && init) ++ init = check_default_argument (decl, init); ++ else ++ init = NULL_TREE; ++ } ++ ++ TREE_CHAIN (decl) = decls; ++ decls = decl; ++ result = tree_cons (init, type, result); ++ } ++ decls = nreverse (decls); ++ result = nreverse (result); ++ if (!ellipsis) ++ result = chainon (result, void_list_node); ++ *parms = decls; ++ ++ return result; ++} ++ ++ ++/* D is a constructor or overloaded `operator='. ++ ++ Let T be the class in which D is declared. Then, this function ++ returns: ++ ++ -1 if D's is an ill-formed constructor or copy assignment operator ++ whose first parameter is of type `T'. ++ 0 if D is not a copy constructor or copy assignment ++ operator. ++ 1 if D is a copy constructor or copy assignment operator whose ++ first parameter is a reference to const qualified T. ++ 2 if D is a copy constructor or copy assignment operator whose ++ first parameter is a reference to non-const qualified T. ++ ++ This function can be used as a predicate. Positive values indicate ++ a copy constructor and nonzero values indicate a copy assignment ++ operator. */ ++ ++int ++copy_fn_p (tree d) ++{ ++ tree args; ++ tree arg_type; ++ int result = 1; ++ ++ my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208); ++ ++ if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d))) ++ /* Instantiations of template member functions are never copy ++ functions. Note that member functions of templated classes are ++ represented as template functions internally, and we must ++ accept those as copy functions. */ ++ return 0; ++ ++ args = FUNCTION_FIRST_USER_PARMTYPE (d); ++ if (!args) ++ return 0; ++ ++ arg_type = TREE_VALUE (args); ++ ++ if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d)) ++ { ++ /* Pass by value copy assignment operator. */ ++ result = -1; ++ } ++ else if (TREE_CODE (arg_type) == REFERENCE_TYPE ++ && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d)) ++ { ++ if (CP_TYPE_CONST_P (TREE_TYPE (arg_type))) ++ result = 2; ++ } ++ else ++ return 0; ++ ++ args = TREE_CHAIN (args); ++ ++ if (args && args != void_list_node && !TREE_PURPOSE (args)) ++ /* There are more non-optional args. */ ++ return 0; ++ ++ return result; ++} ++ ++/* Remember any special properties of member function DECL. */ ++ ++void grok_special_member_properties (tree decl) ++{ ++ if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl)) ++ ; /* Not special. */ ++ else if (DECL_CONSTRUCTOR_P (decl)) ++ { ++ int ctor = copy_fn_p (decl); ++ ++ if (ctor > 0) ++ { ++ /* [class.copy] ++ ++ A non-template constructor for class X is a copy ++ constructor if its first parameter is of type X&, const ++ X&, volatile X& or const volatile X&, and either there ++ are no other parameters or else all other parameters have ++ default arguments. */ ++ TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1; ++ if (ctor > 1) ++ TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1; ++ } ++ else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl))) ++ TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1; ++ } ++ else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR) ++ { ++ /* [class.copy] ++ ++ A non-template assignment operator for class X is a copy ++ assignment operator if its parameter is of type X, X&, const ++ X&, volatile X& or const volatile X&. */ ++ ++ int assop = copy_fn_p (decl); ++ ++ if (assop) ++ { ++ TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1; ++ if (assop != 1) ++ TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1; ++ if (DECL_PURE_VIRTUAL_P (decl)) ++ TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1; ++ } ++ } ++} ++ ++/* Check a constructor DECL has the correct form. Complains ++ if the class has a constructor of the form X(X). */ ++ ++int ++grok_ctor_properties (tree ctype, tree decl) ++{ ++ int ctor_parm = copy_fn_p (decl); ++ ++ if (ctor_parm < 0) ++ { ++ /* [class.copy] ++ ++ A declaration of a constructor for a class X is ill-formed if ++ its first parameter is of type (optionally cv-qualified) X ++ and either there are no other parameters or else all other ++ parameters have default arguments. ++ ++ We *don't* complain about member template instantiations that ++ have this form, though; they can occur as we try to decide ++ what constructor to use during overload resolution. Since ++ overload resolution will never prefer such a constructor to ++ the non-template copy constructor (which is either explicitly ++ or implicitly defined), there's no need to worry about their ++ existence. Theoretically, they should never even be ++ instantiated, but that's hard to forestall. */ ++ error ("invalid constructor; you probably meant `%T (const %T&)'", ++ ctype, ctype); ++ SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype); ++ return 0; ++ } ++ ++ return 1; ++} ++ ++/* An operator with this code is unary, but can also be binary. */ ++ ++static int ++ambi_op_p (enum tree_code code) ++{ ++ return (code == INDIRECT_REF ++ || code == ADDR_EXPR ++ || code == CONVERT_EXPR ++ || code == NEGATE_EXPR ++ || code == PREINCREMENT_EXPR ++ || code == PREDECREMENT_EXPR); ++} ++ ++/* An operator with this name can only be unary. */ ++ ++static int ++unary_op_p (enum tree_code code) ++{ ++ return (code == TRUTH_NOT_EXPR ++ || code == BIT_NOT_EXPR ++ || code == COMPONENT_REF ++ || code == TYPE_EXPR); ++} ++ ++/* DECL is a declaration for an overloaded operator. Returns true if ++ the declaration is valid; false otherwise. If COMPLAIN is true, ++ errors are issued for invalid declarations. */ ++ ++bool ++grok_op_properties (tree decl, int friendp, bool complain) ++{ ++ tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl)); ++ tree argtype; ++ int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE); ++ tree name = DECL_NAME (decl); ++ enum tree_code operator_code; ++ int arity; ++ bool ok; ++ ++ /* Assume that the declaration is valid. */ ++ ok = true; ++ ++ /* Count the number of arguments. */ ++ for (argtype = argtypes, arity = 0; ++ argtype && argtype != void_list_node; ++ argtype = TREE_CHAIN (argtype)) ++ ++arity; ++ ++ if (current_class_type == NULL_TREE) ++ friendp = 1; ++ ++ if (DECL_CONV_FN_P (decl)) ++ operator_code = TYPE_EXPR; ++ else ++ do ++ { ++#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ ++ if (ansi_opname (CODE) == name) \ ++ { \ ++ operator_code = (CODE); \ ++ break; \ ++ } \ ++ else if (ansi_assopname (CODE) == name) \ ++ { \ ++ operator_code = (CODE); \ ++ DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \ ++ break; \ ++ } ++ ++#include "operators.def" ++#undef DEF_OPERATOR ++ ++ abort (); ++ } ++ while (0); ++ my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526); ++ SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); ++ ++ if (! friendp) ++ { ++ switch (operator_code) ++ { ++ case NEW_EXPR: ++ TYPE_HAS_NEW_OPERATOR (current_class_type) = 1; ++ break; ++ ++ case DELETE_EXPR: ++ TYPE_GETS_DELETE (current_class_type) |= 1; ++ break; ++ ++ case VEC_NEW_EXPR: ++ TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1; ++ break; ++ ++ case VEC_DELETE_EXPR: ++ TYPE_GETS_DELETE (current_class_type) |= 2; ++ break; ++ ++ default: ++ break; ++ } ++ } ++ ++ if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR) ++ TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl)); ++ else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR) ++ TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl)); ++ else ++ { ++ /* An operator function must either be a non-static member function ++ or have at least one parameter of a class, a reference to a class, ++ an enumeration, or a reference to an enumeration. 13.4.0.6 */ ++ if (! methodp || DECL_STATIC_FUNCTION_P (decl)) ++ { ++ if (operator_code == TYPE_EXPR ++ || operator_code == CALL_EXPR ++ || operator_code == COMPONENT_REF ++ || operator_code == ARRAY_REF ++ || operator_code == NOP_EXPR) ++ error ("`%D' must be a nonstatic member function", decl); ++ else ++ { ++ tree p; ++ ++ if (DECL_STATIC_FUNCTION_P (decl)) ++ error ("`%D' must be either a non-static member function or a non-member function", decl); ++ ++ for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p)) ++ { ++ tree arg = non_reference (TREE_VALUE (p)); ++ /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used ++ because these checks are performed even on ++ template functions. */ ++ if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE) ++ break; ++ } ++ ++ if (!p || p == void_list_node) ++ { ++ if (!complain) ++ return false; ++ ++ error ("`%D' must have an argument of class or " ++ "enumerated type", ++ decl); ++ ok = false; ++ } ++ } ++ } ++ ++ /* There are no restrictions on the arguments to an overloaded ++ "operator ()". */ ++ if (operator_code == CALL_EXPR) ++ return ok; ++ ++ if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl)) ++ { ++ tree t = TREE_TYPE (name); ++ if (! friendp) ++ { ++ int ref = (TREE_CODE (t) == REFERENCE_TYPE); ++ const char *what = 0; ++ ++ if (ref) ++ t = TYPE_MAIN_VARIANT (TREE_TYPE (t)); ++ ++ if (TREE_CODE (t) == VOID_TYPE) ++ what = "void"; ++ else if (t == current_class_type) ++ what = "the same type"; ++ /* Don't force t to be complete here. */ ++ else if (IS_AGGR_TYPE (t) ++ && COMPLETE_TYPE_P (t) ++ && DERIVED_FROM_P (t, current_class_type)) ++ what = "a base class"; ++ ++ if (what && warn_conversion) ++ warning ("conversion to %s%s will never use a type conversion operator", ++ ref ? "a reference to " : "", what); ++ } ++ } ++ if (operator_code == COND_EXPR) ++ { ++ /* 13.4.0.3 */ ++ error ("ISO C++ prohibits overloading operator ?:"); ++ } ++ else if (ambi_op_p (operator_code)) ++ { ++ if (arity == 1) ++ /* We pick the one-argument operator codes by default, so ++ we don't have to change anything. */ ++ ; ++ else if (arity == 2) ++ { ++ /* If we thought this was a unary operator, we now know ++ it to be a binary operator. */ ++ switch (operator_code) ++ { ++ case INDIRECT_REF: ++ operator_code = MULT_EXPR; ++ break; ++ ++ case ADDR_EXPR: ++ operator_code = BIT_AND_EXPR; ++ break; ++ ++ case CONVERT_EXPR: ++ operator_code = PLUS_EXPR; ++ break; ++ ++ case NEGATE_EXPR: ++ operator_code = MINUS_EXPR; ++ break; ++ ++ case PREINCREMENT_EXPR: ++ operator_code = POSTINCREMENT_EXPR; ++ break; ++ ++ case PREDECREMENT_EXPR: ++ operator_code = POSTDECREMENT_EXPR; ++ break; ++ ++ default: ++ abort (); ++ } ++ ++ SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); ++ ++ if ((operator_code == POSTINCREMENT_EXPR ++ || operator_code == POSTDECREMENT_EXPR) ++ && ! processing_template_decl ++ && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node)) ++ { ++ if (methodp) ++ error ("postfix `%D' must take `int' as its argument", ++ decl); ++ else ++ error ++ ("postfix `%D' must take `int' as its second argument", ++ decl); ++ } ++ } ++ else ++ { ++ if (methodp) ++ error ("`%D' must take either zero or one argument", decl); ++ else ++ error ("`%D' must take either one or two arguments", decl); ++ } ++ ++ /* More Effective C++ rule 6. */ ++ if (warn_ecpp ++ && (operator_code == POSTINCREMENT_EXPR ++ || operator_code == POSTDECREMENT_EXPR ++ || operator_code == PREINCREMENT_EXPR ++ || operator_code == PREDECREMENT_EXPR)) ++ { ++ tree arg = TREE_VALUE (argtypes); ++ tree ret = TREE_TYPE (TREE_TYPE (decl)); ++ if (methodp || TREE_CODE (arg) == REFERENCE_TYPE) ++ arg = TREE_TYPE (arg); ++ arg = TYPE_MAIN_VARIANT (arg); ++ if (operator_code == PREINCREMENT_EXPR ++ || operator_code == PREDECREMENT_EXPR) ++ { ++ if (TREE_CODE (ret) != REFERENCE_TYPE ++ || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)), ++ arg)) ++ warning ("prefix `%D' should return `%T'", decl, ++ build_reference_type (arg)); ++ } ++ else ++ { ++ if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg)) ++ warning ("postfix `%D' should return `%T'", decl, arg); ++ } ++ } ++ } ++ else if (unary_op_p (operator_code)) ++ { ++ if (arity != 1) ++ { ++ if (methodp) ++ error ("`%D' must take `void'", decl); ++ else ++ error ("`%D' must take exactly one argument", decl); ++ } ++ } ++ else /* if (binary_op_p (operator_code)) */ ++ { ++ if (arity != 2) ++ { ++ if (methodp) ++ error ("`%D' must take exactly one argument", decl); ++ else ++ error ("`%D' must take exactly two arguments", decl); ++ } ++ ++ /* More Effective C++ rule 7. */ ++ if (warn_ecpp ++ && (operator_code == TRUTH_ANDIF_EXPR ++ || operator_code == TRUTH_ORIF_EXPR ++ || operator_code == COMPOUND_EXPR)) ++ warning ("user-defined `%D' always evaluates both arguments", ++ decl); ++ } ++ ++ /* Effective C++ rule 23. */ ++ if (warn_ecpp ++ && arity == 2 ++ && !DECL_ASSIGNMENT_OPERATOR_P (decl) ++ && (operator_code == PLUS_EXPR ++ || operator_code == MINUS_EXPR ++ || operator_code == TRUNC_DIV_EXPR ++ || operator_code == MULT_EXPR ++ || operator_code == TRUNC_MOD_EXPR) ++ && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE) ++ warning ("`%D' should return by value", decl); ++ ++ /* [over.oper]/8 */ ++ for (; argtypes && argtypes != void_list_node; ++ argtypes = TREE_CHAIN (argtypes)) ++ if (TREE_PURPOSE (argtypes)) ++ { ++ TREE_PURPOSE (argtypes) = NULL_TREE; ++ if (operator_code == POSTINCREMENT_EXPR ++ || operator_code == POSTDECREMENT_EXPR) ++ { ++ if (pedantic) ++ pedwarn ("`%D' cannot have default arguments", decl); ++ } ++ else ++ error ("`%D' cannot have default arguments", decl); ++ } ++ ++ } ++ ++ return ok; ++} ++ ++static const char * ++tag_name (enum tag_types code) ++{ ++ switch (code) ++ { ++ case record_type: ++ return "struct"; ++ case class_type: ++ return "class"; ++ case union_type: ++ return "union "; ++ case enum_type: ++ return "enum"; ++ default: ++ abort (); ++ } ++} ++ ++/* Name lookup in an elaborated-type-specifier (after the keyword ++ indicated by TAG_CODE) has found the TYPE_DECL DECL. If the ++ elaborated-type-specifier is invalid, issue a diagnostic and return ++ error_mark_node; otherwise, return the *_TYPE to which it referred. ++ If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */ ++ ++tree ++check_elaborated_type_specifier (enum tag_types tag_code, ++ tree decl, ++ bool allow_template_p) ++{ ++ tree type; ++ ++ /* In the case of: ++ ++ struct S { struct S *p; }; ++ ++ name lookup will find the TYPE_DECL for the implicit "S::S" ++ typedef. Adjust for that here. */ ++ if (DECL_SELF_REFERENCE_P (decl)) ++ decl = TYPE_NAME (TREE_TYPE (decl)); ++ ++ type = TREE_TYPE (decl); ++ ++ /* [dcl.type.elab] ++ ++ If the identifier resolves to a typedef-name or a template ++ type-parameter, the elaborated-type-specifier is ill-formed. ++ ++ In other words, the only legitimate declaration to use in the ++ elaborated type specifier is the implicit typedef created when ++ the type is declared. */ ++ if (!DECL_IMPLICIT_TYPEDEF_P (decl)) ++ { ++ error ("using typedef-name `%D' after `%s'", decl, tag_name (tag_code)); ++ return IS_AGGR_TYPE (type) ? type : error_mark_node; ++ } ++ ++ if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) ++ { ++ error ("using template type parameter `%T' after `%s'", ++ type, tag_name (tag_code)); ++ return error_mark_node; ++ } ++ else if (TREE_CODE (type) != RECORD_TYPE ++ && TREE_CODE (type) != UNION_TYPE ++ && tag_code != enum_type) ++ { ++ error ("`%T' referred to as `%s'", type, tag_name (tag_code)); ++ return error_mark_node; ++ } ++ else if (TREE_CODE (type) != ENUMERAL_TYPE ++ && tag_code == enum_type) ++ { ++ error ("`%T' referred to as enum", type); ++ return error_mark_node; ++ } ++ else if (!allow_template_p ++ && TREE_CODE (type) == RECORD_TYPE ++ && CLASSTYPE_IS_TEMPLATE (type)) ++ { ++ /* If a class template appears as elaborated type specifier ++ without a template header such as: ++ ++ template class C {}; ++ void f(class C); // No template header here ++ ++ then the required template argument is missing. */ ++ ++ error ("template argument required for `%s %T'", ++ tag_name (tag_code), ++ DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))); ++ return error_mark_node; ++ } ++ ++ return type; ++} ++ ++/* Get the struct, enum or union (TAG_CODE says which) with tag NAME. ++ Define the tag as a forward-reference if it is not defined. ++ ++ If a declaration is given, process it here, and report an error if ++ multiple declarations are not identical. ++ ++ GLOBALIZE is false when this is also a definition. Only look in ++ the current frame for the name (since C++ allows new names in any ++ scope.) ++ ++ TEMPLATE_HEADER_P is true when this declaration is preceded by ++ a set of template parameters. */ ++ ++tree ++xref_tag (enum tag_types tag_code, tree name, ++ bool globalize, bool template_header_p) ++{ ++ enum tree_code code; ++ tree t; ++ struct cp_binding_level *b = current_binding_level; ++ tree context = NULL_TREE; ++ ++ timevar_push (TV_NAME_LOOKUP); ++ ++ my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0); ++ ++ switch (tag_code) ++ { ++ case record_type: ++ case class_type: ++ code = RECORD_TYPE; ++ break; ++ case union_type: ++ code = UNION_TYPE; ++ break; ++ case enum_type: ++ code = ENUMERAL_TYPE; ++ break; ++ default: ++ abort (); ++ } ++ ++ if (! globalize) ++ { ++ /* If we know we are defining this tag, only look it up in ++ this scope and don't try to find it as a type. */ ++ t = lookup_tag (code, name, b, 1); ++ } ++ else ++ { ++ tree decl = lookup_name (name, 2); ++ ++ if (decl && DECL_CLASS_TEMPLATE_P (decl)) ++ decl = DECL_TEMPLATE_RESULT (decl); ++ ++ if (decl && TREE_CODE (decl) == TYPE_DECL) ++ { ++ /* Two cases we need to consider when deciding if a class ++ template is allowed as an elaborated type specifier: ++ 1. It is a self reference to its own class. ++ 2. It comes with a template header. ++ ++ For example: ++ ++ template class C { ++ class C *c1; // DECL_SELF_REFERENCE_P is true ++ class D; ++ }; ++ template class C; // template_header_p is true ++ template class C::D { ++ class C *c2; // DECL_SELF_REFERENCE_P is true ++ }; */ ++ ++ t = check_elaborated_type_specifier (tag_code, ++ decl, ++ template_header_p ++ | DECL_SELF_REFERENCE_P (decl)); ++ if (t == error_mark_node) ++ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); ++ } ++ else ++ t = NULL_TREE; ++ ++ if (t && current_class_type ++ && template_class_depth (current_class_type) ++ && template_header_p) ++ { ++ /* Since GLOBALIZE is nonzero, we are not looking at a ++ definition of this tag. Since, in addition, we are currently ++ processing a (member) template declaration of a template ++ class, we must be very careful; consider: ++ ++ template ++ struct S1 ++ ++ template ++ struct S2 ++ { template ++ friend struct S1; }; ++ ++ Here, the S2::S1 declaration should not be confused with the ++ outer declaration. In particular, the inner version should ++ have a template parameter of level 2, not level 1. This ++ would be particularly important if the member declaration ++ were instead: ++ ++ template friend struct S1; ++ ++ say, when we should tsubst into `U' when instantiating ++ S2. On the other hand, when presented with: ++ ++ template ++ struct S1 { ++ template ++ struct S2 {}; ++ template ++ friend struct S2; ++ }; ++ ++ we must find the inner binding eventually. We ++ accomplish this by making sure that the new type we ++ create to represent this declaration has the right ++ TYPE_CONTEXT. */ ++ context = TYPE_CONTEXT (t); ++ t = NULL_TREE; ++ } ++ } ++ ++ if (! t) ++ { ++ /* If no such tag is yet defined, create a forward-reference node ++ and record it as the "definition". ++ When a real declaration of this type is found, ++ the forward-reference will be altered into a real type. */ ++ if (code == ENUMERAL_TYPE) ++ { ++ error ("use of enum `%#D' without previous declaration", name); ++ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); ++ } ++ else ++ { ++ t = make_aggr_type (code); ++ TYPE_CONTEXT (t) = context; ++ pushtag (name, t, globalize); ++ } ++ } ++ else ++ { ++ if (!globalize && processing_template_decl && IS_AGGR_TYPE (t)) ++ redeclare_class_template (t, current_template_parms); ++ else if (!processing_template_decl ++ && CLASS_TYPE_P (t) ++ && CLASSTYPE_IS_TEMPLATE (t)) ++ { ++ error ("redeclaration of `%T' as a non-template", t); ++ t = error_mark_node; ++ } ++ } ++ ++ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); ++} ++ ++tree ++xref_tag_from_type (tree old, tree id, int globalize) ++{ ++ enum tag_types tag_kind; ++ ++ if (TREE_CODE (old) == RECORD_TYPE) ++ tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type); ++ else ++ tag_kind = union_type; ++ ++ if (id == NULL_TREE) ++ id = TYPE_IDENTIFIER (old); ++ ++ return xref_tag (tag_kind, id, globalize, false); ++} ++ ++/* REF is a type (named NAME), for which we have just seen some ++ baseclasses. BASE_LIST is a list of those baseclasses; the ++ TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of ++ the base-class. TREE_VIA_VIRTUAL indicates virtual ++ inheritance. CODE_TYPE_NODE indicates whether REF is a class, ++ struct, or union. */ ++ ++void ++xref_basetypes (tree ref, tree base_list) ++{ ++ /* In the declaration `A : X, Y, ... Z' we mark all the types ++ (A, X, Y, ..., Z) so we can check for duplicates. */ ++ tree *basep; ++ ++ int i; ++ enum tag_types tag_code; ++ ++ if (ref == error_mark_node) ++ return; ++ ++ if (TREE_CODE (ref) == UNION_TYPE) ++ { ++ error ("derived union `%T' invalid", ref); ++ return; ++ } ++ ++ tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type); ++ ++ /* First, make sure that any templates in base-classes are ++ instantiated. This ensures that if we call ourselves recursively ++ we do not get confused about which classes are marked and which ++ are not. */ ++ basep = &base_list; ++ while (*basep) ++ { ++ tree basetype = TREE_VALUE (*basep); ++ if (!(processing_template_decl && uses_template_parms (basetype)) ++ && !complete_type_or_else (basetype, NULL)) ++ /* An incomplete type. Remove it from the list. */ ++ *basep = TREE_CHAIN (*basep); ++ else ++ basep = &TREE_CHAIN (*basep); ++ } ++ ++ SET_CLASSTYPE_MARKED (ref); ++ i = list_length (base_list); ++ if (i) ++ { ++ tree binfo = TYPE_BINFO (ref); ++ tree binfos = make_tree_vec (i); ++ tree accesses = make_tree_vec (i); ++ ++ BINFO_BASETYPES (binfo) = binfos; ++ BINFO_BASEACCESSES (binfo) = accesses; ++ ++ for (i = 0; base_list; base_list = TREE_CHAIN (base_list)) ++ { ++ tree access = TREE_PURPOSE (base_list); ++ int via_virtual = TREE_VIA_VIRTUAL (base_list); ++ tree basetype = TREE_VALUE (base_list); ++ tree base_binfo; ++ ++ if (access == access_default_node) ++ /* The base of a derived struct is public by default. */ ++ access = (tag_code == class_type ++ ? access_private_node : access_public_node); ++ ++ if (basetype && TREE_CODE (basetype) == TYPE_DECL) ++ basetype = TREE_TYPE (basetype); ++ if (!basetype ++ || (TREE_CODE (basetype) != RECORD_TYPE ++ && TREE_CODE (basetype) != TYPENAME_TYPE ++ && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM ++ && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)) ++ { ++ error ("base type `%T' fails to be a struct or class type", ++ basetype); ++ continue; ++ } ++ ++ if (CLASSTYPE_MARKED (basetype)) ++ { ++ if (basetype == ref) ++ error ("recursive type `%T' undefined", basetype); ++ else ++ error ("duplicate base type `%T' invalid", basetype); ++ continue; ++ } ++ ++ if (TYPE_FOR_JAVA (basetype) ++ && (current_lang_depth () == 0)) ++ TYPE_FOR_JAVA (ref) = 1; ++ ++ if (CLASS_TYPE_P (basetype)) ++ { ++ base_binfo = TYPE_BINFO (basetype); ++ /* This flag will be in the binfo of the base type, we must ++ clear it after copying the base binfos. */ ++ BINFO_DEPENDENT_BASE_P (base_binfo) ++ = dependent_type_p (basetype); ++ } ++ else ++ base_binfo = make_binfo (size_zero_node, basetype, ++ NULL_TREE, NULL_TREE); ++ ++ TREE_VEC_ELT (binfos, i) = base_binfo; ++ TREE_VEC_ELT (accesses, i) = access; ++ /* This flag will be in the binfo of the base type, we must ++ clear it after copying the base binfos. */ ++ TREE_VIA_VIRTUAL (base_binfo) = via_virtual; ++ ++ SET_CLASSTYPE_MARKED (basetype); ++ ++ /* We are free to modify these bits because they are meaningless ++ at top level, and BASETYPE is a top-level type. */ ++ if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype)) ++ { ++ TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1; ++ /* Converting to a virtual base class requires looking ++ up the offset of the virtual base. */ ++ TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1; ++ } ++ ++ if (CLASS_TYPE_P (basetype)) ++ { ++ TYPE_HAS_NEW_OPERATOR (ref) ++ |= TYPE_HAS_NEW_OPERATOR (basetype); ++ TYPE_HAS_ARRAY_NEW_OPERATOR (ref) ++ |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype); ++ TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype); ++ /* If the base-class uses multiple inheritance, so do we. */ ++ TYPE_USES_MULTIPLE_INHERITANCE (ref) ++ |= TYPE_USES_MULTIPLE_INHERITANCE (basetype); ++ /* Likewise, if converting to a base of the base may require ++ code, then we may need to generate code to convert to a ++ base as well. */ ++ TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) ++ |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype); ++ } ++ i++; ++ } ++ if (i) ++ TREE_VEC_LENGTH (accesses) = TREE_VEC_LENGTH (binfos) = i; ++ else ++ BINFO_BASEACCESSES (binfo) = BINFO_BASETYPES (binfo) = NULL_TREE; ++ ++ if (i > 1) ++ { ++ TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1; ++ /* If there is more than one non-empty they cannot be at the same ++ address. */ ++ TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1; ++ } ++ } ++ ++ /* Copy the base binfos, collect the virtual bases and set the ++ inheritance order chain. */ ++ copy_base_binfos (TYPE_BINFO (ref), ref, NULL_TREE); ++ CLASSTYPE_VBASECLASSES (ref) = nreverse (CLASSTYPE_VBASECLASSES (ref)); ++ ++ if (TYPE_FOR_JAVA (ref)) ++ { ++ if (TYPE_USES_MULTIPLE_INHERITANCE (ref)) ++ error ("Java class '%T' cannot have multiple bases", ref); ++ if (CLASSTYPE_VBASECLASSES (ref)) ++ error ("Java class '%T' cannot have virtual bases", ref); ++ } ++ ++ /* Unmark all the types. */ ++ while (i--) ++ { ++ tree basetype = BINFO_TYPE (BINFO_BASETYPE (TYPE_BINFO (ref), i)); ++ ++ CLEAR_CLASSTYPE_MARKED (basetype); ++ if (CLASS_TYPE_P (basetype)) ++ { ++ TREE_VIA_VIRTUAL (TYPE_BINFO (basetype)) = 0; ++ BINFO_DEPENDENT_BASE_P (TYPE_BINFO (basetype)) = 0; ++ } ++ } ++ CLEAR_CLASSTYPE_MARKED (ref); ++} ++ ++ ++/* Begin compiling the definition of an enumeration type. ++ NAME is its name (or null if anonymous). ++ Returns the type object, as yet incomplete. ++ Also records info about it so that build_enumerator ++ may be used to declare the individual values as they are read. */ ++ ++tree ++start_enum (tree name) ++{ ++ tree enumtype = NULL_TREE; ++ struct cp_binding_level *b = current_binding_level; ++ ++ /* If this is the real definition for a previous forward reference, ++ fill in the contents in the same object that used to be the ++ forward reference. */ ++ ++ if (name != NULL_TREE) ++ enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1); ++ ++ if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE) ++ { ++ error ("multiple definition of `%#T'", enumtype); ++ error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype)); ++ /* Clear out TYPE_VALUES, and start again. */ ++ TYPE_VALUES (enumtype) = NULL_TREE; ++ } ++ else ++ { ++ enumtype = make_node (ENUMERAL_TYPE); ++ pushtag (name, enumtype, 0); ++ } ++ ++ return enumtype; ++} ++ ++/* After processing and defining all the values of an enumeration type, ++ install their decls in the enumeration type and finish it off. ++ ENUMTYPE is the type object and VALUES a list of name-value pairs. */ ++ ++void ++finish_enum (tree enumtype) ++{ ++ tree values; ++ tree decl; ++ tree value; ++ tree minnode; ++ tree maxnode; ++ tree t; ++ bool unsignedp; ++ int lowprec; ++ int highprec; ++ int precision; ++ integer_type_kind itk; ++ tree underlying_type = NULL_TREE; ++ ++ /* We built up the VALUES in reverse order. */ ++ TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype)); ++ ++ /* For an enum defined in a template, just set the type of the values; ++ all further processing is postponed until the template is ++ instantiated. We need to set the type so that tsubst of a CONST_DECL ++ works. */ ++ if (processing_template_decl) ++ { ++ for (values = TYPE_VALUES (enumtype); ++ values; ++ values = TREE_CHAIN (values)) ++ TREE_TYPE (TREE_VALUE (values)) = enumtype; ++ if (at_function_scope_p ()) ++ add_stmt (build_min (TAG_DEFN, enumtype)); ++ return; ++ } ++ ++ /* Determine the minimum and maximum values of the enumerators. */ ++ if (TYPE_VALUES (enumtype)) ++ { ++ minnode = maxnode = NULL_TREE; ++ ++ for (values = TYPE_VALUES (enumtype); ++ values; ++ values = TREE_CHAIN (values)) ++ { ++ decl = TREE_VALUE (values); ++ ++ /* [dcl.enum]: Following the closing brace of an enum-specifier, ++ each enumerator has the type of its enumeration. Prior to the ++ closing brace, the type of each enumerator is the type of its ++ initializing value. */ ++ TREE_TYPE (decl) = enumtype; ++ ++ /* Update the minimum and maximum values, if appropriate. */ ++ value = DECL_INITIAL (decl); ++ /* Figure out what the minimum and maximum values of the ++ enumerators are. */ ++ if (!minnode) ++ minnode = maxnode = value; ++ else if (tree_int_cst_lt (maxnode, value)) ++ maxnode = value; ++ else if (tree_int_cst_lt (value, minnode)) ++ minnode = value; ++ ++ /* Set the TREE_TYPE for the values as well. That's so that when ++ we call decl_constant_value we get an entity of the right type ++ (but with the constant value). But first make a copy so we ++ don't clobber shared INTEGER_CSTs. */ ++ if (TREE_TYPE (value) != enumtype) ++ { ++ value = DECL_INITIAL (decl) = copy_node (value); ++ TREE_TYPE (value) = enumtype; ++ } ++ } ++ } ++ else ++ /* [dcl.enum] ++ ++ If the enumerator-list is empty, the underlying type is as if ++ the enumeration had a single enumerator with value 0. */ ++ minnode = maxnode = integer_zero_node; ++ ++ /* Compute the number of bits require to represent all values of the ++ enumeration. We must do this before the type of MINNODE and ++ MAXNODE are transformed, since min_precision relies on the ++ TREE_TYPE of the value it is passed. */ ++ unsignedp = tree_int_cst_sgn (minnode) >= 0; ++ lowprec = min_precision (minnode, unsignedp); ++ highprec = min_precision (maxnode, unsignedp); ++ precision = MAX (lowprec, highprec); ++ ++ /* Determine the underlying type of the enumeration. ++ ++ [dcl.enum] ++ ++ The underlying type of an enumeration is an integral type that ++ can represent all the enumerator values defined in the ++ enumeration. It is implementation-defined which integral type is ++ used as the underlying type for an enumeration except that the ++ underlying type shall not be larger than int unless the value of ++ an enumerator cannot fit in an int or unsigned int. ++ ++ We use "int" or an "unsigned int" as the underlying type, even if ++ a smaller integral type would work, unless the user has ++ explicitly requested that we use the smallest possible type. */ ++ for (itk = (flag_short_enums ? itk_char : itk_int); ++ itk != itk_none; ++ itk++) ++ { ++ underlying_type = integer_types[itk]; ++ if (TYPE_PRECISION (underlying_type) >= precision ++ && TREE_UNSIGNED (underlying_type) == unsignedp) ++ break; ++ } ++ if (itk == itk_none) ++ { ++ /* DR 377 ++ ++ IF no integral type can represent all the enumerator values, the ++ enumeration is ill-formed. */ ++ error ("no integral type can represent all of the enumerator values " ++ "for `%T'", enumtype); ++ precision = TYPE_PRECISION (long_long_integer_type_node); ++ underlying_type = integer_types[itk_unsigned_long_long]; ++ } ++ ++ /* Compute the minium and maximum values for the type. ++ ++ [dcl.enum] ++ ++ For an enumeration where emin is the smallest enumerator and emax ++ is the largest, the values of the enumeration are the values of the ++ underlying type in the range bmin to bmax, where bmin and bmax are, ++ respectively, the smallest and largest values of the smallest bit- ++ field that can store emin and emax. */ ++ ++ /* The middle-end currently assumes that types with TYPE_PRECISION ++ narrower than their underlying type are suitably zero or sign ++ extended to fill their mode. g++ doesn't make these guarantees. ++ Until the middle-end can represent such paradoxical types, we ++ set the TYPE_PRECISON to the width of the underlying type. */ ++ TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type); ++ ++ set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp); ++ ++ /* [dcl.enum] ++ ++ The value of sizeof() applied to an enumeration type, an object ++ of an enumeration type, or an enumerator, is the value of sizeof() ++ applied to the underlying type. */ ++ TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type); ++ TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type); ++ TYPE_MODE (enumtype) = TYPE_MODE (underlying_type); ++ TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type); ++ TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type); ++ TREE_UNSIGNED (enumtype) = TREE_UNSIGNED (underlying_type); ++ ++ /* Convert each of the enumerators to the type of the underlying ++ type of the enumeration. */ ++ for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values)) ++ { ++ decl = TREE_VALUE (values); ++ value = perform_implicit_conversion (underlying_type, ++ DECL_INITIAL (decl)); ++ TREE_TYPE (value) = enumtype; ++ DECL_INITIAL (decl) = value; ++ TREE_VALUE (values) = value; ++ } ++ ++ /* Fix up all variant types of this enum type. */ ++ for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t)) ++ { ++ TYPE_VALUES (t) = TYPE_VALUES (enumtype); ++ TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype); ++ TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype); ++ TYPE_SIZE (t) = TYPE_SIZE (enumtype); ++ TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype); ++ TYPE_MODE (t) = TYPE_MODE (enumtype); ++ TYPE_PRECISION (t) = TYPE_PRECISION (enumtype); ++ TYPE_ALIGN (t) = TYPE_ALIGN (enumtype); ++ TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype); ++ TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype); ++ } ++ ++ /* Finish debugging output for this type. */ ++ rest_of_type_compilation (enumtype, namespace_bindings_p ()); ++} ++ ++/* Build and install a CONST_DECL for an enumeration constant of the ++ enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided. ++ Assignment of sequential values by default is handled here. */ ++ ++void ++build_enumerator (tree name, tree value, tree enumtype) ++{ ++ tree decl; ++ tree context; ++ tree type; ++ ++ /* Remove no-op casts from the value. */ ++ if (value) ++ STRIP_TYPE_NOPS (value); ++ ++ if (! processing_template_decl) ++ { ++ /* Validate and default VALUE. */ ++ if (value != NULL_TREE) ++ { ++ value = decl_constant_value (value); ++ ++ if (TREE_CODE (value) == INTEGER_CST) ++ { ++ value = perform_integral_promotions (value); ++ constant_expression_warning (value); ++ } ++ else ++ { ++ error ("enumerator value for `%D' not integer constant", name); ++ value = NULL_TREE; ++ } ++ } ++ ++ /* Default based on previous value. */ ++ if (value == NULL_TREE) ++ { ++ tree prev_value; ++ ++ if (TYPE_VALUES (enumtype)) ++ { ++ /* The next value is the previous value ... */ ++ prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype))); ++ /* ... plus one. */ ++ value = cp_build_binary_op (PLUS_EXPR, ++ prev_value, ++ integer_one_node); ++ ++ if (tree_int_cst_lt (value, prev_value)) ++ error ("overflow in enumeration values at `%D'", name); ++ } ++ else ++ value = integer_zero_node; ++ } ++ ++ /* Remove no-op casts from the value. */ ++ STRIP_TYPE_NOPS (value); ++ } ++ ++ /* C++ associates enums with global, function, or class declarations. */ ++ context = current_scope (); ++ if (!context) ++ context = current_namespace; ++ ++ /* Build the actual enumeration constant. Note that the enumeration ++ constants have the type of their initializers until the ++ enumeration is complete: ++ ++ [ dcl.enum ] ++ ++ Following the closing brace of an enum-specifier, each enumer- ++ ator has the type of its enumeration. Prior to the closing ++ brace, the type of each enumerator is the type of its ++ initializing value. ++ ++ In finish_enum we will reset the type. Of course, if we're ++ processing a template, there may be no value. */ ++ type = value ? TREE_TYPE (value) : NULL_TREE; ++ ++ if (context && context == current_class_type) ++ /* This enum declaration is local to the class. We need the full ++ lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */ ++ decl = build_lang_decl (CONST_DECL, name, type); ++ else ++ /* It's a global enum, or it's local to a function. (Note local to ++ a function could mean local to a class method. */ ++ decl = build_decl (CONST_DECL, name, type); ++ ++ DECL_CONTEXT (decl) = FROB_CONTEXT (context); ++ TREE_CONSTANT (decl) = TREE_READONLY (decl) = 1; ++ DECL_INITIAL (decl) = value; ++ ++ if (context && context == current_class_type) ++ /* In something like `struct S { enum E { i = 7 }; };' we put `i' ++ on the TYPE_FIELDS list for `S'. (That's so that you can say ++ things like `S::i' later.) */ ++ finish_member_declaration (decl); ++ else ++ pushdecl (decl); ++ ++ /* Add this enumeration constant to the list for this type. */ ++ TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype)); ++} ++ ++ ++/* We're defining DECL. Make sure that it's type is OK. */ ++ ++static void ++check_function_type (tree decl, tree current_function_parms) ++{ ++ tree fntype = TREE_TYPE (decl); ++ tree return_type = complete_type (TREE_TYPE (fntype)); ++ ++ /* In a function definition, arg types must be complete. */ ++ require_complete_types_for_parms (current_function_parms); ++ ++ if (!COMPLETE_OR_VOID_TYPE_P (return_type)) ++ { ++ error ("return type `%#T' is incomplete", TREE_TYPE (fntype)); ++ ++ /* Make it return void instead, but don't change the ++ type of the DECL_RESULT, in case we have a named return value. */ ++ if (TREE_CODE (fntype) == METHOD_TYPE) ++ { ++ tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))); ++ TREE_TYPE (decl) ++ = build_method_type_directly (ctype, ++ void_type_node, ++ FUNCTION_ARG_CHAIN (decl)); ++ } ++ else ++ TREE_TYPE (decl) ++ = build_function_type (void_type_node, ++ TYPE_ARG_TYPES (TREE_TYPE (decl))); ++ TREE_TYPE (decl) ++ = build_exception_variant (fntype, ++ TYPE_RAISES_EXCEPTIONS (fntype)); ++ } ++ else ++ abstract_virtuals_error (decl, TREE_TYPE (fntype)); ++} ++ ++/* Create the FUNCTION_DECL for a function definition. ++ DECLSPECS and DECLARATOR are the parts of the declaration; ++ they describe the function's name and the type it returns, ++ but twisted together in a fashion that parallels the syntax of C. ++ ++ FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the ++ DECLARATOR is really the DECL for the function we are about to ++ process and that DECLSPECS should be ignored), SF_INCLASS_INLINE ++ indicating that the function is an inline defined in-class. ++ ++ This function creates a binding context for the function body ++ as well as setting up the FUNCTION_DECL in current_function_decl. ++ ++ Returns 1 on success. If the DECLARATOR is not suitable for a function ++ (it defines a datum instead), we return 0, which tells ++ yyparse to report a parse error. ++ ++ For C++, we must first check whether that datum makes any sense. ++ For example, "class A local_a(1,2);" means that variable local_a ++ is an aggregate of type A, which should have a constructor ++ applied to it with the argument list [1, 2]. */ ++ ++int ++start_function (tree declspecs, tree declarator, tree attrs, int flags) ++{ ++ tree decl1; ++ tree ctype = NULL_TREE; ++ tree fntype; ++ tree restype; ++ int doing_friend = 0; ++ struct cp_binding_level *bl; ++ tree current_function_parms; ++ ++ /* Sanity check. */ ++ my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160); ++ my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161); ++ ++ /* This should only be done once on the top most decl. */ ++ if (have_extern_spec) ++ { ++ declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs); ++ have_extern_spec = false; ++ } ++ ++ if (flags & SF_PRE_PARSED) ++ { ++ decl1 = declarator; ++ ++ fntype = TREE_TYPE (decl1); ++ if (TREE_CODE (fntype) == METHOD_TYPE) ++ ctype = TYPE_METHOD_BASETYPE (fntype); ++ ++ /* ISO C++ 11.4/5. A friend function defined in a class is in ++ the (lexical) scope of the class in which it is defined. */ ++ if (!ctype && DECL_FRIEND_P (decl1)) ++ { ++ ctype = DECL_FRIEND_CONTEXT (decl1); ++ ++ /* CTYPE could be null here if we're dealing with a template; ++ for example, `inline friend float foo()' inside a template ++ will have no CTYPE set. */ ++ if (ctype && TREE_CODE (ctype) != RECORD_TYPE) ++ ctype = NULL_TREE; ++ else ++ doing_friend = 1; ++ } ++ } ++ else ++ { ++ decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs); ++ /* If the declarator is not suitable for a function definition, ++ cause a syntax error. */ ++ if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) ++ return 0; ++ ++ cplus_decl_attributes (&decl1, attrs, 0); ++ ++ /* If #pragma weak was used, mark the decl weak now. */ ++ if (global_scope_p (current_binding_level)) ++ maybe_apply_pragma_weak (decl1); ++ ++ fntype = TREE_TYPE (decl1); ++ ++ restype = TREE_TYPE (fntype); ++ ++ if (TREE_CODE (fntype) == METHOD_TYPE) ++ ctype = TYPE_METHOD_BASETYPE (fntype); ++ else if (DECL_MAIN_P (decl1)) ++ { ++ /* If this doesn't return integer_type, or a typedef to ++ integer_type, complain. */ ++ if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node)) ++ { ++ if (pedantic || warn_return_type) ++ pedwarn ("return type for `main' changed to `int'"); ++ TREE_TYPE (decl1) = fntype = default_function_type; ++ } ++ } ++ } ++ ++ if (DECL_DECLARED_INLINE_P (decl1) ++ && lookup_attribute ("noinline", attrs)) ++ warning ("%Jinline function '%D' given attribute noinline", decl1, decl1); ++ ++ if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1)) ++ /* This is a constructor, we must ensure that any default args ++ introduced by this definition are propagated to the clones ++ now. The clones are used directly in overload resolution. */ ++ adjust_clone_args (decl1); ++ ++ /* Sometimes we don't notice that a function is a static member, and ++ build a METHOD_TYPE for it. Fix that up now. */ ++ if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1) ++ && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE) ++ { ++ revert_static_member_fn (decl1); ++ ctype = NULL_TREE; ++ } ++ ++ /* Warn if function was previously implicitly declared ++ (but not if we warned then). */ ++ if (! warn_implicit ++ && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE) ++ cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1))); ++ ++ /* Set up current_class_type, and enter the scope of the class, if ++ appropriate. */ ++ if (ctype) ++ push_nested_class (ctype); ++ else if (DECL_STATIC_FUNCTION_P (decl1)) ++ push_nested_class (DECL_CONTEXT (decl1)); ++ ++ /* Now that we have entered the scope of the class, we must restore ++ the bindings for any template parameters surrounding DECL1, if it ++ is an inline member template. (Order is important; consider the ++ case where a template parameter has the same name as a field of ++ the class.) It is not until after this point that ++ PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */ ++ if (flags & SF_INCLASS_INLINE) ++ maybe_begin_member_template_processing (decl1); ++ ++ /* Effective C++ rule 15. */ ++ if (warn_ecpp ++ && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR ++ && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE) ++ warning ("`operator=' should return a reference to `*this'"); ++ ++ /* Make the init_value nonzero so pushdecl knows this is not tentative. ++ error_mark_node is replaced below (in poplevel) with the BLOCK. */ ++ if (!DECL_INITIAL (decl1)) ++ DECL_INITIAL (decl1) = error_mark_node; ++ ++ /* This function exists in static storage. ++ (This does not mean `static' in the C sense!) */ ++ TREE_STATIC (decl1) = 1; ++ ++ /* We must call push_template_decl after current_class_type is set ++ up. (If we are processing inline definitions after exiting a ++ class scope, current_class_type will be NULL_TREE until set above ++ by push_nested_class.) */ ++ if (processing_template_decl) ++ decl1 = push_template_decl (decl1); ++ ++ /* We are now in the scope of the function being defined. */ ++ current_function_decl = decl1; ++ ++ /* Save the parm names or decls from this function's declarator ++ where store_parm_decls will find them. */ ++ current_function_parms = DECL_ARGUMENTS (decl1); ++ ++ /* Make sure the parameter and return types are reasonable. When ++ you declare a function, these types can be incomplete, but they ++ must be complete when you define the function. */ ++ if (! processing_template_decl) ++ check_function_type (decl1, current_function_parms); ++ ++ /* Build the return declaration for the function. */ ++ restype = TREE_TYPE (fntype); ++ /* Promote the value to int before returning it. */ ++ if (c_promoting_integer_type_p (restype)) ++ restype = type_promotes_to (restype); ++ if (DECL_RESULT (decl1) == NULL_TREE) ++ { ++ DECL_RESULT (decl1) ++ = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype)); ++ c_apply_type_quals_to_decl (cp_type_quals (restype), ++ DECL_RESULT (decl1)); ++ } ++ ++ /* Initialize RTL machinery. We cannot do this until ++ CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this ++ even when processing a template; this is how we get ++ CFUN set up, and our per-function variables initialized. ++ FIXME factor out the non-RTL stuff. */ ++ bl = current_binding_level; ++ allocate_struct_function (decl1); ++ current_binding_level = bl; ++ ++ /* Even though we're inside a function body, we still don't want to ++ call expand_expr to calculate the size of a variable-sized array. ++ We haven't necessarily assigned RTL to all variables yet, so it's ++ not safe to try to expand expressions involving them. */ ++ immediate_size_expand = 0; ++ cfun->x_dont_save_pending_sizes_p = 1; ++ ++ /* Start the statement-tree, start the tree now. */ ++ begin_stmt_tree (&DECL_SAVED_TREE (decl1)); ++ ++ /* Let the user know we're compiling this function. */ ++ announce_function (decl1); ++ ++ /* Record the decl so that the function name is defined. ++ If we already have a decl for this name, and it is a FUNCTION_DECL, ++ use the old decl. */ ++ if (!processing_template_decl && !(flags & SF_PRE_PARSED)) ++ { ++ /* A specialization is not used to guide overload resolution. */ ++ if (!DECL_FUNCTION_MEMBER_P (decl1) ++ && !(DECL_USE_TEMPLATE (decl1) && ++ PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1)))) ++ { ++ tree olddecl = pushdecl (decl1); ++ ++ if (olddecl == error_mark_node) ++ /* If something went wrong when registering the declaration, ++ use DECL1; we have to have a FUNCTION_DECL to use when ++ parsing the body of the function. */ ++ ; ++ else ++ /* Otherwise, OLDDECL is either a previous declaration of ++ the same function or DECL1 itself. */ ++ decl1 = olddecl; ++ } ++ else ++ { ++ /* We need to set the DECL_CONTEXT. */ ++ if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1)) ++ DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1)); ++ /* And make sure we have enough default args. */ ++ check_default_args (decl1); ++ } ++ fntype = TREE_TYPE (decl1); ++ } ++ ++ /* Reset these in case the call to pushdecl changed them. */ ++ current_function_decl = decl1; ++ cfun->decl = decl1; ++ ++ /* If we are (erroneously) defining a function that we have already ++ defined before, wipe out what we knew before. */ ++ if (!DECL_PENDING_INLINE_P (decl1)) ++ DECL_SAVED_FUNCTION_DATA (decl1) = NULL; ++ ++ if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1)) ++ { ++ /* We know that this was set up by `grokclassfn'. We do not ++ wait until `store_parm_decls', since evil parse errors may ++ never get us to that point. Here we keep the consistency ++ between `current_class_type' and `current_class_ptr'. */ ++ tree t = DECL_ARGUMENTS (decl1); ++ ++ my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL, ++ 162); ++ my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE, ++ 19990811); ++ ++ cp_function_chain->x_current_class_ref ++ = build_indirect_ref (t, NULL); ++ cp_function_chain->x_current_class_ptr = t; ++ ++ /* Constructors and destructors need to know whether they're "in ++ charge" of initializing virtual base classes. */ ++ t = TREE_CHAIN (t); ++ if (DECL_HAS_IN_CHARGE_PARM_P (decl1)) ++ { ++ current_in_charge_parm = t; ++ t = TREE_CHAIN (t); ++ } ++ if (DECL_HAS_VTT_PARM_P (decl1)) ++ { ++ if (DECL_NAME (t) != vtt_parm_identifier) ++ abort (); ++ current_vtt_parm = t; ++ } ++ } ++ ++ if (DECL_INTERFACE_KNOWN (decl1)) ++ { ++ tree ctx = decl_function_context (decl1); ++ ++ if (DECL_NOT_REALLY_EXTERN (decl1)) ++ DECL_EXTERNAL (decl1) = 0; ++ ++ if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx) ++ && TREE_PUBLIC (ctx)) ++ /* This is a function in a local class in an extern inline ++ function. */ ++ comdat_linkage (decl1); ++ } ++ /* If this function belongs to an interface, it is public. ++ If it belongs to someone else's interface, it is also external. ++ This only affects inlines and template instantiations. */ ++ else if (interface_unknown == 0 ++ && ! DECL_TEMPLATE_INSTANTIATION (decl1)) ++ { ++ if (DECL_DECLARED_INLINE_P (decl1) ++ || DECL_TEMPLATE_INSTANTIATION (decl1) ++ || processing_template_decl) ++ { ++ DECL_EXTERNAL (decl1) ++ = (interface_only ++ || (DECL_DECLARED_INLINE_P (decl1) ++ && ! flag_implement_inlines ++ && !DECL_VINDEX (decl1))); ++ ++ /* For WIN32 we also want to put these in linkonce sections. */ ++ maybe_make_one_only (decl1); ++ } ++ else ++ DECL_EXTERNAL (decl1) = 0; ++ DECL_NOT_REALLY_EXTERN (decl1) = 0; ++ DECL_INTERFACE_KNOWN (decl1) = 1; ++ } ++ else if (interface_unknown && interface_only ++ && ! DECL_TEMPLATE_INSTANTIATION (decl1)) ++ { ++ /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma ++ interface, we will have interface_only set but not ++ interface_known. In that case, we don't want to use the normal ++ heuristics because someone will supply a #pragma implementation ++ elsewhere, and deducing it here would produce a conflict. */ ++ comdat_linkage (decl1); ++ DECL_EXTERNAL (decl1) = 0; ++ DECL_INTERFACE_KNOWN (decl1) = 1; ++ DECL_DEFER_OUTPUT (decl1) = 1; ++ } ++ else ++ { ++ /* This is a definition, not a reference. ++ So clear DECL_EXTERNAL. */ ++ DECL_EXTERNAL (decl1) = 0; ++ ++ if ((DECL_DECLARED_INLINE_P (decl1) ++ || DECL_TEMPLATE_INSTANTIATION (decl1)) ++ && ! DECL_INTERFACE_KNOWN (decl1) ++ /* Don't try to defer nested functions for now. */ ++ && ! decl_function_context (decl1)) ++ DECL_DEFER_OUTPUT (decl1) = 1; ++ else ++ DECL_INTERFACE_KNOWN (decl1) = 1; ++ } ++ ++ begin_scope (sk_function_parms, decl1); ++ ++ ++function_depth; ++ ++ if (DECL_DESTRUCTOR_P (decl1)) ++ { ++ dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); ++ DECL_CONTEXT (dtor_label) = current_function_decl; ++ } ++ ++ start_fname_decls (); ++ ++ store_parm_decls (current_function_parms); ++ ++ return 1; ++} ++ ++/* Store the parameter declarations into the current function declaration. ++ This is called after parsing the parameter declarations, before ++ digesting the body of the function. ++ ++ Also install to binding contour return value identifier, if any. */ ++ ++static void ++store_parm_decls (tree current_function_parms) ++{ ++ tree fndecl = current_function_decl; ++ tree parm; ++ ++ /* This is a chain of any other decls that came in among the parm ++ declarations. If a parm is declared with enum {foo, bar} x; ++ then CONST_DECLs for foo and bar are put here. */ ++ tree nonparms = NULL_TREE; ++ ++ if (current_function_parms) ++ { ++ /* This case is when the function was defined with an ANSI prototype. ++ The parms already have decls, so we need not do anything here ++ except record them as in effect ++ and complain if any redundant old-style parm decls were written. */ ++ ++ tree specparms = current_function_parms; ++ tree next; ++ ++ /* Must clear this because it might contain TYPE_DECLs declared ++ at class level. */ ++ current_binding_level->names = NULL; ++ ++ /* If we're doing semantic analysis, then we'll call pushdecl ++ for each of these. We must do them in reverse order so that ++ they end in the correct forward order. */ ++ specparms = nreverse (specparms); ++ ++ for (parm = specparms; parm; parm = next) ++ { ++ next = TREE_CHAIN (parm); ++ if (TREE_CODE (parm) == PARM_DECL) ++ { ++ if (DECL_NAME (parm) == NULL_TREE ++ || TREE_CODE (parm) != VOID_TYPE) ++ pushdecl (parm); ++ else ++ error ("parameter `%D' declared void", parm); ++ } ++ else ++ { ++ /* If we find an enum constant or a type tag, ++ put it aside for the moment. */ ++ TREE_CHAIN (parm) = NULL_TREE; ++ nonparms = chainon (nonparms, parm); ++ } ++ } ++ ++ /* Get the decls in their original chain order and record in the ++ function. This is all and only the PARM_DECLs that were ++ pushed into scope by the loop above. */ ++ DECL_ARGUMENTS (fndecl) = getdecls (); ++ } ++ else ++ DECL_ARGUMENTS (fndecl) = NULL_TREE; ++ ++ /* Now store the final chain of decls for the arguments ++ as the decl-chain of the current lexical scope. ++ Put the enumerators in as well, at the front so that ++ DECL_ARGUMENTS is not modified. */ ++ current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl)); ++ ++ /* Do the starting of the exception specifications, if we have any. */ ++ if (flag_exceptions && !processing_template_decl ++ && flag_enforce_eh_specs ++ && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl))) ++ current_eh_spec_block = begin_eh_spec_block (); ++} ++ ++ ++/* We have finished doing semantic analysis on DECL, but have not yet ++ generated RTL for its body. Save away our current state, so that ++ when we want to generate RTL later we know what to do. */ ++ ++static void ++save_function_data (tree decl) ++{ ++ struct language_function *f; ++ ++ /* Save the language-specific per-function data so that we can ++ get it back when we really expand this function. */ ++ my_friendly_assert (!DECL_PENDING_INLINE_P (decl), ++ 19990908); ++ ++ /* Make a copy. */ ++ f = ggc_alloc (sizeof (struct language_function)); ++ memcpy (f, cp_function_chain, sizeof (struct language_function)); ++ DECL_SAVED_FUNCTION_DATA (decl) = f; ++ ++ /* Clear out the bits we don't need. */ ++ f->base.x_stmt_tree.x_last_stmt = NULL_TREE; ++ f->base.x_stmt_tree.x_last_expr_type = NULL_TREE; ++ f->x_named_label_uses = NULL; ++ f->bindings = NULL; ++ f->x_local_names = NULL; ++ ++ /* If we've already decided that we cannot inline this function, we ++ must remember that fact when we actually go to expand the ++ function. */ ++ if (current_function_cannot_inline) ++ { ++ f->cannot_inline = current_function_cannot_inline; ++ DECL_INLINE (decl) = 0; ++ } ++} ++ ++/* Add a note to mark the beginning of the main body of the constructor. ++ This is used to set up the data structures for the cleanup regions for ++ fully-constructed bases and members. */ ++ ++static void ++begin_constructor_body (void) ++{ ++} ++ ++/* Add a note to mark the end of the main body of the constructor. This is ++ used to end the cleanup regions for fully-constructed bases and ++ members. */ ++ ++static void ++finish_constructor_body (void) ++{ ++} ++ ++/* Do all the processing for the beginning of a destructor; set up the ++ vtable pointers and cleanups for bases and members. */ ++ ++static void ++begin_destructor_body (void) ++{ ++ tree if_stmt; ++ tree compound_stmt; ++ ++ /* If the dtor is empty, and we know there is not any possible ++ way we could use any vtable entries, before they are possibly ++ set by a base class dtor, we don't have to setup the vtables, ++ as we know that any base class dtor will set up any vtables ++ it needs. We avoid MI, because one base class dtor can do a ++ virtual dispatch to an overridden function that would need to ++ have a non-related vtable set up, we cannot avoid setting up ++ vtables in that case. We could change this to see if there ++ is just one vtable. ++ ++ ??? In the destructor for a class, the vtables are set ++ appropriately for that class. There will be no non-related ++ vtables. jason 2001-12-11. */ ++ if_stmt = begin_if_stmt (); ++ ++ /* If it is not safe to avoid setting up the vtables, then ++ someone will change the condition to be boolean_true_node. ++ (Actually, for now, we do not have code to set the condition ++ appropriately, so we just assume that we always need to ++ initialize the vtables.) */ ++ finish_if_stmt_cond (boolean_true_node, if_stmt); ++ ++ compound_stmt = begin_compound_stmt (/*has_no_scope=*/false); ++ ++ /* Make all virtual function table pointers in non-virtual base ++ classes point to CURRENT_CLASS_TYPE's virtual function ++ tables. */ ++ initialize_vtbl_ptrs (current_class_ptr); ++ ++ finish_compound_stmt (compound_stmt); ++ finish_then_clause (if_stmt); ++ finish_if_stmt (); ++ ++ /* And insert cleanups for our bases and members so that they ++ will be properly destroyed if we throw. */ ++ push_base_cleanups (); ++} ++ ++/* At the end of every destructor we generate code to delete the object if ++ necessary. Do that now. */ ++ ++static void ++finish_destructor_body (void) ++{ ++ tree exprstmt; ++ ++ /* Any return from a destructor will end up here; that way all base ++ and member cleanups will be run when the function returns. */ ++ add_stmt (build_stmt (LABEL_STMT, dtor_label)); ++ ++ /* In a virtual destructor, we must call delete. */ ++ if (DECL_VIRTUAL_P (current_function_decl)) ++ { ++ tree if_stmt; ++ tree virtual_size = cxx_sizeof (current_class_type); ++ ++ /* [class.dtor] ++ ++ At the point of definition of a virtual destructor (including ++ an implicit definition), non-placement operator delete shall ++ be looked up in the scope of the destructor's class and if ++ found shall be accessible and unambiguous. */ ++ exprstmt = build_op_delete_call ++ (DELETE_EXPR, current_class_ptr, virtual_size, ++ LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE); ++ ++ if_stmt = begin_if_stmt (); ++ finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node, ++ current_in_charge_parm, ++ integer_one_node), ++ if_stmt); ++ finish_expr_stmt (exprstmt); ++ finish_then_clause (if_stmt); ++ finish_if_stmt (); ++ } ++} ++ ++/* Do the necessary processing for the beginning of a function body, which ++ in this case includes member-initializers, but not the catch clauses of ++ a function-try-block. Currently, this means opening a binding level ++ for the member-initializers (in a ctor) and member cleanups (in a dtor). ++ In other functions, this isn't necessary, but it doesn't hurt. */ ++ ++tree ++begin_function_body (void) ++{ ++ tree stmt; ++ ++ if (processing_template_decl) ++ /* Do nothing now. */; ++ else ++ /* Always keep the BLOCK node associated with the outermost pair of ++ curly braces of a function. These are needed for correct ++ operation of dwarfout.c. */ ++ keep_next_level (true); ++ ++ stmt = begin_compound_stmt (/*has_no_scope=*/false); ++ COMPOUND_STMT_BODY_BLOCK (stmt) = 1; ++ ++ if (processing_template_decl) ++ /* Do nothing now. */; ++ else if (DECL_CONSTRUCTOR_P (current_function_decl)) ++ begin_constructor_body (); ++ else if (DECL_DESTRUCTOR_P (current_function_decl)) ++ begin_destructor_body (); ++ ++ return stmt; ++} ++ ++/* Do the processing for the end of a function body. Currently, this means ++ closing out the cleanups for fully-constructed bases and members, and in ++ the case of the destructor, deleting the object if desired. Again, this ++ is only meaningful for [cd]tors, since they are the only functions where ++ there is a significant distinction between the main body and any ++ function catch clauses. Handling, say, main() return semantics here ++ would be wrong, as flowing off the end of a function catch clause for ++ main() would also need to return 0. */ ++ ++void ++finish_function_body (tree compstmt) ++{ ++ /* Close the block. */ ++ finish_compound_stmt (compstmt); ++ ++ if (processing_template_decl) ++ /* Do nothing now. */; ++ else if (DECL_CONSTRUCTOR_P (current_function_decl)) ++ finish_constructor_body (); ++ else if (DECL_DESTRUCTOR_P (current_function_decl)) ++ finish_destructor_body (); ++} ++ ++/* Finish up a function declaration and compile that function ++ all the way to assembler language output. The free the storage ++ for the function definition. ++ ++ FLAGS is a bitwise or of the following values: ++ 2 - INCLASS_INLINE ++ We just finished processing the body of an in-class inline ++ function definition. (This processing will have taken place ++ after the class definition is complete.) */ ++ ++tree ++finish_function (int flags) ++{ ++ tree fndecl = current_function_decl; ++ tree fntype, ctype = NULL_TREE; ++ int inclass_inline = (flags & 2) != 0; ++ int nested; ++ ++ /* When we get some parse errors, we can end up without a ++ current_function_decl, so cope. */ ++ if (fndecl == NULL_TREE) ++ return error_mark_node; ++ ++ if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl) ++ && DECL_VIRTUAL_P (fndecl) ++ && !processing_template_decl) ++ { ++ tree fnclass = DECL_CONTEXT (fndecl); ++ if (fndecl == CLASSTYPE_KEY_METHOD (fnclass)) ++ keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes); ++ } ++ ++ nested = function_depth > 1; ++ fntype = TREE_TYPE (fndecl); ++ ++ /* TREE_READONLY (fndecl) = 1; ++ This caused &foo to be of type ptr-to-const-function ++ which then got a warning when stored in a ptr-to-function variable. */ ++ ++ my_friendly_assert (building_stmt_tree (), 20000911); ++ ++ /* For a cloned function, we've already got all the code we need; ++ there's no need to add any extra bits. */ ++ if (!DECL_CLONED_FUNCTION_P (fndecl)) ++ { ++ if (DECL_MAIN_P (current_function_decl)) ++ { ++ /* Make it so that `main' always returns 0 by default. */ ++#if VMS_TARGET ++ finish_return_stmt (integer_one_node); ++#else ++ finish_return_stmt (integer_zero_node); ++#endif ++ } ++ ++ /* Finish dealing with exception specifiers. */ ++ if (flag_exceptions && !processing_template_decl ++ && flag_enforce_eh_specs ++ && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl))) ++ finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS ++ (TREE_TYPE (current_function_decl)), ++ current_eh_spec_block); ++ } ++ ++ finish_fname_decls (); ++ ++ /* If we're saving up tree structure, tie off the function now. */ ++ finish_stmt_tree (&DECL_SAVED_TREE (fndecl)); ++ ++ /* If this function can't throw any exceptions, remember that. */ ++ if (!processing_template_decl ++ && !cp_function_chain->can_throw ++ && !flag_non_call_exceptions) ++ TREE_NOTHROW (fndecl) = 1; ++ ++ /* This must come after expand_function_end because cleanups might ++ have declarations (from inline functions) that need to go into ++ this function's blocks. */ ++ ++ /* If the current binding level isn't the outermost binding level ++ for this function, either there is a bug, or we have experienced ++ syntax errors and the statement tree is malformed. */ ++ if (current_binding_level->kind != sk_function_parms) ++ { ++ /* Make sure we have already experienced errors. */ ++ if (errorcount == 0) ++ abort (); ++ ++ /* Throw away the broken statement tree and extra binding ++ levels. */ ++ DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE); ++ ++ while (current_binding_level->kind != sk_function_parms) ++ { ++ if (current_binding_level->kind == sk_class) ++ pop_nested_class (); ++ else ++ poplevel (0, 0, 0); ++ } ++ } ++ poplevel (1, 0, 1); ++ ++ /* Statements should always be full-expressions at the outermost set ++ of curly braces for a function. */ ++ my_friendly_assert (stmts_are_full_exprs_p (), 19990831); ++ ++ /* Set up the named return value optimization, if we can. Here, we ++ eliminate the copy from the nrv into the RESULT_DECL and any cleanup ++ for the nrv. genrtl_start_function and declare_return_variable ++ handle making the nrv and RESULT_DECL share space. */ ++ if (current_function_return_value) ++ { ++ tree r = current_function_return_value; ++ tree outer; ++ ++ if (r != error_mark_node ++ /* This is only worth doing for fns that return in memory--and ++ simpler, since we don't have to worry about promoted modes. */ ++ && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl) ++ /* Only allow this for variables declared in the outer scope of ++ the function so we know that their lifetime always ends with a ++ return; see g++.dg/opt/nrv6.C. We could be more flexible if ++ we were to do this optimization in tree-ssa. */ ++ /* Skip the artificial function body block. */ ++ && (outer = BLOCK_SUBBLOCKS (BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl))), ++ chain_member (r, BLOCK_VARS (outer)))) ++ { ++ ++ DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl)); ++ walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl), ++ nullify_returns_r, r); ++ } ++ else ++ /* Clear it so genrtl_start_function and declare_return_variable ++ know we're not optimizing. */ ++ current_function_return_value = NULL_TREE; ++ } ++ ++ /* Remember that we were in class scope. */ ++ if (current_class_name) ++ ctype = current_class_type; ++ ++ /* Must mark the RESULT_DECL as being in this function. */ ++ DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; ++ ++ /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point ++ to the FUNCTION_DECL node itself. */ ++ BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; ++ ++ /* Save away current state, if appropriate. */ ++ if (!processing_template_decl) ++ save_function_data (fndecl); ++ ++ /* If this function calls `setjmp' it cannot be inlined. When ++ `longjmp' is called it is not guaranteed to restore the value of ++ local variables that have been modified since the call to ++ `setjmp'. So, if were to inline this function into some caller ++ `c', then when we `longjmp', we might not restore all variables ++ in `c'. (It might seem, at first blush, that there's no way for ++ this function to modify local variables in `c', but their ++ addresses may have been stored somewhere accessible to this ++ function.) */ ++ if (!processing_template_decl && calls_setjmp_p (fndecl)) ++ DECL_UNINLINABLE (fndecl) = 1; ++ ++ /* Complain if there's just no return statement. */ ++ if (warn_return_type ++ && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE ++ && !dependent_type_p (TREE_TYPE (fntype)) ++ && !current_function_returns_value && !current_function_returns_null ++ /* Don't complain if we abort or throw. */ ++ && !current_function_returns_abnormally ++ && !DECL_NAME (DECL_RESULT (fndecl)) ++ /* Normally, with -Wreturn-type, flow will complain. Unless we're an ++ inline function, as we might never be compiled separately. */ ++ && (DECL_INLINE (fndecl) || processing_template_decl)) ++ warning ("no return statement in function returning non-void"); ++ ++ /* We're leaving the context of this function, so zap cfun. It's still in ++ DECL_SAVED_INSNS, and we'll restore it in tree_rest_of_compilation. */ ++ cfun = NULL; ++ current_function_decl = NULL; ++ ++ /* If this is an in-class inline definition, we may have to pop the ++ bindings for the template parameters that we added in ++ maybe_begin_member_template_processing when start_function was ++ called. */ ++ if (inclass_inline) ++ maybe_end_member_template_processing (); ++ ++ /* Leave the scope of the class. */ ++ if (ctype) ++ pop_nested_class (); ++ ++ --function_depth; ++ ++ /* Clean up. */ ++ if (! nested) ++ /* Let the error reporting routines know that we're outside a ++ function. For a nested function, this value is used in ++ cxx_pop_function_context and then reset via pop_function_context. */ ++ current_function_decl = NULL_TREE; ++ ++ return fndecl; ++} ++ ++/* Create the FUNCTION_DECL for a function definition. ++ DECLSPECS and DECLARATOR are the parts of the declaration; ++ they describe the return type and the name of the function, ++ but twisted together in a fashion that parallels the syntax of C. ++ ++ This function creates a binding context for the function body ++ as well as setting up the FUNCTION_DECL in current_function_decl. ++ ++ Returns a FUNCTION_DECL on success. ++ ++ If the DECLARATOR is not suitable for a function (it defines a datum ++ instead), we return 0, which tells yyparse to report a parse error. ++ ++ May return void_type_node indicating that this method is actually ++ a friend. See grokfield for more details. ++ ++ Came here with a `.pushlevel' . ++ ++ DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING ++ CHANGES TO CODE IN `grokfield'. */ ++ ++tree ++start_method (tree declspecs, tree declarator, tree attrlist) ++{ ++ tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0, ++ &attrlist); ++ ++ if (fndecl == error_mark_node) ++ return error_mark_node; ++ ++ if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL) ++ { ++ error ("invalid member function declaration"); ++ return error_mark_node; ++ } ++ ++ if (attrlist) ++ cplus_decl_attributes (&fndecl, attrlist, 0); ++ ++ /* Pass friends other than inline friend functions back. */ ++ if (fndecl == void_type_node) ++ return fndecl; ++ ++ if (DECL_IN_AGGR_P (fndecl)) ++ { ++ if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type) ++ { ++ if (DECL_CONTEXT (fndecl) ++ && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL) ++ error ("`%D' is already defined in class `%T'", fndecl, ++ DECL_CONTEXT (fndecl)); ++ } ++ return void_type_node; ++ } ++ ++ check_template_shadow (fndecl); ++ ++ DECL_DECLARED_INLINE_P (fndecl) = 1; ++ if (flag_default_inline) ++ DECL_INLINE (fndecl) = 1; ++ ++ /* We process method specializations in finish_struct_1. */ ++ if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl)) ++ { ++ fndecl = push_template_decl (fndecl); ++ if (fndecl == error_mark_node) ++ return fndecl; ++ } ++ ++ if (! DECL_FRIEND_P (fndecl)) ++ { ++ if (TREE_CHAIN (fndecl)) ++ { ++ fndecl = copy_node (fndecl); ++ TREE_CHAIN (fndecl) = NULL_TREE; ++ } ++ grok_special_member_properties (fndecl); ++ } ++ ++ cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0); ++ ++ /* Make a place for the parms. */ ++ begin_scope (sk_function_parms, fndecl); ++ ++ DECL_IN_AGGR_P (fndecl) = 1; ++ return fndecl; ++} ++ ++/* Go through the motions of finishing a function definition. ++ We don't compile this method until after the whole class has ++ been processed. ++ ++ FINISH_METHOD must return something that looks as though it ++ came from GROKFIELD (since we are defining a method, after all). ++ ++ This is called after parsing the body of the function definition. ++ STMTS is the chain of statements that makes up the function body. ++ ++ DECL is the ..._DECL that `start_method' provided. */ ++ ++tree ++finish_method (tree decl) ++{ ++ tree fndecl = decl; ++ tree old_initial; ++ ++ tree link; ++ ++ if (decl == void_type_node) ++ return decl; ++ ++ old_initial = DECL_INITIAL (fndecl); ++ ++ /* Undo the level for the parms (from start_method). ++ This is like poplevel, but it causes nothing to be ++ saved. Saving information here confuses symbol-table ++ output routines. Besides, this information will ++ be correctly output when this method is actually ++ compiled. */ ++ ++ /* Clear out the meanings of the local variables of this level; ++ also record in each decl which block it belongs to. */ ++ ++ for (link = current_binding_level->names; link; link = TREE_CHAIN (link)) ++ { ++ if (DECL_NAME (link) != NULL_TREE) ++ pop_binding (DECL_NAME (link), link); ++ my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163); ++ DECL_CONTEXT (link) = NULL_TREE; ++ } ++ ++ poplevel (0, 0, 0); ++ ++ DECL_INITIAL (fndecl) = old_initial; ++ ++ /* We used to check if the context of FNDECL was different from ++ current_class_type as another way to get inside here. This didn't work ++ for String.cc in libg++. */ ++ if (DECL_FRIEND_P (fndecl)) ++ { ++ CLASSTYPE_INLINE_FRIENDS (current_class_type) ++ = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type)); ++ decl = void_type_node; ++ } ++ ++ return decl; ++} ++ ++ ++/* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that ++ we can lay it out later, when and if its type becomes complete. */ ++ ++void ++maybe_register_incomplete_var (tree var) ++{ ++ my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406); ++ ++ /* Keep track of variables with incomplete types. */ ++ if (!processing_template_decl && TREE_TYPE (var) != error_mark_node ++ && DECL_EXTERNAL (var)) ++ { ++ tree inner_type = TREE_TYPE (var); ++ ++ while (TREE_CODE (inner_type) == ARRAY_TYPE) ++ inner_type = TREE_TYPE (inner_type); ++ inner_type = TYPE_MAIN_VARIANT (inner_type); ++ ++ if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type)) ++ /* RTTI TD entries are created while defining the type_info. */ ++ || (TYPE_LANG_SPECIFIC (inner_type) ++ && TYPE_BEING_DEFINED (inner_type))) ++ incomplete_vars = tree_cons (inner_type, var, incomplete_vars); ++ } ++} ++ ++/* Called when a class type (given by TYPE) is defined. If there are ++ any existing VAR_DECLs whose type hsa been completed by this ++ declaration, update them now. */ ++ ++void ++complete_vars (tree type) ++{ ++ tree *list = &incomplete_vars; ++ ++ my_friendly_assert (CLASS_TYPE_P (type), 20020406); ++ while (*list) ++ { ++ if (same_type_p (type, TREE_PURPOSE (*list))) ++ { ++ tree var = TREE_VALUE (*list); ++ /* Complete the type of the variable. The VAR_DECL itself ++ will be laid out in expand_expr. */ ++ complete_type (TREE_TYPE (var)); ++ /* Remove this entry from the list. */ ++ *list = TREE_CHAIN (*list); ++ } ++ else ++ list = &TREE_CHAIN (*list); ++ } ++} ++ ++/* If DECL is of a type which needs a cleanup, build that cleanup ++ here. */ ++ ++tree ++cxx_maybe_build_cleanup (tree decl) ++{ ++ tree type = TREE_TYPE (decl); ++ ++ if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) ++ { ++ int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR; ++ tree rval; ++ ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ rval = decl; ++ else ++ { ++ cxx_mark_addressable (decl); ++ rval = build_unary_op (ADDR_EXPR, decl, 0); ++ } ++ ++ /* Optimize for space over speed here. */ ++ if (! TYPE_USES_VIRTUAL_BASECLASSES (type) ++ || flag_expensive_optimizations) ++ flags |= LOOKUP_NONVIRTUAL; ++ ++ rval = build_delete (TREE_TYPE (rval), rval, ++ sfk_complete_destructor, flags, 0); ++ ++ if (TYPE_USES_VIRTUAL_BASECLASSES (type) ++ && ! TYPE_HAS_DESTRUCTOR (type)) ++ rval = build_compound_expr (rval, build_vbase_delete (type, decl)); ++ ++ return rval; ++ } ++ return NULL_TREE; ++} ++ ++/* When a stmt has been parsed, this function is called. */ ++ ++void ++finish_stmt (void) ++{ ++ /* Always assume this statement was not an expression statement. If ++ it actually was an expression statement, its our callers ++ responsibility to fix this up. */ ++ last_expr_type = NULL_TREE; ++} ++ ++/* DECL was originally constructed as a non-static member function, ++ but turned out to be static. Update it accordingly. */ ++ ++void ++revert_static_member_fn (tree decl) ++{ ++ tree tmp; ++ tree function = TREE_TYPE (decl); ++ tree args = TYPE_ARG_TYPES (function); ++ ++ if (cp_type_quals (TREE_TYPE (TREE_VALUE (args))) ++ != TYPE_UNQUALIFIED) ++ error ("static member function `%#D' declared with type qualifiers", ++ decl); ++ ++ args = TREE_CHAIN (args); ++ tmp = build_function_type (TREE_TYPE (function), args); ++ tmp = build_qualified_type (tmp, cp_type_quals (function)); ++ tmp = build_exception_variant (tmp, ++ TYPE_RAISES_EXCEPTIONS (function)); ++ TREE_TYPE (decl) = tmp; ++ if (DECL_ARGUMENTS (decl)) ++ DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl)); ++ DECL_STATIC_FUNCTION_P (decl) = 1; ++} ++ ++/* Initialize the variables used during compilation of a C++ ++ function. */ ++ ++void ++cxx_push_function_context (struct function * f) ++{ ++ struct language_function *p ++ = ggc_alloc_cleared (sizeof (struct language_function)); ++ f->language = p; ++ ++ /* Whenever we start a new function, we destroy temporaries in the ++ usual way. */ ++ current_stmt_tree ()->stmts_are_full_exprs_p = 1; ++ ++ if (f->decl) ++ { ++ tree fn = f->decl; ++ ++ if (DECL_SAVED_FUNCTION_DATA (fn)) ++ { ++ /* If we already parsed this function, and we're just expanding it ++ now, restore saved state. */ ++ *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn); ++ ++ /* If we decided that we didn't want to inline this function, ++ make sure the back-end knows that. */ ++ if (!current_function_cannot_inline) ++ current_function_cannot_inline = cp_function_chain->cannot_inline; ++ ++ /* We don't need the saved data anymore. Unless this is an inline ++ function; we need the named return value info for ++ cp_copy_res_decl_for_inlining. */ ++ if (! DECL_INLINE (fn)) ++ DECL_SAVED_FUNCTION_DATA (fn) = NULL; ++ } ++ } ++} ++ ++/* Free the language-specific parts of F, now that we've finished ++ compiling the function. */ ++ ++void ++cxx_pop_function_context (struct function * f) ++{ ++ f->language = 0; ++} ++ ++/* Return which tree structure is used by T, or TS_CP_GENERIC if T is ++ one of the language-independent trees. */ ++ ++enum cp_tree_node_structure_enum ++cp_tree_node_structure (union lang_tree_node * t) ++{ ++ switch (TREE_CODE (&t->generic)) ++ { ++ case DEFAULT_ARG: return TS_CP_DEFAULT_ARG; ++ case IDENTIFIER_NODE: return TS_CP_IDENTIFIER; ++ case OVERLOAD: return TS_CP_OVERLOAD; ++ case TEMPLATE_PARM_INDEX: return TS_CP_TPI; ++ case PTRMEM_CST: return TS_CP_PTRMEM; ++ case BASELINK: return TS_CP_BASELINK; ++ case WRAPPER: return TS_CP_WRAPPER; ++ default: return TS_CP_GENERIC; ++ } ++} ++ ++/* Build the void_list_node (void_type_node having been created). */ ++tree ++build_void_list_node (void) ++{ ++ tree t = build_tree_list (NULL_TREE, void_type_node); ++ TREE_PARMLIST (t) = 1; ++ return t; ++} ++ ++static int ++cp_missing_noreturn_ok_p (tree decl) ++{ ++ /* A missing noreturn is ok for the `main' function. */ ++ return DECL_MAIN_P (decl); ++} ++ ++#include "gt-cp-decl.h" ++#include "gtype-cp.h" +diff -NBaur gcc-3.4.4/gcc/cp/decl.h gcc-3.4.4-new/gcc/cp/decl.h +--- gcc-3.4.4/gcc/cp/decl.h Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/decl.h Sat Mar 20 00:13:12 2004 +@@ -0,0 +1,39 @@ ++/* Variables and structures for declaration processing. ++ Copyright (C) 1993, 2000, 2002 Free Software Foundation, Inc. ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++/* In grokdeclarator, distinguish syntactic contexts of declarators. */ ++enum decl_context ++{ NORMAL, /* Ordinary declaration */ ++ FUNCDEF, /* Function definition */ ++ PARM, /* Declaration of parm before function body */ ++ CATCHPARM, /* Declaration of catch parm */ ++ FIELD, /* Declaration inside struct or union */ ++ BITFIELD, /* Likewise but with specified width */ ++ TYPENAME, /* Typename (inside cast or sizeof) */ ++ MEMFUNCDEF /* Member function definition */ ++}; ++ ++/* We need this in here to get the decl_context definition. */ ++extern tree grokdeclarator (tree, tree, enum decl_context, int, tree*); ++ ++#ifdef DEBUG_CP_BINDING_LEVELS ++/* Purely for debugging purposes. */ ++extern int debug_bindings_indentation; ++#endif diff -NBaur gcc-3.4.4/gcc/cp/decl2.c gcc-3.4.4-new/gcc/cp/decl2.c ---- gcc-3.4.4/gcc/cp/decl2.c Mon Oct 11 15:42:36 2004 -+++ gcc-3.4.4-new/gcc/cp/decl2.c Fri May 20 17:42:39 2005 -@@ -1476,6 +1476,11 @@ - { - TREE_PUBLIC (decl) = 1; - DECL_EXTERNAL (decl) = 1; +--- gcc-3.4.4/gcc/cp/decl2.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/decl2.c Mon Jun 13 23:42:57 2005 +@@ -0,0 +1,3049 @@ ++/* Process declarations and variables for C++ compiler. ++ Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, ++ 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. ++ Hacked by Michael Tiemann (tiemann@cygnus.com) ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++ ++/* Process declarations and symbol lookup for C++ front end. ++ Also constructs types; the standard scalar types at initialization, ++ and structure, union, array and enum types when they are declared. */ ++ ++/* ??? not all decl nodes are given the most useful possible ++ line numbers. For example, the CONST_DECLs for enum values. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "rtl.h" ++#include "expr.h" ++#include "flags.h" ++#include "cp-tree.h" ++#include "decl.h" ++#include "lex.h" ++#include "output.h" ++#include "except.h" ++#include "toplev.h" ++#include "timevar.h" ++#include "cpplib.h" ++#include "target.h" ++#include "c-common.h" ++#include "cgraph.h" ++#include "tree-inline.h" ++extern cpp_reader *parse_in; ++ ++/* This structure contains information about the initializations ++ and/or destructions required for a particular priority level. */ ++typedef struct priority_info_s { ++ /* Nonzero if there have been any initializations at this priority ++ throughout the translation unit. */ ++ int initializations_p; ++ /* Nonzero if there have been any destructions at this priority ++ throughout the translation unit. */ ++ int destructions_p; ++} *priority_info; ++ ++static void mark_vtable_entries (tree); ++static void grok_function_init (tree, tree); ++static bool maybe_emit_vtables (tree); ++static tree build_anon_union_vars (tree); ++static bool acceptable_java_type (tree); ++static tree start_objects (int, int); ++static void finish_objects (int, int, tree); ++static tree start_static_storage_duration_function (unsigned); ++static void finish_static_storage_duration_function (tree); ++static priority_info get_priority_info (int); ++static void do_static_initialization (tree, tree); ++static void do_static_destruction (tree); ++static tree start_static_initialization_or_destruction (tree, int); ++static void finish_static_initialization_or_destruction (tree); ++static void generate_ctor_or_dtor_function (bool, int, location_t *); ++static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node, ++ void *); ++static tree prune_vars_needing_no_initialization (tree *); ++static void write_out_vars (tree); ++static void import_export_class (tree); ++static tree get_guard_bits (tree); ++ ++/* A list of static class variables. This is needed, because a ++ static class variable can be declared inside the class without ++ an initializer, and then initialized, statically, outside the class. */ ++static GTY(()) varray_type pending_statics; ++#define pending_statics_used \ ++ (pending_statics ? pending_statics->elements_used : 0) ++ ++/* A list of functions which were declared inline, but which we ++ may need to emit outline anyway. */ ++static GTY(()) varray_type deferred_fns; ++#define deferred_fns_used \ ++ (deferred_fns ? deferred_fns->elements_used : 0) ++ ++/* Flag used when debugging spew.c */ ++ ++extern int spew_debug; ++ ++/* Nonzero if we're done parsing and into end-of-file activities. */ ++ ++int at_eof; ++ ++/* Functions called along with real static constructors and destructors. */ ++ ++tree static_ctors; ++tree static_dtors; ++ ++ ++/* Incorporate `const' and `volatile' qualifiers for member functions. ++ FUNCTION is a TYPE_DECL or a FUNCTION_DECL. ++ QUALS is a list of qualifiers. Returns any explicit ++ top-level qualifiers of the method's this pointer, anything other than ++ TYPE_UNQUALIFIED will be an extension. */ ++ ++int ++grok_method_quals (tree ctype, tree function, tree quals) ++{ ++ tree fntype = TREE_TYPE (function); ++ tree raises = TYPE_RAISES_EXCEPTIONS (fntype); ++ int type_quals = TYPE_UNQUALIFIED; ++ int dup_quals = TYPE_UNQUALIFIED; ++ int this_quals = TYPE_UNQUALIFIED; ++ ++ do ++ { ++ int tq = cp_type_qual_from_rid (TREE_VALUE (quals)); ++ ++ if ((type_quals | this_quals) & tq) ++ dup_quals |= tq; ++ else if (tq & TYPE_QUAL_RESTRICT) ++ this_quals |= tq; ++ else ++ type_quals |= tq; ++ quals = TREE_CHAIN (quals); ++ } ++ while (quals); ++ ++ if (dup_quals != TYPE_UNQUALIFIED) ++ error ("duplicate type qualifiers in %s declaration", ++ TREE_CODE (function) == FUNCTION_DECL ++ ? "member function" : "type"); ++ ++ ctype = cp_build_qualified_type (ctype, type_quals); ++ fntype = build_method_type_directly (ctype, TREE_TYPE (fntype), ++ (TREE_CODE (fntype) == METHOD_TYPE ++ ? TREE_CHAIN (TYPE_ARG_TYPES (fntype)) ++ : TYPE_ARG_TYPES (fntype))); ++ if (raises) ++ fntype = build_exception_variant (fntype, raises); ++ ++ TREE_TYPE (function) = fntype; ++ return this_quals; ++} ++ ++/* A subroutine of the parser, to handle a component list. */ ++ ++void ++grok_x_components (tree specs) ++{ ++ tree t; ++ ++ specs = strip_attrs (specs); ++ ++ check_tag_decl (specs); ++ t = groktypename (build_tree_list (specs, NULL_TREE)); ++ ++ /* The only case where we need to do anything additional here is an ++ anonymous union field, e.g.: `struct S { union { int i; }; };'. */ ++ if (t == NULL_TREE || !ANON_AGGR_TYPE_P (t)) ++ return; ++ ++ fixup_anonymous_aggr (t); ++ finish_member_declaration (build_decl (FIELD_DECL, NULL_TREE, t)); ++} ++ ++/* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE ++ appropriately. */ ++ ++tree ++cp_build_parm_decl (tree name, tree type) ++{ ++ tree parm = build_decl (PARM_DECL, name, type); ++ /* DECL_ARG_TYPE is only used by the back end and the back end never ++ sees templates. */ ++ if (!processing_template_decl) ++ DECL_ARG_TYPE (parm) = type_passed_as (type); ++ return parm; ++} ++ ++/* Returns a PARM_DECL for a parameter of the indicated TYPE, with the ++ indicated NAME. */ ++ ++tree ++build_artificial_parm (tree name, tree type) ++{ ++ tree parm = cp_build_parm_decl (name, type); ++ DECL_ARTIFICIAL (parm) = 1; ++ /* All our artificial parms are implicitly `const'; they cannot be ++ assigned to. */ ++ TREE_READONLY (parm) = 1; ++ return parm; ++} ++ ++/* Constructors for types with virtual baseclasses need an "in-charge" flag ++ saying whether this constructor is responsible for initialization of ++ virtual baseclasses or not. All destructors also need this "in-charge" ++ flag, which additionally determines whether or not the destructor should ++ free the memory for the object. ++ ++ This function adds the "in-charge" flag to member function FN if ++ appropriate. It is called from grokclassfn and tsubst. ++ FN must be either a constructor or destructor. ++ ++ The in-charge flag follows the 'this' parameter, and is followed by the ++ VTT parm (if any), then the user-written parms. */ ++ ++void ++maybe_retrofit_in_chrg (tree fn) ++{ ++ tree basetype, arg_types, parms, parm, fntype; ++ ++ /* If we've already add the in-charge parameter don't do it again. */ ++ if (DECL_HAS_IN_CHARGE_PARM_P (fn)) ++ return; ++ ++ /* When processing templates we can't know, in general, whether or ++ not we're going to have virtual baseclasses. */ ++ if (processing_template_decl) ++ return; ++ ++ /* We don't need an in-charge parameter for constructors that don't ++ have virtual bases. */ ++ if (DECL_CONSTRUCTOR_P (fn) ++ && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn))) ++ return; ++ ++ arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); ++ basetype = TREE_TYPE (TREE_VALUE (arg_types)); ++ arg_types = TREE_CHAIN (arg_types); ++ ++ parms = TREE_CHAIN (DECL_ARGUMENTS (fn)); ++ ++ /* If this is a subobject constructor or destructor, our caller will ++ pass us a pointer to our VTT. */ ++ if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn))) ++ { ++ parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type); ++ ++ /* First add it to DECL_ARGUMENTS between 'this' and the real args... */ ++ TREE_CHAIN (parm) = parms; ++ parms = parm; ++ ++ /* ...and then to TYPE_ARG_TYPES. */ ++ arg_types = hash_tree_chain (vtt_parm_type, arg_types); ++ ++ DECL_HAS_VTT_PARM_P (fn) = 1; ++ } ++ ++ /* Then add the in-charge parm (before the VTT parm). */ ++ parm = build_artificial_parm (in_charge_identifier, integer_type_node); ++ TREE_CHAIN (parm) = parms; ++ parms = parm; ++ arg_types = hash_tree_chain (integer_type_node, arg_types); ++ ++ /* Insert our new parameter(s) into the list. */ ++ TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms; ++ ++ /* And rebuild the function type. */ ++ fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)), ++ arg_types); ++ if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))) ++ fntype = build_exception_variant (fntype, ++ TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))); ++ TREE_TYPE (fn) = fntype; ++ ++ /* Now we've got the in-charge parameter. */ ++ DECL_HAS_IN_CHARGE_PARM_P (fn) = 1; ++} ++ ++/* Classes overload their constituent function names automatically. ++ When a function name is declared in a record structure, ++ its name is changed to it overloaded name. Since names for ++ constructors and destructors can conflict, we place a leading ++ '$' for destructors. ++ ++ CNAME is the name of the class we are grokking for. ++ ++ FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'. ++ ++ FLAGS contains bits saying what's special about today's ++ arguments. 1 == DESTRUCTOR. 2 == OPERATOR. ++ ++ If FUNCTION is a destructor, then we must add the `auto-delete' field ++ as a second parameter. There is some hair associated with the fact ++ that we must "declare" this variable in the manner consistent with the ++ way the rest of the arguments were declared. ++ ++ QUALS are the qualifiers for the this pointer. */ ++ ++void ++grokclassfn (tree ctype, tree function, enum overload_flags flags, tree quals) ++{ ++ tree fn_name = DECL_NAME (function); ++ int this_quals = TYPE_UNQUALIFIED; ++ ++ /* Even within an `extern "C"' block, members get C++ linkage. See ++ [dcl.link] for details. */ ++ SET_DECL_LANGUAGE (function, lang_cplusplus); ++ ++ if (fn_name == NULL_TREE) ++ { ++ error ("name missing for member function"); ++ fn_name = get_identifier (""); ++ DECL_NAME (function) = fn_name; ++ } ++ ++ if (quals) ++ this_quals = grok_method_quals (ctype, function, quals); ++ ++ if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) ++ { ++ /* Must add the class instance variable up front. */ ++ /* Right now we just make this a pointer. But later ++ we may wish to make it special. */ ++ tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function))); ++ tree qual_type; ++ tree parm; ++ ++ /* The `this' parameter is implicitly `const'; it cannot be ++ assigned to. */ ++ this_quals |= TYPE_QUAL_CONST; ++ qual_type = cp_build_qualified_type (type, this_quals); ++ parm = build_artificial_parm (this_identifier, qual_type); ++ c_apply_type_quals_to_decl (this_quals, parm); ++ TREE_CHAIN (parm) = DECL_ARGUMENTS (function); ++ DECL_ARGUMENTS (function) = parm; ++ } ++ ++ DECL_CONTEXT (function) = ctype; ++ ++ if (flags == DTOR_FLAG) ++ DECL_DESTRUCTOR_P (function) = 1; ++ ++ if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function)) ++ maybe_retrofit_in_chrg (function); ++} ++ ++/* Create an ARRAY_REF, checking for the user doing things backwards ++ along the way. */ ++ ++tree ++grok_array_decl (tree array_expr, tree index_exp) ++{ ++ tree type; ++ tree expr; ++ tree orig_array_expr = array_expr; ++ tree orig_index_exp = index_exp; ++ ++ if (error_operand_p (array_expr) || error_operand_p (index_exp)) ++ return error_mark_node; ++ ++ if (processing_template_decl) ++ { ++ if (type_dependent_expression_p (array_expr) ++ || type_dependent_expression_p (index_exp)) ++ return build_min_nt (ARRAY_REF, array_expr, index_exp); ++ array_expr = build_non_dependent_expr (array_expr); ++ index_exp = build_non_dependent_expr (index_exp); ++ } ++ ++ type = TREE_TYPE (array_expr); ++ my_friendly_assert (type, 20030626); ++ type = non_reference (type); ++ ++ /* If they have an `operator[]', use that. */ ++ if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp))) ++ expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL, ++ array_expr, index_exp, NULL_TREE, ++ /*overloaded_p=*/NULL); ++ else ++ { ++ tree p1, p2, i1, i2; ++ ++ /* Otherwise, create an ARRAY_REF for a pointer or array type. ++ It is a little-known fact that, if `a' is an array and `i' is ++ an int, you can write `i[a]', which means the same thing as ++ `a[i]'. */ ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ p1 = array_expr; ++ else ++ p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false); ++ ++ if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE) ++ p2 = index_exp; ++ else ++ p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false); ++ ++ i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, ++ false); ++ i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, ++ false); ++ ++ if ((p1 && i2) && (i1 && p2)) ++ error ("ambiguous conversion for array subscript"); ++ ++ if (p1 && i2) ++ array_expr = p1, index_exp = i2; ++ else if (i1 && p2) ++ array_expr = p2, index_exp = i1; ++ else ++ { ++ error ("invalid types `%T[%T]' for array subscript", ++ type, TREE_TYPE (index_exp)); ++ return error_mark_node; ++ } ++ ++ if (array_expr == error_mark_node || index_exp == error_mark_node) ++ error ("ambiguous conversion for array subscript"); ++ ++ expr = build_array_ref (array_expr, index_exp); ++ } ++ if (processing_template_decl && expr != error_mark_node) ++ return build_min_non_dep (ARRAY_REF, expr, ++ orig_array_expr, orig_index_exp); ++ return expr; ++} ++ ++/* Given the cast expression EXP, checking out its validity. Either return ++ an error_mark_node if there was an unavoidable error, return a cast to ++ void for trying to delete a pointer w/ the value 0, or return the ++ call to delete. If DOING_VEC is true, we handle things differently ++ for doing an array delete. ++ Implements ARM $5.3.4. This is called from the parser. */ ++ ++tree ++delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete) ++{ ++ tree t, type; ++ ++ if (exp == error_mark_node) ++ return exp; ++ ++ if (processing_template_decl) ++ { ++ t = build_min (DELETE_EXPR, void_type_node, exp, size); ++ DELETE_EXPR_USE_GLOBAL (t) = use_global_delete; ++ DELETE_EXPR_USE_VEC (t) = doing_vec; ++ TREE_SIDE_EFFECTS (t) = 1; ++ return t; ++ } ++ ++ exp = convert_from_reference (exp); ++ ++ /* An array can't have been allocated by new, so complain. */ ++ if (TREE_CODE (exp) == VAR_DECL ++ && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE) ++ warning ("deleting array `%#D'", exp); ++ ++ t = build_expr_type_conversion (WANT_POINTER, exp, true); ++ ++ if (t == NULL_TREE || t == error_mark_node) ++ { ++ error ("type `%#T' argument given to `delete', expected pointer", ++ TREE_TYPE (exp)); ++ return error_mark_node; ++ } ++ ++ type = TREE_TYPE (t); ++ ++ /* As of Valley Forge, you can delete a pointer to const. */ ++ ++ /* You can't delete functions. */ ++ if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) ++ { ++ error ("cannot delete a function. Only pointer-to-objects are valid arguments to `delete'"); ++ return error_mark_node; ++ } ++ ++ /* Deleting ptr to void is undefined behavior [expr.delete/3]. */ ++ if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE) ++ { ++ warning ("deleting `%T' is undefined", type); ++ doing_vec = 0; ++ } ++ ++ /* Deleting a pointer with the value zero is valid and has no effect. */ ++ if (integer_zerop (t)) ++ return build1 (NOP_EXPR, void_type_node, t); ++ ++ if (doing_vec) ++ return build_vec_delete (t, /*maxindex=*/NULL_TREE, ++ sfk_deleting_destructor, ++ use_global_delete); ++ else ++ return build_delete (type, t, sfk_deleting_destructor, ++ LOOKUP_NORMAL, use_global_delete); ++} ++ ++/* Report an error if the indicated template declaration is not the ++ sort of thing that should be a member template. */ ++ ++void ++check_member_template (tree tmpl) ++{ ++ tree decl; ++ ++ my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); ++ decl = DECL_TEMPLATE_RESULT (tmpl); ++ ++ if (TREE_CODE (decl) == FUNCTION_DECL ++ || (TREE_CODE (decl) == TYPE_DECL ++ && IS_AGGR_TYPE (TREE_TYPE (decl)))) ++ { ++ if (current_function_decl) ++ /* 14.5.2.2 [temp.mem] ++ ++ A local class shall not have member templates. */ ++ error ("invalid declaration of member template `%#D' in local class", ++ decl); ++ ++ if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl)) ++ { ++ /* 14.5.2.3 [temp.mem] ++ ++ A member function template shall not be virtual. */ ++ error ++ ("invalid use of `virtual' in template declaration of `%#D'", ++ decl); ++ DECL_VIRTUAL_P (decl) = 0; ++ } ++ ++ /* The debug-information generating code doesn't know what to do ++ with member templates. */ ++ DECL_IGNORED_P (tmpl) = 1; ++ } ++ else ++ error ("template declaration of `%#D'", decl); ++} ++ ++/* Return true iff TYPE is a valid Java parameter or return type. */ ++ ++static bool ++acceptable_java_type (tree type) ++{ ++ if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type)) ++ return 1; ++ if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE) ++ { ++ type = TREE_TYPE (type); ++ if (TREE_CODE (type) == RECORD_TYPE) ++ { ++ tree args; int i; ++ if (! TYPE_FOR_JAVA (type)) ++ return false; ++ if (! CLASSTYPE_TEMPLATE_INFO (type)) ++ return true; ++ args = CLASSTYPE_TI_ARGS (type); ++ i = TREE_VEC_LENGTH (args); ++ while (--i >= 0) ++ { ++ type = TREE_VEC_ELT (args, i); ++ if (TREE_CODE (type) == POINTER_TYPE) ++ type = TREE_TYPE (type); ++ if (! TYPE_FOR_JAVA (type)) ++ return false; ++ } ++ return true; ++ } ++ } ++ return false; ++} ++ ++/* For a METHOD in a Java class CTYPE, return true if ++ the parameter and return types are valid Java types. ++ Otherwise, print appropriate error messages, and return false. */ ++ ++bool ++check_java_method (tree method) ++{ ++ bool jerr = false; ++ tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method)); ++ tree ret_type = TREE_TYPE (TREE_TYPE (method)); ++ ++ if (!acceptable_java_type (ret_type)) ++ { ++ error ("Java method '%D' has non-Java return type `%T'", ++ method, ret_type); ++ jerr = true; ++ } ++ ++ arg_types = TREE_CHAIN (arg_types); ++ if (DECL_HAS_IN_CHARGE_PARM_P (method)) ++ arg_types = TREE_CHAIN (arg_types); ++ if (DECL_HAS_VTT_PARM_P (method)) ++ arg_types = TREE_CHAIN (arg_types); ++ ++ for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types)) ++ { ++ tree type = TREE_VALUE (arg_types); ++ if (!acceptable_java_type (type)) ++ { ++ error ("Java method '%D' has non-Java parameter type `%T'", ++ method, type); ++ jerr = true; ++ } ++ } ++ return !jerr; ++} ++ ++/* Sanity check: report error if this function FUNCTION is not ++ really a member of the class (CTYPE) it is supposed to belong to. ++ CNAME is the same here as it is for grokclassfn above. ++ TEMPLATE_HEADER_P is true when this declaration comes with a ++ template header. */ ++ ++tree ++check_classfn (tree ctype, tree function, bool template_header_p) ++{ ++ int ix; ++ int is_template; ++ ++ if (DECL_USE_TEMPLATE (function) ++ && !(TREE_CODE (function) == TEMPLATE_DECL ++ && DECL_TEMPLATE_SPECIALIZATION (function)) ++ && is_member_template (DECL_TI_TEMPLATE (function))) ++ /* Since this is a specialization of a member template, ++ we're not going to find the declaration in the class. ++ For example, in: ++ ++ struct S { template void f(T); }; ++ template <> void S::f(int); ++ ++ we're not going to find `S::f(int)', but there's no ++ reason we should, either. We let our callers know we didn't ++ find the method, but we don't complain. */ ++ return NULL_TREE; ++ ++ /* OK, is this a definition of a member template? */ ++ is_template = (TREE_CODE (function) == TEMPLATE_DECL ++ || template_header_p); ++ ++ ix = lookup_fnfields_1 (complete_type (ctype), ++ DECL_CONSTRUCTOR_P (function) ? ctor_identifier : ++ DECL_DESTRUCTOR_P (function) ? dtor_identifier : ++ DECL_NAME (function)); ++ ++ if (ix >= 0) ++ { ++ tree methods = CLASSTYPE_METHOD_VEC (ctype); ++ tree fndecls, fndecl = 0; ++ bool is_conv_op; ++ bool pop_p; ++ const char *format = NULL; ++ ++ pop_p = push_scope (ctype); ++ for (fndecls = TREE_VEC_ELT (methods, ix); ++ fndecls; fndecls = OVL_NEXT (fndecls)) ++ { ++ tree p1, p2; ++ ++ fndecl = OVL_CURRENT (fndecls); ++ p1 = TYPE_ARG_TYPES (TREE_TYPE (function)); ++ p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); ++ ++ /* We cannot simply call decls_match because this doesn't ++ work for static member functions that are pretending to ++ be methods, and because the name may have been changed by ++ asm("new_name"). */ ++ ++ /* Get rid of the this parameter on functions that become ++ static. */ ++ if (DECL_STATIC_FUNCTION_P (fndecl) ++ && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) ++ p1 = TREE_CHAIN (p1); ++ ++ /* A member template definition only matches a member template ++ declaration. */ ++ if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL)) ++ continue; ++ ++ if (same_type_p (TREE_TYPE (TREE_TYPE (function)), ++ TREE_TYPE (TREE_TYPE (fndecl))) ++ && compparms (p1, p2) ++ && (DECL_TEMPLATE_SPECIALIZATION (function) ++ == DECL_TEMPLATE_SPECIALIZATION (fndecl)) ++ && (!DECL_TEMPLATE_SPECIALIZATION (function) ++ || (DECL_TI_TEMPLATE (function) ++ == DECL_TI_TEMPLATE (fndecl)))) ++ break; ++ } ++ if (pop_p) ++ pop_scope (ctype); ++ if (fndecls) ++ return OVL_CURRENT (fndecls); ++ error ("prototype for `%#D' does not match any in class `%T'", ++ function, ctype); ++ is_conv_op = DECL_CONV_FN_P (fndecl); ++ ++ if (is_conv_op) ++ ix = CLASSTYPE_FIRST_CONVERSION_SLOT; ++ fndecls = TREE_VEC_ELT (methods, ix); ++ while (fndecls) ++ { ++ fndecl = OVL_CURRENT (fndecls); ++ fndecls = OVL_NEXT (fndecls); ++ ++ if (!fndecls && is_conv_op) ++ { ++ if (TREE_VEC_LENGTH (methods) > ix) ++ { ++ ix++; ++ fndecls = TREE_VEC_ELT (methods, ix); ++ if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls))) ++ { ++ fndecls = NULL_TREE; ++ is_conv_op = false; ++ } ++ } ++ else ++ is_conv_op = false; ++ } ++ if (format) ++ format = " %#D"; ++ else if (fndecls) ++ format = "candidates are: %#D"; ++ else ++ format = "candidate is: %#D"; ++ cp_error_at (format, fndecl); ++ } ++ } ++ else if (!COMPLETE_TYPE_P (ctype)) ++ cxx_incomplete_type_error (function, ctype); ++ else ++ error ("no `%#D' member function declared in class `%T'", ++ function, ctype); ++ ++ /* If we did not find the method in the class, add it to avoid ++ spurious errors (unless the CTYPE is not yet defined, in which ++ case we'll only confuse ourselves when the function is declared ++ properly within the class. */ ++ if (COMPLETE_TYPE_P (ctype)) ++ add_method (ctype, function, /*error_p=*/1); ++ return NULL_TREE; ++} ++ ++/* We have just processed the DECL, which is a static data member. ++ Its initializer, if present, is INIT. The ASMSPEC_TREE, if ++ present, is the assembly-language name for the data member. ++ FLAGS is as for cp_finish_decl. */ ++ ++void ++finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree, ++ int flags) ++{ ++ my_friendly_assert (TREE_PUBLIC (decl), 0); ++ ++ DECL_CONTEXT (decl) = current_class_type; ++ ++ /* We cannot call pushdecl here, because that would fill in the ++ TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do ++ the right thing, namely, to put this decl out straight away. */ ++ /* current_class_type can be NULL_TREE in case of error. */ ++ if (!asmspec_tree && current_class_type) ++ DECL_INITIAL (decl) = error_mark_node; ++ ++ if (! processing_template_decl) ++ { ++ if (!pending_statics) ++ VARRAY_TREE_INIT (pending_statics, 32, "pending_statics"); ++ VARRAY_PUSH_TREE (pending_statics, decl); ++ } ++ ++ if (LOCAL_CLASS_P (current_class_type)) ++ pedwarn ("local class `%#T' shall not have static data member `%#D'", ++ current_class_type, decl); ++ ++ /* Static consts need not be initialized in the class definition. */ ++ if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))) ++ { ++ static int explained = 0; ++ ++ error ("initializer invalid for static member with constructor"); ++ if (!explained) ++ { ++ error ("(an out of class initialization is required)"); ++ explained = 1; ++ } ++ init = NULL_TREE; ++ } ++ /* Force the compiler to know when an uninitialized static const ++ member is being used. */ ++ if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0) ++ TREE_USED (decl) = 1; ++ DECL_INITIAL (decl) = init; ++ DECL_IN_AGGR_P (decl) = 1; ++ ++ cp_finish_decl (decl, init, asmspec_tree, flags); ++} ++ ++/* Process the specs, declarator (NULL if omitted) and width (NULL if omitted) ++ of a structure component, returning a _DECL node. ++ QUALS is a list of type qualifiers for this decl (such as for declaring ++ const member functions). ++ ++ This is done during the parsing of the struct declaration. ++ The _DECL nodes are chained together and the lot of them ++ are ultimately passed to `build_struct' to make the RECORD_TYPE node. ++ ++ If class A defines that certain functions in class B are friends, then ++ the way I have set things up, it is B who is interested in permission ++ granted by A. However, it is in A's context that these declarations ++ are parsed. By returning a void_type_node, class A does not attempt ++ to incorporate the declarations of the friends within its structure. ++ ++ DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING ++ CHANGES TO CODE IN `start_method'. */ ++ ++tree ++grokfield (tree declarator, tree declspecs, tree init, tree asmspec_tree, ++ tree attrlist) ++{ ++ tree value; ++ const char *asmspec = 0; ++ int flags = LOOKUP_ONLYCONVERTING; ++ ++ if (declspecs == NULL_TREE ++ && TREE_CODE (declarator) == SCOPE_REF ++ && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE) ++ { ++ /* Access declaration */ ++ if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0)))) ++ ; ++ else if (TREE_COMPLEXITY (declarator) == current_class_depth) ++ pop_nested_class (); ++ return do_class_using_decl (declarator); ++ } ++ ++ if (init ++ && TREE_CODE (init) == TREE_LIST ++ && TREE_VALUE (init) == error_mark_node ++ && TREE_CHAIN (init) == NULL_TREE) ++ init = NULL_TREE; ++ ++ value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist); ++ if (! value || error_operand_p (value)) ++ /* friend or constructor went bad. */ ++ return error_mark_node; ++ ++ if (TREE_CODE (value) == TYPE_DECL && init) ++ { ++ error ("typedef `%D' is initialized (use __typeof__ instead)", value); ++ init = NULL_TREE; ++ } ++ ++ /* Pass friendly classes back. */ ++ if (value == void_type_node) ++ return value; ++ ++ /* Pass friend decls back. */ ++ if ((TREE_CODE (value) == FUNCTION_DECL ++ || TREE_CODE (value) == TEMPLATE_DECL) ++ && DECL_CONTEXT (value) != current_class_type) ++ return value; ++ ++ if (DECL_NAME (value) != NULL_TREE ++ && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_' ++ && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr")) ++ error ("member `%D' conflicts with virtual function table field name", ++ value); ++ ++ /* Stash away type declarations. */ ++ if (TREE_CODE (value) == TYPE_DECL) ++ { ++ DECL_NONLOCAL (value) = 1; ++ DECL_CONTEXT (value) = current_class_type; ++ ++ if (processing_template_decl) ++ value = push_template_decl (value); ++ ++ return value; ++ } ++ ++ if (DECL_IN_AGGR_P (value)) ++ { ++ error ("`%D' is already defined in `%T'", value, ++ DECL_CONTEXT (value)); ++ return void_type_node; ++ } ++ ++ if (asmspec_tree) ++ asmspec = TREE_STRING_POINTER (asmspec_tree); ++ ++ if (init) ++ { ++ if (TREE_CODE (value) == FUNCTION_DECL) ++ { ++ grok_function_init (value, init); ++ init = NULL_TREE; ++ } ++ else if (pedantic && TREE_CODE (value) != VAR_DECL) ++ /* Already complained in grokdeclarator. */ ++ init = NULL_TREE; ++ else ++ { ++ /* We allow initializers to become parameters to base ++ initializers. */ ++ if (TREE_CODE (init) == TREE_LIST) ++ { ++ if (TREE_CHAIN (init) == NULL_TREE) ++ init = TREE_VALUE (init); ++ else ++ init = digest_init (TREE_TYPE (value), init, (tree *)0); ++ } ++ ++ if (!processing_template_decl) ++ { ++ if (TREE_CODE (init) == CONST_DECL) ++ init = DECL_INITIAL (init); ++ else if (TREE_READONLY_DECL_P (init)) ++ init = decl_constant_value (init); ++ else if (TREE_CODE (init) == CONSTRUCTOR) ++ init = digest_init (TREE_TYPE (value), init, (tree *)0); ++ if (init != error_mark_node && ! TREE_CONSTANT (init)) ++ { ++ /* We can allow references to things that are effectively ++ static, since references are initialized with the ++ address. */ ++ if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE ++ || (TREE_STATIC (init) == 0 ++ && (!DECL_P (init) || DECL_EXTERNAL (init) == 0))) ++ { ++ error ("field initializer is not constant"); ++ init = error_mark_node; ++ } ++ } ++ } ++ } ++ } ++ ++ if (processing_template_decl ++ && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL)) ++ { ++ value = push_template_decl (value); ++ if (error_operand_p (value)) ++ return error_mark_node; ++ } ++ ++ if (attrlist) ++ cplus_decl_attributes (&value, attrlist, 0); ++ ++ if (TREE_CODE (value) == VAR_DECL) ++ { ++ finish_static_data_member_decl (value, init, asmspec_tree, ++ flags); ++ return value; ++ } ++ if (TREE_CODE (value) == FIELD_DECL) ++ { ++ if (asmspec) ++ error ("`asm' specifiers are not permitted on non-static data members"); ++ if (DECL_INITIAL (value) == error_mark_node) ++ init = error_mark_node; ++ cp_finish_decl (value, init, NULL_TREE, flags); ++ DECL_INITIAL (value) = init; ++ DECL_IN_AGGR_P (value) = 1; ++ return value; ++ } ++ if (TREE_CODE (value) == FUNCTION_DECL) ++ { ++ if (asmspec) ++ { ++ /* This must override the asm specifier which was placed ++ by grokclassfn. Lay this out fresh. */ ++ SET_DECL_RTL (value, NULL_RTX); ++ change_decl_assembler_name (value, get_identifier (asmspec)); ++ } ++ if (!DECL_FRIEND_P (value)) ++ grok_special_member_properties (value); ++ ++ cp_finish_decl (value, init, asmspec_tree, flags); ++ ++ /* Pass friends back this way. */ ++ if (DECL_FRIEND_P (value)) ++ return void_type_node; ++ ++ DECL_IN_AGGR_P (value) = 1; ++ return value; ++ } ++ abort (); ++ /* NOTREACHED */ ++ return NULL_TREE; ++} ++ ++/* Like `grokfield', but for bitfields. ++ WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */ ++ ++tree ++grokbitfield (tree declarator, tree declspecs, tree width) ++{ ++ tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL); ++ ++ if (! value) return NULL_TREE; /* friends went bad. */ ++ ++ /* Pass friendly classes back. */ ++ if (TREE_CODE (value) == VOID_TYPE) ++ return void_type_node; ++ ++ if (TREE_CODE (value) == TYPE_DECL) ++ { ++ error ("cannot declare `%D' to be a bit-field type", value); ++ return NULL_TREE; ++ } ++ ++ /* Usually, finish_struct_1 catches bitfields with invalid types. ++ But, in the case of bitfields with function type, we confuse ++ ourselves into thinking they are member functions, so we must ++ check here. */ ++ if (TREE_CODE (value) == FUNCTION_DECL) ++ { ++ error ("cannot declare bit-field `%D' with function type", ++ DECL_NAME (value)); ++ return NULL_TREE; ++ } ++ ++ if (DECL_IN_AGGR_P (value)) ++ { ++ error ("`%D' is already defined in the class %T", value, ++ DECL_CONTEXT (value)); ++ return void_type_node; ++ } ++ ++ if (TREE_STATIC (value)) ++ { ++ error ("static member `%D' cannot be a bit-field", value); ++ return NULL_TREE; ++ } ++ cp_finish_decl (value, NULL_TREE, NULL_TREE, 0); ++ ++ if (width != error_mark_node) ++ { ++ constant_expression_warning (width); ++ DECL_INITIAL (value) = width; ++ SET_DECL_C_BIT_FIELD (value); ++ } ++ ++ DECL_IN_AGGR_P (value) = 1; ++ return value; ++} ++ ++/* When a function is declared with an initializer, ++ do the right thing. Currently, there are two possibilities: ++ ++ class B ++ { ++ public: ++ // initialization possibility #1. ++ virtual void f () = 0; ++ int g (); ++ }; ++ ++ class D1 : B ++ { ++ public: ++ int d1; ++ // error, no f (); ++ }; ++ ++ class D2 : B ++ { ++ public: ++ int d2; ++ void f (); ++ }; ++ ++ class D3 : B ++ { ++ public: ++ int d3; ++ // initialization possibility #2 ++ void f () = B::f; ++ }; ++ ++*/ ++ ++static void ++grok_function_init (tree decl, tree init) ++{ ++ /* An initializer for a function tells how this function should ++ be inherited. */ ++ tree type = TREE_TYPE (decl); ++ ++ if (TREE_CODE (type) == FUNCTION_TYPE) ++ error ("initializer specified for non-member function `%D'", decl); ++ else if (integer_zerop (init)) ++ DECL_PURE_VIRTUAL_P (decl) = 1; ++ else ++ error ("invalid initializer for virtual method `%D'", decl); ++} ++ ++void ++cplus_decl_attributes (tree *decl, tree attributes, int flags) ++{ ++ if (*decl == NULL_TREE || *decl == void_type_node) ++ return; ++ ++ if (TREE_CODE (*decl) == TEMPLATE_DECL) ++ decl = &DECL_TEMPLATE_RESULT (*decl); ++ ++ decl_attributes (decl, attributes, flags); ++ ++ if (TREE_CODE (*decl) == TYPE_DECL) ++ SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl)); ++} ++ ++/* Defer the compilation of the FN until the end of compilation. */ ++ ++void ++defer_fn (tree fn) ++{ ++ if (DECL_DEFERRED_FN (fn)) ++ return; ++ DECL_DEFERRED_FN (fn) = 1; ++ DECL_DEFER_OUTPUT (fn) = 1; ++ if (!deferred_fns) ++ VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns"); ++ ++ VARRAY_PUSH_TREE (deferred_fns, fn); ++} ++ ++/* Walks through the namespace- or function-scope anonymous union OBJECT, ++ building appropriate ALIAS_DECLs. Returns one of the fields for use in ++ the mangled name. */ ++ ++static tree ++build_anon_union_vars (tree object) ++{ ++ tree type = TREE_TYPE (object); ++ tree main_decl = NULL_TREE; ++ tree field; ++ ++ /* Rather than write the code to handle the non-union case, ++ just give an error. */ ++ if (TREE_CODE (type) != UNION_TYPE) ++ error ("anonymous struct not inside named type"); ++ ++ for (field = TYPE_FIELDS (type); ++ field != NULL_TREE; ++ field = TREE_CHAIN (field)) ++ { ++ tree decl; ++ tree ref; ++ ++ if (DECL_ARTIFICIAL (field)) ++ continue; ++ if (TREE_CODE (field) != FIELD_DECL) ++ { ++ cp_pedwarn_at ("\ ++`%#D' invalid; an anonymous union can only have non-static data members", ++ field); ++ continue; ++ } ++ ++ if (TREE_PRIVATE (field)) ++ cp_pedwarn_at ("private member `%#D' in anonymous union", field); ++ else if (TREE_PROTECTED (field)) ++ cp_pedwarn_at ("protected member `%#D' in anonymous union", field); ++ ++ if (processing_template_decl) ++ ref = build_min_nt (COMPONENT_REF, object, DECL_NAME (field)); ++ else ++ ref = build_class_member_access_expr (object, field, NULL_TREE, ++ false); ++ ++ if (DECL_NAME (field)) ++ { ++ decl = build_decl (ALIAS_DECL, DECL_NAME (field), TREE_TYPE (field)); ++ DECL_INITIAL (decl) = ref; ++ TREE_PUBLIC (decl) = 0; ++ TREE_STATIC (decl) = 0; ++ DECL_EXTERNAL (decl) = 1; ++ decl = pushdecl (decl); ++ } ++ else if (ANON_AGGR_TYPE_P (TREE_TYPE (field))) ++ decl = build_anon_union_vars (ref); ++ else ++ decl = 0; ++ ++ if (main_decl == NULL_TREE) ++ main_decl = decl; ++ } ++ ++ return main_decl; ++} ++ ++/* Finish off the processing of a UNION_TYPE structure. If the union is an ++ anonymous union, then all members must be laid out together. PUBLIC_P ++ is nonzero if this union is not declared static. */ ++ ++void ++finish_anon_union (tree anon_union_decl) ++{ ++ tree type; ++ tree main_decl; ++ bool public_p; ++ ++ if (anon_union_decl == error_mark_node) ++ return; ++ ++ type = TREE_TYPE (anon_union_decl); ++ public_p = TREE_PUBLIC (anon_union_decl); ++ ++ /* The VAR_DECL's context is the same as the TYPE's context. */ ++ DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type)); ++ ++ if (TYPE_FIELDS (type) == NULL_TREE) ++ return; ++ ++ if (public_p) ++ { ++ error ("namespace-scope anonymous aggregates must be static"); ++ return; ++ } ++ ++ main_decl = build_anon_union_vars (anon_union_decl); ++ if (main_decl == NULL_TREE) ++ { ++ warning ("anonymous union with no members"); ++ return; ++ } ++ ++ if (!processing_template_decl) ++ { ++ /* Use main_decl to set the mangled name. */ ++ DECL_NAME (anon_union_decl) = DECL_NAME (main_decl); ++ mangle_decl (anon_union_decl); ++ DECL_NAME (anon_union_decl) = NULL_TREE; ++ } ++ ++ pushdecl (anon_union_decl); ++ if (building_stmt_tree () ++ && at_function_scope_p ()) ++ add_decl_stmt (anon_union_decl); ++ else if (!processing_template_decl) ++ rest_of_decl_compilation (anon_union_decl, NULL, ++ toplevel_bindings_p (), at_eof); ++} ++ ++/* Auxiliary functions to make type signatures for ++ `operator new' and `operator delete' correspond to ++ what compiler will be expecting. */ ++ ++tree ++coerce_new_type (tree type) ++{ ++ int e = 0; ++ tree args = TYPE_ARG_TYPES (type); ++ ++ my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107); ++ ++ if (!same_type_p (TREE_TYPE (type), ptr_type_node)) ++ e = 1, error ("`operator new' must return type `%T'", ptr_type_node); ++ ++ if (!args || args == void_list_node ++ || !same_type_p (TREE_VALUE (args), size_type_node)) ++ { ++ e = 2; ++ if (args && args != void_list_node) ++ args = TREE_CHAIN (args); ++ pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", size_type_node); ++ } ++ switch (e) ++ { ++ case 2: ++ args = tree_cons (NULL_TREE, size_type_node, args); ++ /* Fall through. */ ++ case 1: ++ type = build_exception_variant ++ (build_function_type (ptr_type_node, args), ++ TYPE_RAISES_EXCEPTIONS (type)); ++ /* Fall through. */ ++ default:; ++ } ++ return type; ++} ++ ++tree ++coerce_delete_type (tree type) ++{ ++ int e = 0; ++ tree args = TYPE_ARG_TYPES (type); ++ ++ my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107); ++ ++ if (!same_type_p (TREE_TYPE (type), void_type_node)) ++ e = 1, error ("`operator delete' must return type `%T'", void_type_node); ++ ++ if (!args || args == void_list_node ++ || !same_type_p (TREE_VALUE (args), ptr_type_node)) ++ { ++ e = 2; ++ if (args && args != void_list_node) ++ args = TREE_CHAIN (args); ++ error ("`operator delete' takes type `%T' as first parameter", ptr_type_node); ++ } ++ switch (e) ++ { ++ case 2: ++ args = tree_cons (NULL_TREE, ptr_type_node, args); ++ /* Fall through. */ ++ case 1: ++ type = build_exception_variant ++ (build_function_type (void_type_node, args), ++ TYPE_RAISES_EXCEPTIONS (type)); ++ /* Fall through. */ ++ default:; ++ } ++ ++ return type; ++} ++ ++static void ++mark_vtable_entries (tree decl) ++{ ++ tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl)); ++ ++ for (; entries; entries = TREE_CHAIN (entries)) ++ { ++ tree fnaddr = TREE_VALUE (entries); ++ tree fn; ++ ++ STRIP_NOPS (fnaddr); ++ ++ if (TREE_CODE (fnaddr) != ADDR_EXPR ++ && TREE_CODE (fnaddr) != FDESC_EXPR) ++ /* This entry is an offset: a virtual base class offset, a ++ virtual call offset, an RTTI offset, etc. */ ++ continue; ++ ++ fn = TREE_OPERAND (fnaddr, 0); ++ TREE_ADDRESSABLE (fn) = 1; ++ /* When we don't have vcall offsets, we output thunks whenever ++ we output the vtables that contain them. With vcall offsets, ++ we know all the thunks we'll need when we emit a virtual ++ function, so we emit the thunks there instead. */ ++ if (DECL_THUNK_P (fn)) ++ use_thunk (fn, /*emit_p=*/0); ++ mark_used (fn); ++ } ++} ++ ++/* Set DECL up to have the closest approximation of "initialized common" ++ linkage available. */ ++ ++void ++comdat_linkage (tree decl) ++{ ++ if (flag_weak) ++ make_decl_one_only (decl); ++ else if (TREE_CODE (decl) == FUNCTION_DECL ++ || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl))) ++ /* We can just emit function and compiler-generated variables ++ statically; having multiple copies is (for the most part) only ++ a waste of space. ++ ++ There are two correctness issues, however: the address of a ++ template instantiation with external linkage should be the ++ same, independent of what translation unit asks for the ++ address, and this will not hold when we emit multiple copies of ++ the function. However, there's little else we can do. ++ ++ Also, by default, the typeinfo implementation assumes that ++ there will be only one copy of the string used as the name for ++ each type. Therefore, if weak symbols are unavailable, the ++ run-time library should perform a more conservative check; it ++ should perform a string comparison, rather than an address ++ comparison. */ ++ TREE_PUBLIC (decl) = 0; ++ else ++ { ++ /* Static data member template instantiations, however, cannot ++ have multiple copies. */ ++ if (DECL_INITIAL (decl) == 0 ++ || DECL_INITIAL (decl) == error_mark_node) ++ DECL_COMMON (decl) = 1; ++ else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))) ++ { ++ DECL_COMMON (decl) = 1; ++ DECL_INITIAL (decl) = error_mark_node; ++ } ++ else if (!DECL_EXPLICIT_INSTANTIATION (decl)) ++ { ++ /* We can't do anything useful; leave vars for explicit ++ instantiation. */ ++ DECL_EXTERNAL (decl) = 1; ++ DECL_NOT_REALLY_EXTERN (decl) = 0; ++ } ++ } ++ ++ if (DECL_LANG_SPECIFIC (decl)) ++ DECL_COMDAT (decl) = 1; ++} ++ ++/* For win32 we also want to put explicit instantiations in ++ linkonce sections, so that they will be merged with implicit ++ instantiations; otherwise we get duplicate symbol errors. */ ++ ++void ++maybe_make_one_only (tree decl) ++{ ++ /* We used to say that this was not necessary on targets that support weak ++ symbols, because the implicit instantiations will defer to the explicit ++ one. However, that's not actually the case in SVR4; a strong definition ++ after a weak one is an error. Also, not making explicit ++ instantiations one_only means that we can end up with two copies of ++ some template instantiations. */ ++ if (! flag_weak) ++ return; ++ ++ /* We can't set DECL_COMDAT on functions, or finish_file will think ++ we can get away with not emitting them if they aren't used. We need ++ to for variables so that cp_finish_decl will update their linkage, ++ because their DECL_INITIAL may not have been set properly yet. */ ++ ++ make_decl_one_only (decl); ++ ++ if (TREE_CODE (decl) == VAR_DECL) ++ { ++ DECL_COMDAT (decl) = 1; ++ /* Mark it needed so we don't forget to emit it. */ ++ mark_referenced (DECL_ASSEMBLER_NAME (decl)); ++ } ++} ++ ++/* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL, ++ based on TYPE and other static flags. ++ ++ Note that anything public is tagged TREE_PUBLIC, whether ++ it's public in this file or in another one. */ ++ ++void ++import_export_vtable (tree decl, tree type, int final) ++{ ++ if (DECL_INTERFACE_KNOWN (decl)) ++ return; ++ ++ if (TYPE_FOR_JAVA (type)) ++ { ++ TREE_PUBLIC (decl) = 1; ++ DECL_EXTERNAL (decl) = 1; ++ DECL_INTERFACE_KNOWN (decl) = 1; ++ } ++ else if (CLASSTYPE_INTERFACE_KNOWN (type)) ++ { ++ TREE_PUBLIC (decl) = 1; ++ DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type); ++ DECL_INTERFACE_KNOWN (decl) = 1; ++ } ++ else ++ { ++ /* We can only wait to decide if we have real non-inline virtual ++ functions in our class, or if we come from a template. */ ++ ++ int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type) ++ || CLASSTYPE_KEY_METHOD (type) != NULL_TREE); ++ ++ if (final || ! found) ++ { ++ comdat_linkage (decl); ++ DECL_EXTERNAL (decl) = 0; ++ } ++ else ++ { ++ TREE_PUBLIC (decl) = 1; ++ DECL_EXTERNAL (decl) = 1; + /* If found and the class has dllimport attribute, commit to + marking the vtable as dllimport, We don't want to change + linkage when maybe_emit_vtable calls this with final true. */ + if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (type))) + DECL_INTERFACE_KNOWN (decl) = 1; - } - } - } ++ } ++ } ++} ++ ++/* Determine whether or not we want to specifically import or export CTYPE, ++ using various heuristics. */ ++ ++static void ++import_export_class (tree ctype) ++{ ++ /* -1 for imported, 1 for exported. */ ++ int import_export = 0; ++ ++ /* It only makes sense to call this function at EOF. The reason is ++ that this function looks at whether or not the first non-inline ++ non-abstract virtual member function has been defined in this ++ translation unit. But, we can't possibly know that until we've ++ seen the entire translation unit. */ ++ my_friendly_assert (at_eof, 20000226); ++ ++ if (CLASSTYPE_INTERFACE_KNOWN (ctype)) ++ return; ++ ++ /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface, ++ we will have CLASSTYPE_INTERFACE_ONLY set but not ++ CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this ++ heuristic because someone will supply a #pragma implementation ++ elsewhere, and deducing it here would produce a conflict. */ ++ if (CLASSTYPE_INTERFACE_ONLY (ctype)) ++ return; ++ ++ if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype))) ++ import_export = -1; ++ else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype))) ++ import_export = 1; ++ ++ /* If we got -fno-implicit-templates, we import template classes that ++ weren't explicitly instantiated. */ ++ if (import_export == 0 ++ && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype) ++ && ! flag_implicit_templates) ++ import_export = -1; ++ ++ /* Base our import/export status on that of the first non-inline, ++ non-pure virtual function, if any. */ ++ if (import_export == 0 ++ && TYPE_POLYMORPHIC_P (ctype)) ++ { ++ tree method = CLASSTYPE_KEY_METHOD (ctype); ++ if (method) ++ import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1); ++ } ++ ++#ifdef MULTIPLE_SYMBOL_SPACES ++ if (import_export == -1) ++ import_export = 0; ++#endif ++ ++ if (import_export) ++ { ++ SET_CLASSTYPE_INTERFACE_KNOWN (ctype); ++ CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0); ++ } ++} ++ ++/* Return true if VAR has already been provided to the back end; in that ++ case VAR should not be modified further by the front end. */ ++static bool ++var_finalized_p (tree var) ++{ ++ if (flag_unit_at_a_time) ++ return cgraph_varpool_node (var)->finalized; ++ else ++ return TREE_ASM_WRITTEN (var); ++} ++ ++/* If necessary, write out the vtables for the dynamic class CTYPE. ++ Returns true if any vtables were emitted. */ ++ ++static bool ++maybe_emit_vtables (tree ctype) ++{ ++ tree vtbl; ++ tree primary_vtbl; ++ bool needed = false; ++ ++ /* If the vtables for this class have already been emitted there is ++ nothing more to do. */ ++ primary_vtbl = CLASSTYPE_VTABLES (ctype); ++ if (var_finalized_p (primary_vtbl)) ++ return false; ++ /* Ignore dummy vtables made by get_vtable_decl. */ ++ if (TREE_TYPE (primary_vtbl) == void_type_node) ++ return false; ++ ++ import_export_class (ctype); ++ ++ /* See if any of the vtables are needed. */ ++ for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl)) ++ { ++ import_export_vtable (vtbl, ctype, 1); ++ if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl)) ++ break; ++ } ++ if (!vtbl) ++ { ++ /* If the references to this class' vtables are optimized away, ++ still emit the appropriate debugging information. See ++ dfs_debug_mark. */ ++ if (DECL_COMDAT (primary_vtbl) ++ && CLASSTYPE_DEBUG_REQUESTED (ctype)) ++ note_debug_info_needed (ctype); ++ return false; ++ } ++ else if (TREE_PUBLIC (vtbl) && !DECL_COMDAT (vtbl)) ++ needed = true; ++ ++ ++ /* The ABI requires that we emit all of the vtables if we emit any ++ of them. */ ++ for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl)) ++ { ++ /* Write it out. */ ++ import_export_vtable (vtbl, ctype, 1); ++ mark_vtable_entries (vtbl); ++ ++ /* If we know that DECL is needed, mark it as such for the varpool. */ ++ if (needed) ++ cgraph_varpool_mark_needed_node (cgraph_varpool_node (vtbl)); ++ ++ if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0) ++ { ++ /* It had better be all done at compile-time. */ ++ if (store_init_value (vtbl, DECL_INITIAL (vtbl))) ++ abort (); ++ } ++ ++ if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG) ++ { ++ /* Mark the VAR_DECL node representing the vtable itself as a ++ "gratuitous" one, thereby forcing dwarfout.c to ignore it. ++ It is rather important that such things be ignored because ++ any effort to actually generate DWARF for them will run ++ into trouble when/if we encounter code like: ++ ++ #pragma interface ++ struct S { virtual void member (); }; ++ ++ because the artificial declaration of the vtable itself (as ++ manufactured by the g++ front end) will say that the vtable ++ is a static member of `S' but only *after* the debug output ++ for the definition of `S' has already been output. This causes ++ grief because the DWARF entry for the definition of the vtable ++ will try to refer back to an earlier *declaration* of the ++ vtable as a static member of `S' and there won't be one. ++ We might be able to arrange to have the "vtable static member" ++ attached to the member list for `S' before the debug info for ++ `S' get written (which would solve the problem) but that would ++ require more intrusive changes to the g++ front end. */ ++ ++ DECL_IGNORED_P (vtbl) = 1; ++ } ++ ++ /* Always make vtables weak. */ ++ if (flag_weak) ++ comdat_linkage (vtbl); ++ ++ rest_of_decl_compilation (vtbl, NULL, 1, 1); ++ ++ /* Because we're only doing syntax-checking, we'll never end up ++ actually marking the variable as written. */ ++ if (flag_syntax_only) ++ TREE_ASM_WRITTEN (vtbl) = 1; ++ } ++ ++ /* Since we're writing out the vtable here, also write the debug ++ info. */ ++ note_debug_info_needed (ctype); ++ ++ return true; ++} ++ ++/* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an ++ inline function or template instantiation at end-of-file. */ ++ ++void ++import_export_decl (tree decl) ++{ ++ if (DECL_INTERFACE_KNOWN (decl)) ++ return; ++ ++ if (DECL_TEMPLATE_INSTANTIATION (decl) ++ || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) ++ { ++ DECL_NOT_REALLY_EXTERN (decl) = 1; ++ if ((DECL_IMPLICIT_INSTANTIATION (decl) ++ || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) ++ && (flag_implicit_templates ++ || (flag_implicit_inline_templates ++ && TREE_CODE (decl) == FUNCTION_DECL ++ && DECL_DECLARED_INLINE_P (decl)))) ++ { ++ if (!TREE_PUBLIC (decl)) ++ /* Templates are allowed to have internal linkage. See ++ [basic.link]. */ ++ ; ++ else ++ comdat_linkage (decl); ++ } ++ else ++ { ++ DECL_EXTERNAL (decl) = 1; ++ DECL_NOT_REALLY_EXTERN (decl) = 0; ++ } ++ } ++ else if (DECL_FUNCTION_MEMBER_P (decl)) ++ { ++ if (!DECL_DECLARED_INLINE_P (decl)) ++ { ++ tree ctype = DECL_CONTEXT (decl); ++ import_export_class (ctype); ++ if (CLASSTYPE_INTERFACE_KNOWN (ctype)) ++ { ++ DECL_NOT_REALLY_EXTERN (decl) ++ = ! (CLASSTYPE_INTERFACE_ONLY (ctype) ++ || (DECL_DECLARED_INLINE_P (decl) ++ && ! flag_implement_inlines ++ && !DECL_VINDEX (decl))); ++ ++ if (!DECL_NOT_REALLY_EXTERN (decl)) ++ DECL_EXTERNAL (decl) = 1; ++ ++ /* Always make artificials weak. */ ++ if (DECL_ARTIFICIAL (decl) && flag_weak) ++ comdat_linkage (decl); ++ else ++ maybe_make_one_only (decl); ++ } ++ } ++ else ++ comdat_linkage (decl); ++ } ++ else ++ comdat_linkage (decl); ++ ++ DECL_INTERFACE_KNOWN (decl) = 1; ++} ++ ++/* Here, we only decide whether or not the tinfo node should be ++ emitted with the vtable. IS_IN_LIBRARY is nonzero iff the ++ typeinfo for TYPE should be in the runtime library. */ ++ ++void ++import_export_tinfo (tree decl, tree type, bool is_in_library) ++{ ++ if (DECL_INTERFACE_KNOWN (decl)) ++ return; ++ ++ if (IS_AGGR_TYPE (type)) ++ import_export_class (type); ++ ++ if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type) ++ && TYPE_POLYMORPHIC_P (type) ++ /* If -fno-rtti, we're not necessarily emitting this stuff with ++ the class, so go ahead and emit it now. This can happen when ++ a class is used in exception handling. */ ++ && flag_rtti) ++ { ++ DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type); ++ DECL_COMDAT (decl) = 0; ++ } ++ else ++ { ++ DECL_NOT_REALLY_EXTERN (decl) = 1; ++ DECL_COMDAT (decl) = 1; ++ } ++ ++ /* Now override some cases. */ ++ if (flag_weak) ++ DECL_COMDAT (decl) = 1; ++ else if (is_in_library) ++ DECL_COMDAT (decl) = 0; ++ ++ DECL_INTERFACE_KNOWN (decl) = 1; ++} ++ ++/* Return an expression that performs the destruction of DECL, which ++ must be a VAR_DECL whose type has a non-trivial destructor, or is ++ an array whose (innermost) elements have a non-trivial destructor. */ ++ ++tree ++build_cleanup (tree decl) ++{ ++ tree temp; ++ tree type = TREE_TYPE (decl); ++ ++ /* This function should only be called for declarations that really ++ require cleanups. */ ++ my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106); ++ ++ /* Treat all objects with destructors as used; the destructor may do ++ something substantive. */ ++ mark_used (decl); ++ ++ if (TREE_CODE (type) == ARRAY_TYPE) ++ temp = decl; ++ else ++ { ++ cxx_mark_addressable (decl); ++ temp = build1 (ADDR_EXPR, build_pointer_type (type), decl); ++ } ++ temp = build_delete (TREE_TYPE (temp), temp, ++ sfk_complete_destructor, ++ LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0); ++ return temp; ++} ++ ++/* Returns the initialization guard variable for the variable DECL, ++ which has static storage duration. */ ++ ++tree ++get_guard (tree decl) ++{ ++ tree sname; ++ tree guard; ++ ++ sname = mangle_guard_variable (decl); ++ guard = IDENTIFIER_GLOBAL_VALUE (sname); ++ if (! guard) ++ { ++ tree guard_type; ++ ++ /* We use a type that is big enough to contain a mutex as well ++ as an integer counter. */ ++ guard_type = long_long_integer_type_node; ++ guard = build_decl (VAR_DECL, sname, guard_type); ++ ++ /* The guard should have the same linkage as what it guards. */ ++ TREE_PUBLIC (guard) = TREE_PUBLIC (decl); ++ TREE_STATIC (guard) = TREE_STATIC (decl); ++ DECL_COMMON (guard) = DECL_COMMON (decl); ++ DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl); ++ if (TREE_PUBLIC (decl)) ++ DECL_WEAK (guard) = DECL_WEAK (decl); ++ ++ DECL_ARTIFICIAL (guard) = 1; ++ TREE_USED (guard) = 1; ++ pushdecl_top_level_and_finish (guard, NULL_TREE); ++ } ++ return guard; ++} ++ ++/* Return those bits of the GUARD variable that should be set when the ++ guarded entity is actually initialized. */ ++ ++static tree ++get_guard_bits (tree guard) ++{ ++ /* We only set the first byte of the guard, in order to leave room ++ for a mutex in the high-order bits. */ ++ guard = build1 (ADDR_EXPR, ++ build_pointer_type (TREE_TYPE (guard)), ++ guard); ++ guard = build1 (NOP_EXPR, ++ build_pointer_type (char_type_node), ++ guard); ++ guard = build1 (INDIRECT_REF, char_type_node, guard); ++ ++ return guard; ++} ++ ++/* Return an expression which determines whether or not the GUARD ++ variable has already been initialized. */ ++ ++tree ++get_guard_cond (tree guard) ++{ ++ tree guard_value; ++ ++ /* Check to see if the GUARD is zero. */ ++ guard = get_guard_bits (guard); ++ guard_value = integer_zero_node; ++ if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) ++ guard_value = convert (TREE_TYPE (guard), guard_value); ++ return cp_build_binary_op (EQ_EXPR, guard, guard_value); ++} ++ ++/* Return an expression which sets the GUARD variable, indicating that ++ the variable being guarded has been initialized. */ ++ ++tree ++set_guard (tree guard) ++{ ++ tree guard_init; ++ ++ /* Set the GUARD to one. */ ++ guard = get_guard_bits (guard); ++ guard_init = integer_one_node; ++ if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard))) ++ guard_init = convert (TREE_TYPE (guard), guard_init); ++ return build_modify_expr (guard, NOP_EXPR, guard_init); ++} ++ ++/* Start the process of running a particular set of global constructors ++ or destructors. Subroutine of do_[cd]tors. */ ++ ++static tree ++start_objects (int method_type, int initp) ++{ ++ tree fnname; ++ tree body; ++ char type[10]; ++ ++ /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */ ++ ++ if (initp != DEFAULT_INIT_PRIORITY) ++ { ++ char joiner; ++ ++#ifdef JOINER ++ joiner = JOINER; ++#else ++ joiner = '_'; ++#endif ++ ++ sprintf (type, "%c%c%.5u", method_type, joiner, initp); ++ } ++ else ++ sprintf (type, "%c", method_type); ++ ++ fnname = get_file_function_name_long (type); ++ ++ start_function (void_list_node, ++ make_call_declarator (fnname, void_list_node, NULL_TREE, ++ NULL_TREE), ++ NULL_TREE, SF_DEFAULT); ++ ++ /* It can be a static function as long as collect2 does not have ++ to scan the object file to find its ctor/dtor routine. */ ++ TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors; ++ ++ /* Mark this declaration as used to avoid spurious warnings. */ ++ TREE_USED (current_function_decl) = 1; ++ ++ /* Mark this function as a global constructor or destructor. */ ++ if (method_type == 'I') ++ DECL_GLOBAL_CTOR_P (current_function_decl) = 1; ++ else ++ DECL_GLOBAL_DTOR_P (current_function_decl) = 1; ++ DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1; ++ ++ body = begin_compound_stmt (/*has_no_scope=*/false); ++ ++ /* We cannot allow these functions to be elided, even if they do not ++ have external linkage. And, there's no point in deferring ++ compilation of thes functions; they're all going to have to be ++ out anyhow. */ ++ current_function_cannot_inline ++ = "static constructors and destructors cannot be inlined"; ++ ++ return body; ++} ++ ++/* Finish the process of running a particular set of global constructors ++ or destructors. Subroutine of do_[cd]tors. */ ++ ++static void ++finish_objects (int method_type, int initp, tree body) ++{ ++ tree fn; ++ ++ /* Finish up. */ ++ finish_compound_stmt (body); ++ fn = finish_function (0); ++ expand_or_defer_fn (fn); ++ ++ /* When only doing semantic analysis, and no RTL generation, we ++ can't call functions that directly emit assembly code; there is ++ no assembly file in which to put the code. */ ++ if (flag_syntax_only) ++ return; ++ ++ if (targetm.have_ctors_dtors) ++ { ++ rtx fnsym = XEXP (DECL_RTL (fn), 0); ++ if (method_type == 'I') ++ (* targetm.asm_out.constructor) (fnsym, initp); ++ else ++ (* targetm.asm_out.destructor) (fnsym, initp); ++ } ++} ++ ++/* The names of the parameters to the function created to handle ++ initializations and destructions for objects with static storage ++ duration. */ ++#define INITIALIZE_P_IDENTIFIER "__initialize_p" ++#define PRIORITY_IDENTIFIER "__priority" ++ ++/* The name of the function we create to handle initializations and ++ destructions for objects with static storage duration. */ ++#define SSDF_IDENTIFIER "__static_initialization_and_destruction" ++ ++/* The declaration for the __INITIALIZE_P argument. */ ++static GTY(()) tree initialize_p_decl; ++ ++/* The declaration for the __PRIORITY argument. */ ++static GTY(()) tree priority_decl; ++ ++/* The declaration for the static storage duration function. */ ++static GTY(()) tree ssdf_decl; ++ ++/* All the static storage duration functions created in this ++ translation unit. */ ++static GTY(()) varray_type ssdf_decls; ++ ++/* A map from priority levels to information about that priority ++ level. There may be many such levels, so efficient lookup is ++ important. */ ++static splay_tree priority_info_map; ++ ++/* Begins the generation of the function that will handle all ++ initialization and destruction of objects with static storage ++ duration. The function generated takes two parameters of type ++ `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is ++ nonzero, it performs initializations. Otherwise, it performs ++ destructions. It only performs those initializations or ++ destructions with the indicated __PRIORITY. The generated function ++ returns no value. ++ ++ It is assumed that this function will only be called once per ++ translation unit. */ ++ ++static tree ++start_static_storage_duration_function (unsigned count) ++{ ++ tree parm_types; ++ tree type; ++ tree body; ++ char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32]; ++ ++ /* Create the identifier for this function. It will be of the form ++ SSDF_IDENTIFIER_. */ ++ sprintf (id, "%s_%u", SSDF_IDENTIFIER, count); ++ ++ /* Create the parameters. */ ++ parm_types = void_list_node; ++ parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types); ++ parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types); ++ type = build_function_type (void_type_node, parm_types); ++ ++ /* Create the FUNCTION_DECL itself. */ ++ ssdf_decl = build_lang_decl (FUNCTION_DECL, ++ get_identifier (id), ++ type); ++ TREE_PUBLIC (ssdf_decl) = 0; ++ DECL_ARTIFICIAL (ssdf_decl) = 1; ++ ++ /* Put this function in the list of functions to be called from the ++ static constructors and destructors. */ ++ if (!ssdf_decls) ++ { ++ VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls"); ++ ++ /* Take this opportunity to initialize the map from priority ++ numbers to information about that priority level. */ ++ priority_info_map = splay_tree_new (splay_tree_compare_ints, ++ /*delete_key_fn=*/0, ++ /*delete_value_fn=*/ ++ (splay_tree_delete_value_fn) &free); ++ ++ /* We always need to generate functions for the ++ DEFAULT_INIT_PRIORITY so enter it now. That way when we walk ++ priorities later, we'll be sure to find the ++ DEFAULT_INIT_PRIORITY. */ ++ get_priority_info (DEFAULT_INIT_PRIORITY); ++ } ++ ++ VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl); ++ ++ /* Create the argument list. */ ++ initialize_p_decl = cp_build_parm_decl ++ (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node); ++ DECL_CONTEXT (initialize_p_decl) = ssdf_decl; ++ TREE_USED (initialize_p_decl) = 1; ++ priority_decl = cp_build_parm_decl ++ (get_identifier (PRIORITY_IDENTIFIER), integer_type_node); ++ DECL_CONTEXT (priority_decl) = ssdf_decl; ++ TREE_USED (priority_decl) = 1; ++ ++ TREE_CHAIN (initialize_p_decl) = priority_decl; ++ DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl; ++ ++ /* Put the function in the global scope. */ ++ pushdecl (ssdf_decl); ++ ++ /* Start the function itself. This is equivalent to declaring the ++ function as: ++ ++ static void __ssdf (int __initialize_p, init __priority_p); ++ ++ It is static because we only need to call this function from the ++ various constructor and destructor functions for this module. */ ++ start_function (/*specs=*/NULL_TREE, ++ ssdf_decl, ++ /*attrs=*/NULL_TREE, ++ SF_PRE_PARSED); ++ ++ /* Set up the scope of the outermost block in the function. */ ++ body = begin_compound_stmt (/*has_no_scope=*/false); ++ ++ /* This function must not be deferred because we are depending on ++ its compilation to tell us what is TREE_SYMBOL_REFERENCED. */ ++ current_function_cannot_inline ++ = "static storage duration functions cannot be inlined"; ++ ++ return body; ++} ++ ++/* Finish the generation of the function which performs initialization ++ and destruction of objects with static storage duration. After ++ this point, no more such objects can be created. */ ++ ++static void ++finish_static_storage_duration_function (tree body) ++{ ++ /* Close out the function. */ ++ finish_compound_stmt (body); ++ expand_or_defer_fn (finish_function (0)); ++} ++ ++/* Return the information about the indicated PRIORITY level. If no ++ code to handle this level has yet been generated, generate the ++ appropriate prologue. */ ++ ++static priority_info ++get_priority_info (int priority) ++{ ++ priority_info pi; ++ splay_tree_node n; ++ ++ n = splay_tree_lookup (priority_info_map, ++ (splay_tree_key) priority); ++ if (!n) ++ { ++ /* Create a new priority information structure, and insert it ++ into the map. */ ++ pi = xmalloc (sizeof (struct priority_info_s)); ++ pi->initializations_p = 0; ++ pi->destructions_p = 0; ++ splay_tree_insert (priority_info_map, ++ (splay_tree_key) priority, ++ (splay_tree_value) pi); ++ } ++ else ++ pi = (priority_info) n->value; ++ ++ return pi; ++} ++ ++/* Set up to handle the initialization or destruction of DECL. If ++ INITP is nonzero, we are initializing the variable. Otherwise, we ++ are destroying it. */ ++ ++static tree ++start_static_initialization_or_destruction (tree decl, int initp) ++{ ++ tree guard_if_stmt = NULL_TREE; ++ int priority; ++ tree cond; ++ tree guard; ++ tree init_cond; ++ priority_info pi; ++ ++ /* Figure out the priority for this declaration. */ ++ priority = DECL_INIT_PRIORITY (decl); ++ if (!priority) ++ priority = DEFAULT_INIT_PRIORITY; ++ ++ /* Remember that we had an initialization or finalization at this ++ priority. */ ++ pi = get_priority_info (priority); ++ if (initp) ++ pi->initializations_p = 1; ++ else ++ pi->destructions_p = 1; ++ ++ /* Trick the compiler into thinking we are at the file and line ++ where DECL was declared so that error-messages make sense, and so ++ that the debugger will show somewhat sensible file and line ++ information. */ ++ input_location = DECL_SOURCE_LOCATION (decl); ++ ++ /* Because of: ++ ++ [class.access.spec] ++ ++ Access control for implicit calls to the constructors, ++ the conversion functions, or the destructor called to ++ create and destroy a static data member is performed as ++ if these calls appeared in the scope of the member's ++ class. ++ ++ we pretend we are in a static member function of the class of ++ which the DECL is a member. */ ++ if (member_p (decl)) ++ { ++ DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl); ++ DECL_STATIC_FUNCTION_P (current_function_decl) = 1; ++ } ++ ++ /* Conditionalize this initialization on being in the right priority ++ and being initializing/finalizing appropriately. */ ++ guard_if_stmt = begin_if_stmt (); ++ cond = cp_build_binary_op (EQ_EXPR, ++ priority_decl, ++ build_int_2 (priority, 0)); ++ init_cond = initp ? integer_one_node : integer_zero_node; ++ init_cond = cp_build_binary_op (EQ_EXPR, ++ initialize_p_decl, ++ init_cond); ++ cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond); ++ ++ /* Assume we don't need a guard. */ ++ guard = NULL_TREE; ++ /* We need a guard if this is an object with external linkage that ++ might be initialized in more than one place. (For example, a ++ static data member of a template, when the data member requires ++ construction.) */ ++ if (TREE_PUBLIC (decl) && (DECL_COMMON (decl) ++ || DECL_ONE_ONLY (decl) ++ || DECL_WEAK (decl))) ++ { ++ tree guard_cond; ++ ++ guard = get_guard (decl); ++ ++ /* When using __cxa_atexit, we just check the GUARD as we would ++ for a local static. */ ++ if (flag_use_cxa_atexit) ++ { ++ /* When using __cxa_atexit, we never try to destroy ++ anything from a static destructor. */ ++ my_friendly_assert (initp, 20000629); ++ guard_cond = get_guard_cond (guard); ++ } ++ /* If we don't have __cxa_atexit, then we will be running ++ destructors from .fini sections, or their equivalents. So, ++ we need to know how many times we've tried to initialize this ++ object. We do initializations only if the GUARD is zero, ++ i.e., if we are the first to initialize the variable. We do ++ destructions only if the GUARD is one, i.e., if we are the ++ last to destroy the variable. */ ++ else if (initp) ++ guard_cond ++ = cp_build_binary_op (EQ_EXPR, ++ build_unary_op (PREINCREMENT_EXPR, ++ guard, ++ /*noconvert=*/1), ++ integer_one_node); ++ else ++ guard_cond ++ = cp_build_binary_op (EQ_EXPR, ++ build_unary_op (PREDECREMENT_EXPR, ++ guard, ++ /*noconvert=*/1), ++ integer_zero_node); ++ ++ cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond); ++ } ++ ++ finish_if_stmt_cond (cond, guard_if_stmt); ++ ++ /* If we're using __cxa_atexit, we have not already set the GUARD, ++ so we must do so now. */ ++ if (guard && initp && flag_use_cxa_atexit) ++ finish_expr_stmt (set_guard (guard)); ++ ++ return guard_if_stmt; ++} ++ ++/* We've just finished generating code to do an initialization or ++ finalization. GUARD_IF_STMT is the if-statement we used to guard ++ the initialization. */ ++ ++static void ++finish_static_initialization_or_destruction (tree guard_if_stmt) ++{ ++ finish_then_clause (guard_if_stmt); ++ finish_if_stmt (); ++ ++ /* Now that we're done with DECL we don't need to pretend to be a ++ member of its class any longer. */ ++ DECL_CONTEXT (current_function_decl) = NULL_TREE; ++ DECL_STATIC_FUNCTION_P (current_function_decl) = 0; ++} ++ ++/* Generate code to do the initialization of DECL, a VAR_DECL with ++ static storage duration. The initialization is INIT. */ ++ ++static void ++do_static_initialization (tree decl, tree init) ++{ ++ tree guard_if_stmt; ++ ++ /* Set up for the initialization. */ ++ guard_if_stmt ++ = start_static_initialization_or_destruction (decl, ++ /*initp=*/1); ++ ++ /* Perform the initialization. */ ++ if (init) ++ finish_expr_stmt (init); ++ ++ /* If we're using __cxa_atexit, register a a function that calls the ++ destructor for the object. */ ++ if (flag_use_cxa_atexit) ++ register_dtor_fn (decl); ++ ++ /* Finsh up. */ ++ finish_static_initialization_or_destruction (guard_if_stmt); ++} ++ ++/* Generate code to do the static destruction of DECL. If DECL may be ++ initialized more than once in different object files, GUARD is the ++ guard variable to check. PRIORITY is the priority for the ++ destruction. */ ++ ++static void ++do_static_destruction (tree decl) ++{ ++ tree guard_if_stmt; ++ ++ /* If we're using __cxa_atexit, then destructors are registered ++ immediately after objects are initialized. */ ++ my_friendly_assert (!flag_use_cxa_atexit, 20000121); ++ ++ /* If we don't need a destructor, there's nothing to do. */ ++ if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) ++ return; ++ ++ /* Actually do the destruction. */ ++ guard_if_stmt = start_static_initialization_or_destruction (decl, ++ /*initp=*/0); ++ finish_expr_stmt (build_cleanup (decl)); ++ finish_static_initialization_or_destruction (guard_if_stmt); ++} ++ ++/* VARS is a list of variables with static storage duration which may ++ need initialization and/or finalization. Remove those variables ++ that don't really need to be initialized or finalized, and return ++ the resulting list. The order in which the variables appear in ++ VARS is in reverse order of the order in which they should actually ++ be initialized. The list we return is in the unreversed order; ++ i.e., the first variable should be initialized first. */ ++ ++static tree ++prune_vars_needing_no_initialization (tree *vars) ++{ ++ tree *var = vars; ++ tree result = NULL_TREE; ++ ++ while (*var) ++ { ++ tree t = *var; ++ tree decl = TREE_VALUE (t); ++ tree init = TREE_PURPOSE (t); ++ ++ /* Deal gracefully with error. */ ++ if (decl == error_mark_node) ++ { ++ var = &TREE_CHAIN (t); ++ continue; ++ } ++ ++ /* The only things that can be initialized are variables. */ ++ my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420); ++ ++ /* If this object is not defined, we don't need to do anything ++ here. */ ++ if (DECL_EXTERNAL (decl)) ++ { ++ var = &TREE_CHAIN (t); ++ continue; ++ } ++ ++ /* Also, if the initializer already contains errors, we can bail ++ out now. */ ++ if (init && TREE_CODE (init) == TREE_LIST ++ && value_member (error_mark_node, init)) ++ { ++ var = &TREE_CHAIN (t); ++ continue; ++ } ++ ++ /* This variable is going to need initialization and/or ++ finalization, so we add it to the list. */ ++ *var = TREE_CHAIN (t); ++ TREE_CHAIN (t) = result; ++ result = t; ++ } ++ ++ return result; ++} ++ ++/* Make sure we have told the back end about all the variables in ++ VARS. */ ++ ++static void ++write_out_vars (tree vars) ++{ ++ tree v; ++ ++ for (v = vars; v; v = TREE_CHAIN (v)) ++ if (!var_finalized_p (TREE_VALUE (v))) ++ rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1); ++} ++ ++/* Generate a static constructor (if CONSTRUCTOR_P) or destructor ++ (otherwise) that will initialize all gobal objects with static ++ storage duration having the indicated PRIORITY. */ ++ ++static void ++generate_ctor_or_dtor_function (bool constructor_p, int priority, ++ location_t *locus) ++{ ++ char function_key; ++ tree arguments; ++ tree fndecl; ++ tree body; ++ size_t i; ++ ++ input_location = *locus; ++ locus->line++; ++ ++ /* We use `I' to indicate initialization and `D' to indicate ++ destruction. */ ++ function_key = constructor_p ? 'I' : 'D'; ++ ++ /* We emit the function lazily, to avoid generating empty ++ global constructors and destructors. */ ++ body = NULL_TREE; ++ ++ /* Call the static storage duration function with appropriate ++ arguments. */ ++ if (ssdf_decls) ++ for (i = 0; i < ssdf_decls->elements_used; ++i) ++ { ++ fndecl = VARRAY_TREE (ssdf_decls, i); ++ ++ /* Calls to pure or const functions will expand to nothing. */ ++ if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE))) ++ { ++ if (! body) ++ body = start_objects (function_key, priority); ++ ++ arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0), ++ NULL_TREE); ++ arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0), ++ arguments); ++ finish_expr_stmt (build_function_call (fndecl, arguments)); ++ } ++ } ++ ++ /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in ++ calls to any functions marked with attributes indicating that ++ they should be called at initialization- or destruction-time. */ ++ if (priority == DEFAULT_INIT_PRIORITY) ++ { ++ tree fns; ++ ++ for (fns = constructor_p ? static_ctors : static_dtors; ++ fns; ++ fns = TREE_CHAIN (fns)) ++ { ++ fndecl = TREE_VALUE (fns); ++ ++ /* Calls to pure/const functions will expand to nothing. */ ++ if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE))) ++ { ++ if (! body) ++ body = start_objects (function_key, priority); ++ finish_expr_stmt (build_function_call (fndecl, NULL_TREE)); ++ } ++ } ++ } ++ ++ /* Close out the function. */ ++ if (body) ++ finish_objects (function_key, priority, body); ++} ++ ++/* Generate constructor and destructor functions for the priority ++ indicated by N. */ ++ ++static int ++generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data) ++{ ++ location_t *locus = data; ++ int priority = (int) n->key; ++ priority_info pi = (priority_info) n->value; ++ ++ /* Generate the functions themselves, but only if they are really ++ needed. */ ++ if (pi->initializations_p ++ || (priority == DEFAULT_INIT_PRIORITY && static_ctors)) ++ generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus); ++ if (pi->destructions_p ++ || (priority == DEFAULT_INIT_PRIORITY && static_dtors)) ++ generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus); ++ ++ /* Keep iterating. */ ++ return 0; ++} ++ ++/* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark ++ decls referenced from frontend specific constructs; it will be called ++ only for language-specific tree nodes. ++ ++ Here we must deal with member pointers. */ ++ ++tree ++cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, ++ tree from ATTRIBUTE_UNUSED) ++{ ++ tree t = *tp; ++ ++ if (flag_unit_at_a_time) ++ switch (TREE_CODE (t)) ++ { ++ case PTRMEM_CST: ++ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) ++ cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t))); ++ break; ++ case BASELINK: ++ if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL) ++ cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t))); ++ break; ++ ++ default: ++ break; ++ } ++ ++ return NULL; ++} ++ ++/* This routine is called from the last rule in yyparse (). ++ Its job is to create all the code needed to initialize and ++ destroy the global aggregates. We do the destruction ++ first, since that way we only need to reverse the decls once. */ ++ ++void ++finish_file (void) ++{ ++ tree vars; ++ bool reconsider; ++ size_t i; ++ location_t locus; ++ unsigned ssdf_count = 0; ++ ++ locus = input_location; ++ at_eof = 1; ++ ++ /* Bad parse errors. Just forget about it. */ ++ if (! global_bindings_p () || current_class_type || decl_namespace_list) ++ return; ++ ++ if (pch_file) ++ c_common_write_pch (); ++ ++ /* Otherwise, GDB can get confused, because in only knows ++ about source for LINENO-1 lines. */ ++ input_line -= 1; ++ ++ interface_unknown = 1; ++ interface_only = 0; ++ ++ /* We now have to write out all the stuff we put off writing out. ++ These include: ++ ++ o Template specializations that we have not yet instantiated, ++ but which are needed. ++ o Initialization and destruction for non-local objects with ++ static storage duration. (Local objects with static storage ++ duration are initialized when their scope is first entered, ++ and are cleaned up via atexit.) ++ o Virtual function tables. ++ ++ All of these may cause others to be needed. For example, ++ instantiating one function may cause another to be needed, and ++ generating the initializer for an object may cause templates to be ++ instantiated, etc., etc. */ ++ ++ timevar_push (TV_VARCONST); ++ ++ emit_support_tinfos (); ++ ++ do ++ { ++ tree t; ++ size_t n_old, n_new; ++ ++ reconsider = false; ++ ++ /* If there are templates that we've put off instantiating, do ++ them now. */ ++ instantiate_pending_templates (); ++ ggc_collect (); ++ ++ /* Write out virtual tables as required. Note that writing out ++ the virtual table for a template class may cause the ++ instantiation of members of that class. If we write out ++ vtables then we remove the class from our list so we don't ++ have to look at it again. */ ++ ++ while (keyed_classes != NULL_TREE ++ && maybe_emit_vtables (TREE_VALUE (keyed_classes))) ++ { ++ reconsider = true; ++ keyed_classes = TREE_CHAIN (keyed_classes); ++ } ++ ++ t = keyed_classes; ++ if (t != NULL_TREE) ++ { ++ tree next = TREE_CHAIN (t); ++ ++ while (next) ++ { ++ if (maybe_emit_vtables (TREE_VALUE (next))) ++ { ++ reconsider = true; ++ TREE_CHAIN (t) = TREE_CHAIN (next); ++ } ++ else ++ t = next; ++ ++ next = TREE_CHAIN (t); ++ } ++ } ++ ++ /* Write out needed type info variables. We have to be careful ++ looping through unemitted decls, because emit_tinfo_decl may ++ cause other variables to be needed. We stick new elements ++ (and old elements that we may need to reconsider) at the end ++ of the array, then shift them back to the beginning once we're ++ done. */ ++ ++ n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls); ++ for (i = 0; i < n_old; ++i) ++ { ++ tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i); ++ if (emit_tinfo_decl (tinfo_decl)) ++ reconsider = true; ++ else ++ VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl); ++ } ++ ++ /* The only elements we want to keep are the new ones. Copy ++ them to the beginning of the array, then get rid of the ++ leftovers. */ ++ n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old; ++ if (n_new) ++ memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0), ++ &VARRAY_TREE (unemitted_tinfo_decls, n_old), ++ n_new * sizeof (tree)); ++ memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new), ++ 0, n_old * sizeof (tree)); ++ VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new; ++ ++ /* The list of objects with static storage duration is built up ++ in reverse order. We clear STATIC_AGGREGATES so that any new ++ aggregates added during the initialization of these will be ++ initialized in the correct order when we next come around the ++ loop. */ ++ vars = prune_vars_needing_no_initialization (&static_aggregates); ++ ++ if (vars) ++ { ++ tree v; ++ ++ /* We need to start a new initialization function each time ++ through the loop. That's because we need to know which ++ vtables have been referenced, and TREE_SYMBOL_REFERENCED ++ isn't computed until a function is finished, and written ++ out. That's a deficiency in the back-end. When this is ++ fixed, these initialization functions could all become ++ inline, with resulting performance improvements. */ ++ tree ssdf_body; ++ ++ /* Set the line and file, so that it is obviously not from ++ the source file. */ ++ input_location = locus; ++ ssdf_body = start_static_storage_duration_function (ssdf_count); ++ ++ /* Make sure the back end knows about all the variables. */ ++ write_out_vars (vars); ++ ++ /* First generate code to do all the initializations. */ ++ for (v = vars; v; v = TREE_CHAIN (v)) ++ do_static_initialization (TREE_VALUE (v), ++ TREE_PURPOSE (v)); ++ ++ /* Then, generate code to do all the destructions. Do these ++ in reverse order so that the most recently constructed ++ variable is the first destroyed. If we're using ++ __cxa_atexit, then we don't need to do this; functions ++ were registered at initialization time to destroy the ++ local statics. */ ++ if (!flag_use_cxa_atexit) ++ { ++ vars = nreverse (vars); ++ for (v = vars; v; v = TREE_CHAIN (v)) ++ do_static_destruction (TREE_VALUE (v)); ++ } ++ else ++ vars = NULL_TREE; ++ ++ /* Finish up the static storage duration function for this ++ round. */ ++ input_location = locus; ++ finish_static_storage_duration_function (ssdf_body); ++ ++ /* All those initializations and finalizations might cause ++ us to need more inline functions, more template ++ instantiations, etc. */ ++ reconsider = true; ++ ssdf_count++; ++ locus.line++; ++ } ++ ++ for (i = 0; i < deferred_fns_used; ++i) ++ { ++ tree decl = VARRAY_TREE (deferred_fns, i); ++ ++ /* Does it need synthesizing? */ ++ if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl) ++ && TREE_USED (decl) ++ && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl))) ++ { ++ /* Even though we're already at the top-level, we push ++ there again. That way, when we pop back a few lines ++ hence, all of our state is restored. Otherwise, ++ finish_function doesn't clean things up, and we end ++ up with CURRENT_FUNCTION_DECL set. */ ++ push_to_top_level (); ++ synthesize_method (decl); ++ pop_from_top_level (); ++ reconsider = true; ++ } ++ ++ /* If the function has no body, avoid calling ++ import_export_decl. On a system without weak symbols, ++ calling import_export_decl will make an inline template ++ instantiation "static", which will result in errors about ++ the use of undefined functions if there is no body for ++ the function. */ ++ if (!DECL_SAVED_TREE (decl)) ++ continue; ++ ++ import_export_decl (decl); ++ ++ /* We lie to the back-end, pretending that some functions ++ are not defined when they really are. This keeps these ++ functions from being put out unnecessarily. But, we must ++ stop lying when the functions are referenced, or if they ++ are not comdat since they need to be put out now. This ++ is done in a separate for cycle, because if some deferred ++ function is contained in another deferred function later ++ in deferred_fns varray, rest_of_compilation would skip ++ this function and we really cannot expand the same ++ function twice. */ ++ if (DECL_NOT_REALLY_EXTERN (decl) ++ && DECL_INITIAL (decl) ++ && DECL_NEEDED_P (decl)) ++ DECL_EXTERNAL (decl) = 0; ++ ++ /* If we're going to need to write this function out, and ++ there's already a body for it, create RTL for it now. ++ (There might be no body if this is a method we haven't ++ gotten around to synthesizing yet.) */ ++ if (!DECL_EXTERNAL (decl) ++ && DECL_NEEDED_P (decl) ++ && DECL_SAVED_TREE (decl) ++ && !TREE_ASM_WRITTEN (decl) ++ && (!flag_unit_at_a_time ++ || !cgraph_node (decl)->local.finalized)) ++ { ++ /* We will output the function; no longer consider it in this ++ loop. */ ++ DECL_DEFER_OUTPUT (decl) = 0; ++ /* Generate RTL for this function now that we know we ++ need it. */ ++ expand_or_defer_fn (decl); ++ /* If we're compiling -fsyntax-only pretend that this ++ function has been written out so that we don't try to ++ expand it again. */ ++ if (flag_syntax_only) ++ TREE_ASM_WRITTEN (decl) = 1; ++ reconsider = true; ++ } ++ } ++ ++ if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0)) ++ reconsider = true; ++ ++ /* Static data members are just like namespace-scope globals. */ ++ for (i = 0; i < pending_statics_used; ++i) ++ { ++ tree decl = VARRAY_TREE (pending_statics, i); ++ if (var_finalized_p (decl)) ++ continue; ++ import_export_decl (decl); ++ if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl)) ++ DECL_EXTERNAL (decl) = 0; ++ } ++ if (pending_statics ++ && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0), ++ pending_statics_used)) ++ reconsider = true; ++ ++ if (cgraph_assemble_pending_functions ()) ++ reconsider = true; ++ } ++ while (reconsider); ++ ++ /* All used inline functions must have a definition at this point. */ ++ for (i = 0; i < deferred_fns_used; ++i) ++ { ++ tree decl = VARRAY_TREE (deferred_fns, i); ++ ++ if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl) ++ && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl) ++ /* An explicit instantiation can be used to specify ++ that the body is in another unit. It will have ++ already verified there was a definition. */ ++ || DECL_EXPLICIT_INSTANTIATION (decl))) ++ { ++ cp_warning_at ("inline function `%D' used but never defined", decl); ++ /* This symbol is effectively an "extern" declaration now. ++ This is not strictly necessary, but removes a duplicate ++ warning. */ ++ TREE_PUBLIC (decl) = 1; ++ } ++ ++ } ++ ++ /* We give C linkage to static constructors and destructors. */ ++ push_lang_context (lang_name_c); ++ ++ /* Generate initialization and destruction functions for all ++ priorities for which they are required. */ ++ if (priority_info_map) ++ splay_tree_foreach (priority_info_map, ++ generate_ctor_and_dtor_functions_for_priority, ++ /*data=*/&locus); ++ else ++ { ++ ++ if (static_ctors) ++ generate_ctor_or_dtor_function (/*constructor_p=*/true, ++ DEFAULT_INIT_PRIORITY, &locus); ++ if (static_dtors) ++ generate_ctor_or_dtor_function (/*constructor_p=*/false, ++ DEFAULT_INIT_PRIORITY, &locus); ++ } ++ ++ /* We're done with the splay-tree now. */ ++ if (priority_info_map) ++ splay_tree_delete (priority_info_map); ++ ++ /* We're done with static constructors, so we can go back to "C++" ++ linkage now. */ ++ pop_lang_context (); ++ ++ if (flag_unit_at_a_time) ++ { ++ cgraph_finalize_compilation_unit (); ++ cgraph_optimize (); ++ } ++ ++ /* Now, issue warnings about static, but not defined, functions, ++ etc., and emit debugging information. */ ++ walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider); ++ if (pending_statics) ++ check_global_declarations (&VARRAY_TREE (pending_statics, 0), ++ pending_statics_used); ++ ++ finish_repo (); ++ ++ /* The entire file is now complete. If requested, dump everything ++ to a file. */ ++ { ++ int flags; ++ FILE *stream = dump_begin (TDI_all, &flags); ++ ++ if (stream) ++ { ++ dump_node (global_namespace, flags & ~TDF_SLIM, stream); ++ dump_end (TDI_all, stream); ++ } ++ } ++ ++ timevar_pop (TV_VARCONST); ++ ++ if (flag_detailed_statistics) ++ { ++ dump_tree_statistics (); ++ dump_time_statistics (); ++ } ++ input_location = locus; ++} ++ ++/* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the ++ function to call in parse-tree form; it has not yet been ++ semantically analyzed. ARGS are the arguments to the function. ++ They have already been semantically analyzed. */ ++ ++tree ++build_offset_ref_call_from_tree (tree fn, tree args) ++{ ++ tree orig_fn; ++ tree orig_args; ++ tree expr; ++ tree object; ++ ++ orig_fn = fn; ++ orig_args = args; ++ object = TREE_OPERAND (fn, 0); ++ ++ if (processing_template_decl) ++ { ++ my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR ++ || TREE_CODE (fn) == MEMBER_REF, ++ 20030708); ++ if (type_dependent_expression_p (fn) ++ || any_type_dependent_arguments_p (args)) ++ return build_min_nt (CALL_EXPR, fn, args); ++ ++ /* Transform the arguments and add the implicit "this" ++ parameter. That must be done before the FN is transformed ++ because we depend on the form of FN. */ ++ args = build_non_dependent_args (args); ++ if (TREE_CODE (fn) == DOTSTAR_EXPR) ++ object = build_unary_op (ADDR_EXPR, object, 0); ++ object = build_non_dependent_expr (object); ++ args = tree_cons (NULL_TREE, object, args); ++ /* Now that the arguments are done, transform FN. */ ++ fn = build_non_dependent_expr (fn); ++ } ++ ++ /* A qualified name corresponding to a bound pointer-to-member is ++ represented as an OFFSET_REF: ++ ++ struct B { void g(); }; ++ void (B::*p)(); ++ void B::g() { (this->*p)(); } */ ++ if (TREE_CODE (fn) == OFFSET_REF) ++ { ++ tree object_addr = build_unary_op (ADDR_EXPR, object, 0); ++ fn = TREE_OPERAND (fn, 1); ++ fn = get_member_function_from_ptrfunc (&object_addr, fn); ++ args = tree_cons (NULL_TREE, object_addr, args); ++ } ++ ++ expr = build_function_call (fn, args); ++ if (processing_template_decl && expr != error_mark_node) ++ return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args); ++ return expr; ++} ++ ++ ++void ++check_default_args (tree x) ++{ ++ tree arg = TYPE_ARG_TYPES (TREE_TYPE (x)); ++ bool saw_def = false; ++ int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE); ++ for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i) ++ { ++ if (TREE_PURPOSE (arg)) ++ saw_def = true; ++ else if (saw_def) ++ { ++ cp_error_at ("default argument missing for parameter %P of `%+#D'", ++ i, x); ++ break; ++ } ++ } ++} ++ ++void ++mark_used (tree decl) ++{ ++ TREE_USED (decl) = 1; ++ if (processing_template_decl || skip_evaluation) ++ return; ++ ++ if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl) ++ && !TREE_ASM_WRITTEN (decl)) ++ /* Remember it, so we can check it was defined. */ ++ defer_fn (decl); ++ ++ assemble_external (decl); ++ ++ /* Is it a synthesized method that needs to be synthesized? */ ++ if (TREE_CODE (decl) == FUNCTION_DECL ++ && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl) ++ && DECL_ARTIFICIAL (decl) ++ && !DECL_THUNK_P (decl) ++ && ! DECL_INITIAL (decl) ++ /* Kludge: don't synthesize for default args. */ ++ && current_function_decl) ++ { ++ synthesize_method (decl); ++ /* If we've already synthesized the method we don't need to ++ instantiate it, so we can return right away. */ ++ return; ++ } ++ ++ /* If this is a function or variable that is an instance of some ++ template, we now know that we will need to actually do the ++ instantiation. We check that DECL is not an explicit ++ instantiation because that is not checked in instantiate_decl. */ ++ if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL) ++ && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl) ++ && (!DECL_EXPLICIT_INSTANTIATION (decl) ++ || (TREE_CODE (decl) == FUNCTION_DECL ++ && DECL_INLINE (DECL_TEMPLATE_RESULT ++ (template_for_substitution (decl)))))) ++ { ++ bool defer; ++ ++ /* Normally, we put off instantiating functions in order to ++ improve compile times. Maintaining a stack of active ++ functions is expensive, and the inliner knows to ++ instantiate any functions it might need. ++ ++ However, if instantiating this function might help us mark ++ the current function TREE_NOTHROW, we go ahead and ++ instantiate it now. ++ ++ This is not needed for unit-at-a-time since we reorder the functions ++ in topological order anyway. ++ */ ++ defer = (!flag_exceptions ++ || flag_unit_at_a_time ++ || !optimize ++ || TREE_CODE (decl) != FUNCTION_DECL ++ /* If the called function can't throw, we don't need to ++ generate its body to find that out. */ ++ || TREE_NOTHROW (decl) ++ || !cfun ++ || !current_function_decl ++ /* If we already know the current function can't throw, ++ then we don't need to work hard to prove it. */ ++ || TREE_NOTHROW (current_function_decl) ++ /* If we already know that the current function *can* ++ throw, there's no point in gathering more ++ information. */ ++ || cp_function_chain->can_throw); ++ ++ instantiate_decl (decl, defer); ++ } ++} ++ ++#include "gt-cp-decl2.h" +diff -NBaur gcc-3.4.4/gcc/cp/dump.c gcc-3.4.4-new/gcc/cp/dump.c +--- gcc-3.4.4/gcc/cp/dump.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/dump.c Mon Dec 8 20:29:15 2003 +@@ -0,0 +1,420 @@ ++/* Tree-dumping functionality for intermediate representation. ++ Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc. ++ Written by Mark Mitchell ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "cp-tree.h" ++#include "tree-dump.h" ++ ++static void dump_access (dump_info_p, tree); ++ ++static void dump_op (dump_info_p, tree); ++ ++/* Dump a representation of the accessibility information associated ++ with T. */ ++ ++static void ++dump_access (dump_info_p di, tree t) ++{ ++ if (TREE_PROTECTED(t)) ++ dump_string (di, "protected"); ++ else if (TREE_PRIVATE(t)) ++ dump_string (di, "private"); ++ else ++ dump_string (di, "public"); ++} ++ ++/* Dump a representation of the specific operator for an overloaded ++ operator associated with node t. */ ++ ++static void ++dump_op (dump_info_p di, tree t) ++{ ++ switch (DECL_OVERLOADED_OPERATOR_P (t)) { ++ case NEW_EXPR: ++ dump_string (di, "new"); ++ break; ++ case VEC_NEW_EXPR: ++ dump_string (di, "vecnew"); ++ break; ++ case DELETE_EXPR: ++ dump_string (di, "delete"); ++ break; ++ case VEC_DELETE_EXPR: ++ dump_string (di, "vecdelete"); ++ break; ++ case CONVERT_EXPR: ++ dump_string (di, "pos"); ++ break; ++ case NEGATE_EXPR: ++ dump_string (di, "neg"); ++ break; ++ case ADDR_EXPR: ++ dump_string (di, "addr"); ++ break; ++ case INDIRECT_REF: ++ dump_string(di, "deref"); ++ break; ++ case BIT_NOT_EXPR: ++ dump_string(di, "not"); ++ break; ++ case TRUTH_NOT_EXPR: ++ dump_string(di, "lnot"); ++ break; ++ case PREINCREMENT_EXPR: ++ dump_string(di, "preinc"); ++ break; ++ case PREDECREMENT_EXPR: ++ dump_string(di, "predec"); ++ break; ++ case PLUS_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "plusassign"); ++ else ++ dump_string(di, "plus"); ++ break; ++ case MINUS_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "minusassign"); ++ else ++ dump_string(di, "minus"); ++ break; ++ case MULT_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "multassign"); ++ else ++ dump_string (di, "mult"); ++ break; ++ case TRUNC_DIV_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "divassign"); ++ else ++ dump_string (di, "div"); ++ break; ++ case TRUNC_MOD_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "modassign"); ++ else ++ dump_string (di, "mod"); ++ break; ++ case BIT_AND_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "andassign"); ++ else ++ dump_string (di, "and"); ++ break; ++ case BIT_IOR_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "orassign"); ++ else ++ dump_string (di, "or"); ++ break; ++ case BIT_XOR_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "xorassign"); ++ else ++ dump_string (di, "xor"); ++ break; ++ case LSHIFT_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "lshiftassign"); ++ else ++ dump_string (di, "lshift"); ++ break; ++ case RSHIFT_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "rshiftassign"); ++ else ++ dump_string (di, "rshift"); ++ break; ++ case EQ_EXPR: ++ dump_string (di, "eq"); ++ break; ++ case NE_EXPR: ++ dump_string (di, "ne"); ++ break; ++ case LT_EXPR: ++ dump_string (di, "lt"); ++ break; ++ case GT_EXPR: ++ dump_string (di, "gt"); ++ break; ++ case LE_EXPR: ++ dump_string (di, "le"); ++ break; ++ case GE_EXPR: ++ dump_string (di, "ge"); ++ break; ++ case TRUTH_ANDIF_EXPR: ++ dump_string (di, "land"); ++ break; ++ case TRUTH_ORIF_EXPR: ++ dump_string (di, "lor"); ++ break; ++ case COMPOUND_EXPR: ++ dump_string (di, "compound"); ++ break; ++ case MEMBER_REF: ++ dump_string (di, "memref"); ++ break; ++ case COMPONENT_REF: ++ dump_string (di, "ref"); ++ break; ++ case ARRAY_REF: ++ dump_string (di, "subs"); ++ break; ++ case POSTINCREMENT_EXPR: ++ dump_string (di, "postinc"); ++ break; ++ case POSTDECREMENT_EXPR: ++ dump_string (di, "postdec"); ++ break; ++ case CALL_EXPR: ++ dump_string (di, "call"); ++ break; ++ case NOP_EXPR: ++ if (DECL_ASSIGNMENT_OPERATOR_P (t)) ++ dump_string (di, "assign"); ++ break; ++ default: ++ break; ++ } ++} ++ ++bool ++cp_dump_tree (void* dump_info, tree t) ++{ ++ enum tree_code code; ++ dump_info_p di = (dump_info_p) dump_info; ++ ++ /* Figure out what kind of node this is. */ ++ code = TREE_CODE (t); ++ ++ if (DECL_P (t)) ++ { ++ if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus) ++ dump_string (di, language_to_string (DECL_LANGUAGE (t))); ++ } ++ ++ switch (code) ++ { ++ case IDENTIFIER_NODE: ++ if (IDENTIFIER_OPNAME_P (t)) ++ { ++ dump_string (di, "operator"); ++ return true; ++ } ++ else if (IDENTIFIER_TYPENAME_P (t)) ++ { ++ dump_child ("tynm", TREE_TYPE (t)); ++ return true; ++ } ++ break; ++ ++ case OFFSET_TYPE: ++ dump_string (di, "ptrmem"); ++ dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); ++ dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); ++ return true; ++ ++ case RECORD_TYPE: ++ if (TYPE_PTRMEMFUNC_P (t)) ++ { ++ dump_string (di, "ptrmem"); ++ dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); ++ dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); ++ return true; ++ } ++ /* Fall through. */ ++ ++ case UNION_TYPE: ++ /* Is it a type used as a base? */ ++ if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t) ++ && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t) ++ { ++ dump_child ("bfld", TYPE_CONTEXT (t)); ++ return true; ++ } ++ ++ if (! IS_AGGR_TYPE (t)) ++ break; ++ ++ dump_child ("vfld", TYPE_VFIELD (t)); ++ if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t)) ++ dump_string(di, "spec"); ++ ++ if (!dump_flag (di, TDF_SLIM, t)) ++ { ++ int i; ++ ++ for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i) ++ { ++ tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i); ++ dump_child ("base", BINFO_TYPE (base_binfo)); ++ if (TREE_VIA_VIRTUAL (base_binfo)) ++ dump_string (di, "virtual"); ++ dump_access (di, base_binfo); ++ } ++ } ++ break; ++ ++ case FIELD_DECL: ++ dump_access (di, t); ++ if (DECL_MUTABLE_P (t)) ++ dump_string(di, "mutable"); ++ break; ++ ++ case VAR_DECL: ++ if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE) ++ dump_access (di, t); ++ if (TREE_STATIC (t) && !TREE_PUBLIC (t)) ++ dump_string (di, "static"); ++ break; ++ ++ case FUNCTION_DECL: ++ if (!DECL_THUNK_P (t)) ++ { ++ if (DECL_OVERLOADED_OPERATOR_P (t)) { ++ dump_string (di, "operator"); ++ dump_op (di, t); ++ } ++ if (DECL_FUNCTION_MEMBER_P (t)) ++ { ++ dump_string (di, "member"); ++ dump_access (di, t); ++ } ++ if (DECL_PURE_VIRTUAL_P (t)) ++ dump_string (di, "pure"); ++ if (DECL_VIRTUAL_P (t)) ++ dump_string (di, "virtual"); ++ if (DECL_CONSTRUCTOR_P (t)) ++ dump_string (di, "constructor"); ++ if (DECL_DESTRUCTOR_P (t)) ++ dump_string (di, "destructor"); ++ if (DECL_CONV_FN_P (t)) ++ dump_string (di, "conversion"); ++ if (DECL_GLOBAL_CTOR_P (t)) ++ dump_string (di, "global init"); ++ if (DECL_GLOBAL_DTOR_P (t)) ++ dump_string (di, "global fini"); ++ if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)) ++ dump_string (di, "pseudo tmpl"); ++ } ++ else ++ { ++ tree virt = THUNK_VIRTUAL_OFFSET (t); ++ ++ dump_string (di, "thunk"); ++ if (DECL_THIS_THUNK_P (t)) ++ dump_string (di, "this adjusting"); ++ else ++ { ++ dump_string (di, "result adjusting"); ++ if (virt) ++ virt = BINFO_VPTR_FIELD (virt); ++ } ++ dump_int (di, "fixd", THUNK_FIXED_OFFSET (t)); ++ if (virt) ++ dump_int (di, "virt", tree_low_cst (virt, 0)); ++ dump_child ("fn", DECL_INITIAL (t)); ++ } ++ break; ++ ++ case NAMESPACE_DECL: ++ if (DECL_NAMESPACE_ALIAS (t)) ++ dump_child ("alis", DECL_NAMESPACE_ALIAS (t)); ++ else if (!dump_flag (di, TDF_SLIM, t)) ++ dump_child ("dcls", cp_namespace_decls (t)); ++ break; ++ ++ case TEMPLATE_DECL: ++ dump_child ("rslt", DECL_TEMPLATE_RESULT (t)); ++ dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t)); ++ dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); ++ dump_child ("prms", DECL_TEMPLATE_PARMS (t)); ++ break; ++ ++ case OVERLOAD: ++ dump_child ("crnt", OVL_CURRENT (t)); ++ dump_child ("chan", OVL_CHAIN (t)); ++ break; ++ ++ case TRY_BLOCK: ++ dump_stmt (di, t); ++ if (CLEANUP_P (t)) ++ dump_string (di, "cleanup"); ++ dump_child ("body", TRY_STMTS (t)); ++ dump_child ("hdlr", TRY_HANDLERS (t)); ++ dump_next_stmt (di, t); ++ break; ++ ++ case EH_SPEC_BLOCK: ++ dump_stmt (di, t); ++ dump_child ("body", EH_SPEC_STMTS (t)); ++ dump_child ("raises", EH_SPEC_RAISES (t)); ++ dump_next_stmt (di, t); ++ break; ++ ++ case PTRMEM_CST: ++ dump_child ("clas", PTRMEM_CST_CLASS (t)); ++ dump_child ("mbr", PTRMEM_CST_MEMBER (t)); ++ break; ++ ++ case THROW_EXPR: ++ /* These nodes are unary, but do not have code class `1'. */ ++ dump_child ("op 0", TREE_OPERAND (t, 0)); ++ break; ++ ++ case AGGR_INIT_EXPR: ++ dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t)); ++ dump_child ("fn", TREE_OPERAND (t, 0)); ++ dump_child ("args", TREE_OPERAND (t, 1)); ++ dump_child ("decl", TREE_OPERAND (t, 2)); ++ break; ++ ++ case HANDLER: ++ dump_stmt (di, t); ++ dump_child ("parm", HANDLER_PARMS (t)); ++ dump_child ("body", HANDLER_BODY (t)); ++ dump_next_stmt (di, t); ++ break; ++ ++ case MUST_NOT_THROW_EXPR: ++ dump_stmt (di, t); ++ dump_child ("body", TREE_OPERAND (t, 0)); ++ dump_next_stmt (di, t); ++ break; ++ ++ case USING_STMT: ++ dump_stmt (di, t); ++ dump_child ("nmsp", USING_STMT_NAMESPACE (t)); ++ dump_next_stmt (di, t); ++ break; ++ ++ default: ++ break; ++ } ++ ++ return c_dump_tree (di, t); ++} +diff -NBaur gcc-3.4.4/gcc/cp/error.c gcc-3.4.4-new/gcc/cp/error.c +--- gcc-3.4.4/gcc/cp/error.c Thu Jan 1 00:00:00 1970 ++++ gcc-3.4.4-new/gcc/cp/error.c Thu Oct 28 04:49:40 2004 +@@ -0,0 +1,2452 @@ ++/* Call-backs for C++ error reporting. ++ This code is non-reentrant. ++ Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, ++ 2003 Free Software Foundation, Inc. ++ This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 2, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING. If not, write to ++the Free Software Foundation, 59 Temple Place - Suite 330, ++Boston, MA 02111-1307, USA. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tm.h" ++#include "tree.h" ++#include "cp-tree.h" ++#include "real.h" ++#include "toplev.h" ++#include "flags.h" ++#include "diagnostic.h" ++#include "langhooks-def.h" ++#include "cxx-pretty-print.h" ++ ++enum pad { none, before, after }; ++ ++#define pp_template_argument_list_start(PP) \ ++ pp_non_consecutive_character (PP, '<') ++#define pp_template_argument_list_end(PP) \ ++ pp_non_consecutive_character (PP, '>') ++#define pp_separate_with_comma(PP) pp_string (PP, ", ") ++ ++/* The global buffer where we dump everything. It is there only for ++ transitional purpose. It is expected, in the near future, to be ++ completely removed. */ ++static cxx_pretty_printer scratch_pretty_printer; ++#define cxx_pp (&scratch_pretty_printer) ++ ++# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T))) ++ ++#define reinit_global_formatting_buffer() \ ++ output_clear_message_text (scratch_buffer) ++ ++static const char *args_to_string (tree, int); ++static const char *assop_to_string (enum tree_code); ++static const char *code_to_string (enum tree_code); ++static const char *cv_to_string (tree, int); ++static const char *decl_to_string (tree, int); ++static const char *expr_to_string (tree); ++static const char *fndecl_to_string (tree, int); ++static const char *op_to_string (enum tree_code); ++static const char *parm_to_string (int); ++static const char *type_to_string (tree, int); ++ ++static void dump_type (tree, int); ++static void dump_typename (tree, int); ++static void dump_simple_decl (tree, tree, int); ++static void dump_decl (tree, int); ++static void dump_template_decl (tree, int); ++static void dump_function_decl (tree, int); ++static void dump_expr (tree, int); ++static void dump_unary_op (const char *, tree, int); ++static void dump_binary_op (const char *, tree, int); ++static void dump_aggr_type (tree, int); ++static enum pad dump_type_prefix (tree, int); ++static void dump_type_suffix (tree, int); ++static void dump_function_name (tree, int); ++static void dump_expr_list (tree, int); ++static void dump_global_iord (tree); ++static enum pad dump_qualifiers (tree, enum pad); ++static void dump_parameters (tree, int); ++static void dump_exception_spec (tree, int); ++static const char *class_key_or_enum (tree); ++static void dump_template_argument (tree, int); ++static void dump_template_argument_list (tree, int); ++static void dump_template_parameter (tree, int); ++static void dump_template_bindings (tree, tree); ++static void dump_scope (tree, int); ++static void dump_template_parms (tree, int, int); ++ ++static const char *function_category (tree); ++static void maybe_print_instantiation_context (diagnostic_context *); ++static void print_instantiation_full_context (diagnostic_context *); ++static void print_instantiation_partial_context (diagnostic_context *, ++ tree, location_t); ++static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *); ++static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *); ++static void cp_print_error_function (diagnostic_context *, diagnostic_info *); ++ ++static bool cp_printer (pretty_printer *, text_info *); ++static void pp_non_consecutive_character (cxx_pretty_printer *, int); ++static tree locate_error (const char *, va_list); ++static location_t location_of (tree); ++ ++void ++init_error (void) ++{ ++ diagnostic_starter (global_dc) = cp_diagnostic_starter; ++ diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer; ++ diagnostic_format_decoder (global_dc) = cp_printer; ++ ++ pp_construct (pp_base (cxx_pp), NULL, 0); ++ pp_cxx_pretty_printer_init (cxx_pp); ++} ++ ++/* Dump a scope, if deemed necessary. */ ++ ++static void ++dump_scope (tree scope, int flags) ++{ ++ int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF)); ++ ++ if (scope == NULL_TREE) ++ return; ++ ++ if (TREE_CODE (scope) == NAMESPACE_DECL) ++ { ++ if (scope != global_namespace) ++ { ++ dump_decl (scope, f); ++ pp_colon_colon (cxx_pp); ++ } ++ } ++ else if (AGGREGATE_TYPE_P (scope)) ++ { ++ dump_type (scope, f); ++ pp_colon_colon (cxx_pp); ++ } ++ else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL) ++ { ++ dump_function_decl (scope, f); ++ pp_colon_colon (cxx_pp); ++ } ++} ++ ++/* Dump type qualifiers, providing padding as requested. Return an ++ indication of whether we dumped something. */ ++ ++static enum pad ++dump_qualifiers (tree t, enum pad p) ++{ ++ static const int masks[] = ++ {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT}; ++ static const char *const names[] = ++ {"const", "volatile", "__restrict"}; ++ int ix; ++ int quals = TYPE_QUALS (t); ++ int do_after = p == after; ++ ++ if (quals) ++ { ++ for (ix = 0; ix != 3; ix++) ++ if (masks[ix] & quals) ++ { ++ if (p == before) ++ pp_space (cxx_pp); ++ p = before; ++ pp_identifier (cxx_pp, names[ix]); ++ } ++ if (do_after) ++ pp_space (cxx_pp); ++ } ++ else ++ p = none; ++ return p; ++} ++ ++/* Dump the template ARGument under control of FLAGS. */ ++ ++static void ++dump_template_argument (tree arg, int flags) ++{ ++ if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) ++ dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM); ++ else ++ dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM); ++} ++ ++/* Dump a template-argument-list ARGS (always a TREE_VEC) under control ++ of FLAGS. */ ++ ++static void ++dump_template_argument_list (tree args, int flags) ++{ ++ int n = TREE_VEC_LENGTH (args); ++ int need_comma = 0; ++ int i; ++ ++ for (i = 0; i< n; ++i) ++ { ++ if (need_comma) ++ pp_separate_with_comma (cxx_pp); ++ dump_template_argument (TREE_VEC_ELT (args, i), flags); ++ need_comma = 1; ++ } ++} ++ ++/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */ ++ ++static void ++dump_template_parameter (tree parm, int flags) ++{ ++ tree p = TREE_VALUE (parm); ++ tree a = TREE_PURPOSE (parm); ++ ++ if (TREE_CODE (p) == TYPE_DECL) ++ { ++ if (flags & TFF_DECL_SPECIFIERS) ++ { ++ pp_identifier (cxx_pp, "class"); ++ if (DECL_NAME (p)) ++ { ++ pp_space (cxx_pp); ++ pp_tree_identifier (cxx_pp, DECL_NAME (p)); ++ } ++ } ++ else if (DECL_NAME (p)) ++ pp_tree_identifier (cxx_pp, DECL_NAME (p)); ++ else ++ pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p)); ++ } ++ else ++ dump_decl (p, flags | TFF_DECL_SPECIFIERS); ++ ++ if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE) ++ { ++ pp_string (cxx_pp, " = "); ++ if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) ++ dump_type (a, flags & ~TFF_CHASE_TYPEDEF); ++ else ++ dump_expr (a, flags | TFF_EXPR_IN_PARENS); ++ } ++} ++ ++/* Dump, under control of FLAGS, a template-parameter-list binding. ++ PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a ++ TREE_VEC. */ ++ ++static void ++dump_template_bindings (tree parms, tree args) ++{ ++ int need_comma = 0; ++ ++ while (parms) ++ { ++ tree p = TREE_VALUE (parms); ++ int lvl = TMPL_PARMS_DEPTH (parms); ++ int arg_idx = 0; ++ int i; ++ ++ for (i = 0; i < TREE_VEC_LENGTH (p); ++i) ++ { ++ tree arg = NULL_TREE; ++ ++ /* Don't crash if we had an invalid argument list. */ ++ if (TMPL_ARGS_DEPTH (args) >= lvl) ++ { ++ tree lvl_args = TMPL_ARGS_LEVEL (args, lvl); ++ if (NUM_TMPL_ARGS (lvl_args) > arg_idx) ++ arg = TREE_VEC_ELT (lvl_args, arg_idx); ++ } ++ ++ if (need_comma) ++ pp_separate_with_comma (cxx_pp); ++ dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER); ++ pp_string (cxx_pp, " = "); ++ if (arg) ++ dump_template_argument (arg, TFF_PLAIN_IDENTIFIER); ++ else ++ pp_identifier (cxx_pp, ""); ++ ++ ++arg_idx; ++ need_comma = 1; ++ } ++ ++ parms = TREE_CHAIN (parms); ++ } ++} ++ ++/* Dump a human-readable equivalent of TYPE. FLAGS controls the ++ format. */ ++ ++static void ++dump_type (tree t, int flags) ++{ ++ if (t == NULL_TREE) ++ return; ++ ++ if (TYPE_PTRMEMFUNC_P (t)) ++ goto offset_type; ++ ++ switch (TREE_CODE (t)) ++ { ++ case UNKNOWN_TYPE: ++ pp_identifier (cxx_pp, ""); ++ break; ++ ++ case TREE_LIST: ++ /* A list of function parms. */ ++ dump_parameters (t, flags); ++ break; ++ ++ case IDENTIFIER_NODE: ++ pp_tree_identifier (cxx_pp, t); ++ break; ++ ++ case TREE_VEC: ++ dump_type (BINFO_TYPE (t), flags); ++ break; ++ ++ case RECORD_TYPE: ++ case UNION_TYPE: ++ case ENUMERAL_TYPE: ++ dump_aggr_type (t, flags); ++ break; ++ ++ case TYPE_DECL: ++ if (flags & TFF_CHASE_TYPEDEF) ++ { ++ dump_type (DECL_ORIGINAL_TYPE (t) ++ ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); ++ break; ++ } ++ /* Else fall through. */ ++ ++ case TEMPLATE_DECL: ++ case NAMESPACE_DECL: ++ dump_decl (t, flags & ~TFF_DECL_SPECIFIERS); ++ break; ++ ++ case INTEGER_TYPE: ++ case REAL_TYPE: ++ case VOID_TYPE: ++ case BOOLEAN_TYPE: ++ case COMPLEX_TYPE: ++ case VECTOR_TYPE: ++ pp_base (cxx_pp)->padding = pp_none; ++ pp_type_specifier_seq (cxx_pp, t); ++ break; ++ ++ case TEMPLATE_TEMPLATE_PARM: ++ /* For parameters inside template signature. */ ++ if (TYPE_IDENTIFIER (t)) ++ pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); ++ else ++ pp_cxx_canonical_template_parameter (cxx_pp, t); ++ break; ++ ++ case BOUND_TEMPLATE_TEMPLATE_PARM: ++ { ++ tree args = TYPE_TI_ARGS (t); ++ dump_qualifiers (t, after); ++ pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); ++ pp_template_argument_list_start (cxx_pp); ++ dump_template_argument_list (args, flags); ++ pp_template_argument_list_end (cxx_pp); ++ } ++ break; ++ ++ case TEMPLATE_TYPE_PARM: ++ dump_qualifiers (t, after); ++ if (TYPE_IDENTIFIER (t)) ++ pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); ++ else ++ pp_cxx_canonical_template_parameter ++ (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t)); ++ break; ++ ++ /* This is not always necessary for pointers and such, but doing this ++ reduces code size. */ ++ case ARRAY_TYPE: ++ case POINTER_TYPE: ++ case REFERENCE_TYPE: ++ case OFFSET_TYPE: ++ offset_type: ++ case FUNCTION_TYPE: ++ case METHOD_TYPE: ++ { ++ dump_type_prefix (t, flags); ++ dump_type_suffix (t, flags); ++ break; ++ } ++ case TYPENAME_TYPE: ++ dump_qualifiers (t, after); ++ pp_string (cxx_pp, "typename "); ++ dump_typename (t, flags); ++ break; ++ ++ case UNBOUND_CLASS_TEMPLATE: ++ dump_type (TYPE_CONTEXT (t), flags); ++ pp_colon_colon (cxx_pp); ++ pp_identifier (cxx_pp, "template "); ++ dump_type (DECL_NAME (TYPE_NAME (t)), flags); ++ break; ++ ++ case TYPEOF_TYPE: ++ pp_string (cxx_pp, "__typeof ("); ++ dump_expr (TYPE_FIELDS (t), flags & ~TFF_EXPR_IN_PARENS); ++ pp_right_paren (cxx_pp); ++ break; ++ ++ default: ++ pp_unsupported_tree (cxx_pp, t); ++ /* Fall through to error. */ ++ ++ case ERROR_MARK: ++ pp_identifier (cxx_pp, ""); ++ break; ++ } ++} ++ ++/* Dump a TYPENAME_TYPE. We need to notice when the context is itself ++ a TYPENAME_TYPE. */ ++ ++static void ++dump_typename (tree t, int flags) ++{ ++ tree ctx = TYPE_CONTEXT (t); ++ ++ if (TREE_CODE (ctx) == TYPENAME_TYPE) ++ dump_typename (ctx, flags); ++ else ++ dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM); ++ pp_colon_colon (cxx_pp); ++ dump_decl (TYPENAME_TYPE_FULLNAME (t), flags); ++} ++ ++/* Return the name of the supplied aggregate, or enumeral type. */ ++ ++static const char * ++class_key_or_enum (tree t) ++{ ++ if (TREE_CODE (t) == ENUMERAL_TYPE) ++ return "enum"; ++ else if (TREE_CODE (t) == UNION_TYPE) ++ return "union"; ++ else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) ++ return "class"; ++ else ++ return "struct"; ++} ++ ++/* Print out a class declaration T under the control of FLAGS, ++ in the form `class foo'. */ ++ ++static void ++dump_aggr_type (tree t, int flags) ++{ ++ tree name; ++ const char *variety = class_key_or_enum (t); ++ int typdef = 0; ++ int tmplate = 0; ++ ++ dump_qualifiers (t, after); ++ ++ if (flags & TFF_CLASS_KEY_OR_ENUM) ++ { ++ pp_identifier (cxx_pp, variety); ++ pp_space (cxx_pp); ++ } ++ ++ if (flags & TFF_CHASE_TYPEDEF) ++ t = TYPE_MAIN_VARIANT (t); ++ ++ name = TYPE_NAME (t); ++ ++ if (name) ++ { ++ typdef = !DECL_ARTIFICIAL (name); ++ tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE ++ && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t) ++ && (CLASSTYPE_TEMPLATE_SPECIALIZATION (t) ++ || TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL ++ || DECL_TEMPLATE_SPECIALIZATION (CLASSTYPE_TI_TEMPLATE (t)) ++ || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))); ++ dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE); ++ if (tmplate) ++ { ++ /* Because the template names are mangled, we have to locate ++ the most general template, and use that name. */ ++ tree tpl = CLASSTYPE_TI_TEMPLATE (t); ++ ++ while (DECL_TEMPLATE_INFO (tpl)) ++ tpl = DECL_TI_TEMPLATE (tpl); ++ name = tpl; ++ } ++ name = DECL_NAME (name); ++ } ++ ++ if (name == 0 || ANON_AGGRNAME_P (name)) ++ { ++ if (flags & TFF_CLASS_KEY_OR_ENUM) ++ pp_identifier (cxx_pp, ""); ++ else ++ pp_printf (pp_base (cxx_pp), "", variety); ++ } ++ else ++ pp_tree_identifier (cxx_pp, name); ++ if (tmplate) ++ dump_template_parms (TYPE_TEMPLATE_INFO (t), ++ !CLASSTYPE_USE_TEMPLATE (t), ++ flags & ~TFF_TEMPLATE_HEADER); ++} ++ ++/* Dump into the obstack the initial part of the output for a given type. ++ This is necessary when dealing with things like functions returning ++ functions. Examples: ++ ++ return type of `int (* fee ())()': pointer -> function -> int. Both ++ pointer (and reference and offset) and function (and member) types must ++ deal with prefix and suffix. ++ ++ Arrays must also do this for DECL nodes, like int a[], and for things like ++ int *[]&. ++ ++ Return indicates how you should pad an object name after this. I.e. you ++ want to pad non-*, non-& cores, but not pad * or & types. */ ++ ++static enum pad ++dump_type_prefix (tree t, int flags) ++{ ++ enum pad padding = before; ++ ++ if (TYPE_PTRMEMFUNC_P (t)) ++ { ++ t = TYPE_PTRMEMFUNC_FN_TYPE (t); ++ goto offset_type; ++ } ++ ++ switch (TREE_CODE (t)) ++ { ++ case POINTER_TYPE: ++ case REFERENCE_TYPE: ++ { ++ tree sub = TREE_TYPE (t); ++ ++ padding = dump_type_prefix (sub, flags); ++ if (TREE_CODE (sub) == ARRAY_TYPE) ++ { ++ pp_space (cxx_pp); ++ pp_left_paren (cxx_pp); ++ } ++ pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]); ++ padding = dump_qualifiers (t, before); ++ } ++ break; ++ ++ case OFFSET_TYPE: ++ offset_type: ++ padding = dump_type_prefix (TREE_TYPE (t), flags); ++ if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */ ++ { ++ if (padding != none) ++ pp_space (cxx_pp); ++ dump_type (TYPE_OFFSET_BASETYPE (t), flags); ++ pp_colon_colon (cxx_pp); ++ } ++ pp_star (cxx_pp); ++ padding = dump_qualifiers (t, none); ++ break; ++ ++ /* Can only be reached through function pointer -- this would not be ++ correct if FUNCTION_DECLs used it. */ ++ case FUNCTION_TYPE: ++ padding = dump_type_prefix (TREE_TYPE (t), flags); ++ if (padding != none) ++ pp_space (cxx_pp); ++ pp_left_paren (cxx_pp); ++ padding = none; ++ break; ++ ++ case METHOD_TYPE: ++ padding = dump_type_prefix (TREE_TYPE (t), flags); ++ if (padding != none) ++ pp_space (cxx_pp); ++ pp_left_paren (cxx_pp); ++ padding = none; ++ dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags); ++ pp_colon_colon (cxx_pp); ++ break; ++ ++ case ARRAY_TYPE: ++ padding = dump_type_prefix (TREE_TYPE (t), flags); ++ break; ++ ++ case ENUMERAL_TYPE: ++ case IDENTIFIER_NODE: ++ case INTEGER_TYPE: ++ case BOOLEAN_TYPE: ++ case REAL_TYPE: ++ case RECORD_TYPE: ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_TEMPLATE_PARM: ++ case BOUND_TEMPLATE_TEMPLATE_PARM: ++ case TREE_LIST: ++ case TYPE_DECL: ++ case TREE_VEC: ++ case UNION_TYPE: ++ case UNKNOWN_TYPE: ++ case VOID_TYPE: ++ case TYPENAME_TYPE: ++ case COMPLEX_TYPE: ++ case VECTOR_TYPE: ++ case TYPEOF_TYPE: ++ dump_type (t, flags); ++ padding = before; ++ break; ++ ++ default: ++ pp_unsupported_tree (cxx_pp, t); ++ /* fall through. */ ++ case ERROR_MARK: ++ pp_identifier (cxx_pp, ""); ++ break; ++ } ++ return padding; ++} ++ ++/* Dump the suffix of type T, under control of FLAGS. This is the part ++ which appears after the identifier (or function parms). */ ++ ++static void ++dump_type_suffix (tree t, int flags) ++{ ++ if (TYPE_PTRMEMFUNC_P (t)) ++ t = TYPE_PTRMEMFUNC_FN_TYPE (t); ++ ++ switch (TREE_CODE (t)) ++ { ++ case POINTER_TYPE: ++ case REFERENCE_TYPE: ++ case OFFSET_TYPE: ++ if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) ++ pp_right_paren (cxx_pp); ++ dump_type_suffix (TREE_TYPE (t), flags); ++ break; ++ ++ /* Can only be reached through function pointer. */ ++ case FUNCTION_TYPE: ++ case METHOD_TYPE: ++ { ++ tree arg; ++ pp_right_paren (cxx_pp); ++ arg = TYPE_ARG_TYPES (t); ++ if (TREE_CODE (t) == METHOD_TYPE) ++ arg = TREE_CHAIN (arg); ++ ++ /* Function pointers don't have default args. Not in standard C++, ++ anyway; they may in g++, but we'll just pretend otherwise. */ ++ dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS); ++ ++ if (TREE_CODE (t) == METHOD_TYPE) ++ dump_qualifiers ++ (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before); ++ dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags); ++ dump_type_suffix (TREE_TYPE (t), flags); ++ break; ++ } ++ ++ case ARRAY_TYPE: ++ pp_left_bracket (cxx_pp); ++ if (TYPE_DOMAIN (t)) ++ { ++ if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0)) ++ pp_wide_integer ++ (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1); ++ else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR) ++ dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0), ++ flags & ~TFF_EXPR_IN_PARENS); ++ else ++ dump_expr (fold (cp_build_binary_op ++ (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)), ++ integer_one_node)), ++ flags & ~TFF_EXPR_IN_PARENS); ++ } ++ pp_right_bracket (cxx_pp); ++ dump_type_suffix (TREE_TYPE (t), flags); ++ break; ++ ++ case ENUMERAL_TYPE: ++ case IDENTIFIER_NODE: ++ case INTEGER_TYPE: ++ case BOOLEAN_TYPE: ++ case REAL_TYPE: ++ case RECORD_TYPE: ++ case TEMPLATE_TYPE_PARM: ++ case TEMPLATE_TEMPLATE_PARM: ++ case BOUND_TEMPLATE_TEMPLATE_PARM: ++ case TREE_LIST: ++ case TYPE_DECL: ++ case TREE_VEC: ++ case UNION_TYPE: ++ case UNKNOWN_TYPE: ++ case VOID_TYPE: ++ case TYPENAME_TYPE: ++ case COMPLEX_TYPE: ++ case VECTOR_TYPE: ++ case TYPEOF_TYPE: ++ break; ++ ++ default: ++ pp_unsupported_tree (cxx_pp, t); ++ case ERROR_MARK: ++ /* Don't mark it here, we should have already done in ++ dump_type_prefix. */ ++ break; ++ } ++} ++ ++static void ++dump_global_iord (tree t) ++{ ++ const char *p = NULL; ++ ++ if (DECL_GLOBAL_CTOR_P (t)) ++ p = "initializers"; ++ else if (DECL_GLOBAL_DTOR_P (t)) ++ p = "destructors"; ++ else ++ abort (); ++ ++ pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename); ++} ++ ++static void ++dump_simple_decl (tree t, tree type, int flags) ++{ ++ if (flags & TFF_DECL_SPECIFIERS) ++ { ++ if (dump_type_prefix (type, flags) != none) ++ pp_space (cxx_pp); ++ } ++ if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX) ++ dump_scope (CP_DECL_CONTEXT (t), flags); ++ if (DECL_NAME (t)) ++ dump_decl (DECL_NAME (t), flags); ++ else ++ pp_identifier (cxx_pp, ""); ++ if (flags & TFF_DECL_SPECIFIERS) ++ dump_type_suffix (type, flags); ++} ++ ++/* Dump a human readable string for the decl T under control of FLAGS. */ ++ ++static void ++dump_decl (tree t, int flags) ++{ ++ if (t == NULL_TREE) ++ return; ++ ++ switch (TREE_CODE (t)) ++ { ++ case TYPE_DECL: ++ { ++ /* Don't say 'typedef class A' */ ++ if (DECL_ARTIFICIAL (t)) ++ { ++ if ((flags & TFF_DECL_SPECIFIERS) ++ && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) ++ /* Say `class T' not just `T'. */ ++ pp_string (cxx_pp, "class "); ++ ++ dump_type (TREE_TYPE (t), flags); ++ break; ++ } ++ } ++ if (flags & TFF_DECL_SPECIFIERS) ++ pp_string (cxx_pp, "typedef "); ++ dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) ++ ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), ++ flags); ++ break; ++ ++ case VAR_DECL: ++ if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t))) ++ { ++ pp_string (cxx_pp, "vtable for "); ++ my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720); ++ dump_type (DECL_CONTEXT (t), flags); ++ break; ++ } ++ /* Else fall through. */ ++ case FIELD_DECL: ++ case PARM_DECL: ++ case ALIAS_DECL: ++ dump_simple_decl (t, TREE_TYPE (t), flags); ++ break; ++ ++ case RESULT_DECL: ++ pp_string (cxx_pp, " "); ++ dump_simple_decl (t, TREE_TYPE (t), flags); ++ break; ++ ++ case NAMESPACE_DECL: ++ if (flags & TFF_DECL_SPECIFIERS) ++ pp_cxx_declaration (cxx_pp, t); ++ else ++ { ++ dump_scope (CP_DECL_CONTEXT (t), flags); ++ if (DECL_NAME (t) == NULL_TREE) ++ pp_identifier (cxx_pp, ""); ++ else ++ pp_tree_identifier (cxx_pp, DECL_NAME (t)); ++ } ++ break; ++ ++ case SCOPE_REF: ++ pp_expression (cxx_pp, t); ++ break; ++ ++ case ARRAY_REF: ++ dump_decl (TREE_OPERAND (t, 0), flags); ++ pp_left_bracket (cxx_pp); ++ dump_decl (TREE_OPERAND (t, 1), flags); ++ pp_right_bracket (cxx_pp); ++ break; ++ ++ /* So that we can do dump_decl on an aggr type. */ ++ case RECORD_TYPE: ++ case UNION_TYPE: ++ case ENUMERAL_TYPE: ++ dump_type (t, flags); ++ break; ++ ++ case BIT_NOT_EXPR: ++ /* This is a pseudo destructor call which has not been folded into ++ a PSEUDO_DTOR_EXPR yet. */ ++ pp_complement (cxx_pp); ++ dump_type (TREE_OPERAND (t, 0), flags); ++ break; ++ ++ case TYPE_EXPR: ++ abort (); ++ break; ++ ++ /* These special cases are duplicated here so that other functions ++ can feed identifiers to error and get them demangled properly. */ ++ case IDENTIFIER_NODE: ++ if (IDENTIFIER_TYPENAME_P (t)) ++ { ++ pp_string (cxx_pp, "operator "); ++ /* Not exactly IDENTIFIER_TYPE_VALUE. */ ++ dump_type (TREE_TYPE (t), flags); ++ break; ++ } ++ else ++ pp_tree_identifier (cxx_pp, t); ++ break; ++ ++ case OVERLOAD: ++ if (OVL_CHAIN (t)) ++ { ++ t = OVL_CURRENT (t); ++ if (DECL_CLASS_SCOPE_P (t)) ++ { ++ dump_type (DECL_CONTEXT (t), flags); ++ pp_colon_colon (cxx_pp); ++ } ++ else if (DECL_CONTEXT (t)) ++ { ++ dump_decl (DECL_CONTEXT (t), flags); ++ pp_colon_colon (cxx_pp); ++ } ++ dump_decl (DECL_NAME (t), flags); ++ break; ++ } ++ ++ /* If there's only one function, just treat it like an ordinary ++ FUNCTION_DECL. */ ++ t = OVL_CURRENT (t); ++ /* Fall through. */ ++ ++ case FUNCTION_DECL: ++ if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t)) ++ dump_global_iord (t); ++ else if (! DECL_LANG_SPECIFIC (t)) ++ pp_identifier (cxx_pp, ""); ++ else ++ dump_function_decl (t, flags); ++ break; ++ ++ case TEMPLATE_DECL: ++ dump_template_decl (t, flags); ++ break; ++ ++ case TEMPLATE_ID_EXPR: ++ { ++ tree name = TREE_OPERAND (t, 0); ++ ++ if (is_overloaded_fn (name)) ++ name = DECL_NAME (get_first_fn (name)); ++ dump_decl (name, flags); ++ pp_template_argument_list_start (cxx_pp); ++ if (TREE_OPERAND (t, 1)) ++ dump_template_argument_list (TREE_OPERAND (t, 1), flags); ++ pp_template_argument_list_end (cxx_pp); ++ } ++ break; ++ ++ case LABEL_DECL: ++ pp_tree_identifier (cxx_pp, DECL_NAME (t)); ++ break; ++ ++ case CONST_DECL: ++ if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE) ++ || (DECL_INITIAL (t) && ++ TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX)) ++ dump_simple_decl (t, TREE_TYPE (t), flags); ++ else if (DECL_NAME (t)) ++ dump_decl (DECL_NAME (t), flags); ++ else if (DECL_INITIAL (t)) ++ dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS); ++ else ++ pp_identifier (cxx_pp, ""); ++ break; ++ ++ case USING_DECL: ++ pp_string (cxx_pp, "using "); ++ dump_type (DECL_INITIAL (t), flags); ++ pp_colon_colon (cxx_pp); ++ dump_decl (DECL_NAME (t), flags); ++ break; ++ ++ case BASELINK: ++ dump_decl (BASELINK_FUNCTIONS (t), flags); ++ break; ++ ++ case NON_DEPENDENT_EXPR: ++ dump_expr (t, flags); ++ break; ++ ++ case TEMPLATE_TYPE_PARM: ++ if (flags & TFF_DECL_SPECIFIERS) ++ pp_cxx_declaration (cxx_pp, t); ++ else ++ pp_type_id (cxx_pp, t); ++ break; ++ ++ default: ++ pp_unsupported_tree (cxx_pp, t); ++ /* Fallthrough to error. */ ++ ++ case ERROR_MARK: ++ pp_identifier (cxx_pp, ""); ++ break; ++ } ++} ++ ++/* Dump a template declaration T under control of FLAGS. This means the ++ 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */ ++ ++static void ++dump_template_decl (tree t, int flags) ++{ ++ tree orig_parms = DECL_TEMPLATE_PARMS (t); ++ tree parms; ++ int i; ++ ++ if (flags & TFF_TEMPLATE_HEADER) ++ { ++ for (parms = orig_parms = nreverse (orig_parms); ++ parms; ++ parms = TREE_CHAIN (parms)) ++ { ++ tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); ++ int len = TREE_VEC_LENGTH (inner_parms); ++ ++ pp_string (cxx_pp, "template<"); ++ ++ /* If we've shown the template prefix, we'd better show the ++ parameters' and decl's type too. */ ++ flags |= TFF_DECL_SPECIFIERS; ++ ++ for (i = 0; i < len; i++) ++ { ++ if (i) ++ pp_separate_with_comma (cxx_pp); ++ dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags); ++ } ++ pp_template_argument_list_end (cxx_pp); ++ pp_space (cxx_pp); ++ } ++ nreverse(orig_parms); ++ ++ if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) ++ /* Say `template class TT' not just `template TT'. */ ++ pp_string (cxx_pp, "class "); ++ } ++ ++ if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) ++ dump_type (TREE_TYPE (t), ++ ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME ++ | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0))); ++ else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL) ++ dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME); ++ else if (TREE_TYPE (t) == NULL_TREE) ++ abort (); ++ else ++ switch (NEXT_CODE (t)) ++ { ++ case METHOD_TYPE: ++ case FUNCTION_TYPE: ++ dump_function_decl (t, flags | TFF_TEMPLATE_NAME); ++ break; ++ default: ++ /* This case can occur with some invalid code. */ ++ dump_type (TREE_TYPE (t), ++ (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME ++ | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)); ++ } ++} ++ ++/* Pretty print a function decl. There are several ways we want to print a ++ function declaration. The TFF_ bits in FLAGS tells us how to behave. ++ As error can only apply the '#' flag once to give 0 and 1 for V, there ++ is %D which doesn't print the throw specs, and %F which does. */ ++ ++static void ++dump_function_decl (tree t, int flags) ++{ ++ tree fntype; ++ tree parmtypes; ++ tree cname = NULL_TREE; ++ tree template_args = NULL_TREE; ++ tree template_parms = NULL_TREE; ++ int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS; ++ ++ if (TREE_CODE (t) == TEMPLATE_DECL) ++ t = DECL_TEMPLATE_RESULT (t); ++ ++ /* Pretty print template instantiations only. */ ++ if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)) ++ { ++ tree tmpl; ++ ++ template_args = DECL_TI_ARGS (t); ++ tmpl = most_general_template (t); ++ if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL) ++ { ++ template_parms = DECL_TEMPLATE_PARMS (tmpl); ++ t = tmpl; ++ } ++ } ++ ++ fntype = TREE_TYPE (t); ++ parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t); ++ ++ if (DECL_CLASS_SCOPE_P (t)) ++ cname = DECL_CONTEXT (t); ++ /* This is for partially instantiated template methods. */ ++ else if (TREE_CODE (fntype) == METHOD_TYPE) ++ cname = TREE_TYPE (TREE_VALUE (parmtypes)); ++ ++ if (!(flags & TFF_DECL_SPECIFIERS)) ++ /* OK */; ++ else if (DECL_STATIC_FUNCTION_P (t)) ++ pp_identifier (cxx_pp, "static "); ++ else if (DECL_VIRTUAL_P (t)) ++ pp_identifier (cxx_pp, "virtual "); ++ ++ /* Print the return type? */ ++ if (show_return) ++ show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t) ++ && !DECL_DESTRUCTOR_P (t); ++ if (show_return) ++ { ++ dump_type_prefix (TREE_TYPE (fntype), flags); ++ pp_space (cxx_pp); ++ } ++ ++ /* Print the function name. */ ++ if (cname) ++ { ++ dump_type (cname, flags); ++ pp_colon_colon (cxx_pp); ++ } ++ else ++ dump_scope (CP_DECL_CONTEXT (t), flags); ++ ++ dump_function_name (t, flags); ++ ++ if (!(flags & TFF_NO_FUNCTION_ARGUMENTS)) ++ { ++ dump_parameters (parmtypes, flags); ++ ++ if (TREE_CODE (fntype) == METHOD_TYPE) ++ dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))), ++ before); ++ ++ if (flags & TFF_EXCEPTION_SPECIFICATION) ++ dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags); ++ ++ if (show_return) ++ dump_type_suffix (TREE_TYPE (fntype), flags); ++ } ++ ++ /* If T is a template instantiation, dump the parameter binding. */ ++ if (template_parms != NULL_TREE && template_args != NULL_TREE) ++ { ++ pp_string (cxx_pp, " [with "); ++ dump_template_bindings (template_parms, template_args); ++ pp_right_bracket (cxx_pp); ++ } ++} ++ ++/* Print a parameter list. If this is for a member function, the ++ member object ptr (and any other hidden args) should have ++ already been removed. */ ++ ++static void ++dump_parameters (tree parmtypes, int flags) ++{ ++ int first; ++ ++ pp_left_paren (cxx_pp); ++ ++ for (first = 1; parmtypes != void_list_node; ++ parmtypes = TREE_CHAIN (parmtypes)) ++ { ++ if (!first) ++ pp_separate_with_comma (cxx_pp); ++ first = 0; ++ if (!parmtypes) ++ { ++ pp_identifier (cxx_pp, "..."); ++ break; ++ } ++ dump_type (TREE_VALUE (parmtypes), flags); ++ ++ if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) ++ { ++ pp_string (cxx_pp, " = "); ++ dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); ++ } ++ } ++ ++ pp_right_paren (cxx_pp); ++} ++ ++/* Print an exception specification. T is the exception specification. */ ++ ++static void ++dump_exception_spec (tree t, int flags) ++{ ++ if (t) ++ { ++ pp_string (cxx_pp, " throw ("); ++ if (TREE_VALUE (t) != NULL_TREE) ++ while (1) ++ { ++ dump_type (TREE_VALUE (t), flags); ++ t = TREE_CHAIN (t); ++ if (!t) ++ break; ++ pp_separate_with_comma (cxx_pp); ++ } ++ pp_right_paren (cxx_pp); ++ } ++} ++ ++/* Handle the function name for a FUNCTION_DECL node, grokking operators ++ and destructors properly. */ ++ ++static void ++dump_function_name (tree t, int flags) ++{ ++ tree name = DECL_NAME (t); ++ ++ if (TREE_CODE (t) == TEMPLATE_DECL) ++ t = DECL_TEMPLATE_RESULT (t); ++ ++ /* Don't let the user see __comp_ctor et al. */ ++ if (DECL_CONSTRUCTOR_P (t) ++ || DECL_DESTRUCTOR_P (t)) ++ name = constructor_name (DECL_CONTEXT (t)); ++ ++ if (DECL_DESTRUCTOR_P (t)) ++ { ++ pp_complement (cxx_pp); ++ dump_decl (name, TFF_PLAIN_IDENTIFIER); ++ } ++ else if (DECL_CONV_FN_P (t)) ++ { ++ /* This cannot use the hack that the operator's return ++ type is stashed off of its name because it may be ++ used for error reporting. In the case of conflicting ++ declarations, both will have the same name, yet ++ the types will be different, hence the TREE_TYPE field ++ of the first name will be clobbered by the second. */ ++ pp_string (cxx_pp, "operator "); ++ dump_type (TREE_TYPE (TREE_TYPE (t)), flags); ++ } ++ else if (IDENTIFIER_OPNAME_P (name)) ++ pp_tree_identifier (cxx_pp, name); ++ else ++ dump_decl (name, flags); ++ ++ if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t) ++ && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t) ++ && (DECL_TEMPLATE_SPECIALIZATION (t) ++ || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL ++ || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t)) ++ || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) ++ dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags); ++} ++ ++/* Dump the template parameters from the template info INFO under control of ++ FLAGS. PRIMARY indicates whether this is a primary template decl, or ++ specialization (partial or complete). For partial specializations we show ++ the specialized parameter values. For a primary template we show no ++ decoration. */ ++ ++static void ++dump_template_parms (tree info, int primary, int flags) ++{ ++ tree args = info ? TI_ARGS (info) : NULL_TREE; ++ ++ if (primary && flags & TFF_TEMPLATE_NAME) ++ return; ++ flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME); ++ pp_template_argument_list_start (cxx_pp); ++ ++ /* Be careful only to print things when we have them, so as not ++ to crash producing error messages. */ ++ if (args && !primary) ++ { ++ int len, ix; ++ ++ if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) ++ args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1); ++ ++ len = TREE_VEC_LENGTH (args); ++ ++ for (ix = 0; ix != len; ix++) ++ { ++ tree arg = TREE_VEC_ELT (args, ix); ++ ++ if (ix) ++ pp_separate_with_comma (cxx_pp); ++ ++ if (!arg) ++ pp_identifier (cxx_pp, "