//! This module provides a MIR interpreter, which is used in const eval.

use base_db::{CrateId, FileId};

use chalk_ir::Mutability;

use hir_def::{

builtin_type::BuiltinType,

data::adt::{StructFlags, VariantData},

layout::{TagEncoding, Variants},

};

use intern::Interned;

use la_arena::ArenaMap;

use rustc_hash::{FxHashMap, FxHashSet};

infer::PointerCast,

layout::{Layout, LayoutError, RustcEnumVariantIdx},

mapping::from_chalk,

name, static_lifetime,

traits::FnTrait,

utils::{detect_variant_from_bytes, ClosureSubst},

};

use super::{

};

mod shim;

macro_rules! from_bytes {

($ty:tt, $value:expr) => {

($ty::from_le_bytes(match ($value).try_into() {

Err(_) => return Err(MirEvalError::TypeError(stringify!(mismatched size in constructing $ty))),

}))

};

}

macro_rules! not_supported {

};

}

impl VTableMap {

fn id(&mut self, ty: Ty) -> usize {

}

let id = self.id_to_ty.len();

self.id_to_ty.push(ty.clone());

}

}

pub struct Evaluator<'a> {

db: &'a dyn HirDatabase,

trait_env: Arc<TraitEnvironment>,

stack: Vec<u8>,

heap: Vec<u8>,

/// Stores the global location of the statics. We const evaluate every static first time we need it

/// and see it's missing, then we add it to this to reuse.

static_locations: FxHashMap<StaticId, Address>,

/// time of use.

vtable_map: VTableMap,

thread_local_storage: TlsData,

stdout: Vec<u8>,

stderr: Vec<u8>,

crate_id: CrateId,

// FIXME: This is a workaround, see the comment on `interpret_mir`

assert_placeholder_ty_is_unused: bool,

execution_limit: usize,

/// An additional limit on stack depth, to prevent stack overflow

stack_depth_limit: usize,

}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

addr: Address,

ty: Ty,

evaluator: &Evaluator<'_>,

) -> Result<IntervalAndTy> {

let size = evaluator.size_of_sized(&ty, locals, "type of interval")?;

Ok(IntervalAndTy { interval: Interval { addr, size }, ty })

}

}

impl Address {

}

} else {

}

}

fn to_usize(&self) -> usize {

let as_num = match self {

};

as_num

}

fn map(&self, f: impl FnOnce(usize) -> usize) -> Address {

match self {

}

}

fn offset(&self, offset: usize) -> Address {

}

}

TypeIsUnsized(Ty, &'static str),

NotSupported(String),

InvalidConst(Const),

ExecutionLimitExceeded,

StackOverflow,

TargetDataLayoutNotAvailable,

) -> std::result::Result<(), std::fmt::Error> {

writeln!(f, "Mir eval error:")?;

let mut err = self;

err = e;

}

}

}

match err {

MirEvalError::InFunction(..) => unreachable!(),

let data = &arg0.data(Interner);

f.debug_struct("InvalidConst").field("ty", &data.ty).field("value", &arg0).finish()

}

f.debug_struct("WithStack").field("error", e).field("stack", &stack).finish()

}

}

impl DropFlags {

fn add_place(&mut self, p: Place) {

return;

}

self.need_drop.insert(p);

}

}

#[derive(Debug)]

drop_flags: DropFlags,

}

pub fn interpret_mir(

db: &dyn HirDatabase,

// FIXME: This is workaround. Ideally, const generics should have a separate body (issue #7434), but now

// they share their body with their parent, so in MIR lowering we have locals of the parent body, which

// might have placeholders. With this argument, we (wrongly) assume that every placeholder type has

assert_placeholder_ty_is_unused: bool,

) -> (Result<Const>, String, String) {

let ty = body.locals[return_slot()].ty.clone();

let mut memory_map = evaluator.create_memory_map(

&bytes,

&ty,

)?;

memory_map.vtable = evaluator.vtable_map.clone();

return Ok(intern_const_scalar(ConstScalar::Bytes(bytes, memory_map), ty));

})();

(

String::from_utf8_lossy(&evaluator.stdout).into_owned(),

String::from_utf8_lossy(&evaluator.stderr).into_owned(),

)

impl Evaluator<'_> {

pub fn new<'a>(

db: &'a dyn HirDatabase,

assert_placeholder_ty_is_unused: bool,

) -> Evaluator<'a> {

Evaluator {

stack: vec![0],

heap: vec![0],

vtable_map: VTableMap::default(),

thread_local_storage: TlsData::default(),

static_locations: HashMap::default(),

db,

trait_env,

crate_id,

stdout: vec![],

assert_placeholder_ty_is_unused,

stack_depth_limit: 100,

execution_limit: 1000_000,

}

}

