From 5f3682ffcef162363b783eb9ee702debff489fa8 Mon Sep 17 00:00:00 2001 From: Nathan Sidwell Date: Thu, 16 Nov 2017 14:54:54 +0000 Subject: [PATCH] [PATCH] New lang hook https://gcc.gnu.org/ml/gcc-patches/2017-11/msg01340.html PR c++/82836 PR c++/82737 * tree.h (COPY_DECL_RTL): Rename parms for clarity. (SET_DECL_ASSEMBLER_NAME): Forward to overwrite_decl_assembler_name. (COPY_DECL_ASSEMBLER_NAME): Rename parms for clarity. (overwrite_decl_assembler_name): Declare. * tree.c (overwrite_decl_assembler_name): New. * langhooks-def.h (lhd_overwrite_decl_assembler_name): Declare. (LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME): Provide default. (LANG_HOOKS_INITIALIZER): Add it. * langhooks.h (struct lang_hooks): Add overwrite_decl_assembler_name. * langhooks.c (lhd_set_decl_assembler_name): Use SET_DECL_ASSEMBLER_NAME. (lhd_overwrite_decl_assembler_name): Default implementation. PR c++/82836 PR c++/82737 * cp-objcp-common.h (LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME): Override. * cp-tree.h (overwrite_mangling): Declare. * decl2.c (struct mangled_decl_hash): Entries are deletable. (overwrite_mangling): New. PR c++/82836 PR c++/82737 * g++.dg/pr82836.C: New. From-SVN: r254823 --- gcc/ChangeLog | 18 + gcc/cp/ChangeLog | 8 + gcc/cp/cp-objcp-common.h | 2 + gcc/cp/cp-tree.h | 1 + gcc/cp/decl2.c | 38 +- gcc/langhooks-def.h | 5 +- gcc/langhooks.c | 7 + gcc/langhooks.h | 4 + gcc/testsuite/ChangeLog | 4 + gcc/testsuite/g++.dg/pr82836.C | 628 +++++++++++++++++++++++++++++++++ gcc/tree.c | 11 + gcc/tree.h | 31 +- 12 files changed, 739 insertions(+), 18 deletions(-) create mode 100644 gcc/testsuite/g++.dg/pr82836.C diff --git a/gcc/ChangeLog b/gcc/ChangeLog index aaaa6389856..de9c6df23ed 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,21 @@ +2017-11-16 Nathan Sidwell + + PR c++/82836 + PR c++/82737 + * tree.h (COPY_DECL_RTL): Rename parms for clarity. + (SET_DECL_ASSEMBLER_NAME): Forward to + overwrite_decl_assembler_name. + (COPY_DECL_ASSEMBLER_NAME): Rename parms for clarity. + (overwrite_decl_assembler_name): Declare. + * tree.c (overwrite_decl_assembler_name): New. + * langhooks-def.h (lhd_overwrite_decl_assembler_name): Declare. + (LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME): Provide default. + (LANG_HOOKS_INITIALIZER): Add it. + * langhooks.h (struct lang_hooks): Add overwrite_decl_assembler_name. + * langhooks.c (lhd_set_decl_assembler_name): Use + SET_DECL_ASSEMBLER_NAME. + (lhd_overwrite_decl_assembler_name): Default implementation. + 2017-11-16 Wilco Dijkstra Jackson Woodruff diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 31de2a66182..9ceff2f397e 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,5 +1,13 @@ 2017-11-16 Nathan Sidwell + PR c++/82836 + PR c++/82737 + * cp-objcp-common.h (LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME): + Override. + * cp-tree.h (overwrite_mangling): Declare. + * decl2.c (struct mangled_decl_hash): Entries are deletable. + (overwrite_mangling): New. + PR c++/81060 * decl.c (xref_tag_1): Push lambda into current scope. * name-lookup.c (do_pushtag): Don't deal with ts_lambda here. diff --git a/gcc/cp/cp-objcp-common.h b/gcc/cp/cp-objcp-common.h index 3e4cc9c5d4c..a1b1fcdea63 100644 --- a/gcc/cp/cp-objcp-common.h +++ b/gcc/cp/cp-objcp-common.h @@ -73,6 +73,8 @@ extern void cp_register_dumps (gcc::dump_manager *); #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL cxx_dup_lang_specific_decl #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME mangle_decl +#undef LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME +#define LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME overwrite_mangling #undef LANG_HOOKS_PRINT_STATISTICS #define LANG_HOOKS_PRINT_STATISTICS cxx_print_statistics #undef LANG_HOOKS_PRINT_XNODE diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 6051348048f..c6554162078 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -6187,6 +6187,7 @@ extern tree cxx_maybe_build_cleanup (tree, tsubst_flags_t); /* in decl2.c */ extern void record_mangling (tree, bool); +extern void overwrite_mangling (tree, tree); extern void note_mangling_alias (tree, tree); extern void generate_mangling_aliases (void); extern tree build_memfn_type (tree, tree, cp_cv_quals, cp_ref_qualifier); diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 0b183085e0e..bc0db0000de 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -123,9 +123,14 @@ struct mangled_decl_hash : ggc_remove static inline void mark_empty (value_type &p) {p = NULL_TREE;} static inline bool is_empty (value_type p) {return !p;} - /* Nothing is deletable. Everything is insertable. */ - static bool is_deleted (value_type) { return false; } - static void mark_deleted (value_type) { gcc_unreachable (); } + static bool is_deleted (value_type e) + { + return e == reinterpret_cast (1); + } + static void mark_deleted (value_type &e) + { + e = reinterpret_cast (1); + } }; /* A hash table of decls keyed by mangled name. Used to figure out if @@ -4439,6 +4444,33 @@ record_mangling (tree decl, bool need_warning) } } +/* The mangled name of DECL is being forcibly changed to NAME. Remove + any existing knowledge of DECL's mangled name meaning DECL. */ + +void +overwrite_mangling (tree decl, tree name) +{ + if (tree id = DECL_ASSEMBLER_NAME_RAW (decl)) + if ((TREE_CODE (decl) == VAR_DECL + || TREE_CODE (decl) == FUNCTION_DECL) + && mangled_decls) + if (tree *slot + = mangled_decls->find_slot_with_hash (id, IDENTIFIER_HASH_VALUE (id), + NO_INSERT)) + if (*slot == decl) + { + mangled_decls->clear_slot (slot); + + /* If this is an alias, remove it from the symbol table. */ + if (DECL_ARTIFICIAL (decl) && DECL_IGNORED_P (decl)) + if (symtab_node *n = symtab_node::get (decl)) + if (n->cpp_implicit_alias) + n->remove (); + } + + DECL_ASSEMBLER_NAME_RAW (decl) = name; +} + /* The entire file is now complete. If requested, dump everything to a file. */ diff --git a/gcc/langhooks-def.h b/gcc/langhooks-def.h index 61b081bd7cc..44e7edf04ba 100644 --- a/gcc/langhooks-def.h +++ b/gcc/langhooks-def.h @@ -51,7 +51,8 @@ extern const char *lhd_dwarf_name (tree, int); extern int lhd_types_compatible_p (tree, tree); extern void lhd_print_error_function (diagnostic_context *, const char *, struct diagnostic_info *); -extern void lhd_set_decl_assembler_name (tree); +extern void lhd_set_decl_assembler_name (tree decl); +extern void lhd_overwrite_decl_assembler_name (tree decl, tree name); extern bool lhd_warn_unused_global_decl (const_tree); extern tree lhd_type_for_size (unsigned precision, int unsignedp); extern void lhd_incomplete_type_error (location_t, const_tree, const_tree); @@ -107,6 +108,7 @@ extern int lhd_type_dwarf_attribute (const_tree, int); #define LANG_HOOKS_FINISH_INCOMPLETE_DECL lhd_do_nothing_t #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL lhd_do_nothing_t #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lhd_set_decl_assembler_name +#define LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME lhd_overwrite_decl_assembler_name #define LANG_HOOKS_PRINT_STATISTICS lhd_do_nothing #define LANG_HOOKS_PRINT_XNODE lhd_print_tree_nothing #define LANG_HOOKS_PRINT_DECL lhd_print_tree_nothing @@ -310,6 +312,7 @@ extern void lhd_end_section (void); LANG_HOOKS_FINISH_INCOMPLETE_DECL, \ LANG_HOOKS_DUP_LANG_SPECIFIC_DECL, \ LANG_HOOKS_SET_DECL_ASSEMBLER_NAME, \ + LANG_HOOKS_OVERWRITE_DECL_ASSEMBLER_NAME, \ LANG_HOOKS_PRINT_STATISTICS, \ LANG_HOOKS_PRINT_XNODE, \ LANG_HOOKS_PRINT_DECL, \ diff --git a/gcc/langhooks.c b/gcc/langhooks.c index 9b3212b90cf..0fab9d5c068 100644 --- a/gcc/langhooks.c +++ b/gcc/langhooks.c @@ -171,8 +171,15 @@ lhd_set_decl_assembler_name (tree decl) ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl)); id = get_identifier (label); } + SET_DECL_ASSEMBLER_NAME (decl, id); +} +/* Forcibly overwrite the DECL_ASSEMBLER_NAME for DECL to NAME. */ +void +lhd_overwrite_decl_assembler_name (tree decl, tree name) +{ + DECL_ASSEMBLER_NAME_RAW (decl) = name; } /* Type promotion for variable arguments. */ diff --git a/gcc/langhooks.h b/gcc/langhooks.h index d1288f1965d..afc879ff9c2 100644 --- a/gcc/langhooks.h +++ b/gcc/langhooks.h @@ -395,6 +395,10 @@ struct lang_hooks assembler does not talk about it. */ void (*set_decl_assembler_name) (tree); + /* Overwrite the DECL_ASSEMBLER_NAME for a node. The name is being + changed (including to or from NULL_TREE). */ + void (*overwrite_decl_assembler_name) (tree, tree); + /* The front end can add its own statistics to -fmem-report with this hook. It should output to stderr. */ void (*print_statistics) (void); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 36a8449a815..158605a76f7 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,5 +1,9 @@ 2017-11-16 Nathan Sidwell + PR c++/82836 + PR c++/82737 + * g++.dg/pr82836.C: New. + PR c++81060 * g++.dg/cpp0x/lambda/lambda-template13.C: Avoid undefined template using local type error. diff --git a/gcc/testsuite/g++.dg/pr82836.C b/gcc/testsuite/g++.dg/pr82836.C new file mode 100644 index 00000000000..80876644b98 --- /dev/null +++ b/gcc/testsuite/g++.dg/pr82836.C @@ -0,0 +1,628 @@ +// PR c++/82836 +// { dg-do compile { target c++17 } } +// { dg-additional-options "-Wno-pedantic" } +// We were resetting DECL_ASSEMBLER_NAME when processing pragma weak, +// breaking C++'s mangling alias hash table. That hash table needs to +// be tickled in just the right way to hit the problem. + +namespace std { +typedef long unsigned size_t; +inline namespace __cxx11 {} +double abs() {} +__int128 abs(__int128 ) {} +__float128 abs(__float128 ) {} + + +#pragma weak pthread_create +typedef int luaL_Reg; +typedef int swig_lua_const_info; +typedef int swig_lua_attribute; +typedef int swig_lua_class; +} +static int swig_types; +static int swig_module; +namespace std { + template < typename > class allocator; + template < class > struct char_traits; + namespace __cxx11 { + template < typename _CharT, typename = _CharT , + typename = _CharT > + class basic_string; + typedef basic_string< char > string; + } +} +namespace __gnu_cxx { + template < typename > struct __numeric_traits_integer; + struct __conditional_type { + typedef __numeric_traits_integer< int > __type; + }__is_null_pointer0; + template < typename _Value > struct __numeric_traits_integer { + static const _Value __min = 0; + static const _Value __max = 0; + }; + template < typename _Value > + const _Value __numeric_traits_integer< _Value >::__min; + template < typename _Value > + const _Value __numeric_traits_integer< _Value >::__max; + template < typename > + struct __numeric_traits : __conditional_type::__type {}; +} +namespace std { + template < typename _Tp, _Tp __v > struct integral_constant { + static constexpr _Tp value = __v; + }; + template < typename _Tp, _Tp __v > + constexpr _Tp integral_constant< _Tp, __v >::value; + typedef integral_constant< bool, false > false_type; + struct __is_void_helper : false_type {}; + struct is_void : __is_void_helper{}; + template < int > struct conditional ; + template < typename , typename , + template < typename... > class > + struct __detector { + ; + }; + template < typename _Default, template < typename > class _Op> + using __detected_or = __detector< _Default, void, _Op>; + template < typename _Default, template < typename> class _Op + > + using __detected_or_t = + typename __detected_or< _Default, _Op>::type; + struct {}piecewise_construct ; + struct random_access_iterator_tag ; + template < typename , typename > struct iterator { + typedef int difference_type; + typedef int reference; + }; + using __make_not_void = conditional< is_void::value >; + struct pointer_traits + ; + + template <> struct char_traits< char > { + typedef char char_type; + typedef int int_type; + void assign() {} + bool eq() {} + bool lt() {} + int compare() {} + size_t length() {} + char_type find() {} + char_type move() {} + char_type copy() {} + char_type assign(char_type ) {} + char_type to_char_type() {} + int_type to_int_type() {} + bool eq_int_type() {} + int_type eof() {} + int_type not_eof() {} + }; + template <> struct char_traits< wchar_t > { + typedef wchar_t char_type; + typedef int int_type; + void assign() {} + bool eq() {} + bool lt() {} + int compare() {} + size_t length() {} + char_type find() {} + char_type move() {} + char_type copy() {} + char_type assign(char_type ) {} + char_type to_char_type() {} + int_type to_int_type() {} + bool eq_int_type() {} + int_type eof() {} + int_type not_eof() {} + }; +} +typedef int uint_least16_t; +typedef int uint_least32_t; +namespace std { +template <> struct char_traits< char16_t > { + typedef char16_t char_type; + typedef uint_least16_t int_type; + void assign() {} + bool eq() {} + bool lt() {} + int compare() {} + size_t length() {} + char_type find() {} + char_type move() {} + char_type copy() {} + char_type assign(char_type ) {} + char_type to_char_type() {} + int_type to_int_type() {} + bool eq_int_type() {} + int_type eof() {} + int_type not_eof() {} +}; +template <> struct char_traits< char32_t > { + typedef char32_t char_type; + typedef uint_least32_t int_type; + void assign() {} + bool eq() {} + bool lt() {} + int compare() {} + size_t length() {} + char_type find() {} + char_type move() {} + char_type copy() {} + char_type assign(char_type ) {} + char_type to_char_type() {} + int_type to_int_type() {} + bool eq_int_type() {} + int_type eof() {} + int_type not_eof() {} +}; +} +void *operator new(std::size_t) {} +void *operator new[](std::size_t) {} +void operator delete(void *){} +void operator delete[](void *) {} +namespace { + ; +} +namespace std { + +template < typename > class allocator { +public: + + + ~allocator(); +} +; +template < typename _Tp > +struct less { + bool operator()( _Tp , _Tp ) {} +}; +} +typedef int _Atomic_word; +namespace { + _Atomic_word __exchange_and_add_single0; + static void __atomic_add_single(); + _Atomic_word __attribute____exchange_and_add_dispatch0; + static void __attribute____atomic_add_dispatch(); +} +namespace std { + struct __allocator_traits_base { + template < typename = void > struct __rebind { + using type = + allocator< char >; + } + + ; + }; + template < typename , typename > + using __alloc_rebind = + __allocator_traits_base::__rebind<>::type; + template < typename > + struct allocator_traits { + + template < typename _Tp > + using rebind_alloc = __alloc_rebind< char , _Tp >; + }; +} +namespace __gnu_cxx { + template < typename > + struct __alloc_traits : std::allocator_traits< std::allocator< char > > { + template < typename > struct rebind { + typedef rebind_alloc< int > + other; + }; + }; +} +namespace std { + namespace __cxx11 { + template < typename , typename , typename > + class basic_string { + typedef __gnu_cxx::__alloc_traits< char >:: + rebind< int >::other _Char_alloc_type + ; + struct : _Char_alloc_type {}_M_dataplus; + int _S_compare() { + + if (__gnu_cxx::__numeric_traits< int >::__max) + + (__gnu_cxx::__numeric_traits< int >::__min) + ; + } + }; + } + template < typename _CharT, typename _Traits, typename _Alloc > + basic_string< _Traits> operator+( + basic_string< _Alloc > ); + template < typename _CharT, typename _Traits, typename _Alloc > + basic_string< _Traits> operator+( + _Alloc ); + template < typename _CharT, typename _Traits, typename _Alloc > + basic_string< _Traits> operator+( + _Alloc ); + template < typename , typename > struct __hash_base ; + template < typename > struct hash; + template <> struct hash< char > { + void operator0() {} + }; + template <> struct hash< signed char > { + void operator0() {} + }; + template <> struct hash< unsigned char > { + void operator0() {} + }; + template <> struct hash< wchar_t > { + void operator0() {} + }; + template <> struct __hash_base< size_t, char16_t > { + size_t operator0() {} + }; + template <> struct __hash_base< size_t, char32_t > { + size_t operator0() {} + }; + template <> struct hash< short > { + void operator0() {} + }; + template <> struct hash< int > { + void operator0() {} + }; + template <> struct hash< long > { + void operator0() {} + }; + template <> struct hash< long long > { + void operator0() {} + }; + template <> struct hash< unsigned short > { + void operator0() {} + }; + template <> struct hash< unsigned > { + void operator0() {} + }; + template <> struct hash< unsigned long > { + void operator0() {} + }; + template <> struct hash< unsigned long long > { + void operator0() {} + }; + template <> struct hash< __int128 > { + void operator0() {} + }; + template <> struct hash< __int128 unsigned > { + void operator0() {} + }; + typedef long _Bit_type; + struct _Bit_reference { + ; + _Bit_type _M_mask; + _Bit_reference () {} + operator bool() {} + _Bit_reference (bool ) {} + _Bit_reference operator=(_Bit_reference ) {} + bool operator==(_Bit_reference ) {} + bool operator<(_Bit_reference ) {} + void flip() {} + }; + void swap() {} + void swap(bool ) {} + void swap(_Bit_reference ) {} + struct _Bit_iterator_base + :iterator< random_access_iterator_tag, bool > { + _Bit_type *_M_p; + int _M_offset; + _Bit_iterator_base(_Bit_type *, int + _M_offset) {} + void _M_bump_up() {} + void _M_bump_down() {} + void _M_incr() {} + bool operator==(_Bit_iterator_base ) {} + bool operator<(_Bit_iterator_base ) {} + bool operator!=(_Bit_iterator_base ) {} + bool operator>(_Bit_iterator_base ) {} + bool operator<=(_Bit_iterator_base ) {} + bool operator>=(_Bit_iterator_base ) {} + }; + struct _Bit_iterator : _Bit_iterator_base { + _Bit_iterator() : _Bit_iterator_base(0, 0) {} + _Bit_iterator(_Bit_type *__x, int __y) + : _Bit_iterator_base(__x, __y) {} + iterator _M_const_cast() {} + iterator operator+() {} + iterator operator-() {} + reference operator[](difference_type ) {} + }; + void operator+(_Bit_iterator ) {} + struct _Bit_const_iterator : _Bit_iterator_base { + _Bit_const_iterator() : _Bit_iterator_base(0, 0) {} + _Bit_type _Bit_const_iterator___x; + _Bit_const_iterator(int __y) + : _Bit_iterator_base(&_Bit_const_iterator___x, __y) {} + _Bit_const_iterator(_Bit_iterator __x) + : _Bit_iterator_base(_M_p, _M_offset) {} + void _M_const_cast() {} + void operator*() {} + void operator++() {} + void operator++(int) {} + void operator--() {} + }; + class runtime_error { + public: + runtime_error(const string ); + }; + inline namespace _V2 { + class error_category { + bool operator<(error_category __other) { + less< error_category * >()(this, &__other); + } + bool operator==(error_category ) {} + bool operator!=(error_category ) {} + }; + } + struct error_code { + error_code() : _M_cat() {} + error_code(error_category ) : _M_cat() {} + void assign() {} + void clear() {} + int value() {} + error_category category() {} + string message() {} + error_category _M_cat; + }; + inline error_code make_error_code() noexcept {} + inline bool operator<(const error_code , + const error_code ) noexcept {} + struct error_condition { + error_condition() {} + error_condition(const error_category ) {} + void assign() noexcept {} + void clear() noexcept {} + int value() {} + const error_category &category() {} + string message_M_cat; + }; + inline error_condition make_error_condition() noexcept {} + inline bool operator<(const error_condition , + const error_condition ) noexcept {} + inline bool operator==(const error_code , + const error_code ) noexcept {} + inline bool operator==(const error_code , + const error_condition ) noexcept {} + inline bool operator==(const error_condition , + const error_code ) noexcept {} + inline bool operator==(const error_condition , + const error_condition ) noexcept {} + inline bool operator!=(const error_code , + const error_code ) noexcept {} + inline bool operator!=(const error_code , + const error_condition ) noexcept {} + inline bool operator!=(const error_condition , + const error_code ) noexcept {} + inline bool operator!=(const error_condition , + const error_condition ) noexcept {} + class system_error : public runtime_error { + error_code _M_code; + + system_error(error_code __ec = error_code()) + : runtime_error(__ec.message()) {} + system_error(error_code __ec, const string &__what) + : runtime_error(__ec.message()) {} + system_error(error_code __ec, const char *__what) + : runtime_error((__ec.message())) {} + system_error(const char ) + : system_error() {} + system_error(const error_category ) + : runtime_error(error_code().message()) {} + system_error(const string &__what) + : runtime_error(error_code().message()) {} + const error_code &code() {} + void operator0() {} + }; + enum _Ios_Fmtflags {}; + _Ios_Fmtflags operator&(_Ios_Fmtflags __a__b) {} + _Ios_Fmtflags operator|(_Ios_Fmtflags __a, + _Ios_Fmtflags __b) {} + _Ios_Fmtflags operator^(_Ios_Fmtflags __a, + _Ios_Fmtflags __b) {} + _Ios_Fmtflags operator~(_Ios_Fmtflags __a) {} + _Ios_Fmtflags &operator|=(_Ios_Fmtflags , + _Ios_Fmtflags __b) {} + _Ios_Fmtflags &operator&=(_Ios_Fmtflags , + _Ios_Fmtflags __b) {} + _Ios_Fmtflags &operator^=(_Ios_Fmtflags , + _Ios_Fmtflags __b) {} + enum _Ios_Openmode { + _S_ios_openmode_max }; + _Ios_Openmode operator&(_Ios_Openmode __a__b) {} + _Ios_Openmode operator|(_Ios_Openmode __a, + _Ios_Openmode __b) {} + _Ios_Openmode operator^(_Ios_Openmode __a, + _Ios_Openmode __b) {} + _Ios_Openmode operator~(_Ios_Openmode __a) {} + _Ios_Openmode &operator|=(_Ios_Openmode , + _Ios_Openmode __b) {} + _Ios_Openmode &operator&=(_Ios_Openmode , + _Ios_Openmode __b) {} + _Ios_Openmode &operator^=(_Ios_Openmode , + _Ios_Openmode __b) {} + enum _Ios_Iostate { + _S_ios_iostate_max }; + _Ios_Iostate operator&(_Ios_Iostate __a__b) {} + _Ios_Iostate operator|(_Ios_Iostate __a, _Ios_Iostate __b) {} + _Ios_Iostate operator^(_Ios_Iostate __a, _Ios_Iostate __b) {} + _Ios_Iostate operator~(_Ios_Iostate __a) {} + _Ios_Iostate &operator|=(_Ios_Iostate , _Ios_Iostate __b) {} + _Ios_Iostate &operator&=(_Ios_Iostate , _Ios_Iostate __b) {} + _Ios_Iostate &operator^=(_Ios_Iostate , _Ios_Iostate __b) {} + enum class io_errc; + inline error_code make_error_code(io_errc __e) noexcept {} + inline error_condition make_error_condition_wrap_class_string; +static luaL_Reg swig_ClientProfile_methods; +static luaL_Reg swig_ClientProfile_meta; +static swig_lua_attribute swig_ClientProfile_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_ClientProfile_Sf_SwigStatic_constants; +static luaL_Reg swig_ClientProfile_Sf_SwigStatic_methods; +static swig_lua_class swig_ClientProfile_Sf_SwigStatic_classes; +static int swig_ClientProfile_Sf_SwigStatic; +static swig_lua_class swig_ClientProfile_bases; +static const char *swig_ClientProfile_base_names; +static swig_lua_class _wrap_class_ClientProfile; +static int _proxy__wrap_new_Connection0; +static swig_lua_attribute swig_Connection_attributes; +static luaL_Reg swig_Connection_methods; +static luaL_Reg swig_Connection_meta; +static swig_lua_attribute swig_Connection_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_Connection_Sf_SwigStatic_constants; +static luaL_Reg swig_Connection_Sf_SwigStatic_methods; +static swig_lua_class swig_Connection_Sf_SwigStatic_classes; +static int swig_Connection_Sf_SwigStatic; +static swig_lua_class swig_Connection_bases; +static const char swig_Connection_base_names = 0; +static swig_lua_class _wrap_class_Connection; +static int _proxy__wrap_new_ConnectionPool0; +static swig_lua_attribute swig_ConnectionPool_attributes; +static luaL_Reg swig_ConnectionPool_methods; +static luaL_Reg swig_ConnectionPool_meta; +static swig_lua_attribute swig_ConnectionPool_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_ConnectionPool_Sf_SwigStatic_constants; +static luaL_Reg swig_ConnectionPool_Sf_SwigStatic_methods; +static swig_lua_class swig_ConnectionPool_Sf_SwigStatic_classes; +static int swig_ConnectionPool_Sf_SwigStatic; +static swig_lua_class *swig_ConnectionPool_bases ; +static const char *swig_ConnectionPool_base_names ; +static swig_lua_class _wrap_class_ConnectionPool; +static int _proxy__wrap_new_Client0; +static swig_lua_attribute swig_Client_attributes; +static luaL_Reg swig_Client_methods; +static luaL_Reg swig_Client_meta; +static swig_lua_attribute swig_Client_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_Client_Sf_SwigStatic_constants; +static luaL_Reg swig_Client_Sf_SwigStatic_methods; +static swig_lua_class swig_Client_Sf_SwigStatic_classes; +static int swig_Client_Sf_SwigStatic; +static swig_lua_class *swig_Client_bases; +static const char *swig_Client_base_names; +static swig_lua_class _wrap_class_Client; +static int _proxy__wrap_new_PreludeLog0; +static swig_lua_attribute swig_PreludeLog_attributes; +static luaL_Reg swig_PreludeLog_methods; +static luaL_Reg swig_PreludeLog_meta; +static swig_lua_attribute swig_PreludeLog_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_PreludeLog_Sf_SwigStatic_constants; +static luaL_Reg swig_PreludeLog_Sf_SwigStatic_methods; +static swig_lua_class swig_PreludeLog_Sf_SwigStatic_classes; +static int swig_PreludeLog_Sf_SwigStatic; +static swig_lua_class swig_PreludeLog_bases; +static const char *swig_PreludeLog_base_names; +static swig_lua_class _wrap_class_PreludeLog; +static int _proxy__wrap_new_PreludeError0; +static swig_lua_attribute swig_PreludeError_attributes; +static luaL_Reg swig_PreludeError_methods; +static luaL_Reg swig_PreludeError_meta; +static swig_lua_attribute swig_PreludeError_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_PreludeError_Sf_SwigStatic_constants; +static luaL_Reg swig_PreludeError_Sf_SwigStatic_methods; +static swig_lua_class swig_PreludeError_Sf_SwigStatic_classes; +static int swig_PreludeError_Sf_SwigStatic; +static swig_lua_class swig_PreludeError_bases; +static const char *swig_PreludeError_base_names; +static swig_lua_class _wrap_class_PreludeError; +static int _proxy__wrap_new_ClientEasy0; +static swig_lua_attribute swig_ClientEasy_attributes; +static luaL_Reg swig_ClientEasy_methods; +static luaL_Reg swig_ClientEasy_meta; +static swig_lua_attribute swig_ClientEasy_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_ClientEasy_Sf_SwigStatic_constants; +static luaL_Reg swig_ClientEasy_Sf_SwigStatic_methods; +static swig_lua_class swig_ClientEasy_Sf_SwigStatic_classes; +static int swig_ClientEasy_Sf_SwigStatic; +static swig_lua_class *swig_ClientEasy_bases; +static const char *swig_ClientEasy_base_names; +static swig_lua_class _wrap_class_ClientEasy; +static int _proxy__wrap_new_IDMEFCriterion0; +static swig_lua_attribute swig_IDMEFCriterion_attributes; +static luaL_Reg swig_IDMEFCriterion_methods; +static luaL_Reg swig_IDMEFCriterion_meta; +static swig_lua_attribute swig_IDMEFCriterion_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_IDMEFCriterion_Sf_SwigStatic_constants; +static luaL_Reg swig_IDMEFCriterion_Sf_SwigStatic_methods; +static swig_lua_class swig_IDMEFCriterion_Sf_SwigStatic_classes; +static int swig_IDMEFCriterion_Sf_SwigStatic; +static swig_lua_class swig_IDMEFCriterion_bases; +static const char *swig_IDMEFCriterion_base_names; +static swig_lua_class _wrap_class_IDMEFCriterion; +static int _proxy__wrap_new_IDMEFCriteria0; +static swig_lua_attribute swig_IDMEFCriteria_attributes; +static luaL_Reg swig_IDMEFCriteria_methods; +static luaL_Reg swig_IDMEFCriteria_meta; +static swig_lua_attribute swig_IDMEFCriteria_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_IDMEFCriteria_Sf_SwigStatic_constants; +static luaL_Reg swig_IDMEFCriteria_Sf_SwigStatic_methods; +static swig_lua_class swig_IDMEFCriteria_Sf_SwigStatic_classes; +static int swig_IDMEFCriteria_Sf_SwigStatic; +static swig_lua_class swig_IDMEFCriteria_bases; +static const char *swig_IDMEFCriteria_base_names; +static swig_lua_class _wrap_class_IDMEFCriteria; +static int _proxy__wrap_new_IDMEFValue0; +static swig_lua_attribute swig_IDMEFValue_attributes; +static luaL_Reg swig_IDMEFValue_methods; +static luaL_Reg swig_IDMEFValue_meta; +static swig_lua_attribute swig_IDMEFValue_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_IDMEFValue_Sf_SwigStatic_constants; +static luaL_Reg swig_IDMEFValue_Sf_SwigStatic_methods; +static swig_lua_class swig_IDMEFValue_Sf_SwigStatic_classes; +static int swig_IDMEFValue_Sf_SwigStatic; +static swig_lua_class swig_IDMEFValue_bases; +static const char *swig_IDMEFValue_base_names; +static swig_lua_class _wrap_class_IDMEFValue; +static int _proxy__wrap_new_IDMEFPath0; +static swig_lua_attribute swig_IDMEFPath_attributes; +static luaL_Reg swig_IDMEFPath_methods; +static luaL_Reg swig_IDMEFPath_meta; +static swig_lua_attribute swig_IDMEFPath_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_IDMEFPath_Sf_SwigStatic_constants; +static luaL_Reg swig_IDMEFPath_Sf_SwigStatic_methods; +static swig_lua_class swig_IDMEFPath_Sf_SwigStatic_classes; +static int swig_IDMEFPath_Sf_SwigStatic; +static swig_lua_class swig_IDMEFPath_bases; +static const char *swig_IDMEFPath_base_names; +static swig_lua_class _wrap_class_IDMEFPath; +static int _proxy__wrap_new_IDMEFTime0; +static swig_lua_attribute swig_IDMEFTime_attributes; +static luaL_Reg swig_IDMEFTime_methods; +static luaL_Reg swig_IDMEFTime_meta; +static swig_lua_attribute swig_IDMEFTime_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_IDMEFTime_Sf_SwigStatic_constants; +static luaL_Reg swig_IDMEFTime_Sf_SwigStatic_methods; +static swig_lua_class swig_IDMEFTime_Sf_SwigStatic_classes; +static int swig_IDMEFTime_Sf_SwigStatic; +static swig_lua_class swig_IDMEFTime_bases; +static const char *swig_IDMEFTime_base_names; +static swig_lua_class _wrap_class_IDMEFTime; +static int _proxy__wrap_new_IDMEFClass0; +static swig_lua_attribute swig_IDMEFClass_attributes; +static luaL_Reg swig_IDMEFClass_methods; +static luaL_Reg swig_IDMEFClass_meta; +static swig_lua_attribute swig_IDMEFClass_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_IDMEFClass_Sf_SwigStatic_constants; +static luaL_Reg swig_IDMEFClass_Sf_SwigStatic_methods; +static swig_lua_class swig_IDMEFClass_Sf_SwigStatic_classes; +static int swig_IDMEFClass_Sf_SwigStatic; +static swig_lua_class swig_IDMEFClass_bases; +static const char *swig_IDMEFClass_base_names; +static swig_lua_class _wrap_class_IDMEFClass; +static int _proxy__wrap_new_IDMEF0; +static swig_lua_attribute swig_IDMEF_attributes; +static luaL_Reg swig_IDMEF_methods; +static luaL_Reg swig_IDMEF_meta; +static swig_lua_attribute swig_IDMEF_Sf_SwigStatic_attributes; +static swig_lua_const_info swig_IDMEF_Sf_SwigStatic_constants; +static luaL_Reg swig_IDMEF_Sf_SwigStatic_methods; +static swig_lua_class swig_IDMEF_Sf_SwigStatic_classes; +static int swig_IDMEF_Sf_SwigStatic; +static swig_lua_class swig_IDMEF_bases; +static const char *swig_IDMEF_base_names; +static swig_lua_class _wrap_class_IDMEF; +static swig_lua_attribute swig_SwigModule_attributes; +static swig_lua_const_info swig_SwigModule_constants; +static luaL_Reg swig_SwigModule_methods; +static swig_lua_class *swig_SwigModule_classes; +static int swig_SwigModule_namespaces; +static int swig_SwigModule; +} +static void *_p_Prelude__ClientTo_p_Prelude__ClientProfile0; diff --git a/gcc/tree.c b/gcc/tree.c index 28e157f5fd2..72da68322cc 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -674,6 +674,17 @@ decl_assembler_name (tree decl) return DECL_ASSEMBLER_NAME_RAW (decl); } +/* The DECL_ASSEMBLER_NAME_RAW of DECL is being explicitly set to NAME + (either of which may be NULL). Inform the FE, if this changes the + name. */ + +void +overwrite_decl_assembler_name (tree decl, tree name) +{ + if (DECL_ASSEMBLER_NAME_RAW (decl) != name) + lang_hooks.overwrite_decl_assembler_name (decl, name); +} + /* When the target supports COMDAT groups, this indicates which group the DECL is associated with. This can be either an IDENTIFIER_NODE or a decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */ diff --git a/gcc/tree.h b/gcc/tree.h index 39acffe5266..0ec092aa812 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -2528,11 +2528,11 @@ extern void decl_value_expr_insert (tree, tree); #define DECL_RTL_SET_P(NODE) \ (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL) -/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for - NODE1, it will not be set for NODE2; this is a lazy copy. */ -#define COPY_DECL_RTL(NODE1, NODE2) \ - (DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl \ - = DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl) +/* Copy the RTL from SRC_DECL to DST_DECL. If the RTL was not set for + SRC_DECL, it will not be set for DST_DECL; this is a lazy copy. */ +#define COPY_DECL_RTL(SRC_DECL, DST_DECL) \ + (DECL_WRTL_CHECK (DST_DECL)->decl_with_rtl.rtl \ + = DECL_WRTL_CHECK (SRC_DECL)->decl_with_rtl.rtl) /* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */ #define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL) @@ -2723,19 +2723,21 @@ extern void decl_value_expr_insert (tree, tree); /* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */ #define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \ - (DECL_ASSEMBLER_NAME_RAW (NODE) = (NAME)) + overwrite_decl_assembler_name (NODE, NAME) -/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's - DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause - the DECL_ASSEMBLER_NAME of either DECL to be set. In other words, the - semantics of using this macro, are different than saying: +/* Copy the DECL_ASSEMBLER_NAME from SRC_DECL to DST_DECL. Note that + if SRC_DECL's DECL_ASSEMBLER_NAME has not yet been set, using this + macro will not cause the DECL_ASSEMBLER_NAME to be set, but will + clear DECL_ASSEMBLER_NAME of DST_DECL, if it was already set. In + other words, the semantics of using this macro, are different than + saying: - SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1)) + SET_DECL_ASSEMBLER_NAME(DST_DECL, DECL_ASSEMBLER_NAME (SRC_DECL)) - which will try to set the DECL_ASSEMBLER_NAME for DECL1. */ + which will try to set the DECL_ASSEMBLER_NAME for SRC_DECL. */ -#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2) \ - SET_DECL_ASSEMBLER_NAME (DECL2, DECL_ASSEMBLER_NAME_RAW (DECL1)) +#define COPY_DECL_ASSEMBLER_NAME(SRC_DECL, DST_DECL) \ + SET_DECL_ASSEMBLER_NAME (DST_DECL, DECL_ASSEMBLER_NAME_RAW (SRC_DECL)) /* Records the section name in a section attribute. Used to pass the name from decl_attributes to make_function_rtl and make_decl_rtl. */ @@ -3872,6 +3874,7 @@ id_equal (const char *str, const_tree id) || ((NODE) && TREE_TYPE ((NODE)) == error_mark_node)) extern tree decl_assembler_name (tree); +extern void overwrite_decl_assembler_name (tree decl, tree name); extern tree decl_comdat_group (const_tree); extern tree decl_comdat_group_id (const_tree); extern const char *decl_section_name (const_tree); -- 2.30.2