Ignore:
Timestamp:
Aug 20, 2014, 6:03:20 PM (11 years ago)
Author:
[email protected]
Message:

Rename HighFidelityTypeProfiling variables for more clarity
​https://bugs.webkit.org/show_bug.cgi?id=135899

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

Source/JavaScriptCore:

Many names that are used in the type profiling infrastructure
prefix themselves with "HighFidelity" or include the words "high"
and/or "fidelity" in some way. But the words "high" and "fidelity" don't
add anything descriptive to the names surrounding type profiling.
So this patch removes all uses of "HighFidelity" and its variants.

Most renamings change "HighFidelity*" to "TypeProfiler*" or simply
drop the prefix "HighFidelity" all together. Now, almost all names
in relation to type profiling contain in them "TypeProfiler" or
"TypeProfiling" or some combination of the words "type" and "profile".

This patch also changes how we check if type profiling is enabled:
We no longer call vm::isProfilingTypesWithHighFidelity. We now just
check that vm::typeProfiler is not null.

This patch also changes all calls to TypeProfilerLog::processLogEntries
to use ASCIILiteral to form WTFStrings instead of vanilla C string literals.

  • CMakeLists.txt:
  • JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
  • JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • bytecode/BytecodeList.json:
  • bytecode/BytecodeUseDef.h:

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

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dumpBytecode):
(JSC::CodeBlock::CodeBlock):

  • bytecode/TypeLocation.h:
  • bytecode/UnlinkedCodeBlock.cpp:

(JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
(JSC::UnlinkedCodeBlock::typeProfilerExpressionInfoForBytecodeOffset):
(JSC::UnlinkedCodeBlock::addTypeProfilerExpressionInfo):
(JSC::UnlinkedCodeBlock::highFidelityTypeProfileExpressionInfoForBytecodeOffset): Deleted.
(JSC::UnlinkedCodeBlock::addHighFidelityTypeProfileExpressionInfo): Deleted.

  • bytecode/UnlinkedCodeBlock.h:

(JSC::UnlinkedFunctionExecutable::typeProfilingStartOffset):
(JSC::UnlinkedFunctionExecutable::typeProfilingEndOffset):
(JSC::UnlinkedFunctionExecutable::highFidelityTypeProfilingStartOffset): Deleted.
(JSC::UnlinkedFunctionExecutable::highFidelityTypeProfilingEndOffset): Deleted.

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::generate):
(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::emitMove):
(JSC::BytecodeGenerator::emitTypeProfilerExpressionInfo):
(JSC::BytecodeGenerator::emitProfileType):
(JSC::BytecodeGenerator::emitHighFidelityTypeProfilingExpressionInfo): Deleted.
(JSC::BytecodeGenerator::emitProfileTypesWithHighFidelity): Deleted.

  • bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::isProfilingTypesWithHighFidelity): Deleted.

  • 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::ConstDeclNode::emitCodeSingle):
(JSC::EmptyVarExpression::emitBytecode):
(JSC::ReturnNode::emitBytecode):
(JSC::FunctionBodyNode::emitBytecode):

  • heap/Heap.cpp:

(JSC::Heap::collect):

  • inspector/agents/InspectorRuntimeAgent.cpp:

(Inspector::InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets):
(Inspector::recompileAllJSFunctionsForTypeProfiling):
(Inspector::InspectorRuntimeAgent::willDestroyFrontendAndBackend):
(Inspector::InspectorRuntimeAgent::enableTypeProfiler):
(Inspector::InspectorRuntimeAgent::disableTypeProfiler):
(Inspector::InspectorRuntimeAgent::setTypeProfilerEnabledState):
(Inspector::InspectorRuntimeAgent::enableHighFidelityTypeProfiling): Deleted.
(Inspector::InspectorRuntimeAgent::disableHighFidelityTypeProfiling): Deleted.
(Inspector::InspectorRuntimeAgent::setHighFidelityTypeProfilingEnabledState): Deleted.

  • inspector/agents/InspectorRuntimeAgent.h:
  • inspector/protocol/Runtime.json:
  • jit/JIT.cpp:

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

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

(JSC::JIT::emit_op_profile_type):
(JSC::JIT::emit_op_profile_types_with_high_fidelity): Deleted.

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_profile_type):
(JSC::JIT::emit_op_profile_types_with_high_fidelity): Deleted.

  • jit/JITOperations.cpp:
  • jsc.cpp:

(functionDumpTypesForAllVariables):

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

(JSC::CodeCache::getGlobalCodeBlock):

  • runtime/CommonSlowPaths.cpp:

(JSC::SLOW_PATH_DECL):

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

(JSC::ScriptExecutable::ScriptExecutable):
(JSC::ProgramExecutable::ProgramExecutable):
(JSC::FunctionExecutable::FunctionExecutable):
(JSC::ProgramExecutable::initializeGlobalProperties):

  • runtime/Executable.h:

(JSC::ScriptExecutable::typeProfilingStartOffset):
(JSC::ScriptExecutable::typeProfilingEndOffset):
(JSC::ScriptExecutable::highFidelityTypeProfilingStartOffset): Deleted.
(JSC::ScriptExecutable::highFidelityTypeProfilingEndOffset): Deleted.

  • runtime/HighFidelityLog.cpp: Removed.
  • runtime/HighFidelityLog.h: Removed.
  • runtime/HighFidelityTypeProfiler.cpp: Removed.
  • runtime/HighFidelityTypeProfiler.h: Removed.
  • runtime/Options.h:
  • runtime/SymbolTable.cpp:

(JSC::SymbolTable::prepareForTypeProfiling):
(JSC::SymbolTable::uniqueIDForVariable):
(JSC::SymbolTable::uniqueIDForRegister):
(JSC::SymbolTable::prepareForHighFidelityTypeProfiling): Deleted.

  • runtime/SymbolTable.h:
  • runtime/TypeProfiler.cpp: Added.

(JSC::TypeProfiler::logTypesForTypeLocation):
(JSC::TypeProfiler::insertNewLocation):
(JSC::TypeProfiler::getTypesForVariableAtOffsetForInspector):
(JSC::descriptorMatchesTypeLocation):
(JSC::TypeProfiler::findLocation):

  • runtime/TypeProfiler.h: Added.

(JSC::QueryKey::QueryKey):
(JSC::QueryKey::isHashTableDeletedValue):
(JSC::QueryKey::operator==):
(JSC::QueryKey::hash):
(JSC::QueryKeyHash::hash):
(JSC::QueryKeyHash::equal):
(JSC::TypeProfiler::functionHasExecutedCache):
(JSC::TypeProfiler::typeLocationCache):

  • runtime/TypeProfilerLog.cpp: Added.

(JSC::TypeProfilerLog::initializeLog):
(JSC::TypeProfilerLog::~TypeProfilerLog):
(JSC::TypeProfilerLog::processLogEntries):

  • runtime/TypeProfilerLog.h: Added.

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

  • runtime/VM.cpp:

(JSC::VM::VM):
(JSC::VM::enableTypeProfiler):
(JSC::VM::disableTypeProfiler):
(JSC::VM::dumpTypeProfilerData):
(JSC::VM::enableHighFidelityTypeProfiling): Deleted.
(JSC::VM::disableHighFidelityTypeProfiling): Deleted.
(JSC::VM::dumpHighFidelityProfilingTypes): Deleted.

  • runtime/VM.h:

(JSC::VM::typeProfilerLog):
(JSC::VM::typeProfiler):
(JSC::VM::isProfilingTypesWithHighFidelity): Deleted.
(JSC::VM::highFidelityLog): Deleted.
(JSC::VM::highFidelityTypeProfiler): Deleted.

Source/WebInspectorUI:

Change a reference in a comment to a JavaScriptCore file to its
newly renamed variant.

  • UserInterface/Models/ScriptSyntaxTree.js:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r172794 r172820  
    140140
    141141    RegisterID* result = generator.moveToDestinationIfNeeded(dst, generator.thisRegister());
    142     if (generator.isProfilingTypesWithHighFidelity()) {
    143         generator.emitProfileTypesWithHighFidelity(generator.thisRegister(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
     142    if (generator.vm()->typeProfiler()) {
     143        generator.emitProfileType(generator.thisRegister(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
    144144        static const unsigned thisLength = 4;
    145         generator.emitHighFidelityTypeProfilingExpressionInfo(position(), JSTextPosition(-1, position().offset + thisLength, -1));
     145        generator.emitTypeProfilerExpressionInfo(position(), JSTextPosition(-1, position().offset + thisLength, -1));
    146146    }
    147147    return result;
    … …  
    160160        if (dst == generator.ignoredResult())
    161161            return 0;
    162         if (generator.isProfilingTypesWithHighFidelity()) {
    163             generator.emitProfileTypesWithHighFidelity(local.get(), ProfileTypesBytecodeHasGlobalID, nullptr);
    164             generator.emitHighFidelityTypeProfilingExpressionInfo(m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
     162        if (generator.vm()->typeProfiler()) {
     163            generator.emitProfileType(local.get(), ProfileTypeBytecodeHasGlobalID, nullptr);
     164            generator.emitTypeProfilerExpressionInfo(m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
    165165        }
    166166        return generator.moveToDestinationIfNeeded(dst, local.get());
    … …  
    172172    RegisterID* finalDest = generator.finalDestination(dst);
    173173    RegisterID* result = generator.emitGetFromScope(finalDest, scope.get(), m_ident, ThrowIfNotFound);
    174     if (generator.isProfilingTypesWithHighFidelity()) {
    175         generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeGetFromScope, &m_ident);
    176         generator.emitHighFidelityTypeProfilingExpressionInfo(m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
     174    if (generator.vm()->typeProfiler()) {
     175        generator.emitProfileType(finalDest, ProfileTypeBytecodeGetFromScope, &m_ident);
     176        generator.emitTypeProfilerExpressionInfo(m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
    177177    }
    178178    return result;
    … …  
    394394    RegisterID* finalDest = generator.finalDestination(dst);
    395395    RegisterID* ret = generator.emitGetByVal(finalDest, base.get(), property);
    396     if (generator.isProfilingTypesWithHighFidelity()) {
    397         generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    398         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     396    if (generator.vm()->typeProfiler()) {
     397        generator.emitProfileType(finalDest, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     398        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    399399    }
    400400    return ret;
    … …  
    420420    RegisterID* finalDest = generator.finalDestination(dst);
    421421    RegisterID* ret = generator.emitGetById(finalDest, base, m_ident);
    422     if (generator.isProfilingTypesWithHighFidelity()) {
    423         generator.emitProfileTypesWithHighFidelity(finalDest, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    424         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     422    if (generator.vm()->typeProfiler()) {
     423        generator.emitProfileType(finalDest, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     424        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    425425    }
    426426    return ret;
    … …  
    504504    generator.emitLoad(callArguments.thisRegister(), jsUndefined());
    505505    RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    506     if (generator.isProfilingTypesWithHighFidelity()) {
    507         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    508         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     506    if (generator.vm()->typeProfiler()) {
     507        generator.emitProfileType(returnValue.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     508        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    509509    }
    510510    return ret;
    … …  
    525525        // local variable, then it's not one of our built-in constructors.
    526526        RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    527         if (generator.isProfilingTypesWithHighFidelity()) {
    528             generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    529             generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     527        if (generator.vm()->typeProfiler()) {
     528            generator.emitProfileType(returnValue.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     529            generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    530530        }
    531531        return ret;
    … …  
    541541    generator.emitGetFromScope(func.get(), callArguments.thisRegister(), m_ident, ThrowIfNotFound);
    542542    RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
    543     if (generator.isProfilingTypesWithHighFidelity()) {
    544         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    545         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     543    if (generator.vm()->typeProfiler()) {
     544        generator.emitProfileType(returnValue.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     545        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    546546    }
    547547    return ret;
    … …  
    560560    generator.emitMove(callArguments.thisRegister(), base.get());
    561561    RegisterID* ret = generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    562     if (generator.isProfilingTypesWithHighFidelity()) {
    563         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    564         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     562    if (generator.vm()->typeProfiler()) {
     563        generator.emitProfileType(returnValue.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     564        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    565565    }
    566566    return ret;
    … …  
    578578    generator.emitGetById(function.get(), callArguments.thisRegister(), m_ident);
    579579    RegisterID* ret = generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
    580     if (generator.isProfilingTypesWithHighFidelity()) {
    581         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    582         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     580    if (generator.vm()->typeProfiler()) {
     581        generator.emitProfileType(returnValue.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     582        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    583583    }
    584584    return ret;
    … …  
    652652        generator.emitLabel(end.get());
    653653    }
    654     if (generator.isProfilingTypesWithHighFidelity()) {
    655         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    656         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     654    if (generator.vm()->typeProfiler()) {
     655        generator.emitProfileType(returnValue.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     656        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    657657    }
    658658    return returnValue.get();
    … …  
    766766        generator.emitLabel(end.get());
    767767    }
    768     if (generator.isProfilingTypesWithHighFidelity()) {
    769         generator.emitProfileTypesWithHighFidelity(returnValue.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    770         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     768    if (generator.vm()->typeProfiler()) {
     769        generator.emitProfileType(returnValue.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     770        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    771771    }
    772772    return returnValue.get();
    … …  
    803803            generator.emitReadOnlyExceptionIfNeeded();
    804804            localReg = generator.emitMove(generator.tempDestination(dst), localReg);
    805         } else if (local.isCaptured() || generator.isProfilingTypesWithHighFidelity()) {
     805        } else if (local.isCaptured() || generator.vm()->typeProfiler()) {
    806806            RefPtr<RegisterID> tempDst = generator.finalDestination(dst);
    807807            ASSERT(dst != localReg);
    … …  
    811811            emitIncOrDec(generator, tempDstSrc.get(), m_operator);
    812812            generator.emitMove(localReg, tempDstSrc.get());
    813             if (generator.isProfilingTypesWithHighFidelity())
    814                 generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     813            if (generator.vm()->typeProfiler())
     814                generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    815815            return tempDst.get();
    816816        }
    … …  
    823823    RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
    824824    generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound);
    825     if (generator.isProfilingTypesWithHighFidelity()) {
    826         generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodePutToScope, &ident);
    827         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     825    if (generator.vm()->typeProfiler()) {
     826        generator.emitProfileType(value.get(), ProfileTypeBytecodePutToScope, &ident);
     827        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    828828    }
    829829
    … …  
    849849    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    850850    generator.emitPutByVal(base.get(), property.get(), value.get());
    851     if (generator.isProfilingTypesWithHighFidelity()) {
    852         generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    853         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     851    if (generator.vm()->typeProfiler()) {
     852        generator.emitProfileType(value.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     853        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    854854    }
    855855    return generator.moveToDestinationIfNeeded(dst, oldValue);
    … …  
    873873    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    874874    generator.emitPutById(base.get(), ident, value.get());
    875     if (generator.isProfilingTypesWithHighFidelity()) {
    876         generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    877         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     875    if (generator.vm()->typeProfiler()) {
     876        generator.emitProfileType(value.get(), ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     877        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    878878    }
    879879    return generator.moveToDestinationIfNeeded(dst, oldValue);
    … …  
    993993            generator.emitReadOnlyExceptionIfNeeded();
    994994            localReg = generator.emitMove(generator.tempDestination(dst), localReg);
    995         } else if (local.isCaptured() || generator.isProfilingTypesWithHighFidelity()) {
     995        } else if (local.isCaptured() || generator.vm()->typeProfiler()) {
    996996            RefPtr<RegisterID> tempDst = generator.tempDestination(dst);
    997997            generator.emitMove(tempDst.get(), localReg);
    998998            emitIncOrDec(generator, tempDst.get(), m_operator);
    999999            generator.emitMove(localReg, tempDst.get());
    1000             if (generator.isProfilingTypesWithHighFidelity())
    1001                 generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1000            if (generator.vm()->typeProfiler())
     1001                generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    10021002            return generator.moveToDestinationIfNeeded(dst, tempDst.get());
    10031003        }
    … …  
    10111011    emitIncOrDec(generator, value.get(), m_operator);
    10121012    generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound);
    1013     if (generator.isProfilingTypesWithHighFidelity()) {
    1014         generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodePutToScope, &ident);
    1015         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1013    if (generator.vm()->typeProfiler()) {
     1014        generator.emitProfileType(value.get(), ProfileTypeBytecodePutToScope, &ident);
     1015        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    10161016    }
    10171017    return generator.moveToDestinationIfNeeded(dst, value.get());
    … …  
    10341034    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    10351035    generator.emitPutByVal(base.get(), property.get(), value);
    1036     if (generator.isProfilingTypesWithHighFidelity()) {
    1037         generator.emitProfileTypesWithHighFidelity(value, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    1038         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1036    if (generator.vm()->typeProfiler()) {
     1037        generator.emitProfileType(value, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     1038        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    10391039    }
    10401040    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    … …  
    10561056    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    10571057    generator.emitPutById(base.get(), ident, value);
    1058     if (generator.isProfilingTypesWithHighFidelity()) {
    1059         generator.emitProfileTypesWithHighFidelity(value, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    1060         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1058    if (generator.vm()->typeProfiler()) {
     1059        generator.emitProfileType(value, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     1060        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    10611061    }
    10621062    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    … …  
    15071507       
    15081508        if (local.isCaptured()
    1509             || generator.isProfilingTypesWithHighFidelity()
     1509            || generator.vm()->typeProfiler()
    15101510            || generator.leftHandSideNeedsCopy(m_rightHasAssignments, m_right->isPure(generator))) {
    15111511            RefPtr<RegisterID> result = generator.newTemporary();
    … …  
    15141514            generator.emitMove(local.get(), result.get());
    15151515            generator.invalidateForInContextForLocal(local.get());
    1516             if (generator.isProfilingTypesWithHighFidelity())
    1517                 generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1516            if (generator.vm()->typeProfiler())
     1517                generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    15181518            return generator.moveToDestinationIfNeeded(dst, result.get());
    15191519        }
    … …  
    15291529    RefPtr<RegisterID> result = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()), this);
    15301530    RegisterID* returnResult = generator.emitPutToScope(scope.get(), m_ident, result.get(), ThrowIfNotFound);
    1531     if (generator.isProfilingTypesWithHighFidelity()) {
    1532         generator.emitProfileTypesWithHighFidelity(result.get(), ProfileTypesBytecodePutToScope, &m_ident);
    1533         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1531    if (generator.vm()->typeProfiler()) {
     1532        generator.emitProfileType(result.get(), ProfileTypeBytecodePutToScope, &m_ident);
     1533        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    15341534    }
    15351535    return returnResult;
    … …  
    15451545            return generator.emitNode(dst, m_right);
    15461546        }
    1547         if (local.isCaptured() || generator.isProfilingTypesWithHighFidelity()) {
     1547        if (local.isCaptured() || generator.vm()->typeProfiler()) {
    15481548            RefPtr<RegisterID> tempDst = generator.tempDestination(dst);
    15491549            generator.emitNode(tempDst.get(), m_right);
    15501550            generator.emitMove(local.get(), tempDst.get());
    15511551            generator.invalidateForInContextForLocal(local.get());
    1552             if (generator.isProfilingTypesWithHighFidelity())
    1553                 generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1552            if (generator.vm()->typeProfiler())
     1553                generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    15541554            return generator.moveToDestinationIfNeeded(dst, tempDst.get());
    15551555        }
    … …  
    15671567    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    15681568    RegisterID* returnResult = generator.emitPutToScope(scope.get(), m_ident, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound);
    1569     if (generator.isProfilingTypesWithHighFidelity()) {
    1570         generator.emitProfileTypesWithHighFidelity(result.get(), ProfileTypesBytecodePutToScope, &m_ident);
    1571         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1569    if (generator.vm()->typeProfiler()) {
     1570        generator.emitProfileType(result.get(), ProfileTypeBytecodePutToScope, &m_ident);
     1571        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    15721572    }
    15731573    return returnResult;
    … …  
    15841584    RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result);
    15851585    generator.emitPutById(base.get(), m_ident, forwardResult);
    1586     if (generator.isProfilingTypesWithHighFidelity()) {
    1587         generator.emitProfileTypesWithHighFidelity(forwardResult, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    1588         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1586    if (generator.vm()->typeProfiler()) {
     1587        generator.emitProfileType(forwardResult, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     1588        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    15891589    }
    15901590    return generator.moveToDestinationIfNeeded(dst, forwardResult);
    … …  
    16031603    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    16041604    RegisterID* ret = generator.emitPutById(base.get(), m_ident, updatedValue);
    1605     if (generator.isProfilingTypesWithHighFidelity()) {
    1606         generator.emitProfileTypesWithHighFidelity(updatedValue, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    1607         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1605    if (generator.vm()->typeProfiler()) {
     1606        generator.emitProfileType(updatedValue, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     1607        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    16081608    }
    16091609    return ret;
    … …  
    16291629    RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result);
    16301630    generator.emitPutByVal(base.get(), property.get(), forwardResult);
    1631     if (generator.isProfilingTypesWithHighFidelity()) {
    1632         generator.emitProfileTypesWithHighFidelity(forwardResult, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    1633         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1631    if (generator.vm()->typeProfiler()) {
     1632        generator.emitProfileType(forwardResult, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     1633        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    16341634    }
    16351635    return generator.moveToDestinationIfNeeded(dst, forwardResult);
    … …  
    16491649    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
    16501650    generator.emitPutByVal(base.get(), property.get(), updatedValue);
    1651     if (generator.isProfilingTypesWithHighFidelity()) {
    1652         generator.emitProfileTypesWithHighFidelity(updatedValue, ProfileTypesBytecodeDoesNotHaveGlobalID, nullptr);
    1653         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     1651    if (generator.vm()->typeProfiler()) {
     1652        generator.emitProfileType(updatedValue, ProfileTypeBytecodeDoesNotHaveGlobalID, nullptr);
     1653        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    16541654    }
    16551655
    … …  
    16771677
    16781678        // FIXME: Maybe call emitExpressionInfo here.
    1679         if (local.isCaptured() || generator.isProfilingTypesWithHighFidelity()) {
     1679        if (local.isCaptured() || generator.vm()->typeProfiler()) {
    16801680            RefPtr<RegisterID> tempDst = generator.newTemporary();
    16811681            generator.emitNode(tempDst.get(), m_init);
    … …  
    17871787RegisterID* EmptyVarExpression::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    17881788{
    1789     if (!generator.isProfilingTypesWithHighFidelity())
     1789    if (!generator.vm()->typeProfiler())
    17901790        return nullptr;
    17911791
    17921792    if (Local local = generator.local(m_ident))
    1793         generator.emitProfileTypesWithHighFidelity(local.get(), ProfileTypesBytecodeHasGlobalID, nullptr);
     1793        generator.emitProfileType(local.get(), ProfileTypeBytecodeHasGlobalID, nullptr);
    17941794    else {
    17951795        RefPtr<RegisterID> scope = generator.emitResolveScope(generator.newTemporary(), m_ident);
    17961796        RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), m_ident, DoNotThrowIfNotFound);
    1797         generator.emitProfileTypesWithHighFidelity(value.get(), ProfileTypesBytecodeGetFromScope, &m_ident);
    1798     }
    1799 
    1800     generator.emitHighFidelityTypeProfilingExpressionInfo(position(), JSTextPosition(-1, position().offset + m_ident.length(), -1));
     1797        generator.emitProfileType(value.get(), ProfileTypeBytecodeGetFromScope, &m_ident);
     1798    }
     1799
     1800    generator.emitTypeProfilerExpressionInfo(position(), JSTextPosition(-1, position().offset + m_ident.length(), -1));
    18011801
    18021802    // It's safe to return null here because this node will always be a child node of VarStatementNode which ignores our return value.
    … …  
    22772277
    22782278    RefPtr<RegisterID> returnRegister = m_value ? generator.emitNode(dst, m_value) : generator.emitLoad(dst, jsUndefined());
    2279     if (generator.isProfilingTypesWithHighFidelity()) {
    2280         generator.emitProfileTypesWithHighFidelity(returnRegister.get(), ProfileTypesBytecodeFunctionReturnStatement, nullptr);
    2281         generator.emitHighFidelityTypeProfilingExpressionInfo(divotStart(), divotEnd());
     2279    if (generator.vm()->typeProfiler()) {
     2280        generator.emitProfileType(returnRegister.get(), ProfileTypeBytecodeFunctionReturnStatement, nullptr);
     2281        generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
    22822282    }
    22832283    if (generator.scopeDepth()) {
    … …  
    26082608void FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    26092609{
    2610     if (generator.isProfilingTypesWithHighFidelity()) {
     2610    if (generator.vm()->typeProfiler()) {
    26112611        for (size_t i = 0; i < m_parameters->size(); i++) {
    26122612            // FIXME: Handle Destructuring assignments into arguments.
    … …  
    26152615            BindingNode* parameter = static_cast<BindingNode*>(m_parameters->at(i));
    26162616            RegisterID reg(CallFrame::argumentOffset(i));
    2617             generator.emitProfileTypesWithHighFidelity(&reg, ProfileTypesBytecodeFunctionArgument, nullptr);
    2618             generator.emitHighFidelityTypeProfilingExpressionInfo(parameter->divotStart(), parameter->divotEnd());
     2617            generator.emitProfileType(&reg, ProfileTypeBytecodeFunctionArgument, nullptr);
     2618            generator.emitTypeProfilerExpressionInfo(parameter->divotStart(), parameter->divotEnd());
    26192619        }
    26202620    }
    … …  
    26362636    if (!returnNode) {
    26372637        RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
    2638         if (generator.isProfilingTypesWithHighFidelity())
    2639             generator.emitProfileTypesWithHighFidelity(r0, ProfileTypesBytecodeFunctionReturnStatement, nullptr); // Do not emit expression info for this profile because it's not in the user's source code.
     2638        if (generator.vm()->typeProfiler())
     2639            generator.emitProfileType(r0, ProfileTypeBytecodeFunctionReturnStatement, nullptr); // Do not emit expression info for this profile because it's not in the user's source code.
    26402640        ASSERT(startOffset() >= lineStartOffset());
    26412641        generator.emitDebugHook(WillLeaveCallFrame, lastLine(), startOffset(), lineStartOffset());
Note: See TracChangeset for help on using the changeset viewer.