Ok(self.place_addr_and_ty_and_metadata(p, locals)?.0)

}

let place_addr_and_ty = self.place_addr_and_ty_and_metadata(p, locals)?;

Ok(Interval {

addr: place_addr_and_ty.0,

fn ptr_size(&self) -> usize {

match self.db.target_data_layout(self.crate_id) {

None => 8,

}

}

fn place_addr_and_ty_and_metadata<'a>(

&'a self,

p: &Place,

) -> Result<(Address, Ty, Option<IntervalOrOwned>)> {

let mut addr = locals.ptr[p.local].addr;

let mut ty: Ty = locals.body.locals[p.local].ty.clone();

} else {

None

};

}

ProjectionElem::Index(op) => {

let offset = from_bytes!(

let offset = if from_end {

let len = match prev_ty.kind(Interner) {

TyKind::Array(_, c) => match try_const_usize(self.db, c) {

None => {

not_supported!("indexing array with unknown const from end")

}

},

TyKind::Slice(_) => match metadata {

None => not_supported!("slice place without metadata"),

},

_ => not_supported!("bad type for const index"),

_ => TyKind::Error.intern(Interner),

};

metadata = match metadata {

Some(IntervalOrOwned::Owned(

(prev_len - from - to).to_le_bytes().to_vec(),

))

Variants::Single { .. } => &layout,

Variants::Multiple { variants, .. } => {

&variants[match f.parent {

}

_ => {

return Err(MirEvalError::TypeError(

}

fn layout(&self, ty: &Ty) -> Result<Arc<Layout>> {

.layout_of_ty(ty.clone(), self.crate_id)

}

fn layout_adt(&self, adt: AdtId, subst: Substitution) -> Result<Arc<Layout>> {

})

}

Ok(self.place_addr_and_ty_and_metadata(p, locals)?.1)

}

Ok(match o {

Operand::Copy(p) | Operand::Move(p) => self.place_ty(p, locals)?,

Operand::Constant(c) => c.data(Interner).ty.clone(),

})

}

Ok(IntervalAndTy {

interval: self.eval_operand(o, locals)?,

ty: self.operand_ty(o, locals)?,

fn interpret_mir(

&mut self,

) -> Result<Vec<u8>> {

} else {

return Err(MirEvalError::StackOverflow);

}

let mut current_block_idx = body.start_block;

let mut locals =

let (locals_ptr, stack_size) = {

let mut stack_ptr = self.stack.len();

let addr = body

.locals

.iter()

let my_ptr = stack_ptr;

stack_ptr += size;

Ok((id, Interval { addr: Stack(my_ptr), size }))

let stack_size = stack_ptr - self.stack.len();

(addr, stack_size)

};

}

}

use IntervalOrOwned::*;

Ok(match r {

Rvalue::Ref(_, p) => {

let (addr, _, metadata) = self.place_addr_and_ty_and_metadata(p, locals)?;

let mut r = addr.to_bytes();

c[0] = 1 - c[0];

} else {

match op {

UnOp::Neg => {

for k in c.iter_mut() {

let o;

(*k, o) = k.overflowing_add(1);

};

Owned(r.to_le_bytes().into())

}

),

}

}

};

Owned(r.to_le_bytes().into())

}

),

}

}

BinOp::Shr => l128.checked_shr(shift_amount),

_ => unreachable!(),

};

if let Some(r) = r {

break 'b r;

}

};

return Err(MirEvalError::Panic(format!("Overflow in {op:?}")));

};

}

BinOp::Offset => not_supported!("offset binop"),

}

Rvalue::Discriminant(p) => {

let ty = self.place_ty(p, locals)?;

let bytes = self.eval_place(p, locals)?.get(&self)?;

}

let len = match try_const_usize(self.db, &len) {

None => not_supported!("non evaluatable array len in repeat Rvalue"),

};

let size = len * val.len();

Owned(val.iter().copied().cycle().take(size).collect())

}

let Some((size, align)) = self.size_align_of(ty, locals)? else {

not_supported!("unsized box initialization");

};

Owned(addr.to_bytes())

}

Rvalue::CopyForDeref(_) => not_supported!("copy for deref"),

Rvalue::Aggregate(kind, values) => {

let values = values

.iter()

.collect::<Result<Vec<_>>>()?;

match kind {

AggregateKind::Array(_) => {

let mut r = vec![];

r.extend(value);

}

Owned(r)

layout.size.bytes_usize(),

&layout,

None,

)?)

}

let offset = layout

.fields

.offset(u32::from(f.local_id.into_raw()) as usize)

result[offset..offset + op.len()].copy_from_slice(op);

