- Reflect the assertion semantic in the library ABI tag (with a test);

- Address other feedback.

Author: var-const

libcxx/include/__config

@@ -291,14 +291,26 @@ typedef __char32_t char32_t;
 #    define _LIBCPP_HARDENING_SIG n // "none"
 #  endif
 
+#  if _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_OBSERVE
+#    define _LIBCPP_ASSERTION_SEMANTIC_SIG o
+#  elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE
+#    define _LIBCPP_ASSERTION_SEMANTIC_SIG q
+#  elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_ENFORCE
+#    define _LIBCPP_ASSERTION_SEMANTIC_SIG e
+#  else
+#    define _LIBCPP_ASSERTION_SEMANTIC_SIG i // `ignore`
+#  endif
+
 #  if !_LIBCPP_HAS_EXCEPTIONS
 #    define _LIBCPP_EXCEPTIONS_SIG n
 #  else
 #    define _LIBCPP_EXCEPTIONS_SIG e
 #  endif
 
 #  define _LIBCPP_ODR_SIGNATURE                                                                                        \
-    _LIBCPP_CONCAT(_LIBCPP_CONCAT(_LIBCPP_HARDENING_SIG, _LIBCPP_EXCEPTIONS_SIG), _LIBCPP_VERSION)
+    _LIBCPP_CONCAT(                                                                                                    \
+        _LIBCPP_CONCAT(_LIBCPP_CONCAT(_LIBCPP_HARDENING_SIG, _LIBCPP_ASSERTION_SEMANTIC_SIG), _LIBCPP_EXCEPTIONS_SIG), \
+        _LIBCPP_VERSION)
 
 // This macro marks a symbol as being hidden from libc++'s ABI. This is achieved
 // on two levels:

libcxx/include/__configuration/hardening.h

@@ -152,7 +152,8 @@ _LIBCPP_HARDENING_MODE_DEBUG
 //
 // Additionally, a special `hardening-dependent` value selects the assertion semantic based on the hardening mode in
 // effect: the production-capable modes (`fast` and `extensive`) map to `quick_enforce` and the `debug` mode maps to
-// `enforce`.
+// `enforce`. The `hardening-dependent` semantic cannot be selected explicitly, it is only used when no assertion
+// semantic is provided by the user _and_ the library's default semantic is configured to be dependent on hardening.
 //
 // Notes:
 // - Continuing execution after a hardening check fails results in undefined behavior; the `observe` semantic is meant

libcxx/test/extensions/libcxx/odr_signature.assertion_semantics.sh.cpp

@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// ABI tags have no effect in MSVC mode.
+// XFAIL: msvc
+
+// XFAIL: FROZEN-CXX03-HEADERS-FIXME
+
+// Test that we encode the assertion semantic in an ABI tag to avoid ODR violations when linking TUs that have different
+// values for it.
+
+// Note that GCC doesn't support `-Wno-macro-redefined`.
+// RUN: %{cxx} %s %{flags} %{compile_flags} -c -DTU1  -U_LIBCPP_ASSERTION_SEMANTIC -D_LIBCPP_ASSERTION_SEMANTIC=_LIBCPP_ASSERTION_SEMANTIC_IGNORE        -o %t.tu1.o
+// RUN: %{cxx} %s %{flags} %{compile_flags} -c -DTU2  -U_LIBCPP_ASSERTION_SEMANTIC -D_LIBCPP_ASSERTION_SEMANTIC=_LIBCPP_ASSERTION_SEMANTIC_OBSERVE       -o %t.tu2.o
+// RUN: %{cxx} %s %{flags} %{compile_flags} -c -DTU3  -U_LIBCPP_ASSERTION_SEMANTIC -D_LIBCPP_ASSERTION_SEMANTIC=_LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE -o %t.tu3.o
+// RUN: %{cxx} %s %{flags} %{compile_flags} -c -DTU4  -U_LIBCPP_ASSERTION_SEMANTIC -D_LIBCPP_ASSERTION_SEMANTIC=_LIBCPP_ASSERTION_SEMANTIC_ENFORCE       -o %t.tu4.o
+// RUN: %{cxx} %s %{flags} %{compile_flags} -c -DMAIN                                                                                                    -o %t.main.o
+// RUN: %{cxx} %t.tu1.o %t.tu2.o %t.tu3.o %t.tu4.o %t.main.o %{flags} %{link_flags} -o %t.exe
+// RUN: %{exec} %t.exe
+
+#include "test_macros.h"
+
+// `ignore` assertion semantic.
+#ifdef TU1
+#  include <__config>
+_LIBCPP_HIDE_FROM_ABI TEST_NOINLINE inline int f() { return 1; }
+int tu1() { return f(); }
+#endif // TU1
+
+// `observe` assertion semantic.
+#ifdef TU2
+#  include <__config>
+_LIBCPP_HIDE_FROM_ABI TEST_NOINLINE inline int f() { return 2; }
+int tu2() { return f(); }
+#endif // TU2
+
+// `quick-enforce` assertion semantic.
+#ifdef TU3
+#  include <__config>
+_LIBCPP_HIDE_FROM_ABI TEST_NOINLINE inline int f() { return 3; }
+int tu3() { return f(); }
+#endif // TU3
+
+// `enforce` assertion semantic.
+#ifdef TU4
+#  include <__config>
+_LIBCPP_HIDE_FROM_ABI TEST_NOINLINE inline int f() { return 4; }
+int tu4() { return f(); }
+#endif // TU4
+
+#ifdef MAIN
+#  include <cassert>
+
+int tu1();
+int tu2();
+int tu3();
+int tu4();
+
+int main(int, char**) {
+  assert(tu1() == 1);
+  assert(tu2() == 2);
+  assert(tu3() == 3);
+  assert(tu4() == 4);
+  return 0;
+}
+#endif // MAIN

