source: webkit/trunk/JavaScriptCore/runtime/JSImmediate.h@ 48593

Last change on this file since 48593 was 46702, checked in by [email protected], 16 years ago

2009-08-02 Geoffrey Garen <​[email protected]>

Windows build fix: Nixed JSImmediate::prototype, JSImmediate::toObject,
and JSImmediate::toThisObject, and removed their exported symbols.

  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
  • runtime/JSImmediate.cpp:
  • runtime/JSImmediate.h:
  • Property svn:eol-style set to native
File size: 25.4 KB
Line 
1/*
2 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3 * Copyright (C) 2006 Alexey Proskuryakov ([email protected])
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public License
16 * along with this library; see the file COPYING.LIB. If not, write to
17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
19 *
20 */
21
22#ifndef JSImmediate_h
23#define JSImmediate_h
24
25#include <wtf/Platform.h>
26
27#if !USE(JSVALUE32_64)
28
29#include <wtf/Assertions.h>
30#include <wtf/AlwaysInline.h>
31#include <wtf/MathExtras.h>
32#include <wtf/StdLibExtras.h>
33#include "JSValue.h"
34#include <limits>
35#include <limits.h>
36#include <stdarg.h>
37#include <stdint.h>
38#include <stdlib.h>
39
40namespace JSC {
41
42 class ExecState;
43 class JSCell;
44 class JSFastMath;
45 class JSGlobalData;
46 class JSObject;
47 class UString;
48
49#if USE(JSVALUE64)
50 inline intptr_t reinterpretDoubleToIntptr(double value)
51 {
52 return WTF::bitwise_cast<intptr_t>(value);
53 }
54
55 inline double reinterpretIntptrToDouble(intptr_t value)
56 {
57 return WTF::bitwise_cast<double>(value);
58 }
59#endif
60
61 /*
62 * A JSValue* is either a pointer to a cell (a heap-allocated object) or an immediate (a type-tagged
63 * value masquerading as a pointer). The low two bits in a JSValue* are available for type tagging
64 * because allocator alignment guarantees they will be 00 in cell pointers.
65 *
66 * For example, on a 32 bit system:
67 *
68 * JSCell*: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 00
69 * [ high 30 bits: pointer address ] [ low 2 bits -- always 0 ]
70 * JSImmediate: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX TT
71 * [ high 30 bits: 'payload' ] [ low 2 bits -- tag ]
72 *
73 * Where the bottom two bits are non-zero they either indicate that the immediate is a 31 bit signed
74 * integer, or they mark the value as being an immediate of a type other than integer, with a secondary
75 * tag used to indicate the exact type.
76 *
77 * Where the lowest bit is set (TT is equal to 01 or 11) the high 31 bits form a 31 bit signed int value.
78 * Where TT is equal to 10 this indicates this is a type of immediate other than an integer, and the next
79 * two bits will form an extended tag.
80 *
81 * 31 bit signed int: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X1
82 * [ high 30 bits of the value ] [ high bit part of value ]
83 * Other: YYYYYYYYYYYYYYYYYYYYYYYYYYYY ZZ 10
84 * [ extended 'payload' ] [ extended tag ] [ tag 'other' ]
85 *
86 * Where the first bit of the extended tag is set this flags the value as being a boolean, and the following
87 * bit would flag the value as undefined. If neither bits are set, the value is null.
88 *
89 * Other: YYYYYYYYYYYYYYYYYYYYYYYYYYYY UB 10
90 * [ extended 'payload' ] [ undefined | bool ] [ tag 'other' ]
91 *
92 * For boolean value the lowest bit in the payload holds the value of the bool, all remaining bits are zero.
93 * For undefined or null immediates the payload is zero.
94 *
95 * Boolean: 000000000000000000000000000V 01 10
96 * [ boolean value ] [ bool ] [ tag 'other' ]
97 * Undefined: 0000000000000000000000000000 10 10
98 * [ zero ] [ undefined ] [ tag 'other' ]
99 * Null: 0000000000000000000000000000 00 10
100 * [ zero ] [ zero ] [ tag 'other' ]
101 */
102
103 /*
104 * On 64-bit platforms, we support an alternative encoding form for immediates, if
105 * USE(JSVALUE64) is defined. When this format is used, double precision
106 * floating point values may also be encoded as JSImmediates.
107 *
108 * The encoding makes use of unused NaN space in the IEEE754 representation. Any value
109 * with the top 13 bits set represents a QNaN (with the sign bit set). QNaN values
110 * can encode a 51-bit payload. Hardware produced and C-library payloads typically
111 * have a payload of zero. We assume that non-zero payloads are available to encode
112 * pointer and integer values. Since any 64-bit bit pattern where the top 15 bits are
113 * all set represents a NaN with a non-zero payload, we can use this space in the NaN
114 * ranges to encode other values (however there are also other ranges of NaN space that
115 * could have been selected). This range of NaN space is represented by 64-bit numbers
116 * begining with the 16-bit hex patterns 0xFFFE and 0xFFFF - we rely on the fact that no
117 * valid double-precision numbers will begin fall in these ranges.
118 *
119 * The scheme we have implemented encodes double precision values by adding 2^48 to the
120 * 64-bit integer representation of the number. After this manipulation, no encoded
121 * double-precision value will begin with the pattern 0x0000 or 0xFFFF.
122 *
123 * The top 16-bits denote the type of the encoded JSImmediate:
124 *
125 * Pointer: 0000:PPPP:PPPP:PPPP
126 * 0001:****:****:****
127 * Double:{ ...
128 * FFFE:****:****:****
129 * Integer: FFFF:0000:IIII:IIII
130 *
131 * 32-bit signed integers are marked with the 16-bit tag 0xFFFF. The tag 0x0000
132 * denotes a pointer, or another form of tagged immediate. Boolean, null and undefined
133 * values are encoded in the same manner as the default format.
134 */
135
136 class JSImmediate {
137 private:
138 friend class JIT;
139 friend class JSValue;
140 friend class JSFastMath;
141 friend JSValue jsNumber(ExecState* exec, double d);
142 friend JSValue jsNumber(ExecState*, char i);
143 friend JSValue jsNumber(ExecState*, unsigned char i);
144 friend JSValue jsNumber(ExecState*, short i);
145 friend JSValue jsNumber(ExecState*, unsigned short i);
146 friend JSValue jsNumber(ExecState* exec, int i);
147 friend JSValue jsNumber(ExecState* exec, unsigned i);
148 friend JSValue jsNumber(ExecState* exec, long i);
149 friend JSValue jsNumber(ExecState* exec, unsigned long i);
150 friend JSValue jsNumber(ExecState* exec, long long i);
151 friend JSValue jsNumber(ExecState* exec, unsigned long long i);
152 friend JSValue jsNumber(JSGlobalData* globalData, double d);
153 friend JSValue jsNumber(JSGlobalData* globalData, short i);
154 friend JSValue jsNumber(JSGlobalData* globalData, unsigned short i);
155 friend JSValue jsNumber(JSGlobalData* globalData, int i);
156 friend JSValue jsNumber(JSGlobalData* globalData, unsigned i);
157 friend JSValue jsNumber(JSGlobalData* globalData, long i);
158 friend JSValue jsNumber(JSGlobalData* globalData, unsigned long i);
159 friend JSValue jsNumber(JSGlobalData* globalData, long long i);
160 friend JSValue jsNumber(JSGlobalData* globalData, unsigned long long i);
161
162#if USE(JSVALUE64)
163 // If all bits in the mask are set, this indicates an integer number,
164 // if any but not all are set this value is a double precision number.
165 static const intptr_t TagTypeNumber = 0xffff000000000000ll;
166 // This value is 2^48, used to encode doubles such that the encoded value will begin
167 // with a 16-bit pattern within the range 0x0001..0xFFFE.
168 static const intptr_t DoubleEncodeOffset = 0x1000000000000ll;
169#else
170 static const intptr_t TagTypeNumber = 0x1; // bottom bit set indicates integer, this dominates the following bit
171#endif
172 static const intptr_t TagBitTypeOther = 0x2; // second bit set indicates immediate other than an integer
173 static const intptr_t TagMask = TagTypeNumber | TagBitTypeOther;
174
175 static const intptr_t ExtendedTagMask = 0xC; // extended tag holds a further two bits
176 static const intptr_t ExtendedTagBitBool = 0x4;
177 static const intptr_t ExtendedTagBitUndefined = 0x8;
178
179 static const intptr_t FullTagTypeMask = TagMask | ExtendedTagMask;
180 static const intptr_t FullTagTypeBool = TagBitTypeOther | ExtendedTagBitBool;
181 static const intptr_t FullTagTypeUndefined = TagBitTypeOther | ExtendedTagBitUndefined;
182 static const intptr_t FullTagTypeNull = TagBitTypeOther;
183
184#if USE(JSVALUE64)
185 static const int32_t IntegerPayloadShift = 0;
186#else
187 static const int32_t IntegerPayloadShift = 1;
188#endif
189 static const int32_t ExtendedPayloadShift = 4;
190
191 static const intptr_t ExtendedPayloadBitBoolValue = 1 << ExtendedPayloadShift;
192
193 static const int32_t signBit = 0x80000000;
194
195 static ALWAYS_INLINE bool isImmediate(JSValue v)
196 {
197 return rawValue(v) & TagMask;
198 }
199
200 static ALWAYS_INLINE bool isNumber(JSValue v)
201 {
202 return rawValue(v) & TagTypeNumber;
203 }
204
205 static ALWAYS_INLINE bool isIntegerNumber(JSValue v)
206 {
207#if USE(JSVALUE64)
208 return (rawValue(v) & TagTypeNumber) == TagTypeNumber;
209#else
210 return isNumber(v);
211#endif
212 }
213
214#if USE(JSVALUE64)
215 static ALWAYS_INLINE bool isDouble(JSValue v)
216 {
217 return isNumber(v) && !isIntegerNumber(v);
218 }
219#endif
220
221 static ALWAYS_INLINE bool isPositiveIntegerNumber(JSValue v)
222 {
223 // A single mask to check for the sign bit and the number tag all at once.
224 return (rawValue(v) & (signBit | TagTypeNumber)) == TagTypeNumber;
225 }
226
227 static ALWAYS_INLINE bool isBoolean(JSValue v)
228 {
229 return (rawValue(v) & FullTagTypeMask) == FullTagTypeBool;
230 }
231
232 static ALWAYS_INLINE bool isUndefinedOrNull(JSValue v)
233 {
234 // Undefined and null share the same value, bar the 'undefined' bit in the extended tag.
235 return (rawValue(v) & ~ExtendedTagBitUndefined) == FullTagTypeNull;
236 }
237
238 static JSValue from(char);
239 static JSValue from(signed char);
240 static JSValue from(unsigned char);
241 static JSValue from(short);
242 static JSValue from(unsigned short);
243 static JSValue from(int);
244 static JSValue from(unsigned);
245 static JSValue from(long);
246 static JSValue from(unsigned long);
247 static JSValue from(long long);
248 static JSValue from(unsigned long long);
249 static JSValue from(double);
250
251 static ALWAYS_INLINE bool isEitherImmediate(JSValue v1, JSValue v2)
252 {
253 return (rawValue(v1) | rawValue(v2)) & TagMask;
254 }
255
256 static ALWAYS_INLINE bool areBothImmediate(JSValue v1, JSValue v2)
257 {
258 return isImmediate(v1) & isImmediate(v2);
259 }
260
261 static ALWAYS_INLINE bool areBothImmediateIntegerNumbers(JSValue v1, JSValue v2)
262 {
263#if USE(JSVALUE64)
264 return (rawValue(v1) & rawValue(v2) & TagTypeNumber) == TagTypeNumber;
265#else
266 return rawValue(v1) & rawValue(v2) & TagTypeNumber;
267#endif
268 }
269
270 static double toDouble(JSValue);
271 static bool toBoolean(JSValue);
272
273 static bool getUInt32(JSValue, uint32_t&);
274 static bool getTruncatedInt32(JSValue, int32_t&);
275 static bool getTruncatedUInt32(JSValue, uint32_t&);
276
277 static int32_t getTruncatedInt32(JSValue);
278 static uint32_t getTruncatedUInt32(JSValue);
279
280 static JSValue trueImmediate();
281 static JSValue falseImmediate();
282 static JSValue undefinedImmediate();
283 static JSValue nullImmediate();
284 static JSValue zeroImmediate();
285 static JSValue oneImmediate();
286
287 private:
288#if USE(JSVALUE64)
289 static const int minImmediateInt = ((-INT_MAX) - 1);
290 static const int maxImmediateInt = INT_MAX;
291#else
292 static const int minImmediateInt = ((-INT_MAX) - 1) >> IntegerPayloadShift;
293 static const int maxImmediateInt = INT_MAX >> IntegerPayloadShift;
294#endif
295 static const unsigned maxImmediateUInt = maxImmediateInt;
296
297 static ALWAYS_INLINE JSValue makeValue(intptr_t integer)
298 {
299 return JSValue::makeImmediate(integer);
300 }
301
302 // With USE(JSVALUE64) we want the argument to be zero extended, so the
303 // integer doesn't interfere with the tag bits in the upper word. In the default encoding,
304 // if intptr_t id larger then int32_t we sign extend the value through the upper word.
305#if USE(JSVALUE64)
306 static ALWAYS_INLINE JSValue makeInt(uint32_t value)
307#else
308 static ALWAYS_INLINE JSValue makeInt(int32_t value)
309#endif
310 {
311 return makeValue((static_cast<intptr_t>(value) << IntegerPayloadShift) | TagTypeNumber);
312 }
313
314#if USE(JSVALUE64)
315 static ALWAYS_INLINE JSValue makeDouble(double value)
316 {
317 return makeValue(reinterpretDoubleToIntptr(value) + DoubleEncodeOffset);
318 }
319#endif
320
321 static ALWAYS_INLINE JSValue makeBool(bool b)
322 {
323 return makeValue((static_cast<intptr_t>(b) << ExtendedPayloadShift) | FullTagTypeBool);
324 }
325
326 static ALWAYS_INLINE JSValue makeUndefined()
327 {
328 return makeValue(FullTagTypeUndefined);
329 }
330
331 static ALWAYS_INLINE JSValue makeNull()
332 {
333 return makeValue(FullTagTypeNull);
334 }
335
336 template<typename T>
337 static JSValue fromNumberOutsideIntegerRange(T);
338
339#if USE(JSVALUE64)
340 static ALWAYS_INLINE double doubleValue(JSValue v)
341 {
342 return reinterpretIntptrToDouble(rawValue(v) - DoubleEncodeOffset);
343 }
344#endif
345
346 static ALWAYS_INLINE int32_t intValue(JSValue v)
347 {
348 return static_cast<int32_t>(rawValue(v) >> IntegerPayloadShift);
349 }
350
351 static ALWAYS_INLINE uint32_t uintValue(JSValue v)
352 {
353 return static_cast<uint32_t>(rawValue(v) >> IntegerPayloadShift);
354 }
355
356 static ALWAYS_INLINE bool boolValue(JSValue v)
357 {
358 return rawValue(v) & ExtendedPayloadBitBoolValue;
359 }
360
361 static ALWAYS_INLINE intptr_t rawValue(JSValue v)
362 {
363 return v.immediateValue();
364 }
365 };
366
367 ALWAYS_INLINE JSValue JSImmediate::trueImmediate() { return makeBool(true); }
368 ALWAYS_INLINE JSValue JSImmediate::falseImmediate() { return makeBool(false); }
369 ALWAYS_INLINE JSValue JSImmediate::undefinedImmediate() { return makeUndefined(); }
370 ALWAYS_INLINE JSValue JSImmediate::nullImmediate() { return makeNull(); }
371 ALWAYS_INLINE JSValue JSImmediate::zeroImmediate() { return makeInt(0); }
372 ALWAYS_INLINE JSValue JSImmediate::oneImmediate() { return makeInt(1); }
373
374#if USE(JSVALUE64)
375 inline bool doubleToBoolean(double value)
376 {
377 return value < 0.0 || value > 0.0;
378 }
379
380 ALWAYS_INLINE bool JSImmediate::toBoolean(JSValue v)
381 {
382 ASSERT(isImmediate(v));
383 return isNumber(v) ? isIntegerNumber(v) ? v != zeroImmediate()
384 : doubleToBoolean(doubleValue(v)) : v == trueImmediate();
385 }
386#else
387 ALWAYS_INLINE bool JSImmediate::toBoolean(JSValue v)
388 {
389 ASSERT(isImmediate(v));
390 return isIntegerNumber(v) ? v != zeroImmediate() : v == trueImmediate();
391 }
392#endif
393
394 ALWAYS_INLINE uint32_t JSImmediate::getTruncatedUInt32(JSValue v)
395 {
396 // FIXME: should probably be asserting isPositiveIntegerNumber here.
397 ASSERT(isIntegerNumber(v));
398 return intValue(v);
399 }
400
401#if USE(JSVALUE64)
402 template<typename T>
403 inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T value)
404 {
405 return makeDouble(static_cast<double>(value));
406 }
407#else
408 template<typename T>
409 inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T)
410 {
411 return JSValue();
412 }
413#endif
414
415 ALWAYS_INLINE JSValue JSImmediate::from(char i)
416 {
417 return makeInt(i);
418 }
419
420 ALWAYS_INLINE JSValue JSImmediate::from(signed char i)
421 {
422 return makeInt(i);
423 }
424
425 ALWAYS_INLINE JSValue JSImmediate::from(unsigned char i)
426 {
427 return makeInt(i);
428 }
429
430 ALWAYS_INLINE JSValue JSImmediate::from(short i)
431 {
432 return makeInt(i);
433 }
434
435 ALWAYS_INLINE JSValue JSImmediate::from(unsigned short i)
436 {
437 return makeInt(i);
438 }
439
440 ALWAYS_INLINE JSValue JSImmediate::from(int i)
441 {
442#if !USE(JSVALUE64)
443 if ((i < minImmediateInt) | (i > maxImmediateInt))
444 return fromNumberOutsideIntegerRange(i);
445#endif
446 return makeInt(i);
447 }
448
449 ALWAYS_INLINE JSValue JSImmediate::from(unsigned i)
450 {
451 if (i > maxImmediateUInt)
452 return fromNumberOutsideIntegerRange(i);
453 return makeInt(i);
454 }
455
456 ALWAYS_INLINE JSValue JSImmediate::from(long i)
457 {
458 if ((i < minImmediateInt) | (i > maxImmediateInt))
459 return fromNumberOutsideIntegerRange(i);
460 return makeInt(i);
461 }
462
463 ALWAYS_INLINE JSValue JSImmediate::from(unsigned long i)
464 {
465 if (i > maxImmediateUInt)
466 return fromNumberOutsideIntegerRange(i);
467 return makeInt(i);
468 }
469
470 ALWAYS_INLINE JSValue JSImmediate::from(long long i)
471 {
472 if ((i < minImmediateInt) | (i > maxImmediateInt))
473 return JSValue();
474 return makeInt(static_cast<intptr_t>(i));
475 }
476
477 ALWAYS_INLINE JSValue JSImmediate::from(unsigned long long i)
478 {
479 if (i > maxImmediateUInt)
480 return fromNumberOutsideIntegerRange(i);
481 return makeInt(static_cast<intptr_t>(i));
482 }
483
484 ALWAYS_INLINE JSValue JSImmediate::from(double d)
485 {
486 const int intVal = static_cast<int>(d);
487
488 // Check for data loss from conversion to int.
489 if (intVal != d || (!intVal && signbit(d)))
490 return fromNumberOutsideIntegerRange(d);
491
492 return from(intVal);
493 }
494
495 ALWAYS_INLINE int32_t JSImmediate::getTruncatedInt32(JSValue v)
496 {
497 ASSERT(isIntegerNumber(v));
498 return intValue(v);
499 }
500
501 ALWAYS_INLINE double JSImmediate::toDouble(JSValue v)
502 {
503 ASSERT(isImmediate(v));
504
505 if (isIntegerNumber(v))
506 return intValue(v);
507
508#if USE(JSVALUE64)
509 if (isNumber(v)) {
510 ASSERT(isDouble(v));
511 return doubleValue(v);
512 }
513#else
514 ASSERT(!isNumber(v));
515#endif
516
517 if (rawValue(v) == FullTagTypeUndefined)
518 return nonInlineNaN();
519
520 ASSERT(JSImmediate::isBoolean(v) || (v == JSImmediate::nullImmediate()));
521 return rawValue(v) >> ExtendedPayloadShift;
522 }
523
524 ALWAYS_INLINE bool JSImmediate::getUInt32(JSValue v, uint32_t& i)
525 {
526 i = uintValue(v);
527 return isPositiveIntegerNumber(v);
528 }
529
530 ALWAYS_INLINE bool JSImmediate::getTruncatedInt32(JSValue v, int32_t& i)
531 {
532 i = intValue(v);
533 return isIntegerNumber(v);
534 }
535
536 ALWAYS_INLINE bool JSImmediate::getTruncatedUInt32(JSValue v, uint32_t& i)
537 {
538 return getUInt32(v, i);
539 }
540
541 inline JSValue::JSValue(JSNullTag)
542 {
543 *this = JSImmediate::nullImmediate();
544 }
545
546 inline JSValue::JSValue(JSUndefinedTag)
547 {
548 *this = JSImmediate::undefinedImmediate();
549 }
550
551 inline JSValue::JSValue(JSTrueTag)
552 {
553 *this = JSImmediate::trueImmediate();
554 }
555
556 inline JSValue::JSValue(JSFalseTag)
557 {
558 *this = JSImmediate::falseImmediate();
559 }
560
561 inline bool JSValue::isUndefinedOrNull() const
562 {
563 return JSImmediate::isUndefinedOrNull(asValue());
564 }
565
566 inline bool JSValue::isBoolean() const
567 {
568 return JSImmediate::isBoolean(asValue());
569 }
570
571 inline bool JSValue::isTrue() const
572 {
573 return asValue() == JSImmediate::trueImmediate();
574 }
575
576 inline bool JSValue::isFalse() const
577 {
578 return asValue() == JSImmediate::falseImmediate();
579 }
580
581 inline bool JSValue::getBoolean(bool& v) const
582 {
583 if (JSImmediate::isBoolean(asValue())) {
584 v = JSImmediate::toBoolean(asValue());
585 return true;
586 }
587
588 return false;
589 }
590
591 inline bool JSValue::getBoolean() const
592 {
593 return asValue() == jsBoolean(true);
594 }
595
596 inline bool JSValue::isCell() const
597 {
598 return !JSImmediate::isImmediate(asValue());
599 }
600
601 inline bool JSValue::isInt32() const
602 {
603 return JSImmediate::isIntegerNumber(asValue());
604 }
605
606 inline int32_t JSValue::asInt32() const
607 {
608 ASSERT(isInt32());
609 return JSImmediate::getTruncatedInt32(asValue());
610 }
611
612 inline bool JSValue::isUInt32() const
613 {
614 return JSImmediate::isPositiveIntegerNumber(asValue());
615 }
616
617 inline uint32_t JSValue::asUInt32() const
618 {
619 ASSERT(isUInt32());
620 return JSImmediate::getTruncatedUInt32(asValue());
621 }
622
623 class JSFastMath {
624 public:
625 static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValue v1, JSValue v2)
626 {
627 return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
628 }
629
630 static ALWAYS_INLINE JSValue equal(JSValue v1, JSValue v2)
631 {
632 ASSERT(canDoFastBitwiseOperations(v1, v2));
633 return jsBoolean(v1 == v2);
634 }
635
636 static ALWAYS_INLINE JSValue notEqual(JSValue v1, JSValue v2)
637 {
638 ASSERT(canDoFastBitwiseOperations(v1, v2));
639 return jsBoolean(v1 != v2);
640 }
641
642 static ALWAYS_INLINE JSValue andImmediateNumbers(JSValue v1, JSValue v2)
643 {
644 ASSERT(canDoFastBitwiseOperations(v1, v2));
645 return JSImmediate::makeValue(JSImmediate::rawValue(v1) & JSImmediate::rawValue(v2));
646 }
647
648 static ALWAYS_INLINE JSValue xorImmediateNumbers(JSValue v1, JSValue v2)
649 {
650 ASSERT(canDoFastBitwiseOperations(v1, v2));
651 return JSImmediate::makeValue((JSImmediate::rawValue(v1) ^ JSImmediate::rawValue(v2)) | JSImmediate::TagTypeNumber);
652 }
653
654 static ALWAYS_INLINE JSValue orImmediateNumbers(JSValue v1, JSValue v2)
655 {
656 ASSERT(canDoFastBitwiseOperations(v1, v2));
657 return JSImmediate::makeValue(JSImmediate::rawValue(v1) | JSImmediate::rawValue(v2));
658 }
659
660 static ALWAYS_INLINE bool canDoFastRshift(JSValue v1, JSValue v2)
661 {
662 return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
663 }
664
665 static ALWAYS_INLINE bool canDoFastUrshift(JSValue v1, JSValue v2)
666 {
667 return JSImmediate::areBothImmediateIntegerNumbers(v1, v2) && !(JSImmediate::rawValue(v1) & JSImmediate::signBit);
668 }
669
670 static ALWAYS_INLINE JSValue rightShiftImmediateNumbers(JSValue val, JSValue shift)
671 {
672 ASSERT(canDoFastRshift(val, shift) || canDoFastUrshift(val, shift));
673#if USE(JSVALUE64)
674 return JSImmediate::makeValue(static_cast<intptr_t>(static_cast<uint32_t>(static_cast<int32_t>(JSImmediate::rawValue(val)) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f))) | JSImmediate::TagTypeNumber);
675#else
676 return JSImmediate::makeValue((JSImmediate::rawValue(val) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f)) | JSImmediate::TagTypeNumber);
677#endif
678 }
679
680 static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValue v)
681 {
682 // Number is non-negative and an operation involving two of these can't overflow.
683 // Checking for allowed negative numbers takes more time than it's worth on SunSpider.
684 return (JSImmediate::rawValue(v) & (JSImmediate::TagTypeNumber + (JSImmediate::signBit | (JSImmediate::signBit >> 1)))) == JSImmediate::TagTypeNumber;
685 }
686
687 static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValue v1, JSValue v2)
688 {
689 // Number is non-negative and an operation involving two of these can't overflow.
690 // Checking for allowed negative numbers takes more time than it's worth on SunSpider.
691 return canDoFastAdditiveOperations(v1) && canDoFastAdditiveOperations(v2);
692 }
693
694 static ALWAYS_INLINE JSValue addImmediateNumbers(JSValue v1, JSValue v2)
695 {
696 ASSERT(canDoFastAdditiveOperations(v1, v2));
697 return JSImmediate::makeValue(JSImmediate::rawValue(v1) + JSImmediate::rawValue(v2) - JSImmediate::TagTypeNumber);
698 }
699
700 static ALWAYS_INLINE JSValue subImmediateNumbers(JSValue v1, JSValue v2)
701 {
702 ASSERT(canDoFastAdditiveOperations(v1, v2));
703 return JSImmediate::makeValue(JSImmediate::rawValue(v1) - JSImmediate::rawValue(v2) + JSImmediate::TagTypeNumber);
704 }
705
706 static ALWAYS_INLINE JSValue incImmediateNumber(JSValue v)
707 {
708 ASSERT(canDoFastAdditiveOperations(v));
709 return JSImmediate::makeValue(JSImmediate::rawValue(v) + (1 << JSImmediate::IntegerPayloadShift));
710 }
711
712 static ALWAYS_INLINE JSValue decImmediateNumber(JSValue v)
713 {
714 ASSERT(canDoFastAdditiveOperations(v));
715 return JSImmediate::makeValue(JSImmediate::rawValue(v) - (1 << JSImmediate::IntegerPayloadShift));
716 }
717 };
718
719} // namespace JSC
720
721#endif // !USE(JSVALUE32_64)
722
723#endif // JSImmediate_h
Note: See TracBrowser for help on using the repository browser.