From patchwork Mon Nov 6 16:21:14 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nathan Sidwell X-Patchwork-Id: 834840 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-466041-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="gSMZEI4A"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3yVyVk37FNz9s7M for ; Tue, 7 Nov 2017 03:21:30 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:to:cc :from:subject:message-id:date:mime-version:content-type; q=dns; s=default; b=ncgYjMfL/G2M7PympIsSxwApbeqjFpxYC/Pjw9jL45jJnp+4As GQUHw53GardhEA5xMcmLSpVxbiaMdxw7qpWSXwg24dVILbWS4m0hM+HXpDMAOsY3 GtrB6mRjjiNl/DKM7QwA3aRFIHhmtDkobMOdLMZy4AyjJ7TnRTWOYmY08= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:to:cc :from:subject:message-id:date:mime-version:content-type; s= default; bh=cfapviak7py6LVnBgsbxySF3b2c=; b=gSMZEI4AvXT5oQUa+8mB WKJsPH/1qQweav30XgBlOTaBgKlNFbeUvVTUiQRXeBAW3Zj8pQlfKp9rYQ/pYVef 0BjAwRP8x2IaJBG9HDvOBpXSusN2hgDGu3ejjs5nr9UERXLK00IhtVOMvVMlV/uO lVhPSnRSepQNpmeFUDtktNc= Received: (qmail 80486 invoked by alias); 6 Nov 2017 16:21:22 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 80474 invoked by uid 89); 6 Nov 2017 16:21:21 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-10.5 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, RCVD_IN_SORBS_SPAM, SPF_PASS autolearn=ham version=3.3.2 spammy=feet, basic_string, operator!, char16_t X-HELO: mail-it0-f44.google.com Received: from mail-it0-f44.google.com (HELO mail-it0-f44.google.com) (209.85.214.44) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 06 Nov 2017 16:21:18 +0000 Received: by mail-it0-f44.google.com with SMTP id 72so5978854itl.5 for ; Mon, 06 Nov 2017 08:21:18 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:to:cc:from:subject:message-id:date :user-agent:mime-version:content-language; bh=tritwgCBzjp8kmxhb13z+vBl3SLalawgbvOdb+qVcok=; b=D6NJatSMSsDQAaj7aS6fnJnzdTuH9c6f20a1CMPr/o1dhaBiBEIbgIc078alpJTidX npxsJgv4XFQ+y5/LEHS8MmGvrbaN/RRDkgiYooO07xi48juY657p8GNajdcn+Ib3yyiD 4VJYKvcCIPas61XJuH2ONgpaypCz/Jfbaok7s0Qp7qbHjKh+gZmX7VGdVtxH2vvXICs7 Tr6i1tGnis8hMrjHIkNP2tmfrAkbSsIN/GwaoAd8sz8/9NKSSbjxmjeLuC/WmItA2ZQf ssFcmmIhQ68x95vsNKhIYF8LpEBJ0LqZKYxm87ewC33eTsdwK9u6+Kpx4UZEriClBSwU D34Q== X-Gm-Message-State: AJaThX6xklj6UwbuXyA5DJvPIi+cWtq9o27lA2Vs5hkYHhHzmPdSC/EZ NOfI0nti9EXMvGiy8VHnTtQ= X-Google-Smtp-Source: ABhQp+QxTko4TDZjKncUuTMdnKTeiXf4+r3s1nQCNdyqlAfXMi+3Gd9QNN2N4SZBA+VawPCHiVF1YA== X-Received: by 10.36.65.201 with SMTP id b70mr10137169itd.114.1509985276437; Mon, 06 Nov 2017 08:21:16 -0800 (PST) Received: from [172.20.32.31] ([67.201.107.102]) by smtp.googlemail.com with ESMTPSA id s16sm4572895itb.15.2017.11.06.08.21.15 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 06 Nov 2017 08:21:15 -0800 (PST) To: GCC Patches Cc: Jan Hubicka From: Nathan Sidwell Subject: [PR c++/82836] weak pragma checking Message-ID: <6bb0ae53-bbb6-4464-311b-b248f63f7e19@acm.org> Date: Mon, 6 Nov 2017 11:21:14 -0500 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.4.0 MIME-Version: 1.0 This patch addesses 82836, an ICE where c++'s mangling alias hash table has a DECL_ASSEMBLER_NAME change underneath its feet (to NULL). Because of historical changes in the mangling algorithm, the mangler creates a table, hashed by DECL_ASSEMBLER_NAME recording manglings that could have changed. It then generates a bunch of aliases if needed. The hash insertion can occur on any use of DECL_ASSEMBLER_NAME that ends up generating a mangling. However the weak pragma handling has this comment: /* Avoid asking for DECL_ASSEMBLER_NAME when it's not needed. */ which is fine, followed by a set of early-exit checks. Then finally: if (DECL_ASSEMBLER_NAME_SET_P (decl)) id = DECL_ASSEMBLER_NAME (decl); else { id = DECL_ASSEMBLER_NAME (decl); SET_DECL_ASSEMBLER_NAME (decl, NULL_TREE); } What this is trying to do is leave DECL_ASSEMBLER_NAME in the same state it was before the call. I hypothesized it was for stability as we're being called when iterating over some other hash table. But this is coming from a loop of: FOR_EACH_SYMBOL_NAME (...) That seems to be a list iteration. Resetting DECL_ASSEMBLER_NAME is not going to save memory. The mangled identifier will remain in the identifier table. So this patch simply removes the above conditional and uses DECL_ASSEMBLER_NAME directly. nathan 2017-11-06 Nathan Sidwell c-family/ PR c++/82836 * c-pragma.c (maybe_apply_pragma_weak): Don't reset DECL_ASSEMBLER_NAME. PR c++/82836.C * g++.dg/pr82836.C: New. Index: c-family/c-pragma.c =================================================================== --- c-family/c-pragma.c (revision 254427) +++ c-family/c-pragma.c (working copy) @@ -265,12 +265,9 @@ apply_pragma_weak (tree decl, tree value void maybe_apply_pragma_weak (tree decl) { - tree id; int i; pending_weak *pe; - /* Avoid asking for DECL_ASSEMBLER_NAME when it's not needed. */ - /* No weak symbols pending, take the short-cut. */ if (vec_safe_is_empty (pending_weaks)) return; @@ -284,13 +281,8 @@ maybe_apply_pragma_weak (tree decl) if (!VAR_OR_FUNCTION_DECL_P (decl)) return; - if (DECL_ASSEMBLER_NAME_SET_P (decl)) - id = DECL_ASSEMBLER_NAME (decl); - else - { - id = DECL_ASSEMBLER_NAME (decl); - SET_DECL_ASSEMBLER_NAME (decl, NULL_TREE); - } + /* Look at DECL_ASSEMBLER_NAME only when we know we needed it. */ + tree id = DECL_ASSEMBLER_NAME (decl); FOR_EACH_VEC_ELT (*pending_weaks, i, pe) if (id == pe->name) Index: testsuite/g++.dg/pr82836.C =================================================================== --- testsuite/g++.dg/pr82836.C (nonexistent) +++ testsuite/g++.dg/pr82836.C (working copy) @@ -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;