Add support for rocblas to zluda_bindgen (#440)

One step of several for adding cublas support

.github/workflows/pr_master.yml

@@ -91,7 +91,7 @@ jobs:
         tool: cargo-export
     - name: Build
       run: |
-        cargo export target/tests -- test --features ci_build --workspace --exclude cuda_macros --exclude ptx_parser_macros
+        cargo export target/tests -- test --features ci_build --workspace --exclude cuda_macros --exclude ptx_parser_macros --exclude rocblas-sys
         mkdir -p target/amdgpu
         bash .github/workflows/move_tests.sh target/tests amdgpu
         strip target/amdgpu/*

Cargo.lock

@@ -1204,6 +1204,13 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "rocblas-sys"
+version = "0.1.0"
+dependencies = [
+ "hip_runtime-sys",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"

Cargo.toml

@@ -10,6 +10,7 @@ members = [
     "detours-sys",
     "ext/amd_comgr-sys",
     "ext/hip_runtime-sys",
+    "ext/rocblas-sys",
     "format",
     "ptx",
     "ptx_parser",

cuda_types/src/cuda.rs

@@ -8454,301 +8454,301 @@ pub type cuFloatComplex = float2;
 pub type cuDoubleComplex = double2;
 pub type cuComplex = cuFloatComplex;
 impl CUerror {
-    pub const INVALID_VALUE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_VALUE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(1)
     });
-    pub const OUT_OF_MEMORY: CUerror = CUerror(unsafe {
+    pub const r#OUT_OF_MEMORY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(2)
     });
-    pub const NOT_INITIALIZED: CUerror = CUerror(unsafe {
+    pub const r#NOT_INITIALIZED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(3)
     });
-    pub const DEINITIALIZED: CUerror = CUerror(unsafe {
+    pub const r#DEINITIALIZED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(4)
     });
-    pub const PROFILER_DISABLED: CUerror = CUerror(unsafe {
+    pub const r#PROFILER_DISABLED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(5)
     });
-    pub const PROFILER_NOT_INITIALIZED: CUerror = CUerror(unsafe {
+    pub const r#PROFILER_NOT_INITIALIZED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(6)
     });
-    pub const PROFILER_ALREADY_STARTED: CUerror = CUerror(unsafe {
+    pub const r#PROFILER_ALREADY_STARTED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(7)
     });
-    pub const PROFILER_ALREADY_STOPPED: CUerror = CUerror(unsafe {
+    pub const r#PROFILER_ALREADY_STOPPED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(8)
     });
-    pub const STUB_LIBRARY: CUerror = CUerror(unsafe {
+    pub const r#STUB_LIBRARY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(34)
     });
-    pub const DEVICE_UNAVAILABLE: CUerror = CUerror(unsafe {
+    pub const r#DEVICE_UNAVAILABLE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(46)
     });
-    pub const NO_DEVICE: CUerror = CUerror(unsafe {
+    pub const r#NO_DEVICE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(100)
     });
-    pub const INVALID_DEVICE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_DEVICE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(101)
     });
-    pub const DEVICE_NOT_LICENSED: CUerror = CUerror(unsafe {
+    pub const r#DEVICE_NOT_LICENSED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(102)
     });
-    pub const INVALID_IMAGE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_IMAGE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(200)
     });
-    pub const INVALID_CONTEXT: CUerror = CUerror(unsafe {
+    pub const r#INVALID_CONTEXT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(201)
     });
-    pub const CONTEXT_ALREADY_CURRENT: CUerror = CUerror(unsafe {
+    pub const r#CONTEXT_ALREADY_CURRENT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(202)
     });
-    pub const MAP_FAILED: CUerror = CUerror(unsafe {
+    pub const r#MAP_FAILED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(205)
     });
-    pub const UNMAP_FAILED: CUerror = CUerror(unsafe {
+    pub const r#UNMAP_FAILED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(206)
     });
-    pub const ARRAY_IS_MAPPED: CUerror = CUerror(unsafe {
+    pub const r#ARRAY_IS_MAPPED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(207)
     });
-    pub const ALREADY_MAPPED: CUerror = CUerror(unsafe {
+    pub const r#ALREADY_MAPPED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(208)
     });
-    pub const NO_BINARY_FOR_GPU: CUerror = CUerror(unsafe {
+    pub const r#NO_BINARY_FOR_GPU: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(209)
     });
-    pub const ALREADY_ACQUIRED: CUerror = CUerror(unsafe {
+    pub const r#ALREADY_ACQUIRED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(210)
     });
-    pub const NOT_MAPPED: CUerror = CUerror(unsafe {
+    pub const r#NOT_MAPPED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(211)
     });
-    pub const NOT_MAPPED_AS_ARRAY: CUerror = CUerror(unsafe {
+    pub const r#NOT_MAPPED_AS_ARRAY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(212)
     });
-    pub const NOT_MAPPED_AS_POINTER: CUerror = CUerror(unsafe {
+    pub const r#NOT_MAPPED_AS_POINTER: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(213)
     });
-    pub const ECC_UNCORRECTABLE: CUerror = CUerror(unsafe {
+    pub const r#ECC_UNCORRECTABLE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(214)
     });
-    pub const UNSUPPORTED_LIMIT: CUerror = CUerror(unsafe {
+    pub const r#UNSUPPORTED_LIMIT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(215)
     });
-    pub const CONTEXT_ALREADY_IN_USE: CUerror = CUerror(unsafe {
+    pub const r#CONTEXT_ALREADY_IN_USE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(216)
     });
-    pub const PEER_ACCESS_UNSUPPORTED: CUerror = CUerror(unsafe {
+    pub const r#PEER_ACCESS_UNSUPPORTED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(217)
     });
-    pub const INVALID_PTX: CUerror = CUerror(unsafe {
+    pub const r#INVALID_PTX: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(218)
     });
-    pub const INVALID_GRAPHICS_CONTEXT: CUerror = CUerror(unsafe {
+    pub const r#INVALID_GRAPHICS_CONTEXT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(219)
     });
-    pub const NVLINK_UNCORRECTABLE: CUerror = CUerror(unsafe {
+    pub const r#NVLINK_UNCORRECTABLE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(220)
     });
-    pub const JIT_COMPILER_NOT_FOUND: CUerror = CUerror(unsafe {
+    pub const r#JIT_COMPILER_NOT_FOUND: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(221)
     });
-    pub const UNSUPPORTED_PTX_VERSION: CUerror = CUerror(unsafe {
+    pub const r#UNSUPPORTED_PTX_VERSION: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(222)
     });
-    pub const JIT_COMPILATION_DISABLED: CUerror = CUerror(unsafe {
+    pub const r#JIT_COMPILATION_DISABLED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(223)
     });
-    pub const UNSUPPORTED_EXEC_AFFINITY: CUerror = CUerror(unsafe {
+    pub const r#UNSUPPORTED_EXEC_AFFINITY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(224)
     });
-    pub const UNSUPPORTED_DEVSIDE_SYNC: CUerror = CUerror(unsafe {
+    pub const r#UNSUPPORTED_DEVSIDE_SYNC: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(225)
     });
-    pub const CONTAINED: CUerror = CUerror(unsafe {
+    pub const r#CONTAINED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(226)
     });
-    pub const INVALID_SOURCE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_SOURCE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(300)
     });
-    pub const FILE_NOT_FOUND: CUerror = CUerror(unsafe {
+    pub const r#FILE_NOT_FOUND: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(301)
     });
-    pub const SHARED_OBJECT_SYMBOL_NOT_FOUND: CUerror = CUerror(unsafe {
+    pub const r#SHARED_OBJECT_SYMBOL_NOT_FOUND: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(302)
     });
-    pub const SHARED_OBJECT_INIT_FAILED: CUerror = CUerror(unsafe {
+    pub const r#SHARED_OBJECT_INIT_FAILED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(303)
     });
-    pub const OPERATING_SYSTEM: CUerror = CUerror(unsafe {
+    pub const r#OPERATING_SYSTEM: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(304)
     });
-    pub const INVALID_HANDLE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_HANDLE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(400)
     });
-    pub const ILLEGAL_STATE: CUerror = CUerror(unsafe {
+    pub const r#ILLEGAL_STATE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(401)
     });
-    pub const LOSSY_QUERY: CUerror = CUerror(unsafe {
+    pub const r#LOSSY_QUERY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(402)
     });
-    pub const NOT_FOUND: CUerror = CUerror(unsafe {
+    pub const r#NOT_FOUND: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(500)
     });
-    pub const NOT_READY: CUerror = CUerror(unsafe {
+    pub const r#NOT_READY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(600)
     });
-    pub const ILLEGAL_ADDRESS: CUerror = CUerror(unsafe {
+    pub const r#ILLEGAL_ADDRESS: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(700)
     });
-    pub const LAUNCH_OUT_OF_RESOURCES: CUerror = CUerror(unsafe {
+    pub const r#LAUNCH_OUT_OF_RESOURCES: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(701)
     });
-    pub const LAUNCH_TIMEOUT: CUerror = CUerror(unsafe {
+    pub const r#LAUNCH_TIMEOUT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(702)
     });
-    pub const LAUNCH_INCOMPATIBLE_TEXTURING: CUerror = CUerror(unsafe {
+    pub const r#LAUNCH_INCOMPATIBLE_TEXTURING: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(703)
     });
-    pub const PEER_ACCESS_ALREADY_ENABLED: CUerror = CUerror(unsafe {
+    pub const r#PEER_ACCESS_ALREADY_ENABLED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(704)
     });
-    pub const PEER_ACCESS_NOT_ENABLED: CUerror = CUerror(unsafe {
+    pub const r#PEER_ACCESS_NOT_ENABLED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(705)
     });
-    pub const PRIMARY_CONTEXT_ACTIVE: CUerror = CUerror(unsafe {
+    pub const r#PRIMARY_CONTEXT_ACTIVE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(708)
     });
-    pub const CONTEXT_IS_DESTROYED: CUerror = CUerror(unsafe {
+    pub const r#CONTEXT_IS_DESTROYED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(709)
     });
-    pub const ASSERT: CUerror = CUerror(unsafe {
+    pub const r#ASSERT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(710)
     });
-    pub const TOO_MANY_PEERS: CUerror = CUerror(unsafe {
+    pub const r#TOO_MANY_PEERS: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(711)
     });
-    pub const HOST_MEMORY_ALREADY_REGISTERED: CUerror = CUerror(unsafe {
+    pub const r#HOST_MEMORY_ALREADY_REGISTERED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(712)
     });
-    pub const HOST_MEMORY_NOT_REGISTERED: CUerror = CUerror(unsafe {
+    pub const r#HOST_MEMORY_NOT_REGISTERED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(713)
     });
-    pub const HARDWARE_STACK_ERROR: CUerror = CUerror(unsafe {
+    pub const r#HARDWARE_STACK_ERROR: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(714)
     });
-    pub const ILLEGAL_INSTRUCTION: CUerror = CUerror(unsafe {
+    pub const r#ILLEGAL_INSTRUCTION: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(715)
     });
-    pub const MISALIGNED_ADDRESS: CUerror = CUerror(unsafe {
+    pub const r#MISALIGNED_ADDRESS: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(716)
     });
-    pub const INVALID_ADDRESS_SPACE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_ADDRESS_SPACE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(717)
     });
-    pub const INVALID_PC: CUerror = CUerror(unsafe {
+    pub const r#INVALID_PC: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(718)
     });
-    pub const LAUNCH_FAILED: CUerror = CUerror(unsafe {
+    pub const r#LAUNCH_FAILED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(719)
     });
-    pub const COOPERATIVE_LAUNCH_TOO_LARGE: CUerror = CUerror(unsafe {
+    pub const r#COOPERATIVE_LAUNCH_TOO_LARGE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(720)
     });
-    pub const TENSOR_MEMORY_LEAK: CUerror = CUerror(unsafe {
+    pub const r#TENSOR_MEMORY_LEAK: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(721)
     });
-    pub const NOT_PERMITTED: CUerror = CUerror(unsafe {
+    pub const r#NOT_PERMITTED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(800)
     });
-    pub const NOT_SUPPORTED: CUerror = CUerror(unsafe {
+    pub const r#NOT_SUPPORTED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(801)
     });
-    pub const SYSTEM_NOT_READY: CUerror = CUerror(unsafe {
+    pub const r#SYSTEM_NOT_READY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(802)
     });
-    pub const SYSTEM_DRIVER_MISMATCH: CUerror = CUerror(unsafe {
+    pub const r#SYSTEM_DRIVER_MISMATCH: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(803)
     });
-    pub const COMPAT_NOT_SUPPORTED_ON_DEVICE: CUerror = CUerror(unsafe {
+    pub const r#COMPAT_NOT_SUPPORTED_ON_DEVICE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(804)
     });
-    pub const MPS_CONNECTION_FAILED: CUerror = CUerror(unsafe {
+    pub const r#MPS_CONNECTION_FAILED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(805)
     });
-    pub const MPS_RPC_FAILURE: CUerror = CUerror(unsafe {
+    pub const r#MPS_RPC_FAILURE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(806)
     });
-    pub const MPS_SERVER_NOT_READY: CUerror = CUerror(unsafe {
+    pub const r#MPS_SERVER_NOT_READY: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(807)
     });
-    pub const MPS_MAX_CLIENTS_REACHED: CUerror = CUerror(unsafe {
+    pub const r#MPS_MAX_CLIENTS_REACHED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(808)
     });
-    pub const MPS_MAX_CONNECTIONS_REACHED: CUerror = CUerror(unsafe {
+    pub const r#MPS_MAX_CONNECTIONS_REACHED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(809)
     });
-    pub const MPS_CLIENT_TERMINATED: CUerror = CUerror(unsafe {
+    pub const r#MPS_CLIENT_TERMINATED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(810)
     });
-    pub const CDP_NOT_SUPPORTED: CUerror = CUerror(unsafe {
+    pub const r#CDP_NOT_SUPPORTED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(811)
     });
-    pub const CDP_VERSION_MISMATCH: CUerror = CUerror(unsafe {
+    pub const r#CDP_VERSION_MISMATCH: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(812)
     });
-    pub const STREAM_CAPTURE_UNSUPPORTED: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_UNSUPPORTED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(900)
     });
-    pub const STREAM_CAPTURE_INVALIDATED: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_INVALIDATED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(901)
     });
-    pub const STREAM_CAPTURE_MERGE: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_MERGE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(902)
     });
-    pub const STREAM_CAPTURE_UNMATCHED: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_UNMATCHED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(903)
     });
-    pub const STREAM_CAPTURE_UNJOINED: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_UNJOINED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(904)
     });
-    pub const STREAM_CAPTURE_ISOLATION: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_ISOLATION: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(905)
     });
-    pub const STREAM_CAPTURE_IMPLICIT: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_IMPLICIT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(906)
     });
-    pub const CAPTURED_EVENT: CUerror = CUerror(unsafe {
+    pub const r#CAPTURED_EVENT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(907)
     });
-    pub const STREAM_CAPTURE_WRONG_THREAD: CUerror = CUerror(unsafe {
+    pub const r#STREAM_CAPTURE_WRONG_THREAD: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(908)
     });
-    pub const TIMEOUT: CUerror = CUerror(unsafe {
+    pub const r#TIMEOUT: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(909)
     });
-    pub const GRAPH_EXEC_UPDATE_FAILURE: CUerror = CUerror(unsafe {
+    pub const r#GRAPH_EXEC_UPDATE_FAILURE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(910)
     });
-    pub const EXTERNAL_DEVICE: CUerror = CUerror(unsafe {
+    pub const r#EXTERNAL_DEVICE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(911)
     });
-    pub const INVALID_CLUSTER_SIZE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_CLUSTER_SIZE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(912)
     });
-    pub const FUNCTION_NOT_LOADED: CUerror = CUerror(unsafe {
+    pub const r#FUNCTION_NOT_LOADED: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(913)
     });
-    pub const INVALID_RESOURCE_TYPE: CUerror = CUerror(unsafe {
+    pub const r#INVALID_RESOURCE_TYPE: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(914)
     });
-    pub const INVALID_RESOURCE_CONFIGURATION: CUerror = CUerror(unsafe {
+    pub const r#INVALID_RESOURCE_CONFIGURATION: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(915)
     });
-    pub const KEY_ROTATION: CUerror = CUerror(unsafe {
+    pub const r#KEY_ROTATION: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(916)
     });
-    pub const UNKNOWN: CUerror = CUerror(unsafe {
+    pub const r#UNKNOWN: CUerror = CUerror(unsafe {
         ::core::num::NonZeroU32::new_unchecked(999)
     });
 }
@@ -8757,213 +8757,223 @@ impl CUerror {
 pub struct CUerror(pub ::core::num::NonZeroU32);
 pub trait CUresultConsts {
     const SUCCESS: CUresult = CUresult::Ok(());
-    const ERROR_INVALID_VALUE: CUresult = CUresult::Err(CUerror::INVALID_VALUE);
+    const ERROR_INVALID_VALUE: CUresult = CUresult::Err(CUerror::r#INVALID_VALUE);
-    const ERROR_OUT_OF_MEMORY: CUresult = CUresult::Err(CUerror::OUT_OF_MEMORY);
+    const ERROR_OUT_OF_MEMORY: CUresult = CUresult::Err(CUerror::r#OUT_OF_MEMORY);
-    const ERROR_NOT_INITIALIZED: CUresult = CUresult::Err(CUerror::NOT_INITIALIZED);
+    const ERROR_NOT_INITIALIZED: CUresult = CUresult::Err(CUerror::r#NOT_INITIALIZED);
-    const ERROR_DEINITIALIZED: CUresult = CUresult::Err(CUerror::DEINITIALIZED);
+    const ERROR_DEINITIALIZED: CUresult = CUresult::Err(CUerror::r#DEINITIALIZED);
-    const ERROR_PROFILER_DISABLED: CUresult = CUresult::Err(CUerror::PROFILER_DISABLED);
+    const ERROR_PROFILER_DISABLED: CUresult = CUresult::Err(
+        CUerror::r#PROFILER_DISABLED,
+    );
     const ERROR_PROFILER_NOT_INITIALIZED: CUresult = CUresult::Err(
-        CUerror::PROFILER_NOT_INITIALIZED,
+        CUerror::r#PROFILER_NOT_INITIALIZED,
     );
     const ERROR_PROFILER_ALREADY_STARTED: CUresult = CUresult::Err(
-        CUerror::PROFILER_ALREADY_STARTED,
+        CUerror::r#PROFILER_ALREADY_STARTED,
     );
     const ERROR_PROFILER_ALREADY_STOPPED: CUresult = CUresult::Err(
-        CUerror::PROFILER_ALREADY_STOPPED,
+        CUerror::r#PROFILER_ALREADY_STOPPED,
     );
-    const ERROR_STUB_LIBRARY: CUresult = CUresult::Err(CUerror::STUB_LIBRARY);
+    const ERROR_STUB_LIBRARY: CUresult = CUresult::Err(CUerror::r#STUB_LIBRARY);
     const ERROR_DEVICE_UNAVAILABLE: CUresult = CUresult::Err(
-        CUerror::DEVICE_UNAVAILABLE,
+        CUerror::r#DEVICE_UNAVAILABLE,
     );
-    const ERROR_NO_DEVICE: CUresult = CUresult::Err(CUerror::NO_DEVICE);
+    const ERROR_NO_DEVICE: CUresult = CUresult::Err(CUerror::r#NO_DEVICE);
-    const ERROR_INVALID_DEVICE: CUresult = CUresult::Err(CUerror::INVALID_DEVICE);
+    const ERROR_INVALID_DEVICE: CUresult = CUresult::Err(CUerror::r#INVALID_DEVICE);
     const ERROR_DEVICE_NOT_LICENSED: CUresult = CUresult::Err(
-        CUerror::DEVICE_NOT_LICENSED,
+        CUerror::r#DEVICE_NOT_LICENSED,
     );
-    const ERROR_INVALID_IMAGE: CUresult = CUresult::Err(CUerror::INVALID_IMAGE);
+    const ERROR_INVALID_IMAGE: CUresult = CUresult::Err(CUerror::r#INVALID_IMAGE);
-    const ERROR_INVALID_CONTEXT: CUresult = CUresult::Err(CUerror::INVALID_CONTEXT);
+    const ERROR_INVALID_CONTEXT: CUresult = CUresult::Err(CUerror::r#INVALID_CONTEXT);
     const ERROR_CONTEXT_ALREADY_CURRENT: CUresult = CUresult::Err(
-        CUerror::CONTEXT_ALREADY_CURRENT,
+        CUerror::r#CONTEXT_ALREADY_CURRENT,
     );
-    const ERROR_MAP_FAILED: CUresult = CUresult::Err(CUerror::MAP_FAILED);
+    const ERROR_MAP_FAILED: CUresult = CUresult::Err(CUerror::r#MAP_FAILED);
-    const ERROR_UNMAP_FAILED: CUresult = CUresult::Err(CUerror::UNMAP_FAILED);
+    const ERROR_UNMAP_FAILED: CUresult = CUresult::Err(CUerror::r#UNMAP_FAILED);
-    const ERROR_ARRAY_IS_MAPPED: CUresult = CUresult::Err(CUerror::ARRAY_IS_MAPPED);
+    const ERROR_ARRAY_IS_MAPPED: CUresult = CUresult::Err(CUerror::r#ARRAY_IS_MAPPED);
-    const ERROR_ALREADY_MAPPED: CUresult = CUresult::Err(CUerror::ALREADY_MAPPED);
+    const ERROR_ALREADY_MAPPED: CUresult = CUresult::Err(CUerror::r#ALREADY_MAPPED);
-    const ERROR_NO_BINARY_FOR_GPU: CUresult = CUresult::Err(CUerror::NO_BINARY_FOR_GPU);
+    const ERROR_NO_BINARY_FOR_GPU: CUresult = CUresult::Err(
-    const ERROR_ALREADY_ACQUIRED: CUresult = CUresult::Err(CUerror::ALREADY_ACQUIRED);
+        CUerror::r#NO_BINARY_FOR_GPU,
-    const ERROR_NOT_MAPPED: CUresult = CUresult::Err(CUerror::NOT_MAPPED);
+    );
+    const ERROR_ALREADY_ACQUIRED: CUresult = CUresult::Err(CUerror::r#ALREADY_ACQUIRED);
+    const ERROR_NOT_MAPPED: CUresult = CUresult::Err(CUerror::r#NOT_MAPPED);
     const ERROR_NOT_MAPPED_AS_ARRAY: CUresult = CUresult::Err(
-        CUerror::NOT_MAPPED_AS_ARRAY,
+        CUerror::r#NOT_MAPPED_AS_ARRAY,
     );
     const ERROR_NOT_MAPPED_AS_POINTER: CUresult = CUresult::Err(
-        CUerror::NOT_MAPPED_AS_POINTER,
+        CUerror::r#NOT_MAPPED_AS_POINTER,
+    );
+    const ERROR_ECC_UNCORRECTABLE: CUresult = CUresult::Err(
+        CUerror::r#ECC_UNCORRECTABLE,
+    );
+    const ERROR_UNSUPPORTED_LIMIT: CUresult = CUresult::Err(
+        CUerror::r#UNSUPPORTED_LIMIT,
     );
-    const ERROR_ECC_UNCORRECTABLE: CUresult = CUresult::Err(CUerror::ECC_UNCORRECTABLE);
-    const ERROR_UNSUPPORTED_LIMIT: CUresult = CUresult::Err(CUerror::UNSUPPORTED_LIMIT);
     const ERROR_CONTEXT_ALREADY_IN_USE: CUresult = CUresult::Err(
-        CUerror::CONTEXT_ALREADY_IN_USE,
+        CUerror::r#CONTEXT_ALREADY_IN_USE,
     );
     const ERROR_PEER_ACCESS_UNSUPPORTED: CUresult = CUresult::Err(
-        CUerror::PEER_ACCESS_UNSUPPORTED,
+        CUerror::r#PEER_ACCESS_UNSUPPORTED,
     );
-    const ERROR_INVALID_PTX: CUresult = CUresult::Err(CUerror::INVALID_PTX);
+    const ERROR_INVALID_PTX: CUresult = CUresult::Err(CUerror::r#INVALID_PTX);
     const ERROR_INVALID_GRAPHICS_CONTEXT: CUresult = CUresult::Err(
-        CUerror::INVALID_GRAPHICS_CONTEXT,
+        CUerror::r#INVALID_GRAPHICS_CONTEXT,
     );
     const ERROR_NVLINK_UNCORRECTABLE: CUresult = CUresult::Err(
-        CUerror::NVLINK_UNCORRECTABLE,
+        CUerror::r#NVLINK_UNCORRECTABLE,
     );
     const ERROR_JIT_COMPILER_NOT_FOUND: CUresult = CUresult::Err(
-        CUerror::JIT_COMPILER_NOT_FOUND,
+        CUerror::r#JIT_COMPILER_NOT_FOUND,
     );
     const ERROR_UNSUPPORTED_PTX_VERSION: CUresult = CUresult::Err(
-        CUerror::UNSUPPORTED_PTX_VERSION,
+        CUerror::r#UNSUPPORTED_PTX_VERSION,
     );
     const ERROR_JIT_COMPILATION_DISABLED: CUresult = CUresult::Err(
-        CUerror::JIT_COMPILATION_DISABLED,
+        CUerror::r#JIT_COMPILATION_DISABLED,
     );
     const ERROR_UNSUPPORTED_EXEC_AFFINITY: CUresult = CUresult::Err(
-        CUerror::UNSUPPORTED_EXEC_AFFINITY,
+        CUerror::r#UNSUPPORTED_EXEC_AFFINITY,
     );
     const ERROR_UNSUPPORTED_DEVSIDE_SYNC: CUresult = CUresult::Err(
-        CUerror::UNSUPPORTED_DEVSIDE_SYNC,
+        CUerror::r#UNSUPPORTED_DEVSIDE_SYNC,
     );
-    const ERROR_CONTAINED: CUresult = CUresult::Err(CUerror::CONTAINED);
+    const ERROR_CONTAINED: CUresult = CUresult::Err(CUerror::r#CONTAINED);
-    const ERROR_INVALID_SOURCE: CUresult = CUresult::Err(CUerror::INVALID_SOURCE);
+    const ERROR_INVALID_SOURCE: CUresult = CUresult::Err(CUerror::r#INVALID_SOURCE);
-    const ERROR_FILE_NOT_FOUND: CUresult = CUresult::Err(CUerror::FILE_NOT_FOUND);
+    const ERROR_FILE_NOT_FOUND: CUresult = CUresult::Err(CUerror::r#FILE_NOT_FOUND);
     const ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND: CUresult = CUresult::Err(
-        CUerror::SHARED_OBJECT_SYMBOL_NOT_FOUND,
+        CUerror::r#SHARED_OBJECT_SYMBOL_NOT_FOUND,
     );
     const ERROR_SHARED_OBJECT_INIT_FAILED: CUresult = CUresult::Err(
-        CUerror::SHARED_OBJECT_INIT_FAILED,
+        CUerror::r#SHARED_OBJECT_INIT_FAILED,
     );
-    const ERROR_OPERATING_SYSTEM: CUresult = CUresult::Err(CUerror::OPERATING_SYSTEM);
+    const ERROR_OPERATING_SYSTEM: CUresult = CUresult::Err(CUerror::r#OPERATING_SYSTEM);
-    const ERROR_INVALID_HANDLE: CUresult = CUresult::Err(CUerror::INVALID_HANDLE);
+    const ERROR_INVALID_HANDLE: CUresult = CUresult::Err(CUerror::r#INVALID_HANDLE);
-    const ERROR_ILLEGAL_STATE: CUresult = CUresult::Err(CUerror::ILLEGAL_STATE);
+    const ERROR_ILLEGAL_STATE: CUresult = CUresult::Err(CUerror::r#ILLEGAL_STATE);
-    const ERROR_LOSSY_QUERY: CUresult = CUresult::Err(CUerror::LOSSY_QUERY);
+    const ERROR_LOSSY_QUERY: CUresult = CUresult::Err(CUerror::r#LOSSY_QUERY);
-    const ERROR_NOT_FOUND: CUresult = CUresult::Err(CUerror::NOT_FOUND);
+    const ERROR_NOT_FOUND: CUresult = CUresult::Err(CUerror::r#NOT_FOUND);
-    const ERROR_NOT_READY: CUresult = CUresult::Err(CUerror::NOT_READY);
+    const ERROR_NOT_READY: CUresult = CUresult::Err(CUerror::r#NOT_READY);
-    const ERROR_ILLEGAL_ADDRESS: CUresult = CUresult::Err(CUerror::ILLEGAL_ADDRESS);
+    const ERROR_ILLEGAL_ADDRESS: CUresult = CUresult::Err(CUerror::r#ILLEGAL_ADDRESS);
     const ERROR_LAUNCH_OUT_OF_RESOURCES: CUresult = CUresult::Err(
-        CUerror::LAUNCH_OUT_OF_RESOURCES,
+        CUerror::r#LAUNCH_OUT_OF_RESOURCES,
     );
-    const ERROR_LAUNCH_TIMEOUT: CUresult = CUresult::Err(CUerror::LAUNCH_TIMEOUT);
+    const ERROR_LAUNCH_TIMEOUT: CUresult = CUresult::Err(CUerror::r#LAUNCH_TIMEOUT);
     const ERROR_LAUNCH_INCOMPATIBLE_TEXTURING: CUresult = CUresult::Err(
-        CUerror::LAUNCH_INCOMPATIBLE_TEXTURING,
+        CUerror::r#LAUNCH_INCOMPATIBLE_TEXTURING,
     );
     const ERROR_PEER_ACCESS_ALREADY_ENABLED: CUresult = CUresult::Err(
-        CUerror::PEER_ACCESS_ALREADY_ENABLED,
+        CUerror::r#PEER_ACCESS_ALREADY_ENABLED,
     );
     const ERROR_PEER_ACCESS_NOT_ENABLED: CUresult = CUresult::Err(
-        CUerror::PEER_ACCESS_NOT_ENABLED,
+        CUerror::r#PEER_ACCESS_NOT_ENABLED,
     );
     const ERROR_PRIMARY_CONTEXT_ACTIVE: CUresult = CUresult::Err(
-        CUerror::PRIMARY_CONTEXT_ACTIVE,
+        CUerror::r#PRIMARY_CONTEXT_ACTIVE,
     );
     const ERROR_CONTEXT_IS_DESTROYED: CUresult = CUresult::Err(
-        CUerror::CONTEXT_IS_DESTROYED,
+        CUerror::r#CONTEXT_IS_DESTROYED,
     );
-    const ERROR_ASSERT: CUresult = CUresult::Err(CUerror::ASSERT);
+    const ERROR_ASSERT: CUresult = CUresult::Err(CUerror::r#ASSERT);
-    const ERROR_TOO_MANY_PEERS: CUresult = CUresult::Err(CUerror::TOO_MANY_PEERS);
+    const ERROR_TOO_MANY_PEERS: CUresult = CUresult::Err(CUerror::r#TOO_MANY_PEERS);
     const ERROR_HOST_MEMORY_ALREADY_REGISTERED: CUresult = CUresult::Err(
-        CUerror::HOST_MEMORY_ALREADY_REGISTERED,
+        CUerror::r#HOST_MEMORY_ALREADY_REGISTERED,
     );
     const ERROR_HOST_MEMORY_NOT_REGISTERED: CUresult = CUresult::Err(
-        CUerror::HOST_MEMORY_NOT_REGISTERED,
+        CUerror::r#HOST_MEMORY_NOT_REGISTERED,
     );
     const ERROR_HARDWARE_STACK_ERROR: CUresult = CUresult::Err(
-        CUerror::HARDWARE_STACK_ERROR,
+        CUerror::r#HARDWARE_STACK_ERROR,
     );
     const ERROR_ILLEGAL_INSTRUCTION: CUresult = CUresult::Err(
-        CUerror::ILLEGAL_INSTRUCTION,
+        CUerror::r#ILLEGAL_INSTRUCTION,
     );
     const ERROR_MISALIGNED_ADDRESS: CUresult = CUresult::Err(
-        CUerror::MISALIGNED_ADDRESS,
+        CUerror::r#MISALIGNED_ADDRESS,
     );
     const ERROR_INVALID_ADDRESS_SPACE: CUresult = CUresult::Err(
-        CUerror::INVALID_ADDRESS_SPACE,
+        CUerror::r#INVALID_ADDRESS_SPACE,
     );
-    const ERROR_INVALID_PC: CUresult = CUresult::Err(CUerror::INVALID_PC);
+    const ERROR_INVALID_PC: CUresult = CUresult::Err(CUerror::r#INVALID_PC);
-    const ERROR_LAUNCH_FAILED: CUresult = CUresult::Err(CUerror::LAUNCH_FAILED);
+    const ERROR_LAUNCH_FAILED: CUresult = CUresult::Err(CUerror::r#LAUNCH_FAILED);
     const ERROR_COOPERATIVE_LAUNCH_TOO_LARGE: CUresult = CUresult::Err(
-        CUerror::COOPERATIVE_LAUNCH_TOO_LARGE,
+        CUerror::r#COOPERATIVE_LAUNCH_TOO_LARGE,
     );
     const ERROR_TENSOR_MEMORY_LEAK: CUresult = CUresult::Err(
-        CUerror::TENSOR_MEMORY_LEAK,
+        CUerror::r#TENSOR_MEMORY_LEAK,
     );
-    const ERROR_NOT_PERMITTED: CUresult = CUresult::Err(CUerror::NOT_PERMITTED);
+    const ERROR_NOT_PERMITTED: CUresult = CUresult::Err(CUerror::r#NOT_PERMITTED);
-    const ERROR_NOT_SUPPORTED: CUresult = CUresult::Err(CUerror::NOT_SUPPORTED);
+    const ERROR_NOT_SUPPORTED: CUresult = CUresult::Err(CUerror::r#NOT_SUPPORTED);
-    const ERROR_SYSTEM_NOT_READY: CUresult = CUresult::Err(CUerror::SYSTEM_NOT_READY);
+    const ERROR_SYSTEM_NOT_READY: CUresult = CUresult::Err(CUerror::r#SYSTEM_NOT_READY);
     const ERROR_SYSTEM_DRIVER_MISMATCH: CUresult = CUresult::Err(
-        CUerror::SYSTEM_DRIVER_MISMATCH,
+        CUerror::r#SYSTEM_DRIVER_MISMATCH,
     );
     const ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE: CUresult = CUresult::Err(
-        CUerror::COMPAT_NOT_SUPPORTED_ON_DEVICE,
+        CUerror::r#COMPAT_NOT_SUPPORTED_ON_DEVICE,
     );
     const ERROR_MPS_CONNECTION_FAILED: CUresult = CUresult::Err(
-        CUerror::MPS_CONNECTION_FAILED,
+        CUerror::r#MPS_CONNECTION_FAILED,
     );
-    const ERROR_MPS_RPC_FAILURE: CUresult = CUresult::Err(CUerror::MPS_RPC_FAILURE);
+    const ERROR_MPS_RPC_FAILURE: CUresult = CUresult::Err(CUerror::r#MPS_RPC_FAILURE);
     const ERROR_MPS_SERVER_NOT_READY: CUresult = CUresult::Err(
-        CUerror::MPS_SERVER_NOT_READY,
+        CUerror::r#MPS_SERVER_NOT_READY,
     );
     const ERROR_MPS_MAX_CLIENTS_REACHED: CUresult = CUresult::Err(
-        CUerror::MPS_MAX_CLIENTS_REACHED,
+        CUerror::r#MPS_MAX_CLIENTS_REACHED,
     );
     const ERROR_MPS_MAX_CONNECTIONS_REACHED: CUresult = CUresult::Err(
-        CUerror::MPS_MAX_CONNECTIONS_REACHED,
+        CUerror::r#MPS_MAX_CONNECTIONS_REACHED,
     );
     const ERROR_MPS_CLIENT_TERMINATED: CUresult = CUresult::Err(
-        CUerror::MPS_CLIENT_TERMINATED,
+        CUerror::r#MPS_CLIENT_TERMINATED,
+    );
+    const ERROR_CDP_NOT_SUPPORTED: CUresult = CUresult::Err(
+        CUerror::r#CDP_NOT_SUPPORTED,
     );
-    const ERROR_CDP_NOT_SUPPORTED: CUresult = CUresult::Err(CUerror::CDP_NOT_SUPPORTED);
     const ERROR_CDP_VERSION_MISMATCH: CUresult = CUresult::Err(
-        CUerror::CDP_VERSION_MISMATCH,
+        CUerror::r#CDP_VERSION_MISMATCH,
     );
     const ERROR_STREAM_CAPTURE_UNSUPPORTED: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_UNSUPPORTED,
+        CUerror::r#STREAM_CAPTURE_UNSUPPORTED,
     );
     const ERROR_STREAM_CAPTURE_INVALIDATED: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_INVALIDATED,
+        CUerror::r#STREAM_CAPTURE_INVALIDATED,
     );
     const ERROR_STREAM_CAPTURE_MERGE: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_MERGE,
+        CUerror::r#STREAM_CAPTURE_MERGE,
     );
     const ERROR_STREAM_CAPTURE_UNMATCHED: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_UNMATCHED,
+        CUerror::r#STREAM_CAPTURE_UNMATCHED,
     );
     const ERROR_STREAM_CAPTURE_UNJOINED: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_UNJOINED,
+        CUerror::r#STREAM_CAPTURE_UNJOINED,
     );
     const ERROR_STREAM_CAPTURE_ISOLATION: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_ISOLATION,
+        CUerror::r#STREAM_CAPTURE_ISOLATION,
     );
     const ERROR_STREAM_CAPTURE_IMPLICIT: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_IMPLICIT,
+        CUerror::r#STREAM_CAPTURE_IMPLICIT,
     );
-    const ERROR_CAPTURED_EVENT: CUresult = CUresult::Err(CUerror::CAPTURED_EVENT);
+    const ERROR_CAPTURED_EVENT: CUresult = CUresult::Err(CUerror::r#CAPTURED_EVENT);
     const ERROR_STREAM_CAPTURE_WRONG_THREAD: CUresult = CUresult::Err(
-        CUerror::STREAM_CAPTURE_WRONG_THREAD,
+        CUerror::r#STREAM_CAPTURE_WRONG_THREAD,
     );
-    const ERROR_TIMEOUT: CUresult = CUresult::Err(CUerror::TIMEOUT);
+    const ERROR_TIMEOUT: CUresult = CUresult::Err(CUerror::r#TIMEOUT);
     const ERROR_GRAPH_EXEC_UPDATE_FAILURE: CUresult = CUresult::Err(
-        CUerror::GRAPH_EXEC_UPDATE_FAILURE,
+        CUerror::r#GRAPH_EXEC_UPDATE_FAILURE,
     );
-    const ERROR_EXTERNAL_DEVICE: CUresult = CUresult::Err(CUerror::EXTERNAL_DEVICE);
+    const ERROR_EXTERNAL_DEVICE: CUresult = CUresult::Err(CUerror::r#EXTERNAL_DEVICE);
     const ERROR_INVALID_CLUSTER_SIZE: CUresult = CUresult::Err(
-        CUerror::INVALID_CLUSTER_SIZE,
+        CUerror::r#INVALID_CLUSTER_SIZE,
     );
     const ERROR_FUNCTION_NOT_LOADED: CUresult = CUresult::Err(
-        CUerror::FUNCTION_NOT_LOADED,
+        CUerror::r#FUNCTION_NOT_LOADED,
     );
     const ERROR_INVALID_RESOURCE_TYPE: CUresult = CUresult::Err(
-        CUerror::INVALID_RESOURCE_TYPE,
+        CUerror::r#INVALID_RESOURCE_TYPE,
     );
     const ERROR_INVALID_RESOURCE_CONFIGURATION: CUresult = CUresult::Err(
-        CUerror::INVALID_RESOURCE_CONFIGURATION,
+        CUerror::r#INVALID_RESOURCE_CONFIGURATION,
     );
-    const ERROR_KEY_ROTATION: CUresult = CUresult::Err(CUerror::KEY_ROTATION);
+    const ERROR_KEY_ROTATION: CUresult = CUresult::Err(CUerror::r#KEY_ROTATION);
-    const ERROR_UNKNOWN: CUresult = CUresult::Err(CUerror::UNKNOWN);
+    const ERROR_UNKNOWN: CUresult = CUresult::Err(CUerror::r#UNKNOWN);
 }
 impl CUresultConsts for CUresult {}
 #[must_use]

cuda_types/src/nvml.rs

@@ -4706,94 +4706,94 @@ pub struct nvmlPowerSmoothingState_v1_t {
 }
 pub type nvmlPowerSmoothingState_t = nvmlPowerSmoothingState_v1_t;
 impl nvmlError_t {
-    pub const UNINITIALIZED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#UNINITIALIZED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(1)
     });
-    pub const INVALID_ARGUMENT: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#INVALID_ARGUMENT: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(2)
     });
-    pub const NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(3)
     });
-    pub const NO_PERMISSION: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#NO_PERMISSION: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(4)
     });
-    pub const ALREADY_INITIALIZED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#ALREADY_INITIALIZED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(5)
     });
-    pub const NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(6)
     });
-    pub const INSUFFICIENT_SIZE: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#INSUFFICIENT_SIZE: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(7)
     });
-    pub const INSUFFICIENT_POWER: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#INSUFFICIENT_POWER: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(8)
     });
-    pub const DRIVER_NOT_LOADED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#DRIVER_NOT_LOADED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(9)
     });
-    pub const TIMEOUT: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#TIMEOUT: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(10)
     });
-    pub const IRQ_ISSUE: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#IRQ_ISSUE: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(11)
     });
-    pub const LIBRARY_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#LIBRARY_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(12)
     });
-    pub const FUNCTION_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#FUNCTION_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(13)
     });
-    pub const CORRUPTED_INFOROM: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#CORRUPTED_INFOROM: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(14)
     });
-    pub const GPU_IS_LOST: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#GPU_IS_LOST: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(15)
     });
-    pub const RESET_REQUIRED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#RESET_REQUIRED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(16)
     });
-    pub const OPERATING_SYSTEM: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#OPERATING_SYSTEM: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(17)
     });
-    pub const LIB_RM_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#LIB_RM_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(18)
     });
-    pub const IN_USE: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#IN_USE: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(19)
     });
-    pub const MEMORY: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#MEMORY: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(20)
     });
-    pub const NO_DATA: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#NO_DATA: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(21)
     });
-    pub const VGPU_ECC_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#VGPU_ECC_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(22)
     });
-    pub const INSUFFICIENT_RESOURCES: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#INSUFFICIENT_RESOURCES: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(23)
     });
-    pub const FREQ_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#FREQ_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(24)
     });
-    pub const ARGUMENT_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#ARGUMENT_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(25)
     });
-    pub const DEPRECATED: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#DEPRECATED: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(26)
     });
-    pub const NOT_READY: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#NOT_READY: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(27)
     });
-    pub const GPU_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#GPU_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(28)
     });
-    pub const INVALID_STATE: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#INVALID_STATE: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(29)
     });
-    pub const UNKNOWN: nvmlError_t = nvmlError_t(unsafe {
+    pub const r#UNKNOWN: nvmlError_t = nvmlError_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(999)
     });
 }
@@ -4803,75 +4803,77 @@ pub struct nvmlError_t(pub ::core::num::NonZeroU32);
 pub trait nvmlReturn_tConsts {
     const SUCCESS: nvmlReturn_t = nvmlReturn_t::Ok(());
     const ERROR_UNINITIALIZED: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::UNINITIALIZED,
+        nvmlError_t::r#UNINITIALIZED,
     );
     const ERROR_INVALID_ARGUMENT: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::INVALID_ARGUMENT,
+        nvmlError_t::r#INVALID_ARGUMENT,
     );
     const ERROR_NOT_SUPPORTED: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::NOT_SUPPORTED,
+        nvmlError_t::r#NOT_SUPPORTED,
     );
     const ERROR_NO_PERMISSION: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::NO_PERMISSION,
+        nvmlError_t::r#NO_PERMISSION,
     );
     const ERROR_ALREADY_INITIALIZED: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::ALREADY_INITIALIZED,
+        nvmlError_t::r#ALREADY_INITIALIZED,
     );
-    const ERROR_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::NOT_FOUND);
+    const ERROR_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#NOT_FOUND);
     const ERROR_INSUFFICIENT_SIZE: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::INSUFFICIENT_SIZE,
+        nvmlError_t::r#INSUFFICIENT_SIZE,
     );
     const ERROR_INSUFFICIENT_POWER: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::INSUFFICIENT_POWER,
+        nvmlError_t::r#INSUFFICIENT_POWER,
     );
     const ERROR_DRIVER_NOT_LOADED: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::DRIVER_NOT_LOADED,
+        nvmlError_t::r#DRIVER_NOT_LOADED,
     );
-    const ERROR_TIMEOUT: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::TIMEOUT);
+    const ERROR_TIMEOUT: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#TIMEOUT);
-    const ERROR_IRQ_ISSUE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::IRQ_ISSUE);
+    const ERROR_IRQ_ISSUE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#IRQ_ISSUE);
     const ERROR_LIBRARY_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::LIBRARY_NOT_FOUND,
+        nvmlError_t::r#LIBRARY_NOT_FOUND,
     );
     const ERROR_FUNCTION_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::FUNCTION_NOT_FOUND,
+        nvmlError_t::r#FUNCTION_NOT_FOUND,
     );
     const ERROR_CORRUPTED_INFOROM: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::CORRUPTED_INFOROM,
+        nvmlError_t::r#CORRUPTED_INFOROM,
+    );
+    const ERROR_GPU_IS_LOST: nvmlReturn_t = nvmlReturn_t::Err(
+        nvmlError_t::r#GPU_IS_LOST,
     );
-    const ERROR_GPU_IS_LOST: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::GPU_IS_LOST);
     const ERROR_RESET_REQUIRED: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::RESET_REQUIRED,
+        nvmlError_t::r#RESET_REQUIRED,
     );
     const ERROR_OPERATING_SYSTEM: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::OPERATING_SYSTEM,
+        nvmlError_t::r#OPERATING_SYSTEM,
     );
     const ERROR_LIB_RM_VERSION_MISMATCH: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::LIB_RM_VERSION_MISMATCH,
+        nvmlError_t::r#LIB_RM_VERSION_MISMATCH,
     );
-    const ERROR_IN_USE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::IN_USE);
+    const ERROR_IN_USE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#IN_USE);
-    const ERROR_MEMORY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::MEMORY);
+    const ERROR_MEMORY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#MEMORY);
-    const ERROR_NO_DATA: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::NO_DATA);
+    const ERROR_NO_DATA: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#NO_DATA);
     const ERROR_VGPU_ECC_NOT_SUPPORTED: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::VGPU_ECC_NOT_SUPPORTED,
+        nvmlError_t::r#VGPU_ECC_NOT_SUPPORTED,
     );
     const ERROR_INSUFFICIENT_RESOURCES: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::INSUFFICIENT_RESOURCES,
+        nvmlError_t::r#INSUFFICIENT_RESOURCES,
     );
     const ERROR_FREQ_NOT_SUPPORTED: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::FREQ_NOT_SUPPORTED,
+        nvmlError_t::r#FREQ_NOT_SUPPORTED,
     );
     const ERROR_ARGUMENT_VERSION_MISMATCH: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::ARGUMENT_VERSION_MISMATCH,
+        nvmlError_t::r#ARGUMENT_VERSION_MISMATCH,
     );
-    const ERROR_DEPRECATED: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::DEPRECATED);
+    const ERROR_DEPRECATED: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#DEPRECATED);
-    const ERROR_NOT_READY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::NOT_READY);
+    const ERROR_NOT_READY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#NOT_READY);
     const ERROR_GPU_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::GPU_NOT_FOUND,
+        nvmlError_t::r#GPU_NOT_FOUND,
     );
     const ERROR_INVALID_STATE: nvmlReturn_t = nvmlReturn_t::Err(
-        nvmlError_t::INVALID_STATE,
+        nvmlError_t::r#INVALID_STATE,
     );
-    const ERROR_UNKNOWN: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::UNKNOWN);
+    const ERROR_UNKNOWN: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#UNKNOWN);
 }
 impl nvmlReturn_tConsts for nvmlReturn_t {}
 #[must_use]

ext/hip_runtime-sys/src/lib.rs

@@ -13215,241 +13215,241 @@ extern "C" {
     ) -> hipError_t;
 }
 impl hipErrorCode_t {
-    pub const InvalidValue: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidValue: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(1)
     });
-    pub const OutOfMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#OutOfMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(2)
     });
-    pub const MemoryAllocation: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#MemoryAllocation: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(2)
     });
-    pub const NotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(3)
     });
-    pub const InitializationError: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InitializationError: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(3)
     });
-    pub const Deinitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#Deinitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(4)
     });
-    pub const ProfilerDisabled: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ProfilerDisabled: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(5)
     });
-    pub const ProfilerNotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ProfilerNotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(6)
     });
-    pub const ProfilerAlreadyStarted: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ProfilerAlreadyStarted: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(7)
     });
-    pub const ProfilerAlreadyStopped: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ProfilerAlreadyStopped: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(8)
     });
-    pub const InvalidConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(9)
     });
-    pub const InvalidPitchValue: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidPitchValue: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(12)
     });
-    pub const InvalidSymbol: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidSymbol: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(13)
     });
-    pub const InvalidDevicePointer: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidDevicePointer: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(17)
     });
-    pub const InvalidMemcpyDirection: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidMemcpyDirection: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(21)
     });
-    pub const InsufficientDriver: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InsufficientDriver: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(35)
     });
-    pub const MissingConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#MissingConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(52)
     });
-    pub const PriorLaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#PriorLaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(53)
     });
-    pub const InvalidDeviceFunction: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidDeviceFunction: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(98)
     });
-    pub const NoDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NoDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(100)
     });
-    pub const InvalidDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(101)
     });
-    pub const InvalidImage: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidImage: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(200)
     });
-    pub const InvalidContext: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidContext: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(201)
     });
-    pub const ContextAlreadyCurrent: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ContextAlreadyCurrent: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(202)
     });
-    pub const MapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#MapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(205)
     });
-    pub const MapBufferObjectFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#MapBufferObjectFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(205)
     });
-    pub const UnmapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#UnmapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(206)
     });
-    pub const ArrayIsMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ArrayIsMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(207)
     });
-    pub const AlreadyMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#AlreadyMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(208)
     });
-    pub const NoBinaryForGpu: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NoBinaryForGpu: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(209)
     });
-    pub const AlreadyAcquired: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#AlreadyAcquired: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(210)
     });
-    pub const NotMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NotMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(211)
     });
-    pub const NotMappedAsArray: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NotMappedAsArray: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(212)
     });
-    pub const NotMappedAsPointer: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NotMappedAsPointer: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(213)
     });
-    pub const ECCNotCorrectable: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ECCNotCorrectable: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(214)
     });
-    pub const UnsupportedLimit: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#UnsupportedLimit: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(215)
     });
-    pub const ContextAlreadyInUse: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ContextAlreadyInUse: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(216)
     });
-    pub const PeerAccessUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#PeerAccessUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(217)
     });
-    pub const InvalidKernelFile: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidKernelFile: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(218)
     });
-    pub const InvalidGraphicsContext: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidGraphicsContext: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(219)
     });
-    pub const InvalidSource: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidSource: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(300)
     });
-    pub const FileNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#FileNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(301)
     });
-    pub const SharedObjectSymbolNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#SharedObjectSymbolNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(302)
     });
-    pub const SharedObjectInitFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#SharedObjectInitFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(303)
     });
-    pub const OperatingSystem: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#OperatingSystem: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(304)
     });
-    pub const InvalidHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(400)
     });
-    pub const InvalidResourceHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidResourceHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(400)
     });
-    pub const IllegalState: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#IllegalState: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(401)
     });
-    pub const NotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(500)
     });
-    pub const NotReady: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NotReady: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(600)
     });
-    pub const IllegalAddress: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#IllegalAddress: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(700)
     });
-    pub const LaunchOutOfResources: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#LaunchOutOfResources: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(701)
     });
-    pub const LaunchTimeOut: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#LaunchTimeOut: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(702)
     });
-    pub const PeerAccessAlreadyEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#PeerAccessAlreadyEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(704)
     });
-    pub const PeerAccessNotEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#PeerAccessNotEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(705)
     });
-    pub const SetOnActiveProcess: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#SetOnActiveProcess: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(708)
     });
-    pub const ContextIsDestroyed: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#ContextIsDestroyed: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(709)
     });
-    pub const Assert: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#Assert: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(710)
     });
-    pub const HostMemoryAlreadyRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#HostMemoryAlreadyRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(712)
     });
-    pub const HostMemoryNotRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#HostMemoryNotRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(713)
     });
-    pub const LaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#LaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(719)
     });
-    pub const CooperativeLaunchTooLarge: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#CooperativeLaunchTooLarge: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(720)
     });
-    pub const NotSupported: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#NotSupported: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(801)
     });
-    pub const StreamCaptureUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(900)
     });
-    pub const StreamCaptureInvalidated: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureInvalidated: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(901)
     });
-    pub const StreamCaptureMerge: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureMerge: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(902)
     });
-    pub const StreamCaptureUnmatched: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureUnmatched: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(903)
     });
-    pub const StreamCaptureUnjoined: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureUnjoined: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(904)
     });
-    pub const StreamCaptureIsolation: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureIsolation: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(905)
     });
-    pub const StreamCaptureImplicit: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureImplicit: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(906)
     });
-    pub const CapturedEvent: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#CapturedEvent: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(907)
     });
-    pub const StreamCaptureWrongThread: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#StreamCaptureWrongThread: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(908)
     });
-    pub const GraphExecUpdateFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#GraphExecUpdateFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(910)
     });
-    pub const InvalidChannelDescriptor: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidChannelDescriptor: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(911)
     });
-    pub const InvalidTexture: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#InvalidTexture: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(912)
     });
-    pub const Unknown: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#Unknown: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(999)
     });
-    pub const RuntimeMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#RuntimeMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(1052)
     });
-    pub const RuntimeOther: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#RuntimeOther: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(1053)
     });
-    pub const Tbd: hipErrorCode_t = hipErrorCode_t(unsafe {
+    pub const r#Tbd: hipErrorCode_t = hipErrorCode_t(unsafe {
         ::core::num::NonZeroU32::new_unchecked(1054)
     });
 }
@@ -13458,211 +13458,223 @@ impl hipErrorCode_t {
 pub struct hipErrorCode_t(pub ::core::num::NonZeroU32);
 pub trait hipError_tConsts {
     const Success: hipError_t = hipError_t::Ok(());
-    const ErrorInvalidValue: hipError_t = hipError_t::Err(hipErrorCode_t::InvalidValue);
+    const ErrorInvalidValue: hipError_t = hipError_t::Err(
-    const ErrorOutOfMemory: hipError_t = hipError_t::Err(hipErrorCode_t::OutOfMemory);
+        hipErrorCode_t::r#InvalidValue,
+    );
+    const ErrorOutOfMemory: hipError_t = hipError_t::Err(hipErrorCode_t::r#OutOfMemory);
     const ErrorMemoryAllocation: hipError_t = hipError_t::Err(
-        hipErrorCode_t::MemoryAllocation,
+        hipErrorCode_t::r#MemoryAllocation,
     );
     const ErrorNotInitialized: hipError_t = hipError_t::Err(
-        hipErrorCode_t::NotInitialized,
+        hipErrorCode_t::r#NotInitialized,
     );
     const ErrorInitializationError: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InitializationError,
+        hipErrorCode_t::r#InitializationError,
     );
     const ErrorDeinitialized: hipError_t = hipError_t::Err(
-        hipErrorCode_t::Deinitialized,
+        hipErrorCode_t::r#Deinitialized,
     );
     const ErrorProfilerDisabled: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ProfilerDisabled,
+        hipErrorCode_t::r#ProfilerDisabled,
     );
     const ErrorProfilerNotInitialized: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ProfilerNotInitialized,
+        hipErrorCode_t::r#ProfilerNotInitialized,
     );
     const ErrorProfilerAlreadyStarted: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ProfilerAlreadyStarted,
+        hipErrorCode_t::r#ProfilerAlreadyStarted,
     );
     const ErrorProfilerAlreadyStopped: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ProfilerAlreadyStopped,
+        hipErrorCode_t::r#ProfilerAlreadyStopped,
     );
     const ErrorInvalidConfiguration: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidConfiguration,
+        hipErrorCode_t::r#InvalidConfiguration,
     );
     const ErrorInvalidPitchValue: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidPitchValue,
+        hipErrorCode_t::r#InvalidPitchValue,
     );
     const ErrorInvalidSymbol: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidSymbol,
+        hipErrorCode_t::r#InvalidSymbol,
     );
     const ErrorInvalidDevicePointer: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidDevicePointer,
+        hipErrorCode_t::r#InvalidDevicePointer,
     );
     const ErrorInvalidMemcpyDirection: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidMemcpyDirection,
+        hipErrorCode_t::r#InvalidMemcpyDirection,
     );
     const ErrorInsufficientDriver: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InsufficientDriver,
+        hipErrorCode_t::r#InsufficientDriver,
     );
     const ErrorMissingConfiguration: hipError_t = hipError_t::Err(
-        hipErrorCode_t::MissingConfiguration,
+        hipErrorCode_t::r#MissingConfiguration,
     );
     const ErrorPriorLaunchFailure: hipError_t = hipError_t::Err(
-        hipErrorCode_t::PriorLaunchFailure,
+        hipErrorCode_t::r#PriorLaunchFailure,
     );
     const ErrorInvalidDeviceFunction: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidDeviceFunction,
+        hipErrorCode_t::r#InvalidDeviceFunction,
     );
-    const ErrorNoDevice: hipError_t = hipError_t::Err(hipErrorCode_t::NoDevice);
+    const ErrorNoDevice: hipError_t = hipError_t::Err(hipErrorCode_t::r#NoDevice);
     const ErrorInvalidDevice: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidDevice,
+        hipErrorCode_t::r#InvalidDevice,
+    );
+    const ErrorInvalidImage: hipError_t = hipError_t::Err(
+        hipErrorCode_t::r#InvalidImage,
     );
-    const ErrorInvalidImage: hipError_t = hipError_t::Err(hipErrorCode_t::InvalidImage);
     const ErrorInvalidContext: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidContext,
+        hipErrorCode_t::r#InvalidContext,
     );
     const ErrorContextAlreadyCurrent: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ContextAlreadyCurrent,
+        hipErrorCode_t::r#ContextAlreadyCurrent,
     );
-    const ErrorMapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::MapFailed);
+    const ErrorMapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::r#MapFailed);
     const ErrorMapBufferObjectFailed: hipError_t = hipError_t::Err(
-        hipErrorCode_t::MapBufferObjectFailed,
+        hipErrorCode_t::r#MapBufferObjectFailed,
     );
-    const ErrorUnmapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::UnmapFailed);
+    const ErrorUnmapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::r#UnmapFailed);
     const ErrorArrayIsMapped: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ArrayIsMapped,
+        hipErrorCode_t::r#ArrayIsMapped,
     );
     const ErrorAlreadyMapped: hipError_t = hipError_t::Err(
-        hipErrorCode_t::AlreadyMapped,
+        hipErrorCode_t::r#AlreadyMapped,
     );
     const ErrorNoBinaryForGpu: hipError_t = hipError_t::Err(
-        hipErrorCode_t::NoBinaryForGpu,
+        hipErrorCode_t::r#NoBinaryForGpu,
     );
     const ErrorAlreadyAcquired: hipError_t = hipError_t::Err(
-        hipErrorCode_t::AlreadyAcquired,
+        hipErrorCode_t::r#AlreadyAcquired,
     );
-    const ErrorNotMapped: hipError_t = hipError_t::Err(hipErrorCode_t::NotMapped);
+    const ErrorNotMapped: hipError_t = hipError_t::Err(hipErrorCode_t::r#NotMapped);
     const ErrorNotMappedAsArray: hipError_t = hipError_t::Err(
-        hipErrorCode_t::NotMappedAsArray,
+        hipErrorCode_t::r#NotMappedAsArray,
     );
     const ErrorNotMappedAsPointer: hipError_t = hipError_t::Err(
-        hipErrorCode_t::NotMappedAsPointer,
+        hipErrorCode_t::r#NotMappedAsPointer,
     );
     const ErrorECCNotCorrectable: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ECCNotCorrectable,
+        hipErrorCode_t::r#ECCNotCorrectable,
     );
     const ErrorUnsupportedLimit: hipError_t = hipError_t::Err(
-        hipErrorCode_t::UnsupportedLimit,
+        hipErrorCode_t::r#UnsupportedLimit,
     );
     const ErrorContextAlreadyInUse: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ContextAlreadyInUse,
+        hipErrorCode_t::r#ContextAlreadyInUse,
     );
     const ErrorPeerAccessUnsupported: hipError_t = hipError_t::Err(
-        hipErrorCode_t::PeerAccessUnsupported,
+        hipErrorCode_t::r#PeerAccessUnsupported,
     );
     const ErrorInvalidKernelFile: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidKernelFile,
+        hipErrorCode_t::r#InvalidKernelFile,
     );
     const ErrorInvalidGraphicsContext: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidGraphicsContext,
+        hipErrorCode_t::r#InvalidGraphicsContext,
     );
     const ErrorInvalidSource: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidSource,
+        hipErrorCode_t::r#InvalidSource,
+    );
+    const ErrorFileNotFound: hipError_t = hipError_t::Err(
+        hipErrorCode_t::r#FileNotFound,
     );
-    const ErrorFileNotFound: hipError_t = hipError_t::Err(hipErrorCode_t::FileNotFound);
     const ErrorSharedObjectSymbolNotFound: hipError_t = hipError_t::Err(
-        hipErrorCode_t::SharedObjectSymbolNotFound,
+        hipErrorCode_t::r#SharedObjectSymbolNotFound,
     );
     const ErrorSharedObjectInitFailed: hipError_t = hipError_t::Err(
-        hipErrorCode_t::SharedObjectInitFailed,
+        hipErrorCode_t::r#SharedObjectInitFailed,
     );
     const ErrorOperatingSystem: hipError_t = hipError_t::Err(
-        hipErrorCode_t::OperatingSystem,
+        hipErrorCode_t::r#OperatingSystem,
     );
     const ErrorInvalidHandle: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidHandle,
+        hipErrorCode_t::r#InvalidHandle,
     );
     const ErrorInvalidResourceHandle: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidResourceHandle,
+        hipErrorCode_t::r#InvalidResourceHandle,
     );
-    const ErrorIllegalState: hipError_t = hipError_t::Err(hipErrorCode_t::IllegalState);
+    const ErrorIllegalState: hipError_t = hipError_t::Err(
-    const ErrorNotFound: hipError_t = hipError_t::Err(hipErrorCode_t::NotFound);
+        hipErrorCode_t::r#IllegalState,
-    const ErrorNotReady: hipError_t = hipError_t::Err(hipErrorCode_t::NotReady);
+    );
+    const ErrorNotFound: hipError_t = hipError_t::Err(hipErrorCode_t::r#NotFound);
+    const ErrorNotReady: hipError_t = hipError_t::Err(hipErrorCode_t::r#NotReady);
     const ErrorIllegalAddress: hipError_t = hipError_t::Err(
-        hipErrorCode_t::IllegalAddress,
+        hipErrorCode_t::r#IllegalAddress,
     );
     const ErrorLaunchOutOfResources: hipError_t = hipError_t::Err(
-        hipErrorCode_t::LaunchOutOfResources,
+        hipErrorCode_t::r#LaunchOutOfResources,
     );
     const ErrorLaunchTimeOut: hipError_t = hipError_t::Err(
-        hipErrorCode_t::LaunchTimeOut,
+        hipErrorCode_t::r#LaunchTimeOut,
     );
     const ErrorPeerAccessAlreadyEnabled: hipError_t = hipError_t::Err(
-        hipErrorCode_t::PeerAccessAlreadyEnabled,
+        hipErrorCode_t::r#PeerAccessAlreadyEnabled,
     );
     const ErrorPeerAccessNotEnabled: hipError_t = hipError_t::Err(
-        hipErrorCode_t::PeerAccessNotEnabled,
+        hipErrorCode_t::r#PeerAccessNotEnabled,
     );
     const ErrorSetOnActiveProcess: hipError_t = hipError_t::Err(
-        hipErrorCode_t::SetOnActiveProcess,
+        hipErrorCode_t::r#SetOnActiveProcess,
     );
     const ErrorContextIsDestroyed: hipError_t = hipError_t::Err(
-        hipErrorCode_t::ContextIsDestroyed,
+        hipErrorCode_t::r#ContextIsDestroyed,
     );
-    const ErrorAssert: hipError_t = hipError_t::Err(hipErrorCode_t::Assert);
+    const ErrorAssert: hipError_t = hipError_t::Err(hipErrorCode_t::r#Assert);
     const ErrorHostMemoryAlreadyRegistered: hipError_t = hipError_t::Err(
-        hipErrorCode_t::HostMemoryAlreadyRegistered,
+        hipErrorCode_t::r#HostMemoryAlreadyRegistered,
     );
     const ErrorHostMemoryNotRegistered: hipError_t = hipError_t::Err(
-        hipErrorCode_t::HostMemoryNotRegistered,
+        hipErrorCode_t::r#HostMemoryNotRegistered,
     );
     const ErrorLaunchFailure: hipError_t = hipError_t::Err(
-        hipErrorCode_t::LaunchFailure,
+        hipErrorCode_t::r#LaunchFailure,
     );
     const ErrorCooperativeLaunchTooLarge: hipError_t = hipError_t::Err(
-        hipErrorCode_t::CooperativeLaunchTooLarge,
+        hipErrorCode_t::r#CooperativeLaunchTooLarge,
+    );
+    const ErrorNotSupported: hipError_t = hipError_t::Err(
+        hipErrorCode_t::r#NotSupported,
     );
-    const ErrorNotSupported: hipError_t = hipError_t::Err(hipErrorCode_t::NotSupported);
     const ErrorStreamCaptureUnsupported: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureUnsupported,
+        hipErrorCode_t::r#StreamCaptureUnsupported,
     );
     const ErrorStreamCaptureInvalidated: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureInvalidated,
+        hipErrorCode_t::r#StreamCaptureInvalidated,
     );
     const ErrorStreamCaptureMerge: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureMerge,
+        hipErrorCode_t::r#StreamCaptureMerge,
     );
     const ErrorStreamCaptureUnmatched: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureUnmatched,
+        hipErrorCode_t::r#StreamCaptureUnmatched,
     );
     const ErrorStreamCaptureUnjoined: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureUnjoined,
+        hipErrorCode_t::r#StreamCaptureUnjoined,
     );
     const ErrorStreamCaptureIsolation: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureIsolation,
+        hipErrorCode_t::r#StreamCaptureIsolation,
     );
     const ErrorStreamCaptureImplicit: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureImplicit,
+        hipErrorCode_t::r#StreamCaptureImplicit,
     );
     const ErrorCapturedEvent: hipError_t = hipError_t::Err(
-        hipErrorCode_t::CapturedEvent,
+        hipErrorCode_t::r#CapturedEvent,
     );
     const ErrorStreamCaptureWrongThread: hipError_t = hipError_t::Err(
-        hipErrorCode_t::StreamCaptureWrongThread,
+        hipErrorCode_t::r#StreamCaptureWrongThread,
     );
     const ErrorGraphExecUpdateFailure: hipError_t = hipError_t::Err(
-        hipErrorCode_t::GraphExecUpdateFailure,
+        hipErrorCode_t::r#GraphExecUpdateFailure,
     );
     const ErrorInvalidChannelDescriptor: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidChannelDescriptor,
+        hipErrorCode_t::r#InvalidChannelDescriptor,
     );
     const ErrorInvalidTexture: hipError_t = hipError_t::Err(
-        hipErrorCode_t::InvalidTexture,
+        hipErrorCode_t::r#InvalidTexture,
     );
-    const ErrorUnknown: hipError_t = hipError_t::Err(hipErrorCode_t::Unknown);
+    const ErrorUnknown: hipError_t = hipError_t::Err(hipErrorCode_t::r#Unknown);
     const ErrorRuntimeMemory: hipError_t = hipError_t::Err(
-        hipErrorCode_t::RuntimeMemory,
+        hipErrorCode_t::r#RuntimeMemory,
     );
-    const ErrorRuntimeOther: hipError_t = hipError_t::Err(hipErrorCode_t::RuntimeOther);
+    const ErrorRuntimeOther: hipError_t = hipError_t::Err(
-    const ErrorTbd: hipError_t = hipError_t::Err(hipErrorCode_t::Tbd);
+        hipErrorCode_t::r#RuntimeOther,
+    );
+    const ErrorTbd: hipError_t = hipError_t::Err(hipErrorCode_t::r#Tbd);
 }
 impl hipError_tConsts for hipError_t {}
 #[must_use]

ext/rocblas-sys/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "rocblas-sys"
+version = "0.1.0"
+authors = ["Violet <c01368481@gmail.com>"]
+edition = "2021"
+
+[lib]
+
+[dependencies]
+hip_runtime-sys = { version = "0.0.0", path = "../hip_runtime-sys" }

ext/rocblas-sys/build.rs

@@ -0,0 +1,9 @@
+use std::env::VarError;
+
+fn main() -> Result<(), VarError> {
+    if !cfg!(windows) {
+        println!("cargo:rustc-link-lib=dylib=rocblas");
+        println!("cargo:rustc-link-search=native=/opt/rocm/lib/");
+    }
+    Ok(())
+}

zluda_bindgen/src/main.rs

@@ -28,6 +28,7 @@ fn main() {
         &crate_root,
         &["..", "ext", "hip_runtime-sys", "src", "lib.rs"],
     );
+    generate_rocblas(&crate_root, &["..", "ext", "rocblas-sys", "src", "lib.rs"]);
     let cuda_functions = generate_cuda(&crate_root);
     generate_process_address_table(&crate_root, cuda_functions);
     generate_ml(&crate_root);
@@ -655,6 +656,7 @@ fn remove_type(module: &mut syn::File, type_name: &str) {
     let items = items
         .into_iter()
         .filter_map(|item| match item {
+            Item::Type(type_) if type_.ident == type_name => None,
             Item::Enum(enum_) if enum_.ident == type_name => None,
             Item::Struct(struct_) if struct_.ident == type_name => None,
             Item::Impl(impl_) if impl_.self_ty.to_token_stream().to_string() == type_name => None,
@@ -921,6 +923,58 @@ fn generate_hip_runtime(output: &PathBuf, path: &[&str]) {
     write_rust_to_file(output, &prettyplease::unparse(&module))
 }
 
+fn generate_rocblas(output: &PathBuf, path: &[&str]) {
+    let rocblas_header = new_builder()
+        .header("/opt/rocm/include/rocblas/rocblas.h")
+        .allowlist_type("^rocblas.*")
+        .allowlist_function("^rocblas.*")
+        .allowlist_var("^rocblas.*")
+        .must_use_type("rocblas_status")
+        .constified_enum("rocblas_status_")
+        .new_type_alias("^rocblas_handle$")
+        .clang_args(["-I/opt/rocm/include", "-D__HIP_PLATFORM_AMD__"])
+        .generate()
+        .unwrap()
+        .to_string();
+    let mut module: syn::File = syn::parse_str(&rocblas_header).unwrap();
+    remove_type(&mut module, "hipStream_t");
+    remove_type(&mut module, "ihipStream_t");
+    remove_type(&mut module, "hipEvent_t");
+    remove_type(&mut module, "ihipEvent_t");
+    let mut converter = ConvertIntoRustResult {
+        type_: "rocblas_status",
+        underlying_type: "rocblas_status_",
+        new_error_type: "rocblas_error",
+        error_prefix: ("rocblas_status_", "error_"),
+        success: ("rocblas_status_success", "success"),
+        constants: Vec::new(),
+    };
+    module.items = module
+        .items
+        .into_iter()
+        .filter_map(|item| match item {
+            Item::Const(const_) => converter.get_const(const_).map(Item::Const),
+            Item::Use(use_) => converter.get_use(use_).map(Item::Use),
+            Item::Type(type_) => converter.get_type(type_).map(Item::Type),
+            Item::ForeignMod(mut extern_) => {
+                extern_.attrs.push(
+                    parse_quote!(#[cfg_attr(windows, link = "rocblas", kind = "raw-dylib")]),
+                );
+                Some(Item::ForeignMod(extern_))
+            }
+            item => Some(item),
+        })
+        .collect::<Vec<_>>();
+    converter.flush(&mut module.items);
+    add_send_sync(&mut module.items, &["rocblas_handle"]);
+    let mut output = output.clone();
+    output.extend(path);
+    let text = &prettyplease::unparse(&module)
+        .replace("hipStream_t", "hip_runtime_sys::hipStream_t")
+        .replace("hipEvent_t", "hip_runtime_sys::hipEvent_t");
+    write_rust_to_file(output, text)
+}
+
 fn add_send_sync(items: &mut Vec<Item>, arg: &[&str]) {
     for type_ in arg {
         let type_ = Ident::new(type_, Span::call_site());
@@ -1115,7 +1169,7 @@ impl ConvertIntoRustResult {
                 let old_prefix_len = self.underlying_type.len() + 1 + self.error_prefix.0.len();
                 let variant_ident =
                     format_ident!("{}{}", self.error_prefix.1, &ident[old_prefix_len..]);
-                let error_ident = format_ident!("{}", &ident[old_prefix_len..]);
+                let error_ident = format_ident!("r#{}", &ident[old_prefix_len..]);
                 let expr = &const_.expr;
                 result_variants.push(quote! {
                     const #variant_ident: #type_ = #type_::Err(#new_error_type::#error_ident);