[ 0:00] compiling /home/xrockai/src/divine/nightly/test/libcxx/iterators/trivial_iterators.pass.cpp
[ 0:00] In file included from /home/xrockai/src/divine/nightly/test/libcxx/iterators/trivial_iterators.pass.cpp:24:
[ 0:00] In file included from /dios/libcxx/include/iterator:420:
[ 0:00] In file included from /dios/libcxx/include/iosfwd:95:
[ 0:00] In file included from /dios/libcxx/include/wchar.h:118:
[ 0:00] In file included from /dios/include/wchar.h:9:
[ 0:00] In file included from /dios/include/_PDCLIB/int.h:16:
[ 0:00] /dios/include/_PDCLIB/cdefs.h:69:10: warning: Unsupported _ _cplusplus (__cplusplus) (too new) (supported: ISO/IEC 14882:1997, ISO/IEC 14882:2011).
[ 0:00]         #warning Unsupported _ _cplusplus (__cplusplus) (too new) (supported: ISO/IEC 14882:1997, ISO/IEC 14882:2011).
[ 0:00]          ^
[ 0:00] 1 warning generated.
[ 0:01] compiling /dios/lib/config/seqklee.bc
[ 0:01] setting up pass: functionmeta, options = 
[ 0:02] setting up pass: fuse-ctors, options = 
[ 0:02] KLEE: output directory is "/var/obj/divine-nightly/semidbg/test/__test_work_dir.7/_klee_out"
[ 0:04] KLEE: Using Z3 solver backend
[ 0:04] WARNING: this target does not support the llvm.stacksave intrinsic.
[ 0:04] warning: Linking two modules of different target triples: klee_div_zero_check.bc' is 'x86_64-unknown-linux-gnu' whereas 'klee.bc' is 'x86_64-unknown-none-elf'
[ 0:04] 
[ 0:04] KLEE: WARNING: undefined reference to function: __dios_tainted_init
[ 0:07] KLEE: WARNING: undefined reference to function: klee_free
[ 0:07] KLEE: WARNING: undefined reference to function: klee_malloc
[ 0:07] i:1
[ 0:07] KLEE: WARNING ONCE: Alignment of memory from call "klee_malloc" is not modelled. Using alignment of 8.
[ 0:07] about to __boot:0
[ 0:07] about to run the scheduler:0
[ 0:07] KLEE: WARNING ONCE: calling external: __dios_tainted_init() at /dios/libc/sys/start.cpp:49 5
[ 0:07] KLEE: ERROR: /dios/libc/sys/start.cpp:87: failed external call: __dios_tainted_init
[ 0:07] KLEE: NOTE: now ignoring this error at this location
[ 0:07] KLEE: ERROR: EXITING ON ERROR:
[ 0:07] Error: failed external call: __dios_tainted_init
[ 0:07] File: /dios/libc/sys/start.cpp
[ 0:07] Line: 87
[ 0:07] assembly.ll line: 33960
[ 0:07] Stack: 
[ 0:07] 	#000033960 in __dios_start (l=2, argc=1, argv=94592506163720, envp=94592506224648) at /dios/libc/sys/start.cpp:87
[ 0:07] 	#100009986 in _ZN6__dios10sched_nullINS_5ClockINS_10NondetKleeINS_4BaseEEEEEE13run_schedulerINS_7ContextEEEvv () at /dios/sys/sched_null.hpp:163
[ 0:07] 	#200042225 in klee_boot (argc=2, argv=94592481196800) at /dios/arch/klee/boot.c:41
[ 0:07] 
[ 0:07] 
[ 0:07]      1	/* TAGS: c++ fin */
[ 0:07]      2	/* CC_OPTS: -std=c++2a */
[ 0:07]      3	/* VERIFY_OPTS: -o nofail:malloc */
[ 0:07]      4	//===----------------------------------------------------------------------===//
[ 0:07]      5	//
[ 0:07]      6	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
[ 0:07]      7	// See https://llvm.org/LICENSE.txt for license information.
[ 0:07]      8	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
[ 0:07]      9	//
[ 0:07]     10	//===----------------------------------------------------------------------===//
[ 0:07]     11	//
[ 0:07]     12	
[ 0:07]     13	// <iterator>
[ 0:07]     14	
[ 0:07]     15	// __libcpp_is_trivial_iterator<Tp>
[ 0:07]     16	
[ 0:07]     17	// __libcpp_is_trivial_iterator determines if an iterator is a "trivial" one,
[ 0:07]     18	// that can be used w/o worrying about its operations throwing exceptions.
[ 0:07]     19	// Pointers are trivial iterators. Libc++ has three "iterator wrappers":
[ 0:07]     20	// reverse_iterator, move_iterator, and __wrap_iter. If the underlying iterator
[ 0:07]     21	// is trivial, then those are as well.
[ 0:07]     22	//
[ 0:07]     23	
[ 0:07]     24	#include <iterator>
[ 0:07]     25	#include <cassert>
[ 0:07]     26	#include <string>
[ 0:07]     27	#include <vector>
[ 0:07]     28	#include <initializer_list>
[ 0:07]     29	
[ 0:07]     30	#include "test_macros.h"
[ 0:07]     31	#include "test_iterators.h"
[ 0:07]     32	
[ 0:07]     33	#if TEST_STD_VER >= 11
[ 0:07]     34	#define DELETE_FUNCTION = delete
[ 0:07]     35	#else
[ 0:07]     36	#define DELETE_FUNCTION
[ 0:07]     37	#endif
[ 0:07]     38	
[ 0:07]     39	class T;  // incomplete
[ 0:07]     40	
[ 0:07]     41	class my_input_iterator_tag : public std::input_iterator_tag {};
[ 0:07]     42	
[ 0:07]     43	template <class It>
[ 0:07]     44	class my_input_iterator
[ 0:07]     45	{
[ 0:07]     46	    It it_;
[ 0:07]     47	
[ 0:07]     48	    template <class U> friend class my_input_iterator;
[ 0:07]     49	public:
[ 0:07]     50	    typedef          my_input_iterator_tag                     iterator_category;
[ 0:07]     51	    typedef typename std::iterator_traits<It>::value_type      value_type;
[ 0:07]     52	    typedef typename std::iterator_traits<It>::difference_type difference_type;
[ 0:07]     53	    typedef It                                                 pointer;
[ 0:07]     54	    typedef typename std::iterator_traits<It>::reference       reference;
[ 0:07]     55	
[ 0:07]     56	    It base() const {return it_;}
[ 0:07]     57	
[ 0:07]     58	    my_input_iterator() : it_() {}
[ 0:07]     59	    explicit my_input_iterator(It it) : it_(it) {}
[ 0:07]     60	    template <class U>
[ 0:07]     61	        my_input_iterator(const my_input_iterator<U>& u) :it_(u.it_) {}
[ 0:07]     62	
[ 0:07]     63	    reference operator*() const {return *it_;}
[ 0:07]     64	    pointer operator->() const {return it_;}
[ 0:07]     65	
[ 0:07]     66	    my_input_iterator& operator++() {++it_; return *this;}
[ 0:07]     67	    my_input_iterator operator++(int)
[ 0:07]     68	        {my_input_iterator tmp(*this); ++(*this); return tmp;}
[ 0:07]     69	
[ 0:07]     70	    friend bool operator==(const my_input_iterator& x, const my_input_iterator& y)
[ 0:07]     71	        {return x.it_ == y.it_;}
[ 0:07]     72	    friend bool operator!=(const my_input_iterator& x, const my_input_iterator& y)
[ 0:07]     73	        {return !(x == y);}
[ 0:07]     74	
[ 0:07]     75	    template <class T>
[ 0:07]     76	    void operator,(T const &) DELETE_FUNCTION;
[ 0:07]     77	};
[ 0:07]     78	
[ 0:07]     79	template <class T, class U>
[ 0:07]     80	inline
[ 0:07]     81	bool
[ 0:07]     82	operator==(const my_input_iterator<T>& x, const my_input_iterator<U>& y)
[ 0:07]     83	{
[ 0:07]     84	    return x.base() == y.base();
[ 0:07]     85	}
[ 0:07]     86	
[ 0:07]     87	template <class T, class U>
[ 0:07]     88	inline
[ 0:07]     89	bool
[ 0:07]     90	operator!=(const my_input_iterator<T>& x, const my_input_iterator<U>& y)
[ 0:07]     91	{
[ 0:07]     92	    return !(x == y);
[ 0:07]     93	}
[ 0:07]     94	
[ 0:07]     95	
[ 0:07]     96	int main(int, char**)
[ 0:07]     97	{
[ 0:07]     98	//  basic tests
[ 0:07]     99	    static_assert(( std::__libcpp_is_trivial_iterator<char *>::value), "");
[ 0:07]    100	    static_assert(( std::__libcpp_is_trivial_iterator<const char *>::value), "");
[ 0:07]    101	    static_assert(( std::__libcpp_is_trivial_iterator<int *>::value), "");
[ 0:07]    102	    static_assert(( std::__libcpp_is_trivial_iterator<T *>::value), "");
[ 0:07]    103	
[ 0:07]    104	    static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<char *> >      ::value), "");
[ 0:07]    105	    static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<const char *> >::value), "");
[ 0:07]    106	    static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<int *> >       ::value), "");
[ 0:07]    107	    static_assert(( std::__libcpp_is_trivial_iterator<std::move_iterator<T *> >         ::value), "");
[ 0:07]    108	
[ 0:07]    109	    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<char *> >      ::value), "");
[ 0:07]    110	    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<const char *> >::value), "");
[ 0:07]    111	    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<int *> >       ::value), "");
[ 0:07]    112	    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<T *> >         ::value), "");
[ 0:07]    113	
[ 0:07]    114	    static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<char *> >      ::value), "");
[ 0:07]    115	    static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<const char *> >::value), "");
[ 0:07]    116	    static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<int *> >       ::value), "");
[ 0:07]    117	    static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<T *> >         ::value), "");
[ 0:07]    118	
[ 0:07]    119	    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), "");
[ 0:07]    120	
[ 0:07]    121	//  iterators in the libc++ test suite
[ 0:07]    122	    static_assert((!std::__libcpp_is_trivial_iterator<output_iterator       <char *> >::value), "");
[ 0:07]    123	    static_assert((!std::__libcpp_is_trivial_iterator<input_iterator        <char *> >::value), "");
[ 0:07]    124	    static_assert((!std::__libcpp_is_trivial_iterator<forward_iterator      <char *> >::value), "");
[ 0:07]    125	    static_assert((!std::__libcpp_is_trivial_iterator<bidirectional_iterator<char *> >::value), "");
[ 0:07]    126	    static_assert((!std::__libcpp_is_trivial_iterator<random_access_iterator<char *> >::value), "");
[ 0:07]    127	    static_assert((!std::__libcpp_is_trivial_iterator<ThrowingIterator      <char *> >::value), "");
[ 0:07]    128	    static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator   <char *> >::value), "");
[ 0:07]    129	
[ 0:07]    130	
[ 0:07]    131	//  Iterator classification
[ 0:07]    132	    static_assert(( std::__is_input_iterator        <char *>::value), "" );
[ 0:07]    133	    static_assert(( std::__is_forward_iterator      <char *>::value), "" );
[ 0:07]    134	    static_assert(( std::__is_bidirectional_iterator<char *>::value), "" );
[ 0:07]    135	    static_assert(( std::__is_random_access_iterator<char *>::value), "" );
[ 0:07]    136	    static_assert((!std::__is_exactly_input_iterator<char *>::value), "" );
[ 0:07]    137	
[ 0:07]    138	    static_assert(( std::__is_input_iterator        <input_iterator<char *> >::value), "" );
[ 0:07]    139	    static_assert((!std::__is_forward_iterator      <input_iterator<char *> >::value), "" );
[ 0:07]    140	    static_assert((!std::__is_bidirectional_iterator<input_iterator<char *> >::value), "" );
[ 0:07]    141	    static_assert((!std::__is_random_access_iterator<input_iterator<char *> >::value), "" );
[ 0:07]    142	    static_assert(( std::__is_exactly_input_iterator<input_iterator<char *> >::value), "" );
[ 0:07]    143	
[ 0:07]    144	    static_assert(( std::__is_input_iterator        <forward_iterator<char *> >::value), "" );
[ 0:07]    145	    static_assert(( std::__is_forward_iterator      <forward_iterator<char *> >::value), "" );
[ 0:07]    146	    static_assert((!std::__is_bidirectional_iterator<forward_iterator<char *> >::value), "" );
[ 0:07]    147	    static_assert((!std::__is_random_access_iterator<forward_iterator<char *> >::value), "" );
[ 0:07]    148	    static_assert((!std::__is_exactly_input_iterator<forward_iterator<char *> >::value), "" );
[ 0:07]    149	
[ 0:07]    150	    static_assert(( std::__is_input_iterator        <bidirectional_iterator<char *> >::value), "" );
[ 0:07]    151	    static_assert(( std::__is_forward_iterator      <bidirectional_iterator<char *> >::value), "" );
[ 0:07]    152	    static_assert(( std::__is_bidirectional_iterator<bidirectional_iterator<char *> >::value), "" );
[ 0:07]    153	    static_assert((!std::__is_random_access_iterator<bidirectional_iterator<char *> >::value), "" );
[ 0:07]    154	    static_assert((!std::__is_exactly_input_iterator<bidirectional_iterator<char *> >::value), "" );
[ 0:07]    155	
[ 0:07]    156	    static_assert(( std::__is_input_iterator        <random_access_iterator<char *> >::value), "" );
[ 0:07]    157	    static_assert(( std::__is_forward_iterator      <random_access_iterator<char *> >::value), "" );
[ 0:07]    158	    static_assert(( std::__is_bidirectional_iterator<random_access_iterator<char *> >::value), "" );
[ 0:07]    159	    static_assert(( std::__is_random_access_iterator<random_access_iterator<char *> >::value), "" );
[ 0:07]    160	    static_assert((!std::__is_exactly_input_iterator<random_access_iterator<char *> >::value), "" );
[ 0:07]    161	
[ 0:07]    162	    static_assert(( std::__is_input_iterator        <my_input_iterator<char *> >::value), "" );
[ 0:07]    163	    static_assert((!std::__is_forward_iterator      <my_input_iterator<char *> >::value), "" );
[ 0:07]    164	    static_assert((!std::__is_bidirectional_iterator<my_input_iterator<char *> >::value), "" );
[ 0:07]    165	    static_assert((!std::__is_random_access_iterator<my_input_iterator<char *> >::value), "" );
[ 0:07]    166	    static_assert(( std::__is_exactly_input_iterator<my_input_iterator<char *> >::value), "" );
[ 0:07]    167	
[ 0:07]    168	//
[ 0:07]    169	//  iterators from libc++'s containers
[ 0:07]    170	//
[ 0:07]    171	
[ 0:07]    172	//  string
[ 0:07]    173	    static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::iterator>              ::value), "");
[ 0:07]    174	    static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::const_iterator>        ::value), "");
[ 0:07]    175	    static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::reverse_iterator>      ::value), "");
[ 0:07]    176	    static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::const_reverse_iterator>::value), "");
[ 0:07]    177	
[ 0:07]    178	//  vector
[ 0:07]    179	    static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::iterator>              ::value), "");
[ 0:07]    180	    static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::const_iterator>        ::value), "");
[ 0:07]    181	    static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::reverse_iterator>      ::value), "");
[ 0:07]    182	    static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::const_reverse_iterator>::value), "");
[ 0:07]    183	
[ 0:07]    184	#if TEST_STD_VER >= 11
[ 0:07]    185	//  Initializer list  (which has no reverse iterators)
[ 0:07]    186	    static_assert(( std::__libcpp_is_trivial_iterator<std::initializer_list<char>::iterator>              ::value), "");
[ 0:07]    187	    static_assert(( std::__libcpp_is_trivial_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
[ 0:07]    188	#endif
[ 0:07]    189	
[ 0:07]    190	
[ 0:07]    191	  return 0;
[ 0:07]    192	}
[ 0:07] # no errors were expected but one was found anyway