virtual bool
do_is_equal(const memory_resource& __other) const noexcept override
{
+#if __cpp_rtti
if (auto __p = dynamic_cast<const __resource_adaptor_imp*>(&__other))
return _M_alloc == __p->_M_alloc;
+#else
+ if (this == &__other) // Need RTTI to do better than this.
+ return true;
+#endif
return false;
}
{
std::exception e;
+#if __cpp_rtti
const char* str __attribute__((unused)) = typeid(e).name();
-
+#endif
+
typedef std::numeric_limits<long> limit_type;
limit_type limit_l __attribute__((unused));
int r __attribute__((unused)) = limit_type::radix;
} catch(...) {
__cxa_exception *exc = __cxa_get_globals()->caughtExceptions;
VERIFY ( exc != 0 );
+#if __cpp_rtti
VERIFY ( typeid(int) == *exc->exceptionType );
+#endif
}
try {
throw 0LL;
} catch(...) {
__cxa_exception *exc = __cxa_get_globals()->caughtExceptions;
VERIFY ( exc != 0 );
+#if __cpp_rtti
VERIFY ( typeid(long long int) == *exc->exceptionType );
+#endif
}
try {
throw 0.0;
} catch(...) {
__cxa_exception *exc = __cxa_get_globals()->caughtExceptions;
VERIFY ( exc != 0 );
+#if __cpp_rtti
VERIFY ( typeid(double) == *exc->exceptionType );
+#endif
}
}
try {
rethrow_exception(make_exception_ptr(runtime_error("test")));
} catch(exception &e) {
+#if __cpp_rtti
VERIFY( typeid(e) == typeid(runtime_error) );
+#endif
VERIFY( strcmp(e.what(), "test") == 0 );
}
}
// { dg-do compile { target c++11 } }
+// { dg-require-effective-target rtti }
// Copyright (C) 2015-2022 Free Software Foundation, Inc.
//
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
// Copyright (C) 2009-2022 Free Software Foundation, Inc.
//
struct derived2 : base, std::nested_exception { };
-void test01()
+void test01()
{
bool test = false;
VERIFY( test );
}
-void test02()
+void test02()
{
bool test = false;
VERIFY( test );
}
-void test03()
+void test03()
{
bool test = false;
// { dg-do run }
// { dg-require-sharedlib "" }
+// { dg-require-effective-target rtti }
// { dg-options "./testsuite_shared.so" }
#include <typeinfo>
// { dg-do run { target c++11 } }
// { dg-require-effective-target dfp }
+// { dg-require-effective-target rtti }
// 2011-02-23 Benjamin Kosnik <bkoz@redhat.com>
//
template<typename _Tp>
std::string
gen_type_info()
- {
- std::string s1 = typeid(_Tp).name();
- std::string s2 = typeid(_Tp*).name();
- std::string s3 = typeid(const _Tp*).name();
+ {
+ std::string s1 = typeid(_Tp).name();
+ std::string s2 = typeid(_Tp*).name();
+ std::string s3 = typeid(const _Tp*).name();
return std::max(std::max(s1, s2), s3);
}
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
// 2010-09-21 Paolo Carlini <paolo.carlini@oracle.com>
//
combined& c2 = std::any_cast<combined&>(o5);
VERIFY(c2.v[0] == 1 && c2.v[1] == 2
&& std::get<0>(c2.t) == 3 && std::get<1>(c2.t) == 4 );
+#if __cpp_rtti
std::any o6;
o6.emplace<const int&>(i);
VERIFY(o6.type() == o.type());
std::any o10;
o10.emplace<char*>(nullptr);
VERIFY(o9.type() == o10.type());
+#endif
std::any o11;
VERIFY(&o11.emplace<int>(42) == &std::any_cast<int&>(o11));
VERIFY(&o11.emplace<std::vector<int>>({1,2,3}) ==
combined& c2 = std::any_cast<combined&>(o5);
VERIFY(c2.v[0] == 1 && c2.v[1] == 2
&& std::get<0>(c2.t) == 3 && std::get<1>(c2.t) == 4 );
+#if __cpp_rtti
std::any o6(std::in_place_type<int&>, i);
VERIFY(o6.type() == o.type());
std::any o7(std::in_place_type<void()>, nullptr);
std::any o9(std::in_place_type<char(&)[42]>, nullptr);
std::any o10(std::in_place_type<char*>, nullptr);
VERIFY(o9.type() == o10.type());
+#endif
}
{
int arr[3];
any a(arr);
+#if __cpp_rtti
VERIFY( a.type() == typeid(int*) ); // contained value is decayed
+#endif
int (*p1)[3] = any_cast<int[3]>(&a);
+#if __cpp_rtti
VERIFY( a.type() != typeid(int[3]) ); // so any_cast should return nullptr
+#endif
VERIFY( p1 == nullptr );
int (*p2)[] = any_cast<int[]>(&a);
+#if __cpp_rtti
VERIFY( a.type() != typeid(int[]) ); // so any_cast should return nullptr
+#endif
VERIFY( p2 == nullptr );
const int (*p3)[] = any_cast<int[]>(&std::as_const(a));
VERIFY( p3 == nullptr );
// { dg-do run { target c++17 } }
+// { dg-require-effective-target rtti }
// Copyright (C) 2014-2022 Free Software Foundation, Inc.
//
}
VERIFY( thrown );
+#if __cpp_rtti
// target_type returns typeid(void)
VERIFY( f1.target_type() == typeid(void) );
+#endif
// target() always returns a NULL pointer
VERIFY( f1.target<int (*)(float)>() == 0);
// target_type and target() functions
const function<int(float)>& f1c = f1;
+#if __cpp_rtti
VERIFY( typeid(int(*)(float)) == f1.target_type() );
+#endif
VERIFY( f2.target<int(*)(float)>() != 0 );
VERIFY( *f2.target<int(*)(float)>() == &truncate_float );
VERIFY( f1c.target<int(*)(float)>() != 0 );
// target_type and target() functions
const function<int(float)>& f1c = f1;
+#if __cpp_rtti
VERIFY( typeid(long(*)(double)) == f1.target_type() );
+#endif
VERIFY( f2.target<long(*)(double)>() != 0 );
VERIFY( *f2.target<long(*)(double)>() == &truncate_double );
VERIFY( f1c.target<long(*)(double)>() != 0 );
// target_type and target() functions
const function<int(float)>& f1c = f1;
+#if __cpp_rtti
VERIFY( typeid(do_truncate_float_t) == f1.target_type() );
+#endif
VERIFY( f2.target<do_truncate_float_t>() != 0 );
VERIFY( f1c.target<do_truncate_float_t>() != 0 );
}
function<int(X&)> frm(&X::bar);
VERIFY( frm );
VERIFY( frm(x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(int X::*) == frm.target_type() );
+#endif
VERIFY( *frm.target<int X::*>() == &X::bar );
function<int(X&)> fr(&X::foo);
VERIFY( fr );
VERIFY( fr(x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)()) == fr.target_type() );
+#endif
VERIFY( *fr.target<int (X::*)()>() == &X::foo );
function<int(const X&)> frc(&X::foo_c);
VERIFY( frc );
VERIFY( frc(x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const) == frc.target_type() );
+#endif
VERIFY( *frc.target<int (X::*)() const >() == &X::foo_c );
function<int(volatile X&)> frv(&X::foo_v);
VERIFY( frv );
VERIFY( frv(x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
+#endif
VERIFY( *frv.target<int (X::*)() volatile >() == &X::foo_v );
VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
function<int(const volatile X&)> frcv(&X::foo_cv);
VERIFY( frcv );
VERIFY( frcv(x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
+#endif
VERIFY( *frcv.target<int (X::*)() const volatile >() == &X::foo_cv );
VERIFY( frcv.target<int (X::*)() const>() == 0 );
function<int(X*)> grm(&X::bar);
VERIFY( grm );
VERIFY( grm(&x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(int X::*) == grm.target_type() );
+#endif
VERIFY( *grm.target<int X::*>() == &X::bar );
function<int(X*)> gr(&X::foo);
VERIFY( gr );
VERIFY( gr(&x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)()) == gr.target_type() );
+#endif
VERIFY( *gr.target<int (X::*)()>() == &X::foo );
function<int(const X*)> grc(&X::foo_c);
VERIFY( grc );
VERIFY( grc(&x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const) == grc.target_type() );
+#endif
VERIFY( *grc.target<int (X::*)() const >() == &X::foo_c );
function<int(volatile X*)> grv(&X::foo_v);
VERIFY( grv );
VERIFY( grv(&x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
+#endif
VERIFY( *grv.target<int (X::*)() volatile >() == &X::foo_v );
VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
function<int(const volatile X*)> grcv(&X::foo_cv);
VERIFY( grcv );
VERIFY( grcv(&x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
+#endif
VERIFY( *grcv.target<int (X::*)() const volatile >() == &X::foo_cv );
VERIFY( grcv.target<int (X::*)() const>() == 0 );
}
function<int()> f(ref(x));
VERIFY( f );
VERIFY( f() == 17 );
+#if __cpp_rtti
VERIFY( f.target_type() == typeid(std::ref(x)) ); // LWG 2781
+#endif
VERIFY( wraps(f, x) );
function<int()> g = f;
VERIFY( g );
VERIFY( g() == 17 );
+#if __cpp_rtti
VERIFY( g.target_type() == f.target_type() );
+#endif
VERIFY( wraps(g, x) );
function<int()> h = cref(x);
VERIFY( h );
VERIFY( h() == 42 );
+#if __cpp_rtti
VERIFY( h.target_type() == typeid(std::cref(x)) );
+#endif
VERIFY( wraps(h, as_const(x)) );
const function<int()>& hc = h;
+#if __cpp_rtti
VERIFY( hc.target_type() == h.target_type() );
+#endif
VERIFY( wraps(hc, as_const(x)) );
}
// target_type and target() functions
const function<int(float)>& f1c = f1;
using ref_wrapper_type = reference_wrapper<int(*)(float)>;
+#if __cpp_rtti
VERIFY( typeid(ref_wrapper_type) == f1.target_type() );
+#endif
VERIFY( f1.target<ref_wrapper_type>() != nullptr );
VERIFY( wraps(f1, fptr) );
VERIFY( wraps(f1c, fptr) );
// target_type and target() functions
const function<int(float)>& f2c = f2;
using cref_wrapper_type = reference_wrapper<int(* const)(float)>;
+#if __cpp_rtti
VERIFY( typeid(cref_wrapper_type) == f2.target_type() );
+#endif
VERIFY( wraps(f2, as_const(fptr)) );
+#if __cpp_rtti
VERIFY( f2c.target_type() == f2.target_type() );
+#endif
VERIFY( wraps(f2c, as_const(fptr)) );
}
function<int(X&)> frm(ref(X_bar));
VERIFY( frm );
VERIFY( frm(x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_bar)) == frm.target_type() );
+#endif
VERIFY( wraps(frm, X_bar) );
function<int(X&)> fr(ref(X_foo));
VERIFY( fr );
VERIFY( fr(x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo)) == fr.target_type() );
+#endif
VERIFY( wraps(fr, X_foo) );
function<int(const X&)> frc(ref(X_foo_c));
VERIFY( frc );
VERIFY( frc(x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo_c)) == frc.target_type() );
+#endif
VERIFY( wraps(frc, X_foo_c) );
function<int(volatile X&)> frv(ref(X_foo_v));
VERIFY( frv );
VERIFY( frv(x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo_v)) == frv.target_type() );
+#endif
VERIFY( wraps(frv, X_foo_v) );
function<int(const volatile X&)> frcv(ref(X_foo_cv));
VERIFY( frcv );
VERIFY( frcv(x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo_cv)) == frcv.target_type() );
+#endif
VERIFY( wraps(frcv, X_foo_cv) );
function<int(X*)> grm(ref(X_bar));
VERIFY( grm );
VERIFY( grm(&x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_bar)) == grm.target_type() );
+#endif
VERIFY( wraps(grm, X_bar) );
function<int(X*)> gr(ref(X_foo));
VERIFY( gr );
VERIFY( gr(&x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo)) == gr.target_type() );
+#endif
VERIFY( wraps(gr, X_foo) );
function<int(const X*)> grc(ref(X_foo_c));
VERIFY( grc );
VERIFY( grc(&x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo_c)) == grc.target_type() );
+#endif
VERIFY( wraps(grc, X_foo_c) );
function<int(volatile X*)> grv(ref(X_foo_v));
VERIFY( grv );
VERIFY( grv(&x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo_v)) == grv.target_type() );
+#endif
VERIFY( wraps(grv, X_foo_v) );
function<int(const volatile X*)> grcv(ref(X_foo_cv));
VERIFY( grcv );
VERIFY( grcv(&x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(ref(X_foo_cv)) == grcv.target_type() );
+#endif
VERIFY( wraps(grcv, X_foo_cv) );
function<int(X&)> hrm(cref(X_bar));
VERIFY( hrm );
VERIFY( hrm(x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(cref(X_bar)) == hrm.target_type() );
+#endif
VERIFY( wraps(hrm, as_const(X_bar)) );
function<int(X&)> hr(cref(X_foo));
VERIFY( hr );
VERIFY( hr(x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(cref(X_foo)) == hr.target_type() );
+#endif
VERIFY( wraps(hr, as_const(X_foo)) );
function<int(const X&)> hrc(cref(X_foo_c));
VERIFY( hrc );
VERIFY( hrc(x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(cref(X_foo_c)) == hrc.target_type() );
+#endif
VERIFY( wraps(hrc, as_const(X_foo_c)) );
function<int(volatile X&)> hrv(cref(X_foo_v));
VERIFY( hrv );
VERIFY( hrv(x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(cref(X_foo_v)) == hrv.target_type() );
+#endif
VERIFY( wraps(hrv, as_const(X_foo_v)) );
function<int(const volatile X&)> hrcv(cref(X_foo_cv));
VERIFY( hrcv );
VERIFY( hrcv(x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(cref(X_foo_cv)) == hrcv.target_type() );
+#endif
VERIFY( wraps(hrcv, as_const(X_foo_cv)) );
}
test_type c(&r2);
VERIFY( c.resource() == &r2 );
VERIFY( c.resource() != a.resource() );
+#if __cpp_rtti
VERIFY( c == a );
+#endif
}
void
check_ret_type<shared_ptr<void>>(static_pointer_cast<void>(spd));
check_ret_type<shared_ptr<int>>(const_pointer_cast<int>(spci));
+ // Non-polymorphic dynamic_cast works without RTTI.
+ check_ret_type<shared_ptr<MyP>>(dynamic_pointer_cast<MyP>(spa));
+#if __cpp_rtti
+ // But polymorphic dynamic_cast needs RTTI.
check_ret_type<shared_ptr<MyDP>>(dynamic_pointer_cast<MyDP>(spa));
+#endif
}
void
VERIFY(pi.get() == ptr);
VERIFY(pci.get() == ptr);
+#if __cpp_rtti
MyP* pptr = new MyP;
shared_ptr<MyP> pp(pptr);
auto pdp = dynamic_pointer_cast<MyDP>(pp);
VERIFY(pdp.use_count() == 2);
VERIFY(pdp.get() == pptr);
VERIFY(pp.get() == pptr);
+#endif
}
int main()
check_ret_type<shared_ptr<void>>(static_pointer_cast<void>(std::move(spd)));
check_ret_type<shared_ptr<int>>(const_pointer_cast<int>(std::move(spci)));
+ check_ret_type<shared_ptr<MyP>>(dynamic_pointer_cast<MyP>(std::move(spa)));
+#if __cpp_rtti
check_ret_type<shared_ptr<MyDP>>(dynamic_pointer_cast<MyDP>(std::move(spa)));
+#endif
check_ret_type<shared_ptr<void>>(reinterpret_pointer_cast<void>(std::move(spd)));
check_ret_type<shared_ptr<const short>>(reinterpret_pointer_cast<const short>(std::move(spci)));
check_ret_type<shared_ptr<MyDP>>(reinterpret_pointer_cast<MyDP>(std::move(spa)));
VERIFY(pi.get() == ptr);
VERIFY(pci.get() == nullptr);
+#if __cpp_rtti
MyP* pptr = new MyP;
shared_ptr<MyP> pp(pptr);
auto pdp = dynamic_pointer_cast<MyDP>(std::move(pp));
VERIFY(pi.use_count() == 0);
VERIFY(reinterpret_cast<int*>(pl.get()) == ptr);
VERIFY(pi.get() == nullptr);
+#endif
}
int main()
typedef std::reference_wrapper<D> D2;
D2* p3 = std::get_deleter<D2>(p2);
+#if __cpp_rtti
VERIFY( p3 != 0 );
VERIFY( &p3->get() == &d );
+#else
+ VERIFY( p3 == 0 ); // Always returns nullptr without RTTI.
+#endif
return 0;
}
std::shared_ptr<int> p;
VERIFY( std::get_deleter<Del>(p) == nullptr );
p = std::shared_ptr<int>(new int, Del());
+#if __cpp_rtti
VERIFY( std::get_deleter<Del>(p) != nullptr );
+#endif
p = std::shared_ptr<int>(new int);
VERIFY( std::get_deleter<Del>(p) == nullptr );
}
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
// 2010-09-22 Paolo Carlini <paolo.carlini@oracle.com>
//
// { dg-options "-std=gnu++2a" }
// { dg-do run { target c++2a } }
+// { dg-require-effective-target rtti }
// Copyright (C) 2020-2022 Free Software Foundation, Inc.
//
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
// 2010-09-22 Paolo Carlini <paolo.carlini@oracle.com>
//
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
// 2010-09-22 Paolo Carlini <paolo.carlini@oracle.com>
//
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
// 2010-09-22 Paolo Carlini <paolo.carlini@oracle.com>
//
// <http://www.gnu.org/licenses/>.
// { dg-error "complete" "" { target *-*-* } 0 }
+// { dg-error "invalid 'static_cast'" "" { target { ! rtti } } 0 }
#include <locale>
VERIFY( has_facet<base_facet>(loc_derived) );
// Standard derived facet.
+#if __cpp_rtti
VERIFY( !has_facet<derived_facet>(loc_c) );
VERIFY( !has_facet<derived_facet>(loc_base) );
+#endif
VERIFY( has_facet<derived_facet>(loc_derived) );
// User defined derived facet.
VERIFY( !has_facet<derived_facet>(loc_c) );
+#if __cpp_rtti
VERIFY( !has_facet<derived_facet>(loc_base) );
VERIFY( has_facet<derived_facet>(loc_derived) );
// Expect no exception.
VERIFY( true );
}
+#endif
return 0;
}
// 22.1.1 class locale [lib.locale]
-#include <locale>
-#include <typeinfo>
-#include <testsuite_hooks.h>
+// { dg-do compile }
-void test01()
-{
- using namespace std;
+#include <locale>
- VERIFY( typeid(locale::category) == typeid(int) );
-}
+template<typename, typename> struct SameType;
+template<typename T> struct SameType<T, T> { };
-int main()
-{
- test01();
- return 0;
-}
+SameType<std::locale::category, int> check;
// { dg-do compile { target c++11 } }
+// { dg-require-effective-target rtti }
// Copyright (C) 2012-2022 Free Software Foundation, Inc.
//
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// PR libstdc++/53248
+
#include <array>
#include <typeindex>
#include <typeinfo>
// { dg-additional-options "-pthread" { target pthread } }
// { dg-do run { target c++2a } }
// { dg-require-effective-target cxx11_abi }
-// { dg-xfail-run-if "cannot catch forced_unwind" { *-*-* } { "-fno-rtti" } }
+// { dg-require-effective-target rtti }
#include <syncstream>
#include <testsuite_hooks.h>
// 27.4.3 fpos
-// { dg-do run }
+// { dg-do compile }
-#include <typeinfo>
#include <limits>
#include <iterator>
-#include <testsuite_hooks.h>
// libstdc++/14320
-void test01()
-{
- using namespace std;
- typedef istreambuf_iterator<char>::difference_type Distance;
-
- bool found = false;
- // The C++ standard didn't originally have "long long", however that
- // type is in the C++11 standard and testing for it allows
- // ilp32 targets to pass this test when `Distance' is 64 bits.
- if (typeid(Distance) == typeid(long long int))
- found = true;
- if (typeid(Distance) == typeid(long int))
- found = true;
- if (typeid(Distance) == typeid(int))
- found = true;
- if (typeid(Distance) == typeid(short int))
- found = true;
- if (typeid(Distance) == typeid(signed char))
- found = true;
- if (numeric_limits<char>::is_signed &&
- typeid(Distance) == typeid(char))
- found = true;
- if (numeric_limits<wchar_t>::is_signed &&
- typeid(Distance) == typeid(wchar_t))
- found = true;
-
- VERIFY( found );
-}
-
-int main()
-{
- test01();
- return 0;
-}
+typedef std::istreambuf_iterator<char>::difference_type Distance;
+
+#if __cplusplus >= 201103L
+ static_assert( std::is_integral<Distance>::value, "integral type" );
+ static_assert( std::is_signed<Distance>::value, "signed integral type" );
+#else
+template<typename> struct SignedInteger { enum { value = 0 }; };
+// The C++ standard didn't originally have "long long", however that
+// type is in the C++11 standard and testing for it allows
+// ilp32 targets to pass this test when `Distance' is 64 bits.
+template<> struct SignedInteger<long long int> { enum { value = 1 }; };
+template<> struct SignedInteger<long int> { enum { value = 1 }; };
+template<> struct SignedInteger<int> { enum { value = 1 }; };
+template<> struct SignedInteger<short int> { enum { value = 1 }; };
+template<> struct SignedInteger<char> {
+ enum { value = std::numeric_limits<char>::is_signed };
+};
+template<> struct SignedInteger<wchar_t> {
+ enum { value = std::numeric_limits<wchar_t>::is_signed };
+};
+
+char assertion[SignedInteger<Distance>::value ? 1 : -1];
+#endif
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-require-effective-target rtti }
+
// 27.4.3 fpos
#include <typeinfo>
// { dg-options "-D_GLIBCXX_USE_CXX11_ABI=0" }
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
#include <fstream>
#include <system_error>
any x(5); // x holds int
VERIFY(any_cast<int>(x) == 5); // cast to value
any_cast<int&>(x) = 10; // cast to reference
- VERIFY(any_cast<int>(x) == 10);
+ VERIFY(any_cast<int>(x) == 10);
x = "Meow"; // x holds const char*
VERIFY(strcmp(any_cast<const char*>(x), "Meow") == 0);
x = string("Meow"); // x holds string
string s, s2("Jane");
- s = move(any_cast<string&>(x)); // move from any
+ s = move(any_cast<string&>(x)); // move from any
VERIFY(s == "Meow");
any_cast<string&>(x) = move(s2); // move to any
VERIFY(any_cast<const string&>(x) == "Jane");
{
int arr[3];
any a(arr);
+#if __cpp_rtti
VERIFY( a.type() == typeid(int*) ); // contained value is decayed
+#endif
int (*p1)[3] = any_cast<int[3]>(&a);
+#if __cpp_rtti
VERIFY( a.type() != typeid(int[3]) ); // so any_cast should return nullptr
+#endif
VERIFY( p1 == nullptr );
int (*p2)[] = any_cast<int[]>(&a);
+#if __cpp_rtti
VERIFY( a.type() != typeid(int[]) ); // so any_cast should return nullptr
+#endif
VERIFY( p2 == nullptr );
const int (*p3)[] = any_cast<int[]>(&const_cast<const any&>(a));
VERIFY( p3 == nullptr );
// { dg-do run { target c++14 } }
+// { dg-require-effective-target rtti }
// Copyright (C) 2014-2022 Free Software Foundation, Inc.
//
Allocator<int> a1(1), a2(2); // minimal interface allocators
resource_adaptor<decltype(a1)> r1(a1), r2(a2);
VERIFY( r1 == r1 );
+#if __cpp_rtti
VERIFY( r1 == r2 );
+#endif
p = r1.allocate(1);
VERIFY( aligned<max_align_t>(p) );
r1.deallocate(p, 1);
__gnu_cxx::debug_allocator<std::allocator<short>> a5, a6;
resource_adaptor<decltype(a5)> r5(a5), r6(a6);
VERIFY( r5 == r5 );
+#if __cpp_rtti
VERIFY( r5 == r6 );
+#endif
VERIFY( r5 != r1 );
VERIFY( r5 != r3 );
p = r5.allocate(1);
__gnu_cxx::new_allocator<short> a7, a8;
resource_adaptor<decltype(a7)> r7(a7), r8(a8);
VERIFY( r7 == r7 );
+#if __cpp_rtti
VERIFY( r7 == r8 );
+#endif
VERIFY( r7 != r1 );
VERIFY( r7 != r3 );
VERIFY( r7 != r5 );
__gnu_cxx::malloc_allocator<short> a9, a10;
resource_adaptor<decltype(a9)> r9(a9), r10(a10);
VERIFY( r9 == r9 );
+#if __cpp_rtti
VERIFY( r9 == r10 );
+#endif
VERIFY( r9 != r1 );
VERIFY( r9 != r3 );
VERIFY( r9 != r5 );
std::allocator<short> a11, a12;
resource_adaptor<decltype(a11)> r11(a11), r12(a12);
VERIFY( r11 == r11 );
+#if __cpp_rtti
VERIFY( r11 == r12 );
+#endif
VERIFY( r11 != r1 );
VERIFY( r11 != r3 );
VERIFY( r11 != r5 );
}]
}
+# Return 1 if RTTI is enabled by the current test flags.
+proc check_effective_target_rtti { } {
+ return [check_v3_target_prop_cached et_rtti {
+ set cond "__cpp_rtti"
+ return [v3_check_preprocessor_condition rtti $cond]
+ }]
+}
+
set additional_prunes ""
if { [info exists env(GCC_RUNTEST_PARALLELIZE_DIR)] \
}
VERIFY( thrown );
+#if __cpp_rtti
// target_type returns typeid(void)
VERIFY( f1.target_type() == typeid(void) );
const function<int(float)>& f1c = f1;
VERIFY( f1c.target<int (*)(float)>() == 0 );
VERIFY( !f1c );
+#endif
}
int main()
f2 = truncate_float;
VERIFY( f2(3.1f) == 3 );
+#if __cpp_rtti
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(int(*)(float)) == f1.target_type() );
VERIFY( *f2.target<int(*)(float)>() == &truncate_float );
VERIFY( f1c.target<int(*)(float)>() != 0 );
VERIFY( *f1c.target<int(*)(float)>() == &truncate_float );
+#endif
}
int main()
f2 = truncate_double;
VERIFY( f2(3.1f) == 3 );
+#if __cpp_rtti
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(long(*)(double)) == f1.target_type() );
VERIFY( *f2.target<long(*)(double)>() == &truncate_double );
VERIFY( f1c.target<long(*)(double)>() != 0 );
VERIFY( *f1c.target<long(*)(double)>() == &truncate_double );
+#endif
}
int main()
f2 = do_truncate_float_t();
VERIFY( f2(3.1f) == 3 );
+#if __cpp_rtti
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(do_truncate_float_t) == f1.target_type() );
VERIFY( f2.target<do_truncate_float_t>() != 0 );
VERIFY( f1c.target<do_truncate_float_t>() != 0 );
+#endif
}
int main()
function<int(X&)> frm(&X::bar);
VERIFY( frm );
VERIFY( frm(x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(int X::*) == frm.target_type() );
VERIFY( *frm.target<int X::*>() == &X::bar );
+#endif
function<int(X&)> fr(&X::foo);
VERIFY( fr );
VERIFY( fr(x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)()) == fr.target_type() );
VERIFY( *fr.target<int (X::*)()>() == &X::foo );
+#endif
function<int(const X&)> frc(&X::foo_c);
VERIFY( frc );
VERIFY( frc(x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const) == frc.target_type() );
VERIFY( *frc.target<int (X::*)() const >() == &X::foo_c );
+#endif
function<int(volatile X&)> frv(&X::foo_v);
VERIFY( frv );
VERIFY( frv(x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
VERIFY( *frv.target<int (X::*)() volatile >() == &X::foo_v );
VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
+#endif
function<int(const volatile X&)> frcv(&X::foo_cv);
VERIFY( frcv );
VERIFY( frcv(x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
VERIFY( *frcv.target<int (X::*)() const volatile >() == &X::foo_cv );
VERIFY( frcv.target<int (X::*)() const>() == 0 );
+#endif
function<int(X*)> grm(&X::bar);
VERIFY( grm );
VERIFY( grm(&x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(int X::*) == grm.target_type() );
VERIFY( *grm.target<int X::*>() == &X::bar );
+#endif
function<int(X*)> gr(&X::foo);
VERIFY( gr );
VERIFY( gr(&x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)()) == gr.target_type() );
VERIFY( *gr.target<int (X::*)()>() == &X::foo );
+#endif
function<int(const X*)> grc(&X::foo_c);
VERIFY( grc );
VERIFY( grc(&x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const) == grc.target_type() );
VERIFY( *grc.target<int (X::*)() const >() == &X::foo_c );
+#endif
function<int(volatile X*)> grv(&X::foo_v);
VERIFY( grv );
VERIFY( grv(&x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
VERIFY( *grv.target<int (X::*)() volatile >() == &X::foo_v );
VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
+#endif
function<int(const volatile X*)> grcv(&X::foo_cv);
VERIFY( grcv );
VERIFY( grcv(&x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
VERIFY( *grcv.target<int (X::*)() const volatile >() == &X::foo_cv );
VERIFY( grcv.target<int (X::*)() const>() == 0 );
+#endif
}
int main()
function<int()> f(ref(x));
VERIFY( f );
VERIFY( f() == 17 );
+#if __cpp_rtti
VERIFY( f.target_type() == typeid(noncopyable_function_object_type) );
VERIFY( f.target<noncopyable_function_object_type>() == &x );
+#endif
function<int()> g = f;
VERIFY( g );
VERIFY( g() == 17 );
+#if __cpp_rtti
VERIFY( g.target_type() == typeid(noncopyable_function_object_type) );
VERIFY( g.target<noncopyable_function_object_type>() == &x );
+#endif
function<int()> h = cref(x);
VERIFY( h );
VERIFY( h() == 42 );
+#if __cpp_rtti
VERIFY( h.target_type() == typeid(noncopyable_function_object_type) );
VERIFY( h.target<const noncopyable_function_object_type>() == &x );
VERIFY( h.target<const noncopyable_function_object_type>() == &x );
const function<int()>& hc = h;
VERIFY( h.target<noncopyable_function_object_type>() == 0 );
VERIFY( hc.target<noncopyable_function_object_type>() == &x );
+#endif
}
int main()
// Invocation
VERIFY( f1(3.1f) == 3 );
+#if __cpp_rtti
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(int(*)(float)) == f1.target_type() );
VERIFY( f1.target<int(*)(float)>() == &fptr );
VERIFY( f1c.target<int(*)(float)>() != 0 );
VERIFY( f1c.target<int(*)(float)>() == &fptr );
+#endif
function<int(float)> f2(cref(fptr));
VERIFY( f2 );
// Invocation
VERIFY( f2(3.1f) == 3 );
+#if __cpp_rtti
// target_type and target() functions
const function<int(float)>& f2c = f2;
VERIFY( typeid(int(*)(float)) == f2.target_type() );
VERIFY( f2.target<int(* const)(float)>() == &fptr );
VERIFY( f2c.target<int(*)(float)>() != 0 );
VERIFY( f2c.target<int(*)(float)>() == &fptr );
+#endif
}
int main()
function<int(X&)> frm(ref(X_bar));
VERIFY( frm );
VERIFY( frm(x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(int X::*) == frm.target_type() );
VERIFY( frm.target<int X::*>() == &X_bar );
+#endif
function<int(X&)> fr(ref(X_foo));
VERIFY( fr );
VERIFY( fr(x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)()) == fr.target_type() );
VERIFY( fr.target<int (X::*)()>() == &X_foo );
+#endif
function<int(const X&)> frc(ref(X_foo_c));
VERIFY( frc );
VERIFY( frc(x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const) == frc.target_type() );
VERIFY( frc.target<int (X::*)() const >() == &X_foo_c );
+#endif
function<int(volatile X&)> frv(ref(X_foo_v));
VERIFY( frv );
VERIFY( frv(x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
VERIFY( *frv.target<int (X::*)() volatile >() == X_foo_v );
VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
+#endif
function<int(const volatile X&)> frcv(ref(X_foo_cv));
VERIFY( frcv );
VERIFY( frcv(x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
VERIFY( *frcv.target<int (X::*)() const volatile >() == X_foo_cv );
VERIFY( frcv.target<int (X::*)() const>() == 0 );
+#endif
function<int(X*)> grm(ref(X_bar));
VERIFY( grm );
VERIFY( grm(&x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(int X::*) == grm.target_type() );
VERIFY( *grm.target<int X::*>() == X_bar );
+#endif
function<int(X*)> gr(ref(X_foo));
VERIFY( gr );
VERIFY( gr(&x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)()) == gr.target_type() );
VERIFY( *gr.target<int (X::*)()>() == X_foo );
+#endif
function<int(const X*)> grc(ref(X_foo_c));
VERIFY( grc );
VERIFY( grc(&x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const) == grc.target_type() );
VERIFY( *grc.target<int (X::*)() const >() == X_foo_c );
+#endif
function<int(volatile X*)> grv(ref(X_foo_v));
VERIFY( grv );
VERIFY( grv(&x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
VERIFY( *grv.target<int (X::*)() volatile >() == X_foo_v );
VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
+#endif
function<int(const volatile X*)> grcv(ref(X_foo_cv));
VERIFY( grcv );
VERIFY( grcv(&x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
VERIFY( *grcv.target<int (X::*)() const volatile >() == X_foo_cv );
VERIFY( grcv.target<int (X::*)() const>() == 0 );
+#endif
function<int(X&)> hrm(cref(X_bar));
VERIFY( hrm );
VERIFY( hrm(x) == 17 );
+#if __cpp_rtti
VERIFY( typeid(int X::*) == hrm.target_type() );
VERIFY( hrm.target<int X::*>() == 0 );
VERIFY( hrm.target<int X::* const>() == &X_bar );
+#endif
function<int(X&)> hr(cref(X_foo));
VERIFY( hr );
VERIFY( hr(x) == 1 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)()) == hr.target_type() );
VERIFY( hr.target<int (X::* const)()>() == &X_foo );
+#endif
function<int(const X&)> hrc(cref(X_foo_c));
VERIFY( hrc );
VERIFY( hrc(x) == 2 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const) == hrc.target_type() );
VERIFY( hrc.target<int (X::* const)() const >() == &X_foo_c );
+#endif
function<int(volatile X&)> hrv(cref(X_foo_v));
VERIFY( hrv );
VERIFY( hrv(x) == 3 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() volatile) == hrv.target_type() );
VERIFY( hrv.target<int (X::* const)() volatile >() == &X_foo_v );
VERIFY( hrv.target<int (X::* const)() const volatile>() == 0 );
+#endif
function<int(const volatile X&)> hrcv(cref(X_foo_cv));
VERIFY( hrcv );
VERIFY( hrcv(x) == 4 );
+#if __cpp_rtti
VERIFY( typeid(int (X::*)() const volatile) == hrcv.target_type() );
VERIFY( hrcv.target<int (X::* const)() const volatile >() == &X_foo_cv );
VERIFY( hrcv.target<int (X::* const)() const>() == 0 );
+#endif
}
int main()
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
//
// Copyright (C) 2011-2022 Free Software Foundation, Inc.
//
// Sanity check.
static_assert(tl::empty::value != std::true_type::value, "!empty");
-
+
typedef tl::first::type tl1_first;
typedef tl::rest::type tl2;
typedef tl2::first::type tl2_first;
// { dg-do run { target c++11 } }
+// { dg-require-effective-target rtti }
//
// Copyright (C) 2011-2022 Free Software Foundation, Inc.
//
// Sanity check.
static_assert(tl::empty::value != std::true_type::value, "!empty");
-
+
typedef tl::first::type tl1_first;
typedef tl::rest::type tl2;
typedef tl2::first::type tl2_first;
while (!exit);
// Log count info.
+#if __cpp_rtti
std::cout << __f.target_type().name() << std::endl;
+#else
+ std::cout << "[no type info - rtti disabled]\n";
+#endif
std::cout << "end count " << __step << std::endl;
return __step;
}
while (!exit);
// Log count info.
+#if __cpp_rtti
std::cout << __f.target_type().name() << std::endl;
+#else
+ std::cout << "[no type info - rtti disabled]\n";
+#endif
std::cout << "end count " << i << std::endl;
}
};
projects / thirdparty / gcc.git / commitdiff
