Misc fixes

Cargo.toml

@@ -20,9 +20,9 @@ rustc-demangle = "0.1.23"
 cilly = {path = "./cilly"}
 serde = { version = "1.0.183", features = ["derive"] }
 strsim = "0.11.1"
-regex = "1.10.5"
+
 fxhash = "0.2.1"
-ordered-float = { version = "4.2.1", features = ["serde"] }
+
 [profile.dev.package.fxhash]
 opt-level = 3
 [lib]

cilly/Cargo.toml

@@ -12,12 +12,6 @@ lazy_static = "1.4.0"
 postcard = { version = "1.0.6", features = ["use-std"] }
 ar = "0.9.0"
 fxhash = "0.2.1"
-name-variant = "0.1.0"
-internment = { version = "0.8.4", features = ["arc", "serde"] }
-ordered-float = { version = "4.2.1", features = ["serde"] }
-string-interner = { version = "*", features = ["serde"] }
-interner = "0.2.1"
-streaming-iterator = "0.1.9"
 [[bin]]
 name = "linker"
 test = false

cilly/src/cil_iter.rs

@@ -1,4 +1,4 @@
-use crate::{call_site::CallSite, cil_node::CILNode, cil_root::CILRoot};
+use crate::{call_site::CallSite, cil_node::CILNode, cil_root::CILRoot, v2::hashable::HashableF32};
 
 #[derive(Debug, Clone, Copy)]
 pub enum CILIterElem<'a> {
@@ -576,11 +576,7 @@ fn iter() {
             FnSig::new(&[Type::I32, Type::F32], Type::Void),
             true,
         )),
-        args: [
-            CILNode::LdcI32(-77),
-            CILNode::LdcF32(ordered_float::OrderedFloat(3.119765)),
-        ]
-        .into(),
+        args: [CILNode::LdcI32(-77), CILNode::LdcF32(HashableF32(3.119765))].into(),
     };
     let mut iter = root.into_iter();
     assert!(matches!(
@@ -593,9 +589,7 @@ fn iter() {
     ));
     assert!(matches!(
         iter.next(),
-        Some(CILIterElem::Node(CILNode::LdcF32(
-            ordered_float::OrderedFloat(3.119765)
-        )))
+        Some(CILIterElem::Node(CILNode::LdcF32(HashableF32(3.119765))))
     ));
     assert!(iter.next().is_none());
 }

cilly/src/cil_iter_mut.rs

@@ -1,8 +1,6 @@
 use std::marker::PhantomData;
 
-use ordered_float::OrderedFloat;
-
-use crate::{cil_node::CILNode, cil_root::CILRoot};
+use crate::{cil_node::CILNode, cil_root::CILRoot, v2::hashable::HashableF32};
 
 #[derive(Debug)]
 enum CILIterElemUnsafe<'a> {
@@ -615,11 +613,7 @@ fn iter() {
             FnSig::new(&[Type::I32, Type::F32], Type::Void),
             true,
         )),
-        args: [
-            CILNode::LdcI32(-77),
-            CILNode::LdcF32(OrderedFloat(3.119765)),
-        ]
-        .into(),
+        args: [CILNode::LdcI32(-77), CILNode::LdcF32(HashableF32(3.119765))].into(),
     };
     let mut iter = (&mut root).into_iter();
     assert!(matches!(
@@ -632,9 +626,7 @@ fn iter() {
     ));
     assert!(matches!(
         iter.next(),
-        Some(CILIterElemMut::Node(CILNode::LdcF32(OrderedFloat(
-            3.119765
-        ))))
+        Some(CILIterElemMut::Node(CILNode::LdcF32(HashableF32(3.119765))))
     ));
     assert!(iter.next().is_none());
 }

cilly/src/cil_node.rs

@@ -1,9 +1,16 @@
 use crate::{
-    call, call_site::CallSite, cil_iter::CILIterTrait, cil_root::CILRoot,
-    field_desc::FieldDescriptor, fn_sig::FnSig, ptr, static_field_desc::StaticFieldDescriptor,
+    call,
+    call_site::CallSite,
+    cil_iter::CILIterTrait,
+    cil_root::CILRoot,
+    field_desc::FieldDescriptor,
+    fn_sig::FnSig,
+    ptr,
+    static_field_desc::StaticFieldDescriptor,
+    v2::hashable::{HashableF32, HashableF64},
     DotnetTypeRef, IString, Type,
 };
