Fixing clippy issues

Author: udesou

mmtk/build.rs

@@ -11,7 +11,7 @@ fn main() {
 
     let mmtk_dir = match std::env::var(mmtk_dir_key) {
         Ok(mmtk_val) => mmtk_val,
-        _ => format!(".."),
+        _ => "..".to_string(),
     };
 
     // If bindings file already exists, no need to do anything

mmtk/src/active_plan.rs

@@ -18,7 +18,7 @@ pub struct JuliaMutatorIterator<'a> {
 
 impl<'a> JuliaMutatorIterator<'a> {
     fn new(guard: RwLockReadGuard<'a, HashMap<Address, Address>>) -> Self {
-        let vec = guard.keys().map(|addr| *addr).collect();
+        let vec = guard.keys().copied().collect();
         Self {
             _guard: guard,
             vec,
@@ -49,7 +49,7 @@ impl ActivePlan<JuliaVM> for VMActivePlan {
 
     fn is_mutator(tls: VMThread) -> bool {
         // FIXME have a tls field to check whether it is a mutator tls
-        MUTATORS.read().unwrap().keys().find(|mutator_addr| unsafe { &*mutator_addr.to_mut_ptr::<Mutator<JuliaVM>>() }.mutator_tls.0 == tls).is_some()
+        MUTATORS.read().unwrap().keys().any(|mutator_addr| unsafe { &*mutator_addr.to_mut_ptr::<Mutator<JuliaVM>>() }.mutator_tls.0 == tls)
     }
 
     fn mutator(_tls: VMMutatorThread) -> &'static mut Mutator<JuliaVM> {
@@ -67,7 +67,7 @@ impl ActivePlan<JuliaVM> for VMActivePlan {
         _worker: &mut GCWorker<JuliaVM>,
     ) -> ObjectReference {
         queue.enqueue(object);
-        return object;
+        object
     }
 }
 
@@ -80,17 +80,17 @@ pub extern "C" fn mmtk_new_mutator_iterator() -> *mut JuliaMutatorIterator<'stat
 }
 
 #[no_mangle]
-pub extern "C" fn mmtk_get_next_mutator_tls(
+pub unsafe extern "C" fn mmtk_get_next_mutator_tls(
     iter: *mut JuliaMutatorIterator<'static>,
 ) -> OpaquePointer {
-    match unsafe { iter.as_mut() }.unwrap().next() {
+    match { iter.as_mut() }.unwrap().next() {
         Some(m) => m.mutator_tls.0 .0,
         None => OpaquePointer::from_address(Address::ZERO),
     }
 }
 
 #[no_mangle]
-pub extern "C" fn mmtk_close_mutator_iterator(iter: *mut JuliaMutatorIterator<'static>) {
+pub unsafe extern "C" fn mmtk_close_mutator_iterator(iter: *mut JuliaMutatorIterator<'static>) {
     // The boxed pointer will get dropped
     let _to_drop = unsafe { Box::from_raw(iter) };
 }

mmtk/src/api.rs

@@ -52,27 +52,27 @@ pub extern "C" fn mmtk_gc_init(
         }
 
         // Set heap size
-        let success;
-        if min_heap_size != 0 {
-            info!(
-                "Setting mmtk heap size to a variable size with min-max of {}-{} (in bytes)",
-                min_heap_size, max_heap_size
-            );
-            success = builder.options.gc_trigger.set(
-                mmtk::util::options::GCTriggerSelector::DynamicHeapSize(
-                    min_heap_size,
-                    max_heap_size,
-                ),
-            );
-        } else {
-            info!(
-                "Setting mmtk heap size to a fixed max of {} (in bytes)",
-                max_heap_size
-            );
-            success = builder.options.gc_trigger.set(
-                mmtk::util::options::GCTriggerSelector::FixedHeapSize(max_heap_size),
-            );
-        }
+        let success =
+            if min_heap_size != 0 {
+                info!(
+                    "Setting mmtk heap size to a variable size with min-max of {}-{} (in bytes)",
+                    min_heap_size, max_heap_size
+                );
+                builder.options.gc_trigger.set(
+                    mmtk::util::options::GCTriggerSelector::DynamicHeapSize(
+                        min_heap_size,
+                        max_heap_size,
+                    ),
+                )
+            } else {
+                info!(
+                    "Setting mmtk heap size to a fixed max of {} (in bytes)",
+                    max_heap_size
+                );
+                builder.options.gc_trigger.set(
+                    mmtk::util::options::GCTriggerSelector::FixedHeapSize(max_heap_size),
+                )
+            };
         assert!(
             success,
             "Failed to set heap size to {}-{}",

mmtk/src/collection.rs

@@ -61,7 +61,7 @@ impl Collection<JuliaVM> for VMCollection {
         AtomicBool::store(&BLOCK_FOR_GC, false, Ordering::SeqCst);
         AtomicBool::store(&WORLD_HAS_STOPPED, false, Ordering::SeqCst);
 
-        let &(_, ref cvar) = &*STW_COND.clone();
+        let (_, cvar) = &*STW_COND.clone();
         cvar.notify_all();
 
         info!(
@@ -109,7 +109,7 @@ impl Collection<JuliaVM> for VMCollection {
     }
 
     fn is_collection_enabled() -> bool {
-        unsafe { jl_get_gc_disable_counter() <= 0 }
+        unsafe { jl_get_gc_disable_counter() == 0 }
     }
 }
 
@@ -124,7 +124,7 @@ pub fn is_current_gc_nursery() -> bool {
 pub extern "C" fn mmtk_block_thread_for_gc() {
     AtomicBool::store(&BLOCK_FOR_GC, true, Ordering::SeqCst);
 
-    let &(ref lock, ref cvar) = &*STW_COND.clone();
+    let (lock, cvar) = &*STW_COND.clone();
     let mut count = lock.lock().unwrap();
 
     info!("Blocking for GC!");

mmtk/src/julia_finalizer.rs

@@ -75,7 +75,7 @@ impl ArrayListT {
     // Some arraylist_t pointers used in finalizer implementation.
 
     /// ptls->finalizers: new finalizers are registered into this thread local list
-    fn thread_local_finalizer_list(mutator: &Mutator<JuliaVM>) -> &mut ArrayListT {
+    fn thread_local_finalizer_list(mutator: &mut Mutator<JuliaVM>) -> &mut ArrayListT {
         let list = unsafe { jl_gc_get_thread_finalizer_list(mutator.mutator_tls.0 .0) };
         unsafe { &mut *list.to_mut_ptr() }
     }

mmtk/src/julia_scanning.rs

@@ -57,7 +57,7 @@ pub unsafe fn mmtk_jl_to_typeof(t: Address) -> *const jl_datatype_t {
         let ty = jl_small_typeof[t_raw / std::mem::size_of::<Address>()];
         return ty;
     }
-    return t.to_ptr::<jl_datatype_t>();
+    t.to_ptr::<jl_datatype_t>()
 }
 
 const PRINT_OBJ_TYPE: bool = false;
@@ -177,10 +177,10 @@ pub unsafe fn scan_julia_object<SV: SlotVisitor<JuliaVMSlot>>(obj: Address, clos
                 process_slot(closure, slot);
                 obj8_begin = obj8_begin.shift::<u8>(1);
             }
-        } else if vtag_usize == ((jl_small_typeof_tags_jl_string_tag as usize) << 4) {
-            if PRINT_OBJ_TYPE {
-                println!("scan_julia_obj {}: string\n", obj);
-            }
+        } else if vtag_usize == ((jl_small_typeof_tags_jl_string_tag as usize) << 4)
+            && PRINT_OBJ_TYPE
+        {
+            println!("scan_julia_obj {}: string\n", obj);
         }
         return;
     } else {
@@ -310,9 +310,7 @@ pub unsafe fn scan_julia_object<SV: SlotVisitor<JuliaVMSlot>>(obj: Address, clos
 
     let layout = (*vt).layout;
     let npointers = (*layout).npointers;
-    if npointers == 0 {
-        return;
-    } else {
+    if npointers != 0 {
         if vt == jl_binding_partition_type {
             let bpart_ptr = obj.to_mut_ptr::<jl_binding_partition_t>();
             let restriction = (*bpart_ptr).restriction._M_i;
@@ -383,16 +381,16 @@ pub unsafe fn mmtk_scan_gcstack<EV: SlotVisitor<JuliaVMSlot>>(
     let copy_stack = (*ta).ctx.copy_stack_custom();
 
     #[cfg(feature = "julia_copy_stack")]
-    if stkbuf != std::ptr::null_mut() && copy_stack != 0 {
+    if !stkbuf.is_null() && copy_stack != 0 {
         let stkbuf_slot = Address::from_ptr(::std::ptr::addr_of!((*ta).ctx.stkbuf));
         process_slot(closure, stkbuf_slot);
     }
 
     let mut s = (*ta).gcstack;
-    let (mut offset, mut lb, mut ub) = (0 as isize, 0 as u64, u64::MAX);
+    let (mut offset, mut lb, mut ub) = (0_isize, 0_u64, u64::MAX);
 
     #[cfg(feature = "julia_copy_stack")]
-    if stkbuf != std::ptr::null_mut() && copy_stack != 0 && (*ta).ptls == std::ptr::null_mut() {
+    if !stkbuf.is_null() && copy_stack != 0 && (*ta).ptls.is_null() {
         if ((*ta).tid._M_i) < 0 {
             panic!("tid must be positive.")
         }
@@ -402,10 +400,10 @@ pub unsafe fn mmtk_scan_gcstack<EV: SlotVisitor<JuliaVMSlot>>(
         offset = (*ta).ctx.stkbuf as isize - lb as isize;
     }
 
-    if s != std::ptr::null_mut() {
+    if !s.is_null() {
         let s_nroots_addr = ::std::ptr::addr_of!((*s).nroots);
         let mut nroots = read_stack(Address::from_ptr(s_nroots_addr), offset, lb, ub);
-        debug_assert!(nroots.as_usize() as u32 <= std::u32::MAX);
+        debug_assert!(nroots.as_usize() as u32 <= u32::MAX);
         let mut nr = nroots >> 2;
 
         loop {
@@ -458,7 +456,7 @@ pub unsafe fn mmtk_scan_gcstack<EV: SlotVisitor<JuliaVMSlot>>(
     }
 
     // just call into C, since the code is cold
-    if (*ta).excstack != std::ptr::null_mut() {
+    if !(*ta).excstack.is_null() {
         jl_gc_scan_julia_exc_obj(
             Address::from_ptr(ta),
             Address::from_mut_ptr(closure),
@@ -477,9 +475,9 @@ unsafe fn read_stack(addr: Address, offset: isize, lb: u64, ub: u64) -> Address
 #[inline(always)]
 fn get_stack_addr(addr: Address, offset: isize, lb: u64, ub: u64) -> Address {
     if addr.as_usize() >= lb as usize && addr.as_usize() < ub as usize {
-        return addr + offset;
+        addr + offset
     } else {
-        return addr;
+        addr
     }
 }
 
@@ -532,14 +530,14 @@ pub fn mmtk_decode_restriction_value(pku: usize) -> usize {
         // need to apply (pku & ~0x7) to get the object to be traced
         // so we use (pku & 0x7) to get the offset from the object
         // and pass it to process_offset_slot
-        return pku & 0x7;
+        pku & 0x7
     }
 
     #[cfg(not(target_pointer_width = "64"))]
     {
         // when not #ifdef _P64 we simply return pku.val
         // i.e., the offset is 0, since val is the first field
-        return 0;
+        0
     }
 }
 
@@ -573,7 +571,7 @@ pub fn mmtk_jl_array_ndimwords(ndims: u32) -> usize {
         return 0;
     }
 
-    return (ndims - 2) as usize;
+    (ndims - 2) as usize
 }
 
 #[inline(always)]
@@ -602,7 +600,7 @@ pub unsafe fn mmtk_jl_svecref(vt: *mut jl_svec_t, i: usize) -> *const jl_datatyp
     let svec_data = mmtk_jl_svec_data(Address::from_mut_ptr(vt));
     let result_ptr = svec_data + i;
     let result = result_ptr.atomic_load::<AtomicUsize>(Ordering::Relaxed);
-    ::std::mem::transmute::<usize, *const jl_datatype_t>(result)
+    result as *const _jl_datatype_t
 }
 
 #[inline(always)]
@@ -624,32 +622,32 @@ pub unsafe fn mmtk_jl_fielddesc_size(fielddesc_type: u16) -> u32 {
 
 const JL_BT_NON_PTR_ENTRY: usize = usize::MAX;
 
-pub fn mmtk_jl_bt_is_native(bt_entry: *mut jl_bt_element_t) -> bool {
+pub unsafe fn mmtk_jl_bt_is_native(bt_entry: *mut jl_bt_element_t) -> bool {
     let entry = unsafe { (*bt_entry).__bindgen_anon_1.uintptr };
     entry != JL_BT_NON_PTR_ENTRY
 }
 
-pub fn mmtk_jl_bt_entry_size(bt_entry: *mut jl_bt_element_t) -> usize {
+pub unsafe fn mmtk_jl_bt_entry_size(bt_entry: *mut jl_bt_element_t) -> usize {
     if mmtk_jl_bt_is_native(bt_entry) {
         1
     } else {
         2 + mmtk_jl_bt_num_jlvals(bt_entry) + mmtk_jl_bt_num_uintvals(bt_entry)
     }
 }
 
-pub fn mmtk_jl_bt_num_jlvals(bt_entry: *mut jl_bt_element_t) -> usize {
+pub unsafe fn mmtk_jl_bt_num_jlvals(bt_entry: *mut jl_bt_element_t) -> usize {
     debug_assert!(!mmtk_jl_bt_is_native(bt_entry));
     let entry = unsafe { (*bt_entry.add(1)).__bindgen_anon_1.uintptr };
     entry & 0x7
 }
 
-pub fn mmtk_jl_bt_num_uintvals(bt_entry: *mut jl_bt_element_t) -> usize {
+pub unsafe fn mmtk_jl_bt_num_uintvals(bt_entry: *mut jl_bt_element_t) -> usize {
     debug_assert!(!mmtk_jl_bt_is_native(bt_entry));
     let entry = unsafe { (*bt_entry.add(1)).__bindgen_anon_1.uintptr };
     (entry >> 3) & 0x7
 }
 
-pub fn mmtk_jl_bt_entry_jlvalue(bt_entry: *mut jl_bt_element_t, i: usize) -> ObjectReference {
+pub unsafe fn mmtk_jl_bt_entry_jlvalue(bt_entry: *mut jl_bt_element_t, i: usize) -> ObjectReference {
     let entry = unsafe { (*bt_entry.add(2 + i)).__bindgen_anon_1.jlvalue };
     debug_assert!(!entry.is_null());
     unsafe { ObjectReference::from_raw_address_unchecked(Address::from_mut_ptr(entry)) }

mmtk/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::missing_safety_doc)]
+
 extern crate libc;
 extern crate log;
 extern crate mmtk;
@@ -31,6 +33,7 @@ pub mod julia_scanning;
 #[allow(improper_ctypes_definitions)]
 #[allow(non_upper_case_globals)]
 #[allow(non_snake_case)]
+#[allow(clippy::all)]
 pub mod julia_types;
 
 #[derive(Default)]

mmtk/src/object_model.rs

@@ -109,7 +109,7 @@ impl ObjectModel<JuliaVM> for VMObjectModel {
 
             Self::LOCAL_FORWARDING_BITS_SPEC.store_atomic::<JuliaVM, u8>(
                 from,
-                0b10 as u8, // BEING_FORWARDED
+                0b10_u8, // BEING_FORWARDED
                 None,
                 Ordering::SeqCst,
             );
@@ -126,8 +126,7 @@ impl ObjectModel<JuliaVM> for VMObjectModel {
         // not being called by objects in LOS
         debug_assert!(!is_object_in_los(&object));
 
-        let obj_size = unsafe { get_so_object_size(object) };
-        obj_size
+        unsafe { get_so_object_size(object) }
     }
 
     fn get_size_when_copied(_object: ObjectReference) -> usize {
@@ -152,12 +151,11 @@ impl ObjectModel<JuliaVM> for VMObjectModel {
 
     #[inline(always)]
     fn ref_to_object_start(object: ObjectReference) -> Address {
-        let res = if is_object_in_los(&object) {
+        if is_object_in_los(&object) {
             object.to_raw_address() - 48
         } else {
             unsafe { get_object_start_ref(object) }
-        };
-        res
+        }
     }
 
     #[inline(always)]
@@ -178,6 +176,7 @@ pub fn is_object_in_los(object: &ObjectReference) -> bool {
 }
 
 #[inline(always)]
+/// This function uses mutable static variables and requires unsafe annotation
 pub unsafe fn get_so_object_size(object: ObjectReference) -> usize {
     let obj_address = object.to_raw_address();
     let mut vtag = mmtk_jl_typetagof(obj_address);
@@ -199,7 +198,7 @@ pub unsafe fn get_so_object_size(object: ObjectReference) -> usize {
         vtag = Address::from_usize(vtag_usize);
     } else if vtag_usize < ((jl_small_typeof_tags_jl_max_tags as usize) << 4) {
         if vtag_usize == ((jl_small_typeof_tags_jl_simplevector_tag as usize) << 4) {
-            let length = (*obj_address.to_ptr::<jl_svec_t>()).length as usize;
+            let length = (*obj_address.to_ptr::<jl_svec_t>()).length;
             let dtsz = length * std::mem::size_of::<Address>() + std::mem::size_of::<jl_svec_t>();
 
             debug_assert!(
@@ -209,7 +208,7 @@ pub unsafe fn get_so_object_size(object: ObjectReference) -> usize {
             );
 
             return llt_align(dtsz + JULIA_HEADER_SIZE, 16);
-        } else if vtag_usize == ((jl_small_typeof_tags_jl_module_tag as usize) << 4) as usize {
+        } else if vtag_usize == ((jl_small_typeof_tags_jl_module_tag as usize) << 4) {
             let dtsz = std::mem::size_of::<jl_module_t>();
             debug_assert!(
                 dtsz + JULIA_HEADER_SIZE <= 2032,
@@ -276,9 +275,9 @@ pub unsafe fn get_so_object_size(object: ObjectReference) -> usize {
         let how = jl_gc_genericmemory_how(obj_address);
         let res = if how == 0 {
             let layout = (*(mmtk_jl_typetagof(obj_address).to_ptr::<jl_datatype_t>())).layout;
-            let mut sz = (*layout).size as usize * (*m).length as usize;
+            let mut sz = (*layout).size as usize * (*m).length;
             if (*layout).flags.arrayelem_isunion() != 0 {
-                sz += (*m).length as usize;
+                sz += (*m).length;
             }
 
             let dtsz = llt_align(std::mem::size_of::<jl_genericmemory_t>(), 16);
@@ -301,7 +300,7 @@ pub unsafe fn get_so_object_size(object: ObjectReference) -> usize {
         dtsz + JULIA_HEADER_SIZE
     );
 
-    return llt_align(dtsz + JULIA_HEADER_SIZE, 16);
+    llt_align(dtsz + JULIA_HEADER_SIZE, 16)
 }
 
 #[inline(always)]