| // { dg-do compile { target i?86-*-* x86_64-*-* } } |
| // { dg-options "-std=c++11 -O3 -march=westmere" } |
| |
| template <int> struct int_ {}; |
| template <typename> struct add_const { typedef int type; }; |
| template <typename> struct add_reference { typedef int type; }; |
| template <typename T> struct next { typedef typename T::next type; }; |
| template <typename> struct size_impl; |
| template <typename T> struct msvc_eti_base : T {}; |
| template <int N> struct long_ { |
| static const int value = N; |
| typedef long_<N + 1> next; |
| }; |
| template <typename Sequence> |
| struct size : msvc_eti_base<typename size_impl< |
| typename Sequence::tag>::template apply<Sequence>> {}; |
| template <typename Base> struct v_item : Base { |
| typedef typename next<typename Base::size>::type size; |
| }; |
| template <typename = int> struct vector0 { |
| typedef int tag; |
| typedef long_<0> size; |
| }; |
| template <> struct size_impl<int> { |
| template <typename Vector> struct apply : Vector::size {}; |
| }; |
| template <typename> struct vector3 : v_item<v_item<v_item<vector0<>>>> {}; |
| template <typename> struct layout { typedef vector3<int> color_space_t; }; |
| template <typename> struct kth_element_const_reference_type; |
| template <typename> struct iterator_adaptor_get_base; |
| template <typename, typename, int> struct homogeneous_color_base; |
| template <typename> struct element_const_reference_type; |
| template <typename Element, typename Layout> |
| struct homogeneous_color_base<Element, Layout, 3> { |
| Element _v0, _v1, _v2; |
| typename element_const_reference_type<homogeneous_color_base>::type |
| at(int_<0>) { |
| return _v0; |
| } |
| typename element_const_reference_type<homogeneous_color_base>::type |
| at(int_<1>) { |
| return _v1; |
| } |
| typename element_const_reference_type<homogeneous_color_base>::type |
| at(int_<2>) { |
| return _v2; |
| } |
| }; |
| template <typename Element, typename Layout, int K1> |
| struct kth_element_const_reference_type< |
| homogeneous_color_base<Element, Layout, K1>> |
| : add_reference<typename add_const<Element>::type> {}; |
| template <int K, typename E, typename L, int N> |
| typename add_reference<typename add_const<E>::type>::type |
| at_c(homogeneous_color_base<E, L, N> p1) { |
| return p1.at(int_<K>()); |
| } |
| template <typename> class memory_based_step_iterator; |
| template <typename> class memory_based_2d_locator; |
| template <typename> class image_view; |
| template <typename, typename> struct pixel; |
| struct iterator_type_from_pixel { |
| typedef pixel<unsigned char, layout<vector3<int>>> *type; |
| }; |
| template <typename XIterator> struct type_from_x_iterator { |
| typedef image_view< |
| memory_based_2d_locator<memory_based_step_iterator<XIterator>>> view_t; |
| }; |
| template <typename> |
| struct element_const_reference_type |
| : kth_element_const_reference_type< |
| homogeneous_color_base<unsigned, layout<int>, 3>> {}; |
| template <typename, typename> |
| struct pixel : homogeneous_color_base<unsigned char, layout<int>, |
| size<layout<int>::color_space_t>::value> { |
| }; |
| template <typename Iterator> |
| struct iterator_adaptor_get_base<memory_based_step_iterator<Iterator>> { |
| typedef Iterator type; |
| }; |
| template <typename> class memory_based_2d_locator { |
| public: |
| typedef iterator_adaptor_get_base<memory_based_step_iterator< |
| pixel<unsigned, layout<vector3<int>>> *>>::type x_iterator; |
| }; |
| template <typename> class image_view { |
| public: |
| typedef memory_based_2d_locator<int>::x_iterator x_iterator; |
| x_iterator row_begin___trans_tmp_2; |
| x_iterator row_begin(int) { return row_begin___trans_tmp_2; } |
| }; |
| template <typename, bool, typename = int> class image { |
| public: |
| typedef type_from_x_iterator<iterator_type_from_pixel::type>::view_t view_t; |
| image(int); |
| }; |
| template <typename Pixel, bool IsPlanar, typename Alloc> |
| typename image<Pixel, 0>::view_t view(image<Pixel, IsPlanar, Alloc>); |
| template <typename Op> void measure_time(Op p1) { |
| for (;;) |
| p1(); |
| } |
| template <typename, typename> struct fill_nongil_t; |
| template <typename T, typename P> |
| struct fill_nongil_t< |
| image_view<memory_based_2d_locator< |
| memory_based_step_iterator<pixel<T, layout<vector3<int>>> *>>>, |
| P> { |
| typedef image_view<memory_based_2d_locator< |
| memory_based_step_iterator<pixel<T, layout<vector3<int>>> *>>> View; |
| View _v; |
| P _p; |
| fill_nongil_t(View p1, P) : _v(p1) {} |
| void operator()() { |
| T *first = (T *)_v.row_begin(0); |
| T last; |
| while (first != &last) { |
| first[0] = at_c<0>(_p); |
| first[1] = at_c<1>(_p); |
| first[2] = at_c<2>(_p); |
| first += 3; |
| } |
| } |
| }; |
| template <typename, typename> void test_fill(int) { |
| image<int, 0>::view_t __trans_tmp_1; |
| image<int, 0> im(0); |
| __trans_tmp_1 = view(im); |
| measure_time(fill_nongil_t< |
| image_view<memory_based_2d_locator<memory_based_step_iterator< |
| pixel<unsigned char, layout<vector3<int>>> *>>>, |
| pixel<unsigned, int>>(__trans_tmp_1, pixel<unsigned, int>())); |
| } |
| void performance_testtest_method() { |
| test_fill<image_view<int>, pixel<unsigned, int>>(0); |
| } |