fix ci for latest clippy version (#239)

* clippy

* fix ubuntu as well

libafl/src/bolts/staterestore.rs

@@ -173,7 +173,7 @@ where
                     &filename
                 )));
             }
-            state = &file_content
+            state = &file_content;
         }
         let deserialized = postcard::from_bytes(state)?;
         Ok(Some(deserialized))

libafl/src/mutators/mopt_mutator.rs

@@ -189,7 +189,7 @@ impl MOpt {
             }
 
             for i in 0..self.operator_num {
-                self.x_now[swarm][i] /= total_x_now
+                self.x_now[swarm][i] /= total_x_now;
             }
 
             for i in 0..self.operator_num {
@@ -208,7 +208,7 @@ impl MOpt {
                     self.x_now[swarm][i] = V_MIN;
                 }
 
-                x_sum += self.x_now[swarm][i]
+                x_sum += self.x_now[swarm][i];
             }
 
             for i in 0..self.operator_num {
@@ -471,7 +471,7 @@ where
                                 as f64)
                                 / ((mopt.pilot_operator_cycles_v2[swarm_now][i]
                                     - mopt.pilot_operator_cycles[swarm_now][i])
-                                    as f64)
+                                    as f64);
                         }
 
                         if mopt.eff_best[swarm_now][i] < eff {
@@ -496,7 +496,7 @@ where
                         for i in 0..mopt.operator_num {
                             mopt.core_operator_cycles_v2[i] = mopt.core_operator_cycles[i];
                             mopt.core_operator_cycles_v3[i] = mopt.core_operator_cycles[i];
-                            mopt.core_operator_finds_v2[i] = mopt.core_operator_finds[i]
+                            mopt.core_operator_finds_v2[i] = mopt.core_operator_finds[i];
                         }
 
                         let mut swarm_eff = 0.0;

libafl/src/stages/power.rs

@@ -350,7 +350,7 @@ where
                         }
                         f if f >= 8.0 => {
                             if !favored {
-                                factor = 0.4
+                                factor = 0.4;
                             }
                         }
                         _ => {

libafl_frida/src/lib.rs

@@ -126,7 +126,7 @@ impl FridaOptions {
                         }
 
                         if !cfg!(feature = "cmplog") && options.enable_cmplog {
-                            panic!("cmplog feature is disabled!")
+                            panic!("cmplog feature is disabled!");
                         }
                     }
                     "cmplog-cores" => {

libafl_qemu/src/emu.rs

@@ -179,7 +179,9 @@ impl Iterator for GuestMaps {
 
 impl Drop for GuestMaps {
     fn drop(&mut self) {
-        unsafe { free_self_maps(self.orig_c_iter) }
+        unsafe {
+            free_self_maps(self.orig_c_iter);
+        }
     }
 }
 
@@ -190,7 +192,7 @@ pub fn write_mem<T>(addr: u64, buf: &[T]) {
             buf.as_ptr() as *const _ as *const u8,
             host_addr,
             buf.len() * size_of::<T>(),
-        )
+        );
     }
 }
 
@@ -201,7 +203,7 @@ pub fn read_mem<T>(addr: u64, buf: &mut [T]) {
             host_addr as *const u8,
             buf.as_mut_ptr() as *mut _ as *mut u8,
             buf.len() * size_of::<T>(),
-        )
+        );
     }
 }
 
@@ -240,15 +242,21 @@ where
 }
 
 pub fn set_breakpoint(addr: u64) {
-    unsafe { libafl_qemu_set_breakpoint(addr) };
+    unsafe {
+        libafl_qemu_set_breakpoint(addr);
+    }
 }
 
 pub fn remove_breakpoint(addr: u64) {
-    unsafe { libafl_qemu_remove_breakpoint(addr) };
+    unsafe {
+        libafl_qemu_remove_breakpoint(addr);
+    }
 }
 
 pub fn run() {
-    unsafe { libafl_qemu_run() };
+    unsafe {
+        libafl_qemu_run();
+    }
 }
 
 #[must_use]
@@ -298,91 +306,135 @@ pub fn unmap(addr: u64, size: usize) -> Result<(), String> {
 }
 
 pub fn set_exec_edge_hook(hook: extern "C" fn(id: u64)) {
-    unsafe { libafl_exec_edge_hook = hook };
+    unsafe {
+        libafl_exec_edge_hook = hook;
+    }
 }
 
 pub fn set_gen_edge_hook(hook: extern "C" fn(src: u64, dest: u64) -> u64) {
-    unsafe { libafl_gen_edge_hook = hook };
+    unsafe {
+        libafl_gen_edge_hook = hook;
+    }
 }
 
 pub fn set_exec_block_hook(hook: extern "C" fn(pc: u64)) {
-    unsafe { libafl_exec_block_hook = hook };
+    unsafe {
+        libafl_exec_block_hook = hook;
+    }
 }
 
 pub fn set_gen_block_hook(hook: extern "C" fn(pc: u64) -> u64) {
-    unsafe { libafl_gen_block_hook = hook };
+    unsafe {
+        libafl_gen_block_hook = hook;
+    }
 }
 
 pub fn set_exec_read1_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_read_hook1 = hook };
