[ORC-RT] Add unit test infrastructure, extensible_rtti implementation, unit test

[lhames]

Summary

Add unit test infrastructure for the ORC runtime, plus a cut-down
extensible_rtti system and extensible_rtti unit test.

Removes the placeholder.cpp source file.

[lhames]

Fix incomplete cargo-culting of unittest CMake.

[lhames]

Include the whole patch. (Why are you like this arc?)

[lhames]

I've tried to adapt this from the Xray and TSan test CMakeLists.txt. Most of it makes sense to me (as much as any CMake can), but I was surprised by this pattern which showed up in Xray and TSan (and all the other projects that I looked at):

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()

We're already building runtime libraries, but in the tests it looks like we're building a parallel archive for the runtime and writing it to the test directory for the tests to link against. Is there a reason the tests can't just link against the built runtimes?

[lhames]

Looks like this is broken on Linux. Looking in to that now...

[dblaikie]

The extensible RTTI infrastructure is copied (roughly) from LLVM? Might be worth a comment mentioning where it's from in case there's a desire to keep future bug fixes/etc in sync? (both the implementation and the test might benefit from that sort of pointer?)

[lhames]

Fix Linux build, add comments noting that the runtime extensible_rtti
code was adapted from LLVM.

[sgraenitz]

In D102080#2744882, @lhames wrote:

We're already building runtime libraries, but in the tests it looks like we're building a parallel archive for the runtime and writing it to the test directory for the tests to link against. Is there a reason the tests can't just link against the built runtimes?

I think on Apple platforms TSAN only builds a dylib for production [1]. Tests should link statically so it's building a static archive for this case. All other Unix platforms do the opposite. Not sure why, but at least it looks consistent. There's a related comment about that in [2]. Maybe @kubamracek can tell you more :)

The ORC runtime is a static archive in any case right? So I guess this won't apply here. (Disclaimer: not a compiler-rt expert)

[1] https://github.com/llvm/llvm-project/blob/a81e45b8bcb8eb274ad73357e10e2cdf8a314a8c/compiler-rt/lib/tsan/CMakeLists.txt#L140
[2] https://github.com/llvm/llvm-project/blob/c47620a838eae330c04453ed3900aab0ac4159cb/compiler-rt/lib/tsan/tests/CMakeLists.txt#L71

[lhames]

In D102080#2747380, @sgraenitz wrote:

I think on Apple platforms TSAN only builds a dylib for production [1]....

I thought it might be something like that. It might also enable unit-testing of the runtime even if your production build doesn't target the host architecture, but I don't know how common that is?

The ORC runtime is a static archive in any case right? So I guess this won't apply here. (Disclaimer: not a compiler-rt expert)

Yes -- the ORC runtime should only ever be built statically.

[lhames]

@phosek It's really just the CMake changes that need reviewing here. The C++ code is adapted directly from code already in LLVM.

These CMake changes to enable unit testing are the last piece of build infrastructure that I expect to have to add. Everything from here on out is likely to be incremental tweaks and maintenance, plus the actual ORC runtime code. Would you like to continue with pre-commit review for future CMake changes, or switch to post-commit review for that?

[phosek]

LGTM

compiler-rt/lib/orc/CMakeLists.txt

13

Can you also include extensible_rtti.h in here?

[lhames]

compiler-rt/lib/orc/CMakeLists.txt

13

Will do. Thanks for catching that!

[thakis]