-use ordered_float::OrderedFloat;
+
 use serde::{Deserialize, Serialize};
 /// A container for the arguments of a call, callvirt, or newobj instruction.
 #[derive(Clone, Eq, PartialEq, Serialize, Deserialize, Hash, Debug)]
@@ -134,8 +141,8 @@ pub enum CILNode {
     LdcU32(u32),
     LdcI8(i8),
     LdcI16(i16),
-    LdcF64(OrderedFloat<f64>),
-    LdcF32(OrderedFloat<f32>),
+    LdcF64(HashableF64),
+    LdcF32(HashableF32),
     LoadGlobalAllocPtr {
         alloc_id: u64,
     },

cilly/src/v2/class.rs

@@ -271,9 +271,6 @@ impl ClassDef {
         // Merge the static fields, removing duplicates
         self.static_fields_mut().extend(translated.static_fields());
         make_unique(&mut self.static_fields);
-        // Merge the static fields, removing duplicates
-        self.static_fields_mut().extend(translated.static_fields());
-        make_unique(self.static_fields_mut());
         // Merge the methods, removing duplicates
         self.methods_mut().extend(translated.methods());
         make_unique(self.methods_mut());

cilly/src/v2/cst.rs

@@ -1,7 +1,9 @@
-use ordered_float::OrderedFloat;
 use serde::{Deserialize, Serialize};
 
-use super::{CILNode, Float, Int, StringIdx, Type};
+use super::{
+    hashable::{HashableF32, HashableF64},
+    CILNode, Float, Int, StringIdx, Type,
+};
 
 #[derive(PartialEq, Eq, Clone, Debug, Hash, Serialize, Deserialize)]
 pub enum Const {
@@ -17,8 +19,8 @@ pub enum Const {
     USize(u64),
     PlatformString(StringIdx),
     Bool(bool),
-    F32(OrderedFloat<f32>),
-    F64(OrderedFloat<f64>),
+    F32(HashableF32),
+    F64(HashableF64),
 }
 impl Const {
     pub(crate) fn get_type(&self) -> Type {

cilly/src/v2/mod.rs

@@ -30,6 +30,8 @@ pub mod cst;
 pub mod field;
 pub mod float;
 pub mod fnsig;
+/// Defines hashable and equable floating point types. All NaNs are compared by bits, and -0.0 != 0.0.
+pub mod hashable;
 pub mod il_exporter;
 pub mod int;
 pub mod iter;

src/assembly.rs

@@ -30,7 +30,7 @@ use rustc_middle::{
         mono::MonoItem,
         Local, LocalDecl, Statement, Terminator,
     },
-    ty::{Instance, ParamEnv, Ty, TyCtxt, TyKind},
+    ty::{Instance, ParamEnv, TyCtxt, TyKind},
 };
 type LocalDefList = Vec<(Option<IString>, Type)>;
 type ArgsDebugInfo = Vec<Option<IString>>;
@@ -639,14 +639,14 @@ pub fn add_allocation(
         }
         GlobalAlloc::VTable(..) => {
             //TODO: handle VTables
-            let alloc_fld: IString = format!("alloc_{alloc_id:x}").into();
+            let alloc_fld: IString = format!("al_{alloc_id:x}").into();
             let field_desc = StaticFieldDescriptor::new(None, ptr!(Type::U8), alloc_fld.clone());
             asm.add_static(ptr!(Type::U8), &alloc_fld, false);
             return CILNode::LDStaticField(Box::new(field_desc));
         }
         GlobalAlloc::Function { .. } => {
             //TODO: handle constant functions
-            let alloc_fld: IString = format!("alloc_{alloc_id:x}").into();
+            let alloc_fld: IString = format!("al_{alloc_id:x}").into();
             let field_desc = StaticFieldDescriptor::new(None, ptr!(Type::U8), alloc_fld.clone());
             asm.add_static(ptr!(Type::U8), &alloc_fld, false);
 
@@ -662,7 +662,7 @@ pub fn add_allocation(
     // Alloc ids are *not* unique across all crates. Adding the hash here ensures we don't overwrite allocations during linking
     // TODO:consider using something better here / making the hashes stable.
     let byte_hash = calculate_hash(&bytes);
-    let alloc_fld: IString = format!("a_{}{}", encode(alloc_id), encode(byte_hash)).into();
+    let alloc_fld: IString = format!("al_{}_{}", encode(alloc_id), encode(byte_hash)).into();
     let field_desc = StaticFieldDescriptor::new(None, ptr!(Type::U8), alloc_fld.clone());
     if !asm.static_fields().contains_key(&alloc_fld) {
         let init_method =