ConstValue::Slice { data: alloc, start: 0, end: alloc.len() }
}
sym::needs_drop => ConstValue::from_bool(tp_ty.needs_drop(tcx, param_env)),
- sym::size_of | sym::min_align_of | sym::pref_align_of => {
+ sym::min_align_of | sym::pref_align_of => {
let layout = tcx.layout_of(param_env.and(tp_ty)).map_err(|e| err_inval!(Layout(e)))?;
let n = match name {
sym::pref_align_of => layout.align.pref.bytes(),
sym::min_align_of => layout.align.abi.bytes(),
- sym::size_of => layout.size.bytes(),
_ => bug!(),
};
ConstValue::from_machine_usize(n, &tcx)
let (dest, ret) = match ret {
None => match intrinsic_name {
sym::transmute => throw_ub_format!("transmuting to uninhabited type"),
- sym::unreachable => throw_ub!(Unreachable),
- sym::abort => M::abort(self)?,
+ sym::abort => M::abort(self, "the program aborted execution".to_owned())?,
// Unsupported diverging intrinsic.
_ => return Ok(false),
},
sym::min_align_of
| sym::pref_align_of
| sym::needs_drop
- | sym::size_of
| sym::type_id
| sym::type_name
| sym::variant_count => {
let gid = GlobalId { instance, promoted: None };
let ty = match intrinsic_name {
- sym::min_align_of | sym::pref_align_of | sym::size_of | sym::variant_count => {
+ sym::min_align_of | sym::pref_align_of | sym::variant_count => {
self.tcx.types.usize
}
sym::needs_drop => self.tcx.types.bool,
let out_val = numeric_intrinsic(intrinsic_name, bits, kind)?;
self.write_scalar(out_val, dest)?;
}
- sym::wrapping_add
- | sym::wrapping_sub
- | sym::wrapping_mul
- | sym::add_with_overflow
- | sym::sub_with_overflow
- | sym::mul_with_overflow => {
+ sym::add_with_overflow | sym::sub_with_overflow | sym::mul_with_overflow => {
let lhs = self.read_immediate(args[0])?;
let rhs = self.read_immediate(args[1])?;
- let (bin_op, ignore_overflow) = match intrinsic_name {
- sym::wrapping_add => (BinOp::Add, true),
- sym::wrapping_sub => (BinOp::Sub, true),
- sym::wrapping_mul => (BinOp::Mul, true),
- sym::add_with_overflow => (BinOp::Add, false),
- sym::sub_with_overflow => (BinOp::Sub, false),
- sym::mul_with_overflow => (BinOp::Mul, false),
+ let bin_op = match intrinsic_name {
+ sym::add_with_overflow => BinOp::Add,
+ sym::sub_with_overflow => BinOp::Sub,
+ sym::mul_with_overflow => BinOp::Mul,
_ => bug!("Already checked for int ops"),
};
- if ignore_overflow {
- self.binop_ignore_overflow(bin_op, lhs, rhs, dest)?;
- } else {
- self.binop_with_overflow(bin_op, lhs, rhs, dest)?;
- }
+ self.binop_with_overflow(bin_op, lhs, rhs, dest)?;
}
sym::saturating_add | sym::saturating_sub => {
let l = self.read_immediate(args[0])?;
sym::transmute => {
self.copy_op_transmute(args[0], dest)?;
}
+ sym::assert_inhabited => {
+ let ty = instance.substs.type_at(0);
+ let layout = self.layout_of(ty)?;
+
+ if layout.abi.is_uninhabited() {
+ // The run-time intrinsic panics just to get a good backtrace; here we abort
+ // since there is no problem showing a backtrace even for aborts.
+ M::abort(
+ self,
+ format!(
+ "aborted execution: attempted to instantiate uninhabited type `{}`",
+ ty
+ ),
+ )?;
+ }
+ }
sym::simd_insert => {
let index = u64::from(self.read_scalar(args[1])?.to_u32()?);
let elem = args[2];