Hi, this makes our linux and windows bots fail to run cmake, with this diag (this cmake invocation is on macos):

 Running cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=OFF '-DLLVM_ENABLE_PROJECTS=clang;compiler-rt;lld;chrometools;clang-tools-extra;libcxx' '-DLLVM_TARGETS_TO_BUILD=AArch64;ARM;Mips;PowerPC;SystemZ;WebAssembly;X86' -DLLVM_ENABLE_PIC=OFF -DLLVM_ENABLE_UNWIND_TABLES=OFF -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DCLANG_PLUGIN_SUPPORT=OFF -DCLANG_ENABLE_STATIC_ANALYZER=OFF -DCLANG_ENABLE_ARCMT=OFF '-DBUG_REPORT_URL=https://crbug.com and run tools/clang/scripts/process_crashreports.py (only works inside Google) which will upload a report' -DLLVM_INCLUDE_GO_TESTS=OFF -DENABLE_X86_RELAX_RELOCATIONS=NO -DLLVM_ENABLE_DIA_SDK=OFF '-DCOMPILER_RT_SANITIZERS_TO_BUILD=asan;dfsan;msan;hwasan;tsan;cfi' -DLIBCXX_ENABLE_SHARED=OFF -DLIBCXX_ENABLE_STATIC=OFF -DLIBCXX_INCLUDE_TESTS=OFF -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF -DLLVM_ENABLE_LIBXML2=FORCE_ON '-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64' '-DLLVM_ENABLE_PROJECTS=clang;compiler-rt;libcxx;compiler-rt' -DCMAKE_INSTALL_PREFIX=/opt/s/w/ir/cache/builder/src/third_party/llvm-bootstrap-install -DCMAKE_C_FLAGS= -DCMAKE_CXX_FLAGS= -DCMAKE_EXE_LINKER_FLAGS= -DCMAKE_SHARED_LINKER_FLAGS= -DCMAKE_MODULE_LINKER_FLAGS= -DLLVM_ENABLE_ASSERTIONS=ON -DCOMPILER_RT_BUILD_BUILTINS=ON -DCOMPILER_RT_BUILD_CRT=OFF -DCOMPILER_RT_BUILD_LIBFUZZER=OFF -DCOMPILER_RT_BUILD_MEMPROF=OFF -DCOMPILER_RT_BUILD_SANITIZERS=OFF -DCOMPILER_RT_BUILD_XRAY=OFF -DCOMPILER_RT_ENABLE_IOS=OFF -DCOMPILER_RT_ENABLE_WATCHOS=OFF -DCOMPILER_RT_ENABLE_TVOS=OFF -DDARWIN_osx_ARCHS=x86_64 /opt/s/w/ir/cache/builder/src/third_party/llvm/llvm
...
CMake Error at /b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/cmake/Modules/AddCompilerRT.cmake:415 (sanitizer_test_compile):
   Unknown CMake command "sanitizer_test_compile".
 Call Stack (most recent call first):
   /b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/orc/unittests/CMakeLists.txt:68 (generate_compiler_rt_tests)
   /b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/orc/unittests/CMakeLists.txt:97 (add_orc_unittest)

[lhames]

Hi Nico,

Thanks for the heads up. I'm investigating now.

• Lang.

compiler-rt/cmake/config-ix.cmake

 set(ALL_SCUDO_STANDALONE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64})
 if(APPLE)
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64})
 else()
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} powerpc64le)
 endif()
 set(ALL_SHADOWCALLSTACK_SUPPORTED_ARCH ${ARM64})
 
-if (APPLE)
+if (UNIX)
 set(ALL_ORC_SUPPORTED_ARCH ${X86_64})
 endif()
 
 if(APPLE)
   include(CompilerRTDarwinUtils)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)

compiler-rt/lib/orc/CMakeLists.txt

 # Build for all components of the ORC runtime support library.
 
 # ORC runtime library implementation files.
 set(ORC_SOURCES
-  placeholder.cpp
+  extensible_rtti.cpp
   )
 
 # Implementation files for all ORC architectures.
 set(x86_64_SOURCES
 # x86-64 specific assembly files will go here.
 )
 
 set(ORC_IMPL_HEADERS
 # Implementation headers will go here.
+  extensible_rtti.h
 )
 
 # Create list of all source files for
 # consumption by tests.
 set(ORC_ALL_SOURCE_FILES
   ${ORC_SOURCES}
   ${x86_64_SOURCES}
   ${ORC_IMPL_HEADERS}
else() # not Apple
   foreach(arch ${ORC_SUPPORTED_ARCH})
     if(NOT CAN_TARGET_${arch})
       continue()
     endif()
     add_compiler_rt_object_libraries(RTOrc
       ARCHS ${arch}
       SOURCES ${ORC_SOURCES} ${${arch}_SOURCES}
       ADDITIONAL_HEADERS ${ORC_IMPL_HEADERS}
-      CFLAGS $ORC_CFLAGS}
+      CFLAGS ${ORC_CFLAGS}
       DEPS ${ORC_DEPS})
 
     # Common ORC archive for instrumented binaries.
     add_compiler_rt_runtime(clang_rt.orc
      STATIC
      ARCHS ${arch}
      CFLAGS ${ORC_CFLAGS}
      OBJECT_LIBS ${ORC_COMMON_RUNTIME_OBJECT_LIBS} RTOrc
      PARENT_TARGET orc)
   endforeach()
 endif() # not Apple
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(unittests)
+endif()

compiler-rt/lib/orc/extensible_rtti.h

