[AIX] Improve 32/64-bit build configuration

[daltenty]

Summary

AIX supports both 32-bit and 64-bit environments (with 32-bit being the default). This patch improves support for building LLVM on AIX in both 32-bit and 64-bit mode.

• Change host detection to return correct 32/64-bit triple as config_guess does not return the correct version on 64-bit. This can confuse JIT tests and other things that care about what the host triple is.
• Remove manual setting of 64-bit flags on AIX. AIX provides OBJECT_MODE environment variable to enable the user to obtain a 64-bit development environment. CMake will properly set these flags provided the user sets the correct OBJECT_MODE before configuring and setting them manually will interfere with 32-bit builds.
• Don't present the LLVM_BUILD_32_BITS option on AIX, users should use OBJECT_MODE when running CMake instead.

[DiggerLin]

LGTM

[stevewan]

llvm/cmake/modules/GetHostTriple.cmake

29

Since the added code implies the same, I'd suggest that we keep and move this comment to the new code.

[daltenty]

• Don't set -q64 in the CMakeLists, we should use OBJECT_MODE instead on AIX if we are planning to build 64-bit so CMake knows what we are up to.
• Restore comment

[stevewan]

llvm/cmake/modules/HandleLLVMOptions.cmake

174

Is this change somewhat out of scope here and fits better in a separate patch?

[daltenty]

llvm/cmake/modules/HandleLLVMOptions.cmake

174

The reason I'd included in this patch is it affects your ability to test this change. CMake won't set CMAKE_SIZEOF_VOID_P to the 64-bit case unless you have OBJECT_MODE=64 set, but these options override the OBJECT_MODE setting.

Maybe the best option is to split this patch and land this bit first.

[stevewan]

llvm/cmake/modules/HandleLLVMOptions.cmake

174

How's the value of LLVM_BUILD_32_BITS determined? I found in llvm/CMakeLists.txt that,

if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )
  # TODO: support other platforms and toolchains.
  option(LLVM_BUILD_32_BITS "Build 32 bits executables and libraries." OFF)
endif()

which suggests that LLVM_BUILD_32_BITS depends on CMAKE_SIZEOF_VOID_P, but then that means there is a circular dependency? Did I misunderstand something?

Given this piece of code is related to topic, I'm fine with either spliting or keeping it. If we do decide to include it, we'll need to expand the description of this patch.

[daltenty]

llvm/cmake/modules/HandleLLVMOptions.cmake

174

I appears to be user configurable setting in you want to build a 32-bit version on a 64-bit host (which is why it only gets enabled if CMAKE_SIZEOF_VOID_P is 8). This option is probably not relevant on AIX (since you can just configure with CMake in 32-bit or 64-bit object modes and things should work as normal).

We should probably not show this option on AIX either same as WIN32 (in many ways the AIX CMake setup is most similar to WIN32).

I will broaden the patch description, it makes sense to include this all as a single change

[stevewan]

llvm/cmake/modules/HandleLLVMOptions.cmake

174

Yea, I agree that we should drop this option for AIX as it made the way of setting the object mode unnecessarily complex (more than one way of setting up the same thing), and introduced ambiguity (one approach would interfere with the other).

[daltenty]

• Don't present the LLVM_BUILD_32_BITS option on AIX

[stevewan]

LGTM. Thanks.

llvm/CMakeLists.txt

 set(LLVM_LIB_FUZZING_ENGINE "" CACHE PATH
   "Path to fuzzing library for linking with fuzz targets")
 
 option(LLVM_USE_SPLIT_DWARF
   "Use -gsplit-dwarf when compiling llvm." OFF)
 
 # Define an option controlling whether we should build for 32-bit on 64-bit
 # platforms, where supported.
-if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )
+if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT (WIN32 OR ${CMAKE_SYSTEM_NAME} MATCHES "AIX"))
   # TODO: support other platforms and toolchains.
   option(LLVM_BUILD_32_BITS "Build 32 bits executables and libraries." OFF)
 endif()
 
 # Define the default arguments to use with 'lit', and an option for the user to
 # override.
 set(LIT_ARGS_DEFAULT "-sv")
 if (MSVC_IDE OR XCODE)

llvm/cmake/modules/GetHostTriple.cmake

 # Returns the host triple.
 # Invokes config.guess
 
 function( get_host_triple var )
   if( MSVC )
     if( CMAKE_SIZEOF_VOID_P EQUAL 8 )
       set( value "x86_64-pc-windows-msvc" )
     else()
       set( value "i686-pc-windows-msvc" )
     endif()
   elseif( MINGW AND NOT MSYS )
     if( CMAKE_SIZEOF_VOID_P EQUAL 8 )
       set( value "x86_64-w64-windows-gnu" )
     else()
       set( value "i686-pc-windows-gnu" )
     endif()
+  elseif( CMAKE_HOST_SYSTEM_NAME STREQUAL AIX )
+    # We defer to dynamic detection of the host AIX version.
+    if( CMAKE_SIZEOF_VOID_P EQUAL 8 )
+      set( value "powerpc64-ibm-aix" )
+    else()
+      set( value "powerpc-ibm-aix" )
+    endif()
   else( MSVC )
     if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows AND NOT MSYS)
       message(WARNING "unable to determine host target triple")
     else()
       set(config_guess ${LLVM_MAIN_SRC_DIR}/cmake/config.guess)
       execute_process(COMMAND sh ${config_guess}
         RESULT_VARIABLE TT_RV
         OUTPUT_VARIABLE TT_OUT
         OUTPUT_STRIP_TRAILING_WHITESPACE)
       if( NOT TT_RV EQUAL 0 )
         message(FATAL_ERROR "Failed to execute ${config_guess}")
       endif( NOT TT_RV EQUAL 0 )
-      # Defer to dynamic detection of the host AIX version.
-      string(REGEX REPLACE "-aix[0-9][^-]*" "-aix" value ${TT_OUT})
+      set( value ${TT_OUT} )
     endif()
   endif( MSVC )
   set( ${var} ${value} PARENT_SCOPE )
 endfunction( get_host_triple var )

llvm/cmake/modules/HandleLLVMOptions.cmake

if(${RANLIB_RESULT} EQUAL 0)
       set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> Dq  <TARGET> <LINK_FLAGS> <OBJECTS>")
       set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -D <TARGET>")
     endif()
     file(REMOVE ${CMAKE_BINARY_DIR}/t.a)
   endif()
 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()