Implement atomic max/min

Author: antoyo

Cargo.lock

@@ -2,9 +2,9 @@
 #![feature(asm, backtrace, core_intrinsics, global_asm, naked_functions)]
 
 //use backtrace::Backtrace;
-use std::backtrace::Backtrace;
+//use std::backtrace::Backtrace;
 
-global_asm!("
+/*global_asm!("
     .global add_asm
 add_asm:
      mov %rdi, %rax
@@ -16,7 +16,7 @@ global_asm!("
 .global toto
 toto:
      ret"
-);
+);*/
 
 /*global_asm!("
             .att_syntax
@@ -79,8 +79,8 @@ toto:
             .popsection");*/
 
 extern "C" {
-    fn add_asm(a: i64, b: i64) -> i64;
-    fn toto();
+    //fn add_asm(a: i64, b: i64) -> i64;
+    //fn toto();
 }
 
 //#![feature(intrinsics)]
@@ -129,7 +129,7 @@ pub fn example_c() -> [T; N] {
     pub fn atomic_xchg<T: Copy>(dst: *mut T, src: T) -> T;
 }*/
 
-fn rem(num: f32, other: f32) -> f32 {
+/*fn rem(num: f32, other: f32) -> f32 {
     num % other
 }
 
@@ -189,7 +189,7 @@ fn thread_func(_arg: *mut c_void) -> *mut c_void {
     });
 
     std::ptr::null_mut()
-}
+}*/
 
 /*fn main() {
     FOO.with(|foo| {
@@ -249,9 +249,68 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 fn main() {
     //println!("Global panic count: {}", GLOBAL_PANIC_COUNT.load(Ordering::Relaxed));
 
-    let mutex = std::sync::Mutex::new(());
+    /*let x = AtomicUsize::new(0xf731);
+    assert_eq!(x.fetch_min(0x137f, Ordering::SeqCst), 0xf731);
+    assert_eq!(x.load(Ordering::SeqCst), 0x137f);
+    assert_eq!(x.fetch_min(0xf731, Ordering::SeqCst), 0x137f);
+    assert_eq!(x.load(Ordering::SeqCst), 0x137f);
+
+    let x = AtomicUsize::new(0x137f);
+    assert_eq!(x.fetch_max(0xf731, Ordering::SeqCst), 0x137f);
+    assert_eq!(x.load(Ordering::SeqCst), 0xf731);
+    assert_eq!(x.fetch_max(0x137f, Ordering::SeqCst), 0xf731);
+    assert_eq!(x.load(Ordering::SeqCst), 0xf731);
+
+    let b: [i32; 0] = [];
+    assert_eq!(b.binary_search(&5), Err(0));
+
+    let b = [4];
+    assert_eq!(b.binary_search(&3), Err(0));
+    assert_eq!(b.binary_search(&4), Ok(0));
+    assert_eq!(b.binary_search(&5), Err(1));
+
+    let b = [1, 2, 4, 6, 8, 9];
+    assert_eq!(b.binary_search(&5), Err(3));
+    assert_eq!(b.binary_search(&6), Ok(3));
+    assert_eq!(b.binary_search(&7), Err(4));
+    assert_eq!(b.binary_search(&8), Ok(4));
+
+    let b = [1, 2, 4, 5, 6, 8];
+    assert_eq!(b.binary_search(&9), Err(6));
+
+    let b = [1, 2, 4, 6, 7, 8, 9];
+    assert_eq!(b.binary_search(&6), Ok(3));
+    assert_eq!(b.binary_search(&5), Err(3));
+    assert_eq!(b.binary_search(&8), Ok(5));
+
+    let b = [1, 2, 4, 5, 6, 8, 9];
+    assert_eq!(b.binary_search(&7), Err(5));
+    assert_eq!(b.binary_search(&0), Err(0));
+
+    let b = [1, 3, 3, 3, 7];
+    assert_eq!(b.binary_search(&0), Err(0));
+    assert_eq!(b.binary_search(&1), Ok(0));
+    assert_eq!(b.binary_search(&2), Err(1));
+    assert!(match b.binary_search(&3) {
+        Ok(1..=3) => true,
+        _ => false,
+    });
+    assert!(match b.binary_search(&3) {
+        Ok(1..=3) => true,
+        _ => false,
+    });
+    assert_eq!(b.binary_search(&4), Err(4));
+    assert_eq!(b.binary_search(&5), Err(4));
+    assert_eq!(b.binary_search(&6), Err(4));
+    assert_eq!(b.binary_search(&7), Ok(4));
+    assert_eq!(b.binary_search(&8), Err(5));*/
+
+    let b = [(); usize::MAX];
+    assert_eq!(b.binary_search(&()), Ok(usize::MAX / 2));
+
+    /*let mutex = std::sync::Mutex::new(());
     println!("Poisoned: {}", mutex.is_poisoned());
-    let _guard = mutex.lock().unwrap();
+    let _guard = mutex.lock().unwrap();*/
 
     //unsafe { toto() };
     //assert_eq!(unsafe { add_asm(40, 2) }, 42);
@@ -419,7 +478,7 @@ fn main() {
         println!("bits of {}: {:?}", value, &bits[0..popcnt]);
     }*/
 
-    let mut bits = [0u8; 64];
+    /*let mut bits = [0u8; 64];
     for value in 0..=1024u64 {
         let popcnt;
         unsafe {
@@ -441,7 +500,7 @@ fn main() {
             );
         }
         println!("bits of {}: {:?}", value, &bits[0..popcnt]);
-    }
+    }*/
 
     /*let bt = Backtrace::new();
     println!("{:?}", bt);*/

gcc-test-backend/src/main.rs

@@ -52,6 +52,29 @@ type Funclet = ();
 // TODO: remove this variable.
 static mut RETURN_VALUE_COUNT: usize = 0;
 
+enum ExtremumOperation {
+    Max,
+    Min,
+}
+
+trait EnumClone {
+    fn clone(&self) -> Self;
+}
+
+impl EnumClone for AtomicOrdering {
+    fn clone(&self) -> Self {
+        match *self {
+            AtomicOrdering::NotAtomic => AtomicOrdering::NotAtomic,
+            AtomicOrdering::Unordered => AtomicOrdering::Unordered,
+            AtomicOrdering::Monotonic => AtomicOrdering::Monotonic,
+            AtomicOrdering::Acquire => AtomicOrdering::Acquire,
+            AtomicOrdering::Release => AtomicOrdering::Release,
+            AtomicOrdering::AcquireRelease => AtomicOrdering::AcquireRelease,
+            AtomicOrdering::SequentiallyConsistent => AtomicOrdering::SequentiallyConsistent,
+        }
+    }
+}
+
 pub struct Builder<'a: 'gcc, 'gcc, 'tcx> {
     pub cx: &'a CodegenCx<'gcc, 'tcx>,
     pub block: Option<Block<'gcc>>,
@@ -67,6 +90,80 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         }
     }
 
+    fn atomic_extremum(&mut self, operation: ExtremumOperation, dst: RValue<'gcc>, src: RValue<'gcc>, order: AtomicOrdering) -> RValue<'gcc> {
+        let size = self.cx.int_width(src.get_type()) / 8;
+
+        let func = self.current_func();
+
+        let load_ordering =
+            match order {
+                // TODO: does this make sense?
+                AtomicOrdering::AcquireRelease | AtomicOrdering::Release => AtomicOrdering::Acquire,
+                _ => order.clone(),
+            };
+        let previous_value = self.atomic_load(dst, load_ordering.clone(), Size::from_bytes(size));
+        let previous_var = func.new_local(None, previous_value.get_type(), "previous_value");
+        let return_value = func.new_local(None, previous_value.get_type(), "return_value");
+        self.llbb().add_assignment(None, previous_var, previous_value);
+        self.llbb().add_assignment(None, return_value, previous_var.to_rvalue());
+
+        let while_block = func.new_block("while");
+        let after_block = func.new_block("after_while");
+        self.llbb().end_with_jump(None, while_block);
+
+        // NOTE: since jumps were added and compare_exchange doesn't expect this, the current blocks in the
+        // state need to be updated.
+        self.block = Some(while_block);
+        *self.cx.current_block.borrow_mut() = Some(while_block);
+
+        let comparison_operator =
+            match operation {
+                ExtremumOperation::Max => ComparisonOp::LessThan,
+                ExtremumOperation::Min => ComparisonOp::GreaterThan,
+            };
+
+        let cond1 = self.context.new_comparison(None, comparison_operator, previous_var.to_rvalue(), self.context.new_cast(None, src, previous_value.get_type()));
+        let compare_exchange = self.compare_exchange(dst, previous_var.to_rvalue(), src, order, load_ordering, false);
+        let cond2 = self.cx.context.new_unary_op(None, UnaryOp::LogicalNegate, compare_exchange.get_type(), compare_exchange);
+        let cond = self.cx.context.new_binary_op(None, BinaryOp::LogicalAnd, self.cx.bool_type, cond1, cond2);
+
+        while_block.end_with_conditional(None, cond, while_block, after_block);
+
+        // NOTE: since jumps were added in a place rustc does not expect, the current blocks in the
+        // state need to be updated.
+        self.block = Some(after_block);
+        *self.cx.current_block.borrow_mut() = Some(after_block);
+
+        return_value.to_rvalue()
+    }
+
+    fn compare_exchange(&self, dst: RValue<'gcc>, cmp: RValue<'gcc>, src: RValue<'gcc>, order: AtomicOrdering, failure_order: AtomicOrdering, weak: bool) -> RValue<'gcc> {
+        let size = self.cx.int_width(src.get_type());
+        let compare_exchange = self.context.get_builtin_function(&format!("__atomic_compare_exchange_{}", size / 8));
+        let order = self.context.new_rvalue_from_int(self.i32_type, order.to_gcc());
+        let failure_order = self.context.new_rvalue_from_int(self.i32_type, failure_order.to_gcc());
+        let weak = self.context.new_rvalue_from_int(self.bool_type, weak as i32);
+
+        let void_ptr_type = self.context.new_type::<*mut ()>();
+        let volatile_void_ptr_type = void_ptr_type.make_volatile();
+        let dst = self.context.new_cast(None, dst, volatile_void_ptr_type);
+        let expected = self.current_func().new_local(None, cmp.get_type(), "expected");
+        self.llbb().add_assignment(None, expected, cmp);
+        let expected = self.context.new_cast(None, expected.get_address(None), void_ptr_type);
+
+        // NOTE: not sure why, but we need to cast to the signed type.
+        let new_src_type =
+            if size == 64 {
+                // TODO: use sized types (uint64_t, …) when libgccjit supports them.
+                self.cx.long_type
+            }
+            else {
+                src.get_type().to_signed(&self.cx)
+            };
+        let src = self.context.new_cast(None, src, new_src_type);
+        self.context.new_call(None, compare_exchange, &[dst, expected, src, weak, order, failure_order])
+    }
+
     pub fn assign(&self, lvalue: LValue<'gcc>, value: RValue<'gcc>) {
         self.llbb().add_assignment(None, lvalue, value);
     }
@@ -1397,30 +1494,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
 
     // Atomic Operations
     fn atomic_cmpxchg(&mut self, dst: RValue<'gcc>, cmp: RValue<'gcc>, src: RValue<'gcc>, order: AtomicOrdering, failure_order: AtomicOrdering, weak: bool) -> RValue<'gcc> {
-        let size = self.cx.int_width(src.get_type());
-        let compare_exchange = self.context.get_builtin_function(&format!("__atomic_compare_exchange_{}", size / 8));
-        let order = self.context.new_rvalue_from_int(self.i32_type, order.to_gcc());
-        let failure_order = self.context.new_rvalue_from_int(self.i32_type, failure_order.to_gcc());
-        let weak = self.context.new_rvalue_from_int(self.bool_type, weak as i32);
-
-        let void_ptr_type = self.context.new_type::<*mut ()>();
-        let volatile_void_ptr_type = void_ptr_type.make_volatile();
-        let dst = self.context.new_cast(None, dst, volatile_void_ptr_type);
-        let expected = self.current_func().new_local(None, cmp.get_type(), "expected");
-        self.llbb().add_assignment(None, expected, cmp);
-        let expected = self.context.new_cast(None, expected.get_address(None), void_ptr_type);
-
-        // NOTE: not sure why, but we need to cast to the signed type.
-        let new_src_type =
-            if size == 64 {
-                // TODO: use sized types (uint64_t, …) when libgccjit supports them.
-                self.cx.long_type
-            }
-            else {
-                src.get_type().to_signed(&self.cx)
-            };
-        let src = self.context.new_cast(None, src, new_src_type);
-        let success = self.context.new_call(None, compare_exchange, &[dst, expected, src, weak, order, failure_order]);
+        let success = self.compare_exchange(dst, cmp, src, order, failure_order, weak);
 
         let pair_type = self.cx.type_struct(&[src.get_type(), self.bool_type], false);
         let result = self.current_func().new_local(None, pair_type, "atomic_cmpxchg_result");
@@ -1446,10 +1520,10 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
                 AtomicRmwBinOp::AtomicNand => format!("__atomic_fetch_nand_{}", size),
                 AtomicRmwBinOp::AtomicOr => format!("__atomic_fetch_or_{}", size),
                 AtomicRmwBinOp::AtomicXor => format!("__atomic_fetch_xor_{}", size),
-                AtomicRmwBinOp::AtomicMax => unimplemented!(),
-                AtomicRmwBinOp::AtomicMin => unimplemented!(),
-                AtomicRmwBinOp::AtomicUMax => unimplemented!(),
-                AtomicRmwBinOp::AtomicUMin => unimplemented!(),
+                AtomicRmwBinOp::AtomicMax => return self.atomic_extremum(ExtremumOperation::Max, dst, src, order),
+                AtomicRmwBinOp::AtomicMin => return self.atomic_extremum(ExtremumOperation::Min, dst, src, order),
+                AtomicRmwBinOp::AtomicUMax => return self.atomic_extremum(ExtremumOperation::Max, dst, src, order),
+                AtomicRmwBinOp::AtomicUMin => return self.atomic_extremum(ExtremumOperation::Min, dst, src, order),
             };
 
 

src/builder.rs

@@ -1,3 +1,5 @@
+use std::convert::TryInto;
+
 use gccjit::{RValue, Struct, Type};
 use rustc_codegen_ssa::traits::{BaseTypeMethods, DerivedTypeMethods};
 use rustc_codegen_ssa::common::TypeKind;
@@ -237,8 +239,20 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         self.context.new_opaque_struct_type(None, name)
     }
 
-    pub fn type_array(&self, ty: Type<'gcc>, len: u64) -> Type<'gcc> {
-        self.context.new_array_type(None, ty, len as i32)
+    pub fn type_array(&self, ty: Type<'gcc>, mut len: u64) -> Type<'gcc> {
+        if let Some(struct_type) = ty.is_struct() {
+            if struct_type.get_field_count() == 0 {
+                // NOTE: since gccjit only supports i32 for the array size and libcore's tests uses a
+                // size of usize::MAX in test_binary_search, we workaround this by setting the size to
+                // zero for ZSTs.
+                // FIXME: fix gccjit API.
+                len = 0;
+            }
+        }
+
+        let len: i32 = len.try_into().expect("array len");
+
+        self.context.new_array_type(None, ty, len)
     }
 }