1 | // Copyright 2010 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 | #ifndef DOUBLE_CONVERSION_UTILS_H_ |
29 | #define DOUBLE_CONVERSION_UTILS_H_ |
30 | |
31 | #include <cstdlib> |
32 | #include <cstring> |
33 | |
34 | #include <cassert> |
35 | #ifndef ASSERT |
36 | #define ASSERT(condition) \ |
37 | assert(condition); |
38 | #endif |
39 | #ifndef UNIMPLEMENTED |
40 | #define UNIMPLEMENTED() (abort()) |
41 | #endif |
42 | #ifndef DOUBLE_CONVERSION_NO_RETURN |
43 | #ifdef _MSC_VER |
44 | #define DOUBLE_CONVERSION_NO_RETURN __declspec(noreturn) |
45 | #else |
46 | #define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn)) |
47 | #endif |
48 | #endif |
49 | #ifndef UNREACHABLE |
50 | #ifdef _MSC_VER |
51 | void DOUBLE_CONVERSION_NO_RETURN abort_noreturn(); |
52 | inline void abort_noreturn() { abort(); } |
53 | #define UNREACHABLE() (abort_noreturn()) |
54 | #else |
55 | #define UNREACHABLE() (abort()) |
56 | #endif |
57 | #endif |
58 | |
59 | #ifndef DOUBLE_CONVERSION_UNUSED |
60 | #ifdef __GNUC__ |
61 | #define DOUBLE_CONVERSION_UNUSED __attribute__((unused)) |
62 | #else |
63 | #define DOUBLE_CONVERSION_UNUSED |
64 | #endif |
65 | #endif |
66 | |
67 | // Double operations detection based on target architecture. |
68 | // Linux uses a 80bit wide floating point stack on x86. This induces double |
69 | // rounding, which in turn leads to wrong results. |
70 | // An easy way to test if the floating-point operations are correct is to |
71 | // evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then |
72 | // the result is equal to 89255e-22. |
73 | // The best way to test this, is to create a division-function and to compare |
74 | // the output of the division with the expected result. (Inlining must be |
75 | // disabled.) |
76 | // On Linux,x86 89255e-22 != Div_double(89255.0/1e22) |
77 | // |
78 | // For example: |
79 | /* |
80 | // -- in div.c |
81 | double Div_double(double x, double y) { return x / y; } |
82 | |
83 | // -- in main.c |
84 | double Div_double(double x, double y); // Forward declaration. |
85 | |
86 | int main(int argc, char** argv) { |
87 | return Div_double(89255.0, 1e22) == 89255e-22; |
88 | } |
89 | */ |
90 | // Run as follows ./main || echo "correct" |
91 | // |
92 | // If it prints "correct" then the architecture should be here, in the "correct" section. |
93 | #if defined(_M_X64) || defined(__x86_64__) || \ |
94 | defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \ |
95 | defined(__hppa__) || defined(__ia64__) || \ |
96 | defined(__mips__) || \ |
97 | defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \ |
98 | defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \ |
99 | defined(__sparc__) || defined(__sparc) || defined(__s390__) || \ |
100 | defined(__SH4__) || defined(__alpha__) || \ |
101 | defined(_MIPS_ARCH_MIPS32R2) || defined(__ARMEB__) ||\ |
102 | defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \ |
103 | defined(__riscv) || \ |
104 | defined(__or1k__) || defined(__arc__) || \ |
105 | defined(__EMSCRIPTEN__) |
106 | #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 |
107 | #elif defined(__mc68000__) || \ |
108 | defined(__pnacl__) || defined(__native_client__) |
109 | #undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS |
110 | #elif defined(_M_IX86) || defined(__i386__) || defined(__i386) |
111 | #if defined(_WIN32) |
112 | // Windows uses a 64bit wide floating point stack. |
113 | #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 |
114 | #else |
115 | #undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS |
116 | #endif // _WIN32 |
117 | #elif defined(__ghs) |
118 | // Green Hills toolchain uses a 64bit wide floating point stack |
119 | #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 |
120 | #else |
121 | #error Target architecture was not detected as supported by Double-Conversion. |
122 | #endif |
123 | |
124 | #if defined(_WIN32) && !defined(__MINGW32__) |
125 | |
126 | typedef signed char int8_t; |
127 | typedef unsigned char uint8_t; |
128 | typedef short int16_t; // NOLINT |
129 | typedef unsigned short uint16_t; // NOLINT |
130 | typedef int int32_t; |
131 | typedef unsigned int uint32_t; |
132 | typedef __int64 int64_t; |
133 | typedef unsigned __int64 uint64_t; |
134 | // intptr_t and friends are defined in crtdefs.h through stdio.h. |
135 | |
136 | #else |
137 | |
138 | #include <stdint.h> |
139 | |
140 | #endif |
141 | |
142 | typedef uint16_t uc16; |
143 | |
144 | // The following macro works on both 32 and 64-bit platforms. |
145 | // Usage: instead of writing 0x1234567890123456 |
146 | // write UINT64_2PART_C(0x12345678,90123456); |
147 | #define UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u)) |
148 | |
149 | |
150 | // The expression ARRAY_SIZE(a) is a compile-time constant of type |
151 | // size_t which represents the number of elements of the given |
152 | // array. You should only use ARRAY_SIZE on statically allocated |
153 | // arrays. |
154 | #ifndef ARRAY_SIZE |
155 | #define ARRAY_SIZE(a) \ |
156 | ((sizeof(a) / sizeof(*(a))) / \ |
157 | static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) |
158 | #endif |
159 | |
160 | // A macro to disallow the evil copy constructor and operator= functions |
161 | // This should be used in the private: declarations for a class |
162 | #ifndef DC_DISALLOW_COPY_AND_ASSIGN |
163 | #define DC_DISALLOW_COPY_AND_ASSIGN(TypeName) \ |
164 | TypeName(const TypeName&); \ |
165 | void operator=(const TypeName&) |
166 | #endif |
167 | |
168 | // A macro to disallow all the implicit constructors, namely the |
169 | // default constructor, copy constructor and operator= functions. |
170 | // |
171 | // This should be used in the private: declarations for a class |
172 | // that wants to prevent anyone from instantiating it. This is |
173 | // especially useful for classes containing only static methods. |
174 | #ifndef DC_DISALLOW_IMPLICIT_CONSTRUCTORS |
175 | #define DC_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ |
176 | TypeName(); \ |
177 | DC_DISALLOW_COPY_AND_ASSIGN(TypeName) |
178 | #endif |
179 | |
180 | namespace double_conversion { |
181 | |
182 | static const int kCharSize = sizeof(char); |
183 | |
184 | // Returns the maximum of the two parameters. |
185 | template <typename T> |
186 | static T Max(T a, T b) { |
187 | return a < b ? b : a; |
188 | } |
189 | |
190 | |
191 | // Returns the minimum of the two parameters. |
192 | template <typename T> |
193 | static T Min(T a, T b) { |
194 | return a < b ? a : b; |
195 | } |
196 | |
197 | |
198 | inline int StrLength(const char* string) { |
199 | size_t length = strlen(s: string); |
200 | ASSERT(length == static_cast<size_t>(static_cast<int>(length))); |
201 | return static_cast<int>(length); |
202 | } |
203 | |
204 | // This is a simplified version of V8's Vector class. |
205 | template <typename T> |
206 | class Vector { |
207 | public: |
208 | Vector() : start_(NULL), length_(0) {} |
209 | Vector(T* data, int len) : start_(data), length_(len) { |
210 | ASSERT(len == 0 || (len > 0 && data != NULL)); |
211 | } |
212 | |
213 | // Returns a vector using the same backing storage as this one, |
214 | // spanning from and including 'from', to but not including 'to'. |
215 | Vector<T> SubVector(int from, int to) { |
216 | ASSERT(to <= length_); |
217 | ASSERT(from < to); |
218 | ASSERT(0 <= from); |
219 | return Vector<T>(start() + from, to - from); |
220 | } |
221 | |
222 | // Returns the length of the vector. |
223 | int length() const { return length_; } |
224 | |
225 | // Returns whether or not the vector is empty. |
226 | bool is_empty() const { return length_ == 0; } |
227 | |
228 | // Returns the pointer to the start of the data in the vector. |
229 | T* start() const { return start_; } |
230 | |
231 | // Access individual vector elements - checks bounds in debug mode. |
232 | T& operator[](int index) const { |
233 | ASSERT(0 <= index && index < length_); |
234 | return start_[index]; |
235 | } |
236 | |
237 | T& first() { return start_[0]; } |
238 | |
239 | T& last() { return start_[length_ - 1]; } |
240 | |
241 | private: |
242 | T* start_; |
243 | int length_; |
244 | }; |
245 | |
246 | |
247 | // Helper class for building result strings in a character buffer. The |
248 | // purpose of the class is to use safe operations that checks the |
249 | // buffer bounds on all operations in debug mode. |
250 | class StringBuilder { |
251 | public: |
252 | StringBuilder(char* buffer, int buffer_size) |
253 | : buffer_(buffer, buffer_size), position_(0) { } |
254 | |
255 | ~StringBuilder() { if (!is_finalized()) Finalize(); } |
256 | |
257 | int size() const { return buffer_.length(); } |
258 | |
259 | // Get the current position in the builder. |
260 | int position() const { |
261 | ASSERT(!is_finalized()); |
262 | return position_; |
263 | } |
264 | |
265 | // Reset the position. |
266 | void Reset() { position_ = 0; } |
267 | |
268 | // Add a single character to the builder. It is not allowed to add |
269 | // 0-characters; use the Finalize() method to terminate the string |
270 | // instead. |
271 | void AddCharacter(char c) { |
272 | ASSERT(c != '\0'); |
273 | ASSERT(!is_finalized() && position_ < buffer_.length()); |
274 | buffer_[position_++] = c; |
275 | } |
276 | |
277 | // Add an entire string to the builder. Uses strlen() internally to |
278 | // compute the length of the input string. |
279 | void AddString(const char* s) { |
280 | AddSubstring(s, n: StrLength(string: s)); |
281 | } |
282 | |
283 | // Add the first 'n' characters of the given string 's' to the |
284 | // builder. The input string must have enough characters. |
285 | void AddSubstring(const char* s, int n) { |
286 | ASSERT(!is_finalized() && position_ + n < buffer_.length()); |
287 | ASSERT(static_cast<size_t>(n) <= strlen(s)); |
288 | memmove(dest: &buffer_[position_], src: s, n: n * kCharSize); |
289 | position_ += n; |
290 | } |
291 | |
292 | |
293 | // Add character padding to the builder. If count is non-positive, |
294 | // nothing is added to the builder. |
295 | void AddPadding(char c, int count) { |
296 | for (int i = 0; i < count; i++) { |
297 | AddCharacter(c); |
298 | } |
299 | } |
300 | |
301 | // Finalize the string by 0-terminating it and returning the buffer. |
302 | char* Finalize() { |
303 | ASSERT(!is_finalized() && position_ < buffer_.length()); |
304 | buffer_[position_] = '\0'; |
305 | // Make sure nobody managed to add a 0-character to the |
306 | // buffer while building the string. |
307 | ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_)); |
308 | position_ = -1; |
309 | ASSERT(is_finalized()); |
310 | return buffer_.start(); |
311 | } |
312 | |
313 | private: |
314 | Vector<char> buffer_; |
315 | int position_; |
316 | |
317 | bool is_finalized() const { return position_ < 0; } |
318 | |
319 | DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder); |
320 | }; |
321 | |
322 | // The type-based aliasing rule allows the compiler to assume that pointers of |
323 | // different types (for some definition of different) never alias each other. |
324 | // Thus the following code does not work: |
325 | // |
326 | // float f = foo(); |
327 | // int fbits = *(int*)(&f); |
328 | // |
329 | // The compiler 'knows' that the int pointer can't refer to f since the types |
330 | // don't match, so the compiler may cache f in a register, leaving random data |
331 | // in fbits. Using C++ style casts makes no difference, however a pointer to |
332 | // char data is assumed to alias any other pointer. This is the 'memcpy |
333 | // exception'. |
334 | // |
335 | // Bit_cast uses the memcpy exception to move the bits from a variable of one |
336 | // type of a variable of another type. Of course the end result is likely to |
337 | // be implementation dependent. Most compilers (gcc-4.2 and MSVC 2005) |
338 | // will completely optimize BitCast away. |
339 | // |
340 | // There is an additional use for BitCast. |
341 | // Recent gccs will warn when they see casts that may result in breakage due to |
342 | // the type-based aliasing rule. If you have checked that there is no breakage |
343 | // you can use BitCast to cast one pointer type to another. This confuses gcc |
344 | // enough that it can no longer see that you have cast one pointer type to |
345 | // another thus avoiding the warning. |
346 | template <class Dest, class Source> |
347 | inline Dest BitCast(const Source& source) { |
348 | // Compile time assertion: sizeof(Dest) == sizeof(Source) |
349 | // A compile error here means your Dest and Source have different sizes. |
350 | #if __cplusplus >= 201103L |
351 | static_assert(sizeof(Dest) == sizeof(Source), |
352 | "source and destination size mismatch" ); |
353 | #else |
354 | DOUBLE_CONVERSION_UNUSED |
355 | typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1]; |
356 | #endif |
357 | |
358 | Dest dest; |
359 | memmove(&dest, &source, sizeof(dest)); |
360 | return dest; |
361 | } |
362 | |
363 | template <class Dest, class Source> |
364 | inline Dest BitCast(Source* source) { |
365 | return BitCast<Dest>(reinterpret_cast<uintptr_t>(source)); |
366 | } |
367 | |
368 | } // namespace double_conversion |
369 | |
370 | #endif // DOUBLE_CONVERSION_UTILS_H_ |
371 | |