[ORC-RT] Refactor ORC runtime CMake for future test tool(s).

[lhames]

Summary

We want to move functionality from the LLVM ORCTargetProcess library into the
ORC runtime, and this will mean implementing remote-executor testing tools
(like llvm-jitlink-executor and lli-child-target) in the ORC runtime.

This patch refactors the ORC runtime build system to introduce an
add_orc_tool function that can be used to add new test tools. The code is
modeled on existing functions for adding unit tests.

A placeholder orc-rt-executor tool and test are added to verify that the
config changes behave as expected.

[lhames]

Modeling the tools code on unit tests was the easiest way for me to get up and running here, but if there's a better way to build test programs for use with lit I'm happy to use that too.

[phosek]

compiler-rt/lib/orc/tests/CMakeLists.txt

15

Do you see a build failure without this flag? This should now be enabled globally for all of compiler-rt: https://github.com/llvm/llvm-project/blob/9185d6e6bca8ec41b48661c371e813498f840455/compiler-rt/CMakeLists.txt#L71

[lhames]

compiler-rt/lib/orc/tests/CMakeLists.txt

15

@phosek I do see a failure without it. The problem is that generate_compiler_rt_tests results in a call to clang_compile, which uses add_custom_command to perform the compilation: https://github.com/llvm/llvm-project/blob/9185d6e6bca8ec41b48661c371e813498f840455/compiler-rt/cmake/Modules/CompilerRTCompile.cmake#L103.

Since add_custom_command doesn't know about CMAKE_CXX_STANDARD we don't set the standard in that command.

Looks like gwp_asan hit a similar issue recently -- they also specify c++17 manually in their config: https://github.com/llvm/llvm-project/commit/474145c0b2420cb316bb8a9dcc031d613679d496

[phosek]

LGTM

compiler-rt/lib/orc/tests/CMakeLists.txt

15

OK that's something we should address but it doesn't need to block this change.

compiler-rt/lib/orc/tests/tools/orc-rt-executor.cpp

2

Should this file also have the copyright header?

[lhames]

compiler-rt/lib/orc/tests/tools/orc-rt-executor.cpp

2

Yep. Thanks for catching that -- I'll add one.

compiler-rt/lib/orc/CMakeLists.txt

add_compiler_rt_runtime(clang_rt.orc
       CFLAGS ${ORC_CFLAGS}
       LINK_FLAGS ${ORC_LINK_FLAGS}
       LINK_LIBS ${ORC_LINK_LIBS}
       OBJECT_LIBS ${ORC_COMMON_RUNTIME_OBJECT_LIBS} RTOrc
       PARENT_TARGET orc)
   endforeach()
 endif() # not Apple
 
-if(COMPILER_RT_INCLUDE_TESTS)
-  add_subdirectory(unittests)
-endif()
+add_subdirectory(tests)

compiler-rt/lib/orc/tests/CMakeLists.txt

 include(CompilerRTCompile)
 
 include_directories(..)
 
+# Unit tests target.
 add_custom_target(OrcRTUnitTests)
 set_target_properties(OrcRTUnitTests PROPERTIES FOLDER "OrcRT unittests")
 
