Run zluda_bindgen and fix usages

cuda_types/src/cublas.rs

@@ -17,40 +17,6 @@ pub const CUBLAS_VER_MINOR: u32 = 8;
 pub const CUBLAS_VER_PATCH: u32 = 4;
 pub const CUBLAS_VER_BUILD: u32 = 1;
 pub const CUBLAS_VERSION: u32 = 120804;
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_SUCCESS: cublasStatus_t = cublasStatus_t(0);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_NOT_INITIALIZED: cublasStatus_t = cublasStatus_t(1);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_ALLOC_FAILED: cublasStatus_t = cublasStatus_t(3);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_INVALID_VALUE: cublasStatus_t = cublasStatus_t(7);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_ARCH_MISMATCH: cublasStatus_t = cublasStatus_t(8);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_MAPPING_ERROR: cublasStatus_t = cublasStatus_t(11);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_EXECUTION_FAILED: cublasStatus_t = cublasStatus_t(13);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_INTERNAL_ERROR: cublasStatus_t = cublasStatus_t(14);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_NOT_SUPPORTED: cublasStatus_t = cublasStatus_t(15);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_LICENSE_ERROR: cublasStatus_t = cublasStatus_t(16);
-}
-#[repr(transparent)]
-#[must_use]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct cublasStatus_t(pub ::core::ffi::c_uint);
 impl cublasFillMode_t {
     pub const CUBLAS_FILL_MODE_LOWER: cublasFillMode_t = cublasFillMode_t(0);
 }
@@ -322,3 +288,71 @@ pub type cublasHandle_t = *mut cublasContext;
 pub type cublasLogCallback = ::core::option::Option<
     unsafe extern "C" fn(msg: *const ::core::ffi::c_char),
 >;
+impl cublasError_t {
+    pub const NOT_INITIALIZED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(1)
+    });
+    pub const ALLOC_FAILED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(3)
+    });
+    pub const INVALID_VALUE: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(7)
+    });
+    pub const ARCH_MISMATCH: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(8)
+    });
+    pub const MAPPING_ERROR: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(11)
+    });
+    pub const EXECUTION_FAILED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(13)
+    });
+    pub const INTERNAL_ERROR: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(14)
+    });
+    pub const NOT_SUPPORTED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(15)
+    });
+    pub const LICENSE_ERROR: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(16)
+    });
+}
+#[repr(transparent)]
+#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
+pub struct cublasError_t(pub ::core::num::NonZeroU32);
+pub trait cublasStatus_tConsts {
+    const SUCCESS: cublasStatus_t = cublasStatus_t::Ok(());
+    const ERROR_NOT_INITIALIZED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::NOT_INITIALIZED,
+    );
+    const ERROR_ALLOC_FAILED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::ALLOC_FAILED,
+    );
+    const ERROR_INVALID_VALUE: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::INVALID_VALUE,
+    );
+    const ERROR_ARCH_MISMATCH: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::ARCH_MISMATCH,
+    );
+    const ERROR_MAPPING_ERROR: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::MAPPING_ERROR,
+    );
+    const ERROR_EXECUTION_FAILED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::EXECUTION_FAILED,
+    );
+    const ERROR_INTERNAL_ERROR: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::INTERNAL_ERROR,
+    );
+    const ERROR_NOT_SUPPORTED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::NOT_SUPPORTED,
+    );
+    const ERROR_LICENSE_ERROR: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::LICENSE_ERROR,
+    );
+}
+impl cublasStatus_tConsts for cublasStatus_t {}
+#[must_use]
+pub type cublasStatus_t = ::core::result::Result<(), cublasError_t>;
+const _: fn() = || {
+    let _ = std::mem::transmute::<cublasStatus_t, u32>;
+};

cuda_types/src/cufft.rs

@@ -50,62 +50,8 @@ pub struct cudaLibXtDesc_t {
     pub libDescriptor: *mut ::core::ffi::c_void,
 }
 pub type cudaLibXtDesc = cudaLibXtDesc_t;
