use std::{borrow::Cow, cell::RefCell, fmt::Write, iter, mem, ops::Range};

use either::Either;

use hir_def::{

expr_store::HygieneId,

item_tree::FieldsShape,

layout::{TagEncoding, Variants},

resolver::{HasResolver, TypeNs, ValueNs},

signatures::{StaticFlags, StructFlags},

Float,

ieee::{Half as f16, Quad as f128},

};

use rustc_hash::{FxHashMap, FxHashSet};

use span::FileId;

use stdx::never;

use syntax::{SyntaxNodePtr, TextRange};

use triomphe::Arc;

use crate::{

display::{ClosureStyle, DisplayTarget, HirDisplay},

infer::PointerCast,

layout::{Layout, LayoutError, RustcEnumVariantIdx},

method_resolution::{is_dyn_method, lookup_impl_const},

next_solver::{

},

traits::FnTrait,

};

use super::{

#[derive(Debug, Default, Clone, PartialEq, Eq)]

pub struct VTableMap<'db> {

}

impl<'db> VTableMap<'db> {

const OFFSET: usize = 1000; // We should add some offset to ids to make 0 (null) an invalid id.

if let Some(it) = self.ty_to_id.get(&ty) {

return *it;

}

id

}

id.checked_sub(VTableMap::OFFSET)

.and_then(|id| self.id_to_ty.get(id).copied())

.ok_or(MirEvalError::InvalidVTableId(id))

}

let id = from_bytes!(usize, bytes);

self.ty(id)

}

self.keys.len() - 1

}

let r = self.keys.get(key).ok_or_else(|| {

MirEvalError::UndefinedBehavior(format!("Getting invalid tls key {key}"))

})?;

Ok(*r)

}

let r = self.keys.get_mut(key).ok_or_else(|| {

MirEvalError::UndefinedBehavior(format!("Setting invalid tls key {key}"))

})?;

}

}

prev_stack_ptr: usize,

span: (MirSpan, DefWithBodyId),

}

#[derive(Clone)]

Dyn(usize),

}

target_data_layout: Arc<TargetDataLayout>,

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>,

/// We don't really have function pointers, i.e. pointers to some assembly instructions that we can run. Instead, we

/// store the type as an interned id in place of function and vtable pointers, and we recover back the type at the

/// time of use.

thread_local_storage: TlsData,

random_state: oorandom::Rand64,

stdout: Vec<u8>,

stderr: Vec<u8>,

not_special_fn_cache: RefCell<FxHashSet<FunctionId>>,

/// old locals that we normally want to drop here, to reuse their allocations

/// later.

cached_ptr_size: usize,

cached_fn_trait_func: Option<FunctionId>,

cached_fn_mut_trait_func: Option<FunctionId>,

stack_depth_limit: usize,

/// Maximum count of bytes that heap and stack can grow

memory_limit: usize,

}

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

}

#[derive(Debug, Clone)]

interval: Interval,

}

impl Interval {

Self { addr, size }

}

memory.read_memory(self.addr, self.size)

}

memory.write_memory(self.addr, bytes)

}

memory.copy_from_interval(self.addr, interval)

}

}

}

memory.read_memory(self.interval.addr, self.interval.size)

}

fn new(

addr: Address,

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

}

}

}

impl IntervalOrOwned {

Ok(match self {

IntervalOrOwned::Owned(o) => o,

IntervalOrOwned::Borrowed(b) => b.get(memory)?,

impl Address {

#[allow(clippy::double_parens)]

Ok(Address::from_usize(from_bytes!(usize, it)))

}

}

#[derive(Clone, PartialEq, Eq)]

TargetDataLayoutNotAvailable(TargetLoadError),

/// Means that code had undefined behavior. We don't try to actively detect UB, but if it was detected

/// then use this type of error.

UndefinedBehavior(String),

Panic(String),

// FIXME: This should be folded into ConstEvalError?

NotSupported(String),

ExecutionLimitExceeded,

StackOverflow,

/// FIXME: Fold this into InternalError

InvalidVTableId(usize),

/// ?

/// These should not occur, usually indicates a bug in mir lowering.

InternalError(Box<str>),

}

pub fn pretty_print(

&self,

f: &mut String,

let function_name = db.function_signature(*func);

let self_ = match func.lookup(db).container {

ItemContainerId::ImplId(impl_id) => Some({

db.impl_self_ty(impl_id)

.display(db, display_target)

.to_string()

}),

}

}

fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

match self {

Self::ConstEvalError(arg0, arg1) => {

Self::InternalError(arg0) => f.debug_tuple("InternalError").field(arg0).finish(),

Self::InvalidVTableId(arg0) => f.debug_tuple("InvalidVTableId").field(arg0).finish(),

Self::NotSupported(arg0) => f.debug_tuple("NotSupported").field(arg0).finish(),

Self::InFunction(e, stack) => {

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

}

}

}

#[derive(Debug, Default)]

}

