1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213

// Copyright 2015 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.

use std::cmp::Ordering;
use std::num::ParseFloatError;

use syntax::ast;

use rustc_apfloat::{Float, FloatConvert, Status};
use rustc_apfloat::ieee::{Single, Double};

use super::err::*;

// Note that equality for `ConstFloat` means that the it is the same
// constant, not that the rust values are equal. In particular, `NaN
// == NaN` (at least if it's the same NaN; distinct encodings for NaN
// are considering unequal).
#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
pub struct ConstFloat {
    pub ty: ast::FloatTy,

    // This is a bit inefficient but it makes conversions below more
    // ergonomic, and all of this will go away once `miri` is merged.
    pub bits: u128,
}

impl ConstFloat {
    /// Description of the type, not the value
    pub fn description(&self) -> &'static str {
        self.ty.ty_to_string()
    }

    /// Compares the values if they are of the same type
    pub fn try_cmp(self, rhs: Self) -> Result<Ordering, ConstMathErr> {
        match (self.ty, rhs.ty) {
            (ast::FloatTy::F64, ast::FloatTy::F64)  => {
                let a = Double::from_bits(self.bits);
                let b = Double::from_bits(rhs.bits);
                // This is pretty bad but it is the existing behavior.
                Ok(a.partial_cmp(&b).unwrap_or(Ordering::Greater))
            }

            (ast::FloatTy::F32, ast::FloatTy::F32) => {
                let a = Single::from_bits(self.bits);
                let b = Single::from_bits(rhs.bits);
                Ok(a.partial_cmp(&b).unwrap_or(Ordering::Greater))
            }

            _ => Err(CmpBetweenUnequalTypes),
        }
    }

    pub fn from_i128(input: i128, ty: ast::FloatTy) -> Self {
        let bits = match ty {
            ast::FloatTy::F32 => Single::from_i128(input).value.to_bits(),
            ast::FloatTy::F64 => Double::from_i128(input).value.to_bits()
        };
        ConstFloat { bits, ty }
    }

    pub fn from_u128(input: u128, ty: ast::FloatTy) -> Self {
        let bits = match ty {
            ast::FloatTy::F32 => Single::from_u128(input).value.to_bits(),
            ast::FloatTy::F64 => Double::from_u128(input).value.to_bits()
        };
        ConstFloat { bits, ty }
    }

    pub fn from_str(num: &str, ty: ast::FloatTy) -> Result<Self, ParseFloatError> {
        let bits = match ty {
            ast::FloatTy::F32 => {
                let rust_bits = num.parse::<f32>()?.to_bits() as u128;
                let apfloat = num.parse::<Single>().unwrap_or_else(|e| {
                    panic!("apfloat::ieee::Single failed to parse `{}`: {:?}", num, e);
                });
                let apfloat_bits = apfloat.to_bits();
                assert!(rust_bits == apfloat_bits,
                    "apfloat::ieee::Single gave different result for `{}`: \
                     {}({:#x}) vs Rust's {}({:#x})",
                    num, apfloat, apfloat_bits,
                    Single::from_bits(rust_bits), rust_bits);
                apfloat_bits
            }
            ast::FloatTy::F64 => {
                let rust_bits = num.parse::<f64>()?.to_bits() as u128;
                let apfloat = num.parse::<Double>().unwrap_or_else(|e| {
                    panic!("apfloat::ieee::Double failed to parse `{}`: {:?}", num, e);
                });
                let apfloat_bits = apfloat.to_bits();
                assert!(rust_bits == apfloat_bits,
                    "apfloat::ieee::Double gave different result for `{}`: \
                     {}({:#x}) vs Rust's {}({:#x})",
                    num, apfloat, apfloat_bits,
                    Double::from_bits(rust_bits), rust_bits);
                apfloat_bits
            }
        };
        Ok(ConstFloat { bits, ty })
    }

    pub fn to_i128(self, width: usize) -> Option<i128> {
        assert!(width <= 128);
        let r = match self.ty {
            ast::FloatTy::F32 => Single::from_bits(self.bits).to_i128(width),
            ast::FloatTy::F64 => Double::from_bits(self.bits).to_i128(width)
        };
        if r.status.intersects(Status::INVALID_OP) {
            None
        } else {
            Some(r.value)
        }
    }

    pub fn to_u128(self, width: usize) -> Option<u128> {
        assert!(width <= 128);
        let r = match self.ty {
            ast::FloatTy::F32 => Single::from_bits(self.bits).to_u128(width),
            ast::FloatTy::F64 => Double::from_bits(self.bits).to_u128(width)
        };
        if r.status.intersects(Status::INVALID_OP) {
            None
        } else {
            Some(r.value)
        }
    }

    pub fn convert(self, to: ast::FloatTy) -> Self {
        let bits = match (self.ty, to) {
            (ast::FloatTy::F32, ast::FloatTy::F32) |
            (ast::FloatTy::F64, ast::FloatTy::F64) => return self,

            (ast::FloatTy::F32, ast::FloatTy::F64) => {
                Double::to_bits(Single::from_bits(self.bits).convert(&mut false).value)
            }
            (ast::FloatTy::F64, ast::FloatTy::F32) => {
                Single::to_bits(Double::from_bits(self.bits).convert(&mut false).value)
            }
        };
        ConstFloat { bits, ty: to }
    }
}

