diff options
Diffstat (limited to 'Source/JavaScriptCore/bytecode/CodeBlock.cpp')
| -rw-r--r-- | Source/JavaScriptCore/bytecode/CodeBlock.cpp | 1953 |
1 files changed, 763 insertions, 1190 deletions
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.cpp b/Source/JavaScriptCore/bytecode/CodeBlock.cpp index 394974eaa..eec5b7076 100644 --- a/Source/JavaScriptCore/bytecode/CodeBlock.cpp +++ b/Source/JavaScriptCore/bytecode/CodeBlock.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008-2010, 2012-2015 Apple Inc. All rights reserved. + * Copyright (C) 2008, 2009, 2010, 2012, 2013, 2014 Apple Inc. All rights reserved. * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca> * * Redistribution and use in source and binary forms, with or without @@ -11,7 +11,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -30,42 +30,35 @@ #include "config.h" #include "CodeBlock.h" -#include "BasicBlockLocation.h" #include "BytecodeGenerator.h" #include "BytecodeUseDef.h" #include "CallLinkStatus.h" #include "DFGCapabilities.h" #include "DFGCommon.h" #include "DFGDriver.h" -#include "DFGJITCode.h" +#include "DFGNode.h" #include "DFGWorklist.h" #include "Debugger.h" -#include "FunctionExecutableDump.h" #include "Interpreter.h" #include "JIT.h" #include "JITStubs.h" +#include "JSActivation.h" #include "JSCJSValue.h" #include "JSFunction.h" -#include "JSLexicalEnvironment.h" +#include "JSNameScope.h" #include "LLIntEntrypoint.h" #include "LowLevelInterpreter.h" -#include "JSCInlines.h" -#include "PolymorphicGetByIdList.h" +#include "Operations.h" #include "PolymorphicPutByIdList.h" -#include "ProfilerDatabase.h" #include "ReduceWhitespace.h" #include "Repatch.h" #include "RepatchBuffer.h" #include "SlotVisitorInlines.h" -#include "StackVisitor.h" -#include "TypeLocationCache.h" -#include "TypeProfiler.h" #include "UnlinkedInstructionStream.h" #include <wtf/BagToHashMap.h> #include <wtf/CommaPrinter.h> #include <wtf/StringExtras.h> #include <wtf/StringPrintStream.h> -#include <wtf/text/UniquedStringImpl.h> #if ENABLE(DFG_JIT) #include "DFGOperations.h" @@ -134,36 +127,22 @@ CString CodeBlock::sourceCodeOnOneLine() const return reduceWhitespace(sourceCodeForTools()); } -CString CodeBlock::hashAsStringIfPossible() const -{ - if (hasHash() || isSafeToComputeHash()) - return toCString(hash()); - return "<no-hash>"; -} - void CodeBlock::dumpAssumingJITType(PrintStream& out, JITCode::JITType jitType) const { - out.print(inferredName(), "#", hashAsStringIfPossible()); - out.print(":[", RawPointer(this), "->"); - if (!!m_alternative) - out.print(RawPointer(m_alternative.get()), "->"); - out.print(RawPointer(ownerExecutable()), ", ", jitType, codeType()); + if (hasHash() || isSafeToComputeHash()) + out.print(inferredName(), "#", hash(), ":[", RawPointer(this), "->", RawPointer(ownerExecutable()), ", ", jitType, codeType()); + else + out.print(inferredName(), "#<no-hash>:[", RawPointer(this), "->", RawPointer(ownerExecutable()), ", ", jitType, codeType()); if (codeType() == FunctionCode) out.print(specializationKind()); out.print(", ", instructionCount()); if (this->jitType() == JITCode::BaselineJIT && m_shouldAlwaysBeInlined) - out.print(" (ShouldAlwaysBeInlined)"); + out.print(" (SABI)"); if (ownerExecutable()->neverInline()) out.print(" (NeverInline)"); - if (ownerExecutable()->didTryToEnterInLoop()) - out.print(" (DidTryToEnterInLoop)"); if (ownerExecutable()->isStrictMode()) out.print(" (StrictMode)"); - if (this->jitType() == JITCode::BaselineJIT && m_didFailFTLCompilation) - out.print(" (FTLFail)"); - if (this->jitType() == JITCode::BaselineJIT && m_hasBeenCompiledWithFTL) - out.print(" (HadFTLReplacement)"); out.print("]"); } @@ -172,6 +151,11 @@ void CodeBlock::dump(PrintStream& out) const dumpAssumingJITType(out, jitType()); } +static CString constantName(int k, JSValue value) +{ + return toCString(value, "(@k", k - FirstConstantRegisterIndex, ")"); +} + static CString idName(int id0, const Identifier& ident) { return toCString(ident.impl(), "(@id", id0, ")"); @@ -179,16 +163,19 @@ static CString idName(int id0, const Identifier& ident) CString CodeBlock::registerName(int r) const { + if (r == missingThisObjectMarker()) + return "<null>"; + if (isConstantRegisterIndex(r)) - return constantName(r); + return constantName(r, getConstant(r)); - return toCString(VirtualRegister(r)); -} + if (operandIsArgument(r)) { + if (!VirtualRegister(r).toArgument()) + return "this"; + return toCString("arg", VirtualRegister(r).toArgument()); + } -CString CodeBlock::constantName(int index) const -{ - JSValue value = getConstant(index); - return toCString(value, "(", VirtualRegister(index), ")"); + return toCString("loc", VirtualRegister(r).toLocal()); } static CString regexpToSourceString(RegExp* regExp) @@ -267,14 +254,45 @@ void CodeBlock::printGetByIdOp(PrintStream& out, ExecState* exec, int location, case op_get_by_id_out_of_line: op = "get_by_id_out_of_line"; break; + case op_get_by_id_self: + op = "get_by_id_self"; + break; + case op_get_by_id_proto: + op = "get_by_id_proto"; + break; + case op_get_by_id_chain: + op = "get_by_id_chain"; + break; + case op_get_by_id_getter_self: + op = "get_by_id_getter_self"; + break; + case op_get_by_id_getter_proto: + op = "get_by_id_getter_proto"; + break; + case op_get_by_id_getter_chain: + op = "get_by_id_getter_chain"; + break; + case op_get_by_id_custom_self: + op = "get_by_id_custom_self"; + break; + case op_get_by_id_custom_proto: + op = "get_by_id_custom_proto"; + break; + case op_get_by_id_custom_chain: + op = "get_by_id_custom_chain"; + break; + case op_get_by_id_generic: + op = "get_by_id_generic"; + break; case op_get_array_length: op = "array_length"; break; + case op_get_string_length: + op = "string_length"; + break; default: RELEASE_ASSERT_NOT_REACHED(); -#if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) op = 0; -#endif } int r0 = (++it)->u.operand; int r1 = (++it)->u.operand; @@ -284,19 +302,22 @@ void CodeBlock::printGetByIdOp(PrintStream& out, ExecState* exec, int location, it += 4; // Increment up to the value profiler. } -static void dumpStructure(PrintStream& out, const char* name, Structure* structure, const Identifier& ident) +#if ENABLE(JIT) || ENABLE(LLINT) // unused in some configurations +static void dumpStructure(PrintStream& out, const char* name, ExecState* exec, Structure* structure, const Identifier& ident) { if (!structure) return; out.printf("%s = %p", name, structure); - PropertyOffset offset = structure->getConcurrently(ident.impl()); + PropertyOffset offset = structure->getConcurrently(exec->vm(), ident.impl()); if (offset != invalidOffset) out.printf(" (offset = %d)", offset); } +#endif -static void dumpChain(PrintStream& out, StructureChain* chain, const Identifier& ident) +#if ENABLE(JIT) // unused when not ENABLE(JIT), leading to silly warnings +static void dumpChain(PrintStream& out, ExecState* exec, StructureChain* chain, const Identifier& ident) { out.printf("chain = %p: [", chain); bool first = true; @@ -307,10 +328,11 @@ static void dumpChain(PrintStream& out, StructureChain* chain, const Identifier& first = false; else out.printf(", "); - dumpStructure(out, "struct", currentStructure->get(), ident); + dumpStructure(out, "struct", exec, currentStructure->get(), ident); } out.printf("]"); } +#endif void CodeBlock::printGetByIdCacheStatus(PrintStream& out, ExecState* exec, int location, const StubInfoMap& map) { @@ -320,39 +342,65 @@ void CodeBlock::printGetByIdCacheStatus(PrintStream& out, ExecState* exec, int l UNUSED_PARAM(ident); // tell the compiler to shut up in certain platform configurations. +#if ENABLE(LLINT) if (exec->interpreter()->getOpcodeID(instruction[0].u.opcode) == op_get_array_length) out.printf(" llint(array_length)"); else if (Structure* structure = instruction[4].u.structure.get()) { out.printf(" llint("); - dumpStructure(out, "struct", structure, ident); + dumpStructure(out, "struct", exec, structure, ident); out.printf(")"); } +#endif #if ENABLE(JIT) if (StructureStubInfo* stubPtr = map.get(CodeOrigin(location))) { StructureStubInfo& stubInfo = *stubPtr; - if (stubInfo.resetByGC) - out.print(" (Reset By GC)"); - if (stubInfo.seen) { out.printf(" jit("); Structure* baseStructure = 0; Structure* prototypeStructure = 0; - PolymorphicGetByIdList* list = 0; + StructureChain* chain = 0; + PolymorphicAccessStructureList* structureList = 0; + int listSize = 0; switch (stubInfo.accessType) { case access_get_by_id_self: out.printf("self"); baseStructure = stubInfo.u.getByIdSelf.baseObjectStructure.get(); break; - case access_get_by_id_list: - out.printf("list"); - list = stubInfo.u.getByIdList.list; + case access_get_by_id_proto: + out.printf("proto"); + baseStructure = stubInfo.u.getByIdProto.baseObjectStructure.get(); + prototypeStructure = stubInfo.u.getByIdProto.prototypeStructure.get(); + break; + case access_get_by_id_chain: + out.printf("chain"); + baseStructure = stubInfo.u.getByIdChain.baseObjectStructure.get(); + chain = stubInfo.u.getByIdChain.chain.get(); + break; + case access_get_by_id_self_list: + out.printf("self_list"); + structureList = stubInfo.u.getByIdSelfList.structureList; + listSize = stubInfo.u.getByIdSelfList.listSize; + break; + case access_get_by_id_proto_list: + out.printf("proto_list"); + structureList = stubInfo.u.getByIdProtoList.structureList; + listSize = stubInfo.u.getByIdProtoList.listSize; break; case access_unset: out.printf("unset"); break; + case access_get_by_id_generic: + out.printf("generic"); + break; + case access_get_array_length: + out.printf("array_length"); + break; + case access_get_string_length: + out.printf("string_length"); + break; default: RELEASE_ASSERT_NOT_REACHED(); break; @@ -360,24 +408,36 @@ void CodeBlock::printGetByIdCacheStatus(PrintStream& out, ExecState* exec, int l if (baseStructure) { out.printf(", "); - dumpStructure(out, "struct", baseStructure, ident); + dumpStructure(out, "struct", exec, baseStructure, ident); } if (prototypeStructure) { out.printf(", "); - dumpStructure(out, "prototypeStruct", baseStructure, ident); + dumpStructure(out, "prototypeStruct", exec, baseStructure, ident); } - if (list) { - out.printf(", list = %p: [", list); - for (unsigned i = 0; i < list->size(); ++i) { + if (chain) { + out.printf(", "); + dumpChain(out, exec, chain, ident); + } + + if (structureList) { + out.printf(", list = %p: [", structureList); + for (int i = 0; i < listSize; ++i) { if (i) out.printf(", "); out.printf("("); - dumpStructure(out, "base", list->at(i).structure(), ident); - if (!list->at(i).conditionSet().isEmpty()) { - out.printf(", "); - out.print(list->at(i).conditionSet()); + dumpStructure(out, "base", exec, structureList->list[i].base.get(), ident); + if (structureList->list[i].isChain) { + if (structureList->list[i].u.chain.get()) { + out.printf(", "); + dumpChain(out, exec, structureList->list[i].u.chain.get(), ident); + } + } else { + if (structureList->list[i].u.proto.get()) { + out.printf(", "); + dumpStructure(out, "proto", exec, structureList->list[i].u.proto.get(), ident); + } } out.printf(")"); } @@ -391,115 +451,7 @@ void CodeBlock::printGetByIdCacheStatus(PrintStream& out, ExecState* exec, int l #endif } -void CodeBlock::printPutByIdCacheStatus(PrintStream& out, ExecState* exec, int location, const StubInfoMap& map) -{ - Instruction* instruction = instructions().begin() + location; - - const Identifier& ident = identifier(instruction[2].u.operand); - - UNUSED_PARAM(ident); // tell the compiler to shut up in certain platform configurations. - - if (Structure* structure = instruction[4].u.structure.get()) { - switch (exec->interpreter()->getOpcodeID(instruction[0].u.opcode)) { - case op_put_by_id: - case op_put_by_id_out_of_line: - out.print(" llint("); - dumpStructure(out, "struct", structure, ident); - out.print(")"); - break; - - case op_put_by_id_transition_direct: - case op_put_by_id_transition_normal: - case op_put_by_id_transition_direct_out_of_line: - case op_put_by_id_transition_normal_out_of_line: - out.print(" llint("); - dumpStructure(out, "prev", structure, ident); - out.print(", "); - dumpStructure(out, "next", instruction[6].u.structure.get(), ident); - if (StructureChain* chain = instruction[7].u.structureChain.get()) { - out.print(", "); - dumpChain(out, chain, ident); - } - out.print(")"); - break; - - default: - out.print(" llint(unknown)"); - break; - } - } - -#if ENABLE(JIT) - if (StructureStubInfo* stubPtr = map.get(CodeOrigin(location))) { - StructureStubInfo& stubInfo = *stubPtr; - if (stubInfo.resetByGC) - out.print(" (Reset By GC)"); - - if (stubInfo.seen) { - out.printf(" jit("); - - switch (stubInfo.accessType) { - case access_put_by_id_replace: - out.print("replace, "); - dumpStructure(out, "struct", stubInfo.u.putByIdReplace.baseObjectStructure.get(), ident); - break; - case access_put_by_id_transition_normal: - case access_put_by_id_transition_direct: - out.print("transition, "); - dumpStructure(out, "prev", stubInfo.u.putByIdTransition.previousStructure.get(), ident); - out.print(", "); - dumpStructure(out, "next", stubInfo.u.putByIdTransition.structure.get(), ident); - if (stubInfo.u.putByIdTransition.rawConditionSet) - out.print(", ", ObjectPropertyConditionSet::fromRawPointer(stubInfo.u.putByIdTransition.rawConditionSet)); - break; - case access_put_by_id_list: { - out.printf("list = ["); - PolymorphicPutByIdList* list = stubInfo.u.putByIdList.list; - CommaPrinter comma; - for (unsigned i = 0; i < list->size(); ++i) { - out.print(comma, "("); - const PutByIdAccess& access = list->at(i); - - if (access.isReplace()) { - out.print("replace, "); - dumpStructure(out, "struct", access.oldStructure(), ident); - } else if (access.isSetter()) { - out.print("setter, "); - dumpStructure(out, "struct", access.oldStructure(), ident); - } else if (access.isCustom()) { - out.print("custom, "); - dumpStructure(out, "struct", access.oldStructure(), ident); - } else if (access.isTransition()) { - out.print("transition, "); - dumpStructure(out, "prev", access.oldStructure(), ident); - out.print(", "); - dumpStructure(out, "next", access.newStructure(), ident); - if (!access.conditionSet().isEmpty()) - out.print(", ", access.conditionSet()); - } else - out.print("unknown"); - - out.print(")"); - } - out.print("]"); - break; - } - case access_unset: - out.printf("unset"); - break; - default: - RELEASE_ASSERT_NOT_REACHED(); - break; - } - out.printf(")"); - } - } -#else - UNUSED_PARAM(map); -#endif -} - -void CodeBlock::printCallOp(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op, CacheDumpMode cacheDumpMode, bool& hasPrintedProfiling, const CallLinkInfoMap& map) +void CodeBlock::printCallOp(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op, CacheDumpMode cacheDumpMode, bool& hasPrintedProfiling) { int dst = (++it)->u.operand; int func = (++it)->u.operand; @@ -508,6 +460,7 @@ void CodeBlock::printCallOp(PrintStream& out, ExecState* exec, int location, con printLocationAndOp(out, exec, location, it, op); out.printf("%s, %s, %d, %d", registerName(dst).data(), registerName(func).data(), argCount, registerOffset); if (cacheDumpMode == DumpCaches) { +#if ENABLE(LLINT) LLIntCallLinkInfo* callLinkInfo = it[1].u.callLinkInfo; if (callLinkInfo->lastSeenCallee) { out.printf( @@ -515,21 +468,17 @@ void CodeBlock::printCallOp(PrintStream& out, ExecState* exec, int location, con callLinkInfo->lastSeenCallee.get(), callLinkInfo->lastSeenCallee->executable()); } +#endif #if ENABLE(JIT) - if (CallLinkInfo* info = map.get(CodeOrigin(location))) { - JSFunction* target = info->lastSeenCallee(); + if (numberOfCallLinkInfos()) { + JSFunction* target = getCallLinkInfo(location).lastSeenCallee.get(); if (target) out.printf(" jit(%p, exec %p)", target, target->executable()); } - - if (jitType() != JITCode::FTLJIT) - out.print(" status(", CallLinkStatus::computeFor(this, location, map), ")"); -#else - UNUSED_PARAM(map); #endif + out.print(" status(", CallLinkStatus::computeFor(this, location), ")"); } ++it; - ++it; dumpArrayProfiling(out, it, hasPrintedProfiling); dumpValueProfiling(out, it, hasPrintedProfiling); } @@ -544,31 +493,6 @@ void CodeBlock::printPutByIdOp(PrintStream& out, ExecState* exec, int location, it += 5; } -void CodeBlock::dumpSource() -{ - dumpSource(WTF::dataFile()); -} - -void CodeBlock::dumpSource(PrintStream& out) -{ - ScriptExecutable* executable = ownerExecutable(); - if (executable->isFunctionExecutable()) { - FunctionExecutable* functionExecutable = reinterpret_cast<FunctionExecutable*>(executable); - String source = functionExecutable->source().provider()->getRange( - functionExecutable->parametersStartOffset(), - functionExecutable->typeProfilingEndOffset() + 1); // Type profiling end offset is the character before the '}'. - - out.print("function ", inferredName(), source); - return; - } - out.print(executable->source().toString()); -} - -void CodeBlock::dumpBytecode() -{ - dumpBytecode(WTF::dataFile()); -} - void CodeBlock::dumpBytecode(PrintStream& out) { // We only use the ExecState* for things that don't actually lead to JS execution, @@ -586,19 +510,33 @@ void CodeBlock::dumpBytecode(PrintStream& out) static_cast<unsigned long>(instructions().size()), static_cast<unsigned long>(instructions().size() * sizeof(Instruction)), m_numParameters, m_numCalleeRegisters, m_numVars); - if (needsActivation() && codeType() == FunctionCode) - out.printf("; lexical environment in r%d", activationRegister().offset()); + if (symbolTable() && symbolTable()->captureCount()) { + out.printf( + "; %d captured var(s) (from r%d to r%d, inclusive)", + symbolTable()->captureCount(), symbolTable()->captureStart(), symbolTable()->captureEnd() + 1); + } + if (usesArguments()) { + out.printf( + "; uses arguments, in r%d, r%d", + argumentsRegister().offset(), + unmodifiedArgumentsRegister(argumentsRegister()).offset()); + } + if (needsFullScopeChain() && codeType() == FunctionCode) + out.printf("; activation in r%d", activationRegister().offset()); out.printf("\n"); StubInfoMap stubInfos; - CallLinkInfoMap callLinkInfos; - getStubInfoMap(stubInfos); - getCallLinkInfoMap(callLinkInfos); +#if ENABLE(JIT) + { + ConcurrentJITLocker locker(m_lock); + getStubInfoMap(locker, stubInfos); + } +#endif const Instruction* begin = instructions().begin(); const Instruction* end = instructions().end(); for (const Instruction* it = begin; it != end; ++it) - dumpBytecode(out, exec, begin, it, stubInfos, callLinkInfos); + dumpBytecode(out, exec, begin, it, stubInfos); if (numberOfIdentifiers()) { out.printf("\nIdentifiers:\n"); @@ -613,19 +551,7 @@ void CodeBlock::dumpBytecode(PrintStream& out) out.printf("\nConstants:\n"); size_t i = 0; do { - const char* sourceCodeRepresentationDescription = nullptr; - switch (m_constantsSourceCodeRepresentation[i]) { - case SourceCodeRepresentation::Double: - sourceCodeRepresentationDescription = ": in source as double"; - break; - case SourceCodeRepresentation::Integer: - sourceCodeRepresentationDescription = ": in source as integer"; - break; - case SourceCodeRepresentation::Other: - sourceCodeRepresentationDescription = ""; - break; - } - out.printf(" k%u = %s%s\n", static_cast<unsigned>(i), toCString(m_constantRegisters[i].get()).data(), sourceCodeRepresentationDescription); + out.printf(" k%u = %s\n", static_cast<unsigned>(i), toCString(m_constantRegisters[i].get()).data()); ++i; } while (i < m_constantRegisters.size()); } @@ -643,9 +569,7 @@ void CodeBlock::dumpBytecode(PrintStream& out) out.printf("\nException Handlers:\n"); unsigned i = 0; do { - HandlerInfo& handler = m_rareData->m_exceptionHandlers[i]; - out.printf("\t %d: { start: [%4d] end: [%4d] target: [%4d] } %s\n", - i + 1, handler.start, handler.end, handler.target, handler.typeName()); + out.printf("\t %d: { start: [%4d] end: [%4d] target: [%4d] depth: [%4d] }\n", i + 1, m_rareData->m_exceptionHandlers[i].start, m_rareData->m_exceptionHandlers[i].end, m_rareData->m_exceptionHandlers[i].target, m_rareData->m_exceptionHandlers[i].scopeDepth); ++i; } while (i < m_rareData->m_exceptionHandlers.size()); } @@ -674,7 +598,7 @@ void CodeBlock::dumpBytecode(PrintStream& out) out.printf(" %1d = {\n", i); StringJumpTable::StringOffsetTable::const_iterator end = m_rareData->m_stringSwitchJumpTables[i].offsetTable.end(); for (StringJumpTable::StringOffsetTable::const_iterator iter = m_rareData->m_stringSwitchJumpTables[i].offsetTable.begin(); iter != end; ++iter) - out.printf("\t\t\"%s\" => %04d\n", iter->key->utf8().data(), iter->value.branchOffset); + out.printf("\t\t\"%s\" => %04d\n", String(iter->key).utf8().data(), iter->value.branchOffset); out.printf(" }\n"); ++i; } while (i < m_rareData->m_stringSwitchJumpTables.size()); @@ -729,74 +653,52 @@ void CodeBlock::dumpRareCaseProfile(PrintStream& out, const char* name, RareCase out.print(name, profile->m_counter); } -void CodeBlock::printLocationAndOp(PrintStream& out, ExecState*, int location, const Instruction*&, const char* op) -{ - out.printf("[%4d] %-17s ", location, op); -} - -void CodeBlock::printLocationOpAndRegisterOperand(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op, int operand) -{ - printLocationAndOp(out, exec, location, it, op); - out.printf("%s", registerName(operand).data()); -} - -void CodeBlock::dumpBytecode( - PrintStream& out, ExecState* exec, const Instruction* begin, const Instruction*& it, - const StubInfoMap& stubInfos, const CallLinkInfoMap& callLinkInfos) +void CodeBlock::dumpBytecode(PrintStream& out, ExecState* exec, const Instruction* begin, const Instruction*& it, const StubInfoMap& map) { int location = it - begin; bool hasPrintedProfiling = false; - OpcodeID opcode = exec->interpreter()->getOpcodeID(it->u.opcode); - switch (opcode) { + switch (exec->interpreter()->getOpcodeID(it->u.opcode)) { case op_enter: { printLocationAndOp(out, exec, location, it, "enter"); break; } - case op_get_scope: { + case op_touch_entry: { + printLocationAndOp(out, exec, location, it, "touch_entry"); + break; + } + case op_create_activation: { int r0 = (++it)->u.operand; - printLocationOpAndRegisterOperand(out, exec, location, it, "get_scope", r0); + printLocationOpAndRegisterOperand(out, exec, location, it, "create_activation", r0); break; } - case op_create_direct_arguments: { + case op_create_arguments: { int r0 = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "create_direct_arguments"); - out.printf("%s", registerName(r0).data()); + printLocationOpAndRegisterOperand(out, exec, location, it, "create_arguments", r0); break; } - case op_create_scoped_arguments: { + case op_init_lazy_reg: { int r0 = (++it)->u.operand; - int r1 = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "create_scoped_arguments"); - out.printf("%s, %s", registerName(r0).data(), registerName(r1).data()); + printLocationOpAndRegisterOperand(out, exec, location, it, "init_lazy_reg", r0); break; } - case op_create_out_of_band_arguments: { + case op_get_callee: { int r0 = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "create_out_of_band_arguments"); - out.printf("%s", registerName(r0).data()); + printLocationOpAndRegisterOperand(out, exec, location, it, "get_callee", r0); + ++it; break; } case op_create_this: { int r0 = (++it)->u.operand; int r1 = (++it)->u.operand; unsigned inferredInlineCapacity = (++it)->u.operand; - unsigned cachedFunction = (++it)->u.operand; printLocationAndOp(out, exec, location, it, "create_this"); - out.printf("%s, %s, %u, %u", registerName(r0).data(), registerName(r1).data(), inferredInlineCapacity, cachedFunction); + out.printf("%s, %s, %u", registerName(r0).data(), registerName(r1).data(), inferredInlineCapacity); break; } case op_to_this: { int r0 = (++it)->u.operand; printLocationOpAndRegisterOperand(out, exec, location, it, "to_this", r0); - Structure* structure = (++it)->u.structure.get(); - if (structure) - out.print(", cache(struct = ", RawPointer(structure), ")"); - out.print(", ", (++it)->u.toThisStatus); - break; - } - case op_check_tdz: { - int r0 = (++it)->u.operand; - printLocationOpAndRegisterOperand(out, exec, location, it, "op_check_tdz", r0); + ++it; // Skip value profile. break; } case op_new_object: { @@ -851,20 +753,12 @@ void CodeBlock::dumpBytecode( out.printf("%s, %s", registerName(r0).data(), registerName(r1).data()); break; } - case op_profile_type: { + case op_captured_mov: { int r0 = (++it)->u.operand; + int r1 = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "captured_mov"); + out.printf("%s, %s", registerName(r0).data(), registerName(r1).data()); ++it; - ++it; - ++it; - ++it; - printLocationAndOp(out, exec, location, it, "op_profile_type"); - out.printf("%s", registerName(r0).data()); - break; - } - case op_profile_control_flow: { - BasicBlockLocation* basicBlockLocation = (++it)->u.basicBlockLocation; - printLocationAndOp(out, exec, location, it, "profile_control_flow"); - out.printf("[%d, %d]", basicBlockLocation->startOffset(), basicBlockLocation->endOffset()); break; } case op_not: { @@ -925,10 +819,6 @@ void CodeBlock::dumpBytecode( printUnaryOp(out, exec, location, it, "to_number"); break; } - case op_to_string: { - printUnaryOp(out, exec, location, it, "to_string"); - break; - } case op_negate: { printUnaryOp(out, exec, location, it, "negate"); break; @@ -1029,10 +919,6 @@ void CodeBlock::dumpBytecode( printUnaryOp(out, exec, location, it, "is_object"); break; } - case op_is_object_or_null: { - printUnaryOp(out, exec, location, it, "is_object_or_null"); - break; - } case op_is_function: { printUnaryOp(out, exec, location, it, "is_function"); break; @@ -1041,58 +927,81 @@ void CodeBlock::dumpBytecode( printBinaryOp(out, exec, location, it, "in"); break; } + case op_init_global_const_nop: { + printLocationAndOp(out, exec, location, it, "init_global_const_nop"); + it++; + it++; + it++; + it++; + break; + } + case op_init_global_const: { + WriteBarrier<Unknown>* registerPointer = (++it)->u.registerPointer; + int r0 = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "init_global_const"); + out.printf("g%d(%p), %s", m_globalObject->findRegisterIndex(registerPointer), registerPointer, registerName(r0).data()); + it++; + it++; + break; + } case op_get_by_id: case op_get_by_id_out_of_line: - case op_get_array_length: { + case op_get_by_id_self: + case op_get_by_id_proto: + case op_get_by_id_chain: + case op_get_by_id_getter_self: + case op_get_by_id_getter_proto: + case op_get_by_id_getter_chain: + case op_get_by_id_custom_self: + case op_get_by_id_custom_proto: + case op_get_by_id_custom_chain: + case op_get_by_id_generic: + case op_get_array_length: + case op_get_string_length: { printGetByIdOp(out, exec, location, it); - printGetByIdCacheStatus(out, exec, location, stubInfos); + printGetByIdCacheStatus(out, exec, location, map); dumpValueProfiling(out, it, hasPrintedProfiling); break; } + case op_get_arguments_length: { + printUnaryOp(out, exec, location, it, "get_arguments_length"); + it++; + break; + } case op_put_by_id: { printPutByIdOp(out, exec, location, it, "put_by_id"); - printPutByIdCacheStatus(out, exec, location, stubInfos); break; } case op_put_by_id_out_of_line: { printPutByIdOp(out, exec, location, it, "put_by_id_out_of_line"); - printPutByIdCacheStatus(out, exec, location, stubInfos); + break; + } + case op_put_by_id_replace: { + printPutByIdOp(out, exec, location, it, "put_by_id_replace"); + break; + } + case op_put_by_id_transition: { + printPutByIdOp(out, exec, location, it, "put_by_id_transition"); break; } case op_put_by_id_transition_direct: { printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct"); - printPutByIdCacheStatus(out, exec, location, stubInfos); break; } case op_put_by_id_transition_direct_out_of_line: { printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct_out_of_line"); - printPutByIdCacheStatus(out, exec, location, stubInfos); break; } case op_put_by_id_transition_normal: { printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal"); - printPutByIdCacheStatus(out, exec, location, stubInfos); break; } case op_put_by_id_transition_normal_out_of_line: { printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal_out_of_line"); - printPutByIdCacheStatus(out, exec, location, stubInfos); break; } - case op_put_getter_by_id: { - int r0 = (++it)->u.operand; - int id0 = (++it)->u.operand; - int r1 = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "put_getter_by_id"); - out.printf("%s, %s, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), registerName(r1).data()); - break; - } - case op_put_setter_by_id: { - int r0 = (++it)->u.operand; - int id0 = (++it)->u.operand; - int r1 = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "put_setter_by_id"); - out.printf("%s, %s, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), registerName(r1).data()); + case op_put_by_id_generic: { + printPutByIdOp(out, exec, location, it, "put_by_id_generic"); break; } case op_put_getter_setter: { @@ -1122,6 +1031,27 @@ void CodeBlock::dumpBytecode( dumpValueProfiling(out, it, hasPrintedProfiling); break; } + case op_get_argument_by_val: { + int r0 = (++it)->u.operand; + int r1 = (++it)->u.operand; + int r2 = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "get_argument_by_val"); + out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data()); + ++it; + dumpValueProfiling(out, it, hasPrintedProfiling); + break; + } + case op_get_by_pname: { + int r0 = (++it)->u.operand; + int r1 = (++it)->u.operand; + int r2 = (++it)->u.operand; + int r3 = (++it)->u.operand; + int r4 = (++it)->u.operand; + int r5 = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "get_by_pname"); + out.printf("%s, %s, %s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data(), registerName(r4).data(), registerName(r5).data()); + break; + } case op_put_by_val: { int r0 = (++it)->u.operand; int r1 = (++it)->u.operand; @@ -1280,51 +1210,73 @@ void CodeBlock::dumpBytecode( } case op_new_func: { int r0 = (++it)->u.operand; - int r1 = (++it)->u.operand; int f0 = (++it)->u.operand; + int shouldCheck = (++it)->u.operand; printLocationAndOp(out, exec, location, it, "new_func"); - out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0); + out.printf("%s, f%d, %s", registerName(r0).data(), f0, shouldCheck ? "<Checked>" : "<Unchecked>"); + break; + } + case op_new_captured_func: { + int r0 = (++it)->u.operand; + int f0 = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "new_captured_func"); + out.printf("%s, f%d", registerName(r0).data(), f0); + ++it; break; } case op_new_func_exp: { int r0 = (++it)->u.operand; - int r1 = (++it)->u.operand; int f0 = (++it)->u.operand; printLocationAndOp(out, exec, location, it, "new_func_exp"); - out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0); + out.printf("%s, f%d", registerName(r0).data(), f0); break; } case op_call: { - printCallOp(out, exec, location, it, "call", DumpCaches, hasPrintedProfiling, callLinkInfos); + printCallOp(out, exec, location, it, "call", DumpCaches, hasPrintedProfiling); break; } case op_call_eval: { - printCallOp(out, exec, location, it, "call_eval", DontDumpCaches, hasPrintedProfiling, callLinkInfos); + printCallOp(out, exec, location, it, "call_eval", DontDumpCaches, hasPrintedProfiling); break; } - - case op_construct_varargs: case op_call_varargs: { int result = (++it)->u.operand; int callee = (++it)->u.operand; int thisValue = (++it)->u.operand; int arguments = (++it)->u.operand; int firstFreeRegister = (++it)->u.operand; - int varArgOffset = (++it)->u.operand; ++it; - printLocationAndOp(out, exec, location, it, opcode == op_call_varargs ? "call_varargs" : "construct_varargs"); - out.printf("%s, %s, %s, %s, %d, %d", registerName(result).data(), registerName(callee).data(), registerName(thisValue).data(), registerName(arguments).data(), firstFreeRegister, varArgOffset); + printLocationAndOp(out, exec, location, it, "call_varargs"); + out.printf("%s, %s, %s, %s, %d", registerName(result).data(), registerName(callee).data(), registerName(thisValue).data(), registerName(arguments).data(), firstFreeRegister); dumpValueProfiling(out, it, hasPrintedProfiling); break; } - + case op_tear_off_activation: { + int r0 = (++it)->u.operand; + printLocationOpAndRegisterOperand(out, exec, location, it, "tear_off_activation", r0); + break; + } + case op_tear_off_arguments: { + int r0 = (++it)->u.operand; + int r1 = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "tear_off_arguments"); + out.printf("%s, %s", registerName(r0).data(), registerName(r1).data()); + break; + } case op_ret: { int r0 = (++it)->u.operand; printLocationOpAndRegisterOperand(out, exec, location, it, "ret", r0); break; } + case op_ret_object_or_this: { + int r0 = (++it)->u.operand; + int r1 = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "constructor_ret"); + out.printf("%s %s", registerName(r0).data(), registerName(r1).data()); + break; + } case op_construct: { - printCallOp(out, exec, location, it, "construct", DumpCaches, hasPrintedProfiling, callLinkInfos); + printCallOp(out, exec, location, it, "construct", DumpCaches, hasPrintedProfiling); break; } case op_strcat: { @@ -1342,120 +1294,49 @@ void CodeBlock::dumpBytecode( out.printf("%s, %s", registerName(r0).data(), registerName(r1).data()); break; } - case op_get_enumerable_length: { - int dst = it[1].u.operand; - int base = it[2].u.operand; - printLocationAndOp(out, exec, location, it, "op_get_enumerable_length"); - out.printf("%s, %s", registerName(dst).data(), registerName(base).data()); - it += OPCODE_LENGTH(op_get_enumerable_length) - 1; + case op_get_pnames: { + int r0 = it[1].u.operand; + int r1 = it[2].u.operand; + int r2 = it[3].u.operand; + int r3 = it[4].u.operand; + int offset = it[5].u.operand; + printLocationAndOp(out, exec, location, it, "get_pnames"); + out.printf("%s, %s, %s, %s, %d(->%d)", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data(), offset, location + offset); + it += OPCODE_LENGTH(op_get_pnames) - 1; break; } - case op_has_indexed_property: { - int dst = it[1].u.operand; + case op_next_pname: { + int dest = it[1].u.operand; int base = it[2].u.operand; - int propertyName = it[3].u.operand; - ArrayProfile* arrayProfile = it[4].u.arrayProfile; - printLocationAndOp(out, exec, location, it, "op_has_indexed_property"); - out.printf("%s, %s, %s, %p", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data(), arrayProfile); - it += OPCODE_LENGTH(op_has_indexed_property) - 1; - break; - } - case op_has_structure_property: { - int dst = it[1].u.operand; - int base = it[2].u.operand; - int propertyName = it[3].u.operand; - int enumerator = it[4].u.operand; - printLocationAndOp(out, exec, location, it, "op_has_structure_property"); - out.printf("%s, %s, %s, %s", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data(), registerName(enumerator).data()); - it += OPCODE_LENGTH(op_has_structure_property) - 1; - break; - } - case op_has_generic_property: { - int dst = it[1].u.operand; - int base = it[2].u.operand; - int propertyName = it[3].u.operand; - printLocationAndOp(out, exec, location, it, "op_has_generic_property"); - out.printf("%s, %s, %s", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data()); - it += OPCODE_LENGTH(op_has_generic_property) - 1; - break; - } - case op_get_direct_pname: { - int dst = it[1].u.operand; - int base = it[2].u.operand; - int propertyName = it[3].u.operand; - int index = it[4].u.operand; - int enumerator = it[5].u.operand; - ValueProfile* profile = it[6].u.profile; - printLocationAndOp(out, exec, location, it, "op_get_direct_pname"); - out.printf("%s, %s, %s, %s, %s, %p", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data(), registerName(index).data(), registerName(enumerator).data(), profile); - it += OPCODE_LENGTH(op_get_direct_pname) - 1; - break; - - } - case op_get_property_enumerator: { - int dst = it[1].u.operand; - int base = it[2].u.operand; - printLocationAndOp(out, exec, location, it, "op_get_property_enumerator"); - out.printf("%s, %s", registerName(dst).data(), registerName(base).data()); - it += OPCODE_LENGTH(op_get_property_enumerator) - 1; - break; - } - case op_enumerator_structure_pname: { - int dst = it[1].u.operand; - int enumerator = it[2].u.operand; - int index = it[3].u.operand; - printLocationAndOp(out, exec, location, it, "op_enumerator_structure_pname"); - out.printf("%s, %s, %s", registerName(dst).data(), registerName(enumerator).data(), registerName(index).data()); - it += OPCODE_LENGTH(op_enumerator_structure_pname) - 1; - break; - } - case op_enumerator_generic_pname: { - int dst = it[1].u.operand; - int enumerator = it[2].u.operand; - int index = it[3].u.operand; - printLocationAndOp(out, exec, location, it, "op_enumerator_generic_pname"); - out.printf("%s, %s, %s", registerName(dst).data(), registerName(enumerator).data(), registerName(index).data()); - it += OPCODE_LENGTH(op_enumerator_generic_pname) - 1; - break; - } - case op_to_index_string: { - int dst = it[1].u.operand; - int index = it[2].u.operand; - printLocationAndOp(out, exec, location, it, "op_to_index_string"); - out.printf("%s, %s", registerName(dst).data(), registerName(index).data()); - it += OPCODE_LENGTH(op_to_index_string) - 1; + int i = it[3].u.operand; + int size = it[4].u.operand; + int iter = it[5].u.operand; + int offset = it[6].u.operand; + printLocationAndOp(out, exec, location, it, "next_pname"); + out.printf("%s, %s, %s, %s, %s, %d(->%d)", registerName(dest).data(), registerName(base).data(), registerName(i).data(), registerName(size).data(), registerName(iter).data(), offset, location + offset); + it += OPCODE_LENGTH(op_next_pname) - 1; break; } case op_push_with_scope: { - int dst = (++it)->u.operand; - int newScope = (++it)->u.operand; - int currentScope = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "push_with_scope"); - out.printf("%s, %s, %s", registerName(dst).data(), registerName(newScope).data(), registerName(currentScope).data()); + int r0 = (++it)->u.operand; + printLocationOpAndRegisterOperand(out, exec, location, it, "push_with_scope", r0); break; } - case op_get_parent_scope: { - int dst = (++it)->u.operand; - int parentScope = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "get_parent_scope"); - out.printf("%s, %s", registerName(dst).data(), registerName(parentScope).data()); + case op_pop_scope: { + printLocationAndOp(out, exec, location, it, "pop_scope"); break; } - case op_create_lexical_environment: { - int dst = (++it)->u.operand; - int scope = (++it)->u.operand; - int symbolTable = (++it)->u.operand; - int initialValue = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "create_lexical_environment"); - out.printf("%s, %s, %s, %s", - registerName(dst).data(), registerName(scope).data(), registerName(symbolTable).data(), registerName(initialValue).data()); + case op_push_name_scope: { + int id0 = (++it)->u.operand; + int r1 = (++it)->u.operand; + unsigned attributes = (++it)->u.operand; + printLocationAndOp(out, exec, location, it, "push_name_scope"); + out.printf("%s, %s, %u", idName(id0, identifier(id0)).data(), registerName(r1).data(), attributes); break; } case op_catch: { int r0 = (++it)->u.operand; - int r1 = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "catch"); - out.printf("%s, %s", registerName(r0).data(), registerName(r1).data()); + printLocationOpAndRegisterOperand(out, exec, location, it, "catch", r0); break; } case op_throw: { @@ -1467,7 +1348,7 @@ void CodeBlock::dumpBytecode( int k0 = (++it)->u.operand; int k1 = (++it)->u.operand; printLocationAndOp(out, exec, location, it, "throw_static_error"); - out.printf("%s, %s", constantName(k0).data(), k1 ? "true" : "false"); + out.printf("%s, %s", constantName(k0, getConstant(k0)).data(), k1 ? "true" : "false"); break; } case op_debug: { @@ -1494,14 +1375,11 @@ void CodeBlock::dumpBytecode( } case op_resolve_scope: { int r0 = (++it)->u.operand; - int scope = (++it)->u.operand; int id0 = (++it)->u.operand; - ResolveModeAndType modeAndType = ResolveModeAndType((++it)->u.operand); - int depth = (++it)->u.operand; + int resolveModeAndType = (++it)->u.operand; + ++it; // depth printLocationAndOp(out, exec, location, it, "resolve_scope"); - out.printf("%s, %s, %s, %u<%s|%s>, %d", registerName(r0).data(), registerName(scope).data(), idName(id0, identifier(id0)).data(), - modeAndType.operand(), resolveModeName(modeAndType.mode()), resolveTypeName(modeAndType.type()), - depth); + out.printf("%s, %s, %d", registerName(r0).data(), idName(id0, identifier(id0)).data(), resolveModeAndType); ++it; break; } @@ -1509,54 +1387,29 @@ void CodeBlock::dumpBytecode( int r0 = (++it)->u.operand; int r1 = (++it)->u.operand; int id0 = (++it)->u.operand; - ResolveModeAndType modeAndType = ResolveModeAndType((++it)->u.operand); + int resolveModeAndType = (++it)->u.operand; ++it; // Structure - int operand = (++it)->u.operand; // Operand + ++it; // Operand + ++it; // Skip value profile. printLocationAndOp(out, exec, location, it, "get_from_scope"); - out.print(registerName(r0), ", ", registerName(r1)); - if (static_cast<unsigned>(id0) == UINT_MAX) - out.print(", anonymous"); - else - out.print(", ", idName(id0, identifier(id0))); - out.print(", ", modeAndType.operand(), "<", resolveModeName(modeAndType.mode()), "|", resolveTypeName(modeAndType.type()), ">, ", operand); - dumpValueProfiling(out, it, hasPrintedProfiling); + out.printf("%s, %s, %s, %d", registerName(r0).data(), registerName(r1).data(), idName(id0, identifier(id0)).data(), resolveModeAndType); break; } case op_put_to_scope: { int r0 = (++it)->u.operand; int id0 = (++it)->u.operand; int r1 = (++it)->u.operand; - ResolveModeAndType modeAndType = ResolveModeAndType((++it)->u.operand); + int resolveModeAndType = (++it)->u.operand; ++it; // Structure - int operand = (++it)->u.operand; // Operand + ++it; // Operand printLocationAndOp(out, exec, location, it, "put_to_scope"); - out.print(registerName(r0)); - if (static_cast<unsigned>(id0) == UINT_MAX) - out.print(", anonymous"); - else - out.print(", ", idName(id0, identifier(id0))); - out.print(", ", registerName(r1), ", ", modeAndType.operand(), "<", resolveModeName(modeAndType.mode()), "|", resolveTypeName(modeAndType.type()), ">, <structure>, ", operand); - break; - } - case op_get_from_arguments: { - int r0 = (++it)->u.operand; - int r1 = (++it)->u.operand; - int offset = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "get_from_arguments"); - out.printf("%s, %s, %d", registerName(r0).data(), registerName(r1).data(), offset); - dumpValueProfiling(out, it, hasPrintedProfiling); - break; - } - case op_put_to_arguments: { - int r0 = (++it)->u.operand; - int offset = (++it)->u.operand; - int r1 = (++it)->u.operand; - printLocationAndOp(out, exec, location, it, "put_to_arguments"); - out.printf("%s, %d, %s", registerName(r0).data(), offset, registerName(r1).data()); + out.printf("%s, %s, %s, %d", registerName(r0).data(), idName(id0, identifier(id0)).data(), registerName(r1).data(), resolveModeAndType); break; } +#if ENABLE(LLINT_C_LOOP) default: RELEASE_ASSERT_NOT_REACHED(); +#endif } dumpRareCaseProfile(out, "rare case: ", rareCaseProfileForBytecodeOffset(location), hasPrintedProfiling); @@ -1568,7 +1421,7 @@ void CodeBlock::dumpBytecode( out.print(" !! frequent exits: "); CommaPrinter comma; for (unsigned i = 0; i < exitSites.size(); ++i) - out.print(comma, exitSites[i].kind(), " ", exitSites[i].jitType()); + out.print(comma, exitSites[i].kind()); } #else // ENABLE(DFG_JIT) UNUSED_PARAM(location); @@ -1576,13 +1429,11 @@ void CodeBlock::dumpBytecode( out.print("\n"); } -void CodeBlock::dumpBytecode( - PrintStream& out, unsigned bytecodeOffset, - const StubInfoMap& stubInfos, const CallLinkInfoMap& callLinkInfos) +void CodeBlock::dumpBytecode(PrintStream& out, unsigned bytecodeOffset) { ExecState* exec = m_globalObject->globalExec(); const Instruction* it = instructions().begin() + bytecodeOffset; - dumpBytecode(out, exec, instructions().begin(), it, stubInfos, callLinkInfos); + dumpBytecode(out, exec, instructions().begin(), it); } #define FOR_EACH_MEMBER_VECTOR(macro) \ @@ -1610,28 +1461,6 @@ static size_t sizeInBytes(const Vector<T>& vector) return vector.capacity() * sizeof(T); } -namespace { - -class PutToScopeFireDetail : public FireDetail { -public: - PutToScopeFireDetail(CodeBlock* codeBlock, const Identifier& ident) - : m_codeBlock(codeBlock) - , m_ident(ident) - { - } - - virtual void dump(PrintStream& out) const override - { - out.print("Linking put_to_scope in ", FunctionExecutableDump(jsCast<FunctionExecutable*>(m_codeBlock->ownerExecutable())), " for ", m_ident); - } - -private: - CodeBlock* m_codeBlock; - const Identifier& m_ident; -}; - -} // anonymous namespace - CodeBlock::CodeBlock(CopyParsedBlockTag, CodeBlock& other) : m_globalObject(other.m_globalObject) , m_heap(other.m_heap) @@ -1640,26 +1469,22 @@ CodeBlock::CodeBlock(CopyParsedBlockTag, CodeBlock& other) , m_isConstructor(other.m_isConstructor) , m_shouldAlwaysBeInlined(true) , m_didFailFTLCompilation(false) - , m_hasBeenCompiledWithFTL(false) , m_unlinkedCode(*other.m_vm, other.m_ownerExecutable.get(), other.m_unlinkedCode.get()) - , m_hasDebuggerStatement(false) , m_steppingMode(SteppingModeDisabled) , m_numBreakpoints(0) , m_ownerExecutable(*other.m_vm, other.m_ownerExecutable.get(), other.m_ownerExecutable.get()) , m_vm(other.m_vm) , m_instructions(other.m_instructions) , m_thisRegister(other.m_thisRegister) - , m_scopeRegister(other.m_scopeRegister) - , m_lexicalEnvironmentRegister(other.m_lexicalEnvironmentRegister) + , m_argumentsRegister(other.m_argumentsRegister) + , m_activationRegister(other.m_activationRegister) , m_isStrictMode(other.m_isStrictMode) , m_needsActivation(other.m_needsActivation) - , m_mayBeExecuting(false) , m_source(other.m_source) , m_sourceOffset(other.m_sourceOffset) , m_firstLineColumnOffset(other.m_firstLineColumnOffset) , m_codeType(other.m_codeType) , m_constantRegisters(other.m_constantRegisters) - , m_constantsSourceCodeRepresentation(other.m_constantsSourceCodeRepresentation) , m_functionDecls(other.m_functionDecls) , m_functionExprs(other.m_functionExprs) , m_osrExitCounter(0) @@ -1670,11 +1495,11 @@ CodeBlock::CodeBlock(CopyParsedBlockTag, CodeBlock& other) , m_capabilityLevelState(DFG::CapabilityLevelNotSet) #endif { - m_visitAggregateHasBeenCalled.store(false, std::memory_order_relaxed); - ASSERT(m_heap->isDeferred()); - ASSERT(m_scopeRegister.isLocal()); - + + if (SymbolTable* symbolTable = other.symbolTable()) + m_symbolTable.set(*m_vm, m_ownerExecutable.get(), symbolTable); + setNumParameters(other.numParameters()); optimizeAfterWarmUp(); jitAfterWarmUp(); @@ -1689,7 +1514,7 @@ CodeBlock::CodeBlock(CopyParsedBlockTag, CodeBlock& other) } m_heap->m_codeBlocks.add(this); - m_heap->reportExtraMemoryAllocated(sizeof(CodeBlock)); + m_heap->reportExtraMemoryCost(sizeof(CodeBlock)); } CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlinkedCodeBlock, JSScope* scope, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset, unsigned firstLineColumnOffset) @@ -1700,19 +1525,16 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin , m_isConstructor(unlinkedCodeBlock->isConstructor()) , m_shouldAlwaysBeInlined(true) , m_didFailFTLCompilation(false) - , m_hasBeenCompiledWithFTL(false) , m_unlinkedCode(m_globalObject->vm(), ownerExecutable, unlinkedCodeBlock) - , m_hasDebuggerStatement(false) , m_steppingMode(SteppingModeDisabled) , m_numBreakpoints(0) , m_ownerExecutable(m_globalObject->vm(), ownerExecutable, ownerExecutable) , m_vm(unlinkedCodeBlock->vm()) , m_thisRegister(unlinkedCodeBlock->thisRegister()) - , m_scopeRegister(unlinkedCodeBlock->scopeRegister()) - , m_lexicalEnvironmentRegister(unlinkedCodeBlock->activationRegister()) + , m_argumentsRegister(unlinkedCodeBlock->argumentsRegister()) + , m_activationRegister(unlinkedCodeBlock->activationRegister()) , m_isStrictMode(unlinkedCodeBlock->isStrictMode()) - , m_needsActivation(unlinkedCodeBlock->hasActivationRegister() && unlinkedCodeBlock->codeType() == FunctionCode) - , m_mayBeExecuting(false) + , m_needsActivation(unlinkedCodeBlock->needsFullScopeChain() && unlinkedCodeBlock->codeType() == FunctionCode) , m_source(sourceProvider) , m_sourceOffset(sourceOffset) , m_firstLineColumnOffset(firstLineColumnOffset) @@ -1724,59 +1546,54 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin , m_capabilityLevelState(DFG::CapabilityLevelNotSet) #endif { - m_visitAggregateHasBeenCalled.store(false, std::memory_order_relaxed); - ASSERT(m_heap->isDeferred()); - ASSERT(m_scopeRegister.isLocal()); + bool didCloneSymbolTable = false; + + if (SymbolTable* symbolTable = unlinkedCodeBlock->symbolTable()) { + if (codeType() == FunctionCode && symbolTable->captureCount()) { + m_symbolTable.set(*m_vm, m_ownerExecutable.get(), symbolTable->clone(*m_vm)); + didCloneSymbolTable = true; + } else + m_symbolTable.set(*m_vm, m_ownerExecutable.get(), symbolTable); + } + ASSERT(m_source); setNumParameters(unlinkedCodeBlock->numParameters()); - if (vm()->typeProfiler() || vm()->controlFlowProfiler()) - vm()->functionHasExecutedCache()->removeUnexecutedRange(m_ownerExecutable->sourceID(), m_ownerExecutable->typeProfilingStartOffset(), m_ownerExecutable->typeProfilingEndOffset()); - - setConstantRegisters(unlinkedCodeBlock->constantRegisters(), unlinkedCodeBlock->constantsSourceCodeRepresentation()); + setConstantRegisters(unlinkedCodeBlock->constantRegisters()); if (unlinkedCodeBlock->usesGlobalObject()) - m_constantRegisters[unlinkedCodeBlock->globalObjectRegister().toConstantIndex()].set(*m_vm, ownerExecutable, m_globalObject.get()); - - for (unsigned i = 0; i < LinkTimeConstantCount; i++) { - LinkTimeConstant type = static_cast<LinkTimeConstant>(i); - if (unsigned registerIndex = unlinkedCodeBlock->registerIndexForLinkTimeConstant(type)) - m_constantRegisters[registerIndex].set(*m_vm, ownerExecutable, m_globalObject->jsCellForLinkTimeConstant(type)); - } - - HashSet<int, WTF::IntHash<int>, WTF::UnsignedWithZeroKeyHashTraits<int>> clonedConstantSymbolTables; - { - HashSet<SymbolTable*> clonedSymbolTables; - for (unsigned i = 0; i < m_constantRegisters.size(); i++) { - if (m_constantRegisters[i].get().isEmpty()) - continue; - if (SymbolTable* symbolTable = jsDynamicCast<SymbolTable*>(m_constantRegisters[i].get())) { - RELEASE_ASSERT(clonedSymbolTables.add(symbolTable).isNewEntry); - if (m_vm->typeProfiler()) { - ConcurrentJITLocker locker(symbolTable->m_lock); - symbolTable->prepareForTypeProfiling(locker); - } - m_constantRegisters[i].set(*m_vm, ownerExecutable, symbolTable->cloneScopePart(*m_vm)); - clonedConstantSymbolTables.add(i + FirstConstantRegisterIndex); - } - } - } - + m_constantRegisters[unlinkedCodeBlock->globalObjectRegister().offset()].set(*m_vm, ownerExecutable, m_globalObject.get()); m_functionDecls.resizeToFit(unlinkedCodeBlock->numberOfFunctionDecls()); for (size_t count = unlinkedCodeBlock->numberOfFunctionDecls(), i = 0; i < count; ++i) { UnlinkedFunctionExecutable* unlinkedExecutable = unlinkedCodeBlock->functionDecl(i); - if (vm()->typeProfiler() || vm()->controlFlowProfiler()) - vm()->functionHasExecutedCache()->insertUnexecutedRange(m_ownerExecutable->sourceID(), unlinkedExecutable->typeProfilingStartOffset(), unlinkedExecutable->typeProfilingEndOffset()); - m_functionDecls[i].set(*m_vm, ownerExecutable, unlinkedExecutable->link(*m_vm, ownerExecutable->source())); + unsigned lineCount = unlinkedExecutable->lineCount(); + unsigned firstLine = ownerExecutable->lineNo() + unlinkedExecutable->firstLineOffset(); + bool startColumnIsOnOwnerStartLine = !unlinkedExecutable->firstLineOffset(); + unsigned startColumn = unlinkedExecutable->unlinkedBodyStartColumn() + (startColumnIsOnOwnerStartLine ? ownerExecutable->startColumn() : 1); + bool endColumnIsOnStartLine = !lineCount; + unsigned endColumn = unlinkedExecutable->unlinkedBodyEndColumn() + (endColumnIsOnStartLine ? startColumn : 1); + unsigned startOffset = sourceOffset + unlinkedExecutable->startOffset(); + unsigned sourceLength = unlinkedExecutable->sourceLength(); + SourceCode code(m_source, startOffset, startOffset + sourceLength, firstLine, startColumn); + FunctionExecutable* executable = FunctionExecutable::create(*m_vm, code, unlinkedExecutable, firstLine, firstLine + lineCount, startColumn, endColumn); + m_functionDecls[i].set(*m_vm, ownerExecutable, executable); } m_functionExprs.resizeToFit(unlinkedCodeBlock->numberOfFunctionExprs()); for (size_t count = unlinkedCodeBlock->numberOfFunctionExprs(), i = 0; i < count; ++i) { UnlinkedFunctionExecutable* unlinkedExecutable = unlinkedCodeBlock->functionExpr(i); - if (vm()->typeProfiler() || vm()->controlFlowProfiler()) - vm()->functionHasExecutedCache()->insertUnexecutedRange(m_ownerExecutable->sourceID(), unlinkedExecutable->typeProfilingStartOffset(), unlinkedExecutable->typeProfilingEndOffset()); - m_functionExprs[i].set(*m_vm, ownerExecutable, unlinkedExecutable->link(*m_vm, ownerExecutable->source())); + unsigned lineCount = unlinkedExecutable->lineCount(); + unsigned firstLine = ownerExecutable->lineNo() + unlinkedExecutable->firstLineOffset(); + bool startColumnIsOnOwnerStartLine = !unlinkedExecutable->firstLineOffset(); + unsigned startColumn = unlinkedExecutable->unlinkedBodyStartColumn() + (startColumnIsOnOwnerStartLine ? ownerExecutable->startColumn() : 1); + bool endColumnIsOnStartLine = !lineCount; + unsigned endColumn = unlinkedExecutable->unlinkedBodyEndColumn() + (endColumnIsOnStartLine ? startColumn : 1); + unsigned startOffset = sourceOffset + unlinkedExecutable->startOffset(); + unsigned sourceLength = unlinkedExecutable->sourceLength(); + SourceCode code(m_source, startOffset, startOffset + sourceLength, firstLine, startColumn); + FunctionExecutable* executable = FunctionExecutable::create(*m_vm, code, unlinkedExecutable, firstLine, firstLine + lineCount, startColumn, endColumn); + m_functionExprs[i].set(*m_vm, ownerExecutable, executable); } if (unlinkedCodeBlock->hasRareData()) { @@ -1790,13 +1607,15 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin } if (size_t count = unlinkedCodeBlock->numberOfExceptionHandlers()) { m_rareData->m_exceptionHandlers.resizeToFit(count); + size_t nonLocalScopeDepth = scope->depth(); for (size_t i = 0; i < count; i++) { - const UnlinkedHandlerInfo& unlinkedHandler = unlinkedCodeBlock->exceptionHandler(i); - HandlerInfo& handler = m_rareData->m_exceptionHandlers[i]; -#if ENABLE(JIT) - handler.initialize(unlinkedHandler, CodeLocationLabel(MacroAssemblerCodePtr::createFromExecutableAddress(LLInt::getCodePtr(op_catch)))); -#else - handler.initialize(unlinkedHandler); + const UnlinkedHandlerInfo& handler = unlinkedCodeBlock->exceptionHandler(i); + m_rareData->m_exceptionHandlers[i].start = handler.start; + m_rareData->m_exceptionHandlers[i].end = handler.end; + m_rareData->m_exceptionHandlers[i].target = handler.target; + m_rareData->m_exceptionHandlers[i].scopeDepth = nonLocalScopeDepth + handler.scopeDepth; +#if ENABLE(JIT) && ENABLE(LLINT) + m_rareData->m_exceptionHandlers[i].nativeCode = CodeLocationLabel(MacroAssemblerCodePtr::createFromExecutableAddress(LLInt::getCodePtr(llint_op_catch))); #endif } } @@ -1826,8 +1645,10 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin } // Allocate metadata buffers for the bytecode +#if ENABLE(LLINT) if (size_t size = unlinkedCodeBlock->numberOfLLintCallLinkInfos()) m_llintCallLinkInfos.resizeToFit(size); +#endif if (size_t size = unlinkedCodeBlock->numberOfArrayProfiles()) m_arrayProfiles.grow(size); if (size_t size = unlinkedCodeBlock->numberOfArrayAllocationProfiles()) @@ -1841,8 +1662,7 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin unsigned instructionCount = unlinkedCodeBlock->instructions().count(); UnlinkedInstructionStream::Reader instructionReader(unlinkedCodeBlock->instructions()); - RefCountedArray<Instruction> instructions(instructionCount); - + Vector<Instruction, 0, UnsafeVectorOverflow> instructions(instructionCount); for (unsigned i = 0; !instructionReader.atEnd(); ) { const UnlinkedInstruction* pc = instructionReader.next(); @@ -1855,25 +1675,16 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin instructions[i + j].u.operand = pc[j].u.operand; } switch (pc[0].u.opcode) { - case op_has_indexed_property: { - int arrayProfileIndex = pc[opLength - 1].u.operand; - m_arrayProfiles[arrayProfileIndex] = ArrayProfile(i); - - instructions[i + opLength - 1] = &m_arrayProfiles[arrayProfileIndex]; - break; - } case op_call_varargs: - case op_construct_varargs: - case op_get_by_val: { + case op_get_by_val: + case op_get_argument_by_val: { int arrayProfileIndex = pc[opLength - 2].u.operand; m_arrayProfiles[arrayProfileIndex] = ArrayProfile(i); instructions[i + opLength - 2] = &m_arrayProfiles[arrayProfileIndex]; FALLTHROUGH; } - case op_get_direct_pname: - case op_get_by_id: - case op_get_from_arguments: { + case op_get_by_id: { ValueProfile* profile = &m_valueProfiles[pc[opLength - 1].u.operand]; ASSERT(profile->m_bytecodeOffset == -1); profile->m_bytecodeOffset = i; @@ -1920,11 +1731,15 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin int arrayProfileIndex = pc[opLength - 2].u.operand; m_arrayProfiles[arrayProfileIndex] = ArrayProfile(i); instructions[i + opLength - 2] = &m_arrayProfiles[arrayProfileIndex]; +#if ENABLE(LLINT) instructions[i + 5] = &m_llintCallLinkInfos[pc[5].u.operand]; +#endif break; } case op_construct: { +#if ENABLE(LLINT) instructions[i + 5] = &m_llintCallLinkInfos[pc[5].u.operand]; +#endif ValueProfile* profile = &m_valueProfiles[pc[opLength - 1].u.operand]; ASSERT(profile->m_bytecodeOffset == -1); profile->m_bytecodeOffset = i; @@ -1932,28 +1747,41 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin break; } case op_get_by_id_out_of_line: + case op_get_by_id_self: + case op_get_by_id_proto: + case op_get_by_id_chain: + case op_get_by_id_getter_self: + case op_get_by_id_getter_proto: + case op_get_by_id_getter_chain: + case op_get_by_id_custom_self: + case op_get_by_id_custom_proto: + case op_get_by_id_custom_chain: + case op_get_by_id_generic: case op_get_array_length: + case op_get_string_length: CRASH(); - case op_create_lexical_environment: { - int symbolTableIndex = pc[3].u.operand; - RELEASE_ASSERT(clonedConstantSymbolTables.contains(symbolTableIndex)); + case op_init_global_const_nop: { + ASSERT(codeType() == GlobalCode); + Identifier ident = identifier(pc[4].u.operand); + SymbolTableEntry entry = m_globalObject->symbolTable()->get(ident.impl()); + if (entry.isNull()) + break; + + instructions[i + 0] = vm()->interpreter->getOpcode(op_init_global_const); + instructions[i + 1] = &m_globalObject->registerAt(entry.getIndex()); break; } case op_resolve_scope: { - const Identifier& ident = identifier(pc[3].u.operand); - ResolveType type = static_cast<ResolveType>(pc[4].u.operand); - RELEASE_ASSERT(type != LocalClosureVar); - int localScopeDepth = pc[5].u.operand; - - ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Get, type); - instructions[i + 4].u.operand = op.type; - instructions[i + 5].u.operand = op.depth; - if (op.lexicalEnvironment) - instructions[i + 6].u.symbolTable.set(*vm(), ownerExecutable, op.lexicalEnvironment->symbolTable()); - else - instructions[i + 6].u.pointer = nullptr; + const Identifier& ident = identifier(pc[2].u.operand); + ResolveType type = static_cast<ResolveType>(pc[3].u.operand); + + ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), scope, ident, Get, type); + instructions[i + 3].u.operand = op.type; + instructions[i + 4].u.operand = op.depth; + if (op.activation) + instructions[i + 5].u.activation.set(*vm(), ownerExecutable, op.activation); break; } @@ -1964,18 +1792,9 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin instructions[i + opLength - 1] = profile; // get_from_scope dst, scope, id, ResolveModeAndType, Structure, Operand - - int localScopeDepth = pc[5].u.operand; - instructions[i + 5].u.pointer = nullptr; - - ResolveModeAndType modeAndType = ResolveModeAndType(pc[4].u.operand); - if (modeAndType.type() == LocalClosureVar) { - instructions[i + 4] = ResolveModeAndType(modeAndType.mode(), ClosureVar).operand(); - break; - } - const Identifier& ident = identifier(pc[3].u.operand); - ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Get, modeAndType.type()); + ResolveModeAndType modeAndType = ResolveModeAndType(pc[4].u.operand); + ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), scope, ident, Get, modeAndType.type()); instructions[i + 4].u.operand = ResolveModeAndType(modeAndType.mode(), op.type).operand(); if (op.type == GlobalVar || op.type == GlobalVarWithVarInjectionChecks) @@ -1988,131 +1807,35 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin case op_put_to_scope: { // put_to_scope scope, id, value, ResolveModeAndType, Structure, Operand - ResolveModeAndType modeAndType = ResolveModeAndType(pc[4].u.operand); - if (modeAndType.type() == LocalClosureVar) { - // Only do watching if the property we're putting to is not anonymous. - if (static_cast<unsigned>(pc[2].u.operand) != UINT_MAX) { - int symbolTableIndex = pc[5].u.operand; - RELEASE_ASSERT(clonedConstantSymbolTables.contains(symbolTableIndex)); - SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(symbolTableIndex)); - const Identifier& ident = identifier(pc[2].u.operand); - ConcurrentJITLocker locker(symbolTable->m_lock); - auto iter = symbolTable->find(locker, ident.impl()); - RELEASE_ASSERT(iter != symbolTable->end(locker)); - iter->value.prepareToWatch(); - instructions[i + 5].u.watchpointSet = iter->value.watchpointSet(); - } else - instructions[i + 5].u.watchpointSet = nullptr; - break; - } - const Identifier& ident = identifier(pc[2].u.operand); - int localScopeDepth = pc[5].u.operand; - instructions[i + 5].u.pointer = nullptr; - ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Put, modeAndType.type()); + ResolveModeAndType modeAndType = ResolveModeAndType(pc[4].u.operand); + ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), scope, ident, Put, modeAndType.type()); instructions[i + 4].u.operand = ResolveModeAndType(modeAndType.mode(), op.type).operand(); if (op.type == GlobalVar || op.type == GlobalVarWithVarInjectionChecks) instructions[i + 5].u.watchpointSet = op.watchpointSet; else if (op.type == ClosureVar || op.type == ClosureVarWithVarInjectionChecks) { if (op.watchpointSet) - op.watchpointSet->invalidate(PutToScopeFireDetail(this, ident)); + op.watchpointSet->invalidate(); } else if (op.structure) instructions[i + 5].u.structure.set(*vm(), ownerExecutable, op.structure); instructions[i + 6].u.pointer = reinterpret_cast<void*>(op.operand); - break; } - - case op_profile_type: { - RELEASE_ASSERT(vm()->typeProfiler()); - // The format of this instruction is: op_profile_type regToProfile, TypeLocation*, flag, identifier?, resolveType? - size_t instructionOffset = i + opLength - 1; - unsigned divotStart, divotEnd; - GlobalVariableID globalVariableID = 0; - RefPtr<TypeSet> globalTypeSet; - bool shouldAnalyze = m_unlinkedCode->typeProfilerExpressionInfoForBytecodeOffset(instructionOffset, divotStart, divotEnd); - VirtualRegister profileRegister(pc[1].u.operand); - ProfileTypeBytecodeFlag flag = static_cast<ProfileTypeBytecodeFlag>(pc[3].u.operand); - SymbolTable* symbolTable = nullptr; - - switch (flag) { - case ProfileTypeBytecodeClosureVar: { - const Identifier& ident = identifier(pc[4].u.operand); - int localScopeDepth = pc[2].u.operand; - ResolveType type = static_cast<ResolveType>(pc[5].u.operand); - // Even though type profiling may be profiling either a Get or a Put, we can always claim a Get because - // we're abstractly "read"ing from a JSScope. - ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Get, type); - - if (op.type == ClosureVar) - symbolTable = op.lexicalEnvironment->symbolTable(); - else if (op.type == GlobalVar) - symbolTable = m_globalObject.get()->symbolTable(); - - if (symbolTable) { - ConcurrentJITLocker locker(symbolTable->m_lock); - // If our parent scope was created while profiling was disabled, it will not have prepared for profiling yet. - symbolTable->prepareForTypeProfiling(locker); - globalVariableID = symbolTable->uniqueIDForVariable(locker, ident.impl(), *vm()); - globalTypeSet = symbolTable->globalTypeSetForVariable(locker, ident.impl(), *vm()); - } else - globalVariableID = TypeProfilerNoGlobalIDExists; - - break; - } - case ProfileTypeBytecodeLocallyResolved: { - int symbolTableIndex = pc[2].u.operand; - RELEASE_ASSERT(clonedConstantSymbolTables.contains(symbolTableIndex)); - SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(symbolTableIndex)); - const Identifier& ident = identifier(pc[4].u.operand); - ConcurrentJITLocker locker(symbolTable->m_lock); - // If our parent scope was created while profiling was disabled, it will not have prepared for profiling yet. - globalVariableID = symbolTable->uniqueIDForVariable(locker, ident.impl(), *vm()); - globalTypeSet = symbolTable->globalTypeSetForVariable(locker, ident.impl(), *vm()); - - break; - } - case ProfileTypeBytecodeDoesNotHaveGlobalID: - case ProfileTypeBytecodeFunctionArgument: { - globalVariableID = TypeProfilerNoGlobalIDExists; - break; - } - case ProfileTypeBytecodeFunctionReturnStatement: { - RELEASE_ASSERT(ownerExecutable->isFunctionExecutable()); - globalTypeSet = jsCast<FunctionExecutable*>(ownerExecutable)->returnStatementTypeSet(); - globalVariableID = TypeProfilerReturnStatement; - if (!shouldAnalyze) { - // Because a return statement can be added implicitly to return undefined at the end of a function, - // and these nodes don't emit expression ranges because they aren't in the actual source text of - // the user's program, give the type profiler some range to identify these return statements. - // Currently, the text offset that is used as identification is on the open brace of the function - // and is stored on TypeLocation's m_divotForFunctionOffsetIfReturnStatement member variable. - divotStart = divotEnd = m_sourceOffset; - shouldAnalyze = true; - } + + case op_captured_mov: + case op_new_captured_func: { + if (pc[3].u.index == UINT_MAX) { + instructions[i + 3].u.watchpointSet = 0; break; } - } - - std::pair<TypeLocation*, bool> locationPair = vm()->typeProfiler()->typeLocationCache()->getTypeLocation(globalVariableID, - m_ownerExecutable->sourceID(), divotStart, divotEnd, globalTypeSet, vm()); - TypeLocation* location = locationPair.first; - bool isNewLocation = locationPair.second; - - if (flag == ProfileTypeBytecodeFunctionReturnStatement) - location->m_divotForFunctionOffsetIfReturnStatement = m_sourceOffset; - - if (shouldAnalyze && isNewLocation) - vm()->typeProfiler()->insertNewLocation(location); - - instructions[i + 2].u.location = location; - break; - } - - case op_debug: { - if (pc[1].u.index == DidReachBreakpoint) - m_hasDebuggerStatement = true; + StringImpl* uid = identifier(pc[3].u.index).impl(); + RELEASE_ASSERT(didCloneSymbolTable); + ConcurrentJITLocker locker(m_symbolTable->m_lock); + SymbolTable::Map::iterator iter = m_symbolTable->find(locker, uid); + ASSERT(iter != m_symbolTable->end(locker)); + iter->value.prepareToWatch(); + instructions[i + 3].u.watchpointSet = iter->value.watchpointSet(); break; } @@ -2121,11 +1844,7 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin } i += opLength; } - - if (vm()->controlFlowProfiler()) - insertBasicBlockBoundariesForControlFlowProfiler(instructions); - - m_instructions = WTF::move(instructions); + m_instructions = WTF::RefCountedArray<Instruction>(instructions); // Set optimization thresholds only after m_instructions is initialized, since these // rely on the instruction count (and are in theory permitted to also inspect the @@ -2135,14 +1854,25 @@ CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin // If the concurrent thread will want the code block's hash, then compute it here // synchronously. - if (Options::alwaysComputeHash()) + if (Options::showDisassembly() + || Options::showDFGDisassembly() + || Options::dumpBytecodeAtDFGTime() + || Options::dumpGraphAtEachPhase() + || Options::verboseCompilation() + || Options::logCompilationChanges() + || Options::validateGraph() + || Options::validateGraphAtEachPhase() + || Options::verboseOSR() + || Options::verboseCompilationQueue() + || Options::reportCompileTimes() + || Options::verboseCFA()) hash(); if (Options::dumpGeneratedBytecodes()) dumpBytecode(); - + m_heap->m_codeBlocks.add(this); - m_heap->reportExtraMemoryAllocated(sizeof(CodeBlock) + m_instructions.size() * sizeof(Instruction)); + m_heap->reportExtraMemoryCost(sizeof(CodeBlock) + m_instructions.size() * sizeof(Instruction)); } CodeBlock::~CodeBlock() @@ -2153,8 +1883,11 @@ CodeBlock::~CodeBlock() #if ENABLE(VERBOSE_VALUE_PROFILE) dumpValueProfiles(); #endif + +#if ENABLE(LLINT) while (m_incomingLLIntCalls.begin() != m_incomingLLIntCalls.end()) m_incomingLLIntCalls.begin()->remove(); +#endif // ENABLE(LLINT) #if ENABLE(JIT) // We may be destroyed before any CodeBlocks that refer to us are destroyed. // Consider that two CodeBlocks become unreachable at the same time. There @@ -2164,8 +1897,6 @@ CodeBlock::~CodeBlock() // destructor will try to remove nodes from our (no longer valid) linked list. while (m_incomingCalls.begin() != m_incomingCalls.end()) m_incomingCalls.begin()->remove(); - while (m_incomingPolymorphicCalls.begin() != m_incomingPolymorphicCalls.end()) - m_incomingPolymorphicCalls.begin()->remove(); // Note that our outgoing calls will be removed from other CodeBlocks' // m_incomingCalls linked lists through the execution of the ~CallLinkInfo @@ -2206,11 +1937,26 @@ void CodeBlock::visitAggregate(SlotVisitor& visitor) { #if ENABLE(PARALLEL_GC) // I may be asked to scan myself more than once, and it may even happen concurrently. - // To this end, use an atomic operation to check (and set) if I've been called already. - // Only one thread may proceed past this point - whichever one wins the atomic set race. - bool setByMe = m_visitAggregateHasBeenCalled.compareExchangeStrong(false, true); - if (!setByMe) - return; + // To this end, use a CAS loop to check if I've been called already. Only one thread + // may proceed past this point - whichever one wins the CAS race. + unsigned oldValue; + do { + oldValue = m_visitAggregateHasBeenCalled; + if (oldValue) { + // Looks like someone else won! Return immediately to ensure that we don't + // trace the same CodeBlock concurrently. Doing so is hazardous since we will + // be mutating the state of ValueProfiles, which contain JSValues, which can + // have word-tearing on 32-bit, leading to awesome timing-dependent crashes + // that are nearly impossible to track down. + + // Also note that it must be safe to return early as soon as we see the + // value true (well, (unsigned)1), since once a GC thread is in this method + // and has won the CAS race (i.e. was responsible for setting the value true) + // it will definitely complete the rest of this method before declaring + // termination. + return; + } + } while (!WTF::weakCompareAndSwap(&m_visitAggregateHasBeenCalled, 0, 1)); #endif // ENABLE(PARALLEL_GC) if (!!m_alternative) @@ -2219,15 +1965,15 @@ void CodeBlock::visitAggregate(SlotVisitor& visitor) if (CodeBlock* otherBlock = specialOSREntryBlockOrNull()) otherBlock->visitAggregate(visitor); - visitor.reportExtraMemoryVisited(ownerExecutable(), sizeof(CodeBlock)); + visitor.reportExtraMemoryUsage(ownerExecutable(), sizeof(CodeBlock)); if (m_jitCode) - visitor.reportExtraMemoryVisited(ownerExecutable(), m_jitCode->size()); + visitor.reportExtraMemoryUsage(ownerExecutable(), m_jitCode->size()); if (m_instructions.size()) { // Divide by refCount() because m_instructions points to something that is shared // by multiple CodeBlocks, and we only want to count it towards the heap size once. // Having each CodeBlock report only its proportional share of the size is one way // of accomplishing this. - visitor.reportExtraMemoryVisited(ownerExecutable(), m_instructions.size() * sizeof(Instruction) / m_instructions.refCount()); + visitor.reportExtraMemoryUsage(ownerExecutable(), m_instructions.size() * sizeof(Instruction) / m_instructions.refCount()); } visitor.append(&m_unlinkedCode); @@ -2238,6 +1984,10 @@ void CodeBlock::visitAggregate(SlotVisitor& visitor) // and when it runs, it figures out whether it has any work to do. visitor.addUnconditionalFinalizer(this); + // There are two things that we use weak reference harvesters for: DFG fixpoint for + // jettisoning, and trying to find structures that would be live based on some + // inline cache. So it makes sense to register them regardless. + visitor.addWeakReferenceHarvester(this); m_allTransitionsHaveBeenMarked = false; if (shouldImmediatelyAssumeLivenessDuringScan()) { @@ -2248,11 +1998,6 @@ void CodeBlock::visitAggregate(SlotVisitor& visitor) return; } - // There are two things that we use weak reference harvesters for: DFG fixpoint for - // jettisoning, and trying to find structures that would be live based on some - // inline cache. So it makes sense to register them regardless. - visitor.addWeakReferenceHarvester(this); - #if ENABLE(DFG_JIT) // We get here if we're live in the sense that our owner executable is live, // but we're not yet live for sure in another sense: we may yet decide that this @@ -2272,62 +2017,6 @@ void CodeBlock::visitAggregate(SlotVisitor& visitor) #endif // ENABLE(DFG_JIT) } -bool CodeBlock::shouldImmediatelyAssumeLivenessDuringScan() -{ -#if ENABLE(DFG_JIT) - // Interpreter and Baseline JIT CodeBlocks don't need to be jettisoned when - // their weak references go stale. So if a basline JIT CodeBlock gets - // scanned, we can assume that this means that it's live. - if (!JITCode::isOptimizingJIT(jitType())) - return true; - - // For simplicity, we don't attempt to jettison code blocks during GC if - // they are executing. Instead we strongly mark their weak references to - // allow them to continue to execute soundly. - if (m_mayBeExecuting) - return true; - - if (Options::forceDFGCodeBlockLiveness()) - return true; - - return false; -#else - return true; -#endif -} - -bool CodeBlock::isKnownToBeLiveDuringGC() -{ -#if ENABLE(DFG_JIT) - // This should return true for: - // - Code blocks that behave like normal objects - i.e. if they are referenced then they - // are live. - // - Code blocks that were running on the stack. - // - Code blocks that survived the last GC if the current GC is an Eden GC. This is - // because either livenessHasBeenProved would have survived as true or m_mayBeExecuting - // would survive as true. - // - Code blocks that don't have any dead weak references. - - return shouldImmediatelyAssumeLivenessDuringScan() - || m_jitCode->dfgCommon()->livenessHasBeenProved; -#else - return true; -#endif -} - -#if ENABLE(DFG_JIT) -static bool shouldMarkTransition(DFG::WeakReferenceTransition& transition) -{ - if (transition.m_codeOrigin && !Heap::isMarked(transition.m_codeOrigin.get())) - return false; - - if (!Heap::isMarked(transition.m_from.get())) - return false; - - return true; -} -#endif // ENABLE(DFG_JIT) - void CodeBlock::propagateTransitions(SlotVisitor& visitor) { UNUSED_PARAM(visitor); @@ -2337,6 +2026,7 @@ void CodeBlock::propagateTransitions(SlotVisitor& visitor) bool allAreMarkedSoFar = true; +#if ENABLE(LLINT) Interpreter* interpreter = m_vm->interpreter; if (jitType() == JITCode::InterpreterThunk) { const Vector<unsigned>& propertyAccessInstructions = m_unlinkedCode->propertyAccessInstructions(); @@ -2358,6 +2048,7 @@ void CodeBlock::propagateTransitions(SlotVisitor& visitor) } } } +#endif // ENABLE(LLINT) #if ENABLE(JIT) if (JITCode::isJIT(jitType())) { @@ -2404,28 +2095,21 @@ void CodeBlock::propagateTransitions(SlotVisitor& visitor) #if ENABLE(DFG_JIT) if (JITCode::isOptimizingJIT(jitType())) { DFG::CommonData* dfgCommon = m_jitCode->dfgCommon(); - for (unsigned i = 0; i < dfgCommon->transitions.size(); ++i) { - if (shouldMarkTransition(dfgCommon->transitions[i])) { + if ((!dfgCommon->transitions[i].m_codeOrigin + || Heap::isMarked(dfgCommon->transitions[i].m_codeOrigin.get())) + && Heap::isMarked(dfgCommon->transitions[i].m_from.get())) { // If the following three things are live, then the target of the // transition is also live: - // // - This code block. We know it's live already because otherwise // we wouldn't be scanning ourselves. - // // - The code origin of the transition. Transitions may arise from // code that was inlined. They are not relevant if the user's // object that is required for the inlinee to run is no longer // live. - // // - The source of the transition. The transition checks if some // heap location holds the source, and if so, stores the target. // Hence the source must be live for the transition to be live. - // - // We also short-circuit the liveness if the structure is harmless - // to mark (i.e. its global object and prototype are both already - // live). - visitor.append(&dfgCommon->transitions[i].m_to); } else allAreMarkedSoFar = false; @@ -2460,14 +2144,6 @@ void CodeBlock::determineLiveness(SlotVisitor& visitor) break; } } - if (allAreLiveSoFar) { - for (unsigned i = 0; i < dfgCommon->weakStructureReferences.size(); ++i) { - if (!Heap::isMarked(dfgCommon->weakStructureReferences[i].get())) { - allAreLiveSoFar = false; - break; - } - } - } // If some weak references are dead, then this fixpoint iteration was // unsuccessful. @@ -2533,38 +2209,28 @@ void CodeBlock::finalizeUnconditionally() if (Options::verboseOSR()) dataLogF("Clearing LLInt to_this with structure %p.\n", curInstruction[2].u.structure.get()); curInstruction[2].u.structure.clear(); - curInstruction[3].u.toThisStatus = merge( - curInstruction[3].u.toThisStatus, ToThisClearedByGC); break; - case op_create_this: { - auto& cacheWriteBarrier = curInstruction[4].u.jsCell; - if (!cacheWriteBarrier || cacheWriteBarrier.unvalidatedGet() == JSCell::seenMultipleCalleeObjects()) - break; - JSCell* cachedFunction = cacheWriteBarrier.get(); - if (Heap::isMarked(cachedFunction)) + case op_get_callee: + if (!curInstruction[2].u.jsCell || Heap::isMarked(curInstruction[2].u.jsCell.get())) break; if (Options::verboseOSR()) - dataLogF("Clearing LLInt create_this with cached callee %p.\n", cachedFunction); - cacheWriteBarrier.clear(); + dataLogF("Clearing LLInt get callee with function %p.\n", curInstruction[2].u.jsCell.get()); + curInstruction[2].u.jsCell.clear(); break; - } case op_resolve_scope: { - // Right now this isn't strictly necessary. Any symbol tables that this will refer to - // are for outer functions, and we refer to those functions strongly, and they refer - // to the symbol table strongly. But it's nice to be on the safe side. - WriteBarrierBase<SymbolTable>& symbolTable = curInstruction[6].u.symbolTable; - if (!symbolTable || Heap::isMarked(symbolTable.get())) + WriteBarrierBase<JSActivation>& activation = curInstruction[5].u.activation; + if (!activation || Heap::isMarked(activation.get())) break; if (Options::verboseOSR()) - dataLogF("Clearing dead symbolTable %p.\n", symbolTable.get()); - symbolTable.clear(); + dataLogF("Clearing dead activation %p.\n", activation.get()); + activation.clear(); break; } case op_get_from_scope: case op_put_to_scope: { ResolveModeAndType modeAndType = ResolveModeAndType(curInstruction[4].u.operand); - if (modeAndType.type() == GlobalVar || modeAndType.type() == GlobalVarWithVarInjectionChecks || modeAndType.type() == LocalClosureVar) + if (modeAndType.type() == GlobalVar || modeAndType.type() == GlobalVarWithVarInjectionChecks) continue; WriteBarrierBase<Structure>& structure = curInstruction[5].u.structure; if (!structure || Heap::isMarked(structure.get())) @@ -2575,11 +2241,11 @@ void CodeBlock::finalizeUnconditionally() break; } default: - OpcodeID opcodeID = interpreter->getOpcodeID(curInstruction[0].u.opcode); - ASSERT_WITH_MESSAGE_UNUSED(opcodeID, false, "Unhandled opcode in CodeBlock::finalizeUnconditionally, %s(%d) at bc %u", opcodeNames[opcodeID], opcodeID, propertyAccessInstructions[i]); + RELEASE_ASSERT_NOT_REACHED(); } } +#if ENABLE(LLINT) for (unsigned i = 0; i < m_llintCallLinkInfos.size(); ++i) { if (m_llintCallLinkInfos[i].isLinked() && !Heap::isMarked(m_llintCallLinkInfos[i].callee.get())) { if (Options::verboseOSR()) @@ -2589,11 +2255,12 @@ void CodeBlock::finalizeUnconditionally() if (!!m_llintCallLinkInfos[i].lastSeenCallee && !Heap::isMarked(m_llintCallLinkInfos[i].lastSeenCallee.get())) m_llintCallLinkInfos[i].lastSeenCallee.clear(); } +#endif // ENABLE(LLINT) } #if ENABLE(DFG_JIT) // Check if we're not live. If we are, then jettison. - if (!isKnownToBeLiveDuringGC()) { + if (!(shouldImmediatelyAssumeLivenessDuringScan() || m_jitCode->dfgCommon()->livenessHasBeenProved)) { if (Options::verboseOSR()) dataLog(*this, " has dead weak references, jettisoning during GC.\n"); @@ -2617,7 +2284,7 @@ void CodeBlock::finalizeUnconditionally() } } - jettison(Profiler::JettisonDueToWeakReference); + jettison(); return; } #endif // ENABLE(DFG_JIT) @@ -2626,14 +2293,39 @@ void CodeBlock::finalizeUnconditionally() // Handle inline caches. if (!!jitCode()) { RepatchBuffer repatchBuffer(this); - - for (auto iter = callLinkInfosBegin(); !!iter; ++iter) - (*iter)->visitWeak(repatchBuffer); - + for (unsigned i = 0; i < numberOfCallLinkInfos(); ++i) { + if (callLinkInfo(i).isLinked()) { + if (ClosureCallStubRoutine* stub = callLinkInfo(i).stub.get()) { + if (!Heap::isMarked(stub->structure()) + || !Heap::isMarked(stub->executable())) { + if (Options::verboseOSR()) { + dataLog( + "Clearing closure call from ", *this, " to ", + stub->executable()->hashFor(callLinkInfo(i).specializationKind()), + ", stub routine ", RawPointer(stub), ".\n"); + } + callLinkInfo(i).unlink(*m_vm, repatchBuffer); + } + } else if (!Heap::isMarked(callLinkInfo(i).callee.get())) { + if (Options::verboseOSR()) { + dataLog( + "Clearing call from ", *this, " to ", + RawPointer(callLinkInfo(i).callee.get()), " (", + callLinkInfo(i).callee.get()->executable()->hashFor( + callLinkInfo(i).specializationKind()), + ").\n"); + } + callLinkInfo(i).unlink(*m_vm, repatchBuffer); + } + } + if (!!callLinkInfo(i).lastSeenCallee + && !Heap::isMarked(callLinkInfo(i).lastSeenCallee.get())) + callLinkInfo(i).lastSeenCallee.clear(); + } for (Bag<StructureStubInfo>::iterator iter = m_stubInfos.begin(); !!iter; ++iter) { StructureStubInfo& stubInfo = **iter; - if (stubInfo.visitWeakReferences(repatchBuffer)) + if (stubInfo.visitWeakReferences()) continue; resetStubDuringGCInternal(repatchBuffer, stubInfo); @@ -2642,52 +2334,6 @@ void CodeBlock::finalizeUnconditionally() #endif } -void CodeBlock::getStubInfoMap(const ConcurrentJITLocker&, StubInfoMap& result) -{ -#if ENABLE(JIT) - toHashMap(m_stubInfos, getStructureStubInfoCodeOrigin, result); -#else - UNUSED_PARAM(result); -#endif -} - -void CodeBlock::getStubInfoMap(StubInfoMap& result) -{ - ConcurrentJITLocker locker(m_lock); - getStubInfoMap(locker, result); -} - -void CodeBlock::getCallLinkInfoMap(const ConcurrentJITLocker&, CallLinkInfoMap& result) -{ -#if ENABLE(JIT) - toHashMap(m_callLinkInfos, getCallLinkInfoCodeOrigin, result); -#else - UNUSED_PARAM(result); -#endif -} - -void CodeBlock::getCallLinkInfoMap(CallLinkInfoMap& result) -{ - ConcurrentJITLocker locker(m_lock); - getCallLinkInfoMap(locker, result); -} - -void CodeBlock::getByValInfoMap(const ConcurrentJITLocker&, ByValInfoMap& result) -{ -#if ENABLE(JIT) - for (auto* byValInfo : m_byValInfos) - result.add(CodeOrigin(byValInfo->bytecodeIndex), byValInfo); -#else - UNUSED_PARAM(result); -#endif -} - -void CodeBlock::getByValInfoMap(ByValInfoMap& result) -{ - ConcurrentJITLocker locker(m_lock); - getByValInfoMap(locker, result); -} - #if ENABLE(JIT) StructureStubInfo* CodeBlock::addStubInfo() { @@ -2695,25 +2341,9 @@ StructureStubInfo* CodeBlock::addStubInfo() return m_stubInfos.add(); } -StructureStubInfo* CodeBlock::findStubInfo(CodeOrigin codeOrigin) -{ - for (StructureStubInfo* stubInfo : m_stubInfos) { - if (stubInfo->codeOrigin == codeOrigin) - return stubInfo; - } - return nullptr; -} - -ByValInfo* CodeBlock::addByValInfo() -{ - ConcurrentJITLocker locker(m_lock); - return m_byValInfos.add(); -} - -CallLinkInfo* CodeBlock::addCallLinkInfo() +void CodeBlock::getStubInfoMap(const ConcurrentJITLocker&, StubInfoMap& result) { - ConcurrentJITLocker locker(m_lock); - return m_callLinkInfos.add(); + toHashMap(m_stubInfos, getStructureStubInfoCodeOrigin, result); } void CodeBlock::resetStub(StructureStubInfo& stubInfo) @@ -2756,21 +2386,13 @@ void CodeBlock::resetStubDuringGCInternal(RepatchBuffer& repatchBuffer, Structur resetStubInternal(repatchBuffer, stubInfo); stubInfo.resetByGC = true; } - -CallLinkInfo* CodeBlock::getCallLinkInfoForBytecodeIndex(unsigned index) -{ - for (auto iter = m_callLinkInfos.begin(); !!iter; ++iter) { - if ((*iter)->codeOrigin() == CodeOrigin(index)) - return *iter; - } - return nullptr; -} #endif void CodeBlock::stronglyVisitStrongReferences(SlotVisitor& visitor) { visitor.append(&m_globalObject); visitor.append(&m_ownerExecutable); + visitor.append(&m_symbolTable); visitor.append(&m_unlinkedCode); if (m_rareData) m_rareData->m_evalCodeCache.visitAggregate(visitor); @@ -2782,21 +2404,6 @@ void CodeBlock::stronglyVisitStrongReferences(SlotVisitor& visitor) for (unsigned i = 0; i < m_objectAllocationProfiles.size(); ++i) m_objectAllocationProfiles[i].visitAggregate(visitor); -#if ENABLE(DFG_JIT) - if (JITCode::isOptimizingJIT(jitType())) { - // FIXME: This is an antipattern for two reasons. References introduced by the DFG - // that aren't in the original CodeBlock being compiled should be weakly referenced. - // Inline call frames aren't in the original CodeBlock, so they qualify as weak. Also, - // those weak references should already be tracked in the DFG as weak FrozenValues. So, - // there is probably no need for this. We already have assertions that this should be - // unnecessary. - // https://bugs.webkit.org/show_bug.cgi?id=146613 - DFG::CommonData* dfgCommon = m_jitCode->dfgCommon(); - if (dfgCommon->inlineCallFrames.get()) - dfgCommon->inlineCallFrames->visitAggregate(visitor); - } -#endif - updateAllPredictions(); } @@ -2819,9 +2426,6 @@ void CodeBlock::stronglyVisitWeakReferences(SlotVisitor& visitor) for (unsigned i = 0; i < dfgCommon->weakReferences.size(); ++i) visitor.append(&dfgCommon->weakReferences[i]); - - for (unsigned i = 0; i < dfgCommon->weakStructureReferences.size(); ++i) - visitor.append(&dfgCommon->weakStructureReferences[i]); #endif } @@ -2870,7 +2474,66 @@ bool CodeBlock::hasOptimizedReplacement() } #endif -HandlerInfo* CodeBlock::handlerForBytecodeOffset(unsigned bytecodeOffset, RequiredHandler requiredHandler) +bool CodeBlock::isCaptured(VirtualRegister operand, InlineCallFrame* inlineCallFrame) const +{ + if (operand.isArgument()) + return operand.toArgument() && usesArguments(); + + if (inlineCallFrame) + return inlineCallFrame->capturedVars.get(operand.toLocal()); + + // The activation object isn't in the captured region, but it's "captured" + // in the sense that stores to its location can be observed indirectly. + if (needsActivation() && operand == activationRegister()) + return true; + + // Ditto for the arguments object. + if (usesArguments() && operand == argumentsRegister()) + return true; + + // Ditto for the arguments object. + if (usesArguments() && operand == unmodifiedArgumentsRegister(argumentsRegister())) + return true; + + // We're in global code so there are no locals to capture + if (!symbolTable()) + return false; + + return symbolTable()->isCaptured(operand.offset()); +} + +int CodeBlock::framePointerOffsetToGetActivationRegisters(int machineCaptureStart) +{ + // We'll be adding this to the stack pointer to get a registers pointer that looks + // like it would have looked in the baseline engine. For example, if bytecode would + // have put the first captured variable at offset -5 but we put it at offset -1, then + // we'll have an offset of 4. + int32_t offset = 0; + + // Compute where we put the captured variables. This offset will point the registers + // pointer directly at the first captured var. + offset += machineCaptureStart; + + // Now compute the offset needed to make the runtime see the captured variables at the + // same offset that the bytecode would have used. + offset -= symbolTable()->captureStart(); + + return offset; +} + +int CodeBlock::framePointerOffsetToGetActivationRegisters() +{ + if (!JITCode::isOptimizingJIT(jitType())) + return 0; +#if ENABLE(DFG_JIT) + return framePointerOffsetToGetActivationRegisters(jitCode()->dfgCommon()->machineCaptureStart); +#else + RELEASE_ASSERT_NOT_REACHED(); + return 0; +#endif +} + +HandlerInfo* CodeBlock::handlerForBytecodeOffset(unsigned bytecodeOffset) { RELEASE_ASSERT(bytecodeOffset < instructions().size()); @@ -2879,14 +2542,10 @@ HandlerInfo* CodeBlock::handlerForBytecodeOffset(unsigned bytecodeOffset, Requir Vector<HandlerInfo>& exceptionHandlers = m_rareData->m_exceptionHandlers; for (size_t i = 0; i < exceptionHandlers.size(); ++i) { - HandlerInfo& handler = exceptionHandlers[i]; - if ((requiredHandler == RequiredHandler::CatchHandler) && !handler.isCatchHandler()) - continue; - // Handlers are ordered innermost first, so the first handler we encounter // that contains the source address is the correct handler to use. - if (handler.start <= bytecodeOffset && handler.end > bytecodeOffset) - return &handler; + if (exceptionHandlers[i].start <= bytecodeOffset && exceptionHandlers[i].end > bytecodeOffset) + return &exceptionHandlers[i]; } return 0; @@ -2895,7 +2554,7 @@ HandlerInfo* CodeBlock::handlerForBytecodeOffset(unsigned bytecodeOffset, Requir unsigned CodeBlock::lineNumberForBytecodeOffset(unsigned bytecodeOffset) { RELEASE_ASSERT(bytecodeOffset < instructions().size()); - return m_ownerExecutable->firstLine() + m_unlinkedCode->lineNumberForBytecodeOffset(bytecodeOffset); + return m_ownerExecutable->lineNo() + m_unlinkedCode->lineNumberForBytecodeOffset(bytecodeOffset); } unsigned CodeBlock::columnNumberForBytecodeOffset(unsigned bytecodeOffset) @@ -2914,7 +2573,7 @@ void CodeBlock::expressionRangeForBytecodeOffset(unsigned bytecodeOffset, int& d m_unlinkedCode->expressionRangeForBytecodeOffset(bytecodeOffset, divot, startOffset, endOffset, line, column); divot += m_sourceOffset; column += line ? 1 : firstLineColumnOffset(); - line += m_ownerExecutable->firstLine(); + line += m_ownerExecutable->lineNo(); } bool CodeBlock::hasOpDebugForLineAndColumn(unsigned line, unsigned column) @@ -2945,7 +2604,6 @@ void CodeBlock::shrinkToFit(ShrinkMode shrinkMode) if (shrinkMode == EarlyShrink) { m_constantRegisters.shrinkToFit(); - m_constantsSourceCodeRepresentation.shrinkToFit(); if (m_rareData) { m_rareData->m_switchJumpTables.shrinkToFit(); @@ -2954,25 +2612,47 @@ void CodeBlock::shrinkToFit(ShrinkMode shrinkMode) } // else don't shrink these, because we would have already pointed pointers into these tables. } +unsigned CodeBlock::addOrFindConstant(JSValue v) +{ + unsigned result; + if (findConstant(v, result)) + return result; + return addConstant(v); +} + +bool CodeBlock::findConstant(JSValue v, unsigned& index) +{ + unsigned numberOfConstants = numberOfConstantRegisters(); + for (unsigned i = 0; i < numberOfConstants; ++i) { + if (getConstant(FirstConstantRegisterIndex + i) == v) { + index = i; + return true; + } + } + index = numberOfConstants; + return false; +} + #if ENABLE(JIT) void CodeBlock::unlinkCalls() { if (!!m_alternative) m_alternative->unlinkCalls(); +#if ENABLE(LLINT) for (size_t i = 0; i < m_llintCallLinkInfos.size(); ++i) { if (m_llintCallLinkInfos[i].isLinked()) m_llintCallLinkInfos[i].unlink(); } - if (m_callLinkInfos.isEmpty()) +#endif + if (!m_callLinkInfos.size()) return; if (!m_vm->canUseJIT()) return; RepatchBuffer repatchBuffer(this); - for (auto iter = m_callLinkInfos.begin(); !!iter; ++iter) { - CallLinkInfo& info = **iter; - if (!info.isLinked()) + for (size_t i = 0; i < m_callLinkInfos.size(); i++) { + if (!m_callLinkInfos[i].isLinked()) continue; - info.unlink(repatchBuffer); + m_callLinkInfos[i].unlink(*m_vm, repatchBuffer); } } @@ -2981,34 +2661,41 @@ void CodeBlock::linkIncomingCall(ExecState* callerFrame, CallLinkInfo* incoming) noticeIncomingCall(callerFrame); m_incomingCalls.push(incoming); } - -void CodeBlock::linkIncomingPolymorphicCall(ExecState* callerFrame, PolymorphicCallNode* incoming) -{ - noticeIncomingCall(callerFrame); - m_incomingPolymorphicCalls.push(incoming); -} #endif // ENABLE(JIT) void CodeBlock::unlinkIncomingCalls() { +#if ENABLE(LLINT) while (m_incomingLLIntCalls.begin() != m_incomingLLIntCalls.end()) m_incomingLLIntCalls.begin()->unlink(); +#endif // ENABLE(LLINT) #if ENABLE(JIT) - if (m_incomingCalls.isEmpty() && m_incomingPolymorphicCalls.isEmpty()) + if (m_incomingCalls.isEmpty()) return; RepatchBuffer repatchBuffer(this); while (m_incomingCalls.begin() != m_incomingCalls.end()) - m_incomingCalls.begin()->unlink(repatchBuffer); - while (m_incomingPolymorphicCalls.begin() != m_incomingPolymorphicCalls.end()) - m_incomingPolymorphicCalls.begin()->unlink(repatchBuffer); + m_incomingCalls.begin()->unlink(*m_vm, repatchBuffer); #endif // ENABLE(JIT) } +#if ENABLE(LLINT) void CodeBlock::linkIncomingCall(ExecState* callerFrame, LLIntCallLinkInfo* incoming) { noticeIncomingCall(callerFrame); m_incomingLLIntCalls.push(incoming); } +#endif // ENABLE(LLINT) + +void CodeBlock::clearEvalCache() +{ + if (!!m_alternative) + m_alternative->clearEvalCache(); + if (CodeBlock* otherBlock = specialOSREntryBlockOrNull()) + otherBlock->clearEvalCache(); + if (!m_rareData) + return; + m_rareData->m_evalCodeCache.clear(); +} void CodeBlock::install() { @@ -3020,6 +2707,18 @@ PassRefPtr<CodeBlock> CodeBlock::newReplacement() return ownerExecutable()->newReplacementCodeBlockFor(specializationKind()); } +const SlowArgument* CodeBlock::machineSlowArguments() +{ + if (!JITCode::isOptimizingJIT(jitType())) + return symbolTable()->slowArguments(); + +#if ENABLE(DFG_JIT) + return jitCode()->dfgCommon()->slowArguments.get(); +#else // ENABLE(DFG_JIT) + return 0; +#endif // ENABLE(DFG_JIT) +} + #if ENABLE(JIT) CodeBlock* ProgramCodeBlock::replacement() { @@ -3054,27 +2753,19 @@ DFG::CapabilityLevel FunctionCodeBlock::capabilityLevelInternal() } #endif -void CodeBlock::jettison(Profiler::JettisonReason reason, ReoptimizationMode mode, const FireDetail* detail) +void CodeBlock::jettison(ReoptimizationMode mode) { - RELEASE_ASSERT(reason != Profiler::NotJettisoned); - #if ENABLE(DFG_JIT) if (DFG::shouldShowDisassembly()) { dataLog("Jettisoning ", *this); if (mode == CountReoptimization) dataLog(" and counting reoptimization"); - dataLog(" due to ", reason); - if (detail) - dataLog(", ", *detail); dataLog(".\n"); } DeferGCForAWhile deferGC(*m_heap); RELEASE_ASSERT(JITCode::isOptimizingJIT(jitType())); - if (Profiler::Compilation* compilation = jitCode()->dfgCommon()->compilation.get()) - compilation->setJettisonReason(reason, detail); - // We want to accomplish two things here: // 1) Make sure that if this CodeBlock is on the stack right now, then if we return to it // we should OSR exit at the top of the next bytecode instruction after the return. @@ -3114,7 +2805,6 @@ void CodeBlock::jettison(Profiler::JettisonReason reason, ReoptimizationMode mod dataLog(" Did install baseline version of ", *this, "\n"); #else // ENABLE(DFG_JIT) UNUSED_PARAM(mode); - UNUSED_PARAM(detail); UNREACHABLE_FOR_PLATFORM(); #endif // ENABLE(DFG_JIT) } @@ -3126,64 +2816,17 @@ JSGlobalObject* CodeBlock::globalObjectFor(CodeOrigin codeOrigin) return jsCast<FunctionExecutable*>(codeOrigin.inlineCallFrame->executable.get())->eitherCodeBlock()->globalObject(); } -class RecursionCheckFunctor { -public: - RecursionCheckFunctor(CallFrame* startCallFrame, CodeBlock* codeBlock, unsigned depthToCheck) - : m_startCallFrame(startCallFrame) - , m_codeBlock(codeBlock) - , m_depthToCheck(depthToCheck) - , m_foundStartCallFrame(false) - , m_didRecurse(false) - { } - - StackVisitor::Status operator()(StackVisitor& visitor) - { - CallFrame* currentCallFrame = visitor->callFrame(); - - if (currentCallFrame == m_startCallFrame) - m_foundStartCallFrame = true; - - if (m_foundStartCallFrame) { - if (visitor->callFrame()->codeBlock() == m_codeBlock) { - m_didRecurse = true; - return StackVisitor::Done; - } - - if (!m_depthToCheck--) - return StackVisitor::Done; - } - - return StackVisitor::Continue; - } - - bool didRecurse() const { return m_didRecurse; } - -private: - CallFrame* m_startCallFrame; - CodeBlock* m_codeBlock; - unsigned m_depthToCheck; - bool m_foundStartCallFrame; - bool m_didRecurse; -}; - void CodeBlock::noticeIncomingCall(ExecState* callerFrame) { CodeBlock* callerCodeBlock = callerFrame->codeBlock(); if (Options::verboseCallLink()) - dataLog("Noticing call link from ", pointerDump(callerCodeBlock), " to ", *this, "\n"); + dataLog("Noticing call link from ", *callerCodeBlock, " to ", *this, "\n"); -#if ENABLE(DFG_JIT) if (!m_shouldAlwaysBeInlined) return; - - if (!callerCodeBlock) { - m_shouldAlwaysBeInlined = false; - if (Options::verboseCallLink()) - dataLog(" Clearing SABI because caller is native.\n"); - return; - } +#if ENABLE(DFG_JIT) if (!hasBaselineJITProfiling()) return; @@ -3192,13 +2835,6 @@ void CodeBlock::noticeIncomingCall(ExecState* callerFrame) if (!canInline(m_capabilityLevelState)) return; - - if (!DFG::isSmallEnoughToInlineCodeInto(callerCodeBlock)) { - m_shouldAlwaysBeInlined = false; - if (Options::verboseCallLink()) - dataLog(" Clearing SABI because caller is too large.\n"); - return; - } if (callerCodeBlock->jitType() == JITCode::InterpreterThunk) { // If the caller is still in the interpreter, then we can't expect inlining to @@ -3207,14 +2843,7 @@ void CodeBlock::noticeIncomingCall(ExecState* callerFrame) // any of its callers. m_shouldAlwaysBeInlined = false; if (Options::verboseCallLink()) - dataLog(" Clearing SABI because caller is in LLInt.\n"); - return; - } - - if (JITCode::isOptimizingJIT(callerCodeBlock->jitType())) { - m_shouldAlwaysBeInlined = false; - if (Options::verboseCallLink()) - dataLog(" Clearing SABI bcause caller was already optimized.\n"); + dataLog(" Marking SABI because caller is in LLInt.\n"); return; } @@ -3224,47 +2853,42 @@ void CodeBlock::noticeIncomingCall(ExecState* callerFrame) // delay eval optimization by a *lot*. m_shouldAlwaysBeInlined = false; if (Options::verboseCallLink()) - dataLog(" Clearing SABI because caller is not a function.\n"); - return; - } - - // Recursive calls won't be inlined. - RecursionCheckFunctor functor(callerFrame, this, Options::maximumInliningDepth()); - vm()->topCallFrame->iterate(functor); - - if (functor.didRecurse()) { - if (Options::verboseCallLink()) - dataLog(" Clearing SABI because recursion was detected.\n"); - m_shouldAlwaysBeInlined = false; + dataLog(" Marking SABI because caller is not a function.\n"); return; } - if (callerCodeBlock->m_capabilityLevelState == DFG::CapabilityLevelNotSet) { - dataLog("In call from ", *callerCodeBlock, " ", callerFrame->codeOrigin(), " to ", *this, ": caller's DFG capability level is not set.\n"); - CRASH(); + ExecState* frame = callerFrame; + for (unsigned i = Options::maximumInliningDepth(); i--; frame = frame->callerFrame()) { + if (frame->isVMEntrySentinel()) + break; + if (frame->codeBlock() == this) { + // Recursive calls won't be inlined. + if (Options::verboseCallLink()) + dataLog(" Marking SABI because recursion was detected.\n"); + m_shouldAlwaysBeInlined = false; + return; + } } + RELEASE_ASSERT(callerCodeBlock->m_capabilityLevelState != DFG::CapabilityLevelNotSet); + if (canCompile(callerCodeBlock->m_capabilityLevelState)) return; if (Options::verboseCallLink()) - dataLog(" Clearing SABI because the caller is not a DFG candidate.\n"); + dataLog(" Marking SABI because the caller is not a DFG candidate.\n"); m_shouldAlwaysBeInlined = false; #endif } +#if ENABLE(JIT) unsigned CodeBlock::reoptimizationRetryCounter() const { -#if ENABLE(JIT) ASSERT(m_reoptimizationRetryCounter <= Options::reoptimizationRetryCounterMax()); return m_reoptimizationRetryCounter; -#else - return 0; -#endif // ENABLE(JIT) } -#if ENABLE(JIT) void CodeBlock::countReoptimization() { m_reoptimizationRetryCounter++; @@ -3275,11 +2899,6 @@ void CodeBlock::countReoptimization() unsigned CodeBlock::numberOfDFGCompiles() { ASSERT(JITCode::isBaselineCode(jitType())); - if (Options::testTheFTL()) { - if (m_didFailFTLCompilation) - return 1000000; - return (m_hasBeenCompiledWithFTL ? 1 : 0) + m_reoptimizationRetryCounter; - } return (JITCode::isOptimizingJIT(replacement()->jitType()) ? 1 : 0) + m_reoptimizationRetryCounter; } @@ -3360,16 +2979,13 @@ double CodeBlock::optimizationThresholdScalingFactor() ASSERT(instructionCount); // Make sure this is called only after we have an instruction stream; otherwise it'll just return the value of d, which makes no sense. double result = d + a * sqrt(instructionCount + b) + c * instructionCount; - - result *= codeTypeThresholdMultiplier(); - if (Options::verboseOSR()) { dataLog( *this, ": instruction count is ", instructionCount, ", scaling execution counter by ", result, " * ", codeTypeThresholdMultiplier(), "\n"); } - return result; + return result * codeTypeThresholdMultiplier(); } static int32_t clipThreshold(double threshold) @@ -3394,7 +3010,7 @@ int32_t CodeBlock::adjustedCounterValue(int32_t desiredThreshold) bool CodeBlock::checkIfOptimizationThresholdReached() { #if ENABLE(DFG_JIT) - if (DFG::Worklist* worklist = DFG::existingGlobalDFGWorklistOrNull()) { + if (DFG::Worklist* worklist = m_vm->worklist.get()) { if (worklist->compilationState(DFG::CompilationKey(this, DFG::DFGMode)) == DFG::Worklist::Compiled) { optimizeNextInvocation(); @@ -3460,22 +3076,8 @@ void CodeBlock::forceOptimizationSlowPathConcurrently() #if ENABLE(DFG_JIT) void CodeBlock::setOptimizationThresholdBasedOnCompilationResult(CompilationResult result) { - JITCode::JITType type = jitType(); - if (type != JITCode::BaselineJIT) { - dataLog(*this, ": expected to have baseline code but have ", type, "\n"); - RELEASE_ASSERT_NOT_REACHED(); - } - - CodeBlock* theReplacement = replacement(); - if ((result == CompilationSuccessful) != (theReplacement != this)) { - dataLog(*this, ": we have result = ", result, " but "); - if (theReplacement == this) - dataLog("we are our own replacement.\n"); - else - dataLog("our replacement is ", pointerDump(theReplacement), "\n"); - RELEASE_ASSERT_NOT_REACHED(); - } - + RELEASE_ASSERT(jitType() == JITCode::BaselineJIT); + RELEASE_ASSERT((result == CompilationSuccessful) == (replacement() != this)); switch (result) { case CompilationSuccessful: RELEASE_ASSERT(JITCode::isOptimizingJIT(replacement()->jitType())); @@ -3498,8 +3100,6 @@ void CodeBlock::setOptimizationThresholdBasedOnCompilationResult(CompilationResu optimizeAfterWarmUp(); return; } - - dataLog("Unrecognized result: ", static_cast<int>(result), "\n"); RELEASE_ASSERT_NOT_REACHED(); } @@ -3655,7 +3255,9 @@ void CodeBlock::tallyFrequentExitSites() DFG::JITCode* jitCode = m_jitCode->dfg(); for (unsigned i = 0; i < jitCode->osrExit.size(); ++i) { DFG::OSRExit& exit = jitCode->osrExit[i]; - exit.considerAddingAsFrequentExitSite(profiledBlock); + + if (!exit.considerAddingAsFrequentExitSite(profiledBlock)) + continue; } break; } @@ -3668,7 +3270,9 @@ void CodeBlock::tallyFrequentExitSites() FTL::JITCode* jitCode = m_jitCode->ftl(); for (unsigned i = 0; i < jitCode->osrExit.size(); ++i) { FTL::OSRExit& exit = jitCode->osrExit[i]; - exit.considerAddingAsFrequentExitSite(profiledBlock); + + if (!exit.considerAddingAsFrequentExitSite(profiledBlock)) + continue; } break; } @@ -3715,8 +3319,10 @@ void CodeBlock::dumpValueProfiles() unsigned CodeBlock::frameRegisterCount() { switch (jitType()) { +#if ENABLE(LLINT) case JITCode::InterpreterThunk: return LLInt::frameRegisterCountFor(this); +#endif // ENABLE(LLINT) #if ENABLE(JIT) case JITCode::BaselineJIT: @@ -3735,11 +3341,6 @@ unsigned CodeBlock::frameRegisterCount() } } -int CodeBlock::stackPointerOffset() -{ - return virtualRegisterForLocal(frameRegisterCount() - 1).offset(); -} - size_t CodeBlock::predictedMachineCodeSize() { // This will be called from CodeBlock::CodeBlock before either m_vm or the @@ -3799,40 +3400,72 @@ bool CodeBlock::usesOpcode(OpcodeID opcodeID) String CodeBlock::nameForRegister(VirtualRegister virtualRegister) { - for (unsigned i = 0; i < m_constantRegisters.size(); i++) { - if (m_constantRegisters[i].get().isEmpty()) - continue; - if (SymbolTable* symbolTable = jsDynamicCast<SymbolTable*>(m_constantRegisters[i].get())) { - ConcurrentJITLocker locker(symbolTable->m_lock); - auto end = symbolTable->end(locker); - for (auto ptr = symbolTable->begin(locker); ptr != end; ++ptr) { - if (ptr->value.varOffset() == VarOffset(virtualRegister)) { - // FIXME: This won't work from the compilation thread. - // https://bugs.webkit.org/show_bug.cgi?id=115300 - return ptr->key.get(); - } - } + ConcurrentJITLocker locker(symbolTable()->m_lock); + SymbolTable::Map::iterator end = symbolTable()->end(locker); + for (SymbolTable::Map::iterator ptr = symbolTable()->begin(locker); ptr != end; ++ptr) { + if (ptr->value.getIndex() == virtualRegister.offset()) { + // FIXME: This won't work from the compilation thread. + // https://bugs.webkit.org/show_bug.cgi?id=115300 + return String(ptr->key); } } + if (needsActivation() && virtualRegister == activationRegister()) + return ASCIILiteral("activation"); if (virtualRegister == thisRegister()) return ASCIILiteral("this"); + if (usesArguments()) { + if (virtualRegister == argumentsRegister()) + return ASCIILiteral("arguments"); + if (unmodifiedArgumentsRegister(argumentsRegister()) == virtualRegister) + return ASCIILiteral("real arguments"); + } if (virtualRegister.isArgument()) - return String::format("arguments[%3d]", virtualRegister.toArgument()); + return String::format("arguments[%3d]", virtualRegister.toArgument()).impl(); return ""; } -ValueProfile* CodeBlock::valueProfileForBytecodeOffset(int bytecodeOffset) -{ - ValueProfile* result = binarySearch<ValueProfile, int>( - m_valueProfiles, m_valueProfiles.size(), bytecodeOffset, - getValueProfileBytecodeOffset<ValueProfile>); - ASSERT(result->m_bytecodeOffset != -1); - ASSERT(instructions()[bytecodeOffset + opcodeLength( - m_vm->interpreter->getOpcodeID( - instructions()[bytecodeOffset].u.opcode)) - 1].u.profile == result); - return result; -} +namespace { + +struct VerifyCapturedDef { + void operator()(CodeBlock* codeBlock, Instruction* instruction, OpcodeID opcodeID, int operand) + { + unsigned bytecodeOffset = instruction - codeBlock->instructions().begin(); + + if (codeBlock->isConstantRegisterIndex(operand)) { + codeBlock->beginValidationDidFail(); + dataLog(" At bc#", bytecodeOffset, " encountered a definition of a constant.\n"); + codeBlock->endValidationDidFail(); + return; + } + + switch (opcodeID) { + case op_enter: + case op_captured_mov: + case op_init_lazy_reg: + case op_create_arguments: + case op_new_captured_func: + return; + default: + break; + } + + VirtualRegister virtualReg(operand); + if (!virtualReg.isLocal()) + return; + + if (codeBlock->captureCount() && codeBlock->symbolTable()->isCaptured(operand)) { + codeBlock->beginValidationDidFail(); + dataLog(" At bc#", bytecodeOffset, " encountered invalid assignment to captured variable loc", virtualReg.toLocal(), ".\n"); + codeBlock->endValidationDidFail(); + return; + } + + return; + } +}; + +} // anonymous namespace void CodeBlock::validate() { @@ -3849,15 +3482,38 @@ void CodeBlock::validate() } for (unsigned i = m_numCalleeRegisters; i--;) { + bool isCaptured = false; VirtualRegister reg = virtualRegisterForLocal(i); - if (liveAtHead.get(i)) { - beginValidationDidFail(); - dataLog(" Variable ", reg, " is expected to be dead.\n"); - dataLog(" Result: ", liveAtHead, "\n"); - endValidationDidFail(); + if (captureCount()) + isCaptured = reg.offset() <= captureStart() && reg.offset() > captureEnd(); + + if (isCaptured) { + if (!liveAtHead.get(i)) { + beginValidationDidFail(); + dataLog(" Variable loc", i, " is expected to be live because it is captured, but it isn't live.\n"); + dataLog(" Result: ", liveAtHead, "\n"); + endValidationDidFail(); + } + } else { + if (liveAtHead.get(i)) { + beginValidationDidFail(); + dataLog(" Variable loc", i, " is expected to be dead.\n"); + dataLog(" Result: ", liveAtHead, "\n"); + endValidationDidFail(); + } } } + + for (unsigned bytecodeOffset = 0; bytecodeOffset < instructions().size();) { + Instruction* currentInstruction = instructions().begin() + bytecodeOffset; + OpcodeID opcodeID = m_vm->interpreter->getOpcodeID(currentInstruction->u.opcode); + + VerifyCapturedDef verifyCapturedDef; + computeDefsForBytecodeOffset(this, bytecodeOffset, verifyCapturedDef); + + bytecodeOffset += opcodeLength(opcodeID); + } } void CodeBlock::beginValidationDidFail() @@ -3879,98 +3535,15 @@ void CodeBlock::addBreakpoint(unsigned numBreakpoints) { m_numBreakpoints += numBreakpoints; ASSERT(m_numBreakpoints); - if (JITCode::isOptimizingJIT(jitType())) - jettison(Profiler::JettisonDueToDebuggerBreakpoint); + if (jitType() == JITCode::DFGJIT) + jettison(); } void CodeBlock::setSteppingMode(CodeBlock::SteppingMode mode) { m_steppingMode = mode; - if (mode == SteppingModeEnabled && JITCode::isOptimizingJIT(jitType())) - jettison(Profiler::JettisonDueToDebuggerStepping); -} - -RareCaseProfile* CodeBlock::rareCaseProfileForBytecodeOffset(int bytecodeOffset) -{ - return tryBinarySearch<RareCaseProfile, int>( - m_rareCaseProfiles, m_rareCaseProfiles.size(), bytecodeOffset, - getRareCaseProfileBytecodeOffset); -} - -#if ENABLE(JIT) -DFG::CapabilityLevel CodeBlock::capabilityLevel() -{ - DFG::CapabilityLevel result = capabilityLevelInternal(); - m_capabilityLevelState = result; - return result; -} -#endif - -void CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler(RefCountedArray<Instruction>& instructions) -{ - const Vector<size_t>& bytecodeOffsets = unlinkedCodeBlock()->opProfileControlFlowBytecodeOffsets(); - for (size_t i = 0, offsetsLength = bytecodeOffsets.size(); i < offsetsLength; i++) { - // Because op_profile_control_flow is emitted at the beginning of every basic block, finding - // the next op_profile_control_flow will give us the text range of a single basic block. - size_t startIdx = bytecodeOffsets[i]; - RELEASE_ASSERT(vm()->interpreter->getOpcodeID(instructions[startIdx].u.opcode) == op_profile_control_flow); - int basicBlockStartOffset = instructions[startIdx + 1].u.operand; - int basicBlockEndOffset; - if (i + 1 < offsetsLength) { - size_t endIdx = bytecodeOffsets[i + 1]; - RELEASE_ASSERT(vm()->interpreter->getOpcodeID(instructions[endIdx].u.opcode) == op_profile_control_flow); - basicBlockEndOffset = instructions[endIdx + 1].u.operand - 1; - } else { - basicBlockEndOffset = m_sourceOffset + m_ownerExecutable->source().length() - 1; // Offset before the closing brace. - basicBlockStartOffset = std::min(basicBlockStartOffset, basicBlockEndOffset); // Some start offsets may be at the closing brace, ensure it is the offset before. - } - - // The following check allows for the same textual JavaScript basic block to have its bytecode emitted more - // than once and still play nice with the control flow profiler. When basicBlockStartOffset is larger than - // basicBlockEndOffset, it indicates that the bytecode generator has emitted code for the same AST node - // more than once (for example: ForInNode, Finally blocks in TryNode, etc). Though these are different - // basic blocks at the bytecode level, they are generated from the same textual basic block in the JavaScript - // program. The condition: - // (basicBlockEndOffset < basicBlockStartOffset) - // is encountered when op_profile_control_flow lies across the boundary of these duplicated bytecode basic - // blocks and the textual offset goes from the end of the duplicated block back to the beginning. These - // ranges are dummy ranges and are ignored. The duplicated bytecode basic blocks point to the same - // internal data structure, so if any of them execute, it will record the same textual basic block in the - // JavaScript program as executing. - // At the bytecode level, this situation looks like: - // j: op_profile_control_flow (from j->k, we have basicBlockEndOffset < basicBlockStartOffset) - // ... - // k: op_profile_control_flow (we want to skip over the j->k block and start fresh at offset k as the start of a new basic block k->m). - // ... - // m: op_profile_control_flow - if (basicBlockEndOffset < basicBlockStartOffset) { - RELEASE_ASSERT(i + 1 < offsetsLength); // We should never encounter dummy blocks at the end of a CodeBlock. - instructions[startIdx + 1].u.basicBlockLocation = vm()->controlFlowProfiler()->dummyBasicBlock(); - continue; - } - - BasicBlockLocation* basicBlockLocation = vm()->controlFlowProfiler()->getBasicBlockLocation(m_ownerExecutable->sourceID(), basicBlockStartOffset, basicBlockEndOffset); - - // Find all functions that are enclosed within the range: [basicBlockStartOffset, basicBlockEndOffset] - // and insert these functions' start/end offsets as gaps in the current BasicBlockLocation. - // This is necessary because in the original source text of a JavaScript program, - // function literals form new basic blocks boundaries, but they aren't represented - // inside the CodeBlock's instruction stream. - auto insertFunctionGaps = [basicBlockLocation, basicBlockStartOffset, basicBlockEndOffset] (const WriteBarrier<FunctionExecutable>& functionExecutable) { - const UnlinkedFunctionExecutable* executable = functionExecutable->unlinkedExecutable(); - int functionStart = executable->typeProfilingStartOffset(); - int functionEnd = executable->typeProfilingEndOffset(); - if (functionStart >= basicBlockStartOffset && functionEnd <= basicBlockEndOffset) - basicBlockLocation->insertGap(functionStart, functionEnd); - }; - - for (const WriteBarrier<FunctionExecutable>& executable : m_functionDecls) - insertFunctionGaps(executable); - for (const WriteBarrier<FunctionExecutable>& executable : m_functionExprs) - insertFunctionGaps(executable); - - instructions[startIdx + 1].u.basicBlockLocation = basicBlockLocation; - } + if (mode == SteppingModeEnabled && jitType() == JITCode::DFGJIT) + jettison(); } } // namespace JSC |