Support for some basic atomic operations

FractalFir · FractalFir · commit 52509a78caf4 · 2023-12-28T20:12:09.000+01:00
diff --git a/cargo_tests/build_std/src/main.rs b/cargo_tests/build_std/src/main.rs
@@ -107,9 +107,9 @@ fn main() {
     std::hint::black_box(&string);
     unsafe{puts(string.as_ptr())};
     unsafe{puts("Testing some cool shit\n\0".as_ptr())};
-    let mut f = std::fs::File::create("foo.txt").unwrap();
+    //let mut f = std::fs::File::create("foo.txt").unwrap();
 
-    std::hint::black_box(f);
+    //std::hint::black_box(f);
     std::io::stdout().write_all(b"hello world\n").unwrap();
     let s = format!("Hello {}\0",8);
     unsafe{puts(s.as_ptr())};
diff --git a/src/aggregate.rs b/src/aggregate.rs
@@ -232,7 +232,7 @@ fn aggregate_adt<'tyctx>(
                 let field_type =
                     type_cache.type_from_cache(field_type, tyctx, Some(method_instance));
                 // Seting a void field is a no-op.
-                if field_type == Type::Void{
+                if field_type == Type::Void {
                     continue;
                 }
                 ops.extend(obj_getter.iter().cloned());
@@ -290,7 +290,7 @@ fn aggregate_adt<'tyctx>(
                     Some(method_instance),
                 );
                 // Seting a void field is a no-op.
-                if field_type == Type::Void{
+                if field_type == Type::Void {
                     continue;
                 }
                 ops.extend(variant_address.clone());
@@ -332,7 +332,6 @@ fn aggregate_adt<'tyctx>(
             );
             let mut ops: Vec<CILOp> = Vec::with_capacity(fields.len() * 2);
             for field in fields {
-               
                 let field_def = adt
                     .all_fields()
                     .nth(field.0 as usize)
@@ -342,7 +341,7 @@ fn aggregate_adt<'tyctx>(
                 let field_type =
                     type_cache.type_from_cache(field_type, tyctx, Some(method_instance));
                 // Seting a void field is a no-op.
-                if field_type == Type::Void{
+                if field_type == Type::Void {
                     continue;
                 }
                 ops.extend(obj_getter.iter().cloned());
diff --git a/src/assembly.rs b/src/assembly.rs
@@ -304,7 +304,7 @@ impl Assembly {
             match &block_data.terminator {
                 Some(term) => {
                     if crate::INSERT_MIR_DEBUG_COMMENTS {
-                        rustc_middle::ty::print::with_no_trimmed_paths! {ops.push(CILOp::Comment(format!("{term:?}").into()))};
+                        //rustc_middle::ty::print::with_no_trimmed_paths! {ops.push(CILOp::Comment(format!("{term:?}").into()))};
                     }
                     let term_ops = Self::terminator_to_ops(term, mir, tcx, instance, cache);
                     if term_ops != [CILOp::Ret] {
diff --git a/src/assembly_exporter/ilasm_op.rs b/src/assembly_exporter/ilasm_op.rs
@@ -417,6 +417,7 @@ pub fn type_cil(tpe: &Type) -> Cow<'static, str> {
         Type::ISize => "native int".into(),
         Type::USize => "native uint".into(),
         Type::Ptr(inner) => format!("{inner}*", inner = type_cil(inner)).into(),
+        Type::ManagedReference(inner) => format!("{inner}&", inner = type_cil(inner)).into(),
         Type::DotnetType(dotnet_type) => dotnet_type_ref_cli(dotnet_type).into(),
         //Special type
         Type::Unresolved => "valuetype Unresolved".into(),
diff --git a/src/ffi/atomics.rs b/src/ffi/atomics.rs
@@ -0,0 +1,215 @@
+use crate::{
+    assembly::Assembly,
+    cil::{CILOp, CallSite, FieldDescriptor},
+    function_sig::FnSig,
+    method::Method,
+    r#type::{DotnetTypeRef, Type},
+};
+//TODO: propely mimic the semantics used in atomics!
+pub fn add_atomics(asm: &mut Assembly) {
+    add_atomic_load_acquire(asm);
+    add_atomic_cxchgweak_acquire_acquire(asm);
+}
+fn add_atomic_load_acquire(asm: &mut Assembly) {
+    let atomic_load_acquire_calls: Box<[_]> = asm
+        .call_sites()
+        .filter(|call_site| {
+            call_site.signature().inputs().len() == 1
+                && matches!(call_site.signature().inputs()[0], Type::Ptr(_))
+                && call_site.name().contains("atomic_load_acquire")
+        })
+        .cloned()
+        .collect();
+    for call in atomic_load_acquire_calls.iter() {
+        let mut method = Method::new(
+            crate::access_modifier::AccessModifer::Private,
+            true,
+            call.signature().clone(),
+            call.name(),
+            vec![],
+        );
+        match call.signature().output() {
+            //Those can't be implemented using System.Threading.Interlocked, since there is no Read(Uintptr).
+            Type::Ptr(_) => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndISize, CILOp::Ret]),
+            Type::ISize => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndISize, CILOp::Ret]),
+            Type::USize => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndISize, CILOp::Ret]),
+            //Those can be implemented using System.Threading.Interlocked.
+            Type::I64 => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndI64, CILOp::Ret]),
+            Type::U64 => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndI64, CILOp::Ret]),
+            //Those can't be implemented using System.Threading.Interlocked.
+            Type::U8 => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndI8, CILOp::Ret]),
+            Type::I8 => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndI8, CILOp::Ret]),
+            Type::U32 => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndI32, CILOp::Ret]),
+            Type::I32 => method.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndI32, CILOp::Ret]),
+            _ => {
+                eprintln!(
+                    "Warning: `atomic_load_acquire` used with unsuported type({:?})!",
+                    call.signature().output()
+                );
+                continue;
+            }
+        }
+        asm.add_method(method);
+    }
+}
+fn interlocked() -> DotnetTypeRef {
+    DotnetTypeRef::new(Some("System.Threading"), "System.Threading.Interlocked")
+        .with_valuetype(false)
+}
+
+fn add_atomic_cxchgweak_acquire_acquire(asm: &mut Assembly) {
+    let atomic_cxchgweak_acquire_acquire_calls: Box<[_]> = asm
+        .call_sites()
+        .filter(|call_site| {
+            call_site.signature().inputs().len() == 3
+                && call_site
+                    .name()
+                    .contains("atomic_cxchgweak_acquire_acquire")
+        })
+        .cloned()
+        .collect();
+    for call in atomic_cxchgweak_acquire_acquire_calls.iter() {
+        let ret_tuple = call.signature().output();
+        let ret_tuple_dotnet = ret_tuple.as_dotnet().expect("atomic_cxchgweak_acquire_acquire: return tuple invalid!");
+        let mut method = Method::new(
+            crate::access_modifier::AccessModifer::Private,
+            true,
+            call.signature().clone(),
+            call.name(),
+            vec![(None, call.signature().inputs()[1].clone()),(Some("return_tuple".into()),ret_tuple.clone())],
+        );
+        match call.signature().inputs()[1]{
+            //Those can't be implemented using System.Threading.Interlocked, since there is no Read(Uintptr).
+            Type::USize | Type::ISize | Type::Ptr(_) => {
+                let call_sig = FnSig::new(
+                    &[
+                        Type::ManagedReference(Type::USize.into()),
+                        Type::USize,
+                        Type::USize,
+                    ],
+                    &Type::USize,
+                );
+                method.set_ops(vec![
+                   
+                    CILOp::LDArg(0),
+                    CILOp::LDArg(1),
+                    CILOp::LDArg(2),
+                    CILOp::Call(
+                        CallSite::new(
+                            Some(interlocked()),
+                            "CompareExchange".into(),
+                            call_sig,
+                            true,
+                        )
+                        .into(),
+                    ),
+                    CILOp::STLoc(0),
+                    CILOp::LDLocA(1),
+                    CILOp::LDLoc(0),
+                    CILOp::STField(Box::new(FieldDescriptor::new(ret_tuple_dotnet.clone(), call.signature().inputs()[1].clone(),"Item1".into()))),
+                    CILOp::LDLocA(1),
+                    CILOp::LDLoc(0),
+                    CILOp::LDArg(1),
+                    CILOp::Eq,
+                    CILOp::Not,
+                    CILOp::STField(Box::new(FieldDescriptor::new(ret_tuple_dotnet,Type::Bool,"Item2".into()))),
+                    CILOp::LDLoc(1),
+                    CILOp::Ret,
+                ]);
+            }
+            Type::U32 | Type::I32 => {
+                let call_sig = FnSig::new(
+                    &[
+                        Type::ManagedReference(Type::I32.into()),
+                        Type::I32,
+                        Type::I32,
+                    ],
+                    &Type::I32,
+                );
+                method.set_ops(vec![
+                   
+                    CILOp::LDArg(0),
+                    CILOp::LDArg(1),
+                    CILOp::LDArg(2),
+                    CILOp::Call(
+                        CallSite::new(
+                            Some(interlocked()),
+                            "CompareExchange".into(),
+                            call_sig,
+                            true,
+                        )
+                        .into(),
+                    ),
+                    CILOp::STLoc(0),
+                    CILOp::LDLocA(1),
+                    CILOp::LDLoc(0),
+                    CILOp::STField(Box::new(FieldDescriptor::new(ret_tuple_dotnet.clone(), call.signature().inputs()[1].clone(),"Item1".into()))),
+                    CILOp::LDLocA(1),
+                    CILOp::LDLoc(0),
+                    CILOp::LDArg(1),
+                    CILOp::Eq,
+                    CILOp::Not,
+                    CILOp::STField(Box::new(FieldDescriptor::new(ret_tuple_dotnet,Type::Bool,"Item2".into()))),
+                    CILOp::LDLoc(1),
+                    CILOp::Ret,
+                ]);
+            }
+            Type::U64 | Type::I64 => {
+                let call_sig = FnSig::new(
+                    &[
+                        Type::ManagedReference(Type::U64.into()),
+                        Type::U64,
+                        Type::U64,
+                    ],
+                    &Type::U64,
+                );
+                method.set_ops(vec![
+                    
+                    CILOp::LDArg(0),
+                    CILOp::LDArg(1),
+                    CILOp::LDArg(2),
+                    CILOp::Call(
+                        CallSite::new(
+                            Some(interlocked()),
+                            "CompareExchange".into(),
+                            call_sig,
+                            true,
+                        )
+                        .into(),
+                    ),
+                    CILOp::STLoc(0),
+                    CILOp::LDLocA(1),
+                    CILOp::LDLoc(0),
+                    CILOp::STField(Box::new(FieldDescriptor::new(ret_tuple_dotnet.clone(), call.signature().inputs()[1].clone(),"Item1".into()))),
+                    CILOp::LDLocA(1),
+                    CILOp::LDLoc(0),
+                    CILOp::LDArg(1),
+                    CILOp::Eq,
+                    CILOp::Not,
+                    CILOp::STField(Box::new(FieldDescriptor::new(ret_tuple_dotnet,Type::Bool,"Item2".into()))),
+                    CILOp::LDLoc(1),
+                    CILOp::Ret,
+                ]);
+            }
+            //Type::ISize=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndISize,CILOp::Ret]),
+            // Type::USize=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndISize,CILOp::Ret]),
+            //Those can be implemented using System.Threading.Interlocked.
+            //Type::I64=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndI64,CILOp::Ret]),
+            // Type::U64=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndI64,CILOp::Ret]),
+            //Those can't be implemented using System.Threading.Interlocked.
+            //Type::U8=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndI8,CILOp::Ret]),
+            // Type::I8=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndI8,CILOp::Ret]),
+            //Type::U32=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndI32,CILOp::Ret]),
+            //Type::I32=> method.set_ops(vec![CILOp::LDArg(0),CILOp::LDIndI32,CILOp::Ret]),
+            _ => {
+                eprintln!(
+                    "Warning: `atomic_cxchgweak_acquire_acquire` used with unsuported type({:?})!",
+                    call.signature().inputs()[1]
+                );
+                continue;
+            }
+        }
+        asm.add_method(method);
+    }
+}
+//TODO: implement cmp by using System.Threading.Interlocked.CompareExchange<T>(T, T, T)
diff --git a/src/ffi/mod.rs b/src/ffi/mod.rs
@@ -1,3 +1,4 @@
+mod atomics;
 use crate::r#type::DotnetTypeRef;
 use crate::{
     access_modifier::AccessModifer,
@@ -36,7 +37,6 @@ macro_rules! add_method {
         }
     };
 }
