1. 20 Jan, 2014 1 commit
    • akling@apple.com's avatar
      JSC Parser: Shrink BindingNode. · bdf5d1d4
      akling@apple.com authored
      <https://webkit.org/b/127253>
      
      The "divot" and "end" source locations are always identical for
      BindingNodes, so store only "start" and "end" instead.
      
      1.19 MB progression on Membuster3.
      
      Reviewed by Geoff Garen.
      
      * bytecompiler/NodesCodegen.cpp:
      (JSC::BindingNode::bindValue):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createBindingLocation):
      * parser/NodeConstructors.h:
      (JSC::BindingNode::create):
      (JSC::BindingNode::BindingNode):
      * parser/Nodes.h:
      (JSC::BindingNode::divotStart):
      (JSC::BindingNode::divotEnd):
      * parser/Parser.cpp:
      (JSC::Parser<LexerType>::createBindingPattern):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::operatorStackPop):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@162393 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      bdf5d1d4
  2. 22 Oct, 2013 1 commit
  3. 21 Oct, 2013 1 commit
    • oliver@apple.com's avatar
      Source/JavaScriptCore: Support computed property names in object literals · 72d3832f
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=123112
      
      Reviewed by Michael Saboff.
      
      Add support for computed property names to the parser.
      
      * bytecompiler/NodesCodegen.cpp:
      (JSC::PropertyListNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createProperty):
      (JSC::ASTBuilder::getName):
      * parser/NodeConstructors.h:
      (JSC::PropertyNode::PropertyNode):
      * parser/Nodes.h:
      (JSC::PropertyNode::expressionName):
      (JSC::PropertyNode::name):
      * parser/Parser.cpp:
      (JSC::::parseProperty):
      (JSC::::parseStrictObjectLiteral):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::Property::Property):
      (JSC::SyntaxChecker::createProperty):
      (JSC::SyntaxChecker::operatorStackPop):
      
      LayoutTests: Support expression property names in object literals
      https://bugs.webkit.org/show_bug.cgi?id=123112
      
      Reviewed by Michael Saboff.
      
      Add tests
      
      * js/basic-computed-property-name-expected.txt: Added.
      * js/basic-computed-property-name.html: Added.
      * js/parser-syntax-check-expected.txt:
      * js/script-tests/basic-computed-property-name.js: Added.
      (a.string_appeared_here.runTest):
      * js/script-tests/parser-syntax-check.js:
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@157724 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      72d3832f
  4. 16 Oct, 2013 3 commits
    • oliver@apple.com's avatar
      Source/JavaScriptCore: Implement ES6 spread operator · 72f8a820
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=122911
      
      Reviewed by Michael Saboff.
      
      Implement the ES6 spread operator
      
      This has a little bit of refactoring to move the enumeration logic out ForOfNode
      and into BytecodeGenerator, and then adds the logic to make it nicely callback
      driven.
      
      The rest of the logic is just the addition of the SpreadExpressionNode, the parsing,
      and actually handling the spread.
      
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitNewArray):
      (JSC::BytecodeGenerator::emitCall):
      (JSC::BytecodeGenerator::emitEnumeration):
      * bytecompiler/BytecodeGenerator.h:
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::emitBytecode):
      (JSC::ForOfNode::emitBytecode):
      (JSC::SpreadExpressionNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createSpreadExpression):
      * parser/Lexer.cpp:
      (JSC::::lex):
      * parser/NodeConstructors.h:
      (JSC::SpreadExpressionNode::SpreadExpressionNode):
      * parser/Nodes.h:
      (JSC::ExpressionNode::isSpreadExpression):
      (JSC::SpreadExpressionNode::expression):
      * parser/Parser.cpp:
      (JSC::::parseArrayLiteral):
      (JSC::::parseArguments):
      (JSC::::parseMemberExpression):
      * parser/Parser.h:
      (JSC::Parser::getTokenName):
      (JSC::Parser::updateErrorMessageSpecialCase):
      * parser/ParserTokens.h:
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createSpreadExpression):
      
      LayoutTests: Implement spread
      https://bugs.webkit.org/show_bug.cgi?id=122911
      
      Reviewed by Michael Saboff.
      
      Add testcases
      
      * js/basic-spread-expected.txt: Added.
      * js/basic-spread.html: Added.
      * js/parser-syntax-check-expected.txt:
      * js/script-tests/basic-spread.js: Added.
      (f):
      (o.f.o.f.o.f.o.f.h.eval.o.h.o.h.o.h.o.h.g):
      * js/script-tests/parser-syntax-check.js:
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@157545 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      72f8a820
    • commit-queue@webkit.org's avatar
      Unreviewed, rolling out r157529. · dbc42576
      commit-queue@webkit.org authored
      http://trac.webkit.org/changeset/157529
      https://bugs.webkit.org/show_bug.cgi?id=122919
      
      Caused score test failures and some build failures. (Requested
      by rfong on #webkit).
      
      Source/JavaScriptCore:
      
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitNewArray):
      (JSC::BytecodeGenerator::emitCall):
      (JSC::BytecodeGenerator::emitReadOnlyExceptionIfNeeded):
      * bytecompiler/BytecodeGenerator.h:
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::emitBytecode):
      (JSC::CallArguments::CallArguments):
      (JSC::ForOfNode::emitBytecode):
      (JSC::BindingNode::collectBoundIdentifiers):
      * parser/ASTBuilder.h:
      * parser/Lexer.cpp:
      (JSC::::lex):
      * parser/NodeConstructors.h:
      (JSC::DotAccessorNode::DotAccessorNode):
      * parser/Nodes.h:
      * parser/Parser.cpp:
      (JSC::::parseArrayLiteral):
      (JSC::::parseArguments):
      (JSC::::parseMemberExpression):
      * parser/Parser.h:
      (JSC::Parser::getTokenName):
      (JSC::Parser::updateErrorMessageSpecialCase):
      * parser/ParserTokens.h:
      * parser/SyntaxChecker.h:
      
      LayoutTests:
      
      * js/basic-spread-expected.txt: Removed.
      * js/basic-spread.html: Removed.
      * js/parser-syntax-check-expected.txt:
      * js/script-tests/basic-spread.js: Removed.
      * js/script-tests/parser-syntax-check.js:
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@157536 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      dbc42576
    • oliver@apple.com's avatar
      Source/JavaScriptCore: Implement ES6 spread operator · dd4e38f6
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=122911
      
      Reviewed by Michael Saboff.
      
      Implement the ES6 spread operator
      
      This has a little bit of refactoring to move the enumeration logic out ForOfNode
      and into BytecodeGenerator, and then adds the logic to make it nicely callback
      driven.
      
      The rest of the logic is just the addition of the SpreadExpressionNode, the parsing,
      and actually handling the spread.
      
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitNewArray):
      (JSC::BytecodeGenerator::emitCall):
      (JSC::BytecodeGenerator::emitEnumeration):
      * bytecompiler/BytecodeGenerator.h:
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::emitBytecode):
      (JSC::ForOfNode::emitBytecode):
      (JSC::SpreadExpressionNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createSpreadExpression):
      * parser/Lexer.cpp:
      (JSC::::lex):
      * parser/NodeConstructors.h:
      (JSC::SpreadExpressionNode::SpreadExpressionNode):
      * parser/Nodes.h:
      (JSC::ExpressionNode::isSpreadExpression):
      (JSC::SpreadExpressionNode::expression):
      * parser/Parser.cpp:
      (JSC::::parseArrayLiteral):
      (JSC::::parseArguments):
      (JSC::::parseMemberExpression):
      * parser/Parser.h:
      (JSC::Parser::getTokenName):
      (JSC::Parser::updateErrorMessageSpecialCase):
      * parser/ParserTokens.h:
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createSpreadExpression):
      
      LayoutTests: Implement spread
      https://bugs.webkit.org/show_bug.cgi?id=122911
      
      Reviewed by Michael Saboff.
      
      Add testcases
      
      * js/basic-spread-expected.txt: Added.
      * js/basic-spread.html: Added.
      * js/parser-syntax-check-expected.txt:
      * js/script-tests/basic-spread.js: Added.
      (f):
      (o.f.o.f.o.f.o.f.h.eval.o.h.o.h.o.h.o.h.g):
      * js/script-tests/parser-syntax-check.js:
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@157529 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      dd4e38f6
  5. 04 Oct, 2013 1 commit
    • oliver@apple.com's avatar
      Support for-of syntax · 20a9bf08
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=122339
      
      Reviewed by Geoffrey Garen.
      
      Source/JavaScriptCore:
      
      Add support for for-of syntax to JSC.  As part of doing this I had to make
      us support unique empty strings as identifiers.  In a follow on patch i'm
      going to remove the distinction entirely as it's purely a complicating
      separation.
      
      Otherwise the logic here is fairly self-explanatory.
      
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::addConstant):
      (JSC::BytecodeGenerator::emitCall):
      * bytecompiler/BytecodeGenerator.h:
      * bytecompiler/NodesCodegen.cpp:
      (JSC::CallArguments::CallArguments):
      (JSC::ForOfNode::emitBytecode):
      * jit/JITOperations.cpp:
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createForOfLoop):
      * parser/NodeConstructors.h:
      (JSC::EnumerationNode::EnumerationNode):
      (JSC::ForInNode::ForInNode):
      (JSC::ForOfNode::ForOfNode):
      * parser/Nodes.h:
      * parser/Parser.cpp:
      (JSC::::parseVarDeclarationList):
      (JSC::::parseForStatement):
      * parser/Parser.h:
      (JSC::Parser::isofToken):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createForOfLoop):
      * runtime/ArrayIteratorPrototype.cpp:
      (JSC::ArrayIteratorPrototype::finishCreation):
      (JSC::arrayIteratorPrototypeIterate):
      * runtime/ArrayPrototype.cpp:
      (JSC::ArrayPrototype::create):
      (JSC::ArrayPrototype::finishCreation):
      * runtime/ArrayPrototype.h:
      * runtime/CommonIdentifiers.cpp:
      (JSC::CommonIdentifiers::CommonIdentifiers):
      * runtime/CommonIdentifiers.h:
      * runtime/Identifier.h:
      (JSC::Identifier::from):
      * runtime/JSCJSValue.cpp:
      (JSC::JSValue::dumpInContext):
      * runtime/JSGlobalObject.cpp:
      (JSC::JSGlobalObject::reset):
      * runtime/JSObject.cpp:
      (JSC::JSObject::putDirectNativeFunction):
      * runtime/PrivateName.h:
      (JSC::PrivateName::PrivateName):
      * runtime/PropertyName.h:
      (JSC::PropertyName::PropertyName):
      
      Source/WTF:
      
      Update assertions and add a helper function to StringImpl
      to save repeated unique or identifier calls.
      
      * wtf/text/StringImpl.h:
      (WTF::StringImpl::isIdentifierOrUnique):
      (WTF::StringImpl::setIsIdentifier):
      (WTF::StringImpl::setIsAtomic):
      
      LayoutTests:
      
      Add test cases for the one type that supports for-of so far
      
      * js/basic-for-of-expected.txt: Added.
      * js/basic-for-of.html: Added.
      * js/regress/for-of-iterate-array-entries.html: Added.
      * js/regress/for-of-iterate-array-keys.html: Added.
      * js/regress/for-of-iterate-array-values.html: Added.
      * js/regress/script-tests/for-of-iterate-array-entries.js: Added.
      (foo):
      * js/regress/script-tests/for-of-iterate-array-keys.js: Added.
      (foo):
      * js/regress/script-tests/for-of-iterate-array-values.js: Added.
      (foo):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@156910 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      20a9bf08
  6. 02 Oct, 2013 1 commit
  7. 01 Oct, 2013 1 commit
    • fpizlo@apple.com's avatar
      REGRESSION(156464): 50% regression on SunSpider/string-fasta · 4d456e7b
      fpizlo@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=122202
      
      Source/JavaScriptCore: 
      
      Unreviewed, roll out r156464.
              
      This is a progression on string-fasta, since it fixes the regression.
      
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::UnlinkedFunctionExecutable::paramString):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::BytecodeGenerator):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitExpressionInfo):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ForInNode::emitBytecode):
      (JSC::FuncExprNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createFormalParameterList):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::addVar):
      * parser/NodeConstructors.h:
      (JSC::CommaNode::CommaNode):
      (JSC::ParameterNode::ParameterNode):
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.cpp:
      (JSC::FunctionParameters::create):
      (JSC::FunctionParameters::FunctionParameters):
      (JSC::FunctionParameters::~FunctionParameters):
      * parser/Nodes.h:
      (JSC::ExpressionNode::isDotAccessorNode):
      (JSC::CommaNode::append):
      (JSC::ParameterNode::ident):
      (JSC::FunctionParameters::at):
      (JSC::FunctionParameters::identifiers):
      * parser/Parser.cpp:
      (JSC::::Parser):
      (JSC::::parseVarDeclaration):
      (JSC::::parseVarDeclarationList):
      (JSC::::parseForStatement):
      (JSC::::parseFormalParameters):
      (JSC::::parseAssignmentExpression):
      * parser/Parser.h:
      (JSC::Scope::declareParameter):
      (JSC::Parser::declareParameter):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createFormalParameterList):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::operatorStackPop):
      * runtime/JSONObject.cpp:
      * runtime/JSONObject.h:
      
      LayoutTests: 
      
      Unreviewed, roll out r156464.
      
      * js/destructuring-assignment-expected.txt: Removed.
      * js/destructuring-assignment.html: Removed.
      * js/mozilla/strict/13.1-expected.txt:
      * js/mozilla/strict/regress-532254-expected.txt:
      * js/mozilla/strict/script-tests/13.1.js:
      * js/regress/destructuring-arguments-expected.txt: Removed.
      * js/regress/destructuring-arguments-length-expected.txt: Removed.
      * js/regress/destructuring-arguments-length.html: Removed.
      * js/regress/destructuring-arguments.html: Removed.
      * js/regress/destructuring-swap-expected.txt: Removed.
      * js/regress/destructuring-swap.html: Removed.
      * js/regress/script-tests/destructuring-arguments-length.js: Removed.
      * js/regress/script-tests/destructuring-arguments.js: Removed.
      * js/regress/script-tests/destructuring-swap.js: Removed.
      * js/script-tests/destructuring-assignment.js: Removed.
      * sputnik/Conformance/13_Function_Definition/S13_A5.html:
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@156757 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      4d456e7b
  8. 26 Sep, 2013 3 commits
    • oliver@apple.com's avatar
      2013-09-25 Oliver Hunt <oliver@apple.com> · f1ae6d11
      oliver@apple.com authored
              Implement prefixed-destructuring assignment
              https://bugs.webkit.org/show_bug.cgi?id=121930
      
              Reviewed by Mark Hahnenberg.
      
              Relanding with fix after rollout
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@156514 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      f1ae6d11
    • commit-queue@webkit.org's avatar
      Unreviewed, rolling out r156464 and r156480. · c68e9807
      commit-queue@webkit.org authored
      http://trac.webkit.org/changeset/156464
      http://trac.webkit.org/changeset/156480
      https://bugs.webkit.org/show_bug.cgi?id=121981
      
      Leaking too much and killi
      ng buildbot. (Requested by xenon on
      #webkit).
      
      Source/JavaScriptCore:
      
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::UnlinkedFunctionExecutable::paramString):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::BytecodeGenerator):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitExpressionInfo):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ForInNode::emitBytecode):
      (JSC::FuncExprNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createFormalParameterList):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::addVar):
      * parser/NodeConstructors.h:
      (JSC::CommaNode::CommaNode):
      (JSC::ParameterNode::ParameterNode):
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.cpp:
      (JSC::FunctionParameters::create):
      (JSC::FunctionParameters::FunctionParameters):
      (JSC::FunctionParameters::~FunctionParameters):
      * parser/Nodes.h:
      (JSC::CommaNode::append):
      (JSC::ParameterNode::ident):
      (JSC::FunctionParameters::at):
      (JSC::FunctionParameters::identifiers):
      * parser/Parser.cpp:
      (JSC::::Parser):
      (JSC::::parseVarDeclaration):
      (JSC::::parseVarDeclarationList):
      (JSC::::parseForStatement):
      (JSC::::parseFormalParameters):
      (JSC::::parseAssignmentExpression):
      * parser/Parser.h:
      (JSC::Scope::declareParameter):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createFormalParameterList):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::operatorStackPop):
      * runtime/JSONObject.cpp:
      * runtime/JSONObject.h:
      
      LayoutTests:
      
      * js/destructuring-assignment-expected.txt: Removed.
      * js/destructuring-assignment.html: Removed.
      * js/mozilla/strict/13.1-expected.txt:
      * js/mozilla/strict/regress-532254-expected.txt:
      * js/mozilla/strict/script-tests/13.1.js:
      * js/regress/destructuring-arguments-expected.txt: Removed.
      * js/regress/destructuring-arguments-length-expected.txt: Removed.
      * js/regress/destructuring-arguments-length.html: Removed.
      * js/regress/destructuring-arguments.html: Removed.
      * js/regress/destructuring-swap-expected.txt: Removed.
      * js/regress/destructuring-swap.html: Removed.
      * js/regress/script-tests/destructuring-arguments-length.js: Removed.
      * js/regress/script-tests/destructuring-arguments.js: Removed.
      * js/regress/script-tests/destructuring-swap.js: Removed.
      * js/script-tests/destructuring-assignment.js: Removed.
      * sputnik/Conformance/13_Function_Definition/S13_A5.html:
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@156497 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      c68e9807
    • oliver@apple.com's avatar
      Implement prefixed-destructuring assignment · aeca5dcd
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=121930
      
      Reviewed by Mark Hahnenberg.
      
      Source/JavaScriptCore:
      
      This is mostly simple - the semantics of deconstruction are already
      present in the language, so most of the complexity (if you call it
      that) is addition of new AST nodes, and parsing the syntax.
      
      In order to get correct semantics for the parameter lists, FunctionParameters
      now needs to store refcounted references to the parameter patterns.
      There's also a little work to ensure that variable creation and assignment
      occurs in the correct order while the BytecodeGenerator is being constructed.
      
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::UnlinkedFunctionExecutable::paramString):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::BytecodeGenerator):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitExpressionInfo):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ForInNode::emitBytecode):
      (JSC::DeconstructingAssignmentNode::emitBytecode):
      (JSC::DeconstructionPatternNode::~DeconstructionPatternNode):
      (JSC::ArrayPatternNode::emitBytecode):
      (JSC::ArrayPatternNode::emitDirectBinding):
      (JSC::ArrayPatternNode::toString):
      (JSC::ArrayPatternNode::collectBoundIdentifiers):
      (JSC::ObjectPatternNode::toString):
      (JSC::ObjectPatternNode::emitBytecode):
      (JSC::ObjectPatternNode::collectBoundIdentifiers):
      (JSC::BindingNode::emitBytecode):
      (JSC::BindingNode::toString):
      (JSC::BindingNode::collectBoundIdentifiers):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createFormalParameterList):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::addVar):
      (JSC::ASTBuilder::createDeconstructingAssignment):
      (JSC::ASTBuilder::createArrayPattern):
      (JSC::ASTBuilder::appendArrayPatternSkipEntry):
      (JSC::ASTBuilder::appendArrayPatternEntry):
      (JSC::ASTBuilder::createObjectPattern):
      (JSC::ASTBuilder::appendObjectPatternEntry):
      (JSC::ASTBuilder::createBindingLocation):
      * parser/NodeConstructors.h:
      (JSC::CommaNode::CommaNode):
      (JSC::ParameterNode::ParameterNode):
      (JSC::ForInNode::ForInNode):
      (JSC::DeconstructionPatternNode::DeconstructionPatternNode):
      (JSC::ArrayPatternNode::ArrayPatternNode):
      (JSC::ArrayPatternNode::create):
      (JSC::ObjectPatternNode::ObjectPatternNode):
      (JSC::ObjectPatternNode::create):
      (JSC::BindingNode::create):
      (JSC::BindingNode::BindingNode):
      (JSC::DeconstructingAssignmentNode::DeconstructingAssignmentNode):
      * parser/Nodes.cpp:
      (JSC::FunctionParameters::create):
      (JSC::FunctionParameters::FunctionParameters):
      (JSC::FunctionParameters::~FunctionParameters):
      * parser/Nodes.h:
      (JSC::ExpressionNode::isDeconstructionNode):
      (JSC::ArrayNode::elements):
      (JSC::CommaNode::append):
      (JSC::ParameterNode::pattern):
      (JSC::FunctionParameters::at):
      (JSC::FunctionParameters::patterns):
      (JSC::DeconstructionPatternNode::isBindingNode):
      (JSC::DeconstructionPatternNode::emitDirectBinding):
      (JSC::ArrayPatternNode::appendIndex):
      (JSC::ObjectPatternNode::appendEntry):
      (JSC::ObjectPatternNode::Entry::Entry):
      (JSC::BindingNode::boundProperty):
      (JSC::BindingNode::isBindingNode):
      (JSC::DeconstructingAssignmentNode::bindings):
      (JSC::DeconstructingAssignmentNode::isLocation):
      (JSC::DeconstructingAssignmentNode::isDeconstructionNode):
      * parser/Parser.cpp:
      (JSC::::Parser):
      (JSC::::parseVarDeclaration):
      (JSC::::parseVarDeclarationList):
      (JSC::::createBindingPattern):
      (JSC::::parseDeconstructionPattern):
      (JSC::::parseForStatement):
      (JSC::::parseFormalParameters):
      (JSC::::parseAssignmentExpression):
      * parser/Parser.h:
      (JSC::Scope::declareBoundParameter):
      (JSC::Parser::declareBoundParameter):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createFormalParameterList):
      (JSC::SyntaxChecker::addVar):
      (JSC::SyntaxChecker::operatorStackPop):
      * runtime/JSONObject.cpp:
      (JSC::escapeStringToBuilder):
      * runtime/JSONObject.h:
      
      LayoutTests:
      
      Add enw tests, and update old ones.
      
      * js/destructuring-assignment-expected.txt: Added.
      * js/destructuring-assignment.html: Added.
      * js/mozilla/strict/13.1-expected.txt:
      * js/mozilla/strict/regress-532254-expected.txt:
      * js/mozilla/strict/script-tests/13.1.js:
      * js/regress/destructuring-arguments-expected.txt: Added.
      * js/regress/destructuring-arguments-length-expected.txt: Added.
      * js/regress/destructuring-arguments-length.html: Added.
      * js/regress/destructuring-arguments.html: Added.
      * js/regress/destructuring-swap-expected.txt: Added.
      * js/regress/destructuring-swap.html: Added.
      * js/regress/script-tests/destructuring-arguments-length.js: Added.
      (foo):
      * js/regress/script-tests/destructuring-arguments.js: Added.
      (foo):
      * js/regress/script-tests/destructuring-swap.js: Added.
      (foo):
      * js/script-tests/destructuring-assignment.js: Added.
      (testDestructuring):
      (testDeconstructArgs):
      (testDeconstructArgLength):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@156464 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      aeca5dcd
  9. 13 Sep, 2013 1 commit
    • oliver@apple.com's avatar
      Try to kill initialiser expression in for-in statements · 8788100d
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=121311
      
      Reviewed by Gavin Barraclough.
      
      Source/JavaScriptCore:
      
      We'd like to get rid of this pointless initialiser expression
      in for-in statements.  Unfortunately we have to keep the no_in
      variant of expression parsing to avoid ambiguity in the grammar.
      There's a possibility that this will need to be rolled out, but
      we'll need to live on it to see.
      
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ForInNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createForInLoop):
      * parser/NodeConstructors.h:
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.h:
      * parser/Parser.cpp:
      (JSC::::parseForStatement):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createForInLoop):
      
      LayoutTests:
      
      Update test cases to represent the new reality
      
      * js/line-column-numbers-expected.txt:
      * js/line-column-numbers.html:
      * js/parser-syntax-check-expected.txt:
      * js/script-tests/function-declaration-statement.js:
      * js/script-tests/line-column-numbers.js:
      (try.toFuzz22b):
      * js/script-tests/parser-syntax-check.js:
      * js/script-tests/toString-for-var-decl.js:
      (f1):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@155724 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      8788100d
  10. 30 Jul, 2013 1 commit
    • mark.lam@apple.com's avatar
      Fix problems with divot and lineStart mismatches. · 3b256ca6
      mark.lam@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=118662.
      
      Reviewed by Oliver Hunt.
      
      Source/JavaScriptCore: 
      
      r152494 added the recording of lineStart values for divot positions.
      This is needed for the computation of column numbers. Similarly, it also
      added the recording of line numbers for the divot positions. One problem
      with the approach taken was that the line and lineStart values were
      recorded independently, and hence were not always guaranteed to be
      sampled at the same place that the divot position is recorded. This
      resulted in potential mismatches that cause some assertions to fail.
      
      The solution is to introduce a JSTextPosition abstraction that records
      the divot position, line, and lineStart as a single quantity. Wherever
      we record the divot position as an unsigned int previously, we now record
      its JSTextPosition which captures all 3 values in one go. This ensures
      that the captured line and lineStart will always match the captured divot
      position.
      
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitCall):
      (JSC::BytecodeGenerator::emitCallEval):
      (JSC::BytecodeGenerator::emitCallVarargs):
      (JSC::BytecodeGenerator::emitConstruct):
      (JSC::BytecodeGenerator::emitDebugHook):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitExpressionInfo):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ThrowableExpressionData::emitThrowReferenceError):
      (JSC::ResolveNode::emitBytecode):
      (JSC::BracketAccessorNode::emitBytecode):
      (JSC::DotAccessorNode::emitBytecode):
      (JSC::NewExprNode::emitBytecode):
      (JSC::EvalFunctionCallNode::emitBytecode):
      (JSC::FunctionCallValueNode::emitBytecode):
      (JSC::FunctionCallResolveNode::emitBytecode):
      (JSC::FunctionCallBracketNode::emitBytecode):
      (JSC::FunctionCallDotNode::emitBytecode):
      (JSC::CallFunctionCallDotNode::emitBytecode):
      (JSC::ApplyFunctionCallDotNode::emitBytecode):
      (JSC::PostfixNode::emitResolve):
      (JSC::PostfixNode::emitBracket):
      (JSC::PostfixNode::emitDot):
      (JSC::DeleteResolveNode::emitBytecode):
      (JSC::DeleteBracketNode::emitBytecode):
      (JSC::DeleteDotNode::emitBytecode):
      (JSC::PrefixNode::emitResolve):
      (JSC::PrefixNode::emitBracket):
      (JSC::PrefixNode::emitDot):
      (JSC::UnaryOpNode::emitBytecode):
      (JSC::BinaryOpNode::emitStrcat):
      (JSC::BinaryOpNode::emitBytecode):
      (JSC::ThrowableBinaryOpNode::emitBytecode):
      (JSC::InstanceOfNode::emitBytecode):
      (JSC::emitReadModifyAssignment):
      (JSC::ReadModifyResolveNode::emitBytecode):
      (JSC::AssignResolveNode::emitBytecode):
      (JSC::AssignDotNode::emitBytecode):
      (JSC::ReadModifyDotNode::emitBytecode):
      (JSC::AssignBracketNode::emitBytecode):
      (JSC::ReadModifyBracketNode::emitBytecode):
      (JSC::ForInNode::emitBytecode):
      (JSC::WithNode::emitBytecode):
      (JSC::ThrowNode::emitBytecode):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * parser/ASTBuilder.h:
      - Replaced ASTBuilder::PositionInfo with JSTextPosition.
      (JSC::ASTBuilder::BinaryOpInfo::BinaryOpInfo):
      (JSC::ASTBuilder::AssignmentInfo::AssignmentInfo):
      (JSC::ASTBuilder::createResolve):
      (JSC::ASTBuilder::createBracketAccess):
      (JSC::ASTBuilder::createDotAccess):
      (JSC::ASTBuilder::createRegExp):
      (JSC::ASTBuilder::createNewExpr):
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createLabelStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::appendBinaryExpressionInfo):
      (JSC::ASTBuilder::appendUnaryToken):
      (JSC::ASTBuilder::unaryTokenStackLastStart):
      (JSC::ASTBuilder::assignmentStackAppend):
      (JSC::ASTBuilder::createAssignment):
      (JSC::ASTBuilder::setExceptionLocation):
      (JSC::ASTBuilder::makeDeleteNode):
      (JSC::ASTBuilder::makeFunctionCallNode):
      (JSC::ASTBuilder::makeBinaryNode):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * parser/Lexer.cpp:
      (JSC::::lex):
      - Added support for capturing the appropriate JSTextPositions instead
        of just the character offset.
      * parser/Lexer.h:
      (JSC::Lexer::currentPosition):
      (JSC::::lexExpectIdentifier):
      - Added support for capturing the appropriate JSTextPositions instead
        of just the character offset.
      * parser/NodeConstructors.h:
      (JSC::Node::Node):
      (JSC::ResolveNode::ResolveNode):
      (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
      (JSC::FunctionCallValueNode::FunctionCallValueNode):
      (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
      (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
      (JSC::FunctionCallDotNode::FunctionCallDotNode):
      (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
      (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
      (JSC::PostfixNode::PostfixNode):
      (JSC::DeleteResolveNode::DeleteResolveNode):
      (JSC::DeleteBracketNode::DeleteBracketNode):
      (JSC::DeleteDotNode::DeleteDotNode):
      (JSC::PrefixNode::PrefixNode):
      (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
      (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
      (JSC::AssignBracketNode::AssignBracketNode):
      (JSC::AssignDotNode::AssignDotNode):
      (JSC::ReadModifyDotNode::ReadModifyDotNode):
      (JSC::AssignErrorNode::AssignErrorNode):
      (JSC::WithNode::WithNode):
      (JSC::ForInNode::ForInNode):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * parser/Nodes.cpp:
      (JSC::StatementNode::setLoc):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * parser/Nodes.h:
      (JSC::Node::lineNo):
      (JSC::Node::startOffset):
      (JSC::Node::lineStartOffset):
      (JSC::Node::position):
      (JSC::ThrowableExpressionData::ThrowableExpressionData):
      (JSC::ThrowableExpressionData::setExceptionSourceCode):
      (JSC::ThrowableExpressionData::divot):
      (JSC::ThrowableExpressionData::divotStart):
      (JSC::ThrowableExpressionData::divotEnd):
      (JSC::ThrowableSubExpressionData::ThrowableSubExpressionData):
      (JSC::ThrowableSubExpressionData::setSubexpressionInfo):
      (JSC::ThrowableSubExpressionData::subexpressionDivot):
      (JSC::ThrowableSubExpressionData::subexpressionStart):
      (JSC::ThrowableSubExpressionData::subexpressionEnd):
      (JSC::ThrowablePrefixedSubExpressionData::ThrowablePrefixedSubExpressionData):
      (JSC::ThrowablePrefixedSubExpressionData::setSubexpressionInfo):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionDivot):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionStart):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionEnd):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * parser/Parser.cpp:
      (JSC::::Parser):
      (JSC::::parseInner):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      (JSC::::didFinishParsing):
      - Remove setting of m_lastLine value. We always pass in the value from
        m_lastLine anyway. So, this assignment is effectively a nop.
      (JSC::::parseVarDeclaration):
      (JSC::::parseVarDeclarationList):
      (JSC::::parseForStatement):
      (JSC::::parseBreakStatement):
      (JSC::::parseContinueStatement):
      (JSC::::parseReturnStatement):
      (JSC::::parseThrowStatement):
      (JSC::::parseWithStatement):
      (JSC::::parseTryStatement):
      (JSC::::parseBlockStatement):
      (JSC::::parseFunctionDeclaration):
      (JSC::LabelInfo::LabelInfo):
      (JSC::::parseExpressionOrLabelStatement):
      (JSC::::parseExpressionStatement):
      (JSC::::parseAssignmentExpression):
      (JSC::::parseBinaryExpression):
      (JSC::::parseProperty):
      (JSC::::parsePrimaryExpression):
      (JSC::::parseMemberExpression):
      (JSC::::parseUnaryExpression):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * parser/Parser.h:
      (JSC::Parser::next):
      (JSC::Parser::nextExpectIdentifier):
      (JSC::Parser::getToken):
      (JSC::Parser::tokenStartPosition):
      (JSC::Parser::tokenEndPosition):
      (JSC::Parser::lastTokenEndPosition):
      (JSC::::parse):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      * parser/ParserTokens.h:
      (JSC::JSTextPosition::JSTextPosition):
      (JSC::JSTextPosition::operator+):
      (JSC::JSTextPosition::operator-):
      (JSC::JSTextPosition::operator int):
      - Added JSTextPosition.
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::makeFunctionCallNode):
      (JSC::SyntaxChecker::makeAssignNode):
      (JSC::SyntaxChecker::makePrefixNode):
      (JSC::SyntaxChecker::makePostfixNode):
      (JSC::SyntaxChecker::makeDeleteNode):
      (JSC::SyntaxChecker::createResolve):
      (JSC::SyntaxChecker::createBracketAccess):
      (JSC::SyntaxChecker::createDotAccess):
      (JSC::SyntaxChecker::createRegExp):
      (JSC::SyntaxChecker::createNewExpr):
      (JSC::SyntaxChecker::createAssignResolve):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::createReturnStatement):
      (JSC::SyntaxChecker::createBreakStatement):
      (JSC::SyntaxChecker::createContinueStatement):
      (JSC::SyntaxChecker::createWithStatement):
      (JSC::SyntaxChecker::createLabelStatement):
      (JSC::SyntaxChecker::createThrowStatement):
      (JSC::SyntaxChecker::appendBinaryExpressionInfo):
      (JSC::SyntaxChecker::operatorStackPop):
      - Use JSTextPosition instead of passing line and lineStart explicitly.
      
      LayoutTests: 
      
      Added regression test cases from https://bugs.webkit.org/show_bug.cgi?id=118662
      and https://bugs.webkit.org/show_bug.cgi?id=118664.
      
      * fast/js/line-column-numbers-expected.txt:
      * fast/js/line-column-numbers.html:
      * fast/js/script-tests/line-column-numbers.js:
      (try.toFuzz1):
      (try.toFuzz2):
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@153477 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      3b256ca6
  11. 09 Jul, 2013 1 commit
    • mark.lam@apple.com's avatar
      Fix 30% JSBench regression (caused by adding column numbers to stack traces). · 5b45f90a
      mark.lam@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=118481.
      
      Reviewed by Mark Hahnenberg and Geoffrey Garen.
      
      Source/JavaScriptCore: 
      
      Previously, we already capture ExpressionRangeInfo that provides a divot for
      each bytecode that can potentially throw an exception (and therefore generate
      a stack trace). On first attempt to compute column numbers, we then do a walk
      of the source string to record all line start positions in a table associated
      with the SourceProvider. The column number can then be computed as
          divot - lineStartFor(bytecodeOffset).
      
      The computation of this lineStarts table is the source of the 30% JSBench
      performance regression.
      
      The new code now records lineStarts as the lexer and parser scans the source
      code. These lineStarts are then used to compute the column number for the
      given divot, and stored in the ExpressionRangeInfo. Similarly, we also capture
      the line number at the divot point and store that in the ExpressionRangeInfo.
      Hence, to look up line and column numbers, we now lookup the ExpressionRangeInfo
      for the bytecodeOffset, and then compute the line and column from the values
      stored in the expression info.
      
      The strategy:
      1. We want to minimize perturbations to the lexer and parser. Specifically,
         the changes added should not change how it scans code, and generate bytecode.
      2. We regard the divot as the source character position we are interested
         in. As such, we'll capture line and lineStart (for column) at the point
         when we capture the divot information. This ensures that the 3 values are
         consistent.
      
      How the change is done:
      1. Change the lexer to track lineStarts.
      2. Change the parser to capture line and lineStarts at the point of capturing
         divots.
      3. Change the parser and associated code to plumb these values all the way to
         the point that the correspoinding ExpressionRangeInfo is emitted.
      4. Propagate and record SourceCode firstLine and firstLineColumnOffset to the
         the necessary places so that we can add them as needed when reifying
         UnlinkedCodeBlocks into CodeBlocks.
      5. Compress the line and column number values in the ExpressionRangeInfo. In
         practice, we seldom have both large line and column numbers. Hence, we can
         encode both in an uint32_t most of the time. For the times when we encounter
         both large line and column numbers, we have a fallback to store the "fat"
         position info.
      6. Emit an ExpressionRangeInfo for UnaryOp nodes to get more line and column
         number coverage.
      7. Change the interpreter to use the new way of computing line and column.
      8. Delete old line and column computation code that is now unused.
      
      Misc details:
      - the old lexer was tracking both a startOffset and charPosition where
        charPosition equals startOffset - SourceCode.startOffset. We now use
        startOffset exclusively throughout the system for consistency.
        All offset values (including lineStart) are relative to the start of the
        SourceProvider string. These values will only be converted to be relative
        to the SourceCode.startOffset at the very last minute i.e. when the divot
        is stored into the ExpressionRangeInfo.
      
        This change to use the same offset system everywhere reduces confusion
        from having to convert back and forth between the 2 systems. It also
        enables a lot of assertions to be used.
      
      - Also fixed some bugs in the choice of divot positions to use. For example,
        both Eval and Function expressions previously used column numbers from
        the start of the expression but used the line number at the end of the
        expression. This is now fixed to use either the start or end positions
        as appropriate, but not a mix of line and columns from both.
      
      - Why use ints instead of unsigneds for offsets and lineStarts inside the
        lexer and parser?
        Some tests (e.g. fast/js/call-base-resolution.html and
        fast/js/eval-cross-window.html) has shown that lineStart offsets can be
        prior to the SourceCode.startOffset. Keeping the lexer offsets as ints
        simplifies computations and makes it easier to maintain the assertions
        that (startOffset >= lineStartOffset).
      
        However, column and line numbers are always unsigned when we publish
        them to the ExpressionRangeInfo. The ints are only used inside the
        lexer and parser ... well, and bytecode generator.
      
      - For all cases, lineStart is always captured where the divot is captured.
        However, some sputnik conformance tests have shown that we cannot honor
        line breaks for assignment statements like the following:
      
            eval("x\u000A*=\u000A-1;");
      
        In this case, the lineStart is expected to be captured at the start of
        the assignment expression instead of at the divot point in the middle.
        The assignment expression is the only special case for this.
      
      This patch has been tested against the full layout tests both with release
      and debug builds with no regression.
      
      * API/JSContextRef.cpp:
      (JSContextCreateBacktrace):
        - Updated to use the new StackFrame::computeLineAndColumn().
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::CodeBlock):
        - Added m_firstLineColumnOffset initialization.
        - Plumbed the firstLineColumnOffset into the SourceCode.
        - Initialized column for op_debug using the new way.
      (JSC::CodeBlock::lineNumberForBytecodeOffset):
        - Changed to compute line number using the ExpressionRangeInfo.
      (JSC::CodeBlock::columnNumberForBytecodeOffset): Added
        - Changed to compute column number using the ExpressionRangeInfo.
      (JSC::CodeBlock::expressionRangeForBytecodeOffset):
      * bytecode/CodeBlock.h:
      (JSC::CodeBlock::firstLineColumnOffset):
      (JSC::GlobalCodeBlock::GlobalCodeBlock):
        - Plumbed firstLineColumnOffset through to the super class.
      (JSC::ProgramCodeBlock::ProgramCodeBlock):
        - Plumbed firstLineColumnOffset through to the super class.
      (JSC::EvalCodeBlock::EvalCodeBlock):
        - Plumbed firstLineColumnOffset through to the super class.
          But for EvalCodeBlocks, the firstLineColumnOffset is always 1
          because we're starting with a new source string with no start
          offset.
      (JSC::FunctionCodeBlock::FunctionCodeBlock):
        - Plumbed firstLineColumnOffset through to the super class.
      
      * bytecode/ExpressionRangeInfo.h:
        - Added modes for encoding line and column into a single 30-bit
          unsigned. The encoding is in 1 of 3 modes:
          1. FatLineMode: 22-bit line, 8-bit column
          2. FatColumnMode: 8-bit line, 22-bit column
          3. FatLineAndColumnMode: 32-bit line, 32-bit column
      (JSC::ExpressionRangeInfo::encodeFatLineMode): Added.
        - Encodes line and column into the 30-bit position using FatLine mode.
      (JSC::ExpressionRangeInfo::encodeFatColumnMode): Added.
        - Encodes line and column into the 30-bit position using FatColumn mode.
      (JSC::ExpressionRangeInfo::decodeFatLineMode): Added.
        - Decodes the FatLine mode 30-bit position into line and column.
      (JSC::ExpressionRangeInfo::decodeFatColumnMode): Added.
        - Decodes the FatColumn mode 30-bit position into line and column.
      
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
        - Plumbed startColumn through.
      (JSC::UnlinkedFunctionExecutable::link):
        - Plumbed startColumn through.
      (JSC::UnlinkedCodeBlock::lineNumberForBytecodeOffset):
        - Computes a line number using the new way.
      (JSC::UnlinkedCodeBlock::expressionRangeForBytecodeOffset):
        - Added decoding of line and column.
        - Added handling of the case when we do not find a fitting expression
          range info for a specified bytecodeOffset. This only happens if the
          bytecodeOffset is below the first expression range info. In that
          case, we'll use the first expression range info entry.
      (JSC::UnlinkedCodeBlock::addExpressionInfo):
        - Added encoding of line and column.
      
      * bytecode/UnlinkedCodeBlock.h:
        - Added m_expressionInfoFatPositions in RareData.
      (JSC::UnlinkedFunctionExecutable::functionStartColumn):
      (JSC::UnlinkedCodeBlock::shrinkToFit):
        - Removed obsoleted m_lineInfo.
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitCall): Plumbed line and lineStart through.
      (JSC::BytecodeGenerator::emitCallEval): Plumbed line and lineStart through.
      (JSC::BytecodeGenerator::emitCallVarargs): Plumbed line and lineStart through.
      (JSC::BytecodeGenerator::emitConstruct): Plumbed line and lineStart through.
      (JSC::BytecodeGenerator::emitDebugHook): Plumbed lineStart through.
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitNode):
      (JSC::BytecodeGenerator::emitNodeInConditionContext):
        - Removed obsoleted m_lineInfo.
      (JSC::BytecodeGenerator::emitExpressionInfo):
        - Plumbed line and lineStart through.
        - Compute the line and column to be added to the expression range info.
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ThrowableExpressionData::emitThrowReferenceError):
      (JSC::ResolveNode::emitBytecode):
      (JSC::ArrayNode::toArgumentList):
      (JSC::BracketAccessorNode::emitBytecode):
      (JSC::DotAccessorNode::emitBytecode):
      (JSC::NewExprNode::emitBytecode):
      (JSC::EvalFunctionCallNode::emitBytecode):
      (JSC::FunctionCallValueNode::emitBytecode):
      (JSC::FunctionCallResolveNode::emitBytecode):
      (JSC::FunctionCallBracketNode::emitBytecode):
      (JSC::FunctionCallDotNode::emitBytecode):
      (JSC::CallFunctionCallDotNode::emitBytecode):
      (JSC::ApplyFunctionCallDotNode::emitBytecode):
      (JSC::PostfixNode::emitResolve):
      (JSC::PostfixNode::emitBracket):
      (JSC::PostfixNode::emitDot):
      (JSC::DeleteResolveNode::emitBytecode):
      (JSC::DeleteBracketNode::emitBytecode):
      (JSC::DeleteDotNode::emitBytecode):
      (JSC::PrefixNode::emitResolve):
      (JSC::PrefixNode::emitBracket):
      (JSC::PrefixNode::emitDot):
        - Plumbed line and lineStart through the above as needed.
      
      (JSC::UnaryOpNode::emitBytecode):
        - Added emission of an ExpressionRangeInfo for the UnaryOp node.
      
      (JSC::BinaryOpNode::emitStrcat):
      (JSC::ThrowableBinaryOpNode::emitBytecode):
      (JSC::InstanceOfNode::emitBytecode):
      (JSC::emitReadModifyAssignment):
      (JSC::ReadModifyResolveNode::emitBytecode):
      (JSC::AssignResolveNode::emitBytecode):
      (JSC::AssignDotNode::emitBytecode):
      (JSC::ReadModifyDotNode::emitBytecode):
      (JSC::AssignBracketNode::emitBytecode):
      (JSC::ReadModifyBracketNode::emitBytecode):
        - Plumbed line and lineStart through the above as needed.
      
      (JSC::ConstStatementNode::emitBytecode):
      (JSC::EmptyStatementNode::emitBytecode):
      (JSC::DebuggerStatementNode::emitBytecode):
      (JSC::ExprStatementNode::emitBytecode):
      (JSC::VarStatementNode::emitBytecode):
      (JSC::IfElseNode::emitBytecode):
      (JSC::DoWhileNode::emitBytecode):
      (JSC::WhileNode::emitBytecode):
      (JSC::ForNode::emitBytecode):
      (JSC::ForInNode::emitBytecode):
      (JSC::ContinueNode::emitBytecode):
      (JSC::BreakNode::emitBytecode):
      (JSC::ReturnNode::emitBytecode):
      (JSC::WithNode::emitBytecode):
      (JSC::SwitchNode::emitBytecode):
      (JSC::LabelNode::emitBytecode):
      (JSC::ThrowNode::emitBytecode):
      (JSC::TryNode::emitBytecode):
      (JSC::ProgramNode::emitBytecode):
      (JSC::EvalNode::emitBytecode):
      (JSC::FunctionBodyNode::emitBytecode):
        - Plumbed line and lineStart through the above as needed.
      
      * interpreter/Interpreter.cpp:
      (JSC::appendSourceToError):
        - Added line and column arguments for expressionRangeForBytecodeOffset().
      (JSC::StackFrame::computeLineAndColumn):
        - Replaces StackFrame::line() and StackFrame::column().
      (JSC::StackFrame::expressionInfo):
        - Added line and column arguments.
      (JSC::StackFrame::toString):
        - Changed to use the new StackFrame::computeLineAndColumn().
      (JSC::Interpreter::getStackTrace):
        - Added the needed firstLineColumnOffset arg for the StackFrame.
      
      * interpreter/Interpreter.h:
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::BinaryOpInfo::BinaryOpInfo):
      (JSC::ASTBuilder::AssignmentInfo::AssignmentInfo):
      (JSC::ASTBuilder::createResolve):
      (JSC::ASTBuilder::createBracketAccess):
      (JSC::ASTBuilder::createDotAccess):
      (JSC::ASTBuilder::createRegExp):
      (JSC::ASTBuilder::createNewExpr):
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createFunctionExpr):
      (JSC::ASTBuilder::createFunctionBody):
      (JSC::ASTBuilder::createGetterOrSetterProperty):
      (JSC::ASTBuilder::createFuncDeclStatement):
      (JSC::ASTBuilder::createBlockStatement):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createIfStatement):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createVarStatement):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createTryStatement):
      (JSC::ASTBuilder::createSwitchStatement):
      (JSC::ASTBuilder::createWhileStatement):
      (JSC::ASTBuilder::createDoWhileStatement):
      (JSC::ASTBuilder::createLabelStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::createDebugger):
      (JSC::ASTBuilder::createConstStatement):
      (JSC::ASTBuilder::appendBinaryExpressionInfo):
      (JSC::ASTBuilder::appendUnaryToken):
      (JSC::ASTBuilder::unaryTokenStackLastStart):
      (JSC::ASTBuilder::unaryTokenStackLastLineStartPosition): Added.
      (JSC::ASTBuilder::assignmentStackAppend):
      (JSC::ASTBuilder::createAssignment):
      (JSC::ASTBuilder::setExceptionLocation):
      (JSC::ASTBuilder::makeDeleteNode):
      (JSC::ASTBuilder::makeFunctionCallNode):
      (JSC::ASTBuilder::makeBinaryNode):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):.
        - Plumbed line, lineStart, and startColumn through the above as needed.
      
      * parser/Lexer.cpp:
      (JSC::::currentSourcePtr):
      (JSC::::setCode):
        - Added tracking for sourceoffset and lineStart.
      (JSC::::internalShift):
      (JSC::::parseIdentifier):
        - Added tracking for lineStart.
      (JSC::::parseIdentifierSlowCase):
      (JSC::::parseString):
        - Added tracking for lineStart.
      (JSC::::parseStringSlowCase):
      (JSC::::lex):
        - Added tracking for sourceoffset.
      (JSC::::sourceCode):
      * parser/Lexer.h:
      (JSC::Lexer::currentOffset):
      (JSC::Lexer::currentLineStartOffset):
      (JSC::Lexer::setOffset):
        - Added tracking for lineStart.
      (JSC::Lexer::offsetFromSourcePtr): Added. conversion function.
      (JSC::Lexer::sourcePtrFromOffset): Added. conversion function.
      (JSC::Lexer::setOffsetFromSourcePtr):
      (JSC::::lexExpectIdentifier):
        - Added tracking for sourceoffset and lineStart.
      
      * parser/NodeConstructors.h:
      (JSC::Node::Node):
      (JSC::ResolveNode::ResolveNode):
      (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
      (JSC::FunctionCallValueNode::FunctionCallValueNode):
      (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
      (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
      (JSC::FunctionCallDotNode::FunctionCallDotNode):
      (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
      (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
      (JSC::PostfixNode::PostfixNode):
      (JSC::DeleteResolveNode::DeleteResolveNode):
      (JSC::DeleteBracketNode::DeleteBracketNode):
      (JSC::DeleteDotNode::DeleteDotNode):
      (JSC::PrefixNode::PrefixNode):
      (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
      (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
      (JSC::AssignBracketNode::AssignBracketNode):
      (JSC::AssignDotNode::AssignDotNode):
      (JSC::ReadModifyDotNode::ReadModifyDotNode):
      (JSC::AssignErrorNode::AssignErrorNode):
      (JSC::WithNode::WithNode):
      (JSC::ForInNode::ForInNode):
        - Plumbed line and lineStart through the above as needed.
      * parser/Nodes.cpp:
      (JSC::StatementNode::setLoc): Plumbed lineStart.
      (JSC::ScopeNode::ScopeNode): Plumbed lineStart.
      (JSC::ProgramNode::ProgramNode): Plumbed startColumn.
      (JSC::ProgramNode::create): Plumbed startColumn.
      (JSC::EvalNode::create):
      (JSC::FunctionBodyNode::FunctionBodyNode): Plumbed startColumn.
      (JSC::FunctionBodyNode::create): Plumbed startColumn.
      * parser/Nodes.h:
      (JSC::Node::startOffset):
      (JSC::Node::lineStartOffset): Added.
      (JSC::StatementNode::firstLine):
      (JSC::StatementNode::lastLine):
      (JSC::ThrowableExpressionData::ThrowableExpressionData):
      (JSC::ThrowableExpressionData::setExceptionSourceCode):
      (JSC::ThrowableExpressionData::divotStartOffset):
      (JSC::ThrowableExpressionData::divotEndOffset):
      (JSC::ThrowableExpressionData::divotLine):
      (JSC::ThrowableExpressionData::divotLineStart):
      (JSC::ThrowableSubExpressionData::ThrowableSubExpressionData):
      (JSC::ThrowableSubExpressionData::setSubexpressionInfo):
      (JSC::ThrowableSubExpressionData::subexpressionDivot):
      (JSC::ThrowableSubExpressionData::subexpressionStartOffset):
      (JSC::ThrowableSubExpressionData::subexpressionEndOffset):
      (JSC::ThrowableSubExpressionData::subexpressionLine):
      (JSC::ThrowableSubExpressionData::subexpressionLineStart):
      (JSC::ThrowablePrefixedSubExpressionData::ThrowablePrefixedSubExpressionData):
      (JSC::ThrowablePrefixedSubExpressionData::setSubexpressionInfo):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionDivot):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionStartOffset):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionEndOffset):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionLine):
      (JSC::ThrowablePrefixedSubExpressionData::subexpressionLineStart):
      (JSC::ScopeNode::startStartOffset):
      (JSC::ScopeNode::startLineStartOffset):
      (JSC::ProgramNode::startColumn):
      (JSC::EvalNode::startColumn):
      (JSC::FunctionBodyNode::startColumn):
        - Plumbed line and lineStart through the above as needed.
      * parser/Parser.cpp:
      (JSC::::Parser):
      (JSC::::parseSourceElements):
      (JSC::::parseVarDeclarationList):
      (JSC::::parseConstDeclarationList):
      (JSC::::parseForStatement):
      (JSC::::parseBreakStatement):
      (JSC::::parseContinueStatement):
      (JSC::::parseReturnStatement):
      (JSC::::parseThrowStatement):
      (JSC::::parseWithStatement):
        - Plumbed line and lineStart through the above as needed.
      (JSC::::parseFunctionBody):
        - Plumbed startColumn.
      (JSC::::parseFunctionInfo):
      (JSC::::parseFunctionDeclaration):
      (JSC::LabelInfo::LabelInfo):
      (JSC::::parseExpressionOrLabelStatement):
      (JSC::::parseAssignmentExpression):
      (JSC::::parseBinaryExpression):
      (JSC::::parseProperty):
      (JSC::::parseObjectLiteral):
      (JSC::::parsePrimaryExpression):
      (JSC::::parseMemberExpression):
      (JSC::::parseUnaryExpression):
        - Plumbed line, lineStart, startColumn through the above as needed.
      * parser/Parser.h:
      (JSC::Parser::next):
      (JSC::Parser::nextExpectIdentifier):
      (JSC::Parser::tokenStart):
      (JSC::Parser::tokenColumn):
      (JSC::Parser::tokenEnd):
      (JSC::Parser::tokenLineStart):
      (JSC::Parser::lastTokenLine):
      (JSC::Parser::lastTokenLineStart):
      (JSC::::parse):
      * parser/ParserTokens.h:
      (JSC::JSTokenLocation::JSTokenLocation):
        - Plumbed lineStart.
      (JSC::JSTokenLocation::lineStartPosition):
      (JSC::JSTokenLocation::startPosition):
      (JSC::JSTokenLocation::endPosition):
      * parser/SourceCode.h:
      (JSC::SourceCode::SourceCode):
      (JSC::SourceCode::startColumn):
      (JSC::makeSource):
      (JSC::SourceCode::subExpression):
      * parser/SourceProvider.cpp: delete old code.
      * parser/SourceProvider.h: delete old code.
      * parser/SourceProviderCacheItem.h:
      (JSC::SourceProviderCacheItem::closeBraceToken):
      (JSC::SourceProviderCacheItem::SourceProviderCacheItem):
        - Plumbed lineStart.
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::makeFunctionCallNode):
      (JSC::SyntaxChecker::makeAssignNode):
      (JSC::SyntaxChecker::makePrefixNode):
      (JSC::SyntaxChecker::makePostfixNode):
      (JSC::SyntaxChecker::makeDeleteNode):
      (JSC::SyntaxChecker::createResolve):
      (JSC::SyntaxChecker::createBracketAccess):
      (JSC::SyntaxChecker::createDotAccess):
      (JSC::SyntaxChecker::createRegExp):
      (JSC::SyntaxChecker::createNewExpr):
      (JSC::SyntaxChecker::createAssignResolve):
      (JSC::SyntaxChecker::createFunctionExpr):
      (JSC::SyntaxChecker::createFunctionBody):
      (JSC::SyntaxChecker::createFuncDeclStatement):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::createReturnStatement):
      (JSC::SyntaxChecker::createBreakStatement):
      (JSC::SyntaxChecker::createContinueStatement):
      (JSC::SyntaxChecker::createWithStatement):
      (JSC::SyntaxChecker::createLabelStatement):
      (JSC::SyntaxChecker::createThrowStatement):
      (JSC::SyntaxChecker::createGetterOrSetterProperty):
      (JSC::SyntaxChecker::appendBinaryExpressionInfo):
      (JSC::SyntaxChecker::operatorStackPop):
        - Made SyntaxChecker prototype changes to match ASTBuilder due to new
          args added for plumbing line, lineStart, and startColumn.
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::generateBytecode):
      (JSC::CodeCache::getCodeBlock):
        - Plumbed startColumn.
      * runtime/Executable.cpp:
      (JSC::FunctionExecutable::FunctionExecutable):
      (JSC::ProgramExecutable::compileInternal):
      (JSC::FunctionExecutable::produceCodeBlockFor):
      (JSC::FunctionExecutable::fromGlobalCode):
        - Plumbed startColumn.
      * runtime/Executable.h:
      (JSC::ScriptExecutable::startColumn):
      (JSC::ScriptExecutable::recordParse):
      (JSC::FunctionExecutable::create):
        - Plumbed startColumn.
      
      Source/WebCore: 
      
      Test: fast/js/line-column-numbers.html
      
      Updated the bindings to use StackFrame::computeLineAndColumn(). The old
      StackFrame::line() and StackFrame::column() has been removed. The new
      algorithm always computes the 2 values together anyway. Hence it is more
      efficient to return them as a pair instead of doing the same computation
      twice for each half of the result.
      
      * bindings/js/ScriptCallStackFactory.cpp:
      (WebCore::createScriptCallStack):
      (WebCore::createScriptCallStackFromException):
      * bindings/js/ScriptSourceCode.h:
      (WebCore::ScriptSourceCode::ScriptSourceCode):
      
      LayoutTests: 
      
      The fix now computes line and column numbers more accurately. As a result,
      some of the test results need to be re-baselined. Among other fixes, one
      major source of difference is that the old code was incorrectly computing
      0-based column numbers. This has now been fixed to be 1-based.
      Note: line numbers were always 1-based.
      
      Also added a new test: fast/js/line-column-numbers.html, which tests line
      and column numbers for source code in various configurations.
      
      * editing/execCommand/outdent-blockquote-test1-expected.txt:
      * editing/execCommand/outdent-blockquote-test2-expected.txt:
      * editing/execCommand/outdent-blockquote-test3-expected.txt:
      * editing/execCommand/outdent-blockquote-test4-expected.txt:
      * editing/pasteboard/copy-paste-float-expected.txt:
      * editing/pasteboard/paste-blockquote-before-blockquote-expected.txt:
      * editing/pasteboard/paste-double-nested-blockquote-before-blockquote-expected.txt:
      * fast/dom/Window/window-resize-contents-expected.txt:
      * fast/events/remove-target-with-shadow-in-drag-expected.txt:
      * fast/js/line-column-numbers-expected.txt: Added.
      * fast/js/line-column-numbers.html: Added.
      * fast/js/script-tests/line-column-numbers.js: Added.
      (try.doThrow4b):
      (doThrow5b.try.innerFunc):
      (doThrow5b):
      (doThrow6b.try.innerFunc):
      (doThrow6b):
      (catch):
      (try.doThrow11b):
      (try.doThrow14b):
      * fast/js/stack-trace-expected.txt:
      * inspector/console/console-url-line-column-expected.txt:
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@152494 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      5b45f90a
  12. 27 Apr, 2013 2 commits
    • ggaren@apple.com's avatar
      Cleaned up pre/post inc/dec in bytecode · f303611f
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=115222
      
      Reviewed by Filip Pizlo.
      
      Source/JavaScriptCore: 
      
      A few related changes here:
      
      (*) Removed post_inc and post_dec. The two-result form was awkward to
      reason about. Being explicit about the intermediate mov and to_number
      reduces DFG overhead, removes some fragile ASSERTs from the DFG, and
      fixes a const bug. Plus, we get to blow away 262 lines of code.
      
      (*) Renamed pre_inc and pre_dec to inc and dec, since there's only one
      version now.
      
      (*) Renamed to_jsnumber to to_number, to match the ECMA name.
      
      (*) Tightened up the codegen and runtime support for to_number.
      
      
      * JavaScriptCore.order: Order!
      
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::dumpBytecode):
      * bytecode/Opcode.h:
      (JSC::padOpcodeName):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitInc):
      (JSC::BytecodeGenerator::emitDec):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitToNumber):
      (BytecodeGenerator): Removed post_inc and post_dec.
      
      * bytecompiler/NodesCodegen.cpp:
      (JSC::emitPreIncOrDec): Updated for rename.
      
      (JSC::emitPostIncOrDec): Issue an explicit mov and to_number when needed.
      These are rare, and they boil away in the DFG.
      
      (JSC::PostfixNode::emitResolve):
      (JSC::PrefixNode::emitResolve): For const, use an explicit mov instead
      of any special forms. This fixes a bug where we would do string
      add/subtract instead of number.
      
      * dfg/DFGByteCodeParser.cpp:
      (JSC::DFG::ByteCodeParser::parseBlock):
      * dfg/DFGCapabilities.h:
      (JSC::DFG::canCompileOpcode):
      * jit/JIT.cpp:
      (JSC::JIT::privateCompileMainPass):
      (JSC::JIT::privateCompileSlowCases):
      * jit/JIT.h:
      * jit/JITArithmetic.cpp:
      (JSC::JIT::emit_op_inc):
      (JSC::JIT::emitSlow_op_inc):
      (JSC::JIT::emit_op_dec):
      (JSC::JIT::emitSlow_op_dec):
      * jit/JITArithmetic32_64.cpp:
      (JSC::JIT::emit_op_inc):
      (JSC::JIT::emitSlow_op_inc):
      (JSC::JIT::emit_op_dec):
      (JSC::JIT::emitSlow_op_dec): Removed post_inc/dec, and updated for renames.
      
      * jit/JITOpcodes.cpp:
      (JSC::JIT::emit_op_to_number):
      (JSC::JIT::emitSlow_op_to_number): Removed a test for number cells. There's
      no such thing!
      
      * jit/JITOpcodes32_64.cpp:
      (JSC::JIT::emit_op_to_number): Use LowestTag to avoid making assumptions
      about the lowest valued tag.
      
      (JSC::JIT::emitSlow_op_to_number): Updated for renames.
      
      * jit/JITStubs.cpp:
      (JSC::DEFINE_STUB_FUNCTION):
      * jit/JITStubs.h:
      * llint/LLIntSlowPaths.cpp:
      (JSC::LLInt::LLINT_SLOW_PATH_DECL):
      * llint/LLIntSlowPaths.h:
      * llint/LowLevelInterpreter32_64.asm:
      * llint/LowLevelInterpreter64.asm:
      * parser/NodeConstructors.h:
      (JSC::UnaryPlusNode::UnaryPlusNode): Removed post_inc/dec, and updated for renames.
      
      * runtime/Operations.cpp:
      (JSC::jsIsObjectType): Removed a test for number cells. There's
      no such thing!
      
      LayoutTests: 
      
      * fast/js/const-expected.txt:
      * fast/js/resources/const.js: Added tests for some const cases we used
      to get wrong.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@149247 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      f303611f
    • ggaren@apple.com's avatar
      Source/JavaScriptCore: Re-landing <http://trac.webkit.org/changeset/148999> · 81c68cce
      ggaren@apple.com authored
          Filled out more cases of branch folding in bytecode when emitting
          expressions into a branching context
          https://bugs.webkit.org/show_bug.cgi?id=115057
      
          Reviewed by Phil Pizlo.
      
      We can't fold the number == 1 case to boolean because all non-zero numbers
      down-cast to true, but only 1 is == to true.
      
      Source/WTF: Filled out more cases of branch folding in bytecode when emitting expressions into a branching context
      https://bugs.webkit.org/show_bug.cgi?id=115057
      
      Reviewed by Filip Pizlo.
      
      Added a helper constructor for TriState so clients can make one without
      branching or making assumptions about the integer values of TriStates.
      
      * wtf/TriState.h:
      (WTF::triState):
      (WTF):
      
      LayoutTests: Re-landing <http://trac.webkit.org/changeset/148999>
      
          Filled out more cases of branch folding in bytecode when emitting
          expressions into a branching context
          https://bugs.webkit.org/show_bug.cgi?id=115057
      
          Reviewed by Phil Pizlo.
      
      Added a more exhaustive correctness test.
      
      * fast/js/branch-fold-correctness-expected.txt: Added.
      * fast/js/branch-fold-correctness.html: Added.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@149236 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      81c68cce
  13. 25 Apr, 2013 1 commit
    • fpizlo@apple.com's avatar
      Unreviewed, roll out http://trac.webkit.org/changeset/148999 · 335ba39b
      fpizlo@apple.com authored
      It broke http://kripken.github.io/ammo.js/examples/new/ammo.html
      
      Source/JavaScriptCore: 
      
      * JavaScriptCore.order:
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitNewArray):
      (JSC::BytecodeGenerator::emitThrowReferenceError):
      (JSC::BytecodeGenerator::emitReadOnlyExceptionIfNeeded):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::shouldEmitProfileHooks):
      (BytecodeGenerator):
      * bytecompiler/NodesCodegen.cpp:
      (JSC):
      (JSC::NullNode::emitBytecode):
      (JSC::BooleanNode::emitBytecode):
      (JSC::NumberNode::emitBytecode):
      (JSC::StringNode::emitBytecode):
      (JSC::IfNode::emitBytecode):
      (JSC::IfElseNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createIfStatement):
      (ASTBuilder):
      * parser/NodeConstructors.h:
      (JSC):
      (JSC::NullNode::NullNode):
      (JSC::BooleanNode::BooleanNode):
      (JSC::NumberNode::NumberNode):
      (JSC::StringNode::StringNode):
      (JSC::IfNode::IfNode):
      (JSC::IfElseNode::IfElseNode):
      * parser/Nodes.h:
      (JSC::ExpressionNode::isPure):
      (JSC::ExpressionNode::isSubtract):
      (StatementNode):
      (NullNode):
      (JSC::NullNode::isNull):
      (BooleanNode):
      (JSC::BooleanNode::isPure):
      (NumberNode):
      (JSC::NumberNode::value):
      (JSC::NumberNode::isPure):
      (StringNode):
      (JSC::StringNode::isPure):
      (JSC::StringNode::isString):
      (BinaryOpNode):
      (IfNode):
      (JSC):
      (IfElseNode):
      (ContinueNode):
      (BreakNode):
      * parser/Parser.cpp:
      (JSC::::parseIfStatement):
      * parser/ResultType.h:
      (ResultType):
      * runtime/JSCJSValueInlines.h:
      (JSC::JSValue::pureToBoolean):
      * runtime/JSCell.h:
      (JSCell):
      * runtime/JSCellInlines.h:
      (JSC):
      
      Source/WTF: 
      
      * wtf/TriState.h:
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@149158 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      335ba39b
  14. 23 Apr, 2013 1 commit
    • ggaren@apple.com's avatar
      Source/JavaScriptCore: Filled out more cases of branch folding in bytecode when emitting · ec40baf6
      ggaren@apple.com authored
      expressions into a branching context
      https://bugs.webkit.org/show_bug.cgi?id=115057
      
      Reviewed by Filip Pizlo.
      
      This covers a few cases like:
      
          - while (true) { }
          - while (1) { }
          - if (x) break;
          - if (x) continue;
          - if (boolean_expr == boolean_const) { }
          - if (boolean_expr == 1_or_0) { }
          - if (bitop == 1_or_0) { }
      
      This also works, but will bring shame on your family:
      
          - while ("hello world") { }
      
      No change on the benchmarks we track, but a 2.5X speedup on a microbenchmark
      that uses these techniques.
      
      * JavaScriptCore.order: Order!
      
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitNewArray):
      (JSC::BytecodeGenerator::emitThrowReferenceError):
      (JSC::BytecodeGenerator::emitReadOnlyExceptionIfNeeded):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::shouldEmitDebugHooks): Updated ancillary code
      for interface simplifications.
      
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ConstantNode::emitBytecodeInConditionContext): Constants can
      jump unconditionally when used within a condition context.
      
      (JSC::ConstantNode::emitBytecode):
      (JSC::StringNode::jsValue): Gave constants a common base class so I
      could implement their codegen just once.
      
      (JSC::BinaryOpNode::emitBytecodeInConditionContext):
      (JSC::canFoldToBranch):
      (JSC::BinaryOpNode::tryFoldToBranch): Fold (!/=)= and (!/=)== where
      appropriate. A lot of cases are not appropriate because of the surprising
      type conversion semantics of ==. For example, if (number == true) { } is
      not the same as if (number) { } because the former will up-convert true
      to number and then do numeric comparison.
      
      (JSC::singleStatement):
      (JSC::IfElseNode::tryFoldBreakAndContinue):
      (JSC::IfElseNode::emitBytecode):
      (JSC::ContinueNode::trivialTarget):
      (JSC::BreakNode::trivialTarget): Fold "if (expression) break" and
      "if (expression) continue" into direct jumps from expression.
      
      * parser/ASTBuilder.h:
      (ASTBuilder):
      (JSC::ASTBuilder::createIfStatement):
      * parser/NodeConstructors.h:
      (JSC::ConstantNode::ConstantNode):
      (JSC):
      (JSC::NullNode::NullNode):
      (JSC::BooleanNode::BooleanNode):
      (JSC::NumberNode::NumberNode):
      (JSC::StringNode::StringNode):
      (JSC::IfElseNode::IfElseNode):
      * parser/Nodes.h:
      (JSC::ExpressionNode::isConstant):
      (JSC::ExpressionNode::isBoolean):
      (JSC::StatementNode::isBreak):
      (JSC::StatementNode::isContinue):
      (ConstantNode):
      (JSC::ConstantNode::isPure):
      (JSC::ConstantNode::isConstant):
      (NullNode):
      (JSC::NullNode::jsValue):
      (JSC::BooleanNode::value):
      (JSC::BooleanNode::isBoolean):
      (JSC::BooleanNode::jsValue):
      (JSC::NumberNode::value):
      (NumberNode):
      (JSC::NumberNode::jsValue):
      (StringNode):
      (BinaryOpNode):
      (IfElseNode):
      (ContinueNode):
      (JSC::ContinueNode::isContinue):
      (BreakNode):
      (JSC::BreakNode::isBreak):
      * parser/Parser.cpp:
      (JSC::::parseIfStatement):
      * parser/ResultType.h:
      (JSC::ResultType::definitelyIsBoolean):
      (ResultType):
      * runtime/JSCJSValueInlines.h:
      (JSC::JSValue::pureToBoolean):
      * runtime/JSCell.h:
      * runtime/JSCellInlines.h:
      (JSC::JSCell::pureToBoolean): Updated for interface changes above.
      
      Source/WTF: Filled out more cases of branch folding in bytecode when emitting expressions into a branching context
      https://bugs.webkit.org/show_bug.cgi?id=115057
      
      Reviewed by Filip Pizlo.
      
      Added a helper constructor for TriState so clients can make one without
      branching or making assumptions about the integer values of TriStates.
      
      * wtf/TriState.h:
      (WTF::triState):
      (WTF):
      
      LayoutTests: Filled out more cases of branch folding in bytecode when emitting expressions into a branching context
      https://bugs.webkit.org/show_bug.cgi?id=115057
      
      Reviewed by Filip Pizlo.
      
      Added a performance test for interesting branch types.
      
      * fast/js/regress/branch-fold-expected.txt: Added.
      * fast/js/regress/branch-fold.html: Added.
      * fast/js/regress/script-tests/branch-fold.js: Added.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@148999 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      ec40baf6
  15. 18 Apr, 2013 1 commit
    • ggaren@apple.com's avatar
      Renamed JSGlobalData to VM · 9a9a4b52
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=114777
      
      Reviewed by Phil Pizlo.
      
      ../JavaScriptCore: 
      
      * API/APICast.h:
      (JSC):
      (toJS):
      (toRef):
      * API/APIShims.h:
      (JSC::APIEntryShimWithoutLock::APIEntryShimWithoutLock):
      (APIEntryShimWithoutLock):
      (JSC::APIEntryShim::APIEntryShim):
      (APIEntryShim):
      (JSC::APIEntryShim::~APIEntryShim):
      (JSC::APICallbackShim::APICallbackShim):
      (JSC::APICallbackShim::~APICallbackShim):
      (APICallbackShim):
      * API/JSAPIWrapperObject.h:
      (JSAPIWrapperObject):
      * API/JSAPIWrapperObject.mm:
      (JSC::::createStructure):
      (JSC::JSAPIWrapperObject::JSAPIWrapperObject):
      (JSC::JSAPIWrapperObject::finishCreation):
      (JSC::JSAPIWrapperObject::visitChildren):
      * API/JSBase.cpp:
      (JSGarbageCollect):
      (JSReportExtraMemoryCost):
      (JSSynchronousGarbageCollectForDebugging):
      * API/JSCallbackConstructor.cpp:
      (JSC::JSCallbackConstructor::JSCallbackConstructor):
      (JSC::JSCallbackConstructor::finishCreation):
      * API/JSCallbackConstructor.h:
      (JSC::JSCallbackConstructor::createStructure):
      * API/JSCallbackFunction.cpp:
      (JSC::JSCallbackFunction::finishCreation):
      (JSC::JSCallbackFunction::create):
      * API/JSCallbackFunction.h:
      (JSCallbackFunction):
      (JSC::JSCallbackFunction::createStructure):
      * API/JSCallbackObject.cpp:
      (JSC::::create):
      (JSC::::createStructure):
      * API/JSCallbackObject.h:
      (JSC::JSCallbackObjectData::setPrivateProperty):
      (JSC::JSCallbackObjectData::JSPrivatePropertyMap::setPrivateProperty):
      (JSCallbackObject):
      (JSC::JSCallbackObject::setPrivateProperty):
      * API/JSCallbackObjectFunctions.h:
      (JSC::::JSCallbackObject):
      (JSC::::finishCreation):
      (JSC::::put):
      (JSC::::staticFunctionGetter):
      * API/JSClassRef.cpp:
      (OpaqueJSClassContextData::OpaqueJSClassContextData):
      (OpaqueJSClass::contextData):
      (OpaqueJSClass::prototype):
      * API/JSClassRef.h:
      (OpaqueJSClassContextData):
      * API/JSContext.mm:
      (-[JSContext setException:]):
      (-[JSContext initWithGlobalContextRef:]):
      (+[JSContext contextWithGlobalContextRef:]):
      * API/JSContextRef.cpp:
      (JSContextGroupCreate):
      (JSContextGroupRelease):
      (JSGlobalContextCreate):
      (JSGlobalContextCreateInGroup):
      (JSGlobalContextRetain):
      (JSGlobalContextRelease):
      (JSContextGetGroup):
      (JSContextCreateBacktrace):
      * API/JSObjectRef.cpp:
      (JSObjectMake):
      (JSObjectMakeConstructor):
      (JSObjectMakeFunction):
      (JSObjectSetPrototype):
      (JSObjectHasProperty):
      (JSObjectGetProperty):
      (JSObjectSetProperty):
      (JSObjectDeleteProperty):
      (JSObjectGetPrivateProperty):
      (JSObjectSetPrivateProperty):
      (JSObjectDeletePrivateProperty):
      (OpaqueJSPropertyNameArray::OpaqueJSPropertyNameArray):
      (OpaqueJSPropertyNameArray):
      (JSObjectCopyPropertyNames):
      (JSPropertyNameArrayRelease):
      (JSPropertyNameAccumulatorAddName):
      * API/JSScriptRef.cpp:
      (OpaqueJSScript::create):
      (OpaqueJSScript::vm):
      (OpaqueJSScript::OpaqueJSScript):
      (OpaqueJSScript):
      (parseScript):
      * API/JSVirtualMachine.mm:
      (scanExternalObjectGraph):
      * API/JSVirtualMachineInternal.h:
      (JSC):
      * API/JSWrapperMap.mm:
      (makeWrapper):
      * API/ObjCCallbackFunction.h:
      (JSC::ObjCCallbackFunction::createStructure):
      * API/ObjCCallbackFunction.mm:
      (JSC::ObjCCallbackFunction::create):
      * API/OpaqueJSString.cpp:
      (OpaqueJSString::identifier):
      * API/OpaqueJSString.h:
      (JSC):
      (OpaqueJSString):
      * GNUmakefile.list.am:
      * JSCTypedArrayStubs.h:
      (JSC):
      * JavaScriptCore.order:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreExports.def:
      * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
      * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
      * JavaScriptCore.vcxproj/JavaScriptCoreExportGenerator/JavaScriptCoreExports.def.in:
      * JavaScriptCore.xcodeproj/project.pbxproj:
      * KeywordLookupGenerator.py:
      (Trie.printSubTreeAsC):
      * Target.pri:
      * assembler/ARMAssembler.cpp:
      (JSC::ARMAssembler::executableCopy):
      * assembler/ARMAssembler.h:
      (ARMAssembler):
      * assembler/AssemblerBuffer.h:
      (JSC::AssemblerBuffer::executableCopy):
      * assembler/AssemblerBufferWithConstantPool.h:
      (JSC::AssemblerBufferWithConstantPool::executableCopy):
      * assembler/LinkBuffer.cpp:
      (JSC::LinkBuffer::linkCode):
      * assembler/LinkBuffer.h:
      (JSC):
      (JSC::LinkBuffer::LinkBuffer):
      (LinkBuffer):
      * assembler/MIPSAssembler.h:
      (JSC::MIPSAssembler::executableCopy):
      * assembler/SH4Assembler.h:
      (JSC::SH4Assembler::executableCopy):
      * assembler/X86Assembler.h:
      (JSC::X86Assembler::executableCopy):
      (JSC::X86Assembler::X86InstructionFormatter::executableCopy):
      * bytecode/CallLinkInfo.cpp:
      (JSC::CallLinkInfo::unlink):
      * bytecode/CallLinkInfo.h:
      (CallLinkInfo):
      * bytecode/CodeBlock.cpp:
      (JSC::dumpStructure):
      (JSC::CodeBlock::printStructures):
      (JSC::CodeBlock::CodeBlock):
      (JSC::CodeBlock::~CodeBlock):
      (JSC::CodeBlock::visitStructures):
      (JSC::CodeBlock::finalizeUnconditionally):
      (JSC::CodeBlock::createActivation):
      (JSC::CodeBlock::unlinkCalls):
      (JSC::CodeBlock::unlinkIncomingCalls):
      (JSC::CodeBlock::findClosureCallForReturnPC):
      (JSC::ProgramCodeBlock::jettisonImpl):
      (JSC::EvalCodeBlock::jettisonImpl):
      (JSC::FunctionCodeBlock::jettisonImpl):
      (JSC::CodeBlock::predictedMachineCodeSize):
      (JSC::CodeBlock::usesOpcode):
      * bytecode/CodeBlock.h:
      (JSC::CodeBlock::appendWeakReference):
      (JSC::CodeBlock::appendWeakReferenceTransition):
      (JSC::CodeBlock::setJITCode):
      (JSC::CodeBlock::setGlobalData):
      (JSC::CodeBlock::vm):
      (JSC::CodeBlock::valueProfileForBytecodeOffset):
      (JSC::CodeBlock::addConstant):
      (JSC::CodeBlock::setConstantRegisters):
      (CodeBlock):
      (JSC::CodeBlock::WeakReferenceTransition::WeakReferenceTransition):
      * bytecode/EvalCodeCache.h:
      (JSC::EvalCodeCache::getSlow):
      * bytecode/GetByIdStatus.cpp:
      (JSC::GetByIdStatus::computeFromLLInt):
      (JSC::GetByIdStatus::computeForChain):
      (JSC::GetByIdStatus::computeFor):
      * bytecode/GetByIdStatus.h:
      (GetByIdStatus):
      * bytecode/Instruction.h:
      (JSC::Instruction::Instruction):
      * bytecode/ObjectAllocationProfile.h:
      (JSC::ObjectAllocationProfile::initialize):
      (JSC::ObjectAllocationProfile::possibleDefaultPropertyCount):
      * bytecode/PolymorphicAccessStructureList.h:
      (JSC::PolymorphicAccessStructureList::PolymorphicStubInfo::set):
      (JSC::PolymorphicAccessStructureList::PolymorphicAccessStructureList):
      * bytecode/PolymorphicPutByIdList.h:
      (JSC::PutByIdAccess::transition):
      (JSC::PutByIdAccess::replace):
      * bytecode/PreciseJumpTargets.cpp:
      (JSC::computePreciseJumpTargets):
      * bytecode/PutByIdStatus.cpp:
      (JSC::PutByIdStatus::computeFromLLInt):
      (JSC::PutByIdStatus::computeFor):
      * bytecode/PutByIdStatus.h:
      (JSC):
      (PutByIdStatus):
      * bytecode/ResolveGlobalStatus.cpp:
      (JSC::computeForStructure):
      * bytecode/SamplingTool.cpp:
      (JSC::SamplingTool::notifyOfScope):
      * bytecode/SamplingTool.h:
      (JSC::ScriptSampleRecord::ScriptSampleRecord):
      (SamplingTool):
      * bytecode/StructureStubInfo.h:
      (JSC::StructureStubInfo::initGetByIdSelf):
      (JSC::StructureStubInfo::initGetByIdProto):
      (JSC::StructureStubInfo::initGetByIdChain):
      (JSC::StructureStubInfo::initPutByIdTransition):
      (JSC::StructureStubInfo::initPutByIdReplace):
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::generateFunctionCodeBlock):
      (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
      (JSC::UnlinkedFunctionExecutable::link):
      (JSC::UnlinkedFunctionExecutable::fromGlobalCode):
      (JSC::UnlinkedFunctionExecutable::codeBlockFor):
      (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
      * bytecode/UnlinkedCodeBlock.h:
      (JSC::UnlinkedFunctionExecutable::create):
      (UnlinkedFunctionExecutable):
      (JSC::UnlinkedFunctionExecutable::finishCreation):
      (JSC::UnlinkedFunctionExecutable::createStructure):
      (JSC::UnlinkedCodeBlock::addRegExp):
      (JSC::UnlinkedCodeBlock::addConstant):
      (JSC::UnlinkedCodeBlock::addFunctionDecl):
      (JSC::UnlinkedCodeBlock::addFunctionExpr):
      (JSC::UnlinkedCodeBlock::vm):
      (UnlinkedCodeBlock):
      (JSC::UnlinkedCodeBlock::finishCreation):
      (JSC::UnlinkedGlobalCodeBlock::UnlinkedGlobalCodeBlock):
      (JSC::UnlinkedProgramCodeBlock::create):
      (JSC::UnlinkedProgramCodeBlock::addFunctionDeclaration):
      (JSC::UnlinkedProgramCodeBlock::UnlinkedProgramCodeBlock):
      (JSC::UnlinkedProgramCodeBlock::createStructure):
      (JSC::UnlinkedEvalCodeBlock::create):
      (JSC::UnlinkedEvalCodeBlock::UnlinkedEvalCodeBlock):
      (JSC::UnlinkedEvalCodeBlock::createStructure):
      (JSC::UnlinkedFunctionCodeBlock::create):
      (JSC::UnlinkedFunctionCodeBlock::UnlinkedFunctionCodeBlock):
      (JSC::UnlinkedFunctionCodeBlock::createStructure):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::BytecodeGenerator):
      (JSC::BytecodeGenerator::addConstant):
      (JSC::BytecodeGenerator::emitLoad):
      (JSC::BytecodeGenerator::emitDirectPutById):
      (JSC::BytecodeGenerator::addStringConstant):
      (JSC::BytecodeGenerator::expectedFunctionForIdentifier):
      (JSC::BytecodeGenerator::emitThrowReferenceError):
      (JSC::BytecodeGenerator::emitReadOnlyExceptionIfNeeded):
      * bytecompiler/BytecodeGenerator.h:
      (BytecodeGenerator):
      (JSC::BytecodeGenerator::vm):
      (JSC::BytecodeGenerator::propertyNames):
      (JSC::BytecodeGenerator::makeFunction):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::RegExpNode::emitBytecode):
      (JSC::ArrayNode::toArgumentList):
      (JSC::ApplyFunctionCallDotNode::emitBytecode):
      (JSC::InstanceOfNode::emitBytecode):
      * debugger/Debugger.cpp:
      (JSC::Debugger::recompileAllJSFunctions):
      (JSC::evaluateInGlobalCallFrame):
      * debugger/Debugger.h:
      (JSC):
      * debugger/DebuggerActivation.cpp:
      (JSC::DebuggerActivation::DebuggerActivation):
      (JSC::DebuggerActivation::finishCreation):
      * debugger/DebuggerActivation.h:
      (JSC::DebuggerActivation::create):
      (JSC::DebuggerActivation::createStructure):
      (DebuggerActivation):
      * debugger/DebuggerCallFrame.cpp:
      (JSC::DebuggerCallFrame::evaluate):
      * dfg/DFGAbstractState.cpp:
      (JSC::DFG::AbstractState::executeEffects):
      * dfg/DFGAssemblyHelpers.h:
      (JSC::DFG::AssemblyHelpers::AssemblyHelpers):
      (JSC::DFG::AssemblyHelpers::vm):
      (JSC::DFG::AssemblyHelpers::debugCall):
      (JSC::DFG::AssemblyHelpers::emitExceptionCheck):
      (AssemblyHelpers):
      * dfg/DFGByteCodeParser.cpp:
      (JSC::DFG::ByteCodeParser::ByteCodeParser):
      (ByteCodeParser):
      (JSC::DFG::ByteCodeParser::handleConstantInternalFunction):
      (JSC::DFG::ByteCodeParser::parseBlock):
      (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
      (JSC::DFG::ByteCodeParser::parseCodeBlock):
      * dfg/DFGByteCodeParser.h:
      (JSC):
      * dfg/DFGCCallHelpers.h:
      (JSC::DFG::CCallHelpers::CCallHelpers):
      * dfg/DFGCapabilities.cpp:
      (JSC::DFG::canHandleOpcodes):
      * dfg/DFGConstantFoldingPhase.cpp:
      (JSC::DFG::ConstantFoldingPhase::foldConstants):
      * dfg/DFGDisassembler.cpp:
      (JSC::DFG::Disassembler::reportToProfiler):
      * dfg/DFGDriver.cpp:
      (JSC::DFG::compile):
      * dfg/DFGDriver.h:
      (JSC):
      * dfg/DFGFixupPhase.cpp:
      (JSC::DFG::FixupPhase::fixupNode):
      (JSC::DFG::FixupPhase::isStringPrototypeMethodSane):
      (JSC::DFG::FixupPhase::canOptimizeStringObjectAccess):
      * dfg/DFGGraph.cpp:
      (JSC::DFG::Graph::Graph):
      * dfg/DFGGraph.h:
      (Graph):
      * dfg/DFGJITCompiler.cpp:
      (JSC::DFG::JITCompiler::JITCompiler):
      (JSC::DFG::JITCompiler::linkOSRExits):
      (JSC::DFG::JITCompiler::link):
      (JSC::DFG::JITCompiler::compile):
      (JSC::DFG::JITCompiler::compileFunction):
      * dfg/DFGJITCompiler.h:
      (JSC):
      * dfg/DFGOSREntry.cpp:
      (JSC::DFG::prepareOSREntry):
      * dfg/DFGOSRExitCompiler.cpp:
      * dfg/DFGOSRExitCompiler32_64.cpp:
      (JSC::DFG::OSRExitCompiler::compileExit):
      * dfg/DFGOSRExitCompiler64.cpp:
      (JSC::DFG::OSRExitCompiler::compileExit):
      * dfg/DFGOperations.cpp:
      (JSC::DFG::putByVal):
      (JSC::DFG::operationPutByValInternal):
      (JSC::getHostCallReturnValueWithExecState):
      * dfg/DFGPhase.h:
      (JSC::DFG::Phase::vm):
      * dfg/DFGRepatch.cpp:
      (JSC::DFG::generateProtoChainAccessStub):
      (JSC::DFG::tryCacheGetByID):
      (JSC::DFG::tryBuildGetByIDList):
      (JSC::DFG::tryBuildGetByIDProtoList):
      (JSC::DFG::emitPutReplaceStub):
      (JSC::DFG::emitPutTransitionStub):
      (JSC::DFG::tryCachePutByID):
      (JSC::DFG::tryBuildPutByIdList):
      (JSC::DFG::linkSlowFor):
      (JSC::DFG::dfgLinkFor):
      (JSC::DFG::dfgLinkSlowFor):
      (JSC::DFG::dfgLinkClosureCall):
      * dfg/DFGSpeculativeJIT.cpp:
      (JSC::DFG::SpeculativeJIT::typedArrayDescriptor):
      (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
      (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
      (JSC::DFG::SpeculativeJIT::compileFromCharCode):
      (JSC::DFG::SpeculativeJIT::compileMakeRope):
      (JSC::DFG::SpeculativeJIT::compileStringEquality):
      (JSC::DFG::SpeculativeJIT::compileToStringOnCell):
      (JSC::DFG::SpeculativeJIT::speculateObject):
      (JSC::DFG::SpeculativeJIT::speculateObjectOrOther):
      (JSC::DFG::SpeculativeJIT::speculateString):
      (JSC::DFG::SpeculativeJIT::speculateStringOrStringObject):
      * dfg/DFGSpeculativeJIT.h:
      (JSC::DFG::SpeculativeJIT::prepareForExternalCall):
      (JSC::DFG::SpeculativeJIT::emitAllocateBasicStorage):
      (JSC::DFG::SpeculativeJIT::emitAllocateJSObject):
      * dfg/DFGSpeculativeJIT32_64.cpp:
      (JSC::DFG::SpeculativeJIT::compileObjectEquality):
      (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
      (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
      (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
      (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
      (JSC::DFG::SpeculativeJIT::compile):
      * dfg/DFGSpeculativeJIT64.cpp:
      (JSC::DFG::SpeculativeJIT::compileObjectEquality):
      (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
      (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
      (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
      (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
      (JSC::DFG::SpeculativeJIT::compile):
      * dfg/DFGThunks.cpp:
      (JSC::DFG::osrExitGenerationThunkGenerator):
      (JSC::DFG::throwExceptionFromCallSlowPathGenerator):
      (JSC::DFG::slowPathFor):
      (JSC::DFG::linkForThunkGenerator):
      (JSC::DFG::linkCallThunkGenerator):
      (JSC::DFG::linkConstructThunkGenerator):
      (JSC::DFG::linkClosureCallThunkGenerator):
      (JSC::DFG::virtualForThunkGenerator):
      (JSC::DFG::virtualCallThunkGenerator):
      (JSC::DFG::virtualConstructThunkGenerator):
      * dfg/DFGThunks.h:
      (JSC):
      (DFG):
      * heap/BlockAllocator.h:
      (JSC):
      * heap/CopiedSpace.cpp:
      (JSC::CopiedSpace::tryAllocateSlowCase):
      (JSC::CopiedSpace::tryReallocate):
      * heap/CopiedSpaceInlines.h:
      (JSC::CopiedSpace::tryAllocate):
      * heap/GCThreadSharedData.cpp:
      (JSC::GCThreadSharedData::GCThreadSharedData):
      (JSC::GCThreadSharedData::reset):
      * heap/GCThreadSharedData.h:
      (JSC):
      (GCThreadSharedData):
      * heap/HandleSet.cpp:
      (JSC::HandleSet::HandleSet):
      (JSC::HandleSet::~HandleSet):
      (JSC::HandleSet::grow):
      * heap/HandleSet.h:
      (JSC):
      (HandleSet):
      (JSC::HandleSet::vm):
      * heap/Heap.cpp:
      (JSC::Heap::Heap):
      (JSC):
      (JSC::Heap::lastChanceToFinalize):
      (JSC::Heap::protect):
      (JSC::Heap::unprotect):
      (JSC::Heap::stack):
      (JSC::Heap::getConservativeRegisterRoots):
      (JSC::Heap::markRoots):
      (JSC::Heap::deleteAllCompiledCode):
      (JSC::Heap::collect):
      (JSC::Heap::isValidAllocation):
      * heap/Heap.h:
      (JSC):
      (Heap):
      (JSC::Heap::vm):
      * heap/HeapTimer.cpp:
      (JSC::HeapTimer::HeapTimer):
      (JSC::HeapTimer::timerDidFire):
      (JSC::HeapTimer::timerEvent):
      * heap/HeapTimer.h:
      (JSC):
      (HeapTimer):
      * heap/IncrementalSweeper.cpp:
      (JSC::IncrementalSweeper::IncrementalSweeper):
      (JSC::IncrementalSweeper::sweepNextBlock):
      (JSC::IncrementalSweeper::willFinishSweeping):
      (JSC::IncrementalSweeper::create):
      * heap/IncrementalSweeper.h:
      (IncrementalSweeper):
      * heap/Local.h:
      (Local):
      (JSC::::Local):
      (JSC::LocalStack::LocalStack):
      (JSC::LocalStack::push):
      (LocalStack):
      * heap/LocalScope.h:
      (JSC):
      (LocalScope):
      (JSC::LocalScope::LocalScope):
      * heap/MachineStackMarker.cpp:
      (JSC::MachineThreads::addCurrentThread):
      * heap/MarkedAllocator.cpp:
      (JSC::MarkedAllocator::allocateSlowCase):
      * heap/MarkedBlock.cpp:
      (JSC::MarkedBlock::MarkedBlock):
      * heap/MarkedBlock.h:
      (JSC::MarkedBlock::vm):
      * heap/SlotVisitor.cpp:
      (JSC::SlotVisitor::SlotVisitor):
      (JSC::SlotVisitor::setup):
      * heap/Strong.h:
      (JSC):
      (Strong):
      (JSC::Strong::operator=):
      * heap/StrongInlines.h:
      (JSC::::Strong):
      (JSC::::set):
      * heap/SuperRegion.h:
      (JSC):
      * heap/WeakSet.cpp:
      * heap/WeakSet.h:
      (WeakSet):
      (JSC::WeakSet::WeakSet):
      (JSC::WeakSet::vm):
      * interpreter/AbstractPC.cpp:
      (JSC::AbstractPC::AbstractPC):
      * interpreter/AbstractPC.h:
      (JSC):
      (AbstractPC):
      * interpreter/CachedCall.h:
      (JSC::CachedCall::CachedCall):
      * interpreter/CallFrame.h:
      (ExecState):
      (JSC::ExecState::clearException):
      (JSC::ExecState::clearSupplementaryExceptionInfo):
      (JSC::ExecState::exception):
      (JSC::ExecState::hadException):
      (JSC::ExecState::propertyNames):
      (JSC::ExecState::emptyList):
      (JSC::ExecState::interpreter):
      (JSC::ExecState::heap):
      (JSC::ExecState::arrayConstructorTable):
      (JSC::ExecState::arrayPrototypeTable):
      (JSC::ExecState::booleanPrototypeTable):
      (JSC::ExecState::dateTable):
      (JSC::ExecState::dateConstructorTable):
      (JSC::ExecState::errorPrototypeTable):
      (JSC::ExecState::globalObjectTable):
      (JSC::ExecState::jsonTable):
      (JSC::ExecState::mathTable):
      (JSC::ExecState::numberConstructorTable):
      (JSC::ExecState::numberPrototypeTable):
      (JSC::ExecState::objectConstructorTable):
      (JSC::ExecState::privateNamePrototypeTable):
      (JSC::ExecState::regExpTable):
      (JSC::ExecState::regExpConstructorTable):
      (JSC::ExecState::regExpPrototypeTable):
      (JSC::ExecState::stringConstructorTable):
      (JSC::ExecState::abstractReturnPC):
      * interpreter/CallFrameClosure.h:
      (CallFrameClosure):
      * interpreter/Interpreter.cpp:
      (JSC):
      (JSC::eval):
      (JSC::loadVarargs):
      (JSC::Interpreter::Interpreter):
      (JSC::Interpreter::dumpRegisters):
      (JSC::Interpreter::unwindCallFrame):
      (JSC::appendSourceToError):
      (JSC::getCallerInfo):
      (JSC::Interpreter::getStackTrace):
      (JSC::Interpreter::addStackTraceIfNecessary):
      (JSC::Interpreter::throwException):
      (JSC::Interpreter::execute):
      (JSC::Interpreter::executeCall):
      (JSC::Interpreter::executeConstruct):
      (JSC::Interpreter::prepareForRepeatCall):
      (JSC::Interpreter::retrieveArgumentsFromVMCode):
      (JSC::Interpreter::retrieveCallerFromVMCode):
      * interpreter/Interpreter.h:
      (JSC):
      (JSC::TopCallFrameSetter::TopCallFrameSetter):
      (JSC::TopCallFrameSetter::~TopCallFrameSetter):
      (TopCallFrameSetter):
      (JSC::NativeCallFrameTracer::NativeCallFrameTracer):
      (Interpreter):
      * interpreter/JSStack.cpp:
      (JSC::JSStack::JSStack):
      * interpreter/JSStack.h:
      (JSC):
      * jit/ClosureCallStubRoutine.cpp:
      (JSC::ClosureCallStubRoutine::ClosureCallStubRoutine):
      * jit/ClosureCallStubRoutine.h:
      (ClosureCallStubRoutine):
      * jit/ExecutableAllocator.cpp:
      (JSC::ExecutableAllocator::ExecutableAllocator):
      (JSC::ExecutableAllocator::allocate):
      * jit/ExecutableAllocator.h:
      (JSC):
      (ExecutableAllocator):
      * jit/ExecutableAllocatorFixedVMPool.cpp:
      (JSC::ExecutableAllocator::ExecutableAllocator):
      (JSC::ExecutableAllocator::allocate):
      * jit/GCAwareJITStubRoutine.cpp:
      (JSC::GCAwareJITStubRoutine::GCAwareJITStubRoutine):
      (JSC::MarkingGCAwareJITStubRoutineWithOneObject::MarkingGCAwareJITStubRoutineWithOneObject):
      (JSC::createJITStubRoutine):
      * jit/GCAwareJITStubRoutine.h:
      (GCAwareJITStubRoutine):
      (MarkingGCAwareJITStubRoutineWithOneObject):
      (JSC):
      * jit/JIT.cpp:
      (JSC::JIT::JIT):
      (JSC::JIT::privateCompile):
      (JSC::JIT::linkFor):
      (JSC::JIT::linkSlowCall):
      * jit/JIT.h:
      (JSC::JIT::compile):
      (JSC::JIT::compileClosureCall):
      (JSC::JIT::compileGetByIdProto):
      (JSC::JIT::compileGetByIdSelfList):
      (JSC::JIT::compileGetByIdProtoList):
      (JSC::JIT::compileGetByIdChainList):
      (JSC::JIT::compileGetByIdChain):
      (JSC::JIT::compilePutByIdTransition):
      (JSC::JIT::compileGetByVal):
      (JSC::JIT::compilePutByVal):
      (JSC::JIT::compileCTINativeCall):
      (JSC::JIT::compilePatchGetArrayLength):
      (JIT):
      * jit/JITCall.cpp:
      (JSC::JIT::compileLoadVarargs):
      (JSC::JIT::compileCallEvalSlowCase):
      (JSC::JIT::compileOpCallSlowCase):
      (JSC::JIT::privateCompileClosureCall):
      * jit/JITCall32_64.cpp:
      (JSC::JIT::compileLoadVarargs):
      (JSC::JIT::compileCallEvalSlowCase):
      (JSC::JIT::compileOpCallSlowCase):
      (JSC::JIT::privateCompileClosureCall):
      * jit/JITCode.h:
      (JSC):
      (JSC::JITCode::execute):
      * jit/JITDriver.h:
      (JSC::jitCompileIfAppropriate):
      (JSC::jitCompileFunctionIfAppropriate):
      * jit/JITExceptions.cpp:
      (JSC::genericThrow):
      (JSC::jitThrow):
      * jit/JITExceptions.h:
      (JSC):
      * jit/JITInlines.h:
      (JSC::JIT::emitLoadCharacterString):
      (JSC::JIT::updateTopCallFrame):
      * jit/JITOpcodes.cpp:
      (JSC::JIT::privateCompileCTINativeCall):
      (JSC::JIT::emit_op_new_object):
      (JSC::JIT::emit_op_to_primitive):
      (JSC::JIT::emit_op_catch):
      (JSC::JIT::emit_op_convert_this):
      (JSC::JIT::emitSlow_op_convert_this):
      * jit/JITOpcodes32_64.cpp:
      (JSC::JIT::privateCompileCTINativeCall):
      (JSC::JIT::emit_op_new_object):
      (JSC::JIT::emit_op_to_primitive):
      (JSC::JIT::emitSlow_op_eq):
      (JSC::JIT::emitSlow_op_neq):
      (JSC::JIT::compileOpStrictEq):
      (JSC::JIT::emit_op_catch):
      (JSC::JIT::emit_op_convert_this):
      (JSC::JIT::emitSlow_op_convert_this):
      * jit/JITPropertyAccess.cpp:
      (JSC::JIT::stringGetByValStubGenerator):
      (JSC::JIT::emitSlow_op_get_by_val):
      (JSC::JIT::compileGetByIdHotPath):
      (JSC::JIT::privateCompilePutByIdTransition):
      (JSC::JIT::privateCompilePatchGetArrayLength):
      (JSC::JIT::privateCompileGetByIdProto):
      (JSC::JIT::privateCompileGetByIdSelfList):
      (JSC::JIT::privateCompileGetByIdProtoList):
      (JSC::JIT::privateCompileGetByIdChainList):
      (JSC::JIT::privateCompileGetByIdChain):
      (JSC::JIT::privateCompileGetByVal):
      (JSC::JIT::privateCompilePutByVal):
      * jit/JITPropertyAccess32_64.cpp:
      (JSC::JIT::stringGetByValStubGenerator):
      (JSC::JIT::emitSlow_op_get_by_val):
      (JSC::JIT::compileGetByIdHotPath):
      (JSC::JIT::privateCompilePutByIdTransition):
      (JSC::JIT::privateCompilePatchGetArrayLength):
      (JSC::JIT::privateCompileGetByIdProto):
      (JSC::JIT::privateCompileGetByIdSelfList):
      (JSC::JIT::privateCompileGetByIdProtoList):
      (JSC::JIT::privateCompileGetByIdChainList):
      (JSC::JIT::privateCompileGetByIdChain):
      * jit/JITStubs.cpp:
      (JSC::ctiTrampoline):
      (JSC):
      (JSC::performPlatformSpecificJITAssertions):
      (JSC::tryCachePutByID):
      (JSC::tryCacheGetByID):
      (JSC::returnToThrowTrampoline):
      (JSC::throwExceptionFromOpCall):
      (JSC::DEFINE_STUB_FUNCTION):
      (JSC::getPolymorphicAccessStructureListSlot):
      (JSC::jitCompileFor):
      (JSC::lazyLinkFor):
      (JSC::putByVal):
      * jit/JITStubs.h:
      (JSC):
      (JITStackFrame):
      * jit/JITThunks.cpp:
      (JSC::JITThunks::ctiNativeCall):
      (JSC::JITThunks::ctiNativeConstruct):
      (JSC::JITThunks::ctiStub):
      (JSC::JITThunks::hostFunctionStub):
      * jit/JITThunks.h:
      (JSC):
      (JITThunks):
      * jit/JITWriteBarrier.h:
      (JSC):
      (JSC::JITWriteBarrierBase::set):
      (JSC::JITWriteBarrier::set):
      * jit/SpecializedThunkJIT.h:
      (JSC::SpecializedThunkJIT::loadJSStringArgument):
      (JSC::SpecializedThunkJIT::finalize):
      * jit/ThunkGenerator.h:
      (JSC):
      * jit/ThunkGenerators.cpp:
      (JSC::generateSlowCaseFor):
      (JSC::linkForGenerator):
      (JSC::linkCallGenerator):
      (JSC::linkConstructGenerator):
      (JSC::linkClosureCallGenerator):
      (JSC::virtualForGenerator):
      (JSC::virtualCallGenerator):
      (JSC::virtualConstructGenerator):
      (JSC::stringLengthTrampolineGenerator):
      (JSC::nativeForGenerator):
      (JSC::nativeCallGenerator):
      (JSC::nativeConstructGenerator):
      (JSC::stringCharLoad):
      (JSC::charToString):
      (JSC::charCodeAtThunkGenerator):
      (JSC::charAtThunkGenerator):
      (JSC::fromCharCodeThunkGenerator):
      (JSC::sqrtThunkGenerator):
      (JSC::floorThunkGenerator):
      (JSC::ceilThunkGenerator):
      (JSC::roundThunkGenerator):
      (JSC::expThunkGenerator):
      (JSC::logThunkGenerator):
      (JSC::absThunkGenerator):
      (JSC::powThunkGenerator):
      * jit/ThunkGenerators.h:
      (JSC):
      * jsc.cpp:
      (GlobalObject):
      (GlobalObject::create):
      (GlobalObject::createStructure):
      (GlobalObject::finishCreation):
      (GlobalObject::addFunction):
      (GlobalObject::addConstructableFunction):
      (functionDumpCallFrame):
      (functionJSCStack):
      (functionReleaseExecutableMemory):
      (functionRun):
      (main):
      (runWithScripts):
      (jscmain):
      * llint/LLIntData.cpp:
      (JSC::LLInt::Data::performAssertions):
      * llint/LLIntData.h:
      (JSC):
      (Data):
      (JSC::LLInt::Data::performAssertions):
      * llint/LLIntEntrypoints.cpp:
      (JSC::LLInt::getFunctionEntrypoint):
      (JSC::LLInt::getEvalEntrypoint):
      (JSC::LLInt::getProgramEntrypoint):
      * llint/LLIntEntrypoints.h:
      (JSC):
      (LLInt):
      (JSC::LLInt::getEntrypoint):
      * llint/LLIntExceptions.cpp:
      (JSC::LLInt::interpreterThrowInCaller):
      (JSC::LLInt::returnToThrow):
      (JSC::LLInt::callToThrow):
      * llint/LLIntOffsetsExtractor.cpp:
      * llint/LLIntSlowPaths.cpp:
      (LLInt):
      (JSC::LLInt::llint_trace_operand):
      (JSC::LLInt::llint_trace_value):
      (JSC::LLInt::LLINT_SLOW_PATH_DECL):
      (JSC::LLInt::shouldJIT):
      (JSC::LLInt::handleHostCall):
      (JSC::LLInt::setUpCall):
      * llint/LLIntThunks.cpp:
      (JSC::LLInt::generateThunkWithJumpTo):
      (JSC::LLInt::functionForCallEntryThunkGenerator):
      (JSC::LLInt::functionForConstructEntryThunkGenerator):
      (JSC::LLInt::functionForCallArityCheckThunkGenerator):
      (JSC::LLInt::functionForConstructArityCheckThunkGenerator):
      (JSC::LLInt::evalEntryThunkGenerator):
      (JSC::LLInt::programEntryThunkGenerator):
      * llint/LLIntThunks.h:
      (JSC):
      (LLInt):
      * llint/LowLevelInterpreter.asm:
      * llint/LowLevelInterpreter.cpp:
      (JSC::CLoop::execute):
      * llint/LowLevelInterpreter32_64.asm:
      * llint/LowLevelInterpreter64.asm:
      * offlineasm/cloop.rb:
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::ASTBuilder):
      (JSC::ASTBuilder::createSourceElements):
      (JSC::ASTBuilder::createCommaExpr):
      (JSC::ASTBuilder::createLogicalNot):
      (JSC::ASTBuilder::createUnaryPlus):
      (JSC::ASTBuilder::createVoid):
      (JSC::ASTBuilder::thisExpr):
      (JSC::ASTBuilder::createResolve):
      (JSC::ASTBuilder::createObjectLiteral):
      (JSC::ASTBuilder::createArray):
      (JSC::ASTBuilder::createNumberExpr):
      (JSC::ASTBuilder::createString):
      (JSC::ASTBuilder::createBoolean):
      (JSC::ASTBuilder::createNull):
      (JSC::ASTBuilder::createBracketAccess):
      (JSC::ASTBuilder::createDotAccess):
      (JSC::ASTBuilder::createRegExp):
      (JSC::ASTBuilder::createNewExpr):
      (JSC::ASTBuilder::createConditionalExpr):
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createFunctionExpr):
      (JSC::ASTBuilder::createFunctionBody):
      (JSC::ASTBuilder::createGetterOrSetterProperty):
      (JSC::ASTBuilder::createArguments):
      (JSC::ASTBuilder::createArgumentsList):
      (JSC::ASTBuilder::createProperty):
      (JSC::ASTBuilder::createPropertyList):
      (JSC::ASTBuilder::createElementList):
      (JSC::ASTBuilder::createFormalParameterList):
      (JSC::ASTBuilder::createClause):
      (JSC::ASTBuilder::createClauseList):
      (JSC::ASTBuilder::createFuncDeclStatement):
      (JSC::ASTBuilder::createBlockStatement):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createIfStatement):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createEmptyStatement):
      (JSC::ASTBuilder::createVarStatement):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createTryStatement):
      (JSC::ASTBuilder::createSwitchStatement):
      (JSC::ASTBuilder::createWhileStatement):
      (JSC::ASTBuilder::createDoWhileStatement):
      (JSC::ASTBuilder::createLabelStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::createDebugger):
      (JSC::ASTBuilder::createConstStatement):
      (JSC::ASTBuilder::appendConstDecl):
      (JSC::ASTBuilder::addVar):
      (JSC::ASTBuilder::combineCommaNodes):
      (JSC::ASTBuilder::Scope::Scope):
      (JSC::ASTBuilder::createNumber):
      (ASTBuilder):
      (JSC::ASTBuilder::makeTypeOfNode):
      (JSC::ASTBuilder::makeDeleteNode):
      (JSC::ASTBuilder::makeNegateNode):
      (JSC::ASTBuilder::makeBitwiseNotNode):
      (JSC::ASTBuilder::makeMultNode):
      (JSC::ASTBuilder::makeDivNode):
      (JSC::ASTBuilder::makeModNode):
      (JSC::ASTBuilder::makeAddNode):
      (JSC::ASTBuilder::makeSubNode):
      (JSC::ASTBuilder::makeLeftShiftNode):
      (JSC::ASTBuilder::makeRightShiftNode):
      (JSC::ASTBuilder::makeURightShiftNode):
      (JSC::ASTBuilder::makeBitOrNode):
      (JSC::ASTBuilder::makeBitAndNode):
      (JSC::ASTBuilder::makeBitXOrNode):
      (JSC::ASTBuilder::makeFunctionCallNode):
      (JSC::ASTBuilder::makeBinaryNode):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):
      * parser/Lexer.cpp:
      (JSC::Keywords::Keywords):
      (JSC::::Lexer):
      (JSC::::parseIdentifier):
      (JSC::::parseIdentifierSlowCase):
      * parser/Lexer.h:
      (JSC::Keywords::isKeyword):
      (JSC::Keywords::getKeyword):
      (Keywords):
      (Lexer):
      (JSC::::makeIdentifier):
      (JSC::::makeRightSizedIdentifier):
      (JSC::::makeIdentifierLCharFromUChar):
      (JSC::::makeLCharIdentifier):
      * parser/NodeConstructors.h:
      (JSC::ParserArenaFreeable::operator new):
      (JSC::ParserArenaDeletable::operator new):
      (JSC::ParserArenaRefCounted::ParserArenaRefCounted):
      (JSC::PropertyNode::PropertyNode):
      (JSC::ContinueNode::ContinueNode):
      (JSC::BreakNode::BreakNode):
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.cpp:
      (JSC::ScopeNode::ScopeNode):
      (JSC::ProgramNode::ProgramNode):
      (JSC::ProgramNode::create):
      (JSC::EvalNode::EvalNode):
      (JSC::EvalNode::create):
      (JSC::FunctionBodyNode::FunctionBodyNode):
      (JSC::FunctionBodyNode::create):
      * parser/Nodes.h:
      (ParserArenaFreeable):
      (ParserArenaDeletable):
      (ParserArenaRefCounted):
      (ArrayNode):
      (ForInNode):
      (ContinueNode):
      (BreakNode):
      (ScopeNode):
      (ProgramNode):
      (EvalNode):
      (FunctionBodyNode):
      * parser/Parser.cpp:
      (JSC::::Parser):
      (JSC::::parseInner):
      (JSC::::parseSourceElements):
      (JSC::::parseTryStatement):
      (JSC::::parseFunctionBody):
      (JSC::::parseFunctionInfo):
      (JSC::::parseAssignmentExpression):
      (JSC::::parseProperty):
      (JSC::::parsePrimaryExpression):
      (JSC::::parseMemberExpression):
      (JSC::::parseUnaryExpression):
      * parser/Parser.h:
      (JSC):
      (JSC::Scope::Scope):
      (JSC::Scope::declareVariable):
      (JSC::Scope::declareParameter):
      (Scope):
      (Parser):
      (JSC::Parser::pushScope):
      (JSC::::parse):
      (JSC::parse):
      * parser/ParserArena.h:
      (IdentifierArena):
      (JSC::IdentifierArena::makeIdentifier):
      (JSC::IdentifierArena::makeIdentifierLCharFromUChar):
      (JSC::IdentifierArena::makeNumericIdentifier):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::SyntaxChecker):
      (JSC::SyntaxChecker::createProperty):
      (JSC::SyntaxChecker::createGetterOrSetterProperty):
      * profiler/LegacyProfiler.cpp:
      (JSC::LegacyProfiler::startProfiling):
      (JSC::LegacyProfiler::stopProfiling):
      * profiler/LegacyProfiler.h:
      (JSC):
      * profiler/ProfilerBytecode.cpp:
      (JSC::Profiler::Bytecode::toJS):
      * profiler/ProfilerBytecodeSequence.cpp:
      (JSC::Profiler::BytecodeSequence::BytecodeSequence):
      (JSC::Profiler::BytecodeSequence::addSequenceProperties):
      * profiler/ProfilerBytecodes.cpp:
      (JSC::Profiler::Bytecodes::toJS):
      * profiler/ProfilerCompilation.cpp:
      (JSC::Profiler::Compilation::toJS):
      * profiler/ProfilerCompiledBytecode.cpp:
      (JSC::Profiler::CompiledBytecode::toJS):
      * profiler/ProfilerDatabase.cpp:
      (JSC::Profiler::Database::Database):
      (JSC::Profiler::Database::toJS):
      (JSC::Profiler::Database::toJSON):
      * profiler/ProfilerDatabase.h:
      (Database):
      * profiler/ProfilerOSRExit.cpp:
      (JSC::Profiler::OSRExit::toJS):
      * profiler/ProfilerOrigin.cpp:
      (JSC::Profiler::Origin::toJS):
      * profiler/ProfilerProfiledBytecodes.cpp:
      (JSC::Profiler::ProfiledBytecodes::toJS):
      * runtime/ArgList.h:
      (MarkedArgumentBuffer):
      * runtime/Arguments.cpp:
      (JSC::Arguments::putByIndex):
      (JSC::Arguments::put):
      (JSC::Arguments::deleteProperty):
      (JSC::Arguments::defineOwnProperty):
      (JSC::Arguments::tearOff):
      (JSC::Arguments::didTearOffActivation):
      (JSC::Arguments::tearOffForInlineCallFrame):
      * runtime/Arguments.h:
      (JSC::Arguments::create):
      (JSC::Arguments::createStructure):
      (Arguments):
      (JSC::Arguments::Arguments):
      (JSC::Arguments::trySetArgument):
      (JSC::Arguments::finishCreation):
      * runtime/ArrayConstructor.cpp:
      (JSC::ArrayConstructor::finishCreation):
      * runtime/ArrayConstructor.h:
      (JSC::ArrayConstructor::createStructure):
      * runtime/ArrayPrototype.cpp:
      (JSC::ArrayPrototype::ArrayPrototype):
      (JSC::ArrayPrototype::finishCreation):
      (JSC::arrayProtoFuncSort):
      (JSC::arrayProtoFuncSplice):
      * runtime/ArrayPrototype.h:
      (JSC::ArrayPrototype::createStructure):
      * runtime/BatchedTransitionOptimizer.h:
      (JSC::BatchedTransitionOptimizer::BatchedTransitionOptimizer):
      (JSC::BatchedTransitionOptimizer::~BatchedTransitionOptimizer):
      (BatchedTransitionOptimizer):
      * runtime/BooleanConstructor.cpp:
      (JSC::BooleanConstructor::finishCreation):
      (JSC::constructBoolean):
      (JSC::constructBooleanFromImmediateBoolean):
      * runtime/BooleanConstructor.h:
      (JSC::BooleanConstructor::createStructure):
      * runtime/BooleanObject.cpp:
      (JSC::BooleanObject::BooleanObject):
      (JSC::BooleanObject::finishCreation):
      * runtime/BooleanObject.h:
      (BooleanObject):
      (JSC::BooleanObject::create):
      (JSC::BooleanObject::createStructure):
      * runtime/BooleanPrototype.cpp:
      (JSC::BooleanPrototype::BooleanPrototype):
      (JSC::BooleanPrototype::finishCreation):
      (JSC::booleanProtoFuncToString):
      * runtime/BooleanPrototype.h:
      (JSC::BooleanPrototype::createStructure):
      * runtime/Butterfly.h:
      (JSC):
      (Butterfly):
      * runtime/ButterflyInlines.h:
      (JSC::Butterfly::createUninitialized):
      (JSC::Butterfly::create):
      (JSC::Butterfly::growPropertyStorage):
      (JSC::Butterfly::createOrGrowArrayRight):
      (JSC::Butterfly::growArrayRight):
      (JSC::Butterfly::resizeArray):
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::getCodeBlock):
      (JSC::CodeCache::getProgramCodeBlock):
      (JSC::CodeCache::getEvalCodeBlock):
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      * runtime/CodeCache.h:
      (JSC):
      (JSC::SourceCodeValue::SourceCodeValue):
      (CodeCache):
      * runtime/CommonIdentifiers.cpp:
      (JSC):
      (JSC::CommonIdentifiers::CommonIdentifiers):
      * runtime/CommonIdentifiers.h:
      (CommonIdentifiers):
      * runtime/CommonSlowPaths.h:
      (JSC::CommonSlowPaths::opIn):
      * runtime/Completion.cpp:
      (JSC::checkSyntax):
      (JSC::evaluate):
      * runtime/DateConstructor.cpp:
      (JSC::DateConstructor::finishCreation):
      * runtime/DateConstructor.h:
      (JSC::DateConstructor::createStructure):
      * runtime/DateInstance.cpp:
      (JSC::DateInstance::DateInstance):
      (JSC::DateInstance::finishCreation):
      (JSC::DateInstance::calculateGregorianDateTime):
      (JSC::DateInstance::calculateGregorianDateTimeUTC):
      * runtime/DateInstance.h:
      (DateInstance):
      (JSC::DateInstance::create):
      (JSC::DateInstance::createStructure):
      * runtime/DatePrototype.cpp:
      (JSC::DatePrototype::finishCreation):
      (JSC::dateProtoFuncSetTime):
      (JSC::setNewValueFromTimeArgs):
      (JSC::setNewValueFromDateArgs):
      (JSC::dateProtoFuncSetYear):
      (JSC::dateProtoFuncToJSON):
      * runtime/DatePrototype.h:
      (JSC::DatePrototype::createStructure):
      * runtime/Error.cpp:
      (JSC::createError):
      (JSC::createEvalError):
      (JSC::createRangeError):
      (JSC::createReferenceError):
      (JSC::createSyntaxError):
      (JSC::createTypeError):
      (JSC::createURIError):
      (JSC::addErrorInfo):
      (JSC::throwError):
      * runtime/Error.h:
      (JSC):
      (JSC::StrictModeTypeErrorFunction::create):
      (JSC::StrictModeTypeErrorFunction::createStructure):
      * runtime/ErrorConstructor.cpp:
      (JSC::ErrorConstructor::finishCreation):
      * runtime/ErrorConstructor.h:
      (JSC::ErrorConstructor::createStructure):
      * runtime/ErrorInstance.cpp:
      (JSC::ErrorInstance::ErrorInstance):
      * runtime/ErrorInstance.h:
      (JSC::ErrorInstance::createStructure):
      (JSC::ErrorInstance::create):
      (ErrorInstance):
      (JSC::ErrorInstance::finishCreation):
      * runtime/ErrorPrototype.cpp:
      (JSC::ErrorPrototype::ErrorPrototype):
      (JSC::ErrorPrototype::finishCreation):
      * runtime/ErrorPrototype.h:
      (JSC::ErrorPrototype::createStructure):
      * runtime/ExceptionHelpers.cpp:
      (JSC::createInterruptedExecutionException):
      (JSC::createTerminatedExecutionException):
      * runtime/ExceptionHelpers.h:
      (JSC):
      (JSC::InterruptedExecutionError::InterruptedExecutionError):
      (JSC::InterruptedExecutionError::create):
      (JSC::InterruptedExecutionError::createStructure):
      (JSC::TerminatedExecutionError::TerminatedExecutionError):
      (JSC::TerminatedExecutionError::create):
      (JSC::TerminatedExecutionError::createStructure):
      * runtime/Executable.cpp:
      (JSC::jettisonCodeBlock):
      (JSC::EvalExecutable::EvalExecutable):
      (JSC::ProgramExecutable::ProgramExecutable):
      (JSC::FunctionExecutable::FunctionExecutable):
      (JSC::EvalExecutable::compileOptimized):
      (JSC::EvalExecutable::compileInternal):
      (JSC::EvalExecutable::jettisonOptimizedCode):
      (JSC::ProgramExecutable::checkSyntax):
      (JSC::ProgramExecutable::compileOptimized):
      (JSC::ProgramExecutable::jettisonOptimizedCode):
      (JSC::ProgramExecutable::initializeGlobalProperties):
      (JSC::FunctionExecutable::compileOptimizedForCall):
      (JSC::FunctionExecutable::compileOptimizedForConstruct):
      (JSC::FunctionExecutable::produceCodeBlockFor):
      (JSC::FunctionExecutable::jettisonOptimizedCodeForCall):
      (JSC::FunctionExecutable::jettisonOptimizedCodeForConstruct):
      (JSC::FunctionExecutable::fromGlobalCode):
      * runtime/Executable.h:
      (JSC::ExecutableBase::ExecutableBase):
      (JSC::ExecutableBase::finishCreation):
      (JSC::ExecutableBase::createStructure):
      (JSC::NativeExecutable::create):
      (JSC::NativeExecutable::createStructure):
      (JSC::NativeExecutable::finishCreation):
      (JSC::NativeExecutable::NativeExecutable):
      (JSC::ScriptExecutable::ScriptExecutable):
      (JSC::ScriptExecutable::finishCreation):
      (JSC::EvalExecutable::compile):
      (EvalExecutable):
      (JSC::EvalExecutable::create):
      (JSC::EvalExecutable::createStructure):
      (JSC::ProgramExecutable::create):
      (ProgramExecutable):
      (JSC::ProgramExecutable::compile):
      (JSC::ProgramExecutable::createStructure):
      (JSC::FunctionExecutable::create):
      (JSC::FunctionExecutable::compileForCall):
      (FunctionExecutable):
      (JSC::FunctionExecutable::compileForConstruct):
      (JSC::FunctionExecutable::jettisonOptimizedCodeFor):
      (JSC::FunctionExecutable::createStructure):
      (JSC::JSFunction::JSFunction):
      * runtime/ExecutionHarness.h:
      (JSC::prepareForExecution):
      (JSC::prepareFunctionForExecution):
      * runtime/FunctionConstructor.cpp:
      (JSC::FunctionConstructor::finishCreation):
      * runtime/FunctionConstructor.h:
      (JSC::FunctionConstructor::createStructure):
      * runtime/FunctionPrototype.cpp:
      (JSC::FunctionPrototype::finishCreation):
      (JSC::FunctionPrototype::addFunctionProperties):
      (JSC::functionProtoFuncBind):
      * runtime/FunctionPrototype.h:
      (JSC::FunctionPrototype::createStructure):
      * runtime/GCActivityCallback.cpp:
      (JSC::DefaultGCActivityCallback::DefaultGCActivityCallback):
      (JSC::DefaultGCActivityCallback::doWork):
      (JSC::DefaultGCActivityCallback::didAllocate):
      * runtime/GCActivityCallback.h:
      (JSC::GCActivityCallback::GCActivityCallback):
      * runtime/GCActivityCallbackBlackBerry.cpp:
      (JSC::DefaultGCActivityCallback::DefaultGCActivityCallback):
      (JSC::DefaultGCActivityCallback::doWork):
      (JSC::DefaultGCActivityCallback::didAllocate):
      * runtime/GetterSetter.h:
      (JSC::GetterSetter::GetterSetter):
      (JSC::GetterSetter::create):
      (JSC::GetterSetter::setGetter):
      (JSC::GetterSetter::setSetter):
      (JSC::GetterSetter::createStructure):
      * runtime/Identifier.cpp:
      (JSC::Identifier::add):
      (JSC::Identifier::add8):
      (JSC::Identifier::addSlowCase):
      (JSC::Identifier::from):
      (JSC::Identifier::checkCurrentIdentifierTable):
      * runtime/Identifier.h:
      (JSC::Identifier::Identifier):
      (JSC::Identifier::createLCharFromUChar):
      (Identifier):
      (JSC::Identifier::add):
      * runtime/InternalFunction.cpp:
      (JSC::InternalFunction::InternalFunction):
      (JSC::InternalFunction::finishCreation):
      (JSC::InternalFunction::name):
      (JSC::InternalFunction::displayName):
      * runtime/InternalFunction.h:
      (JSC::InternalFunction::createStructure):
      (InternalFunction):
      * runtime/JSAPIValueWrapper.h:
      (JSC::JSAPIValueWrapper::createStructure):
      (JSC::JSAPIValueWrapper::finishCreation):
      (JSC::JSAPIValueWrapper::JSAPIValueWrapper):
      * runtime/JSActivation.cpp:
      (JSC::JSActivation::symbolTablePut):
      (JSC::JSActivation::symbolTablePutWithAttributes):
      (JSC::JSActivation::getOwnPropertySlot):
      (JSC::JSActivation::put):
      (JSC::JSActivation::putDirectVirtual):
      (JSC::JSActivation::argumentsGetter):
      * runtime/JSActivation.h:
      (JSActivation):
      (JSC::JSActivation::create):
      (JSC::JSActivation::createStructure):
      (JSC::JSActivation::JSActivation):
      (JSC::JSActivation::tearOff):
      * runtime/JSArray.cpp:
      (JSC::createArrayButterflyInDictionaryIndexingMode):
      (JSC::JSArray::setLengthWritable):
      (JSC::JSArray::unshiftCountSlowCase):
      (JSC::JSArray::setLength):
      (JSC::JSArray::push):
      (JSC::JSArray::shiftCountWithAnyIndexingType):
      (JSC::JSArray::unshiftCountWithArrayStorage):
      (JSC::JSArray::unshiftCountWithAnyIndexingType):
      (JSC::ContiguousTypeAccessor::setWithValue):
      (JSC::JSArray::sortCompactedVector):
      (JSC::JSArray::sortVector):
      * runtime/JSArray.h:
      (JSC::JSArray::JSArray):
      (JSArray):
      (JSC::JSArray::shiftCountForShift):
      (JSC::JSArray::unshiftCountForShift):
      (JSC::JSArray::createStructure):
      (JSC::createContiguousArrayButterfly):
      (JSC::createArrayButterfly):
      (JSC):
      (JSC::JSArray::create):
      (JSC::JSArray::tryCreateUninitialized):
      (JSC::constructArray):
      * runtime/JSBoundFunction.cpp:
      (JSC::JSBoundFunction::create):
      (JSC::JSBoundFunction::JSBoundFunction):
      * runtime/JSBoundFunction.h:
      (JSC::JSBoundFunction::createStructure):
      * runtime/JSCJSValue.cpp:
      (JSC::JSValue::putToPrimitive):
      (JSC::JSValue::toStringSlowCase):
      * runtime/JSCJSValue.h:
      (JSC):
      * runtime/JSCell.h:
      (JSCell):
      * runtime/JSCellInlines.h:
      (JSC::JSCell::JSCell):
      (JSC::JSCell::finishCreation):
      (JSC::allocateCell):
      (JSC::JSCell::setStructure):
      (JSC::JSCell::fastGetOwnProperty):
      * runtime/JSDateMath.cpp:
      (JSC::getDSTOffset):
      (JSC::getUTCOffset):
      (JSC::parseDate):
      * runtime/JSDestructibleObject.h:
      (JSC::JSDestructibleObject::JSDestructibleObject):
      * runtime/JSFunction.cpp:
      (JSC::JSFunction::create):
      (JSC::JSFunction::JSFunction):
      (JSC::JSFunction::finishCreation):
      (JSC::JSFunction::createAllocationProfile):
      (JSC::JSFunction::name):
      (JSC::JSFunction::displayName):
      (JSC::JSFunction::getOwnPropertySlot):
      (JSC::JSFunction::deleteProperty):
      * runtime/JSFunction.h:
      (JSFunction):
      (JSC::JSFunction::create):
      (JSC::JSFunction::setScope):
      (JSC::JSFunction::createStructure):
      * runtime/JSGlobalData.cpp: Removed.
      * runtime/JSGlobalData.h: Removed.
      * runtime/JSGlobalObject.cpp:
      (JSC::JSGlobalObject::JSGlobalObject):
      (JSC::JSGlobalObject::~JSGlobalObject):
      (JSC::JSGlobalObject::setGlobalThis):
      (JSC::JSGlobalObject::init):
      (JSC::JSGlobalObject::putDirectVirtual):
      (JSC::JSGlobalObject::reset):
      (JSC):
      (JSC::JSGlobalObject::haveABadTime):
      (JSC::JSGlobalObject::createThrowTypeError):
      (JSC::JSGlobalObject::resetPrototype):
      (JSC::JSGlobalObject::addStaticGlobals):
      (JSC::DynamicGlobalObjectScope::DynamicGlobalObjectScope):
      (JSC::JSGlobalObject::createProgramCodeBlock):
      (JSC::JSGlobalObject::createEvalCodeBlock):
      * runtime/JSGlobalObject.h:
      (JSC::JSGlobalObject::create):
      (JSGlobalObject):
      (JSC::JSGlobalObject::finishCreation):
      (JSC::JSGlobalObject::vm):
      (JSC::JSGlobalObject::createStructure):
      (JSC::ExecState::dynamicGlobalObject):
      (JSC::constructEmptyArray):
      (DynamicGlobalObjectScope):
      * runtime/JSGlobalObjectFunctions.cpp:
      (JSC::globalFuncProtoSetter):
      * runtime/JSLock.cpp:
      (JSC::JSLockHolder::JSLockHolder):
      (JSC::JSLockHolder::init):
      (JSC::JSLockHolder::~JSLockHolder):
      (JSC::JSLock::JSLock):
      (JSC::JSLock::willDestroyGlobalData):
      (JSC::JSLock::lock):
      (JSC::JSLock::unlock):
      (JSC::JSLock::DropAllLocks::DropAllLocks):
      (JSC::JSLock::DropAllLocks::~DropAllLocks):
      * runtime/JSLock.h:
      (JSC):
      (JSLockHolder):
      (JSLock):
      (JSC::JSLock::vm):
      (DropAllLocks):
      * runtime/JSNameScope.h:
      (JSC::JSNameScope::createStructure):
      (JSC::JSNameScope::finishCreation):
      (JSC::JSNameScope::JSNameScope):
      * runtime/JSNotAnObject.h:
      (JSC::JSNotAnObject::JSNotAnObject):
      (JSC::JSNotAnObject::create):
      (JSC::JSNotAnObject::createStructure):
      * runtime/JSONObject.cpp:
      (JSC::JSONObject::JSONObject):
      (JSC::JSONObject::finishCreation):
      (Holder):
      (JSC::Stringifier::Stringifier):
      (JSC::Stringifier::stringify):
      (JSC::Stringifier::toJSON):
      (JSC::Stringifier::appendStringifiedValue):
      (JSC::Stringifier::Holder::Holder):
      (JSC::Stringifier::Holder::appendNextProperty):
      (JSC::Walker::Walker):
      (JSC::Walker::walk):
      (JSC::JSONProtoFuncParse):
      (JSC::JSONProtoFuncStringify):
      (JSC::JSONStringify):
      * runtime/JSONObject.h:
      (JSC::JSONObject::createStructure):
      * runtime/JSObject.cpp:
      (JSC::JSObject::put):
      (JSC::JSObject::putByIndex):
      (JSC::JSObject::enterDictionaryIndexingModeWhenArrayStorageAlreadyExists):
      (JSC::JSObject::enterDictionaryIndexingMode):
      (JSC::JSObject::notifyPresenceOfIndexedAccessors):
      (JSC::JSObject::createInitialIndexedStorage):
      (JSC::JSObject::createInitialUndecided):
      (JSC::JSObject::createInitialInt32):
      (JSC::JSObject::createInitialDouble):
      (JSC::JSObject::createInitialContiguous):
      (JSC::JSObject::createArrayStorage):
      (JSC::JSObject::createInitialArrayStorage):
      (JSC::JSObject::convertUndecidedToInt32):
      (JSC::JSObject::convertUndecidedToDouble):
      (JSC::JSObject::convertUndecidedToContiguous):
      (JSC::JSObject::constructConvertedArrayStorageWithoutCopyingElements):
      (JSC::JSObject::convertUndecidedToArrayStorage):
      (JSC::JSObject::convertInt32ToDouble):
      (JSC::JSObject::convertInt32ToContiguous):
      (JSC::JSObject::convertInt32ToArrayStorage):
      (JSC::JSObject::genericConvertDoubleToContiguous):
      (JSC::JSObject::convertDoubleToContiguous):
      (JSC::JSObject::rageConvertDoubleToContiguous):
      (JSC::JSObject::convertDoubleToArrayStorage):
      (JSC::JSObject::convertContiguousToArrayStorage):
      (JSC::JSObject::convertUndecidedForValue):
      (JSC::JSObject::convertInt32ForValue):
      (JSC::JSObject::setIndexQuicklyToUndecided):
      (JSC::JSObject::convertInt32ToDoubleOrContiguousWhilePerformingSetIndex):
      (JSC::JSObject::convertDoubleToContiguousWhilePerformingSetIndex):
      (JSC::JSObject::ensureInt32Slow):
      (JSC::JSObject::ensureDoubleSlow):
      (JSC::JSObject::ensureContiguousSlow):
      (JSC::JSObject::rageEnsureContiguousSlow):
      (JSC::JSObject::ensureArrayStorageSlow):
      (JSC::JSObject::ensureArrayStorageExistsAndEnterDictionaryIndexingMode):
      (JSC::JSObject::switchToSlowPutArrayStorage):
      (JSC::JSObject::putDirectVirtual):
      (JSC::JSObject::setPrototype):
      (JSC::JSObject::setPrototypeWithCycleCheck):
      (JSC::JSObject::putDirectAccessor):
      (JSC::JSObject::deleteProperty):
      (JSC::JSObject::getPropertySpecificValue):
      (JSC::JSObject::getOwnNonIndexPropertyNames):
      (JSC::JSObject::seal):
      (JSC::JSObject::freeze):
      (JSC::JSObject::preventExtensions):
      (JSC::JSObject::reifyStaticFunctionsForDelete):
      (JSC::JSObject::removeDirect):
      (JSC::JSObject::putIndexedDescriptor):
      (JSC::JSObject::defineOwnIndexedProperty):
      (JSC::JSObject::allocateSparseIndexMap):
      (JSC::JSObject::putByIndexBeyondVectorLengthWithoutAttributes):
      (JSC::JSObject::putByIndexBeyondVectorLengthWithArrayStorage):
      (JSC::JSObject::putByIndexBeyondVectorLength):
      (JSC::JSObject::putDirectIndexBeyondVectorLengthWithArrayStorage):
      (JSC::JSObject::putDirectIndexBeyondVectorLength):
      (JSC::JSObject::putDirectNativeFunction):
      (JSC::JSObject::increaseVectorLength):
      (JSC::JSObject::ensureLengthSlow):
      (JSC::JSObject::growOutOfLineStorage):
      (JSC::JSObject::getOwnPropertyDescriptor):
      (JSC::putDescriptor):
      (JSC::JSObject::putDirectMayBeIndex):
      (JSC::DefineOwnPropertyScope::DefineOwnPropertyScope):
      (JSC::DefineOwnPropertyScope::~DefineOwnPropertyScope):
      (DefineOwnPropertyScope):
      (JSC::JSObject::defineOwnNonIndexProperty):
      * runtime/JSObject.h:
      (JSObject):
      (JSC::JSObject::putByIndexInline):
      (JSC::JSObject::putDirectIndex):
      (JSC::JSObject::setIndexQuickly):
      (JSC::JSObject::initializeIndex):
      (JSC::JSObject::getDirect):
      (JSC::JSObject::getDirectOffset):
      (JSC::JSObject::putDirect):
      (JSC::JSObject::isSealed):
      (JSC::JSObject::isFrozen):
      (JSC::JSObject::flattenDictionaryObject):
      (JSC::JSObject::ensureInt32):
      (JSC::JSObject::ensureDouble):
      (JSC::JSObject::ensureContiguous):
      (JSC::JSObject::rageEnsureContiguous):
      (JSC::JSObject::ensureArrayStorage):
      (JSC::JSObject::finishCreation):
      (JSC::JSObject::createStructure):
      (JSC::JSObject::ensureLength):
      (JSC::JSNonFinalObject::createStructure):
      (JSC::JSNonFinalObject::JSNonFinalObject):
      (JSC::JSNonFinalObject::finishCreation):
      (JSC::JSFinalObject::createStructure):
      (JSC::JSFinalObject::finishCreation):
      (JSC::JSFinalObject::JSFinalObject):
      (JSC::JSFinalObject::create):
      (JSC::JSObject::setButterfly):
      (JSC::JSObject::JSObject):
      (JSC::JSObject::inlineGetOwnPropertySlot):
      (JSC::JSObject::putDirectInternal):
      (JSC::JSObject::setStructureAndReallocateStorageIfNecessary):
      (JSC::JSObject::putOwnDataProperty):
      (JSC::JSObject::putDirectWithoutTransition):
      (JSC):
      * runtime/JSPropertyNameIterator.cpp:
      (JSC::JSPropertyNameIterator::JSPropertyNameIterator):
      (JSC::JSPropertyNameIterator::create):
      * runtime/JSPropertyNameIterator.h:
      (JSC::JSPropertyNameIterator::createStructure):
      (JSC::JSPropertyNameIterator::setCachedStructure):
      (JSC::JSPropertyNameIterator::setCachedPrototypeChain):
      (JSC::JSPropertyNameIterator::finishCreation):
      (JSC::StructureRareData::setEnumerationCache):
      * runtime/JSProxy.cpp:
      (JSC::JSProxy::setTarget):
      * runtime/JSProxy.h:
      (JSC::JSProxy::create):
      (JSC::JSProxy::createStructure):
      (JSC::JSProxy::JSProxy):
      (JSC::JSProxy::finishCreation):
      (JSProxy):
      * runtime/JSScope.cpp:
      (JSC::executeResolveOperations):
      (JSC::JSScope::resolveContainingScopeInternal):
      (JSC::JSScope::resolveWithBase):
      (JSC::JSScope::resolveWithThis):
      (JSC::JSScope::resolvePut):
      * runtime/JSScope.h:
      (JSScope):
      (JSC::JSScope::JSScope):
      (JSC::JSScope::vm):
      (JSC::ExecState::vm):
      * runtime/JSSegmentedVariableObject.h:
      (JSC::JSSegmentedVariableObject::JSSegmentedVariableObject):
      (JSC::JSSegmentedVariableObject::finishCreation):
      * runtime/JSString.cpp:
      (JSC::JSRopeString::RopeBuilder::expand):
      (JSC::StringObject::create):
      * runtime/JSString.h:
      (JSC):
      (JSString):
      (JSC::JSString::JSString):
      (JSC::JSString::finishCreation):
      (JSC::JSString::create):
      (JSC::JSString::createHasOtherOwner):
      (JSC::JSString::createStructure):
      (JSRopeString):
      (JSC::JSRopeString::RopeBuilder::RopeBuilder):
      (JSC::JSRopeString::RopeBuilder::append):
      (RopeBuilder):
      (JSC::JSRopeString::JSRopeString):
      (JSC::JSRopeString::finishCreation):
      (JSC::JSRopeString::append):
      (JSC::JSRopeString::createNull):
      (JSC::JSRopeString::create):
      (JSC::jsEmptyString):
      (JSC::jsSingleCharacterString):
      (JSC::jsSingleCharacterSubstring):
      (JSC::jsNontrivialString):
      (JSC::jsString):
      (JSC::jsSubstring):
      (JSC::jsSubstring8):
      (JSC::jsOwnedString):
      (JSC::jsStringBuilder):
      (JSC::inlineJSValueNotStringtoString):
      * runtime/JSStringJoiner.cpp:
      (JSC::JSStringJoiner::build):
      * runtime/JSSymbolTableObject.h:
      (JSC::JSSymbolTableObject::JSSymbolTableObject):
      (JSC::JSSymbolTableObject::finishCreation):
      (JSC::symbolTablePut):
      (JSC::symbolTablePutWithAttributes):
      * runtime/JSVariableObject.h:
      (JSC::JSVariableObject::JSVariableObject):
      * runtime/JSWithScope.h:
      (JSC::JSWithScope::create):
      (JSC::JSWithScope::createStructure):
      (JSC::JSWithScope::JSWithScope):
      * runtime/JSWrapperObject.h:
      (JSWrapperObject):
      (JSC::JSWrapperObject::createStructure):
      (JSC::JSWrapperObject::JSWrapperObject):
      (JSC::JSWrapperObject::setInternalValue):
      * runtime/LiteralParser.cpp:
      (JSC::::tryJSONPParse):
      (JSC::::makeIdentifier):
      (JSC::::parse):
      * runtime/Lookup.cpp:
      (JSC::HashTable::createTable):
      (JSC::setUpStaticFunctionSlot):
      * runtime/Lookup.h:
      (JSC::HashTable::initializeIfNeeded):
      (JSC::HashTable::entry):
      (JSC::HashTable::begin):
      (JSC::HashTable::end):
      (HashTable):
      (JSC::lookupPut):
      * runtime/MathObject.cpp:
      (JSC::MathObject::MathObject):
      (JSC::MathObject::finishCreation):
      (JSC::mathProtoFuncSin):
      * runtime/MathObject.h:
      (JSC::MathObject::createStructure):
      * runtime/MemoryStatistics.cpp:
      * runtime/MemoryStatistics.h:
      * runtime/NameConstructor.cpp:
      (JSC::NameConstructor::finishCreation):
      (JSC::constructPrivateName):
      * runtime/NameConstructor.h:
      (JSC::NameConstructor::createStructure):
      * runtime/NameInstance.cpp:
      (JSC::NameInstance::NameInstance):
      * runtime/NameInstance.h:
      (JSC::NameInstance::createStructure):
      (JSC::NameInstance::create):
      (NameInstance):
      (JSC::NameInstance::finishCreation):
      * runtime/NamePrototype.cpp:
      (JSC::NamePrototype::NamePrototype):
      (JSC::NamePrototype::finishCreation):
      * runtime/NamePrototype.h:
      (JSC::NamePrototype::createStructure):
      * runtime/NativeErrorConstructor.h:
      (JSC::NativeErrorConstructor::createStructure):
      (JSC::NativeErrorConstructor::finishCreation):
      * runtime/NativeErrorPrototype.cpp:
      (JSC::NativeErrorPrototype::finishCreation):
      * runtime/NumberConstructor.cpp:
      (JSC::NumberConstructor::finishCreation):
      (JSC::constructWithNumberConstructor):
      * runtime/NumberConstructor.h:
      (JSC::NumberConstructor::createStructure):
      * runtime/NumberObject.cpp:
      (JSC::NumberObject::NumberObject):
      (JSC::NumberObject::finishCreation):
      (JSC::constructNumber):
      * runtime/NumberObject.h:
      (NumberObject):
      (JSC::NumberObject::create):
      (JSC::NumberObject::createStructure):
      * runtime/NumberPrototype.cpp:
      (JSC::NumberPrototype::NumberPrototype):
      (JSC::NumberPrototype::finishCreation):
      (JSC::integerValueToString):
      (JSC::numberProtoFuncToString):
      * runtime/NumberPrototype.h:
      (JSC::NumberPrototype::createStructure):
      * runtime/ObjectConstructor.cpp:
      (JSC::ObjectConstructor::finishCreation):
      (JSC::objectConstructorGetOwnPropertyDescriptor):
      (JSC::objectConstructorSeal):
      (JSC::objectConstructorFreeze):
      (JSC::objectConstructorPreventExtensions):
      (JSC::objectConstructorIsSealed):
      (JSC::objectConstructorIsFrozen):
      * runtime/ObjectConstructor.h:
      (JSC::ObjectConstructor::createStructure):
      (JSC::constructEmptyObject):
      * runtime/ObjectPrototype.cpp:
      (JSC::ObjectPrototype::ObjectPrototype):
      (JSC::ObjectPrototype::finishCreation):
      (JSC::objectProtoFuncToString):
      * runtime/ObjectPrototype.h:
      (JSC::ObjectPrototype::createStructure):
      * runtime/Operations.cpp:
      (JSC::jsTypeStringForValue):
      * runtime/Operations.h:
      (JSC):
      (JSC::jsString):
      (JSC::jsStringFromArguments):
      (JSC::normalizePrototypeChainForChainAccess):
      (JSC::normalizePrototypeChain):
      * runtime/PropertyMapHashTable.h:
      (JSC::PropertyMapEntry::PropertyMapEntry):
      (JSC::PropertyTable::createStructure):
      (PropertyTable):
      (JSC::PropertyTable::copy):
      * runtime/PropertyNameArray.h:
      (JSC::PropertyNameArray::PropertyNameArray):
      (JSC::PropertyNameArray::vm):
      (JSC::PropertyNameArray::addKnownUnique):
      (PropertyNameArray):
      * runtime/PropertyTable.cpp:
      (JSC::PropertyTable::create):
      (JSC::PropertyTable::clone):
      (JSC::PropertyTable::PropertyTable):
      * runtime/PrototypeMap.cpp:
      (JSC::PrototypeMap::emptyObjectStructureForPrototype):
      * runtime/RegExp.cpp:
      (JSC::RegExp::RegExp):
      (JSC::RegExp::finishCreation):
      (JSC::RegExp::createWithoutCaching):
      (JSC::RegExp::create):
      (JSC::RegExp::compile):
      (JSC::RegExp::compileIfNecessary):
      (JSC::RegExp::match):
      (JSC::RegExp::compileMatchOnly):
      (JSC::RegExp::compileIfNecessaryMatchOnly):
      * runtime/RegExp.h:
      (JSC):
      (RegExp):
      (JSC::RegExp::createStructure):
      * runtime/RegExpCache.cpp:
      (JSC::RegExpCache::lookupOrCreate):
      (JSC::RegExpCache::RegExpCache):
      (JSC::RegExpCache::addToStrongCache):
      * runtime/RegExpCache.h:
      (RegExpCache):
      * runtime/RegExpCachedResult.cpp:
      (JSC::RegExpCachedResult::lastResult):
      (JSC::RegExpCachedResult::setInput):
      * runtime/RegExpCachedResult.h:
      (JSC::RegExpCachedResult::RegExpCachedResult):
      (JSC::RegExpCachedResult::record):
      * runtime/RegExpConstructor.cpp:
      (JSC::RegExpConstructor::RegExpConstructor):
      (JSC::RegExpConstructor::finishCreation):
      (JSC::constructRegExp):
      * runtime/RegExpConstructor.h:
      (JSC::RegExpConstructor::createStructure):
      (RegExpConstructor):
      (JSC::RegExpConstructor::performMatch):
      * runtime/RegExpMatchesArray.cpp:
      (JSC::RegExpMatchesArray::RegExpMatchesArray):
      (JSC::RegExpMatchesArray::create):
      (JSC::RegExpMatchesArray::finishCreation):
      (JSC::RegExpMatchesArray::reifyAllProperties):
      * runtime/RegExpMatchesArray.h:
      (RegExpMatchesArray):
      (JSC::RegExpMatchesArray::createStructure):
      * runtime/RegExpObject.cpp:
      (JSC::RegExpObject::RegExpObject):
      (JSC::RegExpObject::finishCreation):
      (JSC::RegExpObject::match):
      * runtime/RegExpObject.h:
      (JSC::RegExpObject::create):
      (JSC::RegExpObject::setRegExp):
      (JSC::RegExpObject::setLastIndex):
      (JSC::RegExpObject::createStructure):
      * runtime/RegExpPrototype.cpp:
      (JSC::regExpProtoFuncCompile):
      * runtime/RegExpPrototype.h:
      (JSC::RegExpPrototype::createStructure):
      * runtime/SmallStrings.cpp:
      (JSC::SmallStrings::initializeCommonStrings):
      (JSC::SmallStrings::createEmptyString):
      (JSC::SmallStrings::createSingleCharacterString):
      (JSC::SmallStrings::initialize):
      * runtime/SmallStrings.h:
      (JSC):
      (JSC::SmallStrings::singleCharacterString):
      (SmallStrings):
      * runtime/SparseArrayValueMap.cpp:
      (JSC::SparseArrayValueMap::SparseArrayValueMap):
      (JSC::SparseArrayValueMap::finishCreation):
      (JSC::SparseArrayValueMap::create):
      (JSC::SparseArrayValueMap::createStructure):
      (JSC::SparseArrayValueMap::putDirect):
      (JSC::SparseArrayEntry::put):
      * runtime/SparseArrayValueMap.h:
      * runtime/StrictEvalActivation.cpp:
      (JSC::StrictEvalActivation::StrictEvalActivation):
      * runtime/StrictEvalActivation.h:
      (JSC::StrictEvalActivation::create):
      (JSC::StrictEvalActivation::createStructure):
      * runtime/StringConstructor.cpp:
      (JSC::StringConstructor::finishCreation):
      * runtime/StringConstructor.h:
      (JSC::StringConstructor::createStructure):
      * runtime/StringObject.cpp:
      (JSC::StringObject::StringObject):
      (JSC::StringObject::finishCreation):
      (JSC::constructString):
      * runtime/StringObject.h:
      (JSC::StringObject::create):
      (JSC::StringObject::createStructure):
      (StringObject):
      * runtime/StringPrototype.cpp:
      (JSC::StringPrototype::StringPrototype):
      (JSC::StringPrototype::finishCreation):
      (JSC::removeUsingRegExpSearch):
      (JSC::replaceUsingRegExpSearch):
      (JSC::stringProtoFuncMatch):
      (JSC::stringProtoFuncSearch):
      (JSC::stringProtoFuncSplit):
      * runtime/StringPrototype.h:
      (JSC::StringPrototype::createStructure):
      * runtime/StringRecursionChecker.h:
      (JSC::StringRecursionChecker::performCheck):
      (JSC::StringRecursionChecker::~StringRecursionChecker):
      * runtime/Structure.cpp:
      (JSC::StructureTransitionTable::add):
      (JSC::Structure::Structure):
      (JSC::Structure::materializePropertyMap):
      (JSC::Structure::despecifyDictionaryFunction):
      (JSC::Structure::addPropertyTransition):
      (JSC::Structure::removePropertyTransition):
      (JSC::Structure::changePrototypeTransition):
      (JSC::Structure::despecifyFunctionTransition):
      (JSC::Structure::attributeChangeTransition):
      (JSC::Structure::toDictionaryTransition):
      (JSC::Structure::toCacheableDictionaryTransition):
      (JSC::Structure::toUncacheableDictionaryTransition):
      (JSC::Structure::sealTransition):
      (JSC::Structure::freezeTransition):
      (JSC::Structure::preventExtensionsTransition):
      (JSC::Structure::takePropertyTableOrCloneIfPinned):
      (JSC::Structure::nonPropertyTransition):
      (JSC::Structure::isSealed):
      (JSC::Structure::isFrozen):
      (JSC::Structure::flattenDictionaryStructure):
      (JSC::Structure::addPropertyWithoutTransition):
      (JSC::Structure::removePropertyWithoutTransition):
      (JSC::Structure::allocateRareData):
      (JSC::Structure::cloneRareDataFrom):
      (JSC::Structure::copyPropertyTable):
      (JSC::Structure::copyPropertyTableForPinning):
      (JSC::Structure::get):
      (JSC::Structure::despecifyFunction):
      (JSC::Structure::despecifyAllFunctions):
      (JSC::Structure::putSpecificValue):
      (JSC::Structure::createPropertyMap):
      (JSC::Structure::getPropertyNamesFromStructure):
      (JSC::Structure::prototypeChainMayInterceptStoreTo):
      * runtime/Structure.h:
      (Structure):
      (JSC::Structure::finishCreation):
      (JSC::Structure::setPrototypeWithoutTransition):
      (JSC::Structure::setGlobalObject):
      (JSC::Structure::setObjectToStringValue):
      (JSC::Structure::materializePropertyMapIfNecessary):
      (JSC::Structure::materializePropertyMapIfNecessaryForPinning):
      (JSC::Structure::setPreviousID):
      * runtime/StructureChain.cpp:
      (JSC::StructureChain::StructureChain):
      * runtime/StructureChain.h:
      (JSC::StructureChain::create):
      (JSC::StructureChain::createStructure):
      (JSC::StructureChain::finishCreation):
      (StructureChain):
      * runtime/StructureInlines.h:
      (JSC::Structure::create):
      (JSC::Structure::createStructure):
      (JSC::Structure::get):
      (JSC::Structure::setEnumerationCache):
      (JSC::Structure::prototypeChain):
      (JSC::Structure::propertyTable):
      * runtime/StructureRareData.cpp:
      (JSC::StructureRareData::createStructure):
      (JSC::StructureRareData::create):
      (JSC::StructureRareData::clone):
      (JSC::StructureRareData::StructureRareData):
      * runtime/StructureRareData.h:
      (StructureRareData):
      * runtime/StructureRareDataInlines.h:
      (JSC::StructureRareData::setPreviousID):
      (JSC::StructureRareData::setObjectToStringValue):
      * runtime/StructureTransitionTable.h:
      (StructureTransitionTable):
      (JSC::StructureTransitionTable::setSingleTransition):
      * runtime/SymbolTable.h:
      (JSC::SharedSymbolTable::create):
      (JSC::SharedSymbolTable::createStructure):
      (JSC::SharedSymbolTable::SharedSymbolTable):
      * runtime/VM.cpp: Copied from Source/JavaScriptCore/runtime/JSGlobalData.cpp.
      (JSC::VM::VM):
      (JSC::VM::~VM):
      (JSC::VM::createContextGroup):
      (JSC::VM::create):
      (JSC::VM::createLeaked):
      (JSC::VM::sharedInstanceExists):
      (JSC::VM::sharedInstance):
      (JSC::VM::sharedInstanceInternal):
      (JSC::VM::getHostFunction):
      (JSC::VM::ClientData::~ClientData):
      (JSC::VM::resetDateCache):
      (JSC::VM::startSampling):
      (JSC::VM::stopSampling):
      (JSC::VM::discardAllCode):
      (JSC::VM::dumpSampleData):
      (JSC::VM::addSourceProviderCache):
      (JSC::VM::clearSourceProviderCaches):
      (JSC::VM::releaseExecutableMemory):
      (JSC::releaseExecutableMemory):
      (JSC::VM::gatherConservativeRoots):
      (JSC::VM::addRegExpToTrace):
      (JSC::VM::dumpRegExpTrace):
      * runtime/VM.h: Copied from Source/JavaScriptCore/runtime/JSGlobalData.h.
      (VM):
      (JSC::VM::isSharedInstance):
      (JSC::VM::usingAPI):
      (JSC::VM::isInitializingObject):
      (JSC::VM::setInitializingObjectClass):
      (JSC::WeakSet::heap):
      * runtime/WriteBarrier.h:
      (JSC):
      (JSC::WriteBarrierBase::set):
      (JSC::WriteBarrierBase::setMayBeNull):
      (JSC::WriteBarrierBase::setEarlyValue):
      (JSC::WriteBarrier::WriteBarrier):
      * testRegExp.cpp:
      (GlobalObject):
      (GlobalObject::create):
      (GlobalObject::createStructure):
      (GlobalObject::finishCreation):
      (main):
      (testOneRegExp):
      (parseRegExpLine):
      (runFromFiles):
      (realMain):
      * yarr/YarrInterpreter.h:
      (BytecodePattern):
      * yarr/YarrJIT.cpp:
      (YarrGenerator):
      (JSC::Yarr::YarrGenerator::compile):
      (JSC::Yarr::jitCompile):
      * yarr/YarrJIT.h:
      (JSC):
      
      ../WebCore: 
      
      * ForwardingHeaders/runtime/JSGlobalData.h: Removed.
      * ForwardingHeaders/runtime/VM.h: Copied from Source/WebCore/ForwardingHeaders/runtime/JSGlobalData.h.
      * WebCore.exp.in:
      * WebCore.order:
      * WebCore.vcxproj/WebCore.vcxproj:
      * WebCore.vcxproj/WebCore.vcxproj.filters:
      * bindings/js/DOMObjectHashTableMap.cpp:
      (WebCore::DOMObjectHashTableMap::mapFor):
      * bindings/js/DOMObjectHashTableMap.h:
      (JSC):
      (DOMObjectHashTableMap):
      * bindings/js/DOMWrapperWorld.cpp:
      (WebCore::DOMWrapperWorld::DOMWrapperWorld):
      (WebCore::DOMWrapperWorld::~DOMWrapperWorld):
      (WebCore::normalWorld):
      (WebCore::mainThreadNormalWorld):
      * bindings/js/DOMWrapperWorld.h:
      (WebCore::DOMWrapperWorld::create):
      (WebCore::DOMWrapperWorld::vm):
      (DOMWrapperWorld):
      (WebCore):
      * bindings/js/GCController.cpp:
      (WebCore::collect):
      (WebCore::GCController::garbageCollectSoon):
      (WebCore::GCController::garbageCollectNow):
      (WebCore::GCController::setJavaScriptGarbageCollectorTimerEnabled):
      (WebCore::GCController::discardAllCompiledCode):
      * bindings/js/IDBBindingUtilities.cpp:
      (WebCore::get):
      (WebCore::set):
      (WebCore::deserializeIDBValue):
      (WebCore::deserializeIDBValueBuffer):
      (WebCore::idbKeyToScriptValue):
      * bindings/js/JSCallbackData.h:
      (WebCore::JSCallbackData::JSCallbackData):
      * bindings/js/JSCustomSQLStatementErrorCallback.cpp:
      (WebCore::JSSQLStatementErrorCallback::handleEvent):
      * bindings/js/JSCustomXPathNSResolver.cpp:
      (WebCore::JSCustomXPathNSResolver::JSCustomXPathNSResolver):
      (WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):
      * bindings/js/JSDOMBinding.cpp:
      (WebCore::getHashTableForGlobalData):
      (WebCore::reportException):
      (WebCore::cacheDOMStructure):
      * bindings/js/JSDOMBinding.h:
      (WebCore::DOMConstructorObject::createStructure):
      (WebCore::DOMConstructorWithDocument::finishCreation):
      (WebCore::getDOMStructure):
      (WebCore::setInlineCachedWrapper):
      (WebCore):
      (WebCore::jsStringWithCache):
      * bindings/js/JSDOMGlobalObject.cpp:
      (WebCore::JSDOMGlobalObject::JSDOMGlobalObject):
      (WebCore::JSDOMGlobalObject::finishCreation):
      * bindings/js/JSDOMGlobalObject.h:
      (JSDOMGlobalObject):
      (WebCore::JSDOMGlobalObject::createStructure):
      (WebCore::getDOMConstructor):
      * bindings/js/JSDOMWindowBase.cpp:
      (WebCore::JSDOMWindowBase::JSDOMWindowBase):
      (WebCore::JSDOMWindowBase::finishCreation):
      (WebCore::JSDOMWindowBase::updateDocument):
      (WebCore::JSDOMWindowBase::commonVM):
      * bindings/js/JSDOMWindowBase.h:
      (JSDOMWindowBase):
      (WebCore::JSDOMWindowBase::createStructure):
      * bindings/js/JSDOMWindowCustom.cpp:
      (WebCore::JSDOMWindow::setLocation):
      (WebCore::DialogHandler::dialogCreated):
      (WebCore::DialogHandler::returnValue):
      * bindings/js/JSDOMWindowShell.cpp:
      (WebCore::JSDOMWindowShell::JSDOMWindowShell):
      (WebCore::JSDOMWindowShell::finishCreation):
      (WebCore::JSDOMWindowShell::setWindow):
      * bindings/js/JSDOMWindowShell.h:
      (JSDOMWindowShell):
      (WebCore::JSDOMWindowShell::create):
      (WebCore::JSDOMWindowShell::createStructure):
      * bindings/js/JSDOMWrapper.h:
      (WebCore::JSDOMWrapper::JSDOMWrapper):
      * bindings/js/JSDeviceMotionEventCustom.cpp:
      (WebCore::createAccelerationObject):
      (WebCore::createRotationRateObject):
      * bindings/js/JSDictionary.cpp:
      (WebCore::JSDictionary::convertValue):
      * bindings/js/JSDictionary.h:
      (WebCore::JSDictionary::JSDictionary):
      * bindings/js/JSErrorHandler.cpp:
      (WebCore::JSErrorHandler::handleEvent):
      * bindings/js/JSEventListener.cpp:
      (WebCore::JSEventListener::handleEvent):
      * bindings/js/JSEventListener.h:
      (WebCore::JSEventListener::setWrapper):
      (WebCore::JSEventListener::jsFunction):
      * bindings/js/JSHTMLDocumentCustom.cpp:
      (WebCore::JSHTMLDocument::all):
      (WebCore::JSHTMLDocument::setAll):
      * bindings/js/JSHTMLTemplateElementCustom.cpp:
      (WebCore::JSHTMLTemplateElement::content):
      * bindings/js/JSHistoryCustom.cpp:
      (WebCore::JSHistory::state):
      * bindings/js/JSImageConstructor.cpp:
      (WebCore::JSImageConstructor::finishCreation):
      * bindings/js/JSImageConstructor.h:
      (WebCore::JSImageConstructor::createStructure):
      * bindings/js/JSImageDataCustom.cpp:
      (WebCore::toJS):
      * bindings/js/JSInjectedScriptHostCustom.cpp:
      (WebCore::InjectedScriptHost::nodeAsScriptValue):
      (WebCore::JSInjectedScriptHost::functionDetails):
      (WebCore::getJSListenerFunctions):
      (WebCore::JSInjectedScriptHost::getEventListeners):
      (WebCore::JSInjectedScriptHost::inspect):
      * bindings/js/JSLazyEventListener.cpp:
      (WebCore::JSLazyEventListener::initializeJSFunction):
      * bindings/js/JSMessageEventCustom.cpp:
      (WebCore::JSMessageEvent::data):
      (WebCore::handleInitMessageEvent):
      * bindings/js/JSMutationCallback.cpp:
      (WebCore::JSMutationCallback::call):
      * bindings/js/JSMutationObserverCustom.cpp:
      (WebCore::JSMutationObserverConstructor::constructJSMutationObserver):
      * bindings/js/JSNodeFilterCondition.cpp:
      (WebCore::JSNodeFilterCondition::JSNodeFilterCondition):
      * bindings/js/JSNodeFilterCondition.h:
      (WebCore::JSNodeFilterCondition::create):
      (JSNodeFilterCondition):
      * bindings/js/JSNodeFilterCustom.cpp:
      (WebCore::toNodeFilter):
      * bindings/js/JSPopStateEventCustom.cpp:
      (WebCore::cacheState):
      * bindings/js/JSRequestAnimationFrameCallbackCustom.cpp:
      (WebCore::JSRequestAnimationFrameCallback::handleEvent):
      * bindings/js/JSSQLResultSetRowListCustom.cpp:
      (WebCore::JSSQLResultSetRowList::item):
      * bindings/js/JSWorkerContextBase.cpp:
      (WebCore::JSWorkerContextBase::JSWorkerContextBase):
      (WebCore::JSWorkerContextBase::finishCreation):
      * bindings/js/JSWorkerContextBase.h:
      (WebCore::JSWorkerContextBase::createStructure):
      (JSWorkerContextBase):
      * bindings/js/PageScriptDebugServer.cpp:
      (WebCore::PageScriptDebugServer::recompileAllJSFunctions):
      * bindings/js/ScheduledAction.cpp:
      (WebCore::ScheduledAction::ScheduledAction):
      (WebCore::ScheduledAction::executeFunctionInContext):
      * bindings/js/ScheduledAction.h:
      (WebCore::ScheduledAction::ScheduledAction):
      * bindings/js/ScriptCachedFrameData.cpp:
      (WebCore::ScriptCachedFrameData::ScriptCachedFrameData):
      (WebCore::ScriptCachedFrameData::restore):
      (WebCore::ScriptCachedFrameData::clear):
      * bindings/js/ScriptCallStackFactory.cpp:
      (WebCore::createScriptCallStack):
      (WebCore::createScriptArguments):
      * bindings/js/ScriptController.cpp:
      (WebCore::ScriptController::createWindowShell):
      (WebCore::ScriptController::evaluateInWorld):
      (WebCore::ScriptController::createWorld):
      (WebCore::ScriptController::getAllWorlds):
      (WebCore::ScriptController::clearWindowShell):
      (WebCore::ScriptController::initScript):
      (WebCore::ScriptController::updateDocument):
      (WebCore::ScriptController::cacheableBindingRootObject):
      (WebCore::ScriptController::bindingRootObject):
      (WebCore::ScriptController::clearScriptObjects):
      (WebCore::ScriptController::shouldBypassMainWorldContentSecurityPolicy):
      * bindings/js/ScriptControllerMac.mm:
      (WebCore::ScriptController::windowScriptObject):
      * bindings/js/ScriptDebugServer.cpp:
      (WebCore::ScriptDebugServer::dispatchDidPause):
      * bindings/js/ScriptEventListener.cpp:
      (WebCore::eventListenerHandlerBody):
      (WebCore::eventListenerHandler):
      (WebCore::eventListenerHandlerLocation):
      * bindings/js/ScriptFunctionCall.cpp:
      (WebCore::ScriptFunctionCall::call):
      (WebCore::ScriptCallback::call):
      * bindings/js/ScriptGCEvent.cpp:
      (WebCore::ScriptGCEvent::getHeapSize):
      * bindings/js/ScriptObject.cpp:
      (WebCore::ScriptObject::ScriptObject):
      (WebCore::ScriptGlobalObject::set):
      * bindings/js/ScriptState.h:
      (WebCore):
      * bindings/js/ScriptValue.cpp:
      (WebCore::ScriptValue::deserialize):
      * bindings/js/ScriptValue.h:
      (WebCore::ScriptValue::ScriptValue):
      * bindings/js/ScriptWrappable.h:
      (JSC):
      (ScriptWrappable):
      * bindings/js/ScriptWrappableInlines.h:
      (WebCore::ScriptWrappable::setWrapper):
      * bindings/js/SerializedScriptValue.cpp:
      (WebCore::CloneDeserializer::readTerminal):
      (WebCore::SerializedScriptValue::deserializeForInspector):
      (WebCore::SerializedScriptValue::maybeThrowExceptionIfSerializationFailed):
      * bindings/js/WebCoreJSClientData.h:
      (WebCoreJSClientData):
      (WebCore::initNormalWorldClientData):
      * bindings/js/WorkerScriptController.cpp:
      (WebCore::WorkerScriptController::WorkerScriptController):
      (WebCore::WorkerScriptController::~WorkerScriptController):
      (WebCore::WorkerScriptController::initScript):
      (WebCore::WorkerScriptController::evaluate):
      (WebCore::WorkerScriptController::scheduleExecutionTermination):
      (WebCore::WorkerScriptController::isExecutionTerminating):
      (WebCore::WorkerScriptController::disableEval):
      * bindings/js/WorkerScriptController.h:
      (JSC):
      (WebCore::WorkerScriptController::vm):
      (WorkerScriptController):
      * bindings/js/WorkerScriptDebugServer.cpp:
      (WebCore::WorkerScriptDebugServer::recompileAllJSFunctions):
      * bindings/objc/WebScriptObject.mm:
      (+[WebScriptObject _convertValueToObjcValue:JSC::originRootObject:rootObject:]):
      * bindings/scripts/CodeGeneratorJS.pm:
      (GenerateHeader):
      (GenerateImplementation):
      (GenerateCallbackImplementation):
      (JSValueToNative):
      (GenerateConstructorDeclaration):
      (GenerateConstructorHelperMethods):
      * bindings/scripts/test/JS/JSFloat64Array.cpp:
      (WebCore::getJSFloat64ArrayConstructorTable):
      (WebCore::JSFloat64ArrayConstructor::finishCreation):
      (WebCore::getJSFloat64ArrayPrototypeTable):
      (WebCore::getJSFloat64ArrayTable):
      (WebCore::JSFloat64Array::finishCreation):
      (WebCore::JSFloat64Array::createPrototype):
      * bindings/scripts/test/JS/JSFloat64Array.h:
      (WebCore::JSFloat64Array::create):
      (WebCore::JSFloat64Array::createStructure):
      (JSFloat64Array):
      (WebCore::JSFloat64ArrayPrototype::create):
      (WebCore::JSFloat64ArrayPrototype::createStructure):
      (WebCore::JSFloat64ArrayPrototype::JSFloat64ArrayPrototype):
      (WebCore::JSFloat64ArrayConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestActiveDOMObject.cpp:
      (WebCore::JSTestActiveDOMObjectConstructor::finishCreation):
      (WebCore::JSTestActiveDOMObject::finishCreation):
      (WebCore::JSTestActiveDOMObject::createPrototype):
      * bindings/scripts/test/JS/JSTestActiveDOMObject.h:
      (WebCore::JSTestActiveDOMObject::create):
      (WebCore::JSTestActiveDOMObject::createStructure):
      (JSTestActiveDOMObject):
      (WebCore::JSTestActiveDOMObjectPrototype::create):
      (WebCore::JSTestActiveDOMObjectPrototype::createStructure):
      (WebCore::JSTestActiveDOMObjectPrototype::JSTestActiveDOMObjectPrototype):
      (WebCore::JSTestActiveDOMObjectConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestCallback.cpp:
      (WebCore::JSTestCallback::callbackWithNoParam):
      (WebCore::JSTestCallback::callbackWithClass1Param):
      (WebCore::JSTestCallback::callbackWithClass2Param):
      (WebCore::JSTestCallback::callbackWithStringList):
      (WebCore::JSTestCallback::callbackWithBoolean):
      (WebCore::JSTestCallback::callbackRequiresThisToPass):
      * bindings/scripts/test/JS/JSTestCustomNamedGetter.cpp:
      (WebCore::JSTestCustomNamedGetterConstructor::finishCreation):
      (WebCore::JSTestCustomNamedGetter::finishCreation):
      (WebCore::JSTestCustomNamedGetter::createPrototype):
      * bindings/scripts/test/JS/JSTestCustomNamedGetter.h:
      (WebCore::JSTestCustomNamedGetter::create):
      (WebCore::JSTestCustomNamedGetter::createStructure):
      (JSTestCustomNamedGetter):
      (WebCore::JSTestCustomNamedGetterPrototype::create):
      (WebCore::JSTestCustomNamedGetterPrototype::createStructure):
      (WebCore::JSTestCustomNamedGetterPrototype::JSTestCustomNamedGetterPrototype):
      (WebCore::JSTestCustomNamedGetterConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestEventConstructor.cpp:
      (WebCore::JSTestEventConstructorConstructor::finishCreation):
      (WebCore::JSTestEventConstructor::finishCreation):
      (WebCore::JSTestEventConstructor::createPrototype):
      * bindings/scripts/test/JS/JSTestEventConstructor.h:
      (WebCore::JSTestEventConstructor::create):
      (WebCore::JSTestEventConstructor::createStructure):
      (JSTestEventConstructor):
      (WebCore::JSTestEventConstructorPrototype::create):
      (WebCore::JSTestEventConstructorPrototype::createStructure):
      (WebCore::JSTestEventConstructorPrototype::JSTestEventConstructorPrototype):
      (WebCore::JSTestEventConstructorConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestEventTarget.cpp:
      (WebCore::JSTestEventTargetConstructor::finishCreation):
      (WebCore::JSTestEventTarget::finishCreation):
      (WebCore::JSTestEventTarget::createPrototype):
      * bindings/scripts/test/JS/JSTestEventTarget.h:
      (WebCore::JSTestEventTarget::create):
      (WebCore::JSTestEventTarget::createStructure):
      (JSTestEventTarget):
      (WebCore::JSTestEventTargetPrototype::create):
      (WebCore::JSTestEventTargetPrototype::createStructure):
      (WebCore::JSTestEventTargetPrototype::JSTestEventTargetPrototype):
      (WebCore::JSTestEventTargetConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestException.cpp:
      (WebCore::JSTestExceptionConstructor::finishCreation):
      (WebCore::JSTestException::finishCreation):
      (WebCore::JSTestException::createPrototype):
      * bindings/scripts/test/JS/JSTestException.h:
      (WebCore::JSTestException::create):
      (WebCore::JSTestException::createStructure):
      (JSTestException):
      (WebCore::JSTestExceptionPrototype::create):
      (WebCore::JSTestExceptionPrototype::createStructure):
      (WebCore::JSTestExceptionPrototype::JSTestExceptionPrototype):
      (WebCore::JSTestExceptionConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestInterface.cpp:
      (WebCore::JSTestInterfaceConstructor::finishCreation):
      (WebCore::JSTestInterface::finishCreation):
      (WebCore::JSTestInterface::createPrototype):
      * bindings/scripts/test/JS/JSTestInterface.h:
      (WebCore::JSTestInterface::create):
      (WebCore::JSTestInterface::createStructure):
      (JSTestInterface):
      (WebCore::JSTestInterfacePrototype::create):
      (WebCore::JSTestInterfacePrototype::createStructure):
      (WebCore::JSTestInterfacePrototype::JSTestInterfacePrototype):
      (WebCore::JSTestInterfaceConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp:
      (WebCore::JSTestMediaQueryListListenerConstructor::finishCreation):
      (WebCore::JSTestMediaQueryListListener::finishCreation):
      (WebCore::JSTestMediaQueryListListener::createPrototype):
      (WebCore::jsTestMediaQueryListListenerPrototypeFunctionMethod):
      * bindings/scripts/test/JS/JSTestMediaQueryListListener.h:
      (WebCore::JSTestMediaQueryListListener::create):
      (WebCore::JSTestMediaQueryListListener::createStructure):
      (JSTestMediaQueryListListener):
      (WebCore::JSTestMediaQueryListListenerPrototype::create):
      (WebCore::JSTestMediaQueryListListenerPrototype::createStructure):
      (WebCore::JSTestMediaQueryListListenerPrototype::JSTestMediaQueryListListenerPrototype):
      (WebCore::JSTestMediaQueryListListenerConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestNamedConstructor.cpp:
      (WebCore::JSTestNamedConstructorConstructor::finishCreation):
      (WebCore::JSTestNamedConstructorNamedConstructor::finishCreation):
      (WebCore::JSTestNamedConstructor::finishCreation):
      (WebCore::JSTestNamedConstructor::createPrototype):
      * bindings/scripts/test/JS/JSTestNamedConstructor.h:
      (WebCore::JSTestNamedConstructor::create):
      (WebCore::JSTestNamedConstructor::createStructure):
      (JSTestNamedConstructor):
      (WebCore::JSTestNamedConstructorPrototype::create):
      (WebCore::JSTestNamedConstructorPrototype::createStructure):
      (WebCore::JSTestNamedConstructorPrototype::JSTestNamedConstructorPrototype):
      (WebCore::JSTestNamedConstructorConstructor::createStructure):
      (WebCore::JSTestNamedConstructorNamedConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestNode.cpp:
      (WebCore::JSTestNodeConstructor::finishCreation):
      (WebCore::JSTestNode::finishCreation):
      (WebCore::JSTestNode::createPrototype):
      * bindings/scripts/test/JS/JSTestNode.h:
      (WebCore::JSTestNode::create):
      (WebCore::JSTestNode::createStructure):
      (JSTestNode):
      (WebCore::JSTestNodePrototype::create):
      (WebCore::JSTestNodePrototype::createStructure):
      (WebCore::JSTestNodePrototype::JSTestNodePrototype):
      (WebCore::JSTestNodeConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestObj.cpp:
      (WebCore::JSTestObjConstructor::finishCreation):
      (WebCore::JSTestObj::finishCreation):
      (WebCore::JSTestObj::createPrototype):
      (WebCore::jsTestObjCachedAttribute1):
      (WebCore::jsTestObjCachedAttribute2):
      (WebCore::setJSTestObjConditionalAttr4Constructor):
      (WebCore::setJSTestObjConditionalAttr5Constructor):
      (WebCore::setJSTestObjConditionalAttr6Constructor):
      (WebCore::setJSTestObjAnyAttribute):
      (WebCore::setJSTestObjReplaceableAttribute):
      * bindings/scripts/test/JS/JSTestObj.h:
      (WebCore::JSTestObj::create):
      (WebCore::JSTestObj::createStructure):
      (JSTestObj):
      (WebCore::JSTestObjPrototype::create):
      (WebCore::JSTestObjPrototype::createStructure):
      (WebCore::JSTestObjPrototype::JSTestObjPrototype):
      (WebCore::JSTestObjConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp:
      (WebCore::JSTestOverloadedConstructorsConstructor::finishCreation):
      (WebCore::JSTestOverloadedConstructors::finishCreation):
      (WebCore::JSTestOverloadedConstructors::createPrototype):
      * bindings/scripts/test/JS/JSTestOverloadedConstructors.h:
      (WebCore::JSTestOverloadedConstructors::create):
      (WebCore::JSTestOverloadedConstructors::createStructure):
      (JSTestOverloadedConstructors):
      (WebCore::JSTestOverloadedConstructorsPrototype::create):
      (WebCore::JSTestOverloadedConstructorsPrototype::createStructure):
      (WebCore::JSTestOverloadedConstructorsPrototype::JSTestOverloadedConstructorsPrototype):
      (WebCore::JSTestOverloadedConstructorsConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp:
      (WebCore::JSTestSerializedScriptValueInterfaceConstructor::finishCreation):
      (WebCore::JSTestSerializedScriptValueInterface::finishCreation):
      (WebCore::JSTestSerializedScriptValueInterface::createPrototype):
      (WebCore::jsTestSerializedScriptValueInterfaceCachedValue):
      (WebCore::jsTestSerializedScriptValueInterfaceCachedReadonlyValue):
      * bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.h:
      (WebCore::JSTestSerializedScriptValueInterface::create):
      (WebCore::JSTestSerializedScriptValueInterface::createStructure):
      (JSTestSerializedScriptValueInterface):
      (WebCore::JSTestSerializedScriptValueInterfacePrototype::create):
      (WebCore::JSTestSerializedScriptValueInterfacePrototype::createStructure):
      (WebCore::JSTestSerializedScriptValueInterfacePrototype::JSTestSerializedScriptValueInterfacePrototype):
      (WebCore::JSTestSerializedScriptValueInterfaceConstructor::createStructure):
      * bindings/scripts/test/JS/JSTestTypedefs.cpp:
      (WebCore::JSTestTypedefsConstructor::finishCreation):
      (WebCore::JSTestTypedefs::finishCreation):
      (WebCore::JSTestTypedefs::createPrototype):
      * bindings/scripts/test/JS/JSTestTypedefs.h:
      (WebCore::JSTestTypedefs::create):
      (WebCore::JSTestTypedefs::createStructure):
      (JSTestTypedefs):
      (WebCore::JSTestTypedefsPrototype::create):
      (WebCore::JSTestTypedefsPrototype::createStructure):
      (WebCore::JSTestTypedefsPrototype::JSTestTypedefsPrototype):
      (WebCore::JSTestTypedefsConstructor::createStructure):
      * bridge/c/CRuntimeObject.h:
      (JSC::Bindings::CRuntimeObject::createStructure):
      * bridge/c/c_instance.cpp:
      (JSC::Bindings::CRuntimeMethod::create):
      (JSC::Bindings::CRuntimeMethod::createStructure):
      (JSC::Bindings::CRuntimeMethod::finishCreation):
      * bridge/jsc/BridgeJSC.cpp:
      (JSC::Bindings::Instance::createRuntimeObject):
      * bridge/objc/ObjCRuntimeObject.h:
      (JSC::Bindings::ObjCRuntimeObject::createStructure):
      * bridge/objc/objc_instance.mm:
      (ObjCRuntimeMethod::create):
      (ObjCRuntimeMethod::createStructure):
      (ObjCRuntimeMethod::finishCreation):
      * bridge/objc/objc_runtime.h:
      (JSC::Bindings::ObjcFallbackObjectImp::createStructure):
      * bridge/objc/objc_runtime.mm:
      (JSC::Bindings::ObjcFallbackObjectImp::ObjcFallbackObjectImp):
      (JSC::Bindings::ObjcFallbackObjectImp::finishCreation):
      * bridge/qt/qt_instance.cpp:
      (JSC::Bindings::QtRuntimeObject::createStructure):
      (JSC::Bindings::QtInstance::~QtInstance):
      (JSC::Bindings::QtInstance::getQtInstance):
      * bridge/runtime_array.cpp:
      (JSC::RuntimeArray::RuntimeArray):
      (JSC::RuntimeArray::finishCreation):
      * bridge/runtime_array.h:
      (JSC::RuntimeArray::create):
      (JSC::RuntimeArray::createStructure):
      (RuntimeArray):
      * bridge/runtime_method.cpp:
      (JSC::RuntimeMethod::finishCreation):
      * bridge/runtime_method.h:
      (JSC::RuntimeMethod::create):
      (JSC::RuntimeMethod::createStructure):
      (RuntimeMethod):
      * bridge/runtime_object.cpp:
      (JSC::Bindings::RuntimeObject::RuntimeObject):
      (JSC::Bindings::RuntimeObject::finishCreation):
      * bridge/runtime_object.h:
      (JSC::Bindings::RuntimeObject::createStructure):
      * bridge/runtime_root.cpp:
      (JSC::Bindings::RootObject::RootObject):
      (JSC::Bindings::RootObject::gcProtect):
      (JSC::Bindings::RootObject::gcUnprotect):
      (JSC::Bindings::RootObject::updateGlobalObject):
      (JSC::Bindings::RootObject::addRuntimeObject):
      * bridge/runtime_root.h:
      (RootObject):
      * dom/Node.cpp:
      * dom/Node.h:
      (JSC):
      * dom/ScriptExecutionContext.cpp:
      (WebCore::ScriptExecutionContext::vm):
      * dom/ScriptExecutionContext.h:
      (JSC):
      (ScriptExecutionContext):
      * html/HTMLCanvasElement.cpp:
      (WebCore::HTMLCanvasElement::createImageBuffer):
      * html/HTMLImageLoader.cpp:
      (WebCore::HTMLImageLoader::notifyFinished):
      * inspector/ScriptArguments.cpp:
      (WebCore::ScriptArguments::ScriptArguments):
      * loader/icon/IconDatabaseBase.cpp:
      (WebCore):
      (WebCore::iconDatabase):
      (WebCore::setGlobalIconDatabase):
      * platform/qt/MemoryUsageSupportQt.cpp:
      (WebCore::memoryUsageKB):
      (WebCore::actualMemoryUsageKB):
      * platform/win/ClipboardUtilitiesWin.cpp:
      (WebCore::createGlobalData):
      * plugins/PluginView.cpp:
      (WebCore::PluginView::start):
      (WebCore::PluginView::stop):
      (WebCore::PluginView::performRequest):
      (WebCore::PluginView::npObject):
      (WebCore::PluginView::privateBrowsingStateChanged):
      * plugins/blackberry/PluginViewBlackBerry.cpp:
      (WebCore::PluginView::dispatchNPEvent):
      (WebCore::PluginView::setNPWindowIfNeeded):
      (WebCore::PluginView::platformStart):
      (WebCore::PluginView::getWindowInfo):
      * plugins/efl/PluginViewEfl.cpp:
      (WebCore::PluginView::dispatchNPEvent):
      * plugins/gtk/PluginViewGtk.cpp:
      (WebCore::PluginView::dispatchNPEvent):
      (WebCore::PluginView::handleKeyboardEvent):
      (WebCore::PluginView::handleMouseEvent):
      (WebCore::PluginView::setNPWindowIfNeeded):
      (WebCore::PluginView::platformStart):
      * plugins/mac/PluginViewMac.mm:
      (WebCore::PluginView::platformStart):
      * plugins/qt/PluginViewQt.cpp:
      (WebCore::PluginView::dispatchNPEvent):
      (WebCore::PluginView::setNPWindowIfNeeded):
      * plugins/win/PluginViewWin.cpp:
      (WebCore::PluginView::dispatchNPEvent):
      (WebCore::PluginView::handleKeyboardEvent):
      (WebCore::PluginView::handleMouseEvent):
      (WebCore::PluginView::setNPWindowRect):
      * testing/js/WebCoreTestSupport.cpp:
      (WebCoreTestSupport::injectInternalsObject):
      * xml/XMLHttpRequest.cpp:
      (WebCore::XMLHttpRequest::dropProtection):
      
      ../WebKit/blackberry: 
      
      * Api/BlackBerryGlobal.cpp:
      (BlackBerry::WebKit::clearMemoryCaches):
      * WebKitSupport/AboutData.cpp:
      * WebKitSupport/DumpRenderTreeSupport.cpp:
      (DumpRenderTreeSupport::javaScriptObjectsCount):
      
      ../WebKit/efl: 
      
      * WebCoreSupport/DumpRenderTreeSupportEfl.cpp:
      (DumpRenderTreeSupportEfl::javaScriptObjectsCount):
      
      ../WebKit/gtk: 
      
      * WebCoreSupport/DumpRenderTreeSupportGtk.cpp:
      (DumpRenderTreeSupportGtk::gcCountJavascriptObjects):
      
      ../WebKit/mac: 
      
      * Misc/WebCoreStatistics.mm:
      (+[WebCoreStatistics javaScriptObjectsCount]):
      (+[WebCoreStatistics javaScriptGlobalObjectsCount]):
      (+[WebCoreStatistics javaScriptProtectedObjectsCount]):
      (+[WebCoreStatistics javaScriptProtectedGlobalObjectsCount]):
      (+[WebCoreStatistics javaScriptProtectedObjectTypeCounts]):
      (+[WebCoreStatistics javaScriptObjectTypeCounts]):
      (+[WebCoreStatistics shouldPrintExceptions]):
      (+[WebCoreStatistics setShouldPrintExceptions:]):
      (+[WebCoreStatistics memoryStatistics]):
      (+[WebCoreStatistics javaScriptReferencedObjectsCount]):
      * Plugins/Hosted/NetscapePluginHostProxy.mm:
      (identifierFromIdentifierRep):
      * Plugins/Hosted/NetscapePluginInstanceProxy.h:
      (LocalObjectMap):
      * Plugins/Hosted/NetscapePluginInstanceProxy.mm:
      (WebKit::NetscapePluginInstanceProxy::LocalObjectMap::idForObject):
      (WebKit::NetscapePluginInstanceProxy::getWindowNPObject):
      (WebKit::NetscapePluginInstanceProxy::getPluginElementNPObject):
      (WebKit::NetscapePluginInstanceProxy::evaluate):
      (WebKit::NetscapePluginInstanceProxy::addValueToArray):
      * Plugins/Hosted/ProxyInstance.mm:
      (WebKit::ProxyRuntimeMethod::create):
      (WebKit::ProxyRuntimeMethod::createStructure):
      (WebKit::ProxyRuntimeMethod::finishCreation):
      (WebKit::ProxyInstance::getPropertyNames):
      * Plugins/Hosted/ProxyRuntimeObject.h:
      (WebKit::ProxyRuntimeObject::create):
      (WebKit::ProxyRuntimeObject::createStructure):
      * Plugins/WebNetscapePluginStream.mm:
      (WebNetscapePluginStream::wantsAllStreams):
      * Plugins/WebNetscapePluginView.mm:
      (-[WebNetscapePluginView sendEvent:isDrawRect:]):
      (-[WebNetscapePluginView privateBrowsingModeDidChange]):
      (-[WebNetscapePluginView setWindowIfNecessary]):
      (-[WebNetscapePluginView createPluginScriptableObject]):
      (-[WebNetscapePluginView getFormValue:]):
      (-[WebNetscapePluginView evaluateJavaScriptPluginRequest:]):
      (-[WebNetscapePluginView webFrame:didFinishLoadWithReason:]):
      (-[WebNetscapePluginView loadPluginRequest:]):
      (-[WebNetscapePluginView _printedPluginBitmap]):
      * Plugins/WebPluginController.mm:
      (+[WebPluginController plugInViewWithArguments:fromPluginPackage:]):
      (-[WebPluginController stopOnePlugin:]):
      (-[WebPluginController destroyOnePlugin:]):
      (-[WebPluginController startAllPlugins]):
      (-[WebPluginController addPlugin:]):
      * WebKit.order:
      * WebView/WebScriptDebugDelegate.mm:
      (-[WebScriptCallFrame scopeChain]):
      (-[WebScriptCallFrame evaluateWebScript:]):
      * WebView/WebScriptDebugger.mm:
      (WebScriptDebugger::WebScriptDebugger):
      
      ../WebKit/qt: 
      
      * WebCoreSupport/DumpRenderTreeSupportQt.cpp:
      (DumpRenderTreeSupportQt::javaScriptObjectsCount):
      * WebCoreSupport/QWebFrameAdapter.cpp:
      (QWebFrameAdapter::addToJavaScriptWindowObject):
      
      ../WebKit/win: 
      
      * WebCoreStatistics.cpp:
      (WebCoreStatistics::javaScriptObjectsCount):
      (WebCoreStatistics::javaScriptGlobalObjectsCount):
      (WebCoreStatistics::javaScriptProtectedObjectsCount):
      (WebCoreStatistics::javaScriptProtectedGlobalObjectsCount):
      (WebCoreStatistics::javaScriptProtectedObjectTypeCounts):
      * WebJavaScriptCollector.cpp:
      (WebJavaScriptCollector::objectCount):
      
      ../WebKit2: 
      
      * Shared/linux/WebMemorySamplerLinux.cpp:
      (WebKit::WebMemorySampler::sampleWebKit):
      * Shared/mac/WebMemorySampler.mac.mm:
      (WebKit::WebMemorySampler::sampleWebKit):
      * WebProcess/InjectedBundle/InjectedBundle.cpp:
      (WebKit::InjectedBundle::javaScriptObjectsCount):
      * WebProcess/Plugins/Netscape/JSNPMethod.cpp:
      (WebKit::JSNPMethod::finishCreation):
      * WebProcess/Plugins/Netscape/JSNPMethod.h:
      (WebKit::JSNPMethod::create):
      (JSNPMethod):
      (WebKit::JSNPMethod::createStructure):
      * WebProcess/Plugins/Netscape/JSNPObject.cpp:
      (WebKit::JSNPObject::JSNPObject):
      (WebKit::JSNPObject::finishCreation):
      (WebKit::JSNPObject::callMethod):
      (WebKit::JSNPObject::callObject):
      (WebKit::JSNPObject::callConstructor):
      (WebKit::JSNPObject::put):
      (WebKit::JSNPObject::deleteProperty):
      (WebKit::JSNPObject::getOwnPropertyNames):
      (WebKit::JSNPObject::propertyGetter):
      * WebProcess/Plugins/Netscape/JSNPObject.h:
      (WebKit::JSNPObject::create):
      (WebKit::JSNPObject::createStructure):
      * WebProcess/Plugins/Netscape/NPJSObject.cpp:
      (WebKit::NPJSObject::create):
      (WebKit::NPJSObject::initialize):
      * WebProcess/Plugins/Netscape/NPJSObject.h:
      (JSC):
      (NPJSObject):
      * WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp:
      (WebKit::NPRuntimeObjectMap::getOrCreateNPObject):
      (WebKit::NPRuntimeObjectMap::convertJSValueToNPVariant):
      (WebKit::NPRuntimeObjectMap::evaluate):
      * WebProcess/Plugins/Netscape/NPRuntimeObjectMap.h:
      (JSC):
      (NPRuntimeObjectMap):
      * WebProcess/Plugins/PluginView.cpp:
      (WebKit::PluginView::windowScriptNPObject):
      (WebKit::PluginView::pluginElementNPObject):
      * WebProcess/WebPage/WebPage.cpp:
      (WebKit::WebPage::runJavaScriptInMainFrame):
      * WebProcess/WebProcess.cpp:
      (WebKit::WebProcess::getWebCoreStatistics):
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@148696 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      9a9a4b52
  16. 04 Apr, 2013 2 commits
    • ggaren@apple.com's avatar
      Stop pretending that statements return a value · d786e6b6
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=113969
      
      Reviewed by Oliver Hunt.
      
      Expressions have an intrinsic value, which they return to their parent
      in the AST.
      
      Statements just execute for effect in sequence.
      
      This patch moves emitBytecode into the ExpressionNode and StatementNode
      subclasses, and changes the SatementNode subclass to return void. This
      eliminates some cruft where we used to return 0, or try to save a bogus
      register and return it, as if a statement had a consuming parent in the
      AST.
      
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitNode):
      (BytecodeGenerator):
      (JSC::BytecodeGenerator::emitNodeInConditionContext):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ConstStatementNode::emitBytecode):
      (JSC::BlockNode::emitBytecode):
      (JSC::EmptyStatementNode::emitBytecode):
      (JSC::DebuggerStatementNode::emitBytecode):
      (JSC::ExprStatementNode::emitBytecode):
      (JSC::VarStatementNode::emitBytecode):
      (JSC::IfNode::emitBytecode):
      (JSC::IfElseNode::emitBytecode):
      (JSC::DoWhileNode::emitBytecode):
      (JSC::WhileNode::emitBytecode):
      (JSC::ForNode::emitBytecode):
      (JSC::ForInNode::emitBytecode):
      (JSC::ContinueNode::emitBytecode):
      (JSC::BreakNode::emitBytecode):
      (JSC::ReturnNode::emitBytecode):
      (JSC::WithNode::emitBytecode):
      (JSC::CaseClauseNode::emitBytecode):
      (JSC::CaseBlockNode::emitBytecodeForBlock):
      (JSC::SwitchNode::emitBytecode):
      (JSC::LabelNode::emitBytecode):
      (JSC::ThrowNode::emitBytecode):
      (JSC::TryNode::emitBytecode):
      (JSC::ScopeNode::emitStatementsBytecode):
      (JSC::ProgramNode::emitBytecode):
      (JSC::EvalNode::emitBytecode):
      (JSC::FunctionBodyNode::emitBytecode):
      (JSC::FuncDeclNode::emitBytecode):
      * parser/NodeConstructors.h:
      (JSC::PropertyListNode::PropertyListNode):
      (JSC::ArgumentListNode::ArgumentListNode):
      * parser/Nodes.h:
      (Node):
      (ExpressionNode):
      (StatementNode):
      (ConstStatementNode):
      (BlockNode):
      (EmptyStatementNode):
      (DebuggerStatementNode):
      (ExprStatementNode):
      (VarStatementNode):
      (IfNode):
      (IfElseNode):
      (DoWhileNode):
      (WhileNode):
      (ForNode):
      (ForInNode):
      (ContinueNode):
      (BreakNode):
      (ReturnNode):
      (WithNode):
      (LabelNode):
      (ThrowNode):
      (TryNode):
      (ProgramNode):
      (EvalNode):
      (FunctionBodyNode):
      (FuncDeclNode):
      (CaseBlockNode):
      (SwitchNode):
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@147677 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      d786e6b6
    • ggaren@apple.com's avatar
      Simplified bytecode generation by merging prefix and postfix nodes · 20c0b6c5
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=113925
      
      Reviewed by Filip Pizlo.
      
      PostfixNode now inherits from PrefixNode, so when we detect that we're
      in a context where postifx and prefix are equivalent, PostFixNode can
      just call through to PrefixNode codegen, instead of duplicating the
      logic.
      
      * bytecompiler/NodesCodegen.cpp:
      (JSC::PostfixNode::emitResolve):
      (JSC::PostfixNode::emitBracket):
      (JSC::PostfixNode::emitDot):
      * parser/NodeConstructors.h:
      (JSC::PostfixNode::PostfixNode):
      * parser/Nodes.h:
      (JSC):
      (PrefixNode):
      (PostfixNode):
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@147658 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      20c0b6c5
  17. 20 Mar, 2013 1 commit
    • mark.lam@apple.com's avatar
      Source/JavaScriptCore: Fix incorrect debugger column number value. · faa53933
      mark.lam@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=112741.
      
      Reviewed by Oliver Hunt.
      
      1. In lexer, parser, and debugger code, renamed column to charPosition.
      2. Convert the charPosition to the equivalent column number before
         passing it to the debugger.
      3. Changed ScopeNodes to take both a startLocation and an endLocation.
         This allows FunctionBodyNodes, ProgramNodes, and EvalNodess to emit
         correct debug hooks with correct starting line and column numbers.
      4. Fixed the Lexer to not reset the charPosition (previously
         columnNumber) in Lexer::lex().
      
      * JavaScriptCore.order:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreExports.def:
      * JavaScriptCore.vcxproj/JavaScriptCoreExportGenerator/JavaScriptCoreExports.def.in:
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::dumpBytecode):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitDebugHook):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::BytecodeGenerator::emitExpressionInfo):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::toArgumentList):
      (JSC::ConstStatementNode::emitBytecode):
      (JSC::EmptyStatementNode::emitBytecode):
      (JSC::DebuggerStatementNode::emitBytecode):
      (JSC::ExprStatementNode::emitBytecode):
      (JSC::VarStatementNode::emitBytecode):
      (JSC::IfNode::emitBytecode):
      (JSC::IfElseNode::emitBytecode):
      (JSC::DoWhileNode::emitBytecode):
      (JSC::WhileNode::emitBytecode):
      (JSC::ForNode::emitBytecode):
      (JSC::ForInNode::emitBytecode):
      (JSC::ContinueNode::emitBytecode):
      (JSC::BreakNode::emitBytecode):
      (JSC::ReturnNode::emitBytecode):
      (JSC::WithNode::emitBytecode):
      (JSC::SwitchNode::emitBytecode):
      (JSC::LabelNode::emitBytecode):
      (JSC::ThrowNode::emitBytecode):
      (JSC::TryNode::emitBytecode):
      (JSC::ProgramNode::emitBytecode):
      (JSC::EvalNode::emitBytecode):
      (JSC::FunctionBodyNode::emitBytecode):
      * interpreter/Interpreter.cpp:
      (JSC::Interpreter::debug):
      - convert charPosition to column for the debugger.
      * interpreter/Interpreter.h:
      * jit/JITStubs.cpp:
      (DEFINE_STUB_FUNCTION(void, op_debug)):
      * llint/LLIntSlowPaths.cpp:
      (LLINT_SLOW_PATH_DECL(slow_op_debug)):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createFunctionExpr):
      (JSC::ASTBuilder::createFunctionBody):
      (JSC::ASTBuilder::createGetterOrSetterProperty):
      (JSC::ASTBuilder::createFuncDeclStatement):
      (JSC::ASTBuilder::createBlockStatement):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createIfStatement):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createVarStatement):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createTryStatement):
      (JSC::ASTBuilder::createSwitchStatement):
      (JSC::ASTBuilder::createWhileStatement):
      (JSC::ASTBuilder::createDoWhileStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::createDebugger):
      (JSC::ASTBuilder::createConstStatement):
      * parser/Lexer.cpp:
      (JSC::::setCode):
      (JSC::::internalShift):
      (JSC::::shift):
      (JSC::::lex):
      * parser/Lexer.h:
      (JSC::Lexer::currentCharPosition):
      (Lexer):
      (JSC::::lexExpectIdentifier):
      * parser/NodeConstructors.h:
      (JSC::Node::Node):
      * parser/Nodes.cpp:
      (JSC::StatementNode::setLoc):
      (JSC::ScopeNode::ScopeNode):
      (JSC::ProgramNode::ProgramNode):
      (JSC::ProgramNode::create):
      (JSC::EvalNode::EvalNode):
      (JSC::EvalNode::create):
      (JSC::FunctionBodyNode::FunctionBodyNode):
      (JSC::FunctionBodyNode::create):
      * parser/Nodes.h:
      (JSC::Node::charPosition):
      (Node):
      (StatementNode):
      (JSC::StatementNode::lastLine):
      (ScopeNode):
      (JSC::ScopeNode::startLine):
      (JSC::ScopeNode::startCharPosition):
      (ProgramNode):
      (EvalNode):
      (FunctionBodyNode):
      * parser/Parser.cpp:
      (JSC::::Parser):
      (JSC::::parseFunctionBody):
      (JSC::::parseFunctionInfo):
      * parser/Parser.h:
      (JSC::::parse):
      * parser/ParserTokens.h:
      (JSC::JSTokenLocation::JSTokenLocation):
      (JSTokenLocation):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createFunctionBody):
      
      Source/WTF: Introducing String::reverseFindLineTerminator().
      https://bugs.webkit.org/show_bug.cgi?id=112741.
      
      Reviewed by Oliver Hunt.
      
      This is needed by the JSC debugger code for computing column numbers.
      
      * wtf/text/StringImpl.cpp:
      (WTF::StringImpl::reverseFindLineTerminator):
      * wtf/text/StringImpl.h:
      (StringImpl):
      (WTF::reverseFindLineTerminator):
      * wtf/text/WTFString.h:
      (WTF::String::reverseFindLineTerminator):
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@146318 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      faa53933
  18. 11 Sep, 2012 1 commit
    • mlilek@apple.com's avatar
      OS X port should compile with newer versions of clang · 431ac37c
      mlilek@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=96434
      
      Source/JavaScriptCore: 
      
      m_identIsVarDecl is unused - remove it.
      
      Reviewed by Anders Carlsson.
      
      * parser/NodeConstructors.h:
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.h:
      (ForInNode):
      
      Source/WebCore: 
      
      Reviewed by Anders Carlsson.
      
      Guard m_hasTouchEventHandler behind ENABLE(TOUCH_EVENTS).
      * html/HTMLInputElement.cpp:
      (WebCore::HTMLInputElement::HTMLInputElement):
      * html/HTMLInputElement.h:
      (HTMLInputElement):
      
      Fix uninitialized variable.
      * platform/graphics/cg/GraphicsContextCG.cpp:
      (WebCore::createLinearSRGBColorSpace):
      
      Source/WebKit/mac: 
      
      m_isTerminated is unused in the Hosted flavor of NetscapePluginStream.
      
      Reviewed by Anders Carlsson.
      
      * Plugins/Hosted/HostedNetscapePluginStream.h:
      (HostedNetscapePluginStream):
      * Plugins/Hosted/HostedNetscapePluginStream.mm:
      (WebKit::HostedNetscapePluginStream::HostedNetscapePluginStream):
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@128234 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      431ac37c
  19. 06 Sep, 2012 1 commit
  20. 05 Sep, 2012 1 commit
    • barraclough@apple.com's avatar
      Merge prefix/postfix nodes · ff7867a9
      barraclough@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=95898
      
      Reviewed by Geoff Garen.
      
      Simplify the AST.
      This will also mean we have access to m_subscriptHasAssignments when generating a prefix/postfix op applied to a bracket access.
      
      * bytecompiler/NodesCodegen.cpp:
      (JSC::PostfixNode::emitResolve):
          - was PostfixResolveNode::emitBytecode
      (JSC::PostfixNode::emitBracket):
          - was PostfixBracketNode::emitBytecode
      (JSC::PostfixNode::emitDot):
          - was PostfixDotNode::emitBytecode
      (JSC::PostfixNode::emitBytecode):
          - was PostfixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.
      (JSC::PrefixNode::emitResolve):
          - was PrefixResolveNode::emitBytecode
      (JSC::PrefixNode::emitBracket):
          - was PrefixBracketNode::emitBytecode
      (JSC::PrefixNode::emitDot):
          - was PrefixDotNode::emitBytecode
      (JSC::PrefixNode::emitBytecode):
          - was PrefixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::makePrefixNode):
          - Just makes a PrefixNode!
      (JSC::ASTBuilder::makePostfixNode):
          - Just makes a PostfixNode!
      * parser/NodeConstructors.h:
      (JSC::PostfixNode::PostfixNode):
          - Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.
      (JSC::PrefixNode::PrefixNode):
          - Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
      * parser/Nodes.h:
      (PostfixNode):
          - Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.
      (PrefixNode):
          - Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@127654 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      ff7867a9
  21. 05 Aug, 2012 1 commit
    • commit-queue@webkit.org's avatar
      Web Inspector: [JSC] implement setting breakpoints by line:column · 1b331cbe
      commit-queue@webkit.org authored
      https://bugs.webkit.org/show_bug.cgi?id=53003
      
      Source/JavaScriptCore:
      
      Patch by Peter Wang <peter.wang@torchmobile.com.cn> on 2012-08-05
      Reviewed by Geoffrey Garen.
      
      Add a counter to Lexer to record the column info of each Token. Add a column parameter to
      op_debug, cti_op_debug, and _llint_op_debug byte-code command.
      
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::dump):
      * bytecode/Opcode.h:
      (JSC):
      (JSC::padOpcodeName):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::resolve):
      (JSC::BytecodeGenerator::emitDebugHook):
      * bytecompiler/BytecodeGenerator.h:
      (BytecodeGenerator):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::toArgumentList):
      (JSC::ApplyFunctionCallDotNode::emitBytecode):
      (JSC::ConstStatementNode::emitBytecode):
      (JSC::EmptyStatementNode::emitBytecode):
      (JSC::DebuggerStatementNode::emitBytecode):
      (JSC::ExprStatementNode::emitBytecode):
      (JSC::VarStatementNode::emitBytecode):
      (JSC::IfNode::emitBytecode):
      (JSC::IfElseNode::emitBytecode):
      (JSC::DoWhileNode::emitBytecode):
      (JSC::WhileNode::emitBytecode):
      (JSC::ForNode::emitBytecode):
      (JSC::ForInNode::emitBytecode):
      (JSC::ContinueNode::emitBytecode):
      (JSC::BreakNode::emitBytecode):
      (JSC::ReturnNode::emitBytecode):
      (JSC::WithNode::emitBytecode):
      (JSC::SwitchNode::emitBytecode):
      (JSC::LabelNode::emitBytecode):
      (JSC::ThrowNode::emitBytecode):
      (JSC::TryNode::emitBytecode):
      (JSC::ProgramNode::emitBytecode):
      (JSC::EvalNode::emitBytecode):
      (JSC::FunctionBodyNode::emitBytecode):
      * debugger/Debugger.h:
      * interpreter/Interpreter.cpp:
      (JSC::Interpreter::unwindCallFrame):
      (JSC::Interpreter::throwException):
      (JSC::Interpreter::debug):
      (JSC::Interpreter::privateExecute):
      * interpreter/Interpreter.h:
      (Interpreter):
      * jit/JITOpcodes.cpp:
      (JSC::JIT::emit_op_debug):
      * jit/JITOpcodes32_64.cpp:
      (JSC::JIT::emit_op_debug):
      * jit/JITStubs.cpp:
      (JSC::DEFINE_STUB_FUNCTION):
      * llint/LLIntSlowPaths.cpp:
      (JSC::LLInt::LLINT_SLOW_PATH_DECL):
      * llint/LowLevelInterpreter.asm:
      * parser/ASTBuilder.h:
      (ASTBuilder):
      (JSC::ASTBuilder::createCommaExpr):
      (JSC::ASTBuilder::createLogicalNot):
      (JSC::ASTBuilder::createUnaryPlus):
      (JSC::ASTBuilder::createVoid):
      (JSC::ASTBuilder::thisExpr):
      (JSC::ASTBuilder::createResolve):
      (JSC::ASTBuilder::createObjectLiteral):
      (JSC::ASTBuilder::createArray):
      (JSC::ASTBuilder::createNumberExpr):
      (JSC::ASTBuilder::createString):
      (JSC::ASTBuilder::createBoolean):
      (JSC::ASTBuilder::createNull):
      (JSC::ASTBuilder::createBracketAccess):
      (JSC::ASTBuilder::createDotAccess):
      (JSC::ASTBuilder::createRegExp):
      (JSC::ASTBuilder::createNewExpr):
      (JSC::ASTBuilder::createConditionalExpr):
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createFunctionExpr):
      (JSC::ASTBuilder::createFunctionBody):
      (JSC::ASTBuilder::createGetterOrSetterProperty):
      (JSC::ASTBuilder::createArgumentsList):
      (JSC::ASTBuilder::createPropertyList):
      (JSC::ASTBuilder::createFuncDeclStatement):
      (JSC::ASTBuilder::createBlockStatement):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createIfStatement):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createEmptyStatement):
      (JSC::ASTBuilder::createVarStatement):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createTryStatement):
      (JSC::ASTBuilder::createSwitchStatement):
      (JSC::ASTBuilder::createWhileStatement):
      (JSC::ASTBuilder::createDoWhileStatement):
      (JSC::ASTBuilder::createLabelStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::createDebugger):
      (JSC::ASTBuilder::createConstStatement):
      (JSC::ASTBuilder::appendConstDecl):
      (JSC::ASTBuilder::combineCommaNodes):
      (JSC::ASTBuilder::appendBinaryOperation):
      (JSC::ASTBuilder::createAssignment):
      (JSC::ASTBuilder::createNumber):
      (JSC::ASTBuilder::makeTypeOfNode):
      (JSC::ASTBuilder::makeDeleteNode):
      (JSC::ASTBuilder::makeNegateNode):
      (JSC::ASTBuilder::makeBitwiseNotNode):
      (JSC::ASTBuilder::makeMultNode):
      (JSC::ASTBuilder::makeDivNode):
      (JSC::ASTBuilder::makeModNode):
      (JSC::ASTBuilder::makeAddNode):
      (JSC::ASTBuilder::makeSubNode):
      (JSC::ASTBuilder::makeLeftShiftNode):
      (JSC::ASTBuilder::makeRightShiftNode):
      (JSC::ASTBuilder::makeURightShiftNode):
      (JSC::ASTBuilder::makeBitOrNode):
      (JSC::ASTBuilder::makeBitAndNode):
      (JSC::ASTBuilder::makeBitXOrNode):
      (JSC::ASTBuilder::makeFunctionCallNode):
      (JSC::ASTBuilder::makeBinaryNode):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):
      * parser/Lexer.cpp:
      (JSC::::setCode):
      (JSC::::internalShift):
      (JSC::::shift):
      (JSC::::lex):
      * parser/Lexer.h:
      (Lexer):
      (JSC::Lexer::currentColumnNumber):
      (JSC::::lexExpectIdentifier):
      * parser/NodeConstructors.h:
      (JSC::Node::Node):
      (JSC::ExpressionNode::ExpressionNode):
      (JSC::StatementNode::StatementNode):
      (JSC::NullNode::NullNode):
      (JSC::BooleanNode::BooleanNode):
      (JSC::NumberNode::NumberNode):
      (JSC::StringNode::StringNode):
      (JSC::RegExpNode::RegExpNode):
      (JSC::ThisNode::ThisNode):
      (JSC::ResolveNode::ResolveNode):
      (JSC::ArrayNode::ArrayNode):
      (JSC::PropertyListNode::PropertyListNode):
      (JSC::ObjectLiteralNode::ObjectLiteralNode):
      (JSC::BracketAccessorNode::BracketAccessorNode):
      (JSC::DotAccessorNode::DotAccessorNode):
      (JSC::ArgumentListNode::ArgumentListNode):
      (JSC::NewExprNode::NewExprNode):
      (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
      (JSC::FunctionCallValueNode::FunctionCallValueNode):
      (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
      (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
      (JSC::FunctionCallDotNode::FunctionCallDotNode):
      (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
      (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
      (JSC::PrePostResolveNode::PrePostResolveNode):
      (JSC::PostfixResolveNode::PostfixResolveNode):
      (JSC::PostfixBracketNode::PostfixBracketNode):
      (JSC::PostfixDotNode::PostfixDotNode):
      (JSC::PostfixErrorNode::PostfixErrorNode):
      (JSC::DeleteResolveNode::DeleteResolveNode):
      (JSC::DeleteBracketNode::DeleteBracketNode):
      (JSC::DeleteDotNode::DeleteDotNode):
      (JSC::DeleteValueNode::DeleteValueNode):
      (JSC::VoidNode::VoidNode):
      (JSC::TypeOfResolveNode::TypeOfResolveNode):
      (JSC::TypeOfValueNode::TypeOfValueNode):
      (JSC::PrefixResolveNode::PrefixResolveNode):
      (JSC::PrefixBracketNode::PrefixBracketNode):
      (JSC::PrefixDotNode::PrefixDotNode):
      (JSC::PrefixErrorNode::PrefixErrorNode):
      (JSC::UnaryOpNode::UnaryOpNode):
      (JSC::UnaryPlusNode::UnaryPlusNode):
      (JSC::NegateNode::NegateNode):
      (JSC::BitwiseNotNode::BitwiseNotNode):
      (JSC::LogicalNotNode::LogicalNotNode):
      (JSC::BinaryOpNode::BinaryOpNode):
      (JSC::MultNode::MultNode):
      (JSC::DivNode::DivNode):
      (JSC::ModNode::ModNode):
      (JSC::AddNode::AddNode):
      (JSC::SubNode::SubNode):
      (JSC::LeftShiftNode::LeftShiftNode):
      (JSC::RightShiftNode::RightShiftNode):
      (JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
      (JSC::LessNode::LessNode):
      (JSC::GreaterNode::GreaterNode):
      (JSC::LessEqNode::LessEqNode):
      (JSC::GreaterEqNode::GreaterEqNode):
      (JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
      (JSC::InstanceOfNode::InstanceOfNode):
      (JSC::InNode::InNode):
      (JSC::EqualNode::EqualNode):
      (JSC::NotEqualNode::NotEqualNode):
      (JSC::StrictEqualNode::StrictEqualNode):
      (JSC::NotStrictEqualNode::NotStrictEqualNode):
      (JSC::BitAndNode::BitAndNode):
      (JSC::BitOrNode::BitOrNode):
      (JSC::BitXOrNode::BitXOrNode):
      (JSC::LogicalOpNode::LogicalOpNode):
      (JSC::ConditionalNode::ConditionalNode):
      (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
      (JSC::AssignResolveNode::AssignResolveNode):
      (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
      (JSC::AssignBracketNode::AssignBracketNode):
      (JSC::AssignDotNode::AssignDotNode):
      (JSC::ReadModifyDotNode::ReadModifyDotNode):
      (JSC::AssignErrorNode::AssignErrorNode):
      (JSC::CommaNode::CommaNode):
      (JSC::ConstStatementNode::ConstStatementNode):
      (JSC::EmptyStatementNode::EmptyStatementNode):
      (JSC::DebuggerStatementNode::DebuggerStatementNode):
      (JSC::ExprStatementNode::ExprStatementNode):
      (JSC::VarStatementNode::VarStatementNode):
      (JSC::IfNode::IfNode):
      (JSC::IfElseNode::IfElseNode):
      (JSC::DoWhileNode::DoWhileNode):
      (JSC::WhileNode::WhileNode):
      (JSC::ForNode::ForNode):
      (JSC::ContinueNode::ContinueNode):
      (JSC::BreakNode::BreakNode):
      (JSC::ReturnNode::ReturnNode):
      (JSC::WithNode::WithNode):
      (JSC::LabelNode::LabelNode):
      (JSC::ThrowNode::ThrowNode):
      (JSC::TryNode::TryNode):
      (JSC::FuncExprNode::FuncExprNode):
      (JSC::FuncDeclNode::FuncDeclNode):
      (JSC::SwitchNode::SwitchNode):
      (JSC::ConstDeclNode::ConstDeclNode):
      (JSC::BlockNode::BlockNode):
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.cpp:
      (JSC::StatementNode::setLoc):
      (JSC):
      (JSC::ScopeNode::ScopeNode):
      (JSC::ProgramNode::ProgramNode):
      (JSC::ProgramNode::create):
      (JSC::EvalNode::EvalNode):
      (JSC::EvalNode::create):
      (JSC::FunctionBodyNode::FunctionBodyNode):
      (JSC::FunctionBodyNode::create):
      * parser/Nodes.h:
      (Node):
      (JSC::Node::columnNo):
      (ExpressionNode):
      (StatementNode):
      (JSC::StatementNode::column):
      (NullNode):
      (BooleanNode):
      (NumberNode):
      (StringNode):
      (RegExpNode):
      (ThisNode):
      (ResolveNode):
      (ArrayNode):
      (PropertyListNode):
      (ObjectLiteralNode):
      (BracketAccessorNode):
      (DotAccessorNode):
      (ArgumentListNode):
      (NewExprNode):
      (EvalFunctionCallNode):
      (FunctionCallValueNode):
      (FunctionCallResolveNode):
      (FunctionCallBracketNode):
      (FunctionCallDotNode):
      (CallFunctionCallDotNode):
      (ApplyFunctionCallDotNode):
      (PrePostResolveNode):
      (PostfixResolveNode):
      (PostfixBracketNode):
      (PostfixDotNode):
      (PostfixErrorNode):
      (DeleteResolveNode):
      (DeleteBracketNode):
      (DeleteDotNode):
      (DeleteValueNode):
      (VoidNode):
      (TypeOfResolveNode):
      (TypeOfValueNode):
      (PrefixResolveNode):
      (PrefixBracketNode):
      (PrefixDotNode):
      (PrefixErrorNode):
      (UnaryOpNode):
      (UnaryPlusNode):
      (NegateNode):
      (BitwiseNotNode):
      (LogicalNotNode):
      (BinaryOpNode):
      (MultNode):
      (DivNode):
      (ModNode):
      (AddNode):
      (SubNode):
      (LeftShiftNode):
      (RightShiftNode):
      (UnsignedRightShiftNode):
      (LessNode):
      (GreaterNode):
      (LessEqNode):
      (GreaterEqNode):
      (ThrowableBinaryOpNode):
      (InstanceOfNode):
      (InNode):
      (EqualNode):
      (NotEqualNode):
      (StrictEqualNode):
      (NotStrictEqualNode):
      (BitAndNode):
      (BitOrNode):
      (BitXOrNode):
      (LogicalOpNode):
      (ConditionalNode):
      (ReadModifyResolveNode):
      (AssignResolveNode):
      (ReadModifyBracketNode):
      (AssignBracketNode):
      (AssignDotNode):
      (ReadModifyDotNode):
      (AssignErrorNode):
      (CommaNode):
      (ConstDeclNode):
      (ConstStatementNode):
      (BlockNode):
      (EmptyStatementNode):
      (DebuggerStatementNode):
      (ExprStatementNode):
      (VarStatementNode):
      (IfNode):
      (IfElseNode):
      (DoWhileNode):
      (WhileNode):
      (ForNode):
      (ForInNode):
      (ContinueNode):
      (BreakNode):
      (ReturnNode):
      (WithNode):
      (LabelNode):
      (ThrowNode):
      (TryNode):
      (ScopeNode):
      (ProgramNode):
      (EvalNode):
      (FunctionBodyNode):
      (FuncExprNode):
      (FuncDeclNode):
      (SwitchNode):
      * parser/Parser.cpp:
      (JSC::::parseSourceElements):
      (JSC::::parseVarDeclaration):
      (JSC::::parseConstDeclaration):
      (JSC::::parseDoWhileStatement):
      (JSC::::parseWhileStatement):
      (JSC::::parseVarDeclarationList):
      (JSC::::parseConstDeclarationList):
      (JSC::::parseForStatement):
      (JSC::::parseBreakStatement):
      (JSC::::parseContinueStatement):
      (JSC::::parseReturnStatement):
      (JSC::::parseThrowStatement):
      (JSC::::parseWithStatement):
      (JSC::::parseSwitchStatement):
      (JSC::::parseTryStatement):
      (JSC::::parseDebuggerStatement):
      (JSC::::parseBlockStatement):
      (JSC::::parseStatement):
      (JSC::::parseFunctionBody):
      (JSC::::parseFunctionInfo):
      (JSC::::parseFunctionDeclaration):
      (JSC::::parseExpressionOrLabelStatement):
      (JSC::::parseExpressionStatement):
      (JSC::::parseIfStatement):
      (JSC::::parseExpression):
      (JSC::::parseAssignmentExpression):
      (JSC::::parseConditionalExpression):
      (JSC::::parseBinaryExpression):
      (JSC::::parseProperty):
      (JSC::::parseObjectLiteral):
      (JSC::::parseStrictObjectLiteral):
      (JSC::::parseArrayLiteral):
      (JSC::::parsePrimaryExpression):
      (JSC::::parseArguments):
      (JSC::::parseMemberExpression):
      (JSC::::parseUnaryExpression):
      * parser/Parser.h:
      (JSC::Parser::next):
      (JSC::Parser::nextExpectIdentifier):
      (JSC::Parser::tokenStart):
      (JSC::Parser::tokenLine):
      (JSC::Parser::tokenEnd):
      (JSC::Parser::tokenLocation):
      (Parser):
      (JSC::Parser::getTokenName):
      (JSC::::parse):
      * parser/ParserTokens.h:
      (JSC::JSTokenLocation::JSTokenLocation):
      (JSTokenLocation):
      (JSToken):
      * parser/SourceProviderCacheItem.h:
      (JSC::SourceProviderCacheItem::closeBraceToken):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::makeFunctionCallNode):
      (JSC::SyntaxChecker::createCommaExpr):
      (JSC::SyntaxChecker::makeAssignNode):
      (JSC::SyntaxChecker::makePrefixNode):
      (JSC::SyntaxChecker::makePostfixNode):
      (JSC::SyntaxChecker::makeTypeOfNode):
      (JSC::SyntaxChecker::makeDeleteNode):
      (JSC::SyntaxChecker::makeNegateNode):
      (JSC::SyntaxChecker::makeBitwiseNotNode):
      (JSC::SyntaxChecker::createLogicalNot):
      (JSC::SyntaxChecker::createUnaryPlus):
      (JSC::SyntaxChecker::createVoid):
      (JSC::SyntaxChecker::thisExpr):
      (JSC::SyntaxChecker::createResolve):
      (JSC::SyntaxChecker::createObjectLiteral):
      (JSC::SyntaxChecker::createArray):
      (JSC::SyntaxChecker::createNumberExpr):
      (JSC::SyntaxChecker::createString):
      (JSC::SyntaxChecker::createBoolean):
      (JSC::SyntaxChecker::createNull):
      (JSC::SyntaxChecker::createBracketAccess):
      (JSC::SyntaxChecker::createDotAccess):
      (JSC::SyntaxChecker::createRegExp):
      (JSC::SyntaxChecker::createNewExpr):
      (JSC::SyntaxChecker::createConditionalExpr):
      (JSC::SyntaxChecker::createAssignResolve):
      (JSC::SyntaxChecker::createFunctionExpr):
      (JSC::SyntaxChecker::createFunctionBody):
      (JSC::SyntaxChecker::createArgumentsList):
      (JSC::SyntaxChecker::createPropertyList):
      (JSC::SyntaxChecker::createFuncDeclStatement):
      (JSC::SyntaxChecker::createBlockStatement):
      (JSC::SyntaxChecker::createExprStatement):
      (JSC::SyntaxChecker::createIfStatement):
      (JSC::SyntaxChecker::createForLoop):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::createEmptyStatement):
      (JSC::SyntaxChecker::createVarStatement):
      (JSC::SyntaxChecker::createReturnStatement):
      (JSC::SyntaxChecker::createBreakStatement):
      (JSC::SyntaxChecker::createContinueStatement):
      (JSC::SyntaxChecker::createTryStatement):
      (JSC::SyntaxChecker::createSwitchStatement):
      (JSC::SyntaxChecker::createWhileStatement):
      (JSC::SyntaxChecker::createWithStatement):
      (JSC::SyntaxChecker::createDoWhileStatement):
      (JSC::SyntaxChecker::createLabelStatement):
      (JSC::SyntaxChecker::createThrowStatement):
      (JSC::SyntaxChecker::createDebugger):
      (JSC::SyntaxChecker::createConstStatement):
      (JSC::SyntaxChecker::appendConstDecl):
      (JSC::SyntaxChecker::createGetterOrSetterProperty):
      (JSC::SyntaxChecker::combineCommaNodes):
      (JSC::SyntaxChecker::operatorStackPop):
      
      Source/WebCore:
      
      Patch by Peter Wang <peter.wang@torchmobile.com.cn> on 2012-08-05
      Reviewed by Geoffrey Garen.
      
      Since JSC can provide column info now, ScriptDebugServer can use it to support "Pretty Print"
      debug mode. The related interfaces derived from JSC::Debugger was added a parameter.
      
      No new tests for this patch.
      
      * bindings/js/ScriptDebugServer.cpp:
      (WebCore::ScriptDebugServer::setBreakpoint):
      (WebCore::ScriptDebugServer::removeBreakpoint):
      (WebCore):
      (WebCore::ScriptDebugServer::updateCurrentStatementPosition):
      (WebCore::ScriptDebugServer::hasBreakpoint):
      (WebCore::ScriptDebugServer::createCallFrameAndPauseIfNeeded):
      (WebCore::ScriptDebugServer::updateCallFrameAndPauseIfNeeded):
      (WebCore::ScriptDebugServer::callEvent):
      (WebCore::ScriptDebugServer::atStatement):
      (WebCore::ScriptDebugServer::returnEvent):
      (WebCore::ScriptDebugServer::exception):
      (WebCore::ScriptDebugServer::willExecuteProgram):
      (WebCore::ScriptDebugServer::didExecuteProgram):
      (WebCore::ScriptDebugServer::didReachBreakpoint):
      * bindings/js/ScriptDebugServer.h:
      (ScriptDebugServer):
      
      Source/WebKit/mac:
      
      Unreviewed, just changed the interface according the changes of base class JSC::Debugger.
      
      No JSC can provide the column info of current JS statement, mac porting can use it to support
      "Pretty Print" debug mode.
      
      Patch by Peter Wang <peter.wang@torchmobile.com.cn> on 2012-08-05
      
      * WebView/WebScriptDebugger.h:
      (WebScriptDebugger):
      * WebView/WebScriptDebugger.mm:
      (WebScriptDebugger::callEvent):
      (WebScriptDebugger::atStatement):
      (WebScriptDebugger::returnEvent):
      (WebScriptDebugger::exception):
      (WebScriptDebugger::willExecuteProgram):
      (WebScriptDebugger::didExecuteProgram):
      (WebScriptDebugger::didReachBreakpoint):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@124729 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      1b331cbe
  22. 02 Aug, 2012 1 commit
    • commit-queue@webkit.org's avatar
      Unreviewed, rolling out r124406. · 709de8fe
      commit-queue@webkit.org authored
      http://trac.webkit.org/changeset/124406
      https://bugs.webkit.org/show_bug.cgi?id=92951
      
      it set the Mac bots on fire (Requested by pizlo on #webkit).
      
      Patch by Sheriff Bot <webkit.review.bot@gmail.com> on 2012-08-01
      
      Source/JavaScriptCore:
      
      * bytecode/Opcode.h:
      (JSC):
      (JSC::padOpcodeName):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitDebugHook):
      * bytecompiler/BytecodeGenerator.h:
      (BytecodeGenerator):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::toArgumentList):
      (JSC::ApplyFunctionCallDotNode::emitBytecode):
      (JSC::ConditionalNode::emitBytecode):
      (JSC::ConstStatementNode::emitBytecode):
      (JSC::EmptyStatementNode::emitBytecode):
      (JSC::DebuggerStatementNode::emitBytecode):
      (JSC::ExprStatementNode::emitBytecode):
      (JSC::VarStatementNode::emitBytecode):
      (JSC::IfNode::emitBytecode):
      (JSC::IfElseNode::emitBytecode):
      (JSC::DoWhileNode::emitBytecode):
      (JSC::WhileNode::emitBytecode):
      (JSC::ForNode::emitBytecode):
      (JSC::ForInNode::emitBytecode):
      (JSC::ContinueNode::emitBytecode):
      (JSC::BreakNode::emitBytecode):
      (JSC::ReturnNode::emitBytecode):
      (JSC::WithNode::emitBytecode):
      (JSC::SwitchNode::emitBytecode):
      (JSC::LabelNode::emitBytecode):
      (JSC::ThrowNode::emitBytecode):
      (JSC::TryNode::emitBytecode):
      (JSC::ProgramNode::emitBytecode):
      (JSC::EvalNode::emitBytecode):
      (JSC::FunctionBodyNode::emitBytecode):
      * debugger/Debugger.h:
      * interpreter/Interpreter.cpp:
      (JSC::Interpreter::unwindCallFrame):
      (JSC::Interpreter::throwException):
      (JSC::Interpreter::debug):
      * interpreter/Interpreter.h:
      (Interpreter):
      * jit/JITOpcodes.cpp:
      (JSC::JIT::emit_op_debug):
      * jit/JITOpcodes32_64.cpp:
      (JSC::JIT::emit_op_debug):
      * jit/JITStubs.cpp:
      (JSC::DEFINE_STUB_FUNCTION):
      * llint/LLIntSlowPaths.cpp:
      (JSC::LLInt::LLINT_SLOW_PATH_DECL):
      * parser/ASTBuilder.h:
      (ASTBuilder):
      (JSC::ASTBuilder::createCommaExpr):
      (JSC::ASTBuilder::createLogicalNot):
      (JSC::ASTBuilder::createUnaryPlus):
      (JSC::ASTBuilder::createVoid):
      (JSC::ASTBuilder::thisExpr):
      (JSC::ASTBuilder::createResolve):
      (JSC::ASTBuilder::createObjectLiteral):
      (JSC::ASTBuilder::createArray):
      (JSC::ASTBuilder::createNumberExpr):
      (JSC::ASTBuilder::createString):
      (JSC::ASTBuilder::createBoolean):
      (JSC::ASTBuilder::createNull):
      (JSC::ASTBuilder::createBracketAccess):
      (JSC::ASTBuilder::createDotAccess):
      (JSC::ASTBuilder::createRegExp):
      (JSC::ASTBuilder::createNewExpr):
      (JSC::ASTBuilder::createConditionalExpr):
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createFunctionExpr):
      (JSC::ASTBuilder::createFunctionBody):
      (JSC::ASTBuilder::createGetterOrSetterProperty):
      (JSC::ASTBuilder::createArgumentsList):
      (JSC::ASTBuilder::createPropertyList):
      (JSC::ASTBuilder::createFuncDeclStatement):
      (JSC::ASTBuilder::createBlockStatement):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createIfStatement):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createEmptyStatement):
      (JSC::ASTBuilder::createVarStatement):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createTryStatement):
      (JSC::ASTBuilder::createSwitchStatement):
      (JSC::ASTBuilder::createWhileStatement):
      (JSC::ASTBuilder::createDoWhileStatement):
      (JSC::ASTBuilder::createLabelStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::createDebugger):
      (JSC::ASTBuilder::createConstStatement):
      (JSC::ASTBuilder::appendConstDecl):
      (JSC::ASTBuilder::combineCommaNodes):
      (JSC::ASTBuilder::appendBinaryOperation):
      (JSC::ASTBuilder::createAssignment):
      (JSC::ASTBuilder::createNumber):
      (JSC::ASTBuilder::makeTypeOfNode):
      (JSC::ASTBuilder::makeDeleteNode):
      (JSC::ASTBuilder::makeNegateNode):
      (JSC::ASTBuilder::makeBitwiseNotNode):
      (JSC::ASTBuilder::makeMultNode):
      (JSC::ASTBuilder::makeDivNode):
      (JSC::ASTBuilder::makeModNode):
      (JSC::ASTBuilder::makeAddNode):
      (JSC::ASTBuilder::makeSubNode):
      (JSC::ASTBuilder::makeLeftShiftNode):
      (JSC::ASTBuilder::makeRightShiftNode):
      (JSC::ASTBuilder::makeURightShiftNode):
      (JSC::ASTBuilder::makeBitOrNode):
      (JSC::ASTBuilder::makeBitAndNode):
      (JSC::ASTBuilder::makeBitXOrNode):
      (JSC::ASTBuilder::makeFunctionCallNode):
      (JSC::ASTBuilder::makeBinaryNode):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):
      * parser/Lexer.cpp:
      (JSC::::setCode):
      (JSC::::internalShift):
      (JSC::::shift):
      (JSC::::lex):
      * parser/Lexer.h:
      (Lexer):
      (JSC::::lexExpectIdentifier):
      * parser/NodeConstructors.h:
      (JSC::Node::Node):
      (JSC::ExpressionNode::ExpressionNode):
      (JSC::StatementNode::StatementNode):
      (JSC::NullNode::NullNode):
      (JSC::BooleanNode::BooleanNode):
      (JSC::NumberNode::NumberNode):
      (JSC::StringNode::StringNode):
      (JSC::RegExpNode::RegExpNode):
      (JSC::ThisNode::ThisNode):
      (JSC::ResolveNode::ResolveNode):
      (JSC::ArrayNode::ArrayNode):
      (JSC::PropertyListNode::PropertyListNode):
      (JSC::ObjectLiteralNode::ObjectLiteralNode):
      (JSC::BracketAccessorNode::BracketAccessorNode):
      (JSC::DotAccessorNode::DotAccessorNode):
      (JSC::ArgumentListNode::ArgumentListNode):
      (JSC::NewExprNode::NewExprNode):
      (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
      (JSC::FunctionCallValueNode::FunctionCallValueNode):
      (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
      (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
      (JSC::FunctionCallDotNode::FunctionCallDotNode):
      (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
      (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
      (JSC::PrePostResolveNode::PrePostResolveNode):
      (JSC::PostfixResolveNode::PostfixResolveNode):
      (JSC::PostfixBracketNode::PostfixBracketNode):
      (JSC::PostfixDotNode::PostfixDotNode):
      (JSC::PostfixErrorNode::PostfixErrorNode):
      (JSC::DeleteResolveNode::DeleteResolveNode):
      (JSC::DeleteBracketNode::DeleteBracketNode):
      (JSC::DeleteDotNode::DeleteDotNode):
      (JSC::DeleteValueNode::DeleteValueNode):
      (JSC::VoidNode::VoidNode):
      (JSC::TypeOfResolveNode::TypeOfResolveNode):
      (JSC::TypeOfValueNode::TypeOfValueNode):
      (JSC::PrefixResolveNode::PrefixResolveNode):
      (JSC::PrefixBracketNode::PrefixBracketNode):
      (JSC::PrefixDotNode::PrefixDotNode):
      (JSC::PrefixErrorNode::PrefixErrorNode):
      (JSC::UnaryOpNode::UnaryOpNode):
      (JSC::UnaryPlusNode::UnaryPlusNode):
      (JSC::NegateNode::NegateNode):
      (JSC::BitwiseNotNode::BitwiseNotNode):
      (JSC::LogicalNotNode::LogicalNotNode):
      (JSC::BinaryOpNode::BinaryOpNode):
      (JSC::MultNode::MultNode):
      (JSC::DivNode::DivNode):
      (JSC::ModNode::ModNode):
      (JSC::AddNode::AddNode):
      (JSC::SubNode::SubNode):
      (JSC::LeftShiftNode::LeftShiftNode):
      (JSC::RightShiftNode::RightShiftNode):
      (JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
      (JSC::LessNode::LessNode):
      (JSC::GreaterNode::GreaterNode):
      (JSC::LessEqNode::LessEqNode):
      (JSC::GreaterEqNode::GreaterEqNode):
      (JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
      (JSC::InstanceOfNode::InstanceOfNode):
      (JSC::InNode::InNode):
      (JSC::EqualNode::EqualNode):
      (JSC::NotEqualNode::NotEqualNode):
      (JSC::StrictEqualNode::StrictEqualNode):
      (JSC::NotStrictEqualNode::NotStrictEqualNode):
      (JSC::BitAndNode::BitAndNode):
      (JSC::BitOrNode::BitOrNode):
      (JSC::BitXOrNode::BitXOrNode):
      (JSC::LogicalOpNode::LogicalOpNode):
      (JSC::ConditionalNode::ConditionalNode):
      (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
      (JSC::AssignResolveNode::AssignResolveNode):
      (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
      (JSC::AssignBracketNode::AssignBracketNode):
      (JSC::AssignDotNode::AssignDotNode):
      (JSC::ReadModifyDotNode::ReadModifyDotNode):
      (JSC::AssignErrorNode::AssignErrorNode):
      (JSC::CommaNode::CommaNode):
      (JSC::ConstStatementNode::ConstStatementNode):
      (JSC::EmptyStatementNode::EmptyStatementNode):
      (JSC::DebuggerStatementNode::DebuggerStatementNode):
      (JSC::ExprStatementNode::ExprStatementNode):
      (JSC::VarStatementNode::VarStatementNode):
      (JSC::IfNode::IfNode):
      (JSC::IfElseNode::IfElseNode):
      (JSC::DoWhileNode::DoWhileNode):
      (JSC::WhileNode::WhileNode):
      (JSC::ForNode::ForNode):
      (JSC::ContinueNode::ContinueNode):
      (JSC::BreakNode::BreakNode):
      (JSC::ReturnNode::ReturnNode):
      (JSC::WithNode::WithNode):
      (JSC::LabelNode::LabelNode):
      (JSC::ThrowNode::ThrowNode):
      (JSC::TryNode::TryNode):
      (JSC::FuncExprNode::FuncExprNode):
      (JSC::FuncDeclNode::FuncDeclNode):
      (JSC::SwitchNode::SwitchNode):
      (JSC::ConstDeclNode::ConstDeclNode):
      (JSC::BlockNode::BlockNode):
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.cpp:
      (JSC):
      (JSC::StatementNode::setLoc):
      (JSC::ScopeNode::ScopeNode):
      (JSC::ProgramNode::ProgramNode):
      (JSC::ProgramNode::create):
      (JSC::EvalNode::EvalNode):
      (JSC::EvalNode::create):
      (JSC::FunctionBodyNode::FunctionBodyNode):
      (JSC::FunctionBodyNode::create):
      * parser/Nodes.h:
      (Node):
      (ExpressionNode):
      (StatementNode):
      (NullNode):
      (BooleanNode):
      (NumberNode):
      (StringNode):
      (RegExpNode):
      (ThisNode):
      (ResolveNode):
      (ArrayNode):
      (PropertyListNode):
      (ObjectLiteralNode):
      (BracketAccessorNode):
      (DotAccessorNode):
      (ArgumentListNode):
      (NewExprNode):
      (EvalFunctionCallNode):
      (FunctionCallValueNode):
      (FunctionCallResolveNode):
      (FunctionCallBracketNode):
      (FunctionCallDotNode):
      (CallFunctionCallDotNode):
      (ApplyFunctionCallDotNode):
      (PrePostResolveNode):
      (PostfixResolveNode):
      (PostfixBracketNode):
      (PostfixDotNode):
      (PostfixErrorNode):
      (DeleteResolveNode):
      (DeleteBracketNode):
      (DeleteDotNode):
      (DeleteValueNode):
      (VoidNode):
      (TypeOfResolveNode):
      (TypeOfValueNode):
      (PrefixResolveNode):
      (PrefixBracketNode):
      (PrefixDotNode):
      (PrefixErrorNode):
      (UnaryOpNode):
      (UnaryPlusNode):
      (NegateNode):
      (BitwiseNotNode):
      (LogicalNotNode):
      (BinaryOpNode):
      (MultNode):
      (DivNode):
      (ModNode):
      (AddNode):
      (SubNode):
      (LeftShiftNode):
      (RightShiftNode):
      (UnsignedRightShiftNode):
      (LessNode):
      (GreaterNode):
      (LessEqNode):
      (GreaterEqNode):
      (ThrowableBinaryOpNode):
      (InstanceOfNode):
      (InNode):
      (EqualNode):
      (NotEqualNode):
      (StrictEqualNode):
      (NotStrictEqualNode):
      (BitAndNode):
      (BitOrNode):
      (BitXOrNode):
      (LogicalOpNode):
      (ConditionalNode):
      (ReadModifyResolveNode):
      (AssignResolveNode):
      (ReadModifyBracketNode):
      (AssignBracketNode):
      (AssignDotNode):
      (ReadModifyDotNode):
      (AssignErrorNode):
      (CommaNode):
      (ConstDeclNode):
      (ConstStatementNode):
      (BlockNode):
      (EmptyStatementNode):
      (DebuggerStatementNode):
      (ExprStatementNode):
      (VarStatementNode):
      (IfNode):
      (IfElseNode):
      (DoWhileNode):
      (WhileNode):
      (ForNode):
      (ForInNode):
      (ContinueNode):
      (BreakNode):
      (ReturnNode):
      (WithNode):
      (LabelNode):
      (ThrowNode):
      (TryNode):
      (ScopeNode):
      (ProgramNode):
      (EvalNode):
      (FunctionBodyNode):
      (FuncExprNode):
      (FuncDeclNode):
      (SwitchNode):
      * parser/Parser.cpp:
      (JSC::::parseSourceElements):
      (JSC::::parseVarDeclaration):
      (JSC::::parseConstDeclaration):
      (JSC::::parseDoWhileStatement):
      (JSC::::parseWhileStatement):
      (JSC::::parseVarDeclarationList):
      (JSC::::parseConstDeclarationList):
      (JSC::::parseForStatement):
      (JSC::::parseBreakStatement):
      (JSC::::parseContinueStatement):
      (JSC::::parseReturnStatement):
      (JSC::::parseThrowStatement):
      (JSC::::parseWithStatement):
      (JSC::::parseSwitchStatement):
      (JSC::::parseTryStatement):
      (JSC::::parseDebuggerStatement):
      (JSC::::parseBlockStatement):
      (JSC::::parseStatement):
      (JSC::::parseFunctionBody):
      (JSC::::parseFunctionInfo):
      (JSC::::parseFunctionDeclaration):
      (JSC::::parseExpressionOrLabelStatement):
      (JSC::::parseExpressionStatement):
      (JSC::::parseIfStatement):
      (JSC::::parseExpression):
      (JSC::::parseAssignmentExpression):
      (JSC::::parseConditionalExpression):
      (JSC::::parseBinaryExpression):
      (JSC::::parseProperty):
      (JSC::::parseObjectLiteral):
      (JSC::::parseStrictObjectLiteral):
      (JSC::::parseArrayLiteral):
      (JSC::::parsePrimaryExpression):
      (JSC::::parseArguments):
      (JSC::::parseMemberExpression):
      (JSC::::parseUnaryExpression):
      * parser/Parser.h:
      (JSC::Parser::next):
      (JSC::Parser::nextExpectIdentifier):
      (JSC::Parser::tokenStart):
      (JSC::Parser::tokenLine):
      (JSC::Parser::tokenEnd):
      (JSC::Parser::getTokenName):
      (JSC::::parse):
      * parser/ParserTokens.h:
      (JSC::JSTokenInfo::JSTokenInfo):
      (JSTokenInfo):
      (JSToken):
      * parser/SourceProviderCacheItem.h:
      (JSC::SourceProviderCacheItem::closeBraceToken):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::makeFunctionCallNode):
      (JSC::SyntaxChecker::createCommaExpr):
      (JSC::SyntaxChecker::makeAssignNode):
      (JSC::SyntaxChecker::makePrefixNode):
      (JSC::SyntaxChecker::makePostfixNode):
      (JSC::SyntaxChecker::makeTypeOfNode):
      (JSC::SyntaxChecker::makeDeleteNode):
      (JSC::SyntaxChecker::makeNegateNode):
      (JSC::SyntaxChecker::makeBitwiseNotNode):
      (JSC::SyntaxChecker::createLogicalNot):
      (JSC::SyntaxChecker::createUnaryPlus):
      (JSC::SyntaxChecker::createVoid):
      (JSC::SyntaxChecker::thisExpr):
      (JSC::SyntaxChecker::createResolve):
      (JSC::SyntaxChecker::createObjectLiteral):
      (JSC::SyntaxChecker::createArray):
      (JSC::SyntaxChecker::createNumberExpr):
      (JSC::SyntaxChecker::createString):
      (JSC::SyntaxChecker::createBoolean):
      (JSC::SyntaxChecker::createNull):
      (JSC::SyntaxChecker::createBracketAccess):
      (JSC::SyntaxChecker::createDotAccess):
      (JSC::SyntaxChecker::createRegExp):
      (JSC::SyntaxChecker::createNewExpr):
      (JSC::SyntaxChecker::createConditionalExpr):
      (JSC::SyntaxChecker::createAssignResolve):
      (JSC::SyntaxChecker::createFunctionExpr):
      (JSC::SyntaxChecker::createFunctionBody):
      (JSC::SyntaxChecker::createArgumentsList):
      (JSC::SyntaxChecker::createPropertyList):
      (JSC::SyntaxChecker::createFuncDeclStatement):
      (JSC::SyntaxChecker::createBlockStatement):
      (JSC::SyntaxChecker::createExprStatement):
      (JSC::SyntaxChecker::createIfStatement):
      (JSC::SyntaxChecker::createForLoop):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::createEmptyStatement):
      (JSC::SyntaxChecker::createVarStatement):
      (JSC::SyntaxChecker::createReturnStatement):
      (JSC::SyntaxChecker::createBreakStatement):
      (JSC::SyntaxChecker::createContinueStatement):
      (JSC::SyntaxChecker::createTryStatement):
      (JSC::SyntaxChecker::createSwitchStatement):
      (JSC::SyntaxChecker::createWhileStatement):
      (JSC::SyntaxChecker::createWithStatement):
      (JSC::SyntaxChecker::createDoWhileStatement):
      (JSC::SyntaxChecker::createLabelStatement):
      (JSC::SyntaxChecker::createThrowStatement):
      (JSC::SyntaxChecker::createDebugger):
      (JSC::SyntaxChecker::createConstStatement):
      (JSC::SyntaxChecker::appendConstDecl):
      (JSC::SyntaxChecker::createGetterOrSetterProperty):
      (JSC::SyntaxChecker::combineCommaNodes):
      (JSC::SyntaxChecker::operatorStackPop):
      
      Source/WebCore:
      
      * bindings/js/ScriptDebugServer.cpp:
      (WebCore::ScriptDebugServer::setBreakpoint):
      (WebCore::ScriptDebugServer::removeBreakpoint):
      (WebCore::ScriptDebugServer::hasBreakpoint):
      (WebCore::ScriptDebugServer::createCallFrameAndPauseIfNeeded):
      (WebCore::ScriptDebugServer::updateCallFrameAndPauseIfNeeded):
      (WebCore::ScriptDebugServer::callEvent):
      (WebCore::ScriptDebugServer::atStatement):
      (WebCore::ScriptDebugServer::returnEvent):
      (WebCore::ScriptDebugServer::exception):
      (WebCore::ScriptDebugServer::willExecuteProgram):
      (WebCore::ScriptDebugServer::didExecuteProgram):
      (WebCore::ScriptDebugServer::didReachBreakpoint):
      * bindings/js/ScriptDebugServer.h:
      (ScriptDebugServer):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@124413 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      709de8fe
  23. 01 Aug, 2012 1 commit
    • commit-queue@webkit.org's avatar
      Web Inspector: [JSC] implement setting breakpoints by line:column · 3772d07d
      commit-queue@webkit.org authored
      https://bugs.webkit.org/show_bug.cgi?id=53003
      
      Patch by Peter Wang <peter.wang@torchmobile.com.cn> on 2012-08-01
      Reviewed by Geoffrey Garen.
      
      Source/JavaScriptCore:
      
      Add a counter in lexer to record the column of each token. Debugger will use column info
      in "Pretty Print" debug mode of Inspector.
      
      * bytecode/Opcode.h:
      (JSC):
      (JSC::padOpcodeName):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitDebugHook):
      * bytecompiler/BytecodeGenerator.h:
      (BytecodeGenerator):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::toArgumentList):
      (JSC::ApplyFunctionCallDotNode::emitBytecode):
      (JSC::ConditionalNode::emitBytecode):
      (JSC::ConstStatementNode::emitBytecode):
      (JSC::EmptyStatementNode::emitBytecode):
      (JSC::DebuggerStatementNode::emitBytecode):
      (JSC::ExprStatementNode::emitBytecode):
      (JSC::VarStatementNode::emitBytecode):
      (JSC::IfNode::emitBytecode):
      (JSC::IfElseNode::emitBytecode):
      (JSC::DoWhileNode::emitBytecode):
      (JSC::WhileNode::emitBytecode):
      (JSC::ForNode::emitBytecode):
      (JSC::ForInNode::emitBytecode):
      (JSC::ContinueNode::emitBytecode):
      (JSC::BreakNode::emitBytecode):
      (JSC::ReturnNode::emitBytecode):
      (JSC::WithNode::emitBytecode):
      (JSC::SwitchNode::emitBytecode):
      (JSC::LabelNode::emitBytecode):
      (JSC::ThrowNode::emitBytecode):
      (JSC::TryNode::emitBytecode):
      (JSC::ProgramNode::emitBytecode):
      (JSC::EvalNode::emitBytecode):
      (JSC::FunctionBodyNode::emitBytecode):
      * debugger/Debugger.h:
      * interpreter/Interpreter.cpp:
      (JSC::Interpreter::unwindCallFrame):
      (JSC::Interpreter::throwException):
      (JSC::Interpreter::debug):
      * interpreter/Interpreter.h:
      (Interpreter):
      * jit/JITOpcodes.cpp:
      (JSC::JIT::emit_op_debug):
      * jit/JITOpcodes32_64.cpp:
      (JSC::JIT::emit_op_debug):
      * jit/JITStubs.cpp:
      (JSC::DEFINE_STUB_FUNCTION):
      * llint/LLIntSlowPaths.cpp:
      (JSC::LLInt::LLINT_SLOW_PATH_DECL):
      * parser/ASTBuilder.h:
      (ASTBuilder):
      (JSC::ASTBuilder::createCommaExpr):
      (JSC::ASTBuilder::createLogicalNot):
      (JSC::ASTBuilder::createUnaryPlus):
      (JSC::ASTBuilder::createVoid):
      (JSC::ASTBuilder::thisExpr):
      (JSC::ASTBuilder::createResolve):
      (JSC::ASTBuilder::createObjectLiteral):
      (JSC::ASTBuilder::createArray):
      (JSC::ASTBuilder::createNumberExpr):
      (JSC::ASTBuilder::createString):
      (JSC::ASTBuilder::createBoolean):
      (JSC::ASTBuilder::createNull):
      (JSC::ASTBuilder::createBracketAccess):
      (JSC::ASTBuilder::createDotAccess):
      (JSC::ASTBuilder::createRegExp):
      (JSC::ASTBuilder::createNewExpr):
      (JSC::ASTBuilder::createConditionalExpr):
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createFunctionExpr):
      (JSC::ASTBuilder::createFunctionBody):
      (JSC::ASTBuilder::createGetterOrSetterProperty):
      (JSC::ASTBuilder::createArgumentsList):
      (JSC::ASTBuilder::createPropertyList):
      (JSC::ASTBuilder::createFuncDeclStatement):
      (JSC::ASTBuilder::createBlockStatement):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createIfStatement):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createEmptyStatement):
      (JSC::ASTBuilder::createVarStatement):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createTryStatement):
      (JSC::ASTBuilder::createSwitchStatement):
      (JSC::ASTBuilder::createWhileStatement):
      (JSC::ASTBuilder::createDoWhileStatement):
      (JSC::ASTBuilder::createLabelStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::createDebugger):
      (JSC::ASTBuilder::createConstStatement):
      (JSC::ASTBuilder::appendConstDecl):
      (JSC::ASTBuilder::combineCommaNodes):
      (JSC::ASTBuilder::appendBinaryOperation):
      (JSC::ASTBuilder::createAssignment):
      (JSC::ASTBuilder::createNumber):
      (JSC::ASTBuilder::makeTypeOfNode):
      (JSC::ASTBuilder::makeDeleteNode):
      (JSC::ASTBuilder::makeNegateNode):
      (JSC::ASTBuilder::makeBitwiseNotNode):
      (JSC::ASTBuilder::makeMultNode):
      (JSC::ASTBuilder::makeDivNode):
      (JSC::ASTBuilder::makeModNode):
      (JSC::ASTBuilder::makeAddNode):
      (JSC::ASTBuilder::makeSubNode):
      (JSC::ASTBuilder::makeLeftShiftNode):
      (JSC::ASTBuilder::makeRightShiftNode):
      (JSC::ASTBuilder::makeURightShiftNode):
      (JSC::ASTBuilder::makeBitOrNode):
      (JSC::ASTBuilder::makeBitAndNode):
      (JSC::ASTBuilder::makeBitXOrNode):
      (JSC::ASTBuilder::makeFunctionCallNode):
      (JSC::ASTBuilder::makeBinaryNode):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):
      * parser/Lexer.cpp:
      (JSC::::setCode):
      (JSC::::internalShift):
      (JSC::::shift):
      (JSC::::lex):
      * parser/Lexer.h:
      (Lexer):
      (JSC::Lexer::currentColumnNumber):
      (JSC::::lexExpectIdentifier):
      * parser/NodeConstructors.h:
      (JSC::Node::Node):
      (JSC::ExpressionNode::ExpressionNode):
      (JSC::StatementNode::StatementNode):
      (JSC::NullNode::NullNode):
      (JSC::BooleanNode::BooleanNode):
      (JSC::NumberNode::NumberNode):
      (JSC::StringNode::StringNode):
      (JSC::RegExpNode::RegExpNode):
      (JSC::ThisNode::ThisNode):
      (JSC::ResolveNode::ResolveNode):
      (JSC::ArrayNode::ArrayNode):
      (JSC::PropertyListNode::PropertyListNode):
      (JSC::ObjectLiteralNode::ObjectLiteralNode):
      (JSC::BracketAccessorNode::BracketAccessorNode):
      (JSC::DotAccessorNode::DotAccessorNode):
      (JSC::ArgumentListNode::ArgumentListNode):
      (JSC::NewExprNode::NewExprNode):
      (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
      (JSC::FunctionCallValueNode::FunctionCallValueNode):
      (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
      (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
      (JSC::FunctionCallDotNode::FunctionCallDotNode):
      (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
      (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
      (JSC::PrePostResolveNode::PrePostResolveNode):
      (JSC::PostfixResolveNode::PostfixResolveNode):
      (JSC::PostfixBracketNode::PostfixBracketNode):
      (JSC::PostfixDotNode::PostfixDotNode):
      (JSC::PostfixErrorNode::PostfixErrorNode):
      (JSC::DeleteResolveNode::DeleteResolveNode):
      (JSC::DeleteBracketNode::DeleteBracketNode):
      (JSC::DeleteDotNode::DeleteDotNode):
      (JSC::DeleteValueNode::DeleteValueNode):
      (JSC::VoidNode::VoidNode):
      (JSC::TypeOfResolveNode::TypeOfResolveNode):
      (JSC::TypeOfValueNode::TypeOfValueNode):
      (JSC::PrefixResolveNode::PrefixResolveNode):
      (JSC::PrefixBracketNode::PrefixBracketNode):
      (JSC::PrefixDotNode::PrefixDotNode):
      (JSC::PrefixErrorNode::PrefixErrorNode):
      (JSC::UnaryOpNode::UnaryOpNode):
      (JSC::UnaryPlusNode::UnaryPlusNode):
      (JSC::NegateNode::NegateNode):
      (JSC::BitwiseNotNode::BitwiseNotNode):
      (JSC::LogicalNotNode::LogicalNotNode):
      (JSC::BinaryOpNode::BinaryOpNode):
      (JSC::MultNode::MultNode):
      (JSC::DivNode::DivNode):
      (JSC::ModNode::ModNode):
      (JSC::AddNode::AddNode):
      (JSC::SubNode::SubNode):
      (JSC::LeftShiftNode::LeftShiftNode):
      (JSC::RightShiftNode::RightShiftNode):
      (JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
      (JSC::LessNode::LessNode):
      (JSC::GreaterNode::GreaterNode):
      (JSC::LessEqNode::LessEqNode):
      (JSC::GreaterEqNode::GreaterEqNode):
      (JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
      (JSC::InstanceOfNode::InstanceOfNode):
      (JSC::InNode::InNode):
      (JSC::EqualNode::EqualNode):
      (JSC::NotEqualNode::NotEqualNode):
      (JSC::StrictEqualNode::StrictEqualNode):
      (JSC::NotStrictEqualNode::NotStrictEqualNode):
      (JSC::BitAndNode::BitAndNode):
      (JSC::BitOrNode::BitOrNode):
      (JSC::BitXOrNode::BitXOrNode):
      (JSC::LogicalOpNode::LogicalOpNode):
      (JSC::ConditionalNode::ConditionalNode):
      (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
      (JSC::AssignResolveNode::AssignResolveNode):
      (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
      (JSC::AssignBracketNode::AssignBracketNode):
      (JSC::AssignDotNode::AssignDotNode):
      (JSC::ReadModifyDotNode::ReadModifyDotNode):
      (JSC::AssignErrorNode::AssignErrorNode):
      (JSC::CommaNode::CommaNode):
      (JSC::ConstStatementNode::ConstStatementNode):
      (JSC::EmptyStatementNode::EmptyStatementNode):
      (JSC::DebuggerStatementNode::DebuggerStatementNode):
      (JSC::ExprStatementNode::ExprStatementNode):
      (JSC::VarStatementNode::VarStatementNode):
      (JSC::IfNode::IfNode):
      (JSC::IfElseNode::IfElseNode):
      (JSC::DoWhileNode::DoWhileNode):
      (JSC::WhileNode::WhileNode):
      (JSC::ForNode::ForNode):
      (JSC::ContinueNode::ContinueNode):
      (JSC::BreakNode::BreakNode):
      (JSC::ReturnNode::ReturnNode):
      (JSC::WithNode::WithNode):
      (JSC::LabelNode::LabelNode):
      (JSC::ThrowNode::ThrowNode):
      (JSC::TryNode::TryNode):
      (JSC::FuncExprNode::FuncExprNode):
      (JSC::FuncDeclNode::FuncDeclNode):
      (JSC::SwitchNode::SwitchNode):
      (JSC::ConstDeclNode::ConstDeclNode):
      (JSC::BlockNode::BlockNode):
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.cpp:
      (JSC::StatementNode::setLoc):
      (JSC):
      (JSC::ScopeNode::ScopeNode):
      (JSC::ProgramNode::ProgramNode):
      (JSC::ProgramNode::create):
      (JSC::EvalNode::EvalNode):
      (JSC::EvalNode::create):
      (JSC::FunctionBodyNode::FunctionBodyNode):
      (JSC::FunctionBodyNode::create):
      * parser/Nodes.h:
      (Node):
      (JSC::Node::columnNo):
      (ExpressionNode):
      (StatementNode):
      (JSC::StatementNode::column):
      (NullNode):
      (BooleanNode):
      (NumberNode):
      (StringNode):
      (RegExpNode):
      (ThisNode):
      (ResolveNode):
      (ArrayNode):
      (PropertyListNode):
      (ObjectLiteralNode):
      (BracketAccessorNode):
      (DotAccessorNode):
      (ArgumentListNode):
      (NewExprNode):
      (EvalFunctionCallNode):
      (FunctionCallValueNode):
      (FunctionCallResolveNode):
      (FunctionCallBracketNode):
      (FunctionCallDotNode):
      (CallFunctionCallDotNode):
      (ApplyFunctionCallDotNode):
      (PrePostResolveNode):
      (PostfixResolveNode):
      (PostfixBracketNode):
      (PostfixDotNode):
      (PostfixErrorNode):
      (DeleteResolveNode):
      (DeleteBracketNode):
      (DeleteDotNode):
      (DeleteValueNode):
      (VoidNode):
      (TypeOfResolveNode):
      (TypeOfValueNode):
      (PrefixResolveNode):
      (PrefixBracketNode):
      (PrefixDotNode):
      (PrefixErrorNode):
      (UnaryOpNode):
      (UnaryPlusNode):
      (NegateNode):
      (BitwiseNotNode):
      (LogicalNotNode):
      (BinaryOpNode):
      (MultNode):
      (DivNode):
      (ModNode):
      (AddNode):
      (SubNode):
      (LeftShiftNode):
      (RightShiftNode):
      (UnsignedRightShiftNode):
      (LessNode):
      (GreaterNode):
      (LessEqNode):
      (GreaterEqNode):
      (ThrowableBinaryOpNode):
      (InstanceOfNode):
      (InNode):
      (EqualNode):
      (NotEqualNode):
      (StrictEqualNode):
      (NotStrictEqualNode):
      (BitAndNode):
      (BitOrNode):
      (BitXOrNode):
      (LogicalOpNode):
      (ConditionalNode):
      (ReadModifyResolveNode):
      (AssignResolveNode):
      (ReadModifyBracketNode):
      (AssignBracketNode):
      (AssignDotNode):
      (ReadModifyDotNode):
      (AssignErrorNode):
      (CommaNode):
      (ConstDeclNode):
      (ConstStatementNode):
      (BlockNode):
      (EmptyStatementNode):
      (DebuggerStatementNode):
      (ExprStatementNode):
      (VarStatementNode):
      (IfNode):
      (IfElseNode):
      (DoWhileNode):
      (WhileNode):
      (ForNode):
      (ForInNode):
      (ContinueNode):
      (BreakNode):
      (ReturnNode):
      (WithNode):
      (LabelNode):
      (ThrowNode):
      (TryNode):
      (ScopeNode):
      (ProgramNode):
      (EvalNode):
      (FunctionBodyNode):
      (FuncExprNode):
      (FuncDeclNode):
      (SwitchNode):
      * parser/Parser.cpp:
      (JSC::::parseSourceElements):
      (JSC::::parseVarDeclaration):
      (JSC::::parseConstDeclaration):
      (JSC::::parseDoWhileStatement):
      (JSC::::parseWhileStatement):
      (JSC::::parseVarDeclarationList):
      (JSC::::parseConstDeclarationList):
      (JSC::::parseForStatement):
      (JSC::::parseBreakStatement):
      (JSC::::parseContinueStatement):
      (JSC::::parseReturnStatement):
      (JSC::::parseThrowStatement):
      (JSC::::parseWithStatement):
      (JSC::::parseSwitchStatement):
      (JSC::::parseTryStatement):
      (JSC::::parseDebuggerStatement):
      (JSC::::parseBlockStatement):
      (JSC::::parseStatement):
      (JSC::::parseFunctionBody):
      (JSC::::parseFunctionInfo):
      (JSC::::parseFunctionDeclaration):
      (JSC::::parseExpressionOrLabelStatement):
      (JSC::::parseExpressionStatement):
      (JSC::::parseIfStatement):
      (JSC::::parseExpression):
      (JSC::::parseAssignmentExpression):
      (JSC::::parseConditionalExpression):
      (JSC::::parseBinaryExpression):
      (JSC::::parseProperty):
      (JSC::::parseObjectLiteral):
      (JSC::::parseStrictObjectLiteral):
      (JSC::::parseArrayLiteral):
      (JSC::::parsePrimaryExpression):
      (JSC::::parseArguments):
      (JSC::::parseMemberExpression):
      (JSC::::parseUnaryExpression):
      * parser/Parser.h:
      (JSC::Parser::next):
      (JSC::Parser::nextExpectIdentifier):
      (JSC::Parser::tokenStart):
      (JSC::Parser::tokenLine):
      (JSC::Parser::tokenEnd):
      (JSC::Parser::tokenLocation):
      (Parser):
      (JSC::Parser::getTokenName):
      (JSC::::parse):
      * parser/ParserTokens.h:
      (JSC::JSTokenLocation::JSTokenLocation):
      (JSTokenLocation):
      (JSToken):
      * parser/SourceProviderCacheItem.h:
      (JSC::SourceProviderCacheItem::closeBraceToken):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::makeFunctionCallNode):
      (JSC::SyntaxChecker::createCommaExpr):
      (JSC::SyntaxChecker::makeAssignNode):
      (JSC::SyntaxChecker::makePrefixNode):
      (JSC::SyntaxChecker::makePostfixNode):
      (JSC::SyntaxChecker::makeTypeOfNode):
      (JSC::SyntaxChecker::makeDeleteNode):
      (JSC::SyntaxChecker::makeNegateNode):
      (JSC::SyntaxChecker::makeBitwiseNotNode):
      (JSC::SyntaxChecker::createLogicalNot):
      (JSC::SyntaxChecker::createUnaryPlus):
      (JSC::SyntaxChecker::createVoid):
      (JSC::SyntaxChecker::thisExpr):
      (JSC::SyntaxChecker::createResolve):
      (JSC::SyntaxChecker::createObjectLiteral):
      (JSC::SyntaxChecker::createArray):
      (JSC::SyntaxChecker::createNumberExpr):
      (JSC::SyntaxChecker::createString):
      (JSC::SyntaxChecker::createBoolean):
      (JSC::SyntaxChecker::createNull):
      (JSC::SyntaxChecker::createBracketAccess):
      (JSC::SyntaxChecker::createDotAccess):
      (JSC::SyntaxChecker::createRegExp):
      (JSC::SyntaxChecker::createNewExpr):
      (JSC::SyntaxChecker::createConditionalExpr):
      (JSC::SyntaxChecker::createAssignResolve):
      (JSC::SyntaxChecker::createFunctionExpr):
      (JSC::SyntaxChecker::createFunctionBody):
      (JSC::SyntaxChecker::createArgumentsList):
      (JSC::SyntaxChecker::createPropertyList):
      (JSC::SyntaxChecker::createFuncDeclStatement):
      (JSC::SyntaxChecker::createBlockStatement):
      (JSC::SyntaxChecker::createExprStatement):
      (JSC::SyntaxChecker::createIfStatement):
      (JSC::SyntaxChecker::createForLoop):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::createEmptyStatement):
      (JSC::SyntaxChecker::createVarStatement):
      (JSC::SyntaxChecker::createReturnStatement):
      (JSC::SyntaxChecker::createBreakStatement):
      (JSC::SyntaxChecker::createContinueStatement):
      (JSC::SyntaxChecker::createTryStatement):
      (JSC::SyntaxChecker::createSwitchStatement):
      (JSC::SyntaxChecker::createWhileStatement):
      (JSC::SyntaxChecker::createWithStatement):
      (JSC::SyntaxChecker::createDoWhileStatement):
      (JSC::SyntaxChecker::createLabelStatement):
      (JSC::SyntaxChecker::createThrowStatement):
      (JSC::SyntaxChecker::createDebugger):
      (JSC::SyntaxChecker::createConstStatement):
      (JSC::SyntaxChecker::appendConstDecl):
      (JSC::SyntaxChecker::createGetterOrSetterProperty):
      (JSC::SyntaxChecker::combineCommaNodes):
      (JSC::SyntaxChecker::operatorStackPop):
      
      Source/WebCore:
      
      As JSC is enabled to provide column info of statement, ScriptDebugServer can use it to
      support "Pretty Print" debug mode.
      
      No new test case for this patch.
      
      * bindings/js/ScriptDebugServer.cpp:
      (WebCore::ScriptDebugServer::setBreakpoint):
      (WebCore::ScriptDebugServer::removeBreakpoint):
      (WebCore):
      (WebCore::ScriptDebugServer::updateCurrentStatementPosition):
      (WebCore::ScriptDebugServer::hasBreakpoint):
      (WebCore::ScriptDebugServer::createCallFrameAndPauseIfNeeded):
      (WebCore::ScriptDebugServer::updateCallFrameAndPauseIfNeeded):
      (WebCore::ScriptDebugServer::callEvent):
      (WebCore::ScriptDebugServer::atStatement):
      (WebCore::ScriptDebugServer::returnEvent):
      (WebCore::ScriptDebugServer::exception):
      (WebCore::ScriptDebugServer::willExecuteProgram):
      (WebCore::ScriptDebugServer::didExecuteProgram):
      (WebCore::ScriptDebugServer::didReachBreakpoint):
      * bindings/js/ScriptDebugServer.h:
      (ScriptDebugServer):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@124406 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      3772d07d
  24. 06 Jul, 2012 1 commit
    • commit-queue@webkit.org's avatar
      Fix build with recent clang. · c182dfcd
      commit-queue@webkit.org authored
      https://bugs.webkit.org/show_bug.cgi?id=90634
      
      Patch by Nuno Lopes <nlopes@apple.com> on 2012-07-06
      Reviewed by Oliver Hunt.
      
      * jit/SpecializedThunkJIT.h:
      (JSC::SpecializedThunkJIT::SpecializedThunkJIT):
      (SpecializedThunkJIT):
      * jit/ThunkGenerators.cpp:
      (JSC::charCodeAtThunkGenerator):
      (JSC::charAtThunkGenerator):
      (JSC::fromCharCodeThunkGenerator):
      (JSC::sqrtThunkGenerator):
      (JSC::floorThunkGenerator):
      (JSC::ceilThunkGenerator):
      (JSC::roundThunkGenerator):
      (JSC::expThunkGenerator):
      (JSC::logThunkGenerator):
      (JSC::absThunkGenerator):
      (JSC::powThunkGenerator):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):
      * parser/NodeConstructors.h:
      (JSC::PostfixErrorNode::PostfixErrorNode):
      (JSC::PrefixErrorNode::PrefixErrorNode):
      (JSC::AssignResolveNode::AssignResolveNode):
      (JSC::AssignErrorNode::AssignErrorNode):
      (JSC::ForNode::ForNode):
      (JSC::ForInNode::ForInNode):
      * parser/Nodes.h:
      (FunctionCallResolveNode):
      (PostfixErrorNode):
      (PrefixErrorNode):
      (ReadModifyResolveNode):
      (AssignResolveNode):
      (AssignErrorNode):
      (ForNode):
      (ForInNode):
      * parser/Parser.cpp:
      (JSC::::parseVarDeclarationList):
      (JSC::::parseForStatement):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::createAssignResolve):
      (JSC::SyntaxChecker::createForLoop):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@121986 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      c182dfcd
  25. 27 Feb, 2012 1 commit
    • barraclough@apple.com's avatar
      Implement support for op_negate and op_bitnot in the DFG JIT · a6bdfc82
      barraclough@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=79617
      
      Reviewed by Sam Weinig.
      
      Remove op_bitnop - this is redundant, ~x === x^-1.
      This is a fractional (<1%) progression.
      
      Remove not32(X) from the MacroAssemblers - make this an optimization to add32(-1, X).
      Remove CanReuse from the result type - this was unused.
      Remove op_bitnot.
      
      * assembler/MacroAssemblerARM.h:
      (MacroAssemblerARM):
      (JSC::MacroAssemblerARM::xor32):
      * assembler/MacroAssemblerARMv7.h:
      (MacroAssemblerARMv7):
      (JSC::MacroAssemblerARMv7::xor32):
      * assembler/MacroAssemblerMIPS.h:
      (MacroAssemblerMIPS):
      (JSC::MacroAssemblerMIPS::xor32):
      * assembler/MacroAssemblerSH4.h:
      (MacroAssemblerSH4):
      (JSC::MacroAssemblerSH4::xor32):
      * assembler/MacroAssemblerX86Common.h:
      (MacroAssemblerX86Common):
      (JSC::MacroAssemblerX86Common::xor32):
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::dump):
      * bytecode/Opcode.h:
      (JSC):
      (JSC::padOpcodeName):
      * bytecompiler/NodesCodegen.cpp:
      (JSC):
      (JSC::BitwiseNotNode::emitBytecode):
      * interpreter/Interpreter.cpp:
      (JSC::Interpreter::privateExecute):
      * jit/JIT.cpp:
      (JSC::JIT::privateCompileMainPass):
      (JSC::JIT::privateCompileSlowCases):
      * jit/JIT.h:
      (JIT):
      * jit/JITArithmetic32_64.cpp:
      (JSC):
      * jit/JITOpcodes.cpp:
      (JSC):
      * jit/JITStubs.cpp:
      (JSC):
      * jit/JITStubs.h:
      * llint/LLIntSlowPaths.cpp:
      (LLInt):
      * llint/LLIntSlowPaths.h:
      (LLInt):
      * llint/LowLevelInterpreter32_64.asm:
      * parser/NodeConstructors.h:
      (JSC::NegateNode::NegateNode):
      (JSC::BitwiseNotNode::BitwiseNotNode):
      (JSC::MultNode::MultNode):
      (JSC::DivNode::DivNode):
      (JSC::ModNode::ModNode):
      (JSC::SubNode::SubNode):
      (JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
      * parser/Nodes.h:
      (BitwiseNotNode):
      (JSC::BitwiseNotNode::expr):
      (JSC):
      * parser/ResultType.h:
      (ResultType):
      (JSC::ResultType::numberTypeIsInt32):
      (JSC::ResultType::stringOrNumberType):
      (JSC::ResultType::forAdd):
      (JSC::ResultType::forBitOp):
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@109007 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      a6bdfc82
  26. 01 Feb, 2012 1 commit
  27. 31 Oct, 2011 1 commit
    • msaboff@apple.com's avatar
      Towards 8-bit Strings: Move Lexer and Parser Objects out of JSGlobalData · 2e5003e8
      msaboff@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=71138
      
      Restructure and movement of Lexer and Parser code.
      Moved Lexer and Parser objects out of JSGlobalData.
      Added a new ParserTokens class and instance to JSGlobalData that
      have JavaScript token related definitions.
      Replaced JSGlobalData arguments to Node classes with lineNumber,
      as that was the only use of the JSGlobalData.
      Combined JSParser and Parser classes into one class,
      eliminating JSParser.h and .cpp.
      Various supporting #include changes.
      
      These mostly mechanical changes are done in preparation to
      making the Lexer and Parser template classes.
      
      Reviewed by Darin Adler.
      
      * CMakeLists.txt:
      * GNUmakefile.list.am:
      * JavaScriptCore.gypi:
      * JavaScriptCore.pro:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
      * JavaScriptCore.xcodeproj/project.pbxproj:
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ArrayNode::toArgumentList):
      (JSC::ApplyFunctionCallDotNode::emitBytecode):
      * parser/ASTBuilder.h:
      (JSC::ASTBuilder::ASTBuilder):
      (JSC::ASTBuilder::createSourceElements):
      (JSC::ASTBuilder::createCommaExpr):
      (JSC::ASTBuilder::createLogicalNot):
      (JSC::ASTBuilder::createUnaryPlus):
      (JSC::ASTBuilder::createVoid):
      (JSC::ASTBuilder::thisExpr):
      (JSC::ASTBuilder::createResolve):
      (JSC::ASTBuilder::createObjectLiteral):
      (JSC::ASTBuilder::createArray):
      (JSC::ASTBuilder::createNumberExpr):
      (JSC::ASTBuilder::createString):
      (JSC::ASTBuilder::createBoolean):
      (JSC::ASTBuilder::createNull):
      (JSC::ASTBuilder::createBracketAccess):
      (JSC::ASTBuilder::createDotAccess):
      (JSC::ASTBuilder::createRegExp):
      (JSC::ASTBuilder::createNewExpr):
      (JSC::ASTBuilder::createConditionalExpr):
      (JSC::ASTBuilder::createAssignResolve):
      (JSC::ASTBuilder::createFunctionExpr):
      (JSC::ASTBuilder::createFunctionBody):
      (JSC::ASTBuilder::createGetterOrSetterProperty):
      (JSC::ASTBuilder::createArguments):
      (JSC::ASTBuilder::createArgumentsList):
      (JSC::ASTBuilder::createPropertyList):
      (JSC::ASTBuilder::createElementList):
      (JSC::ASTBuilder::createFormalParameterList):
      (JSC::ASTBuilder::createClause):
      (JSC::ASTBuilder::createClauseList):
      (JSC::ASTBuilder::createFuncDeclStatement):
      (JSC::ASTBuilder::createBlockStatement):
      (JSC::ASTBuilder::createExprStatement):
      (JSC::ASTBuilder::createIfStatement):
      (JSC::ASTBuilder::createForLoop):
      (JSC::ASTBuilder::createForInLoop):
      (JSC::ASTBuilder::createEmptyStatement):
      (JSC::ASTBuilder::createVarStatement):
      (JSC::ASTBuilder::createReturnStatement):
      (JSC::ASTBuilder::createBreakStatement):
      (JSC::ASTBuilder::createContinueStatement):
      (JSC::ASTBuilder::createTryStatement):
      (JSC::ASTBuilder::createSwitchStatement):
      (JSC::ASTBuilder::createWhileStatement):
      (JSC::ASTBuilder::createDoWhileStatement):
      (JSC::ASTBuilder::createLabelStatement):
      (JSC::ASTBuilder::createWithStatement):
      (JSC::ASTBuilder::createThrowStatement):
      (JSC::ASTBuilder::createDebugger):
      (JSC::ASTBuilder::createConstStatement):
      (JSC::ASTBuilder::appendConstDecl):
      (JSC::ASTBuilder::combineCommaNodes):
      (JSC::ASTBuilder::appendBinaryOperation):
      (JSC::ASTBuilder::createAssignment):
      (JSC::ASTBuilder::createNumber):
      (JSC::ASTBuilder::makeTypeOfNode):
      (JSC::ASTBuilder::makeDeleteNode):
      (JSC::ASTBuilder::makeNegateNode):
      (JSC::ASTBuilder::makeBitwiseNotNode):
      (JSC::ASTBuilder::makeMultNode):
      (JSC::ASTBuilder::makeDivNode):
      (JSC::ASTBuilder::makeModNode):
      (JSC::ASTBuilder::makeAddNode):
      (JSC::ASTBuilder::makeSubNode):
      (JSC::ASTBuilder::makeLeftShiftNode):
      (JSC::ASTBuilder::makeRightShiftNode):
      (JSC::ASTBuilder::makeURightShiftNode):
      (JSC::ASTBuilder::makeBitOrNode):
      (JSC::ASTBuilder::makeBitAndNode):
      (JSC::ASTBuilder::makeBitXOrNode):
      (JSC::ASTBuilder::makeFunctionCallNode):
      (JSC::ASTBuilder::makeBinaryNode):
      (JSC::ASTBuilder::makeAssignNode):
      (JSC::ASTBuilder::makePrefixNode):
      (JSC::ASTBuilder::makePostfixNode):
      * parser/JSParser.cpp: Removed.
      * parser/JSParser.h: Removed.
      * parser/Lexer.cpp:
      (JSC::Keywords::Keywords):
      (JSC::Lexer::Lexer):
      (JSC::Lexer::~Lexer):
      (JSC::Lexer::setCode):
      (JSC::Lexer::parseIdentifier):
      * parser/Lexer.h:
      (JSC::Keywords::isKeyword):
      (JSC::Keywords::getKeyword):
      (JSC::Keywords::~Keywords):
      (JSC::Lexer::setIsReparsing):
      (JSC::Lexer::isReparsing):
      (JSC::Lexer::lineNumber):
      (JSC::Lexer::setLastLineNumber):
      (JSC::Lexer::lastLineNumber):
      (JSC::Lexer::prevTerminator):
      (JSC::Lexer::sawError):
      (JSC::Lexer::getErrorMessage):
      (JSC::Lexer::currentOffset):
      (JSC::Lexer::setOffset):
      (JSC::Lexer::setLineNumber):
      (JSC::Lexer::sourceProvider):
      (JSC::Lexer::isWhiteSpace):
      (JSC::Lexer::isLineTerminator):
      (JSC::Lexer::convertHex):
      (JSC::Lexer::convertUnicode):
      (JSC::Lexer::makeIdentifier):
      (JSC::Lexer::lexExpectIdentifier):
      * parser/NodeConstructors.h:
      (JSC::ParserArenaFreeable::operator new):
      (JSC::ParserArenaDeletable::operator new):
      (JSC::ParserArenaRefCounted::ParserArenaRefCounted):
      (JSC::Node::Node):
      (JSC::ExpressionNode::ExpressionNode):
      (JSC::StatementNode::StatementNode):
      (JSC::NullNode::NullNode):
      (JSC::BooleanNode::BooleanNode):
      (JSC::NumberNode::NumberNode):
      (JSC::StringNode::StringNode):
      (JSC::RegExpNode::RegExpNode):
      (JSC::ThisNode::ThisNode):
      (JSC::ResolveNode::ResolveNode):
      (JSC::ElementNode::ElementNode):
      (JSC::ArrayNode::ArrayNode):
      (JSC::PropertyNode::PropertyNode):
      (JSC::PropertyListNode::PropertyListNode):
      (JSC::ObjectLiteralNode::ObjectLiteralNode):
      (JSC::BracketAccessorNode::BracketAccessorNode):
      (JSC::DotAccessorNode::DotAccessorNode):
      (JSC::ArgumentListNode::ArgumentListNode):
      (JSC::ArgumentsNode::ArgumentsNode):
      (JSC::NewExprNode::NewExprNode):
      (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
      (JSC::FunctionCallValueNode::FunctionCallValueNode):
      (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
      (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
      (JSC::FunctionCallDotNode::FunctionCallDotNode):
      (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
      (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
      (JSC::PrePostResolveNode::PrePostResolveNode):
      (JSC::PostfixResolveNode::PostfixResolveNode):
      (JSC::PostfixBracketNode::PostfixBracketNode):
      (JSC::PostfixDotNode::PostfixDotNode):
      (JSC::PostfixErrorNode::PostfixErrorNode):
      (JSC::DeleteResolveNode::DeleteResolveNode):
      (JSC::DeleteBracketNode::DeleteBracketNode):
      (JSC::DeleteDotNode::DeleteDotNode):
      (JSC::DeleteValueNode::DeleteValueNode):
      (JSC::VoidNode::VoidNode):
      (JSC::TypeOfResolveNode::TypeOfResolveNode):
      (JSC::TypeOfValueNode::TypeOfValueNode):
      (JSC::PrefixResolveNode::PrefixResolveNode):
      (JSC::PrefixBracketNode::PrefixBracketNode):
      (JSC::PrefixDotNode::PrefixDotNode):
      (JSC::PrefixErrorNode::PrefixErrorNode):
      (JSC::UnaryOpNode::UnaryOpNode):
      (JSC::UnaryPlusNode::UnaryPlusNode):
      (JSC::NegateNode::NegateNode):
      (JSC::BitwiseNotNode::BitwiseNotNode):
      (JSC::LogicalNotNode::LogicalNotNode):
      (JSC::BinaryOpNode::BinaryOpNode):
      (JSC::MultNode::MultNode):
      (JSC::DivNode::DivNode):
      (JSC::ModNode::ModNode):
      (JSC::AddNode::AddNode):
      (JSC::SubNode::SubNode):
      (JSC::LeftShiftNode::LeftShiftNode):
      (JSC::RightShiftNode::RightShiftNode):
      (JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
      (JSC::LessNode::LessNode):
      (JSC::GreaterNode::GreaterNode):
      (JSC::LessEqNode::LessEqNode):
      (JSC::GreaterEqNode::GreaterEqNode):
      (JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
      (JSC::InstanceOfNode::InstanceOfNode):
      (JSC::InNode::InNode):
      (JSC::EqualNode::EqualNode):
      (JSC::NotEqualNode::NotEqualNode):
      (JSC::StrictEqualNode::StrictEqualNode):
      (JSC::NotStrictEqualNode::NotStrictEqualNode):
      (JSC::BitAndNode::BitAndNode):
      (JSC::BitOrNode::BitOrNode):
      (JSC::BitXOrNode::BitXOrNode):
      (JSC::LogicalOpNode::LogicalOpNode):
      (JSC::ConditionalNode::ConditionalNode):
      (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
      (JSC::AssignResolveNode::AssignResolveNode):
      (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
      (JSC::AssignBracketNode::AssignBracketNode):
      (JSC::AssignDotNode::AssignDotNode):
      (JSC::ReadModifyDotNode::ReadModifyDotNode):
      (JSC::AssignErrorNode::AssignErrorNode):
      (JSC::CommaNode::CommaNode):
      (JSC::ConstStatementNode::ConstStatementNode):
      (JSC::SourceElements::SourceElements):
      (JSC::EmptyStatementNode::EmptyStatementNode):
      (JSC::DebuggerStatementNode::DebuggerStatementNode):
      (JSC::ExprStatementNode::ExprStatementNode):
      (JSC::VarStatementNode::VarStatementNode):
      (JSC::IfNode::IfNode):
      (JSC::IfElseNode::IfElseNode):
      (JSC::DoWhileNode::DoWhileNode):
      (JSC::WhileNode::WhileNode):
      (JSC::ForNode::ForNode):
      (JSC::ContinueNode::ContinueNode):
      (JSC::BreakNode::BreakNode):
      (JSC::ReturnNode::ReturnNode):
      (JSC::WithNode::WithNode):
      (JSC::LabelNode::LabelNode):
      (JSC::ThrowNode::ThrowNode):
      (JSC::TryNode::TryNode):
      (JSC::ParameterNode::ParameterNode):
      (JSC::FuncExprNode::FuncExprNode):
      (JSC::FuncDeclNode::FuncDeclNode):
      (JSC::CaseClauseNode::CaseClauseNode):
      (JSC::ClauseListNode::ClauseListNode):
      (JSC::CaseBlockNode::CaseBlockNode):
      (JSC::SwitchNode::SwitchNode):
      (JSC::ConstDeclNode::ConstDeclNode):
      (JSC::BlockNode::BlockNode):
      (JSC::ForInNode::ForInNode):
      * parser/NodeInfo.h:
      * parser/Nodes.cpp:
      (JSC::StatementNode::setLoc):
      (JSC::ScopeNode::ScopeNode):
      (JSC::ProgramNode::ProgramNode):
      (JSC::ProgramNode::create):
      (JSC::EvalNode::EvalNode):
      (JSC::EvalNode::create):
      (JSC::FunctionBodyNode::FunctionBodyNode):
      (JSC::FunctionBodyNode::create):
      * parser/Nodes.h:
      (JSC::Node::lineNo):
      * parser/Parser.cpp:
      (JSC::Parser::Parser):
      (JSC::Parser::~Parser):
      (JSC::Parser::parseInner):
      (JSC::Parser::allowAutomaticSemicolon):
      (JSC::Parser::parseSourceElements):
      (JSC::Parser::parseVarDeclaration):
      (JSC::Parser::parseConstDeclaration):
      (JSC::Parser::parseDoWhileStatement):
      (JSC::Parser::parseWhileStatement):
      (JSC::Parser::parseVarDeclarationList):
      (JSC::Parser::parseConstDeclarationList):
      (JSC::Parser::parseForStatement):
      (JSC::Parser::parseBreakStatement):
      (JSC::Parser::parseContinueStatement):
      (JSC::Parser::parseReturnStatement):
      (JSC::Parser::parseThrowStatement):
      (JSC::Parser::parseWithStatement):
      (JSC::Parser::parseSwitchStatement):
      (JSC::Parser::parseSwitchClauses):
      (JSC::Parser::parseSwitchDefaultClause):
      (JSC::Parser::parseTryStatement):
      (JSC::Parser::parseDebuggerStatement):
      (JSC::Parser::parseBlockStatement):
      (JSC::Parser::parseStatement):
      (JSC::Parser::parseFormalParameters):
      (JSC::Parser::parseFunctionBody):
      (JSC::Parser::parseFunctionInfo):
      (JSC::Parser::parseFunctionDeclaration):
      (JSC::LabelInfo::LabelInfo):
      (JSC::Parser::parseExpressionOrLabelStatement):
      (JSC::Parser::parseExpressionStatement):
      (JSC::Parser::parseIfStatement):
      (JSC::Parser::parseExpression):
      (JSC::Parser::parseAssignmentExpression):
      (JSC::Parser::parseConditionalExpression):
      (JSC::isUnaryOp):
      (JSC::Parser::isBinaryOperator):
      (JSC::Parser::parseBinaryExpression):
      (JSC::Parser::parseProperty):
      (JSC::Parser::parseObjectLiteral):
      (JSC::Parser::parseStrictObjectLiteral):
      (JSC::Parser::parseArrayLiteral):
      (JSC::Parser::parsePrimaryExpression):
      (JSC::Parser::parseArguments):
      (JSC::Parser::parseMemberExpression):
      (JSC::Parser::parseUnaryExpression):
      * parser/Parser.h:
      (JSC::isEvalNode):
      (JSC::EvalNode):
      (JSC::DepthManager::DepthManager):
      (JSC::DepthManager::~DepthManager):
      (JSC::ScopeLabelInfo::ScopeLabelInfo):
      (JSC::Scope::Scope):
      (JSC::Scope::startSwitch):
      (JSC::Scope::endSwitch):
      (JSC::Scope::startLoop):
      (JSC::Scope::endLoop):
      (JSC::Scope::inLoop):
      (JSC::Scope::breakIsValid):
      (JSC::Scope::continueIsValid):
      (JSC::Scope::pushLabel):
      (JSC::Scope::popLabel):
      (JSC::Scope::getLabel):
      (JSC::Scope::setIsFunction):
      (JSC::Scope::isFunction):
      (JSC::Scope::isFunctionBoundary):
      (JSC::Scope::declareVariable):
      (JSC::Scope::declareWrite):
      (JSC::Scope::preventNewDecls):
      (JSC::Scope::allowsNewDecls):
      (JSC::Scope::declareParameter):
      (JSC::Scope::useVariable):
      (JSC::Scope::setNeedsFullActivation):
      (JSC::Scope::collectFreeVariables):
      (JSC::Scope::getUncapturedWrittenVariables):
      (JSC::Scope::getCapturedVariables):
      (JSC::Scope::setStrictMode):
      (JSC::Scope::strictMode):
      (JSC::Scope::isValidStrictMode):
      (JSC::Scope::shadowsArguments):
      (JSC::Scope::copyCapturedVariablesToVector):
      (JSC::Scope::saveFunctionInfo):
      (JSC::Scope::restoreFunctionInfo):
      (JSC::ScopeRef::ScopeRef):
      (JSC::ScopeRef::operator->):
      (JSC::ScopeRef::index):
      (JSC::ScopeRef::hasContainingScope):
      (JSC::ScopeRef::containingScope):
      (JSC::Parser::AllowInOverride::AllowInOverride):
      (JSC::Parser::AllowInOverride::~AllowInOverride):
      (JSC::Parser::AutoPopScopeRef::AutoPopScopeRef):
      (JSC::Parser::AutoPopScopeRef::~AutoPopScopeRef):
      (JSC::Parser::AutoPopScopeRef::setPopped):
      (JSC::Parser::currentScope):
      (JSC::Parser::pushScope):
      (JSC::Parser::popScopeInternal):
      (JSC::Parser::popScope):
      (JSC::Parser::declareVariable):
      (JSC::Parser::declareWrite):
      (JSC::Parser::findCachedFunctionInfo):
      (JSC::Parser::isFunctionBodyNode):
      (JSC::Parser::next):
      (JSC::Parser::nextExpectIdentifier):
      (JSC::Parser::nextTokenIsColon):
      (JSC::Parser::consume):
      (JSC::Parser::getToken):
      (JSC::Parser::match):
      (JSC::Parser::tokenStart):
      (JSC::Parser::tokenLine):
      (JSC::Parser::tokenEnd):
      (JSC::Parser::getTokenName):
      (JSC::Parser::updateErrorMessageSpecialCase):
      (JSC::Parser::updateErrorMessage):
      (JSC::Parser::updateErrorWithNameAndMessage):
      (JSC::Parser::startLoop):
      (JSC::Parser::endLoop):
      (JSC::Parser::startSwitch):
      (JSC::Parser::endSwitch):
      (JSC::Parser::setStrictMode):
      (JSC::Parser::strictMode):
      (JSC::Parser::isValidStrictMode):
      (JSC::Parser::declareParameter):
      (JSC::Parser::breakIsValid):
      (JSC::Parser::continueIsValid):
      (JSC::Parser::pushLabel):
      (JSC::Parser::popLabel):
      (JSC::Parser::getLabel):
      (JSC::Parser::autoSemiColon):
      (JSC::Parser::canRecurse):
      (JSC::Parser::lastTokenEnd):
      (JSC::Parser::DepthManager::DepthManager):
      (JSC::Parser::DepthManager::~DepthManager):
      (JSC::Parser::parse):
      (JSC::parse):
      * parser/ParserTokens.h: Added.
      (JSC::JSTokenInfo::JSTokenInfo):
      * parser/SourceCode.h:
      (JSC::SourceCode::subExpression):
      * parser/SourceProviderCacheItem.h:
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::SyntaxChecker):
      (JSC::SyntaxChecker::makeFunctionCallNode):
      (JSC::SyntaxChecker::createCommaExpr):
      (JSC::SyntaxChecker::makeAssignNode):
      (JSC::SyntaxChecker::makePrefixNode):
      (JSC::SyntaxChecker::makePostfixNode):
      (JSC::SyntaxChecker::makeTypeOfNode):
      (JSC::SyntaxChecker::makeDeleteNode):
      (JSC::SyntaxChecker::makeNegateNode):
      (JSC::SyntaxChecker::makeBitwiseNotNode):
      (JSC::SyntaxChecker::createLogicalNot):
      (JSC::SyntaxChecker::createUnaryPlus):
      (JSC::SyntaxChecker::createVoid):
      (JSC::SyntaxChecker::thisExpr):
      (JSC::SyntaxChecker::createResolve):
      (JSC::SyntaxChecker::createObjectLiteral):
      (JSC::SyntaxChecker::createArray):
      (JSC::SyntaxChecker::createNumberExpr):
      (JSC::SyntaxChecker::createString):
      (JSC::SyntaxChecker::createBoolean):
      (JSC::SyntaxChecker::createNull):
      (JSC::SyntaxChecker::createBracketAccess):
      (JSC::SyntaxChecker::createDotAccess):
      (JSC::SyntaxChecker::createRegExp):
      (JSC::SyntaxChecker::createNewExpr):
      (JSC::SyntaxChecker::createConditionalExpr):
      (JSC::SyntaxChecker::createAssignResolve):
      (JSC::SyntaxChecker::createFunctionExpr):
      (JSC::SyntaxChecker::createFunctionBody):
      (JSC::SyntaxChecker::createArguments):
      (JSC::SyntaxChecker::createArgumentsList):
      (JSC::SyntaxChecker::createProperty):
      (JSC::SyntaxChecker::createPropertyList):
      (JSC::SyntaxChecker::createFuncDeclStatement):
      (JSC::SyntaxChecker::createBlockStatement):
      (JSC::SyntaxChecker::createExprStatement):
      (JSC::SyntaxChecker::createIfStatement):
      (JSC::SyntaxChecker::createForLoop):
      (JSC::SyntaxChecker::createForInLoop):
      (JSC::SyntaxChecker::createEmptyStatement):
      (JSC::SyntaxChecker::createVarStatement):
      (JSC::SyntaxChecker::createReturnStatement):
      (JSC::SyntaxChecker::createBreakStatement):
      (JSC::SyntaxChecker::createContinueStatement):
      (JSC::SyntaxChecker::createTryStatement):
      (JSC::SyntaxChecker::createSwitchStatement):
      (JSC::SyntaxChecker::createWhileStatement):
      (JSC::SyntaxChecker::createWithStatement):
      (JSC::SyntaxChecker::createDoWhileStatement):
      (JSC::SyntaxChecker::createLabelStatement):
      (JSC::SyntaxChecker::createThrowStatement):
      (JSC::SyntaxChecker::createDebugger):
      (JSC::SyntaxChecker::createConstStatement):
      (JSC::SyntaxChecker::appendConstDecl):
      (JSC::SyntaxChecker::createGetterOrSetterProperty):
      (JSC::SyntaxChecker::combineCommaNodes):
      (JSC::SyntaxChecker::operatorStackPop):
      * runtime/Executable.cpp:
      (JSC::EvalExecutable::compileInternal):
      (JSC::ProgramExecutable::checkSyntax):
      (JSC::ProgramExecutable::compileInternal):
      (JSC::FunctionExecutable::produceCodeBlockFor):
      (JSC::FunctionExecutable::fromGlobalCode):
      * runtime/JSGlobalData.cpp:
      (JSC::JSGlobalData::JSGlobalData):
      (JSC::JSGlobalData::~JSGlobalData):
      * runtime/JSGlobalData.h:
      * runtime/LiteralParser.cpp:
      (JSC::LiteralParser::tryJSONPParse):
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@98887 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      2e5003e8
  28. 04 Jul, 2011 1 commit
    • barraclough@apple.com's avatar
      https://bugs.webkit.org/show_bug.cgi?id=63881 · 57b4bdb8
      barraclough@apple.com authored
      Need separate bytecodes for handling >, >= comparisons.
      
      Reviewed by Oliver Hunt.
      
      This clears the way to fix Bug#63880. We currently handle greater-than comparisons
      as being using the corresponding op_less, etc opcodes.  This is incorrect with
      respect to evaluation ordering of the implicit conversions performed on operands -
      we should be calling ToPrimitive on the LHS and RHS operands to the greater than,
      but instead convert RHS then LHS.
      
      This patch adds opcodes for greater-than comparisons mirroring existing ones used
      for less-than.
      
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::dump):
      * bytecode/Opcode.h:
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::emitJumpIfTrue):
      (JSC::BytecodeGenerator::emitJumpIfFalse):
      * bytecompiler/NodesCodegen.cpp:
      * dfg/DFGByteCodeParser.cpp:
      (JSC::DFG::ByteCodeParser::parseBlock):
      * dfg/DFGNode.h:
      * dfg/DFGNonSpeculativeJIT.cpp:
      (JSC::DFG::NonSpeculativeJIT::compare):
      (JSC::DFG::NonSpeculativeJIT::compile):
      * dfg/DFGNonSpeculativeJIT.h:
      * dfg/DFGOperations.cpp:
      * dfg/DFGOperations.h:
      * dfg/DFGSpeculativeJIT.cpp:
      (JSC::DFG::SpeculativeJIT::compare):
      (JSC::DFG::SpeculativeJIT::compile):
      * dfg/DFGSpeculativeJIT.h:
      * interpreter/Interpreter.cpp:
      (JSC::Interpreter::privateExecute):
      * jit/JIT.cpp:
      (JSC::JIT::privateCompileMainPass):
      (JSC::JIT::privateCompileSlowCases):
      * jit/JIT.h:
      (JSC::JIT::emit_op_loop_if_greater):
      (JSC::JIT::emitSlow_op_loop_if_greater):
      (JSC::JIT::emit_op_loop_if_greatereq):
      (JSC::JIT::emitSlow_op_loop_if_greatereq):
      * jit/JITArithmetic.cpp:
      (JSC::JIT::emit_op_jgreater):
      (JSC::JIT::emit_op_jgreatereq):
      (JSC::JIT::emit_op_jngreater):
      (JSC::JIT::emit_op_jngreatereq):
      (JSC::JIT::emitSlow_op_jgreater):
      (JSC::JIT::emitSlow_op_jgreatereq):
      (JSC::JIT::emitSlow_op_jngreater):
      (JSC::JIT::emitSlow_op_jngreatereq):
      (JSC::JIT::emit_compareAndJumpSlow):
      * jit/JITArithmetic32_64.cpp:
      (JSC::JIT::emitBinaryDoubleOp):
      * jit/JITStubs.cpp:
      (JSC::DEFINE_STUB_FUNCTION):
      * jit/JITStubs.h:
      * parser/NodeConstructors.h:
      (JSC::GreaterNode::GreaterNode):
      (JSC::GreaterEqNode::GreaterEqNode):
      * parser/Nodes.h:
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@90371 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      57b4bdb8
  29. 01 Jan, 2011 1 commit
    • abarth@webkit.org's avatar
      Move JavaScriptCore to Source · 76da8fc1
      abarth@webkit.org authored
      https://bugs.webkit.org/show_bug.cgi?id=51604
      
      Reviewed by Eric Seidel.
      
      Update references to JavaScriptCore to point to the new location.
      
      * Android.mk:
      * CMakeLists.txt:
      * DerivedSources.pro:
      * GNUmakefile.am:
      * Makefile:
      * WebKit.pri:
      * WebKit.pro:
      * wscript:
      
      Tools: 
      
      Update references to JavaScriptCore to point to the new location.
      
      * BuildSlaveSupport/build.webkit.org-config/master.cfg:
      * DumpRenderTree/qt/DumpRenderTree.pro:
      * DumpRenderTree/qt/ImageDiff.pro:
      * DumpRenderTree/qt/TestNetscapePlugin/TestNetscapePlugin.pro:
      * DumpRenderTree/wscript:
      * Scripts/build-jsc:
      * Scripts/build-webkit:
      * Scripts/do-file-rename:
      * Scripts/do-webcore-rename:
      * Scripts/run-javascriptcore-tests:
      * Scripts/update-javascriptcore-test-results:
      * Scripts/webkitdirs.pm:
      * Scripts/webkitpy/common/config/build_unittest.py:
      * Scripts/webkitpy/style/checker.py:
      * Scripts/webkitpy/style/checker_unittest.py:
      * Scripts/webkitpy/style/checkers/cpp_unittest.py:
      * WebKitTestRunner/InjectedBundle/qt/InjectedBundle.pro:
      * WebKitTestRunner/qt/WebKitTestRunner.pro:
      * wx/build/settings.py:
      
      WebCore: 
      
      Update references to JavaScriptCore.
      
      * Android.derived.jscbindings.mk:
      * Android.v8bindings.mk:
      * CMakeLists.txt:
      * WebCore.gyp/WebCore.gyp:
      * WebCore.pro:
        - These changes are subtle and might not be 100% correct.
      * move-js-headers.sh:
      
      WebKit/chromium: 
      
      * WebKit.gyp:
        - Point to JavaScriptCore in its new location.
      
      WebKit/gtk: 
      
      * GNUmakefile.am:
      * docs/GNUmakefile.am:
        - Point to JavaScriptCore in its new location.
      
      WebKit/qt: 
      
      * WebKit_pch.h:
      * docs/qtwebkit.qdocconf:
        - Point to JavaScriptCore in its new location.
      
      WebKit/win: 
      
      * WebKit.vcproj/WebKit.sln:
        - Point to JavaScriptCore in its new location.
      
      WebKit/wx: 
      
      * bindings/python/wscript:
      * wscript:
        - Point to JavaScriptCore in its new location.
      
      WebKit2: 
      
      * WebKit2.pro:
        - Point to JavaScriptCore in its new location.
      
      Websites/bugs.webkit.org: 
      
      * PrettyPatch/PrettyPatch.rb:
        - Remove reference to JavaScriptCore as a source directory.
      
      Websites/webkit.org: 
      
      * coding/assertion-guidelines.html:
        - Update documentation to point to the new location of
          JavaScriptCore.
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@74855 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      76da8fc1
  30. 25 Jun, 2010 1 commit
    • oliver@apple.com's avatar
      2010-06-25 Oliver Hunt <oliver@apple.com> · 565dba9d
      oliver@apple.com authored
              Reviewed by Geoffrey Garen.
      
              Remove old js parser
              https://bugs.webkit.org/show_bug.cgi?id=41222
      
              Remove the old yacc parser, this also solves the tiger problem.  Which
              was a conflict between yacc generated token values and those in the
              custom parser
      
              * Android.mk:
              * CMakeLists.txt:
              * DerivedSources.make:
              * DerivedSources.pro:
              * GNUmakefile.am:
              * JavaScriptCore.pro:
              * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
              * JavaScriptCore.xcodeproj/project.pbxproj:
              * parser/Grammar.y: Removed.
              * parser/JSParser.cpp:
              * parser/JSParser.h:
              * parser/Lexer.cpp:
              * parser/NodeConstructors.h:
              (JSC::Node::Node):
              * parser/Parser.cpp:
              (JSC::Parser::parse):
              * wtf/Platform.h:
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@61878 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      565dba9d
  31. 23 Jun, 2010 1 commit
    • oliver@apple.com's avatar
      2010-06-23 Oliver Hunt <oliver@apple.com> · de38e3ed
      oliver@apple.com authored
              Reviewed by Gavin Barraclough.
      
              Custom-written JavaScript parser
              https://bugs.webkit.org/show_bug.cgi?id=34019
      
              Implement a recursive descent parser similar to that used by V8 and
              SpiderMonkey.  Greater than 2x improvement in SunSpider parsing tests.
      
              The parser consists of a JSParser class that uses a TreeBuilder to actually
              build the AST.  There are currently two builders -- the ASTBuilder and
              SyntaxChecker which separate the job of building an AST for code generation
              and simply checking syntactic correctness.
      
              There's still some less than ideal code remaining in the parser to allow
              us to retain the existing lexing code with minimal changes.  We'll tidy
              this up at a later date.
      
              * GNUmakefile.am:
              * JavaScriptCore.gypi:
              * JavaScriptCore.pro:
              * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
              * JavaScriptCore.xcodeproj/project.pbxproj:
              * parser/ASTBuilder.h: Added.
              (JSC::ASTBuilder::BinaryOpInfo::BinaryOpInfo):
              (JSC::ASTBuilder::AssignmentInfo::AssignmentInfo):
              (JSC::ASTBuilder::ASTBuilder):
              (JSC::ASTBuilder::createSourceElements):
              (JSC::ASTBuilder::varDeclarations):
              (JSC::ASTBuilder::funcDeclarations):
              (JSC::ASTBuilder::features):
              (JSC::ASTBuilder::numConstants):
              (JSC::ASTBuilder::appendToComma):
              (JSC::ASTBuilder::createCommaExpr):
              (JSC::ASTBuilder::createLogicalNot):
              (JSC::ASTBuilder::createUnaryPlus):
              (JSC::ASTBuilder::createVoid):
              (JSC::ASTBuilder::thisExpr):
              (JSC::ASTBuilder::createResolve):
              (JSC::ASTBuilder::createObjectLiteral):
              (JSC::ASTBuilder::createArray):
              (JSC::ASTBuilder::createNumberExpr):
              (JSC::ASTBuilder::createString):
              (JSC::ASTBuilder::createBoolean):
              (JSC::ASTBuilder::createNull):
              (JSC::ASTBuilder::createBracketAccess):
              (JSC::ASTBuilder::createDotAccess):
              (JSC::ASTBuilder::createRegex):
              (JSC::ASTBuilder::createNewExpr):
              (JSC::ASTBuilder::createConditionalExpr):
              (JSC::ASTBuilder::createAssignResolve):
              (JSC::ASTBuilder::createFunctionExpr):
              (JSC::ASTBuilder::createFunctionBody):
              (JSC::ASTBuilder::createGetterOrSetterProperty):
              (JSC::ASTBuilder::createArguments):
              (JSC::ASTBuilder::createArgumentsList):
              (JSC::ASTBuilder::createProperty):
              (JSC::ASTBuilder::createPropertyList):
              (JSC::ASTBuilder::createElementList):
              (JSC::ASTBuilder::createFormalParameterList):
              (JSC::ASTBuilder::createClause):
              (JSC::ASTBuilder::createClauseList):
              (JSC::ASTBuilder::setUsesArguments):
              (JSC::ASTBuilder::createFuncDeclStatement):
              (JSC::ASTBuilder::createBlockStatement):
              (JSC::ASTBuilder::createExprStatement):
              (JSC::ASTBuilder::createIfStatement):
              (JSC::ASTBuilder::createForLoop):
              (JSC::ASTBuilder::createForInLoop):
              (JSC::ASTBuilder::createEmptyStatement):
              (JSC::ASTBuilder::createVarStatement):
              (JSC::ASTBuilder::createReturnStatement):
              (JSC::ASTBuilder::createBreakStatement):
              (JSC::ASTBuilder::createContinueStatement):
              (JSC::ASTBuilder::createTryStatement):
              (JSC::ASTBuilder::createSwitchStatement):
              (JSC::ASTBuilder::createWhileStatement):
              (JSC::ASTBuilder::createDoWhileStatement):
              (JSC::ASTBuilder::createLabelStatement):
              (JSC::ASTBuilder::createWithStatement):
              (JSC::ASTBuilder::createThrowStatement):
              (JSC::ASTBuilder::createDebugger):
              (JSC::ASTBuilder::createConstStatement):
              (JSC::ASTBuilder::appendConstDecl):
              (JSC::ASTBuilder::appendStatement):
              (JSC::ASTBuilder::addVar):
              (JSC::ASTBuilder::combineCommaNodes):
              (JSC::ASTBuilder::evalCount):
              (JSC::ASTBuilder::appendBinaryExpressionInfo):
              (JSC::ASTBuilder::operatorStackPop):
              (JSC::ASTBuilder::operatorStackHasHigherPrecedence):
              (JSC::ASTBuilder::getFromOperandStack):
              (JSC::ASTBuilder::shrinkOperandStackBy):
              (JSC::ASTBuilder::appendBinaryOperation):
              (JSC::ASTBuilder::operatorStackAppend):
              (JSC::ASTBuilder::popOperandStack):
              (JSC::ASTBuilder::appendUnaryToken):
              (JSC::ASTBuilder::unaryTokenStackLastType):
              (JSC::ASTBuilder::unaryTokenStackLastStart):
              (JSC::ASTBuilder::unaryTokenStackRemoveLast):
              (JSC::ASTBuilder::assignmentStackAppend):
              (JSC::ASTBuilder::createAssignment):
              (JSC::ASTBuilder::Scope::Scope):
              (JSC::ASTBuilder::setExceptionLocation):
              (JSC::ASTBuilder::incConstants):
              (JSC::ASTBuilder::usesThis):
              (JSC::ASTBuilder::usesCatch):
              (JSC::ASTBuilder::usesClosures):
              (JSC::ASTBuilder::usesArguments):
              (JSC::ASTBuilder::usesAssignment):
              (JSC::ASTBuilder::usesWith):
              (JSC::ASTBuilder::usesEval):
              (JSC::ASTBuilder::createNumber):
              (JSC::ASTBuilder::makeTypeOfNode):
              (JSC::ASTBuilder::makeDeleteNode):
              (JSC::ASTBuilder::makeNegateNode):
              (JSC::ASTBuilder::makeBitwiseNotNode):
              (JSC::ASTBuilder::makeMultNode):
              (JSC::ASTBuilder::makeDivNode):
              (JSC::ASTBuilder::makeAddNode):
              (JSC::ASTBuilder::makeSubNode):
              (JSC::ASTBuilder::makeLeftShiftNode):
              (JSC::ASTBuilder::makeRightShiftNode):
              (JSC::ASTBuilder::makeFunctionCallNode):
              (JSC::ASTBuilder::makeBinaryNode):
              (JSC::ASTBuilder::makeAssignNode):
              (JSC::ASTBuilder::makePrefixNode):
              (JSC::ASTBuilder::makePostfixNode):
              * parser/JSParser.cpp: Added.
              (JSC::JSParser::AllowInOverride::AllowInOverride):
              (JSC::JSParser::AllowInOverride::~AllowInOverride):
              (JSC::JSParser::token):
              (JSC::JSParser::next):
              (JSC::JSParser::consume):
              (JSC::JSParser::match):
              (JSC::JSParser::tokenStart):
              (JSC::JSParser::tokenLine):
              (JSC::JSParser::tokenEnd):
              (JSC::JSParser::):
              (JSC::JSParser::autoSemiColon):
              (JSC::JSParser::canRecurse):
              (JSC::JSParser::lastTokenEnd):
              (JSC::jsParse):
              (JSC::JSParser::JSParser):
              (JSC::JSParser::parseProgram):
              (JSC::JSParser::allowAutomaticSemicolon):
              (JSC::JSParser::parseSourceElements):
              (JSC::JSParser::parseVarDeclaration):
              (JSC::JSParser::parseConstDeclaration):
              (JSC::JSParser::parseDoWhileStatement):
              (JSC::JSParser::parseWhileStatement):
              (JSC::JSParser::parseVarDeclarationList):
              (JSC::JSParser::parseConstDeclarationList):
              (JSC::JSParser::parseForStatement):
              (JSC::JSParser::parseBreakStatement):
              (JSC::JSParser::parseContinueStatement):
              (JSC::JSParser::parseReturnStatement):
              (JSC::JSParser::parseThrowStatement):
              (JSC::JSParser::parseWithStatement):
              (JSC::JSParser::parseSwitchStatement):
              (JSC::JSParser::parseSwitchClauses):
              (JSC::JSParser::parseSwitchDefaultClause):
              (JSC::JSParser::parseTryStatement):
              (JSC::JSParser::parseDebuggerStatement):
              (JSC::JSParser::parseBlockStatement):
              (JSC::JSParser::parseStatement):
              (JSC::JSParser::parseFormalParameters):
              (JSC::JSParser::parseFunctionBody):
              (JSC::JSParser::parseFunctionInfo):
              (JSC::JSParser::parseFunctionDeclaration):
              (JSC::JSParser::parseExpressionOrLabelStatement):
              (JSC::JSParser::parseExpressionStatement):
              (JSC::JSParser::parseIfStatement):
              (JSC::JSParser::parseExpression):
              (JSC::JSParser::parseAssignmentExpression):
              (JSC::JSParser::parseConditionalExpression):
              (JSC::isUnaryOp):
              (JSC::JSParser::isBinaryOperator):
              (JSC::JSParser::parseBinaryExpression):
              (JSC::JSParser::parseProperty):
              (JSC::JSParser::parseObjectLiteral):
              (JSC::JSParser::parseArrayLiteral):
              (JSC::JSParser::parsePrimaryExpression):
              (JSC::JSParser::parseArguments):
              (JSC::JSParser::parseMemberExpression):
              (JSC::JSParser::parseUnaryExpression):
              * parser/JSParser.h: Added.
              (JSC::):
              (JSC::JSTokenInfo::JSTokenInfo):
              * parser/Lexer.cpp:
              (JSC::Lexer::lex):
              * parser/Lexer.h:
              (JSC::Lexer::setLastLineNumber):
              (JSC::Lexer::lastLineNumber):
              * parser/NodeConstructors.h:
              (JSC::Node::Node):
              * parser/Parser.cpp:
              (JSC::Parser::parse):
              * parser/SyntaxChecker.h: Added.
              (JSC::SyntaxChecker::SyntaxChecker):
              (JSC::SyntaxChecker::createSourceElements):
              (JSC::SyntaxChecker::makeFunctionCallNode):
              (JSC::SyntaxChecker::appendToComma):
              (JSC::SyntaxChecker::createCommaExpr):
              (JSC::SyntaxChecker::makeAssignNode):
              (JSC::SyntaxChecker::makePrefixNode):
              (JSC::SyntaxChecker::makePostfixNode):
              (JSC::SyntaxChecker::makeTypeOfNode):
              (JSC::SyntaxChecker::makeDeleteNode):
              (JSC::SyntaxChecker::makeNegateNode):
              (JSC::SyntaxChecker::makeBitwiseNotNode):
              (JSC::SyntaxChecker::createLogicalNot):
              (JSC::SyntaxChecker::createUnaryPlus):
              (JSC::SyntaxChecker::createVoid):
              (JSC::SyntaxChecker::thisExpr):
              (JSC::SyntaxChecker::createResolve):
              (JSC::SyntaxChecker::createObjectLiteral):
              (JSC::SyntaxChecker::createArray):
              (JSC::SyntaxChecker::createNumberExpr):
              (JSC::SyntaxChecker::createString):
              (JSC::SyntaxChecker::createBoolean):
              (JSC::SyntaxChecker::createNull):
              (JSC::SyntaxChecker::createBracketAccess):
              (JSC::SyntaxChecker::createDotAccess):
              (JSC::SyntaxChecker::createRegex):
              (JSC::SyntaxChecker::createNewExpr):
              (JSC::SyntaxChecker::createConditionalExpr):
              (JSC::SyntaxChecker::createAssignResolve):
              (JSC::SyntaxChecker::createFunctionExpr):
              (JSC::SyntaxChecker::createFunctionBody):
              (JSC::SyntaxChecker::createArguments):
              (JSC::SyntaxChecker::createArgumentsList):
              (JSC::SyntaxChecker::createProperty):
              (JSC::SyntaxChecker::createPropertyList):
              (JSC::SyntaxChecker::createElementList):
              (JSC::SyntaxChecker::createFormalParameterList):
              (JSC::SyntaxChecker::createClause):
              (JSC::SyntaxChecker::createClauseList):
              (JSC::SyntaxChecker::setUsesArguments):
              (JSC::SyntaxChecker::createFuncDeclStatement):
              (JSC::SyntaxChecker::createBlockStatement):
              (JSC::SyntaxChecker::createExprStatement):
              (JSC::SyntaxChecker::createIfStatement):
              (JSC::SyntaxChecker::createForLoop):
              (JSC::SyntaxChecker::createForInLoop):
              (JSC::SyntaxChecker::createEmptyStatement):
              (JSC::SyntaxChecker::createVarStatement):
              (JSC::SyntaxChecker::createReturnStatement):
              (JSC::SyntaxChecker::createBreakStatement):
              (JSC::SyntaxChecker::createContinueStatement):
              (JSC::SyntaxChecker::createTryStatement):
              (JSC::SyntaxChecker::createSwitchStatement):
              (JSC::SyntaxChecker::createWhileStatement):
              (JSC::SyntaxChecker::createWithStatement):
              (JSC::SyntaxChecker::createDoWhileStatement):
              (JSC::SyntaxChecker::createLabelStatement):
              (JSC::SyntaxChecker::createThrowStatement):
              (JSC::SyntaxChecker::createDebugger):
              (JSC::SyntaxChecker::createConstStatement):
              (JSC::SyntaxChecker::appendConstDecl):
              (JSC::SyntaxChecker::createGetterOrSetterProperty):
              (JSC::SyntaxChecker::appendStatement):
              (JSC::SyntaxChecker::addVar):
              (JSC::SyntaxChecker::combineCommaNodes):
              (JSC::SyntaxChecker::evalCount):
              (JSC::SyntaxChecker::appendBinaryExpressionInfo):
              (JSC::SyntaxChecker::operatorStackPop):
              * runtime/JSGlobalData.h:
              * wtf/Platform.h:
              * wtf/ThreadSpecific.h:
              (WTF::T):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@61732 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      de38e3ed
  32. 09 Mar, 2010 1 commit
    • barraclough@apple.com's avatar
      This caused a performance regression, by breaking the code · 448a8d3d
      barraclough@apple.com authored
      generator's logic to calculate the skip level for resolving
      variables (traced by rdar:7683350)  Reverting for now.
      
      Reviewed by NOBODY (reverting r54510).
      
      * parser/Grammar.y:
      * parser/NodeConstructors.h:
      (JSC::ContinueNode::ContinueNode):
      (JSC::BreakNode::BreakNode):
      (JSC::ForInNode::ForInNode):
      * runtime/CommonIdentifiers.cpp:
      (JSC::CommonIdentifiers::CommonIdentifiers):
      * runtime/CommonIdentifiers.h:
      * runtime/FunctionPrototype.cpp:
      (JSC::FunctionPrototype::FunctionPrototype):
      * runtime/Identifier.cpp:
      (JSC::Identifier::add):
      * runtime/PropertyNameArray.cpp:
      (JSC::PropertyNameArray::add):
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@55751 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      448a8d3d
  33. 08 Feb, 2010 1 commit
    • barraclough@apple.com's avatar
      Use an empty identifier instead of a null identifier for parse · 419c15b2
      barraclough@apple.com authored
      tokens without an identifier.
      
      Reviewed by Sam Weinig.
      
      This helps encapsulate the null UStringImpl within UString.
      
      * parser/Grammar.y:
      * parser/NodeConstructors.h:
      (JSC::ContinueNode::ContinueNode):
      (JSC::BreakNode::BreakNode):
      (JSC::ForInNode::ForInNode):
      * runtime/CommonIdentifiers.cpp:
      (JSC::CommonIdentifiers::CommonIdentifiers):
      * runtime/CommonIdentifiers.h:
      * runtime/FunctionPrototype.cpp:
      (JSC::FunctionPrototype::FunctionPrototype):
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@54510 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      419c15b2
  34. 22 Aug, 2009 1 commit
    • darin@apple.com's avatar
      Syntax tree nodes should use arena allocation · 85a65c3c
      darin@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=25674
      
      Patch by Darin Adler <darin@apple.com> on 2009-08-21
      Reviewed by Gavin Barraclough.
      
      Use an actual arena now. 0.6% speedup on SunSpider.
      
      New and improved with 100% less leaking of the universe.
      
      * JavaScriptCore.exp:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
      Removed all exports involving the class FunctionBodyNode, which no
      longer needs to be used outside JavaScriptCore.
      
      * JavaScriptCore.xcodeproj/project.pbxproj: Made Nodes.h and
      Executable.h project-internal instead of "private".
      
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::BytecodeGenerator::BytecodeGenerator): Updated since VarStack
      contains const Identifier* now.
      
      * parser/Grammar.y: Made identifiers from the lexer be const
      Identifier* and updated since VarStack contains const Identifier* now.
      
      * parser/Lexer.cpp:
      (JSC::Lexer::setCode): Pass in ParserArena, used for identifiers.
      (JSC::Lexer::makeIdentifier): Changed return type to const Identifier*
      and changed to call ParserArena.
      (JSC::Lexer::clear): Removed the code to manage m_identifiers and
      added code to set m_arena to 0.
      * parser/Lexer.h: Updated for changes above.
      
      * parser/NodeConstructors.h:
      (JSC::ParserArenaFreeable::operator new): Added. Calls allocateFreeable
      on the arena.
      (JSC::ParserArenaDeletable::operator new): Changed to call the
      allocateDeletable function on the arena instead of deleteWithArena.
      (JSC::PropertyNode::PropertyNode): Added new constructor that makes
      numeric identifiers. Some day we might want to optimize this for
      integers so it doesn't create a string for each one.
      (JSC::ContinueNode::ContinueNode): Initialize m_ident to nullIdentifier
      since it's now a const Identifier& so it can't be left uninitialized.
      (JSC::BreakNode::BreakNode): Ditto.
      (JSC::CaseClauseNode::CaseClauseNode): Updated to use SourceElements*
      to keep track of the statements rather than a separate statement vector.
      (JSC::BlockNode::BlockNode): Ditto.
      (JSC::ForInNode::ForInNode): Initialize m_ident to nullIdentifier.
      
      * parser/Nodes.cpp: Moved the comment explaining emitBytecode in here.
      It seemed strangely out of place in the header.
      (JSC::ThrowableExpressionData::emitThrowError): Added an overload for
      UString as well as Identifier.
      (JSC::SourceElements::singleStatement): Added.
      (JSC::SourceElements::lastStatement): Added.
      (JSC::RegExpNode::emitBytecode): Changed the throwError code to use
      the substitution mechanism instead of doing a string append.
      (JSC::SourceElements::emitBytecode): Added. Replaces the old
      statementListEmitCode function, since we now keep the SourceElements
      objects around.
      (JSC::BlockNode::lastStatement): Added.
      (JSC::BlockNode::emitBytecode): Changed to use emitBytecode instead of
      statementListEmitCode.
      (JSC::CaseClauseNode::emitBytecode): Added.
      (JSC::CaseBlockNode::emitBytecodeForBlock): Changed to use emitBytecode
      instead of statementListEmitCode.
      (JSC::ScopeNodeData::ScopeNodeData): Changed to store the
      SourceElements* instead of using releaseContentsIntoVector.
      (JSC::ScopeNode::emitStatementsBytecode): Added.
      (JSC::ScopeNode::singleStatement): Added.
      (JSC::ProgramNode::emitBytecode): Call emitStatementsBytecode instead
      of statementListEmitCode.
      (JSC::EvalNode::emitBytecode): Ditto.
      (JSC::FunctionBodyNode::emitBytecode): Call emitStatementsBytecode
      insetad of statementListEmitCode and check for the return node using
      the new functions.
      
      * parser/Nodes.h: Changed VarStack to store const Identifier* instead
      of Identifier and rely on the arena to control lifetime. Added a new
      ParserArenaFreeable class. Made ParserArenaDeletable inherit from
      FastAllocBase instead of having its own operator new. Base the Node
      class on ParserArenaFreeable. Changed the various Node classes
      to use const Identifier& instead of Identifier to avoid the need to
      call their destructors and allow them to function as "freeable" in the
      arena. Removed extraneous JSC_FAST_CALL on definitions of inline functions.
      Changed ElementNode, PropertyNode, ArgumentsNode, ParameterNode,
      CaseClauseNode, ClauseListNode, and CaseBlockNode to use ParserArenaFreeable
      as a base class since they do not descend from Node. Eliminated the
      StatementVector type and instead have various classes use SourceElements*
      instead of StatementVector. This prevents those classes from having to
      use ParserArenaDeletable to make sure the vector destructor is called.
      
      * parser/Parser.cpp:
      (JSC::Parser::parse): Pass the arena to the lexer.
      
      * parser/Parser.h: Added an include of ParserArena.h, which is no longer
      included by Nodes.h.
      (JSC::Parser::parseFunctionFromGlobalCode): Changed to use the
      singleStatement function, since there is no longer any children function.
      Removed some unneeded use of RefPtr.
      
      * parser/ParserArena.cpp:
      (JSC::ParserArena::ParserArena): Added. Initializes the new members,
      m_freeableMemory, m_freeablePoolEnd, and m_identifiers.
      (JSC::ParserArena::freeablePool): Added. Computes the pool pointer,
      since we store only the current pointer and the end of pool pointer.
      (JSC::ParserArena::deallocateObjects): Added. Contains the common
      memory-deallocation logic used by both the destructor and the
      reset function.
      (JSC::ParserArena::~ParserArena): Changed to call deallocateObjects.
      (JSC::ParserArena::reset): Ditto. Also added code to zero out the
      new structures, and switched to use clear() instead of shrink(0) since
      we don't really reuse arenas.
      (JSC::ParserArena::makeNumericIdentifier): Added.
      (JSC::ParserArena::allocateFreeablePool): Added. Used when the pool
      is empty.
      (JSC::ParserArena::isEmpty): Added. No longer inline, which is fine
      since this is used only for assertions at the moment.
      (JSC::ParserArena::derefWithArena): Make non-inline.
      
      * parser/ParserArena.h: Added an actual arena of "freeable" objects,
      ones that don't need destructors to be called. Also added a separate
      IdentifierArena object, a segmented vector of identifiers that used
      to be in the Lexer.
      
      * runtime/Executable.h: Moved the definition of the
      FunctionExecutable::make function here. It can't go in JSFunction.h
      since that header has to be used outside JavaScriptCore and so can't
      include this, which includes Nodes.h. The function could be moved
      elswhere if we don't want to include JSFunction.h in this header, but
      for now this seems to be the best place.
      
      * runtime/JSFunction.h: Removed the include of Executable.h and
      definition of the FunctionExecutable::make function.
      
      * wtf/FastMalloc.cpp: Fixed an incorrect comment.
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@47664 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      85a65c3c