Changeset 225799 in webkit

Timestamp:

Dec 12, 2017 1:01:57 PM (6 years ago)

Author:

Caio Lima

Message:

[ESNext][BigInt] Implement BigInt literals and JSBigInt
​https://bugs.webkit.org/show_bug.cgi?id=179000

Reviewed by Darin Adler and Yusuke Suzuki.

JSTests:

• bigIntTests.yaml: Added.
• stress/big-int-literal-line-terminator.js: Added.
• stress/big-int-literals.js: Added.
• stress/big-int-operations-error.js: Added.
• stress/big-int-type-of.js: Added.
• stress/big-int-white-space-trailing-leading.js: Added.
• stress/big-int-function-apply.js: Added.

Source/JavaScriptCore:

This patch starts the implementation of BigInt primitive on
JavaScriptCore. We are introducing BigInt primitive and
implementing it on JSBigInt as a subclass of JSCell with BigIntData?
field implemented contiguosly on memory as inline storage of JSBigInt to
take advantages on performance due to cache locality. The
implementation allows 64 or 32 bitwise arithmetic operations.
JSBigInt also has m_sign to store the sign of BigIntData? and
m_length that keeps track of BigInt length.
The implementation is following the V8 one. BigIntData? is manipulated
by JSBigInt::setDigit(index, value) and JSBigInt::digit(index) operations.
We also have some operations to support arithmetics over digits.

It is important to notice that on our representation,
JSBigInt::dataStorage()[0] represents the least significant digit and
JSBigInt::dataStorage()[m_length - 1] represents the most siginificant digit.

We are also introducing into this Patch the BigInt literals lexer and
syntax parsing support. The operation Strict Equals on BigInts is also being
implemented to enable tests.
These features are being implemented behind a runtime flage "--useBigInt" and
are disabled by default.

• JavaScriptCore.xcodeproj/project.pbxproj:
• Sources.txt:
• bytecode/CodeBlock.cpp:
• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::emitEqualityOp):
(JSC::BytecodeGenerator::addBigIntConstant):

• bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::BigIntEntryHash::hash):
(JSC::BytecodeGenerator::BigIntEntryHash::equal):

• bytecompiler/NodesCodegen.cpp:

(JSC::BigIntNode::jsValue const):

• dfg/DFGAbstractInterpreterInlines.h:

(JSC::DFG::isToThisAnIdentity):

• interpreter/Interpreter.cpp:

(JSC::sizeOfVarargs):

• llint/LLIntData.cpp:

(JSC::LLInt::Data::performAssertions):

• llint/LowLevelInterpreter.asm:
• parser/ASTBuilder.h:

(JSC::ASTBuilder::createBigInt):

• parser/Lexer.cpp:

(JSC::Lexer<T>::parseBinary):
(JSC::Lexer<T>::parseOctal):
(JSC::Lexer<T>::parseDecimal):
(JSC::Lexer<T>::lex):
(JSC::Lexer<T>::parseHex): Deleted.

• parser/Lexer.h:
• parser/NodeConstructors.h:

(JSC::BigIntNode::BigIntNode):

• parser/Nodes.h:

(JSC::ExpressionNode::isBigInt const):
(JSC::BigIntNode::value):

• parser/Parser.cpp:

(JSC::Parser<LexerType>::parsePrimaryExpression):

• parser/ParserTokens.h:
• parser/ResultType.h:

(JSC::ResultType::definitelyIsBigInt const):
(JSC::ResultType::mightBeBigInt const):
(JSC::ResultType::isNotBigInt const):
(JSC::ResultType::addResultType):
(JSC::ResultType::bigIntType):
(JSC::ResultType::forAdd):
(JSC::ResultType::forLogicalOp):

• parser/SyntaxChecker.h:

(JSC::SyntaxChecker::createBigInt):

• runtime/CommonIdentifiers.h:
• runtime/JSBigInt.cpp: Added.

(JSC::JSBigInt::visitChildren):
(JSC::JSBigInt::JSBigInt):
(JSC::JSBigInt::initialize):
(JSC::JSBigInt::createStructure):
(JSC::JSBigInt::createZero):
(JSC::JSBigInt::allocationSize):
(JSC::JSBigInt::createWithLength):
(JSC::JSBigInt::finishCreation):
(JSC::JSBigInt::toPrimitive const):
(JSC::JSBigInt::singleDigitValueForString):
(JSC::JSBigInt::parseInt):
(JSC::JSBigInt::toString):
(JSC::JSBigInt::isZero):
(JSC::JSBigInt::inplaceMultiplyAdd):
(JSC::JSBigInt::digitAdd):
(JSC::JSBigInt::digitSub):
(JSC::JSBigInt::digitMul):
(JSC::JSBigInt::digitPow):
(JSC::JSBigInt::digitDiv):
(JSC::JSBigInt::internalMultiplyAdd):
(JSC::JSBigInt::equalToBigInt):
(JSC::JSBigInt::absoluteDivSmall):
(JSC::JSBigInt::calculateMaximumCharactersRequired):
(JSC::JSBigInt::toStringGeneric):
(JSC::JSBigInt::rightTrim):
(JSC::JSBigInt::allocateFor):
(JSC::JSBigInt::estimatedSize):
(JSC::JSBigInt::toNumber const):
(JSC::JSBigInt::getPrimitiveNumber const):

• runtime/JSBigInt.h: Added.

(JSC::JSBigInt::setSign):
(JSC::JSBigInt::sign const):
(JSC::JSBigInt::setLength):
(JSC::JSBigInt::length const):
(JSC::JSBigInt::parseInt):
(JSC::JSBigInt::offsetOfData):
(JSC::JSBigInt::dataStorage):
(JSC::JSBigInt::digit):
(JSC::JSBigInt::setDigit):
(JSC::asBigInt):

• runtime/JSCJSValue.cpp:

(JSC::JSValue::synthesizePrototype const):
(JSC::JSValue::toStringSlowCase const):

• runtime/JSCJSValue.h:
• runtime/JSCJSValueInlines.h:

(JSC::JSValue::isBigInt const):
(JSC::JSValue::strictEqualSlowCaseInline):

• runtime/JSCell.cpp:

(JSC::JSCell::put):
(JSC::JSCell::putByIndex):
(JSC::JSCell::toPrimitive const):
(JSC::JSCell::getPrimitiveNumber const):
(JSC::JSCell::toNumber const):
(JSC::JSCell::toObjectSlow const):

• runtime/JSCell.h:
• runtime/JSCellInlines.h:

(JSC::JSCell::isBigInt const):

• runtime/JSType.h:
• runtime/MathCommon.h:

(JSC::clz64):

• runtime/NumberPrototype.cpp:
• runtime/Operations.cpp:

(JSC::jsTypeStringForValue):
(JSC::jsIsObjectTypeOrNull):

• runtime/Options.h:
• runtime/ParseInt.h:
• runtime/SmallStrings.h:

(JSC::SmallStrings::typeString const):

• runtime/StructureInlines.h:

(JSC::prototypeForLookupPrimitiveImpl):

• runtime/TypeofType.cpp:

(WTF::printInternal):

• runtime/TypeofType.h:
• runtime/VM.cpp:

(JSC::VM::VM):

• runtime/VM.h:

Source/WTF:

• wtf/HashFunctions.h:

Tools:

• Scripts/run-jsc-stress-tests:

Location:

trunk

Files:

• JSTests/ChangeLog (modified) (1 diff)
• JSTests/bigIntTests.yaml (added)
• JSTests/stress/big-int-function-apply.js (added)
• JSTests/stress/big-int-literal-line-terminator.js (added)
• JSTests/stress/big-int-literals.js (added)
• JSTests/stress/big-int-operations-error.js (added)
• JSTests/stress/big-int-type-of.js (added)
• JSTests/stress/big-int-white-space-trailing-leading.js (added)
• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj (modified) (38 diffs)
• Source/JavaScriptCore/Sources.txt (modified) (1 diff)
• Source/JavaScriptCore/bytecode/CodeBlock.cpp (modified) (1 diff)
• Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp (modified) (3 diffs)
• Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h (modified) (5 diffs)
• Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp (modified) (1 diff)
• Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h (modified) (1 diff)
• Source/JavaScriptCore/interpreter/Interpreter.cpp (modified) (1 diff)
• Source/JavaScriptCore/llint/LLIntData.cpp (modified) (4 diffs)
• Source/JavaScriptCore/llint/LowLevelInterpreter.asm (modified) (1 diff)
• Source/JavaScriptCore/parser/ASTBuilder.h (modified) (1 diff)
• Source/JavaScriptCore/parser/Lexer.cpp (modified) (19 diffs)
• Source/JavaScriptCore/parser/Lexer.h (modified) (1 diff)
• Source/JavaScriptCore/parser/NodeConstructors.h (modified) (1 diff)
• Source/JavaScriptCore/parser/Nodes.h (modified) (2 diffs)
• Source/JavaScriptCore/parser/Parser.cpp (modified) (1 diff)
• Source/JavaScriptCore/parser/ParserTokens.h (modified) (2 diffs)
• Source/JavaScriptCore/parser/ResultType.h (modified) (7 diffs)
• Source/JavaScriptCore/parser/SyntaxChecker.h (modified) (2 diffs)
• Source/JavaScriptCore/runtime/CommonIdentifiers.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/JSBigInt.cpp (added)
• Source/JavaScriptCore/runtime/JSBigInt.h (added)
• Source/JavaScriptCore/runtime/JSCJSValue.cpp (modified) (3 diffs)
• Source/JavaScriptCore/runtime/JSCJSValue.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/JSCJSValueInlines.h (modified) (3 diffs)
• Source/JavaScriptCore/runtime/JSCell.cpp (modified) (6 diffs)
• Source/JavaScriptCore/runtime/JSCell.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/JSCellInlines.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/JSModuleRecord.cpp (modified) (1 diff)
• Source/JavaScriptCore/runtime/JSType.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/MathCommon.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/NumberPrototype.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/Operations.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/Options.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/ParseInt.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/SmallStrings.h (modified) (2 diffs)
• Source/JavaScriptCore/runtime/Structure.cpp (modified) (1 diff)
• Source/JavaScriptCore/runtime/StructureInlines.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/TypeofType.cpp (modified) (1 diff)
• Source/JavaScriptCore/runtime/TypeofType.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/VM.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/VM.h (modified) (1 diff)
• Source/WTF/ChangeLog (modified) (1 diff)
• Source/WTF/wtf/HashFunctions.h (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/Scripts/run-jsc-stress-tests (modified) (1 diff)

trunk/JSTests/ChangeLog

@@ +1 @@
+2017-12-12  Caio Lima  <ticaiolima@gmail.com>
+
+        [ESNext][BigInt] Implement BigInt literals and JSBigInt
+        https://bugs.webkit.org/show_bug.cgi?id=179000
+
+        Reviewed by Darin Adler and Yusuke Suzuki.
+
+        * bigIntTests.yaml: Added.
+        * stress/big-int-literal-line-terminator.js: Added.
+        * stress/big-int-literals.js: Added.
+        * stress/big-int-operations-error.js: Added.
+        * stress/big-int-type-of.js: Added.
+        * stress/big-int-white-space-trailing-leading.js: Added.
+        * stress/big-int-function-apply.js: Added.
+
 2017-12-11  Saam Barati  <sbarati@apple.com>
 

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2017-12-12  Caio Lima  <ticaiolima@gmail.com>
+
+        [ESNext][BigInt] Implement BigInt literals and JSBigInt
+        https://bugs.webkit.org/show_bug.cgi?id=179000
+
+        Reviewed by Darin Adler and Yusuke Suzuki.
+
+        This patch starts the implementation of BigInt primitive on
+        JavaScriptCore. We are introducing BigInt primitive and
+        implementing it on JSBigInt as a subclass of JSCell with [[BigIntData]]
+        field implemented contiguosly on memory as inline storage of JSBigInt to
+        take advantages on performance due to cache locality. The
+        implementation allows 64 or 32 bitwise arithmetic operations.
+        JSBigInt also has m_sign to store the sign of [[BigIntData]] and
+        m_length that keeps track of BigInt length.
+        The implementation is following the V8 one. [[BigIntData]] is manipulated
+        by JSBigInt::setDigit(index, value) and JSBigInt::digit(index) operations.
+        We also have some operations to support arithmetics over digits.
+
+        It is important to notice that on our representation,
+        JSBigInt::dataStorage()[0] represents the least significant digit and
+        JSBigInt::dataStorage()[m_length - 1] represents the most siginificant digit.
+
+        We are also introducing into this Patch the BigInt literals lexer and
+        syntax parsing support. The operation Strict Equals on BigInts is also being
+        implemented to enable tests.
+        These features are being implemented behind a runtime flage "--useBigInt" and
+        are disabled by default.
+
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * Sources.txt:
+        * bytecode/CodeBlock.cpp:
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::emitEqualityOp):
+        (JSC::BytecodeGenerator::addBigIntConstant):
+        * bytecompiler/BytecodeGenerator.h:
+        (JSC::BytecodeGenerator::BigIntEntryHash::hash):
+        (JSC::BytecodeGenerator::BigIntEntryHash::equal):
+        * bytecompiler/NodesCodegen.cpp:
+        (JSC::BigIntNode::jsValue const):
+        * dfg/DFGAbstractInterpreterInlines.h:
+        (JSC::DFG::isToThisAnIdentity):
+        * interpreter/Interpreter.cpp:
+        (JSC::sizeOfVarargs):
+        * llint/LLIntData.cpp:
+        (JSC::LLInt::Data::performAssertions):
+        * llint/LowLevelInterpreter.asm:
+        * parser/ASTBuilder.h:
+        (JSC::ASTBuilder::createBigInt):
+        * parser/Lexer.cpp:
+        (JSC::Lexer<T>::parseBinary):
+        (JSC::Lexer<T>::parseOctal):
+        (JSC::Lexer<T>::parseDecimal):
+        (JSC::Lexer<T>::lex):
+        (JSC::Lexer<T>::parseHex): Deleted.
+        * parser/Lexer.h:
+        * parser/NodeConstructors.h:
+        (JSC::BigIntNode::BigIntNode):
+        * parser/Nodes.h:
+        (JSC::ExpressionNode::isBigInt const):
+        (JSC::BigIntNode::value):
+        * parser/Parser.cpp:
+        (JSC::Parser<LexerType>::parsePrimaryExpression):
+        * parser/ParserTokens.h:
+        * parser/ResultType.h:
+        (JSC::ResultType::definitelyIsBigInt const):
+        (JSC::ResultType::mightBeBigInt const):
+        (JSC::ResultType::isNotBigInt const):
+        (JSC::ResultType::addResultType):
+        (JSC::ResultType::bigIntType):
+        (JSC::ResultType::forAdd):
+        (JSC::ResultType::forLogicalOp):
+        * parser/SyntaxChecker.h:
+        (JSC::SyntaxChecker::createBigInt):
+        * runtime/CommonIdentifiers.h:
+        * runtime/JSBigInt.cpp: Added.
+        (JSC::JSBigInt::visitChildren):
+        (JSC::JSBigInt::JSBigInt):
+        (JSC::JSBigInt::initialize):
+        (JSC::JSBigInt::createStructure):
+        (JSC::JSBigInt::createZero):
+        (JSC::JSBigInt::allocationSize):
+        (JSC::JSBigInt::createWithLength):
+        (JSC::JSBigInt::finishCreation):
+        (JSC::JSBigInt::toPrimitive const):
+        (JSC::JSBigInt::singleDigitValueForString):
+        (JSC::JSBigInt::parseInt):
+        (JSC::JSBigInt::toString):
+        (JSC::JSBigInt::isZero):
+        (JSC::JSBigInt::inplaceMultiplyAdd):
+        (JSC::JSBigInt::digitAdd):
+        (JSC::JSBigInt::digitSub):
+        (JSC::JSBigInt::digitMul):
+        (JSC::JSBigInt::digitPow):
+        (JSC::JSBigInt::digitDiv):
+        (JSC::JSBigInt::internalMultiplyAdd):
+        (JSC::JSBigInt::equalToBigInt):
+        (JSC::JSBigInt::absoluteDivSmall):
+        (JSC::JSBigInt::calculateMaximumCharactersRequired):
+        (JSC::JSBigInt::toStringGeneric):
+        (JSC::JSBigInt::rightTrim):
+        (JSC::JSBigInt::allocateFor):
+        (JSC::JSBigInt::estimatedSize):
+        (JSC::JSBigInt::toNumber const):
+        (JSC::JSBigInt::getPrimitiveNumber const):
+        * runtime/JSBigInt.h: Added.
+        (JSC::JSBigInt::setSign):
+        (JSC::JSBigInt::sign const):
+        (JSC::JSBigInt::setLength):
+        (JSC::JSBigInt::length const):
+        (JSC::JSBigInt::parseInt):
+        (JSC::JSBigInt::offsetOfData):
+        (JSC::JSBigInt::dataStorage):
+        (JSC::JSBigInt::digit):
+        (JSC::JSBigInt::setDigit):
+        (JSC::asBigInt):
+        * runtime/JSCJSValue.cpp:
+        (JSC::JSValue::synthesizePrototype const):
+        (JSC::JSValue::toStringSlowCase const):
+        * runtime/JSCJSValue.h:
+        * runtime/JSCJSValueInlines.h:
+        (JSC::JSValue::isBigInt const):
+        (JSC::JSValue::strictEqualSlowCaseInline):
+        * runtime/JSCell.cpp:
+        (JSC::JSCell::put):
+        (JSC::JSCell::putByIndex):
+        (JSC::JSCell::toPrimitive const):
+        (JSC::JSCell::getPrimitiveNumber const):
+        (JSC::JSCell::toNumber const):
+        (JSC::JSCell::toObjectSlow const):
+        * runtime/JSCell.h:
+        * runtime/JSCellInlines.h:
+        (JSC::JSCell::isBigInt const):
+        * runtime/JSType.h:
+        * runtime/MathCommon.h:
+        (JSC::clz64):
+        * runtime/NumberPrototype.cpp:
+        * runtime/Operations.cpp:
+        (JSC::jsTypeStringForValue):
+        (JSC::jsIsObjectTypeOrNull):
+        * runtime/Options.h:
+        * runtime/ParseInt.h:
+        * runtime/SmallStrings.h:
+        (JSC::SmallStrings::typeString const):
+        * runtime/StructureInlines.h:
+        (JSC::prototypeForLookupPrimitiveImpl):
+        * runtime/TypeofType.cpp:
+        (WTF::printInternal):
+        * runtime/TypeofType.h:
+        * runtime/VM.cpp:
+        (JSC::VM::VM):
+        * runtime/VM.h:
+
 2017-12-12  Guillaume Emont  <guijemont@igalia.com>
 

trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

@@ -806 +806 @@
                 2D342F36F7244096804ADB24 /* SourceOrigin.h in Headers */ = {isa = PBXBuildFile; fileRef = 425BA1337E4344E1B269A671 /* SourceOrigin.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 371D842D17C98B6E00ECF994 /* libz.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 371D842C17C98B6E00ECF994 /* libz.dylib */; };
