+2011-12-06 Paolo Carlini <paolo.carlini@oracle.com>
+
+ PR libstdc++/51438
+ * libsupc++/nested_exception.h (nested_exception::~nested_exception):
+ Declare noexcept.
+ * libsupc++/nested_exception.cc: Adjust.
+ * testsuite/18_support/nested_exception/51438.cc: New.
+ * testsuite/18_support/nested_exception/throw_with_nested.cc: Adjust.
+ * testsuite/18_support/nested_exception/rethrow_if_nested.cc:
+ Likewise.
+
+ * src/shared_ptr.cc: Use noexcept where appropriate.
+ * include/std/system_error: Likewise.
+ * include/std/functional: Likewise.
+ * include/bits/shared_ptr_base.h: Likewise.
+ * src/stdexcept.cc: Use _GLIBCXX_USE_NOEXCEPT where appropriate.
+ * include/std/stdexcept: Likewise.
+ * libsupc++/bad_cast.cc: Likewise.
+ * libsupc++/bad_typeid.cc: Likewise.
+ * libsupc++/eh_exception.cc: Likewise.
+ * libsupc++/typeinfo: Likewise.
+ * libsupc++/exception: Likewise.
+ * libsupc++/eh_ptr.cc: Likewise.
+ * libsupc++/bad_alloc.cc: Likewise.
+ * libsupc++/exception_ptr.h: Likewise.
+
+ * include/std/chrono: Use noexcept where appropriate.
+ * src/chrono.cc: Likewise.
+
2011-12-06 Jonathan Wakely <jwakely.gcc@gmail.com>
Chris Jefferson <chris@bubblescope.net>
virtual char const*
what() const noexcept;
- virtual ~bad_weak_ptr() throw();
+ virtual ~bad_weak_ptr() noexcept;
};
// Substitute for bad_weak_ptr object in the case of -fno-exceptions.
static constexpr bool is_steady = false;
static time_point
- now() throw ();
+ now() noexcept;
// Map to C API
static std::time_t
- to_time_t(const time_point& __t)
+ to_time_t(const time_point& __t) noexcept
{
return std::time_t(duration_cast<chrono::seconds>
(__t.time_since_epoch()).count());
}
static time_point
- from_time_t(std::time_t __t)
+ from_time_t(std::time_t __t) noexcept
{
typedef chrono::time_point<system_clock, seconds> __from;
return time_point_cast<system_clock::duration>
static constexpr bool is_steady = true;
static time_point
- now();
+ now() noexcept;
};
#else
typedef system_clock steady_clock;
class bad_function_call : public std::exception
{
public:
- virtual ~bad_function_call() throw();
+ virtual ~bad_function_call() noexcept;
};
/**
explicit
logic_error(const string& __arg);
- virtual ~logic_error() throw();
+ virtual ~logic_error() _GLIBCXX_USE_NOEXCEPT;
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
virtual const char*
- what() const throw();
+ what() const _GLIBCXX_USE_NOEXCEPT;
};
/** Thrown by the library, or by you, to report domain errors (domain in
{
public:
explicit domain_error(const string& __arg);
- virtual ~domain_error() throw();
+ virtual ~domain_error() _GLIBCXX_USE_NOEXCEPT;
};
/** Thrown to report invalid arguments to functions. */
{
public:
explicit invalid_argument(const string& __arg);
- virtual ~invalid_argument() throw();
+ virtual ~invalid_argument() _GLIBCXX_USE_NOEXCEPT;
};
/** Thrown when an object is constructed that would exceed its maximum
{
public:
explicit length_error(const string& __arg);
- virtual ~length_error() throw();
+ virtual ~length_error() _GLIBCXX_USE_NOEXCEPT;
};
/** This represents an argument whose value is not within the expected
{
public:
explicit out_of_range(const string& __arg);
- virtual ~out_of_range() throw();
+ virtual ~out_of_range() _GLIBCXX_USE_NOEXCEPT;
};
/** Runtime errors represent problems outside the scope of a program;
explicit
runtime_error(const string& __arg);
- virtual ~runtime_error() throw();
+ virtual ~runtime_error() _GLIBCXX_USE_NOEXCEPT;
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
virtual const char*
- what() const throw();
+ what() const _GLIBCXX_USE_NOEXCEPT;
};
/** Thrown to indicate range errors in internal computations. */
{
public:
explicit range_error(const string& __arg);
- virtual ~range_error() throw();
+ virtual ~range_error() _GLIBCXX_USE_NOEXCEPT;
};
/** Thrown to indicate arithmetic overflow. */
{
public:
explicit overflow_error(const string& __arg);
- virtual ~overflow_error() throw();
+ virtual ~overflow_error() _GLIBCXX_USE_NOEXCEPT;
};
/** Thrown to indicate arithmetic underflow. */
{
public:
explicit underflow_error(const string& __arg);
- virtual ~underflow_error() throw();
+ virtual ~underflow_error() _GLIBCXX_USE_NOEXCEPT;
};
// @} group exceptions
: runtime_error(__what + ": " + error_code(__v, __ecat).message()),
_M_code(__v, __ecat) { }
- virtual ~system_error() throw();
+ virtual ~system_error() noexcept;
const error_code&
code() const noexcept { return _M_code; }
// Implementation file for the -*- C++ -*- dynamic memory management header.
-// Copyright (C) 2010 Free Software Foundation
+// Copyright (C) 2010, 2011 Free Software Foundation
//
// This file is part of GCC.
//
#include "new"
-std::bad_alloc::~bad_alloc() throw() { }
+std::bad_alloc::~bad_alloc() _GLIBCXX_USE_NOEXCEPT { }
const char*
-std::bad_alloc::what() const throw()
+std::bad_alloc::what() const _GLIBCXX_USE_NOEXCEPT
{
return "std::bad_alloc";
}
// Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2007,
-// 2009 Free Software Foundation
+// 2009, 2010, 2011 Free Software Foundation
//
// This file is part of GCC.
//
namespace std {
-bad_cast::~bad_cast() throw() { }
+bad_cast::~bad_cast() _GLIBCXX_USE_NOEXCEPT { }
const char*
-bad_cast::what() const throw()
+bad_cast::what() const _GLIBCXX_USE_NOEXCEPT
{
return "std::bad_cast";
}
// Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2007,
-// 2009 Free Software Foundation
+// 2009, 2010, 2011 Free Software Foundation
//
// This file is part of GCC.
//
namespace std {
-bad_typeid::~bad_typeid() throw() { }
+bad_typeid::~bad_typeid() _GLIBCXX_USE_NOEXCEPT { }
const char*
-bad_typeid::what() const throw()
+bad_typeid::what() const _GLIBCXX_USE_NOEXCEPT
{
return "std::bad_typeid";
}
// -*- C++ -*- std::exception implementation.
// Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-// 2003, 2004, 2005, 2006, 2007, 2009
+// 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
// Free Software Foundation
//
// This file is part of GCC.
#include "exception"
#include <cxxabi.h>
-std::exception::~exception() throw() { }
+std::exception::~exception() _GLIBCXX_USE_NOEXCEPT { }
-std::bad_exception::~bad_exception() throw() { }
+std::bad_exception::~bad_exception() _GLIBCXX_USE_NOEXCEPT { }
abi::__forced_unwind::~__forced_unwind() throw() { }
abi::__foreign_exception::~__foreign_exception() throw() { }
const char*
-std::exception::what() const throw()
+std::exception::what() const _GLIBCXX_USE_NOEXCEPT
{
// NB: Another elegant option would be returning typeid(*this).name()
// and not overriding what() in bad_exception, bad_alloc, etc. In
}
const char*
-std::bad_exception::what() const throw()
+std::bad_exception::what() const _GLIBCXX_USE_NOEXCEPT
{
return "std::bad_exception";
}
using namespace __cxxabiv1;
-std::__exception_ptr::exception_ptr::exception_ptr() throw()
+std::__exception_ptr::exception_ptr::exception_ptr() _GLIBCXX_USE_NOEXCEPT
: _M_exception_object(0) { }
-std::__exception_ptr::exception_ptr::exception_ptr(void* obj) throw()
+std::__exception_ptr::exception_ptr::exception_ptr(void* obj)
+_GLIBCXX_USE_NOEXCEPT
: _M_exception_object(obj) { _M_addref(); }
-std::__exception_ptr::exception_ptr::exception_ptr(__safe_bool) throw()
+std::__exception_ptr::exception_ptr::exception_ptr(__safe_bool)
+_GLIBCXX_USE_NOEXCEPT
: _M_exception_object(0) { }
std::__exception_ptr::
-exception_ptr::exception_ptr(const exception_ptr& other) throw()
+exception_ptr::exception_ptr(const exception_ptr& other) _GLIBCXX_USE_NOEXCEPT
: _M_exception_object(other._M_exception_object)
{ _M_addref(); }
-std::__exception_ptr::exception_ptr::~exception_ptr() throw()
+std::__exception_ptr::exception_ptr::~exception_ptr() _GLIBCXX_USE_NOEXCEPT
{ _M_release(); }
std::__exception_ptr::exception_ptr&
std::__exception_ptr::
-exception_ptr::operator=(const exception_ptr& other) throw()
+exception_ptr::operator=(const exception_ptr& other) _GLIBCXX_USE_NOEXCEPT
{
exception_ptr(other).swap(*this);
return *this;
void
-std::__exception_ptr::exception_ptr::_M_addref() throw()
+std::__exception_ptr::exception_ptr::_M_addref() _GLIBCXX_USE_NOEXCEPT
{
if (_M_exception_object)
{
void
-std::__exception_ptr::exception_ptr::_M_release() throw()
+std::__exception_ptr::exception_ptr::_M_release() _GLIBCXX_USE_NOEXCEPT
{
if (_M_exception_object)
{
void*
-std::__exception_ptr::exception_ptr::_M_get() const throw()
+std::__exception_ptr::exception_ptr::_M_get() const _GLIBCXX_USE_NOEXCEPT
{ return _M_exception_object; }
void
-std::__exception_ptr::exception_ptr::swap(exception_ptr &other) throw()
+std::__exception_ptr::exception_ptr::swap(exception_ptr &other)
+ _GLIBCXX_USE_NOEXCEPT
{
void *tmp = _M_exception_object;
_M_exception_object = other._M_exception_object;
// Retained for compatibility with CXXABI_1.3.
void
-std::__exception_ptr::exception_ptr::_M_safe_bool_dummy() throw () { }
+std::__exception_ptr::exception_ptr::_M_safe_bool_dummy()
+ _GLIBCXX_USE_NOEXCEPT { }
// Retained for compatibility with CXXABI_1.3.
bool
-std::__exception_ptr::exception_ptr::operator!() const throw()
+std::__exception_ptr::exception_ptr::operator!() const _GLIBCXX_USE_NOEXCEPT
{ return _M_exception_object == 0; }
// Retained for compatibility with CXXABI_1.3.
-std::__exception_ptr::exception_ptr::operator __safe_bool() const throw()
+std::__exception_ptr::exception_ptr::operator __safe_bool() const
+_GLIBCXX_USE_NOEXCEPT
{
return _M_exception_object ? &exception_ptr::_M_safe_bool_dummy : 0;
}
const std::type_info*
-std::__exception_ptr::exception_ptr::__cxa_exception_type() const throw()
+std::__exception_ptr::exception_ptr::__cxa_exception_type() const
+ _GLIBCXX_USE_NOEXCEPT
{
__cxa_exception *eh = __get_exception_header_from_obj (_M_exception_object);
return eh->exceptionType;
bool std::__exception_ptr::operator==(const exception_ptr& lhs,
- const exception_ptr& rhs) throw()
+ const exception_ptr& rhs)
+ _GLIBCXX_USE_NOEXCEPT
{ return lhs._M_exception_object == rhs._M_exception_object; }
bool std::__exception_ptr::operator!=(const exception_ptr& lhs,
- const exception_ptr& rhs) throw()
+ const exception_ptr& rhs)
+ _GLIBCXX_USE_NOEXCEPT
{ return !(lhs == rhs);}
std::exception_ptr
-std::current_exception() throw()
+std::current_exception() _GLIBCXX_USE_NOEXCEPT
{
__cxa_eh_globals *globals = __cxa_get_globals ();
__cxa_exception *header = globals->caughtExceptions;
class exception
{
public:
- exception() throw() { }
- virtual ~exception() throw();
+ exception() _GLIBCXX_USE_NOEXCEPT { }
+ virtual ~exception() _GLIBCXX_USE_NOEXCEPT;
/** Returns a C-style character string describing the general cause
* of the current error. */
- virtual const char* what() const throw();
+ virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
};
/** If an %exception is thrown which is not listed in a function's
class bad_exception : public exception
{
public:
- bad_exception() throw() { }
+ bad_exception() _GLIBCXX_USE_NOEXCEPT { }
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
- virtual ~bad_exception() throw();
+ virtual ~bad_exception() _GLIBCXX_USE_NOEXCEPT;
// See comment in eh_exception.cc.
- virtual const char* what() const throw();
+ virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
};
/// If you write a replacement %terminate handler, it must be of this type.
typedef void (*unexpected_handler) ();
/// Takes a new handler function as an argument, returns the old function.
- terminate_handler set_terminate(terminate_handler) throw();
+ terminate_handler set_terminate(terminate_handler) _GLIBCXX_USE_NOEXCEPT;
/** The runtime will call this function if %exception handling must be
* abandoned for any reason. It can also be called by the user. */
- void terminate() throw() __attribute__ ((__noreturn__));
+ void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__));
/// Takes a new handler function as an argument, returns the old function.
- unexpected_handler set_unexpected(unexpected_handler) throw();
+ unexpected_handler set_unexpected(unexpected_handler) _GLIBCXX_USE_NOEXCEPT;
/** The runtime will call this function if an %exception is thrown which
* violates the function's %exception specification. */
* %exception can result in a call of @c terminate()
* (15.5.1).'
*/
- bool uncaught_exception() throw() __attribute__ ((__pure__));
+ bool uncaught_exception() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__));
// @} group exceptions
} // namespace std
* is none, or the currently handled exception is foreign, return the null
* value.
*/
- exception_ptr current_exception() throw();
+ exception_ptr current_exception() _GLIBCXX_USE_NOEXCEPT;
/// Throw the object pointed to by the exception_ptr.
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
{
void* _M_exception_object;
- explicit exception_ptr(void* __e) throw();
+ explicit exception_ptr(void* __e) _GLIBCXX_USE_NOEXCEPT;
- void _M_addref() throw();
- void _M_release() throw();
+ void _M_addref() _GLIBCXX_USE_NOEXCEPT;
+ void _M_release() _GLIBCXX_USE_NOEXCEPT;
- void *_M_get() const throw() __attribute__ ((__pure__));
+ void *_M_get() const _GLIBCXX_NOEXCEPT __attribute__ ((__pure__));
- friend exception_ptr std::current_exception() throw();
+ friend exception_ptr std::current_exception() _GLIBCXX_USE_NOEXCEPT;
friend void std::rethrow_exception(exception_ptr);
public:
- exception_ptr() throw();
+ exception_ptr() _GLIBCXX_USE_NOEXCEPT;
- exception_ptr(const exception_ptr&) throw();
+ exception_ptr(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
#ifdef __GXX_EXPERIMENTAL_CXX0X__
- exception_ptr(nullptr_t) throw()
+ exception_ptr(nullptr_t) noexcept
: _M_exception_object(0)
{ }
- exception_ptr(exception_ptr&& __o) throw()
+ exception_ptr(exception_ptr&& __o) noexcept
: _M_exception_object(__o._M_exception_object)
{ __o._M_exception_object = 0; }
#endif
typedef void (exception_ptr::*__safe_bool)();
// For construction from nullptr or 0.
- exception_ptr(__safe_bool) throw();
+ exception_ptr(__safe_bool) _GLIBCXX_USE_NOEXCEPT;
#endif
exception_ptr&
- operator=(const exception_ptr&) throw();
+ operator=(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
#ifdef __GXX_EXPERIMENTAL_CXX0X__
exception_ptr&
- operator=(exception_ptr&& __o) throw()
+ operator=(exception_ptr&& __o) noexcept
{
exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
return *this;
}
#endif
- ~exception_ptr() throw();
+ ~exception_ptr() _GLIBCXX_USE_NOEXCEPT;
void
- swap(exception_ptr&) throw();
+ swap(exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
#ifdef _GLIBCXX_EH_PTR_COMPAT
// Retained for compatibility with CXXABI_1.3.
- void _M_safe_bool_dummy() throw() __attribute__ ((__const__));
- bool operator!() const throw() __attribute__ ((__pure__));
- operator __safe_bool() const throw();
+ void _M_safe_bool_dummy() _GLIBCXX_USE_NOEXCEPT
+ __attribute__ ((__const__));
+ bool operator!() const _GLIBCXX_USE_NOEXCEPT
+ __attribute__ ((__pure__));
+ operator __safe_bool() const _GLIBCXX_USE_NOEXCEPT;
#endif
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#endif
friend bool
- operator==(const exception_ptr&, const exception_ptr&) throw()
- __attribute__ ((__pure__));
+ operator==(const exception_ptr&, const exception_ptr&)
+ _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__));
const class type_info*
- __cxa_exception_type() const throw() __attribute__ ((__pure__));
+ __cxa_exception_type() const _GLIBCXX_USE_NOEXCEPT
+ __attribute__ ((__pure__));
};
bool
- operator==(const exception_ptr&, const exception_ptr&) throw()
- __attribute__ ((__pure__));
+ operator==(const exception_ptr&, const exception_ptr&)
+ _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__));
bool
- operator!=(const exception_ptr&, const exception_ptr&) throw()
- __attribute__ ((__pure__));
+ operator!=(const exception_ptr&, const exception_ptr&)
+ _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__));
inline void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
/// Obtain an exception_ptr pointing to a copy of the supplied object.
template<typename _Ex>
exception_ptr
- copy_exception(_Ex __ex) throw()
+ copy_exception(_Ex __ex) _GLIBCXX_USE_NOEXCEPT
{
__try
{
/// Obtain an exception_ptr pointing to a copy of the supplied object.
template<typename _Ex>
exception_ptr
- make_exception_ptr(_Ex __ex) throw()
+ make_exception_ptr(_Ex __ex) _GLIBCXX_USE_NOEXCEPT
{ return std::copy_exception<_Ex>(__ex); }
// @} group exceptions
namespace std
{
#if ATOMIC_INT_LOCK_FREE > 1
- nested_exception::~nested_exception() = default;
+ nested_exception::~nested_exception() noexcept = default;
#endif
} // namespace std
exception_ptr _M_ptr;
public:
- nested_exception() throw() : _M_ptr(current_exception()) { }
+ nested_exception() noexcept : _M_ptr(current_exception()) { }
nested_exception(const nested_exception&) = default;
nested_exception& operator=(const nested_exception&) = default;
- virtual ~nested_exception();
+ virtual ~nested_exception() noexcept;
void
rethrow_nested() const __attribute__ ((__noreturn__))
class bad_cast : public exception
{
public:
- bad_cast() throw() { }
+ bad_cast() _GLIBCXX_USE_NOEXCEPT { }
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
- virtual ~bad_cast() throw();
+ virtual ~bad_cast() _GLIBCXX_USE_NOEXCEPT;
// See comment in eh_exception.cc.
- virtual const char* what() const throw();
+ virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
};
/**
class bad_typeid : public exception
{
public:
- bad_typeid () throw() { }
+ bad_typeid () _GLIBCXX_USE_NOEXCEPT { }
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
- virtual ~bad_typeid() throw();
+ virtual ~bad_typeid() _GLIBCXX_USE_NOEXCEPT;
// See comment in eh_exception.cc.
- virtual const char* what() const throw();
+ virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
};
} // namespace std
constexpr bool system_clock::is_steady;
system_clock::time_point
- system_clock::now() throw ()
+ system_clock::now() noexcept
{
#ifdef _GLIBCXX_USE_CLOCK_REALTIME
timespec tp;
#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
constexpr bool steady_clock::is_steady;
-
+
steady_clock::time_point
- steady_clock::now()
+ steady_clock::now() noexcept
{
timespec tp;
// -EINVAL, -EFAULT
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
- bad_weak_ptr::~bad_weak_ptr() throw() = default;
+ bad_weak_ptr::~bad_weak_ptr() noexcept = default;
char const*
- bad_weak_ptr::what() const throw()
+ bad_weak_ptr::what() const noexcept
{ return "std::bad_weak_ptr"; }
_GLIBCXX_END_NAMESPACE_VERSION
logic_error::logic_error(const string& __arg)
: exception(), _M_msg(__arg) { }
- logic_error::~logic_error() throw() { }
+ logic_error::~logic_error() _GLIBCXX_USE_NOEXCEPT { }
const char*
- logic_error::what() const throw()
+ logic_error::what() const _GLIBCXX_USE_NOEXCEPT
{ return _M_msg.c_str(); }
domain_error::domain_error(const string& __arg)
: logic_error(__arg) { }
- domain_error::~domain_error() throw() { }
+ domain_error::~domain_error() _GLIBCXX_USE_NOEXCEPT { }
invalid_argument::invalid_argument(const string& __arg)
: logic_error(__arg) { }
- invalid_argument::~invalid_argument() throw() { }
+ invalid_argument::~invalid_argument() _GLIBCXX_USE_NOEXCEPT { }
length_error::length_error(const string& __arg)
: logic_error(__arg) { }
- length_error::~length_error() throw() { }
+ length_error::~length_error() _GLIBCXX_USE_NOEXCEPT { }
out_of_range::out_of_range(const string& __arg)
: logic_error(__arg) { }
- out_of_range::~out_of_range() throw() { }
+ out_of_range::~out_of_range() _GLIBCXX_USE_NOEXCEPT { }
runtime_error::runtime_error(const string& __arg)
: exception(), _M_msg(__arg) { }
- runtime_error::~runtime_error() throw() { }
+ runtime_error::~runtime_error() _GLIBCXX_USE_NOEXCEPT { }
const char*
- runtime_error::what() const throw()
+ runtime_error::what() const _GLIBCXX_USE_NOEXCEPT
{ return _M_msg.c_str(); }
range_error::range_error(const string& __arg)
: runtime_error(__arg) { }
- range_error::~range_error() throw() { }
+ range_error::~range_error() _GLIBCXX_USE_NOEXCEPT { }
overflow_error::overflow_error(const string& __arg)
: runtime_error(__arg) { }
- overflow_error::~overflow_error() throw() { }
+ overflow_error::~overflow_error() _GLIBCXX_USE_NOEXCEPT { }
underflow_error::underflow_error(const string& __arg)
: runtime_error(__arg) { }
- underflow_error::~underflow_error() throw() { }
+ underflow_error::~underflow_error() _GLIBCXX_USE_NOEXCEPT { }
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+// { dg-require-atomic-builtins "" }
+
+// Copyright (C) 2011 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <exception>
+#include <stdexcept>
+
+// libstdc++/51438
+void test()
+{
+ try {
+ throw 2;
+ } catch(int) {
+ std::throw_with_nested(std::runtime_error("test"));
+ }
+}
// { dg-options "-std=gnu++0x" }
// { dg-require-atomic-builtins "" }
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
struct derived : std::nested_exception { };
-struct base { virtual ~base(); };
-inline base::~base() = default;
+struct base { virtual ~base() noexcept; };
+inline base::~base() noexcept = default;
struct derived2 : base, std::nested_exception { };
// { dg-options "-std=gnu++0x" }
// { dg-require-atomic-builtins "" }
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
struct derived : std::nested_exception { };
-struct not_derived { virtual ~not_derived(); };
-inline not_derived::~not_derived() = default;
+struct not_derived { virtual ~not_derived() noexcept; };
+inline not_derived::~not_derived() noexcept = default;
void test01()
{
OSDN Git Service
