Skip to content

Commit

Permalink
remove unneeded code
Browse files Browse the repository at this point in the history
  • Loading branch information
@AaronKutch
AaronKutch committed May 4, 2020
1 parent 20c567c commit 30b6b45
Show file tree
Hide file tree
Showing 3 changed files with 0 additions and 220 deletions.
12 changes: 0 additions & 12 deletions src/int/mod.rs
View file
Original file line number Diff line number Diff line change
@@ -1,17 +1,5 @@
use core::ops;

macro_rules! hty {
($ty:ty) => {
<$ty as LargeInt>::HighHalf
};
}

macro_rules! os_ty {
($ty:ty) => {
<$ty as Int>::OtherSign
};
}

pub mod addsub;
pub mod mul;
pub mod shift;
Expand Down
57 changes: 0 additions & 57 deletions src/int/sdiv.rs
View file
Original file line number Diff line number Diff line change
@@ -1,62 +1,5 @@
use int::Int;
use super::specialized_div_rem::*;

trait Div: Int {
/// Returns `a / b`
fn div(self, other: Self) -> Self {
let s_a = self >> (Self::BITS - 1);
let s_b = other >> (Self::BITS - 1);
// NOTE it's OK to overflow here because of the `.unsigned()` below.
// This whole operation is computing the absolute value of the inputs
// So some overflow will happen when dealing with e.g. `i64::MIN`
// where the absolute value is `(-i64::MIN) as u64`
let a = (self ^ s_a).wrapping_sub(s_a);
let b = (other ^ s_b).wrapping_sub(s_b);
let s = s_a ^ s_b;

let r = a.unsigned().aborting_div(b.unsigned());
(Self::from_unsigned(r) ^ s) - s
}
}

impl Div for i32 {}
impl Div for i64 {}
impl Div for i128 {}

trait Mod: Int {
/// Returns `a % b`
fn mod_(self, other: Self) -> Self {
let s = other >> (Self::BITS - 1);
// NOTE(wrapping_sub) see comment in the `div`
let b = (other ^ s).wrapping_sub(s);
let s = self >> (Self::BITS - 1);
let a = (self ^ s).wrapping_sub(s);

let r = a.unsigned().aborting_rem(b.unsigned());
(Self::from_unsigned(r) ^ s) - s
}
}

impl Mod for i32 {}
impl Mod for i64 {}
impl Mod for i128 {}

trait Divmod: Int {
/// Returns `a / b` and sets `*rem = n % d`
fn divmod<F>(self, other: Self, rem: &mut Self, div: F) -> Self
where
F: Fn(Self, Self) -> Self,
{
let r = div(self, other);
// NOTE won't overflow because it's using the result from the
// previous division
*rem = self - r.wrapping_mul(other);
r
}
}

impl Divmod for i32 {}
impl Divmod for i64 {}
// NOTE: there are aborts inside the specialized_div_rem functions if division by 0
// is encountered, however these should be unreachable and optimized away unless
// uses of `std/core::intrinsics::unchecked_div/rem` do not have a 0 check in front
Expand Down
151 changes: 0 additions & 151 deletions src/int/udiv.rs
View file
Original file line number Diff line number Diff line change
@@ -1,156 +1,5 @@
use int::{Int, LargeInt};
use super::specialized_div_rem::*;

macro_rules! udivmod_inner {
($n:expr, $d:expr, $rem:expr, $ty:ty) => {{
let (n, d, rem) = ($n, $d, $rem);
// NOTE X is unknown, K != 0
if n.high() == 0 {
if d.high() == 0 {
// 0 X
// ---
// 0 X

if let Some(rem) = rem {
*rem = <$ty>::from(n.low().aborting_rem(d.low()));
}
return <$ty>::from(n.low().aborting_div(d.low()))
} else {
// 0 X
// ---
// K X
if let Some(rem) = rem {
*rem = n;
}
return 0;
};
}

let mut sr;
let mut q;
let mut r;

if d.low() == 0 {
if d.high() == 0 {
// K X
// ---
// 0 0
// NOTE This should be unreachable in safe Rust because the program will panic before
// this intrinsic is called
::abort();
}

if n.low() == 0 {
// K 0
// ---
// K 0
if let Some(rem) = rem {
*rem = <$ty>::from_parts(0, n.high().aborting_rem(d.high()));
}
return <$ty>::from(n.high().aborting_div(d.high()))
}

// K K
// ---
// K 0

if d.high().is_power_of_two() {
if let Some(rem) = rem {
*rem = <$ty>::from_parts(n.low(), n.high() & (d.high() - 1));
}
return <$ty>::from(n.high() >> d.high().trailing_zeros());
}

sr = d.high().leading_zeros().wrapping_sub(n.high().leading_zeros());

// D > N
if sr > <hty!($ty)>::BITS - 2 {
if let Some(rem) = rem {
*rem = n;
}
return 0;
}

sr += 1;

// 1 <= sr <= <hty!($ty)>::BITS - 1
q = n << (<$ty>::BITS - sr);
r = n >> sr;
} else if d.high() == 0 {
// K X
// ---
// 0 K
if d.low().is_power_of_two() {
if let Some(rem) = rem {
*rem = <$ty>::from(n.low() & (d.low() - 1));
}

if d.low() == 1 {
return n;
} else {
let sr = d.low().trailing_zeros();
return n >> sr;
};
}

sr = 1 + <hty!($ty)>::BITS + d.low().leading_zeros() - n.high().leading_zeros();

// 2 <= sr <= u64::BITS - 1
q = n << (<$ty>::BITS - sr);
r = n >> sr;
} else {
// K X
// ---
// K K
sr = d.high().leading_zeros().wrapping_sub(n.high().leading_zeros());

// D > N
if sr > <hty!($ty)>::BITS - 1 {
if let Some(rem) = rem {
*rem = n;
}
return 0;
}

sr += 1;

// 1 <= sr <= <hty!($ty)>::BITS
q = n << (<$ty>::BITS - sr);
r = n >> sr;
}

// Not a special case
// q and r are initialized with
// q = n << (u64::BITS - sr)
// r = n >> sr
// 1 <= sr <= u64::BITS - 1
let mut carry = 0;

// Don't use a range because they may generate references to memcpy in unoptimized code
let mut i = 0;
while i < sr {
i += 1;

// r:q = ((r:q) << 1) | carry
r = (r << 1) | (q >> (<$ty>::BITS - 1));
q = (q << 1) | carry as $ty;

// carry = 0
// if r >= d {
// r -= d;
// carry = 1;
// }
let s = (d.wrapping_sub(r).wrapping_sub(1)) as os_ty!($ty) >> (<$ty>::BITS - 1);
carry = (s & 1) as hty!($ty);
r -= d & s as $ty;
}

if let Some(rem) = rem {
*rem = r;
}
(q << 1) | carry as $ty
}}
}
// NOTE: there are aborts inside the specialized_div_rem functions if division by 0
// is encountered, however these should be unreachable and optimized away unless
// uses of `std/core::intrinsics::unchecked_div/rem` do not have a 0 check in front
Expand Down

0 comments on commit 30b6b45

Please sign in to comment.