libcxx/test/libcxx/assertions/semantics/assertion_semantic_incorrect_value.sh.cpp

@@ -14,8 +14,10 @@
 // UNSUPPORTED: c++03, libcpp-has-no-experimental-hardening-observe-semantic
 // REQUIRES: verify-support
 
-// Note that GCC doesn't support `-Wno-macro-redefined`.
 // RUN: %{verify} -U_LIBCPP_ASSERTION_SEMANTIC -D_LIBCPP_ASSERTION_SEMANTIC=42
+// `hardening-dependent` cannot be set as the semantic (it's only an indicator to use hardening-related logic to pick
+// the final semantic).
+// RUN: %{verify} -U_LIBCPP_ASSERTION_SEMANTIC -D_LIBCPP_ASSERTION_SEMANTIC=_LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT
 // Make sure that common cases of misuse produce readable errors. We deliberately disallow setting the assertion
 // semantic as if it were a boolean flag.
 // RUN: %{verify} -U_LIBCPP_ASSERTION_SEMANTIC -D_LIBCPP_ASSERTION_SEMANTIC=0

libcxx/test/libcxx/assertions/semantics/override_with_enforce_semantic.pass.cpp

@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This test ensures that we can override the assertion semantic used by any checked hardening mode with `enforce` (this
-// is valid for the `debug` mode as well, though a no-op).
+// This test ensures that we can override the assertion semantic used by any checked hardening mode with `enforce` on
+// a per-TU basis (this is valid for the `debug` mode as well, though a no-op).
 
 // `check_assertion.h` is only available starting from C++11 and requires Unix headers and regex support.
 // REQUIRES: has-unix-headers

libcxx/test/libcxx/assertions/semantics/override_with_ignore_semantic.pass.cpp

@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This test ensures that we can override the assertion semantic used by any hardening mode with `ignore` (this is valid
-// for the `none` mode as well, though a no-op).
+// This test ensures that we can override the assertion semantic used by any hardening mode with `ignore` on a per-TU
+// basis (this is valid for the `none` mode as well, though a no-op).
 
 // `check_assertion.h` is only available starting from C++11 and requires Unix headers and regex support.
 // REQUIRES: has-unix-headers

libcxx/test/libcxx/assertions/semantics/override_with_observe_semantic.pass.cpp

@@ -6,7 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This test ensures that we can override the assertion semantic used by any checked hardening mode with `observe`.
+// This test ensures that we can override the assertion semantic used by any checked hardening mode with `observe` on
+// a per-TU basis.
 
 // `check_assertion.h` is only available starting from C++11 and requires Unix headers and regex support.
 // REQUIRES: has-unix-headers

libcxx/test/libcxx/assertions/semantics/override_with_quick_enforce_semantic.pass.cpp

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // This test ensures that we can override the assertion semantic used by any checked hardening mode with `quick-enforce`
-// (this is valid for the `fast` and `extensive` modes as well, though a no-op).
+// on a per-TU basis (this is valid for the `fast` and `extensive` modes as well, though a no-op).
 
 // `check_assertion.h` is only available starting from C++11 and requires Unix headers and regex support.
 // REQUIRES: has-unix-headers