Line data Source code
1 : // Copyright 2006-2008 the V8 project authors. All rights reserved.
2 : // Redistribution and use in source and binary forms, with or without
3 : // modification, are permitted provided that the following conditions are
4 : // met:
5 : //
6 : // * Redistributions of source code must retain the above copyright
7 : // notice, this list of conditions and the following disclaimer.
8 : // * Redistributions in binary form must reproduce the above
9 : // copyright notice, this list of conditions and the following
10 : // disclaimer in the documentation and/or other materials provided
11 : // with the distribution.
12 : // * Neither the name of Google Inc. nor the names of its
13 : // contributors may be used to endorse or promote products derived
14 : // from this software without specific prior written permission.
15 : //
16 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 :
28 : #include <stdlib.h>
29 :
30 : #include "src/v8.h"
31 :
32 : #include "src/base/platform/platform.h"
33 : #include "src/diy-fp.h"
34 : #include "src/double.h"
35 : #include "test/cctest/cctest.h"
36 :
37 : namespace v8 {
38 : namespace internal {
39 :
40 23724 : TEST(Uint64Conversions) {
41 : // Start by checking the byte-order.
42 : uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF);
43 6 : CHECK_EQ(3512700564088504e-318, Double(ordered).value());
44 :
45 : uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
46 6 : CHECK_EQ(5e-324, Double(min_double64).value());
47 :
48 : uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
49 6 : CHECK_EQ(1.7976931348623157e308, Double(max_double64).value());
50 6 : }
51 :
52 :
53 23724 : TEST(AsDiyFp) {
54 : uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF);
55 : DiyFp diy_fp = Double(ordered).AsDiyFp();
56 6 : CHECK_EQ(0x12 - 0x3FF - 52, diy_fp.e());
57 : // The 52 mantissa bits, plus the implicit 1 in bit 52 as a UINT64.
58 6 : CHECK(V8_2PART_UINT64_C(0x00134567, 89ABCDEF) == diy_fp.f()); // NOLINT
59 :
60 : uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
61 : diy_fp = Double(min_double64).AsDiyFp();
62 6 : CHECK_EQ(-0x3FF - 52 + 1, diy_fp.e());
63 : // This is a denormal; so no hidden bit.
64 6 : CHECK_EQ(1, diy_fp.f());
65 :
66 : uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
67 : diy_fp = Double(max_double64).AsDiyFp();
68 6 : CHECK_EQ(0x7FE - 0x3FF - 52, diy_fp.e());
69 6 : CHECK(V8_2PART_UINT64_C(0x001fffff, ffffffff) == diy_fp.f()); // NOLINT
70 6 : }
71 :
72 :
73 23724 : TEST(AsNormalizedDiyFp) {
74 : uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF);
75 6 : DiyFp diy_fp = Double(ordered).AsNormalizedDiyFp();
76 6 : CHECK_EQ(0x12 - 0x3FF - 52 - 11, diy_fp.e());
77 6 : CHECK((V8_2PART_UINT64_C(0x00134567, 89ABCDEF) << 11) ==
78 : diy_fp.f()); // NOLINT
79 :
80 : uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
81 6 : diy_fp = Double(min_double64).AsNormalizedDiyFp();
82 6 : CHECK_EQ(-0x3FF - 52 + 1 - 63, diy_fp.e());
83 : // This is a denormal; so no hidden bit.
84 6 : CHECK(V8_2PART_UINT64_C(0x80000000, 00000000) == diy_fp.f()); // NOLINT
85 :
86 : uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
87 6 : diy_fp = Double(max_double64).AsNormalizedDiyFp();
88 6 : CHECK_EQ(0x7FE - 0x3FF - 52 - 11, diy_fp.e());
89 6 : CHECK((V8_2PART_UINT64_C(0x001fffff, ffffffff) << 11) ==
90 : diy_fp.f()); // NOLINT
91 6 : }
92 :
93 :
94 23724 : TEST(IsDenormal) {
95 : uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
96 6 : CHECK(Double(min_double64).IsDenormal());
97 : uint64_t bits = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
98 6 : CHECK(Double(bits).IsDenormal());
99 : bits = V8_2PART_UINT64_C(0x00100000, 00000000);
100 6 : CHECK(!Double(bits).IsDenormal());
101 6 : }
102 :
103 :
104 23724 : TEST(IsSpecial) {
105 6 : CHECK(Double(V8_INFINITY).IsSpecial());
106 6 : CHECK(Double(-V8_INFINITY).IsSpecial());
107 6 : CHECK(Double(std::numeric_limits<double>::quiet_NaN()).IsSpecial());
108 : uint64_t bits = V8_2PART_UINT64_C(0xFFF12345, 00000000);
109 6 : CHECK(Double(bits).IsSpecial());
110 : // Denormals are not special:
111 6 : CHECK(!Double(5e-324).IsSpecial());
112 6 : CHECK(!Double(-5e-324).IsSpecial());
113 : // And some random numbers:
114 6 : CHECK(!Double(0.0).IsSpecial());
115 6 : CHECK(!Double(-0.0).IsSpecial());
116 6 : CHECK(!Double(1.0).IsSpecial());
117 6 : CHECK(!Double(-1.0).IsSpecial());
118 6 : CHECK(!Double(1000000.0).IsSpecial());
119 6 : CHECK(!Double(-1000000.0).IsSpecial());
120 6 : CHECK(!Double(1e23).IsSpecial());
121 6 : CHECK(!Double(-1e23).IsSpecial());
122 6 : CHECK(!Double(1.7976931348623157e308).IsSpecial());
123 6 : CHECK(!Double(-1.7976931348623157e308).IsSpecial());
124 6 : }
125 :
126 :
127 23724 : TEST(IsInfinite) {
128 6 : CHECK(Double(V8_INFINITY).IsInfinite());
129 6 : CHECK(Double(-V8_INFINITY).IsInfinite());
130 6 : CHECK(!Double(std::numeric_limits<double>::quiet_NaN()).IsInfinite());
131 6 : CHECK(!Double(0.0).IsInfinite());
132 6 : CHECK(!Double(-0.0).IsInfinite());
133 6 : CHECK(!Double(1.0).IsInfinite());
134 6 : CHECK(!Double(-1.0).IsInfinite());
135 : uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
136 6 : CHECK(!Double(min_double64).IsInfinite());
137 6 : }
138 :
139 :
140 23724 : TEST(Sign) {
141 6 : CHECK_EQ(1, Double(1.0).Sign());
142 6 : CHECK_EQ(1, Double(V8_INFINITY).Sign());
143 6 : CHECK_EQ(-1, Double(-V8_INFINITY).Sign());
144 6 : CHECK_EQ(1, Double(0.0).Sign());
145 6 : CHECK_EQ(-1, Double(-0.0).Sign());
146 : uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
147 6 : CHECK_EQ(1, Double(min_double64).Sign());
148 6 : }
149 :
150 :
151 23724 : TEST(NormalizedBoundaries) {
152 : DiyFp boundary_plus;
153 : DiyFp boundary_minus;
154 6 : DiyFp diy_fp = Double(1.5).AsNormalizedDiyFp();
155 6 : Double(1.5).NormalizedBoundaries(&boundary_minus, &boundary_plus);
156 6 : CHECK_EQ(diy_fp.e(), boundary_minus.e());
157 6 : CHECK_EQ(diy_fp.e(), boundary_plus.e());
158 : // 1.5 does not have a significand of the form 2^p (for some p).
159 : // Therefore its boundaries are at the same distance.
160 6 : CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
161 6 : CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
162 :
163 6 : diy_fp = Double(1.0).AsNormalizedDiyFp();
164 6 : Double(1.0).NormalizedBoundaries(&boundary_minus, &boundary_plus);
165 6 : CHECK_EQ(diy_fp.e(), boundary_minus.e());
166 6 : CHECK_EQ(diy_fp.e(), boundary_plus.e());
167 : // 1.0 does have a significand of the form 2^p (for some p).
168 : // Therefore its lower boundary is twice as close as the upper boundary.
169 6 : CHECK_GT(boundary_plus.f() - diy_fp.f(), diy_fp.f() - boundary_minus.f());
170 6 : CHECK((1 << 9) == diy_fp.f() - boundary_minus.f()); // NOLINT
171 6 : CHECK((1 << 10) == boundary_plus.f() - diy_fp.f()); // NOLINT
172 :
173 : uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
174 6 : diy_fp = Double(min_double64).AsNormalizedDiyFp();
175 6 : Double(min_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus);
176 6 : CHECK_EQ(diy_fp.e(), boundary_minus.e());
177 6 : CHECK_EQ(diy_fp.e(), boundary_plus.e());
178 : // min-value does not have a significand of the form 2^p (for some p).
179 : // Therefore its boundaries are at the same distance.
180 6 : CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
181 : // Denormals have their boundaries much closer.
182 6 : CHECK((static_cast<uint64_t>(1) << 62) ==
183 : diy_fp.f() - boundary_minus.f()); // NOLINT
184 :
185 : uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000);
186 6 : diy_fp = Double(smallest_normal64).AsNormalizedDiyFp();
187 : Double(smallest_normal64).NormalizedBoundaries(&boundary_minus,
188 6 : &boundary_plus);
189 6 : CHECK_EQ(diy_fp.e(), boundary_minus.e());
190 6 : CHECK_EQ(diy_fp.e(), boundary_plus.e());
191 : // Even though the significand is of the form 2^p (for some p), its boundaries
192 : // are at the same distance. (This is the only exception).
193 6 : CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
194 6 : CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
195 :
196 : uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
197 6 : diy_fp = Double(largest_denormal64).AsNormalizedDiyFp();
198 : Double(largest_denormal64).NormalizedBoundaries(&boundary_minus,
199 6 : &boundary_plus);
200 6 : CHECK_EQ(diy_fp.e(), boundary_minus.e());
201 6 : CHECK_EQ(diy_fp.e(), boundary_plus.e());
202 6 : CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
203 6 : CHECK((1 << 11) == diy_fp.f() - boundary_minus.f()); // NOLINT
204 :
205 : uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
206 6 : diy_fp = Double(max_double64).AsNormalizedDiyFp();
207 6 : Double(max_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus);
208 6 : CHECK_EQ(diy_fp.e(), boundary_minus.e());
209 6 : CHECK_EQ(diy_fp.e(), boundary_plus.e());
210 : // max-value does not have a significand of the form 2^p (for some p).
211 : // Therefore its boundaries are at the same distance.
212 6 : CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
213 6 : CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
214 6 : }
215 :
216 :
217 23724 : TEST(NextDouble) {
218 6 : CHECK_EQ(4e-324, Double(0.0).NextDouble());
219 6 : CHECK_EQ(0.0, Double(-0.0).NextDouble());
220 6 : CHECK_EQ(-0.0, Double(-4e-324).NextDouble());
221 : Double d0(-4e-324);
222 6 : Double d1(d0.NextDouble());
223 6 : Double d2(d1.NextDouble());
224 6 : CHECK_EQ(-0.0, d1.value());
225 6 : CHECK_EQ(0.0, d2.value());
226 6 : CHECK_EQ(4e-324, d2.NextDouble());
227 6 : CHECK_EQ(-1.7976931348623157e308, Double(-V8_INFINITY).NextDouble());
228 12 : CHECK_EQ(V8_INFINITY,
229 : Double(V8_2PART_UINT64_C(0x7fefffff, ffffffff)).NextDouble());
230 6 : }
231 :
232 : } // namespace internal
233 71154 : } // namespace v8
|