if p.iterate_over_parents(store).any(|it| self.need_drop.contains(&it)) {

return;

}

self.need_drop.insert(p);

}

// FIXME: replace parents with parts

if let Some(parent) = p.iterate_over_parents(store).find(|it| self.need_drop.contains(it)) {

self.need_drop.remove(&parent);

}

#[derive(Debug)]

}

pub struct MirOutput {

}

}

// 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

// a zero size, hoping that they are all outside of our current body. Even without a fix for #7434, we can

// (and probably should) do better here, for example by excluding bindings outside of the target expression.

assert_placeholder_ty_is_unused: bool,

let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused, trait_env)?;

if evaluator.ptr_size() != size_of::<usize>() {

not_supported!("targets with different pointer size from host");

}

let bytes = interval.get(&evaluator)?;

let mut memory_map = evaluator.create_memory_map(

bytes,

&Locals { ptr: ArenaMap::new(), body, drop_flags: DropFlags::default() },

)?;

let bytes = bytes.into();

memory_map.vtable.shrink_to_fit();

MemoryMap::Complex(Box::new(memory_map))

};

})();

Ok((it, MirOutput { stdout: evaluator.stdout, stderr: evaluator.stderr }))

}

impl<'db> Evaluator<'db> {

pub fn new(

owner: DefWithBodyId,

assert_placeholder_ty_is_unused: bool,

let target_data_layout = match db.target_data_layout(crate_id) {

Ok(target_data_layout) => target_data_layout,

Err(e) => return Err(MirEvalError::TargetDataLayoutNotAvailable(e)),

};

let cached_ptr_size = target_data_layout.pointer_size().bytes_usize();

Ok(Evaluator {

target_data_layout,

stack: vec![0],

mir_or_dyn_index_cache: RefCell::new(Default::default()),

unused_locals_store: RefCell::new(Default::default()),

cached_ptr_size,

.and_then(|x| x.trait_items(db).method_by_name(&Name::new_symbol_root(sym::call))),

x.trait_items(db).method_by_name(&Name::new_symbol_root(sym::call_mut))

}),

x.trait_items(db).method_by_name(&Name::new_symbol_root(sym::call_once))

}),

})

}

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,

size: self.size_of_sized(

locals,

"Type of place that we need its interval",

)?,

self.cached_ptr_size

}

let pair = (ty, proj);

if let Some(r) = self.projected_ty_cache.borrow().get(&pair) {

}

let (ty, proj) = pair;

let r = proj.projected_ty(

|c, subst, f| {

captures

.get(f)

.expect("broken closure field")

.ty

},

self.crate_id,

);

r

}

fn place_addr_and_ty_and_metadata<'a>(

&'a self,

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

let mut metadata: Option<IntervalOrOwned> = None; // locals are always sized

