Ignore:
Timestamp:
Aug 1, 2012, 9:49:25 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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r120244 r124406  
    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);
    … …  
    11281131    RefPtr<Label> beforeElse = generator.newLabel();
    11291132    RefPtr<Label> afterElse = generator.newLabel();
     1133
     1134    generator.emitDebugHook(WillExecuteStatement, lineNo(), lineNo(), columnNo());
    11301135
    11311136    if (m_logical->hasConditionContextCodegen()) {
    … …  
    13861391RegisterID* ConstStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    13871392{
    1388     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1393    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    13891394    return generator.emitNode(m_next);
    13901395}
    … …  
    14291434RegisterID* EmptyStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14301435{
    1431     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1436    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14321437    return dst;
    14331438}
    … …  
    14371442RegisterID* DebuggerStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14381443{
    1439     generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine());
     1444    generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine(), column());
    14401445    return dst;
    14411446}
    … …  
    14461451{
    14471452    ASSERT(m_expr);
    1448     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1453    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14491454    return generator.emitNode(dst, m_expr);
    14501455}
    … …  
    14551460{
    14561461    ASSERT(m_expr);
    1457     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1462    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14581463    return generator.emitNode(m_expr);
    14591464}
    … …  
    14631468RegisterID* IfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14641469{
    1465     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1470    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14661471   
    14671472    RefPtr<Label> afterThen = generator.newLabel();
    … …  
    14871492RegisterID* IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    14881493{
    1489     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1494    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    14901495   
    14911496    RefPtr<Label> beforeElse = generator.newLabel();
    … …  
    15231528    generator.emitLabel(topOfLoop.get());
    15241529    generator.emitLoopHint();
    1525     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
    15261530   
    15271531    RefPtr<RegisterID> result = generator.emitNode(dst, m_statement);
    15281532
    15291533    generator.emitLabel(scope->continueTarget());
    1530     generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
     1534    generator.emitDebugHook(WillExecuteStatement, lastLine(), lastLine(), column());
    15311535    if (m_expr->hasConditionContextCodegen())
    15321536        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), false);
    … …  
    15471551    RefPtr<Label> topOfLoop = generator.newLabel();
    15481552
    1549     generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
     1553    generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo(), m_expr->columnNo());
    15501554    if (m_expr->hasConditionContextCodegen())
    15511555        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), true);
    … …  
    15611565
    15621566    generator.emitLabel(scope->continueTarget());
    1563     generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo());
     1567    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    15641568
    15651569    if (m_expr->hasConditionContextCodegen())
    … …  
    15821586    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
    15831587
    1584     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1588    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    15851589
    15861590    if (m_expr1)
    … …  
    16031607
    16041608    generator.emitLabel(scope->continueTarget());
    1605     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1609    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    16061610    if (m_expr3)
    16071611        generator.emitNode(generator.ignoredResult(), m_expr3);
    … …  
    16301634        return emitThrowReferenceError(generator, "Left side of for-in statement is not a reference.");
    16311635
    1632     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1636    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    16331637
    16341638    if (m_init)
    … …  
    16931697    generator.emitLabel(scope->continueTarget());
    16941698    generator.emitNextPropertyName(propertyName, base.get(), i.get(), size.get(), iter.get(), loopStart.get());
    1695     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1699    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    16961700    generator.emitLabel(scope->breakTarget());
    16971701    return dst;
    … …  
    17031707RegisterID* ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17041708{
    1705     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1709    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17061710   
    17071711    LabelScope* scope = generator.continueTarget(m_ident);
    … …  
    17171721RegisterID* BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17181722{
    1719     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1723    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17201724   
    17211725    LabelScope* scope = generator.breakTarget(m_ident);
    … …  
    17301734RegisterID* ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17311735{
    1732     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1736    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17331737    ASSERT(generator.codeType() == FunctionCode);
    17341738
    … …  
    17461750        generator.emitLabel(l0.get());
    17471751    }
    1748     generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine());
     1752    generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
    17491753    return generator.emitReturn(r0);
    17501754}
    … …  
    17541758RegisterID* WithNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    17551759{
    1756     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1760    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    17571761   
    17581762    RefPtr<RegisterID> scope = generator.newTemporary();
    … …  
    19191923RegisterID* SwitchNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19201924{
    1921     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1925    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19221926   
    19231927    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Switch);
    … …  
    19341938RegisterID* LabelNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19351939{
    1936     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1940    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19371941
    19381942    ASSERT(!generator.breakTarget(m_name));
    … …  
    19491953RegisterID* ThrowNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    19501954{
    1951     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1955    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19521956
    19531957    if (dst == generator.ignoredResult())
    … …  
    19661970    // optimizer knows they may be jumped to from anywhere.
    19671971
    1968     generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
     1972    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    19691973
    19701974    RefPtr<Label> tryStartLabel = generator.newLabel();
    … …  
    20232027RegisterID* ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20242028{
    2025     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
     2029    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());
    20262030
    20272031    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    … …  
    20292033    emitStatementsBytecode(generator, dstRegister.get());
    20302034
    2031     generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine());
     2035    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
    20322036    generator.emitEnd(dstRegister.get());
    20332037    return 0;
    … …  
    20382042RegisterID* EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20392043{
    2040     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
     2044    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());
    20412045
    20422046    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    … …  
    20442048    emitStatementsBytecode(generator, dstRegister.get());
    20452049
    2046     generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine());
     2050    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
    20472051    generator.emitEnd(dstRegister.get());
    20482052    return 0;
    … …  
    20532057RegisterID* FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    20542058{
    2055     generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine());
     2059    generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine(), column());
    20562060    emitStatementsBytecode(generator, generator.ignoredResult());
    20572061
    … …  
    20692073    if (!returnNode) {
    20702074        RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
    2071         generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine());
     2075        generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
    20722076        generator.emitReturn(r0);
    20732077        return 0;
Note: See TracChangeset for help on using the changeset viewer.