-                37C738D21EDB56E4003F2B0B /* ParseInt.h in Headers */ = {isa = PBXBuildFile; fileRef = 37C738D11EDB5672003F2B0B /* ParseInt.h */; };
+                37C738D21EDB56E4003F2B0B /* ParseInt.h in Headers */ = {isa = PBXBuildFile; fileRef = 37C738D11EDB5672003F2B0B /* ParseInt.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 412952771D2CF6BC00E78B89 /* builtins_generate_internals_wrapper_header.py in Headers */ = {isa = PBXBuildFile; fileRef = 412952731D2CF6AC00E78B89 /* builtins_generate_internals_wrapper_header.py */; settings = {ATTRIBUTES = (Private, ); }; };
                 412952781D2CF6BC00E78B89 /* builtins_generate_internals_wrapper_implementation.py in Headers */ = {isa = PBXBuildFile; fileRef = 412952741D2CF6AC00E78B89 /* builtins_generate_internals_wrapper_implementation.py */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -1143 +1143 @@
                 86704B8A12DBA33700A9FE7B /* YarrPattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 86704B8312DBA33700A9FE7B /* YarrPattern.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 868916B0155F286300CB2B9A /* PrivateName.h in Headers */ = {isa = PBXBuildFile; fileRef = 868916A9155F285400CB2B9A /* PrivateName.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                868921C21F9C0CB7001159F6 /* JSBigInt.h in Headers */ = {isa = PBXBuildFile; fileRef = 868921C11F9C0CB7001159F6 /* JSBigInt.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 869EBCB70E8C6D4A008722CC /* ResultType.h in Headers */ = {isa = PBXBuildFile; fileRef = 869EBCB60E8C6D4A008722CC /* ResultType.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 86ADD1450FDDEA980006EEC2 /* ARMv7Assembler.h in Headers */ = {isa = PBXBuildFile; fileRef = 86ADD1430FDDEA980006EEC2 /* ARMv7Assembler.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -3679 +3680 @@
                 86880F4C14353B2100B08D42 /* DFGSpeculativeJIT64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGSpeculativeJIT64.cpp; path = dfg/DFGSpeculativeJIT64.cpp; sourceTree = "<group>"; };
                 868916A9155F285400CB2B9A /* PrivateName.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PrivateName.h; sourceTree = "<group>"; };
+                868921C11F9C0CB7001159F6 /* JSBigInt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSBigInt.h; sourceTree = "<group>"; };
+                868921C31F9C2947001159F6 /* JSBigInt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSBigInt.cpp; sourceTree = "<group>"; };
                 869EBCB60E8C6D4A008722CC /* ResultType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResultType.h; sourceTree = "<group>"; };
                 86A054461556451B00445157 /* LowLevelInterpreter.asm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.asm.asm; name = LowLevelInterpreter.asm; path = llint/LowLevelInterpreter.asm; sourceTree = "<group>"; };
@@ -6495 +6498 @@
                                 E35E035D1B7AB43E0073AD2A /* InspectorInstrumentationObject.cpp */,
                                 E35E035E1B7AB43E0073AD2A /* InspectorInstrumentationObject.h */,
-                                A7A8AF2B17ADB5F3005AB174 /* Int8Array.h */,
                                 A7A8AF2C17ADB5F3005AB174 /* Int16Array.h */,
                                 A7A8AF2D17ADB5F3005AB174 /* Int32Array.h */,
+                                A7A8AF2B17ADB5F3005AB174 /* Int8Array.h */,
                                 BC9BB95B0E19680600DF8855 /* InternalFunction.cpp */,
                                 BC11667A0E199C05008066DD /* InternalFunction.h */,
@@ -6545 +6548 @@
                                 8BC064871E1A583F00B2B8CA /* JSAsyncGeneratorFunction.cpp */,
                                 8BC064881E1A584000B2B8CA /* JSAsyncGeneratorFunction.h */,
+                                868921C31F9C2947001159F6 /* JSBigInt.cpp */,
+                                868921C11F9C0CB7001159F6 /* JSBigInt.h */,
                                 86FA9E8F142BBB2D001773B7 /* JSBoundFunction.cpp */,
                                 86FA9E90142BBB2E001773B7 /* JSBoundFunction.h */,
@@ -6596 +6601 @@
                                 BC756FC70E2031B200DE7D12 /* JSGlobalObjectFunctions.h */,
                                 79B819921DD25CF500DDC714 /* JSGlobalObjectInlines.h */,
-                                0F2B66C917B6B5AB00A7AE3F /* JSInt8Array.h */,
                                 0F2B66CA17B6B5AB00A7AE3F /* JSInt16Array.h */,
                                 0F2B66CB17B6B5AB00A7AE3F /* JSInt32Array.h */,
+                                0F2B66C917B6B5AB00A7AE3F /* JSInt8Array.h */,
                                 E33F507E1B8429A400413856 /* JSInternalPromise.cpp */,
                                 E33F507F1B8429A400413856 /* JSInternalPromise.h */,
@@ -6687 +6692 @@
                                 53917E7C1B791106000EBD33 /* JSTypedArrayViewPrototype.h */,
                                 6507D2970E871E4A00D7D896 /* JSTypeInfo.h */,
+                                0F2B66D417B6B5AB00A7AE3F /* JSUint16Array.h */,
+                                0F2B66D517B6B5AB00A7AE3F /* JSUint32Array.h */,
                                 0F2B66D217B6B5AB00A7AE3F /* JSUint8Array.h */,
                                 0F2B66D317B6B5AB00A7AE3F /* JSUint8ClampedArray.h */,
-                                0F2B66D417B6B5AB00A7AE3F /* JSUint16Array.h */,
-                                0F2B66D517B6B5AB00A7AE3F /* JSUint32Array.h */,
                                 A7CA3AE117DA41AE006538AF /* JSWeakMap.cpp */,
                                 A7CA3AE217DA41AE006538AF /* JSWeakMap.h */,
@@ -6904 +6909 @@
                                 0F2D4DE319832D91007D4B19 /* TypeSet.cpp */,
                                 0F2D4DE419832D91007D4B19 /* TypeSet.h */,
-                                A7A8AF3017ADB5F3005AB174 /* Uint8Array.h */,
-                                A7A8AF3117ADB5F3005AB174 /* Uint8ClampedArray.h */,
                                 A7A8AF3217ADB5F3005AB174 /* Uint16Array.h */,
                                 866739D113BFDE710023D87C /* Uint16WithFraction.h */,
                                 A7A8AF3317ADB5F3005AB174 /* Uint32Array.h */,
+                                A7A8AF3017ADB5F3005AB174 /* Uint8Array.h */,
+                                A7A8AF3117ADB5F3005AB174 /* Uint8ClampedArray.h */,
                                 0FE050231AA9095600D33B33 /* VarOffset.cpp */,
                                 0FE050241AA9095600D33B33 /* VarOffset.h */,
@@ -8040 +8045 @@
                                 0F5CF9891E9ED65200C18692 /* AirStackAllocation.h in Headers */,
                                 0FEC858C1BDACDC70080FF74 /* AirStackSlot.h in Headers */,
-                                0F41545B1FD20B22001B58F6 /* ConstraintConcurrency.h in Headers */,
                                 0F2BBD9E1C5FF4050023EF23 /* AirStackSlotKind.h in Headers */,
                                 0FEC858E1BDACDC70080FF74 /* AirTmp.h in Headers */,
@@ -8051 +8055 @@
                                 0FEC3C531F33A41600F59B6C /* AlignedMemoryAllocator.h in Headers */,
                                 0FA7620B1DB959F900B7A2FD /* AllocatingScope.h in Headers */,
+                                0FDCE11C1FAE6209006F3901 /* AllocationFailureMode.h in Headers */,
                                 0F96303A1D4192C8005609D9 /* AllocatorAttributes.h in Headers */,
+                                0F30CB5E1FCE4E37004B5323 /* AllocatorForMode.h in Headers */,
                                 0F3730911C0CD70C00052BFA /* AllowMacroScratchRegisterUsage.h in Headers */,
                                 A5EA70E919F5B1010098F5EC /* AlternateDispatchableAgent.h in Headers */,
@@ -8059 +8065 @@
                                 BCF605140E203EF800B9A64D /* ArgList.h in Headers */,
                                 0FE050141AA9091100D33B33 /* ArgumentsMode.h in Headers */,
-                                0FBF92BA1FD7700400AC28A8 /* InferredStructureWatchpoint.h in Headers */,
                                 79A228361D35D71F00D8E067 /* ArithProfile.h in Headers */,
                                 0F6B1CB91861244C00845D97 /* ArityCheckMode.h in Headers */,
@@ -8066 +8071 @@
                                 86ADD1450FDDEA980006EEC2 /* ARMv7Assembler.h in Headers */,
                                 65C0285D1717966800351E35 /* ARMv7DOpcode.h in Headers */,
-                                0FDCE1321FB11DA4006F3901 /* IsoAlignedMemoryAllocator.h in Headers */,
                                 0F8335B81639C1EA001443B5 /* ArrayAllocationProfile.h in Headers */,
                                 A7A8AF3517ADB5F3005AB174 /* ArrayBuffer.h in Headers */,
@@ -8116 +8120 @@
                                 0F33FCFB1C1625BE00323F67 /* B3CFG.h in Headers */,
                                 0FEC85061BDACDAC0080FF74 /* B3CheckSpecial.h in Headers */,
-                                FE2B0B731FD9EF700075DA5F /* JSCPoison.h in Headers */,
                                 0FEC85081BDACDAC0080FF74 /* B3CheckValue.h in Headers */,
                                 0FEC850A1BDACDAC0080FF74 /* B3Common.h in Headers */,
-                                0FDCE12D1FAFB4E5006F3901 /* IsoSubspace.h in Headers */,
                                 0FEC850C1BDACDAC0080FF74 /* B3Commutativity.h in Headers */,
                                 0F338E0C1BF0276C0013C88F /* B3Compilation.h in Headers */,
@@ -8171 +8173 @@
                                 0F37308D1C0BD29100052BFA /* B3PhiChildren.h in Headers */,
                                 0FEC852C1BDACDAC0080FF74 /* B3Procedure.h in Headers */,
-                                FE2B0B691FD227E00075DA5F /* JSCPoisonedPtr.h in Headers */,
                                 0FEC852D1BDACDAC0080FF74 /* B3ProcedureInlines.h in Headers */,
                                 0F725CAA1C503DED00AD943A /* B3PureCSE.h in Headers */,
@@ -8244 +8245 @@
                                 0F885E111849A3BE00F1E3FA /* BytecodeUseDef.h in Headers */,
                                 0F8023EA1613832B00A0BA45 /* ByValInfo.h in Headers */,
-                                0F4D8C751FC7A97D001D32AC /* ConstraintParallelism.h in Headers */,
                                 65B8392E1BACAD360044E824 /* CachedRecovery.h in Headers */,
                                 0FEC3C601F379F5300F59B6C /* CagedBarrierPtr.h in Headers */,
@@ -8289 +8289 @@
                                 0FD82E39141AB14D00179C94 /* CompactJITCodeMap.h in Headers */,
                                 A7E5A3A81797432D00E893C0 /* CompilationResult.h in Headers */,
+                                0FDCE12A1FAFA85F006F3901 /* CompleteSubspace.h in Headers */,
                                 BC18C3F40E16F5CD00B34460 /* Completion.h in Headers */,
                                 0F6FC751196110A800E1D02D /* ComplexGetStatus.h in Headers */,
@@ -8300 +8301 @@
                                 A5FD0074189B038C00633231 /* ConsoleTypes.h in Headers */,
                                 0FFC99D1184EC8AD009C10AB /* ConstantMode.h in Headers */,
+                                0F41545B1FD20B22001B58F6 /* ConstraintConcurrency.h in Headers */,
+                                0F4D8C751FC7A97D001D32AC /* ConstraintParallelism.h in Headers */,
                                 0F7DF1341E2970D70095951B /* ConstraintVolatility.h in Headers */,
                                 E354622B1B6065D100545386 /* ConstructAbility.h in Headers */,
@@ -8338 +8341 @@
                                 A704D90317A0BAA8006BA554 /* DFGAbstractInterpreter.h in Headers */,
                                 A704D90417A0BAA8006BA554 /* DFGAbstractInterpreterInlines.h in Headers */,
-                                0F6453181FD246A7002432A1 /* MarkStackMergingConstraint.h in Headers */,
                                 0F620177143FCD3F0068B77C /* DFGAbstractValue.h in Headers */,
                                 0FD3E4021B618AAF00C80E1E /* DFGAdaptiveInferredPropertyValueWatchpoint.h in Headers */,
@@ -8548 +8550 @@
                                 FE1C0FFD1B193E9800B53FCA /* Exception.h in Headers */,
                                 FE6029D91D6E1E4F0030204D /* ExceptionEventLocation.h in Headers */,
-                                0F30CB5E1FCE4E37004B5323 /* AllocatorForMode.h in Headers */,
                                 0F12DE101979D5FD0006FF4E /* ExceptionFuzz.h in Headers */,
                                 BC18C4000E16F5CD00B34460 /* ExceptionHelpers.h in Headers */,
@@ -8635 +8636 @@
                                 0F2B66AE17B6B54500A7AE3F /* GCIncomingRefCountedSet.h in Headers */,
                                 0F2B66AF17B6B54500A7AE3F /* GCIncomingRefCountedSetInlines.h in Headers */,
-                                0FBF92B91FD76FFF00AC28A8 /* InferredStructure.h in Headers */,
                                 2AABCDE718EF294200002096 /* GCLogging.h in Headers */,
                                 0F9715311EB28BEE00A1645D /* GCRequest.h in Headers */,
@@ -8666 +8666 @@
                                 70B791951C024A28002481E2 /* GeneratorFunctionConstructor.h in Headers */,
                                 70B791971C024A29002481E2 /* GeneratorFunctionPrototype.h in Headers */,
-                                0FDCE12A1FAFA85F006F3901 /* CompleteSubspace.h in Headers */,
                                 70B791991C024A29002481E2 /* GeneratorPrototype.h in Headers */,
                                 70B7919D1C024A56002481E2 /* GeneratorPrototype.lut.h in Headers */,
@@ -8693 +8692 @@
                                 DC3D2B0A1D34316200BA918C /* HeapCell.h in Headers */,
                                 0F070A491D543A93006E7232 /* HeapCellInlines.h in Headers */,
+                                0FDCE1221FAE858C006F3901 /* HeapCellType.h in Headers */,
                                 0F0CAEFF1EC4DA8800970D12 /* HeapFinalizerCallback.h in Headers */,
                                 0F32BD111BB34F190093A57F /* HeapHelperPool.h in Headers */,
@@ -8713 +8713 @@
                                 0FB7F39B15ED8E4600F167B2 /* IndexingType.h in Headers */,
                                 14386A791DD6989C008652C4 /* IndirectEvalExecutable.h in Headers */,
+                                0FBF92B91FD76FFF00AC28A8 /* InferredStructure.h in Headers */,
+                                0FBF92BA1FD7700400AC28A8 /* InferredStructureWatchpoint.h in Headers */,
                                 0F0A75231B94BFA900110660 /* InferredType.h in Headers */,
                                 0FFC92121B94D4DF0071DD66 /* InferredTypeTable.h in Headers */,
@@ -8774 +8776 @@
                                 860BD801148EA6F200112B2F /* Intrinsic.h in Headers */,
                                 534E03541E53BD2900213F64 /* IntrinsicGetterAccessCase.h in Headers */,
+                                0FDCE1321FB11DA4006F3901 /* IsoAlignedMemoryAllocator.h in Headers */,
+                                0FDCE12D1FAFB4E5006F3901 /* IsoSubspace.h in Headers */,
                                 8B9F6D561D5912FA001C739F /* IterationKind.h in Headers */,
                                 FE4D55B81AE716CA0052E459 /* IterationStatus.h in Headers */,
@@ -8815 +8819 @@
                                 0F2B66E717B6B5AB00A7AE3F /* JSArrayBufferPrototype.h in Headers */,
                                 0F2B66E917B6B5AB00A7AE3F /* JSArrayBufferView.h in Headers */,
-                                0F9DAA091FD1C3CF0079C5B2 /* MarkingConstraintSolver.h in Headers */,
                                 0F2B66EA17B6B5AB00A7AE3F /* JSArrayBufferViewInlines.h in Headers */,
                                 539FB8BA1C99DA7C00940FA1 /* JSArrayInlines.h in Headers */,
@@ -8822 +8825 @@
                                 BC18C4180E16F5CD00B34460 /* JSBase.h in Headers */,
                                 140D17D70E8AD4A9000CD17D /* JSBasePrivate.h in Headers */,
+                                868921C21F9C0CB7001159F6 /* JSBigInt.h in Headers */,
                                 86FA9E92142BBB2E001773B7 /* JSBoundFunction.h in Headers */,
                                 BC18C4190E16F5CD00B34460 /* JSCallbackConstructor.h in Headers */,
@@ -8843 +8847 @@
                                 A5D2E665195E174000A518E7 /* JSContextRefInternal.h in Headers */,
                                 148CD1D8108CF902008163C6 /* JSContextRefPrivate.h in Headers */,
+                                FE2B0B731FD9EF700075DA5F /* JSCPoison.h in Headers */,
+                                FE2B0B691FD227E00075DA5F /* JSCPoisonedPtr.h in Headers */,
+                                FE2B0B691FD227E00075DA5F /* JSCScrambledPtr.h in Headers */,
                                 A72028B81797601E0098028C /* JSCTestRunnerUtils.h in Headers */,
                                 72AAF7CE1D0D31B3005E60BE /* JSCustomGetterSetterFunction.h in Headers */,
@@ -8903 +8910 @@
                                 D9722752DC54459B9125B539 /* JSModuleLoader.h in Headers */,
                                 E318CBC11B8AEF5100A2929D /* JSModuleNamespaceObject.h in Headers */,
-                                0FDCE11C1FAE6209006F3901 /* AllocationFailureMode.h in Headers */,
                                 E39DA4A71B7E8B7C0084F33A /* JSModuleRecord.h in Headers */,
                                 E33E8D1D1B9013C300346B52 /* JSNativeStdFunction.h in Headers */,
@@ -8933 +8939 @@
                                 BDFCB2BBE90F41349E1B0BED /* JSSourceCode.h in Headers */,
                                 BC18C4270E16F5CD00B34460 /* JSString.h in Headers */,
+                                0F7DF13F1E2AFC4D0095951B /* JSStringHeapCellType.h in Headers */,
                                 FEFD6FC61D5E7992008F2F0B /* JSStringInlines.h in Headers */,
                                 70EC0EC31AA0D7DA00B6AAFA /* JSStringIterator.h in Headers */,
@@ -8939 +8946 @@
                                 BC18C4290E16F5CD00B34460 /* JSStringRefCF.h in Headers */,
                                 1A28D4A8177B71C80007FA3C /* JSStringRefPrivate.h in Headers */,
-                                0F7DF13F1E2AFC4D0095951B /* JSStringHeapCellType.h in Headers */,
                                 0F919D0D157EE0A2004A4E7D /* JSSymbolTableObject.h in Headers */,
                                 70ECA6061AFDBEA200449739 /* JSTemplateRegistryKey.h in Headers */,
@@ -8964 +8970 @@
                                 A7482B9311671147003B0712 /* JSWeakObjectMapRefPrivate.h in Headers */,
                                 0F0B286B1EB8E6CF000EB5D2 /* JSWeakPrivate.h in Headers */,
-                                0F4D8C741FC7A97A001D32AC /* VisitCounter.h in Headers */,
                                 709FB8681AE335C60039D069 /* JSWeakSet.h in Headers */,
                                 AD5C36EB1F75AD73000BCAAF /* JSWebAssembly.h in Headers */,
@@ -9040 +9045 @@
                                 0F660E381E0517BB0031462C /* MarkingConstraint.h in Headers */,
                                 0F660E3A1E0517C10031462C /* MarkingConstraintSet.h in Headers */,
+                                0F9DAA091FD1C3CF0079C5B2 /* MarkingConstraintSolver.h in Headers */,
                                 142D6F1213539A4100B02E86 /* MarkStack.h in Headers */,
+                                0F6453181FD246A7002432A1 /* MarkStackMergingConstraint.h in Headers */,
                                 8612E4CD152389EC00C836BE /* MatchResult.h in Headers */,
                                 4340A4851A9051AF00D73CCA /* MathCommon.h in Headers */,
@@ -9084 +9091 @@
                                 0FD3E40A1B618B6600C80E1E /* ObjectPropertyCondition.h in Headers */,
                                 0FD3E40C1B618B6600C80E1E /* ObjectPropertyConditionSet.h in Headers */,
-                                0F4D8C781FCA3CFA001D32AC /* SimpleMarkingConstraint.h in Headers */,
                                 BC18C4460E16F5CD00B34460 /* ObjectPrototype.h in Headers */,
                                 E124A8F70E555775003091F1 /* OpaqueJSString.h in Headers */,
@@ -9092 +9098 @@
                                 BC18C4480E16F5CD00B34460 /* Operations.h in Headers */,
                                 0FE228ED1436AB2700196C48 /* Options.h in Headers */,
+                                0F9DAA0A1FD1C3D30079C5B2 /* ParallelSourceAdapter.h in Headers */,
                                 37C738D21EDB56E4003F2B0B /* ParseInt.h in Headers */,
                                 BC18C44B0E16F5CD00B34460 /* Parser.h in Headers */,
@@ -9211 +9218 @@
                                 DC17E8191C9C91DB008A6AB3 /* ShadowChickenInlines.h in Headers */,
                                 FE3022D31E3D73A500BAC493 /* SigillCrashAnalyzer.h in Headers */,
+                                0F4D8C781FCA3CFA001D32AC /* SimpleMarkingConstraint.h in Headers */,
                                 0F2B670517B6B5AB00A7AE3F /* SimpleTypedArrayController.h in Headers */,
                                 14BA78F113AAB88F005B7C2C /* SlotVisitor.h in Headers */,
@@ -9292 +9300 @@
                                 0F2B670617B6B5AB00A7AE3F /* TypedArrayAdaptors.h in Headers */,
                                 0F2B670817B6B5AB00A7AE3F /* TypedArrayController.h in Headers */,
-                                0F9DAA0A1FD1C3D30079C5B2 /* ParallelSourceAdapter.h in Headers */,
                                 0F4B94DC17B9F07500DD03A4 /* TypedArrayInlines.h in Headers */,
                                 0F2B670917B6B5AB00A7AE3F /* TypedArrays.h in Headers */,
@@ -9302 +9309 @@
                                 52C952B719A289850069B386 /* TypeProfiler.h in Headers */,
                                 0F2D4DEC19832DC4007D4B19 /* TypeProfilerLog.h in Headers */,
-                                0FDCE1221FAE858C006F3901 /* HeapCellType.h in Headers */,
                                 0F2D4DF019832DD6007D4B19 /* TypeSet.h in Headers */,
                                 0FF4274B158EBE91004CB9FF /* udis86.h in Headers */,
@@ -9333 +9339 @@
                                 0FE0502D1AA9095600D33B33 /* VarOffset.h in Headers */,
                                 0F426A491460CBB700131F8F /* VirtualRegister.h in Headers */,
+                                0F4D8C741FC7A97A001D32AC /* VisitCounter.h in Headers */,
                                 0F952AA11DF7860900E06FBD /* VisitRaceKey.h in Headers */,
                                 BC18C4200E16F5CD00B34460 /* VM.h in Headers */,

trunk/Source/JavaScriptCore/Sources.txt

@@ -773 +773 @@
 runtime/JSAsyncFunction.cpp
 runtime/JSAsyncGeneratorFunction.cpp
+runtime/JSBigInt.cpp
 runtime/JSBoundFunction.cpp
 runtime/JSCJSValue.cpp

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -54 +54 @@
 #include "JIT.h"
 #include "JITMathIC.h"
+#include "JSBigInt.h"
 #include "JSCInlines.h"
 #include "JSCJSValue.h"

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

@@ -40 +40 @@
 #include "Interpreter.h"
 #include "JSAsyncGeneratorFunction.h"
+#include "JSBigInt.h"
 #include "JSCInlines.h"
 #include "JSFixedArray.h"
@@ -1785 +1786 @@
                 return dst;
             }
+            if (Options::useBigInt() && value == "bigint") {
+                rewindUnaryOp();
+                emitOpcode(op_is_cell_with_type);
+                instructions().append(dst->index());
+                instructions().append(srcIndex);
+                instructions().append(BigIntType);
+                return dst;
+            }
             if (value == "object") {
                 rewindUnaryOp();
@@ -3122 +3131 @@
 }
 
+JSValue BytecodeGenerator::addBigIntConstant(const Identifier& identifier, uint8_t radix)
+{
+    return m_bigIntMap.ensure(BigIntMapEntry(identifier.impl(), radix), [&] {
+        JSBigInt* bigIntInMap = JSBigInt::parseInt(nullptr, *vm(), identifier.string(), radix);
+        // FIXME: [ESNext] Enables a way to throw an error on ByteCodeGenerator step
+        // https://bugs.webkit.org/show_bug.cgi?id=180139
+        RELEASE_ASSERT(bigIntInMap);
+        addConstantValue(bigIntInMap);
+
+        return bigIntInMap;
+    }).iterator->value;
+}
+
 JSString* BytecodeGenerator::addStringConstant(const Identifier& identifier)
 {

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

@@ -35 +35 @@
 #include "Interpreter.h"
 #include "JSAsyncGeneratorFunction.h"
+#include "JSBigInt.h"
 #include "JSGeneratorFunction.h"
 #include "Label.h"
@@ -47 +48 @@
 #include <functional>
 #include <wtf/CheckedArithmetic.h>
+#include <wtf/HashFunctions.h>
 #include <wtf/SegmentedVector.h>
 #include <wtf/SetForScope.h>
@@ -1001 +1003 @@
         void allocateAndEmitScope();
 
-        typedef HashMap<double, JSValue> NumberMap;
-        typedef HashMap<UniquedStringImpl*, JSString*, IdentifierRepHash> IdentifierStringMap;
-        typedef HashMap<Ref<TemplateRegistryKey>, RegisterID*> TemplateRegistryKeyMap;
-        
+        using BigIntMapEntry = std::pair<UniquedStringImpl*, uint8_t>;
+
+        using NumberMap = HashMap<double, JSValue>;
+        using IdentifierStringMap = HashMap<UniquedStringImpl*, JSString*, IdentifierRepHash>;
+        using IdentifierBigIntMap = HashMap<BigIntMapEntry, JSBigInt*>;
+        using TemplateRegistryKeyMap = HashMap<Ref<TemplateRegistryKey>, RegisterID*>;
+
         // Helper for emitCall() and emitConstruct(). This works because the set of
         // expected functions have identical behavior for both call and construct
@@ -1087 +1092 @@
     public:
         JSString* addStringConstant(const Identifier&);
+        JSValue addBigIntConstant(const Identifier&, uint8_t radix);
         RegisterID* addTemplateRegistryKeyConstant(Ref<TemplateRegistryKey>&&);
 
@@ -1186 +1192 @@
         JSValueMap m_jsValueMap;
         IdentifierStringMap m_stringMap;
+        IdentifierBigIntMap m_bigIntMap;
         TemplateRegistryKeyMap m_templateRegistryKeyMap;
 

trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

@@ -121 +121 @@
 {
     return generator.addStringConstant(m_value);
+}
+
+JSValue BigIntNode::jsValue(BytecodeGenerator& generator) const
+{
+    return generator.addBigIntConstant(m_value, m_radix);
 }
 

trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h

@@ -178 +178 @@
         valueForNode.m_structure.forEach([&](RegisteredStructure structure) {
             TypeInfo type = structure->typeInfo();
-            ASSERT(type.isObject() || type.type() == StringType || type.type() == SymbolType);
+            ASSERT(type.isObject() || type.type() == StringType || type.type() == SymbolType || type.type() == BigIntType);
             if (!isStrictMode)
                 ASSERT(type.isObject());

trunk/Source/JavaScriptCore/interpreter/Interpreter.cpp

@@ -203 +203 @@
     case StringType:
     case SymbolType:
+    case BigIntType:
         throwException(callFrame, scope, createInvalidFunctionApplyParameterError(callFrame,  arguments));
         return 0;

trunk/Source/JavaScriptCore/llint/LLIntData.cpp

@@ -168 +168 @@
 
     {
-        uint32_t bits = 0x120000;
+        uint32_t bits = 0x480000;
         UNUSED_PARAM(bits);
         ArithProfile arithProfile;
@@ -178 +178 @@
     }
     {
-        uint32_t bits = 0x220000;
+        uint32_t bits = 0x880000;
         UNUSED_PARAM(bits);
         ArithProfile arithProfile;
@@ -188 +188 @@
     }
     {
-        uint32_t bits = 0x240000;
+        uint32_t bits = 0x900000;
         UNUSED_PARAM(bits);
         ArithProfile arithProfile;
@@ -198 +198 @@
     }
     {
-        uint32_t bits = 0x140000;
+        uint32_t bits = 0x500000;
         UNUSED_PARAM(bits);
         ArithProfile arithProfile;

trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

@@ -254 +254 @@
 
 # ArithProfile data
-const ArithProfileInt = 0x100000
-const ArithProfileIntInt = 0x120000
-const ArithProfileNumber = 0x200000
-const ArithProfileNumberInt = 0x220000
-const ArithProfileNumberNumber = 0x240000
-const ArithProfileIntNumber = 0x140000
+const ArithProfileInt = 0x400000
+const ArithProfileIntInt = 0x480000
+const ArithProfileNumber = 0x800000
+const ArithProfileNumberInt = 0x880000
+const ArithProfileNumberNumber = 0x900000
+const ArithProfileIntNumber = 0x500000
 
 # Some register conventions.

trunk/Source/JavaScriptCore/parser/ASTBuilder.h

@@ -233 +233 @@
         return new (m_parserArena) IntegerNode(location, d);
     }
+    
+    ExpressionNode* createBigInt(const JSTokenLocation& location, const Identifier* bigInt, uint8_t radix)
+    {
+        incConstants();
+        return new (m_parserArena) BigIntNode(location, *bigInt, radix);
+    }
 
     ExpressionNode* createString(const JSTokenLocation& location, const Identifier* string)

trunk/Source/JavaScriptCore/parser/Lexer.cpp

@@ -39 +39 @@
 #include <string.h>
 #include <wtf/Assertions.h>
+#include <wtf/Variant.h>
 #include <wtf/dtoa.h>
 
@@ -1501 +1502 @@
 
 template <typename T>
-ALWAYS_INLINE void Lexer<T>::parseHex(double& returnValue)
+ALWAYS_INLINE auto Lexer<T>::parseHex() -> NumberParseResult
 {
     // Optimization: most hexadecimal values fit into 4 bytes.
@@ -1513 +1514 @@
     } while (isASCIIHexDigit(m_current) && maximumDigits >= 0);
 
-    if (maximumDigits >= 0) {
-        returnValue = hexValue;
-        return;
-    }
+    if (LIKELY(maximumDigits >= 0 && m_current != 'n'))
+        return hexValue;
 
     // No more place in the hexValue buffer.
@@ -1534 +1533 @@
     }
 
-    returnValue = parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 16);
-}
-
-template <typename T>
-ALWAYS_INLINE bool Lexer<T>::parseBinary(double& returnValue)
+    if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
+        return makeIdentifier(m_buffer8.data(), m_buffer8.size());
+    
+    return parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 16);
+}
+
+template <typename T>
+ALWAYS_INLINE auto Lexer<T>::parseBinary() -> std::optional<NumberParseResult>
 {
     // Optimization: most binary values fit into 4 bytes.
@@ -1555 +1557 @@
     } while (isASCIIBinaryDigit(m_current) && digit >= 0);
 
-    if (!isASCIIDigit(m_current) && digit >= 0) {
-        returnValue = binaryValue;
-        return true;
-    }
+    if (LIKELY(!isASCIIDigit(m_current) && digit >= 0 && m_current != 'n'))
+        return Variant<double, const Identifier*> { binaryValue };
 
     for (int i = maximumDigits - 1; i > digit; --i)
@@ -1568 +1568 @@
     }
 
-    if (isASCIIDigit(m_current)) {
-        returnValue = 0;
-        return false;
-    }
-
-    returnValue = parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 2);
-    return true;
-}
-
-template <typename T>
-ALWAYS_INLINE bool Lexer<T>::parseOctal(double& returnValue)
+    if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
+        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
+
+    if (isASCIIDigit(m_current))
+        return std::nullopt;
+
+    return Variant<double, const Identifier*> { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 2) };
+}
+
+template <typename T>
+ALWAYS_INLINE auto Lexer<T>::parseOctal() -> std::optional<NumberParseResult>
 {
     // Optimization: most octal values fit into 4 bytes.
@@ -1595 +1595 @@
     } while (isASCIIOctalDigit(m_current) && digit >= 0);
 