+    unsafe {
+        libafl_exec_read_hook1 = hook;
+    }
 }
 
 pub fn set_exec_read2_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_read_hook2 = hook };
+    unsafe {
+        libafl_exec_read_hook2 = hook;
+    }
 }
 
 pub fn set_exec_read4_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_read_hook4 = hook };
+    unsafe {
+        libafl_exec_read_hook4 = hook;
+    }
 }
 
 pub fn set_exec_read8_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_read_hook8 = hook };
+    unsafe {
+        libafl_exec_read_hook8 = hook;
+    }
 }
 
 pub fn set_exec_read_n_hook(hook: extern "C" fn(id: u64, addr: u64, size: u32)) {
-    unsafe { libafl_exec_read_hookN = hook };
+    unsafe {
+        libafl_exec_read_hookN = hook;
+    }
 }
 
 pub fn set_gen_read_hook(hook: extern "C" fn(size: u32) -> u64) {
-    unsafe { libafl_gen_read_hook = hook };
+    unsafe {
+        libafl_gen_read_hook = hook;
+    }
 }
 
 pub fn set_exec_write1_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_write_hook1 = hook };
+    unsafe {
+        libafl_exec_write_hook1 = hook;
+    }
 }
 
 pub fn set_exec_write2_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_write_hook2 = hook };
+    unsafe {
+        libafl_exec_write_hook2 = hook;
+    }
 }
 
 pub fn set_exec_write4_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_write_hook4 = hook };
+    unsafe {
+        libafl_exec_write_hook4 = hook;
+    }
 }
 
 pub fn set_exec_write8_hook(hook: extern "C" fn(id: u64, addr: u64)) {
-    unsafe { libafl_exec_write_hook8 = hook };
+    unsafe {
+        libafl_exec_write_hook8 = hook;
+    }
 }
 
 pub fn set_exec_write_n_hook(hook: extern "C" fn(id: u64, addr: u64, size: u32)) {
-    unsafe { libafl_exec_write_hookN = hook };
+    unsafe {
+        libafl_exec_write_hookN = hook;
+    }
 }
 
 pub fn set_gen_write_hook(hook: extern "C" fn(size: u32) -> u64) {
-    unsafe { libafl_gen_write_hook = hook };
+    unsafe {
+        libafl_gen_write_hook = hook;
+    }
 }
 
 pub fn set_exec_cmp1_hook(hook: extern "C" fn(id: u64, v0: u8, v1: u8)) {
-    unsafe { libafl_exec_cmp_hook1 = hook };
+    unsafe {
+        libafl_exec_cmp_hook1 = hook;
+    }
 }
 
 pub fn set_exec_cmp2_hook(hook: extern "C" fn(id: u64, v0: u16, v1: u16)) {
-    unsafe { libafl_exec_cmp_hook2 = hook };
+    unsafe {
+        libafl_exec_cmp_hook2 = hook;
+    }
 }
 
 pub fn set_exec_cmp4_hook(hook: extern "C" fn(id: u64, v0: u32, v1: u32)) {
-    unsafe { libafl_exec_cmp_hook4 = hook };
+    unsafe {
+        libafl_exec_cmp_hook4 = hook;
+    }
 }
 
 pub fn set_exec_cmp8_hook(hook: extern "C" fn(id: u64, v0: u64, v1: u64)) {
-    unsafe { libafl_exec_cmp_hook8 = hook };
+    unsafe {
+        libafl_exec_cmp_hook8 = hook;
+    }
 }
 
 pub fn set_gen_cmp_hook(hook: extern "C" fn(pc: u64, size: u32) -> u64) {
-    unsafe { libafl_gen_cmp_hook = hook };
+    unsafe {
+        libafl_gen_cmp_hook = hook;
+    }
 }
 
 pub fn set_syscall_hook(
     hook: extern "C" fn(i32, u64, u64, u64, u64, u64, u64, u64, u64) -> SyscallHookResult,
 ) {
-    unsafe { libafl_syscall_hook = hook };
+    unsafe {
+        libafl_syscall_hook = hook;
+    }
 }

libafl_qemu/src/executor.rs

@@ -105,7 +105,9 @@ where
 
     #[allow(clippy::unused_self)]
     pub fn hook_edge_generation(&self, hook: fn(&mut S, src: u64, dest: u64) -> Option<u64>) {
-        unsafe { GEN_EDGE_HOOK_PTR = hook as *const _ };
+        unsafe {
+            GEN_EDGE_HOOK_PTR = hook as *const _;
+        }
         emu::set_gen_edge_hook(gen_edge_hook_wrapper::<S>);
     }
 
@@ -116,7 +118,9 @@ where
 
     #[allow(clippy::unused_self)]
     pub fn hook_block_generation(&self, hook: fn(&mut S, pc: u64) -> Option<u64>) {
-        unsafe { GEN_BLOCK_HOOK_PTR = hook as *const _ };
+        unsafe {
+            GEN_BLOCK_HOOK_PTR = hook as *const _;
+        }
         emu::set_gen_block_hook(gen_block_hook_wrapper::<S>);
     }
 
