--- /dev/null
+// PR ipa/63587
+// { dg-do compile { target c++11 } }
+// { dg-options "-O2 -fno-strict-aliasing" }
+
+template <class> struct A
+{
+};
+template <typename> struct B
+{
+ template <typename> struct C;
+};
+class D;
+template <typename> class F;
+struct G
+{
+ void operator()(const D &, D);
+};
+class D
+{
+public:
+ D (int);
+};
+struct H
+{
+ H (int);
+};
+template <typename _Key, typename, typename, typename _Compare, typename>
+class I
+{
+ typedef _Key key_type;
+ template <typename _Key_compare> struct J
+ {
+ _Key_compare _M_key_compare;
+ };
+ J<_Compare> _M_impl;
+
+public:
+ A<int> _M_get_insert_unique_pos (const key_type &);
+ A<int> _M_get_insert_hint_unique_pos (H &);
+ template <typename... _Args> int _M_emplace_hint_unique (H, _Args &&...);
+};
+template <typename _Key, typename _Tp, typename _Compare = G,
+ typename _Alloc = F<A<_Tp> > >
+class K
+{
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef typename B<_Alloc>::template C<value_type> _Pair_alloc_type;
+ I<key_type, value_type, int, _Compare, _Pair_alloc_type> _M_t;
+
+public:
+ void operator[](key_type)
+ {
+ _M_t._M_emplace_hint_unique (0);
+ }
+};
+template <typename _Key, typename _Val, typename _KeyOfValue,
+ typename _Compare, typename _Alloc>
+A<int>
+I<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_unique_pos (
+ const key_type &p1)
+{
+ _M_impl._M_key_compare (p1, 0);
+}
+template <typename _Key, typename _Val, typename _KeyOfValue,
+ typename _Compare, typename _Alloc>
+A<int>
+I<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_hint_unique_pos (
+ H &)
+{
+ _M_get_insert_unique_pos (0);
+}
+template <typename _Key, typename _Val, typename _KeyOfValue,
+ typename _Compare, typename _Alloc>
+template <typename... _Args>
+int
+I<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_emplace_hint_unique (
+ H p1, _Args &&...)
+{
+ _M_get_insert_hint_unique_pos (p1);
+}
+namespace {
+struct L;
+}
+void
+fn1 ()
+{
+ K<D, L> a;
+ a[0];
+ K<D, int> b;
+ b[0];
+}
--- /dev/null
+// PR ipa/63587
+// { dg-do compile { target c++11 } }
+// { dg-options "-O2" }
+
+namespace boost {
+class basic_cstring
+{
+public:
+ basic_cstring (char *);
+};
+template <typename> struct identity
+{
+};
+struct make_identity;
+struct function_buffer
+{
+};
+template <typename FunctionObj> struct function_obj_invoker0
+{
+ static int
+ invoke (function_buffer &)
+ {
+ FunctionObj f;
+ f ();
+ }
+};
+template <typename FunctionObj> struct get_function_obj_invoker0
+{
+ typedef function_obj_invoker0<FunctionObj> type;
+};
+template <typename FunctionObj> struct apply
+{
+ typedef typename get_function_obj_invoker0<FunctionObj>::type invoker_type;
+};
+struct basic_vtable0
+{
+ typedef int (*invoker_type)(function_buffer &);
+ template <typename F> void assign_to (F, function_buffer);
+ invoker_type invoker;
+};
+class function0
+{
+public:
+ template <typename Functor> function0 (Functor)
+ {
+ typedef typename apply<Functor>::invoker_type invoker_type;
+ basic_vtable0 stored_vtable { invoker_type::invoke };
+ stored_vtable.assign_to (0, functor);
+ }
+ function_buffer functor;
+};
+class function : function0
+{
+public:
+ template <typename Functor> function (Functor f) : function0 (f) {}
+};
+class test_unit_generator
+{
+};
+class test_case
+{
+public:
+ test_case (basic_cstring, basic_cstring, int, function);
+};
+struct auto_test_unit_registrar
+{
+ auto_test_unit_registrar (test_unit_generator);
+};
+template <typename F> F unwrap (F, int);
+struct for_each_impl
+{
+ template <typename Iterator, typename LastIterator, typename TransformFunc,
+ typename F>
+ static void
+ execute (Iterator, LastIterator, TransformFunc, F f)
+ {
+ identity<char> __trans_tmp_1;
+ unwrap (f, 0)(__trans_tmp_1);
+ }
+};
+template <typename, typename, typename F>
+void
+for_each (F f)
+{
+ for_each_impl::execute (0, 0, 0, f);
+}
+template <typename TestCaseTemplate> class test_case_template_invoker
+{
+public:
+ void operator()()
+ {
+ TestCaseTemplate::run (0);
+ }
+};
+template <typename Generator, typename TestCaseTemplate>
+struct generate_test_case_4_type
+{
+ generate_test_case_4_type (basic_cstring, basic_cstring, int, Generator G)
+ : m_test_case_name (0), m_test_case_file (0), m_holder (G)
+ {
+ }
+ template <typename TestType> void operator()(identity<TestType>)
+ {
+ test_case (0, 0, 0, test_case_template_invoker<TestCaseTemplate> ());
+ }
+ basic_cstring m_test_case_name;
+ basic_cstring m_test_case_file;
+ Generator m_holder;
+};
+template <typename TestCaseTemplate>
+class template_test_case_gen : public test_unit_generator
+{
+public:
+ template_test_case_gen (basic_cstring, basic_cstring, int)
+ {
+ for_each<int, make_identity> (
+ generate_test_case_4_type<template_test_case_gen, TestCaseTemplate> (
+ 0, 0, 0, *this));
+ }
+};
+class attribute_name
+{
+ int m_id;
+
+public:
+ attribute_name (char);
+};
+template <typename> struct term;
+namespace exprns_ {
+template <typename> struct expr;
+}
+using exprns_::expr;
+template <typename T> struct Trans_NS_proto_terminal
+{
+ typedef expr<term<T> > type;
+};
+namespace exprns_ {
+template <typename Arg0> struct expr<term<Arg0> >
+{
+ Arg0 child0;
+};
+}
+template <typename Expr> struct actor
+{
+ typename Trans_NS_proto_terminal<Expr>::type proto_expr_;
+};
+template <template <typename> class Actor = actor> struct terminal
+{
+ typedef Actor<int> type;
+};
+namespace log {
+struct to_log_fun
+{
+};
+class value_extractor;
+template <typename, typename = value_extractor, typename = void,
+ template <typename> class = actor>
+class attribute_actor;
+class attribute_terminal
+{
+public:
+ attribute_name m_name;
+ attribute_name
+ get_name ()
+ {
+ return m_name;
+ }
+};
+template <typename, typename, typename, template <typename> class ActorT>
+class attribute_actor : ActorT<attribute_terminal>
+{
+public:
+ typedef int value_type;
+ attribute_name
+ get_name ()
+ {
+ return this->proto_expr_.child0.get_name ();
+ }
+};
+template <typename AttributeValueT>
+attribute_actor<AttributeValueT> attr (attribute_name);
+terminal<>::type stream;
+template <typename LeftT, typename ImplT> class attribute_output_terminal
+{
+public:
+ template <typename U>
+ attribute_output_terminal (LeftT, attribute_name, ImplT, U);
+};
+template <typename LeftT> struct make_output_expression
+{
+ typedef attribute_output_terminal<LeftT, to_log_fun> type;
+ template <typename RightT>
+ static type
+ make (LeftT left, RightT &right)
+ {
+ type (left, right.get_name (), to_log_fun (), 0);
+ }
+};
+template <typename, typename RightT, typename = typename RightT::value_type>
+struct make_output_actor;
+template <template <typename> class ActorT, typename LeftExprT,
+ typename RightT, typename ValueT>
+struct make_output_actor<ActorT<LeftExprT>, RightT, ValueT>
+{
+ typedef make_output_expression<ActorT<LeftExprT> > make_expression;
+ typedef ActorT<typename make_expression::type> type;
+ static type
+ make (ActorT<LeftExprT> left, RightT &right)
+ {
+ type { make_expression::make (left, right) };
+ }
+};
+template <typename LeftExprT, typename T, typename FallbackPolicyT,
+ typename TagT>
+typename make_output_actor<actor<LeftExprT>, attribute_actor<TagT> >::type
+operator<<(actor<LeftExprT> left,
+ attribute_actor<T, FallbackPolicyT, TagT> right)
+{
+ make_output_actor<actor<LeftExprT>, attribute_actor<T> >::make (left, right);
+}
+}
+}
+namespace logging = boost::log;
+namespace expr = logging;
+namespace {
+class my_class;
+}
+template <typename> struct default_formatting
+{
+ void test_method ();
+};
+struct default_formatting_invoker
+{
+ static void
+ run (void *)
+ {
+ default_formatting<int> t;
+ t.test_method ();
+ }
+};
+boost::auto_test_unit_registrar default_formatting_registrar56 (
+ boost::template_test_case_gen<default_formatting_invoker> (0, 0, 0));
+template <typename CharT>
+void
+default_formatting<CharT>::test_method ()
+{
+ expr::stream << expr::attr<my_class> (0);
+ expr::stream << expr::attr<int> (0) << expr::attr<int> (0)
+ << expr::attr<int> (0);
+}
projects / gcc.git / commitdiff