[orc-rt] Rename WrapperFunctionBuffer and headers. (#156799)

Renames WrapperFunctionResult to WrapperFunctionBuffer. This reflects
intended usage as a buffer for both arguments and results.

The WrapperFunctionResult.h headers are renamed to WrapperFunction.h as
they will be extended with further wrapper-function related APIs in an
upcoming patch.

Author: lhames

orc-rt/include/orc-rt-c/WrapperFunctionResult.h renamed to orc-rt/include/orc-rt-c/WrapperFunction.h

@@ -1,4 +1,4 @@
-/*===----- WrapperFunctionResult.h - blob-of-bytes container -----*- C -*-===*\
+/*===--------- WrapperFunction.h - Wrapper function utils ---------*- C -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
@@ -7,12 +7,12 @@
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
-|* Defines orc_rt_WrapperFunctionResult and related APIs.                     *|
+|* Defines orc_rt_WrapperFunctionBuffer and related APIs.                     *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#ifndef ORC_RT_C_WRAPPERFUNCTIONRESULT_H
-#define ORC_RT_C_WRAPPERFUNCTIONRESULT_H
+#ifndef ORC_RT_C_WRAPPERFUNCTION_H
+#define ORC_RT_C_WRAPPERFUNCTION_H
 
 #include "orc-rt-c/ExternC.h"
 
@@ -25,154 +25,154 @@ ORC_RT_C_EXTERN_C_BEGIN
 typedef union {
   char *ValuePtr;
   char Value[sizeof(char *)];
-} orc_rt_WrapperFunctionResultDataUnion;
+} orc_rt_WrapperFunctionBufferDataUnion;
 
 /**
- * orc_rt_WrapperFunctionResult is a kind of C-SmallVector with an
+ * orc_rt_WrapperFunctionBuffer 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_WrapperFunctionResultData) then the value is in
+ * If Size <= sizeof(orc_rt_WrapperFunctionBufferData) then the value is in
  * the 'small' state and the content is held in the first Size bytes of
  * Data.Value.
  *
- * If Size > sizeof(orc_rt_WrapperFunctionResultData) then the value is in the
+ * If Size > sizeof(orc_rt_WrapperFunctionBufferData) 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_WrapperFunctionResultDataUnion Data;
+  orc_rt_WrapperFunctionBufferDataUnion Data;
   size_t Size;
-} orc_rt_WrapperFunctionResult;
+} orc_rt_WrapperFunctionBuffer;
 
 /**
- * Zero-initialize an orc_rt_WrapperFunctionResult.
+ * Zero-initialize an orc_rt_WrapperFunctionBuffer.
  */
 static inline void
-orc_rt_WrapperFunctionResultInit(orc_rt_WrapperFunctionResult *R) {
-  R->Size = 0;
-  R->Data.ValuePtr = 0;
+orc_rt_WrapperFunctionBufferInit(orc_rt_WrapperFunctionBuffer *B) {
+  B->Size = 0;
+  B->Data.ValuePtr = 0;
 }
 
 /**
- * Create an orc_rt_WrapperFunctionResult with an uninitialized buffer of
+ * Create an orc_rt_WrapperFunctionBuffer with an uninitialized buffer of
  * size Size. The buffer is returned via the DataPtr argument.
  */
-static inline orc_rt_WrapperFunctionResult
-orc_rt_WrapperFunctionResultAllocate(size_t Size) {
-  orc_rt_WrapperFunctionResult R;
-  R.Size = Size;
+static inline orc_rt_WrapperFunctionBuffer
+orc_rt_WrapperFunctionBufferAllocate(size_t Size) {
+  orc_rt_WrapperFunctionBuffer B;
+  B.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;
+  B.Data.ValuePtr = 0;
+  if (Size > sizeof(B.Data.Value))
+    B.Data.ValuePtr = (char *)malloc(Size);
+  return B;
 }
 
 /**
- * Create an orc_rt_WrapperFunctionResult from the given data range.
+ * Create an orc_rt_WrapperFunctionBuffer from the given data range.
  */
-static inline orc_rt_WrapperFunctionResult
-orc_rt_CreateWrapperFunctionResultFromRange(const char *Data, size_t Size) {
-  orc_rt_WrapperFunctionResult R;
-  R.Size = Size;
-  if (R.Size > sizeof(R.Data.Value)) {
+static inline orc_rt_WrapperFunctionBuffer
+orc_rt_CreateWrapperFunctionBufferFromRange(const char *Data, size_t Size) {
+  orc_rt_WrapperFunctionBuffer B;
+  B.Size = Size;
+  if (B.Size > sizeof(B.Data.Value)) {
     char *Tmp = (char *)malloc(Size);
     memcpy(Tmp, Data, Size);
-    R.Data.ValuePtr = Tmp;
+    B.Data.ValuePtr = Tmp;
   } else
-    memcpy(R.Data.Value, Data, Size);
-  return R;
+    memcpy(B.Data.Value, Data, Size);
+  return B;
 }
 
 /**
- * Create an orc_rt_WrapperFunctionResult by copying the given string,
+ * Create an orc_rt_WrapperFunctionBuffer 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_WrapperFunctionResult
-orc_rt_CreateWrapperFunctionResultFromString(const char *Source) {
-  return orc_rt_CreateWrapperFunctionResultFromRange(Source,
+static inline orc_rt_WrapperFunctionBuffer
+orc_rt_CreateWrapperFunctionBufferFromString(const char *Source) {
+  return orc_rt_CreateWrapperFunctionBufferFromRange(Source,
                                                      strlen(Source) + 1);
 }
 
 /**
- * Create an orc_rt_WrapperFunctionResult representing an out-of-band
+ * Create an orc_rt_WrapperFunctionBuffer 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_WrapperFunctionResult
-orc_rt_CreateWrapperFunctionResultFromOutOfBandError(const char *ErrMsg) {
-  orc_rt_WrapperFunctionResult R;
-  R.Size = 0;
+static inline orc_rt_WrapperFunctionBuffer
+orc_rt_CreateWrapperFunctionBufferFromOutOfBandError(const char *ErrMsg) {
+  orc_rt_WrapperFunctionBuffer B;
+  B.Size = 0;
   char *Tmp = (char *)malloc(strlen(ErrMsg) + 1);
   strcpy(Tmp, ErrMsg);
-  R.Data.ValuePtr = Tmp;
-  return R;
+  B.Data.ValuePtr = Tmp;
+  return B;
 }
 
 /**
- * This should be called to destroy orc_rt_WrapperFunctionResult values
+ * This should be called to destroy orc_rt_WrapperFunctionBuffer values
  * regardless of their state.
  */
 static inline void
-orc_rt_DisposeWrapperFunctionResult(orc_rt_WrapperFunctionResult *R) {
-  if (R->Size > sizeof(R->Data.Value) || (R->Size == 0 && R->Data.ValuePtr))
-    free(R->Data.ValuePtr);
+orc_rt_WrapperFunctionBufferDispose(orc_rt_WrapperFunctionBuffer *B) {
+  if (B->Size > sizeof(B->Data.Value) || (B->Size == 0 && B->Data.ValuePtr))
+    free(B->Data.ValuePtr);
 }
 
 /**
  * Get a pointer to the data contained in the given
- * orc_rt_WrapperFunctionResult.
+ * orc_rt_WrapperFunctionBuffer.
  */
 static inline char *
-orc_rt_WrapperFunctionResultData(orc_rt_WrapperFunctionResult *R) {
-  assert((R->Size != 0 || R->Data.ValuePtr == NULL) &&
+orc_rt_WrapperFunctionBufferData(orc_rt_WrapperFunctionBuffer *B) {
+  assert((B->Size != 0 || B->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;
+  return B->Size > sizeof(B->Data.Value) ? B->Data.ValuePtr : B->Data.Value;
 }
 
 /**
- * Safely get the size of the given orc_rt_WrapperFunctionResult.
+ * Safely get the size of the given orc_rt_WrapperFunctionBuffer.
  *
  * Asserts that we're not trying to access the size of an error value.
  */
 static inline size_t
-orc_rt_WrapperFunctionResultSize(const orc_rt_WrapperFunctionResult *R) {
-  assert((R->Size != 0 || R->Data.ValuePtr == NULL) &&
+orc_rt_WrapperFunctionBufferSize(const orc_rt_WrapperFunctionBuffer *B) {
+  assert((B->Size != 0 || B->Data.ValuePtr == NULL) &&
          "Cannot get size for out-of-band error value");
-  return R->Size;
+  return B->Size;
 }
 
 /**
  * Returns 1 if this value is equivalent to a value just initialized by
- * orc_rt_WrapperFunctionResultInit, 0 otherwise.
+ * orc_rt_WrapperFunctionBufferInit, 0 otherwise.
  */
 static inline size_t
-orc_rt_WrapperFunctionResultEmpty(const orc_rt_WrapperFunctionResult *R) {
-  return R->Size == 0 && R->Data.ValuePtr == 0;
+orc_rt_WrapperFunctionBufferEmpty(const orc_rt_WrapperFunctionBuffer *B) {
+  return B->Size == 0 && B->Data.ValuePtr == 0;
 }
 
 /**
  * Returns a pointer to the out-of-band error string for this
- * orc_rt_WrapperFunctionResult, or null if there is no error.
+ * orc_rt_WrapperFunctionBuffer, or null if there is no error.
  *
- * The orc_rt_WrapperFunctionResult retains ownership of the error
+ * The orc_rt_WrapperFunctionBuffer retains ownership of the error
  * string, so it should be copied if the caller wishes to preserve it.
  */
-static inline const char *orc_rt_WrapperFunctionResultGetOutOfBandError(
-    const orc_rt_WrapperFunctionResult *R) {
-  return R->Size == 0 ? R->Data.ValuePtr : 0;
+static inline const char *orc_rt_WrapperFunctionBufferGetOutOfBandError(
+    const orc_rt_WrapperFunctionBuffer *B) {
+  return B->Size == 0 ? B->Data.ValuePtr : 0;
 }
 
 ORC_RT_C_EXTERN_C_END
 
-#endif /* ORC_RT_WRAPPERFUNCTIONRESULT_H */
+#endif /* ORC_RT_WRAPPERFUNCTION_H */

orc-rt/include/orc-rt/WrapperFunction.h

@@ -0,0 +1,103 @@
+//===-------- WrapperFunction.h - Wrapper function utils --------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines WrapperFunctionBuffer and related APIs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ORC_RT_WRAPPERFUNCTION_H
+#define ORC_RT_WRAPPERFUNCTION_H
+
+#include "orc-rt-c/WrapperFunction.h"
+
+#include <utility>
+
+namespace orc_rt {
+
+/// A C++ convenience wrapper for orc_rt_WrapperFunctionBuffer. Auto-disposes
+/// the contained result on destruction.
+class WrapperFunctionBuffer {
+public:
+  /// Create a default WrapperFunctionBuffer.
+  WrapperFunctionBuffer() { orc_rt_WrapperFunctionBufferInit(&B); }
+
+  /// Create a WrapperFunctionBuffer from a WrapperFunctionBuffer. This
+  /// instance takes ownership of the result object and will automatically
+  /// call dispose on the result upon destruction.
+  WrapperFunctionBuffer(orc_rt_WrapperFunctionBuffer B) : B(B) {}
+
+  WrapperFunctionBuffer(const WrapperFunctionBuffer &) = delete;
+  WrapperFunctionBuffer &operator=(const WrapperFunctionBuffer &) = delete;
+
+  WrapperFunctionBuffer(WrapperFunctionBuffer &&Other) {
+    orc_rt_WrapperFunctionBufferInit(&B);
+    std::swap(B, Other.B);
+  }
+
+  WrapperFunctionBuffer &operator=(WrapperFunctionBuffer &&Other) {
+    orc_rt_WrapperFunctionBufferDispose(&B);
+    orc_rt_WrapperFunctionBufferInit(&B);
+    std::swap(B, Other.B);
+    return *this;
+  }
+
+  ~WrapperFunctionBuffer() { orc_rt_WrapperFunctionBufferDispose(&B); }
+
+  /// Relinquish ownership of and return the
+  /// orc_rt_WrapperFunctionBuffer.
+  orc_rt_WrapperFunctionBuffer release() {
+    orc_rt_WrapperFunctionBuffer Tmp;
+    orc_rt_WrapperFunctionBufferInit(&Tmp);
+    std::swap(B, Tmp);
+    return Tmp;
+  }
+
+  /// Get a pointer to the data contained in this instance.
+  char *data() { return orc_rt_WrapperFunctionBufferData(&B); }
+
+  /// Returns the size of the data contained in this instance.
+  size_t size() const { return orc_rt_WrapperFunctionBufferSize(&B); }
+
+  /// Returns true if this value is equivalent to a default-constructed
+  /// WrapperFunctionBuffer.
+  bool empty() const { return orc_rt_WrapperFunctionBufferEmpty(&B); }
+
+  /// Create a WrapperFunctionBuffer with the given size and return a pointer
+  /// to the underlying memory.
+  static WrapperFunctionBuffer allocate(size_t Size) {
+    return orc_rt_WrapperFunctionBufferAllocate(Size);
+  }
+
+  /// Copy from the given char range.
+  static WrapperFunctionBuffer copyFrom(const char *Source, size_t Size) {
+    return orc_rt_CreateWrapperFunctionBufferFromRange(Source, Size);
+  }
+
+  /// Copy from the given null-terminated string (includes the null-terminator).
+  static WrapperFunctionBuffer copyFrom(const char *Source) {
+    return orc_rt_CreateWrapperFunctionBufferFromString(Source);
+  }
+
+  /// Create an out-of-band error by copying the given string.
+  static WrapperFunctionBuffer createOutOfBandError(const char *Msg) {
+    return orc_rt_CreateWrapperFunctionBufferFromOutOfBandError(Msg);
+  }
+
+  /// If this value is an out-of-band error then this returns the error message,
+  /// otherwise returns nullptr.
+  const char *getOutOfBandError() const {
+    return orc_rt_WrapperFunctionBufferGetOutOfBandError(&B);
+  }
+
+private:
+  orc_rt_WrapperFunctionBuffer B;
+};
+
+} // namespace orc_rt
+
+#endif // ORC_RT_WRAPPERFUNCTION_H