for proj in p.projection.lookup(&locals.body.projection_store) {

ty = self.projected_ty(ty, proj.clone());

match proj {

ProjectionElem::Deref => {

Some(

Interval { addr: addr.offset(self.ptr_size()), size: self.ptr_size() }

.into(),

);

metadata = None; // Result of index is always sized

let ty_size =

addr = addr.offset(ty_size * offset);

}

&ProjectionElem::ConstantIndex { from_end, offset } => {

let offset = if from_end {

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

Some(it) => it as u64,

None => {

};

metadata = None; // Result of index is always sized

let ty_size =

addr = addr.offset(ty_size * offset);

}

&ProjectionElem::Subslice { from, to } => {

};

metadata = match metadata {

Some(it) => {

None => None,

};

let ty_size =

addr = addr.offset(ty_size * (from as usize));

}

&ProjectionElem::ClosureField(f) => {

let offset = layout.fields.offset(f).bytes_usize();

addr = addr.offset(offset);

metadata = None;

}

ProjectionElem::Field(Either::Right(f)) => {

let offset = layout.fields.offset(f.index as usize).bytes_usize();

addr = addr.offset(offset);

metadata = None; // tuple field is always sized FIXME: This is wrong, the tail can be unsized

}

ProjectionElem::Field(Either::Left(f)) => {

let variant_layout = match &layout.variants {

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

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

.bytes_usize();

addr = addr.offset(offset);

// Unsized field metadata is equal to the metadata of the struct

metadata = None;

}

}

Ok((addr, ty, metadata))

}

if let Some(x) = self.layout_cache.borrow().get(&ty) {

return Ok(x.clone());

}

let r = self

.db

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

self.layout_cache.borrow_mut().insert(ty, r.clone());

Ok(r)

}

}

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

}

Ok(match &o.kind {

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

&OperandKind::Static(s) => {

}

})

}

Ok(IntervalAndTy {

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

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

fn interpret_mir(

&mut self,

args: impl Iterator<Item = IntervalOrOwned>,

if let Some(it) = self.stack_depth_limit.checked_sub(1) {

self.stack_depth_limit = it;

} else {

let args = args

.iter()

.map(|it| self.operand_ty_and_eval(it, locals))

let bytes = self.eval_operand(func, locals)?;

self.exec_fn_pointer(

bytes,

)?

}

TyKind::FnDef(def, generic_args) => self.exec_fn_def(

generic_args,

destination_interval,

&args,

fn fill_locals_for_body(

&mut self,

args: impl Iterator<Item = IntervalOrOwned>,

let mut remain_args = body.param_locals.len();

for ((l, interval), value) in locals.ptr.iter().skip(1).zip(args) {

locals.drop_flags.add_place(l.into(), &locals.body.projection_store);

fn create_locals_for_body(

&mut self,

destination: Option<Interval>,

let mut locals =

match self.unused_locals_store.borrow_mut().entry(body.owner).or_default().pop() {

None => Locals {

continue;

}

let (size, align) = self.size_align_of_sized(

&locals,

"no unsized local in extending stack",

)?;

Ok((locals, prev_stack_pointer))

}

use IntervalOrOwned::*;

Ok(match r {

Rvalue::Use(it) => Borrowed(self.eval_operand(it, locals)?),

Rvalue::UnaryOp(op, val) => {

let mut c = self.eval_operand(val, locals)?.get(self)?;

let mut ty = self.operand_ty(val, locals)?;

c = self.read_memory(Address::from_bytes(c)?, size)?;

}

match f {

let c = -from_bytes!(f16, u16, c);

Owned(u16::try_from(c.to_bits()).unwrap().to_le_bytes().into())

}

let c = -from_bytes!(f32, c);

Owned(c.to_le_bytes().into())

}

let c = -from_bytes!(f64, c);

Owned(c.to_le_bytes().into())

}

let c = -from_bytes!(f128, u128, c);

Owned(c.to_bits().to_le_bytes().into())

}

}

} else {

let mut c = c.to_vec();

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

} else {

match op {

let mut lc = lc.get(self)?;

let mut rc = rc.get(self)?;

let mut ty = self.operand_ty(lhs, locals)?;

let size = if ty.is_str() {

if *op != BinOp::Eq {

never!("Only eq is builtin for `str`");

rc = self.read_memory(Address::from_bytes(rc)?, ls)?;

break 'binary_op Owned(vec![u8::from(lc == rc)]);

} else {

};

lc = self.read_memory(Address::from_bytes(lc)?, size)?;

rc = self.read_memory(Address::from_bytes(rc)?, size)?;

}

match f {

let l = from_bytes!(f16, u16, lc);

let r = from_bytes!(f16, u16, rc);

match op {

),

}

}

let l = from_bytes!(f32, lc);

let r = from_bytes!(f32, rc);

match op {

),

}

}

let l = from_bytes!(f64, lc);

let r = from_bytes!(f64, rc);

match op {

),

}

}

let l = from_bytes!(f128, u128, lc);

let r = from_bytes!(f128, u128, rc);

match op {

}

}

} else {

let l128 = IntValue::from_bytes(lc, is_signed);

let r128 = IntValue::from_bytes(rc, is_signed);

match op {

Owned(result.to_le_bytes().to_vec())

}

Rvalue::Repeat(it, len) => {

Some(it) => it as usize,

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

};

}

