Ignore:
Timestamp:
Aug 14, 2014, 4:59:44 PM (11 years ago)
Author:
[email protected]
Message:

Allow high fidelity type profiling to be enabled and disabled.
​https://bugs.webkit.org/show_bug.cgi?id=135423

Patch by Saam Barati <​[email protected]> on 2014-08-14
Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

  • Merged op_put_to_scope_with_profile and op_get_from_scope_with_profile into op_profile_types_with_high_fidelity by adding extra arguments to the opcode.
  • Altered SymbolTable to use less memory by adding a rare data structure for type profiling.
  • Created an interface to turn on and off type profiling from the Web Inspector.
  • Refactored how entries are written to HighFidelityLog to make it easier to inline when generating machine code.
  • Implemented op_profile_types_with_high_fidelity in the baseline JIT by inlining the process of writing to the log and doing a small amount of type inference optimizations.
  • bytecode/BytecodeList.json:
  • bytecode/BytecodeUseDef.h:

(JSC::computeUsesForBytecodeOffset):
(JSC::computeDefsForBytecodeOffset):

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dumpBytecode):
(JSC::CodeBlock::CodeBlock):
(JSC::CodeBlock::finalizeUnconditionally):
(JSC::CodeBlock::scopeDependentProfile): Deleted.

  • bytecode/CodeBlock.h:
  • bytecode/TypeLocation.h:

(JSC::TypeLocation::TypeLocation):

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::generate):
(JSC::BytecodeGenerator::emitMove):
(JSC::BytecodeGenerator::emitProfileTypesWithHighFidelity):
(JSC::BytecodeGenerator::emitGetFromScopeWithProfile): Deleted.
(JSC::BytecodeGenerator::emitPutToScopeWithProfile): Deleted.

  • bytecompiler/BytecodeGenerator.h:
  • bytecompiler/NodesCodegen.cpp:

(JSC::ThisNode::emitBytecode):
(JSC::ResolveNode::emitBytecode):
(JSC::BracketAccessorNode::emitBytecode):
(JSC::DotAccessorNode::emitBytecode):
(JSC::FunctionCallValueNode::emitBytecode):
(JSC::FunctionCallResolveNode::emitBytecode):
(JSC::FunctionCallBracketNode::emitBytecode):
(JSC::FunctionCallDotNode::emitBytecode):
(JSC::CallFunctionCallDotNode::emitBytecode):
(JSC::ApplyFunctionCallDotNode::emitBytecode):
(JSC::PostfixNode::emitResolve):
(JSC::PostfixNode::emitBracket):
(JSC::PostfixNode::emitDot):
(JSC::PrefixNode::emitResolve):
(JSC::PrefixNode::emitBracket):
(JSC::PrefixNode::emitDot):
(JSC::ReadModifyResolveNode::emitBytecode):
(JSC::AssignResolveNode::emitBytecode):
(JSC::AssignDotNode::emitBytecode):
(JSC::ReadModifyDotNode::emitBytecode):
(JSC::AssignBracketNode::emitBytecode):
(JSC::ReadModifyBracketNode::emitBytecode):
(JSC::ReturnNode::emitBytecode):
(JSC::FunctionBodyNode::emitBytecode):

  • inspector/agents/InspectorRuntimeAgent.cpp:

(Inspector::InspectorRuntimeAgent::InspectorRuntimeAgent):
(Inspector::InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets):
(Inspector::TypeRecompiler::operator()):
(Inspector::recompileAllJSFunctionsForTypeProfiling):
(Inspector::InspectorRuntimeAgent::willDestroyFrontendAndBackend):
(Inspector::InspectorRuntimeAgent::enableHighFidelityTypeProfiling):
(Inspector::InspectorRuntimeAgent::disableHighFidelityTypeProfiling):
(Inspector::InspectorRuntimeAgent::setHighFidelityTypeProfilingEnabledState):

  • inspector/agents/InspectorRuntimeAgent.h:
  • inspector/agents/JSGlobalObjectRuntimeAgent.cpp:

