298c348cd2b4e5ab5c92c7bb799a30f3ebfa6231
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSBigInt.h
1 /*
2  * Copyright (C) 2017 Caio Lima <ticaiolima@gmail.com>
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "ExceptionHelpers.h"
29 #include "JSObject.h"
30 #include "ParseInt.h"
31 #include <wtf/CagedPtr.h>
32 #include <wtf/text/StringBuilder.h>
33 #include <wtf/text/StringView.h>
34 #include <wtf/text/WTFString.h>
35
36 namespace JSC {
37
38 class JSBigInt final : public JSCell {
39     using Base = JSCell;
40     static const unsigned StructureFlags = Base::StructureFlags | OverridesToThis;
41
42 public:
43
44     JSBigInt(VM&, Structure*, int length);
45
46     enum class InitializationType { None, WithZero };
47     void initialize(InitializationType);
48
49     static void visitChildren(JSCell*, SlotVisitor&);
50
51     static size_t estimatedSize(JSCell*);
52     static size_t allocationSize(int length);
53
54     static Structure* createStructure(VM&, JSGlobalObject*, JSValue prototype);
55
56     static JSBigInt* createZero(VM&);
57     static JSBigInt* createWithLength(VM&, int length);
58
59     static JSBigInt* createFrom(VM&, int32_t value);
60     static JSBigInt* createFrom(VM&, uint32_t value);
61     static JSBigInt* createFrom(VM&, int64_t value);
62     static JSBigInt* createFrom(VM&, bool value);
63
64     DECLARE_EXPORT_INFO;
65
66     void finishCreation(VM&);
67
68     JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
69
70     void setSign(bool sign) { m_sign = sign; }
71     bool sign() const { return m_sign; }
72
73     void setLength(int length) { m_length = length; }
74     int length() const { return m_length; }
75
76     static JSBigInt* parseInt(ExecState*, VM&, StringView, uint8_t radix);
77     static JSBigInt* parseInt(ExecState*, StringView);
78
79     std::optional<uint8_t> singleDigitValueForString();
80     String toString(ExecState&, int radix);
81     
82     JS_EXPORT_PRIVATE static bool equals(JSBigInt*, JSBigInt*);
83
84     bool getPrimitiveNumber(ExecState*, double& number, JSValue& result) const;
85     double toNumber(ExecState*) const;
86
87     JSObject* toObject(ExecState*, JSGlobalObject*) const;
88     
89 private:
90     using Digit = uintptr_t;
91     static constexpr const int bitsPerByte = 8;
92     static constexpr const int digitBits = sizeof(Digit) * bitsPerByte;
93     static constexpr const int halfDigitBits = digitBits / 2;
94     static constexpr const Digit halfDigitMask = (1ull << halfDigitBits) - 1;
95     static constexpr const int maxInt = 0x7FFFFFFF;
96     
97     // The maximum length that the current implementation supports would be
98     // maxInt / digitBits. However, we use a lower limit for now, because
99     // raising it later is easier than lowering it.
100     // Support up to 1 million bits.
101     static const int maxLength = 1024 * 1024 / (sizeof(void*) * bitsPerByte);
102     
103     static uint64_t calculateMaximumCharactersRequired(int length, int radix, Digit lastDigit, bool sign);
104     
105     static void absoluteDivSmall(ExecState&, JSBigInt* x, Digit divisor, JSBigInt** quotient, Digit& remainder);
106     static void internalMultiplyAdd(JSBigInt* source, Digit factor, Digit summand, int, JSBigInt* result);
107
108     // Digit arithmetic helpers.
109     static Digit digitAdd(Digit a, Digit b, Digit& carry);
110     static Digit digitSub(Digit a, Digit b, Digit& borrow);
111     static Digit digitMul(Digit a, Digit b, Digit& high);
112     static Digit digitDiv(Digit high, Digit low, Digit divisor, Digit& remainder);
113     static Digit digitPow(Digit base, Digit exponent);
114
115     static String toStringGeneric(ExecState&, JSBigInt*, int radix);
116
117     bool isZero();
118
119     template <typename CharType>
120     static JSBigInt* parseInt(ExecState*, CharType*  data, int length);
121
122     template <typename CharType>
123     static JSBigInt* parseInt(ExecState*, VM&, CharType* data, int length, int startIndex, int radix, bool allowEmptyString = true);
124
125     static JSBigInt* allocateFor(ExecState*, VM&, int radix, int charcount);
126
127     JSBigInt* rightTrim(VM&);
128
129     void inplaceMultiplyAdd(Digit multiplier, Digit part);
130     
131     static size_t offsetOfData();
132     Digit* dataStorage();
133
134     Digit digit(int);
135     void setDigit(int, Digit);
136         
137     int m_length;
138     bool m_sign;
139 };
140
141 inline JSBigInt* asBigInt(JSValue value)
142 {
143     ASSERT(value.asCell()->isBigInt());
144     return jsCast<JSBigInt*>(value.asCell());
145 }
146
147 } // namespace JSC