+# Testing tools target.
+add_custom_target(OrcRTTools)
+set_target_properties(OrcRTTools PROPERTIES FOLDER "OrcRT tools")
+
 set(ORC_UNITTEST_CFLAGS
+# FIXME: This should be set for all unit tests.
+  -std=c++17
   ${ORC_CFLAGS}
   ${COMPILER_RT_UNITTEST_CFLAGS}
-  ${COMPILER_RT_GTEST_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/lib/orc
   )
 
 function(add_orc_lib library)
   add_library(${library} STATIC ${ARGN})
   set_target_properties(${library} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     FOLDER "Compiler-RT Runtime tests")

 else()
   append_list_if(COMPILER_RT_HAS_LIBM -lm ORC_UNITTEST_LINK_FLAGS)
   append_list_if(COMPILER_RT_HAS_LIBRT -lrt ORC_UNITTEST_LINK_FLAGS)
   append_list_if(COMPILER_RT_HAS_LIBDL -ldl ORC_UNITTEST_LINK_FLAGS)
   append_list_if(COMPILER_RT_HAS_LIBPTHREAD -pthread ORC_UNITTEST_LINK_FLAGS)
   append_list_if(COMPILER_RT_HAS_LIBEXECINFO -lexecinfo ORC_UNITTEST_LINK_FLAGS)
 endif()
 
-set(ORC_DEPS llvm_gtest orc)
+set(ORC_DEPS orc)
 # ORC uses C++ standard library headers.
 if (TARGET cxx-headers OR HAVE_LIBCXX)
-  set(ORC_DEPS cxx-headers)
+  list(APPEND ORC_DEPS cxx-headers)
 endif()
 
 macro(add_orc_unittest testname)
   cmake_parse_arguments(TEST "" "" "SOURCES;HEADERS" ${ARGN})
   if(UNIX)
     foreach(arch ${ORC_TEST_ARCH})
       set(TEST_OBJECTS)
       get_orc_lib_for_arch(${arch} ORC_RUNTIME_LIBS)
       generate_compiler_rt_tests(TEST_OBJECTS
         OrcRTUnitTests "${testname}-${arch}-Test" "${arch}"
         SOURCES ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE}
         RUNTIME "${ORC_RUNTIME_LIBS}"
         COMPILE_DEPS ${TEST_HEADERS} ${ORC_HEADERS}
+        DEPS llvm_gtest ${ORC_DEPS}
+        CFLAGS ${ORC_UNITTEST_CFLAGS} ${COMPILER_RT_GTEST_CFLAGS}
+        LINK_FLAGS ${ORC_UNITTEST_LINK_FLAGS})
+    endforeach()
+  endif()
+endmacro()
+
+macro(add_orc_tool toolname)
+  cmake_parse_arguments(TOOL "" "" "SOURCES;HEADERS" ${ARGN})
+  if(UNIX)
+    foreach(arch ${ORC_TEST_ARCH})
+      set(TOOL_OBJECTS)
+      get_orc_lib_for_arch(${arch} ORC_RUNTIME_LIBS)
+      generate_compiler_rt_tests(TOOL_OBJECTS
+        OrcRTTools "${toolname}-${arch}" "${arch}"
+        SOURCES ${TOOL_SOURCES}
+        RUNTIME "${ORC_RUNTIME_LIBS}"
+        COMPILE_DEPS ${TOOL_HEADERS} ${ORC_HEADERS}
         DEPS ${ORC_DEPS}
         CFLAGS ${ORC_UNITTEST_CFLAGS}
         LINK_FLAGS ${ORC_UNITTEST_LINK_FLAGS})
     endforeach()
   endif()
 endmacro()
 
-set(UNITTEST_SOURCES
-  adt_test.cpp
-  c_api_test.cpp
-  endian_test.cpp
-  error_test.cpp
-  executor_address_test.cpp
-  extensible_rtti_test.cpp
-  orc_unit_test_main.cpp
-  wrapper_function_utils_test.cpp
-  simple_packed_serialization_test.cpp
-  )
-
-if (COMPILER_RT_CAN_EXECUTE_TESTS)
-
-  if (APPLE)
-    add_orc_lib("RTOrc.test.osx"
-      $<TARGET_OBJECTS:RTOrc.osx>)
-  else()
-    foreach(arch ${ORC_SUPPORTED_ARCH})
-      add_orc_lib("RTOrc.test.${arch}"
-        $<TARGET_OBJECTS:RTOrc.${arch}>)
-    endforeach()
-  endif()
 
-  add_orc_unittest(OrcUnitTest SOURCES ${UNITTEST_SOURCES})
-
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(unit)
 endif()
+add_subdirectory(tools)

compiler-rt/lib/orc/tests/tools/CMakeLists.txt

+add_orc_tool(orc-rt-executor SOURCES orc-rt-executor.cpp)

compiler-rt/lib/orc/tests/tools/orc-rt-executor.cpp

+//===- orc-rt-executor.cpp ------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Contains the orc-rt-executor test tool. This is a "blank executable" that
+// links the ORC runtime and can accept code from a JIT controller like lii or
+// llvm-jitlink.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstring>
+#include <iostream>
+#include <optional>
+#include <string_view>
+
+void printHelp(std::string_view ProgName, std::ostream &OS) {
+  OS << "usage: " << ProgName << " [help] [<mode>] <program arguments>...\n"
+     << "  <mode>                 -- specify how to listen for JIT'd program\n"
+     << "    filedesc=<in>,<out>  -- read from <in> filedesc, write to out\n"
+     << "    tcp=<host>:<port>    -- listen on the given host/port\n"
+     << "  help                   -- print help and exit\n"
+     << "\n"
+     << " Notes:\n"
+     << "   Program arguments will be made available to the JIT controller.\n"
+     << "   When running a JIT'd program containing a main function the\n"
+     << "   controller may choose to pass these on to main, however\n"
+     << "   orc-rt-executor does not enforce this.\n";
+}
+
+int main(int argc, char *argv[]) {
+  if (argc < 2) {
+    printHelp("orc-rt-executor", std::cerr);
+    std::cerr << "error: insufficient arguments.\n";
+    exit(1);
+  }
+
+  if (!strcmp(argv[1], "help")) {
+    printHelp(argv[0], std::cerr);
+    exit(0);
+  }
+
+  std::cerr << "error: One day I will be a real program, but I am not yet.\n";
+
+  return 0;
+}

compiler-rt/lib/orc/tests/unit/CMakeLists.txt