-
 /// Inserts a small subset of libc and some standard types into an assembly.
 pub fn insert_ffi_functions(asm: &mut Assembly, tyctx: TyCtxt) {
     let c_void = Type::c_void(tyctx);
@@ -169,6 +169,7 @@ pub fn insert_ffi_functions(asm: &mut Assembly, tyctx: TyCtxt) {
         CILOp::Ret,
     ]);
     asm.add_method(free);
+    //TODO: add volatile prefix to volatile loads
     let mut volatile_load = Method::new(
         AccessModifer::Private,
         true,
@@ -187,6 +188,9 @@ pub fn insert_ffi_functions(asm: &mut Assembly, tyctx: TyCtxt) {
     );
     volatile_load.set_ops(vec![CILOp::LDArg(0), CILOp::LDIndISize, CILOp::Ret]);
     asm.add_method(volatile_load);
+
+    atomics::add_atomics(asm);
+
     abort(asm);
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -62,7 +62,7 @@ extern crate stable_mir;
 // Debug config
 
 /// Tells the codegen to insert comments containing the MIR statemtens after each one of them.
-const INSERT_MIR_DEBUG_COMMENTS: bool = false;
+const INSERT_MIR_DEBUG_COMMENTS: bool = true;
 /// Prints local types of all compiled MIR functions.
 const PRINT_LOCAL_TYPES: bool = false;
 /// Tells the codegen to optmize the emiited CIL.
diff --git a/src/method.rs b/src/method.rs
@@ -54,10 +54,17 @@ impl Method {
         }
     }
     pub(crate) fn ensure_valid(&mut self) {
-        if let Some(CILOp::Ret) = self.ops.iter().last() {
-            //Do nothing
-        } else {
-            self.ops.push(CILOp::Ret);
+        let last = self.ops.iter().last();
+        let last = match last {
+            Some(last) => last,
+            None => return,
+        };
+        match last{
+            CILOp::Ret=>(),
+            CILOp::Throw=>(),
+            CILOp::Rethrow=>(),
+            CILOp::GoTo(_)=>(),
+            _=>self.ops.extend(CILOp::throw_msg("Critical error: reached the end of a function not termianted with a return statement")),
         }
     }
     /// Adds a local variable of type `local`
diff --git a/src/place/mod.rs b/src/place/mod.rs
@@ -1,7 +1,7 @@
 // FIXME: This file may contain unnecesary morphize calls.
 
 use crate::cil::CILOp;
-use crate::r#type::{DotnetTypeRef, Type, pointer_to_is_fat};
+use crate::r#type::{pointer_to_is_fat, DotnetTypeRef, Type};
 
 use rustc_middle::mir::Place;
 
@@ -128,24 +128,28 @@ pub fn deref_op<'ctx>(
                     type_cache.type_from_cache(derefed_type, tyctx, Some(*method_instance));
                 vec![CILOp::LdObj(derefed_type.into())]
             }