-impl cufftResult_t {
-    pub const CUFFT_SUCCESS: cufftResult_t = cufftResult_t(0);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_PLAN: cufftResult_t = cufftResult_t(1);
-}
-impl cufftResult_t {
-    pub const CUFFT_ALLOC_FAILED: cufftResult_t = cufftResult_t(2);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_TYPE: cufftResult_t = cufftResult_t(3);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_VALUE: cufftResult_t = cufftResult_t(4);
-}
-impl cufftResult_t {
-    pub const CUFFT_INTERNAL_ERROR: cufftResult_t = cufftResult_t(5);
-}
-impl cufftResult_t {
-    pub const CUFFT_EXEC_FAILED: cufftResult_t = cufftResult_t(6);
-}
-impl cufftResult_t {
-    pub const CUFFT_SETUP_FAILED: cufftResult_t = cufftResult_t(7);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_SIZE: cufftResult_t = cufftResult_t(8);
-}
-impl cufftResult_t {
-    pub const CUFFT_UNALIGNED_DATA: cufftResult_t = cufftResult_t(9);
-}
-impl cufftResult_t {
-    pub const CUFFT_INCOMPLETE_PARAMETER_LIST: cufftResult_t = cufftResult_t(10);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_DEVICE: cufftResult_t = cufftResult_t(11);
-}
-impl cufftResult_t {
-    pub const CUFFT_PARSE_ERROR: cufftResult_t = cufftResult_t(12);
-}
-impl cufftResult_t {
-    pub const CUFFT_NO_WORKSPACE: cufftResult_t = cufftResult_t(13);
-}
-impl cufftResult_t {
-    pub const CUFFT_NOT_IMPLEMENTED: cufftResult_t = cufftResult_t(14);
-}
-impl cufftResult_t {
-    pub const CUFFT_LICENSE_ERROR: cufftResult_t = cufftResult_t(15);
-}
-impl cufftResult_t {
-    pub const CUFFT_NOT_SUPPORTED: cufftResult_t = cufftResult_t(16);
-}
-#[repr(transparent)]
 #[must_use]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub type cufftResult_t = ::core::ffi::c_uint;
-pub struct cufftResult_t(pub ::core::ffi::c_uint);
-pub use self::cufftResult_t as cufftResult;
 pub type cufftReal = f32;
 pub type cufftDoubleReal = f64;
 pub type cufftComplex = super::cuda::cuComplex;
@@ -425,3 +371,97 @@ pub type cufftJITCallbackStoreD = ::core::option::Option<
         sharedPointer: *mut ::core::ffi::c_void,
     ),
 >;
