format

afl/src/mutators/mutations.rs

@@ -33,18 +33,44 @@ where
 const ARITH_MAX: u64 = 35;
 
 const INTERESTING_8: [i8; 9] = [-128, -1, 0, 1, 16, 32, 64, 100, 127];
-const INTERESTING_16: [i16; 19] = [-128, -1, 0, 1, 16, 32, 64, 100, 127, -32768, -129, 128, 255, 256, 512, 1000, 1024, 4096, 32767];
+const INTERESTING_16: [i16; 19] = [
-const INTERESTING_32: [i32; 27] = [-128, -1, 0, 1, 16, 32, 64, 100, 127, -32768, -129, 128, 255, 256, 512, 1000, 1024, 4096, 32767, -2147483648, -100663046, -32769, 32768, 65535, 65536, 100663045, 2147483647];
+    -128, -1, 0, 1, 16, 32, 64, 100, 127, -32768, -129, 128, 255, 256, 512, 1000, 1024, 4096, 32767,
+];
+const INTERESTING_32: [i32; 27] = [
+    -128,
+    -1,
+    0,
+    1,
+    16,
+    32,
+    64,
+    100,
+    127,
+    -32768,
+    -129,
+    128,
+    255,
+    256,
+    512,
+    1000,
+    1024,
+    4096,
+    32767,
+    -2147483648,
+    -100663046,
+    -32769,
+    32768,
+    65535,
+    65536,
+    100663045,
+    2147483647,
+];
 
 fn self_mem_move(data: &mut [u8], from: usize, to: usize, len: usize) {
     debug_assert!(from + len <= data.len());
     debug_assert!(to + len <= data.len());
     let ptr = data.as_mut_ptr();
-    unsafe {
+    unsafe { core::ptr::copy(ptr.offset(from as isize), ptr.offset(to as isize), len) }
-        core::ptr::copy(ptr.offset(from as isize),
-        ptr.offset(to as isize),
-        len)
-    }
 }
 
 fn mem_move(dst: &mut [u8], src: &[u8], from: usize, to: usize, len: usize) {
@@ -53,18 +79,18 @@ fn mem_move(dst: &mut [u8], src: &[u8], from: usize, to: usize, len: usize) {
     let dst_ptr = dst.as_mut_ptr();
     let src_ptr = src.as_ptr();
     unsafe {
-        core::ptr::copy(src_ptr.offset(from as isize),
+        core::ptr::copy(
+            src_ptr.offset(from as isize),
             dst_ptr.offset(to as isize),
-        len)
+            len,
+        )
     }
 }
 
 fn mem_set(data: &mut [u8], from: usize, len: usize, val: u8) {
     debug_assert!(from + len <= data.len());
     let ptr = data.as_mut_ptr();
-    unsafe {
+    unsafe { core::ptr::write_bytes(ptr.offset(from as isize), val, len) }
-        core::ptr::write_bytes(ptr.offset(from as isize), val, len)
-    }
 }
 
 /// Bitflip mutation for inputs with a bytes vector
@@ -540,7 +566,11 @@ where
     }
 
     let val = input.bytes()[rand.below(size as u64) as usize];
-    let start = if size == 1 { 0 } else { rand.below(size as u64 -1) as usize };
+    let start = if size == 1 {
+        0
+    } else {
+        rand.below(size as u64 - 1) as usize
+    };
     let end = rand.below((size - start) as u64) as usize;
     mem_set(input.bytes_mut(), start, end - start, val);
     Ok(MutationResult::Mutated)
@@ -564,7 +594,11 @@ where
     }
 
     let val = rand.below(256) as u8;
-    let start = if size == 1 { 0 } else { rand.below(size as u64 -1) as usize };
+    let start = if size == 1 {
+        0
+    } else {
+        rand.below(size as u64 - 1) as usize
+    };
     let end = rand.below((size - start) as u64) as usize;
     mem_set(input.bytes_mut(), start, end - start, val);
     Ok(MutationResult::Mutated)
@@ -622,8 +656,6 @@ where
     Ok(MutationResult::Mutated)
 }
 
-
-
 /// Returns the first and last diff position between the given vectors, stopping at the min len
 fn locate_diffs(this: &[u8], other: &[u8]) -> (i64, i64) {
     let mut first_diff: i64 = -1;