Rvalue::ShallowInitBox(_, _) => not_supported!("shallow init box"),

Rvalue::ShallowInitBoxWithAlloc(ty) => {

not_supported!("unsized box initialization");

};

let addr = self.heap_allocate(size, align)?;

let values = values

.iter()

.map(|it| self.eval_operand(it, locals))

match kind {

AggregateKind::Array(_) => {

let mut r = vec![];

Owned(r)

}

AggregateKind::Tuple(ty) => {

Owned(self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

)?)

}

AggregateKind::Union(it, f) => {

let offset = layout

.fields

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

}

AggregateKind::Adt(it, subst) => {

let (size, variant_layout, tag) =

Owned(self.construct_with_layout(

size,

&variant_layout,

)?)

}

AggregateKind::Closure(ty) => {

Owned(self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

CastKind::PointerCoercion(cast) => match cast {

PointerCast::ReifyFnPointer | PointerCast::ClosureFnPointer(_) => {

let current_ty = self.operand_ty(operand, locals)?;

let id = self.vtable_map.id(current_ty);

let ptr_size = self.ptr_size();

Owned(id.to_le_bytes()[0..ptr_size].to_vec())

PointerCast::Unsize => {

let current_ty = self.operand_ty(operand, locals)?;

let addr = self.eval_operand(operand, locals)?;

}

PointerCast::MutToConstPointer | PointerCast::UnsafeFnPointer => {

// This is no-op

| CastKind::PointerExposeAddress

| CastKind::PointerFromExposedAddress => {

let current_ty = self.operand_ty(operand, locals)?;

let current = pad16(self.eval_operand(operand, locals)?.get(self)?, is_signed);

let dest_size =

Owned(current[0..dest_size].to_vec())

}

CastKind::FloatToInt => {

let ty = self.operand_ty(operand, locals)?;

not_supported!("invalid float to int cast");

};

let value = self.eval_operand(operand, locals)?.get(self)?;

let value = match ty {

let value = value.try_into().unwrap();

f32::from_le_bytes(value) as f64

}

let value = value.try_into().unwrap();

f64::from_le_bytes(value)

}

not_supported!("unstable floating point type f16 and f128");

}

};

let dest_size =

let dest_bits = dest_size * 8;

let (max, min) = if dest_bits == 128 {

(i128::MAX, i128::MIN)

}

CastKind::FloatToFloat => {

let ty = self.operand_ty(operand, locals)?;

not_supported!("invalid float to int cast");

};

let value = self.eval_operand(operand, locals)?.get(self)?;

let value = match ty {

let value = value.try_into().unwrap();

f32::from_le_bytes(value) as f64

}

let value = value.try_into().unwrap();

f64::from_le_bytes(value)

}

not_supported!("unstable floating point type f16 and f128");

}

};

not_supported!("invalid float to float cast");

};

match target_ty {

not_supported!("unstable floating point type f16 and f128");

}

}

}

CastKind::IntToFloat => {

let current_ty = self.operand_ty(operand, locals)?;

let value = pad16(self.eval_operand(operand, locals)?.get(self)?, is_signed);

let value = i128::from_le_bytes(value);

not_supported!("invalid int to float cast");

};

match target_ty {

not_supported!("unstable floating point type f16 and f128");

}

}

})

}

return Ok(0);

};

match &layout.variants {

fn coerce_unsized_look_through_fields<T>(

&self,

if let Some(it) = goal(kind) {

return Ok(it);

}

{

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

if let Some(ty) =

{

}

}

}

fn coerce_unsized(

&mut self,

addr: Interval,

match it {

_ => None,

}

}

/// Adds metadata to the address and create the fat pointer result of the unsizing operation.

fn unsizing_ptr_from_addr(

&mut self,

addr: Interval,

use IntervalOrOwned::*;

TyKind::Array(_, size) => {

None => {

not_supported!("unevaluatble len of array in coerce unsized")

}

not_supported!("slice unsizing from non array type {t:?}")

}

},

let vtable = self.vtable_map.id(current_ty);

let mut r = Vec::with_capacity(16);

let addr = addr.get(self)?;

r.extend(vtable.to_le_bytes());

Owned(r)

}

