new ra wip

[bigint-presentation-code.git] / register_allocator / src / interned.rs

diff --git a/register_allocator/src/interned.rs b/register_allocator/src/interned.rs
index f28d6af9de6078f57c70e86af1c6420d58eef910..f99839fc2ca48f7603ddbaa57110e90403f6c5fa 100644 (file)
--- a/register_allocator/src/interned.rs
+++ b/register_allocator/src/interned.rs
@@ -9,6 +9,11 @@ use std::{
     rc::Rc,
 };
 
+use crate::{
+    loc::Loc,
+    loc_set::{LocSet, LocSetMaxConflictsWith},
+};
+
 #[derive(Clone)]
 pub struct Interned<T: ?Sized> {
     ptr: Rc<T>,
@@ -72,25 +77,28 @@ impl<T: ?Sized> Ord for Interned<T> {
 #[derive(Default)]
 struct Interners {
     str: Interner<str>,
+    loc_set: Interner<LocSet>,
+    loc_set_max_conflicts_with_loc_set: Interner<LocSetMaxConflictsWith<Interned<LocSet>>>,
+    loc_set_max_conflicts_with_loc: Interner<LocSetMaxConflictsWith<Loc>>,
 }
 
-pub struct GlobalArena {
+pub struct GlobalState {
     interners: Interners,
 }
 
-scoped_tls::scoped_thread_local!(static GLOBAL_ARENA: GlobalArena);
+scoped_tls::scoped_thread_local!(static GLOBAL_STATE: GlobalState);
 
-impl GlobalArena {
+impl GlobalState {
     pub fn scope<R>(f: impl FnOnce() -> R) -> R {
-        GLOBAL_ARENA.set(
-            &GlobalArena {
+        GLOBAL_STATE.set(
+            &GlobalState {
                 interners: Interners::default(),
             },
             f,
         )
     }
-    pub fn get<R>(f: impl for<'a> FnOnce(&'a GlobalArena) -> R) -> R {
-        GLOBAL_ARENA.with(f)
+    pub fn get<R>(f: impl for<'a> FnOnce(&'a GlobalState) -> R) -> R {
+        GLOBAL_STATE.with(f)
     }
 }
 
@@ -135,26 +143,26 @@ impl<T: ?Sized + Eq + Hash> Interner<T> {
 }
 
 pub trait InternTarget: Intern<Target = Self> + Hash + Eq {
-    fn get_interner(global_arena: &GlobalArena) -> &Interner<Self>;
-    fn into_interned(input: Self, global_arena: &GlobalArena) -> Interned<Self>
+    fn get_interner(global_state: &GlobalState) -> &Interner<Self>;
+    fn into_interned(input: Self, global_state: &GlobalState) -> Interned<Self>
     where
         Self: Sized,
     {
-        Self::get_interner(global_arena).intern(InternInput {
+        Self::get_interner(global_state).intern(InternInput {
             input,
             borrow: |v| v,
             into_rc: Rc::new,
         })
     }
-    fn rc_into_interned(input: Rc<Self>, global_arena: &GlobalArena) -> Interned<Self> {
-        Self::get_interner(global_arena).intern(InternInput {
+    fn rc_into_interned(input: Rc<Self>, global_state: &GlobalState) -> Interned<Self> {
+        Self::get_interner(global_state).intern(InternInput {
             input,
             borrow: |v| &**v,
             into_rc: |v| v,
         })
     }
-    fn rc_to_interned(input: &Rc<Self>, global_arena: &GlobalArena) -> Interned<Self> {
-        Self::get_interner(global_arena).intern(InternInput {
+    fn rc_to_interned(input: &Rc<Self>, global_state: &GlobalState) -> Interned<Self> {
+        Self::get_interner(global_state).intern(InternInput {
             input,
             borrow: |v| &***v,
             into_rc: |v| v.clone(),
@@ -163,8 +171,8 @@ pub trait InternTarget: Intern<Target = Self> + Hash + Eq {
 }
 
 impl InternTarget for str {
-    fn get_interner(global_arena: &GlobalArena) -> &Interner<Self> {
-        &global_arena.interners.str
+    fn get_interner(global_state: &GlobalState) -> &Interner<Self> {
+        &global_state.interners.str
     }
 }
 
@@ -175,8 +183,8 @@ impl Intern for str {
         v.into()
     }
 
-    fn to_interned(&self, global_arena: &GlobalArena) -> Interned<Self::Target> {
-        Self::get_interner(global_arena).intern(InternInput {
+    fn to_interned(&self, global_state: &GlobalState) -> Interned<Self::Target> {
+        Self::get_interner(global_state).intern(InternInput {
             input: self,
             borrow: |v| &**v,
             into_rc: Self::to_rc_target,
@@ -191,15 +199,15 @@ impl Intern for &'_ str {
         Rc::from(*v)
     }
 
-    fn to_interned(&self, global_arena: &GlobalArena) -> Interned<Self::Target> {
-        Self::Target::to_interned(self, global_arena)
+    fn to_interned(&self, global_state: &GlobalState) -> Interned<Self::Target> {
+        Self::Target::to_interned(self, global_state)
     }
 
-    fn into_interned(self, global_arena: &GlobalArena) -> Interned<Self::Target>
+    fn into_interned(self, global_state: &GlobalState) -> Interned<Self::Target>
     where
         Self: Sized,
     {
-        Self::Target::to_interned(self, global_arena)
+        Self::Target::to_interned(self, global_state)
     }
 }
 
@@ -210,15 +218,15 @@ impl Intern for &'_ mut str {
         Rc::from(&**v)
     }
 
-    fn to_interned(&self, global_arena: &GlobalArena) -> Interned<Self::Target> {
-        Self::Target::to_interned(self, global_arena)
+    fn to_interned(&self, global_state: &GlobalState) -> Interned<Self::Target> {
+        Self::Target::to_interned(self, global_state)
     }
 
-    fn into_interned(self, global_arena: &GlobalArena) -> Interned<Self::Target>
+    fn into_interned(self, global_state: &GlobalState) -> Interned<Self::Target>
     where
         Self: Sized,
     {
-        Self::Target::to_interned(self, global_arena)
+        Self::Target::to_interned(self, global_state)
     }
 }
 
@@ -229,8 +237,8 @@ impl Intern for String {
         Rc::from(&**v)
     }
 
-    fn to_interned(&self, global_arena: &GlobalArena) -> Interned<Self::Target> {
-        Self::Target::to_interned(self, global_arena)
+    fn to_interned(&self, global_state: &GlobalState) -> Interned<Self::Target> {
+        Self::Target::to_interned(self, global_state)
     }
 
     fn into_rc_target(v: Self) -> Rc<Self::Target>
@@ -240,11 +248,11 @@ impl Intern for String {
         Rc::from(v)
     }
 
-    fn into_interned(self, global_arena: &GlobalArena) -> Interned<Self::Target>
+    fn into_interned(self, global_state: &GlobalState) -> Interned<Self::Target>
     where
         Self: Sized,
     {
-        Self::Target::to_interned(&self, global_arena)
+        Self::Target::to_interned(&self, global_state)
     }
 }
 
@@ -257,17 +265,17 @@ pub trait Intern {
         Self::to_rc_target(&v)
     }
     fn to_rc_target(v: &Self) -> Rc<Self::Target>;
-    fn into_interned(self, global_arena: &GlobalArena) -> Interned<Self::Target>
+    fn into_interned(self, global_state: &GlobalState) -> Interned<Self::Target>
     where
         Self: Sized,
     {
         <<Self as Intern>::Target as InternTarget>::rc_into_interned(
             Self::into_rc_target(self),
-            global_arena,
+            global_state,
         )
     }
-    fn to_interned(&self, global_arena: &GlobalArena) -> Interned<Self::Target> {
-        Self::Target::rc_into_interned(Self::to_rc_target(self), global_arena)
+    fn to_interned(&self, global_state: &GlobalState) -> Interned<Self::Target> {
+        Self::Target::rc_into_interned(Self::to_rc_target(self), global_state)
     }
 }
 
@@ -300,18 +308,36 @@ impl<T: Clone + InternTarget> Intern for T {
         v.into()
     }
 
-    fn into_interned(self, global_arena: &GlobalArena) -> Interned<Self::Target>
+    fn into_interned(self, global_state: &GlobalState) -> Interned<Self::Target>
     where
         Self: Sized,
     {
-        InternTarget::into_interned(self, global_arena)
+        InternTarget::into_interned(self, global_state)
     }
 
-    fn to_interned(&self, global_arena: &GlobalArena) -> Interned<Self::Target> {
-        InternTarget::get_interner(global_arena).intern(InternInput {
+    fn to_interned(&self, global_state: &GlobalState) -> Interned<Self::Target> {
+        InternTarget::get_interner(global_state).intern(InternInput {
             input: self,
             borrow: |v| &**v,
             into_rc: |v| v.clone().into(),
         })
     }
 }
+
+impl InternTarget for LocSet {
+    fn get_interner(global_state: &GlobalState) -> &Interner<Self> {
+        &global_state.interners.loc_set
+    }
+}
+
+impl InternTarget for LocSetMaxConflictsWith<Interned<LocSet>> {
+    fn get_interner(global_state: &GlobalState) -> &Interner<Self> {
+        &global_state.interners.loc_set_max_conflicts_with_loc_set
+    }
+}
+
+impl InternTarget for LocSetMaxConflictsWith<Loc> {
+    fn get_interner(global_state: &GlobalState) -> &Interner<Self> {
+        &global_state.interners.loc_set_max_conflicts_with_loc
+    }
+}