-            TyKind::Ref(_, inner, _) => if pointer_to_is_fat(*inner,tyctx,Some(*method_instance)) {
-                vec![CILOp::LdObj(
-                    type_cache
-                        .type_from_cache(derefed_type, tyctx, Some(*method_instance))
-                        .into(),
-                )]
-            }else{
-                vec![CILOp::LDIndISize]
-            },
-            TyKind::RawPtr(type_and_mut) => if pointer_to_is_fat(type_and_mut.ty,tyctx,Some(*method_instance)) {
-                vec![CILOp::LdObj(
-                    type_cache
-                        .type_from_cache(derefed_type, tyctx, Some(*method_instance))
-                        .into(),
-                )]
-            }else{
-                vec![CILOp::LDIndISize]
-            },
+            TyKind::Ref(_, inner, _) => {
+                if pointer_to_is_fat(*inner, tyctx, Some(*method_instance)) {
+                    vec![CILOp::LdObj(
+                        type_cache
+                            .type_from_cache(derefed_type, tyctx, Some(*method_instance))
+                            .into(),
+                    )]
+                } else {
+                    vec![CILOp::LDIndISize]
+                }
+            }
+            TyKind::RawPtr(type_and_mut) => {
+                if pointer_to_is_fat(type_and_mut.ty, tyctx, Some(*method_instance)) {
+                    vec![CILOp::LdObj(
+                        type_cache
+                            .type_from_cache(derefed_type, tyctx, Some(*method_instance))
+                            .into(),
+                    )]
+                } else {
+                    vec![CILOp::LDIndISize]
+                }
+            }
             TyKind::Array(_, _) => {
                 let derefed_type =
                     type_cache.type_from_cache(derefed_type, tyctx, Some(*method_instance));
diff --git a/src/place/set.rs b/src/place/set.rs
diff --git a/src/rvalue.rs b/src/rvalue.rs
diff --git a/src/type/tycache.rs b/src/type/tycache.rs
diff --git a/src/type/type.rs b/src/type/type.rs

Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,7 @@ impl Assembly {`
`304`	`304`	`match &block_data.terminator {`
`305`	`305`	`Some(term) => {`
`306`	`306`	`if crate::INSERT_MIR_DEBUG_COMMENTS {`
`307`		`- rustc_middle::ty::print::with_no_trimmed_paths! {ops.push(CILOp::Comment(format!("{term:?}").into()))};`
	`307`	`+ //rustc_middle::ty::print::with_no_trimmed_paths! {ops.push(CILOp::Comment(format!("{term:?}").into()))};`
`308`	`308`	`}`
`309`	`309`	`let term_ops = Self::terminator_to_ops(term, mir, tcx, instance, cache);`
`310`	`310`	`if term_ops != [CILOp::Ret] {`
Original file line number	Diff line number	Diff line change
`@@ -54,10 +54,17 @@ impl Method {`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`pub(crate) fn ensure_valid(&mut self) {`
`57`		`- if let Some(CILOp::Ret) = self.ops.iter().last() {`
`58`		`- //Do nothing`
`59`		`- } else {`
`60`		`- self.ops.push(CILOp::Ret);`
	`57`	`+ let last = self.ops.iter().last();`
	`58`	`+ let last = match last {`
	`59`	`+ Some(last) => last,`
	`60`	`+ None => return,`
	`61`	`+ };`
	`62`	`+ match last{`
	`63`	`+ CILOp::Ret=>(),`
	`64`	`+ CILOp::Throw=>(),`
	`65`	`+ CILOp::Rethrow=>(),`
	`66`	`+ CILOp::GoTo(_)=>(),`
	`67`	`+ _=>self.ops.extend(CILOp::throw_msg("Critical error: reached the end of a function not termianted with a return statement")),`
`61`	`68`	`}`
`62`	`69`	`}`
`63`	`70`	/// Adds a local variable of type `local`