[JSC] NumberPrototype::extractRadixFromArgs incorrectly cast double to int32_t
[WebKit-https.git] / Source / JavaScriptCore / runtime / BigIntPrototype.cpp
1 /*
2  * Copyright (C) 2017 Caio Lima <ticaiolima@gmail.com>.
3  * Copyright (C) 2017 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28 #include "BigIntPrototype.h"
29
30 #include "Error.h"
31 #include "JSBigInt.h"
32 #include "JSCBuiltins.h"
33 #include "JSCInlines.h"
34 #include "JSCell.h"
35 #include "JSFunction.h"
36 #include "JSGlobalObject.h"
37 #include "JSString.h"
38 #include "NumberPrototype.h"
39 #include <wtf/Assertions.h>
40 #include <wtf/Variant.h>
41
42 namespace JSC {
43
44 static EncodedJSValue JSC_HOST_CALL bigIntProtoFuncToString(ExecState*);
45 static EncodedJSValue JSC_HOST_CALL bigIntProtoFuncToLocaleString(ExecState*);
46 static EncodedJSValue JSC_HOST_CALL bigIntProtoFuncValueOf(ExecState*);
47
48 }
49
50 #include "BigIntPrototype.lut.h"
51
52 namespace JSC {
53
54 const ClassInfo BigIntPrototype::s_info = { "BigInt", &Base::s_info, &bigIntPrototypeTable, nullptr, CREATE_METHOD_TABLE(BigIntPrototype) };
55
56 /* Source for BigIntPrototype.lut.h
57 @begin bigIntPrototypeTable
58   toString          bigIntProtoFuncToString         DontEnum|Function 0
59   toLocaleString    bigIntProtoFuncToLocaleString   DontEnum|Function 0
60   valueOf           bigIntProtoFuncValueOf          DontEnum|Function 0
61 @end
62 */
63
64 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(BigIntPrototype);
65
66 BigIntPrototype::BigIntPrototype(VM& vm, Structure* structure)
67     : JSNonFinalObject(vm, structure)
68 {
69 }
70
71 void BigIntPrototype::finishCreation(VM& vm, JSGlobalObject*)
72 {
73     Base::finishCreation(vm);
74     ASSERT(inherits(vm, info()));
75     putDirectWithoutTransition(vm, vm.propertyNames->toStringTagSymbol, jsString(&vm, "BigInt"), PropertyAttribute::DontEnum | PropertyAttribute::ReadOnly);
76 }
77
78 // ------------------------------ Functions ---------------------------
79
80 static ALWAYS_INLINE JSBigInt* toThisBigIntValue(VM& vm, JSValue thisValue)
81 {
82     if (thisValue.isCell()) {
83         if (JSBigInt* bigInt = jsDynamicCast<JSBigInt*>(vm, thisValue.asCell()))
84             return bigInt;
85         
86         if (BigIntObject* bigIntObject = jsDynamicCast<BigIntObject*>(vm, thisValue.asCell()))
87             return bigIntObject->internalValue();
88     }
89
90     return nullptr;
91 }
92
93 EncodedJSValue JSC_HOST_CALL bigIntProtoFuncToString(ExecState* state)
94 {
95     VM& vm = state->vm();
96     auto scope = DECLARE_THROW_SCOPE(vm);
97
98     JSBigInt* value = toThisBigIntValue(vm, state->thisValue());
99     if (!value)
100         return throwVMTypeError(state, scope, ASCIILiteral("'this' value must be a BigInt or BigIntObject"));
101     
102     ASSERT(value);
103
104     auto radix = extractToStringRadixArgument(state, state->argument(0));
105     if (WTF::holds_alternative<EncodedJSValue>(radix))
106         return WTF::get<EncodedJSValue>(radix);
107
108     String resultString = value->toString(*state, WTF::get<int32_t>(radix));
109     RETURN_IF_EXCEPTION(scope, encodedJSValue());
110     if (resultString.length() == 1)
111         return JSValue::encode(vm.smallStrings.singleCharacterString(resultString[0]));
112
113     scope.release();
114     return JSValue::encode(jsNontrivialString(&vm, resultString));
115 }
116
117 EncodedJSValue JSC_HOST_CALL bigIntProtoFuncToLocaleString(ExecState* state)
118 {
119     return bigIntProtoFuncToString(state);
120 }
121
122 EncodedJSValue JSC_HOST_CALL bigIntProtoFuncValueOf(ExecState* state)
123 {
124     VM& vm = state->vm();
125     if (JSBigInt* value = toThisBigIntValue(vm, state->thisValue()))
126         return JSValue::encode(value);
127     
128     auto scope = DECLARE_THROW_SCOPE(vm);
129     return throwVMTypeError(state, scope, ASCIILiteral("'this' value must be a BigInt or BigIntObject"));
130 }
131
132 } // namespace JSC