+impl cufftError_t {
+    pub const INVALID_PLAN: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(1)
+    });
+    pub const ALLOC_FAILED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(2)
+    });
+    pub const INVALID_TYPE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(3)
+    });
+    pub const INVALID_VALUE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(4)
+    });
+    pub const INTERNAL_ERROR: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(5)
+    });
+    pub const EXEC_FAILED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(6)
+    });
+    pub const SETUP_FAILED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(7)
+    });
+    pub const INVALID_SIZE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(8)
+    });
+    pub const UNALIGNED_DATA: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(9)
+    });
+    pub const INCOMPLETE_PARAMETER_LIST: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(10)
+    });
+    pub const INVALID_DEVICE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(11)
+    });
+    pub const PARSE_ERROR: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(12)
+    });
+    pub const NO_WORKSPACE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(13)
+    });
+    pub const NOT_IMPLEMENTED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(14)
+    });
+    pub const LICENSE_ERROR: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(15)
+    });
+    pub const NOT_SUPPORTED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(16)
+    });
+}
+#[repr(transparent)]
+#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
+pub struct cufftError_t(pub ::core::num::NonZeroU32);
+pub trait cufftResultConsts {
+    const SUCCESS: cufftResult = cufftResult::Ok(());
+    const ERROR_INVALID_PLAN: cufftResult = cufftResult::Err(cufftError_t::INVALID_PLAN);
+    const ERROR_ALLOC_FAILED: cufftResult = cufftResult::Err(cufftError_t::ALLOC_FAILED);
+    const ERROR_INVALID_TYPE: cufftResult = cufftResult::Err(cufftError_t::INVALID_TYPE);
+    const ERROR_INVALID_VALUE: cufftResult = cufftResult::Err(
+        cufftError_t::INVALID_VALUE,
+    );
+    const ERROR_INTERNAL_ERROR: cufftResult = cufftResult::Err(
+        cufftError_t::INTERNAL_ERROR,
+    );
+    const ERROR_EXEC_FAILED: cufftResult = cufftResult::Err(cufftError_t::EXEC_FAILED);
+    const ERROR_SETUP_FAILED: cufftResult = cufftResult::Err(cufftError_t::SETUP_FAILED);
+    const ERROR_INVALID_SIZE: cufftResult = cufftResult::Err(cufftError_t::INVALID_SIZE);
+    const ERROR_UNALIGNED_DATA: cufftResult = cufftResult::Err(
+        cufftError_t::UNALIGNED_DATA,
+    );
+    const ERROR_INCOMPLETE_PARAMETER_LIST: cufftResult = cufftResult::Err(
+        cufftError_t::INCOMPLETE_PARAMETER_LIST,
+    );
+    const ERROR_INVALID_DEVICE: cufftResult = cufftResult::Err(
+        cufftError_t::INVALID_DEVICE,
+    );
+    const ERROR_PARSE_ERROR: cufftResult = cufftResult::Err(cufftError_t::PARSE_ERROR);
+    const ERROR_NO_WORKSPACE: cufftResult = cufftResult::Err(cufftError_t::NO_WORKSPACE);
+    const ERROR_NOT_IMPLEMENTED: cufftResult = cufftResult::Err(
+        cufftError_t::NOT_IMPLEMENTED,
+    );
+    const ERROR_LICENSE_ERROR: cufftResult = cufftResult::Err(
+        cufftError_t::LICENSE_ERROR,
+    );
+    const ERROR_NOT_SUPPORTED: cufftResult = cufftResult::Err(
+        cufftError_t::NOT_SUPPORTED,
+    );
+}
+impl cufftResultConsts for cufftResult {}
+#[must_use]
+pub type cufftResult = ::core::result::Result<(), cufftError_t>;
+const _: fn() = || {
+    let _ = std::mem::transmute::<cufftResult, u32>;
+};

cuda_types/src/cusparse.rs

