2019-02-08 09:27:00 -06:00
|
|
|
use rustc::ty::Ty;
|
2017-07-25 04:32:48 -05:00
|
|
|
use rustc::mir;
|
|
|
|
|
2018-11-01 02:56:41 -05:00
|
|
|
use crate::*;
|
2017-07-25 04:32:48 -05:00
|
|
|
|
|
|
|
pub trait EvalContextExt<'tcx> {
|
|
|
|
fn ptr_op(
|
|
|
|
&self,
|
|
|
|
bin_op: mir::BinOp,
|
2019-02-08 07:01:40 -06:00
|
|
|
left: ImmTy<'tcx, Borrow>,
|
|
|
|
right: ImmTy<'tcx, Borrow>,
|
2018-10-16 04:21:38 -05:00
|
|
|
) -> EvalResult<'tcx, (Scalar<Borrow>, bool)>;
|
2017-07-25 04:32:48 -05:00
|
|
|
|
|
|
|
fn ptr_int_arithmetic(
|
|
|
|
&self,
|
|
|
|
bin_op: mir::BinOp,
|
2018-10-16 04:21:38 -05:00
|
|
|
left: Pointer<Borrow>,
|
2018-08-14 13:25:56 -05:00
|
|
|
right: u128,
|
2017-07-25 04:32:48 -05:00
|
|
|
signed: bool,
|
2018-10-16 04:21:38 -05:00
|
|
|
) -> EvalResult<'tcx, (Scalar<Borrow>, bool)>;
|
2018-08-15 14:01:40 -05:00
|
|
|
|
2018-08-28 11:13:58 -05:00
|
|
|
fn ptr_eq(
|
|
|
|
&self,
|
2018-10-16 04:21:38 -05:00
|
|
|
left: Scalar<Borrow>,
|
|
|
|
right: Scalar<Borrow>,
|
2018-08-28 11:13:58 -05:00
|
|
|
) -> EvalResult<'tcx, bool>;
|
|
|
|
|
2018-08-15 14:01:40 -05:00
|
|
|
fn pointer_offset_inbounds(
|
|
|
|
&self,
|
2018-10-16 04:21:38 -05:00
|
|
|
ptr: Scalar<Borrow>,
|
2018-08-15 14:01:40 -05:00
|
|
|
pointee_ty: Ty<'tcx>,
|
|
|
|
offset: i64,
|
2018-10-16 04:21:38 -05:00
|
|
|
) -> EvalResult<'tcx, Scalar<Borrow>>;
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
|
|
|
|
2018-10-16 11:01:50 -05:00
|
|
|
impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, 'tcx> {
|
2017-07-25 04:32:48 -05:00
|
|
|
fn ptr_op(
|
|
|
|
&self,
|
|
|
|
bin_op: mir::BinOp,
|
2019-02-08 07:01:40 -06:00
|
|
|
left: ImmTy<'tcx, Borrow>,
|
|
|
|
right: ImmTy<'tcx, Borrow>,
|
2018-10-16 04:21:38 -05:00
|
|
|
) -> EvalResult<'tcx, (Scalar<Borrow>, bool)> {
|
2018-08-28 11:13:58 -05:00
|
|
|
use rustc::mir::BinOp::*;
|
|
|
|
|
2019-02-08 09:27:00 -06:00
|
|
|
trace!("ptr_op: {:?} {:?} {:?}", *left, bin_op, *right);
|
|
|
|
|
|
|
|
// Operations that support fat pointers
|
|
|
|
match bin_op {
|
|
|
|
Eq | Ne => {
|
|
|
|
let eq = match (*left, *right) {
|
|
|
|
(Immediate::Scalar(left), Immediate::Scalar(right)) =>
|
|
|
|
self.ptr_eq(left.not_undef()?, right.not_undef()?)?,
|
|
|
|
(Immediate::ScalarPair(left1, left2), Immediate::ScalarPair(right1, right2)) =>
|
|
|
|
self.ptr_eq(left1.not_undef()?, right1.not_undef()?)? &&
|
|
|
|
self.ptr_eq(left2.not_undef()?, right2.not_undef()?)?,
|
|
|
|
_ => bug!("Type system should not allow comparing Scalar with ScalarPair"),
|
|
|
|
};
|
|
|
|
return Ok((Scalar::from_bool(if bin_op == Eq { eq } else { !eq }), false));
|
|
|
|
}
|
|
|
|
_ => {},
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now we expect no more fat pointers
|
2019-02-08 07:01:40 -06:00
|
|
|
let left_layout = left.layout;
|
|
|
|
let left = left.to_scalar()?;
|
|
|
|
let right_layout = right.layout;
|
|
|
|
let right = right.to_scalar()?;
|
2018-08-28 11:13:58 -05:00
|
|
|
debug_assert!(left.is_ptr() || right.is_ptr() || bin_op == Offset);
|
2018-07-15 14:25:03 -05:00
|
|
|
|
2017-07-25 04:32:48 -05:00
|
|
|
match bin_op {
|
2018-08-15 14:01:40 -05:00
|
|
|
Offset => {
|
|
|
|
let pointee_ty = left_layout.ty
|
2018-01-14 11:59:13 -06:00
|
|
|
.builtin_deref(true)
|
2017-08-10 10:48:38 -05:00
|
|
|
.expect("Offset called on non-ptr type")
|
|
|
|
.ty;
|
2018-08-15 14:01:40 -05:00
|
|
|
let ptr = self.pointer_offset_inbounds(
|
2018-07-10 10:32:38 -05:00
|
|
|
left,
|
2017-08-10 10:48:38 -05:00
|
|
|
pointee_ty,
|
2018-08-28 11:13:58 -05:00
|
|
|
right.to_isize(self)?,
|
2017-08-10 10:48:38 -05:00
|
|
|
)?;
|
2018-08-28 11:13:58 -05:00
|
|
|
Ok((ptr, false))
|
2017-08-10 10:48:38 -05:00
|
|
|
}
|
2018-08-28 11:13:58 -05:00
|
|
|
// These need both to be pointer, and fail if they are not in the same location
|
|
|
|
Lt | Le | Gt | Ge | Sub if left.is_ptr() && right.is_ptr() => {
|
|
|
|
let left = left.to_ptr().expect("we checked is_ptr");
|
|
|
|
let right = right.to_ptr().expect("we checked is_ptr");
|
2017-07-25 04:32:48 -05:00
|
|
|
if left.alloc_id == right.alloc_id {
|
|
|
|
let res = match bin_op {
|
|
|
|
Lt => left.offset < right.offset,
|
|
|
|
Le => left.offset <= right.offset,
|
|
|
|
Gt => left.offset > right.offset,
|
|
|
|
Ge => left.offset >= right.offset,
|
2017-08-10 10:48:38 -05:00
|
|
|
Sub => {
|
2018-08-28 11:13:58 -05:00
|
|
|
// subtract the offsets
|
2018-10-19 12:51:41 -05:00
|
|
|
let left_offset = Scalar::from_uint(left.offset.bytes(), self.memory().pointer_size());
|
|
|
|
let right_offset = Scalar::from_uint(right.offset.bytes(), self.memory().pointer_size());
|
2018-08-15 14:01:40 -05:00
|
|
|
let layout = self.layout_of(self.tcx.types.usize)?;
|
2017-08-10 10:48:38 -05:00
|
|
|
return self.binary_op(
|
|
|
|
Sub,
|
2019-02-08 07:01:40 -06:00
|
|
|
ImmTy::from_scalar(left_offset, layout),
|
|
|
|
ImmTy::from_scalar(right_offset, layout),
|
2018-08-28 11:13:58 -05:00
|
|
|
)
|
2017-08-10 10:48:38 -05:00
|
|
|
}
|
2017-07-25 04:32:48 -05:00
|
|
|
_ => bug!("We already established it has to be one of these operators."),
|
|
|
|
};
|
2018-08-28 11:13:58 -05:00
|
|
|
Ok((Scalar::from_bool(res), false))
|
2017-07-25 04:32:48 -05:00
|
|
|
} else {
|
|
|
|
// Both are pointers, but from different allocations.
|
2017-08-02 09:59:01 -05:00
|
|
|
err!(InvalidPointerMath)
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
|
|
|
}
|
2018-08-28 11:13:58 -05:00
|
|
|
// These work if the left operand is a pointer, and the right an integer
|
|
|
|
Add | BitAnd | Sub | Rem if left.is_ptr() && right.is_bits() => {
|
2017-07-25 04:32:48 -05:00
|
|
|
// Cast to i128 is fine as we checked the kind to be ptr-sized
|
2017-08-10 10:48:38 -05:00
|
|
|
self.ptr_int_arithmetic(
|
|
|
|
bin_op,
|
2018-08-28 11:13:58 -05:00
|
|
|
left.to_ptr().expect("we checked is_ptr"),
|
2018-10-19 12:51:41 -05:00
|
|
|
right.to_bits(self.memory().pointer_size()).expect("we checked is_bits"),
|
2018-08-28 11:13:58 -05:00
|
|
|
right_layout.abi.is_signed(),
|
|
|
|
)
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
2018-08-14 13:00:18 -05:00
|
|
|
// Commutative operators also work if the integer is on the left
|
2018-08-28 11:13:58 -05:00
|
|
|
Add | BitAnd if left.is_bits() && right.is_ptr() => {
|
2017-07-25 04:32:48 -05:00
|
|
|
// This is a commutative operation, just swap the operands
|
2017-08-10 10:48:38 -05:00
|
|
|
self.ptr_int_arithmetic(
|
|
|
|
bin_op,
|
2018-08-28 11:13:58 -05:00
|
|
|
right.to_ptr().expect("we checked is_ptr"),
|
2018-10-19 12:51:41 -05:00
|
|
|
left.to_bits(self.memory().pointer_size()).expect("we checked is_bits"),
|
2018-08-28 11:13:58 -05:00
|
|
|
left_layout.abi.is_signed(),
|
|
|
|
)
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
2018-08-28 11:13:58 -05:00
|
|
|
// Nothing else works
|
|
|
|
_ => err!(InvalidPointerMath),
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-28 11:13:58 -05:00
|
|
|
fn ptr_eq(
|
|
|
|
&self,
|
2018-10-16 04:21:38 -05:00
|
|
|
left: Scalar<Borrow>,
|
|
|
|
right: Scalar<Borrow>,
|
2018-08-28 11:13:58 -05:00
|
|
|
) -> EvalResult<'tcx, bool> {
|
2019-02-08 09:27:00 -06:00
|
|
|
let size = self.pointer_size();
|
2018-08-28 11:13:58 -05:00
|
|
|
Ok(match (left, right) {
|
|
|
|
(Scalar::Bits { .. }, Scalar::Bits { .. }) =>
|
|
|
|
left.to_bits(size)? == right.to_bits(size)?,
|
|
|
|
(Scalar::Ptr(left), Scalar::Ptr(right)) => {
|
|
|
|
// Comparison illegal if one of them is out-of-bounds, *unless* they
|
|
|
|
// are in the same allocation.
|
|
|
|
if left.alloc_id == right.alloc_id {
|
|
|
|
left.offset == right.offset
|
|
|
|
} else {
|
|
|
|
// This accepts one-past-the end. So technically there is still
|
|
|
|
// some non-determinism that we do not fully rule out when two
|
|
|
|
// allocations sit right next to each other. The C/C++ standards are
|
|
|
|
// somewhat fuzzy about this case, so I think for now this check is
|
|
|
|
// "good enough".
|
2018-11-13 10:19:42 -06:00
|
|
|
// Dead allocations in miri cannot overlap with live allocations, but
|
|
|
|
// on read hardware this can easily happen. Thus for comparisons we require
|
|
|
|
// both pointers to be live.
|
2018-12-25 06:29:38 -06:00
|
|
|
self.memory().check_bounds_ptr(left, InboundsCheck::Live)?;
|
|
|
|
self.memory().check_bounds_ptr(right, InboundsCheck::Live)?;
|
2018-11-13 10:19:42 -06:00
|
|
|
// Two in-bounds pointers, we can compare across allocations
|
2018-08-28 11:13:58 -05:00
|
|
|
left == right
|
|
|
|
}
|
|
|
|
}
|
2018-09-01 04:26:54 -05:00
|
|
|
// Comparing ptr and integer
|
2018-08-30 04:04:48 -05:00
|
|
|
(Scalar::Ptr(ptr), Scalar::Bits { bits, size }) |
|
|
|
|
(Scalar::Bits { bits, size }, Scalar::Ptr(ptr)) => {
|
|
|
|
assert_eq!(size as u64, self.pointer_size().bytes());
|
2018-09-15 10:12:48 -05:00
|
|
|
let bits = bits as u64;
|
2018-09-01 04:26:54 -05:00
|
|
|
|
2018-09-15 10:12:48 -05:00
|
|
|
// Case I: Comparing with NULL
|
2018-08-30 04:04:48 -05:00
|
|
|
if bits == 0 {
|
2018-09-15 10:12:48 -05:00
|
|
|
// Test if the ptr is in-bounds. Then it cannot be NULL.
|
2018-11-13 10:19:42 -06:00
|
|
|
// Even dangling pointers cannot be NULL.
|
2018-12-25 06:26:40 -06:00
|
|
|
if self.memory().check_bounds_ptr(ptr, InboundsCheck::MaybeDead).is_ok() {
|
2018-09-15 10:12:48 -05:00
|
|
|
return Ok(false);
|
|
|
|
}
|
|
|
|
}
|
2018-11-20 01:42:51 -06:00
|
|
|
|
2018-12-25 06:26:40 -06:00
|
|
|
let (alloc_size, alloc_align) = self.memory()
|
|
|
|
.get_size_and_align(ptr.alloc_id, InboundsCheck::MaybeDead)
|
|
|
|
.expect("determining size+align of dead ptr cannot fail");
|
2018-11-20 01:42:51 -06:00
|
|
|
|
2018-09-15 10:12:48 -05:00
|
|
|
// Case II: Alignment gives it away
|
2018-11-23 02:46:51 -06:00
|
|
|
if ptr.offset.bytes() % alloc_align.bytes() == 0 {
|
2018-09-15 10:12:48 -05:00
|
|
|
// The offset maintains the allocation alignment, so we know `base+offset`
|
|
|
|
// is aligned by `alloc_align`.
|
|
|
|
// FIXME: We could be even more general, e.g. offset 2 into a 4-aligned
|
|
|
|
// allocation cannot equal 3.
|
2018-11-23 02:46:51 -06:00
|
|
|
if bits % alloc_align.bytes() != 0 {
|
2018-09-15 10:12:48 -05:00
|
|
|
// The integer is *not* aligned. So they cannot be equal.
|
|
|
|
return Ok(false);
|
|
|
|
}
|
2018-08-30 04:04:48 -05:00
|
|
|
}
|
2018-09-15 10:12:48 -05:00
|
|
|
// Case III: The integer is too big, and the allocation goes on a bit
|
|
|
|
// without wrapping around the address space.
|
|
|
|
{
|
|
|
|
// Compute the highest address at which this allocation could live.
|
|
|
|
// Substract one more, because it must be possible to add the size
|
|
|
|
// to the base address without overflowing -- IOW, the very last address
|
|
|
|
// of the address space is never dereferencable (but it can be in-bounds, i.e.,
|
|
|
|
// one-past-the-end).
|
|
|
|
let max_base_addr =
|
|
|
|
((1u128 << self.pointer_size().bits())
|
|
|
|
- u128::from(alloc_size.bytes())
|
|
|
|
- 1
|
|
|
|
) as u64;
|
|
|
|
if let Some(max_addr) = max_base_addr.checked_add(ptr.offset.bytes()) {
|
|
|
|
if bits > max_addr {
|
|
|
|
// The integer is too big, this cannot possibly be equal
|
|
|
|
return Ok(false)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// None of the supported cases.
|
|
|
|
return err!(InvalidPointerMath);
|
2018-08-30 04:04:48 -05:00
|
|
|
}
|
2018-08-28 11:13:58 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2017-07-25 04:32:48 -05:00
|
|
|
fn ptr_int_arithmetic(
|
|
|
|
&self,
|
|
|
|
bin_op: mir::BinOp,
|
2018-10-16 04:21:38 -05:00
|
|
|
left: Pointer<Borrow>,
|
2018-08-14 13:25:56 -05:00
|
|
|
right: u128,
|
2017-07-25 04:32:48 -05:00
|
|
|
signed: bool,
|
2018-10-16 04:21:38 -05:00
|
|
|
) -> EvalResult<'tcx, (Scalar<Borrow>, bool)> {
|
2017-07-25 04:32:48 -05:00
|
|
|
use rustc::mir::BinOp::*;
|
|
|
|
|
2018-10-16 04:21:38 -05:00
|
|
|
fn map_to_primval((res, over): (Pointer<Borrow>, bool)) -> (Scalar<Borrow>, bool) {
|
2018-05-26 10:07:34 -05:00
|
|
|
(Scalar::Ptr(res), over)
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
Ok(match bin_op {
|
|
|
|
Sub =>
|
|
|
|
// The only way this can overflow is by underflowing, so signdeness of the right operands does not matter
|
2018-08-14 13:25:56 -05:00
|
|
|
map_to_primval(left.overflowing_signed_offset(-(right as i128), self)),
|
2017-07-25 04:32:48 -05:00
|
|
|
Add if signed =>
|
2018-08-14 13:25:56 -05:00
|
|
|
map_to_primval(left.overflowing_signed_offset(right as i128, self)),
|
2017-07-25 04:32:48 -05:00
|
|
|
Add if !signed =>
|
2018-05-20 04:26:40 -05:00
|
|
|
map_to_primval(left.overflowing_offset(Size::from_bytes(right as u64), self)),
|
2017-07-25 04:32:48 -05:00
|
|
|
|
|
|
|
BitAnd if !signed => {
|
2018-11-23 02:46:51 -06:00
|
|
|
let ptr_base_align = self.memory().get(left.alloc_id)?.align.bytes();
|
2018-08-14 13:25:56 -05:00
|
|
|
let base_mask = {
|
|
|
|
// FIXME: Use interpret::truncate, once that takes a Size instead of a Layout
|
2018-10-19 12:51:41 -05:00
|
|
|
let shift = 128 - self.memory().pointer_size().bits();
|
2018-08-14 13:25:56 -05:00
|
|
|
let value = !(ptr_base_align as u128 - 1);
|
|
|
|
// truncate (shift left to drop out leftover values, shift right to fill with zeroes)
|
|
|
|
(value << shift) >> shift
|
|
|
|
};
|
2018-10-19 12:51:41 -05:00
|
|
|
let ptr_size = self.memory().pointer_size().bytes() as u8;
|
2018-08-14 13:25:56 -05:00
|
|
|
trace!("Ptr BitAnd, align {}, operand {:#010x}, base_mask {:#010x}",
|
|
|
|
ptr_base_align, right, base_mask);
|
2017-07-25 04:32:48 -05:00
|
|
|
if right & base_mask == base_mask {
|
|
|
|
// Case 1: The base address bits are all preserved, i.e., right is all-1 there
|
2018-08-14 13:25:56 -05:00
|
|
|
let offset = (left.offset.bytes() as u128 & right) as u64;
|
2018-10-16 04:21:38 -05:00
|
|
|
(
|
|
|
|
Scalar::Ptr(Pointer::new_with_tag(
|
|
|
|
left.alloc_id,
|
|
|
|
Size::from_bytes(offset),
|
|
|
|
left.tag,
|
|
|
|
)),
|
|
|
|
false,
|
|
|
|
)
|
2017-07-25 04:32:48 -05:00
|
|
|
} else if right & base_mask == 0 {
|
|
|
|
// Case 2: The base address bits are all taken away, i.e., right is all-0 there
|
2018-08-14 13:25:56 -05:00
|
|
|
(Scalar::Bits { bits: (left.offset.bytes() as u128) & right, size: ptr_size }, false)
|
2017-07-25 04:32:48 -05:00
|
|
|
} else {
|
2017-08-02 09:59:01 -05:00
|
|
|
return err!(ReadPointerAsBytes);
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-14 13:00:18 -05:00
|
|
|
Rem if !signed => {
|
2018-08-14 05:16:29 -05:00
|
|
|
// Doing modulo a divisor of the alignment is allowed.
|
|
|
|
// (Intuition: Modulo a divisor leaks less information.)
|
2018-11-23 02:46:51 -06:00
|
|
|
let ptr_base_align = self.memory().get(left.alloc_id)?.align.bytes();
|
2018-08-14 13:00:18 -05:00
|
|
|
let right = right as u64;
|
2018-10-19 12:51:41 -05:00
|
|
|
let ptr_size = self.memory().pointer_size().bytes() as u8;
|
2018-08-14 13:00:18 -05:00
|
|
|
if right == 1 {
|
|
|
|
// modulo 1 is always 0
|
|
|
|
(Scalar::Bits { bits: 0, size: ptr_size }, false)
|
2018-08-14 05:16:29 -05:00
|
|
|
} else if ptr_base_align % right == 0 {
|
2018-08-14 13:00:18 -05:00
|
|
|
// the base address would be cancelled out by the modulo operation, so we can
|
|
|
|
// just take the modulo of the offset
|
|
|
|
(Scalar::Bits { bits: (left.offset.bytes() % right) as u128, size: ptr_size }, false)
|
2017-07-25 04:32:48 -05:00
|
|
|
} else {
|
2017-08-02 09:59:01 -05:00
|
|
|
return err!(ReadPointerAsBytes);
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
_ => {
|
|
|
|
let msg = format!("unimplemented binary op on pointer {:?}: {:?}, {:?} ({})", bin_op, left, right, if signed { "signed" } else { "unsigned" });
|
2017-08-02 09:59:01 -05:00
|
|
|
return err!(Unimplemented(msg));
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
2018-08-15 14:01:40 -05:00
|
|
|
|
|
|
|
/// This function raises an error if the offset moves the pointer outside of its allocation. We consider
|
|
|
|
/// ZSTs their own huge allocation that doesn't overlap with anything (and nothing moves in there because the size is 0).
|
|
|
|
/// We also consider the NULL pointer its own separate allocation, and all the remaining integers pointers their own
|
|
|
|
/// allocation.
|
|
|
|
fn pointer_offset_inbounds(
|
|
|
|
&self,
|
2018-10-16 04:21:38 -05:00
|
|
|
ptr: Scalar<Borrow>,
|
2018-08-15 14:01:40 -05:00
|
|
|
pointee_ty: Ty<'tcx>,
|
|
|
|
offset: i64,
|
2018-10-16 04:21:38 -05:00
|
|
|
) -> EvalResult<'tcx, Scalar<Borrow>> {
|
2018-08-15 14:01:40 -05:00
|
|
|
// FIXME: assuming here that type size is < i64::max_value()
|
|
|
|
let pointee_size = self.layout_of(pointee_ty)?.size.bytes() as i64;
|
|
|
|
let offset = offset.checked_mul(pointee_size).ok_or_else(|| EvalErrorKind::Overflow(mir::BinOp::Mul))?;
|
|
|
|
// Now let's see what kind of pointer this is
|
|
|
|
if let Scalar::Ptr(ptr) = ptr {
|
2018-11-20 01:42:51 -06:00
|
|
|
// Both old and new pointer must be in-bounds of a *live* allocation.
|
2018-08-15 14:01:40 -05:00
|
|
|
// (Of the same allocation, but that part is trivial with our representation.)
|
2018-12-26 06:16:47 -06:00
|
|
|
self.memory().check_bounds_ptr(ptr, InboundsCheck::Live)?;
|
2018-08-15 14:01:40 -05:00
|
|
|
let ptr = ptr.signed_offset(offset, self)?;
|
2018-12-26 06:16:47 -06:00
|
|
|
self.memory().check_bounds_ptr(ptr, InboundsCheck::Live)?;
|
2018-08-15 14:01:40 -05:00
|
|
|
Ok(Scalar::Ptr(ptr))
|
|
|
|
} else {
|
2018-10-08 03:22:26 -05:00
|
|
|
// An integer pointer. They can only be offset by 0, and we pretend there
|
|
|
|
// is a little zero-sized allocation here.
|
|
|
|
if offset == 0 {
|
|
|
|
Ok(ptr)
|
|
|
|
} else {
|
|
|
|
err!(InvalidPointerMath)
|
|
|
|
}
|
2018-08-15 14:01:40 -05:00
|
|
|
}
|
|
|
|
}
|
2017-07-25 04:32:48 -05:00
|
|
|
}
|