[AIX][compiler-rt] Fix cmake build of libatomic for cmake-3.16+

[lkail]

Summary

cmake-3.16+ for AIX changes the default behavior of building a SHARED library which breaks AIX's build of libatomic, i.e., cmake-3.16+ builds SHARED as an archive of dynamic libraries. To fix it, we have to build libatomic.so.1 as MODULE which keeps libatomic.so.1 as an normal dynamic library.

[jsji]

compiler-rt/cmake/Modules/CompilerRTAIXUtils.cmake

20

Can we move the common flags up and add -Wl, -G only > 3.16?

compiler-rt/lib/builtins/CMakeLists.txt

771

Add comments about why we need to update BUILTIN_TYPE here.

[lkail]

Address comments.

[jsji]

LGTM. Thanks.

[lkail]

Removed F_LOADONLY flag to get symbols visible to binder.

compiler-rt/cmake/Modules/AddCompilerRT.cmake

else()
       set(${output} "${name}-${arch}${COMPILER_RT_OS_SUFFIX}")
     endif()
   endif()
 endmacro()
 
 # Adds static or shared runtime for a list of architectures and operating
 # systems and puts it in the proper directory in the build and install trees.
 # add_compiler_rt_runtime(<name>
-#                         {OBJECT|STATIC|SHARED}
+#                         {OBJECT|STATIC|SHARED|MODULE}
 #                         ARCHS <architectures>
 #                         OS <os list>
 #                         SOURCES <source files>
 #                         CFLAGS <compile flags>
 #                         LINK_FLAGS <linker flags>
 #                         DEFS <compile definitions>
 #                         DEPS <dependencies>
 #                         LINK_LIBS <linked libraries> (only for shared library)
 #                         OBJECT_LIBS <object libraries to use as sources>
 #                         PARENT_TARGET <convenience parent target>
 #                         ADDITIONAL_HEADERS <header files>)
 function(add_compiler_rt_runtime name type)
-  if(NOT type MATCHES "^(OBJECT|STATIC|SHARED)$")
-    message(FATAL_ERROR "type argument must be OBJECT, STATIC or SHARED")
+  if(NOT type MATCHES "^(OBJECT|STATIC|SHARED|MODULE)$")
+    message(FATAL_ERROR
+            "type argument must be OBJECT, STATIC, SHARED or MODULE")
     return()
   endif()
   cmake_parse_arguments(LIB
     ""
     "PARENT_TARGET"
     "OS;ARCHS;SOURCES;CFLAGS;LINK_FLAGS;DEFS;DEPS;LINK_LIBS;OBJECT_LIBS;ADDITIONAL_HEADERS"
     ${ARGN})
   set(libnames)

compiler-rt/cmake/Modules/CompilerRTAIXUtils.cmake

 include(CMakeParseArguments)
 include(CompilerRTUtils)
 
 function(get_aix_libatomic_default_link_flags link_flags export_list)
-  set(${link_flags}
+  set(linkopts
     "-Wl,-H512 -Wl,-D0 \
      -Wl,-T512 -Wl,-bhalt:4 -Wl,-bernotok \
      -Wl,-bnoentry -Wl,-bexport:${export_list} \
-     -Wl,-bmodtype:SRE -Wl,-lc" PARENT_SCOPE)
+     -Wl,-bmodtype:SRE -Wl,-lc")
+  # Add `-Wl,-G`. Quoted from release notes of cmake-3.16.0
+  # > On AIX, runtime linking is no longer enabled by default.
+  # See https://cmake.org/cmake/help/latest/release/3.16.html
+  if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.16.0")
+    set(linkopts "-Wl,-G" "${linkopts}")
+  endif()
+  set(${link_flags} ${linkopts} PARENT_SCOPE)
+endfunction()
+
+function(get_aix_libatomic_type type)
+  if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
+    set(${type} SHARED PARENT_SCOPE)
+  else()
+    set(${type} MODULE PARENT_SCOPE)
+  endif()
 endfunction()
 
 macro(archive_aix_libatomic name)
   cmake_parse_arguments(LIB
     ""
     ""
     "ARCHS;PARENT_TARGET"
     ${ARGN})
   set(shared_libraries_to_archive "")
   foreach (arch ${LIB_ARCHS})
     if(CAN_TARGET_${arch})
       set(output_dir "${CMAKE_CURRENT_BINARY_DIR}/libatomic-${arch}.dir")
       # FIXME: Target name should be kept consistent with definition
       # in AddCompilerRT.cmake added by
       # add_compiler_rt_runtime(<name> SHARED ...)
       set(target ${name}-dynamic-${arch})
       if(TARGET ${target})
         file(MAKE_DIRECTORY ${output_dir})
         add_custom_command(OUTPUT "${output_dir}/libatomic.so.1"
                            POST_BUILD
                            COMMAND ${CMAKE_COMMAND} -E
                            copy "$<TARGET_FILE:${target}>"
                                 "${output_dir}/libatomic.so.1"
+                           # If built with MODULE, F_LOADONLY is set.
+                           # We have to remove this flag at POST_BUILD.
+                           COMMAND ${CMAKE_STRIP} -X32_64 -E
+                                "${output_dir}/libatomic.so.1"
                            DEPENDS ${target})
         list(APPEND shared_libraries_to_archive "${output_dir}/libatomic.so.1")
       endif()
     endif()
   endforeach()
   if(shared_libraries_to_archive)
     set(output_dir "")
     set(install_dir "")

compiler-rt/lib/builtins/CMakeLists.txt

 
 option(COMPILER_RT_BUILD_STANDALONE_LIBATOMIC
   "Build standalone shared atomic library."
   OFF)
 
 if(COMPILER_RT_BUILD_STANDALONE_LIBATOMIC)
   add_custom_target(builtins-standalone-atomic)
   set(BUILTIN_DEPS "")
+  set(BUILTIN_TYPE SHARED)
   if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
     if(NOT COMPILER_RT_LIBATOMIC_LINK_FLAGS)
       get_aix_libatomic_default_link_flags(COMPILER_RT_LIBATOMIC_LINK_FLAGS
         "${CMAKE_CURRENT_SOURCE_DIR}/ppc/atomic.exp")
     endif()
     # The compiler needs builtins to link any other binaries, so let
     # clang_rt.atomic be built after builtins.
     set(BUILTIN_DEPS builtins)
+    # For different versions of cmake, SHARED behaves differently. For some
+    # versions, we might need MODULE rather than SHARED.
+    get_aix_libatomic_type(BUILTIN_TYPE)
   endif()
   foreach (arch ${BUILTIN_SUPPORTED_ARCH})
     if(CAN_TARGET_${arch})
       add_compiler_rt_runtime(clang_rt.atomic
-                              SHARED
+                              ${BUILTIN_TYPE}
                               ARCHS ${arch}
                               SOURCES atomic.c
                               LINK_FLAGS ${COMPILER_RT_LIBATOMIC_LINK_FLAGS}
                               DEPS ${BUILTIN_DEPS}
                               PARENT_TARGET builtins-standalone-atomic)
     endif()
   endforeach()
   # FIXME: On AIX, we have to archive built shared libraries into a static