-    if (!isASCIIDigit(m_current) && digit >= 0) {
-        returnValue = octalValue;
-        return true;
-    }
+    if (LIKELY(!isASCIIDigit(m_current) && digit >= 0 && m_current != 'n'))
+        return Variant<double, const Identifier*> { octalValue };
+
 
     for (int i = maximumDigits - 1; i > digit; --i)
@@ -1608 +1607 @@
     }
 
-    if (isASCIIDigit(m_current)) {
-        returnValue = 0;
-        return false;
-    }
-
-    returnValue = parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 8);
-    return true;
-}
-
-template <typename T>
-ALWAYS_INLINE bool Lexer<T>::parseDecimal(double& returnValue)
+    if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
+        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
+
+    if (isASCIIDigit(m_current))
+        return std::nullopt;
+
+    return Variant<double, const Identifier*> { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 8) };
+}
+
+template <typename T>
+ALWAYS_INLINE auto Lexer<T>::parseDecimal() -> std::optional<NumberParseResult>
 {
     // Optimization: most decimal values fit into 4 bytes.
@@ -1639 +1638 @@
         } while (isASCIIDigit(m_current) && digit >= 0);
 
-        if (digit >= 0 && m_current != '.' && (m_current | 0x20) != 'e') {
-            returnValue = decimalValue;
-            return true;
-        }
+        if (digit >= 0 && m_current != '.' && !isASCIIAlphaCaselessEqual(m_current, 'e') && m_current != 'n')
+            return Variant<double, const Identifier*> { decimalValue };
 
         for (int i = maximumDigits - 1; i > digit; --i)
