Add additional offload-tblgen tests and associated fixes

callumfare · callumfare · commit 2251d843e16e · 2024-12-04T11:46:52.000Z
diff --git a/offload/new-api/API/Platform.td b/offload/new-api/API/Platform.td
@@ -50,7 +50,7 @@ def : Enum {
   let is_typed = 1;
   let etors = [
     TaggedEtor<"NAME", "char[]", "The string denoting name of the platform. The size of the info needs to be dynamically queried.">,
-    TaggedEtor<"VENDOR_NAME", "char[]","The string denoting name of the vendor of the platform. The size of the info needs to be dynamically queried.">,
+    TaggedEtor<"VENDOR_NAME", "char[]", "The string denoting name of the vendor of the platform. The size of the info needs to be dynamically queried.">,
     TaggedEtor<"VERSION", "char[]", "The string denoting the version of the platform. The size of the info needs to be dynamically queried.">,
     TaggedEtor<"BACKEND", "offload_platform_backend_t", "The native backend of the platform.">
   ];
diff --git a/offload/new-api/include/offload_api.h b/offload/new-api/include/offload_api.h
@@ -213,16 +213,16 @@ OFFLOAD_APIEXPORT offload_result_t OFFLOAD_APICALL offloadPlatformGetCount(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Supported platform info
 typedef enum offload_platform_info_t {
-  /// The string denoting name of the platform. The size of the info needs to be
-  /// dynamically queried.
+  /// [char[]] The string denoting name of the platform. The size of the info
+  /// needs to be dynamically queried.
   OFFLOAD_PLATFORM_INFO_NAME = 0,
-  /// The string denoting name of the vendor of the platform. The size of the
-  /// info needs to be dynamically queried.
+  /// [char[]] The string denoting name of the vendor of the platform. The size
+  /// of the info needs to be dynamically queried.
   OFFLOAD_PLATFORM_INFO_VENDOR_NAME = 1,
-  /// The string denoting the version of the platform. The size of the info
-  /// needs to be dynamically queried.
+  /// [char[]] The string denoting the version of the platform. The size of the
+  /// info needs to be dynamically queried.
   OFFLOAD_PLATFORM_INFO_VERSION = 2,
-  /// The native backend of the platform.
+  /// [offload_platform_backend_t] The native backend of the platform.
   OFFLOAD_PLATFORM_INFO_BACKEND = 3,
   /// @cond
   OFFLOAD_PLATFORM_INFO_FORCE_UINT32 = 0x7fffffff
@@ -328,15 +328,15 @@ typedef enum offload_device_type_t {
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Supported device info
 typedef enum offload_device_info_t {
-  /// type of the device
+  /// [offload_device_type_t] type of the device
   OFFLOAD_DEVICE_INFO_TYPE = 0,
-  /// the platform associated with the device
+  /// [offload_platform_handle_t] the platform associated with the device
   OFFLOAD_DEVICE_INFO_PLATFORM = 1,
-  /// Device name
+  /// [char[]] Device name
   OFFLOAD_DEVICE_INFO_NAME = 2,
-  /// Device vendor
+  /// [char[]] Device vendor
   OFFLOAD_DEVICE_INFO_VENDOR = 3,
-  /// Driver version
+  /// [char[]] Driver version
   OFFLOAD_DEVICE_INFO_DRIVER_VERSION = 4,
   /// @cond
   OFFLOAD_DEVICE_INFO_FORCE_UINT32 = 0x7fffffff
diff --git a/offload/test/tools/offload-tblgen/functions_ranged_param.td b/offload/test/tools/offload-tblgen/functions_ranged_param.td
@@ -0,0 +1,36 @@
+// RUN: %offload-tblgen -gen-print-header -I %S/../../../new-api/API %s | %fcheck-generic
+
+// Check that ranged function parameters are implemented correctly. These
+// are pointers to an array of an arbitrary size. Their size is described as a
+// range between two values. This is typically between 0 and a parameter such
+// as NumItems. The range information helps the printing code print the entire
+// range of the output rather than just the pointer or the first element.
+
+include "APIDefs.td"
+
+def : Handle {
+    let name = "some_handle_t";
+    let desc = "An example handle type";
+}
+
+def : Function {
+    let name = "FunctionA";
+    let desc = "Function A description";
+    let details = [ "Function A detailed information" ];
+  let params = [
+    Param<"size_t", "OutCount", "the number of things to write out", PARAM_IN>,
+    RangedParam<"some_handle_t*", "OutPtr", "pointer to the output things.", PARAM_OUT,
+      Range<"0", "OutCount">>
+  ];
+  let returns = [];
+}
+
+// CHECK: inline std::ostream &operator<<(std::ostream &os, const struct function_a_params_t *params) {
+// CHECK:   os << ".OutPtr = ";
+// CHECK:   for (size_t i = 0; i < *params->pOutCount; i++) {
+// CHECK:     if (i > 0) {
+// CHECK:       os << ", ";
+// CHECK:     }
+// CHECK:     printPtr(os, (*params->pOutPtr)[i]);
+// CHECK:   }
+// CHECK:   os << "}";
diff --git a/offload/test/tools/offload-tblgen/type_tagged_enum.td b/offload/test/tools/offload-tblgen/type_tagged_enum.td
@@ -0,0 +1,76 @@
+// RUN: %offload-tblgen -gen-api -I %S/../../../new-api/API %s | %fcheck-generic --check-prefix=CHECK-API
+// RUN: %offload-tblgen -gen-print-header -I %S/../../../new-api/API %s | %fcheck-generic --check-prefix=CHECK-PRINT
+
+// Check that type-tagged enumerators are implemented correctly. They enable
+// functions to return data of an arbitrary type and size via a void*, using
+// the value of an enum parameter to indicate which type is being returned.
+// This allows, for example, for a single offloadDeviceGetInfo function, rather
+// than requiring a separate entry point for every possible query.
+
+include "APIDefs.td"
+
+def : Handle {
+    let name = "some_handle_t";
+    let desc = "An example handle type";
+}
+
+def : Enum {
+  let name = "my_type_tagged_enum_t";
+  let desc = "Example type tagged enum";
+  let is_typed = 1;
+  let etors = [
+    TaggedEtor<"VALUE_ONE", "uint32_t", "Value one.">,
+    TaggedEtor<"VALUE_TWO", "char[]", "Value two.">,
+    TaggedEtor<"VALUE_THREE", "some_handle_t", "Value three.">
+  ];
+}
+
+// Check the tagged types appear in the comments
+// CHECK-API: typedef enum my_type_tagged_enum_t {
+// CHECK-API-NEXT: [uint32_t] Value one.
+// CHECK-API-NEXT: MY_TYPE_TAGGED_ENUM_VALUE_ONE = 0,
+// CHECK-API-NEXT: [char[]] Value two.
+// CHECK-API-NEXT: MY_TYPE_TAGGED_ENUM_VALUE_TWO = 1,
+// CHECK-API-NEXT: [some_handle_t] Value three.
+// CHECK-API-NEXT: MY_TYPE_TAGGED_ENUM_VALUE_THREE = 2,
+
+def : Function {
+    let name = "FunctionA";
+    let desc = "Function A description";
+    let details = [ "Function A detailed information" ];
+  let params = [
+    Param<"my_type_tagged_enum_t", "PropName", "type of the info to retrieve", PARAM_IN>,
+    Param<"size_t", "PropSize", "the number of bytes pointed to by PropValue.", PARAM_IN>,
+    TypeTaggedParam<"void*", "PropValue", "array of bytes holding the info. "
+      "If PropSize is not equal to or greater to the real number of bytes needed to return the info "
+      "then the OFFLOAD_ERRC_INVALID_SIZE error is returned and PropValue is not used.", PARAM_OUT,
+      TypeInfo<"PropName" , "PropSize">>
+  ];
+  let returns = [];
+}
+
+// Check that a tagged enum print function definition is generated
+// CHECK-PRINT: void printTagged(std::ostream &os, const void *ptr, my_type_tagged_enum_t value, size_t size) {
+// CHECK-PRINT: case MY_TYPE_TAGGED_ENUM_VALUE_ONE: {
+// CHECK-PRINT:   const uint32_t * const tptr = (const uint32_t * const)ptr;
+// CHECK-PRINT:   os << (const void *)tptr << " (";
+// CHECK-PRINT:   os << *tptr;
+// CHECK-PRINT:   os << ")";
+// CHECK-PRINT:   break;
+// CHECK-PRINT: }
+// CHECK-PRINT: case MY_TYPE_TAGGED_ENUM_VALUE_TWO: {
+// CHECK-PRINT:   printPtr(os, (const char*) ptr);
+// CHECK-PRINT:   break;
+// CHECK-PRINT: }
+// CHECK-PRINT: case MY_TYPE_TAGGED_ENUM_VALUE_THREE: {
+// CHECK-PRINT:   const some_handle_t * const tptr = (const some_handle_t * const)ptr;
+// CHECK-PRINT:   os << (const void *)tptr << " (";
+// CHECK-PRINT:   os << *tptr;
+// CHECK-PRINT:   os << ")";
+// CHECK-PRINT:   break;
+// CHECK-PRINT: }
+
+// Check that the tagged type information is used when printing function parameters
+// CHECK-PRINT: std::ostream &operator<<(std::ostream &os, const struct function_a_params_t *params) {
+// CHECK-PRINT: os << ".PropValue = " 
+// CHECK-PRINT-NEXT: printTagged(os, *params->pPropValue, *params->pPropName, *params->pPropSize);
diff --git a/offload/tools/offload-tblgen/APIGen.cpp b/offload/tools/offload-tblgen/APIGen.cpp
@@ -125,7 +125,13 @@ static void ProcessEnum(const EnumRec &Enum, raw_ostream &OS) {
 
   uint32_t EtorVal = 0;
   for (const auto &EnumVal : Enum.getValues()) {
-    OS << TAB_1 << MakeComment(EnumVal.getDesc());
+    if (Enum.isTyped()) {
+      OS << MakeComment(
+          formatv("[{0}] {1}", EnumVal.getTaggedType(), EnumVal.getDesc())
+              .str());
+    } else {
+      OS << MakeComment(EnumVal.getDesc());
+    }
     OS << formatv(TAB_1 "{0}_{1} = {2},\n", Enum.getEnumValNamePrefix(),
                   EnumVal.getName(), EtorVal++);
   }
diff --git a/offload/tools/offload-tblgen/PrintGen.cpp b/offload/tools/offload-tblgen/PrintGen.cpp
@@ -123,7 +123,7 @@ inline std::ostream &operator<<(std::ostream &os, const struct {0} *params) {{
     OS << formatv(TAB_1 "os << \".{0} = \";\n", Param.getName());
     if (auto Range = Param.getRange()) {
       OS << formatv(TAB_1 "os << \"{{\";\n");
-      OS << formatv(TAB_1 "for (size_t i = {0}; i < *params->p{1}; i++){{\n",
+      OS << formatv(TAB_1 "for (size_t i = {0}; i < *params->p{1}; i++) {{\n",
                     Range->first, Range->second);
       OS << TAB_2 "if (i > 0) {\n";
       OS << TAB_3 " os << \", \";\n";
