Ignore:
Timestamp:
Jul 30, 2013, 10:01:40 AM (12 years ago)
Author:
[email protected]
Message:

Fix problems with divot and lineStart mismatches.
​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):

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r153221 r153477  
    8888RegisterID* ThrowableExpressionData::emitThrowReferenceError(BytecodeGenerator& generator, const String& message)
    8989{
    90     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     90    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    9191    generator.emitThrowReferenceError(message);
    9292    return generator.newTemporary();
    … …  
    153153    }
    154154   
    155     unsigned divot = m_startOffset + m_ident.length();
    156     generator.emitExpressionInfo(divot, m_ident.length(), 0, m_divotLine, m_divotLineStart);
     155    JSTextPosition divot = m_start + m_ident.length();
     156    generator.emitExpressionInfo(divot, m_start, divot);
    157157    RefPtr<RegisterID> scope = generator.emitResolveScope(generator.tempDestination(dst), m_ident);
    158158    return generator.emitGetFromScope(generator.finalDestination(dst), scope.get(), m_ident, ThrowIfNotFound);
    … …  
    326326        && !generator.symbolTable().slowArguments()) {
    327327        RegisterID* property = generator.emitNode(m_subscript);
    328         generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     328        generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    329329        return generator.emitGetArgumentByVal(generator.finalDestination(dst), generator.uncheckedRegisterForArguments(), property);
    330330    }
    … …  
    332332    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments, m_subscript->isPure(generator));
    333333    RegisterID* property = generator.emitNode(m_subscript);
    334     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     334    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    335335    return generator.emitGetByVal(generator.finalDestination(dst), base.get(), property);
    336336}
    … …  
    346346        if (!generator.willResolveToArguments(resolveNode->identifier()))
    347347            goto nonArgumentsPath;
    348         generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     348        generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    349349        return generator.emitGetArgumentsLength(generator.finalDestination(dst), generator.uncheckedRegisterForArguments());
    350350    }
    … …  
    352352nonArgumentsPath:
    353353    RegisterID* base = generator.emitNode(m_base);
    354     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     354    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    355355    return generator.emitGetById(generator.finalDestination(dst), base, m_ident);
    356356}
    … …  
    376376    RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());
    377377    CallArguments callArguments(generator, m_args);
    378     return generator.emitConstruct(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     378    return generator.emitConstruct(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
    379379}
    380380
    … …  
    413413        CallArguments callArguments(generator, m_args);
    414414        generator.emitLoad(callArguments.thisRegister(), jsUndefined());
    415         return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), startOffset(), divotEndOffset(), divotLine(), divotLineStart());
     415        return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd());
    416416    }
    417417
    418418    RefPtr<RegisterID> func = generator.newTemporary();
    419419    CallArguments callArguments(generator, m_args);
    420     generator.emitExpressionInfo(divot() - divotStartOffset() + 4, 4, 0, divotLine(), divotLineStart());
     420    JSTextPosition newDivot = divotStart() + 4;
     421    generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
    421422    generator.emitResolveScope(callArguments.thisRegister(), generator.propertyNames().eval);
    422423    generator.emitGetFromScope(func.get(), callArguments.thisRegister(), generator.propertyNames().eval, ThrowIfNotFound);
    423     return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), startOffset(), divotEndOffset(), divotLine(), divotLineStart());
     424    return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd());
    424425}
    425426
    … …  
    432433    CallArguments callArguments(generator, m_args);
    433434    generator.emitLoad(callArguments.thisRegister(), jsUndefined());
    434     return generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     435    return generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    435436}
    436437
    … …  
    448449        // This passes NoExpectedFunction because we expect that if the function is in a
    449450        // local variable, then it's not one of our built-in constructors.
    450         return generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     451        return generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    451452    }
    452453
    … …  
    454455    RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());
    455456    CallArguments callArguments(generator, m_args);
    456     int identifierStart = divot() - divotStartOffset();
    457 
    458     generator.emitExpressionInfo(identifierStart + m_ident.length(), m_ident.length(), 0, divotLine(), divotLineStart());
     457
     458    JSTextPosition newDivot = divotStart() + m_ident.length();
     459    generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
    459460    generator.emitResolveScope(callArguments.thisRegister(), m_ident);
    460461    generator.emitGetFromScope(func.get(), callArguments.thisRegister(), m_ident, ThrowIfNotFound);
    461     return generator.emitCall(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     462    return generator.emitCall(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
    462463}
    463464
    … …  
    468469    RefPtr<RegisterID> base = generator.emitNode(m_base);
    469470    RegisterID* property = generator.emitNode(m_subscript);
    470     generator.emitExpressionInfo(subexpressionDivot(), subexpressionStartOffset(), subexpressionEndOffset(), subexpressionLine(), subexpressionLineStart());
     471    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
    471472    RefPtr<RegisterID> function = generator.emitGetByVal(generator.tempDestination(dst), base.get(), property);
    472473    RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());
    473474    CallArguments callArguments(generator, m_args);
    474475    generator.emitMove(callArguments.thisRegister(), base.get());
    475     return generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     476    return generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    476477}
    477478
    … …  
    484485    CallArguments callArguments(generator, m_args);
    485486    generator.emitNode(callArguments.thisRegister(), m_base);
    486     generator.emitExpressionInfo(subexpressionDivot(), subexpressionStartOffset(), subexpressionEndOffset(), subexpressionLine(), subexpressionLineStart());
     487    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
    487488    generator.emitGetById(function.get(), callArguments.thisRegister(), m_ident);
    488     return generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     489    return generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    489490}
    490491
    … …  
    494495    RefPtr<Label> end = generator.newLabel();
    495496    RefPtr<RegisterID> base = generator.emitNode(m_base);
    496     generator.emitExpressionInfo(subexpressionDivot(), subexpressionStartOffset(), subexpressionEndOffset(), subexpressionLine(), subexpressionLineStart());
     497    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
    497498    RefPtr<RegisterID> function = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);
    498499    RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());
    … …  
    506507            CallArguments callArguments(generator, m_args);
    507508            generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
    508             generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     509            generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    509510            generator.emitJump(end.get());
    510511
    … …  
    514515            CallArguments callArguments(generator, m_args);
    515516            generator.emitLoad(callArguments.thisRegister(), jsUndefined());
    516             generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     517            generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    517518            generator.emitJump(end.get());
    518519        }
    … …  
    522523        CallArguments callArguments(generator, m_args);
    523524        generator.emitMove(callArguments.thisRegister(), base.get());
    524         generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     525        generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    525526    }
    526527    generator.emitLabel(end.get());
    … …  
    544545    RefPtr<Label> end = generator.newLabel();
    545546    RefPtr<RegisterID> base = generator.emitNode(m_base);
    546     generator.emitExpressionInfo(subexpressionDivot(), subexpressionStartOffset(), subexpressionEndOffset(), subexpressionLine(), subexpressionLineStart());
     547    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
    547548    RefPtr<RegisterID> function = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);
    548549    RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());
    … …  
    559560                    CallArguments callArguments(generator, m_args);
    560561                    generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
    561                     generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     562                    generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    562563                } else {
    563564                    m_args->m_listNode = m_args->m_listNode->m_next;
    … …  
    565566                    CallArguments callArguments(generator, m_args);
    566567                    generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
    567                     generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     568                    generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    568569                }
    569570                m_args->m_listNode = oldList;
    … …  
    572573                CallArguments callArguments(generator, m_args);
    573574                generator.emitLoad(callArguments.thisRegister(), jsUndefined());
    574                 generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     575                generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    575576            }
    576577        } else {
    … …  
    593594                generator.emitNode(args->m_expr);
    594595
    595             generator.emitCallVarargs(returnValue.get(), realFunction.get(), thisRegister.get(), argsRegister.get(), generator.newTemporary(), profileHookRegister.get(), divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     596            generator.emitCallVarargs(returnValue.get(), realFunction.get(), thisRegister.get(), argsRegister.get(), generator.newTemporary(), profileHookRegister.get(), divot(), divotStart(), divotEnd());
    596597        }
    597598        generator.emitJump(end.get());
    … …  
    601602        CallArguments callArguments(generator, m_args);
    602603        generator.emitMove(callArguments.thisRegister(), base.get());
    603         generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     604        generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    604605    }
    605606    generator.emitLabel(end.get());
    … …  
    640641    }
    641642
    642     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     643    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    643644    RefPtr<RegisterID> scope = generator.emitResolveScope(generator.newTemporary(), ident);
    644645    RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), ident, ThrowIfNotFound);
    … …  
    661662    RefPtr<RegisterID> property = generator.emitNode(subscript);
    662663
    663     generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->divotStartOffset(), bracketAccessor->divotEndOffset(), bracketAccessor->divotLine(), bracketAccessor->divotLineStart());
     664    generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->divotStart(), bracketAccessor->divotEnd());
    664665    RefPtr<RegisterID> value = generator.emitGetByVal(generator.newTemporary(), base.get(), property.get());
    665666    RegisterID* oldValue = emitPostIncOrDec(generator, generator.tempDestination(dst), value.get(), m_operator);
    666     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     667    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    667668    generator.emitPutByVal(base.get(), property.get(), value.get());
    668669    return generator.moveToDestinationIfNeeded(dst, oldValue);
    … …  
    681682    RefPtr<RegisterID> base = generator.emitNode(baseNode);
    682683
    683     generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->divotStartOffset(), dotAccessor->divotEndOffset(), dotAccessor->divotLine(), dotAccessor->divotLineStart());
     684    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->divotStart(), dotAccessor->divotEnd());
    684685    RefPtr<RegisterID> value = generator.emitGetById(generator.newTemporary(), base.get(), ident);
    685686    RegisterID* oldValue = emitPostIncOrDec(generator, generator.tempDestination(dst), value.get(), m_operator);
    686     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     687    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    687688    generator.emitPutById(base.get(), ident, value.get());
    688689    return generator.moveToDestinationIfNeeded(dst, oldValue);
    … …  
    712713        return generator.emitLoad(generator.finalDestination(dst), false);
    713714
    714     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     715    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    715716    RefPtr<RegisterID> base = generator.emitResolveScope(generator.tempDestination(dst), m_ident);
    716717    return generator.emitDeleteById(generator.finalDestination(dst, base.get()), base.get(), m_ident);
    … …  
    724725    RegisterID* r1 = generator.emitNode(m_subscript);
    725726
    726     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     727    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    727728    return generator.emitDeleteByVal(generator.finalDestination(dst), r0.get(), r1);
    728729}
    … …  
    734735    RegisterID* r0 = generator.emitNode(m_base);
    735736
    736     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     737    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    737738    return generator.emitDeleteById(generator.finalDestination(dst), r0, m_ident);
    738739}
    … …  
    806807    }
    807808
    808     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     809    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    809810    RefPtr<RegisterID> scope = generator.emitResolveScope(generator.tempDestination(dst), ident);
    810811    RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), ident, ThrowIfNotFound);
    … …  
    825826    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    826827
    827     generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->divotStartOffset(), bracketAccessor->divotEndOffset(), bracketAccessor->divotLine(), bracketAccessor->divotLineStart());
     828    generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->divotStart(), bracketAccessor->divotEnd());
    828829    RegisterID* value = generator.emitGetByVal(propDst.get(), base.get(), property.get());
    829830    emitIncOrDec(generator, value, m_operator);
    830     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     831    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    831832    generator.emitPutByVal(base.get(), property.get(), value);
    832833    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    … …  
    843844    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    844845
    845     generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->divotStartOffset(), dotAccessor->divotEndOffset(), dotAccessor->divotLine(), dotAccessor->divotLineStart());
     846    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->divotStart(), dotAccessor->divotEnd());
    846847    RegisterID* value = generator.emitGetById(propDst.get(), base.get(), ident);
    847848    emitIncOrDec(generator, value, m_operator);
    848     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     849    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    849850    generator.emitPutById(base.get(), ident, value);
    850851    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    … …  
    872873{
    873874    RegisterID* src = generator.emitNode(m_expr);
    874     generator.emitExpressionInfo(startOffset(), 0, 0, lineNo(), lineStartOffset());
     875    generator.emitExpressionInfo(position(), position(), position());
    875876    return generator.emitUnaryOp(opcodeID(), generator.finalDestination(dst), src);
    876877}
    … …  
    10041005    // If this is required the node is passed as 'emitExpressionInfoForMe'; do so now.
    10051006    if (emitExpressionInfoForMe)
    1006         generator.emitExpressionInfo(emitExpressionInfoForMe->divot(), emitExpressionInfoForMe->divotStartOffset(), emitExpressionInfoForMe->divotEndOffset(), emitExpressionInfoForMe->divotLine(), emitExpressionInfoForMe->divotLineStart());
    1007 
     1007        generator.emitExpressionInfo(emitExpressionInfoForMe->divot(), emitExpressionInfoForMe->divotStart(), emitExpressionInfoForMe->divotEnd());
    10081008    // If there is an assignment convert the lhs now.  This will also copy lhs to
    10091009    // the temporary register we allocated for it.
    … …  
    10771077
    10781078    if (opcodeID == op_add && m_expr1->isAdd() && m_expr1->resultDescriptor().definitelyIsString()) {
    1079         generator.emitExpressionInfo(startOffset(), 0, 0, lineNo(), lineStartOffset());
     1079        generator.emitExpressionInfo(position(), position(), position());
    10801080        return emitStrcat(generator, dst);
    10811081    }
    … …  
    10991099    bool wasTypeof = generator.m_lastOpcodeID == op_typeof;
    11001100    RegisterID* src2 = generator.emitNode(right);
    1101     generator.emitExpressionInfo(startOffset(), 0, 0, lineNo(), lineStartOffset());
     1101    generator.emitExpressionInfo(position(), position(), position());
    11021102    if (wasTypeof && (opcodeID == op_neq || opcodeID == op_nstricteq)) {
    11031103        RefPtr<RegisterID> tmp = generator.tempDestination(dst);
    … …  
    11471147    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1, m_rightHasAssignments, m_expr2->isPure(generator));
    11481148    RegisterID* src2 = generator.emitNode(m_expr2);
    1149     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1149    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    11501150    return generator.emitBinaryOp(opcodeID(), generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor()));
    11511151}
    … …  
    11591159    RefPtr<Label> target = generator.newLabel();
    11601160
    1161     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1161    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    11621162    generator.emitCheckHasInstance(dstReg.get(), src1.get(), src2.get(), target.get());
    11631163
    1164     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1164    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    11651165    generator.emitGetById(prototype.get(), src2.get(), generator.vm()->propertyNames->prototype);
    11661166
    1167     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1167    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    11681168    RegisterID* result = generator.emitInstanceOf(dstReg.get(), src1.get(), prototype.get());
    11691169    generator.emitLabel(target.get());
    … …  
    12761276    // If this is required the node is passed as 'emitExpressionInfoForMe'; do so now.
    12771277    if (emitExpressionInfoForMe)
    1278         generator.emitExpressionInfo(emitExpressionInfoForMe->divot(), emitExpressionInfoForMe->divotStartOffset(), emitExpressionInfoForMe->divotEndOffset(), emitExpressionInfoForMe->divotLine(), emitExpressionInfoForMe->divotLineStart());
    1279 
     1278        generator.emitExpressionInfo(emitExpressionInfoForMe->divot(), emitExpressionInfoForMe->divotStart(), emitExpressionInfoForMe->divotEnd());
    12801279    return generator.emitBinaryOp(opcodeID, dst, src1, src2, types);
    12811280}
    … …  
    13011300    }
    13021301
    1303     generator.emitExpressionInfo(divot() - divotStartOffset() + m_ident.length(), m_ident.length(), 0, divotLine(), divotLineStart());
     1302    JSTextPosition newDivot = divotStart() + m_ident.length();
     1303    generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
    13041304    RefPtr<RegisterID> scope = generator.emitResolveScope(generator.newTemporary(), m_ident);
    13051305    RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), m_ident, ThrowIfNotFound);
    … …  
    13211321    }
    13221322
     1323    if (generator.isStrictMode())
     1324        generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    13231325    RefPtr<RegisterID> scope = generator.emitResolveScope(generator.newTemporary(), m_ident);
    13241326    if (dst == generator.ignoredResult())
    13251327        dst = 0;
    13261328    RefPtr<RegisterID> result = generator.emitNode(dst, m_right);
    1327     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1329    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    13281330    return generator.emitPutToScope(scope.get(), m_ident, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound);
    13291331}
    … …  
    13361338    RefPtr<RegisterID> value = generator.destinationForAssignResult(dst);
    13371339    RegisterID* result = generator.emitNode(value.get(), m_right);
    1338     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1340    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    13391341    RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result);
    13401342    generator.emitPutById(base.get(), m_ident, forwardResult);
    … …  
    13481350    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_rightHasAssignments, m_right->isPure(generator));
    13491351
    1350     generator.emitExpressionInfo(subexpressionDivot(), subexpressionStartOffset(), subexpressionEndOffset(), subexpressionLine(), subexpressionLineStart());
     1352    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
    13511353    RefPtr<RegisterID> value = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);
    13521354    RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
    13531355
    1354     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1356    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    13551357    return generator.emitPutById(base.get(), m_ident, updatedValue);
    13561358}
    … …  
    13721374    RegisterID* result = generator.emitNode(value.get(), m_right);
    13731375
    1374     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1376    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    13751377    RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result);
    13761378    generator.emitPutByVal(base.get(), property.get(), forwardResult);
    … …  
    13851387    RefPtr<RegisterID> property = generator.emitNodeForLeftHandSide(m_subscript, m_rightHasAssignments, m_right->isPure(generator));
    13861388
    1387     generator.emitExpressionInfo(subexpressionDivot(), subexpressionStartOffset(), subexpressionEndOffset(), subexpressionLine(), subexpressionLineStart());
     1389    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
    13881390    RefPtr<RegisterID> value = generator.emitGetByVal(generator.tempDestination(dst), base.get(), property.get());
    13891391    RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
    13901392
    1391     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1393    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    13921394    generator.emitPutByVal(base.get(), property.get(), updatedValue);
    13931395
    … …  
    16961698            propertyName = generator.newTemporary();
    16971699            RefPtr<RegisterID> protect = propertyName;
     1700            if (generator.isStrictMode())
     1701                generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    16981702            RegisterID* scope = generator.emitResolveScope(generator.newTemporary(), ident);
    1699             generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     1703            generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    17001704            generator.emitPutToScope(scope, ident, propertyName, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound);
    17011705        } else {
    … …  
    17111715        RegisterID* base = generator.emitNode(assignNode->base());
    17121716
    1713         generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStartOffset(), assignNode->divotEndOffset(), assignNode->divotLine(), assignNode->divotLineStart());
     1717        generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStart(), assignNode->divotEnd());
    17141718        generator.emitPutById(base, ident, propertyName);
    17151719    } else {
    … …  
    17211725        RegisterID* subscript = generator.emitNode(assignNode->subscript());
    17221726       
    1723         generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStartOffset(), assignNode->divotEndOffset(), assignNode->divotLine(), assignNode->divotLineStart());
     1727        generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStart(), assignNode->divotEnd());
    17241728        generator.emitPutByVal(base.get(), subscript, propertyName);
    17251729    }   
    … …  
    18171821
    18181822    RefPtr<RegisterID> scope = generator.emitNode(m_expr);
    1819     generator.emitExpressionInfo(m_divot, m_expressionLength, 0, m_divotLine, m_divotLineStart);
     1823    generator.emitExpressionInfo(m_divot, m_divot - m_expressionLength, m_divot);
    18201824    generator.emitPushWithScope(scope.get());
    18211825    generator.emitNode(dst, m_statement);
    … …  
    20212025        dst = 0;
    20222026    RefPtr<RegisterID> expr = generator.emitNode(m_expr);
    2023     generator.emitExpressionInfo(divot(), divotStartOffset(), divotEndOffset(), divotLine(), divotLineStart());
     2027    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    20242028    generator.emitThrow(expr.get());
    20252029}
Note: See TracChangeset for help on using the changeset viewer.