+2015-01-15 Torvald Riegel <triegel@redhat.com>
+
+ testsuite/libitm.c++/libstdc++-safeexc.C: New.
+
2016-01-13 Torvald Riegel <triegel@redhat.com>
* beginend.cc (gtm_thread::trycommit): Fix seq_cst fences.
--- /dev/null
+// Tests that the exceptions declared by the TM TS (N4514) as transaction_safe
+// are indeed that. Thus, this also tests the transactional clones in
+// libstdc++ and libsupc++.
+
+// { dg-do run }
+
+#include <iostream>
+#include <exception>
+#include <stdexcept>
+#include <string>
+
+using namespace std;
+
+template<typename T> void thrower(const T& t)
+{
+ try
+ {
+ atomic_commit
+ {
+ throw t;
+ }
+ }
+ catch (T ex)
+ {
+ if (ex != t) abort ();
+ }
+}
+
+template<typename T> void thrower1(const string& what)
+{
+ try
+ {
+ atomic_commit
+ {
+ throw T ();
+ }
+ }
+ catch (T ex)
+ {
+ if (what != ex.what()) abort ();
+ }
+}
+
+template<typename T> void thrower2(const string& what)
+{
+ try
+ {
+ atomic_commit
+ {
+ throw T (what);
+ }
+ }
+ catch (T ex)
+ {
+ if (what != ex.what()) abort ();
+ }
+}
+
+
+int main ()
+{
+ thrower<unsigned int> (23);
+ thrower<int> (23);
+ thrower<unsigned short> (23);
+ thrower<short> (23);
+ thrower<unsigned char> (23);
+ thrower<char> (23);
+ thrower<unsigned long int> (42);
+ thrower<long int> (42);
+ thrower<unsigned long long int> (42);
+ thrower<long long int> (42);
+ thrower<double> (23.42);
+ thrower<long double> (23.42);
+ thrower<float> (23.42);
+ thrower<void*> (0);
+ thrower<void**> (0);
+ thrower1<exception> ("std::exception");
+ thrower1<bad_exception> ("std::bad_exception");
+ thrower2<logic_error> ("test");
+ thrower2<domain_error> ("test");
+ thrower2<invalid_argument> ("test");
+ thrower2<length_error> ("test");
+ thrower2<out_of_range> ("test");
+ thrower2<runtime_error> ("test");
+ thrower2<range_error> ("test");
+ thrower2<overflow_error> ("test");
+ thrower2<underflow_error> ("test");
+ return 0;
+}
+2016-01-15 Torvald Riegel <triegel@redhat.com>
+
+ * include/bits/basic_string.h (basic_string): Declare friends.
+ * include/bits/c++config (_GLIBCXX_TXN_SAFE,
+ _GLIBCXX_TXN_SAFE_DYN, _GLIBCXX_USE_ALLOCATOR_NEW): New.
+ * include/std/stdexcept (logic_error, domain_error, invalid_argument,
+ length_error, out_of_range, runtime_error, range_error,
+ underflow_error, overflow_error): Declare members as transaction-safe.
+ (logic_error, runtime_error): Declare friend functions.
+ * libsupc++/exception (exception, bad_exception): Declare members as
+ transaction-safe.
+ * src/c++11/cow-stdexcept.cc: Define transactional clones for the
+ transaction-safe members of exceptions and helper functions.
+ * libsupc++/eh_exception.cc: Adjust and define transactional clones.
+ * config/abi/pre/gnu.ver (GLIBCXX_3.4.22) Add transactional clones.
+ (CXXABI_1.3.10): New.
+ * acinclude.m4 (GLIBCXX_CHECK_SIZE_T_MANGLING): New.
+ (GLIBCXX_ENABLE_ALLOCATOR): Set ENABLE_ALLOCATOR_NEW.
+ * configure.ac: Call GLIBCXX_CHECK_SIZE_T_MANGLING.
+ * include/Makefile.am: Write ENABLE_ALLOCATOR_NEW to c++config.h.
+ * include/Makefile.in: Regenerate.
+ * config.h.in: Regenerate.
+ * configure: Regenerate.
+ * testsuite/util/testsuite_abi.cc (check_version): Add CXXABI_1.3.10.
+
2016-01-15 Steve Ellcey <sellcey@imgtec.com>
* include/ext/random.tcc: Use __builtin_isfinite instead of
;;
esac
+ GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
+ test $enable_libstdcxx_allocator_flag = new)
AC_SUBST(ALLOCATOR_H)
AC_SUBST(ALLOCATOR_NAME)
])
AC_LANG_RESTORE
])
+dnl
+dnl Check how size_t is mangled. Copied from libitm.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
+ AC_CACHE_CHECK([how size_t is mangled],
+ glibcxx_cv_size_t_mangling, [
+ AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
+ [glibcxx_cv_size_t_mangling=m], [
+ AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
+ [glibcxx_cv_size_t_mangling=j], [
+ AC_TRY_COMPILE([],
+ [extern __SIZE_TYPE__ x; extern unsigned long long x;],
+ [glibcxx_cv_size_t_mangling=y], [
+ AC_TRY_COMPILE([],
+ [extern __SIZE_TYPE__ x; extern unsigned short x;],
+ [glibcxx_cv_size_t_mangling=t],
+ [glibcxx_cv_size_t_mangling=x])
+ ])
+ ])
+ ])
+ ])
+ if test $glibcxx_cv_size_t_mangling = x; then
+ AC_MSG_ERROR([Unknown underlying type for size_t])
+ fi
+ AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
+ [Define to the letter to which size_t is mangled.])
+])
+
# Macros from the top-level gcc directory.
m4_include([../config/gc++filt.m4])
m4_include([../config/tls.m4])
/* Define if compatibility should be provided for -mlong-double-64. */
#undef _GLIBCXX_LONG_DOUBLE_COMPAT
+/* Define to the letter to which size_t is mangled. */
+#undef _GLIBCXX_MANGLE_SIZE_T
+
/* Define if ptrdiff_t is int. */
#undef _GLIBCXX_PTRDIFF_T_IS_INT
_ZNSt6thread6_StateD[012]Ev;
_ZNSt6thread15_M_start_threadESt10unique_ptrINS_6_StateESt14default_deleteIS1_EEPFvvE;
+ # Support for the Transactional Memory TS (N4514)
+ _ZGTtNSt11logic_errorC[12]EPKc;
+ _ZGTtNSt11logic_errorC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNKSt11logic_error4whatEv;
+ _ZGTtNSt11logic_errorD[012]Ev;
+ _ZGTtNSt12domain_errorC[12]EPKc;
+ _ZGTtNSt12domain_errorC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNSt12domain_errorD[012]Ev;
+ _ZGTtNSt16invalid_argumentC[12]EPKc;
+ _ZGTtNSt16invalid_argumentC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNSt16invalid_argumentD[012]Ev;
+ _ZGTtNSt12length_errorC[12]EPKc;
+ _ZGTtNSt12length_errorC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNSt12length_errorD[012]Ev;
+ _ZGTtNSt12out_of_rangeC[12]EPKc;
+ _ZGTtNSt12out_of_rangeC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNSt12out_of_rangeD[012]Ev;
+ _ZGTtNSt13runtime_errorC[12]EPKc;
+ _ZGTtNSt13runtime_errorC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNKSt13runtime_error4whatEv;
+ _ZGTtNSt13runtime_errorD[012]Ev;
+ _ZGTtNSt11range_errorC[12]EPKc;
+ _ZGTtNSt11range_errorC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNSt11range_errorD[012]Ev;
+ _ZGTtNSt14overflow_errorC[12]EPKc;
+ _ZGTtNSt14overflow_errorC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNSt14overflow_errorD[012]Ev;
+ _ZGTtNSt15underflow_errorC[12]EPKc;
+ _ZGTtNSt15underflow_errorC[12]ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;
+ _ZGTtNSt15underflow_errorD[012]Ev;
+
} GLIBCXX_3.4.21;
# Symbols in the support library (libsupc++) have their own tag.
} CXXABI_1.3.8;
+CXXABI_1.3.10 {
+
+ # Support for the Transactional Memory TS (N4514)
+ _ZGTtNKSt9exceptionD1Ev;
+ _ZGTtNKSt9exception4whatEv;
+ _ZGTtNKSt13bad_exceptionD1Ev;
+ _ZGTtNKSt13bad_exception4whatEv;
+
+} CXXABI_1.3.9;
+
# Symbols in the support library (libsupc++) supporting transactional memory.
CXXABI_TM_1 {
C_INCLUDE_DIR
ALLOCATOR_NAME
ALLOCATOR_H
+ENABLE_ALLOCATOR_NEW_FALSE
+ENABLE_ALLOCATOR_NEW_TRUE
CLOCALE_INTERNAL_H
CLOCALE_CC
CTIME_CC
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<_LT_EOF
-#line 11597 "configure"
+#line 11599 "configure"
#include "confdefs.h"
#if HAVE_DLFCN_H
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<_LT_EOF
-#line 11703 "configure"
+#line 11705 "configure"
#include "confdefs.h"
#if HAVE_DLFCN_H
# Fake what AC_TRY_COMPILE does.
cat > conftest.$ac_ext << EOF
-#line 15389 "configure"
+#line 15391 "configure"
int main()
{
typedef bool atomic_type;
rm -f conftest*
cat > conftest.$ac_ext << EOF
-#line 15424 "configure"
+#line 15426 "configure"
int main()
{
typedef short atomic_type;
rm -f conftest*
cat > conftest.$ac_ext << EOF
-#line 15459 "configure"
+#line 15461 "configure"
int main()
{
// NB: _Atomic_word not necessarily int.
rm -f conftest*
cat > conftest.$ac_ext << EOF
-#line 15495 "configure"
+#line 15497 "configure"
int main()
{
typedef long long atomic_type;
# unnecessary for this test.
cat > conftest.$ac_ext << EOF
-#line 15574 "configure"
+#line 15576 "configure"
int main()
{
_Decimal32 d1;
# unnecessary for this test.
cat > conftest.$ac_ext << EOF
-#line 15616 "configure"
+#line 15618 "configure"
template<typename T1, typename T2>
struct same
{ typedef T2 type; };
rm -f conftest*
cat > conftest.$ac_ext << EOF
-#line 15650 "configure"
+#line 15652 "configure"
template<typename T1, typename T2>
struct same
{ typedef T2 type; };
+
# Check whether --enable-cheaders was given.
if test "${enable_cheaders+set}" = set; then :
enableval=$enable_cheaders;
+# For Transactional Memory TS
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking how size_t is mangled" >&5
+$as_echo_n "checking how size_t is mangled... " >&6; }
+if test "${glibcxx_cv_size_t_mangling+set}" = set; then :
+ $as_echo_n "(cached) " >&6
+else
+
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+extern __SIZE_TYPE__ x; extern unsigned long x;
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ glibcxx_cv_size_t_mangling=m
+else
+
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+extern __SIZE_TYPE__ x; extern unsigned int x;
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ glibcxx_cv_size_t_mangling=j
+else
+
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+extern __SIZE_TYPE__ x; extern unsigned long long x;
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ glibcxx_cv_size_t_mangling=y
+else
+
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+extern __SIZE_TYPE__ x; extern unsigned short x;
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ glibcxx_cv_size_t_mangling=t
+else
+ glibcxx_cv_size_t_mangling=x
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_size_t_mangling" >&5
+$as_echo "$glibcxx_cv_size_t_mangling" >&6; }
+ if test $glibcxx_cv_size_t_mangling = x; then
+ as_fn_error "Unknown underlying type for size_t" "$LINENO" 5
+ fi
+
+cat >>confdefs.h <<_ACEOF
+#define _GLIBCXX_MANGLE_SIZE_T $glibcxx_cv_size_t_mangling
+_ACEOF
+
+
+
# Define documentation rules conditionally.
# See if makeinfo has been installed and is modern enough
fi
+ if test $enable_libstdcxx_allocator_flag = new; then
+ ENABLE_ALLOCATOR_NEW_TRUE=
+ ENABLE_ALLOCATOR_NEW_FALSE='#'
+else
+ ENABLE_ALLOCATOR_NEW_TRUE='#'
+ ENABLE_ALLOCATOR_NEW_FALSE=
+fi
+
+
if test $enable_cheaders = c; then
GLIBCXX_C_HEADERS_C_TRUE=
GLIBCXX_C_HEADERS_C_FALSE='#'
as_fn_error "conditional \"GLIBCXX_BUILD_PCH\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
+if test -z "${ENABLE_ALLOCATOR_NEW_TRUE}" && test -z "${ENABLE_ALLOCATOR_NEW_FALSE}"; then
+ as_fn_error "conditional \"ENABLE_ALLOCATOR_NEW\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
if test -z "${GLIBCXX_C_HEADERS_C_TRUE}" && test -z "${GLIBCXX_C_HEADERS_C_FALSE}"; then
as_fn_error "conditional \"GLIBCXX_C_HEADERS_C\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
GLIBCXX_ENABLE_FILESYSTEM_TS
GLIBCXX_CHECK_FILESYSTEM_DEPS
+# For Transactional Memory TS
+GLIBCXX_CHECK_SIZE_T_MANGLING
+
# Define documentation rules conditionally.
# See if makeinfo has been installed and is modern enough
echo 0 > stamp-cxx11-abi
endif
+if ENABLE_ALLOCATOR_NEW
+stamp-allocator-new:
+ echo 1 > stamp-allocator-new
+else
+stamp-allocator-new:
+ echo 0 > stamp-allocator-new
+endif
+
# NB: The non-empty default ldbl_compat works around an AIX sed
# oddity, see libstdc++/31957 for details.
${host_builddir}/c++config.h: ${CONFIG_HEADER} \
stamp-visibility \
stamp-extern-template \
stamp-dual-abi \
- stamp-cxx11-abi
+ stamp-cxx11-abi \
+ stamp-allocator-new
@date=`cat ${toplevel_srcdir}/gcc/DATESTAMP` ;\
ns_version=`cat stamp-namespace-version` ;\
visibility=`cat stamp-visibility` ;\
externtemplate=`cat stamp-extern-template` ;\
dualabi=`cat stamp-dual-abi` ;\
cxx11abi=`cat stamp-cxx11-abi` ;\
+ allocatornew=`cat stamp-allocator-new` ;\
ldbl_compat='s,g,g,' ;\
grep "^[ ]*#[ ]*define[ ][ ]*_GLIBCXX_LONG_DOUBLE_COMPAT[ ][ ]*1[ ]*$$" \
${CONFIG_HEADER} > /dev/null 2>&1 \
-e "s,define _GLIBCXX_EXTERN_TEMPLATE$$, define _GLIBCXX_EXTERN_TEMPLATE $$externtemplate," \
-e "s,define _GLIBCXX_USE_DUAL_ABI, define _GLIBCXX_USE_DUAL_ABI $$dualabi," \
-e "s,define _GLIBCXX_USE_CXX11_ABI, define _GLIBCXX_USE_CXX11_ABI $$cxx11abi," \
+ -e "s,define _GLIBCXX_USE_ALLOCATOR_NEW, define _GLIBCXX_USE_ALLOCATOR_NEW $$allocatornew," \
-e "$$ldbl_compat" \
< ${glibcxx_srcdir}/include/bits/c++config > $@ ;\
sed -e 's/HAVE_/_GLIBCXX_HAVE_/g' \
@ENABLE_CXX11_ABI_FALSE@stamp-cxx11-abi:
@ENABLE_CXX11_ABI_FALSE@ echo 0 > stamp-cxx11-abi
+@ENABLE_ALLOCATOR_NEW_TRUE@stamp-allocator-new:
+@ENABLE_ALLOCATOR_NEW_TRUE@ echo 1 > stamp-allocator-new
+@ENABLE_ALLOCATOR_NEW_FALSE@stamp-allocator-new:
+@ENABLE_ALLOCATOR_NEW_FALSE@ echo 0 > stamp-allocator-new
+
# NB: The non-empty default ldbl_compat works around an AIX sed
# oddity, see libstdc++/31957 for details.
${host_builddir}/c++config.h: ${CONFIG_HEADER} \
stamp-visibility \
stamp-extern-template \
stamp-dual-abi \
- stamp-cxx11-abi
+ stamp-cxx11-abi \
+ stamp-allocator-new
@date=`cat ${toplevel_srcdir}/gcc/DATESTAMP` ;\
ns_version=`cat stamp-namespace-version` ;\
visibility=`cat stamp-visibility` ;\
externtemplate=`cat stamp-extern-template` ;\
dualabi=`cat stamp-dual-abi` ;\
cxx11abi=`cat stamp-cxx11-abi` ;\
+ allocatornew=`cat stamp-allocator-new` ;\
ldbl_compat='s,g,g,' ;\
grep "^[ ]*#[ ]*define[ ][ ]*_GLIBCXX_LONG_DOUBLE_COMPAT[ ][ ]*1[ ]*$$" \
${CONFIG_HEADER} > /dev/null 2>&1 \
-e "s,define _GLIBCXX_EXTERN_TEMPLATE$$, define _GLIBCXX_EXTERN_TEMPLATE $$externtemplate," \
-e "s,define _GLIBCXX_USE_DUAL_ABI, define _GLIBCXX_USE_DUAL_ABI $$dualabi," \
-e "s,define _GLIBCXX_USE_CXX11_ABI, define _GLIBCXX_USE_CXX11_ABI $$cxx11abi," \
+ -e "s,define _GLIBCXX_USE_ALLOCATOR_NEW, define _GLIBCXX_USE_ALLOCATOR_NEW $$allocatornew," \
-e "$$ldbl_compat" \
< ${glibcxx_srcdir}/include/bits/c++config > $@ ;\
sed -e 's/HAVE_/_GLIBCXX_HAVE_/g' \
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
+
+# ifdef _GLIBCXX_TM_TS_INTERNAL
+ friend void
+ ::_txnal_cow_string_C1_for_exceptions(void* that, const char* s,
+ void* exc);
+ friend const char*
+ ::_txnal_cow_string_c_str(const void *that);
+ friend void
+ ::_txnal_cow_string_D1(void *that);
+ friend void
+ ::_txnal_cow_string_D1_commit(void *that);
+# endif
};
#endif // !_GLIBCXX_USE_CXX11_ABI
# define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
# define _GLIBCXX_END_EXTERN_C }
+#define _GLIBCXX_USE_ALLOCATOR_NEW
+
+// Conditionally enable annotations for the Transactional Memory TS on C++11.
+// Most of the following conditions are due to limitations in the current
+// implementation.
+#if __cplusplus >= 201103L && _GLIBCXX_USE_CXX11_ABI \
+ && _GLIBCXX_USE_DUAL_ABI && __cpp_transactional_memory >= 201505L \
+ && !_GLIBCXX_FULLY_DYNAMIC_STRING && __GXX_WEAK__ \
+ && _GLIBCXX_USE_ALLOCATOR_NEW
+#define _GLIBCXX_TXN_SAFE transaction_safe
+#define _GLIBCXX_TXN_SAFE_DYN transaction_safe_dynamic
+#else
+#define _GLIBCXX_TXN_SAFE
+#define _GLIBCXX_TXN_SAFE_DYN
+#endif
+
#else // !__cplusplus
# define _GLIBCXX_BEGIN_EXTERN_C
# define _GLIBCXX_END_EXTERN_C
public:
/** Takes a character string describing the error. */
explicit
- logic_error(const string& __arg);
+ logic_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
explicit
- logic_error(const char*);
+ logic_error(const char*) _GLIBCXX_TXN_SAFE;
#endif
#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS
logic_error& operator=(const logic_error&) _GLIBCXX_USE_NOEXCEPT;
#endif
- virtual ~logic_error() _GLIBCXX_USE_NOEXCEPT;
+ virtual ~logic_error() _GLIBCXX_TXN_SAFE_DYN _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 _GLIBCXX_USE_NOEXCEPT;
+ what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
+
+# ifdef _GLIBCXX_TM_TS_INTERNAL
+ friend void*
+ ::_txnal_logic_error_get_msg(void* e);
+# endif
};
/** Thrown by the library, or by you, to report domain errors (domain in
class domain_error : public logic_error
{
public:
- explicit domain_error(const string& __arg);
+ explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
- explicit domain_error(const char*);
+ explicit domain_error(const char*) _GLIBCXX_TXN_SAFE;
#endif
virtual ~domain_error() _GLIBCXX_USE_NOEXCEPT;
};
class invalid_argument : public logic_error
{
public:
- explicit invalid_argument(const string& __arg);
+ explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
- explicit invalid_argument(const char*);
+ explicit invalid_argument(const char*) _GLIBCXX_TXN_SAFE;
#endif
virtual ~invalid_argument() _GLIBCXX_USE_NOEXCEPT;
};
class length_error : public logic_error
{
public:
- explicit length_error(const string& __arg);
+ explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
- explicit length_error(const char*);
+ explicit length_error(const char*) _GLIBCXX_TXN_SAFE;
#endif
virtual ~length_error() _GLIBCXX_USE_NOEXCEPT;
};
class out_of_range : public logic_error
{
public:
- explicit out_of_range(const string& __arg);
+ explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
- explicit out_of_range(const char*);
+ explicit out_of_range(const char*) _GLIBCXX_TXN_SAFE;
#endif
virtual ~out_of_range() _GLIBCXX_USE_NOEXCEPT;
};
public:
/** Takes a character string describing the error. */
explicit
- runtime_error(const string& __arg);
+ runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
explicit
- runtime_error(const char*);
+ runtime_error(const char*) _GLIBCXX_TXN_SAFE;
#endif
#if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS
runtime_error& operator=(const runtime_error&) _GLIBCXX_USE_NOEXCEPT;
#endif
- virtual ~runtime_error() _GLIBCXX_USE_NOEXCEPT;
+ virtual ~runtime_error() _GLIBCXX_TXN_SAFE_DYN _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 _GLIBCXX_USE_NOEXCEPT;
+ what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
+
+# ifdef _GLIBCXX_TM_TS_INTERNAL
+ friend void*
+ ::_txnal_runtime_error_get_msg(void* e);
+# endif
};
/** Thrown to indicate range errors in internal computations. */
class range_error : public runtime_error
{
public:
- explicit range_error(const string& __arg);
+ explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
- explicit range_error(const char*);
+ explicit range_error(const char*) _GLIBCXX_TXN_SAFE;
#endif
virtual ~range_error() _GLIBCXX_USE_NOEXCEPT;
};
class overflow_error : public runtime_error
{
public:
- explicit overflow_error(const string& __arg);
+ explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
- explicit overflow_error(const char*);
+ explicit overflow_error(const char*) _GLIBCXX_TXN_SAFE;
#endif
virtual ~overflow_error() _GLIBCXX_USE_NOEXCEPT;
};
class underflow_error : public runtime_error
{
public:
- explicit underflow_error(const string& __arg);
+ explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
- explicit underflow_error(const char*);
+ explicit underflow_error(const char*) _GLIBCXX_TXN_SAFE;
#endif
virtual ~underflow_error() _GLIBCXX_USE_NOEXCEPT;
};
#include "exception"
#include <cxxabi.h>
-std::exception::~exception() _GLIBCXX_USE_NOEXCEPT { }
+std::exception::~exception() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT { }
-std::bad_exception::~bad_exception() _GLIBCXX_USE_NOEXCEPT { }
+std::bad_exception::~bad_exception() _GLIBCXX_TXN_SAFE_DYN
+ _GLIBCXX_USE_NOEXCEPT
+{ }
abi::__forced_unwind::~__forced_unwind() throw() { }
abi::__foreign_exception::~__foreign_exception() throw() { }
const char*
-std::exception::what() const _GLIBCXX_USE_NOEXCEPT
+std::exception::what() const _GLIBCXX_TXN_SAFE_DYN _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 _GLIBCXX_USE_NOEXCEPT
+std::bad_exception::what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
{
return "std::bad_exception";
}
+
+// Transactional clones for the destructors and what().
+// what() is effectively transaction_pure, but we do not want to annotate it
+// as such; thus, we call exactly the respective nontransactional function.
+extern "C" {
+
+void
+_ZGTtNKSt9exceptionD1Ev(const std::exception*)
+{ }
+
+const char*
+_ZGTtNKSt9exception4whatEv(const std::exception* that)
+{
+ // We really want the non-virtual call here. We already executed the
+ // indirect call representing the virtual call, and the TM runtime or the
+ // compiler resolved it to this transactional clone. In the clone, we want
+ // to do the same as for the nontransactional original, so we just call it.
+ return that->std::exception::what();
+}
+
+void
+_ZGTtNKSt13bad_exceptionD1Ev(
+ const std::bad_exception*)
+{ }
+
+const char*
+_ZGTtNKSt13bad_exception4whatEv(
+ const std::bad_exception* that)
+{
+ // Also see _ZGTtNKSt9exception4whatEv.
+ return that->std::bad_exception::what();
+}
+
+}
{
public:
exception() _GLIBCXX_USE_NOEXCEPT { }
- virtual ~exception() _GLIBCXX_USE_NOEXCEPT;
+ virtual ~exception() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
/** Returns a C-style character string describing the general cause
* of the current error. */
- virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
+ virtual const char*
+ what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
};
/** If an %exception is thrown which is not listed in a function's
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
- virtual ~bad_exception() _GLIBCXX_USE_NOEXCEPT;
+ virtual ~bad_exception() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
// See comment in eh_exception.cc.
- virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
+ virtual const char*
+ what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
};
/// If you write a replacement %terminate handler, it must be of this type.
// ISO C++ 14882: 19.1 Exception classes
//
+// Enable hooks for support for the Transactional Memory TS (N4514).
+#define _GLIBCXX_TM_TS_INTERNAL
+void
+_txnal_cow_string_C1_for_exceptions(void* that, const char* s, void* exc);
+const char*
+_txnal_cow_string_c_str(const void* that);
+void
+_txnal_cow_string_D1(void* that);
+void
+_txnal_cow_string_D1_commit(void* that);
+void*
+_txnal_logic_error_get_msg(void* e);
+void*
+_txnal_runtime_error_get_msg(void* e);
+
// All exception classes still use the classic COW std::string.
#define _GLIBCXX_USE_CXX11_ABI 0
#define _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS 1
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
+
+// Support for the Transactional Memory TS (N4514).
+//
+// logic_error and runtime_error both carry a message in the form of a COW
+// string. This COW string is never made visible to users of the exception
+// because what() returns a C string. The COW string can be constructed as
+// either a copy of a COW string of another logic_error/runtime_error, or
+// using a C string or SSO string; thus, the COW string's _Rep is only
+// accessed by logic_error operations. We control all txnal clones of those
+// operations and thus can ensure that _Rep is never accessed transactionally.
+// Furthermore, _Rep will always have been allocated or deallocated via
+// global new or delete, so nontransactional writes we do to _Rep cannot
+// interfere with transactional accesses.
+extern "C" {
+
+#ifndef _GLIBCXX_MANGLE_SIZE_T
+#error Mangled name of size_t type not defined.
+#endif
+#define CONCAT1(x,y) x##y
+#define CONCAT(x,y) CONCAT1(x,y)
+#define _ZGTtnaX CONCAT(_ZGTtna,_GLIBCXX_MANGLE_SIZE_T)
+
+#ifdef __i386__
+/* Only for 32-bit x86. */
+# define ITM_REGPARM __attribute__((regparm(2)))
+#else
+# define ITM_REGPARM
+#endif
+
+#if __GXX_WEAK__
+// Declare all libitm symbols we rely on, but make them weak so that we do
+// not depend on libitm.
+extern void* _ZGTtnaX (size_t sz) __attribute__((weak));
+extern void _ZGTtdlPv (void* ptr) __attribute__((weak));
+extern uint8_t _ITM_RU1(const uint8_t *p)
+ ITM_REGPARM __attribute__((weak));
+extern uint32_t _ITM_RU4(const uint32_t *p)
+ ITM_REGPARM __attribute__((weak));
+extern uint64_t _ITM_RU8(const uint64_t *p)
+ ITM_REGPARM __attribute__((weak));
+extern void _ITM_memcpyRtWn(void *, const void *, size_t)
+ ITM_REGPARM __attribute__((weak));
+extern void _ITM_memcpyRnWt(void *, const void *, size_t)
+ ITM_REGPARM __attribute__((weak));
+extern void _ITM_addUserCommitAction(void (*)(void *), uint64_t, void *)
+ ITM_REGPARM __attribute__((weak));
+
+#else
+// If there is no support for weak symbols, create dummies. The exceptions
+// will not be declared transaction_safe in this case.
+void* _ZGTtnaX (size_t) { return NULL; }
+void _ZGTtdlPv (void*) { }
+uint8_t _ITM_RU1(const uint8_t *) { return 0; }
+uint32_t _ITM_RU4(const uint32_t *) { return 0; }
+uint64_t _ITM_RU8(const uint64_t *) { return 0; }
+void _ITM_memcpyRtWn(void *, const void *, size_t) { }
+void _ITM_memcpyRnWt(void *, const void *, size_t) { }
+void _ITM_addUserCommitAction(void (*)(void *), uint64_t, void *) { };
+#endif
+
+}
+
+// A transactional version of basic_string::basic_string(const char *s)
+// that also notifies the TM runtime about allocations belonging to this
+// exception.
+void
+_txnal_cow_string_C1_for_exceptions(void* that, const char* s, void *exc)
+{
+ typedef std::basic_string<char> bs_type;
+ bs_type *bs = (bs_type*) that;
+
+ // First, do a transactional strlen, but including the trailing zero.
+ bs_type::size_type len = 1;
+ for (const char *ss = s; _ITM_RU1((const uint8_t*) ss) != 0; ss++, len++);
+
+
+ // Allocate memory for the string and the refcount. We use the
+ // transactional clone of global new[]; if this throws, it will do so in a
+ // transaction-compatible way.
+ // The allocation belongs to this exception, so tell the runtime about it.
+ // TODO Once this is supported, link the following allocation to this
+ // exception: void *prev = _ITM_setAssociatedException(exc);
+ bs_type::_Rep *rep;
+ try
+ {
+ rep = (bs_type::_Rep*) _ZGTtnaX (len + sizeof (bs_type::_Rep));
+ }
+ catch (...)
+ {
+ // Pop the association with this exception.
+ // TODO Once this is supported, link the following allocation to this
+ // exception: _ITM_setAssociatedException(prev);
+ // We do not need to instrument a rethrow.
+ throw;
+ }
+ // Pop the association with this exception.
+ // TODO Once this is supported, link the following allocation to this
+ // exception: _ITM_setAssociatedException(prev);
+
+ // Now initialize the rest of the string and copy the C string. The memory
+ // will be freshly allocated, so nontransactional accesses are sufficient,
+ // including the writes when copying the string (see above).
+ rep->_M_set_sharable();
+ rep->_M_length = rep->_M_capacity = len - 1;
+ _ITM_memcpyRtWn(rep->_M_refdata(), s, len);
+ new (&bs->_M_dataplus) bs_type::_Alloc_hider(rep->_M_refdata(),
+ bs_type::allocator_type());
+}
+
+static void* txnal_read_ptr(void* const * ptr)
+{
+ static_assert(sizeof(uint64_t) == sizeof(void*)
+ || sizeof(uint32_t) == sizeof(void*));
+ // FIXME make a true compile-time choice to prevent warnings.
+#if __UINTPTR_MAX__ == __UINT64_MAX__
+ return (void*)_ITM_RU8((const uint64_t*)ptr);
+#else
+ return (void*)_ITM_RU4((const uint32_t*)ptr);
+#endif
+}
+
+// We must access the data pointer in the COW string transactionally because
+// another transaction can delete the string and reuse the memory.
+const char*
+_txnal_cow_string_c_str(const void* that)
+{
+ typedef std::basic_string<char> bs_type;
+ const bs_type *bs = (const bs_type*) that;
+
+ return (const char*) txnal_read_ptr((void**)&bs->_M_dataplus._M_p);
+}
+
+const char*
+_txnal_sso_string_c_str(const void* that)
+{
+ return (const char*) txnal_read_ptr(
+ (void* const*)const_cast<char* const*>(
+ &((const std::__sso_string*) that)->_M_s._M_p));
+}
+
+void
+_txnal_cow_string_D1_commit(void* data)
+{
+ typedef std::basic_string<char> bs_type;
+ bs_type::_Rep *rep = (bs_type::_Rep*) data;
+ rep->_M_dispose(bs_type::allocator_type());
+}
+
+void
+_txnal_cow_string_D1(void* that)
+{
+ typedef std::basic_string<char> bs_type;
+ bs_type::_Rep *rep = reinterpret_cast<bs_type::_Rep*>(
+ const_cast<char*>(_txnal_cow_string_c_str(that))) - 1;
+
+ // The string can be shared, in which case we would need to decrement the
+ // reference count. We cannot undo that because we might lose the string
+ // otherwise. Therefore, we register a commit action that will dispose of
+ // the string's _Rep.
+ enum {_ITM_noTransactionId = 1};
+ _ITM_addUserCommitAction(_txnal_cow_string_D1_commit, _ITM_noTransactionId,
+ rep);
+}
+
+void*
+_txnal_logic_error_get_msg(void* e)
+{
+ std::logic_error* le = (std::logic_error*) e;
+ return &le->_M_msg;
+}
+
+void*
+_txnal_runtime_error_get_msg(void* e)
+{
+ std::runtime_error* le = (std::runtime_error*) e;
+ return &le->_M_msg;
+}
+
+// The constructors are only declared transaction-safe if the C++11 ABI is
+// used for std::string and the exception classes use a COW string internally.
+// A user must not call these constructors otherwise; if they do, it will
+// result in undefined behavior, which is in this case not initializing this
+// string.
+#if _GLIBCXX_USE_DUAL_ABI
+#define CTORDTORSTRINGCSTR(s) _txnal_sso_string_c_str((s))
+#else
+#define CTORDTORSTRINGCSTR(s) ""
+#endif
+
+// This macro defines transaction constructors and destructors for a specific
+// exception class. NAME is the variable part of the mangled name, CLASS is
+// the class name, and BASE must be logic_error or runtime_error (which is
+// then used to call the proper friend function that can return a pointer to
+// the _M_msg member declared by the given (base) class).
+#define CTORDTOR(NAME, CLASS, BASE) \
+void \
+_ZGTtNSt##NAME##C1EPKc (CLASS* that, const char* s) \
+{ \
+ /* This will use the singleton _Rep for an empty string and just \
+ point to it instead of allocating memory. Thus, we can use it as \
+ source, copy it into the object we are constructing, and then \
+ construct the COW string in the latter manually. Note that the \
+ exception classes will not be declared transaction_safe if the \
+ shared empty _Rep is disabled with --enable-fully-dynamic-string \
+ (in which case _GLIBCXX_FULLY_DYNAMIC_STRING is nonzero). */ \
+ CLASS e(""); \
+ _ITM_memcpyRnWt(that, &e, sizeof(CLASS)); \
+ _txnal_cow_string_C1_for_exceptions(_txnal_##BASE##_get_msg(that), \
+ s, that); \
+} \
+void \
+_ZGTtNSt##NAME##C2EPKc (CLASS*, const char*) \
+ __attribute__((alias ("_ZGTtNSt" #NAME "C1EPKc"))); \
+void \
+_ZGTtNSt##NAME##C1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE( \
+ CLASS* that, const std::__sso_string& s) \
+{ \
+ CLASS e(""); \
+ _ITM_memcpyRnWt(that, &e, sizeof(CLASS)); \
+ /* Get the C string from the SSO string. */ \
+ _txnal_cow_string_C1_for_exceptions(_txnal_##BASE##_get_msg(that), \
+ CTORDTORSTRINGCSTR(&s), that); \
+} \
+void \
+_ZGTtNSt##NAME##C2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE( \
+ CLASS*, const std::__sso_string&) __attribute__((alias \
+("_ZGTtNSt" #NAME \
+ "C1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"))); \
+void \
+_ZGTtNSt##NAME##D1Ev(CLASS* that) \
+{ _txnal_cow_string_D1(_txnal_##BASE##_get_msg(that)); } \
+void \
+_ZGTtNSt##NAME##D2Ev(CLASS*) \
+__attribute__((alias ("_ZGTtNSt" #NAME "D1Ev"))); \
+void \
+_ZGTtNSt##NAME##D0Ev(CLASS* that) \
+{ \
+ _ZGTtNSt##NAME##D1Ev(that); \
+ _ZGTtdlPv(that); \
+}
+
+// Now create all transactional constructors and destructors, as well as the
+// two virtual what() functions.
+extern "C" {
+
+CTORDTOR(11logic_error, std::logic_error, logic_error)
+
+const char*
+_ZGTtNKSt11logic_error4whatEv(const std::logic_error* that)
+{
+ return _txnal_cow_string_c_str(_txnal_logic_error_get_msg(
+ const_cast<std::logic_error*>(that)));
+}
+
+CTORDTOR(12domain_error, std::domain_error, logic_error)
+CTORDTOR(16invalid_argument, std::invalid_argument, logic_error)
+CTORDTOR(12length_error, std::length_error, logic_error)
+CTORDTOR(12out_of_range, std::out_of_range, logic_error)
+
+
+CTORDTOR(13runtime_error, std::runtime_error, runtime_error)
+
+const char*
+_ZGTtNKSt13runtime_error4whatEv(const std::runtime_error* that)
+{
+ return _txnal_cow_string_c_str(_txnal_runtime_error_get_msg(
+ const_cast<std::runtime_error*>(that)));
+}
+
+CTORDTOR(11range_error, std::range_error, runtime_error)
+CTORDTOR(14overflow_error, std::overflow_error, runtime_error)
+CTORDTOR(15underflow_error, std::underflow_error, runtime_error)
+
+}
known_versions.push_back("CXXABI_1.3.7");
known_versions.push_back("CXXABI_1.3.8");
known_versions.push_back("CXXABI_1.3.9");
+ known_versions.push_back("CXXABI_1.3.10");
known_versions.push_back("CXXABI_TM_1");
known_versions.push_back("CXXABI_FLOAT128");
}
// Check that added symbols are added in the latest pre-release version.
bool latestp = (test.version_name == "GLIBCXX_3.4.22"
- || test.version_name == "CXXABI_1.3.9"
+ || test.version_name == "CXXABI_1.3.10"
|| test.version_name == "CXXABI_FLOAT128"
|| test.version_name == "CXXABI_TM_1");
if (added && !latestp)
projects / gcc.git / commitdiff