mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #118927 - celinval:smir-missing-info, r=compiler-errors

Browse Source 
Erase late bound regions from `Instance::fn_sig()` and add a few more details to StableMIR APIs

The Instance `fn_sig()` still included a late bound regions which needed a new compiler function in order to be erased. I've also bundled the following small fixes in this PR, let me know if you want me to isolate any of them.

  - Add missing `CoroutineKind::AsyncGen`.
  - Add optional spread argument to function body which is needed to properly analyze compiler shims.
  - Add a utility method to iterate over all locals together with their declaration.
  - Add a method to get the description of `AssertMessage`*.

* For the last one, we could consider eventually calling the internal `AssertKind::description()` to avoid code duplication. However, we still don't have ways to convert `AssertMessage`, `Operand`, `Place` and others, in order to use that. The other downside of using the internal method is that it will panic for some of the variants.

r ? `@ouz-a`
This commit is contained in:
Ali MJ Al-Nasrawy 2023-12-15 10:58:23 +03:00 committed by GitHub
commit 578758ae04
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 95 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
compiler/rustc_smir/src/rustc_smir/context.rs
View File

@ -5,7 +5,9 @@
use rustc_middle::ty; use rustc_middle::ty;
use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths}; use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths};
use rustc_middle::ty::{GenericPredicates, Instance, ParamEnv, ScalarInt, ValTree}; use rustc_middle::ty::{
GenericPredicates, Instance, ParamEnv, ScalarInt, TypeVisitableExt, ValTree,
};
use rustc_span::def_id::LOCAL_CRATE; use rustc_span::def_id::LOCAL_CRATE;
use stable_mir::compiler_interface::Context; use stable_mir::compiler_interface::Context;
use stable_mir::mir::alloc::GlobalAlloc; use stable_mir::mir::alloc::GlobalAlloc;
@ -324,7 +326,8 @@ fn instance_body(&self, def: InstanceDef) -> Option<Body> {
fn instance_ty(&self, def: InstanceDef) -> stable_mir::ty::Ty { fn instance_ty(&self, def: InstanceDef) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let instance = tables.instances[def]; let instance = tables.instances[def];
instance.ty(tables.tcx, ParamEnv::empty()).stable(&mut *tables) assert!(!instance.has_non_region_param(), "{instance:?} needs further substitution");
instance.ty(tables.tcx, ParamEnv::reveal_all()).stable(&mut *tables)
} }
fn instance_def_id(&self, def: InstanceDef) -> stable_mir::DefId { fn instance_def_id(&self, def: InstanceDef) -> stable_mir::DefId {

1
compiler/rustc_smir/src/rustc_smir/convert/mir.rs
View File

@ -36,6 +36,7 @@ fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T {
.collect(), .collect(),
self.arg_count, self.arg_count,
self.var_debug_info.iter().map(|info| info.stable(tables)).collect(), self.var_debug_info.iter().map(|info| info.stable(tables)).collect(),
self.spread_arg.stable(tables),
) )
} }
} }

4
compiler/rustc_smir/src/rustc_smir/convert/mod.rs
View File

@ -57,7 +57,9 @@ fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T {
stable_mir::mir::CoroutineKind::Gen(source.stable(tables)) stable_mir::mir::CoroutineKind::Gen(source.stable(tables))
} }
CoroutineKind::Coroutine => stable_mir::mir::CoroutineKind::Coroutine, CoroutineKind::Coroutine => stable_mir::mir::CoroutineKind::Coroutine,
CoroutineKind::AsyncGen(_) => todo!(), CoroutineKind::AsyncGen(source) => {
stable_mir::mir::CoroutineKind::AsyncGen(source.stable(tables))
}
} }
} }
} }

69
compiler/stable_mir/src/mir/body.rs
View File