@@ -85,50 +85,6 @@ pub struct pruneInfo {
     _unused: [u8; 0],
 }
 pub type pruneInfo_t = *mut pruneInfo;
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_SUCCESS: cusparseStatus_t = cusparseStatus_t(0);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_NOT_INITIALIZED: cusparseStatus_t = cusparseStatus_t(1);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_ALLOC_FAILED: cusparseStatus_t = cusparseStatus_t(2);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_INVALID_VALUE: cusparseStatus_t = cusparseStatus_t(3);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_ARCH_MISMATCH: cusparseStatus_t = cusparseStatus_t(4);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_MAPPING_ERROR: cusparseStatus_t = cusparseStatus_t(5);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_EXECUTION_FAILED: cusparseStatus_t = cusparseStatus_t(6);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_INTERNAL_ERROR: cusparseStatus_t = cusparseStatus_t(7);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t(
-        8,
-    );
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_ZERO_PIVOT: cusparseStatus_t = cusparseStatus_t(9);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t(10);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_INSUFFICIENT_RESOURCES: cusparseStatus_t = cusparseStatus_t(
-        11,
-    );
-}
-#[repr(transparent)]
-#[must_use]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct cusparseStatus_t(pub ::core::ffi::c_uint);
 impl cusparsePointerMode_t {
     pub const CUSPARSE_POINTER_MODE_HOST: cusparsePointerMode_t = cusparsePointerMode_t(
         0,
@@ -530,3 +486,83 @@ impl cusparseSpMMOpAlg_t {
 #[repr(transparent)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct cusparseSpMMOpAlg_t(pub ::core::ffi::c_uint);
+impl cusparseError_t {
+    pub const NOT_INITIALIZED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(1)
+    });
+    pub const ALLOC_FAILED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(2)
+    });
+    pub const INVALID_VALUE: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(3)
+    });
+    pub const ARCH_MISMATCH: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(4)
+    });
+    pub const MAPPING_ERROR: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(5)
+    });
+    pub const EXECUTION_FAILED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(6)
+    });
+    pub const INTERNAL_ERROR: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(7)
+    });
+    pub const MATRIX_TYPE_NOT_SUPPORTED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(8)
+    });
+    pub const ZERO_PIVOT: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(9)
+    });
+    pub const NOT_SUPPORTED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(10)
+    });
+    pub const INSUFFICIENT_RESOURCES: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(11)
+    });
+}
+#[repr(transparent)]
+#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
+pub struct cusparseError_t(pub ::core::num::NonZeroU32);
+pub trait cusparseStatus_tConsts {
+    const SUCCESS: cusparseStatus_t = cusparseStatus_t::Ok(());
+    const ERROR_NOT_INITIALIZED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::NOT_INITIALIZED,
+    );
+    const ERROR_ALLOC_FAILED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::ALLOC_FAILED,
+    );
+    const ERROR_INVALID_VALUE: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::INVALID_VALUE,
+    );
+    const ERROR_ARCH_MISMATCH: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::ARCH_MISMATCH,
+    );
+    const ERROR_MAPPING_ERROR: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::MAPPING_ERROR,
+    );
+    const ERROR_EXECUTION_FAILED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::EXECUTION_FAILED,
+    );
+    const ERROR_INTERNAL_ERROR: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::INTERNAL_ERROR,
+    );
+    const ERROR_MATRIX_TYPE_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::MATRIX_TYPE_NOT_SUPPORTED,
+    );
+    const ERROR_ZERO_PIVOT: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::ZERO_PIVOT,
+    );
+    const ERROR_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::NOT_SUPPORTED,
+    );
+    const ERROR_INSUFFICIENT_RESOURCES: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::INSUFFICIENT_RESOURCES,
+    );
+}
+impl cusparseStatus_tConsts for cusparseStatus_t {}
+#[must_use]
+pub type cusparseStatus_t = ::core::result::Result<(), cusparseError_t>;
+const _: fn() = || {
+    let _ = std::mem::transmute::<cusparseStatus_t, u32>;
+};

format/src/format_generated_blas.rs

@@ -1,48 +1,6 @@
 // Generated automatically by zluda_bindgen
 // DO NOT EDIT MANUALLY
 #![allow(warnings)]
