Dump function names and allow overriding result of cuDeviceComputeCapability

zluda_dump/src/cuda.rs

@@ -2355,12 +2355,13 @@ extern_redirect! {
         dev: CUdevice,
     ) -> CUresult;
 }
-extern_redirect! {
+extern_redirect_with_post! {
     pub fn cuDeviceGetAttribute(
         pi: *mut ::std::os::raw::c_int,
         attrib: CUdevice_attribute,
         dev: CUdevice,
     ) -> CUresult;
+    super::cuDeviceGetAttribute_Post;
 }
 extern_redirect! {
     pub fn cuDeviceGetNvSciSyncAttributes(
@@ -2372,12 +2373,13 @@ extern_redirect! {
 extern_redirect! {
     pub fn cuDeviceGetProperties(prop: *mut CUdevprop, dev: CUdevice) -> CUresult;
 }
-extern_redirect! {
+extern_redirect_with_post! {
     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! {
     pub fn cuDevicePrimaryCtxRetain(pctx: *mut CUcontext, dev: CUdevice) -> CUresult;

zluda_dump/src/lib.rs

@@ -182,6 +182,7 @@ impl GlobalDelayedState {
 struct Settings {
     dump_dir: Option<PathBuf>,
     libcuda_path: String,
+    override_cc_major: Option<u32>,
 }
 
 impl Settings {
@@ -191,7 +192,7 @@ impl Settings {
             Ok(Some(dir)) => {
                 logger.log(log::LogEntry::CreatedDumpDirectory(dir.clone()));
                 Some(dir)
-            },
+            }
             Ok(None) => None,
             Err(err) => {
                 logger.log(log::LogEntry::ErrorBox(err));
@@ -206,9 +207,24 @@ impl Settings {
             }
             Ok(env_string) => env_string,
         };
+        let override_cc_major = match env::var("ZLUDA_OVERRIDE_COMPUTE_CAPABILITY_MAJOR") {
+            Err(env::VarError::NotPresent) => None,
+            Err(e) => {
+                logger.log(log::LogEntry::ErrorBox(Box::new(e) as _));
+                None
+            }
+            Ok(env_string) => match str::parse::<u32>(&*env_string) {
+                Err(e) => {
+                    logger.log(log::LogEntry::ErrorBox(Box::new(e) as _));
+                    None
+                }
+                Ok(cc) => Some(cc),
+            },
+        };
         Settings {
             dump_dir,
             libcuda_path,
+            override_cc_major,
         }
     }
 
@@ -1471,4 +1487,40 @@ pub(crate) fn cuModuleGetFunction_Post(
     if !state.module_exists(hmod) {
         fn_logger.log(log::LogEntry::UnknownModule(hmod))
     }
+    match unsafe { CStr::from_ptr(name) }.to_str() {
+        Ok(str) => fn_logger.log(log::LogEntry::FunctionParameter {
+            name: "name",
+            value: str.to_string(),
+        }),
+        Err(e) => fn_logger.log(log::LogEntry::MalformedFunctionName(e)),
+    }
+}
+
+#[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,
+) {
+    fn_logger.log(log::LogEntry::FunctionParameter {
+        name: "attrib",
+        value: attrib.0.to_string(),
+    });
+}
+
+#[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,
+    state: &mut trace::StateTracker,
+    result: CUresult,
+) {
+    if let Some(major_ver_override) = state.override_cc_major {
+        unsafe { *major = major_ver_override as i32 };
+    }
 }

zluda_dump/src/log.rs

@@ -302,6 +302,11 @@ 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),
@@ -377,6 +382,8 @@ impl Display for LogEntry {
                 expected,
                 observed,
             } => write!(f, "Unexected argument"),
+            LogEntry::MalformedFunctionName(e) => e.fmt(f),
+            LogEntry::FunctionParameter { name, value } => write!(f, "{}: {}", name, value),
         }
     }
 }

zluda_dump/src/trace.rs

@@ -21,6 +21,7 @@ pub(crate) struct StateTracker {
     submodule_counter: usize,
     last_module_version: Option<usize>,
     pub(crate) dark_api: dark_api::DarkApiState,
+    pub(crate) override_cc_major: Option<u32>,
 }
 
 impl StateTracker {
@@ -32,6 +33,7 @@ impl StateTracker {
             submodule_counter: 0,
             last_module_version: None,
             dark_api: dark_api::DarkApiState::new(),
+            override_cc_major: settings.override_cc_major,
         }
     }