Ignore:
Timestamp:
Nov 15, 2008, 12:34:40 PM (17 years ago)
Author:
[email protected]
Message:

2008-11-15 Geoffrey Garen <​[email protected]>

Reviewed by Sam Weinig.


Renamed all forms of "byte code" "opcode" "op code" "code" "bitcode"
etc. to "bytecode".

  • VM/CTI.cpp: (JSC::CTI::printBytecodeOperandTypes): (JSC::CTI::emitAllocateNumber): (JSC::CTI::emitNakedCall): (JSC::CTI::emitNakedFastCall): (JSC::CTI::emitCTICall): (JSC::CTI::emitJumpSlowCaseIfNotJSCell): (JSC::CTI::emitJumpSlowCaseIfNotImmNum): (JSC::CTI::emitJumpSlowCaseIfNotImmNums): (JSC::CTI::emitFastArithIntToImmOrSlowCase): (JSC::CTI::compileOpCall): (JSC::CTI::emitSlowScriptCheck): (JSC::CTI::compileBinaryArithOp): (JSC::CTI::compileBinaryArithOpSlowCase): (JSC::CTI::privateCompileMainPass): (JSC::CTI::privateCompileSlowCases): (JSC::CTI::privateCompile):
  • VM/CTI.h: (JSC::CallRecord::CallRecord): (JSC::SwitchRecord::SwitchRecord):
  • VM/CodeBlock.cpp: (JSC::CodeBlock::printStructureIDs): (JSC::CodeBlock::dump): (JSC::CodeBlock::~CodeBlock): (JSC::CodeBlock::derefStructureIDs): (JSC::CodeBlock::refStructureIDs):
  • VM/CodeBlock.h: (JSC::StructureStubInfo::StructureStubInfo):
  • VM/ExceptionHelpers.cpp: (JSC::createNotAnObjectError):
  • VM/Instruction.h: (JSC::Instruction::Instruction): (JSC::Instruction::):
  • VM/Machine.cpp: (JSC::BytecodeInterpreter::isBytecode): (JSC::BytecodeInterpreter::throwException): (JSC::BytecodeInterpreter::execute): (JSC::BytecodeInterpreter::tryCachePutByID): (JSC::BytecodeInterpreter::uncachePutByID): (JSC::BytecodeInterpreter::tryCacheGetByID): (JSC::BytecodeInterpreter::uncacheGetByID): (JSC::BytecodeInterpreter::privateExecute): (JSC::BytecodeInterpreter::tryCTICachePutByID): (JSC::BytecodeInterpreter::tryCTICacheGetByID): (JSC::BytecodeInterpreter::cti_op_call_JSFunction): (JSC::BytecodeInterpreter::cti_vm_dontLazyLinkCall): (JSC::BytecodeInterpreter::cti_vm_lazyLinkCall):
  • VM/Machine.h: (JSC::BytecodeInterpreter::getBytecode): (JSC::BytecodeInterpreter::getBytecodeID): (JSC::BytecodeInterpreter::isCallBytecode):
  • VM/Opcode.cpp: (JSC::): (JSC::BytecodeStats::BytecodeStats): (JSC::compareBytecodeIndices): (JSC::compareBytecodePairIndices): (JSC::BytecodeStats::~BytecodeStats): (JSC::BytecodeStats::recordInstruction): (JSC::BytecodeStats::resetLastInstruction):
  • VM/Opcode.h: (JSC::): (JSC::padBytecodeName):
  • VM/SamplingTool.cpp: (JSC::ScopeSampleRecord::sample): (JSC::SamplingTool::run): (JSC::compareBytecodeIndicesSampling): (JSC::SamplingTool::dump):
  • VM/SamplingTool.h: (JSC::ScopeSampleRecord::ScopeSampleRecord): (JSC::SamplingTool::SamplingTool):
  • bytecompiler/CodeGenerator.cpp: (JSC::CodeGenerator::generate): (JSC::CodeGenerator::CodeGenerator): (JSC::CodeGenerator::emitLabel): (JSC::CodeGenerator::emitBytecode): (JSC::CodeGenerator::emitJump): (JSC::CodeGenerator::emitJumpIfTrue): (JSC::CodeGenerator::emitJumpIfFalse): (JSC::CodeGenerator::emitMove): (JSC::CodeGenerator::emitUnaryOp): (JSC::CodeGenerator::emitPreInc): (JSC::CodeGenerator::emitPreDec): (JSC::CodeGenerator::emitPostInc): (JSC::CodeGenerator::emitPostDec): (JSC::CodeGenerator::emitBinaryOp): (JSC::CodeGenerator::emitEqualityOp): (JSC::CodeGenerator::emitUnexpectedLoad): (JSC::CodeGenerator::emitInstanceOf): (JSC::CodeGenerator::emitResolve): (JSC::CodeGenerator::emitGetScopedVar): (JSC::CodeGenerator::emitPutScopedVar): (JSC::CodeGenerator::emitResolveBase): (JSC::CodeGenerator::emitResolveWithBase): (JSC::CodeGenerator::emitResolveFunction): (JSC::CodeGenerator::emitGetById): (JSC::CodeGenerator::emitPutById): (JSC::CodeGenerator::emitPutGetter): (JSC::CodeGenerator::emitPutSetter): (JSC::CodeGenerator::emitDeleteById): (JSC::CodeGenerator::emitGetByVal): (JSC::CodeGenerator::emitPutByVal): (JSC::CodeGenerator::emitDeleteByVal): (JSC::CodeGenerator::emitPutByIndex): (JSC::CodeGenerator::emitNewObject): (JSC::CodeGenerator::emitNewArray): (JSC::CodeGenerator::emitNewFunction): (JSC::CodeGenerator::emitNewRegExp): (JSC::CodeGenerator::emitNewFunctionExpression): (JSC::CodeGenerator::emitCall): (JSC::CodeGenerator::emitReturn): (JSC::CodeGenerator::emitUnaryNoDstOp): (JSC::CodeGenerator::emitConstruct): (JSC::CodeGenerator::emitPopScope): (JSC::CodeGenerator::emitDebugHook): (JSC::CodeGenerator::emitComplexJumpScopes): (JSC::CodeGenerator::emitJumpScopes): (JSC::CodeGenerator::emitNextPropertyName): (JSC::CodeGenerator::emitCatch): (JSC::CodeGenerator::emitNewError): (JSC::CodeGenerator::emitJumpSubroutine): (JSC::CodeGenerator::emitSubroutineReturn): (JSC::CodeGenerator::emitPushNewScope): (JSC::CodeGenerator::beginSwitch): (JSC::CodeGenerator::endSwitch):
  • bytecompiler/CodeGenerator.h: (JSC::CodeGenerator::emitNode):
  • jsc.cpp: (runWithScripts):
  • masm/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::emitModRm_opr): (JSC::X86Assembler::emitModRm_opr_Unchecked): (JSC::X86Assembler::emitModRm_opm): (JSC::X86Assembler::emitModRm_opm_Unchecked): (JSC::X86Assembler::emitModRm_opmsib):
  • parser/Nodes.cpp: (JSC::NullNode::emitBytecode): (JSC::BooleanNode::emitBytecode): (JSC::NumberNode::emitBytecode): (JSC::StringNode::emitBytecode): (JSC::RegExpNode::emitBytecode): (JSC::ThisNode::emitBytecode): (JSC::ResolveNode::emitBytecode): (JSC::ArrayNode::emitBytecode): (JSC::ObjectLiteralNode::emitBytecode): (JSC::PropertyListNode::emitBytecode): (JSC::BracketAccessorNode::emitBytecode): (JSC::DotAccessorNode::emitBytecode): (JSC::ArgumentListNode::emitBytecode): (JSC::NewExprNode::emitBytecode): (JSC::EvalFunctionCallNode::emitBytecode): (JSC::FunctionCallValueNode::emitBytecode): (JSC::FunctionCallResolveNode::emitBytecode): (JSC::FunctionCallBracketNode::emitBytecode): (JSC::FunctionCallDotNode::emitBytecode): (JSC::PostfixResolveNode::emitBytecode): (JSC::PostfixBracketNode::emitBytecode): (JSC::PostfixDotNode::emitBytecode): (JSC::PostfixErrorNode::emitBytecode): (JSC::DeleteResolveNode::emitBytecode): (JSC::DeleteBracketNode::emitBytecode): (JSC::DeleteDotNode::emitBytecode): (JSC::DeleteValueNode::emitBytecode): (JSC::VoidNode::emitBytecode): (JSC::TypeOfResolveNode::emitBytecode): (JSC::TypeOfValueNode::emitBytecode): (JSC::PrefixResolveNode::emitBytecode): (JSC::PrefixBracketNode::emitBytecode): (JSC::PrefixDotNode::emitBytecode): (JSC::PrefixErrorNode::emitBytecode): (JSC::UnaryOpNode::emitBytecode): (JSC::BinaryOpNode::emitBytecode): (JSC::EqualNode::emitBytecode): (JSC::StrictEqualNode::emitBytecode): (JSC::ReverseBinaryOpNode::emitBytecode): (JSC::ThrowableBinaryOpNode::emitBytecode): (JSC::InstanceOfNode::emitBytecode): (JSC::LogicalOpNode::emitBytecode): (JSC::ConditionalNode::emitBytecode): (JSC::emitReadModifyAssignment): (JSC::ReadModifyResolveNode::emitBytecode): (JSC::AssignResolveNode::emitBytecode): (JSC::AssignDotNode::emitBytecode): (JSC::ReadModifyDotNode::emitBytecode): (JSC::AssignErrorNode::emitBytecode): (JSC::AssignBracketNode::emitBytecode): (JSC::ReadModifyBracketNode::emitBytecode): (JSC::CommaNode::emitBytecode): (JSC::ConstDeclNode::emitBytecode): (JSC::ConstStatementNode::emitBytecode): (JSC::BlockNode::emitBytecode): (JSC::EmptyStatementNode::emitBytecode): (JSC::DebuggerStatementNode::emitBytecode): (JSC::ExprStatementNode::emitBytecode): (JSC::VarStatementNode::emitBytecode): (JSC::IfNode::emitBytecode): (JSC::IfElseNode::emitBytecode): (JSC::DoWhileNode::emitBytecode): (JSC::WhileNode::emitBytecode): (JSC::ForNode::emitBytecode): (JSC::ForInNode::emitBytecode): (JSC::ContinueNode::emitBytecode): (JSC::BreakNode::emitBytecode): (JSC::ReturnNode::emitBytecode): (JSC::WithNode::emitBytecode): (JSC::SwitchNode::emitBytecode): (JSC::LabelNode::emitBytecode): (JSC::ThrowNode::emitBytecode): (JSC::TryNode::emitBytecode): (JSC::ScopeNode::ScopeNode): (JSC::EvalNode::emitBytecode): (JSC::FunctionBodyNode::emitBytecode): (JSC::ProgramNode::emitBytecode): (JSC::FuncDeclNode::emitBytecode): (JSC::FuncExprNode::emitBytecode):
  • parser/Nodes.h: (JSC::UnaryPlusNode::): (JSC::NegateNode::): (JSC::BitwiseNotNode::): (JSC::LogicalNotNode::): (JSC::MultNode::): (JSC::DivNode::): (JSC::ModNode::): (JSC::AddNode::): (JSC::SubNode::): (JSC::LeftShiftNode::): (JSC::RightShiftNode::): (JSC::UnsignedRightShiftNode::): (JSC::LessNode::): (JSC::GreaterNode::): (JSC::LessEqNode::): (JSC::GreaterEqNode::): (JSC::InstanceOfNode::): (JSC::InNode::): (JSC::EqualNode::): (JSC::NotEqualNode::): (JSC::StrictEqualNode::): (JSC::NotStrictEqualNode::): (JSC::BitAndNode::): (JSC::BitOrNode::): (JSC::BitXOrNode::): (JSC::ProgramNode::): (JSC::EvalNode::): (JSC::FunctionBodyNode::):
  • runtime/JSNotAnObject.h:
  • runtime/StructureID.cpp: (JSC::StructureID::fromDictionaryTransition):
  • wtf/Platform.h:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/parser/Nodes.cpp

    r38423 r38425  
    275275// ------------------------------ NullNode -------------------------------------
    276276
    277 RegisterID* NullNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     277RegisterID* NullNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    278278{
    279279    if (dst == ignoredResult())
    … …  
    284284// ------------------------------ BooleanNode ----------------------------------
    285285
    286 RegisterID* BooleanNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     286RegisterID* BooleanNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    287287{
    288288    if (dst == ignoredResult())
    … …  
    293293// ------------------------------ NumberNode -----------------------------------
    294294
    295 RegisterID* NumberNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     295RegisterID* NumberNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    296296{
    297297    if (dst == ignoredResult())
    … …  
    302302// ------------------------------ StringNode -----------------------------------
    303303
    304 RegisterID* StringNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     304RegisterID* StringNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    305305{
    306306    if (dst == ignoredResult())
    … …  
    311311// ------------------------------ RegExpNode -----------------------------------
    312312
    313 RegisterID* RegExpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     313RegisterID* RegExpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    314314{
    315315    RefPtr<RegExp> regExp = RegExp::create(generator.globalData(), m_pattern, m_flags);
    … …  
    323323// ------------------------------ ThisNode -------------------------------------
    324324
    325 RegisterID* ThisNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     325RegisterID* ThisNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    326326{
    327327    if (dst == ignoredResult())
    … …  
    337337}
    338338
    339 RegisterID* ResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     339RegisterID* ResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    340340{
    341341    if (RegisterID* local = generator.registerFor(m_ident)) {
    … …  
    374374}
    375375
    376 RegisterID* ArrayNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     376RegisterID* ArrayNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    377377{
    378378    // FIXME: Should we put all of this code into emitNewArray?
    … …  
    429429}
    430430
    431 RegisterID* ObjectLiteralNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     431RegisterID* ObjectLiteralNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    432432{
    433433     if (!m_list) {
    … …  
    452452}
    453453
    454 RegisterID* PropertyListNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     454RegisterID* PropertyListNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    455455{
    456456    RefPtr<RegisterID> newObj = generator.tempDestination(dst);
    … …  
    495495}
    496496
    497 RegisterID* BracketAccessorNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     497RegisterID* BracketAccessorNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    498498{
    499499    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_subscriptHasAssignments, m_subscript->isPure(generator));
    … …  
    515515}
    516516
    517 RegisterID* DotAccessorNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     517RegisterID* DotAccessorNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    518518{
    519519    RegisterID* base = generator.emitNode(m_base.get());
    … …  
    535535}
    536536
    537 RegisterID* ArgumentListNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     537RegisterID* ArgumentListNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    538538{
    539539    ASSERT(m_expr);
    … …  
    566566}
    567567
    568 RegisterID* NewExprNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     568RegisterID* NewExprNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    569569{
    570570    RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
    … …  
    584584}
    585585
    586 RegisterID* EvalFunctionCallNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     586RegisterID* EvalFunctionCallNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    587587{
    588588    RefPtr<RegisterID> func = generator.tempDestination(dst);
    … …  
    605605}
    606606
    607 RegisterID* FunctionCallValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     607RegisterID* FunctionCallValueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    608608{
    609609    RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
    … …  
    624624}
    625625
    626 RegisterID* FunctionCallResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     626RegisterID* FunctionCallResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    627627{
    628628    if (RefPtr<RegisterID> local = generator.registerFor(m_ident)) {
    … …  
    662662}
    663663
    664 RegisterID* FunctionCallBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     664RegisterID* FunctionCallBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    665665{
    666666    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    … …  
    685685}
    686686
    687 RegisterID* FunctionCallDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     687RegisterID* FunctionCallDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    688688{
    689689    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    … …  
    706706}
    707707
    708 RegisterID* PostfixResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     708RegisterID* PostfixResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    709709{
    710710    if (RegisterID* local = generator.registerFor(m_ident)) {
    … …  
    763763}
    764764
    765 RegisterID* PostfixBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     765RegisterID* PostfixBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    766766{
    767767    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    … …  
    797797}
    798798
    799 RegisterID* PostfixDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     799RegisterID* PostfixDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    800800{
    801801    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    … …  
    830830}
    831831
    832 RegisterID* PostfixErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
     832RegisterID* PostfixErrorNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    833833{
    834834    return emitThrowError(generator, ReferenceError, m_operator == OpPlusPlus ? "Postfix ++ operator applied to value that is not a reference." : "Postfix -- operator applied to value that is not a reference.");
    … …  
    837837// ------------------------------ DeleteResolveNode -----------------------------------
    838838
    839 RegisterID* DeleteResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     839RegisterID* DeleteResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    840840{
    841841    if (generator.registerFor(m_ident))
    … …  
    860860}
    861861
    862 RegisterID* DeleteBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     862RegisterID* DeleteBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    863863{
    864864    RefPtr<RegisterID> r0 = generator.emitNode(m_base.get());
    … …  
    881881}
    882882
    883 RegisterID* DeleteDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     883RegisterID* DeleteDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    884884{
    885885    RegisterID* r0 = generator.emitNode(m_base.get());
    … …  
    901901}
    902902
    903 RegisterID* DeleteValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     903RegisterID* DeleteValueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    904904{
    905905    generator.emitNode(ignoredResult(), m_expr.get());
    … …  
    921921}
    922922
    923 RegisterID* VoidNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     923RegisterID* VoidNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    924924{
    925925    if (dst == ignoredResult()) {
    … …  
    933933// ------------------------------ TypeOfValueNode -----------------------------------
    934934
    935 RegisterID* TypeOfResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     935RegisterID* TypeOfResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    936936{
    937937    if (RegisterID* local = generator.registerFor(m_ident)) {
    … …  
    960960}
    961961
    962 RegisterID* TypeOfValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     962RegisterID* TypeOfValueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    963963{
    964964    if (dst == ignoredResult()) {
    … …  
    972972// ------------------------------ PrefixResolveNode ----------------------------------
    973973
    974 RegisterID* PrefixResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     974RegisterID* PrefixResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    975975{
    976976    if (RegisterID* local = generator.registerFor(m_ident)) {
    … …  
    10171017}
    10181018
    1019 RegisterID* PrefixBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1019RegisterID* PrefixBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    10201020{
    10211021    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    … …  
    10461046}
    10471047
    1048 RegisterID* PrefixDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1048RegisterID* PrefixDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    10491049{
    10501050    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    … …  
    10741074}
    10751075
    1076 RegisterID* PrefixErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
     1076RegisterID* PrefixErrorNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    10771077{
    10781078    return emitThrowError(generator, ReferenceError, m_operator == OpPlusPlus ? "Prefix ++ operator applied to value that is not a reference." : "Prefix -- operator applied to value that is not a reference.");
    … …  
    10911091}
    10921092
    1093 RegisterID* UnaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1093RegisterID* UnaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    10941094{
    10951095    RegisterID* src = generator.emitNode(m_expr.get());
    1096     return generator.emitUnaryOp(opcode(), generator.finalDestination(dst), src, m_expr->resultDescriptor());
     1096    return generator.emitUnaryOp(bytecode(), generator.finalDestination(dst), src, m_expr->resultDescriptor());
    10971097}
    10981098
    … …  
    11101110}
    11111111
    1112 RegisterID* BinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    1113 {
    1114     OpcodeID opcode = this->opcode();
    1115     if (opcode == op_neq) {
     1112RegisterID* BinaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
     1113{
     1114    BytecodeID bytecode = this->bytecode();
     1115    if (bytecode == op_neq) {
    11161116        if (m_expr1->isNull() || m_expr2->isNull()) {
    11171117            RefPtr<RegisterID> src = generator.emitNode(dst, m_expr1->isNull() ? m_expr2.get() : m_expr1.get());
    … …  
    11221122    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
    11231123    RegisterID* src2 = generator.emitNode(m_expr2.get());
    1124     return generator.emitBinaryOp(opcode, generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor()));
    1125 }
    1126 
    1127 RegisterID* EqualNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1124    return generator.emitBinaryOp(bytecode, generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor()));
     1125}
     1126
     1127RegisterID* EqualNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    11281128{
    11291129    if (m_expr1->isNull() || m_expr2->isNull()) {
    … …  
    11371137}
    11381138
    1139 RegisterID* StrictEqualNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1139RegisterID* StrictEqualNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    11401140{
    11411141    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
    … …  
    11441144}
    11451145
    1146 RegisterID* ReverseBinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1146RegisterID* ReverseBinaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    11471147{
    11481148    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
    11491149    RegisterID* src2 = generator.emitNode(m_expr2.get());
    1150     return generator.emitBinaryOp(opcode(), generator.finalDestination(dst, src1.get()), src2, src1.get(), OperandTypes(m_expr2->resultDescriptor(), m_expr1->resultDescriptor()));
    1151 }
    1152 
    1153 RegisterID* ThrowableBinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1150    return generator.emitBinaryOp(bytecode(), generator.finalDestination(dst, src1.get()), src2, src1.get(), OperandTypes(m_expr2->resultDescriptor(), m_expr1->resultDescriptor()));
     1151}
     1152
     1153RegisterID* ThrowableBinaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    11541154{
    11551155    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
    11561156    RegisterID* src2 = generator.emitNode(m_expr2.get());
    11571157    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    1158     return generator.emitBinaryOp(opcode(), generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor()));
    1159 }
    1160 
    1161 RegisterID* InstanceOfNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1158    return generator.emitBinaryOp(bytecode(), generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor()));
     1159}
     1160
     1161RegisterID* InstanceOfNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    11621162{
    11631163    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
    … …  
    11841184}
    11851185
    1186 RegisterID* LogicalOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1186RegisterID* LogicalOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    11871187{
    11881188    RefPtr<RegisterID> temp = generator.tempDestination(dst);
    … …  
    12141214}
    12151215
    1216 RegisterID* ConditionalNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1216RegisterID* ConditionalNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    12171217{
    12181218    RefPtr<RegisterID> newDst = generator.finalDestination(dst);
    … …  
    12491249static ALWAYS_INLINE RegisterID* emitReadModifyAssignment(CodeGenerator& generator, RegisterID* dst, RegisterID* src1, RegisterID* src2, Operator oper, OperandTypes types)
    12501250{
    1251     OpcodeID opcode;
     1251    BytecodeID bytecode;
    12521252    switch (oper) {
    12531253        case OpMultEq:
    1254             opcode = op_mul;
     1254            bytecode = op_mul;
    12551255            break;
    12561256        case OpDivEq:
    1257             opcode = op_div;
     1257            bytecode = op_div;
    12581258            break;
    12591259        case OpPlusEq:
    1260             opcode = op_add;
     1260            bytecode = op_add;
    12611261            break;
    12621262        case OpMinusEq:
    1263             opcode = op_sub;
     1263            bytecode = op_sub;
    12641264            break;
    12651265        case OpLShift:
    1266             opcode = op_lshift;
     1266            bytecode = op_lshift;
    12671267            break;
    12681268        case OpRShift:
    1269             opcode = op_rshift;
     1269            bytecode = op_rshift;
    12701270            break;
    12711271        case OpURShift:
    1272             opcode = op_urshift;
     1272            bytecode = op_urshift;
    12731273            break;
    12741274        case OpAndEq:
    1275             opcode = op_bitand;
     1275            bytecode = op_bitand;
    12761276            break;
    12771277        case OpXOrEq:
    1278             opcode = op_bitxor;
     1278            bytecode = op_bitxor;
    12791279            break;
    12801280        case OpOrEq:
    1281             opcode = op_bitor;
     1281            bytecode = op_bitor;
    12821282            break;
    12831283        case OpModEq:
    1284             opcode = op_mod;
     1284            bytecode = op_mod;
    12851285            break;
    12861286        default:
    … …  
    12891289    }
    12901290   
    1291     return generator.emitBinaryOp(opcode, dst, src1, src2, types);
    1292 }
    1293 
    1294 RegisterID* ReadModifyResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1291    return generator.emitBinaryOp(bytecode, dst, src1, src2, types);
     1292}
     1293
     1294RegisterID* ReadModifyResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    12951295{
    12961296    if (RegisterID* local = generator.registerFor(m_ident)) {
    … …  
    13461346}
    13471347
    1348 RegisterID* AssignResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1348RegisterID* AssignResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    13491349{
    13501350    if (RegisterID* local = generator.registerFor(m_ident)) {
    … …  
    13881388}
    13891389
    1390 RegisterID* AssignDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1390RegisterID* AssignDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    13911391{
    13921392    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_rightHasAssignments, m_right->isPure(generator));
    … …  
    14111411}
    14121412
    1413 RegisterID* ReadModifyDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1413RegisterID* ReadModifyDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    14141414{
    14151415    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_rightHasAssignments, m_right->isPure(generator));
    … …  
    14371437}
    14381438
    1439 RegisterID* AssignErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
     1439RegisterID* AssignErrorNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    14401440{
    14411441    return emitThrowError(generator, ReferenceError, "Left side of assignment is not a reference.");
    … …  
    14561456}
    14571457
    1458 RegisterID* AssignBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1458RegisterID* AssignBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    14591459{
    14601460    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_subscriptHasAssignments || m_rightHasAssignments, m_subscript->isPure(generator) && m_right->isPure(generator));
    … …  
    14821482}
    14831483
    1484 RegisterID* ReadModifyBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1484RegisterID* ReadModifyBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    14851485{
    14861486    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_subscriptHasAssignments || m_rightHasAssignments, m_subscript->isPure(generator) && m_right->isPure(generator));
    … …  
    15111511}
    15121512
    1513 RegisterID* CommaNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1513RegisterID* CommaNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    15141514{
    15151515    generator.emitNode(ignoredResult(), m_expr1.get());
    … …  
    15531553}
    15541554
    1555 RegisterID* ConstDeclNode::emitCode(CodeGenerator& generator, RegisterID*)
     1555RegisterID* ConstDeclNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    15561556{
    15571557    RegisterID* result = 0;
    … …  
    15741574}
    15751575
    1576 RegisterID* ConstStatementNode::emitCode(CodeGenerator& generator, RegisterID*)
     1576RegisterID* ConstStatementNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    15771577{
    15781578    return generator.emitNode(m_next.get());
    … …  
    16141614}
    16151615
    1616 RegisterID* BlockNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1616RegisterID* BlockNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    16171617{
    16181618    return statementListEmitCode(m_children, generator, dst);
    … …  
    16211621// ------------------------------ EmptyStatementNode ---------------------------
    16221622
    1623 RegisterID* EmptyStatementNode::emitCode(CodeGenerator&, RegisterID* dst)
     1623RegisterID* EmptyStatementNode::emitBytecode(CodeGenerator&, RegisterID* dst)
    16241624{
    16251625    return dst;
    … …  
    16281628// ------------------------------ DebuggerStatementNode ---------------------------
    16291629
    1630 RegisterID* DebuggerStatementNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1630RegisterID* DebuggerStatementNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    16311631{
    16321632    generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine());
    … …  
    16361636// ------------------------------ ExprStatementNode ----------------------------
    16371637
    1638 RegisterID* ExprStatementNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1638RegisterID* ExprStatementNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    16391639{
    16401640    ASSERT(m_expr);
    … …  
    16541654}
    16551655
    1656 RegisterID* VarStatementNode::emitCode(CodeGenerator& generator, RegisterID*)
     1656RegisterID* VarStatementNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    16571657{
    16581658    ASSERT(m_expr);
    … …  
    16731673}
    16741674
    1675 RegisterID* IfNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1675RegisterID* IfNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    16761676{
    16771677    RefPtr<LabelID> afterThen = generator.newLabel();
    … …  
    17031703}
    17041704
    1705 RegisterID* IfElseNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1705RegisterID* IfElseNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    17061706{
    17071707    RefPtr<LabelID> beforeElse = generator.newLabel();
    … …  
    17431743}
    17441744
    1745 RegisterID* DoWhileNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1745RegisterID* DoWhileNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    17461746{
    17471747    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
    … …  
    17791779}
    17801780
    1781 RegisterID* WhileNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1781RegisterID* WhileNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    17821782{
    17831783    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
    … …  
    18191819}
    18201820
    1821 RegisterID* ForNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1821RegisterID* ForNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    18221822{
    18231823    if (dst == ignoredResult())
    … …  
    18971897}
    18981898
    1899 RegisterID* ForInNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1899RegisterID* ForInNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    19001900{
    19011901    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
    … …  
    19631963
    19641964// ECMA 12.7
    1965 RegisterID* ContinueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1965RegisterID* ContinueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    19661966{
    19671967    LabelScope* scope = generator.continueTarget(m_ident);
    … …  
    19791979
    19801980// ECMA 12.8
    1981 RegisterID* BreakNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     1981RegisterID* BreakNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    19821982{
    19831983    LabelScope* scope = generator.breakTarget(m_ident);
    … …  
    20042004}
    20052005
    2006 RegisterID* ReturnNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     2006RegisterID* ReturnNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    20072007{
    20082008    if (generator.codeType() != FunctionCode)
    … …  
    20342034}
    20352035
    2036 RegisterID* WithNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     2036RegisterID* WithNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    20372037{
    20382038    RefPtr<RegisterID> scope = generator.emitNode(m_expr.get()); // scope must be protected until popped
    … …  
    22372237}
    22382238
    2239 RegisterID* SwitchNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     2239RegisterID* SwitchNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    22402240{
    22412241    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Switch);
    … …  
    22602260}
    22612261
    2262 RegisterID* LabelNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     2262RegisterID* LabelNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    22632263{
    22642264    if (generator.breakTarget(m_name))
    … …  
    22842284}
    22852285
    2286 RegisterID* ThrowNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     2286RegisterID* ThrowNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    22872287{
    22882288    if (dst == ignoredResult())
    … …  
    23082308}
    23092309
    2310 RegisterID* TryNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     2310RegisterID* TryNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    23112311{
    23122312    RefPtr<LabelID> tryStartLabel = generator.newLabel();
    … …  
    23902390    if (funcStack)
    23912391        m_functionStack = *funcStack;
    2392 #if ENABLE(OPCODE_SAMPLING)
     2392#if ENABLE(BYTECODE_SAMPLING)
    23932393    globalData->interpreter->sampler()->notifyOfScope(this);
    23942394#endif
    … …  
    24142414}
    24152415
    2416 RegisterID* EvalNode::emitCode(CodeGenerator& generator, RegisterID*)
     2416RegisterID* EvalNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    24172417{
    24182418    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
    … …  
    25042504}
    25052505
    2506 RegisterID* FunctionBodyNode::emitCode(CodeGenerator& generator, RegisterID*)
     2506RegisterID* FunctionBodyNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    25072507{
    25082508    generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine());
    … …  
    25162516}
    25172517
    2518 RegisterID* ProgramNode::emitCode(CodeGenerator& generator, RegisterID*)
     2518RegisterID* ProgramNode::emitBytecode(CodeGenerator& generator, RegisterID*)
    25192519{
    25202520    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
    … …  
    25772577}
    25782578
    2579 RegisterID* FuncDeclNode::emitCode(CodeGenerator&, RegisterID* dst)
     2579RegisterID* FuncDeclNode::emitBytecode(CodeGenerator&, RegisterID* dst)
    25802580{
    25812581    return dst;
    … …  
    25952595}
    25962596
    2597 RegisterID* FuncExprNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     2597RegisterID* FuncExprNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
    25982598{
    25992599    return generator.emitNewFunctionExpression(generator.finalDestination(dst), this);
Note: See TracChangeset for help on using the changeset viewer.