+//===------ extensible_rtti.h - Extensible RTTI for ORC RT ------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+//
+// Provides an extensible RTTI mechanism, that can be used regardless of whether
+// the runtime is built with -frtti or not. This is predominantly used to
+// support error handling.
+//
+// The RTTIRoot class defines methods for comparing type ids. Implementations
+// of these methods can be injected into new classes using the RTTIExtends
+// class template.
+//
+// E.g.
+//
+//   @code{.cpp}
+//   class MyBaseClass : public RTTIExtends<MyBaseClass, RTTIRoot> {
+//   public:
+//     static char ID;
+//     virtual void foo() = 0;
+//   };
+//
+//   class MyDerivedClass1 : public RTTIExtends<MyDerivedClass1, MyBaseClass> {
+//   public:
+//     static char ID;
+//     void foo() override {}
+//   };
+//
+//   class MyDerivedClass2 : public RTTIExtends<MyDerivedClass2, MyBaseClass> {
+//   public:
+//     static char ID;
+//     void foo() override {}
+//   };
+//
+//   char MyBaseClass::ID = 0;
+//   char MyDerivedClass1::ID = 0;
+//   char MyDerivedClass2:: ID = 0;
+//
+//   void fn() {
+//     std::unique_ptr<MyBaseClass> B = std::make_unique<MyDerivedClass1>();
+//     outs() << isa<MyBaseClass>(B) << "\n"; // Outputs "1".
+//     outs() << isa<MyDerivedClass1>(B) << "\n"; // Outputs "1".
+//     outs() << isa<MyDerivedClass2>(B) << "\n"; // Outputs "0'.
+//   }
+//
+//   @endcode
+//
+// Note:
+//   This header was adapted from llvm/Support/ExtensibleRTTI.h, however the
+// data structures are not shared and the code need not be kept in sync.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ORC_RT_EXTENSIBLE_RTTI_H
+#define ORC_RT_EXTENSIBLE_RTTI_H
+
+namespace __orc_rt {
+
+template <typename ThisT, typename ParentT> class RTTIExtends;
+
+/// Base class for the extensible RTTI hierarchy.
+///
+/// This class defines virtual methods, dynamicClassID and isA, that enable
+/// type comparisons.
+class RTTIRoot {
+public:
+  virtual ~RTTIRoot() = default;
+
+  /// Returns the class ID for this type.
+  static const void *classID() { return &ID; }
+
+  /// Returns the class ID for the dynamic type of this RTTIRoot instance.
+  virtual const void *dynamicClassID() const = 0;
+
+  /// Returns true if this class's ID matches the given class ID.
+  virtual bool isA(const void *const ClassID) const {
+    return ClassID == classID();
+  }
+
+  /// Check whether this instance is a subclass of QueryT.
+  template <typename QueryT> bool isA() const { return isA(QueryT::classID()); }
+
+  static bool classof(const RTTIRoot *R) { return R->isA<RTTIRoot>(); }
+
+private:
+  virtual void anchor();
+
+  static char ID;
+};
+
+/// Inheritance utility for extensible RTTI.
+///
+/// Supports single inheritance only: A class can only have one
+/// ExtensibleRTTI-parent (i.e. a parent for which the isa<> test will work),
+/// though it can have many non-ExtensibleRTTI parents.
+///
+/// RTTIExtents uses CRTP so the first template argument to RTTIExtends is the
+/// newly introduced type, and the *second* argument is the parent class.
+///
+/// class MyType : public RTTIExtends<MyType, RTTIRoot> {
+/// public:
+///   static char ID;
+/// };
+///
+/// class MyDerivedType : public RTTIExtends<MyDerivedType, MyType> {
+/// public:
+///   static char ID;
+/// };
+///
+template <typename ThisT, typename ParentT> class RTTIExtends : public ParentT {
+public:
+  // Inherit constructors and isA methods from ParentT.
+  using ParentT::isA;
+  using ParentT::ParentT;
+
+  static char ID;
+
+  static const void *classID() { return &ThisT::ID; }
+
+  const void *dynamicClassID() const override { return &ThisT::ID; }
+
+  bool isA(const void *const ClassID) const override {
+    return ClassID == classID() || ParentT::isA(ClassID);
+  }
+
+  static bool classof(const RTTIRoot *R) { return R->isA<ThisT>(); }
+};
+
+template <typename ThisT, typename ParentT>
+char RTTIExtends<ThisT, ParentT>::ID = 0;
+
+/// Returns true if the given value is an instance of the template type
+/// parameter.
+template <typename To, typename From> bool isa(const From &Value) {
+  return To::classof(&Value);
+}
+
+} // end namespace __orc_rt
+
+#endif // ORC_RT_EXTENSIBLE_RTTI_H

compiler-rt/lib/orc/extensible_rtti.cpp

+//===- extensible_rtti.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of the ORC runtime support library.
+//
+// Note:
+//   This source file was adapted from lib/Support/ExtensibleRTTI.cpp, however
+// the data structures are not shared and the code need not be kept in sync.
+//
+//===----------------------------------------------------------------------===//
+
+#include "extensible_rtti.h"
+
+namespace __orc_rt {
+
+char RTTIRoot::ID = 0;
+void RTTIRoot::anchor() {}
+
+} // end namespace __orc_rt

