Fix function_casts_as_integer "issues"

benches/normalize.rs

@@ -14,11 +14,11 @@ where
     M: Measurement,
 {
     let mut addrs = [
-        libc::atexit as Addr,
-        libc::chdir as Addr,
-        libc::fopen as Addr,
-        normalize_process_impl::<M> as Addr,
-        Normalizer::normalize_user_addrs as Addr,
+        libc::atexit as *const () as Addr,
+        libc::chdir as *const () as Addr,
+        libc::fopen as *const () as Addr,
+        normalize_process_impl::<M> as *const () as Addr,
+        Normalizer::normalize_user_addrs as *const () as Addr,
     ];
     let () = addrs.sort();
     let opts = NormalizeOpts {

benches/symbolize.rs

@@ -24,11 +24,11 @@ use criterion::BenchmarkGroup;
 fn symbolize_process() {
     let src = Source::Process(Process::new(Pid::Slf));
     let addrs = [
-        libc::atexit as Addr,
-        libc::chdir as Addr,
-        libc::fopen as Addr,
-        symbolize_process as Addr,
-        Symbolizer::symbolize_single as Addr,
+        libc::atexit as *const () as Addr,
+        libc::chdir as *const () as Addr,
+        libc::fopen as *const () as Addr,
+        symbolize_process as *const () as Addr,
+        Symbolizer::symbolize_single as *const () as Addr,
     ];
 
     let symbolizer = Symbolizer::new();

capi/benches/normalize.rs

@@ -16,11 +16,11 @@ use criterion::BenchmarkGroup;
 
 fn normalize_process_impl(read_build_ids: bool) {
     let mut addrs = [
-        libc::atexit as Addr,
-        libc::chdir as Addr,
-        libc::fopen as Addr,
-        blaze_normalizer_new_opts as Addr,
-        blaze_normalize_user_addrs_opts as Addr,
+        libc::atexit as *const () as Addr,
+        libc::chdir as *const () as Addr,
+        libc::fopen as *const () as Addr,
+        blaze_normalizer_new_opts as *const () as Addr,
+        blaze_normalize_user_addrs_opts as *const () as Addr,
     ];
     let () = addrs.sort();
 

capi/src/normalize.rs

@@ -1066,11 +1066,11 @@ mod tests {
         fn test(normalizer: *const blaze_normalizer) {
             let addrs = [
                 0x0,
-                libc::atexit as Addr,
-                libc::chdir as Addr,
-                libc::fopen as Addr,
-                elf_conversion as Addr,
-                normalize_user_addrs as Addr,
+                libc::atexit as *const () as Addr,
+                libc::chdir as *const () as Addr,
+                libc::fopen as *const () as Addr,
+                elf_conversion as *const () as Addr,
+                normalize_user_addrs as *const () as Addr,
             ];
 
             let result = unsafe {
@@ -1110,11 +1110,11 @@ mod tests {
 
     fn test_normalize_user_addrs_sorted(use_procmap_query: bool) {
         let mut addrs = [
-            libc::atexit as Addr,
-            libc::chdir as Addr,
-            libc::fopen as Addr,
-            elf_conversion as Addr,
-            normalize_user_addrs as Addr,
+            libc::atexit as *const () as Addr,
+            libc::chdir as *const () as Addr,
+            libc::fopen as *const () as Addr,
+            elf_conversion as *const () as Addr,
+            normalize_user_addrs as *const () as Addr,
         ];
         let () = addrs.sort();
 
@@ -1167,11 +1167,11 @@ mod tests {
     #[test]
     fn normalize_user_addrs_unsorted_failure() {
         let mut addrs = [
-            libc::atexit as Addr,
-            libc::chdir as Addr,
-            libc::fopen as Addr,
-            elf_conversion as Addr,
-            normalize_user_addrs as Addr,
+            libc::atexit as *const () as Addr,
+            libc::chdir as *const () as Addr,
+            libc::fopen as *const () as Addr,
+            elf_conversion as *const () as Addr,
+            normalize_user_addrs as *const () as Addr,
         ];
         let () = addrs.sort_by(|addr1, addr2| addr1.cmp(addr2).reverse());
 
@@ -1344,7 +1344,10 @@ mod tests {
     fn normalize_local_vdso_address() {
         use libc::gettimeofday;
 
-        let addrs = [normalize_local_vdso_address as Addr, gettimeofday as Addr];
+        let addrs = [
+            normalize_local_vdso_address as *const () as Addr,
+            gettimeofday as *const () as Addr,
+        ];
         let normalizer = blaze_normalizer_new();
         assert!(!normalizer.is_null());
 

capi/src/symbolize.rs

@@ -2071,7 +2071,7 @@ mod tests {
         };
 
         let symbolizer = blaze_symbolizer_new();
-        let addrs = [blaze_symbolizer_new as Addr];
+        let addrs = [blaze_symbolizer_new as *const () as Addr];
         let result = unsafe {
             blaze_symbolize_process_abs_addrs(symbolizer, &process_src, addrs.as_ptr(), addrs.len())
         };
@@ -2110,7 +2110,7 @@ mod tests {
             perf_map: true,
             ..Default::default()
         };
-        let addrs = [blaze_symbolizer_new as Addr];
+        let addrs = [blaze_symbolizer_new as *const () as Addr];
         let result = unsafe {
             blaze_symbolize_process_abs_addrs(symbolizer, &src, addrs.as_ptr(), addrs.len())
         };
@@ -2183,7 +2183,7 @@ mod tests {
         };
 
         let symbolizer = blaze_symbolizer_new();
-        let addrs = [blaze_symbolizer_new as Addr];
+        let addrs = [blaze_symbolizer_new as *const () as Addr];
         let result = unsafe {
             blaze_symbolize_elf_virt_offsets(symbolizer, &elf_src, addrs.as_ptr(), addrs.len())
         };

examples/normalize-virt-offset.rs

@@ -16,7 +16,7 @@ use blazesym::Pid;
 fn main() {
     let normalizer = Normalizer::new();
     let normalized = normalizer
-        .normalize_user_addrs(Pid::Slf, [main as Addr].as_slice())
+        .normalize_user_addrs(Pid::Slf, [main as *const () as Addr].as_slice())
         .unwrap();
     assert_eq!(normalized.outputs.len(), 1);
 

src/normalize/ioctl.rs

@@ -314,7 +314,7 @@ mod tests {
             let pid = Pid::Slf;
             let path = format!("/proc/{pid}/maps");
             let file = File::open(path).unwrap();
-            let addr = valid_vma_querying_ioctl as Addr;
+            let addr = valid_vma_querying_ioctl as *const () as Addr;
             let entry = query_procmap(&file, pid, addr, build_ids).unwrap().unwrap();
             assert!(
                 entry.range.contains(&addr),

tests/allocs.rs

@@ -66,11 +66,11 @@ fn normalize_process() {
     {
         let normalizer = Normalizer::builder().build();
         let mut addrs = [
-            libc::atexit as Addr,
-            libc::chdir as Addr,
-            libc::fopen as Addr,
-            normalize_process as Addr,
-            Normalizer::normalize_user_addrs as Addr,
+            libc::atexit as *const () as Addr,
+            libc::chdir as *const () as Addr,
+            libc::fopen as *const () as Addr,
+            normalize_process as *const () as Addr,
+            Normalizer::normalize_user_addrs as *const () as Addr,
         ];
         let () = addrs.sort();
 

tests/suite/normalize.rs

@@ -36,9 +36,9 @@ use crate::suite::common::RemoteProcess;
 #[test]
 fn normalize_unsorted_err() {
     let mut addrs = [
-        libc::atexit as Addr,
-        libc::chdir as Addr,
-        libc::fopen as Addr,
+        libc::atexit as *const () as Addr,
+        libc::chdir as *const () as Addr,
+        libc::fopen as *const () as Addr,
     ];
     let () = addrs.sort();
     let () = addrs.swap(0, 1);
@@ -86,18 +86,18 @@ fn normalize_unknown_addrs() {
 fn normalization_self() {
     fn test(normalizer: &Normalizer) {
         let addrs = [
-            libc::__errno_location as Addr,
-            libc::dlopen as Addr,
-            libc::fopen as Addr,
-            normalize_unknown_addrs as Addr,
-            normalization_self as Addr,
-            normalize::Normalizer::new as Addr,
+            libc::__errno_location as *const () as Addr,
+            libc::dlopen as *const () as Addr,
+            libc::fopen as *const () as Addr,
+            normalize_unknown_addrs as *const () as Addr,
+            normalization_self as *const () as Addr,
+            normalize::Normalizer::new as *const () as Addr,
         ];
 
         let (errno_idx, _) = addrs
             .iter()
             .enumerate()
-            .find(|(_idx, addr)| **addr == libc::__errno_location as Addr)
+            .find(|(_idx, addr)| **addr == libc::__errno_location as *const () as Addr)
             .unwrap();
 
         let normalized = normalizer
@@ -460,7 +460,7 @@ fn normalize_no_self_vma_path_reporting() {
     let normalized = normalizer
         .normalize_user_addrs_opts(
             Pid::Slf,
-            [normalize_no_self_vma_path_reporting as Addr].as_slice(),
+            [normalize_no_self_vma_path_reporting as *const () as Addr].as_slice(),
             &opts,
         )
         .unwrap();
@@ -505,7 +505,7 @@ fn normalize_process_symbolic_paths() {
 fn normalize_local_vdso_address() {
     use libc::gettimeofday;
 
-    let addrs = [gettimeofday as Addr];
+    let addrs = [gettimeofday as *const () as Addr];
     let normalizer = Normalizer::new();
     let normalized = normalizer.normalize_user_addrs(Pid::Slf, &addrs).unwrap();
     assert_eq!(normalized.outputs.len(), 1);

tests/suite/symbolize.rs

@@ -936,7 +936,10 @@ fn symbolize_rust_dwp() {
 #[test]
 fn symbolize_process() {
     let src = Source::Process(Process::new(Pid::Slf));
-    let addrs = [symbolize_process as Addr, Symbolizer::symbolize as Addr];
+    let addrs = [
+        symbolize_process as *const () as Addr,
+        Symbolizer::symbolize as *const () as Addr,
+    ];
     let symbolizer = Symbolizer::new();
     let results = symbolizer
         .symbolize(&src, Input::AbsAddr(&addrs))
@@ -1107,8 +1110,8 @@ fn symbolize_process_with_custom_dispatch() {
     fn test(dispatcher: impl ProcessDispatch + 'static) {
         let src = Source::Process(Process::new(Pid::Slf));
         let addrs = [
-            symbolize_process as Addr,
-            symbolize_process_with_custom_dispatch as Addr,
+            symbolize_process as *const () as Addr,
+            symbolize_process_with_custom_dispatch as *const () as Addr,
         ];
         let symbolizer = Symbolizer::builder()
             .set_process_dispatcher(dispatcher)
@@ -1146,7 +1149,10 @@ fn symbolize_own_process_vdso() {
     let src = Source::Process(Process::new(Pid::Slf));
     // Both functions are typically provided by the vDSO, though there
     // is no guarantee of that.
-    let addrs = [gettimeofday as Addr, clock_gettime as Addr];
+    let addrs = [
+        gettimeofday as *const () as Addr,
+        clock_gettime as *const () as Addr,
+    ];
     let symbolizer = Symbolizer::new();
 
     // Symbolize twice, to exercise both cache population and cache