Rollup merge of #132247 - workingjubilee:add-rustc-abi-to-smir, r=celinval

workingjubilee · web-flow · commit e20026cac087 · 2024-10-28T10:18:49.000-07:00
stable_mir: Directly use types from rustc_abi

In most cases, rustc_target is not necessary, so use rustc_abi instead of its reexports.
diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs
@@ -170,7 +170,7 @@ impl<'tcx> Tables<'tcx> {
         stable_mir::mir::mono::StaticDef(self.create_def_id(did))
     }
 
-    pub(crate) fn layout_id(&mut self, layout: rustc_target::abi::Layout<'tcx>) -> Layout {
+    pub(crate) fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> Layout {
         self.layouts.create_or_fetch(layout)
     }
 }
diff --git a/compiler/rustc_smir/src/rustc_smir/alloc.rs b/compiler/rustc_smir/src/rustc_smir/alloc.rs
@@ -1,3 +1,4 @@
+use rustc_abi::{Align, Size};
 use rustc_middle::mir::ConstValue;
 use rustc_middle::mir::interpret::{AllocRange, Pointer, alloc_range};
 use stable_mir::Error;
@@ -7,7 +8,7 @@ use stable_mir::ty::{Allocation, ProvenanceMap};
 use crate::rustc_smir::{Stable, Tables};
 
 /// Creates new empty `Allocation` from given `Align`.