(Inspector::JSGlobalObjectRuntimeAgent::willDestroyFrontendAndBackend):

  • inspector/protocol/Runtime.json:
  • jit/JIT.cpp:

(JSC::JIT::privateCompileMainPass):
(JSC::JIT::privateCompile):

  • jit/JIT.h:
  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_profile_types_with_high_fidelity):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_profile_types_with_high_fidelity):

  • jit/JITOperations.cpp:
  • jit/JITOperations.h:
  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(JSC::LLInt::getFromScopeCommon): Deleted.
(JSC::LLInt::putToScopeCommon): Deleted.

  • llint/LLIntSlowPaths.h:
  • llint/LowLevelInterpreter.asm:
  • runtime/CodeCache.cpp:

(JSC::CodeCache::getGlobalCodeBlock):

  • runtime/CommonSlowPaths.cpp:

(JSC::SLOW_PATH_DECL):

  • runtime/CommonSlowPaths.h:
  • runtime/HighFidelityLog.cpp:

(JSC::HighFidelityLog::initializeHighFidelityLog):
(JSC::HighFidelityLog::~HighFidelityLog):
(JSC::HighFidelityLog::processHighFidelityLog):

  • runtime/HighFidelityLog.h:

(JSC::HighFidelityLog::LogEntry::structureIDOffset):
(JSC::HighFidelityLog::LogEntry::valueOffset):
(JSC::HighFidelityLog::LogEntry::locationOffset):
(JSC::HighFidelityLog::recordTypeInformationForLocation):
(JSC::HighFidelityLog::logEndPtr):
(JSC::HighFidelityLog::logStartOffset):
(JSC::HighFidelityLog::currentLogEntryOffset):

  • runtime/HighFidelityTypeProfiler.cpp:

(JSC::HighFidelityTypeProfiler::logTypesForTypeLocation):
(JSC::descriptorMatchesTypeLocation):

  • runtime/HighFidelityTypeProfiler.h:
  • runtime/SymbolTable.cpp:

(JSC::SymbolTable::SymbolTable):
(JSC::SymbolTable::cloneCapturedNames):
(JSC::SymbolTable::prepareForHighFidelityTypeProfiling):
(JSC::SymbolTable::uniqueIDForVariable):
(JSC::SymbolTable::uniqueIDForRegister):
(JSC::SymbolTable::globalTypeSetForRegister):
(JSC::SymbolTable::globalTypeSetForVariable):

  • runtime/SymbolTable.h:

(JSC::SymbolTable::add):
(JSC::SymbolTable::set):

  • runtime/TypeLocationCache.cpp:

(JSC::TypeLocationCache::getTypeLocation):

  • runtime/TypeSet.cpp:

(JSC::TypeSet::getRuntimeTypeForValue):
(JSC::TypeSet::addTypeInformation):
(JSC::TypeSet::allPrimitiveTypeNames):
(JSC::TypeSet::addTypeForValue): Deleted.

  • runtime/TypeSet.h:
  • runtime/VM.cpp:

(JSC::VM::VM):
(JSC::VM::nextTypeLocation):
(JSC::VM::enableHighFidelityTypeProfiling):
(JSC::VM::disableHighFidelityTypeProfiling):
(JSC::VM::dumpHighFidelityProfilingTypes):

  • runtime/VM.h:

(JSC::VM::nextLocation): Deleted.

Source/WebCore:

PageRuntimeAgent and WorkerRuntimeAgent now call their super
class's (InspectorRuntimeAgent) implementation of willDestroyFrontendAndBackend
to give InspectorRuntimeAgent a chance to recompile all JavaScript
functions, if necessary, for type profiling.

  • inspector/PageRuntimeAgent.cpp:

(WebCore::PageRuntimeAgent::willDestroyFrontendAndBackend):

  • inspector/WorkerRuntimeAgent.cpp:

(WebCore::WorkerRuntimeAgent::willDestroyFrontendAndBackend):

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r172413 r172614  
    138138    if (dst == generator.ignoredResult())
    139139        return 0;
    140     return generator.moveToDestinationIfNeeded(dst, generator.thisRegister());
     140
     141    RegisterID* result = generator.moveToDestinationIfNeeded(dst, generator.thisRegister());
     142    if (generator.isProfilingTypesWithHighFidelity()) {
     143        generator.emitProfileTypesWithHighFidelity(generator.thisRegister(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
     144        static const unsigned thisLength = 4;
     145        generator.emitHighFidelityTypeProfilingExpressionInfo(position(), JSTextPosition(-1, position().offset + thisLength, -1));
     146    }
     147    return result;
    141148}
    142149
    … …  
    154161            return 0;
    155162        if (generator.isProfilingTypesWithHighFidelity()) {
    156             generator.emitProfileTypesWithHighFidelity(local.get(), ProfileTypesBytecodeHasGlobalID);
     163            generator.emitProfileTypesWithHighFidelity(local.get(), ProfileTypesBytecodeHasGlobalID, nullptr);
    157164            generator.emitHighFidelityTypeProfilingExpressionInfo(m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
    158165        }
    … …  
    163170    generator.emitExpressionInfo(divot, m_start, divot);
    164171    RefPtr<RegisterID> scope = generator.emitResolveScope(generator.tempDestination(dst), m_ident);
    165     RegisterID* ret;
     172    RegisterID* finalDest = generator.finalDestination(dst);
     173    RegisterID* result = generator.emitGetFromScope(finalDest, scope.get(), m_ident, ThrowIfNotFound);
    166174    if (generator.isProfilingTypesWithHighFidelity()) {
    167         ret = generator.emitGetFromScopeWithProfile(generator.finalDestination(dst), scope.get(), m_ident, ThrowIfNotFound);
     175        generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeGetFromScope, &m_ident);
    168176        generator.emitHighFidelityTypeProfilingExpressionInfo(m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
    169     } else
    170         ret = generator.emitGetFromScope(generator.finalDestination(dst), scope.get(), m_ident, ThrowIfNotFound);
    171     return ret;
     177    }
     178    return result;
    172179}
    173180
    … …  
    388395    RegisterID* ret = generator.emitGetByVal(finalDest, base.get(), property);
    389396    if (generator.isProfilingTypesWithHighFidelity()) {
    390         generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeDoesNotHaveGlobalID);
     397        generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    391398        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    392399    }
    … …  
    414421    RegisterID* ret = generator.emitGetById(finalDest, base, m_ident);
    415422    if (generator.isProfilingTypesWithHighFidelity()) {
    416         generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeDoesNotHaveGlobalID);
     423        generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    417424        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    418425    }
    … …  
    498505    RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    499506    if (generator.isProfilingTypesWithHighFidelity()) {
    500         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     507        generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    501508        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    502509    }
    … …  
    519526        RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    520527        if (generator.isProfilingTypesWithHighFidelity()) {
    521             generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     528            generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    522529            generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    523530        }
    … …  
    535542    RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
    536543    if (generator.isProfilingTypesWithHighFidelity()) {
    537         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     544        generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    538545        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    539546    }
    … …  
    554561    RegisterID* ret = generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    555562    if (generator.isProfilingTypesWithHighFidelity()) {
    556         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     563        generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    557564        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    558565    }
    … …  
    572579    RegisterID* ret = generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    573580    if (generator.isProfilingTypesWithHighFidelity()) {
    574         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     581        generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    575582        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    576583    }
    … …  
    646653    }
    647654    if (generator.isProfilingTypesWithHighFidelity()) {
    648         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     655        generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    649656        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    650657    }
    … …  
    760767    }
    761768    if (generator.isProfilingTypesWithHighFidelity()) {
    762         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     769        generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    763770        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    764771    }
    … …  
    815822    RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), ident, ThrowIfNotFound);
    816823    RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
     824    generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound);
    817825    if (generator.isProfilingTypesWithHighFidelity()) {
    818         generator.emitPutToScopeWithProfile(scope.get(), ident, value.get(), ThrowIfNotFound);
     826        generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodePutToScope, &ident);
    819827        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    820     } else
    821         generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound);
     828    }
    822829
    823830    return oldValue.get();
    … …  
    843850    generator.emitPutByVal(base.get(), property.get(), value.get());
    844851    if (generator.isProfilingTypesWithHighFidelity()) {
    845         generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     852        generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    846853        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    847854    }
    … …  
    867874    generator.emitPutById(base.get(), ident, value.get());
    868875    if (generator.isProfilingTypesWithHighFidelity()) {
    869         generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodeDoesNotHaveGlobalID);
     876        generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    870877        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    871878    }
    … …  
    10031010    RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), ident, ThrowIfNotFound);
    10041011    emitIncOrDec(generator, value.get(), m_operator);
     1012    generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound);
    10051013    if (generator.isProfilingTypesWithHighFidelity()) {
    1006         generator.emitPutToScopeWithProfile(scope.get(), ident, value.get(), ThrowIfNotFound);
     1014        generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodePutToScope, &ident);
    10071015        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    1008     } else
    1009         generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound);
     1016    }
    10101017    return generator.moveToDestinationIfNeeded(dst, value.get());
    10111018}
    … …  
    10281035    generator.emitPutByVal(base.get(), property.get(), value);
    10291036    if (generator.isProfilingTypesWithHighFidelity()) {
    1030         generator.emitProfileTypesWithHighFidelity(value, ProfileTypesBytecodeDoesNotHaveGlobalID);
     1037        generator.emitProfileTypesWithHighFidelity(value, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    10311038        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    10321039    }
    … …  
    10501057    generator.emitPutById(base.get(), ident, value);
    10511058    if (generator.isProfilingTypesWithHighFidelity()) {
    1052         generator.emitProfileTypesWithHighFidelity(value, ProfileTypesBytecodeDoesNotHaveGlobalID);
     1059        generator.emitProfileTypesWithHighFidelity(value, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    10531060        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    10541061    }
    … …  
    15211528    RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), m_ident, ThrowIfNotFound);
    15221529    RefPtr<RegisterID> result = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()), this);
    1523     RegisterID* ret;
     1530    RegisterID* returnResult = generator.emitPutToScope(scope.get(), m_ident, result.get(), ThrowIfNotFound);
    15241531    if (generator.isProfilingTypesWithHighFidelity()) {
    1525         ret = generator.emitPutToScopeWithProfile(scope.get(), m_ident, result.get(), ThrowIfNotFound);
     1532        generator.emitProfileTypesWithHighFidelity(result.get(), ProfileTypesBytecodePutToScope, &m_ident);
    15261533        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    1527     } else
    1528         ret = generator.emitPutToScope(scope.get(), m_ident, result.get(), ThrowIfNotFound);
    1529     return ret;
     1534    }
     1535    return returnResult;
    15301536}
    15311537
    … …  
    15601566    RefPtr<RegisterID> result = generator.emitNode(dst, m_right);
    15611567    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    1562     RegisterID* ret;
     1568    RegisterID* returnResult = generator.emitPutToScope(scope.get(), m_ident, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound);
    15631569    if (generator.isProfilingTypesWithHighFidelity()) {
    1564         ret = generator.emitPutToScopeWithProfile(scope.get(), m_ident, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound);
     1570        generator.emitProfileTypesWithHighFidelity(result.get(), ProfileTypesBytecodePutToScope, &m_ident);
    15651571        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    1566     } else
    1567         ret = generator.emitPutToScope(scope.get(), m_ident, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound);
    1568     return ret;
     1572    }
     1573    return returnResult;
    15691574}
    15701575
    … …  
    15801585    generator.emitPutById(base.get(), m_ident, forwardResult);
    15811586    if (generator.isProfilingTypesWithHighFidelity()) {
    1582         generator.emitProfileTypesWithHighFidelity(forwardResult, ProfileTypesBytecodeDoesNotHaveGlobalID);
     1587        generator.emitProfileTypesWithHighFidelity(forwardResult, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    15831588        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    15841589    }
    … …  
    15991604    RegisterID* ret = generator.emitPutById(base.get(), m_ident, updatedValue);
    16001605    if (generator.isProfilingTypesWithHighFidelity()) {
    1601         generator.emitProfileTypesWithHighFidelity(updatedValue, ProfileTypesBytecodeDoesNotHaveGlobalID);
     1606        generator.emitProfileTypesWithHighFidelity(updatedValue, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    16021607        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    16031608    }
    … …  
    16251630    generator.emitPutByVal(base.get(), property.get(), forwardResult);
    16261631    if (generator.isProfilingTypesWithHighFidelity()) {
    1627         generator.emitProfileTypesWithHighFidelity(forwardResult, ProfileTypesBytecodeDoesNotHaveGlobalID);
     1632        generator.emitProfileTypesWithHighFidelity(forwardResult, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    16281633        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    16291634    }
    … …  
    16451650    generator.emitPutByVal(base.get(), property.get(), updatedValue);
    16461651    if (generator.isProfilingTypesWithHighFidelity()) {
    1647         generator.emitProfileTypesWithHighFidelity(updatedValue, ProfileTypesBytecodeDoesNotHaveGlobalID);
     1652        generator.emitProfileTypesWithHighFidelity(updatedValue, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    16481653        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    16491654    }
    … …  
    22522257    RefPtr<RegisterID> returnRegister = m_value ? generator.emitNode(dst, m_value) : generator.emitLoad(dst, jsUndefined());
    22532258    if (generator.isProfilingTypesWithHighFidelity()) {
    2254         generator.emitProfileTypesWithHighFidelity(returnRegister.get(), ProfileTypesBytecodeFunctionReturnStatement);
     2259        generator.emitProfileTypesWithHighFidelity(returnRegister.get(), ProfileTypesBytecodeFunctionReturnStatement, nullptr);
    22552260        generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
    22562261    }
    … …  
    25832588{
    25842589    if (generator.isProfilingTypesWithHighFidelity()) {
    2585         JSTextPosition start(-1, m_startStartOffset, -1); // This divot is at the open brace of the function.
    2586         JSTextPosition end(-1, m_startStartOffset + 1, -1);
    2587         generator.emitProfileTypesWithHighFidelity(generator.thisRegister(), ProfileTypesBytecodeFunctionThisObject);
    2588         generator.emitHighFidelityTypeProfilingExpressionInfo(start, end);
    25892590        for (size_t i = 0; i < m_parameters->size(); i++) {
    25902591            // FIXME: Handle Destructuring assignments into arguments.
    … …  
    25932594            BindingNode* parameter = static_cast<BindingNode*>(m_parameters->at(i));
    25942595            RegisterID reg(CallFrame::argumentOffset(i));
    2595             generator.emitProfileTypesWithHighFidelity(&reg, ProfileTypesBytecodeFunctionArgument);
     2596            generator.emitProfileTypesWithHighFidelity(&reg, ProfileTypesBytecodeFunctionArgument, nullptr);
    25962597            generator.emitHighFidelityTypeProfilingExpressionInfo(parameter->divotStart(), parameter->divotEnd());
    25972598        }
    … …  
    26152616        RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
    26162617        if (generator.isProfilingTypesWithHighFidelity())
    2617             generator.emitProfileTypesWithHighFidelity(r0, ProfileTypesBytecodeFunctionReturnStatement); // Do not emit expression info for this profile because it's not in the user's source code.
     2618            generator.emitProfileTypesWithHighFidelity(r0, ProfileTypesBytecodeFunctionReturnStatement, nullptr); // Do not emit expression info for this profile because it's not in the user's source code.
    26182619        ASSERT(startOffset() >= lineStartOffset());
    26192620        generator.emitDebugHook(WillLeaveCallFrame, lastLine(), startOffset(), lineStartOffset());
Note: See TracChangeset for help on using the changeset viewer.