Owned(result)

}

let (size, variant_layout, tag) =

Owned(self.make_by_layout(

size,

&variant_layout,

tag,

)?)

}

AggregateKind::Closure(ty) => {

layout.size.bytes_usize(),

&layout,

None,

)?)

}

}

})

}

fn coerce_unsized_look_through_fields<T>(

&self,

ty: &Ty,

goal: impl Fn(&TyKind) -> Option<T>,

) -> Result<T> {

let kind = ty.kind(Interner);

}

if let TyKind::Adt(id, subst) = kind {

if let AdtId::StructId(struct_id) = id.0 {

let field_types = self.db.field_types(struct_id.into());

let mut field_types = field_types.iter();

if let Some(ty) =

{

return self.coerce_unsized_look_through_fields(&ty, goal);

}

current_ty: &Ty,

target_ty: &Ty,

) -> Result<IntervalOrOwned> {

TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) => Some(ty.clone()),

_ => None,

}

}

}

}

},

})

}

fn layout_of_variant(

&mut self,

subst: Substitution,

) -> Result<(usize, Arc<Layout>, Option<(usize, usize, i128)>)> {

if let DefWithBodyId::VariantId(f) = locals.body.owner {

if AdtId::from(f.parent) == adt {

// Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and

// infinite sized type errors) we use a dummy layout

return Ok((16, self.layout(&TyBuilder::unit())?, Some((0, 16, i))));

}

}

.db

.target_data_layout(self.crate_id)

.ok_or(MirEvalError::TargetDataLayoutNotAvailable)?;

_ => not_supported!("multi variant layout for non-enums"),

};

let rustc_enum_variant_idx = RustcEnumVariantIdx(enum_variant_id.local_id);

} else {

discriminant = (variants

.iter_enumerated()

.unwrap() as i128)

.wrapping_add(*niche_start as i128);

true

Ok(result)

}

Operand::Copy(p) | Operand::Move(p) => {

locals.drop_flags.remove_place(p);

self.eval_place(p, locals)?

let addr = self.eval_static(*st, locals)?;

Interval::new(addr, self.ptr_size())

}

})

}

})?;

}

}

}

ConstScalar::Unknown => not_supported!("evaluating unknown const"),

}

let addr = self.place_addr(p, locals)?;

Ok(Interval::new(

addr,

return Ok(&[]);

}

let (mem, pos) = match addr {

return Err(MirEvalError::UndefinedBehavior(format!(

)));

}

};

.ok_or_else(|| MirEvalError::UndefinedBehavior("out of bound memory read".to_string()))

}

let (mem, pos) = match addr {

return Err(MirEvalError::UndefinedBehavior(format!(

)));

}

};

Ok(())

}

if let DefWithBodyId::VariantId(f) = locals.body.owner {

if let Some((adt, _)) = ty.as_adt() {

if AdtId::from(f.parent) == adt {

/// A version of `self.size_of` which returns error if the type is unsized. `what` argument should

/// be something that complete this: `error: type {ty} was unsized. {what} should be sized`

match self.size_align_of(ty, locals)? {

None => Err(MirEvalError::TypeIsUnsized(ty.clone(), what)),

}

}

let pos = self.heap.len();

self.heap.extend(iter::repeat(0).take(size));

}

fn detect_fn_trait(&self, def: FunctionId) -> Option<FnTrait> {

let ItemContainerId::TraitId(parent) = self.db.lookup_intern_function(def).container else {

return None;

};

match l {

FnOnce => Some(FnTrait::FnOnce),

FnMut => Some(FnTrait::FnMut),

}

}

fn rec(

this: &Evaluator<'_>,

bytes: &[u8],

ty: &Ty,

mm: &mut MemoryMap,

) -> Result<()> {

match ty.kind(Interner) {

old_vtable: &VTableMap,

addr: Address,

ty: &Ty,

) -> Result<()> {

// FIXME: support indirect references

let layout = self.layout(ty)?;

match size {

Some(_) => {

let current = from_bytes!(usize, self.read_memory(addr, my_size)?);

}

}

None => {

let current = from_bytes!(usize, self.read_memory(addr, my_size / 2)?);

}

}

}

bytes: Interval,

destination: Interval,

args: &[IntervalAndTy],

span: MirSpan,

let id = from_bytes!(usize, bytes.get(self)?);

let next_ty = self.vtable_map.ty(id)?.clone();

match &next_ty.data(Interner).kind {

TyKind::FnDef(def, generic_args) => {

}

TyKind::Closure(id, subst) => {

}

}

}

