[ORC-RT] Make the ORC runtime C API public.

[lhames]

Summary

This will be the first public header for the ORC runtime, so I'm posting this
for review to make sure I've set it up more-or-less correctly.

The long term aim is to make more ORC runtime headers public so that executors
can access the runtime directly (rather than it only being visible to JIT'd
code).

[beanz]

LGTM

[phosek]

LGTM

[lhames]

Thanks everyone!

compiler-rt/include/CMakeLists.txt

 if (COMPILER_RT_BUILD_XRAY)
   set(XRAY_HEADERS
     xray/xray_interface.h
     xray/xray_log_interface.h
     xray/xray_records.h
     )
 endif(COMPILER_RT_BUILD_XRAY)
 
+if (COMPILER_RT_BUILD_ORC)
+  set(ORC_HEADERS
+    orc/c_api.h
+    )
+endif(COMPILER_RT_BUILD_ORC)
+
 if (COMPILER_RT_BUILD_PROFILE)
   set(PROFILE_HEADERS
     profile/InstrProfData.inc
     )
 endif(COMPILER_RT_BUILD_PROFILE)
 
 set(COMPILER_RT_HEADERS
   ${SANITIZER_HEADERS}
   ${FUZZER_HEADERS}
   ${MEMPROF_HEADERS}
   ${XRAY_HEADERS}
+  ${ORC_HEADERS}
   ${PROFILE_HEADERS})
 
 set(output_dir ${COMPILER_RT_OUTPUT_DIR}/include)
 
 # Copy compiler-rt headers to the build tree.
 set(out_files)
 foreach( f ${COMPILER_RT_HEADERS} )
   set( src ${CMAKE_CURRENT_SOURCE_DIR}/${f} )
install(FILES ${FUZZER_HEADERS}
   COMPONENT compiler-rt-headers
   PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
   DESTINATION ${COMPILER_RT_INSTALL_INCLUDE_DIR}/fuzzer)
 # Install xray headers.
 install(FILES ${XRAY_HEADERS}
   COMPONENT compiler-rt-headers
   PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
   DESTINATION ${COMPILER_RT_INSTALL_INCLUDE_DIR}/xray)