if id != current_id {

not_supported!("unsizing struct with different type");

}

AdtId::StructId(s) => s,

AdtId::UnionId(_) => not_supported!("unsizing unions"),

AdtId::EnumId(_) => not_supported!("unsizing enums"),

not_supported!("unsizing struct without field");

};

let target_last_field = self.db.field_types(id.into())[last_field]

let current_last_field = self.db.field_types(id.into())[last_field]

return self.unsizing_ptr_from_addr(

target_last_field,

current_last_field,

fn layout_of_variant(

&mut self,

it: VariantId,

let adt = it.adt_id(self.db);

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

&& let VariantId::EnumVariantId(it) = it

// 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

let i = self.const_eval_discriminant(it)?;

}

let layout = self.layout_adt(adt, subst)?;

Ok(match &layout.variants {

variant_layout: &Layout,

tag: Option<(usize, usize, i128)>,

values: impl Iterator<Item = IntervalOrOwned>,

let mut result = vec![0; size];

if let Some((offset, size, value)) = tag {

match result.get_mut(offset..offset + size) {

Ok(result)

}

Ok(match &it.kind {

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

locals.drop_flags.remove_place(p, &locals.body.projection_store);

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

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

}

})

}

#[allow(clippy::double_parens)]

let result_owner;

subst = s;

}

}

not_supported!("unevaluatable constant");

}

};

let patch_map = memory_map.transform_addresses(|b, align| {

let addr = self.heap_allocate(b.len(), align)?;

self.write_memory(addr, b)?;

} else if size < 16 && v.len() == 16 {

Cow::Borrowed(&v[0..size])

} else {

}

} else {

Cow::Borrowed(v)

MemoryMap::Complex(cm) => cm.vtable.ty_of_bytes(bytes),

},

addr,

locals,

)?;

Ok(Interval::new(addr, size))

}

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

Ok(Interval::new(

addr,

))

}

if size == 0 {

return Ok(&[]);

}

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

}

let (mem, pos) = match addr {

Stack(it) => (&mut self.stack, it),

Heap(it) => (&mut self.heap, it),

.ok_or_else(|| MirEvalError::UndefinedBehavior("out of bound memory write".to_owned()))

}

if r.is_empty() {

return Ok(());

}

Ok(())

}

match r {

IntervalOrOwned::Borrowed(r) => self.copy_from_interval(addr, r),

IntervalOrOwned::Owned(r) => self.write_memory(addr, &r),

}

}

if r.size == 0 {

return Ok(());

}

Ok(())

}

return Ok(layout

.is_sized()

}

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

&& let Some((AdtId::EnumId(e), _)) = ty.as_adt()

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

return Ok(Some((16, 16)));

}

if self.assert_placeholder_ty_is_unused

&& matches!(layout, Err(MirEvalError::LayoutError(LayoutError::HasPlaceholder, _)))

{

return Ok(Some((0, 1)));

}

let layout = layout?;

}

/// 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)? {

Some(it) => Ok(it.0),

}

}

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

fn size_align_of_sized(

&self,

what: &'static str,

match self.size_align_of(ty, locals)? {

Some(it) => Ok(it),

}

}

if !align.is_power_of_two() || align > 10000 {

return Err(MirEvalError::UndefinedBehavior(format!("Alignment {align} is invalid")));

}

fn create_memory_map(

&self,

bytes: &[u8],

fn rec<'db>(

this: &Evaluator<'db>,

bytes: &[u8],

mm: &mut ComplexMemoryMap<'db>,

stack_depth_limit: usize,

if stack_depth_limit.checked_sub(1).is_none() {

return Err(MirEvalError::StackOverflow);

}

let size = this.size_align_of(t, locals)?;

match size {

Some((size, _)) => {

None => {

let mut check_inner = None;

let (addr, meta) = bytes.split_at(bytes.len() / 2);

TyKind::Str => 1,

TyKind::Slice(t) => {

this.size_of_sized(t, locals, "slice inner type")?

}

let t = this.vtable_map.ty_of_bytes(meta)?;

}

_ => return Ok(()),

};

_ => from_bytes!(usize, meta),

};

let size = element_size * count;

let addr = Address::from_bytes(addr)?;

let b = this.read_memory(addr, size)?;

mm.insert(addr.to_usize(), b.into());

for i in 0..count {

let offset = element_size * i;

rec(

)?;

}

}

