802 lines
26 KiB
Rust
802 lines
26 KiB
Rust
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
#![feature(compiler_builtins)]
|
|
#![no_std]
|
|
#![compiler_builtins]
|
|
#![unstable(feature = "compiler_builtins_lib",
|
|
reason = "internal implementation detail of rustc right now",
|
|
issue = "0")]
|
|
#![crate_name = "compiler_builtins"]
|
|
#![crate_type = "rlib"]
|
|
#![allow(unused_features)]
|
|
#![feature(staged_api, core_intrinsics, repr_simd,
|
|
i128_type, core_float, abi_unadjusted, associated_consts)]
|
|
#![allow(non_camel_case_types, unused_variables, unused_imports)]
|
|
#![cfg_attr(stage0, allow(dead_code))]
|
|
|
|
#[cfg(any(target_pointer_width="32", target_pointer_width="16", target_os="windows",
|
|
target_arch="mips64"))]
|
|
pub mod reimpls {
|
|
|
|
#![allow(unused_comparisons)]
|
|
|
|
use core::intrinsics::unchecked_div;
|
|
use core::intrinsics::unchecked_rem;
|
|
use core::ptr;
|
|
|
|
// C API is expected to tolerate some amount of size mismatch in ABI. Hopefully the amount of
|
|
// handling is sufficient for bootstrapping.
|
|
#[cfg(stage0)]
|
|
type u128_ = u64;
|
|
#[cfg(stage0)]
|
|
type i128_ = i64;
|
|
#[cfg(not(stage0))]
|
|
type u128_ = u128;
|
|
#[cfg(not(stage0))]
|
|
type i128_ = i128;
|
|
|
|
macro_rules! ashl {
|
|
($a:expr, $b:expr, $ty:ty) => {{
|
|
let (a, b) = ($a, $b);
|
|
let bits = (::core::mem::size_of::<$ty>() * 8) as $ty;
|
|
let half_bits = bits >> 1;
|
|
if b & half_bits != 0 {
|
|
<$ty>::from_parts(0, a.low().wrapping_shl(
|
|
b.wrapping_sub(half_bits) as u32))
|
|
} else if b == 0 {
|
|
a
|
|
} else {
|
|
<$ty>::from_parts(a.low().wrapping_shl(b as u32),
|
|
a.high().wrapping_shl(b as u32)
|
|
| a.low()
|
|
.wrapping_shr(half_bits.wrapping_sub(b) as u32))
|
|
}
|
|
}}
|
|
}
|
|
|
|
#[export_name="__ashlti3"]
|
|
pub extern "C" fn shl(a: u128_, b: u128_) -> u128_ {
|
|
ashl!(a, b, u128_)
|
|
}
|
|
|
|
macro_rules! ashr {
|
|
($a: expr, $b: expr, $ty:ty) => {{
|
|
let (a, b) = ($a, $b);
|
|
let bits = (::core::mem::size_of::<$ty>() * 8) as $ty;
|
|
let half_bits = bits >> 1;
|
|
if b & half_bits != 0 {
|
|
<$ty>::from_parts(a.high().wrapping_shr(b.wrapping_sub(half_bits) as u32)
|
|
as <$ty as LargeInt>::LowHalf,
|
|
a.high().wrapping_shr(half_bits.wrapping_sub(1) as u32))
|
|
} else if b == 0 {
|
|
a
|
|
} else {
|
|
let high_unsigned = a.high() as <$ty as LargeInt>::LowHalf;
|
|
<$ty>::from_parts(high_unsigned.wrapping_shl(half_bits.wrapping_sub(b) as u32)
|
|
| a.low().wrapping_shr(b as u32),
|
|
a.high().wrapping_shr(b as u32))
|
|
}
|
|
}}
|
|
}
|
|
|
|
#[export_name="__ashrti3"]
|
|
pub extern "C" fn shr(a: i128_, b: i128_) -> i128_ {
|
|
ashr!(a, b, i128_)
|
|
}
|
|
|
|
macro_rules! lshr {
|
|
($a: expr, $b: expr, $ty:ty) => {{
|
|
let (a, b) = ($a, $b);
|
|
let bits = (::core::mem::size_of::<$ty>() * 8) as $ty;
|
|
let half_bits = bits >> 1;
|
|
if b & half_bits != 0 {
|
|
<$ty>::from_parts(a.high().wrapping_shr(b.wrapping_sub(half_bits) as u32), 0)
|
|
} else if b == 0 {
|
|
a
|
|
} else {
|
|
<$ty>::from_parts(a.high().wrapping_shl(half_bits.wrapping_sub(b) as u32)
|
|
| a.low().wrapping_shr(b as u32),
|
|
a.high().wrapping_shr(b as u32))
|
|
}
|
|
}}
|
|
}
|
|
|
|
|
|
#[export_name="__lshrti3"]
|
|
pub extern "C" fn lshr(a: u128_, b: u128_) -> u128_ {
|
|
lshr!(a, b, u128_)
|
|
}
|
|
|
|
#[cfg(stage0)]
|
|
pub extern "C" fn u128_div_mod(n: u128_, d: u128_, rem: *mut u128_) -> u128_ {
|
|
unsafe {
|
|
if !rem.is_null() {
|
|
*rem = unchecked_rem(n, d);
|
|
}
|
|
unchecked_div(n, d)
|
|
}
|
|
}
|
|
|
|
#[cfg(not(stage0))]
|
|
pub extern "C" fn u128_div_mod(n: u128_, d: u128_, rem: *mut u128_) -> u128_ {
|
|
// Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide
|
|
unsafe {
|
|
// special cases, X is unknown, K != 0
|
|
if n.high() == 0 {
|
|
if d.high() == 0 {
|
|
// 0 X
|
|
// ---
|
|
// 0 X
|
|
if !rem.is_null() {
|
|
*rem = u128::from(unchecked_rem(n.low(), d.low()));
|
|
}
|
|
return u128::from(unchecked_div(n.low(), d.low()));
|
|
} else {
|
|
// 0 X
|
|
// ---
|
|
// K X
|
|
if !rem.is_null() {
|
|
*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
|
|
if !rem.is_null() {
|
|
*rem = u128::from(unchecked_rem(n.high(), d.low()));
|
|
}
|
|
return u128::from(unchecked_div(n.high(), d.low()));
|
|
}
|
|
|
|
if n.low() == 0 {
|
|
// K 0
|
|
// ---
|
|
// K 0
|
|
if !rem.is_null() {
|
|
*rem = u128::from_parts(0, unchecked_rem(n.high(), d.high()));
|
|
}
|
|
return u128::from(unchecked_div(n.high(), d.high()));
|
|
}
|
|
|
|
// K K
|
|
// ---
|
|
// K 0
|
|
|
|
if d.high().is_power_of_two() {
|
|
if !rem.is_null() {
|
|
*rem = u128::from_parts(n.low(),
|
|
n.high() & (d.high().wrapping_sub(1)));
|
|
}
|
|
return u128::from(n.high().wrapping_shr(d.high().trailing_zeros()));
|
|
}
|
|
|
|
// K K
|
|
// ---
|
|
// K 0
|
|
sr = d.high().leading_zeros().wrapping_sub(n.high().leading_zeros());
|
|
|
|
// D > N
|
|
if sr > 64 - 2 {
|
|
if !rem.is_null() {
|
|
*rem = n;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sr = sr.wrapping_add(1);
|
|
|
|
// 1 <= sr <= u64::bits() - 1
|
|
q = n.wrapping_shl(64u32.wrapping_sub(sr));
|
|
r = n.wrapping_shr(sr);
|
|
} else {
|
|
if d.high() == 0 {
|
|
// K X
|
|
// ---
|
|
// 0 K
|
|
if d.low().is_power_of_two() {
|
|
if !rem.is_null() {
|
|
*rem = u128::from(n.low() & (d.low().wrapping_sub(1)));
|
|
}
|
|
|
|
if d.low() == 1 {
|
|
return n;
|
|
} else {
|
|
let sr = d.low().trailing_zeros();
|
|
return n.wrapping_shr(sr);
|
|
};
|
|
}
|
|
|
|
sr = (1 + 64u32)
|
|
.wrapping_add(d.low().leading_zeros())
|
|
.wrapping_sub(n.high().leading_zeros());
|
|
|
|
// 2 <= sr <= u64::bits() - 1
|
|
q = n.wrapping_shl(128u32.wrapping_sub(sr));
|
|
r = n.wrapping_shr(sr);
|
|
// FIXME the C compiler-rt implementation has something here
|
|
// that looks like a speed optimisation.
|
|
// It would be worth a try to port it to Rust too and
|
|
// compare the speed.
|
|
} else {
|
|
// K X
|
|
// ---
|
|
// K K
|
|
sr = d.high().leading_zeros().wrapping_sub(n.high().leading_zeros());
|
|
|
|
// D > N
|
|
if sr > 64 - 1 {
|
|
if !rem.is_null() {
|
|
*rem = n;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sr = sr.wrapping_add(1);
|
|
|
|
// 1 <= sr <= u32::bits()
|
|
q = n.wrapping_shl(128u32.wrapping_sub(sr));
|
|
r = n.wrapping_shr(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;
|
|
|
|
// FIXME: replace this with a for loop
|
|
// (atm not doable as this generates call to
|
|
// eh_personality when optimisations are turned off,
|
|
// which in turn gives a linker error in later
|
|
// compilation steps)
|
|
while sr > 0 {
|
|
// r:q = ((r:q) << 1) | carry
|
|
r = r.wrapping_shl(1) | q.wrapping_shr(128 - 1);
|
|
q = q.wrapping_shl(1) | carry as u128;
|
|
|
|
// carry = 0
|
|
// if r >= d {
|
|
// r -= d;
|
|
// carry = 1;
|
|
// }
|
|
let s = ((d.wrapping_sub(r).wrapping_sub(1)) as i128).wrapping_shr(128 - 1);
|
|
carry = (s & 1) as u64;
|
|
r = r.wrapping_sub(d & s as u128);
|
|
sr = sr.wrapping_sub(1);
|
|
}
|
|
|
|
if !rem.is_null() {
|
|
*rem = r;
|
|
}
|
|
(q.wrapping_shl(1)) | carry as u128
|
|
}
|
|
}
|
|
|
|
fn i128_mod(a: i128_, b: i128_) -> i128_ {
|
|
let b = b.uabs();
|
|
let sa = a.signum();
|
|
let a = a.uabs();
|
|
unsafe {
|
|
let mut r = ::core::mem::zeroed();
|
|
u128_div_mod(a, b, &mut r);
|
|
if sa == -1 { (r as i128_).unchecked_neg() } else { r as i128_ }
|
|
}
|
|
}
|
|
|
|
fn i128_div(a: i128_, b: i128_) -> i128_ {
|
|
let sa = a.signum();
|
|
let sb = b.signum();
|
|
let a = a.uabs();
|
|
let b = b.uabs();
|
|
let sr = sa.wrapping_mul(sb); // sign of quotient
|
|
(if sr == -1 {
|
|
(u128_div_mod(a, b, ptr::null_mut()) as i128_).unchecked_neg()
|
|
} else {
|
|
u128_div_mod(a, b, ptr::null_mut()) as i128_
|
|
})
|
|
}
|
|
|
|
#[cfg(stage0)]
|
|
#[export_name="__udivti3"]
|
|
pub extern "C" fn u128_div(a: u128_, b: u128_) -> u128_ {
|
|
(a / b)
|
|
}
|
|
|
|
macro_rules! mulo {
|
|
($a:expr, $b:expr, $o: expr, $ty: ty) => {{
|
|
let (a, b, overflow) = ($a, $b, $o);
|
|
*overflow = 0;
|
|
let result = a.wrapping_mul(b);
|
|
if a == <$ty>::min_value() {
|
|
if b != 0 && b != 1 {
|
|
*overflow = 1;
|
|
}
|
|
return result;
|
|
}
|
|
if b == <$ty>::min_value() {
|
|
if a != 0 && a != 1 {
|
|
*overflow = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
let sa = a.signum();
|
|
let abs_a = a.iabs();
|
|
let sb = b.signum();
|
|
let abs_b = b.iabs();
|
|
if abs_a < 2 || abs_b < 2 {
|
|
return result;
|
|
}
|
|
if sa == sb {
|
|
if abs_a > unchecked_div(<$ty>::max_value(), abs_b) {
|
|
*overflow = 1;
|
|
}
|
|
} else {
|
|
if abs_a > unchecked_div(<$ty>::min_value(), abs_b.unchecked_neg()) {
|
|
*overflow = 1;
|
|
}
|
|
}
|
|
result
|
|
}}
|
|
}
|
|
|
|
pub trait LargeInt {
|
|
type LowHalf;
|
|
type HighHalf;
|
|
|
|
fn low(self) -> Self::LowHalf;
|
|
fn high(self) -> Self::HighHalf;
|
|
fn from_parts(low: Self::LowHalf, high: Self::HighHalf) -> Self;
|
|
}
|
|
impl LargeInt for u64 {
|
|
type LowHalf = u32;
|
|
type HighHalf = u32;
|
|
|
|
fn low(self) -> u32 {
|
|
self as u32
|
|
}
|
|
fn high(self) -> u32 {
|
|
(self.wrapping_shr(32)) as u32
|
|
}
|
|
fn from_parts(low: u32, high: u32) -> u64 {
|
|
low as u64 | (high as u64).wrapping_shl(32)
|
|
}
|
|
}
|
|
impl LargeInt for i64 {
|
|
type LowHalf = u32;
|
|
type HighHalf = i32;
|
|
|
|
fn low(self) -> u32 {
|
|
self as u32
|
|
}
|
|
fn high(self) -> i32 {
|
|
self.wrapping_shr(32) as i32
|
|
}
|
|
fn from_parts(low: u32, high: i32) -> i64 {
|
|
u64::from_parts(low, high as u32) as i64
|
|
}
|
|
}
|
|
#[cfg(not(stage0))]
|
|
impl LargeInt for u128 {
|
|
type LowHalf = u64;
|
|
type HighHalf = u64;
|
|
|
|
fn low(self) -> u64 {
|
|
self as u64
|
|
}
|
|
fn high(self) -> u64 {
|
|
self.wrapping_shr(64) as u64
|
|
}
|
|
fn from_parts(low: u64, high: u64) -> u128 {
|
|
(high as u128).wrapping_shl(64) | low as u128
|
|
}
|
|
}
|
|
#[cfg(not(stage0))]
|
|
impl LargeInt for i128 {
|
|
type LowHalf = u64;
|
|
type HighHalf = i64;
|
|
|
|
fn low(self) -> u64 {
|
|
self as u64
|
|
}
|
|
fn high(self) -> i64 {
|
|
self.wrapping_shr(64) as i64
|
|
}
|
|
fn from_parts(low: u64, high: i64) -> i128 {
|
|
u128::from_parts(low, high as u64) as i128
|
|
}
|
|
}
|
|
|
|
macro_rules! mul {
|
|
($a:expr, $b:expr, $ty: ty, $tyh: ty) => {{
|
|
let (a, b) = ($a, $b);
|
|
let half_bits = ((::core::mem::size_of::<$tyh>() * 8) / 2) as u32;
|
|
let lower_mask = (!0u64).wrapping_shr(half_bits);
|
|
let mut low = (a.low() & lower_mask).wrapping_mul(b.low() & lower_mask);
|
|
let mut t = low.wrapping_shr(half_bits);
|
|
low &= lower_mask;
|
|
t = t.wrapping_add(a.low().wrapping_shr(half_bits)
|
|
.wrapping_mul(b.low() & lower_mask));
|
|
low = low.wrapping_add((t & lower_mask).wrapping_shl(half_bits));
|
|
let mut high = t.wrapping_shr(half_bits) as $tyh;
|
|
t = low.wrapping_shr(half_bits);
|
|
low &= lower_mask;
|
|
t = t.wrapping_add(b.low().wrapping_shr(half_bits)
|
|
.wrapping_mul(a.low() & lower_mask));
|
|
low = low.wrapping_add((t & lower_mask).wrapping_shl(half_bits));
|
|
high = high.wrapping_add(t.wrapping_shr(half_bits) as $tyh);
|
|
high = high.wrapping_add(a.low().wrapping_shr(half_bits)
|
|
.wrapping_mul(b.low().wrapping_shr(half_bits)) as $tyh);
|
|
high = high
|
|
.wrapping_add(a.high()
|
|
.wrapping_mul(b.low() as $tyh))
|
|
.wrapping_add((a.low() as $tyh)
|
|
.wrapping_mul(b.high()));
|
|
<$ty>::from_parts(low, high)
|
|
}}
|
|
}
|
|
|
|
#[cfg(stage0)]
|
|
#[export_name="__multi3"]
|
|
pub extern "C" fn u128_mul(a: i128_, b: i128_) -> i128_ {
|
|
((a as i64).wrapping_mul(b as i64) as i128_)
|
|
}
|
|
|
|
#[cfg(not(stage0))]
|
|
#[export_name="__multi3"]
|
|
pub extern "C" fn u128_mul(a: i128_, b: i128_) -> i128_ {
|
|
mul!(a, b, i128_, i64)
|
|
}
|
|
|
|
trait AbsExt: Sized {
|
|
fn uabs(self) -> u128_ {
|
|
self.iabs() as u128_
|
|
}
|
|
fn iabs(self) -> i128_;
|
|
}
|
|
|
|
#[cfg(stage0)]
|
|
impl AbsExt for i128_ {
|
|
fn iabs(self) -> i128_ {
|
|
let s = self >> 63;
|
|
((self ^ s).wrapping_sub(s))
|
|
}
|
|
}
|
|
|
|
#[cfg(not(stage0))]
|
|
impl AbsExt for i128_ {
|
|
fn iabs(self) -> i128_ {
|
|
let s = self >> 127;
|
|
((self ^ s).wrapping_sub(s))
|
|
}
|
|
}
|
|
|
|
trait NegExt: Sized {
|
|
fn unchecked_neg(self) -> i128_;
|
|
}
|
|
|
|
impl NegExt for i128_ {
|
|
fn unchecked_neg(self) -> i128_ {
|
|
(!self).wrapping_add(1)
|
|
}
|
|
}
|
|
|
|
trait FloatStuff: Sized {
|
|
type ToBytes;
|
|
|
|
const MANTISSA_BITS: u32;
|
|
const MAX_EXP: i32;
|
|
const EXP_MASK: Self::ToBytes;
|
|
const MANTISSA_MASK: Self::ToBytes;
|
|
const MANTISSA_LEAD_BIT: Self::ToBytes;
|
|
|
|
fn to_bytes(self) -> Self::ToBytes;
|
|
fn get_exponent(self) -> i32;
|
|
}
|
|
|
|
impl FloatStuff for f32 {
|
|
type ToBytes = u32;
|
|
const MANTISSA_BITS: u32 = 23;
|
|
const MAX_EXP: i32 = 127;
|
|
const EXP_MASK: u32 = 0x7F80_0000;
|
|
const MANTISSA_MASK: u32 = 0x007F_FFFF;
|
|
const MANTISSA_LEAD_BIT: u32 = 0x0080_0000;
|
|
|
|
fn to_bytes(self) -> u32 { unsafe { ::core::mem::transmute(self) } }
|
|
fn get_exponent(self) -> i32 {
|
|
((self.to_bytes() & Self::EXP_MASK).wrapping_shr(Self::MANTISSA_BITS) as i32)
|
|
.wrapping_sub(Self::MAX_EXP)
|
|
}
|
|
}
|
|
|
|
impl FloatStuff for f64 {
|
|
type ToBytes = u64;
|
|
const MANTISSA_BITS: u32 = 52;
|
|
const MAX_EXP: i32 = 1023;
|
|
const EXP_MASK: u64 = 0x7FF0_0000_0000_0000;
|
|
const MANTISSA_MASK: u64 = 0x000F_FFFF_FFFF_FFFF;
|
|
const MANTISSA_LEAD_BIT: u64 = 0x0010_0000_0000_0000;
|
|
|
|
fn to_bytes(self) -> u64 { unsafe { ::core::mem::transmute(self) } }
|
|
fn get_exponent(self) -> i32 {
|
|
((self.to_bytes() & Self::EXP_MASK).wrapping_shr(Self::MANTISSA_BITS) as i32)
|
|
.wrapping_sub(Self::MAX_EXP)
|
|
}
|
|
}
|
|
|
|
macro_rules! float_as_unsigned {
|
|
($from: expr, $fromty: ty, $outty: ty) => { {
|
|
use core::num::Float;
|
|
let repr = $from.to_bytes();
|
|
let sign = $from.signum();
|
|
let exponent = $from.get_exponent();
|
|
let mantissa_fraction = repr & <$fromty as FloatStuff>::MANTISSA_MASK;
|
|
let mantissa = mantissa_fraction | <$fromty as FloatStuff>::MANTISSA_LEAD_BIT;
|
|
if sign == -1.0 || exponent < 0 { return 0 as u128_; }
|
|
if exponent > ::core::mem::size_of::<$outty>() as i32 * 8 {
|
|
return !(0 as u128_);
|
|
}
|
|
(if exponent < (<$fromty as FloatStuff>::MANTISSA_BITS) as i32 {
|
|
(mantissa as $outty)
|
|
.wrapping_shr((<$fromty as FloatStuff>::MANTISSA_BITS as i32)
|
|
.wrapping_sub(exponent) as u32)
|
|
} else {
|
|
(mantissa as $outty)
|
|
.wrapping_shl(exponent.wrapping_sub(
|
|
<$fromty as FloatStuff>::MANTISSA_BITS as i32) as u32)
|
|
})
|
|
} }
|
|
}
|
|
|
|
macro_rules! float_as_signed {
|
|
($from: expr, $fromty: ty, $outty: ty) => {{
|
|
use core::num::Float;
|
|
let repr = $from.to_bytes();
|
|
let sign = $from.signum();
|
|
let exponent = $from.get_exponent();
|
|
let mantissa_fraction = repr & <$fromty as FloatStuff>::MANTISSA_MASK;
|
|
let mantissa = mantissa_fraction | <$fromty as FloatStuff>::MANTISSA_LEAD_BIT;
|
|
|
|
if exponent < 0 { return 0 as i128_; }
|
|
if exponent > ::core::mem::size_of::<$outty>() as i32 * 8 {
|
|
let ret = if sign > 0.0 { <$outty>::max_value() } else { <$outty>::min_value() };
|
|
return ret
|
|
}
|
|
let r = if exponent < (<$fromty as FloatStuff>::MANTISSA_BITS) as i32 {
|
|
(mantissa as $outty)
|
|
.wrapping_shr((<$fromty as FloatStuff>::MANTISSA_BITS as i32)
|
|
.wrapping_sub(exponent) as u32)
|
|
} else {
|
|
(mantissa as $outty)
|
|
.wrapping_shl(exponent.wrapping_sub(
|
|
<$fromty as FloatStuff>::MANTISSA_BITS as i32) as u32)
|
|
};
|
|
(if sign >= 0.0 { r } else { r.unchecked_neg() })
|
|
}}
|
|
}
|
|
|
|
|
|
fn i128_as_f64(a: i128_) -> f64 {
|
|
match a.signum() {
|
|
1 => u128_as_f64(a.uabs()),
|
|
0 => 0.0,
|
|
_ => -u128_as_f64(a.uabs()),
|
|
}
|
|
}
|
|
|
|
fn i128_as_f32(a: i128_) -> f32 {
|
|
match a.signum() {
|
|
1 => u128_as_f32(a.uabs()),
|
|
0 => 0.0,
|
|
_ => -u128_as_f32(a.uabs()),
|
|
}
|
|
}
|
|
|
|
fn u128_as_f64(mut a: u128_) -> f64 {
|
|
use ::core::f64::MANTISSA_DIGITS;
|
|
if a == 0 { return 0.0; }
|
|
let sd = 128u32.wrapping_sub(a.leading_zeros());
|
|
let mut e = sd.wrapping_sub(1);
|
|
const MD1 : u32 = MANTISSA_DIGITS + 1;
|
|
const MD2 : u32 = MANTISSA_DIGITS + 2;
|
|
|
|
// SNAP: replace this with !0u128
|
|
let negn :u128_ = !0;
|
|
|
|
if sd > MANTISSA_DIGITS {
|
|
a = match sd {
|
|
MD1 => a.wrapping_shl(1),
|
|
MD2 => a,
|
|
_ => a.wrapping_shr(sd.wrapping_sub(MANTISSA_DIGITS + 2)) |
|
|
(if (a & (negn.wrapping_shr(128 + MANTISSA_DIGITS + 2)
|
|
.wrapping_sub(sd as u128_))) == 0 { 0 } else { 1 })
|
|
};
|
|
a |= if (a & 4) == 0 { 0 } else { 1 };
|
|
a = a.wrapping_add(1);
|
|
a = a.wrapping_shr(2);
|
|
if a & (1 << MANTISSA_DIGITS) != 0 {
|
|
a = a.wrapping_shr(1);
|
|
e = e.wrapping_add(1);
|
|
}
|
|
} else {
|
|
a = a.wrapping_shl(MANTISSA_DIGITS.wrapping_sub(sd));
|
|
}
|
|
unsafe {
|
|
::core::mem::transmute((e as u64).wrapping_add(1023).wrapping_shl(52)
|
|
| (a as u64 & 0x000f_ffff_ffff_ffff))
|
|
}
|
|
}
|
|
|
|
fn u128_as_f32(mut a: u128_) -> f32 {
|
|
use ::core::f32::MANTISSA_DIGITS;
|
|
if a == 0 { return 0.0; }
|
|
let sd = 128u32.wrapping_sub(a.leading_zeros());
|
|
let mut e = sd.wrapping_sub(1);
|
|
const MD1 : u32 = MANTISSA_DIGITS + 1;
|
|
const MD2 : u32 = MANTISSA_DIGITS + 2;
|
|
|
|
// SNAP: replace this with !0u128
|
|
let negn :u128_ = !0;
|
|
|
|
if sd > MANTISSA_DIGITS {
|
|
a = match sd {
|
|
MD1 => a.wrapping_shl(1),
|
|
MD2 => a,
|
|
_ => a.wrapping_shr(sd.wrapping_sub(MANTISSA_DIGITS + 2)) |
|
|
(if (a & (negn.wrapping_shr(128 + MANTISSA_DIGITS + 2)
|
|
.wrapping_sub(sd as u128_))) == 0 { 0 } else { 1 })
|
|
};
|
|
a |= if (a & 4) == 0 { 0 } else { 1 };
|
|
a = a.wrapping_add(1);
|
|
a = a.wrapping_shr(2);
|
|
if a & (1 << MANTISSA_DIGITS) != 0 {
|
|
a = a.wrapping_shr(1);
|
|
e = e.wrapping_add(1);
|
|
}
|
|
} else {
|
|
a = a.wrapping_shl(MANTISSA_DIGITS.wrapping_sub(sd));
|
|
}
|
|
unsafe {
|
|
::core::mem::transmute((e as u32).wrapping_add(127).wrapping_shl(23)
|
|
| (a as u32 & 0x007f_ffff))
|
|
}
|
|
}
|
|
|
|
|
|
macro_rules! why_are_abi_strings_checked_by_parser { ($cret:ty, $conv:expr, $unadj:tt) => {
|
|
mod imp {
|
|
use super::{i128_, u128_, LargeInt, FloatStuff, NegExt, AbsExt};
|
|
use super::{i128_as_f64, i128_as_f32, u128_as_f64, u128_as_f32,
|
|
i128_div, i128_mod, u128_div_mod, unchecked_div, ptr};
|
|
// For x64
|
|
// rdx:rcx, r9:r8, stack -> rdx:rax
|
|
// aka.
|
|
// define i128 @__muloti4(i128, i128, i32*)
|
|
#[export_name="__muloti4"]
|
|
pub unsafe extern $unadj fn i128_mul_oflow(a: i128_, b: i128_, o: *mut i32) -> i128_ {
|
|
mulo!(a, b, o, i128_)
|
|
}
|
|
|
|
// For x64
|
|
// rdx:rax -> xmm0
|
|
// aka.
|
|
// define double @__muloti4(i128)
|
|
#[export_name="__floattidf"]
|
|
pub extern $unadj fn i128_as_f64_(a: i128_) -> f64 {
|
|
i128_as_f64(a)
|
|
}
|
|
#[export_name="__floattisf"]
|
|
pub extern $unadj fn i128_as_f32_(a: i128_) -> f32 {
|
|
i128_as_f32(a)
|
|
}
|
|
#[export_name="__floatuntidf"]
|
|
pub extern $unadj fn u128_as_f64_(a: u128_) -> f64 {
|
|
u128_as_f64(a)
|
|
}
|
|
#[export_name="__floatuntisf"]
|
|
pub extern $unadj fn u128_as_f32_(a: u128_) -> f32 {
|
|
u128_as_f32(a)
|
|
}
|
|
|
|
// For x64
|
|
// xmm0 -> rdx:rax
|
|
// aka.
|
|
// define i128 @stuff(double)
|
|
#[export_name="__fixunsdfti"]
|
|
pub extern $unadj fn f64_as_u128(a: f64) -> u128_ {
|
|
float_as_unsigned!(a, f64, u128_)
|
|
}
|
|
|
|
#[export_name="__fixunssfti"]
|
|
pub extern "unadjusted" fn f32_as_u128(a: f32) -> u128_ {
|
|
float_as_unsigned!(a, f32, u128_)
|
|
}
|
|
|
|
#[export_name="__fixdfti"]
|
|
pub extern "unadjusted" fn f64_as_i128(a: f64) -> i128_ {
|
|
float_as_signed!(a, f64, i128_)
|
|
}
|
|
|
|
#[export_name="__fixsfti"]
|
|
pub extern "unadjusted" fn f32_as_i128(a: f32) -> i128_ {
|
|
float_as_signed!(a, f32, i128_)
|
|
}
|
|
|
|
#[repr(simd)]
|
|
pub struct u64x2(u64, u64);
|
|
|
|
// For x64
|
|
// pointers -> xmm0
|
|
// aka.
|
|
// define <2 x u64> @stuff(i128*, i128*, i128*)
|
|
//
|
|
// That almost matches the C ABI, so we simply use the C ABI
|
|
#[export_name="__udivmodti4"]
|
|
pub extern "C" fn u128_div_mod_(n: u128_, d: u128_, rem: *mut u128_) -> $cret {
|
|
let x = u128_div_mod(n, d, rem);
|
|
($conv)(x)
|
|
}
|
|
|
|
#[export_name="__udivti3"]
|
|
pub extern "C" fn u128_div_(a: u128_, b: u128_) -> $cret {
|
|
let x = u128_div_mod(a, b, ptr::null_mut());
|
|
($conv)(x)
|
|
}
|
|
|
|
#[export_name="__umodti3"]
|
|
pub extern "C" fn u128_mod_(a: u128_, b: u128_) -> $cret {
|
|
unsafe {
|
|
let mut r = ::core::mem::zeroed();
|
|
u128_div_mod(a, b, &mut r);
|
|
($conv)(r)
|
|
}
|
|
}
|
|
|
|
#[export_name="__divti3"]
|
|
pub extern "C" fn i128_div_(a: i128_, b: i128_) -> $cret {
|
|
let x = i128_div(a, b);
|
|
($conv)(x as u128_)
|
|
}
|
|
|
|
#[export_name="__modti3"]
|
|
pub extern "C" fn i128_mod_(a: i128_, b: i128_) -> $cret {
|
|
let x = i128_mod(a, b);
|
|
($conv)(x as u128_)
|
|
}
|
|
}
|
|
} }
|
|
|
|
// LLVM expectations for ABI on windows x64 are pure madness.
|
|
#[cfg(not(stage0))]
|
|
#[cfg(all(windows, target_pointer_width="64"))]
|
|
why_are_abi_strings_checked_by_parser!(u64x2,
|
|
|i: u128_| u64x2(i.low(), i.high()),
|
|
"unadjusted");
|
|
|
|
#[cfg(not(stage0))]
|
|
#[cfg(not(all(windows, target_pointer_width="64")))]
|
|
why_are_abi_strings_checked_by_parser!(u128_, |i|{ i }, "C");
|
|
|
|
#[cfg(not(stage0))]
|
|
pub use self::imp::*;
|
|
}
|