[Offload][NFC] Use tablegen names rather than name parameter for API (#154736)

Author: RossBrunton

offload/liboffload/API/APIDefs.td

@@ -145,7 +145,6 @@ defvar DefaultReturns = [Return<PREFIX#"_RESULT_SUCCESS">,
                          Return<PREFIX#"_ERRC_DEVICE_LOST">];
 
 class APIObject {
-  string name;
   string desc;
 }
 

offload/liboffload/API/Common.td

@@ -10,77 +10,64 @@
 //
 //===----------------------------------------------------------------------===//
 
-def : Macro {
-  let name = "OL_VERSION_MAJOR";
+def OL_VERSION_MAJOR : Macro {
   let desc = "Major version of the Offload API";
   let value = "0";
 }
 
-def : Macro {
-  let name = "OL_VERSION_MINOR";
+def OL_VERSION_MINOR : Macro {
   let desc = "Minor version of the Offload API";
   let value = "0";
 }
 
-def : Macro {
-  let name = "OL_VERSION_PATCH";
+def OL_VERSION_PATCH : Macro {
   let desc = "Patch version of the Offload API";
   let value = "1";
 }
 
-def : Macro {
-  let name = "OL_APICALL";
+def OL_APICALL : Macro {
   let desc = "Calling convention for all API functions";
   let condition = "defined(_WIN32)";
   let value = "__cdecl";
   let alt_value = "";
 }
 
-def : Macro {
-  let name = "OL_APIEXPORT";
+def OL_APIEXPORT : Macro {
   let desc = "Microsoft-specific dllexport storage-class attribute";
   let condition = "defined(_WIN32)";
   let value = "__declspec(dllexport)";
   let alt_value = "";
 }
 
-def : Handle {
-  let name = "ol_platform_handle_t";
+def ol_platform_handle_t : Handle {
   let desc = "Handle of a platform instance";
 }
 
-def : Handle {
-  let name = "ol_device_handle_t";
+def ol_device_handle_t : Handle {
   let desc = "Handle of platform's device object";
 }
 
-def : Handle {
-  let name = "ol_context_handle_t";
+def ol_context_handle_t : Handle {
   let desc = "Handle of context object";
 }
 
-def : Handle {
-  let name = "ol_queue_handle_t";
+def ol_queue_handle_t : Handle {
   let desc = "Handle of queue object";
 }
 
-def : Handle {
-  let name = "ol_event_handle_t";
+def ol_event_handle_t : Handle {
   let desc = "Handle of event object";
 }
 
-def : Handle {
-  let name = "ol_program_handle_t";
+def ol_program_handle_t : Handle {
   let desc = "Handle of program object";
 }
 
-def : Handle {
-  let name = "ol_symbol_handle_t";
+def ol_symbol_handle_t : Handle {
   let desc = "Handle of an object in a device's memory for a specific program";
 }
 
-def ErrorCode : Enum {
-  let name = "ol_errc_t";
+def ol_errc_t : Enum {
   let desc = "Defines Return/Error codes";
   let etors =[
     Etor<"SUCCESS", "success">,
@@ -115,29 +102,25 @@ def ErrorCode : Enum {
   ];
 }
 
-def : Struct {
-  let name = "ol_error_struct_t";
+def ol_error_struct_t : Struct {
   let desc = "Details of the error condition returned by an API call";
   let members = [
     StructMember<"ol_errc_t", "Code", "The error code">,
     StructMember<"const char*", "Details", "String containing error details">
   ];
 }
 
-def : Typedef {
-  let name = "ol_result_t";
+def ol_result_t : Typedef {
   let desc = "Result type returned by all entry points.";
   let value = "const struct ol_error_struct_t*";
 }
 
-def : Macro {
-  let name = "OL_SUCCESS";
+def OL_SUCCESS : Macro {
   let desc = "Success condition";
   let value = "NULL";
 }
 
-def : Struct {
-  let name = "ol_code_location_t";
+def ol_code_location_t : Struct {
   let desc = "Code location information that can optionally be associated with an API call";
   let members = [
     StructMember<"const char*", "FunctionName", "Function name">,
@@ -147,8 +130,7 @@ def : Struct {
   ];
 }
 
-def : Struct {
-  let name = "ol_dimensions_t";
+def ol_dimensions_t : Struct {
   let desc = "A three element vector";
   let members = [
     StructMember<"uint32_t", "x", "X">,
@@ -157,8 +139,7 @@ def : Struct {
   ];
 }
 
-def : Function {
-  let name = "olInit";
+def olInit : Function {
   let desc = "Perform initialization of the Offload library and plugins";
   let details = [
     "This must be the first API call made by a user of the Offload library",
@@ -168,8 +149,7 @@ def : Function {
   let returns = [];
 }
 
-def : Function {
-  let name = "olShutDown";
+def olShutDown : Function {
   let desc = "Release the resources in use by Offload";
   let details = [
     "This decrements an internal reference count. When this reaches 0, all resources will be released",

offload/liboffload/API/Device.td

@@ -10,8 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-def : Enum {
-  let name = "ol_device_type_t";
+def ol_device_type_t : Enum {
   let desc = "Supported device types.";
   let etors =[
     Etor<"DEFAULT", "The default device type as preferred by the runtime">,
@@ -22,8 +21,7 @@ def : Enum {
   ];
 }
 
-def DeviceInfo : Enum {
-  let name = "ol_device_info_t";
+def ol_device_info_t : Enum {
   let desc = "Supported device info.";
   let is_typed = 1;
   list<TaggedEtor> basic_etors =[
@@ -47,8 +45,7 @@ def DeviceInfo : Enum {
   let etors = !listconcat(basic_etors, fp_configs, native_vec_widths);
 }
 
-def : Enum {
-  let name = "ol_device_fp_capability_flag_t";
+def ol_device_fp_capability_flag_t : Enum {
   let desc = "Device floating-point capability flags";
   let is_bit_field = 1;
   let etors =[
@@ -63,14 +60,12 @@ def : Enum {
   ];
 }
 
-def : Typedef {
-  let name = "ol_device_fp_capability_flags_t";
+def ol_device_fp_capability_flags_t : Typedef {
   let desc = "Device floating-point capability flags";
   let value = "uint32_t";
 }
 
-def : FptrTypedef {
-  let name = "ol_device_iterate_cb_t";
+def ol_device_iterate_cb_t : FptrTypedef {
   let desc = "User-provided function to be used with `olIterateDevices`";
   let params = [
     Param<"ol_device_handle_t", "Device", "the device handle of the current iteration", PARAM_IN>,
@@ -79,8 +74,7 @@ def : FptrTypedef {
   let return = "bool";
 }
 
-def : Function {
-  let name = "olIterateDevices";
+def olIterateDevices : Function {
   let desc = "Iterates over all available devices, calling the callback for each device.";
   let details = [
     "If the user-provided callback returns `false`, the iteration is stopped."
@@ -94,8 +88,7 @@ def : Function {
   ];
 }
 
-def : Function {
-  let name = "olGetDeviceInfo";
+def olGetDeviceInfo : Function {
   let desc = "Queries the given property of the device.";
   let details = [];
   let params = [
@@ -118,8 +111,7 @@ def : Function {
   ];
 }
 
-def : Function {
-  let name = "olGetDeviceInfoSize";
+def olGetDeviceInfoSize : Function {
   let desc = "Returns the storage size of the given device query.";
   let details = [];
   let params = [

offload/liboffload/API/Event.td

@@ -10,8 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-def : Function {
-    let name = "olCreateEvent";
+def olCreateEvent : Function {
     let desc = "Enqueue an event to `Queue` and return it.";
     let details = [
       "This event can be used with `olSyncEvent` and `olWaitEvents` and will be complete once all enqueued work prior to the `olCreateEvent` call is complete.",
@@ -23,8 +22,7 @@ def : Function {
     let returns = [];
 }
 
-def : Function {
-    let name = "olDestroyEvent";
+def olDestroyEvent : Function {
     let desc = "Destroy the event and free all underlying resources.";
     let details = [];
     let params = [
@@ -33,8 +31,7 @@ def : Function {
     let returns = [];
 }
 
-def : Function {
-    let name = "olSyncEvent";
+def olSyncEvent : Function {
     let desc = "Block the calling thread until the event is complete.";
     let details = [];
     let params = [
@@ -43,17 +40,15 @@ def : Function {
     let returns = [];
 }
 
-def : Enum {
-  let name = "ol_event_info_t";
+def ol_event_info_t : Enum {
   let desc = "Supported event info.";
   let is_typed = 1;
   let etors = [
     TaggedEtor<"QUEUE", "ol_queue_handle_t", "The handle of the queue associated with the device.">
   ];
 }
 
-def : Function {
-  let name = "olGetEventInfo";
+def olGetEventInfo : Function {
   let desc = "Queries the given property of the event.";
   let details = [
     "`olGetEventInfoSize` can be used to query the storage size "
@@ -77,8 +72,7 @@ def : Function {
   ];
 }
 
-def : Function {
-  let name = "olGetEventInfoSize";
+def olGetEventInfoSize : Function {
   let desc = "Returns the storage size of the given event query.";
   let details = [];
   let params = [

offload/liboffload/API/Kernel.td

@@ -10,8 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-def : Struct {
-    let name = "ol_kernel_launch_size_args_t";
+def ol_kernel_launch_size_args_t : Struct {
     let desc = "Size-related arguments for a kernel launch.";
     let members = [
         StructMember<"size_t", "Dimensions", "Number of work dimensions">,
@@ -21,8 +20,7 @@ def : Struct {
     ];
 }
 
-def : Function {
-    let name = "olLaunchKernel";
+def olLaunchKernel : Function {
     let desc = "Enqueue a kernel launch with the specified size and parameters.";
     let details = [
         "If a queue is not specified, kernel execution happens synchronously",
@@ -43,8 +41,7 @@ def : Function {
     ];
 }
 
-def : Function {
-    let name = "olCalculateOptimalOccupancy";
+def olCalculateOptimalOccupancy : Function {
     let desc = "Given dynamic memory size, query the device for a workgroup size that will result in optimal occupancy.";
     let details = [
         "For most devices, this will be the largest workgroup size that will result in all work items fitting on the device at once.",

offload/liboffload/API/Memory.td

@@ -10,8 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-def : Enum {
-  let name = "ol_alloc_type_t";
+def ol_alloc_type_t : Enum {
   let desc = "Represents the type of allocation made with olMemAlloc.";
   let etors = [
     Etor<"HOST", "Host allocation">,
@@ -20,8 +19,7 @@ def : Enum {
   ];
 }
 
-def : Function {
-  let name = "olMemAlloc";
+def olMemAlloc : Function {
   let desc = "Creates a memory allocation on the specified device.";
   let params = [
     Param<"ol_device_handle_t", "Device", "handle of the device to allocate on", PARAM_IN>,
@@ -36,17 +34,15 @@ def : Function {
   ];
 }
 
-def : Function {
-  let name = "olMemFree";
+def olMemFree : Function {
   let desc = "Frees a memory allocation previously made by olMemAlloc.";
   let params = [
     Param<"void*", "Address", "address of the allocation to free", PARAM_IN>,
   ];
   let returns = [];
 }
 
-def : Function {
-    let name = "olMemcpy";
+def olMemcpy : Function {
     let desc = "Enqueue a memcpy operation.";
     let details = [
         "For host pointers, use the host device belonging to the OL_PLATFORM_BACKEND_HOST platform.",