Move zluda_dump to the new CUDA infrastructure

14 files changed, 3317 insertions, 2976 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 76f3277..6371981 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,8 @@
 [workspace]

 

 members = [

+    "cuda_base",

+    "cuda_types",

     "detours-sys",

     "hip_runtime-sys",

     "level_zero-sys",

diff --git a/cuda_base/Cargo.toml b/cuda_base/Cargo.toml
new file mode 100644
index 0000000..997a426
--- /dev/null
+++ b/cuda_base/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "cuda_base"
+version = "0.0.0"
+authors = ["Andrzej Janik <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+quote = "1.0"
+syn = { version = "1.0", features = ["full", "visit-mut"] }
+proc-macro2 = "1.0"
+rustc-hash = "1.1.0"
+
+[lib]
+proc-macro = true
diff --git a/cuda_base/README b/cuda_base/README
new file mode 100644
index 0000000..a284995
--- /dev/null
+++ b/cuda_base/README
@@ -0,0 +1 @@
+bindgen /usr/local/cuda/include/cuda.h -o src/cuda.rs --with-derive-eq --whitelist-function="^cu.*" --whitelist-var="^CU.*" --size_t-is-usize --default-enum-style=newtype --no-layout-tests --no-doc-comments --no-derive-debug --new-type-alias "^CUdevice_v\d+$|^CUdeviceptr_v\d+$" --must-use-type "cudaError_enum" -- -D__CUDA_API_VERSION_INTERNAL

diff --git a/zluda_dump/src/cuda.rs b/cuda_base/src/cuda.rs
index 3836137..a3a67c6 100644
--- a/zluda_dump/src/cuda.rs
+++ b/cuda_base/src/cuda.rs
@@ -1,15 +1,47 @@
-/* automatically generated by rust-bindgen 0.56.0 */
+/* automatically generated by rust-bindgen 0.59.2 */
 
-pub type __uint32_t = ::std::os::raw::c_uint;
-pub type __uint64_t = ::std::os::raw::c_ulong;
+pub const CUDA_VERSION: u32 = 11050;
+pub const CU_IPC_HANDLE_SIZE: u32 = 64;
+pub const CU_MEMHOSTALLOC_PORTABLE: u32 = 1;
+pub const CU_MEMHOSTALLOC_DEVICEMAP: u32 = 2;
+pub const CU_MEMHOSTALLOC_WRITECOMBINED: u32 = 4;
+pub const CU_MEMHOSTREGISTER_PORTABLE: u32 = 1;
+pub const CU_MEMHOSTREGISTER_DEVICEMAP: u32 = 2;
+pub const CU_MEMHOSTREGISTER_IOMEMORY: u32 = 4;
+pub const CU_MEMHOSTREGISTER_READ_ONLY: u32 = 8;
+pub const CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL: u32 = 1;
+pub const CUDA_EXTERNAL_MEMORY_DEDICATED: u32 = 1;
+pub const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC: u32 = 1;
+pub const CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC: u32 = 2;
+pub const CUDA_NVSCISYNC_ATTR_SIGNAL: u32 = 1;
+pub const CUDA_NVSCISYNC_ATTR_WAIT: u32 = 2;
+pub const CU_MEM_CREATE_USAGE_TILE_POOL: u32 = 1;
+pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC: u32 = 1;
+pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC: u32 = 2;
+pub const CUDA_ARRAY3D_LAYERED: u32 = 1;
+pub const CUDA_ARRAY3D_2DARRAY: u32 = 1;
+pub const CUDA_ARRAY3D_SURFACE_LDST: u32 = 2;
+pub const CUDA_ARRAY3D_CUBEMAP: u32 = 4;
+pub const CUDA_ARRAY3D_TEXTURE_GATHER: u32 = 8;
+pub const CUDA_ARRAY3D_DEPTH_TEXTURE: u32 = 16;
+pub const CUDA_ARRAY3D_COLOR_ATTACHMENT: u32 = 32;
+pub const CUDA_ARRAY3D_SPARSE: u32 = 64;
+pub const CU_TRSA_OVERRIDE_FORMAT: u32 = 1;
+pub const CU_TRSF_READ_AS_INTEGER: u32 = 1;
+pub const CU_TRSF_NORMALIZED_COORDINATES: u32 = 2;
+pub const CU_TRSF_SRGB: u32 = 16;
+pub const CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION: u32 = 32;
+pub const CU_PARAM_TR_DEFAULT: i32 = -1;
 pub type cuuint32_t = u32;
 pub type cuuint64_t = u64;
 #[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct CUdeviceptr(pub usize);
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUdeviceptr_v2(pub ::std::os::raw::c_ulonglong);
+pub type CUdeviceptr = CUdeviceptr_v2;
 #[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct CUdevice(pub ::std::os::raw::c_int);
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUdevice_v1(pub ::std::os::raw::c_int);
+pub type CUdevice = CUdevice_v1;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CUctx_st {
@@ -70,8 +102,10 @@ pub struct CUgraphicsResource_st {
     _unused: [u8; 0],
 }
 pub type CUgraphicsResource = *mut CUgraphicsResource_st;
-pub type CUtexObject = ::std::os::raw::c_ulonglong;
-pub type CUsurfObject = ::std::os::raw::c_ulonglong;
+pub type CUtexObject_v1 = ::std::os::raw::c_ulonglong;
+pub type CUtexObject = CUtexObject_v1;
+pub type CUsurfObject_v1 = ::std::os::raw::c_ulonglong;
+pub type CUsurfObject = CUsurfObject_v1;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CUextMemory_st {
@@ -103,23 +137,37 @@ pub struct CUgraphExec_st {
 }
 pub type CUgraphExec = *mut CUgraphExec_st;
 #[repr(C)]
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone)]
+pub struct CUmemPoolHandle_st {
+    _unused: [u8; 0],
+}
+pub type CUmemoryPool = *mut CUmemPoolHandle_st;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct CUuserObject_st {
+    _unused: [u8; 0],
+}
+pub type CUuserObject = *mut CUuserObject_st;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUuuid_st {
-    pub bytes: [::std::os::raw::c_uchar; 16usize],
+    pub bytes: [::std::os::raw::c_char; 16usize],
 }
 pub type CUuuid = CUuuid_st;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUipcEventHandle_st {
     pub reserved: [::std::os::raw::c_char; 64usize],
 }
-pub type CUipcEventHandle = CUipcEventHandle_st;
+pub type CUipcEventHandle_v1 = CUipcEventHandle_st;
+pub type CUipcEventHandle = CUipcEventHandle_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUipcMemHandle_st {
     pub reserved: [::std::os::raw::c_char; 64usize],
 }
-pub type CUipcMemHandle = CUipcMemHandle_st;
+pub type CUipcMemHandle_v1 = CUipcMemHandle_st;
+pub type CUipcMemHandle = CUipcMemHandle_v1;
 impl CUstreamBatchMemOpType_enum {
     pub const CU_STREAM_MEM_OP_WAIT_VALUE_32: CUstreamBatchMemOpType_enum =
         CUstreamBatchMemOpType_enum(1);
@@ -141,7 +189,7 @@ impl CUstreamBatchMemOpType_enum {
         CUstreamBatchMemOpType_enum(3);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUstreamBatchMemOpType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUstreamBatchMemOpType_enum as CUstreamBatchMemOpType;
 #[repr(C)]
@@ -152,7 +200,6 @@ pub union CUstreamBatchMemOpParams_union {
     pub writeValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
     pub flushRemoteWrites: CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
     pub pad: [cuuint64_t; 6usize],
-    _bindgen_union_align: [u64; 6usize],
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -169,7 +216,6 @@ pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st {
 pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 {
     pub value: cuuint32_t,
     pub value64: cuuint64_t,
-    _bindgen_union_align: u64,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -186,15 +232,15 @@ pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st {
 pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 {
     pub value: cuuint32_t,
     pub value64: cuuint64_t,
-    _bindgen_union_align: u64,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st {
     pub operation: CUstreamBatchMemOpType,
     pub flags: ::std::os::raw::c_uint,
 }
-pub type CUstreamBatchMemOpParams = CUstreamBatchMemOpParams_union;
+pub type CUstreamBatchMemOpParams_v1 = CUstreamBatchMemOpParams_union;
+pub type CUstreamBatchMemOpParams = CUstreamBatchMemOpParams_v1;
 impl CUarray_format_enum {
     pub const CU_AD_FORMAT_UNSIGNED_INT8: CUarray_format_enum = CUarray_format_enum(1);
 }
@@ -219,8 +265,89 @@ impl CUarray_format_enum {
 impl CUarray_format_enum {
     pub const CU_AD_FORMAT_FLOAT: CUarray_format_enum = CUarray_format_enum(32);
 }
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_NV12: CUarray_format_enum = CUarray_format_enum(176);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_UNORM_INT8X1: CUarray_format_enum = CUarray_format_enum(192);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_UNORM_INT8X2: CUarray_format_enum = CUarray_format_enum(193);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_UNORM_INT8X4: CUarray_format_enum = CUarray_format_enum(194);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_UNORM_INT16X1: CUarray_format_enum = CUarray_format_enum(195);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_UNORM_INT16X2: CUarray_format_enum = CUarray_format_enum(196);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_UNORM_INT16X4: CUarray_format_enum = CUarray_format_enum(197);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_SNORM_INT8X1: CUarray_format_enum = CUarray_format_enum(198);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_SNORM_INT8X2: CUarray_format_enum = CUarray_format_enum(199);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_SNORM_INT8X4: CUarray_format_enum = CUarray_format_enum(200);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_SNORM_INT16X1: CUarray_format_enum = CUarray_format_enum(201);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_SNORM_INT16X2: CUarray_format_enum = CUarray_format_enum(202);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_SNORM_INT16X4: CUarray_format_enum = CUarray_format_enum(203);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC1_UNORM: CUarray_format_enum = CUarray_format_enum(145);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC1_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(146);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC2_UNORM: CUarray_format_enum = CUarray_format_enum(147);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC2_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(148);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC3_UNORM: CUarray_format_enum = CUarray_format_enum(149);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC3_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(150);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC4_UNORM: CUarray_format_enum = CUarray_format_enum(151);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC4_SNORM: CUarray_format_enum = CUarray_format_enum(152);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC5_UNORM: CUarray_format_enum = CUarray_format_enum(153);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC5_SNORM: CUarray_format_enum = CUarray_format_enum(154);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC6H_UF16: CUarray_format_enum = CUarray_format_enum(155);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC6H_SF16: CUarray_format_enum = CUarray_format_enum(156);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC7_UNORM: CUarray_format_enum = CUarray_format_enum(157);
+}
+impl CUarray_format_enum {
+    pub const CU_AD_FORMAT_BC7_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(158);
+}
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUarray_format_enum(pub ::std::os::raw::c_uint);
 pub use self::CUarray_format_enum as CUarray_format;
 impl CUaddress_mode_enum {
@@ -236,7 +363,7 @@ impl CUaddress_mode_enum {
     pub const CU_TR_ADDRESS_MODE_BORDER: CUaddress_mode_enum = CUaddress_mode_enum(3);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUaddress_mode_enum(pub ::std::os::raw::c_uint);
 pub use self::CUaddress_mode_enum as CUaddress_mode;
 impl CUfilter_mode_enum {
@@ -246,7 +373,7 @@ impl CUfilter_mode_enum {
     pub const CU_TR_FILTER_MODE_LINEAR: CUfilter_mode_enum = CUfilter_mode_enum(1);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUfilter_mode_enum(pub ::std::os::raw::c_uint);
 pub use self::CUfilter_mode_enum as CUfilter_mode;
 impl CUdevice_attribute_enum {
@@ -672,6 +799,10 @@ impl CUdevice_attribute_enum {
         CUdevice_attribute_enum(102);
 }
 impl CUdevice_attribute_enum {
+    pub const CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED: CUdevice_attribute_enum =
+        CUdevice_attribute_enum(102);
+}
+impl CUdevice_attribute_enum {
     pub const CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED:
         CUdevice_attribute_enum = CUdevice_attribute_enum(103);
 }
@@ -716,14 +847,38 @@ impl CUdevice_attribute_enum {
         CUdevice_attribute_enum(113);
 }
 impl CUdevice_attribute_enum {
-    pub const CU_DEVICE_ATTRIBUTE_MAX: CUdevice_attribute_enum = CUdevice_attribute_enum(114);
+    pub const CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED: CUdevice_attribute_enum =
+        CUdevice_attribute_enum(114);
+}
+impl CUdevice_attribute_enum {
+    pub const CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED: CUdevice_attribute_enum =
+        CUdevice_attribute_enum(115);
+}
+impl CUdevice_attribute_enum {
+    pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED: CUdevice_attribute_enum =
+        CUdevice_attribute_enum(116);
+}
+impl CUdevice_attribute_enum {
+    pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS: CUdevice_attribute_enum =
+        CUdevice_attribute_enum(117);
+}
+impl CUdevice_attribute_enum {
+    pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING: CUdevice_attribute_enum =
+        CUdevice_attribute_enum(118);
+}
+impl CUdevice_attribute_enum {
+    pub const CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES: CUdevice_attribute_enum =
+        CUdevice_attribute_enum(119);
+}
+impl CUdevice_attribute_enum {
+    pub const CU_DEVICE_ATTRIBUTE_MAX: CUdevice_attribute_enum = CUdevice_attribute_enum(120);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUdevice_attribute_enum(pub ::std::os::raw::c_uint);
 pub use self::CUdevice_attribute_enum as CUdevice_attribute;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUdevprop_st {
     pub maxThreadsPerBlock: ::std::os::raw::c_int,
     pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
@@ -736,7 +891,8 @@ pub struct CUdevprop_st {
     pub clockRate: ::std::os::raw::c_int,
     pub textureAlign: ::std::os::raw::c_int,
 }
-pub type CUdevprop = CUdevprop_st;
+pub type CUdevprop_v1 = CUdevprop_st;
+pub type CUdevprop = CUdevprop_v1;
 impl CUpointer_attribute_enum {
     pub const CU_POINTER_ATTRIBUTE_CONTEXT: CUpointer_attribute_enum = CUpointer_attribute_enum(1);
 }
@@ -799,8 +955,12 @@ impl CUpointer_attribute_enum {
     pub const CU_POINTER_ATTRIBUTE_ACCESS_FLAGS: CUpointer_attribute_enum =
         CUpointer_attribute_enum(16);
 }
+impl CUpointer_attribute_enum {
+    pub const CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE: CUpointer_attribute_enum =
+        CUpointer_attribute_enum(17);
+}
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUpointer_attribute_enum(pub ::std::os::raw::c_uint);
 pub use self::CUpointer_attribute_enum as CUpointer_attribute;
 impl CUfunction_attribute_enum {
@@ -846,7 +1006,7 @@ impl CUfunction_attribute_enum {
     pub const CU_FUNC_ATTRIBUTE_MAX: CUfunction_attribute_enum = CUfunction_attribute_enum(10);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUfunction_attribute_enum(pub ::std::os::raw::c_uint);
 pub use self::CUfunction_attribute_enum as CUfunction_attribute;
 impl CUfunc_cache_enum {
@@ -862,7 +1022,7 @@ impl CUfunc_cache_enum {
     pub const CU_FUNC_CACHE_PREFER_EQUAL: CUfunc_cache_enum = CUfunc_cache_enum(3);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUfunc_cache_enum(pub ::std::os::raw::c_uint);
 pub use self::CUfunc_cache_enum as CUfunc_cache;
 impl CUsharedconfig_enum {
@@ -877,7 +1037,7 @@ impl CUsharedconfig_enum {
         CUsharedconfig_enum(2);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUsharedconfig_enum(pub ::std::os::raw::c_uint);
 pub use self::CUsharedconfig_enum as CUsharedconfig;
 impl CUmemorytype_enum {
@@ -893,7 +1053,7 @@ impl CUmemorytype_enum {
     pub const CU_MEMORYTYPE_UNIFIED: CUmemorytype_enum = CUmemorytype_enum(4);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemorytype_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemorytype_enum as CUmemorytype;
 impl CUmem_advise_enum {
@@ -915,7 +1075,7 @@ impl CUmem_advise_enum {
     pub const CU_MEM_ADVISE_UNSET_ACCESSED_BY: CUmem_advise_enum = CUmem_advise_enum(6);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmem_advise_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmem_advise_enum as CUmem_advise;
 impl CUmem_range_attribute_enum {
@@ -935,7 +1095,7 @@ impl CUmem_range_attribute_enum {
         CUmem_range_attribute_enum(4);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmem_range_attribute_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmem_range_attribute_enum as CUmem_range_attribute;
 impl CUjit_option_enum {
@@ -999,10 +1159,25 @@ impl CUjit_option_enum {
     pub const CU_JIT_GLOBAL_SYMBOL_COUNT: CUjit_option_enum = CUjit_option_enum(19);
 }
 impl CUjit_option_enum {
-    pub const CU_JIT_NUM_OPTIONS: CUjit_option_enum = CUjit_option_enum(20);
+    pub const CU_JIT_LTO: CUjit_option_enum = CUjit_option_enum(20);
+}
+impl CUjit_option_enum {
+    pub const CU_JIT_FTZ: CUjit_option_enum = CUjit_option_enum(21);
+}
+impl CUjit_option_enum {
+    pub const CU_JIT_PREC_DIV: CUjit_option_enum = CUjit_option_enum(22);
+}
+impl CUjit_option_enum {
+    pub const CU_JIT_PREC_SQRT: CUjit_option_enum = CUjit_option_enum(23);
+}
+impl CUjit_option_enum {
+    pub const CU_JIT_FMA: CUjit_option_enum = CUjit_option_enum(24);
+}
+impl CUjit_option_enum {
+    pub const CU_JIT_NUM_OPTIONS: CUjit_option_enum = CUjit_option_enum(25);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUjit_option_enum(pub ::std::os::raw::c_uint);
 pub use self::CUjit_option_enum as CUjit_option;
 impl CUjitInputType_enum {
@@ -1021,10 +1196,13 @@ impl CUjitInputType_enum {
     pub const CU_JIT_INPUT_LIBRARY: CUjitInputType_enum = CUjitInputType_enum(4);
 }
 impl CUjitInputType_enum {
-    pub const CU_JIT_NUM_INPUT_TYPES: CUjitInputType_enum = CUjitInputType_enum(5);
+    pub const CU_JIT_INPUT_NVVM: CUjitInputType_enum = CUjitInputType_enum(5);
+}
+impl CUjitInputType_enum {
+    pub const CU_JIT_NUM_INPUT_TYPES: CUjitInputType_enum = CUjitInputType_enum(6);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUjitInputType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUjitInputType_enum as CUjitInputType;
 #[repr(C)]
@@ -1058,7 +1236,7 @@ impl CUlimit_enum {
     pub const CU_LIMIT_MAX: CUlimit_enum = CUlimit_enum(7);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUlimit_enum(pub ::std::os::raw::c_uint);
 pub use self::CUlimit_enum as CUlimit;
 impl CUresourcetype_enum {
@@ -1074,7 +1252,7 @@ impl CUresourcetype_enum {
     pub const CU_RESOURCE_TYPE_PITCH2D: CUresourcetype_enum = CUresourcetype_enum(3);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUresourcetype_enum(pub ::std::os::raw::c_uint);
 pub use self::CUresourcetype_enum as CUresourcetype;
 pub type CUhostFn =
@@ -1089,11 +1267,11 @@ impl CUaccessProperty_enum {
     pub const CU_ACCESS_PROPERTY_PERSISTING: CUaccessProperty_enum = CUaccessProperty_enum(2);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUaccessProperty_enum(pub ::std::os::raw::c_uint);
 pub use self::CUaccessProperty_enum as CUaccessProperty;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq)]
 pub struct CUaccessPolicyWindow_st {
     pub base_ptr: *mut ::std::os::raw::c_void,
     pub num_bytes: usize,
@@ -1101,9 +1279,10 @@ pub struct CUaccessPolicyWindow_st {
     pub hitProp: CUaccessProperty,
     pub missProp: CUaccessProperty,
 }
-pub type CUaccessPolicyWindow = CUaccessPolicyWindow_st;
+pub type CUaccessPolicyWindow_v1 = CUaccessPolicyWindow_st;
+pub type CUaccessPolicyWindow = CUaccessPolicyWindow_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_KERNEL_NODE_PARAMS_st {
     pub func: CUfunction,
     pub gridDimX: ::std::os::raw::c_uint,
@@ -1116,9 +1295,10 @@ pub struct CUDA_KERNEL_NODE_PARAMS_st {
     pub kernelParams: *mut *mut ::std::os::raw::c_void,
     pub extra: *mut *mut ::std::os::raw::c_void,
 }
-pub type CUDA_KERNEL_NODE_PARAMS = CUDA_KERNEL_NODE_PARAMS_st;
+pub type CUDA_KERNEL_NODE_PARAMS_v1 = CUDA_KERNEL_NODE_PARAMS_st;
+pub type CUDA_KERNEL_NODE_PARAMS = CUDA_KERNEL_NODE_PARAMS_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_MEMSET_NODE_PARAMS_st {
     pub dst: CUdeviceptr,
     pub pitch: usize,
@@ -1127,14 +1307,16 @@ pub struct CUDA_MEMSET_NODE_PARAMS_st {
     pub width: usize,
     pub height: usize,
 }
-pub type CUDA_MEMSET_NODE_PARAMS = CUDA_MEMSET_NODE_PARAMS_st;
+pub type CUDA_MEMSET_NODE_PARAMS_v1 = CUDA_MEMSET_NODE_PARAMS_st;
+pub type CUDA_MEMSET_NODE_PARAMS = CUDA_MEMSET_NODE_PARAMS_v1;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CUDA_HOST_NODE_PARAMS_st {
     pub fn_: CUhostFn,
     pub userData: *mut ::std::os::raw::c_void,
 }
-pub type CUDA_HOST_NODE_PARAMS = CUDA_HOST_NODE_PARAMS_st;
+pub type CUDA_HOST_NODE_PARAMS_v1 = CUDA_HOST_NODE_PARAMS_st;
+pub type CUDA_HOST_NODE_PARAMS = CUDA_HOST_NODE_PARAMS_v1;
 impl CUgraphNodeType_enum {
     pub const CU_GRAPH_NODE_TYPE_KERNEL: CUgraphNodeType_enum = CUgraphNodeType_enum(0);
 }
@@ -1159,8 +1341,20 @@ impl CUgraphNodeType_enum {
 impl CUgraphNodeType_enum {
     pub const CU_GRAPH_NODE_TYPE_EVENT_RECORD: CUgraphNodeType_enum = CUgraphNodeType_enum(7);
 }
+impl CUgraphNodeType_enum {
+    pub const CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL: CUgraphNodeType_enum = CUgraphNodeType_enum(8);
+}
+impl CUgraphNodeType_enum {
+    pub const CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT: CUgraphNodeType_enum = CUgraphNodeType_enum(9);
+}
+impl CUgraphNodeType_enum {
+    pub const CU_GRAPH_NODE_TYPE_MEM_ALLOC: CUgraphNodeType_enum = CUgraphNodeType_enum(10);
+}
+impl CUgraphNodeType_enum {
+    pub const CU_GRAPH_NODE_TYPE_MEM_FREE: CUgraphNodeType_enum = CUgraphNodeType_enum(11);
+}
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUgraphNodeType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUgraphNodeType_enum as CUgraphNodeType;
 impl CUsynchronizationPolicy_enum {
@@ -1177,7 +1371,7 @@ impl CUsynchronizationPolicy_enum {
         CUsynchronizationPolicy_enum(4);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUsynchronizationPolicy_enum(pub ::std::os::raw::c_uint);
 pub use self::CUsynchronizationPolicy_enum as CUsynchronizationPolicy;
 impl CUkernelNodeAttrID_enum {
@@ -1189,7 +1383,7 @@ impl CUkernelNodeAttrID_enum {
         CUkernelNodeAttrID_enum(2);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUkernelNodeAttrID_enum(pub ::std::os::raw::c_uint);
 pub use self::CUkernelNodeAttrID_enum as CUkernelNodeAttrID;
 #[repr(C)]
@@ -1197,9 +1391,9 @@ pub use self::CUkernelNodeAttrID_enum as CUkernelNodeAttrID;
 pub union CUkernelNodeAttrValue_union {
     pub accessPolicyWindow: CUaccessPolicyWindow,
     pub cooperative: ::std::os::raw::c_int,
-    _bindgen_union_align: [u64; 4usize],
 }
-pub type CUkernelNodeAttrValue = CUkernelNodeAttrValue_union;
+pub type CUkernelNodeAttrValue_v1 = CUkernelNodeAttrValue_union;
+pub type CUkernelNodeAttrValue = CUkernelNodeAttrValue_v1;
 impl CUstreamCaptureStatus_enum {
     pub const CU_STREAM_CAPTURE_STATUS_NONE: CUstreamCaptureStatus_enum =
         CUstreamCaptureStatus_enum(0);
@@ -1213,7 +1407,7 @@ impl CUstreamCaptureStatus_enum {
         CUstreamCaptureStatus_enum(2);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUstreamCaptureStatus_enum(pub ::std::os::raw::c_uint);
 pub use self::CUstreamCaptureStatus_enum as CUstreamCaptureStatus;
 impl CUstreamCaptureMode_enum {
@@ -1228,7 +1422,7 @@ impl CUstreamCaptureMode_enum {
         CUstreamCaptureMode_enum(2);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUstreamCaptureMode_enum(pub ::std::os::raw::c_uint);
 pub use self::CUstreamCaptureMode_enum as CUstreamCaptureMode;
 impl CUstreamAttrID_enum {
@@ -1240,7 +1434,7 @@ impl CUstreamAttrID_enum {
         CUstreamAttrID_enum(3);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUstreamAttrID_enum(pub ::std::os::raw::c_uint);
 pub use self::CUstreamAttrID_enum as CUstreamAttrID;
 #[repr(C)]
@@ -1248,9 +1442,39 @@ pub use self::CUstreamAttrID_enum as CUstreamAttrID;
 pub union CUstreamAttrValue_union {
     pub accessPolicyWindow: CUaccessPolicyWindow,
     pub syncPolicy: CUsynchronizationPolicy,
-    _bindgen_union_align: [u64; 4usize],
 }
-pub type CUstreamAttrValue = CUstreamAttrValue_union;
+pub type CUstreamAttrValue_v1 = CUstreamAttrValue_union;
+pub type CUstreamAttrValue = CUstreamAttrValue_v1;
+impl CUexecAffinityType_enum {
+    pub const CU_EXEC_AFFINITY_TYPE_SM_COUNT: CUexecAffinityType_enum = CUexecAffinityType_enum(0);
+}
+impl CUexecAffinityType_enum {
+    pub const CU_EXEC_AFFINITY_TYPE_MAX: CUexecAffinityType_enum = CUexecAffinityType_enum(1);
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct CUexecAffinityType_enum(pub ::std::os::raw::c_uint);
+pub use self::CUexecAffinityType_enum as CUexecAffinityType;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUexecAffinitySmCount_st {
+    pub val: ::std::os::raw::c_uint,
+}
+pub type CUexecAffinitySmCount_v1 = CUexecAffinitySmCount_st;
+pub type CUexecAffinitySmCount = CUexecAffinitySmCount_v1;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct CUexecAffinityParam_st {
+    pub type_: CUexecAffinityType,
+    pub param: CUexecAffinityParam_st__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union CUexecAffinityParam_st__bindgen_ty_1 {
+    pub smCount: CUexecAffinitySmCount,
+}
+pub type CUexecAffinityParam_v1 = CUexecAffinityParam_st;
+pub type CUexecAffinityParam = CUexecAffinityParam_v1;
 impl cudaError_enum {
     pub const CUDA_SUCCESS: cudaError_enum = cudaError_enum(0);
 }
@@ -1354,6 +1578,12 @@ impl cudaError_enum {
     pub const CUDA_ERROR_UNSUPPORTED_PTX_VERSION: cudaError_enum = cudaError_enum(222);
 }
 impl cudaError_enum {
+    pub const CUDA_ERROR_JIT_COMPILATION_DISABLED: cudaError_enum = cudaError_enum(223);
+}
+impl cudaError_enum {
+    pub const CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY: cudaError_enum = cudaError_enum(224);
+}
+impl cudaError_enum {
     pub const CUDA_ERROR_INVALID_SOURCE: cudaError_enum = cudaError_enum(300);
 }
 impl cudaError_enum {
@@ -1453,6 +1683,21 @@ impl cudaError_enum {
     pub const CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE: cudaError_enum = cudaError_enum(804);
 }
 impl cudaError_enum {
+    pub const CUDA_ERROR_MPS_CONNECTION_FAILED: cudaError_enum = cudaError_enum(805);
+}
+impl cudaError_enum {
+    pub const CUDA_ERROR_MPS_RPC_FAILURE: cudaError_enum = cudaError_enum(806);
+}
+impl cudaError_enum {
+    pub const CUDA_ERROR_MPS_SERVER_NOT_READY: cudaError_enum = cudaError_enum(807);
+}
+impl cudaError_enum {
+    pub const CUDA_ERROR_MPS_MAX_CLIENTS_REACHED: cudaError_enum = cudaError_enum(808);
+}
+impl cudaError_enum {
+    pub const CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED: cudaError_enum = cudaError_enum(809);
+}
+impl cudaError_enum {
     pub const CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED: cudaError_enum = cudaError_enum(900);
 }
 impl cudaError_enum {
@@ -1486,10 +1731,14 @@ impl cudaError_enum {
     pub const CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE: cudaError_enum = cudaError_enum(910);
 }
 impl cudaError_enum {
+    pub const CUDA_ERROR_EXTERNAL_DEVICE: cudaError_enum = cudaError_enum(911);
+}
+impl cudaError_enum {
     pub const CUDA_ERROR_UNKNOWN: cudaError_enum = cudaError_enum(999);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)]
+#[must_use]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct cudaError_enum(pub ::std::os::raw::c_uint);
 pub use self::cudaError_enum as CUresult;
 impl CUdevice_P2PAttribute_enum {
@@ -1513,7 +1762,7 @@ impl CUdevice_P2PAttribute_enum {
         CUdevice_P2PAttribute_enum(4);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUdevice_P2PAttribute_enum(pub ::std::os::raw::c_uint);
 pub use self::CUdevice_P2PAttribute_enum as CUdevice_P2PAttribute;
 pub type CUstreamCallback = ::std::option::Option<
@@ -1526,7 +1775,7 @@ pub type CUstreamCallback = ::std::option::Option<
 pub type CUoccupancyB2DSize =
     ::std::option::Option<unsafe extern "C" fn(blockSize: ::std::os::raw::c_int) -> usize>;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_MEMCPY2D_st {
     pub srcXInBytes: usize,
     pub srcY: usize,
@@ -1545,9 +1794,10 @@ pub struct CUDA_MEMCPY2D_st {
     pub WidthInBytes: usize,
     pub Height: usize,
 }
-pub type CUDA_MEMCPY2D = CUDA_MEMCPY2D_st;
+pub type CUDA_MEMCPY2D_v2 = CUDA_MEMCPY2D_st;
+pub type CUDA_MEMCPY2D = CUDA_MEMCPY2D_v2;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_MEMCPY3D_st {
     pub srcXInBytes: usize,
     pub srcY: usize,
@@ -1575,9 +1825,10 @@ pub struct CUDA_MEMCPY3D_st {
     pub Height: usize,
     pub Depth: usize,
 }
-pub type CUDA_MEMCPY3D = CUDA_MEMCPY3D_st;
+pub type CUDA_MEMCPY3D_v2 = CUDA_MEMCPY3D_st;
+pub type CUDA_MEMCPY3D = CUDA_MEMCPY3D_v2;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_MEMCPY3D_PEER_st {
     pub srcXInBytes: usize,
     pub srcY: usize,
@@ -1605,18 +1856,20 @@ pub struct CUDA_MEMCPY3D_PEER_st {
     pub Height: usize,
     pub Depth: usize,
 }
-pub type CUDA_MEMCPY3D_PEER = CUDA_MEMCPY3D_PEER_st;
+pub type CUDA_MEMCPY3D_PEER_v1 = CUDA_MEMCPY3D_PEER_st;
+pub type CUDA_MEMCPY3D_PEER = CUDA_MEMCPY3D_PEER_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_ARRAY_DESCRIPTOR_st {
     pub Width: usize,
     pub Height: usize,
     pub Format: CUarray_format,
     pub NumChannels: ::std::os::raw::c_uint,
 }
-pub type CUDA_ARRAY_DESCRIPTOR = CUDA_ARRAY_DESCRIPTOR_st;
+pub type CUDA_ARRAY_DESCRIPTOR_v2 = CUDA_ARRAY_DESCRIPTOR_st;
+pub type CUDA_ARRAY_DESCRIPTOR = CUDA_ARRAY_DESCRIPTOR_v2;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_ARRAY3D_DESCRIPTOR_st {
     pub Width: usize,
     pub Height: usize,
@@ -1625,9 +1878,10 @@ pub struct CUDA_ARRAY3D_DESCRIPTOR_st {
     pub NumChannels: ::std::os::raw::c_uint,
     pub Flags: ::std::os::raw::c_uint,
 }
-pub type CUDA_ARRAY3D_DESCRIPTOR = CUDA_ARRAY3D_DESCRIPTOR_st;
+pub type CUDA_ARRAY3D_DESCRIPTOR_v2 = CUDA_ARRAY3D_DESCRIPTOR_st;
+pub type CUDA_ARRAY3D_DESCRIPTOR = CUDA_ARRAY3D_DESCRIPTOR_v2;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st {
     pub tileExtent: CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1,
     pub miptailFirstLevel: ::std::os::raw::c_uint,
@@ -1636,13 +1890,14 @@ pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st {
     pub reserved: [::std::os::raw::c_uint; 4usize],
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1 {
     pub width: ::std::os::raw::c_uint,
     pub height: ::std::os::raw::c_uint,
     pub depth: ::std::os::raw::c_uint,
 }
-pub type CUDA_ARRAY_SPARSE_PROPERTIES = CUDA_ARRAY_SPARSE_PROPERTIES_st;
+pub type CUDA_ARRAY_SPARSE_PROPERTIES_v1 = CUDA_ARRAY_SPARSE_PROPERTIES_st;
+pub type CUDA_ARRAY_SPARSE_PROPERTIES = CUDA_ARRAY_SPARSE_PROPERTIES_v1;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CUDA_RESOURCE_DESC_st {
@@ -1658,20 +1913,19 @@ pub union CUDA_RESOURCE_DESC_st__bindgen_ty_1 {
     pub linear: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
     pub pitch2D: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
     pub reserved: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
-    _bindgen_union_align: [u64; 16usize],
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
     pub hArray: CUarray,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
     pub hMipmappedArray: CUmipmappedArray,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
     pub devPtr: CUdeviceptr,
     pub format: CUarray_format,
@@ -1679,7 +1933,7 @@ pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
     pub sizeInBytes: usize,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
     pub devPtr: CUdeviceptr,
     pub format: CUarray_format,
@@ -1689,13 +1943,14 @@ pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
     pub pitchInBytes: usize,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
     pub reserved: [::std::os::raw::c_int; 32usize],
 }
-pub type CUDA_RESOURCE_DESC = CUDA_RESOURCE_DESC_st;
+pub type CUDA_RESOURCE_DESC_v1 = CUDA_RESOURCE_DESC_st;
+pub type CUDA_RESOURCE_DESC = CUDA_RESOURCE_DESC_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq)]
 pub struct CUDA_TEXTURE_DESC_st {
     pub addressMode: [CUaddress_mode; 3usize],
     pub filterMode: CUfilter_mode,
@@ -1708,7 +1963,8 @@ pub struct CUDA_TEXTURE_DESC_st {
     pub borderColor: [f32; 4usize],
     pub reserved: [::std::os::raw::c_int; 12usize],
 }
-pub type CUDA_TEXTURE_DESC = CUDA_TEXTURE_DESC_st;
+pub type CUDA_TEXTURE_DESC_v1 = CUDA_TEXTURE_DESC_st;
+pub type CUDA_TEXTURE_DESC = CUDA_TEXTURE_DESC_v1;
 impl CUresourceViewFormat_enum {
     pub const CU_RES_VIEW_FORMAT_NONE: CUresourceViewFormat_enum = CUresourceViewFormat_enum(0);
 }
@@ -1843,11 +2099,11 @@ impl CUresourceViewFormat_enum {
         CUresourceViewFormat_enum(34);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUresourceViewFormat_enum(pub ::std::os::raw::c_uint);
 pub use self::CUresourceViewFormat_enum as CUresourceViewFormat;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_RESOURCE_VIEW_DESC_st {
     pub format: CUresourceViewFormat,
     pub width: usize,
@@ -1859,9 +2115,10 @@ pub struct CUDA_RESOURCE_VIEW_DESC_st {
     pub lastLayer: ::std::os::raw::c_uint,
     pub reserved: [::std::os::raw::c_uint; 16usize],
 }
-pub type CUDA_RESOURCE_VIEW_DESC = CUDA_RESOURCE_VIEW_DESC_st;
+pub type CUDA_RESOURCE_VIEW_DESC_v1 = CUDA_RESOURCE_VIEW_DESC_st;
+pub type CUDA_RESOURCE_VIEW_DESC = CUDA_RESOURCE_VIEW_DESC_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_LAUNCH_PARAMS_st {
     pub function: CUfunction,
     pub gridDimX: ::std::os::raw::c_uint,
@@ -1874,7 +2131,8 @@ pub struct CUDA_LAUNCH_PARAMS_st {
     pub hStream: CUstream,
     pub kernelParams: *mut *mut ::std::os::raw::c_void,
 }
-pub type CUDA_LAUNCH_PARAMS = CUDA_LAUNCH_PARAMS_st;
+pub type CUDA_LAUNCH_PARAMS_v1 = CUDA_LAUNCH_PARAMS_st;
+pub type CUDA_LAUNCH_PARAMS = CUDA_LAUNCH_PARAMS_v1;
 impl CUexternalMemoryHandleType_enum {
     pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: CUexternalMemoryHandleType_enum =
         CUexternalMemoryHandleType_enum(1);
@@ -1908,7 +2166,7 @@ impl CUexternalMemoryHandleType_enum {
         CUexternalMemoryHandleType_enum(8);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUexternalMemoryHandleType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUexternalMemoryHandleType_enum as CUexternalMemoryHandleType;
 #[repr(C)]
@@ -1926,33 +2184,36 @@ pub union CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1 {
     pub fd: ::std::os::raw::c_int,
     pub win32: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
     pub nvSciBufObject: *const ::std::os::raw::c_void,
-    _bindgen_union_align: [u64; 2usize],
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
     pub handle: *mut ::std::os::raw::c_void,
     pub name: *const ::std::os::raw::c_void,
 }
-pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st;
+pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1 = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st;
+pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st {
     pub offset: ::std::os::raw::c_ulonglong,
     pub size: ::std::os::raw::c_ulonglong,
     pub flags: ::std::os::raw::c_uint,
     pub reserved: [::std::os::raw::c_uint; 16usize],
 }
-pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st;
+pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1 = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st;
+pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
     pub offset: ::std::os::raw::c_ulonglong,
     pub arrayDesc: CUDA_ARRAY3D_DESCRIPTOR,
     pub numLevels: ::std::os::raw::c_uint,
     pub reserved: [::std::os::raw::c_uint; 16usize],
 }
-pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC = CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st;
+pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1 =
+    CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st;
+pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC = CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1;
 impl CUexternalSemaphoreHandleType_enum {
     pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: CUexternalSemaphoreHandleType_enum =
         CUexternalSemaphoreHandleType_enum(1);
@@ -1985,8 +2246,16 @@ impl CUexternalSemaphoreHandleType_enum {
     pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT:
         CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(8);
 }
+impl CUexternalSemaphoreHandleType_enum {
+    pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD:
+        CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(9);
+}
+impl CUexternalSemaphoreHandleType_enum {
+    pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32:
+        CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(10);
+}
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUexternalSemaphoreHandleType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUexternalSemaphoreHandleType_enum as CUexternalSemaphoreHandleType;
 #[repr(C)]
@@ -2003,15 +2272,15 @@ pub union CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1 {
     pub fd: ::std::os::raw::c_int,
     pub win32: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
     pub nvSciSyncObj: *const ::std::os::raw::c_void,
-    _bindgen_union_align: [u64; 2usize],
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
     pub handle: *mut ::std::os::raw::c_void,
     pub name: *const ::std::os::raw::c_void,
 }
-pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st;
+pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1 = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st;
+pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st {
@@ -2028,7 +2297,7 @@ pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1 {
     pub reserved: [::std::os::raw::c_uint; 12usize],
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1 {
     pub value: ::std::os::raw::c_ulonglong,
 }
@@ -2037,14 +2306,14 @@ pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1
 pub union CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
     pub fence: *mut ::std::os::raw::c_void,
     pub reserved: ::std::os::raw::c_ulonglong,
-    _bindgen_union_align: u64,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3 {
     pub key: ::std::os::raw::c_ulonglong,
 }
-pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st;
+pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1 = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st;
+pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st {
@@ -2061,7 +2330,7 @@ pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1 {
     pub reserved: [::std::os::raw::c_uint; 10usize],
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1 {
     pub value: ::std::os::raw::c_ulonglong,
 }
@@ -2070,16 +2339,39 @@ pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1 {
 pub union CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
     pub fence: *mut ::std::os::raw::c_void,
     pub reserved: ::std::os::raw::c_ulonglong,
-    _bindgen_union_align: u64,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3 {
     pub key: ::std::os::raw::c_ulonglong,
     pub timeoutMs: ::std::os::raw::c_uint,
 }
-pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st;
-pub type CUmemGenericAllocationHandle = ::std::os::raw::c_ulonglong;
+pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1 = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st;
+pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st {
+    pub extSemArray: *mut CUexternalSemaphore,
+    pub paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,
+    pub numExtSems: ::std::os::raw::c_uint,
+}
+pub type CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1 = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st;
+pub type CUDA_EXT_SEM_SIGNAL_NODE_PARAMS = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_st {
+    pub extSemArray: *mut CUexternalSemaphore,
+    pub paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,
+    pub numExtSems: ::std::os::raw::c_uint,
+}
+pub type CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1 = CUDA_EXT_SEM_WAIT_NODE_PARAMS_st;
+pub type CUDA_EXT_SEM_WAIT_NODE_PARAMS = CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1;
+pub type CUmemGenericAllocationHandle_v1 = ::std::os::raw::c_ulonglong;
+pub type CUmemGenericAllocationHandle = CUmemGenericAllocationHandle_v1;
+impl CUmemAllocationHandleType_enum {
+    pub const CU_MEM_HANDLE_TYPE_NONE: CUmemAllocationHandleType_enum =
+        CUmemAllocationHandleType_enum(0);
+}
 impl CUmemAllocationHandleType_enum {
     pub const CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR: CUmemAllocationHandleType_enum =
         CUmemAllocationHandleType_enum(1);
@@ -2094,10 +2386,10 @@ impl CUmemAllocationHandleType_enum {
 }
 impl CUmemAllocationHandleType_enum {
     pub const CU_MEM_HANDLE_TYPE_MAX: CUmemAllocationHandleType_enum =
-        CUmemAllocationHandleType_enum(4294967295);
+        CUmemAllocationHandleType_enum(2147483647);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemAllocationHandleType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemAllocationHandleType_enum as CUmemAllocationHandleType;
 impl CUmemAccess_flags_enum {
@@ -2112,10 +2404,10 @@ impl CUmemAccess_flags_enum {
 }
 impl CUmemAccess_flags_enum {
     pub const CU_MEM_ACCESS_FLAGS_PROT_MAX: CUmemAccess_flags_enum =
-        CUmemAccess_flags_enum(4294967295);
+        CUmemAccess_flags_enum(2147483647);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemAccess_flags_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemAccess_flags_enum as CUmemAccess_flags;
 impl CUmemLocationType_enum {
@@ -2125,10 +2417,10 @@ impl CUmemLocationType_enum {
     pub const CU_MEM_LOCATION_TYPE_DEVICE: CUmemLocationType_enum = CUmemLocationType_enum(1);
 }
 impl CUmemLocationType_enum {
-    pub const CU_MEM_LOCATION_TYPE_MAX: CUmemLocationType_enum = CUmemLocationType_enum(4294967295);
+    pub const CU_MEM_LOCATION_TYPE_MAX: CUmemLocationType_enum = CUmemLocationType_enum(2147483647);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemLocationType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemLocationType_enum as CUmemLocationType;
 impl CUmemAllocationType_enum {
@@ -2140,10 +2432,10 @@ impl CUmemAllocationType_enum {
 }
 impl CUmemAllocationType_enum {
     pub const CU_MEM_ALLOCATION_TYPE_MAX: CUmemAllocationType_enum =
-        CUmemAllocationType_enum(4294967295);
+        CUmemAllocationType_enum(2147483647);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemAllocationType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemAllocationType_enum as CUmemAllocationType;
 impl CUmemAllocationGranularity_flags_enum {
@@ -2155,7 +2447,7 @@ impl CUmemAllocationGranularity_flags_enum {
         CUmemAllocationGranularity_flags_enum(1);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemAllocationGranularity_flags_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemAllocationGranularity_flags_enum as CUmemAllocationGranularity_flags;
 impl CUarraySparseSubresourceType_enum {
@@ -2167,7 +2459,7 @@ impl CUarraySparseSubresourceType_enum {
         CUarraySparseSubresourceType_enum(1);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUarraySparseSubresourceType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUarraySparseSubresourceType_enum as CUarraySparseSubresourceType;
 impl CUmemOperationType_enum {
@@ -2177,14 +2469,14 @@ impl CUmemOperationType_enum {
     pub const CU_MEM_OPERATION_TYPE_UNMAP: CUmemOperationType_enum = CUmemOperationType_enum(2);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemOperationType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemOperationType_enum as CUmemOperationType;
 impl CUmemHandleType_enum {
     pub const CU_MEM_HANDLE_TYPE_GENERIC: CUmemHandleType_enum = CUmemHandleType_enum(0);
 }
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUmemHandleType_enum(pub ::std::os::raw::c_uint);
 pub use self::CUmemHandleType_enum as CUmemHandleType;
 #[repr(C)]
@@ -2207,17 +2499,15 @@ pub struct CUarrayMapInfo_st {
 pub union CUarrayMapInfo_st__bindgen_ty_1 {
     pub mipmap: CUmipmappedArray,
     pub array: CUarray,
-    _bindgen_union_align: u64,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union CUarrayMapInfo_st__bindgen_ty_2 {
     pub sparseLevel: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
     pub miptail: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2,
-    _bindgen_union_align: [u64; 4usize],
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1 {
     pub level: ::std::os::raw::c_uint,
     pub layer: ::std::os::raw::c_uint,
@@ -2229,7 +2519,7 @@ pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1 {
     pub extentDepth: ::std::os::raw::c_uint,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2 {
     pub layer: ::std::os::raw::c_uint,
     pub offset: ::std::os::raw::c_ulonglong,
@@ -2239,18 +2529,19 @@ pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2 {
 #[derive(Copy, Clone)]
 pub union CUarrayMapInfo_st__bindgen_ty_3 {
     pub memHandle: CUmemGenericAllocationHandle,
-    _bindgen_union_align: u64,
 }
-pub type CUarrayMapInfo = CUarrayMapInfo_st;
+pub type CUarrayMapInfo_v1 = CUarrayMapInfo_st;
+pub type CUarrayMapInfo = CUarrayMapInfo_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUmemLocation_st {
     pub type_: CUmemLocationType,
     pub id: ::std::os::raw::c_int,
 }
-pub type CUmemLocation = CUmemLocation_st;
+pub type CUmemLocation_v1 = CUmemLocation_st;
+pub type CUmemLocation = CUmemLocation_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUmemAllocationProp_st {
     pub type_: CUmemAllocationType,
     pub requestedHandleTypes: CUmemAllocationHandleType,
@@ -2259,21 +2550,23 @@ pub struct CUmemAllocationProp_st {
     pub allocFlags: CUmemAllocationProp_st__bindgen_ty_1,
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUmemAllocationProp_st__bindgen_ty_1 {
     pub compressionType: ::std::os::raw::c_uchar,
     pub gpuDirectRDMACapable: ::std::os::raw::c_uchar,
     pub usage: ::std::os::raw::c_ushort,
     pub reserved: [::std::os::raw::c_uchar; 4usize],
 }
-pub type CUmemAllocationProp = CUmemAllocationProp_st;
+pub type CUmemAllocationProp_v1 = CUmemAllocationProp_st;
+pub type CUmemAllocationProp = CUmemAllocationProp_v1;
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct CUmemAccessDesc_st {
     pub location: CUmemLocation,
     pub flags: CUmemAccess_flags,
 }
-pub type CUmemAccessDesc = CUmemAccessDesc_st;
+pub type CUmemAccessDesc_v1 = CUmemAccessDesc_st;
+pub type CUmemAccessDesc = CUmemAccessDesc_v1;
 impl CUgraphExecUpdateResult_enum {
     pub const CU_GRAPH_EXEC_UPDATE_SUCCESS: CUgraphExecUpdateResult_enum =
         CUgraphExecUpdateResult_enum(0);
@@ -2302,52 +2595,159 @@ impl CUgraphExecUpdateResult_enum {
     pub const CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED: CUgraphExecUpdateResult_enum =
         CUgraphExecUpdateResult_enum(6);
 }
+impl CUgraphExecUpdateResult_enum {
+    pub const CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE: CUgraphExecUpdateResult_enum =
+        CUgraphExecUpdateResult_enum(7);
+}
 #[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct CUgraphExecUpdateResult_enum(pub ::std::os::raw::c_uint);
 pub use self::CUgraphExecUpdateResult_enum as CUgraphExecUpdateResult;
-extern_redirect! {
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES: CUmemPool_attribute_enum =
+        CUmemPool_attribute_enum(1);
+}
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC: CUmemPool_attribute_enum =
+        CUmemPool_attribute_enum(2);
+}
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES: CUmemPool_attribute_enum =
+        CUmemPool_attribute_enum(3);
+}
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_RELEASE_THRESHOLD: CUmemPool_attribute_enum =
+        CUmemPool_attribute_enum(4);
+}
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT: CUmemPool_attribute_enum =
+        CUmemPool_attribute_enum(5);
+}
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH: CUmemPool_attribute_enum =
+        CUmemPool_attribute_enum(6);
+}
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_USED_MEM_CURRENT: CUmemPool_attribute_enum =
+        CUmemPool_attribute_enum(7);
+}
+impl CUmemPool_attribute_enum {
+    pub const CU_MEMPOOL_ATTR_USED_MEM_HIGH: CUmemPool_attribute_enum = CUmemPool_attribute_enum(8);
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct CUmemPool_attribute_enum(pub ::std::os::raw::c_uint);
+pub use self::CUmemPool_attribute_enum as CUmemPool_attribute;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUmemPoolProps_st {
+    pub allocType: CUmemAllocationType,
+    pub handleTypes: CUmemAllocationHandleType,
+    pub location: CUmemLocation,
+    pub win32SecurityAttributes: *mut ::std::os::raw::c_void,
+    pub reserved: [::std::os::raw::c_uchar; 64usize],
+}
+pub type CUmemPoolProps_v1 = CUmemPoolProps_st;
+pub type CUmemPoolProps = CUmemPoolProps_v1;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUmemPoolPtrExportData_st {
+    pub reserved: [::std::os::raw::c_uchar; 64usize],
+}
+pub type CUmemPoolPtrExportData_v1 = CUmemPoolPtrExportData_st;
+pub type CUmemPoolPtrExportData = CUmemPoolPtrExportData_v1;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUDA_MEM_ALLOC_NODE_PARAMS_st {
+    pub poolProps: CUmemPoolProps,
+    pub accessDescs: *const CUmemAccessDesc,
+    pub accessDescCount: usize,
+    pub bytesize: usize,
+    pub dptr: CUdeviceptr,
+}
+pub type CUDA_MEM_ALLOC_NODE_PARAMS = CUDA_MEM_ALLOC_NODE_PARAMS_st;
+impl CUgraphMem_attribute_enum {
+    pub const CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT: CUgraphMem_attribute_enum =
+        CUgraphMem_attribute_enum(0);
+}
+impl CUgraphMem_attribute_enum {
+    pub const CU_GRAPH_MEM_ATTR_USED_MEM_HIGH: CUgraphMem_attribute_enum =
+        CUgraphMem_attribute_enum(1);
+}
+impl CUgraphMem_attribute_enum {
+    pub const CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT: CUgraphMem_attribute_enum =
+        CUgraphMem_attribute_enum(2);
+}
+impl CUgraphMem_attribute_enum {
+    pub const CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH: CUgraphMem_attribute_enum =
+        CUgraphMem_attribute_enum(3);
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct CUgraphMem_attribute_enum(pub ::std::os::raw::c_uint);
+pub use self::CUgraphMem_attribute_enum as CUgraphMem_attribute;
+impl CUflushGPUDirectRDMAWritesScope_enum {
+    pub const CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER: CUflushGPUDirectRDMAWritesScope_enum =
+        CUflushGPUDirectRDMAWritesScope_enum(100);
+}
+impl CUflushGPUDirectRDMAWritesScope_enum {
+    pub const CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES: CUflushGPUDirectRDMAWritesScope_enum =
+        CUflushGPUDirectRDMAWritesScope_enum(200);
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct CUflushGPUDirectRDMAWritesScope_enum(pub ::std::os::raw::c_uint);
+pub use self::CUflushGPUDirectRDMAWritesScope_enum as CUflushGPUDirectRDMAWritesScope;
+impl CUflushGPUDirectRDMAWritesTarget_enum {
+    pub const CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX:
+        CUflushGPUDirectRDMAWritesTarget_enum = CUflushGPUDirectRDMAWritesTarget_enum(0);
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct CUflushGPUDirectRDMAWritesTarget_enum(pub ::std::os::raw::c_uint);
+pub use self::CUflushGPUDirectRDMAWritesTarget_enum as CUflushGPUDirectRDMAWritesTarget;
+extern "C" {
     pub fn cuGetErrorString(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGetErrorName(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuInit(Flags: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGet(device: *mut CUdevice, ordinal: ::std::os::raw::c_int) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetCount(count: *mut ::std::os::raw::c_int) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetName(
         name: *mut ::std::os::raw::c_char,
         len: ::std::os::raw::c_int,
         dev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetUuid(uuid: *mut CUuuid, dev: CUdevice) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuDeviceGetUuid_v2(uuid: *mut CUuuid, dev: CUdevice) -> CUresult;
+}
+extern "C" {
     pub fn cuDeviceGetLuid(
         luid: *mut ::std::os::raw::c_char,
         deviceNodeMask: *mut ::std::os::raw::c_uint,
         dev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuDeviceTotalMem(bytes: *mut usize, dev: CUdevice) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceTotalMem_v2(bytes: *mut usize, dev: CUdevice) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetTexture1DLinearMaxWidth(
         maxWidthInElements: *mut usize,
         format: CUarray_format,
@@ -2355,155 +2755,163 @@ extern_redirect! {
         dev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect_with_post! {
+extern "C" {
     pub fn cuDeviceGetAttribute(
         pi: *mut ::std::os::raw::c_int,
         attrib: CUdevice_attribute,
         dev: CUdevice,
     ) -> CUresult;
-    super::cuDeviceGetAttribute_Post;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetNvSciSyncAttributes(
         nvSciSyncAttrList: *mut ::std::os::raw::c_void,
         dev: CUdevice,
         flags: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuDeviceSetMemPool(dev: CUdevice, pool: CUmemoryPool) -> CUresult;
+}
+extern "C" {
+    pub fn cuDeviceGetMemPool(pool: *mut CUmemoryPool, dev: CUdevice) -> CUresult;
+}
+extern "C" {
+    pub fn cuDeviceGetDefaultMemPool(pool_out: *mut CUmemoryPool, dev: CUdevice) -> CUresult;
+}
+extern "C" {
+    pub fn cuFlushGPUDirectRDMAWrites(
+        target: CUflushGPUDirectRDMAWritesTarget,
+        scope: CUflushGPUDirectRDMAWritesScope,
+    ) -> CUresult;
+}
+extern "C" {
     pub fn cuDeviceGetProperties(prop: *mut CUdevprop, dev: CUdevice) -> CUresult;
 }
-extern_redirect_with_post! {
+extern "C" {
     pub fn cuDeviceComputeCapability(
         major: *mut ::std::os::raw::c_int,
         minor: *mut ::std::os::raw::c_int,
         dev: CUdevice,
     ) -> CUresult;
-    super::cuDeviceComputeCapability_Post;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDevicePrimaryCtxRetain(pctx: *mut CUcontext, dev: CUdevice) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuDevicePrimaryCtxRelease(dev: CUdevice) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuDevicePrimaryCtxRelease_v2(dev: CUdevice) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuDevicePrimaryCtxSetFlags(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuDevicePrimaryCtxSetFlags_v2(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDevicePrimaryCtxGetState(
         dev: CUdevice,
         flags: *mut ::std::os::raw::c_uint,
         active: *mut ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuDevicePrimaryCtxReset(dev: CUdevice) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuDevicePrimaryCtxReset_v2(dev: CUdevice) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuCtxCreate(
-        pctx: *mut CUcontext,
-        flags: ::std::os::raw::c_uint,
+extern "C" {
+    pub fn cuDeviceGetExecAffinitySupport(
+        pi: *mut ::std::os::raw::c_int,
+        type_: CUexecAffinityType,
         dev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxCreate_v2(
         pctx: *mut CUcontext,
         flags: ::std::os::raw::c_uint,
         dev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuCtxDestroy(ctx: CUcontext) -> CUresult;
+extern "C" {
+    pub fn cuCtxCreate_v3(
+        pctx: *mut CUcontext,
+        paramsArray: *mut CUexecAffinityParam,
+        numParams: ::std::os::raw::c_int,
+        flags: ::std::os::raw::c_uint,
+        dev: CUdevice,
+    ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxDestroy_v2(ctx: CUcontext) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuCtxPushCurrent(ctx: CUcontext) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuCtxPushCurrent_v2(ctx: CUcontext) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuCtxPopCurrent(pctx: *mut CUcontext) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuCtxPopCurrent_v2(pctx: *mut CUcontext) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxSetCurrent(ctx: CUcontext) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetCurrent(pctx: *mut CUcontext) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetDevice(device: *mut CUdevice) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxSynchronize() -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxSetLimit(limit: CUlimit, value: usize) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetLimit(pvalue: *mut usize, limit: CUlimit) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetCacheConfig(pconfig: *mut CUfunc_cache) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxSetCacheConfig(config: CUfunc_cache) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetSharedMemConfig(pConfig: *mut CUsharedconfig) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxSetSharedMemConfig(config: CUsharedconfig) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetApiVersion(ctx: CUcontext, version: *mut ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxGetStreamPriorityRange(
         leastPriority: *mut ::std::os::raw::c_int,
         greatestPriority: *mut ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxResetPersistingL2Cache() -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuCtxGetExecAffinity(
+        pExecAffinity: *mut CUexecAffinityParam,
+        type_: CUexecAffinityType,
+    ) -> CUresult;
+}
+extern "C" {
     pub fn cuCtxAttach(pctx: *mut CUcontext, flags: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxDetach(ctx: CUcontext) -> CUresult;
 }
-extern_redirect_with_post! {
+extern "C" {
     pub fn cuModuleLoad(module: *mut CUmodule, fname: *const ::std::os::raw::c_char) -> CUresult;
-    super::cuModuleLoad_Post;
 }
-extern_redirect_with_post! {
+extern "C" {
     pub fn cuModuleLoadData(
         module: *mut CUmodule,
         image: *const ::std::os::raw::c_void,
     ) -> CUresult;
-    super::cuModuleLoadData_Post;
 }
-extern_redirect_with_post! {
+extern "C" {
     pub fn cuModuleLoadDataEx(
         module: *mut CUmodule,
         image: *const ::std::os::raw::c_void,
@@ -2511,35 +2919,24 @@ extern_redirect_with_post! {
         options: *mut CUjit_option,
         optionValues: *mut *mut ::std::os::raw::c_void,
     ) -> CUresult;
-    super::cuModuleLoadDataEx_Post;
 }
-extern_redirect_with_post! {
+extern "C" {
     pub fn cuModuleLoadFatBinary(
         module: *mut CUmodule,
         fatCubin: *const ::std::os::raw::c_void,
     ) -> CUresult;
-    super::cuModuleLoadFatBinary_Post;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuModuleUnload(hmod: CUmodule) -> CUresult;
 }
-extern_redirect_with_post! {
+extern "C" {
     pub fn cuModuleGetFunction(
         hfunc: *mut CUfunction,
         hmod: CUmodule,
         name: *const ::std::os::raw::c_char,
     ) -> CUresult;
-    super::cuModuleGetFunction_Post;
 }
-extern_redirect! {
-    pub fn cuModuleGetGlobal(
-        dptr: *mut CUdeviceptr,
-        bytes: *mut usize,
-        hmod: CUmodule,
-        name: *const ::std::os::raw::c_char,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuModuleGetGlobal_v2(
         dptr: *mut CUdeviceptr,
         bytes: *mut usize,
@@ -2547,29 +2944,21 @@ extern_redirect! {
         name: *const ::std::os::raw::c_char,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuModuleGetTexRef(
         pTexRef: *mut CUtexref,
         hmod: CUmodule,
         name: *const ::std::os::raw::c_char,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuModuleGetSurfRef(
         pSurfRef: *mut CUsurfref,
         hmod: CUmodule,
         name: *const ::std::os::raw::c_char,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuLinkCreate(
-        numOptions: ::std::os::raw::c_uint,
-        options: *mut CUjit_option,
-        optionValues: *mut *mut ::std::os::raw::c_void,
-        stateOut: *mut CUlinkState,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuLinkCreate_v2(
         numOptions: ::std::os::raw::c_uint,
         options: *mut CUjit_option,
@@ -2577,19 +2966,7 @@ extern_redirect! {
         stateOut: *mut CUlinkState,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuLinkAddData(
-        state: CUlinkState,
-        type_: CUjitInputType,
-        data: *mut ::std::os::raw::c_void,
-        size: usize,
-        name: *const ::std::os::raw::c_char,
-        numOptions: ::std::os::raw::c_uint,
-        options: *mut CUjit_option,
-        optionValues: *mut *mut ::std::os::raw::c_void,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuLinkAddData_v2(
         state: CUlinkState,
         type_: CUjitInputType,
@@ -2601,17 +2978,7 @@ extern_redirect! {
         optionValues: *mut *mut ::std::os::raw::c_void,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuLinkAddFile(
-        state: CUlinkState,
-        type_: CUjitInputType,
-        path: *const ::std::os::raw::c_char,
-        numOptions: ::std::os::raw::c_uint,
-        options: *mut CUjit_option,
-        optionValues: *mut *mut ::std::os::raw::c_void,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuLinkAddFile_v2(
         state: CUlinkState,
         type_: CUjitInputType,
@@ -2621,38 +2988,23 @@ extern_redirect! {
         optionValues: *mut *mut ::std::os::raw::c_void,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuLinkComplete(
         state: CUlinkState,
         cubinOut: *mut *mut ::std::os::raw::c_void,
         sizeOut: *mut usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuLinkDestroy(state: CUlinkState) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemGetInfo(free: *mut usize, total: *mut usize) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemGetInfo_v2(free: *mut usize, total: *mut usize) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemAlloc(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemAlloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemAllocPitch(
-        dptr: *mut CUdeviceptr,
-        pPitch: *mut usize,
-        WidthInBytes: usize,
-        Height: usize,
-        ElementSizeBytes: ::std::os::raw::c_uint,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemAllocPitch_v2(
         dptr: *mut CUdeviceptr,
         pPitch: *mut usize,
@@ -2661,130 +3013,96 @@ extern_redirect! {
         ElementSizeBytes: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemFree(dptr: CUdeviceptr) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemFree_v2(dptr: CUdeviceptr) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemGetAddressRange(
-        pbase: *mut CUdeviceptr,
-        psize: *mut usize,
-        dptr: CUdeviceptr,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemGetAddressRange_v2(
         pbase: *mut CUdeviceptr,
         psize: *mut usize,
         dptr: CUdeviceptr,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemAllocHost(pp: *mut *mut ::std::os::raw::c_void, bytesize: usize) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemAllocHost_v2(pp: *mut *mut ::std::os::raw::c_void, bytesize: usize) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemFreeHost(p: *mut ::std::os::raw::c_void) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemHostAlloc(
         pp: *mut *mut ::std::os::raw::c_void,
         bytesize: usize,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemHostGetDevicePointer(
-        pdptr: *mut CUdeviceptr,
-        p: *mut ::std::os::raw::c_void,
-        Flags: ::std::os::raw::c_uint,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemHostGetDevicePointer_v2(
         pdptr: *mut CUdeviceptr,
         p: *mut ::std::os::raw::c_void,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemHostGetFlags(
         pFlags: *mut ::std::os::raw::c_uint,
         p: *mut ::std::os::raw::c_void,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemAllocManaged(
         dptr: *mut CUdeviceptr,
         bytesize: usize,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetByPCIBusId(
         dev: *mut CUdevice,
         pciBusId: *const ::std::os::raw::c_char,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetPCIBusId(
         pciBusId: *mut ::std::os::raw::c_char,
         len: ::std::os::raw::c_int,
         dev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuIpcGetEventHandle(pHandle: *mut CUipcEventHandle, event: CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuIpcOpenEventHandle(phEvent: *mut CUevent, handle: CUipcEventHandle) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuIpcGetMemHandle(pHandle: *mut CUipcMemHandle, dptr: CUdeviceptr) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuIpcOpenMemHandle(
-        pdptr: *mut CUdeviceptr,
-        handle: CUipcMemHandle,
-        Flags: ::std::os::raw::c_uint,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuIpcOpenMemHandle_v2(
         pdptr: *mut CUdeviceptr,
         handle: CUipcMemHandle,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuIpcCloseMemHandle(dptr: CUdeviceptr) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemHostRegister(
-        p: *mut ::std::os::raw::c_void,
-        bytesize: usize,
-        Flags: ::std::os::raw::c_uint,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuMemHostRegister_v2(
         p: *mut ::std::os::raw::c_void,
         bytesize: usize,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemHostUnregister(p: *mut ::std::os::raw::c_void) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpy(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult;
+extern "C" {
+    pub fn cuMemcpy_ptds(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyPeer(
+extern "C" {
+    pub fn cuMemcpyPeer_ptds(
         dstDevice: CUdeviceptr,
         dstContext: CUcontext,
         srcDevice: CUdeviceptr,
@@ -2792,114 +3110,61 @@ extern_redirect! {
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyHtoD(
+extern "C" {
+    pub fn cuMemcpyHtoD_v2_ptds(
         dstDevice: CUdeviceptr,
         srcHost: *const ::std::os::raw::c_void,
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyHtoD_v2(
-        dstDevice: CUdeviceptr,
-        srcHost: *const ::std::os::raw::c_void,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyDtoH(
+extern "C" {
+    pub fn cuMemcpyDtoH_v2_ptds(
         dstHost: *mut ::std::os::raw::c_void,
         srcDevice: CUdeviceptr,
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyDtoH_v2(
-        dstHost: *mut ::std::os::raw::c_void,
-        srcDevice: CUdeviceptr,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyDtoD(
-        dstDevice: CUdeviceptr,
-        srcDevice: CUdeviceptr,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyDtoD_v2(
+extern "C" {
+    pub fn cuMemcpyDtoD_v2_ptds(
         dstDevice: CUdeviceptr,
         srcDevice: CUdeviceptr,
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyDtoA(
-        dstArray: CUarray,
-        dstOffset: usize,
-        srcDevice: CUdeviceptr,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyDtoA_v2(
+extern "C" {
+    pub fn cuMemcpyDtoA_v2_ptds(
         dstArray: CUarray,
         dstOffset: usize,
         srcDevice: CUdeviceptr,
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyAtoD(
+extern "C" {
+    pub fn cuMemcpyAtoD_v2_ptds(
         dstDevice: CUdeviceptr,
         srcArray: CUarray,
         srcOffset: usize,
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyAtoD_v2(
-        dstDevice: CUdeviceptr,
-        srcArray: CUarray,
-        srcOffset: usize,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyHtoA(
+extern "C" {
+    pub fn cuMemcpyHtoA_v2_ptds(
         dstArray: CUarray,
         dstOffset: usize,
         srcHost: *const ::std::os::raw::c_void,
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyHtoA_v2(
-        dstArray: CUarray,
-        dstOffset: usize,
-        srcHost: *const ::std::os::raw::c_void,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyAtoH(
-        dstHost: *mut ::std::os::raw::c_void,
-        srcArray: CUarray,
-        srcOffset: usize,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyAtoH_v2(
+extern "C" {
+    pub fn cuMemcpyAtoH_v2_ptds(
         dstHost: *mut ::std::os::raw::c_void,
         srcArray: CUarray,
         srcOffset: usize,
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyAtoA(
+extern "C" {
+    pub fn cuMemcpyAtoA_v2_ptds(
         dstArray: CUarray,
         dstOffset: usize,
         srcArray: CUarray,
@@ -2907,46 +3172,28 @@ extern_redirect! {
         ByteCount: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyAtoA_v2(
-        dstArray: CUarray,
-        dstOffset: usize,
-        srcArray: CUarray,
-        srcOffset: usize,
-        ByteCount: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy2D(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy2D_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
+extern "C" {
+    pub fn cuMemcpy2D_v2_ptds(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpy2DUnaligned(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
+extern "C" {
+    pub fn cuMemcpy2DUnaligned_v2_ptds(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpy2DUnaligned_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy3D(pCopy: *const CUDA_MEMCPY3D) -> CUresult;
+extern "C" {
+    pub fn cuMemcpy3D_v2_ptds(pCopy: *const CUDA_MEMCPY3D) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpy3D_v2(pCopy: *const CUDA_MEMCPY3D) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy3DPeer(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult;
+extern "C" {
+    pub fn cuMemcpy3DPeer_ptds(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyAsync(
+extern "C" {
+    pub fn cuMemcpyAsync_ptsz(
         dst: CUdeviceptr,
         src: CUdeviceptr,
         ByteCount: usize,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyPeerAsync(
+extern "C" {
+    pub fn cuMemcpyPeerAsync_ptsz(
         dstDevice: CUdeviceptr,
         dstContext: CUcontext,
         srcDevice: CUdeviceptr,
@@ -2955,65 +3202,32 @@ extern_redirect! {
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyHtoDAsync(
-        dstDevice: CUdeviceptr,
-        srcHost: *const ::std::os::raw::c_void,
-        ByteCount: usize,
-        hStream: CUstream,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyHtoDAsync_v2(
+extern "C" {
+    pub fn cuMemcpyHtoDAsync_v2_ptsz(
         dstDevice: CUdeviceptr,
         srcHost: *const ::std::os::raw::c_void,
         ByteCount: usize,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyDtoHAsync(
+extern "C" {
+    pub fn cuMemcpyDtoHAsync_v2_ptsz(
         dstHost: *mut ::std::os::raw::c_void,
         srcDevice: CUdeviceptr,
         ByteCount: usize,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyDtoHAsync_v2(
-        dstHost: *mut ::std::os::raw::c_void,
-        srcDevice: CUdeviceptr,
-        ByteCount: usize,
-        hStream: CUstream,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyDtoDAsync(
-        dstDevice: CUdeviceptr,
-        srcDevice: CUdeviceptr,
-        ByteCount: usize,
-        hStream: CUstream,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyDtoDAsync_v2(
+extern "C" {
+    pub fn cuMemcpyDtoDAsync_v2_ptsz(
         dstDevice: CUdeviceptr,
         srcDevice: CUdeviceptr,
         ByteCount: usize,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyHtoAAsync(
-        dstArray: CUarray,
-        dstOffset: usize,
-        srcHost: *const ::std::os::raw::c_void,
-        ByteCount: usize,
-        hStream: CUstream,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyHtoAAsync_v2(
+extern "C" {
+    pub fn cuMemcpyHtoAAsync_v2_ptsz(
         dstArray: CUarray,
         dstOffset: usize,
         srcHost: *const ::std::os::raw::c_void,
@@ -3021,17 +3235,8 @@ extern_redirect! {
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpyAtoHAsync(
-        dstHost: *mut ::std::os::raw::c_void,
-        srcArray: CUarray,
-        srcOffset: usize,
-        ByteCount: usize,
-        hStream: CUstream,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpyAtoHAsync_v2(
+extern "C" {
+    pub fn cuMemcpyAtoHAsync_v2_ptsz(
         dstHost: *mut ::std::os::raw::c_void,
         srcArray: CUarray,
         srcOffset: usize,
@@ -3039,62 +3244,41 @@ extern_redirect! {
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemcpy2DAsync(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy2DAsync_v2(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy3DAsync(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy3DAsync_v2(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemcpy3DPeerAsync(pCopy: *const CUDA_MEMCPY3D_PEER, hStream: CUstream) -> CUresult;
+extern "C" {
+    pub fn cuMemcpy2DAsync_v2_ptsz(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD8(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize)
-        -> CUresult;
+extern "C" {
+    pub fn cuMemcpy3DAsync_v2_ptsz(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD8_v2(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize)
-        -> CUresult;
+extern "C" {
+    pub fn cuMemcpy3DPeerAsync_ptsz(
+        pCopy: *const CUDA_MEMCPY3D_PEER,
+        hStream: CUstream,
+    ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD16(
+extern "C" {
+    pub fn cuMemsetD8_v2_ptds(
         dstDevice: CUdeviceptr,
-        us: ::std::os::raw::c_ushort,
+        uc: ::std::os::raw::c_uchar,
         N: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD16_v2(
+extern "C" {
+    pub fn cuMemsetD16_v2_ptds(
         dstDevice: CUdeviceptr,
         us: ::std::os::raw::c_ushort,
         N: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD32(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize)
-        -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemsetD32_v2(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize)
-        -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemsetD2D8(
+extern "C" {
+    pub fn cuMemsetD32_v2_ptds(
         dstDevice: CUdeviceptr,
-        dstPitch: usize,
-        uc: ::std::os::raw::c_uchar,
-        Width: usize,
-        Height: usize,
+        ui: ::std::os::raw::c_uint,
+        N: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD2D8_v2(
+extern "C" {
+    pub fn cuMemsetD2D8_v2_ptds(
         dstDevice: CUdeviceptr,
         dstPitch: usize,
         uc: ::std::os::raw::c_uchar,
@@ -3102,17 +3286,8 @@ extern_redirect! {
         Height: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD2D16(
-        dstDevice: CUdeviceptr,
-        dstPitch: usize,
-        us: ::std::os::raw::c_ushort,
-        Width: usize,
-        Height: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemsetD2D16_v2(
+extern "C" {
+    pub fn cuMemsetD2D16_v2_ptds(
         dstDevice: CUdeviceptr,
         dstPitch: usize,
         us: ::std::os::raw::c_ushort,
@@ -3120,17 +3295,8 @@ extern_redirect! {
         Height: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD2D32(
-        dstDevice: CUdeviceptr,
-        dstPitch: usize,
-        ui: ::std::os::raw::c_uint,
-        Width: usize,
-        Height: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuMemsetD2D32_v2(
+extern "C" {
+    pub fn cuMemsetD2D32_v2_ptds(
         dstDevice: CUdeviceptr,
         dstPitch: usize,
         ui: ::std::os::raw::c_uint,
@@ -3138,32 +3304,32 @@ extern_redirect! {
         Height: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD8Async(
+extern "C" {
+    pub fn cuMemsetD8Async_ptsz(
         dstDevice: CUdeviceptr,
         uc: ::std::os::raw::c_uchar,
         N: usize,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD16Async(
+extern "C" {
+    pub fn cuMemsetD16Async_ptsz(
         dstDevice: CUdeviceptr,
         us: ::std::os::raw::c_ushort,
         N: usize,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD32Async(
+extern "C" {
+    pub fn cuMemsetD32Async_ptsz(
         dstDevice: CUdeviceptr,
         ui: ::std::os::raw::c_uint,
         N: usize,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD2D8Async(
+extern "C" {
+    pub fn cuMemsetD2D8Async_ptsz(
         dstDevice: CUdeviceptr,
         dstPitch: usize,
         uc: ::std::os::raw::c_uchar,
@@ -3172,8 +3338,8 @@ extern_redirect! {
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD2D16Async(
+extern "C" {
+    pub fn cuMemsetD2D16Async_ptsz(
         dstDevice: CUdeviceptr,
         dstPitch: usize,
         us: ::std::os::raw::c_ushort,
@@ -3182,8 +3348,8 @@ extern_redirect! {
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemsetD2D32Async(
+extern "C" {
+    pub fn cuMemsetD2D32Async_ptsz(
         dstDevice: CUdeviceptr,
         dstPitch: usize,
         ui: ::std::os::raw::c_uint,
@@ -3192,87 +3358,70 @@ extern_redirect! {
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuArrayCreate(
-        pHandle: *mut CUarray,
-        pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuArrayCreate_v2(
         pHandle: *mut CUarray,
         pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuArrayGetDescriptor(
-        pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR,
-        hArray: CUarray,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuArrayGetDescriptor_v2(
         pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR,
         hArray: CUarray,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuArrayGetSparseProperties(
         sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES,
         array: CUarray,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMipmappedArrayGetSparseProperties(
         sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES,
         mipmap: CUmipmappedArray,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuArrayDestroy(hArray: CUarray) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuArray3DCreate(
-        pHandle: *mut CUarray,
-        pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR,
+extern "C" {
+    pub fn cuArrayGetPlane(
+        pPlaneArray: *mut CUarray,
+        hArray: CUarray,
+        planeIdx: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuArrayDestroy(hArray: CUarray) -> CUresult;
+}
+extern "C" {
     pub fn cuArray3DCreate_v2(
         pHandle: *mut CUarray,
         pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuArray3DGetDescriptor(
-        pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR,
-        hArray: CUarray,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuArray3DGetDescriptor_v2(
         pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR,
         hArray: CUarray,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMipmappedArrayCreate(
         pHandle: *mut CUmipmappedArray,
         pMipmappedArrayDesc: *const CUDA_ARRAY3D_DESCRIPTOR,
         numMipmapLevels: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMipmappedArrayGetLevel(
         pLevelArray: *mut CUarray,
         hMipmappedArray: CUmipmappedArray,
         level: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMipmappedArrayDestroy(hMipmappedArray: CUmipmappedArray) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemAddressReserve(
         ptr: *mut CUdeviceptr,
         size: usize,
@@ -3281,10 +3430,10 @@ extern_redirect! {
         flags: ::std::os::raw::c_ulonglong,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemAddressFree(ptr: CUdeviceptr, size: usize) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemCreate(
         handle: *mut CUmemGenericAllocationHandle,
         size: usize,
@@ -3292,10 +3441,10 @@ extern_redirect! {
         flags: ::std::os::raw::c_ulonglong,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemRelease(handle: CUmemGenericAllocationHandle) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemMap(
         ptr: CUdeviceptr,
         size: usize,
@@ -3304,17 +3453,17 @@ extern_redirect! {
         flags: ::std::os::raw::c_ulonglong,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemMapArrayAsync(
+extern "C" {
+    pub fn cuMemMapArrayAsync_ptsz(
         mapInfoList: *mut CUarrayMapInfo,
         count: ::std::os::raw::c_uint,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemUnmap(ptr: CUdeviceptr, size: usize) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemSetAccess(
         ptr: CUdeviceptr,
         size: usize,
@@ -3322,14 +3471,14 @@ extern_redirect! {
         count: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemGetAccess(
         flags: *mut ::std::os::raw::c_ulonglong,
         location: *const CUmemLocation,
         ptr: CUdeviceptr,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemExportToShareableHandle(
         shareableHandle: *mut ::std::os::raw::c_void,
         handle: CUmemGenericAllocationHandle,
@@ -3337,48 +3486,132 @@ extern_redirect! {
         flags: ::std::os::raw::c_ulonglong,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemImportFromShareableHandle(
         handle: *mut CUmemGenericAllocationHandle,
         osHandle: *mut ::std::os::raw::c_void,
         shHandleType: CUmemAllocationHandleType,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemGetAllocationGranularity(
         granularity: *mut usize,
         prop: *const CUmemAllocationProp,
         option: CUmemAllocationGranularity_flags,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemGetAllocationPropertiesFromHandle(
         prop: *mut CUmemAllocationProp,
         handle: CUmemGenericAllocationHandle,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemRetainAllocationHandle(
         handle: *mut CUmemGenericAllocationHandle,
         addr: *mut ::std::os::raw::c_void,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuMemFreeAsync_ptsz(dptr: CUdeviceptr, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemAllocAsync_ptsz(
+        dptr: *mut CUdeviceptr,
+        bytesize: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolTrimTo(pool: CUmemoryPool, minBytesToKeep: usize) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolSetAttribute(
+        pool: CUmemoryPool,
+        attr: CUmemPool_attribute,
+        value: *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolGetAttribute(
+        pool: CUmemoryPool,
+        attr: CUmemPool_attribute,
+        value: *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolSetAccess(
+        pool: CUmemoryPool,
+        map: *const CUmemAccessDesc,
+        count: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolGetAccess(
+        flags: *mut CUmemAccess_flags,
+        memPool: CUmemoryPool,
+        location: *mut CUmemLocation,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolCreate(pool: *mut CUmemoryPool, poolProps: *const CUmemPoolProps) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolDestroy(pool: CUmemoryPool) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemAllocFromPoolAsync_ptsz(
+        dptr: *mut CUdeviceptr,
+        bytesize: usize,
+        pool: CUmemoryPool,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolExportToShareableHandle(
+        handle_out: *mut ::std::os::raw::c_void,
+        pool: CUmemoryPool,
+        handleType: CUmemAllocationHandleType,
+        flags: ::std::os::raw::c_ulonglong,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolImportFromShareableHandle(
+        pool_out: *mut CUmemoryPool,
+        handle: *mut ::std::os::raw::c_void,
+        handleType: CUmemAllocationHandleType,
+        flags: ::std::os::raw::c_ulonglong,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolExportPointer(
+        shareData_out: *mut CUmemPoolPtrExportData,
+        ptr: CUdeviceptr,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPoolImportPointer(
+        ptr_out: *mut CUdeviceptr,
+        pool: CUmemoryPool,
+        shareData: *mut CUmemPoolPtrExportData,
+    ) -> CUresult;
+}
+extern "C" {
     pub fn cuPointerGetAttribute(
         data: *mut ::std::os::raw::c_void,
         attribute: CUpointer_attribute,
         ptr: CUdeviceptr,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuMemPrefetchAsync(
+extern "C" {
+    pub fn cuMemPrefetchAsync_ptsz(
         devPtr: CUdeviceptr,
         count: usize,
         dstDevice: CUdevice,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemAdvise(
         devPtr: CUdeviceptr,
         count: usize,
@@ -3386,7 +3619,7 @@ extern_redirect! {
         device: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemRangeGetAttribute(
         data: *mut ::std::os::raw::c_void,
         dataSize: usize,
@@ -3395,7 +3628,7 @@ extern_redirect! {
         count: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuMemRangeGetAttributes(
         data: *mut *mut ::std::os::raw::c_void,
         dataSizes: *mut usize,
@@ -3405,14 +3638,14 @@ extern_redirect! {
         count: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuPointerSetAttribute(
         value: *const ::std::os::raw::c_void,
         attribute: CUpointer_attribute,
         ptr: CUdeviceptr,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuPointerGetAttributes(
         numAttributes: ::std::os::raw::c_uint,
         attributes: *mut CUpointer_attribute,
@@ -3420,241 +3653,256 @@ extern_redirect! {
         ptr: CUdeviceptr,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuStreamCreate(phStream: *mut CUstream, Flags: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuStreamCreateWithPriority(
         phStream: *mut CUstream,
         flags: ::std::os::raw::c_uint,
         priority: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamGetPriority(hStream: CUstream, priority: *mut ::std::os::raw::c_int)
-        -> CUresult;
+extern "C" {
+    pub fn cuStreamGetPriority_ptsz(
+        hStream: CUstream,
+        priority: *mut ::std::os::raw::c_int,
+    ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamGetFlags(hStream: CUstream, flags: *mut ::std::os::raw::c_uint) -> CUresult;
+extern "C" {
+    pub fn cuStreamGetFlags_ptsz(hStream: CUstream, flags: *mut ::std::os::raw::c_uint)
+        -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamGetCtx(hStream: CUstream, pctx: *mut CUcontext) -> CUresult;
+extern "C" {
+    pub fn cuStreamGetCtx_ptsz(hStream: CUstream, pctx: *mut CUcontext) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamWaitEvent(
+extern "C" {
+    pub fn cuStreamWaitEvent_ptsz(
         hStream: CUstream,
         hEvent: CUevent,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamAddCallback(
+extern "C" {
+    pub fn cuStreamAddCallback_ptsz(
         hStream: CUstream,
         callback: CUstreamCallback,
         userData: *mut ::std::os::raw::c_void,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamBeginCapture(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuStreamBeginCapture_v2(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult;
+extern "C" {
+    pub fn cuStreamBeginCapture_v2_ptsz(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuThreadExchangeStreamCaptureMode(mode: *mut CUstreamCaptureMode) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamEndCapture(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult;
+extern "C" {
+    pub fn cuStreamEndCapture_ptsz(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamIsCapturing(
+extern "C" {
+    pub fn cuStreamIsCapturing_ptsz(
         hStream: CUstream,
         captureStatus: *mut CUstreamCaptureStatus,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamGetCaptureInfo(
+extern "C" {
+    pub fn cuStreamGetCaptureInfo_ptsz(
         hStream: CUstream,
-        captureStatus: *mut CUstreamCaptureStatus,
-        id: *mut cuuint64_t,
+        captureStatus_out: *mut CUstreamCaptureStatus,
+        id_out: *mut cuuint64_t,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamAttachMemAsync(
+extern "C" {
+    pub fn cuStreamGetCaptureInfo_v2_ptsz(
+        hStream: CUstream,
+        captureStatus_out: *mut CUstreamCaptureStatus,
+        id_out: *mut cuuint64_t,
+        graph_out: *mut CUgraph,
+        dependencies_out: *mut *const CUgraphNode,
+        numDependencies_out: *mut usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamUpdateCaptureDependencies_ptsz(
+        hStream: CUstream,
+        dependencies: *mut CUgraphNode,
+        numDependencies: usize,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamAttachMemAsync_ptsz(
         hStream: CUstream,
         dptr: CUdeviceptr,
         length: usize,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamQuery(hStream: CUstream) -> CUresult;
-}
-extern_redirect! {
-    pub fn cuStreamSynchronize(hStream: CUstream) -> CUresult;
+extern "C" {
+    pub fn cuStreamQuery_ptsz(hStream: CUstream) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamDestroy(hStream: CUstream) -> CUresult;
+extern "C" {
+    pub fn cuStreamSynchronize_ptsz(hStream: CUstream) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuStreamDestroy_v2(hStream: CUstream) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamCopyAttributes(dst: CUstream, src: CUstream) -> CUresult;
+extern "C" {
+    pub fn cuStreamCopyAttributes_ptsz(dst: CUstream, src: CUstream) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamGetAttribute(
+extern "C" {
+    pub fn cuStreamGetAttribute_ptsz(
         hStream: CUstream,
         attr: CUstreamAttrID,
         value_out: *mut CUstreamAttrValue,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamSetAttribute(
+extern "C" {
+    pub fn cuStreamSetAttribute_ptsz(
         hStream: CUstream,
         attr: CUstreamAttrID,
         value: *const CUstreamAttrValue,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuEventCreate(phEvent: *mut CUevent, Flags: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuEventRecord(hEvent: CUevent, hStream: CUstream) -> CUresult;
+extern "C" {
+    pub fn cuEventRecord_ptsz(hEvent: CUevent, hStream: CUstream) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuEventRecordWithFlags(
+extern "C" {
+    pub fn cuEventRecordWithFlags_ptsz(
         hEvent: CUevent,
         hStream: CUstream,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuEventQuery(hEvent: CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuEventSynchronize(hEvent: CUevent) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuEventDestroy(hEvent: CUevent) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuEventDestroy_v2(hEvent: CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuEventElapsedTime(pMilliseconds: *mut f32, hStart: CUevent, hEnd: CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuImportExternalMemory(
         extMem_out: *mut CUexternalMemory,
         memHandleDesc: *const CUDA_EXTERNAL_MEMORY_HANDLE_DESC,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuExternalMemoryGetMappedBuffer(
         devPtr: *mut CUdeviceptr,
         extMem: CUexternalMemory,
         bufferDesc: *const CUDA_EXTERNAL_MEMORY_BUFFER_DESC,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuExternalMemoryGetMappedMipmappedArray(
         mipmap: *mut CUmipmappedArray,
         extMem: CUexternalMemory,
         mipmapDesc: *const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDestroyExternalMemory(extMem: CUexternalMemory) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuImportExternalSemaphore(
         extSem_out: *mut CUexternalSemaphore,
         semHandleDesc: *const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuSignalExternalSemaphoresAsync(
+extern "C" {
+    pub fn cuSignalExternalSemaphoresAsync_ptsz(
         extSemArray: *const CUexternalSemaphore,
         paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,
         numExtSems: ::std::os::raw::c_uint,
         stream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuWaitExternalSemaphoresAsync(
+extern "C" {
+    pub fn cuWaitExternalSemaphoresAsync_ptsz(
         extSemArray: *const CUexternalSemaphore,
         paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,
         numExtSems: ::std::os::raw::c_uint,
         stream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDestroyExternalSemaphore(extSem: CUexternalSemaphore) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamWaitValue32(
+extern "C" {
+    pub fn cuStreamWaitValue32_ptsz(
         stream: CUstream,
         addr: CUdeviceptr,
         value: cuuint32_t,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamWaitValue64(
+extern "C" {
+    pub fn cuStreamWaitValue64_ptsz(
         stream: CUstream,
         addr: CUdeviceptr,
         value: cuuint64_t,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamWriteValue32(
+extern "C" {
+    pub fn cuStreamWriteValue32_ptsz(
         stream: CUstream,
         addr: CUdeviceptr,
         value: cuuint32_t,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamWriteValue64(
+extern "C" {
+    pub fn cuStreamWriteValue64_ptsz(
         stream: CUstream,
         addr: CUdeviceptr,
         value: cuuint64_t,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuStreamBatchMemOp(
+extern "C" {
+    pub fn cuStreamBatchMemOp_ptsz(
         stream: CUstream,
         count: ::std::os::raw::c_uint,
         paramArray: *mut CUstreamBatchMemOpParams,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuFuncGetAttribute(
         pi: *mut ::std::os::raw::c_int,
         attrib: CUfunction_attribute,
         hfunc: CUfunction,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuFuncSetAttribute(
         hfunc: CUfunction,
         attrib: CUfunction_attribute,
         value: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuFuncSetCacheConfig(hfunc: CUfunction, config: CUfunc_cache) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuFuncSetSharedMemConfig(hfunc: CUfunction, config: CUsharedconfig) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuLaunchKernel(
+extern "C" {
+    pub fn cuFuncGetModule(hmod: *mut CUmodule, hfunc: CUfunction) -> CUresult;
+}
+extern "C" {
+    pub fn cuLaunchKernel_ptsz(
         f: CUfunction,
         gridDimX: ::std::os::raw::c_uint,
         gridDimY: ::std::os::raw::c_uint,
@@ -3668,8 +3916,8 @@ extern_redirect! {
         extra: *mut *mut ::std::os::raw::c_void,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuLaunchCooperativeKernel(
+extern "C" {
+    pub fn cuLaunchCooperativeKernel_ptsz(
         f: CUfunction,
         gridDimX: ::std::os::raw::c_uint,
         gridDimY: ::std::os::raw::c_uint,
@@ -3682,21 +3930,21 @@ extern_redirect! {
         kernelParams: *mut *mut ::std::os::raw::c_void,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuLaunchCooperativeKernelMultiDevice(
         launchParamsList: *mut CUDA_LAUNCH_PARAMS,
         numDevices: ::std::os::raw::c_uint,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuLaunchHostFunc(
+extern "C" {
+    pub fn cuLaunchHostFunc_ptsz(
         hStream: CUstream,
         fn_: CUhostFn,
         userData: *mut ::std::os::raw::c_void,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuFuncSetBlockShape(
         hfunc: CUfunction,
         x: ::std::os::raw::c_int,
@@ -3704,23 +3952,23 @@ extern_redirect! {
         z: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuFuncSetSharedSize(hfunc: CUfunction, bytes: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuParamSetSize(hfunc: CUfunction, numbytes: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuParamSeti(
         hfunc: CUfunction,
         offset: ::std::os::raw::c_int,
         value: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuParamSetf(hfunc: CUfunction, offset: ::std::os::raw::c_int, value: f32) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuParamSetv(
         hfunc: CUfunction,
         offset: ::std::os::raw::c_int,
@@ -3728,17 +3976,17 @@ extern_redirect! {
         numbytes: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuLaunch(f: CUfunction) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuLaunchGrid(
         f: CUfunction,
         grid_width: ::std::os::raw::c_int,
         grid_height: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuLaunchGridAsync(
         f: CUfunction,
         grid_width: ::std::os::raw::c_int,
@@ -3746,17 +3994,17 @@ extern_redirect! {
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuParamSetTexRef(
         hfunc: CUfunction,
         texunit: ::std::os::raw::c_int,
         hTexRef: CUtexref,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphCreate(phGraph: *mut CUgraph, flags: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddKernelNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3765,19 +4013,19 @@ extern_redirect! {
         nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphKernelNodeGetParams(
         hNode: CUgraphNode,
         nodeParams: *mut CUDA_KERNEL_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphKernelNodeSetParams(
         hNode: CUgraphNode,
         nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddMemcpyNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3787,19 +4035,19 @@ extern_redirect! {
         ctx: CUcontext,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphMemcpyNodeGetParams(
         hNode: CUgraphNode,
         nodeParams: *mut CUDA_MEMCPY3D,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphMemcpyNodeSetParams(
         hNode: CUgraphNode,
         nodeParams: *const CUDA_MEMCPY3D,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddMemsetNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3809,19 +4057,19 @@ extern_redirect! {
         ctx: CUcontext,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphMemsetNodeGetParams(
         hNode: CUgraphNode,
         nodeParams: *mut CUDA_MEMSET_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphMemsetNodeSetParams(
         hNode: CUgraphNode,
         nodeParams: *const CUDA_MEMSET_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddHostNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3830,19 +4078,19 @@ extern_redirect! {
         nodeParams: *const CUDA_HOST_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphHostNodeGetParams(
         hNode: CUgraphNode,
         nodeParams: *mut CUDA_HOST_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphHostNodeSetParams(
         hNode: CUgraphNode,
         nodeParams: *const CUDA_HOST_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddChildGraphNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3851,10 +4099,10 @@ extern_redirect! {
         childGraph: CUgraph,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphChildGraphNodeGetGraph(hNode: CUgraphNode, phGraph: *mut CUgraph) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddEmptyNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3862,7 +4110,7 @@ extern_redirect! {
         numDependencies: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddEventRecordNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3871,13 +4119,13 @@ extern_redirect! {
         event: CUevent,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphEventRecordNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphEventRecordNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddEventWaitNode(
         phGraphNode: *mut CUgraphNode,
         hGraph: CUgraph,
@@ -3886,40 +4134,126 @@ extern_redirect! {
         event: CUevent,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphEventWaitNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphEventWaitNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuGraphAddExternalSemaphoresSignalNode(
+        phGraphNode: *mut CUgraphNode,
+        hGraph: CUgraph,
+        dependencies: *const CUgraphNode,
+        numDependencies: usize,
+        nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphExternalSemaphoresSignalNodeGetParams(
+        hNode: CUgraphNode,
+        params_out: *mut CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphExternalSemaphoresSignalNodeSetParams(
+        hNode: CUgraphNode,
+        nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphAddExternalSemaphoresWaitNode(
+        phGraphNode: *mut CUgraphNode,
+        hGraph: CUgraph,
+        dependencies: *const CUgraphNode,
+        numDependencies: usize,
+        nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphExternalSemaphoresWaitNodeGetParams(
+        hNode: CUgraphNode,
+        params_out: *mut CUDA_EXT_SEM_WAIT_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphExternalSemaphoresWaitNodeSetParams(
+        hNode: CUgraphNode,
+        nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphAddMemAllocNode(
+        phGraphNode: *mut CUgraphNode,
+        hGraph: CUgraph,
+        dependencies: *const CUgraphNode,
+        numDependencies: usize,
+        nodeParams: *mut CUDA_MEM_ALLOC_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphMemAllocNodeGetParams(
+        hNode: CUgraphNode,
+        params_out: *mut CUDA_MEM_ALLOC_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphAddMemFreeNode(
+        phGraphNode: *mut CUgraphNode,
+        hGraph: CUgraph,
+        dependencies: *const CUgraphNode,
+        numDependencies: usize,
+        dptr: CUdeviceptr,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphMemFreeNodeGetParams(hNode: CUgraphNode, dptr_out: *mut CUdeviceptr) -> CUresult;
+}
+extern "C" {
+    pub fn cuDeviceGraphMemTrim(device: CUdevice) -> CUresult;
+}
+extern "C" {
+    pub fn cuDeviceGetGraphMemAttribute(
+        device: CUdevice,
+        attr: CUgraphMem_attribute,
+        value: *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuDeviceSetGraphMemAttribute(
+        device: CUdevice,
+        attr: CUgraphMem_attribute,
+        value: *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
     pub fn cuGraphClone(phGraphClone: *mut CUgraph, originalGraph: CUgraph) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphNodeFindInClone(
         phNode: *mut CUgraphNode,
         hOriginalNode: CUgraphNode,
         hClonedGraph: CUgraph,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphNodeGetType(hNode: CUgraphNode, type_: *mut CUgraphNodeType) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphGetNodes(
         hGraph: CUgraph,
         nodes: *mut CUgraphNode,
         numNodes: *mut usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphGetRootNodes(
         hGraph: CUgraph,
         rootNodes: *mut CUgraphNode,
         numRootNodes: *mut usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphGetEdges(
         hGraph: CUgraph,
         from: *mut CUgraphNode,
@@ -3927,21 +4261,21 @@ extern_redirect! {
         numEdges: *mut usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphNodeGetDependencies(
         hNode: CUgraphNode,
         dependencies: *mut CUgraphNode,
         numDependencies: *mut usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphNodeGetDependentNodes(
         hNode: CUgraphNode,
         dependentNodes: *mut CUgraphNode,
         numDependentNodes: *mut usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphAddDependencies(
         hGraph: CUgraph,
         from: *const CUgraphNode,
@@ -3949,7 +4283,7 @@ extern_redirect! {
         numDependencies: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphRemoveDependencies(
         hGraph: CUgraph,
         from: *const CUgraphNode,
@@ -3957,11 +4291,11 @@ extern_redirect! {
         numDependencies: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphDestroyNode(hNode: CUgraphNode) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuGraphInstantiate(
+extern "C" {
+    pub fn cuGraphInstantiate_v2(
         phGraphExec: *mut CUgraphExec,
         hGraph: CUgraph,
         phErrorNode: *mut CUgraphNode,
@@ -3969,23 +4303,21 @@ extern_redirect! {
         bufferSize: usize,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuGraphInstantiate_v2(
+extern "C" {
+    pub fn cuGraphInstantiateWithFlags(
         phGraphExec: *mut CUgraphExec,
         hGraph: CUgraph,
-        phErrorNode: *mut CUgraphNode,
-        logBuffer: *mut ::std::os::raw::c_char,
-        bufferSize: usize,
+        flags: ::std::os::raw::c_ulonglong,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecKernelNodeSetParams(
         hGraphExec: CUgraphExec,
         hNode: CUgraphNode,
         nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecMemcpyNodeSetParams(
         hGraphExec: CUgraphExec,
         hNode: CUgraphNode,
@@ -3993,7 +4325,7 @@ extern_redirect! {
         ctx: CUcontext,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecMemsetNodeSetParams(
         hGraphExec: CUgraphExec,
         hNode: CUgraphNode,
@@ -4001,47 +4333,61 @@ extern_redirect! {
         ctx: CUcontext,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecHostNodeSetParams(
         hGraphExec: CUgraphExec,
         hNode: CUgraphNode,
         nodeParams: *const CUDA_HOST_NODE_PARAMS,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecChildGraphNodeSetParams(
         hGraphExec: CUgraphExec,
         hNode: CUgraphNode,
         childGraph: CUgraph,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecEventRecordNodeSetEvent(
         hGraphExec: CUgraphExec,
         hNode: CUgraphNode,
         event: CUevent,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecEventWaitNodeSetEvent(
         hGraphExec: CUgraphExec,
         hNode: CUgraphNode,
         event: CUevent,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuGraphUpload(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult;
+extern "C" {
+    pub fn cuGraphExecExternalSemaphoresSignalNodeSetParams(
+        hGraphExec: CUgraphExec,
+        hNode: CUgraphNode,
+        nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphExecExternalSemaphoresWaitNodeSetParams(
+        hGraphExec: CUgraphExec,
+        hNode: CUgraphNode,
+        nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS,
+    ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuGraphLaunch(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult;
+extern "C" {
+    pub fn cuGraphUpload_ptsz(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuGraphLaunch_ptsz(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult;
+}
+extern "C" {
     pub fn cuGraphExecDestroy(hGraphExec: CUgraphExec) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphDestroy(hGraph: CUgraph) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphExecUpdate(
         hGraphExec: CUgraphExec,
         hGraph: CUgraph,
@@ -4049,24 +4395,61 @@ extern_redirect! {
         updateResult_out: *mut CUgraphExecUpdateResult,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphKernelNodeCopyAttributes(dst: CUgraphNode, src: CUgraphNode) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphKernelNodeGetAttribute(
         hNode: CUgraphNode,
         attr: CUkernelNodeAttrID,
         value_out: *mut CUkernelNodeAttrValue,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphKernelNodeSetAttribute(
         hNode: CUgraphNode,
         attr: CUkernelNodeAttrID,
         value: *const CUkernelNodeAttrValue,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuGraphDebugDotPrint(
+        hGraph: CUgraph,
+        path: *const ::std::os::raw::c_char,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuUserObjectCreate(
+        object_out: *mut CUuserObject,
+        ptr: *mut ::std::os::raw::c_void,
+        destroy: CUhostFn,
+        initialRefcount: ::std::os::raw::c_uint,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuUserObjectRetain(object: CUuserObject, count: ::std::os::raw::c_uint) -> CUresult;
+}
+extern "C" {
+    pub fn cuUserObjectRelease(object: CUuserObject, count: ::std::os::raw::c_uint) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphRetainUserObject(
+        graph: CUgraph,
+        object: CUuserObject,
+        count: ::std::os::raw::c_uint,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphReleaseUserObject(
+        graph: CUgraph,
+        object: CUuserObject,
+        count: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
     pub fn cuOccupancyMaxActiveBlocksPerMultiprocessor(
         numBlocks: *mut ::std::os::raw::c_int,
         func: CUfunction,
@@ -4074,7 +4457,7 @@ extern_redirect! {
         dynamicSMemSize: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
         numBlocks: *mut ::std::os::raw::c_int,
         func: CUfunction,
@@ -4083,7 +4466,7 @@ extern_redirect! {
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuOccupancyMaxPotentialBlockSize(
         minGridSize: *mut ::std::os::raw::c_int,
         blockSize: *mut ::std::os::raw::c_int,
@@ -4093,7 +4476,7 @@ extern_redirect! {
         blockSizeLimit: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuOccupancyMaxPotentialBlockSizeWithFlags(
         minGridSize: *mut ::std::os::raw::c_int,
         blockSize: *mut ::std::os::raw::c_int,
@@ -4104,7 +4487,7 @@ extern_redirect! {
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuOccupancyAvailableDynamicSMemPerBlock(
         dynamicSmemSize: *mut usize,
         func: CUfunction,
@@ -4112,29 +4495,21 @@ extern_redirect! {
         blockSize: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetArray(
         hTexRef: CUtexref,
         hArray: CUarray,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetMipmappedArray(
         hTexRef: CUtexref,
         hMipmappedArray: CUmipmappedArray,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuTexRefSetAddress(
-        ByteOffset: *mut usize,
-        hTexRef: CUtexref,
-        dptr: CUdeviceptr,
-        bytes: usize,
-    ) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetAddress_v2(
         ByteOffset: *mut usize,
         hTexRef: CUtexref,
@@ -4142,7 +4517,7 @@ extern_redirect! {
         bytes: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetAddress2D_v3(
         hTexRef: CUtexref,
         desc: *const CUDA_ARRAY_DESCRIPTOR,
@@ -4150,122 +4525,119 @@ extern_redirect! {
         Pitch: usize,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetFormat(
         hTexRef: CUtexref,
         fmt: CUarray_format,
         NumPackedComponents: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetAddressMode(
         hTexRef: CUtexref,
         dim: ::std::os::raw::c_int,
         am: CUaddress_mode,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetMipmapFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetMipmapLevelBias(hTexRef: CUtexref, bias: f32) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetMipmapLevelClamp(
         hTexRef: CUtexref,
         minMipmapLevelClamp: f32,
         maxMipmapLevelClamp: f32,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetMaxAnisotropy(
         hTexRef: CUtexref,
         maxAniso: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetBorderColor(hTexRef: CUtexref, pBorderColor: *mut f32) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefSetFlags(hTexRef: CUtexref, Flags: ::std::os::raw::c_uint) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuTexRefGetAddress(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult;
-}
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetAddress_v2(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetArray(phArray: *mut CUarray, hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetMipmappedArray(
         phMipmappedArray: *mut CUmipmappedArray,
         hTexRef: CUtexref,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetAddressMode(
         pam: *mut CUaddress_mode,
         hTexRef: CUtexref,
         dim: ::std::os::raw::c_int,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetFormat(
         pFormat: *mut CUarray_format,
         pNumChannels: *mut ::std::os::raw::c_int,
         hTexRef: CUtexref,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetMipmapFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetMipmapLevelBias(pbias: *mut f32, hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetMipmapLevelClamp(
         pminMipmapLevelClamp: *mut f32,
         pmaxMipmapLevelClamp: *mut f32,
         hTexRef: CUtexref,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetMaxAnisotropy(
         pmaxAniso: *mut ::std::os::raw::c_int,
         hTexRef: CUtexref,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetBorderColor(pBorderColor: *mut f32, hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefGetFlags(pFlags: *mut ::std::os::raw::c_uint, hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefCreate(pTexRef: *mut CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexRefDestroy(hTexRef: CUtexref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuSurfRefSetArray(
         hSurfRef: CUsurfref,
         hArray: CUarray,
         Flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuSurfRefGetArray(phArray: *mut CUarray, hSurfRef: CUsurfref) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexObjectCreate(
         pTexObject: *mut CUtexObject,
         pResDesc: *const CUDA_RESOURCE_DESC,
@@ -4273,57 +4645,57 @@ extern_redirect! {
         pResViewDesc: *const CUDA_RESOURCE_VIEW_DESC,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexObjectDestroy(texObject: CUtexObject) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexObjectGetResourceDesc(
         pResDesc: *mut CUDA_RESOURCE_DESC,
         texObject: CUtexObject,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexObjectGetTextureDesc(
         pTexDesc: *mut CUDA_TEXTURE_DESC,
         texObject: CUtexObject,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuTexObjectGetResourceViewDesc(
         pResViewDesc: *mut CUDA_RESOURCE_VIEW_DESC,
         texObject: CUtexObject,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuSurfObjectCreate(
         pSurfObject: *mut CUsurfObject,
         pResDesc: *const CUDA_RESOURCE_DESC,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuSurfObjectDestroy(surfObject: CUsurfObject) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuSurfObjectGetResourceDesc(
         pResDesc: *mut CUDA_RESOURCE_DESC,
         surfObject: CUsurfObject,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceCanAccessPeer(
         canAccessPeer: *mut ::std::os::raw::c_int,
         dev: CUdevice,
         peerDev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxEnablePeerAccess(peerContext: CUcontext, Flags: ::std::os::raw::c_uint)
         -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuCtxDisablePeerAccess(peerContext: CUcontext) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuDeviceGetP2PAttribute(
         value: *mut ::std::os::raw::c_int,
         attrib: CUdevice_P2PAttribute,
@@ -4331,10 +4703,10 @@ extern_redirect! {
         dstDevice: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphicsUnregisterResource(resource: CUgraphicsResource) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphicsSubResourceGetMappedArray(
         pArray: *mut CUarray,
         resource: CUgraphicsResource,
@@ -4342,76 +4714,992 @@ extern_redirect! {
         mipLevel: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphicsResourceGetMappedMipmappedArray(
         pMipmappedArray: *mut CUmipmappedArray,
         resource: CUgraphicsResource,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuGraphicsResourceGetMappedPointer(
+extern "C" {
+    pub fn cuGraphicsResourceGetMappedPointer_v2(
         pDevPtr: *mut CUdeviceptr,
         pSize: *mut usize,
         resource: CUgraphicsResource,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuGraphicsResourceGetMappedPointer_v2(
-        pDevPtr: *mut CUdeviceptr,
-        pSize: *mut usize,
+extern "C" {
+    pub fn cuGraphicsResourceSetMapFlags_v2(
         resource: CUgraphicsResource,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphicsMapResources_ptsz(
+        count: ::std::os::raw::c_uint,
+        resources: *mut CUgraphicsResource,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphicsUnmapResources_ptsz(
+        count: ::std::os::raw::c_uint,
+        resources: *mut CUgraphicsResource,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGetProcAddress(
+        symbol: *const ::std::os::raw::c_char,
+        pfn: *mut *mut ::std::os::raw::c_void,
+        cudaVersion: ::std::os::raw::c_int,
+        flags: cuuint64_t,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuGetExportTable(
+        ppExportTable: *mut *const ::std::os::raw::c_void,
+        pExportTableId: *const CUuuid,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemHostRegister(
+        p: *mut ::std::os::raw::c_void,
+        bytesize: usize,
+        Flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
     pub fn cuGraphicsResourceSetMapFlags(
         resource: CUgraphicsResource,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuGraphicsResourceSetMapFlags_v2(
+extern "C" {
+    pub fn cuLinkCreate(
+        numOptions: ::std::os::raw::c_uint,
+        options: *mut CUjit_option,
+        optionValues: *mut *mut ::std::os::raw::c_void,
+        stateOut: *mut CUlinkState,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuLinkAddData(
+        state: CUlinkState,
+        type_: CUjitInputType,
+        data: *mut ::std::os::raw::c_void,
+        size: usize,
+        name: *const ::std::os::raw::c_char,
+        numOptions: ::std::os::raw::c_uint,
+        options: *mut CUjit_option,
+        optionValues: *mut *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuLinkAddFile(
+        state: CUlinkState,
+        type_: CUjitInputType,
+        path: *const ::std::os::raw::c_char,
+        numOptions: ::std::os::raw::c_uint,
+        options: *mut CUjit_option,
+        optionValues: *mut *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuTexRefSetAddress2D_v2(
+        hTexRef: CUtexref,
+        desc: *const CUDA_ARRAY_DESCRIPTOR,
+        dptr: CUdeviceptr,
+        Pitch: usize,
+    ) -> CUresult;
+}
+#[repr(transparent)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUdeviceptr_v1(pub ::std::os::raw::c_uint);
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUDA_MEMCPY2D_v1_st {
+    pub srcXInBytes: ::std::os::raw::c_uint,
+    pub srcY: ::std::os::raw::c_uint,
+    pub srcMemoryType: CUmemorytype,
+    pub srcHost: *const ::std::os::raw::c_void,
+    pub srcDevice: CUdeviceptr_v1,
+    pub srcArray: CUarray,
+    pub srcPitch: ::std::os::raw::c_uint,
+    pub dstXInBytes: ::std::os::raw::c_uint,
+    pub dstY: ::std::os::raw::c_uint,
+    pub dstMemoryType: CUmemorytype,
+    pub dstHost: *mut ::std::os::raw::c_void,
+    pub dstDevice: CUdeviceptr_v1,
+    pub dstArray: CUarray,
+    pub dstPitch: ::std::os::raw::c_uint,
+    pub WidthInBytes: ::std::os::raw::c_uint,
+    pub Height: ::std::os::raw::c_uint,
+}
+pub type CUDA_MEMCPY2D_v1 = CUDA_MEMCPY2D_v1_st;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUDA_MEMCPY3D_v1_st {
+    pub srcXInBytes: ::std::os::raw::c_uint,
+    pub srcY: ::std::os::raw::c_uint,
+    pub srcZ: ::std::os::raw::c_uint,
+    pub srcLOD: ::std::os::raw::c_uint,
+    pub srcMemoryType: CUmemorytype,
+    pub srcHost: *const ::std::os::raw::c_void,
+    pub srcDevice: CUdeviceptr_v1,
+    pub srcArray: CUarray,
+    pub reserved0: *mut ::std::os::raw::c_void,
+    pub srcPitch: ::std::os::raw::c_uint,
+    pub srcHeight: ::std::os::raw::c_uint,
+    pub dstXInBytes: ::std::os::raw::c_uint,
+    pub dstY: ::std::os::raw::c_uint,
+    pub dstZ: ::std::os::raw::c_uint,
+    pub dstLOD: ::std::os::raw::c_uint,
+    pub dstMemoryType: CUmemorytype,
+    pub dstHost: *mut ::std::os::raw::c_void,
+    pub dstDevice: CUdeviceptr_v1,
+    pub dstArray: CUarray,
+    pub reserved1: *mut ::std::os::raw::c_void,
+    pub dstPitch: ::std::os::raw::c_uint,
+    pub dstHeight: ::std::os::raw::c_uint,
+    pub WidthInBytes: ::std::os::raw::c_uint,
+    pub Height: ::std::os::raw::c_uint,
+    pub Depth: ::std::os::raw::c_uint,
+}
+pub type CUDA_MEMCPY3D_v1 = CUDA_MEMCPY3D_v1_st;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUDA_ARRAY_DESCRIPTOR_v1_st {
+    pub Width: ::std::os::raw::c_uint,
+    pub Height: ::std::os::raw::c_uint,
+    pub Format: CUarray_format,
+    pub NumChannels: ::std::os::raw::c_uint,
+}
+pub type CUDA_ARRAY_DESCRIPTOR_v1 = CUDA_ARRAY_DESCRIPTOR_v1_st;
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct CUDA_ARRAY3D_DESCRIPTOR_v1_st {
+    pub Width: ::std::os::raw::c_uint,
+    pub Height: ::std::os::raw::c_uint,
+    pub Depth: ::std::os::raw::c_uint,
+    pub Format: CUarray_format,
+    pub NumChannels: ::std::os::raw::c_uint,
+    pub Flags: ::std::os::raw::c_uint,
+}
+pub type CUDA_ARRAY3D_DESCRIPTOR_v1 = CUDA_ARRAY3D_DESCRIPTOR_v1_st;
+extern "C" {
+    pub fn cuDeviceTotalMem(bytes: *mut ::std::os::raw::c_uint, dev: CUdevice) -> CUresult;
+}
+extern "C" {
+    pub fn cuCtxCreate(
+        pctx: *mut CUcontext,
+        flags: ::std::os::raw::c_uint,
+        dev: CUdevice,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuModuleGetGlobal(
+        dptr: *mut CUdeviceptr_v1,
+        bytes: *mut ::std::os::raw::c_uint,
+        hmod: CUmodule,
+        name: *const ::std::os::raw::c_char,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemGetInfo(
+        free: *mut ::std::os::raw::c_uint,
+        total: *mut ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemAlloc(dptr: *mut CUdeviceptr_v1, bytesize: ::std::os::raw::c_uint) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemAllocPitch(
+        dptr: *mut CUdeviceptr_v1,
+        pPitch: *mut ::std::os::raw::c_uint,
+        WidthInBytes: ::std::os::raw::c_uint,
+        Height: ::std::os::raw::c_uint,
+        ElementSizeBytes: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemFree(dptr: CUdeviceptr_v1) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemGetAddressRange(
+        pbase: *mut CUdeviceptr_v1,
+        psize: *mut ::std::os::raw::c_uint,
+        dptr: CUdeviceptr_v1,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemAllocHost(
+        pp: *mut *mut ::std::os::raw::c_void,
+        bytesize: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemHostGetDevicePointer(
+        pdptr: *mut CUdeviceptr_v1,
+        p: *mut ::std::os::raw::c_void,
+        Flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoD(
+        dstDevice: CUdeviceptr_v1,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoH(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcDevice: CUdeviceptr_v1,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoD(
+        dstDevice: CUdeviceptr_v1,
+        srcDevice: CUdeviceptr_v1,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoA(
+        dstArray: CUarray,
+        dstOffset: ::std::os::raw::c_uint,
+        srcDevice: CUdeviceptr_v1,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoD(
+        dstDevice: CUdeviceptr_v1,
+        srcArray: CUarray,
+        srcOffset: ::std::os::raw::c_uint,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoA(
+        dstArray: CUarray,
+        dstOffset: ::std::os::raw::c_uint,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoH(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcArray: CUarray,
+        srcOffset: ::std::os::raw::c_uint,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoA(
+        dstArray: CUarray,
+        dstOffset: ::std::os::raw::c_uint,
+        srcArray: CUarray,
+        srcOffset: ::std::os::raw::c_uint,
+        ByteCount: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoAAsync(
+        dstArray: CUarray,
+        dstOffset: ::std::os::raw::c_uint,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: ::std::os::raw::c_uint,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoHAsync(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcArray: CUarray,
+        srcOffset: ::std::os::raw::c_uint,
+        ByteCount: ::std::os::raw::c_uint,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy2D(pCopy: *const CUDA_MEMCPY2D_v1) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy2DUnaligned(pCopy: *const CUDA_MEMCPY2D_v1) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy3D(pCopy: *const CUDA_MEMCPY3D_v1) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoDAsync(
+        dstDevice: CUdeviceptr_v1,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: ::std::os::raw::c_uint,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoHAsync(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcDevice: CUdeviceptr_v1,
+        ByteCount: ::std::os::raw::c_uint,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoDAsync(
+        dstDevice: CUdeviceptr_v1,
+        srcDevice: CUdeviceptr_v1,
+        ByteCount: ::std::os::raw::c_uint,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy2DAsync(pCopy: *const CUDA_MEMCPY2D_v1, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy3DAsync(pCopy: *const CUDA_MEMCPY3D_v1, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD8(
+        dstDevice: CUdeviceptr_v1,
+        uc: ::std::os::raw::c_uchar,
+        N: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD16(
+        dstDevice: CUdeviceptr_v1,
+        us: ::std::os::raw::c_ushort,
+        N: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD32(
+        dstDevice: CUdeviceptr_v1,
+        ui: ::std::os::raw::c_uint,
+        N: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D8(
+        dstDevice: CUdeviceptr_v1,
+        dstPitch: ::std::os::raw::c_uint,
+        uc: ::std::os::raw::c_uchar,
+        Width: ::std::os::raw::c_uint,
+        Height: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D16(
+        dstDevice: CUdeviceptr_v1,
+        dstPitch: ::std::os::raw::c_uint,
+        us: ::std::os::raw::c_ushort,
+        Width: ::std::os::raw::c_uint,
+        Height: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D32(
+        dstDevice: CUdeviceptr_v1,
+        dstPitch: ::std::os::raw::c_uint,
+        ui: ::std::os::raw::c_uint,
+        Width: ::std::os::raw::c_uint,
+        Height: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuArrayCreate(
+        pHandle: *mut CUarray,
+        pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR_v1,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuArrayGetDescriptor(
+        pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR_v1,
+        hArray: CUarray,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuArray3DCreate(
+        pHandle: *mut CUarray,
+        pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR_v1,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuArray3DGetDescriptor(
+        pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR_v1,
+        hArray: CUarray,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuTexRefSetAddress(
+        ByteOffset: *mut ::std::os::raw::c_uint,
+        hTexRef: CUtexref,
+        dptr: CUdeviceptr_v1,
+        bytes: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuTexRefSetAddress2D(
+        hTexRef: CUtexref,
+        desc: *const CUDA_ARRAY_DESCRIPTOR_v1,
+        dptr: CUdeviceptr_v1,
+        Pitch: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuTexRefGetAddress(pdptr: *mut CUdeviceptr_v1, hTexRef: CUtexref) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphicsResourceGetMappedPointer(
+        pDevPtr: *mut CUdeviceptr_v1,
+        pSize: *mut ::std::os::raw::c_uint,
         resource: CUgraphicsResource,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuCtxDestroy(ctx: CUcontext) -> CUresult;
+}
+extern "C" {
+    pub fn cuCtxPopCurrent(pctx: *mut CUcontext) -> CUresult;
+}
+extern "C" {
+    pub fn cuCtxPushCurrent(ctx: CUcontext) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamDestroy(hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuEventDestroy(hEvent: CUevent) -> CUresult;
+}
+extern "C" {
+    pub fn cuDevicePrimaryCtxRelease(dev: CUdevice) -> CUresult;
+}
+extern "C" {
+    pub fn cuDevicePrimaryCtxReset(dev: CUdevice) -> CUresult;
+}
+extern "C" {
+    pub fn cuDevicePrimaryCtxSetFlags(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoD_v2(
+        dstDevice: CUdeviceptr,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoH_v2(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcDevice: CUdeviceptr,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoD_v2(
+        dstDevice: CUdeviceptr,
+        srcDevice: CUdeviceptr,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoA_v2(
+        dstArray: CUarray,
+        dstOffset: usize,
+        srcDevice: CUdeviceptr,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoD_v2(
+        dstDevice: CUdeviceptr,
+        srcArray: CUarray,
+        srcOffset: usize,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoA_v2(
+        dstArray: CUarray,
+        dstOffset: usize,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoH_v2(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcArray: CUarray,
+        srcOffset: usize,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoA_v2(
+        dstArray: CUarray,
+        dstOffset: usize,
+        srcArray: CUarray,
+        srcOffset: usize,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoAAsync_v2(
+        dstArray: CUarray,
+        dstOffset: usize,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAtoHAsync_v2(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcArray: CUarray,
+        srcOffset: usize,
+        ByteCount: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy2D_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy2DUnaligned_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy3D_v2(pCopy: *const CUDA_MEMCPY3D) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyHtoDAsync_v2(
+        dstDevice: CUdeviceptr,
+        srcHost: *const ::std::os::raw::c_void,
+        ByteCount: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoHAsync_v2(
+        dstHost: *mut ::std::os::raw::c_void,
+        srcDevice: CUdeviceptr,
+        ByteCount: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyDtoDAsync_v2(
+        dstDevice: CUdeviceptr,
+        srcDevice: CUdeviceptr,
+        ByteCount: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy2DAsync_v2(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy3DAsync_v2(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD8_v2(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize)
+        -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD16_v2(
+        dstDevice: CUdeviceptr,
+        us: ::std::os::raw::c_ushort,
+        N: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD32_v2(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize)
+        -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D8_v2(
+        dstDevice: CUdeviceptr,
+        dstPitch: usize,
+        uc: ::std::os::raw::c_uchar,
+        Width: usize,
+        Height: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D16_v2(
+        dstDevice: CUdeviceptr,
+        dstPitch: usize,
+        us: ::std::os::raw::c_ushort,
+        Width: usize,
+        Height: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D32_v2(
+        dstDevice: CUdeviceptr,
+        dstPitch: usize,
+        ui: ::std::os::raw::c_uint,
+        Width: usize,
+        Height: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyAsync(
+        dst: CUdeviceptr,
+        src: CUdeviceptr,
+        ByteCount: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyPeer(
+        dstDevice: CUdeviceptr,
+        dstContext: CUcontext,
+        srcDevice: CUdeviceptr,
+        srcContext: CUcontext,
+        ByteCount: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpyPeerAsync(
+        dstDevice: CUdeviceptr,
+        dstContext: CUcontext,
+        srcDevice: CUdeviceptr,
+        srcContext: CUcontext,
+        ByteCount: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy3DPeer(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemcpy3DPeerAsync(pCopy: *const CUDA_MEMCPY3D_PEER, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD8Async(
+        dstDevice: CUdeviceptr,
+        uc: ::std::os::raw::c_uchar,
+        N: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD16Async(
+        dstDevice: CUdeviceptr,
+        us: ::std::os::raw::c_ushort,
+        N: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD32Async(
+        dstDevice: CUdeviceptr,
+        ui: ::std::os::raw::c_uint,
+        N: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D8Async(
+        dstDevice: CUdeviceptr,
+        dstPitch: usize,
+        uc: ::std::os::raw::c_uchar,
+        Width: usize,
+        Height: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D16Async(
+        dstDevice: CUdeviceptr,
+        dstPitch: usize,
+        us: ::std::os::raw::c_ushort,
+        Width: usize,
+        Height: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemsetD2D32Async(
+        dstDevice: CUdeviceptr,
+        dstPitch: usize,
+        ui: ::std::os::raw::c_uint,
+        Width: usize,
+        Height: usize,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamGetPriority(hStream: CUstream, priority: *mut ::std::os::raw::c_int)
+        -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamGetFlags(hStream: CUstream, flags: *mut ::std::os::raw::c_uint) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamGetCtx(hStream: CUstream, pctx: *mut CUcontext) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamWaitEvent(
+        hStream: CUstream,
+        hEvent: CUevent,
+        Flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamAddCallback(
+        hStream: CUstream,
+        callback: CUstreamCallback,
+        userData: *mut ::std::os::raw::c_void,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamAttachMemAsync(
+        hStream: CUstream,
+        dptr: CUdeviceptr,
+        length: usize,
         flags: ::std::os::raw::c_uint,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
+    pub fn cuStreamQuery(hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamSynchronize(hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuEventRecord(hEvent: CUevent, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuEventRecordWithFlags(
+        hEvent: CUevent,
+        hStream: CUstream,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuLaunchKernel(
+        f: CUfunction,
+        gridDimX: ::std::os::raw::c_uint,
+        gridDimY: ::std::os::raw::c_uint,
+        gridDimZ: ::std::os::raw::c_uint,
+        blockDimX: ::std::os::raw::c_uint,
+        blockDimY: ::std::os::raw::c_uint,
+        blockDimZ: ::std::os::raw::c_uint,
+        sharedMemBytes: ::std::os::raw::c_uint,
+        hStream: CUstream,
+        kernelParams: *mut *mut ::std::os::raw::c_void,
+        extra: *mut *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuLaunchHostFunc(
+        hStream: CUstream,
+        fn_: CUhostFn,
+        userData: *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
     pub fn cuGraphicsMapResources(
         count: ::std::os::raw::c_uint,
         resources: *mut CUgraphicsResource,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect! {
+extern "C" {
     pub fn cuGraphicsUnmapResources(
         count: ::std::os::raw::c_uint,
         resources: *mut CUgraphicsResource,
         hStream: CUstream,
     ) -> CUresult;
 }
-extern_redirect_with_post! {
-    pub fn cuGetExportTable(
-        ppExportTable: *mut *const ::std::os::raw::c_void,
-        pExportTableId: *const CUuuid,
+extern "C" {
+    pub fn cuStreamWriteValue32(
+        stream: CUstream,
+        addr: CUdeviceptr,
+        value: cuuint32_t,
+        flags: ::std::os::raw::c_uint,
     ) -> CUresult;
-    super::cuGetExportTable_Post;
 }
-extern_redirect! {
-    pub fn cuFuncGetModule(hmod: *mut CUmodule, hfunc: CUfunction) -> CUresult;
+extern "C" {
+    pub fn cuStreamWaitValue32(
+        stream: CUstream,
+        addr: CUdeviceptr,
+        value: cuuint32_t,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
 }
-#[repr(transparent)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-pub struct CUoutput_mode_enum(pub ::std::os::raw::c_uint);
-pub use self::CUoutput_mode_enum as CUoutput_mode;
-extern_redirect! {
-    pub fn cuProfilerInitialize(
-        configFile: *const ::std::os::raw::c_char,
-        outputFile: *const ::std::os::raw::c_char,
-        outputMode: CUoutput_mode,
+extern "C" {
+    pub fn cuStreamWriteValue64(
+        stream: CUstream,
+        addr: CUdeviceptr,
+        value: cuuint64_t,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamWaitValue64(
+        stream: CUstream,
+        addr: CUdeviceptr,
+        value: cuuint64_t,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamBatchMemOp(
+        stream: CUstream,
+        count: ::std::os::raw::c_uint,
+        paramArray: *mut CUstreamBatchMemOpParams,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemPrefetchAsync(
+        devPtr: CUdeviceptr,
+        count: usize,
+        dstDevice: CUdevice,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuLaunchCooperativeKernel(
+        f: CUfunction,
+        gridDimX: ::std::os::raw::c_uint,
+        gridDimY: ::std::os::raw::c_uint,
+        gridDimZ: ::std::os::raw::c_uint,
+        blockDimX: ::std::os::raw::c_uint,
+        blockDimY: ::std::os::raw::c_uint,
+        blockDimZ: ::std::os::raw::c_uint,
+        sharedMemBytes: ::std::os::raw::c_uint,
+        hStream: CUstream,
+        kernelParams: *mut *mut ::std::os::raw::c_void,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuSignalExternalSemaphoresAsync(
+        extSemArray: *const CUexternalSemaphore,
+        paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,
+        numExtSems: ::std::os::raw::c_uint,
+        stream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuWaitExternalSemaphoresAsync(
+        extSemArray: *const CUexternalSemaphore,
+        paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,
+        numExtSems: ::std::os::raw::c_uint,
+        stream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamBeginCapture(hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamBeginCapture_ptsz(hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamBeginCapture_v2(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamEndCapture(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamIsCapturing(
+        hStream: CUstream,
+        captureStatus: *mut CUstreamCaptureStatus,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamGetCaptureInfo(
+        hStream: CUstream,
+        captureStatus_out: *mut CUstreamCaptureStatus,
+        id_out: *mut cuuint64_t,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamGetCaptureInfo_v2(
+        hStream: CUstream,
+        captureStatus_out: *mut CUstreamCaptureStatus,
+        id_out: *mut cuuint64_t,
+        graph_out: *mut CUgraph,
+        dependencies_out: *mut *const CUgraphNode,
+        numDependencies_out: *mut usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphUpload(hGraph: CUgraphExec, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphLaunch(hGraph: CUgraphExec, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamCopyAttributes(dstStream: CUstream, srcStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamGetAttribute(
+        hStream: CUstream,
+        attr: CUstreamAttrID,
+        value: *mut CUstreamAttrValue,
     ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuProfilerStart() -> CUresult;
+extern "C" {
+    pub fn cuStreamSetAttribute(
+        hStream: CUstream,
+        attr: CUstreamAttrID,
+        param: *const CUstreamAttrValue,
+    ) -> CUresult;
 }
-extern_redirect! {
-    pub fn cuProfilerStop() -> CUresult;
+extern "C" {
+    pub fn cuIpcOpenMemHandle(
+        pdptr: *mut CUdeviceptr,
+        handle: CUipcMemHandle,
+        Flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuGraphInstantiate(
+        phGraphExec: *mut CUgraphExec,
+        hGraph: CUgraph,
+        phErrorNode: *mut CUgraphNode,
+        logBuffer: *mut ::std::os::raw::c_char,
+        bufferSize: usize,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemMapArrayAsync(
+        mapInfoList: *mut CUarrayMapInfo,
+        count: ::std::os::raw::c_uint,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemFreeAsync(dptr: CUdeviceptr, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemAllocAsync(dptr: *mut CUdeviceptr, bytesize: usize, hStream: CUstream) -> CUresult;
+}
+extern "C" {
+    pub fn cuMemAllocFromPoolAsync(
+        dptr: *mut CUdeviceptr,
+        bytesize: usize,
+        pool: CUmemoryPool,
+        hStream: CUstream,
+    ) -> CUresult;
+}
+extern "C" {
+    pub fn cuStreamUpdateCaptureDependencies(
+        hStream: CUstream,
+        dependencies: *mut CUgraphNode,
+        numDependencies: usize,
+        flags: ::std::os::raw::c_uint,
+    ) -> CUresult;
 }
diff --git a/cuda_base/src/lib.rs b/cuda_base/src/lib.rs
new file mode 100644
index 0000000..57c7156
--- /dev/null
+++ b/cuda_base/src/lib.rs
@@ -0,0 +1,485 @@
+extern crate proc_macro;
+
+use std::collections::hash_map;
+use std::iter;
+
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::{format_ident, quote, ToTokens};
+use rustc_hash::{FxHashMap, FxHashSet};
+use syn::parse::{Parse, ParseStream};
+use syn::punctuated::Punctuated;
+use syn::token::Brace;
+use syn::visit_mut::VisitMut;
+use syn::{
+    bracketed, parse_macro_input, Abi, Fields, File, FnArg, ForeignItem, ForeignItemFn, Ident,
+    Item, ItemForeignMod, ItemMacro, LitStr, Macro, MacroDelimiter, PatType, Path, PathArguments,
+    PathSegment, ReturnType, Signature, Token, Type, TypeArray, TypePath, TypePtr,
+};
+
+const CUDA_RS: &'static str = include_str! {"cuda.rs"};
+
+// This macro copies cuda.rs as-is with some changes:
+// * All function declarations are filtered out
+// * CUdeviceptr_v2 is redefined from `unsigned long long` to `*void`
+// * `extern "C"` gets replaced by `extern "system"`
+// * CUuuid_st is redefined to use uchar instead of char
+#[proc_macro]
+pub fn cuda_type_declarations(_: TokenStream) -> TokenStream {
+    let mut cuda_module = syn::parse_str::<File>(CUDA_RS).unwrap();
+    cuda_module.items = cuda_module
+        .items
+        .into_iter()
+        .filter_map(|item| match item {
+            Item::ForeignMod(_) => None,
+            Item::Struct(mut struct_) => {
+                if "CUdeviceptr_v2" == struct_.ident.to_string() {
+                    match &mut struct_.fields {
+                        Fields::Unnamed(ref mut fields) => {
+                            fields.unnamed[0].ty =
+                                absolute_path_to_mut_ptr(&["std", "os", "raw", "c_void"])
+                        }
+                        _ => unreachable!(),
+                    }
+                } else if "CUuuid_st" == struct_.ident.to_string() {
+                    match &mut struct_.fields {
+                        Fields::Named(ref mut fields) => match fields.named[0].ty {
+                            Type::Array(TypeArray { ref mut elem, .. }) => {
+                                *elem = Box::new(Type::Path(TypePath {
+                                    qself: None,
+                                    path: segments_to_path(&["std", "os", "raw", "c_uchar"]),
+                                }))
+                            }
+                            _ => unreachable!(),
+                        },
+                        _ => panic!(),
+                    }
+                }
+                Some(Item::Struct(struct_))
+            }
+            i => Some(i),
+        })
+        .collect::<Vec<_>>();
+    syn::visit_mut::visit_file_mut(&mut FixAbi, &mut cuda_module);
+    cuda_module.into_token_stream().into()
+}
+
+fn segments_to_path(path: &[&'static str]) -> Path {
+    let mut segments = Punctuated::new();
+    for ident in path {
+        let ident = PathSegment {
+            ident: Ident::new(ident, Span::call_site()),
+            arguments: PathArguments::None,
+        };
+        segments.push(ident);
+    }
+    Path {
+        leading_colon: Some(Token![::](Span::call_site())),
+        segments,
+    }
+}
+
+fn absolute_path_to_mut_ptr(path: &[&'static str]) -> Type {
+    Type::Ptr(TypePtr {
+        star_token: Token![*](Span::call_site()),
+        const_token: None,
+        mutability: Some(Token![mut](Span::call_site())),
+        elem: Box::new(Type::Path(TypePath {
+            qself: None,
+            path: segments_to_path(path),
+        })),
+    })
+}
+
+struct FixAbi;
+
+impl VisitMut for FixAbi {
+    fn visit_abi_mut(&mut self, i: &mut Abi) {
+        if let Some(ref mut name) = i.name {
+            *name = LitStr::new("system", Span::call_site());
+        }
+    }
+}
+
+// This macro accepts following arguments:
+// * `type_path`: path to the module with type definitions (in the module tree)
+// * `normal_macro`: ident for a normal macro
+// * `override_macro`: ident for an override macro
+// * `override_fns`: list of override functions
+// Then macro goes through every function in rust.rs, and for every fn `foo`:
+// * if `foo` is contained in `override_fns` then pass it into `override_macro`
+// * if `foo` is not contained in `override_fns` pass it to `normal_macro`
+// Both `override_macro` and `normal_macro` expect this format:
+//   macro_foo!("system" fn cuCtxDetach(ctx: CUcontext) -> CUresult)
+// Additionally, it does a fixup of CUDA types so they get prefixed with `type_path`
+#[proc_macro]
+pub fn cuda_function_declarations(tokens: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(tokens as FnDeclInput);
+    let cuda_module = syn::parse_str::<File>(CUDA_RS).unwrap();
+    let override_fns = input
+        .override_fns
+        .iter()
+        .map(ToString::to_string)
+        .collect::<FxHashSet<_>>();
+    cuda_module
+        .items
+        .into_iter()
+        .filter_map(|item| match item {
+            Item::ForeignMod(ItemForeignMod { mut items, .. }) => match items.pop().unwrap() {
+                ForeignItem::Fn(ForeignItemFn {
+                    sig:
+                        Signature {
+                            ident,
+                            inputs,
+                            output,
+                            ..
+                        },
+                    ..
+                }) => {
+                    let path = if override_fns.contains(&ident.to_string()) {
+                        &input.override_macro
+                    } else {
+                        &input.normal_macro
+                    }
+                    .clone();
+                    let inputs = inputs
+                        .into_iter()
+                        .map(|fn_arg| match fn_arg {
+                            FnArg::Typed(mut pat_type) => {
+                                pat_type.ty =
+                                    prepend_cuda_path_to_type(&input.type_path, pat_type.ty);
+                                FnArg::Typed(pat_type)
+                            }
+                            _ => unreachable!(),
+                        })
+                        .collect::<Punctuated<_, Token![,]>>();
+                    let output = match output {
+                        ReturnType::Type(_, type_) => type_,
+                        ReturnType::Default => unreachable!(),
+                    };
+                    let type_path = input.type_path.clone();
+                    let tokens = quote! {
+                        "system" fn #ident(#inputs) -> #type_path :: #output
+                    };
+                    Some(Item::Macro(ItemMacro {
+                        attrs: Vec::new(),
+                        ident: None,
+                        mac: Macro {
+                            path,
+                            bang_token: Token![!](Span::call_site()),
+                            delimiter: MacroDelimiter::Brace(Brace {
+                                span: Span::call_site(),
+                            }),
+                            tokens,
+                        },
+                        semi_token: None,
+                    }))
+                }
+                _ => unreachable!(),
+            },
+            _ => None,
+        })
+        .map(Item::into_token_stream)
+        .collect::<proc_macro2::TokenStream>()
+        .into()
+}
+
+fn prepend_cuda_path_to_type(base_path: &Path, type_: Box<Type>) -> Box<Type> {
+    match *type_ {
+        Type::Path(mut type_path) => {
+            type_path.path = prepend_cuda_path_to_path(base_path, type_path.path);
+            Box::new(Type::Path(type_path))
+        }
+        Type::Ptr(mut type_ptr) => {
+            type_ptr.elem = prepend_cuda_path_to_type(base_path, type_ptr.elem);
+            Box::new(Type::Ptr(type_ptr))
+        }
+        _ => unreachable!(),
+    }
+}
+
+fn prepend_cuda_path_to_path(base_path: &Path, path: Path) -> Path {
+    if path.leading_colon.is_some() {
+        return path;
+    }
+    if path.segments.len() == 1 {
+        let ident = path.segments[0].ident.to_string();
+        if ident.starts_with("CU") || ident.starts_with("cu") {
+            let mut base_path = base_path.clone();
+            base_path.segments.extend(path.segments);
+            return base_path;
+        }
+    }
+    path
+}
+
+struct FnDeclInput {
+    type_path: Path,
+    normal_macro: Path,
+    override_macro: Path,
+    override_fns: Punctuated<Ident, Token![,]>,
+}
+
+impl Parse for FnDeclInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let type_path = input.parse::<Path>()?;
+        input.parse::<Token![,]>()?;
+        let normal_macro = input.parse::<Path>()?;
+        input.parse::<Token![,]>()?;
+        let override_macro = input.parse::<Path>()?;
+        input.parse::<Token![,]>()?;
+        let override_fns_content;
+        bracketed!(override_fns_content in input);
+        let override_fns = override_fns_content.parse_terminated(Ident::parse)?;
+        Ok(Self {
+            type_path,
+            normal_macro,
+            override_macro,
+            override_fns,
+        })
+    }
+}
+
+// This trait accepts following parameters:
+// * `type_path`: path to the module with type definitions (in the module tree)
+// * `trait_`: name of the trait to be derived
+// * `ignore_structs`: bracketed list of types to ignore
+// * `ignore_fns`: bracketed list of fns to ignore
+#[proc_macro]
+pub fn cuda_derive_display_trait(tokens: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(tokens as DeriveDisplayInput);
+    let cuda_module = syn::parse_str::<File>(CUDA_RS).unwrap();
+    let mut derive_state = DeriveDisplayState::new(input);
+    cuda_module
+        .items
+        .into_iter()
+        .filter_map(|i| cuda_derive_display_trait_for_item(&mut derive_state, i))
+        .collect::<proc_macro2::TokenStream>()
+        .into()
+}
+
+fn cuda_derive_display_trait_for_item(
+    state: &mut DeriveDisplayState,
+    item: Item,
+) -> Option<proc_macro2::TokenStream> {
+    let path_prefix = &state.type_path;
+    let path_prefix_iter = iter::repeat(&path_prefix);
+    let trait_ = &state.trait_;
+    let trait_iter = iter::repeat(&state.trait_);
+    match item {
+        Item::Const(_) => None,
+        Item::ForeignMod(ItemForeignMod { mut items, .. }) => match items.pop().unwrap() {
+            ForeignItem::Fn(ForeignItemFn {
+                sig: Signature { ident, inputs, .. },
+                ..
+            }) => {
+                if state.ignore_fns.contains(&ident) {
+                    return None;
+                }
+                let inputs = inputs
+                    .into_iter()
+                    .map(|fn_arg| match fn_arg {
+                        FnArg::Typed(mut pat_type) => {
+                            pat_type.ty = prepend_cuda_path_to_type(path_prefix, pat_type.ty);
+                            FnArg::Typed(pat_type)
+                        }
+                        _ => unreachable!(),
+                    })
+                    .collect::<Vec<_>>();
+                let inputs_iter = inputs.iter();
+                let mut arg_name_iter = inputs.iter().map(|fn_arg| match fn_arg {
+                    FnArg::Typed(PatType { pat, .. }) => pat,
+                    _ => unreachable!(),
+                });
+                let fn_name = format_ident!("write_{}", ident);
+                Some(match arg_name_iter.next() {
+                    Some(first_arg_name) => quote! {
+                        pub fn #fn_name(writer: &mut (impl std::io::Write + ?Sized), #(#inputs_iter,)*) -> std::io::Result<()> {
+                            writer.write_all(concat!("(", stringify!(#first_arg_name), ": ").as_bytes())?;
+                            CudaDisplay::write(&#first_arg_name, writer)?;
+                            #(
+                                writer.write_all(b", ")?;
+                                writer.write_all(concat!(stringify!(#arg_name_iter), ": ").as_bytes())?;
+                                CudaDisplay::write(&#arg_name_iter, writer)?;
+                            )*
+                            writer.write_all(b")")
+                        }
+                    },
+                    None => quote! {
+                        pub fn #fn_name(writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
+                            writer.write_all(b"()")
+                        }
+                    },
+                })
+            }
+            _ => unreachable!(),
+        },
+        Item::Impl(mut item_impl) => {
+            let enum_ = match *(item_impl.self_ty) {
+                Type::Path(mut path) => path.path.segments.pop().unwrap().into_value().ident,
+                _ => unreachable!(),
+            };
+            let variant_ = match item_impl.items.pop().unwrap() {
+                syn::ImplItem::Const(item_const) => item_const.ident,
+                _ => unreachable!(),
+            };
+            state.record_enum_variant(enum_, variant_);
+            None
+        }
+        Item::Struct(item_struct) => {
+            let item_struct_name = item_struct.ident.to_string();
+            if state.ignore_structs.contains(&item_struct.ident) {
+                return None;
+            }
+            if item_struct_name.ends_with("_enum") {
+                let enum_ = &item_struct.ident;
+                let enum_iter = iter::repeat(&item_struct.ident);
+                let variants = state.enums.get(&item_struct.ident).unwrap().iter();
+                Some(quote! {
+                    impl #trait_ for #path_prefix :: #enum_ {
+                        fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
+                            match self {
+                                #(& #path_prefix_iter :: #enum_iter :: #variants => writer.write_all(stringify!(#variants).as_bytes()),)*
+                                _ => write!(writer, "{}", self.0)
+                            }
+                        }
+                    }
+                })
+            } else {
+                let struct_ = &item_struct.ident;
+                let (first_field, rest_of_fields) = match item_struct.fields {
+                    Fields::Named(fields) => {
+                        let mut all_idents = fields.named.into_iter().filter_map(|f| {
+                            let f_ident = f.ident.unwrap();
+                            let name = f_ident.to_string();
+                            if name.starts_with("reserved") || name == "_unused" {
+                                None
+                            } else {
+                                Some(f_ident)
+                            }
+                        });
+                        let first = match all_idents.next() {
+                            Some(f) => f,
+                            None => return None,
+                        };
+                        (first, all_idents)
+                    }
+                    _ => return None,
+                };
+                Some(quote! {
+                    impl #trait_ for #path_prefix :: #struct_ {
+                        fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
+                            writer.write_all(concat!("{ ", stringify!(#first_field), ": ").as_bytes())?;
+                            #trait_::write(&self.#first_field, writer)?;
+                            #(
+                                writer.write_all(concat!(", ", stringify!(#rest_of_fields), ": ").as_bytes())?;
+                                #trait_iter::write(&self.#rest_of_fields, writer)?;
+                            )*
+                            writer.write_all(b" }")
+                        }
+                    }
+                })
+            }
+        }
+        Item::Type(item_type) => match *(item_type.ty) {
+            Type::Ptr(_) => {
+                let type_ = item_type.ident;
+                Some(quote! {
+                    impl #trait_ for #path_prefix :: #type_ {
+                        fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
+                            write!(writer, "{:p}", *self)
+                        }
+                    }
+                })
+            }
+            Type::Path(type_path) => {
+                if type_path.path.leading_colon.is_some() {
+                    let option_seg = type_path.path.segments.last().unwrap();
+                    if option_seg.ident == "Option" {
+                        match &option_seg.arguments {
+                            PathArguments::AngleBracketed(generic) => match generic.args[0] {
+                                syn::GenericArgument::Type(Type::BareFn(_)) => {
+                                    let type_ = &item_type.ident;
+                                    return Some(quote! {
+                                        impl #trait_ for #path_prefix :: #type_ {
+                                            fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
+                                                write!(writer, "{:p}", unsafe { std::mem::transmute::<#path_prefix :: #type_, *mut ::std::ffi::c_void>(*self) })
+                                            }
+                                        }
+                                    });
+                                }
+                                _ => unreachable!(),
+                            },
+                            _ => unreachable!(),
+                        }
+                    }
+                }
+                None
+            }
+            _ => unreachable!(),
+        },
+        Item::Union(_) => None,
+        Item::Use(_) => None,
+        _ => unreachable!(),
+    }
+}
+
+struct DeriveDisplayState {
+    type_path: Path,
+    trait_: Path,
+    ignore_structs: FxHashSet<Ident>,
+    ignore_fns: FxHashSet<Ident>,
+    enums: FxHashMap<Ident, Vec<Ident>>,
+}
+
+impl DeriveDisplayState {
+    fn new(input: DeriveDisplayInput) -> Self {
+        DeriveDisplayState {
+            type_path: input.type_path,
+            trait_: input.trait_,
+            ignore_structs: input.ignore_structs.into_iter().collect(),
+            ignore_fns: input.ignore_fns.into_iter().collect(),
+            enums: Default::default(),
+        }
+    }
+
+    fn record_enum_variant(&mut self, enum_: Ident, variant: Ident) {
+        match self.enums.entry(enum_) {
+            hash_map::Entry::Occupied(mut entry) => {
+                entry.get_mut().push(variant);
+            }
+            hash_map::Entry::Vacant(entry) => {
+                entry.insert(vec![variant]);
+            }
+        }
+    }
+}
+
+struct DeriveDisplayInput {
+    type_path: Path,
+    trait_: Path,
+    ignore_structs: Punctuated<Ident, Token![,]>,
+    ignore_fns: Punctuated<Ident, Token![,]>,
+}
+
+impl Parse for DeriveDisplayInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let type_path = input.parse::<Path>()?;
+        input.parse::<Token![,]>()?;
+        let trait_ = input.parse::<Path>()?;
+        input.parse::<Token![,]>()?;
+        let ignore_structs_buffer;
+        bracketed!(ignore_structs_buffer in input);
+        let ignore_structs = ignore_structs_buffer.parse_terminated(Ident::parse)?;
+        input.parse::<Token![,]>()?;
+        let ignore_fns_buffer;
+        bracketed!(ignore_fns_buffer in input);
+        let ignore_fns = ignore_fns_buffer.parse_terminated(Ident::parse)?;
+        Ok(Self {
+            type_path,
+            trait_,
+            ignore_structs,
+            ignore_fns,
+        })
+    }
+}
diff --git a/cuda_types/Cargo.toml b/cuda_types/Cargo.toml
new file mode 100644
index 0000000..e779830
--- /dev/null
+++ b/cuda_types/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "cuda_types"
+version = "0.0.0"
+authors = ["Andrzej Janik <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+cuda_base = { path = "../cuda_base" }
diff --git a/cuda_types/src/lib.rs b/cuda_types/src/lib.rs
new file mode 100644
index 0000000..6d24020
--- /dev/null
+++ b/cuda_types/src/lib.rs
@@ -0,0 +1,3 @@
+use cuda_base::cuda_type_declarations;

+

+cuda_type_declarations!();
\ No newline at end of file
diff --git a/zluda_dump/Cargo.toml b/zluda_dump/Cargo.toml
index b8f82ac..89381aa 100644
--- a/zluda_dump/Cargo.toml
+++ b/zluda_dump/Cargo.toml
@@ -18,6 +18,8 @@ lazy_static = "1.4"
 # we don't need elf32, but goblin has a bug where elf64 does not build without elf32

 goblin = { version = "0.4", default-features = false, features = ["elf64", "elf32", "archive"] }

 paste = "1.0"

+cuda_base = { path = "../cuda_base" }

+cuda_types = { path = "../cuda_types" }

 

 [target.'cfg(windows)'.dependencies]

 winapi = { version = "0.3", features = ["libloaderapi", "debugapi", "std"] }

diff --git a/zluda_dump/src/dark_api.rs b/zluda_dump/src/dark_api.rs
index 3ae50ed..50ce088 100644
--- a/zluda_dump/src/dark_api.rs
+++ b/zluda_dump/src/dark_api.rs
@@ -1,11 +1,9 @@
+use crate::format;

+use crate::{log, os, trace::StateTracker};

 use crate::{log::UInt, GlobalDelayedState};

+use cuda_types::{CUmodule, CUresult, CUuuid};

 use std::borrow::Cow;

-

-use crate::{

-    cuda::{CUmodule, CUresult, CUuuid},

-    log, os,

-    trace::StateTracker,

-};

+use std::hash::Hash;

 use std::{

     collections::{hash_map, HashMap},

     ffi::c_void,

@@ -17,10 +15,19 @@ use std::{
 pub(crate) struct DarkApiState {

     // Key is Box<CUuuid, because thunk reporting unknown export table needs a

     // stablememory location for the guid

-    overrides: HashMap<Box<CUuuid>, Vec<*const c_void>>,

+    overrides: HashMap<Box<CUuuidWrapper>, Vec<*const c_void>>,

     original: OriginalExports,

 }

 

+#[derive(Eq, PartialEq)]

+pub(crate) struct CUuuidWrapper(pub CUuuid);

+

+impl Hash for CUuuidWrapper {

+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

+        self.0.bytes.hash(state);

+    }

+}

+

 pub(crate) struct OriginalExports {

     original_get_module_from_cubin: Option<

         unsafe extern "system" fn(

@@ -69,11 +76,13 @@ pub(crate) fn override_export_table(
 ) {

     let state = &mut state.dark_api;

     let export_table_mut = unsafe { &mut *pp_export_table };

-    let export_id = Box::new(unsafe { *p_export_table_id });

+    let export_id = Box::new(CUuuidWrapper(unsafe { *p_export_table_id }));

     *export_table_mut = match state.overrides.entry(export_id) {

         hash_map::Entry::Occupied(entry) => entry.get().as_ptr() as *const _,

         hash_map::Entry::Vacant(entry) => {

-            let guid_ptr = &**entry.key() as *const _;

+            let guid_ptr = unsafe {

+                mem::transmute::<*const CUuuidWrapper, *const CUuuid>(&**entry.key() as *const _)

+            };

             entry

                 .insert(unsafe {

                     create_new_override(*pp_export_table as *const _, guid_ptr, &mut state.original)

@@ -123,7 +132,7 @@ unsafe extern "system" fn report_unknown_export_table_call(
     if let Ok(mut global_state) = crate::GLOBAL_STATE.lock() {

         let mut logger = global_state

             .log_factory

-            .get_logger_dark_api(*export_table, idx);

+            .get_logger_dark_api(*export_table, idx, None);

         logger.log(log::LogEntry::UnknownExportTableFn)

     }

 }

@@ -351,10 +360,21 @@ unsafe extern "system" fn get_module_from_cubin(
     module: *mut CUmodule,

     fatbinc_wrapper: *const FatbincWrapper,

 ) -> CUresult {

+    let arguments_writer = Box::new(move |writer: &mut dyn std::io::Write| {

+        writer.write_all(b"(")?;

+        writer.write_all(stringify!(module).as_bytes())?;

+        writer.write_all(b": ")?;

+        format::CudaDisplay::write(&module, writer)?;

+        writer.write_all(b", ")?;

+        writer.write_all(stringify!(fatbinc_wrapper).as_bytes())?;

+        write!(writer, ": {:p})", fatbinc_wrapper)

+    });

     let global_state = &mut *super::GLOBAL_STATE.lock().unwrap();

-    let mut fn_logger = global_state

-        .log_factory

-        .get_logger_dark_api(CUDART_INTERFACE_GUID, 1);

+    let mut fn_logger = global_state.log_factory.get_logger_dark_api(

+        CUDART_INTERFACE_GUID,

+        1,

+        Some(arguments_writer),

+    );

     let global_state = &mut *super::GLOBAL_STATE.lock().unwrap();

     let delayed_state = global_state.delayed_state.unwrap_mut();

     record_submodules_from_wrapped_fatbin(

@@ -375,10 +395,27 @@ unsafe extern "system" fn get_module_from_cubin_ext1(
     ptr2: *mut c_void,

     _unknown: usize,

 ) -> CUresult {

+    let arguments_writer = Box::new(move |writer: &mut dyn std::io::Write| {

+        writer.write_all(b"(")?;

+        writer.write_all(stringify!(module).as_bytes())?;

+        writer.write_all(b": ")?;

+        format::CudaDisplay::write(&module, writer)?;

+        writer.write_all(b", ")?;

+        writer.write_all(stringify!(fatbinc_wrapper).as_bytes())?;

+        write!(writer, ": {:p}, ", fatbinc_wrapper)?;

+        writer.write_all(stringify!(ptr1).as_bytes())?;

+        write!(writer, ": {:p}, ", ptr1)?;

+        writer.write_all(stringify!(ptr2).as_bytes())?;

+        write!(writer, ": {:p}, ", ptr2)?;

+        writer.write_all(stringify!(_unknown).as_bytes())?;

+        write!(writer, ": {})", _unknown)

+    });

     let global_state = &mut *super::GLOBAL_STATE.lock().unwrap();

-    let mut fn_logger = global_state

-        .log_factory

-        .get_logger_dark_api(CUDART_INTERFACE_GUID, 6);

+    let mut fn_logger = global_state.log_factory.get_logger_dark_api(

+        CUDART_INTERFACE_GUID,

+        6,

+        Some(arguments_writer),

+    );

     if ptr1 != ptr::null_mut() {

         fn_logger.log(log::LogEntry::UnexpectedArgument {

             arg_name: stringify!(ptr1),

@@ -421,10 +458,27 @@ unsafe extern "system" fn get_module_from_cubin_ext2(
     ptr2: *mut c_void,

     _unknown: usize,

 ) -> CUresult {

+    let arguments_writer = Box::new(move |writer: &mut dyn std::io::Write| {

+        writer.write_all(b"(")?;

+        writer.write_all(stringify!(fatbin_header).as_bytes())?;

+        write!(writer, ": {:p}, ", fatbin_header)?;

+        writer.write_all(stringify!(module).as_bytes())?;

+        writer.write_all(b": ")?;

+        format::CudaDisplay::write(&module, writer)?;

+        writer.write_all(b", ")?;

+        writer.write_all(stringify!(ptr1).as_bytes())?;

+        write!(writer, ": {:p}, ", ptr1)?;

+        writer.write_all(stringify!(ptr2).as_bytes())?;

+        write!(writer, ": {:p}, ", ptr2)?;

+        writer.write_all(stringify!(_unknown).as_bytes())?;

+        write!(writer, ": {})", _unknown)

+    });

     let global_state = &mut *super::GLOBAL_STATE.lock().unwrap();

-    let mut fn_logger = global_state

-        .log_factory

-        .get_logger_dark_api(CUDART_INTERFACE_GUID, 8);

+    let mut fn_logger = global_state.log_factory.get_logger_dark_api(

+        CUDART_INTERFACE_GUID,

+        8,

+        Some(arguments_writer),

+    );

     if ptr1 != ptr::null_mut() {

         fn_logger.log(log::LogEntry::UnexpectedArgument {

             arg_name: stringify!(ptr1),

diff --git a/zluda_dump/src/format.rs b/zluda_dump/src/format.rs
index bee8d4c..5577b30 100644
--- a/zluda_dump/src/format.rs
+++ b/zluda_dump/src/format.rs
@@ -1,953 +1,577 @@
-use paste::paste;

+extern crate cuda_types;

 use std::{

     ffi::{c_void, CStr},

-    io::Write,

-    mem, ptr,

+    fmt::LowerHex,

+    mem, ptr, slice,

 };

 

-use crate::cuda::*;

+use cuda_base::cuda_derive_display_trait;

 

-pub(crate) trait FormatCudaObject {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write);

+pub(crate) trait CudaDisplay {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()>;

 }

 

-fn write_post_execution_ptr<T: FormatCudaObject + Copy>(

-    t: *const T,

-    result: CUresult,

-    f: &mut impl Write,

-) {

-    if t == ptr::null() {

-        write!(f, "NULL").ok();

-    } else if result != CUresult::CUDA_SUCCESS {

-        write!(f, "NONE").ok();

-    } else {

-        unsafe { *t }.write_post_execution(result, f)

-    }

-}

-

-impl<T: FormatCudaObject + Copy> FormatCudaObject for *mut T {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write_post_execution_ptr(self, result, f)

-    }

-}

-

-impl<T: FormatCudaObject + Copy> FormatCudaObject for *const T {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write_post_execution_ptr(self, result, f)

+impl CudaDisplay for cuda_types::CUuuid {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        let guid = self.bytes;

+        write!(writer, "{{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15])

     }

 }

 

-impl FormatCudaObject for CUmodule {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUdevice {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", self.0)

     }

 }

 

-impl FormatCudaObject for CUfunction {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUdeviceptr {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", self.0)

     }

 }

 

-impl FormatCudaObject for *mut c_void {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUdeviceptr_v1 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", self.0 as usize as *const ())

     }

 }

 

-impl FormatCudaObject for *const c_void {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for u8 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUstream {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for u16 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUgraphicsResource {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for i32 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUdeviceptr {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self.0 as *const ()).ok();

+impl CudaDisplay for u32 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUtexref {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self as *const ()).ok();

+impl CudaDisplay for u64 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUmipmappedArray {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for usize {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUarray {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for f32 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUcontext {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+pub fn write_handle<T: LowerHex>(

+    this: &[T; 64],

+    writer: &mut (impl std::io::Write + ?Sized),

+) -> std::io::Result<()> {

+    writer.write_all(b"0x")?;

+    for i in (0..64).rev() {

+        write!(writer, "{:02x}", this[i])?;

     }

+    Ok(())

 }

 

-impl FormatCudaObject for CUsurfref {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUipcMemHandle {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write_handle(&self.reserved, writer)

     }

 }

 

-impl FormatCudaObject for CUgraphNode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUipcEventHandle {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write_handle(&self.reserved, writer)

     }

 }

 

-impl FormatCudaObject for CUgraphExec {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUmemPoolPtrExportData_v1 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write_handle(&self.reserved, writer)

     }

 }

 

-impl FormatCudaObject for CUevent {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *mut c_void {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", *self)

     }

 }

 

-impl FormatCudaObject for CUgraph {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *const c_void {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", *self)

     }

 }

 

-impl FormatCudaObject for CUexternalSemaphore {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *const i8 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(

+            writer,

+            "\"{}\"",

+            unsafe { CStr::from_ptr(*self as _) }.to_string_lossy()

+        )

     }

 }

 

-impl FormatCudaObject for CUexternalMemory {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *mut i8 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(

+            writer,

+            "\"{}\"",

+            unsafe { CStr::from_ptr(*self as _) }.to_string_lossy()

+        )

     }

 }

 

-impl FormatCudaObject for CUhostFn {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match self.map(|x| unsafe { mem::transmute::<_, *const ()>(x) }) {

-            Some(x) => write!(f, "{:p}", x),

-            None => write!(f, "NULL"),

+impl CudaDisplay for cuda_types::CUstreamBatchMemOpParams {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        unsafe {

+            match self.operation {

+                // The below is not a typo, `WAIT_VALUE` and `WRITE_VALUE` are

+                // distinct operations with nominally distinct union variants, but

+                // in reality they are structurally different, so we take a little

+                // shortcut here

+                cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_32

+                | cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_32 => {

+                    write_wait_value(&self.waitValue, writer, false)

+                }

+                cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_64

+                | cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_64 => {

+                    write_wait_value(&self.waitValue, writer, true)

+                }

+                cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES => {

+                    CudaDisplay::write(&self.flushRemoteWrites, writer)

+                }

+                _ => {

+                    writer.write_all(b"{ operation: ")?;

+                    CudaDisplay::write(&self.operation, writer)?;

+                    writer.write_all(b", ... }")

+                }

+            }

         }

-        .ok();

     }

 }

 

-impl FormatCudaObject for CUoccupancyB2DSize {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match self.map(|x| unsafe { mem::transmute::<_, *const ()>(x) }) {

-            Some(x) => write!(f, "{:p}", x),

-            None => write!(f, "NULL"),

-        }

-        .ok();

+pub fn write_wait_value(

+    this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,

+    writer: &mut (impl std::io::Write + ?Sized),

+    is_64_bit: bool,

+) -> std::io::Result<()> {

+    writer.write_all(b"{ operation: ")?;

+    CudaDisplay::write(&this.operation, writer)?;

+    writer.write_all(b", address: ")?;

+    CudaDisplay::write(&this.address, writer)?;

+    write_wait_value_32_or_64(&this.__bindgen_anon_1, writer, is_64_bit)?;

+    writer.write_all(b", flags: ")?;

+    CudaDisplay::write(&this.flags, writer)?;

+    writer.write_all(b", alias: ")?;

+    CudaDisplay::write(&this.alias, writer)?;

+    writer.write_all(b" }")

+}

+

+pub fn write_wait_value_32_or_64(

+    this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,

+    writer: &mut (impl std::io::Write + ?Sized),

+    is_64_bit: bool,

+) -> std::io::Result<()> {

+    if is_64_bit {

+        writer.write_all(b", value64: ")?;

+        CudaDisplay::write(unsafe { &this.value64 }, writer)

+    } else {

+        writer.write_all(b", value: ")?;

+        CudaDisplay::write(unsafe { &this.value }, writer)

     }

 }

 

-impl FormatCudaObject for CUDA_RESOURCE_DESC {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

+impl CudaDisplay for cuda_types::CUDA_RESOURCE_DESC_st {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ resType: ")?;

+        CudaDisplay::write(&self.resType, writer)?;

         match self.resType {

-            CU_RESOURCE_TYPE_ARRAY => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_ARRAY, hArray: {:p}, flags: {}}}",

-                    self.res.array.hArray, self.flags

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_ARRAY => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.array }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

-            CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_MIPMAPPED_ARRAY, hMipmappedArray: {:p}, flags: {}}}",

-                    self.res.mipmap.hMipmappedArray, self.flags

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.mipmap }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

-            CU_RESOURCE_TYPE_LINEAR => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_LINEAR, devPtr: {:p}, format:",

-                    self.res.linear.devPtr.0 as *const ()

-                ).ok();

-                self.res.linear.format.write_post_execution(result, f);

-                write!(

-                    f,

-                    ", numChannels: {}, sizeInBytes: {}}}",

-                    self.res.linear.numChannels, self.res.linear.sizeInBytes,

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_LINEAR => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.linear }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

-            CU_RESOURCE_TYPE_PITCH2D => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_PITCH2D, devPtr: {:p}, format:",

-                    self.res.pitch2D.devPtr.0 as *const ()

-                ).ok();

-                self.res.pitch2D.format.write_post_execution(result, f);

-                write!(

-                    f,

-                    ", numChannels: {}, width: {}, height: {}, pitchInBytes: {}}}",

-                    self.res.pitch2D.numChannels, self.res.pitch2D.width, self.res.pitch2D.height, self.res.pitch2D.pitchInBytes

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_PITCH2D => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.pitch2D }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

             _ => {

-                write!(f, "{{resType: {}, flags: {}}}", self.resType.0, self.flags)

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b", ... }")

             }

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_RESOURCE_VIEW_DESC {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{{format: ").ok();

-        self.format.write_post_execution(result, f);

-        write!(

-            f,

-            ", width: {}, height: {}, depth: {}, firstMipmapLevel: {}, lastMipmapLevel: {}, firstLayer: {}, lastLayer: {}}}",

-            self.width,

-            self.height,

-            self.depth,

-            self.firstMipmapLevel,

-            self.lastMipmapLevel,

-            self.firstLayer,

-            self.lastLayer

-        ).ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_TEXTURE_DESC {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{{addressMode: [").ok();

-        let [addressMode_0, addressMode_1, addressMode_2] = self.addressMode;

-        addressMode_0.write_post_execution(result, f);

-        write!(f, ", ").ok();

-        addressMode_1.write_post_execution(result, f);

-        write!(f, ", ").ok();

-        addressMode_2.write_post_execution(result, f);

-        write!(

-            f,

-            "], flags: {}, maxAnisotropy: {}, mipmapFilterMode: ",

-            self.flags, self.maxAnisotropy

-        );

-        self.mipmapFilterMode.write_post_execution(result, f);

-        write!(

-            f,

-            ", mipmapLevelBias: {}, minMipmapLevelClamp: {}, maxMipmapLevelClamp: {}, borderColor: [{}, {}, {}, {}]}}",

-            self.mipmapLevelBias,

-            self.minMipmapLevelClamp,

-            self.maxMipmapLevelClamp,

-            self.borderColor[0],

-            self.borderColor[1],

-            self.borderColor[2],

-            self.borderColor[3]

-        ).ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_ARRAY_DESCRIPTOR {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(

-            f,

-            "{{Width: {}, Height: {}, Format: ",

-            self.Width, self.Height

-        )

-        .ok();

-        self.Format.write_post_execution(result, f);

-        write!(f, ",  NumChannels: {}}}", self.NumChannels).ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_MEMCPY3D {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(

-            f,

-            "{{srcXInBytes: {}, srcY: {}, srcZ: {}, srcLOD: {}, srcMemoryType: ",

-            self.srcXInBytes, self.srcY, self.srcZ, self.srcLOD,

-        )

-        .ok();

-        self.srcMemoryType.write_post_execution(result, f);

-        write!(

-            f,

-            ", srcHost: {:p}, srcDevice: {:p}, srcArray: {:p}, srcPitch: {}, srcHeight: {}, dstXInBytes: {}, dstY: {}, dstZ: {}, dstLOD: {}, dstMemoryType: ",

-            self.srcHost,

-            self.srcDevice.0 as *const (),

-            self.srcArray,

-            self.srcPitch,

-            self.srcHeight,

-            self.dstXInBytes,

-            self.dstY,

-            self.dstZ,

-            self.dstLOD,

-        ).ok();

-        self.dstMemoryType.write_post_execution(result, f);

-        write!(

-            f,

-            ", dstHost: {:p}, dstDevice: {:p}, dstArray: {:p}, dstPitch: {}, dstHeight: {}, WidthInBytes: {}, Height: {}, Depth: {}}}",

-            self.dstHost,

-            self.dstDevice.0 as *const (),

-            self.dstArray,

-            self.dstPitch,

-            self.dstHeight,

-            self.WidthInBytes,

-            self.Height,

-            self.Depth,

-        ).ok();

-    }

-}

-

-impl FormatCudaObject for CUmemLocation {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{{type: ").ok();

-        self.type_.write_post_execution(result, f);

-        write!(f, ", id: {}}}", self.id).ok();

-    }

-}

-

-impl FormatCudaObject for *const i8 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(

-            f,

-            "\"{}\"",

-            unsafe { CStr::from_ptr(self) }.to_str().unwrap()

-        )

-        .ok();

-    }

-}

-

-impl FormatCudaObject for u32 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-impl FormatCudaObject for u64 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-impl FormatCudaObject for i32 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

     }

 }

 

-impl FormatCudaObject for f32 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-impl FormatCudaObject for CUdevice {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self.0).ok();

-    }

-}

-

-impl FormatCudaObject for usize {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-// TODO: support it properly

-impl FormatCudaObject for CUoutput_mode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self.0).ok();

-    }

-}

-

-impl FormatCudaObject for CUuuid {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        let guid = self.bytes;

-        write!(f, "{{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]).ok();

-    }

-}

-

-// ENUMS

-

-/*

-impl FormatCudaObject for CUjit_option {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cujit_option(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl CudaDisplay for cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ type: ")?;

+        CudaDisplay::write(&self.type_, writer)?;

+        match self.type_ {

+            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.fd }, writer)?;

+            }

+            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32

+            | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP

+            | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE

+            |cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE => {

+                write_win32_handle(unsafe { self.handle.win32 }, writer)?;

+            }

+            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT

+            | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.win32.handle }, writer)?;

+            }

+            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.nvSciBufObject }, writer)?;

+            }

+            _ => {

+                writer.write_all(b", size: ")?;

+                CudaDisplay::write(&self.size, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                return writer.write_all(b", ... }")

+            }

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUdevice_attribute {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cudevice_attribute(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+        writer.write_all(b", size: ")?;

+        CudaDisplay::write(&self.size, writer)?;

+        writer.write_all(b", flags: ")?;

+        CudaDisplay::write(&self.flags, writer)?;

+        writer.write_all(b" }")

+    }

+}

+

+pub fn write_win32_handle(

+    win32: cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,

+    writer: &mut (impl std::io::Write + ?Sized),

+) -> std::io::Result<()> {

+    if win32.handle != ptr::null_mut() {

+        writer.write_all(b", handle: ")?;

+        CudaDisplay::write(&win32.handle, writer)?;

+    }

+    if win32.name != ptr::null_mut() {

+        let name_ptr = win32.name as *const u16;

+        let mut strlen = 0usize;

+        while unsafe { *name_ptr.add(strlen) } != 0 {

+            strlen += 1;

         }

-        .ok();

+        let text = String::from_utf16_lossy(unsafe { slice::from_raw_parts(name_ptr, strlen) });

+        write!(writer, ", name: \"{}\"", text)?;

     }

+    Ok(())

 }

 

-impl FormatCudaObject for CUdevice_P2PAttribute {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cudevice_p2pattribute(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl CudaDisplay for cuda_types::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ type: ")?;

+        CudaDisplay::write(&self.type_, writer)?;

+        match self.type_ {

+            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.fd }, writer)?;

+            }

+            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32

+            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE

+            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE

+            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX

+            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT => {

+                write_win32_handle(unsafe { mem::transmute(self.handle.win32) }, writer)?;

+            }

+            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.win32.handle }, writer)?;

+            }

+            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.nvSciSyncObj }, writer)?;

+            }

+            _ => {

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                return writer.write_all(b", ... }")

+            }

         }

-        .ok();

+        writer.write_all(b", flags: ")?;

+        CudaDisplay::write(&self.flags, writer)?;

+        writer.write_all(b" }")

     }

 }

 

-impl FormatCudaObject for CUarray_format {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cuarray_format(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

-        }

-        .ok();

+impl CudaDisplay

+    for cuda_types::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2

+{

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ fence: ")?;

+        CudaDisplay::write(&unsafe { self.fence }, writer)?;

+        writer.write_all(b" }")

     }

 }

 

-impl FormatCudaObject for CUresourceViewFormat {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_curesourceview_format(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

-        }

-        .ok();

+impl CudaDisplay

+    for cuda_types::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2

+{

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ fence: ")?;

+        CudaDisplay::write(&unsafe { self.fence }, writer)?;

+        writer.write_all(b" }")

     }

 }

 

-impl FormatCudaObject for CUaddress_mode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cuaddress_mode(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl<T: CudaDisplay> CudaDisplay for *mut T {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        if *self == ptr::null_mut() {

+            writer.write_all(b"NULL")

+        } else {

+            let this: &T = unsafe { &**self };

+            this.write(writer)

         }

-        .ok();

     }

 }

 

-impl FormatCudaObject for CUfilter_mode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cufilter_mode(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl<T: CudaDisplay> CudaDisplay for *const T {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        if *self == ptr::null() {

+            writer.write_all(b"NULL")

+        } else {

+            let this: &T = unsafe { &**self };

+            this.write(writer)

         }

-        .ok();

     }

 }

 

-impl FormatCudaObject for CUgraphExecUpdateResult {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cugraph_exec_updateresult(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl<T: CudaDisplay, const N: usize> CudaDisplay for [T; N] {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"[")?;

+        for i in 0..N {

+            CudaDisplay::write(self, writer)?;

+            if i != N - 1 {

+                writer.write_all(b", ")?;

+            }

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUmemorytype {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cumemorytype(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+        writer.write_all(b"]")

+    }

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuStreamBatchMemOp(

+    writer: &mut (impl std::io::Write + ?Sized),

+    stream: cuda_types::CUstream,

+    count: ::std::os::raw::c_uint,

+    paramArray: *mut cuda_types::CUstreamBatchMemOpParams,

+    flags: ::std::os::raw::c_uint,

+) -> std::io::Result<()> {

+    writer.write_all(b"(stream: ")?;

+    CudaDisplay::write(&stream, writer)?;

+    writer.write_all(b", ")?;

+    writer.write_all(b"count: ")?;

+    CudaDisplay::write(&count, writer)?;

+    writer.write_all(b", paramArray: [")?;

+    for i in 0..count {

+        if i != 0 {

+            writer.write_all(b", ")?;

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUmemLocationType {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cumemorytype(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+        CudaDisplay::write(&unsafe { paramArray.add(i as usize) }, writer)?;

+    }

+    writer.write_all(b"], flags: ")?;

+    CudaDisplay::write(&flags, writer)?;

+    writer.write_all(b") ")

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuGraphKernelNodeGetAttribute(

+    writer: &mut (impl std::io::Write + ?Sized),

+    hNode: cuda_types::CUgraphNode,

+    attr: cuda_types::CUkernelNodeAttrID,

+    value_out: *mut cuda_types::CUkernelNodeAttrValue,

+) -> std::io::Result<()> {

+    writer.write_all(b"(hNode: ")?;

+    CudaDisplay::write(&hNode, writer)?;

+    writer.write_all(b", attr: ")?;

+    CudaDisplay::write(&attr, writer)?;

+    match attr {

+        cuda_types::CUkernelNodeAttrID::CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).accessPolicyWindow }, writer)?;

         }

-        .ok();

-    }

-}

-*/

-

-macro_rules! stringify_enum {

-    ($type_:ident, [ $($variant:ident),+ ]) => {

-        paste! {

-            pub(crate) fn [<stringify_ $type_>](x: $type_) -> Option<&'static str> {

-                match x {

-                    $(

-                        $type_::$variant => Some(stringify!($variant)),

-                    )+

-                    _ => None

-                }

-            }

-

-            impl FormatCudaObject for $type_ {

-                fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-                    match [<stringify_ $type_>](self) {

-                        Some(text) => write!(f, "{}", text),

-                        None => write!(f, "{}", self.0),

-                    }

-                    .ok();

-                }

-            }

+        cuda_types::CUkernelNodeAttrID::CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).cooperative }, writer)?;

         }

-    }

-}

-

-stringify_enum! {

-    CUdevice_attribute_enum,

-    [

-        CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z,

-        CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X,

-        CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y,

-        CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z,

-        CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY,

-        CU_DEVICE_ATTRIBUTE_WARP_SIZE,

-        CU_DEVICE_ATTRIBUTE_MAX_PITCH,

-        CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_CLOCK_RATE,

-        CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT,

-        CU_DEVICE_ATTRIBUTE_GPU_OVERLAP,

-        CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT,

-        CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT,

-        CU_DEVICE_ATTRIBUTE_INTEGRATED,

-        CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_MODE,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES,

-        CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT,

-        CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS,

-        CU_DEVICE_ATTRIBUTE_ECC_ENABLED,

-        CU_DEVICE_ATTRIBUTE_PCI_BUS_ID,

-        CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID,

-        CU_DEVICE_ATTRIBUTE_TCC_DRIVER,

-        CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE,

-        CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH,

-        CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE,

-        CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT,

-        CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE,

-        CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID,

-        CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY,

-        CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD,

-        CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID,

-        CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO,

-        CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS,

-        CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR,

-        CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH,

-        CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH,

-        CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN,

-        CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES,

-        CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES,

-        CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST,

-        CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE,

-        CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE,

-        CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED

-    ]

-}

-

-stringify_enum! {

-    CUjit_option,

-    [

-        CU_JIT_MAX_REGISTERS,

-        CU_JIT_THREADS_PER_BLOCK,

-        CU_JIT_WALL_TIME,

-        CU_JIT_INFO_LOG_BUFFER,

-        CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,

-        CU_JIT_ERROR_LOG_BUFFER,

-        CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,

-        CU_JIT_OPTIMIZATION_LEVEL,

-        CU_JIT_TARGET_FROM_CUCONTEXT,

-        CU_JIT_TARGET,

-        CU_JIT_FALLBACK_STRATEGY,

-        CU_JIT_GENERATE_DEBUG_INFO,

-        CU_JIT_LOG_VERBOSE,

-        CU_JIT_GENERATE_LINE_INFO,

-        CU_JIT_CACHE_MODE,

-        CU_JIT_NEW_SM3X_OPT,

-        CU_JIT_FAST_COMPILE,

-        CU_JIT_GLOBAL_SYMBOL_NAMES,

-        CU_JIT_GLOBAL_SYMBOL_ADDRESSES,

-        CU_JIT_GLOBAL_SYMBOL_COUNT,

-        CU_JIT_NUM_OPTIONS

-    ]

-}

-

-stringify_enum! {

-    CUresult,

-    [

-        CUDA_SUCCESS,

-        CUDA_ERROR_INVALID_VALUE,

-        CUDA_ERROR_OUT_OF_MEMORY,

-        CUDA_ERROR_NOT_INITIALIZED,

-        CUDA_ERROR_DEINITIALIZED,

-        CUDA_ERROR_PROFILER_DISABLED,

-        CUDA_ERROR_PROFILER_NOT_INITIALIZED,

-        CUDA_ERROR_PROFILER_ALREADY_STARTED,

-        CUDA_ERROR_PROFILER_ALREADY_STOPPED,

-        CUDA_ERROR_NO_DEVICE,

-        CUDA_ERROR_INVALID_DEVICE,

-        CUDA_ERROR_INVALID_IMAGE,

-        CUDA_ERROR_INVALID_CONTEXT,

-        CUDA_ERROR_CONTEXT_ALREADY_CURRENT,

-        CUDA_ERROR_MAP_FAILED,

-        CUDA_ERROR_UNMAP_FAILED,

-        CUDA_ERROR_ARRAY_IS_MAPPED,

-        CUDA_ERROR_ALREADY_MAPPED,

-        CUDA_ERROR_NO_BINARY_FOR_GPU,

-        CUDA_ERROR_ALREADY_ACQUIRED,

-        CUDA_ERROR_NOT_MAPPED,

-        CUDA_ERROR_NOT_MAPPED_AS_ARRAY,

-        CUDA_ERROR_NOT_MAPPED_AS_POINTER,

-        CUDA_ERROR_ECC_UNCORRECTABLE,

-        CUDA_ERROR_UNSUPPORTED_LIMIT,

-        CUDA_ERROR_CONTEXT_ALREADY_IN_USE,

-        CUDA_ERROR_PEER_ACCESS_UNSUPPORTED,

-        CUDA_ERROR_INVALID_PTX,

-        CUDA_ERROR_INVALID_GRAPHICS_CONTEXT,

-        CUDA_ERROR_NVLINK_UNCORRECTABLE,

-        CUDA_ERROR_JIT_COMPILER_NOT_FOUND,

-        CUDA_ERROR_INVALID_SOURCE,

-        CUDA_ERROR_FILE_NOT_FOUND,

-        CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND,

-        CUDA_ERROR_SHARED_OBJECT_INIT_FAILED,

-        CUDA_ERROR_OPERATING_SYSTEM,

-        CUDA_ERROR_INVALID_HANDLE,

-        CUDA_ERROR_ILLEGAL_STATE,

-        CUDA_ERROR_NOT_FOUND,

-        CUDA_ERROR_NOT_READY,

-        CUDA_ERROR_ILLEGAL_ADDRESS,

-        CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES,

-        CUDA_ERROR_LAUNCH_TIMEOUT,

-        CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING,

-        CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED,

-        CUDA_ERROR_PEER_ACCESS_NOT_ENABLED,

-        CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE,

-        CUDA_ERROR_CONTEXT_IS_DESTROYED,

-        CUDA_ERROR_ASSERT,

-        CUDA_ERROR_TOO_MANY_PEERS,

-        CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED,

-        CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED,

-        CUDA_ERROR_HARDWARE_STACK_ERROR,

-        CUDA_ERROR_ILLEGAL_INSTRUCTION,

-        CUDA_ERROR_MISALIGNED_ADDRESS,

-        CUDA_ERROR_INVALID_ADDRESS_SPACE,

-        CUDA_ERROR_INVALID_PC,

-        CUDA_ERROR_LAUNCH_FAILED,

-        CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE,

-        CUDA_ERROR_NOT_PERMITTED,

-        CUDA_ERROR_NOT_SUPPORTED,

-        CUDA_ERROR_SYSTEM_NOT_READY,

-        CUDA_ERROR_SYSTEM_DRIVER_MISMATCH,

-        CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE,

-        CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED,

-        CUDA_ERROR_STREAM_CAPTURE_INVALIDATED,

-        CUDA_ERROR_STREAM_CAPTURE_MERGE,

-        CUDA_ERROR_STREAM_CAPTURE_UNMATCHED,

-        CUDA_ERROR_STREAM_CAPTURE_UNJOINED,

-        CUDA_ERROR_STREAM_CAPTURE_ISOLATION,

-        CUDA_ERROR_STREAM_CAPTURE_IMPLICIT,

-        CUDA_ERROR_CAPTURED_EVENT,

-        CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD,

-        CUDA_ERROR_TIMEOUT,

-        CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE,

-        CUDA_ERROR_UNKNOWN

-    ]

-}

-

-stringify_enum! {

-    CUdevice_P2PAttribute,

-    [

-        CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK,

-        CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED,

-        CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED,

-        CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED,

-        CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED

-    ]

-}

-

-stringify_enum! {

-    CUarray_format,

-    [

-        CU_AD_FORMAT_UNSIGNED_INT8,

-        CU_AD_FORMAT_UNSIGNED_INT16,

-        CU_AD_FORMAT_UNSIGNED_INT32,

-        CU_AD_FORMAT_SIGNED_INT8,

-        CU_AD_FORMAT_SIGNED_INT16,

-        CU_AD_FORMAT_SIGNED_INT32,

-        CU_AD_FORMAT_HALF,

-        CU_AD_FORMAT_FLOAT

-    ]

-}

-

-stringify_enum! {

-    CUresourceViewFormat,

-    [

-        CU_RES_VIEW_FORMAT_NONE,

-        CU_RES_VIEW_FORMAT_UINT_1X8,

-        CU_RES_VIEW_FORMAT_UINT_2X8,

-        CU_RES_VIEW_FORMAT_UINT_4X8,

-        CU_RES_VIEW_FORMAT_SINT_1X8,

-        CU_RES_VIEW_FORMAT_SINT_2X8,

-        CU_RES_VIEW_FORMAT_SINT_4X8,

-        CU_RES_VIEW_FORMAT_UINT_1X16,

-        CU_RES_VIEW_FORMAT_UINT_2X16,

-        CU_RES_VIEW_FORMAT_UINT_4X16,

-        CU_RES_VIEW_FORMAT_SINT_1X16,

-        CU_RES_VIEW_FORMAT_SINT_2X16,

-        CU_RES_VIEW_FORMAT_SINT_4X16,

-        CU_RES_VIEW_FORMAT_UINT_1X32,

-        CU_RES_VIEW_FORMAT_UINT_2X32,

-        CU_RES_VIEW_FORMAT_UINT_4X32,

-        CU_RES_VIEW_FORMAT_SINT_1X32,

-        CU_RES_VIEW_FORMAT_SINT_2X32,

-        CU_RES_VIEW_FORMAT_SINT_4X32,

-        CU_RES_VIEW_FORMAT_FLOAT_1X16,

-        CU_RES_VIEW_FORMAT_FLOAT_2X16,

-        CU_RES_VIEW_FORMAT_FLOAT_4X16,

-        CU_RES_VIEW_FORMAT_FLOAT_1X32,

-        CU_RES_VIEW_FORMAT_FLOAT_2X32,

-        CU_RES_VIEW_FORMAT_FLOAT_4X32,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC1,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC2,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC3,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC4,

-        CU_RES_VIEW_FORMAT_SIGNED_BC4,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC5,

-        CU_RES_VIEW_FORMAT_SIGNED_BC5,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC6H,

-        CU_RES_VIEW_FORMAT_SIGNED_BC6H,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC7

-    ]

-}

-

-stringify_enum! {

-    CUaddress_mode,

-    [

-        CU_TR_ADDRESS_MODE_WRAP,

-        CU_TR_ADDRESS_MODE_CLAMP,

-        CU_TR_ADDRESS_MODE_MIRROR,

-        CU_TR_ADDRESS_MODE_BORDER

-    ]

-}

-

-stringify_enum! {

-    CUfilter_mode,

-    [

-        CU_TR_FILTER_MODE_POINT,

-        CU_TR_FILTER_MODE_LINEAR

-    ]

-}

-

-stringify_enum! {

-    CUgraphExecUpdateResult,

-    [

-        CU_GRAPH_EXEC_UPDATE_SUCCESS,

-        CU_GRAPH_EXEC_UPDATE_ERROR,

-        CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED

-    ]

-}

-

-stringify_enum! {

-    CUmemorytype,

-    [

-        CU_MEMORYTYPE_HOST,

-        CU_MEMORYTYPE_DEVICE,

-        CU_MEMORYTYPE_ARRAY,

-        CU_MEMORYTYPE_UNIFIED

-    ]

-}

-

-stringify_enum! {

-    CUmemLocationType,

-    [

-        CU_MEM_LOCATION_TYPE_INVALID,

-        CU_MEM_LOCATION_TYPE_DEVICE

-    ]

-}

-

-stringify_enum! {

-    CUlimit,

-    [

-        CU_LIMIT_STACK_SIZE,

-        CU_LIMIT_PRINTF_FIFO_SIZE,

-        CU_LIMIT_MALLOC_HEAP_SIZE,

-        CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH,

-        CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT,

-        CU_LIMIT_MAX_L2_FETCH_GRANULARITY,

-        CU_LIMIT_PERSISTING_L2_CACHE_SIZE

-    ]

-}

-

-stringify_enum! {

-    CUpointer_attribute,

-    [

-        CU_POINTER_ATTRIBUTE_CONTEXT,

-        CU_POINTER_ATTRIBUTE_MEMORY_TYPE,

-        CU_POINTER_ATTRIBUTE_DEVICE_POINTER,

-        CU_POINTER_ATTRIBUTE_HOST_POINTER,

-        CU_POINTER_ATTRIBUTE_P2P_TOKENS,

-        CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,

-        CU_POINTER_ATTRIBUTE_BUFFER_ID,

-        CU_POINTER_ATTRIBUTE_IS_MANAGED,

-        CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,

-        CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,

-        CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,

-        CU_POINTER_ATTRIBUTE_RANGE_SIZE,

-        CU_POINTER_ATTRIBUTE_MAPPED,

-        CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,

-        CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,

-        CU_POINTER_ATTRIBUTE_ACCESS_FLAGS

-    ]

-}

-

-stringify_enum! {

-    CUfunction_attribute,

-    [

-        CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK,

-        CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_NUM_REGS,

-        CU_FUNC_ATTRIBUTE_PTX_VERSION,

-        CU_FUNC_ATTRIBUTE_BINARY_VERSION,

-        CU_FUNC_ATTRIBUTE_CACHE_MODE_CA,

-        CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT

-    ]

-}

-

-stringify_enum! {

-    CUmem_range_attribute,

-    [

-        CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,

-        CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,

-        CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,

-        CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION

-    ]

-}

-

-stringify_enum! {

-    CUfunc_cache,

-    [

-        CU_FUNC_CACHE_PREFER_NONE,

-        CU_FUNC_CACHE_PREFER_SHARED,

-        CU_FUNC_CACHE_PREFER_L1,

-        CU_FUNC_CACHE_PREFER_EQUAL

-    ]

-}

-

-stringify_enum! {

-    CUstreamCaptureMode,

+        _ => return writer.write_all(b", ...) "),

+    }

+    writer.write_all(b") ")

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuGraphKernelNodeSetAttribute(

+    writer: &mut (impl std::io::Write + ?Sized),

+    hNode: cuda_types::CUgraphNode,

+    attr: cuda_types::CUkernelNodeAttrID,

+    value_out: *const cuda_types::CUkernelNodeAttrValue,

+) -> std::io::Result<()> {

+    write_cuGraphKernelNodeGetAttribute(writer, hNode, attr, value_out as *mut _)

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuStreamGetAttribute(

+    writer: &mut (impl std::io::Write + ?Sized),

+    hStream: cuda_types::CUstream,

+    attr: cuda_types::CUstreamAttrID,

+    value_out: *mut cuda_types::CUstreamAttrValue,

+) -> std::io::Result<()> {

+    writer.write_all(b"(hStream: ")?;

+    CudaDisplay::write(&hStream, writer)?;

+    writer.write_all(b", attr: ")?;

+    CudaDisplay::write(&attr, writer)?;

+    match attr {

+        cuda_types::CUstreamAttrID::CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).accessPolicyWindow }, writer)?;

+        }

+        cuda_types::CUstreamAttrID::CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).syncPolicy }, writer)?;

+        }

+        _ => return writer.write_all(b", ...) "),

+    }

+    writer.write_all(b") ")

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuStreamGetAttribute_ptsz(

+    writer: &mut (impl std::io::Write + ?Sized),

+    hStream: cuda_types::CUstream,

+    attr: cuda_types::CUstreamAttrID,

+    value_out: *mut cuda_types::CUstreamAttrValue,

+) -> std::io::Result<()> {

+    write_cuStreamGetAttribute(writer, hStream, attr, value_out)

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuStreamSetAttribute(

+    writer: &mut (impl std::io::Write + ?Sized),

+    hStream: cuda_types::CUstream,

+    attr: cuda_types::CUstreamAttrID,

+    value_out: *const cuda_types::CUstreamAttrValue,

+) -> std::io::Result<()> {

+    write_cuStreamGetAttribute(writer, hStream, attr, value_out as *mut _)

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuStreamSetAttribute_ptsz(

+    writer: &mut (impl std::io::Write + ?Sized),

+    hStream: cuda_types::CUstream,

+    attr: cuda_types::CUstreamAttrID,

+    value_out: *const cuda_types::CUstreamAttrValue,

+) -> std::io::Result<()> {

+    write_cuStreamSetAttribute(writer, hStream, attr, value_out)

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuCtxCreate_v3(

+    _writer: &mut (impl std::io::Write + ?Sized),

+    _pctx: *mut cuda_types::CUcontext,

+    _paramsArray: *mut cuda_types::CUexecAffinityParam,

+    _numParams: ::std::os::raw::c_int,

+    _flags: ::std::os::raw::c_uint,

+    _dev: cuda_types::CUdevice,

+) -> std::io::Result<()> {

+    todo!()

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuCtxGetExecAffinity(

+    _writer: &mut (impl std::io::Write + ?Sized),

+    _pExecAffinity: *mut cuda_types::CUexecAffinityParam,

+    _type_: cuda_types::CUexecAffinityType,

+) -> std::io::Result<()> {

+    todo!()

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuMemMapArrayAsync(

+    _writer: &mut (impl std::io::Write + ?Sized),

+    _mapInfoList: *mut cuda_types::CUarrayMapInfo,

+    _count: ::std::os::raw::c_uint,

+    _hStream: cuda_types::CUstream,

+) -> std::io::Result<()> {

+    todo!()

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuMemMapArrayAsync_ptsz(

+    writer: &mut (impl std::io::Write + ?Sized),

+    mapInfoList: *mut cuda_types::CUarrayMapInfo,

+    count: ::std::os::raw::c_uint,

+    hStream: cuda_types::CUstream,

+) -> std::io::Result<()> {

+    write_cuMemMapArrayAsync(writer, mapInfoList, count, hStream)

+}

+

+cuda_derive_display_trait!(

+    cuda_types,

+    CudaDisplay,

     [

-        CU_STREAM_CAPTURE_MODE_GLOBAL,

-        CU_STREAM_CAPTURE_MODE_THREAD_LOCAL,

-        CU_STREAM_CAPTURE_MODE_RELAXED

-    ]

-}

-

-stringify_enum! {

-    CUmem_advise,

+        CUarrayMapInfo_st,

+        CUDA_RESOURCE_DESC_st,

+        CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st,

+        CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st,

+        CUexecAffinityParam_st,

+        CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,

+        CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,

+        CUuuid_st

+    ],

     [

-        CU_MEM_ADVISE_SET_READ_MOSTLY,

-        CU_MEM_ADVISE_UNSET_READ_MOSTLY,

-        CU_MEM_ADVISE_SET_PREFERRED_LOCATION,

-        CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION,

-        CU_MEM_ADVISE_SET_ACCESSED_BY,

-        CU_MEM_ADVISE_UNSET_ACCESSED_BY

+        cuCtxCreate_v3,

+        cuCtxGetExecAffinity,

+        cuGraphKernelNodeGetAttribute,

+        cuGraphKernelNodeSetAttribute,

+        cuMemMapArrayAsync,

+        cuMemMapArrayAsync_ptsz,

+        cuStreamBatchMemOp,

+        cuStreamGetAttribute,

+        cuStreamGetAttribute_ptsz,

+        cuStreamSetAttribute,

+        cuStreamSetAttribute_ptsz

     ]

-}

+);

diff --git a/zluda_dump/src/lib.rs b/zluda_dump/src/lib.rs
index ecfd1ac..d79c391 100644
--- a/zluda_dump/src/lib.rs
+++ b/zluda_dump/src/lib.rs
@@ -1,107 +1,76 @@
+use cuda_types::{
+    CUdevice, CUdevice_attribute, CUfunction, CUjit_option, CUmodule, CUresult, CUuuid,
+};
+use paste::paste;
+use std::io;
 use std::{
-    collections::{hash_map, BTreeMap, HashMap},
-    env,
-    error::Error,
-    ffi::{c_void, CStr},
-    fs,
-    io::{self, prelude::*},
-    mem,
-    os::raw::{c_int, c_uint, c_ulong, c_ushort},
-    path::PathBuf,
-    ptr::NonNull,
-    rc::Rc,
-    slice,
+    collections::HashMap, env, error::Error, ffi::c_void, fs, path::PathBuf, ptr::NonNull, rc::Rc,
     sync::Mutex,
 };
-use std::{fs::File, ptr};
-
-use cuda::{
-    CUdevice, CUdevice_attribute, CUdeviceptr, CUfunction, CUjitInputType, CUjit_option,
-    CUlinkState, CUmodule, CUresult, CUstream, CUuuid,
-};
-use ptx::ast;
-use regex::Regex;
 
 #[macro_use]
 extern crate lazy_static;
 
-const CU_LAUNCH_PARAM_END: *mut c_void = 0 as *mut _;
-const CU_LAUNCH_PARAM_BUFFER_POINTER: *mut c_void = 1 as *mut _;
-const CU_LAUNCH_PARAM_BUFFER_SIZE: *mut c_void = 2 as *mut _;
-
 macro_rules! extern_redirect {
-    (pub fn $fn_name:ident ( $($arg_id:ident: $arg_type:ty),* $(,)? ) -> $ret_type:ty ;) => {
+    ($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:path) => {
         #[no_mangle]
-        pub extern "system" fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type {
+        pub extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type {
             let original_fn = |fn_ptr| {
                 let typed_fn = unsafe { std::mem::transmute::<_, extern "system" fn( $( $arg_id : $arg_type),* ) -> $ret_type>(fn_ptr) };
                 typed_fn($( $arg_id ),*)
             };
-            let get_formatted_args = |fn_logger: &mut crate::log::FunctionLogger, result: CUresult| {
-                let arg_count = (count_tts!($($arg_id),*) + 1) / 2;
-                fn_logger.begin_writing_arguments(arg_count);
-                $(
-                    fn_logger.write_single_argument(result, $arg_id);
-                )*
-                fn_logger.end_writing_arguments();
-            };
+            let get_formatted_args = Box::new(move |writer: &mut dyn std::io::Write| {
+                (paste! { format :: [<write_ $fn_name>] }) (
+                    writer
+                    $(,$arg_id)*
+                )
+            });
             crate::handle_cuda_function_call(stringify!($fn_name), original_fn, get_formatted_args)
         }
     };
 }
 
-macro_rules! count_tts {
-    () => {0usize};
-    ($_head:tt $($tail:tt)*) => {1usize + count_tts!($($tail)*)};
-}
-
 macro_rules! extern_redirect_with_post {
-    (
-        pub fn $fn_name:ident ( $($arg_id:ident: $arg_type:ty),* $(,)? ) -> $ret_type:ty ;
-        $post_fn:path ;
-    ) => {
+    ($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:path) => {
         #[no_mangle]
         pub extern "system" fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type {
             let original_fn = |fn_ptr| {
                 let typed_fn = unsafe { std::mem::transmute::<_, extern "system" fn( $( $arg_id : $arg_type),* ) -> $ret_type>(fn_ptr) };
                 typed_fn($( $arg_id ),*)
             };
-            let get_formatted_args = |fn_logger: &mut crate::log::FunctionLogger, result: CUresult| {
-                let arg_count = (count_tts!($($arg_id),*) + 1) / 2;
-                fn_logger.begin_writing_arguments(arg_count);
-                $(
-                    fn_logger.write_single_argument(result, $arg_id);
-                )*
-                fn_logger.end_writing_arguments();
-            };
+            let get_formatted_args = Box::new(move |writer: &mut dyn std::io::Write| {
+                (paste! { format :: [<write_ $fn_name>] }) (
+                    writer
+                    $(,$arg_id)*
+                )
+            });
             crate::handle_cuda_function_call_with_probes(
                 stringify!($fn_name),
                 || (), original_fn,
                 get_formatted_args,
-                move |logger, state, _, cuda_result| $post_fn ( $( $arg_id ),* , logger, state, cuda_result )
+                move |logger, state, _, cuda_result| paste! { [<$fn_name _Post>] } ( $( $arg_id ),* , logger, state, cuda_result )
             )
         }
     };
 }
 
-macro_rules! extern_redirect_with {
-    (
-        pub fn $fn_name:ident ( $($arg_id:ident: $arg_type:ty),* $(,)? ) -> $ret_type:ty ;
-        $receiver:path ;
-    ) => {
-        #[no_mangle]
-        pub extern "system" fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type {
-            let original_fn = |fn_ptr| {
-                let typed_fn = unsafe { std::mem::transmute::<_, extern "system" fn( $( $arg_id : $arg_type),* ) -> $ret_type>(fn_ptr) };
-                typed_fn($( $arg_id ),*)
-            };
-            crate::handle_cuda_function_call(stringify!($fn_name), original_fn)
-        }
-    };
-}
+use cuda_base::cuda_function_declarations;
+cuda_function_declarations!(
+    cuda_types,
+    extern_redirect,
+    extern_redirect_with_post,
+    [
+        cuModuleLoad,
+        cuModuleLoadData,
+        cuModuleLoadDataEx,
+        cuGetExportTable,
+        cuModuleGetFunction,
+        cuDeviceGetAttribute,
+        cuDeviceComputeCapability,
+        cuModuleLoadFatBinary
+    ]
+);
 
-#[allow(warnings)]
-mod cuda;
 mod dark_api;
 mod format;
 mod log;
@@ -110,20 +79,6 @@ mod log;
 mod os;
 mod trace;
 
-pub static mut LIBCUDA_HANDLE: *mut c_void = ptr::null_mut();
-pub static mut PENDING_LINKING: Option<HashMap<CUlinkState, Vec<ModuleDump>>> = None;
-pub static mut LINKED_CUBINS: Option<HashMap<*mut c_void, ModuleDump>> = None;
-pub static mut MODULES: Option<HashMap<CUmodule, ModuleDump>> = None;
-pub static mut MODULE_DUMP_COUNTER: usize = 0;
-pub static mut KERNELS: Option<HashMap<CUfunction, KernelDump>> = None;
-static mut BUFFERS: Option<BTreeMap<usize, (usize, AllocLocation)>> = None;
-pub static mut LAUNCH_COUNTER: usize = 0;
-pub static mut KERNEL_PATTERN: Option<Regex> = None;
-pub static mut OVERRIDE_COMPUTE_CAPABILITY_MAJOR: Option<i32> = None;
-pub static mut KERNEL_INDEX_MINIMUM: usize = 0;
-pub static mut KERNEL_INDEX_MAXIMUM: usize = usize::MAX;
-static mut LOG_FACTORY: Option<log::Factory> = None;
-
 lazy_static! {
     static ref GLOBAL_STATE: Mutex<GlobalState> = Mutex::new(GlobalState::new());
 }
@@ -179,9 +134,11 @@ struct GlobalDelayedState {
 impl GlobalDelayedState {
     fn new<'a>(
         func: &'static str,
+        arguments_writer: Box<dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>>,
         factory: &'a mut log::Factory,
     ) -> (LateInit<Self>, log::FunctionLogger<'a>) {
-        let (mut fn_logger, settings) = factory.get_first_logger_and_init_settings(func);
+        let (mut fn_logger, settings) =
+            factory.get_first_logger_and_init_settings(func, arguments_writer);
         let maybe_libcuda_handle = unsafe { os::load_cuda_library(&settings.libcuda_path) };
         let libcuda_handle = match NonNull::new(maybe_libcuda_handle) {
             Some(h) => h,
@@ -285,16 +242,22 @@ pub struct ModuleDump {
 fn handle_cuda_function_call(
     func: &'static str,
     original_cuda_fn: impl FnOnce(NonNull<c_void>) -> CUresult,
-    print_arguments_fn: impl FnOnce(&mut crate::log::FunctionLogger, CUresult),
+    arguments_writer: Box<dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>>,
 ) -> CUresult {
-    handle_cuda_function_call_with_probes(func, || (), original_cuda_fn, print_arguments_fn, |_| ())
+    handle_cuda_function_call_with_probes(
+        func,
+        || (),
+        original_cuda_fn,
+        arguments_writer,
+        |_, _, _, _| (),
+    )
 }
 
 fn handle_cuda_function_call_with_probes<T, PostFn>(
     func: &'static str,
     pre_probe: impl FnOnce() -> T,
     original_cuda_fn: impl FnOnce(NonNull<c_void>) -> CUresult,
-    print_arguments_fn: impl FnOnce(&mut crate::log::FunctionLogger, CUresult),
+    arguments_writer: Box<dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>>,
     post_probe: PostFn,
 ) -> CUresult
 where
@@ -307,14 +270,15 @@ where
     // extract any useful trace or logging anyway
     let mut global_state = &mut *global_state_mutex.lock().unwrap();
     let (mut logger, delayed_state) = match global_state.delayed_state {
-        LateInit::Success(ref mut delayed_state) => {
-            (global_state.log_factory.get_logger(func), delayed_state)
-        }
+        LateInit::Success(ref mut delayed_state) => (
+            global_state.log_factory.get_logger(func, arguments_writer),
+            delayed_state,
+        ),
         // There's no libcuda to load, so we might as well panic
         LateInit::Error => panic!(),
         LateInit::Unitialized => {
             let (new_delayed_state, logger) =
-                GlobalDelayedState::new(func, &mut global_state.log_factory);
+                GlobalDelayedState::new(func, arguments_writer, &mut global_state.log_factory);
             global_state.delayed_state = new_delayed_state;
             (logger, global_state.delayed_state.as_mut().unwrap())
         }
@@ -326,7 +290,6 @@ where
     let pre_result = pre_probe();
     let cu_result = original_cuda_fn(fn_ptr);
     logger.result = Some(cu_result);
-    print_arguments_fn(&mut logger, cu_result);
     post_probe(
         &mut logger,
         &mut delayed_state.cuda_state,
@@ -349,72 +312,6 @@ pub struct KernelDump {
     arguments: Option<Vec<usize>>,
 }
 
-// We are doing dlopen here instead of just using LD_PRELOAD,
-// it's because CUDA Runtime API does dlopen to open libcuda.so, which ignores LD_PRELOAD
-pub unsafe fn init_libcuda_handle(func: &'static str) {
-    if LIBCUDA_HANDLE == ptr::null_mut() {
-        let mut log_factory = log::Factory::new();
-        let (logger, settings) = log_factory.get_first_logger_and_init_settings(func);
-        MODULES = Some(HashMap::new());
-        KERNELS = Some(HashMap::new());
-        BUFFERS = Some(BTreeMap::new());
-        let libcuda_handle = ptr::null_mut();
-        assert_ne!(libcuda_handle, ptr::null_mut());
-        LIBCUDA_HANDLE = libcuda_handle;
-        match env::var("ZLUDA_DUMP_KERNEL") {
-            Ok(kernel_filter) => match Regex::new(&kernel_filter) {
-                Ok(r) => KERNEL_PATTERN = Some(r),
-                Err(err) => {
-                    os_log!("Error parsing ZLUDA_DUMP_KERNEL: {}", err);
-                }
-            },
-            Err(_) => (),
-        }
-        if let Ok(kernel_min_str) = env::var("ZLUDA_DUMP_MIN_INDEX") {
-            match kernel_min_str.parse::<usize>() {
-                Ok(kernel_min_value) => KERNEL_INDEX_MINIMUM = kernel_min_value,
-                Err(err) => {
-                    os_log!("Error parsing ZLUDA_DUMP_MIN_INDEX: {}", err);
-                }
-            }
-        }
-        if let Ok(kernel_max_str) = env::var("ZLUDA_DUMP_MAX_INDEX") {
-            match kernel_max_str.parse::<usize>() {
-                Ok(kernel_max_value) => KERNEL_INDEX_MAXIMUM = kernel_max_value,
-                Err(err) => {
-                    os_log!("Error parsing ZLUDA_DUMP_MAX_INDEX: {}", err);
-                }
-            }
-        }
-        match env::var("ZLUDA_OVERRIDE_COMPUTE_CAPABILITY_MAJOR") {
-            Ok(cc_override) => match str::parse::<i32>(&cc_override) {
-                Ok(ver) => OVERRIDE_COMPUTE_CAPABILITY_MAJOR = Some(ver),
-                Err(err) => {
-                    os_log!(
-                        "Error parsing ZLUDA_OVERRIDE_COMPUTE_CAPABILITY_MAJOR: {}",
-                        err
-                    );
-                }
-            },
-            Err(_) => (),
-        }
-        drop(logger);
-    }
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuModuleLoadData(
-    module: *mut CUmodule,
-    raw_image: *const ::std::os::raw::c_void,
-    cont: impl FnOnce(*mut CUmodule, *const c_void) -> CUresult,
-) -> CUresult {
-    let result = cont(module, raw_image);
-    if result == CUresult::CUDA_SUCCESS {
-        record_module_image_raw(*module, raw_image);
-    }
-    result
-}
-
 #[allow(non_snake_case)]
 pub(crate) fn cuModuleLoad_Post(
     module: *mut CUmodule,
@@ -457,1013 +354,6 @@ pub(crate) fn cuModuleLoadDataEx_Post(
     cuModuleLoadData_Post(module, raw_image, fn_logger, state, result)
 }
 
-unsafe fn record_module_image_raw(module: CUmodule, raw_image: *const ::std::os::raw::c_void) {
-    if *(raw_image as *const u32) == 0x464c457f {
-        os_log!("Unsupported ELF module image: {:?}", raw_image);
-        return;
-    }
-    let image = to_str(raw_image);
-    match image {
-        None => os_log!("Malformed module image: {:?}", raw_image),
-        Some(image) => record_module_image_with_module(module, raw_image, image),
-    };
-}
-
-unsafe fn record_module_image_with_module(
-    module: CUmodule,
-    raw_image: *const ::std::os::raw::c_void,
-    image: &str,
-) {
-    match record_module_image_impl(raw_image, image) {
-        Ok(dump) => {
-            MODULES
-                .get_or_insert_with(|| HashMap::new())
-                .insert(module, dump);
-        }
-        Err(e) => {
-            os_log!("{}", e);
-        }
-    }
-}
-
-unsafe fn record_module_image_with_linker(
-    link_obj: CUlinkState,
-    raw_image: *const ::std::os::raw::c_void,
-    image: &str,
-) {
-    match record_module_image_impl(raw_image, image) {
-        Ok(dump) => {
-            match PENDING_LINKING
-                .get_or_insert_with(|| HashMap::new())
-                .entry(link_obj)
-            {
-                hash_map::Entry::Occupied(mut vec) => {
-                    vec.get_mut().push(dump);
-                }
-                hash_map::Entry::Vacant(e) => {
-                    e.insert(vec![dump]);
-                }
-            };
-        }
-        Err(e) => {
-            os_log!("{}", e);
-        }
-    }
-}
-
-unsafe fn record_module_image_impl(
-    raw_image: *const ::std::os::raw::c_void,
-    image: &str,
-) -> Result<ModuleDump, Box<dyn Error>> {
-    if !image.contains(&".version") {
-        return Err(format!(
-            "Malformed module image (no `.version`): {:?}",
-            raw_image
-        ))?;
-    }
-    let mut errors = Vec::new();
-    let ast = ptx::ModuleParser::new().parse(&mut errors, image);
-    let kernels_args = match (&*errors, ast) {
-        (&[], Ok(ast)) => {
-            let kernels_args = ast
-                .directives
-                .iter()
-                .filter_map(directive_to_kernel)
-                .collect::<HashMap<_, _>>();
-            Some(kernels_args)
-        }
-        (err_vec, res) => {
-            // Don't print errors - it's usually too verbose to be useful
-            os_log!(
-                "{} errors when parsing module image: {:?}",
-                err_vec.len() + res.iter().len(),
-                raw_image
-            );
-            None
-        }
-    };
-    let dump = ModuleDump {
-        content: Rc::new(image.to_string()),
-        kernels_args,
-    };
-    if let Err(e) = try_dump_module_image(image) {
-        return Err(format!(
-            "Errors when saving module image: {:?}, {}",
-            raw_image, e
-        ))?;
-    }
-    Ok(dump)
-}
-
-unsafe fn try_dump_module_image(image: &str) -> Result<(), Box<dyn Error>> {
-    let mut dump_path = get_dump_dir()?;
-    dump_path.push(format!("module_{:04}.ptx", MODULE_DUMP_COUNTER));
-    MODULE_DUMP_COUNTER += 1;
-    let mut file = File::create(dump_path)?;
-    file.write_all(image.as_bytes())?;
-    Ok(())
-}
-
-unsafe fn to_str<T>(image: *const T) -> Option<&'static str> {
-    let ptr = image as *const u8;
-    let mut offset = 0;
-    loop {
-        let c = *ptr.add(offset);
-        if !c.is_ascii() {
-            return None;
-        }
-        if c == 0 {
-            return Some(std::str::from_utf8_unchecked(slice::from_raw_parts(
-                ptr, offset,
-            )));
-        }
-        offset += 1;
-    }
-}
-
-fn directive_to_kernel(dir: &ast::Directive<ast::ParsedArgParams>) -> Option<(String, Vec<usize>)> {
-    match dir {
-        ast::Directive::Method(
-            _,
-            ast::Function {
-                func_directive:
-                    ast::MethodDeclaration {
-                        name: ast::MethodName::Kernel(name),
-                        input_arguments,
-                        ..
-                    },
-                ..
-            },
-        ) => {
-            let arg_sizes = input_arguments
-                .iter()
-                .map(|arg| ast::Type::from(arg.v_type.clone()).size_of())
-                .collect();
-            Some((name.to_string(), arg_sizes))
-        }
-        _ => None,
-    }
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuModuleLoadDataEx(
-    module: *mut CUmodule,
-    image: *const c_void,
-    numOptions: c_uint,
-    options: *mut CUjit_option,
-    optionValues: *mut *mut c_void,
-    cont: impl FnOnce(
-        *mut CUmodule,
-        *const c_void,
-        c_uint,
-        *mut CUjit_option,
-        *mut *mut c_void,
-    ) -> CUresult,
-) -> CUresult {
-    let result = cont(module, image, numOptions, options, optionValues);
-    if result == CUresult::CUDA_SUCCESS {
-        record_module_image_raw(*module, image);
-    }
-    result
-}
-
-#[allow(non_snake_case)]
-unsafe fn cuModuleGetFunction(
-    hfunc: *mut CUfunction,
-    hmod: CUmodule,
-    name: *const ::std::os::raw::c_char,
-    cont: impl FnOnce(*mut CUfunction, CUmodule, *const ::std::os::raw::c_char) -> CUresult,
-) -> CUresult {
-    let result = cont(hfunc, hmod, name);
-    if result != CUresult::CUDA_SUCCESS {
-        return result;
-    }
-    if let Some(modules) = &MODULES {
-        if let Some(module_dump) = modules.get(&hmod) {
-            if let Some(kernel) = to_str(name) {
-                let kernel_args = if let Some(kernels) = &module_dump.kernels_args {
-                    if let Some(args) = kernels.get(kernel) {
-                        Some(args.clone())
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                };
-                KERNELS.as_mut().unwrap().insert(
-                    *hfunc,
-                    KernelDump {
-                        module_content: module_dump.content.clone(),
-                        name: kernel.to_string(),
-                        arguments: kernel_args,
-                    },
-                );
-            } else {
-                os_log!("Malformed name at: {:?}", hfunc);
-            }
-        } else {
-            os_log!("Unknown module: {:?}", hmod);
-        }
-    } else {
-        os_log!("Unknown module: {:?}", hmod);
-    }
-    CUresult::CUDA_SUCCESS
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuMemAlloc(
-    dptr: *mut CUdeviceptr,
-    bytesize: usize,
-    cont: impl FnOnce(*mut CUdeviceptr, usize) -> CUresult,
-) -> CUresult {
-    cuMemAlloc_impl(false, dptr, bytesize, cont)
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuMemAlloc_v2(
-    dptr: *mut CUdeviceptr,
-    bytesize: usize,
-    cont: impl FnOnce(*mut CUdeviceptr, usize) -> CUresult,
-) -> CUresult {
-    cuMemAlloc_impl(true, dptr, bytesize, cont)
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuMemAlloc_impl(
-    is_v2: bool,
-    dptr: *mut CUdeviceptr,
-    bytesize: usize,
-    cont: impl FnOnce(*mut CUdeviceptr, usize) -> CUresult,
-) -> CUresult {
-    let result = cont(dptr, bytesize);
-    assert_eq!(result, CUresult::CUDA_SUCCESS);
-    let start = (*dptr).0 as usize;
-    let location = if is_v2 {
-        AllocLocation::DeviceV2
-    } else {
-        AllocLocation::Device
-    };
-    BUFFERS
-        .as_mut()
-        .unwrap()
-        .insert(start, (bytesize, location));
-    CUresult::CUDA_SUCCESS
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuMemHostAlloc(
-    pp: *mut *mut c_void,
-    bytesize: usize,
-    flags: c_uint,
-    cont: impl FnOnce(*mut *mut c_void, usize, c_uint) -> CUresult,
-) -> CUresult {
-    let result = cont(pp, bytesize, flags);
-    assert_eq!(result, CUresult::CUDA_SUCCESS);
-    let start = (*pp) as usize;
-    BUFFERS
-        .as_mut()
-        .unwrap()
-        .insert(start, (bytesize, AllocLocation::Host));
-    CUresult::CUDA_SUCCESS
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuLaunchKernel(
-    f: CUfunction,
-    gridDimX: ::std::os::raw::c_uint,
-    gridDimY: ::std::os::raw::c_uint,
-    gridDimZ: ::std::os::raw::c_uint,
-    blockDimX: ::std::os::raw::c_uint,
-    blockDimY: ::std::os::raw::c_uint,
-    blockDimZ: ::std::os::raw::c_uint,
-    sharedMemBytes: ::std::os::raw::c_uint,
-    hStream: CUstream,
-    kernelParams: *mut *mut ::std::os::raw::c_void,
-    extra: *mut *mut ::std::os::raw::c_void,
-    cont: impl FnOnce(
-        CUfunction,
-        ::std::os::raw::c_uint,
-        ::std::os::raw::c_uint,
-        ::std::os::raw::c_uint,
-        ::std::os::raw::c_uint,
-        ::std::os::raw::c_uint,
-        ::std::os::raw::c_uint,
-        ::std::os::raw::c_uint,
-        CUstream,
-        *mut *mut ::std::os::raw::c_void,
-        *mut *mut ::std::os::raw::c_void,
-    ) -> CUresult,
-) -> CUresult {
-    let mut error;
-    let dump_env = match create_dump_dir(f, LAUNCH_COUNTER) {
-        Ok(dump_env) => dump_env,
-        Err(err) => {
-            os_log!("Error when creating the dump directory: {}", err);
-            None
-        }
-    };
-    if let Some(dump_env) = &dump_env {
-        dump_pre_data(
-            gridDimX,
-            gridDimY,
-            gridDimZ,
-            blockDimX,
-            blockDimY,
-            blockDimZ,
-            sharedMemBytes,
-            kernelParams,
-            extra,
-            dump_env,
-        )
-        .unwrap_or_else(|err| os_log!("{}", err));
-    };
-    error = cont(
-        f,
-        gridDimX,
-        gridDimY,
-        gridDimZ,
-        blockDimX,
-        blockDimY,
-        blockDimZ,
-        sharedMemBytes,
-        hStream,
-        kernelParams,
-        extra,
-    );
-    assert_eq!(error, CUresult::CUDA_SUCCESS);
-    error = cuda::cuStreamSynchronize(hStream);
-    assert_eq!(error, CUresult::CUDA_SUCCESS);
-    if let Some((_, kernel_dump)) = &dump_env {
-        dump_arguments(
-            kernelParams,
-            extra,
-            "post",
-            &kernel_dump.name,
-            LAUNCH_COUNTER,
-            kernel_dump.arguments.as_ref().map(|vec| &vec[..]),
-        )
-        .unwrap_or_else(|err| os_log!("{}", err));
-    }
-    LAUNCH_COUNTER += 1;
-    CUresult::CUDA_SUCCESS
-}
-
-#[allow(non_snake_case)]
-fn dump_launch_arguments(
-    gridDimX: u32,
-    gridDimY: u32,
-    gridDimZ: u32,
-    blockDimX: u32,
-    blockDimY: u32,
-    blockDimZ: u32,
-    sharedMemBytes: u32,
-    dump_dir: &PathBuf,
-) -> Result<(), Box<dyn Error>> {
-    let mut module_file_path = dump_dir.clone();
-    module_file_path.push("launch.txt");
-    let mut module_file = File::create(module_file_path)?;
-    write!(&mut module_file, "{}\n", gridDimX)?;
-    write!(&mut module_file, "{}\n", gridDimY)?;
-    write!(&mut module_file, "{}\n", gridDimZ)?;
-    write!(&mut module_file, "{}\n", blockDimX)?;
-    write!(&mut module_file, "{}\n", blockDimY)?;
-    write!(&mut module_file, "{}\n", blockDimZ)?;
-    write!(&mut module_file, "{}\n", sharedMemBytes)?;
-    Ok(())
-}
-
-unsafe fn should_dump_kernel(counter: usize, name: &str) -> bool {
-    if counter < KERNEL_INDEX_MINIMUM {
-        return false;
-    }
-    if counter > KERNEL_INDEX_MAXIMUM {
-        return false;
-    }
-    match &KERNEL_PATTERN {
-        Some(pattern) => pattern.is_match(name),
-        None => true,
-    }
-}
-
-unsafe fn create_dump_dir(
-    f: CUfunction,
-    counter: usize,
-) -> Result<Option<(PathBuf, &'static KernelDump)>, Box<dyn Error>> {
-    match KERNELS.as_ref().and_then(|kernels| kernels.get(&f)) {
-        Some(kernel_dump) => {
-            if !should_dump_kernel(counter, &kernel_dump.name) {
-                return Ok(None);
-            }
-            let mut dump_dir = get_dump_dir()?;
-            dump_dir.push(format!("{:04}_{}", counter, kernel_dump.name));
-            fs::create_dir_all(&dump_dir)?;
-            Ok(Some((dump_dir, kernel_dump)))
-        }
-        None => Err(format!("Unknown kernel: {:?}", f))?,
-    }
-}
-
-#[allow(non_snake_case)]
-unsafe fn dump_pre_data(
-    gridDimX: ::std::os::raw::c_uint,
-    gridDimY: ::std::os::raw::c_uint,
-    gridDimZ: ::std::os::raw::c_uint,
-    blockDimX: ::std::os::raw::c_uint,
-    blockDimY: ::std::os::raw::c_uint,
-    blockDimZ: ::std::os::raw::c_uint,
-    sharedMemBytes: ::std::os::raw::c_uint,
-    kernelParams: *mut *mut ::std::os::raw::c_void,
-    extra: *mut *mut ::std::os::raw::c_void,
-    (dump_dir, kernel_dump): &(PathBuf, &'static KernelDump),
-) -> Result<(), Box<dyn Error>> {
-    dump_launch_arguments(
-        gridDimX,
-        gridDimY,
-        gridDimZ,
-        blockDimX,
-        blockDimY,
-        blockDimZ,
-        sharedMemBytes,
-        dump_dir,
-    )?;
-    let mut module_file_path = dump_dir.clone();
-    module_file_path.push("module.ptx");
-    let mut module_file = File::create(module_file_path)?;
-    module_file.write_all(kernel_dump.module_content.as_bytes())?;
-    dump_arguments(
-        kernelParams,
-        extra,
-        "pre",
-        &kernel_dump.name,
-        LAUNCH_COUNTER,
-        kernel_dump.arguments.as_ref().map(|vec| &vec[..]),
-    )?;
-    Ok(())
-}
-
-fn dump_arguments(
-    kernel_params: *mut *mut ::std::os::raw::c_void,
-    extra: *mut *mut ::std::os::raw::c_void,
-    prefix: &str,
-    kernel_name: &str,
-    counter: usize,
-    args: Option<&[usize]>,
-) -> Result<(), Box<dyn Error>> {
-    let args = match args {
-        None => return Ok(()),
-        Some(a) => a,
-    };
-    let mut dump_dir = get_dump_dir()?;
-    dump_dir.push(format!("{:04}_{}", counter, kernel_name));
-    dump_dir.push(prefix);
-    if dump_dir.exists() {
-        fs::remove_dir_all(&dump_dir)?;
-    }
-    fs::create_dir_all(&dump_dir)?;
-    if kernel_params != ptr::null_mut() {
-        for (i, arg_len) in args.iter().enumerate() {
-            unsafe { dump_argument_to_file(&dump_dir, i, *arg_len, *kernel_params.add(i))? };
-        }
-    } else {
-        let mut offset = 0;
-        let mut buffer_ptr = None;
-        let mut buffer_size = None;
-        loop {
-            match unsafe { *extra.add(offset) } {
-                CU_LAUNCH_PARAM_END => break,
-                CU_LAUNCH_PARAM_BUFFER_POINTER => {
-                    buffer_ptr = Some(unsafe { *extra.add(offset + 1) as *mut u8 });
-                }
-                CU_LAUNCH_PARAM_BUFFER_SIZE => {
-                    buffer_size = Some(unsafe { *(*extra.add(offset + 1) as *mut usize) });
-                }
-                _ => return Err("Malformed `extra` parameter to kernel launch")?,
-            }
-            offset += 2;
-        }
-        match (buffer_size, buffer_ptr) {
-            (Some(buffer_size), Some(buffer_ptr)) => {
-                let sum_of_kernel_argument_sizes = args.iter().fold(0, |offset, size_of_arg| {
-                    size_of_arg + round_up_to_multiple(offset, *size_of_arg)
-                });
-                if buffer_size < sum_of_kernel_argument_sizes {
-                    return Err("Malformed `extra` parameter to kernel launch")?;
-                }
-                let mut offset = 0;
-                for (i, arg_size) in args.iter().enumerate() {
-                    let buffer_offset = round_up_to_multiple(offset, *arg_size);
-                    unsafe {
-                        dump_argument_to_file(
-                            &dump_dir,
-                            i,
-                            *arg_size,
-                            buffer_ptr.add(buffer_offset) as *const _,
-                        )?
-                    };
-                    offset = buffer_offset + *arg_size;
-                }
-            }
-            _ => return Err("Malformed `extra` parameter to kernel launch")?,
-        }
-    }
-    Ok(())
-}
-
-fn round_up_to_multiple(x: usize, multiple: usize) -> usize {
-    ((x + multiple - 1) / multiple) * multiple
-}
-
-unsafe fn dump_argument_to_file(
-    dump_dir: &PathBuf,
-    i: usize,
-    arg_len: usize,
-    ptr: *const c_void,
-) -> Result<(), Box<dyn Error>> {
-    // Don't check if arg_len == sizeof(void*), there are libraries
-    // which for some reason pass 32 pointers (4 bytes) in 8 byte arguments
-    match get_buffer_length(*(ptr as *mut usize)) {
-        Some((start, len, location)) => {
-            let mut output = vec![0u8; len];
-            let memcpy_fn = match location {
-                AllocLocation::Device => |src, dst: usize, len| {
-                    let error = cuda::cuMemcpyDtoH(dst as *mut _, CUdeviceptr(src), len);
-                    assert_eq!(error, CUresult::CUDA_SUCCESS);
-                },
-                AllocLocation::DeviceV2 => |src, dst: usize, len| {
-                    let error = cuda::cuMemcpyDtoH_v2(dst as *mut _, CUdeviceptr(src), len);
-                    assert_eq!(error, CUresult::CUDA_SUCCESS);
-                },
-                AllocLocation::Host => |src, dst: usize, len| {
-                    ptr::copy_nonoverlapping(src as *mut u8, dst as *mut u8, len);
-                },
-            };
-            memcpy_fn(start, output.as_mut_ptr() as usize, len);
-            let mut path = dump_dir.clone();
-            path.push(format!("arg_{:03}.buffer", i));
-            let mut file = File::create(path)?;
-            file.write_all(&mut output)?;
-        }
-        None => {
-            let mut path = dump_dir.clone();
-            path.push(format!("arg_{:03}", i));
-            let mut file = File::create(path)?;
-            file.write_all(slice::from_raw_parts(ptr as *mut u8, arg_len))?;
-        }
-    }
-    Ok(())
-}
-
-unsafe fn get_buffer_length(ptr: usize) -> Option<(usize, usize, AllocLocation)> {
-    BUFFERS
-        .as_mut()
-        .unwrap()
-        .range(..=ptr)
-        .next_back()
-        .and_then(|(start, (len, loc))| {
-            let end = *start + *len;
-            if ptr < end {
-                Some((ptr, end - ptr, *loc))
-            } else {
-                None
-            }
-        })
-}
-
-fn get_dump_dir() -> Result<PathBuf, Box<dyn Error>> {
-    let dir = env::var("ZLUDA_DUMP_DIR")?;
-    let mut main_dir = PathBuf::from(dir);
-    let current_exe = env::current_exe()?;
-    main_dir.push(current_exe.file_name().unwrap());
-    fs::create_dir_all(&main_dir)?;
-    Ok(main_dir)
-}
-
-// TODO make this more common with ZLUDA implementation
-const CUDART_INTERFACE_GUID: CUuuid = CUuuid {
-    bytes: [
-        0x6b, 0xd5, 0xfb, 0x6c, 0x5b, 0xf4, 0xe7, 0x4a, 0x89, 0x87, 0xd9, 0x39, 0x12, 0xfd, 0x9d,
-        0xf9,
-    ],
-};
-
-static mut OVERRIDEN_INTERFACE_VTABLES: Option<HashMap<Box<CUuuid>, Vec<*const c_void>>> = None;
-
-static mut ORIGINAL_GET_MODULE_FROM_CUBIN: Option<
-    unsafe extern "system" fn(
-        result: *mut CUmodule,
-        fatbinc_wrapper: *const FatbincWrapper,
-    ) -> CUresult,
-> = None;
-static mut ORIGINAL_GET_MODULE_FROM_CUBIN_EXT1: Option<
-    unsafe extern "system" fn(
-        result: *mut CUmodule,
-        fatbinc_wrapper: *const FatbincWrapper,
-        ptr1: *mut c_void,
-        ptr2: *mut c_void,
-        _unknown: usize,
-    ) -> CUresult,
-> = None;
-static mut ORIGINAL_GET_MODULE_FROM_CUBIN_EXT2: Option<
-    unsafe extern "system" fn(
-        fatbinc_wrapper: *const FatbinHeader,
-        result: *mut CUmodule,
-        ptr1: *mut c_void,
-        ptr2: *mut c_void,
-        _unknown: usize,
-    ) -> CUresult,
-> = None;
-
-unsafe extern "system" fn report_unknown_export_table_call(
-    export_table: *const CUuuid,
-    idx: usize,
-) {
-    let guid = (*export_table).bytes;
-    os_log!("Call to an unsupported export table function: {{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}::{}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15], idx);
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuGetExportTable(
-    ppExportTable: *mut *const ::std::os::raw::c_void,
-    pExportTableId: *const CUuuid,
-    cont: impl FnOnce(*mut *const ::std::os::raw::c_void, *const CUuuid) -> CUresult,
-) -> CUresult {
-    if ppExportTable == ptr::null_mut() || pExportTableId == ptr::null() {
-        return CUresult::CUDA_ERROR_INVALID_VALUE;
-    }
-    let guid = (*pExportTableId).bytes;
-    os_log!("Requested export table id: {{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]);
-    override_export_table(ppExportTable, pExportTableId, cont)
-}
-
-unsafe fn override_export_table(
-    export_table_ptr: *mut *const ::std::os::raw::c_void,
-    export_table_id: *const CUuuid,
-    cont: impl FnOnce(*mut *const ::std::os::raw::c_void, *const CUuuid) -> CUresult,
-) -> CUresult {
-    let overrides_map = OVERRIDEN_INTERFACE_VTABLES.get_or_insert_with(|| HashMap::new());
-    if let Some(override_table) = overrides_map.get(&*export_table_id) {
-        *export_table_ptr = override_table.as_ptr() as *const _;
-        return CUresult::CUDA_SUCCESS;
-    }
-    let base_result = cont(export_table_ptr, export_table_id);
-    if base_result != CUresult::CUDA_SUCCESS {
-        return base_result;
-    }
-    let export_table = (*export_table_ptr) as *mut *const c_void;
-    let boxed_guid = Box::new(*export_table_id);
-    let byte_length: usize = *(export_table as *const usize);
-    let mut override_table = Vec::new();
-    if byte_length < 0x10000 {
-        override_table.push(byte_length as *const _);
-        let length = byte_length / mem::size_of::<usize>();
-        for i in 1..length {
-            let current_fn = export_table.add(i);
-            if (*current_fn as usize) == usize::max_value() {
-                override_table.push(usize::max_value() as *const _);
-                break;
-            }
-            override_table.push(get_export_override_fn(*current_fn, &*boxed_guid, i));
-        }
-    } else {
-        let mut i = 0;
-        loop {
-            let current_fn = export_table.add(i);
-            if (*current_fn as usize) == usize::max_value() {
-                override_table.push(usize::max_value() as *const _);
-                break;
-            }
-            override_table.push(get_export_override_fn(*current_fn, &*boxed_guid, i));
-            i += 1;
-        }
-    }
-    *export_table_ptr = override_table.as_ptr() as *const _;
-    overrides_map.insert(boxed_guid, override_table);
-    CUresult::CUDA_SUCCESS
-}
-
-const TOOLS_RUNTIME_CALLBACK_HOOKS_GUID: CUuuid = CUuuid {
-    bytes: [
-        0xa0, 0x94, 0x79, 0x8c, 0x2e, 0x74, 0x2e, 0x74, 0x93, 0xf2, 0x08, 0x00, 0x20, 0x0c, 0x0a,
-        0x66,
-    ],
-};
-
-const CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID: CUuuid = CUuuid {
-    bytes: [
-        0xc6, 0x93, 0x33, 0x6e, 0x11, 0x21, 0xdf, 0x11, 0xa8, 0xc3, 0x68, 0xf3, 0x55, 0xd8, 0x95,
-        0x93,
-    ],
-};
-
-const CTX_CREATE_BYPASS_GUID: CUuuid = CUuuid {
-    bytes: [
-        0x0C, 0xA5, 0x0B, 0x8C, 0x10, 0x04, 0x92, 0x9A, 0x89, 0xA7, 0xD0, 0xDF, 0x10, 0xE7, 0x72,
-        0x86,
-    ],
-};
-
-const HEAP_ACCESS_GUID: CUuuid = CUuuid {
-    bytes: [
-        0x19, 0x5B, 0xCB, 0xF4, 0xD6, 0x7D, 0x02, 0x4A, 0xAC, 0xC5, 0x1D, 0x29, 0xCE, 0xA6, 0x31,
-        0xAE,
-    ],
-};
-
-const DEVICE_EXTENDED_RT_GUID: CUuuid = CUuuid {
-    bytes: [
-        0xB1u8, 0x05, 0x41, 0xE1, 0xF7, 0xC7, 0xC7, 0x4A, 0x9F, 0x64, 0xF2, 0x23, 0xBE, 0x99, 0xF1,
-        0xE2,
-    ],
-};
-
-unsafe fn get_export_override_fn(
-    original_fn: *const c_void,
-    guid: *const CUuuid,
-    idx: usize,
-) -> *const c_void {
-    match (*guid, idx) {
-        (TOOLS_RUNTIME_CALLBACK_HOOKS_GUID, 2)
-        | (TOOLS_RUNTIME_CALLBACK_HOOKS_GUID, 6)
-        | (CUDART_INTERFACE_GUID, 2)
-        | (CUDART_INTERFACE_GUID, 7)
-        | (CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID, 0)
-        | (CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID, 1)
-        | (CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID, 2)
-        | (CTX_CREATE_BYPASS_GUID, 1)
-        | (HEAP_ACCESS_GUID, 1)
-        | (HEAP_ACCESS_GUID, 2)
-        | (DEVICE_EXTENDED_RT_GUID, 5)
-        | (DEVICE_EXTENDED_RT_GUID, 13) => original_fn,
-        (CUDART_INTERFACE_GUID, 1) => {
-            ORIGINAL_GET_MODULE_FROM_CUBIN = mem::transmute(original_fn);
-            get_module_from_cubin as *const _
-        }
-        (CUDART_INTERFACE_GUID, 6) => {
-            ORIGINAL_GET_MODULE_FROM_CUBIN_EXT1 = mem::transmute(original_fn);
-            get_module_from_cubin_ext1 as *const _
-        }
-        (CUDART_INTERFACE_GUID, 8) => {
-            ORIGINAL_GET_MODULE_FROM_CUBIN_EXT2 = mem::transmute(original_fn);
-            get_module_from_cubin_ext2 as *const _
-        }
-        _ => os::get_thunk(original_fn, report_unknown_export_table_call, guid, idx),
-    }
-}
-
-const FATBINC_MAGIC: c_uint = 0x466243B1;
-const FATBINC_VERSION: c_uint = 0x1;
-
-#[repr(C)]
-struct FatbincWrapper {
-    magic: c_uint,
-    version: c_uint,
-    data: *const FatbinHeader,
-    filename_or_fatbins: *const c_void,
-}
-
-const FATBIN_MAGIC: c_uint = 0xBA55ED50;
-const LEGACY_FATBIN_MAGIC: c_uint = 0x1EE55A01;
-const FATBIN_VERSION: c_ushort = 0x01;
-
-#[repr(C, align(8))]
-struct FatbinHeader {
-    magic: c_uint,
-    version: c_ushort,
-    header_size: c_ushort,
-    files_size: c_ulong, // excluding frame header, size of all blocks framed by this frame
-}
-
-const FATBIN_FILE_HEADER_KIND_PTX: c_ushort = 0x01;
-const FATBIN_FILE_HEADER_VERSION_CURRENT: c_ushort = 0x101;
-
-// assembly file header is a bit different, but we don't care
-#[repr(C)]
-#[derive(Debug)]
-struct FatbinFileHeader {
-    kind: c_ushort,
-    version: c_ushort,
-    header_size: c_uint,
-    padded_payload_size: c_uint,
-    unknown0: c_uint, // check if it's written into separately
-    payload_size: c_uint,
-    unknown1: c_uint,
-    unknown2: c_uint,
-    sm_version: c_uint,
-    bit_width: c_uint,
-    unknown3: c_uint,
-    unknown4: c_ulong,
-    unknown5: c_ulong,
-    uncompressed_payload: c_ulong,
-}
-
-unsafe fn get_module_from_cubin_impl(
-    module: *mut CUmodule,
-    fatbinc_wrapper: *const FatbincWrapper,
-    get_module_base: impl FnOnce() -> CUresult,
-) -> CUresult {
-    if module == ptr::null_mut()
-        || (*fatbinc_wrapper).magic != FATBINC_MAGIC
-        || (*fatbinc_wrapper).version != FATBINC_VERSION
-    {
-        return CUresult::CUDA_ERROR_INVALID_VALUE;
-    }
-    get_module_from_cubin_unwrapped(module, (*fatbinc_wrapper).data, get_module_base)
-}
-
-unsafe fn get_module_from_cubin_unwrapped(
-    module: *mut CUmodule,
-    fatbin_header: *const FatbinHeader,
-    get_module_base: impl FnOnce() -> CUresult,
-) -> CUresult {
-    if (*fatbin_header).magic != FATBIN_MAGIC || (*fatbin_header).version != FATBIN_VERSION {
-        return CUresult::CUDA_ERROR_INVALID_VALUE;
-    }
-    let file = (fatbin_header as *const u8).add((*fatbin_header).header_size as usize);
-    let end = file.add((*fatbin_header).files_size as usize);
-    let mut ptx_files = get_ptx_files(file, end);
-    ptx_files.sort_unstable_by_key(|f| c_uint::max_value() - (**f).sm_version);
-    let mut maybe_kernel_text = None;
-    for file in ptx_files {
-        match decompress_kernel_module(file) {
-            None => continue,
-            Some(vec) => {
-                maybe_kernel_text = Some(vec);
-                break;
-            }
-        };
-    }
-    let result = get_module_base();
-    if result != CUresult::CUDA_SUCCESS {
-        return result;
-    }
-    if let Some(text) = maybe_kernel_text {
-        match CStr::from_bytes_with_nul(&text) {
-            Ok(cstr) => match cstr.to_str() {
-                Ok(utf8_str) => {
-                    record_module_image_with_module(*module, text.as_ptr() as _, utf8_str)
-                }
-                Err(_) => {}
-            },
-            Err(_) => {}
-        }
-    } else {
-        os_log!("Unsupported runtime module: {:?}", *module);
-    }
-    result
-}
-
-unsafe extern "system" fn get_module_from_cubin(
-    module: *mut CUmodule,
-    fatbinc_wrapper: *const FatbincWrapper,
-) -> CUresult {
-    get_module_from_cubin_impl(module, fatbinc_wrapper, || {
-        ORIGINAL_GET_MODULE_FROM_CUBIN.unwrap()(module, fatbinc_wrapper)
-    })
-}
-
-unsafe extern "system" fn get_module_from_cubin_ext1(
-    module: *mut CUmodule,
-    fatbinc_wrapper: *const FatbincWrapper,
-    ptr1: *mut c_void,
-    ptr2: *mut c_void,
-    _unknown: usize,
-) -> CUresult {
-    get_module_from_cubin_impl(module, fatbinc_wrapper, || {
-        ORIGINAL_GET_MODULE_FROM_CUBIN_EXT1.unwrap()(module, fatbinc_wrapper, ptr1, ptr2, _unknown)
-    })
-}
-
-unsafe extern "system" fn get_module_from_cubin_ext2(
-    fatbin_header: *const FatbinHeader,
-    module: *mut CUmodule,
-    ptr1: *mut c_void,
-    ptr2: *mut c_void,
-    _unknown: usize,
-) -> CUresult {
-    get_module_from_cubin_unwrapped(module, fatbin_header, || {
-        ORIGINAL_GET_MODULE_FROM_CUBIN_EXT2.unwrap()(fatbin_header, module, ptr1, ptr2, _unknown)
-    })
-}
-
-unsafe fn get_ptx_files(file: *const u8, end: *const u8) -> Vec<*const FatbinFileHeader> {
-    let mut index = file;
-    let mut result = Vec::new();
-    while index < end {
-        let file = index as *const FatbinFileHeader;
-        if (*file).kind == FATBIN_FILE_HEADER_KIND_PTX
-            && (*file).version == FATBIN_FILE_HEADER_VERSION_CURRENT
-        {
-            result.push(file)
-        }
-        index = index.add((*file).header_size as usize + (*file).padded_payload_size as usize);
-    }
-    result
-}
-
-const MAX_PTX_MODULE_DECOMPRESSION_BOUND: usize = 16 * 1024 * 1024;
-
-unsafe fn decompress_kernel_module(file: *const FatbinFileHeader) -> Option<Vec<u8>> {
-    let decompressed_size = usize::max(1024, (*file).uncompressed_payload as usize);
-    let mut decompressed_vec = vec![0u8; decompressed_size];
-    loop {
-        match lz4_sys::LZ4_decompress_safe(
-            (file as *const u8).add((*file).header_size as usize) as *const _,
-            decompressed_vec.as_mut_ptr() as *mut _,
-            (*file).payload_size as c_int,
-            decompressed_vec.len() as c_int,
-        ) {
-            error if error < 0 => {
-                let new_size = decompressed_vec.len() * 2;
-                if new_size > MAX_PTX_MODULE_DECOMPRESSION_BOUND {
-                    return None;
-                }
-                decompressed_vec.resize(decompressed_vec.len() * 2, 0);
-            }
-            real_decompressed_size => {
-                decompressed_vec.truncate(real_decompressed_size as usize);
-                if decompressed_vec.last().copied().unwrap_or(1) != 0 {
-                    decompressed_vec.push(0);
-                }
-                return Some(decompressed_vec);
-            }
-        }
-    }
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuDeviceGetAttribute(
-    pi: *mut ::std::os::raw::c_int,
-    attrib: CUdevice_attribute,
-    dev: CUdevice,
-    cont: impl FnOnce(*mut ::std::os::raw::c_int, CUdevice_attribute, CUdevice) -> CUresult,
-) -> CUresult {
-    if attrib == CUdevice_attribute::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR {
-        if let Some(ver) = OVERRIDE_COMPUTE_CAPABILITY_MAJOR {
-            *pi = ver;
-            return CUresult::CUDA_SUCCESS;
-        }
-    }
-    cont(pi, attrib, dev)
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuLinkAddData(
-    state: CUlinkState,
-    type_: CUjitInputType,
-    data: *mut ::std::os::raw::c_void,
-    size: usize,
-    name: *const ::std::os::raw::c_char,
-    numOptions: ::std::os::raw::c_uint,
-    options: *mut CUjit_option,
-    optionValues: *mut *mut ::std::os::raw::c_void,
-    cont: impl FnOnce(
-        CUlinkState,
-        CUjitInputType,
-        *mut ::std::os::raw::c_void,
-        usize,
-        *const ::std::os::raw::c_char,
-        ::std::os::raw::c_uint,
-        *mut CUjit_option,
-        *mut *mut ::std::os::raw::c_void,
-    ) -> CUresult,
-) -> CUresult {
-    if let Some(image) = to_str(data) {
-        record_module_image_with_linker(state, data, image)
-    } else {
-        os_log!("PTX module not a string: {:?}", data);
-    }
-    cont(
-        state,
-        type_,
-        data,
-        size,
-        name,
-        numOptions,
-        options,
-        optionValues,
-    )
-}
-
-#[allow(non_snake_case)]
-pub unsafe fn cuLinkAddFile(
-    state: CUlinkState,
-    type_: CUjitInputType,
-    path: *const ::std::os::raw::c_char,
-    numOptions: ::std::os::raw::c_uint,
-    options: *mut CUjit_option,
-    optionValues: *mut *mut ::std::os::raw::c_void,
-    cont: impl FnOnce(
-        CUlinkState,
-        CUjitInputType,
-        *const ::std::os::raw::c_char,
-        ::std::os::raw::c_uint,
-        *mut CUjit_option,
-        *mut *mut ::std::os::raw::c_void,
-    ) -> CUresult,
-) -> CUresult {
-    cont(state, type_, path, numOptions, options, optionValues)
-}
-
 #[allow(non_snake_case)]
 pub(crate) fn cuGetExportTable_Post(
     ppExportTable: *mut *const ::std::os::raw::c_void,
@@ -1480,34 +370,34 @@ pub(crate) fn cuGetExportTable_Post(
 
 #[allow(non_snake_case)]
 pub(crate) fn cuModuleGetFunction_Post(
-    hfunc: *mut CUfunction,
-    hmod: CUmodule,
-    name: *const ::std::os::raw::c_char,
-    fn_logger: &mut log::FunctionLogger,
-    state: &mut trace::StateTracker,
-    result: CUresult,
+    _hfunc: *mut CUfunction,
+    _hmod: CUmodule,
+    _name: *const ::std::os::raw::c_char,
+    _fn_logger: &mut log::FunctionLogger,
+    _state: &mut trace::StateTracker,
+    _result: CUresult,
 ) {
 }
 
 #[allow(non_snake_case)]
 pub(crate) fn cuDeviceGetAttribute_Post(
-    pi: *mut ::std::os::raw::c_int,
-    attrib: CUdevice_attribute,
-    dev: CUdevice,
-    fn_logger: &mut log::FunctionLogger,
-    state: &mut trace::StateTracker,
-    result: CUresult,
+    _pi: *mut ::std::os::raw::c_int,
+    _attrib: CUdevice_attribute,
+    _dev: CUdevice,
+    _fn_logger: &mut log::FunctionLogger,
+    _state: &mut trace::StateTracker,
+    _result: CUresult,
 ) {
 }
 
 #[allow(non_snake_case)]
 pub(crate) fn cuDeviceComputeCapability_Post(
     major: *mut ::std::os::raw::c_int,
-    minor: *mut ::std::os::raw::c_int,
-    dev: CUdevice,
-    fn_logger: &mut log::FunctionLogger,
+    _minor: *mut ::std::os::raw::c_int,
+    _dev: CUdevice,
+    _fn_logger: &mut log::FunctionLogger,
     state: &mut trace::StateTracker,
-    result: CUresult,
+    _result: CUresult,
 ) {
     if let Some(major_ver_override) = state.override_cc_major {
         unsafe { *major = major_ver_override as i32 };
@@ -1516,10 +406,10 @@ pub(crate) fn cuDeviceComputeCapability_Post(
 
 #[allow(non_snake_case)]
 pub(crate) fn cuModuleLoadFatBinary_Post(
-    module: *mut CUmodule,
-    fatCubin: *const ::std::os::raw::c_void,
-    fn_logger: &mut log::FunctionLogger,
-    state: &mut trace::StateTracker,
+    _module: *mut CUmodule,
+    _fatCubin: *const ::std::os::raw::c_void,
+    _fn_logger: &mut log::FunctionLogger,
+    _state: &mut trace::StateTracker,
     result: CUresult,
 ) {
     if result == CUresult::CUDA_SUCCESS {
diff --git a/zluda_dump/src/log.rs b/zluda_dump/src/log.rs
index 8c226f9..00fe506 100644
--- a/zluda_dump/src/log.rs
+++ b/zluda_dump/src/log.rs
@@ -1,14 +1,11 @@
-use crate::cuda::CUmodule;

-use crate::cuda::CUuuid;

 use crate::format;

-use crate::format::FormatCudaObject;

+use cuda_types::CUmodule;

+use cuda_types::CUuuid;

 

 use super::CUresult;

 use super::Settings;

-use std::borrow::Cow;

 use std::error::Error;

 use std::ffi::c_void;

-use std::ffi::FromBytesWithNulError;

 use std::ffi::NulError;

 use std::fmt::Display;

 use std::fs::File;

@@ -185,8 +182,9 @@ impl Factory {
     pub(crate) fn get_first_logger_and_init_settings(

         &mut self,

         func: &'static str,

+        arguments_writer: Box<dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>>,

     ) -> (FunctionLogger, Settings) {

-        let mut first_logger = self.get_logger(func);

+        let mut first_logger = self.get_logger(func, arguments_writer);

         let settings = Settings::read_and_init(&mut first_logger);

         match Self::initalize_fallible_emitter(&settings) {

             Ok(fallible_emitter) => {

@@ -201,7 +199,11 @@ impl Factory {
         (first_logger, settings)

     }

 

-    pub(crate) fn get_logger(&mut self, func: &'static str) -> FunctionLogger {

+    pub(crate) fn get_logger(

+        &mut self,

+        func: &'static str,

+        arguments_writer: Box<dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>>,

+    ) -> FunctionLogger {

         FunctionLogger {

             result: None,

             name: CudaFunctionName::Normal(func),

@@ -209,12 +211,16 @@ impl Factory {
             infallible_emitter: &mut self.infallible_emitter,

             write_buffer: &mut self.write_buffer,

             log_queue: &mut self.log_queue,

-            finished_writing_args: false,

-            args_to_write: 0,

+            arguments_writer: Some(arguments_writer),

         }

     }

 

-    pub(crate) fn get_logger_dark_api(&mut self, guid: CUuuid, index: usize) -> FunctionLogger {

+    pub(crate) fn get_logger_dark_api(

+        &mut self,

+        guid: CUuuid,

+        index: usize,

+        arguments_writer: Option<Box<dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>>>,

+    ) -> FunctionLogger {

         FunctionLogger {

             result: None,

             name: CudaFunctionName::Dark { guid, index },

@@ -222,8 +228,7 @@ impl Factory {
             infallible_emitter: &mut self.infallible_emitter,

             write_buffer: &mut self.write_buffer,

             log_queue: &mut self.log_queue,

-            finished_writing_args: false,

-            args_to_write: 0,

+            arguments_writer,

         }

     }

 }

@@ -243,10 +248,9 @@ pub(crate) struct FunctionLogger<'a> {
     name: CudaFunctionName,

     infallible_emitter: &'a mut Box<dyn WriteTrailingZeroAware>,

     fallible_emitter: &'a mut Option<Box<dyn WriteTrailingZeroAware>>,

+    arguments_writer: Option<Box<dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>>>,

     write_buffer: &'a mut WriteBuffer,

     log_queue: &'a mut Vec<LogEntry>,

-    args_to_write: usize,

-    finished_writing_args: bool,

 }

 

 impl<'a> FunctionLogger<'a> {

@@ -261,22 +265,31 @@ impl<'a> FunctionLogger<'a> {
     }

 

     fn flush_log_queue_to_write_buffer(&mut self) {

-        // TODO: remove this once everything has been converted to dtailed logging

-        if !self.finished_writing_args {

-            self.begin_writing_arguments(0);

-            self.write_buffer.write("...) -> ");

+        self.write_buffer.start_line();

+        match self.name {

+            CudaFunctionName::Normal(fn_name) => self.write_buffer.write(fn_name),

+            CudaFunctionName::Dark { guid, index } => {

+                format::CudaDisplay::write(&guid, &mut self.write_buffer).ok();

+                write!(&mut self.write_buffer, "::{}", index).ok();

+            }

         }

-        if let Some(result) = self.result {

-            match format::stringify_CUresult(result) {

-                Some(text) => self.write_buffer.write(text),

-                None => write!(self.write_buffer, "{}", result.0).unwrap(),

+        match &mut self.arguments_writer {

+            Some(arg_writer) => {

+                arg_writer(&mut self.write_buffer).ok();

             }

+            None => {

+                self.write_buffer.write_all(b"(...)").ok();

+            }

+        }

+        self.write_buffer.write_all(b" -> ").ok();

+        if let Some(result) = self.result {

+            format::CudaDisplay::write(&result, self.write_buffer).ok();

         } else {

-            self.write_buffer.write("(UNKNOWN)");

+            self.write_buffer.write_all(b"UNKNOWN").ok();

         };

         self.write_buffer.end_line();

         for entry in self.log_queue.iter() {

-            write!(self.write_buffer, "    {}", entry).unwrap_or_else(|_| unreachable!());

+            write!(self.write_buffer, "    {}", entry).ok();

             self.write_buffer.end_line();

         }

         self.write_buffer.finish();

@@ -290,35 +303,6 @@ impl<'a> FunctionLogger<'a> {
         self.write_buffer.end_line();

         self.write_buffer.finish();

     }

-

-    pub(crate) fn begin_writing_arguments(&mut self, len: usize) {

-        self.args_to_write = len;

-        match self.name {

-            CudaFunctionName::Normal(fn_name) => self.write_buffer.write(fn_name),

-            CudaFunctionName::Dark { guid, index } => {

-                guid.write_post_execution(CUresult::CUDA_SUCCESS, &mut self.write_buffer);

-                write!(&mut self.write_buffer, "::{}", index).ok();

-            }

-        }

-        self.write_buffer.write("(")

-    }

-

-    pub(crate) fn write_single_argument<'x>(

-        &mut self,

-        result: CUresult,

-        arg: impl FormatCudaObject,

-    ) {

-        self.args_to_write -= 1;

-        arg.write_post_execution(result, self.write_buffer);

-        if self.args_to_write != 0 {

-            self.write_buffer.write(", ")

-        }

-    }

-

-    pub(crate) fn end_writing_arguments(&mut self) {

-        self.write_buffer.write(") -> ");

-        self.finished_writing_args = true;

-    }

 }

 

 impl<'a> Drop for FunctionLogger<'a> {

@@ -347,18 +331,12 @@ pub(crate) enum LogEntry {
         raw_image: *const c_void,

         kind: &'static str,

     },

-    MalformedFunctionName(Utf8Error),

-    FunctionParameter {

-        name: &'static str,

-        value: String,

-    },

     MalformedModulePath(Utf8Error),

     NonUtf8ModuleText(Utf8Error),

     NulInsideModuleText(NulError),

     ModuleParsingError(String),

     Lz4DecompressionFailure,

     UnknownExportTableFn,

-    UnknownModule(CUmodule),

     UnexpectedArgument {

         arg_name: &'static str,

         expected: Vec<UInt>,

@@ -406,7 +384,6 @@ impl Display for LogEntry {
             LogEntry::NulInsideModuleText(e) => e.fmt(f),

             LogEntry::Lz4DecompressionFailure => write!(f, "LZ4 decompression failure"),

             LogEntry::UnknownExportTableFn => write!(f, "Unknown export table function"),

-            LogEntry::UnknownModule(hmod) => write!(f, "Unknown module {:?}", hmod),

             LogEntry::UnexpectedBinaryField {

                 field_name,

                 expected,

@@ -437,8 +414,6 @@ impl Display for LogEntry {
                     .join(", "),

                 observed

             ),

-            LogEntry::MalformedFunctionName(e) => e.fmt(f),

-            LogEntry::FunctionParameter { name, value } => write!(f, "{}: {}", name, value),

         }

     }

 }

diff --git a/zluda_dump/src/os_win.rs b/zluda_dump/src/os_win.rs
index d80f6e6..c138cc0 100644
--- a/zluda_dump/src/os_win.rs
+++ b/zluda_dump/src/os_win.rs
@@ -1,8 +1,6 @@
 use std::{

-    ffi::{c_void, CStr, CString, OsString},

-    mem,

-    os::raw::c_ushort,

-    ptr,

+    ffi::{c_void, CStr},

+    mem, ptr,

 };

 

 use std::os::windows::io::AsRawHandle;

@@ -12,7 +10,7 @@ use winapi::{
     um::libloaderapi::{GetProcAddress, LoadLibraryW},

 };

 

-use crate::cuda::CUuuid;

+use cuda_types::CUuuid;

 

 pub(crate) const LIBCUDA_DEFAULT_PATH: &'static str = "C:\\Windows\\System32\\nvcuda.dll";

 const LOAD_LIBRARY_NO_REDIRECT: &'static [u8] = b"ZludaLoadLibraryW_NoRedirect\0";

diff --git a/zluda_dump/src/trace.rs b/zluda_dump/src/trace.rs
index 2afc1c5..59a0a0f 100644
--- a/zluda_dump/src/trace.rs
+++ b/zluda_dump/src/trace.rs
@@ -1,7 +1,8 @@
 use ptx::{ast::PtxError, Token};

 use ptx::{DisplayParseError, ModuleParserExt};

 

-use crate::{cuda::CUmodule, dark_api, log, Settings};

+use crate::{dark_api, log, Settings};

+use cuda_types::CUmodule;

 use std::{

     collections::HashMap,

     ffi::{c_void, CStr, CString},

@@ -171,7 +172,7 @@ impl StateTracker {
         submodule_index: Option<usize>,

         module_text: &str,

     ) {

-        let (ast, errors) = ptx::ModuleParser::parse_unchecked(module_text);

+        let (_ast, errors) = ptx::ModuleParser::parse_unchecked(module_text);

         if !errors.is_empty() {

             fn_logger.log(log::LogEntry::ModuleParsingError(

                 DumpWriter::get_file_name(module_index, version, submodule_index, "log"),

@@ -185,10 +186,6 @@ impl StateTracker {
             ));

         }

     }

-

-    pub(crate) fn module_exists(&self, hmod: CUmodule) -> bool {

-        self.modules.contains_key(&hmod)

-    }

 }

 

 struct ParsedModule {