+set(UNITTEST_SOURCES
+  adt_test.cpp
+  c_api_test.cpp
+  endian_test.cpp
+  error_test.cpp
+  executor_address_test.cpp
+  extensible_rtti_test.cpp
+  orc_unit_test_main.cpp
+  wrapper_function_utils_test.cpp
+  simple_packed_serialization_test.cpp
+  )
+
+if (COMPILER_RT_CAN_EXECUTE_TESTS)
+  add_orc_unittest(OrcUnitTest SOURCES ${UNITTEST_SOURCES})
+endif()

compiler-rt/test/orc/TestCases/Generic/lit.local.cfg.py

+if not config.test_target_is_host_executable:
+  config.unsupported = True

compiler-rt/test/orc/TestCases/Generic/orc-rt-executor-usage.test

+// Test that the orc-remote-executor tool errors out as expected when called
+// with no arguments.
+//
+// RUN: not %orc_rt_executor 2>&1 | FileCheck %s
+
+// CHECK: usage: orc-rt-executor [help] [<mode>] <program arguments>...

compiler-rt/test/orc/lit.cfg.py

 # -*- Python -*-
 
 import os
 
 # Setup config name.
 config.name = 'ORC' + config.name_suffix
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
-def build_invocation(compile_flags):
-  return ' ' + ' '.join([config.clang] + compile_flags) + ' '
+# Determine whether the test target is compatible with execution on the host.
+host_arch_compatible = config.target_arch == config.host_arch
+
+if config.host_arch == "x86_64h" and config.target_arch == "x86_64":
+  host_arch_compatible = True
+config.test_target_is_host_executable = config.target_os == config.host_os and host_arch_compatible
 
 # Assume that llvm-jitlink is in the config.llvm_tools_dir.
 llvm_jitlink = os.path.join(config.llvm_tools_dir, 'llvm-jitlink')
+orc_rt_executor_stem = os.path.join(config.compiler_rt_obj_root, 'lib/orc/tests/tools/orc-rt-executor')
 lli = os.path.join(config.llvm_tools_dir, 'lli')
 if config.host_os == 'Darwin':
   orc_rt_path = '%s/libclang_rt.orc_osx.a' % config.compiler_rt_libdir
 else:
   orc_rt_path = '%s/libclang_rt.orc%s.a' % (config.compiler_rt_libdir, config.target_suffix)
 
 if config.libunwind_shared:
   config.available_features.add('libunwind-available')
   shared_libunwind_path = os.path.join(config.libunwind_install_dir, 'libunwind.so')
   config.substitutions.append( ("%shared_libunwind", shared_libunwind_path) )
 
+def build_invocation(compile_flags):
+  return ' ' + ' '.join([config.clang] + compile_flags) + ' '
+
 config.substitutions.append(
     ('%clang ', build_invocation([config.target_cflags])))
 config.substitutions.append(
     ('%clangxx ',
      build_invocation(config.cxx_mode_flags + [config.target_cflags])))
 if config.host_os == 'Windows':
   config.substitutions.append(
       ('%llvm_jitlink', (llvm_jitlink + ' -orc-runtime=' +
        orc_rt_path + ' -no-process-syms=true -slab-allocate=64MB')))
 else:
   config.substitutions.append(
       ('%llvm_jitlink', (llvm_jitlink + ' -orc-runtime=' + orc_rt_path)))
 config.substitutions.append(
+    ('%orc_rt_executor', orc_rt_executor_stem + "-" + config.host_arch))
+config.substitutions.append(
     ('%lli_orc_jitlink', (lli + ' -jit-kind=orc -jit-linker=jitlink -orc-runtime=' + orc_rt_path)))
 
 # Default test suffixes.
-config.suffixes = ['.c', '.cpp', '.S', '.ll']
+config.suffixes = ['.c', '.cpp', '.S', '.ll', '.test']
 
 # Exclude Inputs directories.
 config.excludes = ['Inputs']
 
 if config.host_os not in ['Darwin', 'FreeBSD', 'Linux', 'Windows']:
   config.unsupported = True

compiler-rt/test/orc/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 # Tool-specific config options.
 config.name_suffix = "@ORC_TEST_CONFIG_SUFFIX@"
 config.orc_lit_source_dir = "@ORC_LIT_SOURCE_DIR@"
 config.target_cflags = "@ORC_TEST_TARGET_CFLAGS@"
 config.target_arch = "@ORC_TEST_TARGET_ARCH@"
+config.target_os = "@ORC_TEST_TARGET_OS@"
 config.built_with_llvm = ("@COMPILER_RT_STANDALONE_BUILD@" != "TRUE")
 config.libunwind_shared = "@LIBUNWIND_ENABLE_SHARED@"
 config.libunwind_install_dir = "@LLVM_BINARY_DIR@/@LIBUNWIND_INSTALL_LIBRARY_DIR@"
 
 # Load common config for all compiler-rt lit tests
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 # Load tool-specific config that would do the real work.
 lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg.py")