Add __cxa_guard_acquire hooks to support cooperative scheduling

[EricWF]

Summary

description to come soon!

CMakeLists.txt

 option(LIBCXXABI_ENABLE_THREADS "Build with threads enabled" ON)
 option(LIBCXXABI_HAS_PTHREAD_API "Ignore auto-detection and force use of pthread API" OFF)
 option(LIBCXXABI_HAS_EXTERNAL_THREAD_API
   "Build libc++abi with an externalized threading API.
   This option may only be set to ON when LIBCXXABI_ENABLE_THREADS=ON." OFF)
 option(LIBCXXABI_BUILD_EXTERNAL_THREAD_LIBRARY
   "Build libc++abi with an externalized threading library.
    This option may only be set to ON when LIBCXXABI_ENABLE_THREADS=ON" OFF)
+option(LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS
+  "Build libc++abi with support for overridding
+  __libcppabi_begin_potentially_blocking_region_begin and
+  __libcppabi_potentially_blocking_region_end as weak symbols" OFF)
 
 # FIXME: This option should default to off. Unfortunatly GCC 4.9 fails to link
 # programs to due undefined references to new/delete in libc++abi. Once this
 # has been fixed or worked around the default value should be changed.
 option(LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS
     "Build libc++abi with definitions for operator new/delete. Normally libc++
     provides these definitions" ON)
 option(LIBCXXABI_BUILD_32_BITS "Build 32 bit libc++abi." ${LLVM_BUILD_32_BITS})

 if (LIBCXXABI_SILENT_TERMINATE)
   add_definitions(-DLIBCXXABI_SILENT_TERMINATE)
 endif()
 
 if (LIBCXXABI_BAREMETAL)
     add_definitions(-DLIBCXXABI_BAREMETAL)
 endif()
 
+if (LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS)
+  add_definitions(-DLIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS)
+endif()
+
 string(REPLACE ";" " " LIBCXXABI_CXX_FLAGS "${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBCXXABI_C_FLAGS}")
 
 #===============================================================================
 # Setup Source Code
 #===============================================================================
 

src/CMakeLists.txt

set(LIBCXXABI_SOURCES
   # C++ STL files
   stdlib_exception.cpp
   stdlib_stdexcept.cpp
   stdlib_typeinfo.cpp
   # Internal files
   abort_message.cpp
   fallback_malloc.cpp
   private_typeinfo.cpp
+  potentially_blocking_region_hooks.cpp
 )
 
 if (LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS)
   list(APPEND LIBCXXABI_SOURCES stdlib_new_delete.cpp)
 endif()
 
 if (LIBCXXABI_ENABLE_EXCEPTIONS)
   list(APPEND LIBCXXABI_SOURCES cxa_exception.cpp)

src/cxa_guard.cpp

 //===---------------------------- cxa_guard.cpp ---------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "__cxxabi_config.h"
 
 #include "abort_message.h"
+#include "potentially_blocking_region_hooks.h"
 #include <__threading_support>
 
 #include <stdint.h>
 
 /*
     This implementation must be careful to not call code external to this file
     which will turn around and try to call __cxa_guard_acquire reentrantly.
     For this reason, the headers of this file are as restricted as possible.

 
 }  // unnamed namespace
 
 extern "C"
 {
 
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 _LIBCXXABI_FUNC_VIS int __cxa_guard_acquire(guard_type *guard_object) {
+    potentially_blocking_region lpbr;
+
     char* initialized = (char*)guard_object;
     if (std::__libcpp_mutex_lock(&guard_mut))
         abort_message("__cxa_guard_acquire failed to acquire mutex");
     int result = *initialized == 0;
     if (result)
     {
 #if defined(__APPLE__) && !defined(__arm__)
         // This is a special-case pthread dependency for Mac. We can't pull this

src/potentially_blocking_region_hooks.h

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LIBCXXABI_SRC_POTENTIALLY_BLOCKING_REGION_HOOKS_H
+#define LIBCXXABI_SRC_POTENTIALLY_BLOCKING_REGION_HOOKS_H
+
+#include "__cxxabi_config.h"
+
+#ifdef LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS
+extern "C" {
+  _LIBCXXABI_FUNC_VIS void __libcppabi_potentially_blocking_region_begin(void);
+  _LIBCXXABI_FUNC_VIS void __libcppabi_potentially_blocking_region_end(void);
+} // extern "C"
+#else
+namespace {
+  void __libcppabi_potentially_blocking_region_begin() {}
+  void __libcppabi_potentially_blocking_region_end() {}
+} // end namespace
+#endif // LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS
+
+namespace {
+struct potentially_blocking_region {
+  potentially_blocking_region() {
+    __libcppabi_potentially_blocking_region_begin();
+  }
+  ~potentially_blocking_region() {
+    __libcppabi_potentially_blocking_region_end();
+  }
+private:
+  potentially_blocking_region(potentially_blocking_region const&) = delete;
+  potentially_blocking_region& operator=(potentially_blocking_region const&) = delete;
+};
+
+} // end namespace
+#endif // LIBCXXABI_SRC_POTENTIALLY_BLOCKING_REGION_HOOKS_H

src/potentially_blocking_region_hooks.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "potentially_blocking_region_hooks.h"
+
+#ifdef LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS
+extern "C" {
+  _LIBCXXABI_WEAK void __libcppabi_potentially_blocking_region_begin(void) {}
+  _LIBCXXABI_WEAK void __libcppabi_potentially_blocking_region_end(void) {}
+} // extern "C"
+#endif // LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS

test/CMakeLists.txt

 endif()
 
 pythonize_bool(LIBCXXABI_BUILD_32_BITS)
 pythonize_bool(LIBCXX_ENABLE_SHARED)
 pythonize_bool(LIBCXXABI_ENABLE_SHARED)
 pythonize_bool(LIBCXXABI_ENABLE_THREADS)
 pythonize_bool(LIBCXXABI_ENABLE_EXCEPTIONS)
 pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
+pythonize_bool(LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS)
 pythonize_bool(LIBCXXABI_BUILD_EXTERNAL_THREAD_LIBRARY)
 set(LIBCXXABI_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
     "TargetInfo to use when setting up test environment.")
 set(LIBCXXABI_EXECUTOR "None" CACHE STRING
     "Executor to use when running tests.")
 
 set(AUTO_GEN_COMMENT "## Autogenerated by libcxxabi configuration.\n# Do not edit!")
 

test/libcxxabi/test/config.py

def configure_features(self):
             self.config.available_features.add('libcxxabi-no-exceptions')
         if not self.has_cpp_feature('noexcept_function_type', 201510):
             self.config.available_features.add('libcxxabi-no-noexcept-function-type')
         # test_exception_storage_nodynmem.pass.cpp fails under this specific configuration
         if self.get_lit_bool('cxx_ext_threads', False) and self.get_lit_bool('libcxxabi_shared', False):
             self.config.available_features.add('libcxxabi-shared-externally-threaded')
         if not self.get_lit_bool('llvm_unwinder', False):
             self.config.available_features.add('libcxxabi-has-system-unwinder')
+        if self.get_lit_bool('enable_potentially_blocking_region_hooks', False):
+            self.config.available_features.add('libcxxabi-potentially-blocking-region-hooks')
 
     def configure_compile_flags(self):
         self.cxx.compile_flags += [
             '-DLIBCXXABI_NO_TIMER',
             '-D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS',
         ]
         if self.get_lit_bool('enable_exceptions', True):
             self.cxx.compile_flags += ['-funwind-tables']

test/lit.site.cfg.in

 config.enable_shared            = "@LIBCXX_ENABLE_SHARED@"
 config.enable_exceptions        = "@LIBCXXABI_ENABLE_EXCEPTIONS@"
 config.host_triple              = "@LLVM_HOST_TRIPLE@"
 config.target_triple            = "@TARGET_TRIPLE@"
 config.use_target               = len("@LIBCXXABI_TARGET_TRIPLE@") > 0
 config.sysroot                  = "@LIBCXXABI_SYSROOT@"
 config.gcc_toolchain            = "@LIBCXXABI_GCC_TOOLCHAIN@"
 config.cxx_ext_threads          = "@LIBCXXABI_BUILD_EXTERNAL_THREAD_LIBRARY@"
+config.enable_potentially_blocking_region_hooks = "@LIBCXXABI_ENABLE_POTENTIALLY_BLOCKING_REGION_HOOKS@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXXABI_SOURCE_DIR@/test/lit.cfg")

test/potentially_blocking_callbacks.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// REQUIRES: libcxxabi-potentially-blocking-region-hooks
+
+// extern "C" void __libcpp_potentially_blocking_region_begin(void);
+// extern "C" void __libcpp_potentially_blocking_region_begin(void);
+
+// Test that potentially blocking region hooks can be overridden by the
+// user and that they are called by `__cxa_guard_acquire`.
+
+#include <cassert>
+
+int begin_called = 0;
+int end_called = 0;
+
+extern "C" void __libcppabi_potentially_blocking_region_begin() {
+  ++begin_called;
+}
+
+extern "C" void __libcppabi_potentially_blocking_region_end() {
+  ++end_called;
+}
+
+extern int init_val;
+
+template <int>
+void test_fn() {
+  static int dummy = init_val;
+  ((void)dummy);
+}
+
+int init_val = 0;
+
+int main() {
+  assert(begin_called == end_called);
+  begin_called = end_called = 0;
+  test_fn<1>();
+  assert(begin_called == 1);
+  assert(end_called == 1);
+}