[PR c++/82836] weak pragma checking

[Nathan Sidwell <nathan at acm dot org>]

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

--
Nathan Sidwell

2017-11-06  Nathan Sidwell  <nathan@acm.org>

	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;