[CMAKE] Specify all_load when exporting symbols from an executable (macOS)

[jranieri-grammatech]

Summary

This changes the CMake export_executable_symbols function to force all symbols pulled in from static libraries to be linked into the final executable, even if they weren't directly referenced by the executable. This is necessary for plugins that wish to link against the executable and use LLVM functionality that the executable itself doesn't use.

In my specific use case, I'm writing a Clang plugin that wishes to use LLVM's JSON libraries.

[beanz]

I'm not really sure this is the best solution. This will result in bloating the clang binary substantially. An alternative approach would be to use linker order precedence, and pass the LLVM executable first, then LLVM static archives later on the link line. That would allow minimal tool binaries, and link the LLVM bits into your plugin.

[jranieri-grammatech]

In D53778#1277902, @beanz wrote:

I'm not really sure this is the best solution. This will result in bloating the clang binary substantially. An alternative approach would be to use linker order precedence, and pass the LLVM executable first, then LLVM static archives later on the link line. That would allow minimal tool binaries, and link the LLVM bits into your plugin.

I was able to get this to work by adding -bundle_loader /opt/clang/bin/clang-8 /opt/clang/lib/libLLVMSupport.a. Do you think adding -bundle_loader is something add_llvm_loadable_module should be responsible for doing?

[beanz]

Adding -bundle_loader in add_llvm_loadable_module doesn't work because LLVM modules can be loaded by lots of different tools, so they actually need to be fully self-contained. Obviously if a specific distribution is only supporting the module from one tool that distribution can do things differently, but as a general rule we can't make that assumption.

We could however add a new add_clang_plugin function to AddClang.cmake which could make the assumption that clang is your -bundle_loader. That would likely meet your needs.

[jranieri-grammatech]

Specify -bundle_loader when giving a PLUGIN_TOOL to add_llvm_loadable_module. This doesn't limit what executables can load the resulting shared library and just informs the static linker what functions will be present when the library is loaded.

[jranieri-grammatech]

rC345628 makes Clang depend on llvm::json, so this is no longer relevant for my purposes but I think it is a bit nicer to go this approach than always using -undefined suppress. I'd be okay with abandoning this revision if you'd prefer to keep things as-is.

cmake/modules/AddLLVM.cmake

if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LTO" OR
       endif()
     endif()
     set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
   endif()
   set_target_properties(${name} PROPERTIES FOLDER "Libraries")
 endmacro(add_llvm_library name)
 
 macro(add_llvm_loadable_module name)
+  cmake_parse_arguments(ARG "" "PLUGIN_TOOL" "" ${ARGN})
   llvm_add_library(${name} MODULE ${ARGN})
   if(NOT TARGET ${name})
     # Add empty "phony" target
     add_custom_target(${name})
   else()
     if( EXCLUDE_FROM_ALL )
       set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON)
     else()
else()
         install(TARGETS ${name}
                 ${export_to_llvmexports}
                 LIBRARY DESTINATION ${dlldir}
                 ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
       endif()
       set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
     endif()
   endif()
+  if(APPLE)
+    if(ARG_PLUGIN_TOOL)
+      if(TARGET ${ARG_PLUGIN_TOOL})
+        add_dependencies(${name} ${ARG_PLUGIN_TOOL})
+      endif()
+      set_property(
+        TARGET ${name}
+        APPEND_STRING
+        PROPERTY LINK_FLAGS
+                 " -bundle_loader ${LLVM_TOOLS_BINARY_DIR}/${ARG_PLUGIN_TOOL}")
+    else()
+      set_property(TARGET ${name}
+                   APPEND_STRING
+                   PROPERTY LINK_FLAGS
+                            "  -Wl,-flat_namespace -Wl,-undefined -Wl,suppress")
+    endif()
+  endif()
 
   set_target_properties(${name} PROPERTIES FOLDER "Loadable modules")
 endmacro(add_llvm_loadable_module name)
 
 
 macro(add_llvm_executable name)
   cmake_parse_arguments(ARG "DISABLE_LLVM_LINK_LLVM_DYLIB;IGNORE_EXTERNALIZE_DEBUGINFO;NO_INSTALL_RPATH" "" "DEPENDS" ${ARGN})
   llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} )

cmake/modules/HandleLLVMOptions.cmake

 
 # We use *.dylib rather than *.so on darwin.
 set(LLVM_PLUGIN_EXT ${CMAKE_SHARED_LIBRARY_SUFFIX})
 
 if(APPLE)
   if(LLVM_ENABLE_LLD AND LLVM_ENABLE_LTO)
     message(FATAL_ERROR "lld does not support LTO on Darwin")
   endif()
-  # Darwin-specific linker flags for loadable modules.
-  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-flat_namespace -Wl,-undefined -Wl,suppress")
 endif()
 
 # Pass -Wl,-z,defs. This makes sure all symbols are defined. Otherwise a DSO
 # build might work on ELF but fail on MachO/COFF.
 if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin" OR WIN32 OR CYGWIN OR
         ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR
         ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD") AND
    NOT LLVM_USE_SANITIZER)