-fn new_empty_allocation(align: rustc_target::abi::Align) -> Allocation {
+fn new_empty_allocation(align: Align) -> Allocation {
     Allocation {
         bytes: Vec::new(),
         provenance: ProvenanceMap { ptrs: Vec::new() },
@@ -45,7 +46,7 @@ pub(crate) fn try_new_allocation<'tcx>(
                 .align;
             let mut allocation = rustc_middle::mir::interpret::Allocation::uninit(size, align.abi);
             allocation
-                .write_scalar(&tables.tcx, alloc_range(rustc_target::abi::Size::ZERO, size), scalar)
+                .write_scalar(&tables.tcx, alloc_range(Size::ZERO, size), scalar)
                 .map_err(|e| e.stable(tables))?;
             allocation.stable(tables)
         }
@@ -59,7 +60,7 @@ pub(crate) fn try_new_allocation<'tcx>(
         }
         ConstValue::Slice { data, meta } => {
             let alloc_id = tables.tcx.reserve_and_set_memory_alloc(data);
-            let ptr = Pointer::new(alloc_id.into(), rustc_target::abi::Size::ZERO);
+            let ptr = Pointer::new(alloc_id.into(), Size::ZERO);
             let scalar_ptr = rustc_middle::mir::interpret::Scalar::from_pointer(ptr, &tables.tcx);
             let scalar_meta =
                 rustc_middle::mir::interpret::Scalar::from_target_usize(meta, &tables.tcx);
@@ -72,7 +73,7 @@ pub(crate) fn try_new_allocation<'tcx>(
             allocation
                 .write_scalar(
                     &tables.tcx,
-                    alloc_range(rustc_target::abi::Size::ZERO, tables.tcx.data_layout.pointer_size),
+                    alloc_range(Size::ZERO, tables.tcx.data_layout.pointer_size),
                     scalar_ptr,
                 )
                 .map_err(|e| e.stable(tables))?;
@@ -112,10 +113,7 @@ pub(super) fn allocation_filter<'tcx>(
         .map(Some)
         .collect();
     for (i, b) in bytes.iter_mut().enumerate() {
-        if !alloc
-            .init_mask()
-            .get(rustc_target::abi::Size::from_bytes(i + alloc_range.start.bytes_usize()))
-        {
+        if !alloc.init_mask().get(Size::from_bytes(i + alloc_range.start.bytes_usize())) {
             *b = None;
         }
     }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/abi.rs b/compiler/rustc_smir/src/rustc_smir/convert/abi.rs
@@ -1,9 +1,9 @@
-//! Conversion of internal Rust compiler `rustc_target::abi` and `rustc_abi` items to stable ones.
+//! Conversion of internal Rust compiler `rustc_target` and `rustc_abi` items to stable ones.
 
 #![allow(rustc::usage_of_qualified_ty)]
 
 use rustc_middle::ty;
-use rustc_target::abi::call::Conv;
+use rustc_target::callconv::{self, Conv};
 use stable_mir::abi::{
     AddressSpace, ArgAbi, CallConvention, FieldsShape, FloatLength, FnAbi, IntegerLength, Layout,
     LayoutShape, PassMode, Primitive, Scalar, TagEncoding, TyAndLayout, ValueAbi, VariantsShape,
@@ -15,7 +15,7 @@ use stable_mir::ty::{Align, IndexedVal, VariantIdx};
 
 use crate::rustc_smir::{Stable, Tables};
 
-impl<'tcx> Stable<'tcx> for rustc_target::abi::VariantIdx {
+impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx {
     type T = VariantIdx;
     fn stable(&self, _: &mut Tables<'_>) -> Self::T {
         VariantIdx::to_val(self.as_usize())
@@ -33,25 +33,23 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Endian {
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_target::abi::TyAndLayout<'tcx, ty::Ty<'tcx>> {
+impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> {
     type T = TyAndLayout;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
         TyAndLayout { ty: self.ty.stable(tables), layout: self.layout.stable(tables) }
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_target::abi::Layout<'tcx> {
+impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> {
     type T = Layout;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
         tables.layout_id(tables.tcx.lift(*self).unwrap())
     }
 }
 
-impl<'tcx> Stable<'tcx>
-    for rustc_abi::LayoutData<rustc_target::abi::FieldIdx, rustc_target::abi::VariantIdx>
-{
+impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {
     type T = LayoutShape;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
@@ -65,7 +63,7 @@ impl<'tcx> Stable<'tcx>
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::FnAbi<'tcx, ty::Ty<'tcx>> {
+impl<'tcx> Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> {
     type T = FnAbi;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
@@ -81,7 +79,7 @@ impl<'tcx> Stable<'tcx> for rustc_target::abi::call::FnAbi<'tcx, ty::Ty<'tcx>> {
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::ArgAbi<'tcx, ty::Ty<'tcx>> {
+impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> {
     type T = ArgAbi;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
@@ -93,7 +91,7 @@ impl<'tcx> Stable<'tcx> for rustc_target::abi::call::ArgAbi<'tcx, ty::Ty<'tcx>>
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::Conv {
+impl<'tcx> Stable<'tcx> for callconv::Conv {
     type T = CallConvention;
 
     fn stable(&self, _tables: &mut Tables<'_>) -> Self::T {
@@ -122,31 +120,29 @@ impl<'tcx> Stable<'tcx> for rustc_target::abi::call::Conv {
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::PassMode {
+impl<'tcx> Stable<'tcx> for callconv::PassMode {
     type T = PassMode;
 
     fn stable(&self, _tables: &mut Tables<'_>) -> Self::T {
         match self {
-            rustc_target::abi::call::PassMode::Ignore => PassMode::Ignore,
-            rustc_target::abi::call::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)),
-            rustc_target::abi::call::PassMode::Pair(first, second) => {
+            callconv::PassMode::Ignore => PassMode::Ignore,
+            callconv::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)),
+            callconv::PassMode::Pair(first, second) => {
                 PassMode::Pair(opaque(first), opaque(second))
             }
-            rustc_target::abi::call::PassMode::Cast { pad_i32, cast } => {
+            callconv::PassMode::Cast { pad_i32, cast } => {
                 PassMode::Cast { pad_i32: *pad_i32, cast: opaque(cast) }
             }
-            rustc_target::abi::call::PassMode::Indirect { attrs, meta_attrs, on_stack } => {
-                PassMode::Indirect {
-                    attrs: opaque(attrs),
-                    meta_attrs: opaque(meta_attrs),
-                    on_stack: *on_stack,
-                }
-            }
+            callconv::PassMode::Indirect { attrs, meta_attrs, on_stack } => PassMode::Indirect {
+                attrs: opaque(attrs),
+                meta_attrs: opaque(meta_attrs),
+                on_stack: *on_stack,
+            },
         }
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_target::abi::FieldIdx> {
+impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_abi::FieldIdx> {
     type T = FieldsShape;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
@@ -163,9 +159,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_target::abi::FieldIdx>
     }
 }
 
-impl<'tcx> Stable<'tcx>
-    for rustc_abi::Variants<rustc_target::abi::FieldIdx, rustc_target::abi::VariantIdx>
-{
+impl<'tcx> Stable<'tcx> for rustc_abi::Variants<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {
     type T = VariantsShape;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
@@ -185,7 +179,7 @@ impl<'tcx> Stable<'tcx>
     }
 }
 
-impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding<rustc_target::abi::VariantIdx> {
+impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding<rustc_abi::VariantIdx> {
     type T = TagEncoding;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
@@ -691,11 +691,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::Allocation {
     type T = stable_mir::ty::Allocation;
 
     fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
-        alloc::allocation_filter(
-            self,
-            alloc_range(rustc_target::abi::Size::ZERO, self.size()),
-            tables,
-        )
+        alloc::allocation_filter(self, alloc_range(rustc_abi::Size::ZERO, self.size()), tables)
     }
 }
 
diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs
@@ -36,7 +36,7 @@ pub struct Tables<'tcx> {
     pub(crate) instances: IndexMap<ty::Instance<'tcx>, InstanceDef>,
     pub(crate) ty_consts: IndexMap<ty::Const<'tcx>, TyConstId>,
     pub(crate) mir_consts: IndexMap<mir::Const<'tcx>, MirConstId>,
-    pub(crate) layouts: IndexMap<rustc_target::abi::Layout<'tcx>, Layout>,
+    pub(crate) layouts: IndexMap<rustc_abi::Layout<'tcx>, Layout>,
 }
 
 impl<'tcx> Tables<'tcx> {

Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ impl<'tcx> Tables<'tcx> {`
`170`	`170`	`stable_mir::mir::mono::StaticDef(self.create_def_id(did))`
`171`	`171`	`}`
`172`	`172`
`173`		`- pub(crate) fn layout_id(&mut self, layout: rustc_target::abi::Layout<'tcx>) -> Layout {`
	`173`	`+ pub(crate) fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> Layout {`
`174`	`174`	`self.layouts.create_or_fetch(layout)`
`175`	`175`	`}`
`176`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,9 @@`
`1`		-//! Conversion of internal Rust compiler `rustc_target::abi` and `rustc_abi` items to stable ones.
	`1`	+//! Conversion of internal Rust compiler `rustc_target` and `rustc_abi` items to stable ones.
`2`	`2`
`3`	`3`	`#![allow(rustc::usage_of_qualified_ty)]`
`4`	`4`
`5`	`5`	`use rustc_middle::ty;`
`6`		`-use rustc_target::abi::call::Conv;`
	`6`	`+use rustc_target::callconv::{self, Conv};`
`7`	`7`	`use stable_mir::abi::{`
`8`	`8`	`AddressSpace, ArgAbi, CallConvention, FieldsShape, FloatLength, FnAbi, IntegerLength, Layout,`
`9`	`9`	`LayoutShape, PassMode, Primitive, Scalar, TagEncoding, TyAndLayout, ValueAbi, VariantsShape,`
`@@ -15,7 +15,7 @@ use stable_mir::ty::{Align, IndexedVal, VariantIdx};`
`15`	`15`
`16`	`16`	`use crate::rustc_smir::{Stable, Tables};`
`17`	`17`
`18`		`-impl<'tcx> Stable<'tcx> for rustc_target::abi::VariantIdx {`
	`18`	`+impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx {`
`19`	`19`	`type T = VariantIdx;`
`20`	`20`	`fn stable(&self, _: &mut Tables<'_>) -> Self::T {`
`21`	`21`	`VariantIdx::to_val(self.as_usize())`
`@@ -33,25 +33,23 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Endian {`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`-impl<'tcx> Stable<'tcx> for rustc_target::abi::TyAndLayout<'tcx, ty::Ty<'tcx>> {`
	`36`	`+impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> {`
`37`	`37`	`type T = TyAndLayout;`
`38`	`38`
`39`	`39`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`40`	`40`	`TyAndLayout { ty: self.ty.stable(tables), layout: self.layout.stable(tables) }`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`		`-impl<'tcx> Stable<'tcx> for rustc_target::abi::Layout<'tcx> {`
	`44`	`+impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> {`
`45`	`45`	`type T = Layout;`
`46`	`46`
`47`	`47`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`48`	`48`	`tables.layout_id(tables.tcx.lift(*self).unwrap())`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`		`-impl<'tcx> Stable<'tcx>`
`53`		`- for rustc_abi::LayoutData<rustc_target::abi::FieldIdx, rustc_target::abi::VariantIdx>`
`54`		`-{`
	`52`	`+impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {`
`55`	`53`	`type T = LayoutShape;`
`56`	`54`
`57`	`55`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`@@ -65,7 +63,7 @@ impl<'tcx> Stable<'tcx>`
`65`	`63`	`}`
`66`	`64`	`}`
`67`	`65`
`68`		`-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::FnAbi<'tcx, ty::Ty<'tcx>> {`
	`66`	`+impl<'tcx> Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> {`
`69`	`67`	`type T = FnAbi;`
`70`	`68`
`71`	`69`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`@@ -81,7 +79,7 @@ impl<'tcx> Stable<'tcx> for rustc_target::abi::call::FnAbi<'tcx, ty::Ty<'tcx>> {`
`81`	`79`	`}`
`82`	`80`	`}`
`83`	`81`
`84`		`-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::ArgAbi<'tcx, ty::Ty<'tcx>> {`
	`82`	`+impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> {`
`85`	`83`	`type T = ArgAbi;`
`86`	`84`
`87`	`85`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`@@ -93,7 +91,7 @@ impl<'tcx> Stable<'tcx> for rustc_target::abi::call::ArgAbi<'tcx, ty::Ty<'tcx>>`
`93`	`91`	`}`
`94`	`92`	`}`
`95`	`93`
`96`		`-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::Conv {`
	`94`	`+impl<'tcx> Stable<'tcx> for callconv::Conv {`
`97`	`95`	`type T = CallConvention;`
`98`	`96`
`99`	`97`	`fn stable(&self, _tables: &mut Tables<'_>) -> Self::T {`
`@@ -122,31 +120,29 @@ impl<'tcx> Stable<'tcx> for rustc_target::abi::call::Conv {`
`122`	`120`	`}`
`123`	`121`	`}`
`124`	`122`
`125`		`-impl<'tcx> Stable<'tcx> for rustc_target::abi::call::PassMode {`
	`123`	`+impl<'tcx> Stable<'tcx> for callconv::PassMode {`
`126`	`124`	`type T = PassMode;`
`127`	`125`
`128`	`126`	`fn stable(&self, _tables: &mut Tables<'_>) -> Self::T {`
`129`	`127`	`match self {`
`130`		`- rustc_target::abi::call::PassMode::Ignore => PassMode::Ignore,`
`131`		`- rustc_target::abi::call::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)),`
`132`		`- rustc_target::abi::call::PassMode::Pair(first, second) => {`
	`128`	`+ callconv::PassMode::Ignore => PassMode::Ignore,`
	`129`	`+ callconv::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)),`
	`130`	`+ callconv::PassMode::Pair(first, second) => {`
`133`	`131`	`PassMode::Pair(opaque(first), opaque(second))`
`134`	`132`	`}`
`135`		`- rustc_target::abi::call::PassMode::Cast { pad_i32, cast } => {`
	`133`	`+ callconv::PassMode::Cast { pad_i32, cast } => {`
`136`	`134`	`PassMode::Cast { pad_i32: *pad_i32, cast: opaque(cast) }`
`137`	`135`	`}`
`138`		`- rustc_target::abi::call::PassMode::Indirect { attrs, meta_attrs, on_stack } => {`
`139`		`- PassMode::Indirect {`
`140`		`- attrs: opaque(attrs),`
`141`		`- meta_attrs: opaque(meta_attrs),`
`142`		`- on_stack: *on_stack,`
`143`		`- }`
`144`		`- }`
	`136`	`+ callconv::PassMode::Indirect { attrs, meta_attrs, on_stack } => PassMode::Indirect {`
	`137`	`+ attrs: opaque(attrs),`
	`138`	`+ meta_attrs: opaque(meta_attrs),`
	`139`	`+ on_stack: *on_stack,`
	`140`	`+ },`
`145`	`141`	`}`
`146`	`142`	`}`
`147`	`143`	`}`
`148`	`144`
`149`		`-impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_target::abi::FieldIdx> {`
	`145`	`+impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_abi::FieldIdx> {`
`150`	`146`	`type T = FieldsShape;`
`151`	`147`
`152`	`148`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`@@ -163,9 +159,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_target::abi::FieldIdx>`
`163`	`159`	`}`
`164`	`160`	`}`
`165`	`161`
`166`		`-impl<'tcx> Stable<'tcx>`
`167`		`- for rustc_abi::Variants<rustc_target::abi::FieldIdx, rustc_target::abi::VariantIdx>`
`168`		`-{`
	`162`	`+impl<'tcx> Stable<'tcx> for rustc_abi::Variants<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {`
`169`	`163`	`type T = VariantsShape;`
`170`	`164`
`171`	`165`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`@@ -185,7 +179,7 @@ impl<'tcx> Stable<'tcx>`
`185`	`179`	`}`
`186`	`180`	`}`
`187`	`181`
`188`		`-impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding<rustc_target::abi::VariantIdx> {`
	`182`	`+impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding<rustc_abi::VariantIdx> {`
`189`	`183`	`type T = TagEncoding;`
`190`	`184`
`191`	`185`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
Original file line number	Diff line number	Diff line change
`@@ -691,11 +691,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::Allocation {`
`691`	`691`	`type T = stable_mir::ty::Allocation;`
`692`	`692`
`693`	`693`	`fn stable(&self, tables: &mut Tables<'_>) -> Self::T {`
`694`		`- alloc::allocation_filter(`
`695`		`- self,`
`696`		`- alloc_range(rustc_target::abi::Size::ZERO, self.size()),`
`697`		`- tables,`
`698`		`- )`
	`694`	`+ alloc::allocation_filter(self, alloc_range(rustc_abi::Size::ZERO, self.size()), tables)`
`699`	`695`	`}`
`700`	`696`	`}`
`701`	`697`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ pub struct Tables<'tcx> {`
`36`	`36`	`pub(crate) instances: IndexMap<ty::Instance<'tcx>, InstanceDef>,`
`37`	`37`	`pub(crate) ty_consts: IndexMap<ty::Const<'tcx>, TyConstId>,`
`38`	`38`	`pub(crate) mir_consts: IndexMap<mir::Const<'tcx>, MirConstId>,`
`39`		`- pub(crate) layouts: IndexMap<rustc_target::abi::Layout<'tcx>, Layout>,`
	`39`	`+ pub(crate) layouts: IndexMap<rustc_abi::Layout<'tcx>, Layout>,`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`impl<'tcx> Tables<'tcx> {`