[wip] Convert the NATIVE llvm build process to be project agnostic

[lanza]

Summary

lldb recently added a tablegen tool. In order to properly cross compile
lldb standalone there needs to be a mechanism to generate the native
lldb build, analgous to what's done for the NATIVE llvm build. Thus,
we can simply modify this setup to allow for any project to be used.

CMakeLists.txt

 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 include_directories( ${LLVM_INCLUDE_DIR} ${LLVM_MAIN_INCLUDE_DIR})
 
 # when crosscompiling import the executable targets from a file
 if(LLVM_USE_HOST_TOOLS)
   include(CrossCompile)
+  llvm_create_cross_target(NATIVE_LLVM ${CMAKE_SOURCE_DIR} "" Release)
 endif(LLVM_USE_HOST_TOOLS)
 if(LLVM_TARGET_IS_CROSSCOMPILE_HOST)
 # Dummy use to avoid CMake Warning: Manually-specified variables were not used
 # (this is a variable that CrossCompile sets on recursive invocations)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
   # On FreeBSD, /usr/local/* is not used by default. In order to build LLVM

cmake/modules/CrossCompile.cmake

 include(LLVMExternalProjectUtils)
 
-function(llvm_create_cross_target_internal target_name toolchain buildtype)
+
+function(llvm_create_cross_target target_name project_dir toolchain buildtype)
 
   if(NOT DEFINED LLVM_${target_name}_BUILD)
     set(LLVM_${target_name}_BUILD "${CMAKE_BINARY_DIR}/${target_name}")
     set(LLVM_${target_name}_BUILD ${LLVM_${target_name}_BUILD} PARENT_SCOPE)
     message(STATUS "Setting native build dir to " ${LLVM_${target_name}_BUILD})
   endif(NOT DEFINED LLVM_${target_name}_BUILD)
 
   if (EXISTS ${LLVM_MAIN_SRC_DIR}/cmake/platforms/${toolchain}.cmake)
function(llvm_create_cross_target target_name project_dir toolchain buildtype)
   string(REPLACE ";" "$<SEMICOLON>" llvm_enable_projects_arg
          "${LLVM_ENABLE_PROJECTS}")
   string(REPLACE ";" "$<SEMICOLON>" llvm_external_projects_arg
          "${LLVM_EXTERNAL_PROJECTS}")
 
   add_custom_command(OUTPUT ${LLVM_${target_name}_BUILD}/CMakeCache.txt
     COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
         -DCMAKE_MAKE_PROGRAM="${CMAKE_MAKE_PROGRAM}"
-        ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${CMAKE_SOURCE_DIR}
+        ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${project_dir}
         -DLLVM_TARGET_IS_CROSSCOMPILE_HOST=TRUE
         -DLLVM_TARGETS_TO_BUILD="${targets_to_build_arg}"
         -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="${experimental_targets_to_build_arg}"
         -DLLVM_DEFAULT_TARGET_TRIPLE="${TARGET_TRIPLE}"
         -DLLVM_TARGET_ARCH="${LLVM_TARGET_ARCH}"
         -DLLVM_ENABLE_PROJECTS="${llvm_enable_projects_arg}"
         -DLLVM_EXTERNAL_PROJECTS="${llvm_external_projects_arg}"
         -DLLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN="${LLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN}"
         ${build_type_flags} ${linker_flag} ${external_clang_dir}
+        ${ARGN}
     WORKING_DIRECTORY ${LLVM_${target_name}_BUILD}
     DEPENDS CREATE_LLVM_${target_name}
-    COMMENT "Configuring ${target_name} LLVM...")
+    COMMENT "Configuring ${target_name}...")
 
   add_custom_target(CONFIGURE_LLVM_${target_name}
                     DEPENDS ${LLVM_${target_name}_BUILD}/CMakeCache.txt)
 
 endfunction()
 
-function(llvm_create_cross_target target_name sysroot)
-  llvm_create_cross_target_internal(${target_name} ${sysroot} ${CMAKE_BUILD_TYPE})
-endfunction()
-
 # Sets up a native build for a tool, used e.g. for cross-compilation and
 # LLVM_OPTIMIZED_TABLEGEN. Always builds in Release.
 # - target: The target to build natively
 # - output_path_var: A variable name which receives the path to the built target
 # - DEPENDS: Any additional dependencies for the target
-function(build_native_tool target output_path_var)
+function(build_native_llvm_tool target output_path_var)
   cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
 
   if(CMAKE_CONFIGURATION_TYPES)
-    set(output_path "${LLVM_NATIVE_BUILD}/Release/bin/${target}")
+    set(output_path "${LLVM_NATIVE_LLVM_BUILD}/Release/bin/${target}")
   else()
