Add exe-owned registry variants to dynamic_loading test

Add a second axis to the dynamic_loading test variants: which module owns
and exports the single shared registry-state symbol. Selected at compile
time via the REGISTRY_IN_EXE macro -- registry.cpp exports the state unless
REGISTRY_IN_EXE is set, in which case main.cpp (the executable) exports it
and the shared libraries import it.

CMake builds all four variants ({dll,exe}-owned x {default,indirect}); the
exe-owned ones link the libraries against the executable's import library
(ENABLE_EXPORTS). b2 builds only the two dll-owned variants: it does not
expose an executable's import library to dependent DLLs, so the reverse
linkage cannot be expressed on Windows.

Also rename the default-registry variant suffix from "" to "_default".

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: jll63

test/dynamic_loading/CMakeLists.txt

@@ -10,44 +10,72 @@ else()
 endif()
 
 # Build one set of {registry, method, overrider} shared libraries plus a test
-# executable. Each variant compiles the very same sources but with a different
-# default registry, selected by extra preprocessor definitions (ARGN) applied to
-# every target so all modules agree (ODR). Targets are suffixed and outputs go
-# to a per-variant directory so that main.cpp, which locates its sibling
-# libraries by filename fragment at runtime, never picks up the other variant.
-function(boost_openmethod_add_dynamic_loading_variant suffix)
+# executable. Each variant compiles the very same sources but with two knobs:
+#
+#   owner  - which module owns and exports the single shared registry-state
+#            symbol: "dll" (lib_registry owns it; method/overrider/exe import it)
+#            or "exe" (the executable owns it; all three libraries import it).
+#            In the "exe" case the libraries must link *against* the executable
+#            (reverse linkage); ENABLE_EXPORTS makes the exe produce the import
+#            library / -rdynamic exports needed for that.
+#   ARGN   - extra preprocessor definitions (e.g. the default registry) applied
+#            to every target so all modules agree (ODR).
+#
+# Targets are suffixed and outputs go to a per-variant directory so that
+# main.cpp, which locates its sibling libraries by filename fragment at runtime,
+# never picks up another variant's libraries.
+function(boost_openmethod_add_dynamic_loading_variant suffix owner)
     set(extra_defs ${ARGN})
     set(reg  boost_openmethod-dl_test_registry${suffix})
     set(meth boost_openmethod-dl_test_method${suffix})
     set(ovr  boost_openmethod-dl_test_overrider${suffix})
     set(exe  boost_openmethod-test_dynamic_loading${suffix})
     set(outdir "${CMAKE_CURRENT_BINARY_DIR}/dynamic_loading${suffix}")
 
-    # lib_registry: exports the registry's static policy state
     add_library(${reg} SHARED registry.cpp)
-    target_link_libraries(${reg} PUBLIC Boost::openmethod PRIVATE Boost::dll)
-
-    # lib_method: exports the speak method; imports registry state from lib_registry
     add_library(${meth} SHARED method.cpp)
-    target_link_libraries(${meth} PUBLIC Boost::openmethod ${reg} PRIVATE Boost::dll)
-
-    # lib_overrider: adds a Dog overrider; imported at runtime via Boost.DLL
     add_library(${ovr} SHARED overrider.cpp)
-    target_link_libraries(${ovr} PRIVATE Boost::openmethod ${meth} Boost::dll)
-
-    # Test executable: links against lib_method (and lib_registry transitively);
-    # dynamically loads lib_overrider at runtime.
     add_executable(${exe} main.cpp)
