OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Simplify bitwise operations

Browse Source
This commit is contained in:
varkor 2018-05-24 10:48:23 +01:00
parent c388c11a60
commit 97a032ebb4
1 changed files with 42 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
src/librustc_mir/hair/pattern/_match.rs
View File

@ -483,11 +483,11 @@ fn all_constructors<'a, 'tcx: 'a>(cx: &mut MatchCheckCtxt<'a, 'tcx>,
ty::TyUint(_) if exhaustive_integer_patterns => {
// FIXME(49937): refactor these bit manipulations into interpret.
let bits = cx.tcx.layout_of(ty::ParamEnv::reveal_all().and(pcx.ty))
.unwrap().size.bits() as u32;
let max = (!0u128).wrapping_shr(128 - bits);
.unwrap().size.bits() as u128;
let max = !0u128 >> (128 - bits);
value_constructors = true;
vec![ConstantRange(ty::Const::from_bits(cx.tcx, 0u128, pcx.ty),
ty::Const::from_bits(cx.tcx, max as u128, pcx.ty),
vec![ConstantRange(ty::Const::from_bits(cx.tcx, 0, pcx.ty),
ty::Const::from_bits(cx.tcx, max, pcx.ty),
RangeEnd::Included)]
}
_ => {
@ -604,21 +604,21 @@ fn max_slice_length<'p, 'a: 'p, 'tcx: 'a, I>(
}
/// An inclusive interval, used for precise integer exhaustiveness checking.
/// `Interval`s always store a contiguous range of integers. This means that
/// signed values are encoded by offsetting them such that `0` represents the
/// minimum value for the integer, regardless of sign.
/// For example, the range `-128...127` is encoded as `0...255`.
/// `IntRange`s always store a contiguous range. This means that values are
/// encoded such that `0` encodes the minimum value for the integer,
/// regardless of the signedness.
/// For example, the pattern `-128...127i8` is encoded as `0..=255`.
/// This makes comparisons and arithmetic on interval endpoints much more
/// straightforward. See `offset_sign` for the conversion technique.
struct Interval<'tcx> {
/// straightforward. See `encode` and `decode` for details.
struct IntRange<'tcx> {
pub range: RangeInclusive<u128>,
pub ty: Ty<'tcx>,
}
impl<'tcx> Interval<'tcx> {
impl<'tcx> IntRange<'tcx> {
fn from_ctor(tcx: TyCtxt<'_, 'tcx, 'tcx>,
ctor: &Constructor<'tcx>)
-> Option<Interval<'tcx>> {
-> Option<IntRange<'tcx>> {
match ctor {
ConstantRange(lo, hi, end) => {
assert_eq!(lo.ty, hi.ty);
@ -627,13 +627,13 @@ impl<'tcx> Interval<'tcx> {
if let Some(hi) = hi.assert_bits(ty) {
// Perform a shift if the underlying types are signed,
// which makes the interval arithmetic simpler.
let (lo, hi) = Self::offset_sign(tcx, ty, lo..=hi, true);
let (lo, hi) = Self::encode(tcx, ty, lo..=hi);
// Make sure the interval is well-formed.
return if lo > hi || lo == hi && *end == RangeEnd::Excluded {
None
} else {
let offset = (*end == RangeEnd::Excluded) as u128;
Some(Interval { range: lo..=(hi - offset), ty })
Some(IntRange { range: lo..=(hi - offset), ty })
};
}
}
@ -642,8 +642,8 @@ impl<'tcx> Interval<'tcx> {
ConstantValue(val) => {
let ty = val.ty;
if let Some(val) = val.assert_bits(ty) {
let (lo, hi) = Self::offset_sign(tcx, ty, val..=val, true);
Some(Interval { range: lo..=hi, ty })
let (lo, hi) = Self::encode(tcx, ty, val..=val);
Some(IntRange { range: lo..=hi, ty })
} else {
None
}
@ -654,11 +654,11 @@ impl<'tcx> Interval<'tcx> {
}
}
fn offset_sign(tcx: TyCtxt<'_, 'tcx, 'tcx>,
ty: Ty<'tcx>,
range: RangeInclusive<u128>,
encode: bool)
-> (u128, u128) {
fn convert(tcx: TyCtxt<'_, 'tcx, 'tcx>,
ty: Ty<'tcx>,
range: RangeInclusive<u128>,
encode: bool)
-> (u128, u128) {
// We ensure that all integer values are contiguous: that is, that their
// minimum value is represented by 0, so that comparisons and increments/
// decrements on interval endpoints work consistently whether the endpoints
@ -670,13 +670,14 @@ impl<'tcx> Interval<'tcx> {
let bits = tcx.layout_of(ty::ParamEnv::reveal_all().and(ty))
.unwrap().size.bits() as u128;
let min = 1u128 << (bits - 1);
let shift = 1u128.overflowing_shl(bits as u32);
let mask = shift.0.wrapping_sub(1 + (shift.1 as u128));
let mask = !0u128 >> (128 - bits);
if encode {
let offset = |x: u128| x.wrapping_sub(min) & mask;
(offset(lo), offset(hi))
} else {
let offset = |x: u128| {
// FIXME: this shouldn't be necessary once `print_miri_value`
// sign-extends `TyInt`.
interpret::sign_extend(tcx, x.wrapping_add(min) & mask, ty)
.expect("layout error for TyInt")
};
@ -686,10 +687,24 @@ impl<'tcx> Interval<'tcx> {
ty::TyUint(_) | ty::TyChar => {
(lo, hi)
}
_ => bug!("`Interval` should only contain integer types")
_ => bug!("`IntRange` should only contain integer types")
}
}
fn encode(tcx: TyCtxt<'_, 'tcx, 'tcx>,
ty: Ty<'tcx>,
range: RangeInclusive<u128>)
-> (u128, u128) {
Self::convert(tcx, ty, range, true)
}
fn decode(tcx: TyCtxt<'_, 'tcx, 'tcx>,
ty: Ty<'tcx>,
range: RangeInclusive<u128>)
-> (u128, u128) {
Self::convert(tcx, ty, range, false)
}
fn into_inner(self) -> (u128, u128) {
self.range.into_inner()
}
@ -702,10 +717,10 @@ fn ranges_subtract_pattern<'a, 'tcx>(cx: &mut MatchCheckCtxt<'a, 'tcx>,
pat_ctor: &Constructor<'tcx>,
ranges: Vec<Constructor<'tcx>>)
-> Vec<Constructor<'tcx>> {
if let Some(pat_interval) = Interval::from_ctor(cx.tcx, pat_ctor) {
if let Some(pat_interval) = IntRange::from_ctor(cx.tcx, pat_ctor) {
let mut remaining_ranges = vec![];
let mut ranges: Vec<_> = ranges.into_iter().filter_map(|r| {
Interval::from_ctor(cx.tcx, &r).map(|i| i.into_inner())
IntRange::from_ctor(cx.tcx, &r).map(|i| i.into_inner())
}).collect();
let ty = pat_interval.ty;
let (pat_interval_lo, pat_interval_hi) = pat_interval.into_inner();
@ -729,7 +744,7 @@ fn ranges_subtract_pattern<'a, 'tcx>(cx: &mut MatchCheckCtxt<'a, 'tcx>,
}
// Convert the remaining ranges from pairs to inclusive `ConstantRange`s.
remaining_ranges.into_iter().map(|r| {
let (lo, hi) = Interval::offset_sign(cx.tcx, ty, r, false);
let (lo, hi) = IntRange::decode(cx.tcx, ty, r);
ConstantRange(ty::Const::from_bits(cx.tcx, lo, ty),
ty::Const::from_bits(cx.tcx, hi, ty),
RangeEnd::Included)