Ignore:
Timestamp:
Aug 5, 2012, 8:16:46 PM (13 years ago)
Author:
[email protected]
Message:

Web Inspector: [JSC] implement setting breakpoints by line:column
​https://bugs.webkit.org/show_bug.cgi?id=53003

Source/JavaScriptCore:

Patch by Peter Wang <​[email protected]> 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 <​[email protected]> 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 <​[email protected]> 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):

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r124413 r124729  
    203203}
    204204
    205 ArgumentListNode* ArrayNode::toArgumentList(JSGlobalData* globalData, int lineNumber) const
     205ArgumentListNode* ArrayNode::toArgumentList(JSGlobalData* globalData, int lineNumber, int columnNumber) const
    206206{
    207207    ASSERT(!m_elision && !m_optional);
    … …  
    209209    if (!ptr)
    210210        return 0;
    211     ArgumentListNode* head = new (globalData) ArgumentListNode(lineNumber, ptr->value());
     211    JSTokenLocation location;
     212    location.line = lineNumber;
     213    location.column = columnNumber;
     214    ArgumentListNode* head = new (globalData) ArgumentListNode(location, ptr->value());
    212215    ArgumentListNode* tail = head;
    213216    ptr = ptr->next();
    214217    for (; ptr; ptr = ptr->next()) {
    215218        ASSERT(!ptr->elision());
    216         tail = new (globalData) ArgumentListNode(lineNumber, tail, ptr->value());
     219        tail = new (globalData) ArgumentListNode(location, tail, ptr->value());
    217220    }
    218221    return head;
    … …  
    537540                    ASSERT(m_args->m_listNode->m_next->m_expr->isSimpleArray());
    538541                    ASSERT(!m_args->m_listNode->m_next->m_next);
    539                     m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.globalData(), 0);
     542                    m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.globalData(), 0, 0);
    540543                    RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
    541544                    CallArguments callArguments(generator, m_args);
    … …  
    13861389RegisterID* ConstStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    13871390{
    1388     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1391    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    13891392    return generator.emitNode(m_next);
    13901393}
    … …  
    14291432RegisterID* EmptyStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14301433{
    1431     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1434    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14321435    return dst;
    14331436}
    … …  
    14371440RegisterID* DebuggerStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14381441{
    1439     generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine());
     1442    generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine(), column());
    14401443    return dst;
    14411444}
    … …  
    14461449{
    14471450    ASSERT(m_expr);
    1448     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1451    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14491452    return generator.emitNode(dst, m_expr);
    14501453}
    … …  
    14551458{
    14561459    ASSERT(m_expr);
    1457     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1460    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14581461    return generator.emitNode(m_expr);
    14591462}
    … …  
    14631466RegisterID* IfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14641467{
    1465     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1468    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14661469   
    14671470    RefPtr<Label> afterThen = generator.newLabel();
    … …  
    14871490RegisterID* IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14881491{
    1489     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1492    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14901493   
    14911494    RefPtr<Label> beforeElse = generator.newLabel();
    … …  
    15231526    generator.emitLabel(topOfLoop.get());
    15241527    generator.emitLoopHint();
    1525     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    1526    
     1528    generator.emitDebugHook(WillExecuteStatement, lastLine(), lastLine(), column());
     1529
    15271530    RefPtr<RegisterID> result = generator.emitNode(dst, m_statement);
    15281531
    15291532    generator.emitLabel(scope->continueTarget());
    1530     generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
     1533    generator.emitDebugHook(WillExecuteStatement, lastLine(), lastLine(), column());
    15311534    if (m_expr->hasConditionContextCodegen())
    15321535        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), false);
    … …  
    15471550    RefPtr<Label> topOfLoop = generator.newLabel();
    15481551
    1549     generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
     1552    generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo(), m_expr->columnNo());
    15501553    if (m_expr->hasConditionContextCodegen())
    15511554        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), true);
    … …  
    15611564
    15621565    generator.emitLabel(scope->continueTarget());
    1563     generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
     1566    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    15641567
    15651568    if (m_expr->hasConditionContextCodegen())
    … …  
    15821585    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
    15831586
    1584     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1587    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    15851588
    15861589    if (m_expr1)
    … …  
    16031606
    16041607    generator.emitLabel(scope->continueTarget());
    1605     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1608    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    16061609    if (m_expr3)
    16071610        generator.emitNode(generator.ignoredResult(), m_expr3);
    … …  
    16301633        return emitThrowReferenceError(generator, "Left side of for-in statement is not a reference.");
    16311634
    1632     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1635    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    16331636
    16341637    if (m_init)
    … …  
    16931696    generator.emitLabel(scope->continueTarget());
    16941697    generator.emitNextPropertyName(propertyName, base.get(), i.get(), size.get(), iter.get(), loopStart.get());
    1695     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1698    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    16961699    generator.emitLabel(scope->breakTarget());
    16971700    return dst;
    … …  
    17031706RegisterID* ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17041707{
    1705     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1708    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17061709   
    17071710    LabelScope* scope = generator.continueTarget(m_ident);
    … …  
    17171720RegisterID* BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17181721{
    1719     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1722    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17201723   
    17211724    LabelScope* scope = generator.breakTarget(m_ident);
    … …  
    17301733RegisterID* ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17311734{
    1732     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1735    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17331736    ASSERT(generator.codeType() == FunctionCode);
    17341737
    … …  
    17461749        generator.emitLabel(l0.get());
    17471750    }
    1748     generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine());
     1751    generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
    17491752    return generator.emitReturn(r0);
    17501753}
    … …  
    17541757RegisterID* WithNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17551758{
    1756     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1759    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17571760   
    17581761    RefPtr<RegisterID> scope = generator.newTemporary();
    … …  
    19191922RegisterID* SwitchNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19201923{
    1921     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1924    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19221925   
    19231926    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Switch);
    … …  
    19341937RegisterID* LabelNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19351938{
    1936     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1939    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19371940
    19381941    ASSERT(!generator.breakTarget(m_name));
    … …  
    19491952RegisterID* ThrowNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19501953{
    1951     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1954    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19521955
    19531956    if (dst == generator.ignoredResult())
    … …  
    19661969    // optimizer knows they may be jumped to from anywhere.
    19671970
    1968     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1971    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19691972
    19701973    RefPtr<Label> tryStartLabel = generator.newLabel();
    … …  
    20232026RegisterID* ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20242027{
    2025     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
     2028    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());
    20262029
    20272030    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    … …  
    20292032    emitStatementsBytecode(generator, dstRegister.get());
    20302033
    2031     generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine());
     2034    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
    20322035    generator.emitEnd(dstRegister.get());
    20332036    return 0;
    … …  
    20382041RegisterID* EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20392042{
    2040     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
     2043    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());
    20412044
    20422045    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    … …  
    20442047    emitStatementsBytecode(generator, dstRegister.get());
    20452048
    2046     generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine());
     2049    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
    20472050    generator.emitEnd(dstRegister.get());
    20482051    return 0;
    … …  
    20532056RegisterID* FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20542057{
    2055     generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine());
     2058    generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine(), column());
    20562059    emitStatementsBytecode(generator, generator.ignoredResult());
    20572060
    … …  
    20692072    if (!returnNode) {
    20702073        RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
    2071         generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine());
     2074        generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
    20722075        generator.emitReturn(r0);
    20732076        return 0;
Note: See TracChangeset for help on using the changeset viewer.