[Bug lto/63226] ICE with -flto-odr-type-merging

["burnus at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63226

--- Comment #5 from Tobias Burnus <burnus at gcc dot gnu.org> ---
Created attachment 33478
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=33478&action=edit
Second test file pair (1/2): one37.ii

         namespace std {
           template<typename _Arg, typename _Result>     struct unary_function 
   {
   };
         }
               namespace mpl_ {
         }
               namespace mpl_ {
         template< bool C_ > struct bool_ {
      };
    template< typename T, T N > struct integral_c;
    }
               namespace boost {
    namespace mpl {
   using ::mpl_::integral_c;
   }
    }
               namespace mpl_ {
         template< typename T, T N > struct integral_c {
          static const T value = N;
      };
         }
               namespace boost{
         template <class T, T val> struct integral_constant : public
mpl::integral_c<T, val> {
   };
         namespace detail {
      template <typename T> struct cv_traits_imp {
        typedef T unqualified_type;
    };
      };
         template< typename T > struct is_void :
::boost::integral_constant<bool,false> {
   };
         template< typename T > struct is_integral :
::boost::integral_constant<bool,false> {
   };
         namespace type_traits {
      template <typename T> struct is_mem_fun_pointer_impl {
  static const bool value = false;
  };
      }
         template< typename T > struct remove_cv {
      typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
      };
         template< typename T > struct is_member_function_pointer :
::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename
remove_cv<T>::type>::value> {
   };
         template< typename T > struct is_member_pointer :
::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value>
{
   };
         namespace type_traits {
      template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 =
true, bool b6 = true, bool b7 = true> struct ice_and;
      template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and {
        static const bool value = false;
    };
      template <bool b> struct ice_not {
  static const bool value = true;
  };
      }
         namespace detail {
      template< typename T > struct is_pointer_helper {
  static const bool value = false;
  };
      template< typename T > struct is_pointer_impl {
  static const bool value = (::boost::type_traits::ice_and<
::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value ,
::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value
>::value)          ;
  };
      }
         template< typename T > struct is_pointer :
::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> {
   };
         namespace mpl {
      template<       bool C     , typename T1     , typename T2     > struct
if_c {
    };
      template<       typename T1     , typename T2     > struct
if_c<false,T1,T2> {
        typedef T2 type;
    };
      }
           template <bool B, class T = void>   struct enable_if_c {
          typedef T type;
        };
           template<typename Signature> class function;
           namespace detail {
          namespace function {
          union function_buffer       {           mutable void (*func_ptr)();  
      };
          struct function_ptr_tag {  };
          template<typename F>       class get_function_tag       {          
typedef typename mpl::if_c<(is_pointer<F>::value),                             
      function_ptr_tag,                                   
function_ptr_tag>::type ptr_or_obj_tag;         public:         typedef
ptr_or_obj_tag type;         };
          template<typename Functor>       struct functor_manager       {      
  public:         static inline void         manage(const function_buffer&
in_buffer, function_buffer& out_buffer)         {  }         };
          struct vtable_base       {           void (*manager)(const
function_buffer& in_buffer,                         function_buffer&
out_buffer);         };
        }
        }
         class function_base {
      };
           namespace detail {
          namespace function {
          template<         typename FunctionObj,         typename R ,        
typename T0       >       struct function_obj_invoker1       {           static
R invoke(function_buffer& function_obj_ptr ,                         T0 a0)    
    {           }         };
          template<         typename FunctionObj,         typename R ,        
typename T0       >       struct void_function_obj_invoker1       {         };
          template<         typename FunctionObj,         typename R ,        
typename T0        >       struct get_function_obj_invoker1       {          
typedef typename mpl::if_c<(is_void<R>::value),                            
void_function_obj_invoker1<                             FunctionObj,           
                 R ,                             T0                          
>,                           function_obj_invoker1<                            
FunctionObj,                             R ,                             T0    
                      >                        >::type type;         };
          template<typename Tag>       struct get_invoker1 {          
template<typename FunctionObj,                  typename R , typename T0>      
  struct apply         {             typedef typename
get_function_obj_invoker1<                              FunctionObj,           
                  R ,                              T0                          
 >::type             invoker_type;             typedef
functor_manager<FunctionObj> manager_type;           };         };
          template<typename R , typename T0>       struct basic_vtable1       {
          typedef R result_type;           typedef result_type
(*invoker_type)(function_buffer&                                             , 
                                           T0);         vtable_base base;      
    invoker_type invoker;         };
        }
        }
           template<     typename R ,     typename T0   >   class function1 :
public function_base        {
      typedef boost::detail::function::basic_vtable1<               R , T0>    
  vtable_type;
        public:          template<typename Functor>     function1(Functor f    
                        ,typename enable_if_c<                            
(boost::type_traits::ice_not<                             
(is_integral<Functor>::value)>::value),                                        
int>::type = 0                             ) :       function_base()     {
          typedef typename detail::function::get_function_tag<Functor>::type
tag;
          typedef detail::function::get_invoker1<tag> get_invoker;
          typedef typename get_invoker::                          template
apply<Functor, R ,                         T0>         handler_type;
          typedef typename handler_type::invoker_type invoker_type;
          typedef typename handler_type::manager_type manager_type;
          static vtable_type stored_vtable =         {   {  
&manager_type::manage }  , &invoker_type::invoke };
        }
        };
         template<typename R ,          typename T0> class function<R ( T0)>  
: public function1<R , T0> {
        typedef function1<R , T0> base_type;
      public:      template<typename Functor>   function(Functor f           
,typename enable_if_c<                            
(boost::type_traits::ice_not<                          
(is_integral<Functor>::value)>::value),                        int>::type = 0  
         ) :     base_type(f)   {
      }
      };
         }
           typedef boost::function<void (const char*)> WarningHandler;
           class ParserImpl;
           class MyParser {
           ParserImpl* impl;
       public:                 MyParser ();
       };
           class ParserImpl {
       public:                 ParserImpl (WarningHandler warner);
       };
           static void DisplayWarning (const char* msg) {
    }
           MyParser::MyParser () {
           impl = new ParserImpl(DisplayWarning);
       }