-    target_link_libraries(${exe}
-        PUBLIC Boost::openmethod ${reg} ${meth}
-        PRIVATE Boost::openmethod Boost::unit_test_framework Boost::dll)
-    add_dependencies(${exe} ${reg} ${meth} ${ovr})
+
+    # ENABLE_EXPORTS must be set before any library links against the executable
+    # (the exe-owned case below), as CMake validates that at the
+    # target_link_libraries call. The properties are (re)applied to every target
+    # in the foreach further down.
+    set_target_properties(${exe} PROPERTIES ENABLE_EXPORTS ON)
+
+    if (owner STREQUAL "exe")
+        # The executable owns and exports the registry state; the libraries
+        # import it and therefore link against the executable.
+        list(APPEND extra_defs REGISTRY_IN_EXE)
+        target_link_libraries(${reg}  PUBLIC Boost::openmethod ${exe} PRIVATE Boost::dll)
+        target_link_libraries(${meth} PUBLIC Boost::openmethod ${exe} PRIVATE Boost::dll)
+        target_link_libraries(${ovr}  PRIVATE Boost::openmethod ${meth} ${exe} Boost::dll)
+        target_link_libraries(${exe}
+            PRIVATE Boost::openmethod Boost::unit_test_framework Boost::dll)
+    else()
+        # lib_registry owns and exports the registry state; method/overrider/exe
+        # import it. lib_method links lib_registry; the exe links both and loads
+        # lib_overrider at runtime.
+        target_link_libraries(${reg}  PUBLIC Boost::openmethod PRIVATE Boost::dll)
+        target_link_libraries(${meth} PUBLIC Boost::openmethod ${reg} PRIVATE Boost::dll)
+        target_link_libraries(${ovr}  PRIVATE Boost::openmethod ${meth} Boost::dll)
+        target_link_libraries(${exe}
+            PUBLIC Boost::openmethod ${reg} ${meth}
+            PRIVATE Boost::openmethod Boost::unit_test_framework Boost::dll)
+        # The exe links/loads the libraries, so build them first.
+        add_dependencies(${exe} ${reg} ${meth} ${ovr})
+    endif()
+    # In the exe-owned case the libraries link against the exe, so the build
+    # order is the reverse (handled by the link dependency); we must not add
+    # exe -> libraries here or we'd form a cycle. Either way, building `tests`
+    # builds every module of the variant.
 
     # Put all of this variant's outputs in one directory so Boost.DLL can locate
     # the shared libraries relative to the test executable at runtime.
-    # ENABLE_EXPORTS is required so that symbols from each shared library are
-    # visible to other shared libraries loaded at runtime (e.g. the overrider
-    # can resolve symbols from the method/registry libraries).
+    # ENABLE_EXPORTS is required so that symbols from each module are visible to
+    # the shared libraries loaded at runtime (e.g. the overrider can resolve
+    # symbols from the method/registry/exe, and an exe-owned registry state can
+    # be imported by the dlopen'd libraries).
     # CXX_VISIBILITY_PRESET must be "default" so that the template static
     # variables used as the shared registry state are exported with DEFAULT ELF
     # visibility. With hidden visibility (as set by BoostRoot.cmake in the
@@ -69,17 +97,20 @@ function(boost_openmethod_add_dynamic_loading_variant suffix)
     endforeach()
 
     if (TARGET tests)
-        add_dependencies(tests ${exe})
+        add_dependencies(tests ${reg} ${meth} ${ovr} ${exe})
     endif()
 
     boost_openmethod_add_test(${exe})
 endfunction()
 
-# Variant 1: the default registry.
-boost_openmethod_add_dynamic_loading_variant("")
-
-# Variant 2: indirect_registry (default_registry + indirect_vptr policy),
-# selected via BOOST_OPENMETHOD_DEFAULT_REGISTRY.
+# Four variants: {registry owned by dll, by exe} x {default, indirect} registry.
+# indirect_registry (default_registry + indirect_vptr) is selected via
+# BOOST_OPENMETHOD_DEFAULT_REGISTRY.
+boost_openmethod_add_dynamic_loading_variant("_default" dll)
+boost_openmethod_add_dynamic_loading_variant(
+    "_indirect" dll
+    BOOST_OPENMETHOD_DEFAULT_REGISTRY=::boost::openmethod::indirect_registry)
+boost_openmethod_add_dynamic_loading_variant("_exereg_default" exe)
 boost_openmethod_add_dynamic_loading_variant(
-    "_indirect"
+    "_exereg_indirect" exe
     BOOST_OPENMETHOD_DEFAULT_REGISTRY=::boost::openmethod::indirect_registry)

test/dynamic_loading/Jamfile

@@ -44,11 +44,19 @@ local VISIBILITY = <local-visibility>global ;
 # default registry, selected by extra requirements (e.g. a <define>) applied to
 # every target so all modules agree (ODR). Targets are suffixed and outputs go
 # to a per-variant <location-prefix> so that main.cpp, which locates its sibling
