From 34efdaf078b01a7387007c4e6bde6db86384c4b7 Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Tue, 2 May 2017 14:43:35 +0000 Subject: gcc-7.1.0 --- include/ChangeLog | 155 +++++- include/ansidecl.h | 40 +- include/demangle.h | 44 +- include/dwarf2.def | 75 ++- include/dwarf2.h | 141 +++++- include/dyn-string.h | 2 +- include/environ.h | 2 +- include/fibheap.h | 2 +- include/filenames.h | 2 +- include/floatformat.h | 2 +- include/fnmatch.h | 2 +- include/gcc-c-fe.def | 37 +- include/gcc-c-interface.h | 23 +- include/gcc-cp-fe.def | 1050 +++++++++++++++++++++++++++++++++++++++ include/gcc-cp-interface.h | 496 ++++++++++++++++++ include/gcc-interface.h | 111 ++++- include/gdb/gdb-index.h | 2 +- include/getopt.h | 2 +- include/gomp-constants.h | 8 +- include/hashtab.h | 2 +- include/hsa.h | 635 +++++++++++++++++++++++ include/leb128.h | 2 +- include/libiberty.h | 13 +- include/longlong.h | 31 +- include/lto-symtab.h | 2 +- include/md5.h | 2 +- include/objalloc.h | 2 +- include/obstack.h | 2 +- include/partition.h | 2 +- include/plugin-api.h | 2 +- include/safe-ctype.h | 2 +- include/sha1.h | 2 +- include/simple-object.h | 2 +- include/sort.h | 2 +- include/splay-tree.h | 2 +- include/symcat.h | 2 +- include/timeval-utils.h | 2 +- include/vtv-change-permission.h | 2 +- include/xregex2.h | 2 +- include/xtensa-config.h | 2 +- 40 files changed, 2775 insertions(+), 136 deletions(-) create mode 100644 include/gcc-cp-fe.def create mode 100644 include/gcc-cp-interface.h create mode 100644 include/hsa.h (limited to 'include') diff --git a/include/ChangeLog b/include/ChangeLog index d8ea905977..28fd2c126d 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,10 +1,150 @@ -2016-08-22 Release Manager +2017-05-02 Release Manager - * GCC 6.2.0 released. + * GCC 7.1.0 released. -2016-04-27 Release Manager +2017-04-04 Jonathan Wakely - * GCC 6.1.0 released. + * ansidecl.h (ATTRIBUTE_PACKED): Fix typo in comment. + +2017-02-25 Jakub Jelinek + + PR debug/77589 + * dwarf2.def (DW_OP_GNU_variable_value): New opcode. + +2017-01-30 Alexandre Oliva + + Introduce C++ support in libcc1. + * gcc-c-fe.def (int_type_v0): Rename from... + (int_type): ... this. Introduce new version. + (float_type_v0): Rename from... + (float_type): ... this. Introduce new version. + (char_type): New. + * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. + (gcc_type_array): Move... + * gcc-interface.h: ... here. + * gcc-cp-fe.def: New. + * gcc-cp-interface.h: New. + +2017-01-30 Jan Kratochvil + + * gcc-interface.h (enum gcc_base_api_version): Update comment + for GCC_FE_VERSION_1. + (struct gcc_base_vtable): Rename set_arguments to + set_arguments_v0. Add set_arguments, set_triplet_regexp and + set_driver_filename. + + * gcc-interface.h (enum gcc_base_api_version): Add comment to + GCC_FE_VERSION_1. + (struct gcc_base_vtable): Rename compile to compile_v0. + Update comment for compile. New methods set_verbose and + compile. + + * gcc-interface.h (enum gcc_base_api_version): Add + GCC_FE_VERSION_1. + +2017-01-24 Pekka Jääskeläinen + Martin Jambor + + * hsa.h: Moved here from libgomp/plugin/hsa.h. + +2017-01-04 Richard Earnshaw + Jiong Wang + + * dwarf2.def (DW_OP_AARCH64_operation): Reserve the number 0xea. + (DW_CFA_GNU_window_save): Comments the multiplexing on AArch64. + +2017-01-04 Jakub Jelinek + + Update copyright years. + +2016-12-21 Jakub Jelinek + + * dwarf2.def (DW_FORM_ref_sup): Renamed to ... + (DW_FORM_ref_sup4): ... this. New form. + (DW_FORM_ref_sup8): New form. + +2016-11-03 David Tolnay + Mark Wielaard + + * demangle.h (DMGL_RUST): New macro. + (DMGL_STYLE_MASK): Add DMGL_RUST. + (demangling_styles): Add dlang_rust. + (RUST_DEMANGLING_STYLE_STRING): New macro. + (RUST_DEMANGLING): New macro. + (rust_demangle): New prototype. + (rust_is_mangled): Likewise. + (rust_demangle_sym): Likewise. + +2016-11-07 Jason Merrill + + * demangle.h (enum demangle_component_type): Add + DEMANGLE_COMPONENT_NOEXCEPT, DEMANGLE_COMPONENT_THROW_SPEC. + +2016-10-17 Jakub Jelinek + + * dwarf2.h (enum dwarf_calling_convention): Add new DWARF5 + calling convention codes. + (enum dwarf_line_number_content_type): New. + (enum dwarf_location_list_entry_type): Add DWARF5 DW_LLE_* + codes. + (enum dwarf_source_language): Add new DWARF5 DW_LANG_* codes. + (enum dwarf_macro_record_type): Add DWARF5 DW_MACRO_* codes. + (enum dwarf_name_index_attribute): New. + (enum dwarf_range_list_entry): New. + (enum dwarf_unit_type): New. + * dwarf2.def: Add new DWARF5 DW_TAG_*, DW_FORM_*, DW_AT_*, + DW_OP_* and DW_ATE_* entries. + +2016-10-14 Pedro Alves + + * ansidecl.h [__cplusplus >= 201103 && GCC_VERSION < 4007] (FINAL, + OVERRIDE): Define as empty. + [__cplusplus < 201103 && GCC_VERSION < 4007] (FINAL): Define as + __final. + [__cplusplus < 201103 && GCC_VERSION >= 4007] (OVERRIDE): Define as + empty. + +2016-10-14 Pedro Alves + + * ansidecl.h (GCC_FINAL): Delete. + (OVERRIDE, FINAL): New, moved from gcc/coretypes.h. + +2016-08-15 Jakub Jelinek + + * dwarf2.def (DW_AT_string_length_bit_size, + DW_AT_string_length_byte_size): New attributes. + +2016-08-12 Alexandre Oliva + + PR debug/63240 + * dwarf2.def (DW_AT_deleted, DW_AT_defaulted): New. + * dwarf2.h (enum dwarf_defaulted_attribute): New. + +2016-07-29 Aldy Hernandez + + * libiberty.h (MAX_ALLOCA_SIZE): New macro. + +2016-05-26 Chung-Lin Tang + + * gomp-constants.h (GOMP_VERSION): Increment to 1, add comment to + describe the need for incrementing this macro whenever the plugin + interface is modified. + +2016-04-29 Tom Tromey + + * dwarf2.h (enum dwarf_source_language) : New constants. + +2016-04-29 Oleg Endo + + * longlong.h (umul_ppmm): Remove SHMEDIA checks. + (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. + +2016-04-29 Claudiu Zissulescu + + * longlong.h (add_ssaaaa): Replace obsolete 'J' constraint with + 'Cal' constraint. + (sub_ddmmss): Likewise. 2016-03-17 Thomas Schwinge @@ -50,6 +190,13 @@ * libiberty.h (dupargv): Change arg to char * const *. (writeargv, countargv): Likewise. +2015-11-27 Pedro Alves + + PR other/61321 + PR other/61233 + * demangle.h (enum demangle_component_type) + : New value. + 2015-11-25 Rainer Orth * vtv-change-permission.h (VTV_PAGE_SIZE) [__sun__ && __svr4__ && diff --git a/include/ansidecl.h b/include/ansidecl.h index 6e4bfc21f2..25f33dad23 100644 --- a/include/ansidecl.h +++ b/include/ansidecl.h @@ -1,5 +1,5 @@ /* ANSI and traditional C compatability macros - Copyright (C) 1991-2015 Free Software Foundation, Inc. + Copyright (C) 1991-2017 Free Software Foundation, Inc. This file is part of the GNU C Library. This program is free software; you can redistribute it and/or modify @@ -252,7 +252,7 @@ So instead we use the macro below and test it against specific values. */ # endif /* GNUC >= 3.0 */ #endif /* ATTRIBUTE_ALIGNED_ALIGNOF */ -/* Useful for structures whose layout must much some binary specification +/* Useful for structures whose layout must match some binary specification regardless of the alignment and padding qualities of the compiler. */ #ifndef ATTRIBUTE_PACKED # define ATTRIBUTE_PACKED __attribute__ ((packed)) @@ -313,13 +313,39 @@ So instead we use the macro below and test it against specific values. */ #define ENUM_BITFIELD(TYPE) unsigned int #endif - /* This is used to mark a class or virtual function as final. */ -#if __cplusplus >= 201103L -#define GCC_FINAL final +/* C++11 adds the ability to add "override" after an implementation of a + virtual function in a subclass, to: + (A) document that this is an override of a virtual function + (B) allow the compiler to issue a warning if it isn't (e.g. a mismatch + of the type signature). + + Similarly, it allows us to add a "final" to indicate that no subclass + may subsequently override the vfunc. + + Provide OVERRIDE and FINAL as macros, allowing us to get these benefits + when compiling with C++11 support, but without requiring C++11. + + For gcc, use "-std=c++11" to enable C++11 support; gcc 6 onwards enables + this by default (actually GNU++14). */ + +#if __cplusplus >= 201103 +/* C++11 claims to be available: use it. final/override were only + implemented in 4.7, though. */ +# if GCC_VERSION < 4007 +# define OVERRIDE +# define FINAL +# else +# define OVERRIDE override +# define FINAL final +# endif #elif GCC_VERSION >= 4007 -#define GCC_FINAL __final +/* G++ 4.7 supports __final in C++98. */ +# define OVERRIDE +# define FINAL __final #else -#define GCC_FINAL +/* No C++11 support; leave the macros empty: */ +# define OVERRIDE +# define FINAL #endif #ifdef __cplusplus diff --git a/include/demangle.h b/include/demangle.h index 1d7cadf4b7..996203b2d7 100644 --- a/include/demangle.h +++ b/include/demangle.h @@ -1,5 +1,5 @@ /* Defs for interface to demanglers. - Copyright (C) 1992-2015 Free Software Foundation, Inc. + Copyright (C) 1992-2017 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License @@ -63,9 +63,10 @@ extern "C" { #define DMGL_GNU_V3 (1 << 14) #define DMGL_GNAT (1 << 15) #define DMGL_DLANG (1 << 16) +#define DMGL_RUST (1 << 17) /* Rust wraps GNU_V3 style mangling. */ /* If none of these are set, use 'current_demangling_style' as the default. */ -#define DMGL_STYLE_MASK (DMGL_AUTO|DMGL_GNU|DMGL_LUCID|DMGL_ARM|DMGL_HP|DMGL_EDG|DMGL_GNU_V3|DMGL_JAVA|DMGL_GNAT|DMGL_DLANG) +#define DMGL_STYLE_MASK (DMGL_AUTO|DMGL_GNU|DMGL_LUCID|DMGL_ARM|DMGL_HP|DMGL_EDG|DMGL_GNU_V3|DMGL_JAVA|DMGL_GNAT|DMGL_DLANG|DMGL_RUST) /* Enumeration of possible demangling styles. @@ -88,7 +89,8 @@ extern enum demangling_styles gnu_v3_demangling = DMGL_GNU_V3, java_demangling = DMGL_JAVA, gnat_demangling = DMGL_GNAT, - dlang_demangling = DMGL_DLANG + dlang_demangling = DMGL_DLANG, + rust_demangling = DMGL_RUST } current_demangling_style; /* Define string names for the various demangling styles. */ @@ -104,6 +106,7 @@ extern enum demangling_styles #define JAVA_DEMANGLING_STYLE_STRING "java" #define GNAT_DEMANGLING_STYLE_STRING "gnat" #define DLANG_DEMANGLING_STYLE_STRING "dlang" +#define RUST_DEMANGLING_STYLE_STRING "rust" /* Some macros to test what demangling style is active. */ @@ -118,6 +121,7 @@ extern enum demangling_styles #define JAVA_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_JAVA) #define GNAT_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_GNAT) #define DLANG_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_DLANG) +#define RUST_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_RUST) /* Provide information about the available demangle styles. This code is pulled from gdb into libiberty because it is useful to binutils also. */ @@ -175,6 +179,27 @@ ada_demangle (const char *mangled, int options); extern char * dlang_demangle (const char *mangled, int options); +/* Returns non-zero iff MANGLED is a rust mangled symbol. MANGLED must + already have been demangled through cplus_demangle_v3. If this function + returns non-zero then MANGLED can be demangled (in-place) using + RUST_DEMANGLE_SYM. */ +extern int +rust_is_mangled (const char *mangled); + +/* Demangles SYM (in-place) if RUST_IS_MANGLED returned non-zero for SYM. + If RUST_IS_MANGLED returned zero for SYM then RUST_DEMANGLE_SYM might + replace characters that cannot be demangled with '?' and might truncate + SYM. After calling RUST_DEMANGLE_SYM SYM might be shorter, but never + larger. */ +extern void +rust_demangle_sym (char *sym); + +/* Demangles MANGLED if it was GNU_V3 and then RUST mangled, otherwise + returns NULL. Uses CPLUS_DEMANGLE_V3, RUST_IS_MANGLED and + RUST_DEMANGLE_SYM. Returns a new string that is owned by the caller. */ +extern char * +rust_demangle (const char *mangled, int options); + enum gnu_v3_ctor_kinds { gnu_v3_complete_object_ctor = 1, gnu_v3_base_object_ctor, @@ -449,7 +474,9 @@ enum demangle_component_type /* A transaction-safe function type. */ DEMANGLE_COMPONENT_TRANSACTION_SAFE, /* A cloned function. */ - DEMANGLE_COMPONENT_CLONE + DEMANGLE_COMPONENT_CLONE, + DEMANGLE_COMPONENT_NOEXCEPT, + DEMANGLE_COMPONENT_THROW_SPEC }; /* Types which are only used internally. */ @@ -467,6 +494,11 @@ struct demangle_component /* The type of this component. */ enum demangle_component_type type; + /* Guard against recursive component printing. + Initialize to zero. Private to d_print_comp. + All other fields are final after initialization. */ + int d_printing; + union { /* For DEMANGLE_COMPONENT_NAME. */ @@ -661,7 +693,7 @@ cplus_demangle_v3_components (const char *mangled, int options, void **mem); extern char * cplus_demangle_print (int options, - const struct demangle_component *tree, + struct demangle_component *tree, int estimated_length, size_t *p_allocated_size); @@ -681,7 +713,7 @@ cplus_demangle_print (int options, extern int cplus_demangle_print_callback (int options, - const struct demangle_component *tree, + struct demangle_component *tree, demangle_callbackref callback, void *opaque); #ifdef __cplusplus diff --git a/include/dwarf2.def b/include/dwarf2.def index 2dfee5666d..ea6194ef33 100644 --- a/include/dwarf2.def +++ b/include/dwarf2.def @@ -1,7 +1,7 @@ /* -*- c -*- Declarations and definitions of codes relating to the DWARF2 and DWARF3 symbolic debugging information formats. - Copyright (C) 1992-2015 Free Software Foundation, Inc. + Copyright (C) 1992-2017 Free Software Foundation, Inc. Written by Gary Funck (gary@intrepid.com) The Ada Joint Program Office (AJPO), Florida State University and Silicon Graphics Inc. @@ -132,7 +132,14 @@ DW_TAG (DW_TAG_type_unit, 0x41) DW_TAG (DW_TAG_rvalue_reference_type, 0x42) DW_TAG (DW_TAG_template_alias, 0x43) /* DWARF 5. */ +DW_TAG (DW_TAG_coarray_type, 0x44) +DW_TAG (DW_TAG_generic_subrange, 0x45) +DW_TAG (DW_TAG_dynamic_type, 0x46) DW_TAG (DW_TAG_atomic_type, 0x47) +DW_TAG (DW_TAG_call_site, 0x48) +DW_TAG (DW_TAG_call_site_parameter, 0x49) +DW_TAG (DW_TAG_skeleton_unit, 0x4a) +DW_TAG (DW_TAG_immutable_type, 0x4b) DW_TAG_DUP (DW_TAG_lo_user, 0x4080) DW_TAG_DUP (DW_TAG_hi_user, 0xffff) @@ -202,6 +209,17 @@ DW_FORM (DW_FORM_sec_offset, 0x17) DW_FORM (DW_FORM_exprloc, 0x18) DW_FORM (DW_FORM_flag_present, 0x19) DW_FORM (DW_FORM_ref_sig8, 0x20) +/* DWARF 5. */ +DW_FORM (DW_FORM_strx, 0x1a) +DW_FORM (DW_FORM_addrx, 0x1b) +DW_FORM (DW_FORM_ref_sup4, 0x1c) +DW_FORM (DW_FORM_strp_sup, 0x1d) +DW_FORM (DW_FORM_data16, 0x1e) +DW_FORM (DW_FORM_line_strp, 0x1f) +DW_FORM (DW_FORM_implicit_const, 0x21) +DW_FORM (DW_FORM_loclistx, 0x22) +DW_FORM (DW_FORM_rnglistx, 0x23) +DW_FORM (DW_FORM_ref_sup8, 0x24) /* Extensions for Fission. See http://gcc.gnu.org/wiki/DebugFission. */ DW_FORM (DW_FORM_GNU_addr_index, 0x1f01) DW_FORM (DW_FORM_GNU_str_index, 0x1f02) @@ -309,7 +327,35 @@ DW_AT (DW_AT_const_expr, 0x6c) DW_AT (DW_AT_enum_class, 0x6d) DW_AT (DW_AT_linkage_name, 0x6e) /* DWARF 5. */ +DW_AT (DW_AT_string_length_bit_size, 0x6f) +DW_AT (DW_AT_string_length_byte_size, 0x70) +DW_AT (DW_AT_rank, 0x71) +DW_AT (DW_AT_str_offsets_base, 0x72) +DW_AT (DW_AT_addr_base, 0x73) +DW_AT (DW_AT_rnglists_base, 0x74) +DW_AT (DW_AT_dwo_name, 0x76) +DW_AT (DW_AT_reference, 0x77) +DW_AT (DW_AT_rvalue_reference, 0x78) +DW_AT (DW_AT_macros, 0x79) +DW_AT (DW_AT_call_all_calls, 0x7a) +DW_AT (DW_AT_call_all_source_calls, 0x7b) +DW_AT (DW_AT_call_all_tail_calls, 0x7c) +DW_AT (DW_AT_call_return_pc, 0x7d) +DW_AT (DW_AT_call_value, 0x7e) +DW_AT (DW_AT_call_origin, 0x7f) +DW_AT (DW_AT_call_parameter, 0x80) +DW_AT (DW_AT_call_pc, 0x81) +DW_AT (DW_AT_call_tail_call, 0x82) +DW_AT (DW_AT_call_target, 0x83) +DW_AT (DW_AT_call_target_clobbered, 0x84) +DW_AT (DW_AT_call_data_location, 0x85) +DW_AT (DW_AT_call_data_value, 0x86) DW_AT (DW_AT_noreturn, 0x87) +DW_AT (DW_AT_alignment, 0x88) +DW_AT (DW_AT_export_symbols, 0x89) +DW_AT (DW_AT_deleted, 0x8a) +DW_AT (DW_AT_defaulted, 0x8b) +DW_AT (DW_AT_loclists_base, 0x8c) DW_AT_DUP (DW_AT_lo_user, 0x2000) /* Implementation-defined range start. */ DW_AT_DUP (DW_AT_hi_user, 0x3fff) /* Implementation-defined range end. */ @@ -591,6 +637,18 @@ DW_OP (DW_OP_bit_piece, 0x9d) DW_OP (DW_OP_implicit_value, 0x9e) DW_OP (DW_OP_stack_value, 0x9f) +/* DWARF 5 extensions. */ +DW_OP (DW_OP_implicit_pointer, 0xa0) +DW_OP (DW_OP_addrx, 0xa1) +DW_OP (DW_OP_constx, 0xa2) +DW_OP (DW_OP_entry_value, 0xa3) +DW_OP (DW_OP_const_type, 0xa4) +DW_OP (DW_OP_regval_type, 0xa5) +DW_OP (DW_OP_deref_type, 0xa6) +DW_OP (DW_OP_xderef_type, 0xa7) +DW_OP (DW_OP_convert, 0xa8) +DW_OP (DW_OP_reinterpret, 0xa9) + DW_OP_DUP (DW_OP_lo_user, 0xe0) /* Implementation-defined range start. */ DW_OP_DUP (DW_OP_hi_user, 0xff) /* Implementation-defined range end. */ @@ -617,6 +675,9 @@ DW_OP (DW_OP_GNU_parameter_ref, 0xfa) /* Extensions for Fission. See http://gcc.gnu.org/wiki/DebugFission. */ DW_OP (DW_OP_GNU_addr_index, 0xfb) DW_OP (DW_OP_GNU_const_index, 0xfc) +/* The GNU variable value extension. + See http://dwarfstd.org/ShowIssue.php?issue=161109.2 . */ +DW_OP (DW_OP_GNU_variable_value, 0xfd) /* HP extensions. */ DW_OP_DUP (DW_OP_HP_unknown, 0xe0) /* Ouch, the same as GNU_push_tls_address. */ DW_OP (DW_OP_HP_is_value, 0xe1) @@ -627,6 +688,12 @@ DW_OP (DW_OP_HP_unmod_range, 0xe5) DW_OP (DW_OP_HP_tls, 0xe6) /* PGI (STMicroelectronics) extensions. */ DW_OP (DW_OP_PGI_omp_thread_num, 0xf8) +/* AARCH64 extensions. + DW_OP_AARCH64_operation takes one mandatory unsigned LEB128 operand. + Bits[6:0] of this operand is the action code, all others bits are initialized + to 0 except explicitly documented for one action. Please refer AArch64 DWARF + ABI documentation for details. */ +DW_OP (DW_OP_AARCH64_operation, 0xea) DW_END_OP DW_FIRST_ATE (DW_ATE_void, 0x0) @@ -648,6 +715,9 @@ DW_ATE (DW_ATE_unsigned_fixed, 0xe) DW_ATE (DW_ATE_decimal_float, 0xf) /* DWARF 4. */ DW_ATE (DW_ATE_UTF, 0x10) +/* DWARF 5. */ +DW_ATE (DW_ATE_UCS, 0x11) +DW_ATE (DW_ATE_ASCII, 0x12) DW_ATE_DUP (DW_ATE_lo_user, 0x80) DW_ATE_DUP (DW_ATE_hi_user, 0xff) @@ -705,7 +775,8 @@ DW_CFA (DW_CFA_hi_user, 0x3f) /* SGI/MIPS specific. */ DW_CFA (DW_CFA_MIPS_advance_loc8, 0x1d) -/* GNU extensions. */ +/* GNU extensions. + NOTE: DW_CFA_GNU_window_save is multiplexed on Sparc and AArch64. */ DW_CFA (DW_CFA_GNU_window_save, 0x2d) DW_CFA (DW_CFA_GNU_args_size, 0x2e) DW_CFA (DW_CFA_GNU_negative_offset_extended, 0x2f) diff --git a/include/dwarf2.h b/include/dwarf2.h index 4ada87162f..9c788803e4 100644 --- a/include/dwarf2.h +++ b/include/dwarf2.h @@ -1,6 +1,6 @@ /* Declarations and definitions of codes relating to the DWARF2 and DWARF3 symbolic debugging information formats. - Copyright (C) 1992-2015 Free Software Foundation, Inc. + Copyright (C) 1992-2017 Free Software Foundation, Inc. Written by Gary Funck (gary@intrepid.com) The Ada Joint Program Office (AJPO), Florida State University and Silicon Graphics Inc. @@ -175,6 +175,10 @@ enum dwarf_calling_convention DW_CC_program = 0x2, DW_CC_nocall = 0x3, + /* DWARF 5. */ + DW_CC_pass_by_reference = 0x4, + DW_CC_pass_by_value = 0x5, + DW_CC_lo_user = 0x40, DW_CC_hi_user = 0xff, @@ -257,15 +261,38 @@ enum dwarf_line_number_hp_sfc_ops DW_LNE_HP_SFC_associate = 3 }; -/* Type codes for location list entries. - Extension for Fission. See http://gcc.gnu.org/wiki/DebugFission. */ +/* Content type codes in line table directory_entry_format + and file_name_entry_format sequences. */ +enum dwarf_line_number_content_type + { + DW_LNCT_path = 0x1, + DW_LNCT_directory_index = 0x2, + DW_LNCT_timestamp = 0x3, + DW_LNCT_size = 0x4, + DW_LNCT_MD5 = 0x5, + DW_LNCT_lo_user = 0x2000, + DW_LNCT_hi_user = 0x3fff + }; +/* Type codes for location list entries. */ enum dwarf_location_list_entry_type { - DW_LLE_GNU_end_of_list_entry = 0, - DW_LLE_GNU_base_address_selection_entry = 1, - DW_LLE_GNU_start_end_entry = 2, - DW_LLE_GNU_start_length_entry = 3 + DW_LLE_end_of_list = 0x00, + DW_LLE_base_addressx = 0x01, + DW_LLE_startx_endx = 0x02, + DW_LLE_startx_length = 0x03, + DW_LLE_offset_pair = 0x04, + DW_LLE_default_location = 0x05, + DW_LLE_base_address = 0x06, + DW_LLE_start_end = 0x07, + DW_LLE_start_length = 0x08, + + /* Former extension for Fission. + See http://gcc.gnu.org/wiki/DebugFission. */ + DW_LLE_GNU_end_of_list_entry = 0x00, + DW_LLE_GNU_base_address_selection_entry = 0x01, + DW_LLE_GNU_start_end_entry = 0x02, + DW_LLE_GNU_start_length_entry = 0x03 }; #define DW_CIE_ID 0xffffffff @@ -305,13 +332,22 @@ enum dwarf_source_language /* DWARF 4. */ DW_LANG_Python = 0x0014, /* DWARF 5. */ + DW_LANG_OpenCL = 0x0015, DW_LANG_Go = 0x0016, - - DW_LANG_C_plus_plus_11 = 0x001a, /* dwarf5.20141029.pdf DRAFT */ + DW_LANG_Modula3 = 0x0017, + DW_LANG_Haskell = 0x0018, + DW_LANG_C_plus_plus_03 = 0x0019, + DW_LANG_C_plus_plus_11 = 0x001a, + DW_LANG_OCaml = 0x001b, + DW_LANG_Rust = 0x001c, DW_LANG_C11 = 0x001d, + DW_LANG_Swift = 0x001e, + DW_LANG_Julia = 0x001f, + DW_LANG_Dylan = 0x0020, DW_LANG_C_plus_plus_14 = 0x0021, DW_LANG_Fortran03 = 0x0022, DW_LANG_Fortran08 = 0x0023, + DW_LANG_RenderScript = 0x0024, DW_LANG_lo_user = 0x8000, /* Implementation-defined range start. */ DW_LANG_hi_user = 0xffff, /* Implementation-defined range start. */ @@ -325,7 +361,10 @@ enum dwarf_source_language DW_LANG_HP_Basic91 = 0x8004, DW_LANG_HP_Pascal91 = 0x8005, DW_LANG_HP_IMacro = 0x8006, - DW_LANG_HP_Assembler = 0x8007 + DW_LANG_HP_Assembler = 0x8007, + + /* Rust extension, but replaced in DWARF 5. */ + DW_LANG_Rust_old = 0x9000 }; /* Names and codes for macro information. */ @@ -338,24 +377,86 @@ enum dwarf_macinfo_record_type DW_MACINFO_vendor_ext = 255 }; +/* DW_TAG_defaulted/DW_TAG_GNU_defaulted attributes. */ +enum dwarf_defaulted_attribute + { + DW_DEFAULTED_no = 0x00, + DW_DEFAULTED_in_class = 0x01, + DW_DEFAULTED_out_of_class = 0x02 + }; + /* Names and codes for new style macro information. */ enum dwarf_macro_record_type { - DW_MACRO_GNU_define = 1, - DW_MACRO_GNU_undef = 2, - DW_MACRO_GNU_start_file = 3, - DW_MACRO_GNU_end_file = 4, - DW_MACRO_GNU_define_indirect = 5, - DW_MACRO_GNU_undef_indirect = 6, - DW_MACRO_GNU_transparent_include = 7, + DW_MACRO_define = 0x01, + DW_MACRO_undef = 0x02, + DW_MACRO_start_file = 0x03, + DW_MACRO_end_file = 0x04, + DW_MACRO_define_strp = 0x05, + DW_MACRO_undef_strp = 0x06, + DW_MACRO_import = 0x07, + DW_MACRO_define_sup = 0x08, + DW_MACRO_undef_sup = 0x09, + DW_MACRO_import_sup = 0x0a, + DW_MACRO_define_strx = 0x0b, + DW_MACRO_undef_strx = 0x0c, + DW_MACRO_lo_user = 0xe0, + DW_MACRO_hi_user = 0xff, + + /* Compatibility macros for the GNU .debug_macro extension. */ + DW_MACRO_GNU_define = 0x01, + DW_MACRO_GNU_undef = 0x02, + DW_MACRO_GNU_start_file = 0x03, + DW_MACRO_GNU_end_file = 0x04, + DW_MACRO_GNU_define_indirect = 0x05, + DW_MACRO_GNU_undef_indirect = 0x06, + DW_MACRO_GNU_transparent_include = 0x07, /* Extensions for DWZ multifile. See http://www.dwarfstd.org/ShowIssue.php?issue=120604.1&type=open . */ - DW_MACRO_GNU_define_indirect_alt = 8, - DW_MACRO_GNU_undef_indirect_alt = 9, - DW_MACRO_GNU_transparent_include_alt = 10, + DW_MACRO_GNU_define_indirect_alt = 0x08, + DW_MACRO_GNU_undef_indirect_alt = 0x09, + DW_MACRO_GNU_transparent_include_alt = 0x0a, DW_MACRO_GNU_lo_user = 0xe0, DW_MACRO_GNU_hi_user = 0xff }; + +/* Index attributes in the Abbreviations Table. */ +enum dwarf_name_index_attribute + { + DW_IDX_compile_unit = 1, + DW_IDX_type_unit = 2, + DW_IDX_die_offset = 3, + DW_IDX_parent = 4, + DW_IDX_type_hash = 5, + DW_IDX_lo_user = 0x2000, + DW_IDX_hi_user = 0x3fff + }; + +/* Range list entry kinds in .debug_rnglists* section. */ +enum dwarf_range_list_entry + { + DW_RLE_end_of_list = 0x00, + DW_RLE_base_addressx = 0x01, + DW_RLE_startx_endx = 0x02, + DW_RLE_startx_length = 0x03, + DW_RLE_offset_pair = 0x04, + DW_RLE_base_address = 0x05, + DW_RLE_start_end = 0x06, + DW_RLE_start_length = 0x07 + }; + +/* Unit types in unit_type unit header field. */ +enum dwarf_unit_type + { + DW_UT_compile = 0x01, + DW_UT_type = 0x02, + DW_UT_partial = 0x03, + DW_UT_skeleton = 0x04, + DW_UT_split_compile = 0x05, + DW_UT_split_type = 0x06, + DW_UT_lo_user = 0x80, + DW_UT_hi_user = 0xff + }; /* @@@ For use with GNU frame unwind information. */ diff --git a/include/dyn-string.h b/include/dyn-string.h index 7c3684b7cf..6c0accc724 100644 --- a/include/dyn-string.h +++ b/include/dyn-string.h @@ -1,5 +1,5 @@ /* An abstract string datatype. - Copyright (C) 1998-2015 Free Software Foundation, Inc. + Copyright (C) 1998-2017 Free Software Foundation, Inc. Contributed by Mark Mitchell (mark@markmitchell.com). This file is part of GCC. diff --git a/include/environ.h b/include/environ.h index c18902ba5b..326a27812d 100644 --- a/include/environ.h +++ b/include/environ.h @@ -1,5 +1,5 @@ /* Declare the environ system variable. - Copyright (C) 2015 Free Software Foundation, Inc. + Copyright (C) 2015-2017 Free Software Foundation, Inc. This file is part of the libiberty library. Libiberty is free software; you can redistribute it and/or diff --git a/include/fibheap.h b/include/fibheap.h index 85b10c58b6..c27842290e 100644 --- a/include/fibheap.h +++ b/include/fibheap.h @@ -1,5 +1,5 @@ /* A Fibonacci heap datatype. - Copyright (C) 1998-2015 Free Software Foundation, Inc. + Copyright (C) 1998-2017 Free Software Foundation, Inc. Contributed by Daniel Berlin (dan@cgsoftware.com). This file is part of GCC. diff --git a/include/filenames.h b/include/filenames.h index 1161daaa4f..5a2a0552e4 100644 --- a/include/filenames.h +++ b/include/filenames.h @@ -5,7 +5,7 @@ use forward- and back-slash in path names interchangeably, and some of them have case-insensitive file names. - Copyright (C) 2000-2015 Free Software Foundation, Inc. + Copyright (C) 2000-2017 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. diff --git a/include/floatformat.h b/include/floatformat.h index af4d09cb86..8869715bba 100644 --- a/include/floatformat.h +++ b/include/floatformat.h @@ -1,5 +1,5 @@ /* IEEE floating point support declarations, for GDB, the GNU Debugger. - Copyright (C) 1991-2015 Free Software Foundation, Inc. + Copyright (C) 1991-2017 Free Software Foundation, Inc. This file is part of GDB. diff --git a/include/fnmatch.h b/include/fnmatch.h index 0789fc1469..d969758fe5 100644 --- a/include/fnmatch.h +++ b/include/fnmatch.h @@ -1,4 +1,4 @@ -/* Copyright (C) 1991-2015 Free Software Foundation, Inc. +/* Copyright (C) 1991-2017 Free Software Foundation, Inc. NOTE: The canonical source of this file is maintained with the GNU C Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. diff --git a/include/gcc-c-fe.def b/include/gcc-c-fe.def index 25ace1c852..acf1940c01 100644 --- a/include/gcc-c-fe.def +++ b/include/gcc-c-fe.def @@ -1,6 +1,6 @@ /* Interface between GCC C FE and GDB -*- c -*- - Copyright (C) 2014-2015 Free Software Foundation, Inc. + Copyright (C) 2014-2017 Free Software Foundation, Inc. This file is part of GCC. @@ -125,16 +125,18 @@ GCC_METHOD3 (gcc_type, build_function_type, const struct gcc_type_array *, /* Argument ARGUMENT_TYPES. */ int /* bool */) /* Argument IS_VARARGS. */ -/* Return an integer type with the given properties. */ +/* Return an integer type with the given properties. + Deprecated in v1, use int_type instead. */ -GCC_METHOD2 (gcc_type, int_type, +GCC_METHOD2 (gcc_type, int_type_v0, int /* bool */, /* Argument IS_UNSIGNED. */ unsigned long) /* Argument SIZE_IN_BYTES. */ -/* Return a floating point type with the given properties. */ +/* Return a floating point type with the given properties. + Deprecated in v1, use float_type instead. */ -GCC_METHOD1 (gcc_type, float_type, - unsigned long) /* Argument SIZE_IN_BYTES. */ +GCC_METHOD1 (gcc_type, float_type_v0, + unsigned long) /* Argument SIZE_IN_BYTES. */ /* Return the 'void' type. */ @@ -195,3 +197,26 @@ GCC_METHOD5 (int /* bool */, build_constant, GCC_METHOD1 (gcc_type, error, const char *) /* Argument MESSAGE. */ + +/* Return an integer type with the given properties. If BUILTIN_NAME + is non-NULL, it must name a builtin integral type with the given + signedness and size, and that is the type that will be returned. */ + +GCC_METHOD3 (gcc_type, int_type, + int /* bool */, /* Argument IS_UNSIGNED. */ + unsigned long, /* Argument SIZE_IN_BYTES. */ + const char *) /* Argument BUILTIN_NAME. */ + +/* Return the 'char' type, a distinct type from both 'signed char' and + 'unsigned char' returned by int_type. */ + +GCC_METHOD0 (gcc_type, char_type) + +/* Return a floating point type with the given properties. If BUILTIN_NAME + is non-NULL, it must name a builtin integral type with the given + signedness and size, and that is the type that will be returned. */ + +GCC_METHOD2 (gcc_type, float_type, + unsigned long, /* Argument SIZE_IN_BYTES. */ + const char *) /* Argument BUILTIN_NAME. */ + diff --git a/include/gcc-c-interface.h b/include/gcc-c-interface.h index 95d0fc94e5..e048c86307 100644 --- a/include/gcc-c-interface.h +++ b/include/gcc-c-interface.h @@ -1,6 +1,6 @@ /* Interface between GCC C FE and GDB - Copyright (C) 2014-2015 Free Software Foundation, Inc. + Copyright (C) 2014-2017 Free Software Foundation, Inc. This file is part of GCC. @@ -41,7 +41,11 @@ struct gcc_c_context; enum gcc_c_api_version { - GCC_C_FE_VERSION_0 = 0 + GCC_C_FE_VERSION_0 = 0, + + /* Added char_type. Added new version of int_type and float_type, + deprecated int_type_v0 and float_type_v0. */ + GCC_C_FE_VERSION_1 = 1 }; /* Qualifiers. */ @@ -111,19 +115,6 @@ typedef gcc_address gcc_c_symbol_address_function (void *datum, struct gcc_c_context *ctxt, const char *identifier); -/* An array of types used for creating a function type. */ - -struct gcc_type_array -{ - /* Number of elements. */ - - int n_elements; - - /* The elements. */ - - gcc_type *elements; -}; - /* The vtable used by the C front end. */ struct gcc_c_fe_vtable @@ -146,7 +137,7 @@ struct gcc_c_fe_vtable provides the declaration. DATUM is an arbitrary piece of data that is passed back verbatim - to the callbakcs in requests. */ + to the callbacks in requests. */ void (*set_callbacks) (struct gcc_c_context *self, gcc_c_oracle_function *binding_oracle, diff --git a/include/gcc-cp-fe.def b/include/gcc-cp-fe.def new file mode 100644 index 0000000000..c367c1db1e --- /dev/null +++ b/include/gcc-cp-fe.def @@ -0,0 +1,1050 @@ +/* Interface between GCC C++ FE and GDB -*- c -*- + + Copyright (C) 2014-2017 Free Software Foundation, Inc. + + This file is part of GCC. + + This program 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 3 of the License, or + (at your option) any later version. + + This program 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 this program. If not, see . */ + + + +/* Push namespace NAME as the current binding level, to which + newly-introduced decls will be bound. An empty string identifies + the global namespace, whereas NULL identifies an anonymous + namespace. A namespace named NAME is created in the current scope, + if needed. + + If the newly-created namespace is to be an inline namespace, see + make_namespace_inline. */ + +GCC_METHOD1 (int /* bool */, push_namespace, + const char *) /* Argument NAME. */ + +/* Push TYPE as the current binding level, making its members visible + for name lookup. The current scope before the call must be the + scope in which the class was declared. This should be used if the + definition of a class is already finished, but one wishes to define + a nested class, or to enter the scope of one of its member + functions. */ + +GCC_METHOD1 (int /* bool */, push_class, + gcc_type) /* Argument TYPE. */ + +/* Push FUNCTION_DECL as the current (empty) binding level (see + reactivate_decl). The current enclosing scope before the call must + be the scope in which the function was declared. */ + +GCC_METHOD1 (int /* bool */, push_function, + gcc_decl) /* Argument FUNCTION_DECL. */ + +/* Make DECL visible (again?) within SCOPE. When SCOPE is NULL, it + means the current scope; if it is not NULL, it must name a function + that is currently active, even if not at the top of the binding + chain. + + This function can be used to make e.g. a global function or + variable visible in a namespace or local scope (overriding another + enclosing definition of the same name), but its most common + expected use of this primitive, that gives it its name, is to make + declarations visible again after reentering a function scope, + because when a function is entered with push_function, that does + NOT make any of the declarations nested in it visible for name + lookup. + + There is a reason/excuse for that: unlike namespaces and classes, + G++ doesn't ever have to reenter function scopes, so its name + resolution infrastructure is not prepared to do that. But wait, + there is also a good use for this apparent limitation: a function + may contain multiple scopes (blocks), and the name may be bound to + different symbols in each of these scopes. With this interface, as + we reenter a function scope, we may choose which symbols to make + visible for the code snippet, or, if there could be template + functions in local scopes, for unresolved names in nested template + class default arguments, or in nested template function signatures. + + As for making a local declaration visible for the code snippet, + there are two possibilities: a) introduce it upfront, while + entering the scope for the user expression (see the enter_scope + callback, called by g++ when encountering the push_user_expression + pragma), which might save some scope switching and reactivate_decl + (though this can't be helped if some declarations have to be + introduced and discarded, because of multiple definitions of the + same name in different scopes within a function: they have to be + defined in discriminator order); or b) introduce it when its name + is looked up, entering the scope, introducing the declaration, + leaving the scope, and then reactivating the declaration in its + local scope. + + Here's some more detail on how reactivate_decl works. Say there's + a function foo whose body looks like this: + + { + { +// point 1 + class c {} o __attribute__ ((__used__)); // c , o + } + struct c { + void f() { +// point 2 + } + } o __attribute__ ((__used__)); // c_0, o_0 + { + class c {} p __attribute__ ((__used__)); // c_1, p +// point 3 + o.f(); + } + } + + When we are about to define class c at point 1, we enter the + function foo scope, and since no symbols are visible at point 1, we + proceed to declare class c. We may then define the class right + away, or, if we leave the function scope, and we later wish to + define it, or to define object o, we can reenter the scope and just + use the previously-obtained gcc_decl to define the class, without + having to reactivate the declaration. + + Now, if we are to set up the binding context for point 2, we have + to define c_0::f, and in order to do so, we have to declare and + define c_0. Before we can declare c_0, we MUST at least declare c. + + As a general rule, before we can declare or define any local name + with a discriminator, we have to at least declare any other + occurrences of the same name in the same enclosing entity with + lower or absent discriminator. + + So, we declare c, then we leave the function scope and reenter it + so as to declare c_0 (also with name "c", which is why we have to + leave and reenter the function scope, otherwise we would get an + error because of the duplicate definition; g++ will assign a + discriminator because it still remembers there was an earlier + declaration of c_0 within the function, it's just no longer in + scope), then we can define c_0, including its member function f. + + Likewise, if we wish to define o_0, we have to define o first. If + we wish to declare (and maybe then define) c_1, we have to at least + declare (c and then) c_0 first. + + Then, as we set up the binding context to compile a code snippet at + point 3, we may choose to activate c_1, o_0 and p upfront, + declaring and discarding c, c_0 and o, and then reentering the + funciton scope to declare c_1, o_0 and p; or we can wait for oracle + lookups of c, o or p. If c is looked up, and the debugger resolves + c in the scope to c_1, it is expected to enter the function scope + from the top level, declare c, leave it, reenter it, declare c_0, + leave it, reenter it, declare c_1, leave it, and then reactivate + c_1 in the function scope. If c_1 is needed as a complete type, + the definition may be given right after the declaration, or the + scope will have to be reentered in order to define the class. + +. If the code snippet is at point 2, we don't need to (re)activate + any declaration: nothing from any local scope is visible. Just + entering the scope of the class containing member function f + reactivates the names of its members, including the class name + itself. */ + +GCC_METHOD2 (int /* bool */, reactivate_decl, + gcc_decl, /* Argument DECL. */ + gcc_decl) /* Argument SCOPE. */ + +/* Pop the namespace last entered with push_namespace, or class last + entered with push_class, or function last entered with + push_function, restoring the binding level in effect before the + matching push_* call. */ + +GCC_METHOD0 (int /* bool */, pop_binding_level) + +/* Return the NAMESPACE_DECL, TYPE_DECL or FUNCTION_DECL of the + binding level that would be popped by pop_scope. */ + +GCC_METHOD0 (gcc_decl, get_current_binding_level_decl) + +/* Make the current binding level an inline namespace. It must be a + namespace to begin with. It is safe to call this more than once + for the same namespace, but after the first call, subsequent ones + will not return a success status. */ + +GCC_METHOD0 (int /* bool */, make_namespace_inline) + +/* Add USED_NS to the namespaces used by the current binding level. + Use get_current_binding_level_decl to obtain USED_NS's + gcc_decl. */ + +GCC_METHOD1 (int /* bool */, add_using_namespace, + gcc_decl) /* Argument USED_NS. */ + +/* Introduce a namespace alias declaration, as in: + + namespace foo = [... ::] bar; + + After this call, namespace TARGET will be visible as ALIAS within + the current namespace. Get the declaration for TARGET by calling + get_current_binding_level_decl after pushing into it. */ + +GCC_METHOD2 (int /* bool */, add_namespace_alias, + const char *, /* Argument ALIAS. */ + gcc_decl) /* Argument TARGET. */ + +/* Introduce a using declaration, as in: + + using foo::bar; + + The TARGET decl names the qualifying scope (foo:: above) and the + identifier (bar), but that does not mean that only TARGET will be + brought into the current scope: all bindings of TARGET's identifier + in the qualifying scope will be brought in. + + FLAGS should specify GCC_CP_SYMBOL_USING. If the current scope is + a class scope, visibility flags must be supplied. + + Even when TARGET is template dependent, we don't need to specify + whether or not it is a typename: the supplied declaration (that + could be a template-dependent type converted to declaration by + get_type_decl) indicates so. */ + +GCC_METHOD2 (int /* bool */, add_using_decl, + enum gcc_cp_symbol_kind, /* Argument FLAGS. */ + gcc_decl) /* Argument TARGET. */ + +/* Create a new "decl" in GCC, and bind it in the current binding + level. A decl is a declaration, basically a kind of symbol. + + NAME is the name of the new symbol. SYM_KIND is the kind of + symbol being requested. SYM_TYPE is the new symbol's C++ type; + except for labels, where this is not meaningful and should be + zero. If SUBSTITUTION_NAME is not NULL, then a reference to this + decl in the source will later be substituted with a dereference + of a variable of the given name. Otherwise, for symbols having + an address (e.g., functions), ADDRESS is the address. FILENAME + and LINE_NUMBER refer to the symbol's source location. If this + is not known, FILENAME can be NULL and LINE_NUMBER can be 0. + This function returns the new decl. + + Use this function to register typedefs, functions and variables to + namespace and local binding levels, and typedefs, member functions + (static or not), and static data members to class binding levels. + Class members must have their access controls specified with + GCC_CP_ACCESS_* flags in SYM_KIND. + + Note that, since access controls are disabled, we have no means to + express private, protected and public. + + There are various flags that can be set in SYM_KIND to specify + additional semantics. Look for GCC_CP_FLAGs in the definition of + enum gcc_cp_symbol_kind in gcc-cp-interface.h. + + In order to define member functions, pass GCC_CP_SYMBOL_FUNCTION in + SYM_KIND, and a function_type for static member functions or a + method type for non-static member functions, including constructors + and destructors. Use build_function_type to create a function + type; for a method type, start by creating a function type without + any compiler-introduced artificial arguments (the implicit this + pointer, and the __in_chrg added to constructors and destructors, + and __vtt_parm added to the former), and then use build_method_type + to create the method type out of the class type and the function + type. + + For operator functions, set GCC_CP_FLAG_SPECIAL_FUNCTION in + SYM_KIND, in addition to any other applicable flags, and pass as + NAME a string starting with the two-character mangling for operator + name: "ps" for unary plus, "mL" for multiply and assign, *=; etc. + Use "cv" for type converstion operators (the target type portion + may be omitted, as it is taken from the return type in SYM_TYPE). + For operator"", use "li" followed by the identifier (the mangled + name mandates digits specifying the length of the identifier; if + present, they determine the end of the identifier, otherwise, the + identifier extents to the end of the string, so that "li3_Kme" and + "li_Km" are equivalent). + + Constructors and destructors need special care, because for each + constructor and destructor there may be multiple clones defined + internally by the compiler. With build_decl, you can introduce the + base declaration of a constructor or a destructor, setting + GCC_CP_FLAG_SPECIAL_FUNCTION the flag and using names starting with + capital "C" or "D", respectively, followed by a digit (see below), + a blank, or NUL ('\0'). DO NOT supply an ADDRESS or a + SUBSTITUTION_NAME to build_decl, it would be meaningless (and + rejected) for the base declaration; use define_cdtor_clone to + introduce the address of each clone. For constructor templates, + declare the template with build_decl, and then, for each + specialization, introduce it with + build_function_template_specialization, and then define the + addresses of each of its clones with define_cdtor_clone. + + NAMEs for GCC_CP_FLAG_SPECIAL_FUNCTION: + + NAME meaning + C? constructor base declaration (? may be 1, 2, 4, blank or NUL) + D? destructor base declaration (? may be 0, 1, 2, 4, blank or NUL) + nw operator new + na operator new[] + dl operator delete + da operator delete[] + ps operator + (unary) + ng operator - (unary) + ad operator & (unary) + de operator * (unary) + co operator ~ + pl operator + + mi operator - + ml operator * + dv operator / + rm operator % + an operator & + or operator | + eo operator ^ + aS operator = + pL operator += + mI operator -= + mL operator *= + dV operator /= + rM operator %= + aN operator &= + oR operator |= + eO operator ^= + ls operator << + rs operator >> + lS operator <<= + rS operator >>= + eq operator == + ne operator != + lt operator < + gt operator > + le operator <= + ge operator >= + nt operator ! + aa operator && + oo operator || + pp operator ++ + mm operator -- + cm operator , + pm operator ->* + pt operator -> + cl operator () + ix operator [] + qu operator ? + cv operator (conversion operator) + li operator "" + + FIXME: How about attributes? */ + +GCC_METHOD7 (gcc_decl, build_decl, + const char *, /* Argument NAME. */ + enum gcc_cp_symbol_kind, /* Argument SYM_KIND. */ + gcc_type, /* Argument SYM_TYPE. */ + const char *, /* Argument SUBSTITUTION_NAME. */ + gcc_address, /* Argument ADDRESS. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Supply the ADDRESS of one of the multiple clones of constructor or + destructor CDTOR. The clone is specified by NAME, using the + following name mangling conventions: + + C1 in-charge constructor + C2 not-in-charge constructor + C4 unified constructor + D0 deleting destructor + D1 in-charge destructor + D2 not-in-charge destructor + D4 unified destructor + + The following information is not necessary to use the API. + + C1 initializes an instance of the class (rather than of derived + classes), including virtual base classes, whereas C2 initializes a + sub-object (of the given class type) of an instance of some derived + class (or a full object that doesn't have any virtual base + classes). + + D0 and D1 destruct an instance of the class, including virtual base + classes, but only the former calls operator delete to release the + object's storage at the end; D2 destructs a sub-object (of the + given class type) of an instance of a derived class (or a full + object that doesn't have any virtual base classes). + + The [CD]4 manglings (and symbol definitions) are non-standard, but + GCC uses them in some cases: rather than assuming they are + in-charge or not-in-charge, they test the implicit argument that + the others ignore to tell how to behave. These are used instead of + cloning when we just can't use aliases. */ + +GCC_METHOD3 (gcc_decl, define_cdtor_clone, + const char *, /* Argument NAME. */ + gcc_decl, /* Argument CDTOR. */ + gcc_address) /* Argument ADDRESS. */ + +/* Return the type associated with the given declaration. This is + most useful to obtain the type associated with a forward-declared + class, because it is the gcc_type, rather than the gcc_decl, that + has to be used to build other types, but build_decl returns a + gcc_decl rather than a gcc_type. This call can in theory be used + to obtain the type from any other declaration; it is supposed to + return the same type that was supplied when the declaration was + created. */ + +GCC_METHOD1 (gcc_type, get_decl_type, + gcc_decl) /* Argument DECL. */ + +/* Return the declaration for a type. */ + +GCC_METHOD1 (gcc_decl, get_type_decl, + gcc_type) /* Argument TYPE. */ + +/* Declare DECL as a friend of the current class scope, if TYPE is + NULL, or of TYPE itself otherwise. DECL may be a function or a + class, be they template generics, template specializations or not + templates. TYPE must be a class type (not a template generic). + + The add_friend call cannot introduce a declaration; even if the + friend is first declared as a friend in the source code, the + declaration belongs in the enclosing namespace, so it must be + introduced in that namespace, and the resulting declaration can + then be made a friend. + + DECL cannot, however, be a member of a template class generic, + because we have no means to introduce their declarations. This + interface has no notion of definitions for template generics. As a + consequence, users of this interface must introduce each friend + template member specialization separately, i.e., instead of: + + template friend struct X::M; + + they must be declared as if they were: + + friend struct X::M; + friend struct X::M; + ... for each specialization of X. + + + Specializations of a template can have each others' members as + friends: + + template class foo { + int f(); + template friend int foo::f(); + }; + + It wouldn't always be possible to define all specializations of a + template class before introducing the friend declarations in their + expanded, per-specialization form. + + In order to simplify such friend declarations, and to enable + incremental friend declarations as template specializations are + introduced, add_friend can be called after the befriending class is + fully defined, passing it a non-NULL TYPE argument naming the + befriending class type. */ + +GCC_METHOD2 (int /* bool */, add_friend, + gcc_decl, /* Argument DECL. */ + gcc_type) /* Argument TYPE. */ + +/* Return the type of a pointer to a given base type. */ + +GCC_METHOD1 (gcc_type, build_pointer_type, + gcc_type) /* Argument BASE_TYPE. */ + +/* Return the type of a reference to a given base type. */ + +GCC_METHOD2 (gcc_type, build_reference_type, + gcc_type, /* Argument BASE_TYPE. */ + enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ + +/* Create a new pointer-to-member type. MEMBER_TYPE is the data + member type, while CLASS_TYPE is the class type containing the data + member. For pointers to member functions, MEMBER_TYPE must be a + method type, and CLASS_TYPE must be specified even though it might + be possible to extract it from the method type. */ + +GCC_METHOD2 (gcc_type, build_pointer_to_member_type, + gcc_type, /* Argument CLASS_TYPE. */ + gcc_type) /* Argument MEMBER_TYPE. */ + +/* Start a template parameter list scope and enters it, so that + subsequent build_type_template_parameter and + build_value_template_parameter calls create template parameters in + the list. The list is closed by a build_decl call with + GCC_CP_SYMBOL_FUNCTION or GCC_CP_SYMBOL_CLASS, that, when the scope + is a template parameter list, declares a template function or a + template class with the then-closed parameter list. The scope in + which the new declaration is to be introduced by build_decl must be + entered before calling start_template_decl, and build_decl returns + to that scope, from the template parameter list scope, before + introducing the declaration. */ + +GCC_METHOD0 (int /* bool */, start_template_decl) + +/* Build a typename template-parameter (e.g., the T in template + ). Either PACK_P should be nonzero, to indicate an + argument pack (the last argument in a variadic template argument + list, as in template ), or DEFAULT_TYPE may be + non-NULL to set the default type argument (e.g. X) for the template + parameter. FILENAME and LINE_NUMBER may specify the source + location in which the template parameter was declared. */ + +GCC_METHOD5 (gcc_type, build_type_template_parameter, + const char *, /* Argument ID. */ + int /* bool */, /* Argument PACK_P. */ + gcc_type, /* Argument DEFAULT_TYPE. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Build a template template-parameter (e.g., the T in template +