[AIX][CMake] Changes for building on AIX with XL and GCC

[xingxue]

Summary

In support of IBM's efforts to produce a viable C and C++ LLVM compiler for AIX (ref: RFC at http://lists.llvm.org/pipermail/llvm-dev/2019-February/130175.html), this patch adds customizations to the CMake files in order to properly invoke the host toolchain for the build on AIX. Additional changes to enable a successful build will follow.

[sfertile]

llvm/cmake/modules/HandleLLVMOptions.cmake

138 ↗

(On Diff #186903)

I'm interested in why you choose bigtoc linker option over using large code model? From the little I understand about the bigtoc option it seems that large code model would be the preferable solution when expecting to have a toc that is a lot bigger then 64K.

[hubert.reinterpretcast]

llvm/cmake/modules/HandleLLVMOptions.cmake

138 ↗

(On Diff #186903)

-fPIC is already specified. Even if the code is generated using the large code model, TOC overflow is a hard error for the linker unless if -bbigtoc is specified. On linking, the XL compiler specifies -bbigtoc to the linker in response -qpic=large.

You can see this for yourself if you compile the following with -q64 -qpic=large and link with only -q64:

#define x2A( BASE )  BASE ## a, BASE ## b
#define x2B( BASE )  x2A(BASE ## a), x2A(BASE ## b)
#define x2C( BASE )  x2B(BASE ## a), x2B(BASE ## b)
#define x2D( BASE )  x2C(BASE ## a), x2C(BASE ## b)
#define x2E( BASE )  x2D(BASE ## a), x2D(BASE ## b)
#define x2F( BASE )  x2E(BASE ## a), x2E(BASE ## b)
#define x2G( BASE )  x2F(BASE ## a), x2F(BASE ## b)
#define x2H( BASE )  x2G(BASE ## a), x2G(BASE ## b)
#define x2I( BASE )  x2H(BASE ## a), x2H(BASE ## b)
#define x2J( BASE )  x2I(BASE ## a), x2I(BASE ## b)
#define x2K( BASE )  x2J(BASE ## a), x2J(BASE ## b)

#define x2KA( BASE )  x2K(BASE ## a), x2K(BASE ## b)
#define x2KB( BASE )  x2KA(BASE ## a), x2KA(BASE ## b)
int x2KB( x );

int main(void) { x2KB( ++x ); }

[hubert.reinterpretcast]

llvm/cmake/modules/HandleLLVMOptions.cmake

138 ↗

(On Diff #186903)

Okay, it seems -fPIC does not enable the large code model for GCC on AIX (but does for the new XL compilers). -mcmodel=large should be added for GCC; however, the linker option remains necessary.

[chandlerc]

llvm/include/llvm/Config/abi-breaking.h.cmake

37–41 ↗

(On Diff #186903)

Is this correct though? I would expect non-hidden visibility checks to break things.

[hubert.reinterpretcast]

llvm/include/llvm/Config/abi-breaking.h.cmake

37–41 ↗

(On Diff #186903)

My understanding is yes: AIX does not export by default. Maybe a comment in the code is warranted?

[sfertile]

llvm/cmake/modules/HandleLLVMOptions.cmake

138 ↗

(On Diff #186903)

I had a look at the example. You are right, the code XL generates does need the link-option. The code generated for main uses the large code model with R_TOCU/R_TOCL relocations, but the compiler inserts a bunch of code that still uses small code model R_TOC relocations (namely ._start, ._thread_init, and ._C_runtime_startup). The code gcc generates for the example links just fine without the extra option as they only use large code model relocations. We need to add -mcmodel=large for gcc, and only use -bbigtoc for XL.

[xingxue]

Address review comments:

• Add comment regarding correctness of not applying a visibility attribute when using GCC on AIX.
• Apply -mcmodel=large for GCC on AIX, and use -Wl,-bbigtoc for XL (on AIX) only.

[hubert.reinterpretcast]

llvm/cmake/modules/HandleLLVMOptions.cmake

139 ↗

(On Diff #188459)

For this and other instances of STREQUAL "XL", we should use MATCHES "XL" so that "XLClang" is also matched. See https://gitlab.kitware.com/cmake/cmake/merge_requests/2921.

[xingxue]

Address review comments:

• Replaced 'STREQUAL "XL"' with 'MATCHES "XL"'.

[hubert.reinterpretcast]

I believe all comments on this have been addressed. This LGTM. I'll probably commit this on Monday.

[hubert.reinterpretcast]

llvm/include/llvm/Config/abi-breaking.h.cmake

37 ↗

(On Diff #188983)

__GNU__ is not the macro we want to check here (it checks for GNU Hurd, i.e., the OS). The intention is to check for GCC. I am not sure if there is a better way to check for "real" GCC as opposed to the GCC-compatible compilers other than to filter for each of the known compatible compilers that do not suffer from the same limitation as GCC.

[xingxue]

Address review comments:

• Check __GNUC__ for GCC instead of __GNU__ and exclude CLANG which also sets macro __GNUC__.

[joerg]

Why do you exclude clang? I would expect LLVM at this point to not support visibility attributes on XCOFF either?

[hubert.reinterpretcast]

In D58250#1425142, @joerg wrote:

Why do you exclude clang? I would expect LLVM at this point to not support visibility attributes on XCOFF either?

The scope of this patch is to enable use of GCC and IBM XL compilers on AIX as build compilers for LLVM. The desired semantic of the line in question is to disable the use of the visibility attribute for GCC. The condition on __clang__ is meant to prevent gobbling up non-GCC compilers in the check for __GNUC__. The consideration of whether Clang should itself be exempted from the use of the visibility attribute on AIX seems premature.

llvm/trunk/cmake/modules/AddLLVM.cmake

if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
     if(NOT LLVM_NO_DEAD_STRIP)
       if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
         # ld64's implementation of -dead_strip breaks tools that use plugins.
         set_property(TARGET ${target_name} APPEND_STRING PROPERTY
                      LINK_FLAGS " -Wl,-dead_strip")
       elseif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
         set_property(TARGET ${target_name} APPEND_STRING PROPERTY
                      LINK_FLAGS " -Wl,-z -Wl,discard-unused=sections")
-      elseif(NOT WIN32 AND NOT LLVM_LINKER_IS_GOLD AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
+      elseif(NOT WIN32 AND NOT LLVM_LINKER_IS_GOLD AND
+             NOT ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD|AIX")
         # Object files are compiled with -ffunction-data-sections.
         # Versions of bfd ld < 2.23.1 have a bug in --gc-sections that breaks
         # tools that use plugins. Always pass --gc-sections once we require
         # a newer linker.
         set_property(TARGET ${target_name} APPEND_STRING PROPERTY
                      LINK_FLAGS " -Wl,--gc-sections")
       endif()
+    else() #LLVM_NO_DEAD_STRIP
+      if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+        set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+                     LINK_FLAGS " -Wl,-bnogc")
+      endif()
     endif()
   endif()
 endfunction(add_link_opts)
 
 # Set each output directory according to ${CMAKE_CONFIGURATION_TYPES}.
 # Note: Don't set variables CMAKE_*_OUTPUT_DIRECTORY any more,
 # or a certain builder, for eaxample, msbuild.exe, would be confused.
 function(set_output_directory target)

llvm/trunk/cmake/modules/HandleLLVMOptions.cmake

 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()
 
+if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+  if(NOT LLVM_BUILD_32_BITS)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "XL")
+      append("-q64" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+    else()
+      append("-maix64" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+    endif()
+    set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> -X64 qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+    set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> -X64 q  <TARGET> <LINK_FLAGS> <OBJECTS>")
+    set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> -X64 <TARGET>")
+    set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -X64 <TARGET>")
+  endif()
+  # -fPIC does not enable the large code model for GCC on AIX but does for XL.
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    append("-mcmodel=large" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES "XL")
+    # XL generates a small number of relocations not of the large model, -bbigtoc is needed.
+    append("-Wl,-bbigtoc"
+           CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+  endif()
+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" OR
-  ${CMAKE_SYSTEM_NAME} MATCHES "DragonFly") AND
+if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin|FreeBSD|OpenBSD|DragonFly|AIX" OR
+        WIN32 OR CYGWIN) AND
    NOT LLVM_USE_SANITIZER)
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs")
 endif()
 
 # Pass -Wl,-z,nodelete. This makes sure our shared libraries are not unloaded
 # by dlclose(). We need that since the CLI API relies on cross-references
 # between global objects which became horribly broken when one of the libraries
 # is unloaded.
if( XCODE )
     message(WARNING "-fPIC not supported with Xcode.")
   elseif( WIN32 OR CYGWIN)
     # On Windows all code is PIC. MinGW warns if -fPIC is used.
   else()
     add_flag_or_print_warning("-fPIC" FPIC)
   endif()
 endif()
 
-if(NOT WIN32 AND NOT CYGWIN)
+if(NOT WIN32 AND NOT CYGWIN AND NOT (${CMAKE_SYSTEM_NAME} MATCHES "AIX" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
   # MinGW warns if -fvisibility-inlines-hidden is used.
+  # GCC on AIX warns if -fvisibility-inlines-hidden is used.
   check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG)
   append_if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG "-fvisibility-inlines-hidden" CMAKE_CXX_FLAGS)
 endif()
 
 if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND MINGW)
   add_definitions( -D_FILE_OFFSET_BITS=64 )
 endif()
 

llvm/trunk/include/llvm/Config/abi-breaking.h.cmake

 #define LLVM_XSTR(s) LLVM_STR(s)
 #define LLVM_STR(s) #s
 #pragma detect_mismatch("LLVM_ENABLE_ABI_BREAKING_CHECKS", LLVM_XSTR(LLVM_ENABLE_ABI_BREAKING_CHECKS))
 #undef LLVM_XSTR
 #undef LLVM_STR
 #elif defined(_WIN32) || defined(__CYGWIN__) // Win32 w/o #pragma detect_mismatch
 // FIXME: Implement checks without weak.
 #elif defined(__cplusplus)
+#if !(defined(_AIX) && defined(__GNUC__) && !defined(__clang__))
+#define LLVM_HIDDEN_VISIBILITY __attribute__ ((visibility("hidden")))
+#else
+// GCC on AIX does not support visibility attributes. Symbols are not
+// exported by default on AIX.
+#define LLVM_HIDDEN_VISIBILITY
+#endif
 namespace llvm {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 extern int EnableABIBreakingChecks;
-__attribute__((weak, visibility ("hidden"))) int *VerifyEnableABIBreakingChecks = &EnableABIBreakingChecks;
+LLVM_HIDDEN_VISIBILITY
+__attribute__((weak)) int *VerifyEnableABIBreakingChecks =
+    &EnableABIBreakingChecks;
 #else
 extern int DisableABIBreakingChecks;
-__attribute__((weak, visibility ("hidden"))) int *VerifyDisableABIBreakingChecks = &DisableABIBreakingChecks;
+LLVM_HIDDEN_VISIBILITY
+__attribute__((weak)) int *VerifyDisableABIBreakingChecks =
+    &DisableABIBreakingChecks;
 #endif
 }
+#undef LLVM_HIDDEN_VISIBILITY
 #endif // _MSC_VER
 
 #endif // LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
 
 #endif