+use chalk_ir::TyKind;

+use hir_def::resolver::HasResolver;

+use hir_expand::mod_path::ModPath;

+

+mod simd;

+

+ Ok(it) => it,

+ ($it: expr) => {

+ return Err(MirEvalError::NotSupported(format!($it)))

+ locals: &Locals,

+ let is_platform_intrinsic = match &function_data.abi {

+ Some(abi) => *abi == Interned::new_str("platform-intrinsic"),

+ None => match def.lookup(self.db.upcast()).container {

+ hir_def::ItemContainerId::ExternBlockId(block) => {

+ let id = block.lookup(self.db.upcast()).id;

+ id.item_tree(self.db.upcast())[id.value].abi.as_deref()

+ == Some("platform-intrinsic")

+ }

+ _ => false,

+ },

+ };

+ if is_platform_intrinsic {

+ self.exec_platform_intrinsic(

+ function_data.name.as_text().unwrap_or_default().as_str(),

+ args,

+ generic_args,

+ destination,

+ &locals,

+ span,

+ )?;

+ return Ok(true);

+ }

+ .filter_map(|it| it.path().as_ident())

+ .filter_map(|it| it.as_str())

+ .find(|it| {

+ .contains(it)

+ if let Some(it) = self.detect_lang_function(def) {

+ args.iter().map(|it| Ok(it.get(&self)?.to_owned())).collect::<Result<Vec<_>>>()?;

+ let result = self.exec_lang_item(it, generic_args, &arg_bytes, locals, span)?;

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

+ if old_size >= new_size {

+ destination.write_from_interval(self, ptr.interval)?;

+ } else {

+ let ptr = Address::from_bytes(ptr.get(self)?)?;

+ let align = from_bytes!(usize, align.get(self)?);

+ let result = self.heap_allocate(new_size, align)?;

+ Interval { addr: result, size: old_size }

+ .write_from_interval(self, Interval { addr: ptr, size: old_size })?;

+ destination.write_from_bytes(self, &result.to_bytes())?;

+ }

+ let candidate = self.db.lang_attr(def.into())?;

+ it: LangItem,

+ locals: &Locals,

+ match it {

+ let resolver = self.db.crate_def_map(self.crate_id).crate_root().resolver(self.db.upcast());

+ let Some(format_fn) = resolver.resolve_path_in_value_ns_fully(

+ self.db.upcast(),

+ &hir_def::path::Path::from_known_path_with_no_generic(ModPath::from_segments(

+ hir_expand::mod_path::PathKind::Abs,

+ [name![std], name![fmt], name![format]].into_iter(),

+ )),

+ ) else {

+ not_supported!("std::fmt::format not found");

+ };

+ let hir_def::resolver::ValueNs::FunctionId(format_fn) = format_fn else { not_supported!("std::fmt::format is not a function") };

+ let message_string = self.interpret_mir(self.db.mir_body(format_fn.into()).map_err(|e| MirEvalError::MirLowerError(format_fn, e))?, args.map(|x| IntervalOrOwned::Owned(x.clone())))?;

+ let addr = Address::from_bytes(&message_string[self.ptr_size()..2 * self.ptr_size()])?;

+ let size = from_bytes!(usize, message_string[2 * self.ptr_size()..]);

+ Ok(std::string::String::from_utf8_lossy(self.read_memory(addr, size)?).into_owned())

+ .unwrap_or_else(|e| format!("Failed to render panic format args: {e:?}"));

+ generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner)).ok_or(

+ it => not_supported!("Executing lang item {it:?}"),

+ }

+ }

+

+ fn exec_syscall(

+ &mut self,

+ id: i64,

+ args: &[IntervalAndTy],

+ destination: Interval,

+ _locals: &Locals,

+ _span: MirSpan,

+ ) -> Result<()> {

+ match id {

+ 318 => {

+ // SYS_getrandom

+ let [buf, len, _flags] = args else {

+ return Err(MirEvalError::TypeError("SYS_getrandom args are not provided"));

+ };

+ let addr = Address::from_bytes(buf.get(self)?)?;

+ let size = from_bytes!(usize, len.get(self)?);

+ for i in 0..size {

+ let rand_byte = self.random_state.rand_u64() as u8;

+ self.write_memory(addr.offset(i), &[rand_byte])?;

+ }

+ destination.write_from_interval(self, len.interval)

+ }

+ _ => {

+ not_supported!("Unknown syscall id {id:?}")

+ }

+ locals: &Locals,

+ span: MirSpan,

+ return Err(MirEvalError::TypeError(

+ "pthread_getspecific arg0 is not provided",

+ ));

+ return Err(MirEvalError::TypeError(

+ "pthread_setspecific arg0 is not provided",

+ ));

+ return Err(MirEvalError::TypeError(

+ "pthread_setspecific arg1 is not provided",

+ ));

+ "syscall" => {

+ let Some((id, rest)) = args.split_first() else {

+ return Err(MirEvalError::TypeError(

+ "syscall arg1 is not provided",

+ ));

+ };

+ let id = from_bytes!(i64, id.get(self)?);

+ self.exec_syscall(id, rest, destination, locals, span)

+ }

+ "sched_getaffinity" => {

+ let [_pid, _set_size, set] = args else {

+ return Err(MirEvalError::TypeError("libc::write args are not provided"));

+ };

+ let set = Address::from_bytes(set.get(self)?)?;

+ // Only enable core 0 (we are single threaded anyway), which is bitset 0x0000001

+ self.write_memory(set, &[1])?;

+ // return 0 as success

+ self.write_memory_using_ref(destination.addr, destination.size)?.fill(0);

+ Ok(())

+ }

+ fn exec_platform_intrinsic(

+ &mut self,

+ name: &str,

+ args: &[IntervalAndTy],

+ generic_args: &Substitution,

+ destination: Interval,

+ locals: &Locals,

+ span: MirSpan,

+ ) -> Result<()> {

+ if let Some(name) = name.strip_prefix("simd_") {

+ return self.exec_simd_intrinsic(name, args, generic_args, destination, locals, span);

+ }

+ not_supported!("unknown platform intrinsic {name}");

+ }

+

+ locals: &Locals,

+ return Err(MirEvalError::TypeError(

+ "f64 intrinsic signature doesn't match fn (f64) -> f64",

+ ));

+ return Err(MirEvalError::TypeError(

+ "f64 intrinsic signature doesn't match fn (f64, f64) -> f64",

+ ));

+ return Err(MirEvalError::TypeError(

+ "powif64 signature doesn't match fn (f64, i32) -> f64",

+ ));

+ return Err(MirEvalError::TypeError(

+ "fmaf64 signature doesn't match fn (f64, f64, f64) -> f64",

+ ));

+ return Err(MirEvalError::TypeError(

+ "f32 intrinsic signature doesn't match fn (f32) -> f32",

+ ));

+ return Err(MirEvalError::TypeError(

+ "f32 intrinsic signature doesn't match fn (f32, f32) -> f32",

+ ));

+ return Err(MirEvalError::TypeError(

+ "powif32 signature doesn't match fn (f32, i32) -> f32",

+ ));

+ return Err(MirEvalError::TypeError(

+ "fmaf32 signature doesn't match fn (f32, f32, f32) -> f32",

+ ));

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner)) else {

+ "size_of_val" => {

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ return Err(MirEvalError::TypeError("size_of_val generic arg is not provided"));

+ };

+ let [arg] = args else {

+ return Err(MirEvalError::TypeError("size_of_val args are not provided"));

+ };

+ if let Some((size, _)) = self.size_align_of(ty, locals)? {

+ destination.write_from_bytes(self, &size.to_le_bytes())

+ } else {

+ let metadata = arg.interval.slice(self.ptr_size()..self.ptr_size() * 2);

+ let (size, _) = self.size_align_of_unsized(ty, metadata, locals)?;

+ destination.write_from_bytes(self, &size.to_le_bytes())

+ }

+ }

+ "min_align_of_val" => {

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner)) else {

+ return Err(MirEvalError::TypeError("min_align_of_val generic arg is not provided"));

+ };

+ let [arg] = args else {

+ return Err(MirEvalError::TypeError("min_align_of_val args are not provided"));

+ };

+ if let Some((_, align)) = self.size_align_of(ty, locals)? {

+ destination.write_from_bytes(self, &align.to_le_bytes())

+ } else {

+ let metadata = arg.interval.slice(self.ptr_size()..self.ptr_size() * 2);

+ let (_, align) = self.size_align_of_unsized(ty, metadata, locals)?;

+ destination.write_from_bytes(self, &align.to_le_bytes())

+ }

+ }

