Ignore:
Timestamp:
Aug 1, 2012, 11:44:46 PM (13 years ago)
Author:
[email protected]
Message:

Unreviewed, rolling out r124406.
​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 <​[email protected]> 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):

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

    r124406 r124413  
    203203}
    204204
    205 ArgumentListNode* ArrayNode::toArgumentList(JSGlobalData* globalData, int lineNumber, int columnNumber) const
     205ArgumentListNode* ArrayNode::toArgumentList(JSGlobalData* globalData, int lineNumber) const
    206206{
    207207    ASSERT(!m_elision && !m_optional);
    … …  
    209209    if (!ptr)
    210210        return 0;
    211     JSTokenLocation location;
    212     location.line = lineNumber;
    213     location.column = columnNumber;
    214     ArgumentListNode* head = new (globalData) ArgumentListNode(location, ptr->value());
     211    ArgumentListNode* head = new (globalData) ArgumentListNode(lineNumber, ptr->value());
    215212    ArgumentListNode* tail = head;
    216213    ptr = ptr->next();
    217214    for (; ptr; ptr = ptr->next()) {
    218215        ASSERT(!ptr->elision());
    219         tail = new (globalData) ArgumentListNode(location, tail, ptr->value());
     216        tail = new (globalData) ArgumentListNode(lineNumber, tail, ptr->value());
    220217    }
    221218    return head;
    … …  
    540537                    ASSERT(m_args->m_listNode->m_next->m_expr->isSimpleArray());
    541538                    ASSERT(!m_args->m_listNode->m_next->m_next);
    542                     m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.globalData(), 0, 0);
     539                    m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.globalData(), 0);
    543540                    RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
    544541                    CallArguments callArguments(generator, m_args);
    … …  
    11311128    RefPtr<Label> beforeElse = generator.newLabel();
    11321129    RefPtr<Label> afterElse = generator.newLabel();
    1133 
    1134     generator.emitDebugHook(WillExecuteStatement, lineNo(), lineNo(), columnNo());
    11351130
    11361131    if (m_logical->hasConditionContextCodegen()) {
    … …  
    13911386RegisterID* ConstStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    13921387{
    1393     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1388    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    13941389    return generator.emitNode(m_next);
    13951390}
    … …  
    14341429RegisterID* EmptyStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14351430{
    1436     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1431    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    14371432    return dst;
    14381433}
    … …  
    14421437RegisterID* DebuggerStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14431438{
    1444     generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine(), column());
     1439    generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine());
    14451440    return dst;
    14461441}
    … …  
    14511446{
    14521447    ASSERT(m_expr);
    1453     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1448    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    14541449    return generator.emitNode(dst, m_expr);
    14551450}
    … …  
    14601455{
    14611456    ASSERT(m_expr);
    1462     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1457    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    14631458    return generator.emitNode(m_expr);
    14641459}
    … …  
    14681463RegisterID* IfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14691464{
    1470     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1465    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    14711466   
    14721467    RefPtr<Label> afterThen = generator.newLabel();
    … …  
    14921487RegisterID* IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14931488{
    1494     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1489    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    14951490   
    14961491    RefPtr<Label> beforeElse = generator.newLabel();
    … …  
    15281523    generator.emitLabel(topOfLoop.get());
    15291524    generator.emitLoopHint();
     1525    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    15301526   
    15311527    RefPtr<RegisterID> result = generator.emitNode(dst, m_statement);
    15321528
    15331529    generator.emitLabel(scope->continueTarget());
    1534     generator.emitDebugHook(WillExecuteStatement, lastLine(), lastLine(), column());
     1530    generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
    15351531    if (m_expr->hasConditionContextCodegen())
    15361532        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), false);
    … …  
    15511547    RefPtr<Label> topOfLoop = generator.newLabel();
    15521548
    1553     generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo(), m_expr->columnNo());
     1549    generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
    15541550    if (m_expr->hasConditionContextCodegen())
    15551551        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), true);
    … …  
    15651561
    15661562    generator.emitLabel(scope->continueTarget());
    1567     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1563    generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
    15681564
    15691565    if (m_expr->hasConditionContextCodegen())
    … …  
    15861582    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
    15871583
    1588     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1584    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    15891585
    15901586    if (m_expr1)
    … …  
    16071603
    16081604    generator.emitLabel(scope->continueTarget());
    1609     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1605    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    16101606    if (m_expr3)
    16111607        generator.emitNode(generator.ignoredResult(), m_expr3);
    … …  
    16341630        return emitThrowReferenceError(generator, "Left side of for-in statement is not a reference.");
    16351631
    1636     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1632    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    16371633
    16381634    if (m_init)
    … …  
    16971693    generator.emitLabel(scope->continueTarget());
    16981694    generator.emitNextPropertyName(propertyName, base.get(), i.get(), size.get(), iter.get(), loopStart.get());
    1699     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1695    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    17001696    generator.emitLabel(scope->breakTarget());
    17011697    return dst;
    … …  
    17071703RegisterID* ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17081704{
    1709     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1705    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    17101706   
    17111707    LabelScope* scope = generator.continueTarget(m_ident);
    … …  
    17211717RegisterID* BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17221718{
    1723     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1719    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    17241720   
    17251721    LabelScope* scope = generator.breakTarget(m_ident);
    … …  
    17341730RegisterID* ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17351731{
    1736     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1732    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    17371733    ASSERT(generator.codeType() == FunctionCode);
    17381734
    … …  
    17501746        generator.emitLabel(l0.get());
    17511747    }
    1752     generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
     1748    generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine());
    17531749    return generator.emitReturn(r0);
    17541750}
    … …  
    17581754RegisterID* WithNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17591755{
    1760     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1756    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    17611757   
    17621758    RefPtr<RegisterID> scope = generator.newTemporary();
    … …  
    19231919RegisterID* SwitchNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19241920{
    1925     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1921    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    19261922   
    19271923    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Switch);
    … …  
    19381934RegisterID* LabelNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19391935{
    1940     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1936    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    19411937
    19421938    ASSERT(!generator.breakTarget(m_name));
    … …  
    19531949RegisterID* ThrowNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19541950{
    1955     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1951    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    19561952
    19571953    if (dst == generator.ignoredResult())
    … …  
    19701966    // optimizer knows they may be jumped to from anywhere.
    19711967
    1972     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
     1968    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    19731969
    19741970    RefPtr<Label> tryStartLabel = generator.newLabel();
    … …  
    20272023RegisterID* ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20282024{
    2029     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());
     2025    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
    20302026
    20312027    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    … …  
    20332029    emitStatementsBytecode(generator, dstRegister.get());
    20342030
    2035     generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
     2031    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine());
    20362032    generator.emitEnd(dstRegister.get());
    20372033    return 0;
    … …  
    20422038RegisterID* EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20432039{
    2044     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());
     2040    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
    20452041
    20462042    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    … …  
    20482044    emitStatementsBytecode(generator, dstRegister.get());
    20492045
    2050     generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
     2046    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine());
    20512047    generator.emitEnd(dstRegister.get());
    20522048    return 0;
    … …  
    20572053RegisterID* FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20582054{
    2059     generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine(), column());
     2055    generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine());
    20602056    emitStatementsBytecode(generator, generator.ignoredResult());
    20612057
    … …  
    20732069    if (!returnNode) {
    20742070        RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
    2075         generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
     2071        generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine());
    20762072        generator.emitReturn(r0);
    20772073        return 0;
Note: See TracChangeset for help on using the changeset viewer.