-    set(output_path "${LLVM_NATIVE_BUILD}/bin/${target}")
+    set(output_path "${LLVM_NATIVE_LLVM_BUILD}/bin/${target}")
   endif()
 
-  llvm_ExternalProject_BuildCmd(build_cmd ${target} ${LLVM_NATIVE_BUILD}
+  llvm_ExternalProject_BuildCmd(build_cmd ${target} ${LLVM_NATIVE_LLVM_BUILD}
                                 CONFIGURATION Release)
   add_custom_command(OUTPUT "${output_path}"
                      COMMAND ${build_cmd}
-                     DEPENDS CONFIGURE_LLVM_NATIVE ${ARG_DEPENDS}
-                     WORKING_DIRECTORY "${LLVM_NATIVE_BUILD}"
+                     DEPENDS CONFIGURE_LLVM_NATIVE_LLVM ${ARG_DEPENDS}
+                     WORKING_DIRECTORY "${LLVM_NATIVE_LLVM_BUILD}"
                      COMMENT "Building native ${target}..."
                      USES_TERMINAL)
   set(${output_path_var} "${output_path}" PARENT_SCOPE)
 endfunction()
-
-llvm_create_cross_target_internal(NATIVE "" Release)

cmake/modules/TableGen.cmake

set(${project}_TABLEGEN "${target}" CACHE
       STRING "Native TableGen executable. Saves building one when cross-compiling.")
 
   # Effective tblgen executable to be used:
   set(${project}_TABLEGEN_EXE ${${project}_TABLEGEN} PARENT_SCOPE)
   set(${project}_TABLEGEN_TARGET ${${project}_TABLEGEN} PARENT_SCOPE)
 
   if(LLVM_USE_HOST_TOOLS)
     if( ${${project}_TABLEGEN} STREQUAL "${target}" )
-      build_native_tool(${target} ${project}_TABLEGEN_EXE)
+      build_native_llvm_tool(${target} ${project}_TABLEGEN_EXE)
       set(${project}_TABLEGEN_EXE ${${project}_TABLEGEN_EXE} PARENT_SCOPE)
 
       add_custom_target(${project}-tablegen-host DEPENDS ${${project}_TABLEGEN_EXE})
       set(${project}_TABLEGEN_TARGET ${project}-tablegen-host PARENT_SCOPE)
 
       # Create an artificial dependency between tablegen projects, because they
       # compile the same dependencies, thus using the same build folders.
       # FIXME: A proper fix requires sequentially chaining tablegens.

tools/llvm-config/CMakeLists.txt

target_compile_options(llvm-config PUBLIC
     "-fmodules-ignore-macro=CMAKE_CFG_INTDIR"
     )
 endif()
 
 # Add the dependency on the generation step.
 add_file_dependencies(${CMAKE_CURRENT_SOURCE_DIR}/llvm-config.cpp ${BUILDVARIABLES_OBJPATH})
 
 if(CMAKE_CROSSCOMPILING AND NOT LLVM_CONFIG_PATH)
-  build_native_tool(llvm-config LLVM_CONFIG_PATH)
+  build_native_llvm_tool(llvm-config LLVM_CONFIG_PATH)
   set(LLVM_CONFIG_PATH "${LLVM_CONFIG_PATH}" CACHE STRING "")
 
   add_custom_target(NativeLLVMConfig DEPENDS ${LLVM_CONFIG_PATH})
   add_dependencies(llvm-config NativeLLVMConfig)
 endif()

tools/llvm-shlib/CMakeLists.txt

if(MSVC)
   endif()
 
   # Generate the exports file dynamically.
   set(GEN_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/gen-msvc-exports.py)
 
   set(LLVM_EXPORTED_SYMBOL_FILE ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/libllvm-c.exports)
 
   if(CMAKE_CROSSCOMPILING)
-    build_native_tool(llvm-nm llvm_nm)
+    build_native_llvm_tool(llvm-nm llvm_nm)
     set(llvm_nm_target "${llvm_nm}")
   else()
     set(llvm_nm $<TARGET_FILE:llvm-nm>)
     set(llvm_nm_target llvm-nm)
   endif()
 
   add_custom_command(OUTPUT ${LLVM_EXPORTED_SYMBOL_FILE}
     COMMAND ${PYTHON_EXECUTABLE} ${GEN_SCRIPT} --libsfile ${LIBSFILE} ${GEN_UNDERSCORE} --nm "${llvm_nm}" -o ${LLVM_EXPORTED_SYMBOL_FILE}
     DEPENDS ${LIB_NAMES} ${llvm_nm_target}
     COMMENT "Generating export list for LLVM-C"
     VERBATIM )
 
   # Finally link the target.
   add_llvm_library(LLVM-C SHARED ${SOURCES} DEPENDS intrinsics_gen)
 
 endif()