[orc] Fix unit tests that use ORC C API

[benlangmuir]

Summary

• c_api_tests was failing to build after the API change to __orc_rt_CWrapperFunctionResultAllocate

• wrapper_function_utils_test was causing an assertion failure, because it was creating a result for void(void) with Size = 0, but seeing an uninitialized pointer, which it considered to be an out-of-bound error.

I noticed locally that making modifications to c_api.h is not causing
these unit tests to be rebuilt, which may be how the bug slipped in in
the first place.

[lhames]

LGTM. Thanks Ben!

I was running this manually during runtime bringup, but never did check that it was being run by any testers. I'll look in to that.

compiler-rt/lib/orc/c_api.h

 /**
  * 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.
  */

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

 //===-- c_api_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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "c_api.h"
 #include "gtest/gtest.h"
 
 TEST(CAPITest, CWrapperFunctionResultInit) {
   __orc_rt_CWrapperFunctionResult R;
   __orc_rt_CWrapperFunctionResultInit(&R);
 
   EXPECT_EQ(R.Size, 0U);
   EXPECT_EQ(R.Data.ValuePtr, nullptr);
 
   // Check that this value isn't treated as an out-of-band error.
   EXPECT_EQ(__orc_rt_CWrapperFunctionResultGetOutOfBandError(&R), nullptr);
 
   // Check that we can dispose of the value.
   __orc_rt_DisposeCWrapperFunctionResult(&R);
 }
 
 TEST(CAPITest, CWrapperFunctionResultAllocSmall) {
   constexpr size_t SmallAllocSize = sizeof(const char *);
 
-  __orc_rt_CWrapperFunctionResult R;
-  char *DataPtr = __orc_rt_CWrapperFunctionResultAllocate(&R, SmallAllocSize);
+  auto R = __orc_rt_CWrapperFunctionResultAllocate(SmallAllocSize);
+  char *DataPtr = __orc_rt_CWrapperFunctionResultData(&R);
 
   for (size_t I = 0; I != SmallAllocSize; ++I)
     DataPtr[I] = 0x55 + I;
 
   // Check that the inline storage in R.Data.Value contains the expected
   // sequence.
   EXPECT_EQ(R.Size, SmallAllocSize);
   for (size_t I = 0; I != SmallAllocSize; ++I)
TEST(CAPITest, CWrapperFunctionResultAllocSmall) {
 
   // Check that we can dispose of the value.
   __orc_rt_DisposeCWrapperFunctionResult(&R);
 }
 
 TEST(CAPITest, CWrapperFunctionResultAllocLarge) {
   constexpr size_t LargeAllocSize = sizeof(const char *) + 1;
 
-  __orc_rt_CWrapperFunctionResult R;
-  char *DataPtr = __orc_rt_CWrapperFunctionResultAllocate(&R, LargeAllocSize);
+  auto R = __orc_rt_CWrapperFunctionResultAllocate(LargeAllocSize);
+  char *DataPtr = __orc_rt_CWrapperFunctionResultData(&R);
 
   for (size_t I = 0; I != LargeAllocSize; ++I)
     DataPtr[I] = 0x55 + I;
 
   // Check that the inline storage in R.Data.Value contains the expected
   // sequence.
   EXPECT_EQ(R.Size, LargeAllocSize);
   EXPECT_EQ(R.Data.ValuePtr, DataPtr);