@@ -1652 +1649 @@
         shift();
     }
-
-    return false;
+    
+    if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
+        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
+
+    return std::nullopt;
 }
 
@@ -2101 +2101 @@
             break;
         }
-        goto inNumberAfterDecimalPoint;
+        parseNumberAfterDecimalPoint();
+        token = DOUBLE;
+        if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
+            if (!parseNumberAfterExponentIndicator()) {
+                m_lexErrorMessage = ASCIILiteral("Non-number found after exponent indicator");
+                token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
+                goto returnError;
+            }
+        }
+        size_t parsedLength;
+        tokenData->doubleValue = parseDouble(m_buffer8.data(), m_buffer8.size(), parsedLength);
+        if (token == INTEGER)
+            token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
+
+        if (UNLIKELY(isIdentStart(m_current))) {
+            m_lexErrorMessage = ASCIILiteral("No identifiers allowed directly after numeric literal");
+            token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
+            goto returnError;
+        }
+        m_buffer8.shrink(0);
+        break;
     case CharacterZero:
         shift();
-        if ((m_current | 0x20) == 'x') {
+        if (isASCIIAlphaCaselessEqual(m_current, 'x')) {
             if (!isASCIIHexDigit(peek(1))) {
                 m_lexErrorMessage = ASCIILiteral("No hexadecimal digits after '0x'");
@@ -2114 +2134 @@
             shift();
 
-            parseHex(tokenData->doubleValue);
+            auto parseNumberResult = parseHex();
+            if (WTF::holds_alternative<double>(parseNumberResult))
+                tokenData->doubleValue = WTF::get<double>(parseNumberResult);
+            else {
+                token = BIGINT;
+                shift();
+                tokenData->bigIntString = WTF::get<const Identifier*>(parseNumberResult);
+                tokenData->radix = 16;
+            }
+
             if (isIdentStart(m_current)) {
                 m_lexErrorMessage = ASCIILiteral("No space between hexadecimal literal and identifier");
@@ -2120 +2149 @@
                 goto returnError;
             }
-            token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
+            if (LIKELY(token != BIGINT))
+                token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
             m_buffer8.shrink(0);
             break;
         }
-        if ((m_current | 0x20) == 'b') {
+        if (isASCIIAlphaCaselessEqual(m_current, 'b')) {
             if (!isASCIIBinaryDigit(peek(1))) {
                 m_lexErrorMessage = ASCIILiteral("No binary digits after '0b'");
@@ -2134 +2164 @@
             shift();
 
-            parseBinary(tokenData->doubleValue);
+            auto parseNumberResult = parseBinary();
+            if (!parseNumberResult)
+                tokenData->doubleValue = 0;
+            else if (WTF::holds_alternative<double>(*parseNumberResult))
+                tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
+            else {
+                token = BIGINT;
+                shift();
+                tokenData->bigIntString = WTF::get<const Identifier*>(*parseNumberResult);
+                tokenData->radix = 2;
+            }
+
             if (isIdentStart(m_current)) {
                 m_lexErrorMessage = ASCIILiteral("No space between binary literal and identifier");
@@ -2140 +2181 @@
                 goto returnError;
             }
-            token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
+            if (LIKELY(token != BIGINT))
+                token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
             m_buffer8.shrink(0);
             break;
         }
 
-        if ((m_current | 0x20) == 'o') {
+        if (isASCIIAlphaCaselessEqual(m_current, 'o')) {
             if (!isASCIIOctalDigit(peek(1))) {
                 m_lexErrorMessage = ASCIILiteral("No octal digits after '0o'");
@@ -2155 +2197 @@
             shift();
 
-            parseOctal(tokenData->doubleValue);
+            auto parseNumberResult = parseOctal();
+            if (!parseNumberResult)
+                tokenData->doubleValue = 0;
+            else if (WTF::holds_alternative<double>(*parseNumberResult))
+                tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
+            else {
+                token = BIGINT;
+                shift();
+                tokenData->bigIntString = WTF::get<const Identifier*>(*parseNumberResult);
+                tokenData->radix = 8;
+            }
+
             if (isIdentStart(m_current)) {
                 m_lexErrorMessage = ASCIILiteral("No space between octal literal and identifier");
@@ -2161 +2214 @@
                 goto returnError;
             }
-            token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
+            if (LIKELY(token != BIGINT))
+                token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
             m_buffer8.shrink(0);
             break;
@@ -2173 +2227 @@
         }
         if (isASCIIOctalDigit(m_current)) {
-            if (parseOctal(tokenData->doubleValue)) {
+            auto parseNumberResult = parseOctal();
+            if (parseNumberResult && WTF::holds_alternative<double>(*parseNumberResult)) {
+                tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
                 token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
             }
@@ -2180 +2236 @@
     case CharacterNumber:
         if (LIKELY(token != INTEGER && token != DOUBLE)) {
-            if (!parseDecimal(tokenData->doubleValue)) {
-                token = INTEGER;
-                if (m_current == '.') {
+            auto parseNumberResult = parseDecimal();
+            if (parseNumberResult && WTF::holds_alternative<double>(*parseNumberResult)) {
+                tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
+                token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
+            } else {
+                if (parseNumberResult) {
+                    ASSERT(WTF::get<const Identifier*>(*parseNumberResult));
+                    token = BIGINT;
                     shift();
-inNumberAfterDecimalPoint:
-                    parseNumberAfterDecimalPoint();
-                    token = DOUBLE;
+                    tokenData->bigIntString = WTF::get<const Identifier*>(*parseNumberResult);
+                    tokenData->radix = 10;
+                } else {
+                    token = INTEGER;
+                    if (m_current == '.') {
+                        shift();
+                        parseNumberAfterDecimalPoint();
+                        token = DOUBLE;
+                    }
+                    if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
+                        if (!parseNumberAfterExponentIndicator()) {
+                            m_lexErrorMessage = ASCIILiteral("Non-number found after exponent indicator");
+                            token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
+                            goto returnError;
+                        }
+                    }
+                    size_t parsedLength;
+                    tokenData->doubleValue = parseDouble(m_buffer8.data(), m_buffer8.size(), parsedLength);
+                    if (token == INTEGER)
+                        token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
                 }
-                if ((m_current | 0x20) == 'e') {
-                    if (!parseNumberAfterExponentIndicator()) {
-                        m_lexErrorMessage = ASCIILiteral("Non-number found after exponent indicator");
-                        token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
-                        goto returnError;
-                    }
-                }
-                size_t parsedLength;
-                tokenData->doubleValue = parseDouble(m_buffer8.data(), m_buffer8.size(), parsedLength);
-                if (token == INTEGER)
-                    token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
-            } else
-                token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
+            }
         }
 

trunk/Source/JavaScriptCore/parser/Lexer.h

@@ -174 +174 @@
     template <bool shouldBuildStrings> NEVER_INLINE StringParseResult parseStringSlowCase(JSTokenData*, bool strictMode);
 
+
     template <bool shouldBuildStrings, LexerEscapeParseMode escapeParseMode> ALWAYS_INLINE StringParseResult parseComplexEscape(bool strictMode, T stringQuoteCharacter);
     ALWAYS_INLINE StringParseResult parseTemplateLiteral(JSTokenData*, RawStringsBuildMode);
-    ALWAYS_INLINE void parseHex(double& returnValue);
-    ALWAYS_INLINE bool parseBinary(double& returnValue);
-    ALWAYS_INLINE bool parseOctal(double& returnValue);
-    ALWAYS_INLINE bool parseDecimal(double& returnValue);
+    
+    using NumberParseResult = Variant<double, const Identifier*>;
+    ALWAYS_INLINE NumberParseResult parseHex();
+    ALWAYS_INLINE std::optional<NumberParseResult> parseBinary();
+    ALWAYS_INLINE std::optional<NumberParseResult> parseOctal();
+    ALWAYS_INLINE std::optional<NumberParseResult> parseDecimal();
     ALWAYS_INLINE void parseNumberAfterDecimalPoint();
     ALWAYS_INLINE bool parseNumberAfterExponentIndicator();

trunk/Source/JavaScriptCore/parser/NodeConstructors.h

@@ -93 +93 @@
     }
 
+    inline BigIntNode::BigIntNode(const JSTokenLocation& location, const Identifier& value, uint8_t radix)
+        : ConstantNode(location, ResultType::bigIntType())
+        , m_value(value)
+        , m_radix(radix)
+    {
+    }
+
     inline StringNode::StringNode(const JSTokenLocation& location, const Identifier& value)
         : ConstantNode(location, ResultType::stringType())

trunk/Source/JavaScriptCore/parser/Nodes.h

@@ -163 +163 @@
         virtual bool isNumber() const { return false; }
         virtual bool isString() const { return false; }
+        virtual bool isBigInt() const { return false; }
         virtual bool isObjectLiteral() const { return false; }
         virtual bool isArrayLiteral() const { return false; }
@@ -329 +330 @@
     };
 
+    class BigIntNode final : public ConstantNode {
+    public:
+        BigIntNode(const JSTokenLocation&, const Identifier&, uint8_t radix);
+        const Identifier& value() { return m_value; }
+
+    private:
+        bool isBigInt() const final { return true; }
+        JSValue jsValue(BytecodeGenerator&) const final;
+
+        const Identifier& m_value;
+        const uint8_t m_radix;
+    };
+
     class ThrowableExpressionData {
     public:

trunk/Source/JavaScriptCore/parser/Parser.cpp

@@ -4493 +4493 @@
         return createResolveAndUseVariable(context, ident, *ident == m_vm->propertyNames->eval, start, location);
     }
+    case BIGINT: {
+        const Identifier* ident = m_token.m_data.bigIntString;
+        JSTokenLocation location(tokenLocation());
+        next();
+        return context.createBigInt(location, ident, m_token.m_data.radix);
+    }
     case STRING: {
         const Identifier* ident = m_token.m_data.ident;

trunk/Source/JavaScriptCore/parser/ParserTokens.h

@@ -111 +111 @@
     INTEGER,
     DOUBLE,
+    BIGINT,
     IDENT,
     STRING,
@@ -219 +220 @@
     };
     struct {
+        const Identifier* bigIntString;
+        uint8_t radix;
+    };
+    struct {
         const Identifier* cooked;
         const Identifier* raw;

trunk/Source/JavaScriptCore/parser/ResultType.h

@@ -32 +32 @@
         friend struct OperandTypes;
 
-        typedef uint8_t Type;
+        using Type = uint8_t;
         static const Type TypeInt32 = 1;
         static const Type TypeMaybeNumber = 0x02;
@@ -38 +38 @@
         static const Type TypeMaybeNull   = 0x08;
         static const Type TypeMaybeBool   = 0x10;
-        static const Type TypeMaybeOther  = 0x20;
-
-        static const Type TypeBits = TypeMaybeNumber | TypeMaybeString | TypeMaybeNull | TypeMaybeBool | TypeMaybeOther;
+        static const Type TypeMaybeBigInt = 0x20;
+        static const Type TypeMaybeOther  = 0x40;
+
+        static const Type TypeBits = TypeMaybeNumber | TypeMaybeString | TypeMaybeNull | TypeMaybeBool | TypeMaybeBigInt | TypeMaybeOther;
 
     public:
-        static const int numBitsNeeded = 6;
+        static const int numBitsNeeded = 7;
         static_assert((TypeBits & ((1 << numBitsNeeded) - 1)) == TypeBits, "This is necessary for correctness.");
 
@@ -71 +72 @@
         }
 
+        bool definitelyIsBigInt() const
+        {
+            return (m_bits & TypeBits) == TypeMaybeBigInt;
+        }
+
         bool mightBeNumber() const
         {
@@ -81 +87 @@
         }
         
+        bool mightBeBigInt() const
+        {
+            return m_bits & TypeMaybeBigInt;
+        }
+
+        bool isNotBigInt() const
+        {
+            return !mightBeBigInt();
+        }
+        
         static ResultType nullType()
         {
@@ -106 +122 @@
         }
         
+        static ResultType addResultType()
+        {
+            return ResultType(TypeMaybeNumber | TypeMaybeString | TypeMaybeBigInt);
+        }
+        
         static ResultType stringType()
         {
             return ResultType(TypeMaybeString);
+        }
+        
+        static ResultType bigIntType()
+        {
+            return ResultType(TypeMaybeBigInt);
         }
         
@@ -122 +148 @@
             if (op1.definitelyIsString() || op2.definitelyIsString())
                 return stringType();
-            return stringOrNumberType();
+            if (op1.definitelyIsBigInt() && op2.definitelyIsBigInt())
+                return bigIntType();
+            return addResultType();
         }
 
@@ -135 +163 @@
             if (op1.definitelyIsString() && op2.definitelyIsString())
                 return stringType();
+            if (op1.definitelyIsBigInt() && op2.definitelyIsBigInt())
+                return bigIntType();
             return unknownType();
         }

trunk/Source/JavaScriptCore/parser/SyntaxChecker.h

@@ -71 +71 @@
     static const constexpr int MetaPropertyBit = 0x80000000;
     enum : int { NoneExpr = 0,
-        ResolveEvalExpr, ResolveExpr, IntegerExpr, DoubleExpr, StringExpr,
+        ResolveEvalExpr, ResolveExpr, IntegerExpr, DoubleExpr, StringExpr, BigIntExpr,
         ThisExpr, NullExpr, BoolExpr, RegExpExpr, ObjectLiteralExpr,
         FunctionExpr, ClassExpr, SuperExpr, ImportExpr, BracketExpr, DotExpr, CallExpr,
@@ -176 +176 @@
     ExpressionType createDoubleExpr(const JSTokenLocation&, double) { return DoubleExpr; }
     ExpressionType createIntegerExpr(const JSTokenLocation&, double) { return IntegerExpr; }
+    ExpressionType createBigInt(const JSTokenLocation&, const Identifier*, int) { return BigIntExpr; }
     ExpressionType createString(const JSTokenLocation&, const Identifier*) { return StringExpr; }
     ExpressionType createBoolean(const JSTokenLocation&, bool) { return BoolExpr; }

trunk/Source/JavaScriptCore/runtime/CommonIdentifiers.h

@@ -31 +31 @@
     macro(ArrayIterator) \
     macro(BYTES_PER_ELEMENT) \
+    macro(BigInt) \
     macro(Boolean) \
     macro(Collator) \

trunk/Source/JavaScriptCore/runtime/JSCJSValue.cpp

@@ -30 +30 @@
 #include "ExceptionHelpers.h"
 #include "GetterSetter.h"
+#include "JSBigInt.h"
 #include "JSCInlines.h"
 #include "JSFunction.h"
@@ -130 +131 @@
         if (isString())
             return exec->lexicalGlobalObject()->stringPrototype();
+        // FIXME: [ESNext][BigInt] Implement BigIntConstructor and BigIntPrototype
+        // https://bugs.webkit.org/show_bug.cgi?id=175359
+        RELEASE_ASSERT(!isBigInt());
         ASSERT(isSymbol());
         return exec->lexicalGlobalObject()->symbolPrototype();
@@ -376 +380 @@
         return errorValue();
     }
+    if (isBigInt()) {
+        JSBigInt* bigInt = asBigInt(*this);
+        if (auto digit = bigInt->singleDigitValueForString())
+            return vm.smallStrings.singleCharacterString(*digit + '0');
+        return jsNontrivialString(&vm, bigInt->toString(*exec, 10));
+    }
 
     ASSERT(isCell());

trunk/Source/JavaScriptCore/runtime/JSCJSValue.h

@@ -223 +223 @@
     bool isNumber() const;
     bool isString() const;
+    bool isBigInt() const;
     bool isSymbol() const;
     bool isPrimitive() const;

trunk/Source/JavaScriptCore/runtime/JSCJSValueInlines.h

@@ -30 +30 @@
 #include "Identifier.h"
 #include "InternalFunction.h"
+#include "JSBigInt.h"
 #include "JSCJSValue.h"
 #include "JSCellInlines.h"
@@ -577 +578 @@
 {
     return isCell() && asCell()->isString();
+}
+
+inline bool JSValue::isBigInt() const
+{
+    return isCell() && asCell()->isBigInt();
 }
 
@@ -1021 +1027 @@
     if (v1.asCell()->isString() && v2.asCell()->isString())
         return asString(v1)->equal(exec, asString(v2));
+    if (v1.isBigInt() && v2.isBigInt())
+        return JSBigInt::equals(asBigInt(v1.asCell()), asBigInt(v2.asCell()));
     return v1 == v2;
 }

trunk/Source/JavaScriptCore/runtime/JSCell.cpp

@@ -114 +114 @@
 bool JSCell::put(JSCell* cell, ExecState* exec, PropertyName identifier, JSValue value, PutPropertySlot& slot)
 {
-    if (cell->isString() || cell->isSymbol())
+    if (cell->isString() || cell->isSymbol() || cell->isBigInt())
         return JSValue(cell).putToPrimitive(exec, identifier, value, slot);
 
@@ -123 +123 @@
 bool JSCell::putByIndex(JSCell* cell, ExecState* exec, unsigned identifier, JSValue value, bool shouldThrow)
 {
-    if (cell->isString() || cell->isSymbol()) {
+    if (cell->isString() || cell->isSymbol() || cell->isBigInt()) {
         PutPropertySlot slot(cell, shouldThrow);
         return JSValue(cell).putToPrimitive(exec, Identifier::from(exec, identifier), value, slot);
@@ -156 +156 @@
     if (isSymbol())
         return static_cast<const Symbol*>(this)->toPrimitive(exec, preferredType);
+    if (isBigInt())
+        return static_cast<const JSBigInt*>(this)->toPrimitive(exec, preferredType);
     return static_cast<const JSObject*>(this)->toPrimitive(exec, preferredType);
 }
@@ -165 +167 @@
     if (isSymbol())
         return static_cast<const Symbol*>(this)->getPrimitiveNumber(exec, number, value);
+    if (isBigInt())
+        return static_cast<const JSBigInt*>(this)->getPrimitiveNumber(exec, number, value);
     return static_cast<const JSObject*>(this)->getPrimitiveNumber(exec, number, value);
 }
@@ -174 +178 @@
     if (isSymbol())
         return static_cast<const Symbol*>(this)->toNumber(exec);
+    if (isBigInt())
+        return static_cast<const JSBigInt*>(this)->toNumber(exec);
     return static_cast<const JSObject*>(this)->toNumber(exec);
 }
@@ -182 +188 @@
     if (isString())
         return static_cast<const JSString*>(this)->toObject(exec, globalObject);
+    // FIXME: [ESNext][BigInt] Implement JSBigInt, BigIntConstructor and BigIntPrototype
+    // https://bugs.webkit.org/show_bug.cgi?id=175359
+    RELEASE_ASSERT(!isBigInt());
     ASSERT(isSymbol());
     return static_cast<const Symbol*>(this)->toObject(exec, globalObject);

trunk/Source/JavaScriptCore/runtime/JSCell.h

@@ -109 +109 @@
     // Querying the type.
     bool isString() const;
+    bool isBigInt() const;
     bool isSymbol() const;
     bool isObject() const;

trunk/Source/JavaScriptCore/runtime/JSCellInlines.h

@@ -193 +193 @@
 }
 
+inline bool JSCell::isBigInt() const
+{
+    return m_type == BigIntType;
+}
+
 inline bool JSCell::isSymbol() const
 {

trunk/Source/JavaScriptCore/runtime/JSModuleRecord.cpp

@@ -27 +27 @@
 #include "JSModuleRecord.h"
 
+#include "BuiltinNames.h"
 #include "Error.h"
 #include "Interpreter.h"
 #include "JSCInlines.h"
 #include "JSModuleEnvironment.h"
+#include "JSModuleLoader.h"
 #include "JSModuleNamespaceObject.h"
 #include "UnlinkedModuleProgramCodeBlock.h"

trunk/Source/JavaScriptCore/runtime/JSType.h

@@ -34 +34 @@
     StringType,
     SymbolType,
+    BigIntType,
 
     CustomGetterSetterType,

trunk/Source/JavaScriptCore/runtime/MathCommon.h

@@ -67 +67 @@
 }
 
+inline int clz64(uint64_t number)
+{
+#if COMPILER(GCC_OR_CLANG)
+    int zeroCount = 64;
+    if (number)
+        zeroCount = __builtin_clzll(number);
+    return zeroCount;
+#else
+    int zeroCount = 0;
+    for (int i = 63; i >= 0; i--) {
+        if (!(number >> i))
+            zeroCount++;
+        else
+            break;
+    }
+    return zeroCount;
+#endif
+}
+
 // This in the ToInt32 operation is defined in section 9.5 of the ECMA-262 spec.
 // Note that this operation is identical to ToUInt32 other than to interpretation

trunk/Source/JavaScriptCore/runtime/NumberPrototype.cpp

@@ -30 +30 @@
 #include "JSGlobalObject.h"
 #include "JSString.h"
+#include "ParseInt.h"
 #include "Uint16WithFraction.h"
 #include <wtf/dtoa.h>
@@ -139 +140 @@
 // fo any number of digits an IEEE number may require to represent.
 typedef char RadixBuffer[2180];
-
-// Mapping from integers 0..35 to digit identifying this value, for radix 2..36.
-static const char radixDigits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
 static inline char* int52ToStringWithRadix(char* startOfResultString, int64_t int52Value, unsigned radix)

trunk/Source/JavaScriptCore/runtime/Operations.cpp

@@ -83 +83 @@
     if (v.isSymbol())
         return vm.smallStrings.symbolString();
+    if (v.isBigInt())
+        return vm.smallStrings.bigintString();
     if (v.isObject()) {
         JSObject* object = asObject(v);
@@ -113 +115 @@
 
     JSType type = v.asCell()->type();
-    if (type == StringType || type == SymbolType)
+    if (type == StringType || type == SymbolType || type == BigIntType)
         return false;
     if (type >= ObjectType) {

trunk/Source/JavaScriptCore/runtime/Options.h

@@ -481 +481 @@
     v(bool, useEagerWebAssemblyModuleHashing, false, Normal, "Unnamed WebAssembly modules are identified in backtraces through their hash, if available.") \
     v(bool, useObjectRestSpread, true, Normal, "If true, we will enable Object Rest/Spread feature.") \
+    v(bool, useBigInt, false, Normal, "If true, we will enable BigInt support.") \
     v(bool, useArrayAllocationProfiling, true, Normal, "If true, we will use our normal array allocation profiling. If false, the allocation profile will always claim to be undecided.")\
     v(bool, forcePolyProto, false, Normal, "If true, create_this will always create an object with a poly proto structure.")

trunk/Source/JavaScriptCore/runtime/ParseInt.h

@@ -227 +227 @@
 }
 
+// Mapping from integers 0..35 to digit identifying this value, for radix 2..36.
+const char radixDigits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+
 } // namespace JSC

trunk/Source/JavaScriptCore/runtime/SmallStrings.h

@@ -41 +41 @@
     macro(string) \
     macro(symbol) \
+    macro(bigint) \
     macro(true)
 
@@ -104 +105 @@
         case TypeofType::Function:
             return functionString();
+        case TypeofType::BigInt:
+            return bigintString();
         }
         

trunk/Source/JavaScriptCore/runtime/Structure.cpp

@@ -27 +27 @@
 #include "Structure.h"
 
+#include "BuiltinNames.h"
 #include "CodeBlock.h"
 #include "DumpContext.h"

trunk/Source/JavaScriptCore/runtime/StructureInlines.h

@@ -204 +204 @@
     ASSERT(structure->typeInfo().type() == SymbolType);
     return globalObject->symbolPrototype();
-
 }
 

trunk/Source/JavaScriptCore/runtime/TypeofType.cpp

@@ -55 +55 @@
         out.print("function");
         return;
+    case TypeofType::BigInt:
+        out.print("bigint");
+        return;
     }
     