impl ::std::fmt::Display for ConstFloat {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
        match self.ty {
            ast::FloatTy::F32 => write!(fmt, "{:#}", Single::from_bits(self.bits))?,
            ast::FloatTy::F64 => write!(fmt, "{:#}", Double::from_bits(self.bits))?,
        }
        write!(fmt, "{}", self.ty)
    }
}

impl ::std::fmt::Debug for ConstFloat {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
        ::std::fmt::Display::fmt(self, fmt)
    }
}

macro_rules! derive_binop {
    ($op:ident, $func:ident) => {
        impl ::std::ops::$op for ConstFloat {
            type Output = Result<Self, ConstMathErr>;
            fn $func(self, rhs: Self) -> Result<Self, ConstMathErr> {
                let bits = match (self.ty, rhs.ty) {
                    (ast::FloatTy::F32, ast::FloatTy::F32) =>{
                        let a = Single::from_bits(self.bits);
                        let b = Single::from_bits(rhs.bits);
                        a.$func(b).value.to_bits()
                    }
                    (ast::FloatTy::F64, ast::FloatTy::F64) => {
                        let a = Double::from_bits(self.bits);
                        let b = Double::from_bits(rhs.bits);
                        a.$func(b).value.to_bits()
                    }
                    _ => return Err(UnequalTypes(Op::$op)),
                };
                Ok(ConstFloat { bits, ty: self.ty })
            }
        }
    }
}

derive_binop!(Add, add);
derive_binop!(Sub, sub);
derive_binop!(Mul, mul);
derive_binop!(Div, div);
derive_binop!(Rem, rem);

impl ::std::ops::Neg for ConstFloat {
    type Output = Self;
    fn neg(self) -> Self {
        let bits = match self.ty {
            ast::FloatTy::F32 => (-Single::from_bits(self.bits)).to_bits(),
            ast::FloatTy::F64 => (-Double::from_bits(self.bits)).to_bits(),
        };
        ConstFloat { bits, ty: self.ty }
    }
}

/// This is `f32::MAX + (0.5 ULP)` as an integer. Numbers greater or equal to this
/// are rounded to infinity when converted to `f32`.
///
/// NB: Computed as maximum significand with an extra 1 bit added (for the half ULP)
/// shifted by the maximum exponent (accounting for normalization).
pub const MAX_F32_PLUS_HALF_ULP: u128 = ((1 << (Single::PRECISION + 1)) - 1)
                                        << (Single::MAX_EXP - Single::PRECISION as i16);