fn exec_closure(

generic_args: &Substitution,

destination: Interval,

args: &[IntervalAndTy],

span: MirSpan,

let mir_body = self

.db

.monomorphized_mir_body_for_closure(

generic_args.clone(),

self.trait_env.clone(),

)

let closure_data = if mir_body.locals[mir_body.param_locals[0]].ty.as_reference().is_some()

{

closure_data.addr.to_bytes()

closure_data.get(self)?.to_owned()

};

let arg_bytes = iter::once(Ok(closure_data))

.collect::<Result<Vec<_>>>()?;

}

fn exec_fn_def(

generic_args: &Substitution,

destination: Interval,

args: &[IntervalAndTy],

span: MirSpan,

let def: CallableDefId = from_chalk(self.db, def);

let generic_args = generic_args.clone();

match def {

CallableDefId::FunctionId(def) => {

if let Some(_) = self.detect_fn_trait(def) {

}

}

CallableDefId::StructId(id) => {

let (size, variant_layout, tag) =

size,

&variant_layout,

tag,

)?;

destination.write_from_bytes(self, &result)?;

}

CallableDefId::EnumVariantId(id) => {

let (size, variant_layout, tag) =

size,

&variant_layout,

tag,

)?;

destination.write_from_bytes(self, &result)?;

}

}

}

fn exec_fn_with_args(

def: FunctionId,

args: &[IntervalAndTy],

generic_args: Substitution,

destination: Interval,

span: MirSpan,

if self.detect_and_exec_special_function(

def,

args,

destination,

span,

)? {

}

if let Some(self_ty_idx) =

is_dyn_method(self.db, self.trait_env.clone(), def, generic_args.clone())

{

// `&T`, `&mut T`, `Box<T>`, `Rc<T>`, `Arc<T>`, and `Pin<P>` where `P` is one of possible recievers,

// the vtable is exactly in the `[ptr_size..2*ptr_size]` bytes. So we can use it without branching on

// the type.

let ty =

let mut args_for_target = args.to_vec();

args_for_target[0] = IntervalAndTy {

interval: args_for_target[0].interval.slice(0..self.ptr_size()),

ty: ty.clone(),

};

let ty = GenericArgData::Ty(ty.clone()).intern(Interner);

return self.exec_fn_with_args(

def,

&args_for_target,

generics_for_target,

locals,

destination,

span,

);

}

let (imp, generic_args) =

}

fn exec_looked_up_function(

&mut self,

generic_args: Substitution,

imp: FunctionId,

span: MirSpan,

destination: Interval,

let def = imp.into();

let mir_body = self

.db

.monomorphized_mir_body(def, generic_args, self.trait_env.clone())

.map_err(|e| {

MirEvalError::InFunction(

Box::new(MirEvalError::MirLowerError(imp, e)),

)

})?;

}

fn exec_fn_trait(

&mut self,

args: &[IntervalAndTy],

destination: Interval,

span: MirSpan,

let func = args.get(0).ok_or(MirEvalError::TypeError("fn trait with no arg"))?;

let mut func_ty = func.ty.clone();

let mut func_data = func.interval;

}

match &func_ty.data(Interner).kind {

TyKind::FnDef(def, subst) => {

}

TyKind::Function(_) => {

}

TyKind::Closure(closure, subst) => {

*closure,

func_data,

&Substitution::from_iter(Interner, ClosureSubst(subst).parent_subst()),

&args[1..],

locals,

span,

}

}

}

if let Some(o) = self.static_locations.get(&st) {

return Ok(*o);

};

Box::new(e),

)

})?;

} else {

let ty = &self.db.infer(st.into())[self.db.body(st.into()).body_expr];

let Some((size, align)) = self.size_align_of(&ty, locals)? else {

not_supported!("unsized extern static");

};

Interval::new(addr, size)

};

self.write_memory(addr, &result.addr.to_bytes())?;

self.static_locations.insert(st, addr);

Ok(addr)

}

}

let (addr, ty, metadata) = self.place_addr_and_ty_and_metadata(place, locals)?;

if !locals.drop_flags.remove_place(place) {

return Ok(());

}

let metadata = match metadata {

None => vec![],

};

self.run_drop_glue_deep(ty, locals, addr, &metadata, span)

fn run_drop_glue_deep(

&mut self,

ty: Ty,

addr: Address,

_metadata: &[u8],

span: MirSpan,

// we can ignore drop in them.

return Ok(());

};

self.trait_env.clone(),

drop_fn,

Substitution::from1(Interner, ty.clone()),

subst,

locals,

impl_drop_candidate,

span,

Interval { addr: Address::Invalid(0), size: 0 },

)?;

}

match ty.kind(Interner) {

}

}

let fill_with = if is_negative { 255 } else { 0 };

.copied()

.chain(iter::repeat(fill_with))

.take(16)