[Bug c++/50464] New: Using -Ofast -march=bdver1 results in internal compiler error: in extract_insn, at recog.c:2109

[geir at cray dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=50464

             Bug #: 50464
           Summary: Using -Ofast -march=bdver1 results in internal
                    compiler error: in extract_insn, at recog.c:2109
    Classification: Unclassified
           Product: gcc
           Version: 4.6.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: geir@cray.com


Compiling following reduced test case gets the compiler error:

DataspaceIdentifier.cpp: In function 'void createDataspaceIdentifier()':
DataspaceIdentifier.cpp:172:1: error: unrecognizable insn:
(insn 88 87 89 11 (set:V2DI (reg:V2DI 144)
        (if_then_else:V2DI (reg:V2DI 146)
            (const_vector:V2DI [
                    (const_int -1 [0xffffffffffffffff])
                    (const_int -1 [0xffffffffffffffff])
                ])
            (reg:V2DI 122 [ vect_var_.44 ]))) DataspaceIdentifier.cpp:155 -1
     (nil))
DataspaceIdentifier.cpp:172:1: internal compiler error: in extract_insn, at
recog.c:2109
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://gcc.gnu.org/bugs.html> for instructions.


$ g++ --version
g++ (GCC) 4.6.1 20110627 (Cray Inc.)
Copyright (C) 2011 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ cat DataspaceIdentifier.cpp

typedef long unsigned int size_t;
typedef unsigned long ulong_t;
typedef signed long slong_t;

extern "C++" {
  void* operator new(size_t);
}

  template<typename _Iterator>
    struct iterator_traits
    {
      typedef typename _Iterator::reference reference;
    };

  template<typename _Tp>
    struct iterator_traits<_Tp*>
    {
      typedef _Tp& reference;
    };

  template<typename _Iterator, typename _Container>
    class __normal_iterator
    {
    protected:
      _Iterator _M_current;
      typedef iterator_traits<_Iterator> __traits_type;

    public:
      typedef typename __traits_type::reference reference;

      explicit
      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

      reference
      operator*() const
      { return *_M_current; }

      __normal_iterator&
      operator++()
      {
         ++_M_current;
         return *this;
      }

      const _Iterator&
      base() const
      { return _M_current; }
    };

  template<typename _Iterator, typename _Container>
    inline bool
    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    { return __lhs.base() != __rhs.base(); }

  template<typename _Tp>
    class allocator
    {
    public:
      typedef _Tp* pointer;
      typedef _Tp value_type;

      template<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };

       pointer allocate(size_t __n, const void* = 0)
       {
          return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
       }
    };

  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;

      struct _Vector_impl
      : public _Tp_alloc_type
      {
        typename _Tp_alloc_type::pointer _M_start;
        typename _Tp_alloc_type::pointer _M_finish;
        typename _Tp_alloc_type::pointer _M_end_of_storage;

        _Vector_impl(_Tp_alloc_type const& __a) { }
      };

    public:
      typedef _Alloc allocator_type;

      _Vector_base(size_t __n, const allocator_type& __a)
      : _M_impl(__a)
      {
        this->_M_impl._M_start = this->_M_allocate(__n);
        this->_M_impl._M_finish = this->_M_impl._M_start;
        this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
      }

    public:
      _Vector_impl _M_impl;

      typename _Tp_alloc_type::pointer
      _M_allocate(size_t __n)
      { return __n != 0 ? _M_impl.allocate(__n) : 0; }

    };

  template<typename _Tp, typename _Alloc = allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {
      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;

    public:
      typedef _Tp value_type;
      typedef typename _Tp_alloc_type::pointer pointer;
      typedef __normal_iterator<pointer, vector> iterator;
      typedef _Alloc allocator_type;

    protected:
      using _Base::_M_allocate;
      using _Base::_M_impl;

    public:

      explicit
      vector(size_t __n, const value_type& __value = value_type(),
      const allocator_type& __a = allocator_type())
      : _Base(__n, __a)
      { _M_fill_initialize(__n, __value); }

      iterator begin()
      { return iterator(this->_M_impl._M_start); }

      iterator end()
      { return iterator(this->_M_impl._M_finish); }

    protected:
      void
      _M_fill_initialize(size_t __n, const value_type& __value)
      {
         this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
      }
    };

  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    _OutputIterator
    replace_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result,
   const _Tp& __old_value, const _Tp& __new_value)
    {
      ;
      for (; __first != __last; ++__first, ++__result)
         if (*__first == __old_value)
            *__result = __new_value;
         else
            *__result = *__first;
      return __result;
    }

extern size_t shape_rank;

void createDataspaceIdentifier()
{
  vector< ulong_t > dataspaceDims( shape_rank );
  vector< ulong_t > maxDataspaceDims( shape_rank );

  replace_copy(
    dataspaceDims.begin(), dataspaceDims.end(),
    maxDataspaceDims.begin(), ulong_t( 0 ), ((ulong_t)(slong_t)(-1)) );
}

$ g++ -Ofast -march=bdver1 -c DataspaceIdentifier.cpp
DataspaceIdentifier.cpp: In function 'void createDataspaceIdentifier()':
DataspaceIdentifier.cpp:172:1: error: unrecognizable insn:
(insn 88 87 89 11 (set:V2DI (reg:V2DI 144)
        (if_then_else:V2DI (reg:V2DI 146)
            (const_vector:V2DI [
                    (const_int -1 [0xffffffffffffffff])
                    (const_int -1 [0xffffffffffffffff])
                ])
            (reg:V2DI 122 [ vect_var_.44 ]))) DataspaceIdentifier.cpp:155 -1
     (nil))
DataspaceIdentifier.cpp:172:1: internal compiler error: in extract_insn, at
recog.c:2109
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://gcc.gnu.org/bugs.html> for instructions.
$ g++ -march=bdver1 -c DataspaceIdentifier.cpp
$