compiler-rt/lib/orc/placeholder.cpp

-void placeholder(void) {}

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

+include_directories(..)
+
+add_custom_target(OrcRTUnitTests)
+set_target_properties(OrcRTUnitTests PROPERTIES FOLDER "OrcRT unittests")
+
+set(ORC_UNITTEST_CFLAGS
+  ${ORC_CFLAGS}
+  ${COMPILER_RT_UNITTEST_CFLAGS}
+  ${COMPILER_RT_GTEST_CFLAGS}
+  -I${COMPILER_RT_SOURCE_DIR}/lib/orc
+  )
+
+# We add the include directories one at a time in our CFLAGS.
+foreach (DIR ${LLVM_INCLUDE_DIR} ${LLVM_MAIN_INCLUDE_DIR})
+  list(APPEND ORC_UNITTEST_CFLAGS -I${DIR})
+endforeach()
+
+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")
+endfunction()
+
+function(get_orc_lib_for_arch arch lib)
+  if(APPLE)
+    set(tgt_name "RTOrc.test.osx")
+  else()
+    set(tgt_name "RTOrc.test.${arch}")
+  endif()
+  set(${lib} "${tgt_name}" PARENT_SCOPE)
+endfunction()
+
+set(ORC_TEST_ARCH ${ORC_SUPPORTED_ARCH})
+set(ORC_UNITTEST_LINK_FLAGS
+  ${COMPILER_RT_UNITTEST_LINK_FLAGS}
+  ${CMAKE_THREAD_LIBS_INIT}
+  )
+
+if(APPLE)
+  darwin_filter_host_archs(ORC_SUPPORTED_ARCH ORC_TEST_ARCH)
+  list(APPEND ORC_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
+  list(APPEND ORC_UNITTEST_LINK_FLAGS ${DARWIN_osx_LINK_FLAGS})
+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()
+
+foreach(lib ${SANITIZER_TEST_CXX_LIBRARIES})
+  list(APPEND ORC_UNITTEST_LINK_FLAGS -l${lib})
+endforeach()
+
+set(ORC_DEPS gtest orc)
+# ORC uses C++ standard library headers.
+if (TARGET cxx-headers OR HAVE_LIBCXX)
+  set(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}
+        DEPS ${ORC_DEPS}
+        CFLAGS ${ORC_UNITTEST_CFLAGS}
+        LINK_FLAGS ${ORC_UNITTEST_LINK_FLAGS})
+    endforeach()
+  endif()
+endmacro()
+
+set(UNITTEST_SOURCES
+  extensible_rtti_test.cpp
+  orc_unit_test_main.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})
+
+endif()

compiler-rt/lib/orc/unittests/extensible_rtti_test.cpp

+//===-- extensible_rtti_test.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of the ORC runtime.
+//
+// Note:
+//   This unit test was adapted from
+//   llvm/unittests/Support/ExtensibleRTTITest.cpp
+//
+//===----------------------------------------------------------------------===//
+
+#include "extensible_rtti.h"
+#include "gtest/gtest.h"
+
+using namespace __orc_rt;
+
+namespace {
+
+class MyBase : public RTTIExtends<MyBase, RTTIRoot> {};
+
+class MyDerivedA : public RTTIExtends<MyDerivedA, MyBase> {};
+
+class MyDerivedB : public RTTIExtends<MyDerivedB, MyBase> {};
+
+} // end anonymous namespace
+
+TEST(ExtensibleRTTITest, BaseCheck) {
+  MyBase MB;
+  MyDerivedA MDA;
+  MyDerivedB MDB;
+
+  // Check MB properties.
+  EXPECT_TRUE(isa<RTTIRoot>(MB));
+  EXPECT_TRUE(isa<MyBase>(MB));
+  EXPECT_FALSE(isa<MyDerivedA>(MB));
+  EXPECT_FALSE(isa<MyDerivedB>(MB));
+
+  // Check MDA properties.
+  EXPECT_TRUE(isa<RTTIRoot>(MDA));
+  EXPECT_TRUE(isa<MyBase>(MDA));
+  EXPECT_TRUE(isa<MyDerivedA>(MDA));
+  EXPECT_FALSE(isa<MyDerivedB>(MDA));
+
+  // Check MDB properties.
+  EXPECT_TRUE(isa<RTTIRoot>(MDB));
+  EXPECT_TRUE(isa<MyBase>(MDB));
+  EXPECT_FALSE(isa<MyDerivedA>(MDB));
+  EXPECT_TRUE(isa<MyDerivedB>(MDB));
+}

compiler-rt/lib/orc/unittests/orc_unit_test_main.cpp

+//===-- orc_unit_test_main.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of the ORC runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "gtest/gtest.h"
+
+int main(int argc, char **argv) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}