&mut self,
instance: ty::Instance<'tcx>,
args: &[OpTy<'tcx, Tag>],
- ret: Option<(&PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
+ dest: &PlaceTy<'tcx, Tag>,
+ ret: Option<mir::BasicBlock>,
_unwind: StackPopUnwind,
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- if this.emulate_intrinsic(instance, args, ret)? {
+ if this.emulate_intrinsic(instance, args, dest, ret)? {
return Ok(());
}
// All supported intrinsics have a return place.
let intrinsic_name = this.tcx.item_name(instance.def_id());
let intrinsic_name = intrinsic_name.as_str();
- let (dest, ret) = match ret {
+ let ret = match ret {
None => throw_unsup_format!("unimplemented (diverging) intrinsic: {}", intrinsic_name),
Some(p) => p,
};
match intrinsic_name {
// Miri overwriting CTFE intrinsics.
"ptr_guaranteed_eq" => {
- let &[ref left, ref right] = check_arg_count(args)?;
+ let [left, right] = check_arg_count(args)?;
let left = this.read_immediate(left)?;
let right = this.read_immediate(right)?;
this.binop_ignore_overflow(mir::BinOp::Eq, &left, &right, dest)?;
}
"ptr_guaranteed_ne" => {
- let &[ref left, ref right] = check_arg_count(args)?;
+ let [left, right] = check_arg_count(args)?;
let left = this.read_immediate(left)?;
let right = this.read_immediate(right)?;
this.binop_ignore_overflow(mir::BinOp::Ne, &left, &right, dest)?;
// Raw memory accesses
"volatile_load" => {
- let &[ref place] = check_arg_count(args)?;
+ let [place] = check_arg_count(args)?;
let place = this.deref_operand(place)?;
this.copy_op(&place.into(), dest)?;
}
"volatile_store" => {
- let &[ref place, ref dest] = check_arg_count(args)?;
+ let [place, dest] = check_arg_count(args)?;
let place = this.deref_operand(place)?;
this.copy_op(dest, &place.into())?;
}
"write_bytes" | "volatile_set_memory" => {
- let &[ref ptr, ref val_byte, ref count] = check_arg_count(args)?;
+ let [ptr, val_byte, count] = check_arg_count(args)?;
let ty = instance.substs.type_at(0);
let ty_layout = this.layout_of(ty)?;
let val_byte = this.read_scalar(val_byte)?.to_u8()?;
// Floating-point operations
"fabsf32" => {
- let &[ref f] = check_arg_count(args)?;
+ let [f] = check_arg_count(args)?;
let f = this.read_scalar(f)?.to_f32()?;
// Can be implemented in soft-floats.
this.write_scalar(Scalar::from_f32(f.abs()), dest)?;
}
"fabsf64" => {
- let &[ref f] = check_arg_count(args)?;
+ let [f] = check_arg_count(args)?;
let f = this.read_scalar(f)?.to_f64()?;
// Can be implemented in soft-floats.
this.write_scalar(Scalar::from_f64(f.abs()), dest)?;
| "truncf32"
| "roundf32"
=> {
- let &[ref f] = check_arg_count(args)?;
+ let [f] = check_arg_count(args)?;
// FIXME: Using host floats.
let f = f32::from_bits(this.read_scalar(f)?.to_u32()?);
let f = match intrinsic_name {
| "truncf64"
| "roundf64"
=> {
- let &[ref f] = check_arg_count(args)?;
+ let [f] = check_arg_count(args)?;
// FIXME: Using host floats.
let f = f64::from_bits(this.read_scalar(f)?.to_u64()?);
let f = match intrinsic_name {
| "fdiv_fast"
| "frem_fast"
=> {
- let &[ref a, ref b] = check_arg_count(args)?;
+ let [a, b] = check_arg_count(args)?;
let a = this.read_immediate(a)?;
let b = this.read_immediate(b)?;
let op = match intrinsic_name {
| "maxnumf32"
| "copysignf32"
=> {
- let &[ref a, ref b] = check_arg_count(args)?;
+ let [a, b] = check_arg_count(args)?;
let a = this.read_scalar(a)?.to_f32()?;
let b = this.read_scalar(b)?.to_f32()?;
let res = match intrinsic_name {
| "maxnumf64"
| "copysignf64"
=> {
- let &[ref a, ref b] = check_arg_count(args)?;
+ let [a, b] = check_arg_count(args)?;
let a = this.read_scalar(a)?.to_f64()?;
let b = this.read_scalar(b)?.to_f64()?;
let res = match intrinsic_name {
}
"powf32" => {
- let &[ref f, ref f2] = check_arg_count(args)?;
+ let [f, f2] = check_arg_count(args)?;
// FIXME: Using host floats.
let f = f32::from_bits(this.read_scalar(f)?.to_u32()?);
let f2 = f32::from_bits(this.read_scalar(f2)?.to_u32()?);
}
"powf64" => {
- let &[ref f, ref f2] = check_arg_count(args)?;
+ let [f, f2] = check_arg_count(args)?;
// FIXME: Using host floats.
let f = f64::from_bits(this.read_scalar(f)?.to_u64()?);
let f2 = f64::from_bits(this.read_scalar(f2)?.to_u64()?);
}
"fmaf32" => {
- let &[ref a, ref b, ref c] = check_arg_count(args)?;
+ let [a, b, c] = check_arg_count(args)?;
let a = this.read_scalar(a)?.to_f32()?;
let b = this.read_scalar(b)?.to_f32()?;
let c = this.read_scalar(c)?.to_f32()?;
}
"fmaf64" => {
- let &[ref a, ref b, ref c] = check_arg_count(args)?;
+ let [a, b, c] = check_arg_count(args)?;
let a = this.read_scalar(a)?.to_f64()?;
let b = this.read_scalar(b)?.to_f64()?;
let c = this.read_scalar(c)?.to_f64()?;
}
"powif32" => {
- let &[ref f, ref i] = check_arg_count(args)?;
+ let [f, i] = check_arg_count(args)?;
// FIXME: Using host floats.
let f = f32::from_bits(this.read_scalar(f)?.to_u32()?);
let i = this.read_scalar(i)?.to_i32()?;
}
"powif64" => {
- let &[ref f, ref i] = check_arg_count(args)?;
+ let [f, i] = check_arg_count(args)?;
// FIXME: Using host floats.
let f = f64::from_bits(this.read_scalar(f)?.to_u64()?);
let i = this.read_scalar(i)?.to_i32()?;
}
"float_to_int_unchecked" => {
- let &[ref val] = check_arg_count(args)?;
+ let [val] = check_arg_count(args)?;
let val = this.read_immediate(val)?;
let res = match val.layout.ty.kind() {
| "simd_round"
| "simd_trunc"
| "simd_fsqrt" => {
- let &[ref op] = check_arg_count(args)?;
+ let [op] = check_arg_count(args)?;
let (op, op_len) = this.operand_to_simd(op)?;
let (dest, dest_len) = this.place_to_simd(dest)?;
| "simd_arith_offset" => {
use mir::BinOp;
- let &[ref left, ref right] = check_arg_count(args)?;
+ let [left, right] = check_arg_count(args)?;
let (left, left_len) = this.operand_to_simd(left)?;
let (right, right_len) = this.operand_to_simd(right)?;
let (dest, dest_len) = this.place_to_simd(dest)?;
}
}
"simd_fma" => {
- let &[ref a, ref b, ref c] = check_arg_count(args)?;
+ let [a, b, c] = check_arg_count(args)?;
let (a, a_len) = this.operand_to_simd(a)?;
let (b, b_len) = this.operand_to_simd(b)?;
let (c, c_len) = this.operand_to_simd(c)?;
| "simd_reduce_min" => {
use mir::BinOp;
- let &[ref op] = check_arg_count(args)?;
+ let [op] = check_arg_count(args)?;
let (op, op_len) = this.operand_to_simd(op)?;
let imm_from_bool =
| "simd_reduce_mul_ordered" => {
use mir::BinOp;
- let &[ref op, ref init] = check_arg_count(args)?;
+ let [op, init] = check_arg_count(args)?;
let (op, op_len) = this.operand_to_simd(op)?;
let init = this.read_immediate(init)?;
this.write_immediate(*res, dest)?;
}
"simd_select" => {
- let &[ref mask, ref yes, ref no] = check_arg_count(args)?;
+ let [mask, yes, no] = check_arg_count(args)?;
let (mask, mask_len) = this.operand_to_simd(mask)?;
let (yes, yes_len) = this.operand_to_simd(yes)?;
let (no, no_len) = this.operand_to_simd(no)?;
}
}
"simd_select_bitmask" => {
- let &[ref mask, ref yes, ref no] = check_arg_count(args)?;
+ let [mask, yes, no] = check_arg_count(args)?;
let (yes, yes_len) = this.operand_to_simd(yes)?;
let (no, no_len) = this.operand_to_simd(no)?;
let (dest, dest_len) = this.place_to_simd(dest)?;
}
#[rustfmt::skip]
"simd_cast" | "simd_as" => {
- let &[ref op] = check_arg_count(args)?;
+ let [op] = check_arg_count(args)?;
let (op, op_len) = this.operand_to_simd(op)?;
let (dest, dest_len) = this.place_to_simd(dest)?;
}
}
"simd_shuffle" => {
- let &[ref left, ref right, ref index] = check_arg_count(args)?;
+ let [left, right, index] = check_arg_count(args)?;
let (left, left_len) = this.operand_to_simd(left)?;
let (right, right_len) = this.operand_to_simd(right)?;
let (dest, dest_len) = this.place_to_simd(dest)?;
for i in 0..dest_len {
let src_index: u64 = this
- .read_immediate(&this.operand_index(index, i)?.into())?
+ .read_immediate(&this.operand_index(index, i)?)?
.to_scalar()?
.to_u32()?
.into();
}
}
"simd_gather" => {
- let &[ref passthru, ref ptrs, ref mask] = check_arg_count(args)?;
+ let [passthru, ptrs, mask] = check_arg_count(args)?;
let (passthru, passthru_len) = this.operand_to_simd(passthru)?;
let (ptrs, ptrs_len) = this.operand_to_simd(ptrs)?;
let (mask, mask_len) = this.operand_to_simd(mask)?;
}
}
"simd_scatter" => {
- let &[ref value, ref ptrs, ref mask] = check_arg_count(args)?;
+ let [value, ptrs, mask] = check_arg_count(args)?;
let (value, value_len) = this.operand_to_simd(value)?;
let (ptrs, ptrs_len) = this.operand_to_simd(ptrs)?;
let (mask, mask_len) = this.operand_to_simd(mask)?;
}
}
"simd_bitmask" => {
- let &[ref op] = check_arg_count(args)?;
+ let [op] = check_arg_count(args)?;
let (op, op_len) = this.operand_to_simd(op)?;
let bitmask_len = op_len.max(8);
}
// Atomic operations
- "atomic_load" => this.atomic_load(args, dest, AtomicReadOp::SeqCst)?,
+ "atomic_load_seqcst" => this.atomic_load(args, dest, AtomicReadOp::SeqCst)?,
"atomic_load_relaxed" => this.atomic_load(args, dest, AtomicReadOp::Relaxed)?,
- "atomic_load_acq" => this.atomic_load(args, dest, AtomicReadOp::Acquire)?,
+ "atomic_load_acquire" => this.atomic_load(args, dest, AtomicReadOp::Acquire)?,
- "atomic_store" => this.atomic_store(args, AtomicWriteOp::SeqCst)?,
+ "atomic_store_seqcst" => this.atomic_store(args, AtomicWriteOp::SeqCst)?,
"atomic_store_relaxed" => this.atomic_store(args, AtomicWriteOp::Relaxed)?,
- "atomic_store_rel" => this.atomic_store(args, AtomicWriteOp::Release)?,
+ "atomic_store_release" => this.atomic_store(args, AtomicWriteOp::Release)?,
- "atomic_fence_acq" => this.atomic_fence(args, AtomicFenceOp::Acquire)?,
- "atomic_fence_rel" => this.atomic_fence(args, AtomicFenceOp::Release)?,
+ "atomic_fence_acquire" => this.atomic_fence(args, AtomicFenceOp::Acquire)?,
+ "atomic_fence_release" => this.atomic_fence(args, AtomicFenceOp::Release)?,
"atomic_fence_acqrel" => this.atomic_fence(args, AtomicFenceOp::AcqRel)?,
- "atomic_fence" => this.atomic_fence(args, AtomicFenceOp::SeqCst)?,
+ "atomic_fence_seqcst" => this.atomic_fence(args, AtomicFenceOp::SeqCst)?,
- "atomic_singlethreadfence_acq" => this.compiler_fence(args, AtomicFenceOp::Acquire)?,
- "atomic_singlethreadfence_rel" => this.compiler_fence(args, AtomicFenceOp::Release)?,
+ "atomic_singlethreadfence_acquire" =>
+ this.compiler_fence(args, AtomicFenceOp::Acquire)?,
+ "atomic_singlethreadfence_release" =>
+ this.compiler_fence(args, AtomicFenceOp::Release)?,
"atomic_singlethreadfence_acqrel" =>
this.compiler_fence(args, AtomicFenceOp::AcqRel)?,
- "atomic_singlethreadfence" => this.compiler_fence(args, AtomicFenceOp::SeqCst)?,
+ "atomic_singlethreadfence_seqcst" =>
+ this.compiler_fence(args, AtomicFenceOp::SeqCst)?,
- "atomic_xchg" => this.atomic_exchange(args, dest, AtomicRwOp::SeqCst)?,
- "atomic_xchg_acq" => this.atomic_exchange(args, dest, AtomicRwOp::Acquire)?,
- "atomic_xchg_rel" => this.atomic_exchange(args, dest, AtomicRwOp::Release)?,
+ "atomic_xchg_seqcst" => this.atomic_exchange(args, dest, AtomicRwOp::SeqCst)?,
+ "atomic_xchg_acquire" => this.atomic_exchange(args, dest, AtomicRwOp::Acquire)?,
+ "atomic_xchg_release" => this.atomic_exchange(args, dest, AtomicRwOp::Release)?,
"atomic_xchg_acqrel" => this.atomic_exchange(args, dest, AtomicRwOp::AcqRel)?,
"atomic_xchg_relaxed" => this.atomic_exchange(args, dest, AtomicRwOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchg" =>
+ "atomic_cxchg_seqcst_seqcst" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::SeqCst, AtomicReadOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_cxchg_acq" =>
+ "atomic_cxchg_acquire_acquire" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::Acquire, AtomicReadOp::Acquire)?,
#[rustfmt::skip]
- "atomic_cxchg_rel" =>
+ "atomic_cxchg_release_relaxed" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::Release, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchg_acqrel" =>
+ "atomic_cxchg_acqrel_acquire" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::AcqRel, AtomicReadOp::Acquire)?,
#[rustfmt::skip]
- "atomic_cxchg_relaxed" =>
+ "atomic_cxchg_relaxed_relaxed" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::Relaxed, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchg_acq_failrelaxed" =>
+ "atomic_cxchg_acquire_relaxed" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::Acquire, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchg_acqrel_failrelaxed" =>
+ "atomic_cxchg_acqrel_relaxed" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::AcqRel, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchg_failrelaxed" =>
+ "atomic_cxchg_seqcst_relaxed" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::SeqCst, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchg_failacq" =>
+ "atomic_cxchg_seqcst_acquire" =>
this.atomic_compare_exchange(args, dest, AtomicRwOp::SeqCst, AtomicReadOp::Acquire)?,
#[rustfmt::skip]
- "atomic_cxchgweak" =>
+ "atomic_cxchgweak_seqcst_seqcst" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::SeqCst, AtomicReadOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_cxchgweak_acq" =>
+ "atomic_cxchgweak_acquire_acquire" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::Acquire, AtomicReadOp::Acquire)?,
#[rustfmt::skip]
- "atomic_cxchgweak_rel" =>
+ "atomic_cxchgweak_release_relaxed" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::Release, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchgweak_acqrel" =>
+ "atomic_cxchgweak_acqrel_acquire" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::AcqRel, AtomicReadOp::Acquire)?,
#[rustfmt::skip]
- "atomic_cxchgweak_relaxed" =>
+ "atomic_cxchgweak_relaxed_relaxed" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::Relaxed, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchgweak_acq_failrelaxed" =>
+ "atomic_cxchgweak_acquire_relaxed" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::Acquire, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchgweak_acqrel_failrelaxed" =>
+ "atomic_cxchgweak_acqrel_relaxed" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::AcqRel, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchgweak_failrelaxed" =>
+ "atomic_cxchgweak_seqcst_relaxed" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::SeqCst, AtomicReadOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_cxchgweak_failacq" =>
+ "atomic_cxchgweak_seqcst_acquire" =>
this.atomic_compare_exchange_weak(args, dest, AtomicRwOp::SeqCst, AtomicReadOp::Acquire)?,
#[rustfmt::skip]
- "atomic_or" =>
+ "atomic_or_seqcst" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitOr, false), AtomicRwOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_or_acq" =>
+ "atomic_or_acquire" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitOr, false), AtomicRwOp::Acquire)?,
#[rustfmt::skip]
- "atomic_or_rel" =>
+ "atomic_or_release" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitOr, false), AtomicRwOp::Release)?,
#[rustfmt::skip]
"atomic_or_acqrel" =>
"atomic_or_relaxed" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitOr, false), AtomicRwOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_xor" =>
+ "atomic_xor_seqcst" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitXor, false), AtomicRwOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_xor_acq" =>
+ "atomic_xor_acquire" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitXor, false), AtomicRwOp::Acquire)?,
#[rustfmt::skip]
- "atomic_xor_rel" =>
+ "atomic_xor_release" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitXor, false), AtomicRwOp::Release)?,
#[rustfmt::skip]
"atomic_xor_acqrel" =>
"atomic_xor_relaxed" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitXor, false), AtomicRwOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_and" =>
+ "atomic_and_seqcst" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, false), AtomicRwOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_and_acq" =>
+ "atomic_and_acquire" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, false), AtomicRwOp::Acquire)?,
#[rustfmt::skip]
- "atomic_and_rel" =>
+ "atomic_and_release" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, false), AtomicRwOp::Release)?,
#[rustfmt::skip]
"atomic_and_acqrel" =>
"atomic_and_relaxed" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, false), AtomicRwOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_nand" =>
+ "atomic_nand_seqcst" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, true), AtomicRwOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_nand_acq" =>
+ "atomic_nand_acquire" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, true), AtomicRwOp::Acquire)?,
#[rustfmt::skip]
- "atomic_nand_rel" =>
+ "atomic_nand_release" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, true), AtomicRwOp::Release)?,
#[rustfmt::skip]
"atomic_nand_acqrel" =>
"atomic_nand_relaxed" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, true), AtomicRwOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_xadd" =>
+ "atomic_xadd_seqcst" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Add, false), AtomicRwOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_xadd_acq" =>
+ "atomic_xadd_acquire" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Add, false), AtomicRwOp::Acquire)?,
#[rustfmt::skip]
- "atomic_xadd_rel" =>
+ "atomic_xadd_release" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Add, false), AtomicRwOp::Release)?,
#[rustfmt::skip]
"atomic_xadd_acqrel" =>
"atomic_xadd_relaxed" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Add, false), AtomicRwOp::Relaxed)?,
#[rustfmt::skip]
- "atomic_xsub" =>
+ "atomic_xsub_seqcst" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Sub, false), AtomicRwOp::SeqCst)?,
#[rustfmt::skip]
- "atomic_xsub_acq" =>
+ "atomic_xsub_acquire" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Sub, false), AtomicRwOp::Acquire)?,
#[rustfmt::skip]
- "atomic_xsub_rel" =>
+ "atomic_xsub_release" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Sub, false), AtomicRwOp::Release)?,
#[rustfmt::skip]
"atomic_xsub_acqrel" =>
#[rustfmt::skip]
"atomic_xsub_relaxed" =>
this.atomic_op(args, dest, AtomicOp::MirOp(BinOp::Sub, false), AtomicRwOp::Relaxed)?,
- "atomic_min" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::SeqCst)?,
- "atomic_min_acq" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Acquire)?,
- "atomic_min_rel" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Release)?,
+ "atomic_min_seqcst" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::SeqCst)?,
+ "atomic_min_acquire" =>
+ this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Acquire)?,
+ "atomic_min_release" =>
+ this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Release)?,
"atomic_min_acqrel" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::AcqRel)?,
"atomic_min_relaxed" =>
this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Relaxed)?,
- "atomic_max" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::SeqCst)?,
- "atomic_max_acq" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Acquire)?,
- "atomic_max_rel" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Release)?,
+ "atomic_max_seqcst" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::SeqCst)?,
+ "atomic_max_acquire" =>
+ this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Acquire)?,
+ "atomic_max_release" =>
+ this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Release)?,
"atomic_max_acqrel" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::AcqRel)?,
"atomic_max_relaxed" =>
this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Relaxed)?,
- "atomic_umin" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::SeqCst)?,
- "atomic_umin_acq" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Acquire)?,
- "atomic_umin_rel" => this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Release)?,
+ "atomic_umin_seqcst" =>
+ this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::SeqCst)?,
+ "atomic_umin_acquire" =>
+ this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Acquire)?,
+ "atomic_umin_release" =>
+ this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Release)?,
"atomic_umin_acqrel" =>
this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::AcqRel)?,
"atomic_umin_relaxed" =>
this.atomic_op(args, dest, AtomicOp::Min, AtomicRwOp::Relaxed)?,
- "atomic_umax" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::SeqCst)?,
- "atomic_umax_acq" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Acquire)?,
- "atomic_umax_rel" => this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Release)?,
+ "atomic_umax_seqcst" =>
+ this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::SeqCst)?,
+ "atomic_umax_acquire" =>
+ this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Acquire)?,
+ "atomic_umax_release" =>
+ this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::Release)?,
"atomic_umax_acqrel" =>
this.atomic_op(args, dest, AtomicOp::Max, AtomicRwOp::AcqRel)?,
"atomic_umax_relaxed" =>
// Other
"exact_div" => {
- let &[ref num, ref denom] = check_arg_count(args)?;
+ let [num, denom] = check_arg_count(args)?;
this.exact_div(&this.read_immediate(num)?, &this.read_immediate(denom)?, dest)?;
}
"try" => return this.handle_try(args, dest, ret),
"breakpoint" => {
- let &[] = check_arg_count(args)?;
+ let [] = check_arg_count(args)?;
// normally this would raise a SIGTRAP, which aborts if no debugger is connected
throw_machine_stop!(TerminationInfo::Abort("Trace/breakpoint trap".to_string()))
}
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- let &[ref place] = check_arg_count(args)?;
+ let [place] = check_arg_count(args)?;
let place = this.deref_operand(place)?;
// make sure it fits into a scalar; otherwise it cannot be atomic
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- let &[ref place, ref val] = check_arg_count(args)?;
+ let [place, val] = check_arg_count(args)?;
let place = this.deref_operand(place)?;
let val = this.read_scalar(val)?; // make sure it fits into a scalar; otherwise it cannot be atomic
args: &[OpTy<'tcx, Tag>],
atomic: AtomicFenceOp,
) -> InterpResult<'tcx> {
- let &[] = check_arg_count(args)?;
+ let [] = check_arg_count(args)?;
let _ = atomic;
//FIXME: compiler fences are currently ignored
Ok(())
atomic: AtomicFenceOp,
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- let &[] = check_arg_count(args)?;
+ let [] = check_arg_count(args)?;
this.validate_atomic_fence(atomic)?;
Ok(())
}
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- let &[ref place, ref rhs] = check_arg_count(args)?;
+ let [place, rhs] = check_arg_count(args)?;
let place = this.deref_operand(place)?;
if !place.layout.ty.is_integral() {
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- let &[ref place, ref new] = check_arg_count(args)?;
+ let [place, new] = check_arg_count(args)?;
let place = this.deref_operand(place)?;
let new = this.read_scalar(new)?;
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- let &[ref place, ref expect_old, ref new] = check_arg_count(args)?;
+ let [place, expect_old, new] = check_arg_count(args)?;
let place = this.deref_operand(place)?;
let expect_old = this.read_immediate(expect_old)?; // read as immediate for the sake of `binary_op()`
let new = this.read_scalar(new)?;
Scalar::from_int(val, size)
}
-fn simd_element_to_bool<'tcx>(elem: ImmTy<'tcx, Tag>) -> InterpResult<'tcx, bool> {
+fn simd_element_to_bool(elem: ImmTy<'_, Tag>) -> InterpResult<'_, bool> {
let val = elem.to_scalar()?.to_int(elem.layout.size)?;
Ok(match val {
0 => false,
projects / rust.git / blobdiff