+ "type_name" => {

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ return Err(MirEvalError::TypeError("type_name generic arg is not provided"));

+ };

+ let Ok(ty_name) = ty.display_source_code(

+ self.db,

+ locals.body.owner.module(self.db.upcast()),

+ true,

+ ) else {

+ not_supported!("fail in generating type_name using source code display");

+ };

+ let len = ty_name.len();

+ let addr = self.heap_allocate(len, 1)?;

+ self.write_memory(addr, ty_name.as_bytes())?;

+ destination.slice(0..self.ptr_size()).write_from_bytes(self, &addr.to_bytes())?;

+ destination

+ .slice(self.ptr_size()..2 * self.ptr_size())

+ .write_from_bytes(self, &len.to_le_bytes())

+ }

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ "saturating_add" | "saturating_sub" => {

+ let ans = match name {

+ "saturating_add" => lhs.saturating_add(rhs),

+ "saturating_sub" => lhs.saturating_sub(rhs),

+ _ => unreachable!(),

+ };

+ "wrapping_shl" | "unchecked_shl" => {

+ // FIXME: signed

+ let [lhs, rhs] = args else {

+ return Err(MirEvalError::TypeError("unchecked_shl args are not provided"));

+ };

+ let lhs = u128::from_le_bytes(pad16(lhs.get(self)?, false));

+ let rhs = u128::from_le_bytes(pad16(rhs.get(self)?, false));

+ let ans = lhs.wrapping_shl(rhs as u32);

+ destination.write_from_bytes(self, &ans.to_le_bytes()[0..destination.size])

+ }

+ "wrapping_shr" | "unchecked_shr" => {

+ // FIXME: signed

+ let [lhs, rhs] = args else {

+ return Err(MirEvalError::TypeError("unchecked_shr args are not provided"));

+ };

+ let lhs = u128::from_le_bytes(pad16(lhs.get(self)?, false));

+ let rhs = u128::from_le_bytes(pad16(rhs.get(self)?, false));

+ let ans = lhs.wrapping_shr(rhs as u32);

+ destination.write_from_bytes(self, &ans.to_le_bytes()[0..destination.size])

+ }

+ || ans.to_le_bytes()[op_size..].iter().any(|&it| it != 0 && it != 255);

+ return Err(MirEvalError::TypeError(

+ "copy_nonoverlapping args are not provided",

+ ));

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ return Err(MirEvalError::TypeError(

+ "copy_nonoverlapping generic arg is not provided",

+ ));

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ return Err(MirEvalError::TypeError("ctpop arg is not provided"));

+ "ctlz" | "ctlz_nonzero" => {

+ let [arg] = args else {

+ return Err(MirEvalError::TypeError("cttz arg is not provided"));

+ };

+ let result =

+ u128::from_le_bytes(pad16(arg.get(self)?, false)).leading_zeros() as usize;

+ let result = result - (128 - arg.interval.size * 8);

+ destination

+ .write_from_bytes(self, &(result as u128).to_le_bytes()[0..destination.size])

+ }

+ return Err(MirEvalError::TypeError("cttz arg is not provided"));

+ "rotate_left" => {

+ let [lhs, rhs] = args else {

+ return Err(MirEvalError::TypeError("rotate_left args are not provided"));

+ };

+ let lhs = &lhs.get(self)?[0..destination.size];

+ let rhs = rhs.get(self)?[0] as u32;

+ match destination.size {

+ 1 => {

+ let r = from_bytes!(u8, lhs).rotate_left(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 2 => {

+ let r = from_bytes!(u16, lhs).rotate_left(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 4 => {

+ let r = from_bytes!(u32, lhs).rotate_left(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 8 => {

+ let r = from_bytes!(u64, lhs).rotate_left(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 16 => {

+ let r = from_bytes!(u128, lhs).rotate_left(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ s => not_supported!("destination with size {s} for rotate_left"),

+ }

+ }

+ "rotate_right" => {

+ let [lhs, rhs] = args else {

+ return Err(MirEvalError::TypeError("rotate_right args are not provided"));

+ };

+ let lhs = &lhs.get(self)?[0..destination.size];

+ let rhs = rhs.get(self)?[0] as u32;

+ match destination.size {

+ 1 => {

+ let r = from_bytes!(u8, lhs).rotate_right(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 2 => {

+ let r = from_bytes!(u16, lhs).rotate_right(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 4 => {

+ let r = from_bytes!(u32, lhs).rotate_right(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 8 => {

+ let r = from_bytes!(u64, lhs).rotate_right(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ 16 => {

+ let r = from_bytes!(u128, lhs).rotate_right(rhs);

+ destination.write_from_bytes(self, &r.to_le_bytes())

+ }

+ s => not_supported!("destination with size {s} for rotate_right"),

+ }

+ }

+ "discriminant_value" => {

+ let [arg] = args else {

+ return Err(MirEvalError::TypeError("discriminant_value arg is not provided"));

+ };

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ return Err(MirEvalError::TypeError(

+ "discriminant_value generic arg is not provided",

+ ));

+ };

+ let addr = Address::from_bytes(arg.get(self)?)?;

+ let size = self.size_of_sized(ty, locals, "discriminant_value ptr type")?;

+ let interval = Interval { addr, size };

+ let r = self.compute_discriminant(ty.clone(), interval.get(self)?)?;

+ destination.write_from_bytes(self, &r.to_le_bytes()[0..destination.size])

+ }

+ if let Some(target) = self.db.lang_item(self.crate_id, LangItem::FnOnce) {

+ if let Some(def) = target

+ .as_trait()

+ .and_then(|it| self.db.trait_data(it).method_by_name(&name![call_once]))

+ {

+ self.exec_fn_trait(

+ def,

+ &args,

+ // FIXME: wrong for manual impls of `FnOnce`

+ Substitution::empty(Interner),

+ locals,

+ destination,

+ None,

+ span,

+ )?;

+ return Ok(());

+ }

+ }

+ not_supported!("FnOnce was not available for executing const_eval_select");

+ }

+ "read_via_copy" | "volatile_load" => {

+ let [arg] = args else {

+ return Err(MirEvalError::TypeError("read_via_copy args are not provided"));

+ };

+ let addr = Address::from_bytes(arg.interval.get(self)?)?;

+ destination.write_from_interval(self, Interval { addr, size: destination.size })

+ }

+ "write_bytes" => {

+ let [dst, val, count] = args else {

+ return Err(MirEvalError::TypeError("write_bytes args are not provided"));

+ };

+ let count = from_bytes!(usize, count.get(self)?);

+ let val = from_bytes!(u8, val.get(self)?);

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

+ else {

+ return Err(MirEvalError::TypeError(

+ "write_bytes generic arg is not provided",

+ ));

+ };

+ let dst = Address::from_bytes(dst.get(self)?)?;

+ let size = self.size_of_sized(ty, locals, "copy_nonoverlapping ptr type")?;

+ let size = count * size;

+ self.write_memory_using_ref(dst, size)?.fill(val);

+ Ok(())

+ fn size_align_of_unsized(

+ &mut self,

+ ty: &Ty,

+ metadata: Interval,

+ locals: &Locals,

+ ) -> Result<(usize, usize)> {

+ Ok(match ty.kind(Interner) {

+ TyKind::Str => (from_bytes!(usize, metadata.get(self)?), 1),

+ TyKind::Slice(inner) => {

+ let len = from_bytes!(usize, metadata.get(self)?);

+ let (size, align) = self.size_align_of_sized(inner, locals, "slice inner type")?;

+ (size * len, align)

+ }

+ TyKind::Dyn(_) => self.size_align_of_sized(

+ self.vtable_map.ty_of_bytes(metadata.get(self)?)?,

+ locals,

+ "dyn concrete type",

+ )?,

+ TyKind::Adt(id, subst) => {

+ let id = id.0;

+ let layout = self.layout_adt(id, subst.clone())?;

+ let id = match id {

+ AdtId::StructId(s) => s,

+ _ => not_supported!("unsized enum or union"),

+ };

+ let field_types = &self.db.field_types(id.into());

+ let last_field_ty =

+ field_types.iter().rev().next().unwrap().1.clone().substitute(Interner, subst);

+ let sized_part_size =

+ layout.fields.offset(field_types.iter().count() - 1).bytes_usize();

+ let sized_part_align = layout.align.abi.bytes() as usize;

+ let (unsized_part_size, unsized_part_align) =

+ self.size_align_of_unsized(&last_field_ty, metadata, locals)?;

+ let align = sized_part_align.max(unsized_part_align) as isize;

+ let size = (sized_part_size + unsized_part_size) as isize;

+ // Must add any necessary padding to `size`

+ // (to make it a multiple of `align`) before returning it.

+ //

+ // Namely, the returned size should be, in C notation:

+ //

+ // `size + ((size & (align-1)) ? align : 0)`

+ //

+ // emulated via the semi-standard fast bit trick:

+ //

+ // `(size + (align-1)) & -align`

+ let size = (size + (align - 1)) & (-align);

+ (size as usize, align as usize)

+ }

+ _ => not_supported!("unsized type other than str, slice, struct and dyn"),

+ })

+ }

+

+ locals: &Locals,

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner)) else {