1 /* { dg-do compile } */ 2 /* { dg-options "-Wuninitialized -O2" } */ 3 4 namespace std { 5 typedef __SIZE_TYPE__ size_t; 6 } 7 extern "C++" { new(std::size_t,void * __p)8 inline void* operator new(std::size_t, void* __p) throw() { 9 return __p; 10 } 11 } 12 namespace boost{ 13 __extension__ typedef long long long_long_type; 14 } 15 namespace mpl_ { 16 namespace aux { 17 } 18 } 19 namespace boost { 20 namespace mpl { 21 using namespace mpl_; 22 } 23 } 24 namespace mpl_ { 25 struct integral_c_tag { 26 }; 27 template< int N > struct int_ { 28 }; 29 } 30 namespace boost { 31 namespace mpl { 32 } 33 } 34 namespace mpl_ { 35 template< bool C_ > struct bool_; 36 typedef bool_<true> true_; 37 typedef bool_<false> false_; 38 } 39 namespace mpl_ { 40 template< bool C_ > struct bool_ { 41 static const bool value = C_; 42 }; 43 template< typename T, T N > struct integral_c { 44 static const T value = N; 45 }; 46 } 47 namespace boost{ 48 template <class T, T val> struct integral_constant : public mpl::integral_c<T, val> { 49 }; 50 template<> struct integral_constant<bool,false> : public mpl::false_ { 51 typedef integral_constant<bool,false> type; 52 }; 53 template< typename T > struct is_lvalue_reference : ::boost::integral_constant<bool,false> { 54 }; 55 template< typename T > struct is_rvalue_reference : ::boost::integral_constant<bool,false> { 56 }; 57 namespace type_traits { 58 template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false> struct ice_or; 59 template <> struct ice_or<false, false, false, false, false, false, false> { 60 static const bool value = false; 61 }; 62 } 63 } 64 namespace boost { 65 namespace detail { 66 template <typename T> struct is_reference_impl { 67 static const bool value = (::boost::type_traits::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value) ; 68 }; 69 } 70 template< typename T > struct is_reference : ::boost::integral_constant<bool,::boost::detail::is_reference_impl<T>::value> { 71 }; 72 namespace detail { 73 template< typename T > struct alignment_of_impl { 74 static const std::size_t value = __alignof__(T); 75 }; 76 } 77 template< typename T > struct alignment_of : ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { 78 }; 79 } 80 namespace mpl_ { 81 struct na { 82 }; 83 } 84 namespace boost { 85 namespace mpl { 86 } 87 } 88 namespace boost { 89 namespace mpl { 90 template< bool C , typename T1 , typename T2 > struct if_c { 91 typedef T1 type; 92 }; 93 template< typename T1 , typename T2 > struct if_c<false,T1,T2> { 94 typedef T2 type; 95 }; 96 template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ { 97 private: typedef if_c< static_cast<bool>(T1::value) , T2 , T3 > almost_type_; 98 public: typedef typename almost_type_::type type; 99 }; 100 } 101 } 102 namespace boost{ 103 template <bool x> struct STATIC_ASSERTION_FAILURE; 104 template <> struct STATIC_ASSERTION_FAILURE<true> { 105 }; 106 template<int x> struct static_assert_test{ 107 }; 108 namespace detail { 109 class alignment_dummy; 110 typedef void (*function_ptr)(); 111 typedef int (alignment_dummy::*member_ptr); 112 typedef int (alignment_dummy::*member_function_ptr)(); 113 template <bool found, std::size_t target, class TestType> struct lower_alignment_helper { 114 typedef char type; 115 enum { value = true }; 116 }; 117 template <std::size_t target, class TestType> struct lower_alignment_helper<false,target,TestType> { 118 enum { value = (alignment_of<TestType>::value == target) }; 119 typedef typename mpl::if_c<value, TestType, char>::type type; 120 }; 121 template <typename T> struct has_one_T { 122 T data; 123 }; 124 template <std::size_t target> union lower_alignment { 125 enum { found0 = false }; 126 typename lower_alignment_helper< found0,target,char >::type t0; 127 enum { found1 = lower_alignment_helper<found0,target,char >::value }; 128 typename lower_alignment_helper< found1,target,short >::type t1; 129 enum { found2 = lower_alignment_helper<found1,target,short >::value }; 130 typename lower_alignment_helper< found2,target,int >::type t2; 131 enum { found3 = lower_alignment_helper<found2,target,int >::value }; 132 typename lower_alignment_helper< found3,target,long >::type t3; 133 enum { found4 = lower_alignment_helper<found3,target,long >::value }; 134 typename lower_alignment_helper< found4,target,::boost::long_long_type >::type t4; 135 enum { found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value }; 136 typename lower_alignment_helper< found5,target,float >::type t5; 137 enum { found6 = lower_alignment_helper<found5,target,float >::value }; 138 typename lower_alignment_helper< found6,target,double >::type t6; 139 enum { found7 = lower_alignment_helper<found6,target,double >::value }; 140 typename lower_alignment_helper< found7,target,long double >::type t7; 141 enum { found8 = lower_alignment_helper<found7,target,long double >::value }; 142 typename lower_alignment_helper< found8,target,void* >::type t8; 143 enum { found9 = lower_alignment_helper<found8,target,void* >::value }; 144 typename lower_alignment_helper< found9,target,function_ptr >::type t9; 145 enum { found10 = lower_alignment_helper<found9,target,function_ptr >::value }; 146 typename lower_alignment_helper< found10,target,member_ptr >::type t10; 147 enum { found11 = lower_alignment_helper<found10,target,member_ptr >::value }; 148 typename lower_alignment_helper< found11,target,member_function_ptr >::type t11; 149 enum { found12 = lower_alignment_helper<found11,target,member_function_ptr >::value }; 150 typename lower_alignment_helper< found12,target,boost::detail::has_one_T< char > >::type t12; 151 enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value }; 152 typename lower_alignment_helper< found13,target,boost::detail::has_one_T< short > >::type t13; 153 enum { found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value }; 154 typename lower_alignment_helper< found14,target,boost::detail::has_one_T< int > >::type t14; 155 enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value }; 156 typename lower_alignment_helper< found15,target,boost::detail::has_one_T< long > >::type t15; 157 enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value }; 158 typename lower_alignment_helper< found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::type t16; 159 enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value }; 160 typename lower_alignment_helper< found17,target,boost::detail::has_one_T< float > >::type t17; 161 enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value }; 162 typename lower_alignment_helper< found18,target,boost::detail::has_one_T< double > >::type t18; 163 enum { found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T< double > >::value }; 164 typename lower_alignment_helper< found19,target,boost::detail::has_one_T< long double > >::type t19; 165 enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value }; 166 typename lower_alignment_helper< found20,target,boost::detail::has_one_T< void* > >::type t20; 167 enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T< void* > >::value }; 168 typename lower_alignment_helper< found21,target,boost::detail::has_one_T< function_ptr > >::type t21; 169 enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T< function_ptr > >::value }; 170 typename lower_alignment_helper< found22,target,boost::detail::has_one_T< member_ptr > >::type t22; 171 enum { found23 = lower_alignment_helper<found22,target,boost::detail::has_one_T< member_ptr > >::value }; 172 typename lower_alignment_helper< found23,target,boost::detail::has_one_T< member_function_ptr > >::type t23; 173 enum { found24 = lower_alignment_helper<found23,target,boost::detail::has_one_T< member_function_ptr > >::value }; 174 }; 175 union max_align { 176 }; 177 template<std::size_t TAlign, std::size_t Align> struct is_aligned { 178 static const bool value = (TAlign >= Align) & (TAlign % Align == 0) ; 179 }; 180 template <std::size_t Align> class type_with_alignment_imp { 181 typedef ::boost::detail::lower_alignment<Align> t1; 182 typedef typename mpl::if_c< ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value , t1 , ::boost::detail::max_align >::type align_t; 183 static const std::size_t found = alignment_of<align_t>::value; 184 typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found >= Align) == 0 ? false : true) >)> boost_static_assert_typedef_206; 185 typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found % Align == 0) == 0 ? false : true) >)> boost_static_assert_typedef_207; 186 public: typedef align_t type; 187 }; 188 } 189 template <std::size_t Align> class type_with_alignment : public ::boost::detail::type_with_alignment_imp<Align> { 190 }; 191 } 192 namespace boost { 193 namespace detail{ 194 } 195 template< typename T > struct remove_reference { 196 }; 197 } 198 namespace boost { 199 namespace mpl { 200 namespace aux { 201 template< typename T > struct nested_type_wknd : T::type { }; 202 } 203 } 204 namespace mpl { 205 namespace aux { 206 template< long C_ > struct not_impl : bool_<!C_> { }; 207 } 208 template< typename T = na > struct not_ : aux::not_impl< ::boost::mpl::aux::nested_type_wknd<T>::value > { 209 }; 210 } 211 namespace detail { 212 template <typename T> struct make_reference_content { 213 typedef T type; 214 }; 215 } 216 namespace detail { 217 struct none_helper{ 218 }; 219 } 220 typedef int detail::none_helper::*none_t ; 221 } 222 namespace boost_optional_detail { 223 template <class T, class Factory> inline void construct(Factory const& factory, void* address) { 224 } 225 } 226 namespace boost { 227 class in_place_factory_base ; 228 class typed_in_place_factory_base ; 229 namespace optional_detail { 230 template <class T> class aligned_storage { 231 union __attribute__((may_alias)) dummy_u { char data[ sizeof(T) ]; typename type_with_alignment< ::boost::alignment_of<T>::value >::type aligner_; } 232 dummy_ ; 233 public: void const* address() const { return &dummy_; } 234 void * address() { return &dummy_; } 235 } 236 ; 237 template<class T> struct types_when_isnt_ref { 238 typedef T const& reference_const_type ; 239 typedef T & reference_type ; 240 typedef T const* pointer_const_type ; 241 typedef T * pointer_type ; 242 typedef T const& argument_type ; 243 } 244 ; 245 template<class T> struct types_when_is_ref { 246 typedef typename remove_reference<T>::type raw_type ; 247 typedef raw_type& reference_const_type ; 248 typedef raw_type& argument_type ; 249 } 250 ; 251 struct optional_tag { 252 } 253 ; 254 template<class T> struct optional_base : public optional_tag { 255 typedef typename ::boost::detail::make_reference_content<T>::type internal_type ; 256 typedef aligned_storage<internal_type> storage_type ; 257 typedef types_when_isnt_ref<T> types_when_not_ref ; 258 typedef types_when_is_ref<T> types_when_ref ; 259 typedef optional_base<T> this_type ; 260 typedef T value_type ; 261 typedef mpl::true_ is_reference_tag ; 262 typedef mpl::false_ is_not_reference_tag ; 263 typedef typename is_reference<T>::type is_reference_predicate ; 264 typedef typename mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ; 265 typedef bool (this_type::*unspecified_bool_type)() const; 266 typedef typename types::reference_type reference_type ; 267 typedef typename types::reference_const_type reference_const_type ; 268 typedef typename types::pointer_type pointer_type ; 269 typedef typename types::pointer_const_type pointer_const_type ; 270 typedef typename types::argument_type argument_type ; 271 optional_base() : m_initialized(false) {} 272 optional_base ( argument_type val ) : m_initialized(false) { construct(val); } 273 optional_base ( bool cond, argument_type val ) : m_initialized(false) { if ( cond ) construct(val); } 274 optional_base ( optional_base const& rhs ) : m_initialized(false) { if ( rhs.is_initialized() ) construct(rhs.get_impl()); } 275 pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; } 276 pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; } 277 bool is_initialized() const { return m_initialized ; } 278 void construct ( argument_type val ) { new (m_storage.address()) internal_type(val) ; m_initialized = true ; } 279 template<class Expr> void construct ( Expr const& factory, in_place_factory_base const* ) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::mpl::not_<is_reference_predicate>::value) == 0 ? false : true) >)> boost_static_assert_typedef_355 ; boost_optional_detail::construct<value_type>(factory, m_storage.address()); m_initialized = true ; } 280 template<class Expr> void construct ( Expr const& factory, typed_in_place_factory_base const* ) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::mpl::not_<is_reference_predicate>::value) == 0 ? false : true) >)> boost_static_assert_typedef_364 ; factory.apply(m_storage.address()) ; m_initialized = true ; } 281 void destroy() { } 282 unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; } 283 reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; } 284 reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; } 285 pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; } 286 pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; } 287 internal_type const* get_object() const { union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() }; return caster.as_ptype; } 288 internal_type * get_object() { union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() }; return caster.as_ptype; } 289 reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; } 290 pointer_type cast_ptr( internal_type * p, is_reference_tag ) { return &p->get() ; } 291 bool m_initialized ; 292 storage_type m_storage ; 293 } 294 ; 295 } 296 template<class T> class optional : public optional_detail::optional_base<T> { 297 typedef optional_detail::optional_base<T> base ; 298 public : typedef optional<T> this_type ; 299 typedef typename base::reference_const_type reference_const_type ; 300 reference_const_type get() const { 301 (static_cast<void> (0)) ; 302 return this->get_impl(); 303 } 304 reference_const_type operator *() const { 305 return this->get() ; 306 } 307 bool operator!() const { 308 return !this->is_initialized() ; 309 } 310 } 311 ; 312 template<class OptionalPointee> inline bool equal_pointees2 ( OptionalPointee const& x, OptionalPointee const& y ) { 313 return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ; 314 } 315 template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) { 316 return equal_pointees2(x,y); 317 } 318 template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) { 319 return !( x == y ) ; 320 } 321 } 322 ::boost::optional< std::size_t > getitem(); 323 class BAR { 324 public: int FOO(); 325 private: ::boost::optional< std::size_t > m_aHoveredItem; 326 }; 327 int BAR::FOO() { 328 ::boost::optional< std::size_t > aOldItem(getitem()); 329 ::boost::optional< std::size_t > aNewItem(m_aHoveredItem); 330 if (aOldItem != aNewItem) return 1; 331 return 0; 332 } 333 334