@@ -127,7 +131,9 @@ where
 
     #[allow(clippy::unused_self)]
     pub fn hook_read_generation(&self, hook: fn(&mut S, size: usize) -> Option<u64>) {
-        unsafe { GEN_READ_HOOK_PTR = hook as *const _ };
+        unsafe {
+            GEN_READ_HOOK_PTR = hook as *const _;
+        }
         emu::set_gen_read_hook(gen_read_hook_wrapper::<S>);
     }
 
@@ -158,7 +164,9 @@ where
 
     #[allow(clippy::unused_self)]
     pub fn hook_write_generation(&self, hook: fn(&mut S, size: usize) -> Option<u64>) {
-        unsafe { GEN_WRITE_HOOK_PTR = hook as *const _ };
+        unsafe {
+            GEN_WRITE_HOOK_PTR = hook as *const _;
+        }
         emu::set_gen_write_hook(gen_write_hook_wrapper::<S>);
     }
 
@@ -189,7 +197,9 @@ where
 
     #[allow(clippy::unused_self)]
     pub fn hook_cmp_generation(&self, hook: fn(&mut S, pc: u64, size: usize) -> Option<u64>) {
-        unsafe { GEN_CMP_HOOK_PTR = hook as *const _ };
+        unsafe {
+            GEN_CMP_HOOK_PTR = hook as *const _;
+        }
         emu::set_gen_cmp_hook(gen_cmp_hook_wrapper::<S>);
     }
 

libafl_qemu/src/hooks.rs

@@ -60,17 +60,23 @@ where
         Some(*meta.map.get(&(src, dest)).unwrap())
     } else {
         meta.current_id = ((id + 1) & (EDGES_MAP_SIZE - 1)) as u64;
-        unsafe { MAX_EDGES_NUM = meta.current_id as usize };
+        unsafe {
+            MAX_EDGES_NUM = meta.current_id as usize;
+        }
         Some(id as u64)
     }
 }
 
 pub extern "C" fn trace_edge_hitcount(id: u64) {
-    unsafe { EDGES_MAP[id as usize] += 1 };
+    unsafe {
+        EDGES_MAP[id as usize] += 1;
+    }
 }
 
 pub extern "C" fn trace_edge_single(id: u64) {
-    unsafe { EDGES_MAP[id as usize] = 1 };
+    unsafe {
+        EDGES_MAP[id as usize] = 1;
+    }
 }
 
 pub fn gen_unique_cmp_ids<S>(state: &mut S, pc: u64, _size: usize) -> Option<u64>
@@ -94,17 +100,25 @@ where
 }
 
 pub extern "C" fn trace_cmp1_cmplog(id: u64, v0: u8, v1: u8) {
-    unsafe { __libafl_targets_cmplog_instructions(id as usize, 1, u64::from(v0), u64::from(v1)) }
+    unsafe {
+        __libafl_targets_cmplog_instructions(id as usize, 1, u64::from(v0), u64::from(v1));
+    }
 }
 
 pub extern "C" fn trace_cmp2_cmplog(id: u64, v0: u16, v1: u16) {
-    unsafe { __libafl_targets_cmplog_instructions(id as usize, 2, u64::from(v0), u64::from(v1)) }
+    unsafe {
+        __libafl_targets_cmplog_instructions(id as usize, 2, u64::from(v0), u64::from(v1));
+    }
 }
 
 pub extern "C" fn trace_cmp4_cmplog(id: u64, v0: u32, v1: u32) {
-    unsafe { __libafl_targets_cmplog_instructions(id as usize, 4, u64::from(v0), u64::from(v1)) }
+    unsafe {
+        __libafl_targets_cmplog_instructions(id as usize, 4, u64::from(v0), u64::from(v1));
+    }
 }
 
 pub extern "C" fn trace_cmp8_cmplog(id: u64, v0: u64, v1: u64) {
-    unsafe { __libafl_targets_cmplog_instructions(id as usize, 8, v0, v1) }
+    unsafe {
+        __libafl_targets_cmplog_instructions(id as usize, 8, v0, v1);
+    }
 }

libafl_sugar/src/inmemory.rs

@@ -194,7 +194,7 @@ where
                     state
                         .load_initial_inputs(&mut fuzzer, &mut executor, &mut mgr, &self.input_dirs)
                         .unwrap_or_else(|_| {
-                            panic!("Failed to load initial corpus at {:?}", &self.input_dirs)
+                            panic!("Failed to load initial corpus at {:?}", &self.input_dirs);
                         });
                     println!("We imported {} inputs from disk.", state.corpus().count());
                 }

libafl_sugar/src/qemu.rs

@@ -220,7 +220,7 @@ where
                     state
                         .load_initial_inputs(&mut fuzzer, &mut executor, &mut mgr, &self.input_dirs)
                         .unwrap_or_else(|_| {
-                            panic!("Failed to load initial corpus at {:?}", &self.input_dirs)
+                            panic!("Failed to load initial corpus at {:?}", &self.input_dirs);
                         });
                     println!("We imported {} inputs from disk.", state.corpus().count());
                 }