+# Install ORC headers.
+install(FILES ${ORC_HEADERS}
+  COMPONENT compiler-rt-headers
+  PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
+  DESTINATION ${COMPILER_RT_INSTALL_INCLUDE_DIR}/orc)
 # Install profile headers.
 install(FILES ${PROFILE_HEADERS}
   COMPONENT compiler-rt-headers
   PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
   DESTINATION ${COMPILER_RT_INSTALL_INCLUDE_DIR}/profile)
 
 if (NOT CMAKE_CONFIGURATION_TYPES) # don't add this for IDEs.
   add_custom_target(install-compiler-rt-headers

compiler-rt/include/orc/c_api.h

 /*===- c_api.h - C API for the ORC runtime ------------------------*- 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                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file defines the C API for the ORC runtime                            *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #ifndef ORC_RT_C_API_H
 #define ORC_RT_C_API_H
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 /* Helper to suppress strict prototype warnings. */
 #ifdef __clang__
 #define ORC_RT_C_STRICT_PROTOTYPES_BEGIN                                       \
   _Pragma("clang diagnostic push")                                             \
       _Pragma("clang diagnostic error \"-Wstrict-prototypes\"")
 #define ORC_RT_C_STRICT_PROTOTYPES_END _Pragma("clang diagnostic pop")
 #else
 #define ORC_RT_C_STRICT_PROTOTYPES_BEGIN
 #define ORC_RT_C_STRICT_PROTOTYPES_END
 #endif
 
 /* Helper to wrap C code for C++ */
 #ifdef __cplusplus
 #define ORC_RT_C_EXTERN_C_BEGIN                                                \
   extern "C" {                                                                 \
   ORC_RT_C_STRICT_PROTOTYPES_BEGIN
 #define ORC_RT_C_EXTERN_C_END                                                  \
   ORC_RT_C_STRICT_PROTOTYPES_END                                               \
   }
 #else
 #define ORC_RT_C_EXTERN_C_BEGIN ORC_RT_C_STRICT_PROTOTYPES_BEGIN
 #define ORC_RT_C_EXTERN_C_END ORC_RT_C_STRICT_PROTOTYPES_END
 #endif
 
 ORC_RT_C_EXTERN_C_BEGIN
 
 typedef union {
   char *ValuePtr;
   char Value[sizeof(char *)];
 } __orc_rt_CWrapperFunctionResultDataUnion;
 
 /**
  * __orc_rt_CWrapperFunctionResult is a kind of C-SmallVector with an
  * out-of-band error state.
  *
  * If Size == 0 and Data.ValuePtr is non-zero then the value is in the
  * 'out-of-band error' state, and Data.ValuePtr points at a malloc-allocated,
  * null-terminated string error message.
  *
  * If Size <= sizeof(__orc_rt_CWrapperFunctionResultData) then the value is in
  * the 'small' state and the content is held in the first Size bytes of
  * Data.Value.
  *
  * If Size > sizeof(OrtRTCWrapperFunctionResultData) then the value is in the
  * 'large' state and the content is held in the first Size bytes of the
  * memory pointed to by Data.ValuePtr. This memory must have been allocated by
  * malloc, and will be freed with free when this value is destroyed.
  */
 typedef struct {
   __orc_rt_CWrapperFunctionResultDataUnion Data;
   size_t Size;
 } __orc_rt_CWrapperFunctionResult;
 
 typedef struct __orc_rt_CSharedOpaqueJITProcessControl
     *__orc_rt_SharedJITProcessControlRef;
 
 /**
  * Zero-initialize an __orc_rt_CWrapperFunctionResult.
  */
 static inline void
 __orc_rt_CWrapperFunctionResultInit(__orc_rt_CWrapperFunctionResult *R) {
   R->Size = 0;
   R->Data.ValuePtr = 0;
 }
 
 /**
  * Create an __orc_rt_CWrapperFunctionResult with an uninitialized buffer of
  * size Size. The buffer is returned via the DataPtr argument.
  */
 static inline __orc_rt_CWrapperFunctionResult
 __orc_rt_CWrapperFunctionResultAllocate(size_t Size) {
   __orc_rt_CWrapperFunctionResult R;
   R.Size = Size;
   // If Size is 0 ValuePtr must be 0 or it is considered an out-of-band error.
   R.Data.ValuePtr = 0;
   if (Size > sizeof(R.Data.Value))
     R.Data.ValuePtr = (char *)malloc(Size);
   return R;
 }
 
 /**
  * Create an __orc_rt_WrapperFunctionResult from the given data range.
  */
 static inline __orc_rt_CWrapperFunctionResult
 __orc_rt_CreateCWrapperFunctionResultFromRange(const char *Data, size_t Size) {
   __orc_rt_CWrapperFunctionResult R;
   R.Size = Size;
   if (R.Size > sizeof(R.Data.Value)) {
     char *Tmp = (char *)malloc(Size);
     memcpy(Tmp, Data, Size);
     R.Data.ValuePtr = Tmp;
   } else
     memcpy(R.Data.Value, Data, Size);
   return R;
 }
 
 /**
  * Create an __orc_rt_CWrapperFunctionResult by copying the given string,
  * including the null-terminator.
  *
  * This function copies the input string. The client is responsible for freeing
  * the ErrMsg arg.
  */
 static inline __orc_rt_CWrapperFunctionResult
 __orc_rt_CreateCWrapperFunctionResultFromString(const char *Source) {
   return __orc_rt_CreateCWrapperFunctionResultFromRange(Source,
                                                         strlen(Source) + 1);
 }
 
 /**
  * Create an __orc_rt_CWrapperFunctionResult representing an out-of-band
  * error.
  *
  * This function copies the input string. The client is responsible for freeing
  * the ErrMsg arg.
  */
 static inline __orc_rt_CWrapperFunctionResult
 __orc_rt_CreateCWrapperFunctionResultFromOutOfBandError(const char *ErrMsg) {
   __orc_rt_CWrapperFunctionResult R;
   R.Size = 0;
   char *Tmp = (char *)malloc(strlen(ErrMsg) + 1);
   strcpy(Tmp, ErrMsg);
   R.Data.ValuePtr = Tmp;
   return R;
 }
 
 /**
  * This should be called to destroy __orc_rt_CWrapperFunctionResult values
  * regardless of their state.
  */
 static inline void
 __orc_rt_DisposeCWrapperFunctionResult(__orc_rt_CWrapperFunctionResult *R) {
   if (R->Size > sizeof(R->Data.Value) ||
       (R->Size == 0 && R->Data.ValuePtr))
     free(R->Data.ValuePtr);
 }
 
 /**
  * Get a pointer to the data contained in the given
  * __orc_rt_CWrapperFunctionResult.
  */
 static inline char *
 __orc_rt_CWrapperFunctionResultData(__orc_rt_CWrapperFunctionResult *R) {
   assert((R->Size != 0 || R->Data.ValuePtr == NULL) &&
          "Cannot get data for out-of-band error value");
   return R->Size > sizeof(R->Data.Value) ? R->Data.ValuePtr : R->Data.Value;
 }
 
 /**
  * Safely get the size of the given __orc_rt_CWrapperFunctionResult.
  *
  * Asserts that we're not trying to access the size of an error value.
  */
 static inline size_t
 __orc_rt_CWrapperFunctionResultSize(const __orc_rt_CWrapperFunctionResult *R) {
   assert((R->Size != 0 || R->Data.ValuePtr == NULL) &&
          "Cannot get size for out-of-band error value");
   return R->Size;
 }
 
 /**
  * Returns 1 if this value is equivalent to a value just initialized by
  * __orc_rt_CWrapperFunctionResultInit, 0 otherwise.
  */
 static inline size_t
 __orc_rt_CWrapperFunctionResultEmpty(const __orc_rt_CWrapperFunctionResult *R) {
   return R->Size == 0 && R->Data.ValuePtr == 0;
 }
 
 /**
  * Returns a pointer to the out-of-band error string for this
  * __orc_rt_CWrapperFunctionResult, or null if there is no error.
  *
  * The __orc_rt_CWrapperFunctionResult retains ownership of the error
  * string, so it should be copied if the caller wishes to preserve it.
  */
 static inline const char *__orc_rt_CWrapperFunctionResultGetOutOfBandError(
     const __orc_rt_CWrapperFunctionResult *R) {
   return R->Size == 0 ? R->Data.ValuePtr : 0;
 }
 
 ORC_RT_C_EXTERN_C_END
 
 #endif /* ORC_RT_C_API_H */

compiler-rt/lib/orc/common.h

 //===- common.h - Common utilities for the ORC runtime ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of the ORC runtime support library.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ORC_RT_COMMON_H
 #define ORC_RT_COMMON_H
 
-#include "c_api.h"
 #include "compiler.h"
+#include "orc/c_api.h"
 #include <type_traits>
 
 /// This macro should be used to define tags that will be associated with
 /// handlers in the JIT process, and call can be used to define tags f
 #define ORC_RT_JIT_DISPATCH_TAG(X) \
 extern "C" char X; \
 char X = 0;
 

compiler-rt/lib/orc/macho_ehframe_registration.cpp

 //===- ehframe_registration.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 contains code required to load the rest of the MachO runtime.
 //
 //===----------------------------------------------------------------------===//
 
 #include "adt.h"
-#include "c_api.h"
 #include "common.h"
 #include "executor_address.h"
+#include "orc/c_api.h"
 #include "wrapper_function_utils.h"
 
 using namespace __orc_rt;
 
 // eh-frame registration functions.
 // We expect these to be available for all processes.
 extern "C" void __register_frame(const void *);
 extern "C" void __deregister_frame(const void *);

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

macro(add_orc_unittest testname)
   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}
+        COMPILE_DEPS ${TEST_HEADERS} ${ORC_HEADERS}
         DEPS ${ORC_DEPS}
         CFLAGS ${ORC_UNITTEST_CFLAGS}
         LINK_FLAGS ${ORC_UNITTEST_LINK_FLAGS})
     endforeach()
   endif()
 endmacro()
 
 set(UNITTEST_SOURCES

compiler-rt/lib/orc/wrapper_function_utils.h

 //===-- wrapper_function_utils.h - Utilities for wrapper funcs --*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of the ORC runtime support library.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ORC_RT_WRAPPER_FUNCTION_UTILS_H
 #define ORC_RT_WRAPPER_FUNCTION_UTILS_H
 
-#include "c_api.h"
+#include "orc/c_api.h"
 #include "common.h"
 #include "error.h"
 #include "executor_address.h"
 #include "simple_packed_serialization.h"
 #include <type_traits>
 
 namespace __orc_rt {