@ -22,6 +22,11 @@ pub struct Body {
/// Debug information pertaining to user variables, including captures. /// Debug information pertaining to user variables, including captures.
pub var_debug_info: Vec<VarDebugInfo>, pub var_debug_info: Vec<VarDebugInfo>,
/// Mark an argument (which must be a tuple) as getting passed as its individual components.
///
/// This is used for the "rust-call" ABI such as closures.
pub(super) spread_arg: Option<Local>,
} }
pub type BasicBlockIdx = usize; pub type BasicBlockIdx = usize;
@ -36,6 +41,7 @@ pub fn new(
locals: LocalDecls, locals: LocalDecls,
arg_count: usize, arg_count: usize,
var_debug_info: Vec<VarDebugInfo>, var_debug_info: Vec<VarDebugInfo>,
spread_arg: Option<Local>,
) -> Self { ) -> Self {
// If locals doesn't contain enough entries, it can lead to panics in // If locals doesn't contain enough entries, it can lead to panics in
// `ret_local`, `arg_locals`, and `inner_locals`. // `ret_local`, `arg_locals`, and `inner_locals`.
@ -43,7 +49,7 @@ pub fn new(
locals.len() > arg_count, locals.len() > arg_count,
"A Body must contain at least a local for the return value and each of the function's arguments" "A Body must contain at least a local for the return value and each of the function's arguments"
); );
Self { blocks, locals, arg_count, var_debug_info } Self { blocks, locals, arg_count, var_debug_info, spread_arg }
} }
/// Return local that holds this function's return value. /// Return local that holds this function's return value.
@ -75,6 +81,11 @@ pub fn local_decl(&self, local: Local) -> Option<&LocalDecl> {
self.locals.get(local) self.locals.get(local)
} }
/// Get an iterator for all local declarations.
pub fn local_decls(&self) -> impl Iterator<Item = (Local, &LocalDecl)> {
self.locals.iter().enumerate()
}
pub fn dump<W: io::Write>(&self, w: &mut W) -> io::Result<()> { pub fn dump<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
writeln!(w, "{}", function_body(self))?; writeln!(w, "{}", function_body(self))?;
self.blocks self.blocks
@ -98,6 +109,10 @@ pub fn dump<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
.collect::<Result<Vec<_>, _>>()?; .collect::<Result<Vec<_>, _>>()?;
Ok(()) Ok(())
} }
pub fn spread_arg(&self) -> Option<Local> {
self.spread_arg
}
} }
type LocalDecls = Vec<LocalDecl>; type LocalDecls = Vec<LocalDecl>;
@ -248,6 +263,57 @@ pub enum AssertMessage {
MisalignedPointerDereference { required: Operand, found: Operand }, MisalignedPointerDereference { required: Operand, found: Operand },
} }
impl AssertMessage {
pub fn description(&self) -> Result<&'static str, Error> {
match self {
AssertMessage::Overflow(BinOp::Add, _, _) => Ok("attempt to add with overflow"),
AssertMessage::Overflow(BinOp::Sub, _, _) => Ok("attempt to subtract with overflow"),
AssertMessage::Overflow(BinOp::Mul, _, _) => Ok("attempt to multiply with overflow"),
AssertMessage::Overflow(BinOp::Div, _, _) => Ok("attempt to divide with overflow"),
AssertMessage::Overflow(BinOp::Rem, _, _) => {
Ok("attempt to calculate the remainder with overflow")
}
AssertMessage::OverflowNeg(_) => Ok("attempt to negate with overflow"),
AssertMessage::Overflow(BinOp::Shr, _, _) => Ok("attempt to shift right with overflow"),
AssertMessage::Overflow(BinOp::Shl, _, _) => Ok("attempt to shift left with overflow"),
AssertMessage::Overflow(op, _, _) => Err(error!("`{:?}` cannot overflow", op)),
AssertMessage::DivisionByZero(_) => Ok("attempt to divide by zero"),
AssertMessage::RemainderByZero(_) => {
Ok("attempt to calculate the remainder with a divisor of zero")
}
AssertMessage::ResumedAfterReturn(CoroutineKind::Coroutine) => {
Ok("coroutine resumed after completion")
}
AssertMessage::ResumedAfterReturn(CoroutineKind::Async(_)) => {
Ok("`async fn` resumed after completion")
}
AssertMessage::ResumedAfterReturn(CoroutineKind::Gen(_)) => {
Ok("`async gen fn` resumed after completion")
}
AssertMessage::ResumedAfterReturn(CoroutineKind::AsyncGen(_)) => {
Ok("`gen fn` should just keep returning `AssertMessage::None` after completion")
}
AssertMessage::ResumedAfterPanic(CoroutineKind::Coroutine) => {
Ok("coroutine resumed after panicking")
}
AssertMessage::ResumedAfterPanic(CoroutineKind::Async(_)) => {
Ok("`async fn` resumed after panicking")
}
AssertMessage::ResumedAfterPanic(CoroutineKind::Gen(_)) => {
Ok("`async gen fn` resumed after panicking")
}
AssertMessage::ResumedAfterPanic(CoroutineKind::AsyncGen(_)) => {
Ok("`gen fn` should just keep returning `AssertMessage::None` after panicking")
}
AssertMessage::BoundsCheck { .. } => Ok("index out of bounds"),
AssertMessage::MisalignedPointerDereference { .. } => {
Ok("misaligned pointer dereference")
}
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum BinOp { pub enum BinOp {
Add, Add,
@ -325,6 +391,7 @@ pub enum CoroutineKind {
Async(CoroutineSource), Async(CoroutineSource),
Coroutine, Coroutine,
Gen(CoroutineSource), Gen(CoroutineSource),
AsyncGen(CoroutineSource),
} }
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]

7
compiler/stable_mir/src/mir/mono.rs
View File

@ -1,6 +1,6 @@
use crate::crate_def::CrateDef; use crate::crate_def::CrateDef;
use crate::mir::Body; use crate::mir::Body;
use crate::ty::{Allocation, ClosureDef, ClosureKind, FnDef, FnSig, GenericArgs, IndexedVal, Ty}; use crate::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, IndexedVal, Ty};
use crate::{with, CrateItem, DefId, Error, ItemKind, Opaque, Symbol}; use crate::{with, CrateItem, DefId, Error, ItemKind, Opaque, Symbol};
use std::fmt::{Debug, Formatter}; use std::fmt::{Debug, Formatter};
@ -115,11 +115,6 @@ pub fn resolve_closure(
}) })
} }
/// Get this function signature with all types already instantiated.
pub fn fn_sig(&self) -> FnSig {
self.ty().kind().fn_sig().unwrap().skip_binder()
}
/// Check whether this instance is an empty shim. /// Check whether this instance is an empty shim.
/// ///
/// Allow users to check if this shim can be ignored when called directly. /// Allow users to check if this shim can be ignored when called directly.