-# libraries by filename fragment at runtime, never picks up the other variant.
+# libraries by filename fragment at runtime, never picks up another variant's
+# libraries.
+#
+# Here lib_registry always owns and exports the single shared registry-state
+# symbol; method/overrider/exe import it. The CMake build additionally has
+# "exe-owned" variants (the executable owns the state and the libraries link
+# against it). Those are CMake-only: b2 does not expose an executable's import
+# library to dependent DLLs, so the reverse linkage they need cannot be
+# expressed on Windows. See test/dynamic_loading/CMakeLists.txt.
 rule make-variant ( suffix : extra-req * )
 {
     # lib_registry: owns and exports the registry's static policy state.
-    # registry.cpp defines EXPORT_REGISTRY and INCLUDED_FROM itself.
+    # registry.cpp defines EXPORT_REGISTRY (since REGISTRY_IN_EXE is unset).
     lib boost_openmethod-dl_test_registry$(suffix)
         : registry.cpp
         : <link>shared
@@ -59,7 +67,7 @@ rule make-variant ( suffix : extra-req * )
         ;
 
     # lib_method: exports the speak() open-method; imports registry from
-    # lib_registry.  method.cpp defines EXPORT_METHOD and INCLUDED_FROM itself.
+    # lib_registry.
     lib boost_openmethod-dl_test_method$(suffix)
         : method.cpp
         : <link>shared
@@ -71,7 +79,6 @@ rule make-variant ( suffix : extra-req * )
         ;
 
     # lib_overrider: adds the Dog overrider; dynamically loaded at runtime.
-    # overrider.cpp defines INCLUDED_FROM itself.
     lib boost_openmethod-dl_test_overrider$(suffix)
         : overrider.cpp
         : <link>shared
@@ -85,8 +92,8 @@ rule make-variant ( suffix : extra-req * )
         ;
 
     # Test executable:
-    #   sources (linked)   : main.cpp, lib_registry, unit_test_framework, boost_dll
-    #   runtime-loaded     : lib_method, lib_overrider
+    #   sources (linked) : main.cpp, lib_registry, unit_test_framework, boost_dll
+    #   runtime-loaded   : lib_method, lib_overrider
     # All shared libraries are placed alongside the test executable via
     # <location-prefix>dynamic_loading$(suffix).test, so main.cpp can find them
     # by scanning dll::program_location().parent_path() on all platforms.
@@ -113,10 +120,8 @@ rule make-variant ( suffix : extra-req * )
         ;
 }
 
-# Variant 1: the default registry.
-make-variant "" : ;
-
-# Variant 2: indirect_registry (default_registry + indirect_vptr policy),
-# selected via BOOST_OPENMETHOD_DEFAULT_REGISTRY.
+# Two variants (dll-owned registry state) x {default, indirect} registry. The
+# exe-owned variants are CMake-only (see the note above).
+make-variant _default : ;
 make-variant _indirect
     : <define>BOOST_OPENMETHOD_DEFAULT_REGISTRY=::boost::openmethod::indirect_registry ;

test/dynamic_loading/main.cpp

@@ -8,6 +8,12 @@
 
 #define INCLUDED_FROM "main.cpp"
 
+// When the build asks for the executable to own the registry state
+// (REGISTRY_IN_EXE), this module exports it and the shared libraries import it.
+#if defined(REGISTRY_IN_EXE)
+#define EXPORT_REGISTRY
+#endif
+
 #include "registry.hpp"
 #include "method.hpp"
 
@@ -22,6 +28,14 @@
 using namespace boost::openmethod;
 namespace mp11 = boost::mp11;
 
+#if defined(_WIN32) || defined(__CYGWIN__)
+#if defined(EXPORT_REGISTRY)
+static_assert(std::is_base_of_v<policies::dllexport, default_registry_dllvar>);
+#else
+static_assert(std::is_base_of_v<policies::dllimport, default_registry_dllvar>);
+#endif
+#endif
+
 using policy_ids_fn = const void**();
 
 BOOST_OPENMETHOD_CLASSES(Animal, Dog);

test/dynamic_loading/registry.cpp

@@ -7,7 +7,12 @@
 #pragma GCC diagnostic ignored "-Wunused-function"
 #endif
 
+// This module owns and exports the registry state, unless the build asks for
+// the executable to own it (REGISTRY_IN_EXE), in which case this becomes a
+// client that imports the state.
+#if !defined(REGISTRY_IN_EXE)
 #define EXPORT_REGISTRY
+#endif
 
 #include "registry.hpp"
 #include "classes.hpp"
@@ -19,8 +24,12 @@ namespace mp11 = boost::mp11;
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 #include <boost/config.hpp>
+#if defined(EXPORT_REGISTRY)
 static_assert(std::is_base_of_v<policies::dllexport, default_registry_dllvar>);
 #else
+static_assert(std::is_base_of_v<policies::dllimport, default_registry_dllvar>);
+#endif
+#else
 #include <boost/dll/alias.hpp>
 #endif