let offset = layout.fields.offset(id).bytes_usize();

rec(

this,

&bytes[offset..offset + size],

)?;

}

}

AdtId::StructId(s) => {

let data = s.fields(this.db);

let field_types = this.db.field_types(s.into());

for (f, _) in data.fields().iter() {

let offset = layout

.fields

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

.bytes_usize();

rec(

this,

&bytes[offset..offset + size],

}

}

AdtId::EnumId(e) => {

if let Some((v, l)) = detect_variant_from_bytes(

&layout,

this.db,

for (f, _) in data.fields().iter() {

let offset =

l.fields.offset(u32::from(f.into_raw()) as usize).bytes_usize();

rec(

this,

&bytes[offset..offset + size],

}

AdtId::UnionId(_) => (),

},

}

_ => (),

}

fn patch_addresses(

&mut self,

patch_map: &FxHashMap<usize, usize>,

addr: Address,

// FIXME: support indirect references

let layout = self.layout(ty)?;

use rustc_type_ir::TyKind;

match ty.kind() {

TyKind::Ref(_, t, _) => {

match size {

Some(_) => {

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

}

TyKind::Adt(id, args) => match id.def_id().0 {

AdtId::StructId(s) => {

let offset = layout.fields.offset(i).bytes_usize();

self.patch_addresses(

patch_map,

ty_of_bytes,

self.read_memory(addr, layout.size.bytes_usize())?,

e,

) {

let offset = layout.fields.offset(i).bytes_usize();

self.patch_addresses(

patch_map,

ty_of_bytes,

}

}

TyKind::Array(inner, len) => {

Some(it) => it as usize,

None => not_supported!("non evaluatable array len in patching addresses"),

};

for i in 0..len {

self.patch_addresses(

patch_map,

&mut self,

bytes: Interval,

destination: Interval,

span: MirSpan,

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

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

use rustc_type_ir::TyKind;

match next_ty.kind() {

TyKind::Closure(id, generic_args) => self.exec_closure(

bytes.slice(0..0),

destination,

args,

locals,

fn exec_closure(

&mut self,

closure_data: Interval,

destination: Interval,

span: MirSpan,

let mir_body = self

.db

.map_err(|it| MirEvalError::MirLowerErrorForClosure(closure, it))?;

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

{

};

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

.chain(args.iter().map(|it| Ok(it.get(self)?.to_owned())))

let interval = self

.interpret_mir(mir_body, arg_bytes.into_iter().map(IntervalOrOwned::Owned))

.map_err(|e| {

fn exec_fn_def(

&mut self,

def: CallableDefId,

destination: Interval,

span: MirSpan,

match def {

CallableDefId::FunctionId(def) => {

if self.detect_fn_trait(def).is_some() {

fn get_mir_or_dyn_index(

&self,

def: FunctionId,

span: MirSpan,

let pair = (def, generic_args);

if let Some(r) = self.mir_or_dyn_index_cache.borrow().get(&pair) {

return Ok(r.clone());

}

let (def, generic_args) = pair;

let r = if let Some(self_ty_idx) =

{

MirOrDynIndex::Dyn(self_ty_idx)

} else {

let (imp, generic_args) =

let mir_body = self

.db

fn exec_fn_with_args(

&mut self,

mut def: FunctionId,

destination: Interval,

span: MirSpan,

if self.detect_and_exec_special_function(

def,

args,

locals,

destination,

span,

def = redirect_def;

}

let arg_bytes = args.iter().map(|it| IntervalOrOwned::Borrowed(it.interval));

MirOrDynIndex::Dyn(self_ty_idx) => {

// In the layout of current possible receiver, which at the moment of writing this code is one of

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

.vtable_map

.ty_of_bytes(&first_arg[self.ptr_size()..self.ptr_size() * 2])?;

let mut args_for_target = args.to_vec();

args_for_target[0] = IntervalAndTy {

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

};

generic_args

.enumerate()

);

self.exec_fn_with_args(

def,

fn exec_looked_up_function(

&mut self,

def: FunctionId,

arg_bytes: impl Iterator<Item = IntervalOrOwned>,

span: MirSpan,

destination: Interval,

Ok(if let Some(target_bb) = target_bb {

let (mut locals, prev_stack_ptr) =

self.create_locals_for_body(&mir_body, Some(destination))?;

fn exec_fn_trait(

&mut self,

def: FunctionId,

destination: Interval,

span: MirSpan,

let func = args

.first()

.ok_or_else(|| MirEvalError::InternalError("fn trait with no arg".into()))?;

let mut func_data = func.interval;

let id =

from_bytes!(usize, &func_data.get(self)?[self.ptr_size()..self.ptr_size() * 2]);

func_data = func_data.slice(0..self.ptr_size());

}

func_data = Interval { addr: Address::from_bytes(func_data.get(self)?)?, size };

}

self.exec_fn_pointer(func_data, destination, &args[1..], locals, target_bb, span)

}

TyKind::Closure(closure, subst) => self.exec_closure(

func_data,

destination,

&args[1..],

locals,

let arg0 = func;

let args = &args[1..];

let arg1 = {

let result = self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

)?;

// FIXME: there is some leak here

let size = layout.size.bytes_usize();

self.write_memory(addr, &result)?;

IntervalAndTy { interval: Interval { addr, size }, ty }

};

}

}

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

return Ok(*o);

};

let konst = self.db.const_eval_static(st).map_err(|e| {

MirEvalError::ConstEvalError(static_data.name.as_str().to_owned(), Box::new(e))

})?;

} else {

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

not_supported!("unsized extern static");

};

Ok(addr)

}

let r = self.db.const_eval_discriminant(variant);

match r {

Ok(r) => Ok(r),

}

}

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

if !locals.drop_flags.remove_place(place, &locals.body.projection_store) {

return Ok(());

fn run_drop_glue_deep(

&mut self,

addr: Address,

_metadata: &[u8],

span: MirSpan,

let Some(drop_fn) = (|| {

drop_trait.trait_items(self.db).method_by_name(&Name::new_symbol_root(sym::drop))

})() else {

// in some tests we don't have drop trait in minicore, and

return Ok(());

};

if let Ok(MirOrDynIndex::Mir(body)) =

self.get_mir_or_dyn_index(drop_fn, generic_args, locals, span)

{

None,

)?;

}

AdtId::StructId(s) => {

let data = self.db.struct_signature(s);

if data.flags.contains(StructFlags::IS_MANUALLY_DROP) {

return Ok(());

}

let variant_fields = s.fields(self.db);

match variant_fields.shape {

FieldsShape::Record | FieldsShape::Tuple => {

.offset(u32::from(field.into_raw()) as usize)

.bytes_usize();

let addr = addr.offset(offset);

self.run_drop_glue_deep(ty, locals, addr, &[], span)?;

}

}

AdtId::EnumId(_) => (),

}

}

| TyKind::Array(_, _)

| TyKind::Slice(_)

| TyKind::Ref(_, _, _)

| TyKind::FnDef(_, _)

| TyKind::Str

| TyKind::Never

| TyKind::Closure(_, _)

| TyKind::Coroutine(_, _)

| TyKind::CoroutineWitness(_, _)

| TyKind::Foreign(_)

| TyKind::Placeholder(_)

};

Ok(())

}

self.stdout.extend(interval.get(self)?.to_vec());

Ok(())

}

self.stderr.extend(interval.get(self)?.to_vec());

Ok(())

}

}

owner: DefWithBodyId,

let mut evaluator = Evaluator::new(db, owner, false, None)?;

let locals = &Locals {

ptr: ArenaMap::new(),

// and its ABI doesn't break yet, we put it in memory manually.

let a2 = evaluator.heap_allocate(evaluator.ptr_size() * 2, evaluator.ptr_size())?;

evaluator.write_memory(a2, &data.addr.to_bytes())?;

evaluator.write_memory(a2.offset(evaluator.ptr_size()), &debug_fmt_fn_ptr.to_le_bytes())?;

// a3 = ::core::fmt::Arguments::new_v1(a1, a2)

// FIXME: similarly, we should call function here, not directly working with memory.