-impl crate::CudaDisplay for cuda_types::cublas::cublasStatus_t {
-    fn write(
-        &self,
-        _fn_name: &'static str,
-        _index: usize,
-        writer: &mut (impl std::io::Write + ?Sized),
-    ) -> std::io::Result<()> {
-        match self {
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_SUCCESS => {
-                writer.write_all(stringify!(CUBLAS_STATUS_SUCCESS).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_NOT_INITIALIZED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_NOT_INITIALIZED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_ALLOC_FAILED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_ALLOC_FAILED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INVALID_VALUE => {
-                writer.write_all(stringify!(CUBLAS_STATUS_INVALID_VALUE).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_ARCH_MISMATCH => {
-                writer.write_all(stringify!(CUBLAS_STATUS_ARCH_MISMATCH).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_MAPPING_ERROR => {
-                writer.write_all(stringify!(CUBLAS_STATUS_MAPPING_ERROR).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_EXECUTION_FAILED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_EXECUTION_FAILED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INTERNAL_ERROR => {
-                writer.write_all(stringify!(CUBLAS_STATUS_INTERNAL_ERROR).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_NOT_SUPPORTED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_NOT_SUPPORTED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_LICENSE_ERROR => {
-                writer.write_all(stringify!(CUBLAS_STATUS_LICENSE_ERROR).as_bytes())
-            }
-            _ => write!(writer, "{}", self.0),
-        }
-    }
-}
 impl crate::CudaDisplay for cuda_types::cublas::cublasFillMode_t {
     fn write(
         &self,
@@ -30267,3 +30225,29 @@ pub fn write_cublasUint8gemmBias(
     crate::CudaDisplay::write(&C_shift, "cublasUint8gemmBias", arg_idx, writer)?;
     writer.write_all(b")")
 }
+impl crate::CudaDisplay for cuda_types::cublas::cublasStatus_t {
+    fn write(
+        &self,
+        _fn_name: &'static str,
+        _index: usize,
+        writer: &mut (impl std::io::Write + ?Sized),
+    ) -> std::io::Result<()> {
+        match self {
+            Ok(()) => writer.write_all(b"CUBLAS_STATUS_SUCCESS"),
+            Err(err) => {
+                match err.0.get() {
+                    1 => writer.write_all("CUBLAS_STATUS_NOT_INITIALIZED".as_bytes()),
+                    3 => writer.write_all("CUBLAS_STATUS_ALLOC_FAILED".as_bytes()),
+                    7 => writer.write_all("CUBLAS_STATUS_INVALID_VALUE".as_bytes()),
+                    8 => writer.write_all("CUBLAS_STATUS_ARCH_MISMATCH".as_bytes()),
+                    11 => writer.write_all("CUBLAS_STATUS_MAPPING_ERROR".as_bytes()),
+                    13 => writer.write_all("CUBLAS_STATUS_EXECUTION_FAILED".as_bytes()),
+                    14 => writer.write_all("CUBLAS_STATUS_INTERNAL_ERROR".as_bytes()),
+                    15 => writer.write_all("CUBLAS_STATUS_NOT_SUPPORTED".as_bytes()),
+                    16 => writer.write_all("CUBLAS_STATUS_LICENSE_ERROR".as_bytes()),
+                    err => write!(writer, "{}", err),
+                }
+            }
+        }
+    }
+}

format/src/format_generated_fft.rs

@@ -61,69 +61,6 @@ impl crate::CudaDisplay for cuda_types::cufft::cudaLibXtDesc_t {
         writer.write_all(b" }")
     }
 }
-impl crate::CudaDisplay for cuda_types::cufft::cufftResult_t {
-    fn write(
-        &self,
-        _fn_name: &'static str,
-        _index: usize,
-        writer: &mut (impl std::io::Write + ?Sized),
-    ) -> std::io::Result<()> {
-        match self {
-            &cuda_types::cufft::cufftResult_t::CUFFT_SUCCESS => {
-                writer.write_all(stringify!(CUFFT_SUCCESS).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_PLAN => {
-                writer.write_all(stringify!(CUFFT_INVALID_PLAN).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_ALLOC_FAILED => {
-                writer.write_all(stringify!(CUFFT_ALLOC_FAILED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_TYPE => {
-                writer.write_all(stringify!(CUFFT_INVALID_TYPE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_VALUE => {
-                writer.write_all(stringify!(CUFFT_INVALID_VALUE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INTERNAL_ERROR => {
-                writer.write_all(stringify!(CUFFT_INTERNAL_ERROR).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_EXEC_FAILED => {
-                writer.write_all(stringify!(CUFFT_EXEC_FAILED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_SETUP_FAILED => {
-                writer.write_all(stringify!(CUFFT_SETUP_FAILED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_SIZE => {
-                writer.write_all(stringify!(CUFFT_INVALID_SIZE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_UNALIGNED_DATA => {
-                writer.write_all(stringify!(CUFFT_UNALIGNED_DATA).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INCOMPLETE_PARAMETER_LIST => {
-                writer.write_all(stringify!(CUFFT_INCOMPLETE_PARAMETER_LIST).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_DEVICE => {
-                writer.write_all(stringify!(CUFFT_INVALID_DEVICE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_PARSE_ERROR => {
-                writer.write_all(stringify!(CUFFT_PARSE_ERROR).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_NO_WORKSPACE => {
-                writer.write_all(stringify!(CUFFT_NO_WORKSPACE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_NOT_IMPLEMENTED => {
-                writer.write_all(stringify!(CUFFT_NOT_IMPLEMENTED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_LICENSE_ERROR => {
-                writer.write_all(stringify!(CUFFT_LICENSE_ERROR).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_NOT_SUPPORTED => {
-                writer.write_all(stringify!(CUFFT_NOT_SUPPORTED).as_bytes())
-            }
-            _ => write!(writer, "{}", self.0),
-        }
-    }
-}
 impl crate::CudaDisplay for cuda_types::cufft::cufftType_t {
     fn write(
         &self,
@@ -2232,3 +2169,36 @@ pub fn write_cufftXtSetWorkAreaPolicy(
     crate::CudaDisplay::write(&workSize, "cufftXtSetWorkAreaPolicy", arg_idx, writer)?;
     writer.write_all(b")")
 }
+impl crate::CudaDisplay for cuda_types::cufft::cufftResult {
+    fn write(
+        &self,
+        _fn_name: &'static str,
+        _index: usize,
+        writer: &mut (impl std::io::Write + ?Sized),
+    ) -> std::io::Result<()> {
+        match self {
+            Ok(()) => writer.write_all(b"CUFFT_SUCCESS"),
+            Err(err) => {
+                match err.0.get() {
+                    1 => writer.write_all("CUFFT_INVALID_PLAN".as_bytes()),
+                    2 => writer.write_all("CUFFT_ALLOC_FAILED".as_bytes()),
+                    3 => writer.write_all("CUFFT_INVALID_TYPE".as_bytes()),
+                    4 => writer.write_all("CUFFT_INVALID_VALUE".as_bytes()),
+                    5 => writer.write_all("CUFFT_INTERNAL_ERROR".as_bytes()),
+                    6 => writer.write_all("CUFFT_EXEC_FAILED".as_bytes()),
+                    7 => writer.write_all("CUFFT_SETUP_FAILED".as_bytes()),
+                    8 => writer.write_all("CUFFT_INVALID_SIZE".as_bytes()),
+                    9 => writer.write_all("CUFFT_UNALIGNED_DATA".as_bytes()),
+                    10 => writer.write_all("CUFFT_INCOMPLETE_PARAMETER_LIST".as_bytes()),
+                    11 => writer.write_all("CUFFT_INVALID_DEVICE".as_bytes()),
+                    12 => writer.write_all("CUFFT_PARSE_ERROR".as_bytes()),
+                    13 => writer.write_all("CUFFT_NO_WORKSPACE".as_bytes()),
+                    14 => writer.write_all("CUFFT_NOT_IMPLEMENTED".as_bytes()),
+                    15 => writer.write_all("CUFFT_LICENSE_ERROR".as_bytes()),
+                    16 => writer.write_all("CUFFT_NOT_SUPPORTED".as_bytes()),
+                    err => write!(writer, "{}", err),
+                }
+            }
+        }
+    }
+}

format/src/format_generated_sparse.rs

@@ -155,60 +155,6 @@ impl crate::CudaDisplay for cuda_types::cusparse::pruneInfo_t {
         }
     }
 }
-impl crate::CudaDisplay for cuda_types::cusparse::cusparseStatus_t {
-    fn write(
-        &self,
-        _fn_name: &'static str,
-        _index: usize,
-        writer: &mut (impl std::io::Write + ?Sized),
-    ) -> std::io::Result<()> {
-        match self {
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_SUCCESS => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_SUCCESS).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_NOT_INITIALIZED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_NOT_INITIALIZED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_ALLOC_FAILED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_ALLOC_FAILED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INVALID_VALUE => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_INVALID_VALUE).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_ARCH_MISMATCH => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_ARCH_MISMATCH).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_MAPPING_ERROR => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_MAPPING_ERROR).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_EXECUTION_FAILED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_EXECUTION_FAILED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INTERNAL_ERROR => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_INTERNAL_ERROR).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED => {
-                writer
-                    .write_all(
-                        stringify!(CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED).as_bytes(),
-                    )
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_ZERO_PIVOT => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_ZERO_PIVOT).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_NOT_SUPPORTED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_NOT_SUPPORTED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INSUFFICIENT_RESOURCES => {
-                writer
-                    .write_all(
-                        stringify!(CUSPARSE_STATUS_INSUFFICIENT_RESOURCES).as_bytes(),
-                    )
-            }
-            _ => write!(writer, "{}", self.0),
-        }
-    }
-}
 impl crate::CudaDisplay for cuda_types::cusparse::cusparsePointerMode_t {
     fn write(
         &self,
@@ -31120,3 +31066,41 @@ pub fn write_cusparseSpMMOp_destroyPlan(
     crate::CudaDisplay::write(&plan, "cusparseSpMMOp_destroyPlan", arg_idx, writer)?;
     writer.write_all(b")")
 }
+impl crate::CudaDisplay for cuda_types::cusparse::cusparseStatus_t {
+    fn write(
+        &self,
+        _fn_name: &'static str,
+        _index: usize,
+        writer: &mut (impl std::io::Write + ?Sized),
+    ) -> std::io::Result<()> {
+        match self {
+            Ok(()) => writer.write_all(b"CUSPARSE_STATUS_SUCCESS"),
+            Err(err) => {
+                match err.0.get() {
+                    1 => writer.write_all("CUSPARSE_STATUS_NOT_INITIALIZED".as_bytes()),
+                    2 => writer.write_all("CUSPARSE_STATUS_ALLOC_FAILED".as_bytes()),
+                    3 => writer.write_all("CUSPARSE_STATUS_INVALID_VALUE".as_bytes()),
+                    4 => writer.write_all("CUSPARSE_STATUS_ARCH_MISMATCH".as_bytes()),
+                    5 => writer.write_all("CUSPARSE_STATUS_MAPPING_ERROR".as_bytes()),
+                    6 => writer.write_all("CUSPARSE_STATUS_EXECUTION_FAILED".as_bytes()),
+                    7 => writer.write_all("CUSPARSE_STATUS_INTERNAL_ERROR".as_bytes()),
+                    8 => {
+                        writer
+                            .write_all(
+                                "CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED".as_bytes(),
+                            )
+                    }
+                    9 => writer.write_all("CUSPARSE_STATUS_ZERO_PIVOT".as_bytes()),
+                    10 => writer.write_all("CUSPARSE_STATUS_NOT_SUPPORTED".as_bytes()),
+                    11 => {
+                        writer
+                            .write_all(
+                                "CUSPARSE_STATUS_INSUFFICIENT_RESOURCES".as_bytes(),
+                            )
+                    }
+                    err => write!(writer, "{}", err),
+                }
+            }
+        }
+    }
+}

zluda_bindgen/src/main.rs

@@ -35,7 +35,7 @@ fn main() {
     generate_cublaslt(&crate_root);
     generate_cufft(&crate_root);
     generate_cusparse(&crate_root);
-    // generate_cudnn(&crate_root);
+    generate_cudnn(&crate_root);
 }
 
 fn generate_process_address_table(crate_root: &PathBuf, mut cuda_fns: Vec<Ident>) {

zluda_dump_common/src/lib.rs

@@ -1,4 +1,9 @@
-use cuda_types::cuda::{CUerror, CUresult, CUresultConsts, CUuuid};
+use cuda_types::{
+    cublas::cublasStatus_tConsts,
+    cuda::{CUerror, CUresult, CUresultConsts, CUuuid},
+    cufft::cufftResultConsts,
+    cusparse::cusparseStatus_tConsts,
+};
 use dark_api::ByteVecFfi;
 use std::{ffi::c_void, num::NonZero, ptr, sync::LazyLock};
 
@@ -124,15 +129,21 @@ impl<T> ReprUsize for *const T {
 
 impl ReprUsize for cuda_types::cublas::cublasStatus_t {
     fn to_usize(self) -> usize {
-        self.0 as usize
+        match self {
+            cuda_types::cublas::cublasStatus_t::SUCCESS => 0,
+            Err(err) => err.0.get() as usize,
+        }
     }
 
     fn from_usize(x: usize) -> Self {
-        Self(x as u32)
+        match NonZero::new(x as u32) {
+            None => Ok(()),
+            Some(err) => Err(cuda_types::cublas::cublasError_t(err)),
+        }
     }
 
     const INTERNAL_ERROR: usize =
-        cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INTERNAL_ERROR.0 as usize;
+        cuda_types::cublas::cublasError_t::INTERNAL_ERROR.0.get() as usize;
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
         let mut writer = Vec::new();
@@ -150,8 +161,9 @@ impl ReprUsize for cuda_types::cudnn9::cudnnStatus_t {
         Self(x as u32)
     }
 
-    const INTERNAL_ERROR: usize =
+    // TODO: handle this after cudnn fix
-        cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INTERNAL_ERROR.0 as usize;
+
+    const INTERNAL_ERROR: usize = 14;
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
         let mut writer = Vec::new();
@@ -240,13 +252,21 @@ impl ReprUsize for *mut std::ffi::c_void {
     }
 }
 
-impl ReprUsize for cuda_types::cufft::cufftResult_t {
+impl ReprUsize for cuda_types::cufft::cufftResult {
+    const INTERNAL_ERROR: usize = cuda_types::cufft::cufftError_t::INTERNAL_ERROR.0.get() as usize;
+
     fn to_usize(self) -> usize {
-        self.0 as usize
+        match self {
+            cuda_types::cufft::cufftResult::SUCCESS => 0,
+            Err(err) => err.0.get() as usize,
+        }
     }
 
     fn from_usize(x: usize) -> Self {
-        Self(x as u32)
+        match NonZero::new(x as u32) {
+            None => Ok(()),
+            Some(err) => Err(cuda_types::cufft::cufftError_t(err)),
+        }
     }
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
@@ -258,15 +278,22 @@ impl ReprUsize for cuda_types::cufft::cufftResult_t {
 
 impl ReprUsize for cuda_types::cusparse::cusparseStatus_t {
     fn to_usize(self) -> usize {
-        self.0 as usize
+        match self {
+            cuda_types::cusparse::cusparseStatus_t::SUCCESS => 0,
+            Err(err) => err.0.get() as usize,
+        }
     }
 
     fn from_usize(x: usize) -> Self {
-        Self(x as u32)
+        match NonZero::new(x as u32) {
+            None => Ok(()),
+            Some(err) => Err(cuda_types::cusparse::cusparseError_t(err)),
+        }
     }
 
-    const INTERNAL_ERROR: usize =
+    const INTERNAL_ERROR: usize = cuda_types::cusparse::cusparseError_t::INTERNAL_ERROR
-        cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INTERNAL_ERROR.0 as usize;
+        .0
+        .get() as usize;
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
         let mut writer = Vec::new();