trunk/Source/JavaScriptCore/runtime/TypeofType.h

@@ -32 +32 @@
 enum class TypeofType {
     Undefined,
+    BigInt,
     Boolean,
     Number,

trunk/Source/JavaScriptCore/runtime/VM.cpp

@@ -67 +67 @@
 #include "JSAPIValueWrapper.h"
 #include "JSArray.h"
+#include "JSBigInt.h"
 #include "JSCInlines.h"
 #include "JSDestructibleObjectHeapCellType.h"
@@ -309 +310 @@
     setIteratorStructure.set(*this, JSSetIterator::createStructure(*this, 0, jsNull()));
     mapIteratorStructure.set(*this, JSMapIterator::createStructure(*this, 0, jsNull()));
+    bigIntStructure.set(*this, JSBigInt::createStructure(*this, 0, jsNull()));
 
     sentinelSetBucket.set(*this, JSSet::BucketType::createSentinel(*this));

trunk/Source/JavaScriptCore/runtime/VM.h

@@ -410 +410 @@
     Strong<Structure> setIteratorStructure;
     Strong<Structure> mapIteratorStructure;
+    Strong<Structure> bigIntStructure;
 
     Strong<JSCell> emptyPropertyNameEnumerator;

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2017-12-12  Caio Lima  <ticaiolima@gmail.com>
+
+        [ESNext][BigInt] Implement BigInt literals and JSBigInt
+        https://bugs.webkit.org/show_bug.cgi?id=179000
+
+        Reviewed by Darin Adler and Yusuke Suzuki.
+
+        * wtf/HashFunctions.h:
+
 2017-12-12  Joseph Pecoraro  <pecoraro@apple.com>
 

trunk/Source/WTF/wtf/HashFunctions.h

@@ -219 +219 @@
 
     template<> struct DefaultHash<bool> { typedef IntHash<uint8_t> Hash; };
+    template<> struct DefaultHash<uint8_t> { typedef IntHash<uint8_t> Hash; };
     template<> struct DefaultHash<short> { typedef IntHash<unsigned> Hash; };
     template<> struct DefaultHash<unsigned short> { typedef IntHash<unsigned> Hash; };

trunk/Tools/ChangeLog

@@ +1 @@
+2017-12-12  Caio Lima  <ticaiolima@gmail.com>
+
+        [ESNext][BigInt] Implement BigInt literals and JSBigInt
+        https://bugs.webkit.org/show_bug.cgi?id=179000
+
+        Reviewed by Darin Adler and Yusuke Suzuki.
+
+        * Scripts/run-jsc-stress-tests:
+
 2017-12-12  Carlos Alberto Lopez Perez  <clopez@igalia.com>
 

trunk/Tools/Scripts/run-jsc-stress-tests

@@ -617 +617 @@
 end
 
+def runBigIntEnabled(*optionalTestSpecificOptions)
+    run("big-int-enabled", "--useBigInt=true" , *(FTL_OPTIONS + optionalTestSpecificOptions))
+end
+
 def runFTLNoCJIT(*optionalTestSpecificOptions)
     run("misc-ftl-no-cjit", *(FTL_OPTIONS + NO_CJIT_OPTIONS + optionalTestSpecificOptions))