implement a new bridge trait Allocation

Author: makai410

compiler/rustc_smir/src/rustc_smir/alloc.rs

@@ -10,7 +10,8 @@ use rustc_middle::mir::interpret::{
 };
 use rustc_middle::ty::{Ty, layout};
 
-use super::SmirCtxt;
+use super::{SmirCtxt, Tables};
+use crate::rustc_smir::bridge::Allocation as _;
 use crate::rustc_smir::{Bridge, SmirError};
 
 pub fn create_ty_and_layout<'tcx, B: Bridge>(
@@ -70,10 +71,12 @@ pub fn try_new_indirect<'tcx, B: Bridge>(
 }
 
 /// Creates an `Allocation` only from information within the `AllocRange`.
-pub fn allocation_filter(
+pub fn allocation_filter<'tcx, B: Bridge>(
     alloc: &rustc_middle::mir::interpret::Allocation,
     alloc_range: AllocRange,
-) -> (Vec<Option<u8>>, Vec<(usize, AllocId)>) {
+    tables: &mut Tables<'tcx, B>,
+    cx: &SmirCtxt<'tcx, B>,
+) -> B::Allocation {
     let mut bytes: Vec<Option<u8>> = alloc
         .inspect_with_uninit_and_ptr_outside_interpreter(
             alloc_range.start.bytes_usize()..alloc_range.end().bytes_usize(),
@@ -97,5 +100,5 @@ pub fn allocation_filter(
         ptrs.push((offset.bytes_usize() - alloc_range.start.bytes_usize(), prov.alloc_id()));
     }
 
-    (bytes, ptrs)
+    B::Allocation::new(bytes, ptrs, alloc.align.bytes(), alloc.mutability, tables, cx)
 }

compiler/rustc_smir/src/rustc_smir/bridge.rs

@@ -6,7 +6,8 @@
 
 use std::fmt::Debug;
 
-use super::Bridge;
+use super::context::SmirCtxt;
+use super::{Bridge, Tables};
 
 pub trait SmirError {
     fn new(msg: String) -> Self;
@@ -17,6 +18,17 @@ pub trait Prov<B: Bridge> {
     fn new(aid: B::AllocId) -> Self;
 }
 
+pub trait Allocation<B: Bridge> {
+    fn new<'tcx>(
+        bytes: Vec<Option<u8>>,
+        ptrs: Vec<(usize, rustc_middle::mir::interpret::AllocId)>,
+        align: u64,
+        mutability: rustc_middle::mir::Mutability,
+        tables: &mut Tables<'tcx, B>,
+        cx: &SmirCtxt<'tcx, B>,
+    ) -> Self;
+}
+
 macro_rules! make_bridge_trait {
     ($name:ident) => {
         pub trait $name<B: Bridge> {

compiler/rustc_smir/src/rustc_smir/mod.rs

@@ -225,6 +225,8 @@ pub trait Bridge: Sized {
     type OpaqueDef: OpaqueDef<Self>;
     type Prov: Prov<Self>;
     type StaticDef: StaticDef<Self>;
+
+    type Allocation: Allocation<Self>;
 }
 
 pub trait IndexedVal {

compiler/rustc_smir/src/stable_mir/alloc.rs

@@ -73,12 +73,5 @@ pub(super) fn allocation_filter<'tcx>(
     tables: &mut Tables<'tcx, BridgeTys>,
     cx: &SmirCtxt<'tcx, BridgeTys>,
 ) -> Allocation {
-    let (bytes, ptrs) = alloc::allocation_filter(alloc, alloc_range);
-    let ptrs = ptrs.iter().map(|(i, aid)| (*i, tables.prov(*aid))).collect();
-    Allocation {
-        bytes,
-        provenance: ProvenanceMap { ptrs },
-        align: alloc.align.bytes(),
-        mutability: alloc.mutability.stable(tables, cx),
-    }
+    alloc::allocation_filter(alloc, alloc_range, tables, cx)
 }

compiler/rustc_smir/src/stable_mir/compiler_interface.rs

@@ -63,6 +63,8 @@ impl Bridge for BridgeTys {
     type OpaqueDef = stable_mir::ty::OpaqueDef;
     type Prov = stable_mir::ty::Prov;
     type StaticDef = stable_mir::mir::mono::StaticDef;
+
+    type Allocation = stable_mir::ty::Allocation;
 }
 
 /// Stable public API for querying compiler information.

compiler/rustc_smir/src/stable_mir/mod.rs

@@ -28,13 +28,18 @@ use std::fmt::Debug;
 use std::{fmt, io};
 
 pub(crate) use rustc_smir::IndexedVal;
+use rustc_smir::Tables;
+use rustc_smir::context::SmirCtxt;
 use serde::Serialize;
 use stable_mir::compiler_interface::with;
 pub use stable_mir::crate_def::{CrateDef, CrateDefItems, CrateDefType, DefId};
 pub use stable_mir::error::*;
 use stable_mir::mir::mono::StaticDef;
 use stable_mir::mir::{Body, Mutability};
-use stable_mir::ty::{AssocItem, FnDef, ForeignModuleDef, ImplDef, Span, TraitDef, Ty};
+use stable_mir::ty::{
+    AssocItem, FnDef, ForeignModuleDef, ImplDef, ProvenanceMap, Span, TraitDef, Ty,
+};
+use stable_mir::unstable::Stable;
 
 use crate::{rustc_smir, stable_mir};
 
@@ -277,3 +282,23 @@ impl rustc_smir::bridge::Prov<compiler_interface::BridgeTys> for stable_mir::ty:
         Self(aid)
     }
 }
+
+impl rustc_smir::bridge::Allocation<compiler_interface::BridgeTys> for stable_mir::ty::Allocation {
+    fn new<'tcx>(
+        bytes: Vec<Option<u8>>,
+        ptrs: Vec<(usize, rustc_middle::mir::interpret::AllocId)>,
+        align: u64,
+        mutability: rustc_middle::mir::Mutability,
+        tables: &mut Tables<'tcx, compiler_interface::BridgeTys>,
+        cx: &SmirCtxt<'tcx, compiler_interface::BridgeTys>,
+    ) -> Self {
+        Self {
+            bytes,
+            provenance: ProvenanceMap {
+                ptrs: ptrs.iter().map(|(i, aid)| (*i, tables.prov(*aid))).collect(),
+            },
+            align,
+            mutability: mutability.stable(tables, cx),
+        }
+    }
+}