[creduce-bugs] crash

[John Regehr <regehr@cs.utah.edu>]

$ ~/creduce-install/libexec/clang_delta 
--transformation=empty-struct-to-int --counter=1  small.cpp
Segmentation fault: 11

 
            
            
           
           
           template< typename _Tp>     struct iterator     ;
           template<class _T1, class _T2>     struct pair     {
                   
              ;
          };
         
            
                class new_allocator     {
          public:       
            typedef int value_type;
            template<typename _Tp1>         struct rebind         {
   typedef new_allocator other;
   };
                                                                  };
         
            
           template<typename _Tp>     class allocator: public new_allocator     {};
           template< typename _Arg2>     struct binary_function     ;
           template<typename _Tp>     struct equal_to : public binary_function< _Tp>     {};
         
            
         
      template<typename T> struct atomic_impl ;
      
         template<typename T> struct atomic: atomic_impl<T> {};
          class tbb_allocator ;
         
            
         
      
   template<class Solist, typename Value> class flist_iterator : public iterator< Value> {};
   template< typename Value> class solist_iterator : public flist_iterator<int, Value> {};
   
   template < typename Allocator> class split_ordered_list {
   public:     
       typedef typename Allocator::template rebind<int>::other allocator_type;
       
       typedef solist_iterator< typename allocator_type::value_type> iterator;
   };
    
                       
   
   template <typename Traits> class concurrent_unordered_base : public Traits {
       typedef typename Traits::value_type value_type;
       typedef split_ordered_list< typename Traits::allocator_type> solist_t;
       typedef typename solist_t::iterator iterator;
       using Traits::my_hash_compare;
       using Traits::get_key;
   public:                                   
                 const value_type & insert_value;
void  insert(void) {
            {
                       const int &__trans_tmp_1 = get_key(internal_insert_value);
                       
                       for (;
              ;
              )         ;
                   }
            
            ;
       }
                                                                                             private:                              const value_type & internal_insert_value;

   };
   
      
           class tbb_hash ;
         
      template<   typename Allocator> class concurrent_unordered_map_traits {
   protected:     typedef pair<const int, int> value_type;
       
       typedef typename Allocator::template rebind<value_type>::other allocator_type;
       enum {
   allow_multimapping  };
       template<class Type1, class Type2>     static const int& get_key(const pair<Type1, Type2>& value) ;
       int my_hash_compare;
   };
      template <             typename Allocator = tbb_allocator > class Trans_NS_interface5_concurrent_unordered_multimap :     public concurrent_unordered_base< concurrent_unordered_map_traits<        Allocator> > {};
      
         
         
            class NoAssign {};
            template <typename base_alloc_t > class local_counting_allocator : public base_alloc_t {};
            template < template<typename X> class Allocator = allocator> class debug_allocator : public Allocator<int> {};
            typedef local_counting_allocator<debug_allocator<allocator> > MyAllocator;
            typedef Trans_NS_interface5_concurrent_unordered_multimap<    MyAllocator> MyMultiMap;
            template<typename T> class AssignBody: NoAssign {};
            template<> class AssignBody<int>: NoAssign {
             MyMultiMap &table;
             void operator()(int i) const {
              for(int j = 0;
      0 <  + 1;
      ++j) 
               table.insert();
           
          }
         };