9
compiler/stable_mir/src/mir/pretty.rs
View File

@ -260,6 +260,7 @@ pub fn pretty_assert_message(msg: &AssertMessage) -> String {
); );
pretty pretty
} }
AssertMessage::Overflow(op, _, _) => unreachable!("`{:?}` cannot overflow", op),
AssertMessage::OverflowNeg(op) => { AssertMessage::OverflowNeg(op) => {
let pretty_op = pretty_operand(op); let pretty_op = pretty_operand(op);
pretty.push_str( pretty.push_str(
@ -279,17 +280,15 @@ pub fn pretty_assert_message(msg: &AssertMessage) -> String {
); );
pretty pretty
} }
AssertMessage::ResumedAfterReturn(_) => {
format!("attempt to resume a generator after completion")
}
AssertMessage::ResumedAfterPanic(_) => format!("attempt to resume a panicked generator"),
AssertMessage::MisalignedPointerDereference { required, found } => { AssertMessage::MisalignedPointerDereference { required, found } => {
let pretty_required = pretty_operand(required); let pretty_required = pretty_operand(required);
let pretty_found = pretty_operand(found); let pretty_found = pretty_operand(found);
pretty.push_str(format!("\"misaligned pointer dereference: address must be a multiple of {{}} but is {{}}\",{pretty_required}, {pretty_found}").as_str()); pretty.push_str(format!("\"misaligned pointer dereference: address must be a multiple of {{}} but is {{}}\",{pretty_required}, {pretty_found}").as_str());
pretty pretty
} }
_ => todo!(), AssertMessage::ResumedAfterReturn(_) | AssertMessage::ResumedAfterPanic(_) => {
msg.description().unwrap().to_string()
}
} }
} }

2
compiler/stable_mir/src/mir/visit.rs
View File

@ -133,7 +133,7 @@ fn visit_var_debug_info(&mut self, var_debug_info: &VarDebugInfo) {
} }
fn super_body(&mut self, body: &Body) { fn super_body(&mut self, body: &Body) {
let Body { blocks, locals: _, arg_count, var_debug_info } = body; let Body { blocks, locals: _, arg_count, var_debug_info, spread_arg: _ } = body;
for bb in blocks { for bb in blocks {
self.visit_basic_block(bb); self.visit_basic_block(bb);

14
compiler/stable_mir/src/ty.rs
View File

@ -22,9 +22,7 @@ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
/// Constructors for `Ty`. /// Constructors for `Ty`.
impl Ty { impl Ty {
/// Create a new type from a given kind. /// Create a new type from a given kind.
/// pub fn from_rigid_kind(kind: RigidTy) -> Ty {
/// Note that not all types may be supported at this point.
fn from_rigid_kind(kind: RigidTy) -> Ty {
with(|cx| cx.new_rigid_ty(kind)) with(|cx| cx.new_rigid_ty(kind))
} }
@ -77,6 +75,16 @@ pub fn usize_ty() -> Ty {
pub fn bool_ty() -> Ty { pub fn bool_ty() -> Ty {
Ty::from_rigid_kind(RigidTy::Bool) Ty::from_rigid_kind(RigidTy::Bool)
} }
/// Create a type representing a signed integer.
pub fn signed_ty(inner: IntTy) -> Ty {
Ty::from_rigid_kind(RigidTy::Int(inner))
}
/// Create a type representing an unsigned integer.
pub fn unsigned_ty(inner: UintTy) -> Ty {
Ty::from_rigid_kind(RigidTy::Uint(inner))
}
} }
impl Ty { impl Ty {

2
tests/ui-fulldeps/stable-mir/check_defs.rs
View File

@ -69,7 +69,7 @@ fn extract_elem_ty(ty: Ty) -> Ty {
/// Check signature and type of `Vec::<u8>::new` and its generic version. /// Check signature and type of `Vec::<u8>::new` and its generic version.
fn test_vec_new(instance: mir::mono::Instance) { fn test_vec_new(instance: mir::mono::Instance) {
let sig = instance.fn_sig(); let sig = instance.ty().kind().fn_sig().unwrap().skip_binder();
assert_matches!(sig.inputs(), &[]); assert_matches!(sig.inputs(), &[]);
let elem_ty = extract_elem_ty(sig.output()); let elem_ty = extract_elem_ty(sig.output());
assert_matches!(elem_ty.kind(), TyKind::RigidTy(RigidTy::Uint(UintTy::U8))); assert_matches!(elem_ty.kind(), TyKind::RigidTy(RigidTy::Uint(UintTy::U8)));