Changeset 230129 in webkit


Ignore:
Timestamp:
Mar 31, 2018, 12:04:00 AM (7 years ago)
Author:
mark.lam@apple.com
Message:

Add pointer profiling support in baseline JIT and supporting files.
​https://bugs.webkit.org/show_bug.cgi?id=184200
<rdar://problem/39057300>

Reviewed by Filip Pizlo.

Source/JavaScriptCore:

  1. To simplify pointer profiling support, vmEntryToJavaScript() now always enters the code via the arity check entry.
  2. To accommodate (1), all JITCode must now populate their arity check entry code pointers as well. For native code, programs, evals, and modules that don't do arity check, we set the normal entry as the arity check entry (though with the CodeEntryWithArityCheckPtrTag profile instead).
  • assembler/AbstractMacroAssembler.h:
  • assembler/LinkBuffer.h:

(JSC::LinkBuffer::locationOfNearCall):

  • assembler/MacroAssemblerARM64.h:

(JSC::MacroAssemblerARM64::readCallTarget):
(JSC::MacroAssemblerARM64::linkCall):

  • bytecode/AccessCase.cpp:

(JSC::AccessCase::generateImpl):

  • bytecode/AccessCaseSnippetParams.cpp:

(JSC::SlowPathCallGeneratorWithArguments::generateImpl):

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::addJITAddIC):
(JSC::CodeBlock::addJITMulIC):
(JSC::CodeBlock::addJITSubIC):
(JSC::CodeBlock::addJITNegIC):

  • bytecode/CodeBlock.h:

(JSC::CodeBlock::addMathIC):

  • bytecode/InlineAccess.cpp:

(JSC::InlineAccess::rewireStubAsJump):

  • bytecode/LLIntCallLinkInfo.h:

(JSC::LLIntCallLinkInfo::unlink):
(): Deleted.

  • bytecode/PolymorphicAccess.cpp:

(JSC::AccessGenerationState::emitExplicitExceptionHandler):
(JSC::PolymorphicAccess::regenerate):

  • dfg/DFGJITFinalizer.cpp:

(JSC::DFG::JITFinalizer::finalize):
(JSC::DFG::JITFinalizer::finalizeFunction):

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileValueAdd):
(JSC::DFG::SpeculativeJIT::compileArithSub):
(JSC::DFG::SpeculativeJIT::compileArithNegate):
(JSC::DFG::SpeculativeJIT::compileArithMul):
(JSC::DFG::SpeculativeJIT::emitSwitchIntJump):
(JSC::DFG::SpeculativeJIT::emitSwitchImm):
(JSC::DFG::SpeculativeJIT::emitSwitchStringOnString):

  • disassembler/ARM64Disassembler.cpp:

(JSC::tryToDisassemble):

  • ftl/FTLJITFinalizer.cpp:

(JSC::FTL::JITFinalizer::finalizeCommon):

  • ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileValueAdd):
(JSC::FTL::DFG::LowerDFGToB3::compileUnaryMathIC):
(JSC::FTL::DFG::LowerDFGToB3::compileBinaryMathIC):
(JSC::FTL::DFG::LowerDFGToB3::compileArithAddOrSub):
(JSC::FTL::DFG::LowerDFGToB3::compileArithMul):
(JSC::FTL::DFG::LowerDFGToB3::compileArithNegate):

  • heap/JITStubRoutineSet.h:

(JSC::JITStubRoutineSet::mark):

  • jit/AssemblyHelpers.cpp:

(JSC::AssemblyHelpers::callExceptionFuzz):
(JSC::AssemblyHelpers::debugCall):

  • jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::emitFunctionPrologue):

  • jit/CCallHelpers.cpp:

(JSC::CCallHelpers::ensureShadowChickenPacket):

  • jit/CCallHelpers.h:

(JSC::CCallHelpers::prepareForTailCallSlow):

  • jit/CallFrameShuffler.cpp:

(JSC::CallFrameShuffler::prepareForTailCall):

  • jit/ExecutableAllocator.cpp:

(JSC::FixedVMPoolExecutableAllocator::jitWriteThunkGenerator):

  • jit/ExecutableAllocator.h:

(JSC::performJITMemcpy):

  • jit/JIT.cpp:

(JSC::JIT::compileWithoutLinking):
(JSC::JIT::link):

  • jit/JITArithmetic.cpp:

(JSC::JIT::emit_op_negate):
(JSC::JIT::emit_op_add):
(JSC::JIT::emitMathICFast):
(JSC::JIT::emitMathICSlow):
(JSC::JIT::emit_op_mul):
(JSC::JIT::emit_op_sub):

  • jit/JITCode.cpp:

(JSC::JITCode::execute):
(JSC::JITCodeWithCodeRef::executableAddressAtOffset):
(JSC::DirectJITCode::DirectJITCode):
(JSC::DirectJITCode::initializeCodeRef):
(JSC::NativeJITCode::addressForCall):

  • jit/JITExceptions.cpp:

(JSC::genericUnwind):

  • jit/JITMathIC.h:

(JSC::isProfileEmpty):
(JSC::JITBinaryMathIC::JITBinaryMathIC):
(JSC::JITUnaryMathIC::JITUnaryMathIC):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_switch_imm):
(JSC::JIT::emit_op_switch_char):
(JSC::JIT::emit_op_switch_string):
(JSC::JIT::privateCompileHasIndexedProperty):
(JSC::JIT::emitSlow_op_has_indexed_property):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileHasIndexedProperty):

  • jit/JITOperations.cpp:

(JSC::getByVal):
(JSC::tryGetByValOptimize):

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::stringGetByValStubGenerator):
(JSC::JIT::emitGetByValWithCachedId):
(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emitPutByValWithCachedId):
(JSC::JIT::emitSlow_op_put_by_val):
(JSC::JIT::emitSlow_op_try_get_by_id):
(JSC::JIT::emitSlow_op_get_by_id):
(JSC::JIT::emitSlow_op_get_by_id_with_this):
(JSC::JIT::emitSlow_op_put_by_id):
(JSC::JIT::privateCompileGetByVal):
(JSC::JIT::privateCompileGetByValWithCachedId):
(JSC::JIT::privateCompilePutByVal):
(JSC::JIT::privateCompilePutByValWithCachedId):

  • jit/JITThunks.cpp:

(JSC::JITThunks::hostFunctionStub):

  • jit/Repatch.cpp:

(JSC::tryCacheGetByID):
(JSC::repatchGetByID):
(JSC::appropriateOptimizingPutByIdFunction):
(JSC::tryCachePutByID):
(JSC::repatchPutByID):
(JSC::linkFor):
(JSC::revertCall):
(JSC::linkPolymorphicCall):
(JSC::resetGetByID):
(JSC::resetPutByID):

  • jit/Repatch.h:
  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::finalize):
(JSC::SpecializedThunkJIT::callDoubleToDouble):

  • jit/ThunkGenerators.cpp:

(JSC::emitPointerValidation):
(JSC::throwExceptionFromCallSlowPathGenerator):
(JSC::slowPathFor):
(JSC::linkCallThunkGenerator): Deleted.
(JSC::linkPolymorphicCallThunkGenerator): Deleted.
(JSC::virtualThunkFor): Deleted.
(JSC::nativeForGenerator): Deleted.
(JSC::nativeCallGenerator): Deleted.
(JSC::nativeTailCallGenerator): Deleted.
(JSC::nativeTailCallWithoutSavedTagsGenerator): Deleted.
(JSC::nativeConstructGenerator): Deleted.
(JSC::internalFunctionCallGenerator): Deleted.
(JSC::internalFunctionConstructGenerator): Deleted.
(JSC::arityFixupGenerator): Deleted.
(JSC::unreachableGenerator): Deleted.
(JSC::stringCharLoad): Deleted.
(JSC::charToString): Deleted.
(JSC::charCodeAtThunkGenerator): Deleted.
(JSC::charAtThunkGenerator): Deleted.
(JSC::fromCharCodeThunkGenerator): Deleted.
(JSC::clz32ThunkGenerator): Deleted.
(JSC::sqrtThunkGenerator): Deleted.
(JSC::floorThunkGenerator): Deleted.
(JSC::ceilThunkGenerator): Deleted.
(JSC::truncThunkGenerator): Deleted.
(JSC::roundThunkGenerator): Deleted.
(JSC::expThunkGenerator): Deleted.
(JSC::logThunkGenerator): Deleted.
(JSC::absThunkGenerator): Deleted.
(JSC::imulThunkGenerator): Deleted.
(JSC::randomThunkGenerator): Deleted.
(JSC::boundThisNoArgsFunctionCallGenerator): Deleted.

  • llint/LLIntData.cpp:

(JSC::LLInt::initialize):

  • llint/LLIntData.h:

(JSC::LLInt::getCodePtr):

  • llint/LLIntEntrypoint.cpp:

(JSC::LLInt::setEvalEntrypoint):
(JSC::LLInt::setProgramEntrypoint):
(JSC::LLInt::setModuleProgramEntrypoint):

  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::setUpCall):

  • llint/LLIntThunks.cpp:

(JSC::LLInt::generateThunkWithJumpTo):

  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
  • llint/LowLevelInterpreter64.asm:
  • runtime/ExecutableBase.h:
  • runtime/NativeExecutable.cpp:

(JSC::NativeExecutable::finishCreation):

  • runtime/NativeFunction.h:

(JSC::TaggedNativeFunction::TaggedNativeFunction):
(JSC::TaggedNativeFunction::operator NativeFunction):

  • runtime/PropertySlot.h:

(JSC::PropertySlot::setCustom):
(JSC::PropertySlot::setCacheableCustom):

  • runtime/PtrTag.h:
  • runtime/PutPropertySlot.h:

(JSC::PutPropertySlot::setCustomValue):
(JSC::PutPropertySlot::setCustomAccessor):

  • runtime/SamplingProfiler.cpp:

(JSC::SamplingProfiler::takeSample):

  • runtime/VMTraps.cpp:

(JSC::SignalContext::SignalContext):
(JSC::VMTraps::tryInstallTrapBreakpoints):

  • tools/SigillCrashAnalyzer.cpp:

(JSC::installCrashHandler):

  • yarr/YarrJIT.cpp:

(JSC::Yarr::YarrGenerator::generateTryReadUnicodeCharacterHelper):
(JSC::Yarr::YarrGenerator::generateEnter):

Source/WTF:

  • wtf/PointerPreparations.h:
  • Remove WTF_PREPARE_FUNCTION_POINTER_FOR_EXECUTION. It is no longer needed.
Location:
trunk/Source
Files:
58 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r230127 r230129  
     12018-03-30  Mark Lam  <mark.lam@apple.com>
     2
     3        Add pointer profiling support in baseline JIT and supporting files.
     4        https://bugs.webkit.org/show_bug.cgi?id=184200
     5        <rdar://problem/39057300>
     6
     7        Reviewed by Filip Pizlo.
     8
     9        1. To simplify pointer profiling support, vmEntryToJavaScript() now always enters
     10           the code via the arity check entry.
     11        2. To accommodate (1), all JITCode must now populate their arity check entry code
     12           pointers as well.  For native code, programs, evals, and modules that don't
     13           do arity check, we set the normal entry as the arity check entry (though with
     14           the CodeEntryWithArityCheckPtrTag profile instead).
     15
     16        * assembler/AbstractMacroAssembler.h:
     17        * assembler/LinkBuffer.h:
     18        (JSC::LinkBuffer::locationOfNearCall):
     19        * assembler/MacroAssemblerARM64.h:
     20        (JSC::MacroAssemblerARM64::readCallTarget):
     21        (JSC::MacroAssemblerARM64::linkCall):
     22        * bytecode/AccessCase.cpp:
     23        (JSC::AccessCase::generateImpl):
     24        * bytecode/AccessCaseSnippetParams.cpp:
     25        (JSC::SlowPathCallGeneratorWithArguments::generateImpl):
     26        * bytecode/CodeBlock.cpp:
     27        (JSC::CodeBlock::addJITAddIC):
     28        (JSC::CodeBlock::addJITMulIC):
     29        (JSC::CodeBlock::addJITSubIC):
     30        (JSC::CodeBlock::addJITNegIC):
     31        * bytecode/CodeBlock.h:
     32        (JSC::CodeBlock::addMathIC):
     33        * bytecode/InlineAccess.cpp:
     34        (JSC::InlineAccess::rewireStubAsJump):
     35        * bytecode/LLIntCallLinkInfo.h:
     36        (JSC::LLIntCallLinkInfo::unlink):
     37        (): Deleted.
     38        * bytecode/PolymorphicAccess.cpp:
     39        (JSC::AccessGenerationState::emitExplicitExceptionHandler):
     40        (JSC::PolymorphicAccess::regenerate):
     41        * dfg/DFGJITFinalizer.cpp:
     42        (JSC::DFG::JITFinalizer::finalize):
     43        (JSC::DFG::JITFinalizer::finalizeFunction):
     44        * dfg/DFGSpeculativeJIT.cpp:
     45        (JSC::DFG::SpeculativeJIT::compileValueAdd):
     46        (JSC::DFG::SpeculativeJIT::compileArithSub):
     47        (JSC::DFG::SpeculativeJIT::compileArithNegate):
     48        (JSC::DFG::SpeculativeJIT::compileArithMul):
     49        (JSC::DFG::SpeculativeJIT::emitSwitchIntJump):
     50        (JSC::DFG::SpeculativeJIT::emitSwitchImm):
     51        (JSC::DFG::SpeculativeJIT::emitSwitchStringOnString):
     52        * disassembler/ARM64Disassembler.cpp:
     53        (JSC::tryToDisassemble):
     54        * ftl/FTLJITFinalizer.cpp:
     55        (JSC::FTL::JITFinalizer::finalizeCommon):
     56        * ftl/FTLLowerDFGToB3.cpp:
     57        (JSC::FTL::DFG::LowerDFGToB3::compileValueAdd):
     58        (JSC::FTL::DFG::LowerDFGToB3::compileUnaryMathIC):
     59        (JSC::FTL::DFG::LowerDFGToB3::compileBinaryMathIC):
     60        (JSC::FTL::DFG::LowerDFGToB3::compileArithAddOrSub):
     61        (JSC::FTL::DFG::LowerDFGToB3::compileArithMul):
     62        (JSC::FTL::DFG::LowerDFGToB3::compileArithNegate):
     63        * heap/JITStubRoutineSet.h:
     64        (JSC::JITStubRoutineSet::mark):
     65        * jit/AssemblyHelpers.cpp:
     66        (JSC::AssemblyHelpers::callExceptionFuzz):
     67        (JSC::AssemblyHelpers::debugCall):
     68        * jit/AssemblyHelpers.h:
     69        (JSC::AssemblyHelpers::emitFunctionPrologue):
     70        * jit/CCallHelpers.cpp:
     71        (JSC::CCallHelpers::ensureShadowChickenPacket):
     72        * jit/CCallHelpers.h:
     73        (JSC::CCallHelpers::prepareForTailCallSlow):
     74        * jit/CallFrameShuffler.cpp:
     75        (JSC::CallFrameShuffler::prepareForTailCall):
     76        * jit/ExecutableAllocator.cpp:
     77        (JSC::FixedVMPoolExecutableAllocator::jitWriteThunkGenerator):
     78        * jit/ExecutableAllocator.h:
     79        (JSC::performJITMemcpy):
     80        * jit/JIT.cpp:
     81        (JSC::JIT::compileWithoutLinking):
     82        (JSC::JIT::link):
     83        * jit/JITArithmetic.cpp:
     84        (JSC::JIT::emit_op_negate):
     85        (JSC::JIT::emit_op_add):
     86        (JSC::JIT::emitMathICFast):
     87        (JSC::JIT::emitMathICSlow):
     88        (JSC::JIT::emit_op_mul):
     89        (JSC::JIT::emit_op_sub):
     90        * jit/JITCode.cpp:
     91        (JSC::JITCode::execute):
     92        (JSC::JITCodeWithCodeRef::executableAddressAtOffset):
     93        (JSC::DirectJITCode::DirectJITCode):
     94        (JSC::DirectJITCode::initializeCodeRef):
     95        (JSC::NativeJITCode::addressForCall):
     96        * jit/JITExceptions.cpp:
     97        (JSC::genericUnwind):
     98        * jit/JITMathIC.h:
     99        (JSC::isProfileEmpty):
     100        (JSC::JITBinaryMathIC::JITBinaryMathIC):
     101        (JSC::JITUnaryMathIC::JITUnaryMathIC):
     102        * jit/JITOpcodes.cpp:
     103        (JSC::JIT::emit_op_switch_imm):
     104        (JSC::JIT::emit_op_switch_char):
     105        (JSC::JIT::emit_op_switch_string):
     106        (JSC::JIT::privateCompileHasIndexedProperty):
     107        (JSC::JIT::emitSlow_op_has_indexed_property):
     108        * jit/JITOpcodes32_64.cpp:
     109        (JSC::JIT::privateCompileHasIndexedProperty):
     110        * jit/JITOperations.cpp:
     111        (JSC::getByVal):
     112        (JSC::tryGetByValOptimize):
     113        * jit/JITPropertyAccess.cpp:
     114        (JSC::JIT::stringGetByValStubGenerator):
     115        (JSC::JIT::emitGetByValWithCachedId):
     116        (JSC::JIT::emitSlow_op_get_by_val):
     117        (JSC::JIT::emitPutByValWithCachedId):
     118        (JSC::JIT::emitSlow_op_put_by_val):
     119        (JSC::JIT::emitSlow_op_try_get_by_id):
     120        (JSC::JIT::emitSlow_op_get_by_id):
     121        (JSC::JIT::emitSlow_op_get_by_id_with_this):
     122        (JSC::JIT::emitSlow_op_put_by_id):
     123        (JSC::JIT::privateCompileGetByVal):
     124        (JSC::JIT::privateCompileGetByValWithCachedId):
     125        (JSC::JIT::privateCompilePutByVal):
     126        (JSC::JIT::privateCompilePutByValWithCachedId):
     127        * jit/JITThunks.cpp:
     128        (JSC::JITThunks::hostFunctionStub):
     129        * jit/Repatch.cpp:
     130        (JSC::tryCacheGetByID):
     131        (JSC::repatchGetByID):
     132        (JSC::appropriateOptimizingPutByIdFunction):
     133        (JSC::tryCachePutByID):
     134        (JSC::repatchPutByID):
     135        (JSC::linkFor):
     136        (JSC::revertCall):
     137        (JSC::linkPolymorphicCall):
     138        (JSC::resetGetByID):
     139        (JSC::resetPutByID):
     140        * jit/Repatch.h:
     141        * jit/SpecializedThunkJIT.h:
     142        (JSC::SpecializedThunkJIT::finalize):
     143        (JSC::SpecializedThunkJIT::callDoubleToDouble):
     144        * jit/ThunkGenerators.cpp:
     145        (JSC::emitPointerValidation):
     146        (JSC::throwExceptionFromCallSlowPathGenerator):
     147        (JSC::slowPathFor):
     148        (JSC::linkCallThunkGenerator): Deleted.
     149        (JSC::linkPolymorphicCallThunkGenerator): Deleted.
     150        (JSC::virtualThunkFor): Deleted.
     151        (JSC::nativeForGenerator): Deleted.
     152        (JSC::nativeCallGenerator): Deleted.
     153        (JSC::nativeTailCallGenerator): Deleted.
     154        (JSC::nativeTailCallWithoutSavedTagsGenerator): Deleted.
     155        (JSC::nativeConstructGenerator): Deleted.
     156        (JSC::internalFunctionCallGenerator): Deleted.
     157        (JSC::internalFunctionConstructGenerator): Deleted.
     158        (JSC::arityFixupGenerator): Deleted.
     159        (JSC::unreachableGenerator): Deleted.
     160        (JSC::stringCharLoad): Deleted.
     161        (JSC::charToString): Deleted.
     162        (JSC::charCodeAtThunkGenerator): Deleted.
     163        (JSC::charAtThunkGenerator): Deleted.
     164        (JSC::fromCharCodeThunkGenerator): Deleted.
     165        (JSC::clz32ThunkGenerator): Deleted.
     166        (JSC::sqrtThunkGenerator): Deleted.
     167        (JSC::floorThunkGenerator): Deleted.
     168        (JSC::ceilThunkGenerator): Deleted.
     169        (JSC::truncThunkGenerator): Deleted.
     170        (JSC::roundThunkGenerator): Deleted.
     171        (JSC::expThunkGenerator): Deleted.
     172        (JSC::logThunkGenerator): Deleted.
     173        (JSC::absThunkGenerator): Deleted.
     174        (JSC::imulThunkGenerator): Deleted.
     175        (JSC::randomThunkGenerator): Deleted.
     176        (JSC::boundThisNoArgsFunctionCallGenerator): Deleted.
     177        * llint/LLIntData.cpp:
     178        (JSC::LLInt::initialize):
     179        * llint/LLIntData.h:
     180        (JSC::LLInt::getCodePtr):
     181        * llint/LLIntEntrypoint.cpp:
     182        (JSC::LLInt::setEvalEntrypoint):
     183        (JSC::LLInt::setProgramEntrypoint):
     184        (JSC::LLInt::setModuleProgramEntrypoint):
     185        * llint/LLIntSlowPaths.cpp:
     186        (JSC::LLInt::setUpCall):
     187        * llint/LLIntThunks.cpp:
     188        (JSC::LLInt::generateThunkWithJumpTo):
     189        * llint/LowLevelInterpreter.asm:
     190        * llint/LowLevelInterpreter32_64.asm:
     191        * llint/LowLevelInterpreter64.asm:
     192        * runtime/ExecutableBase.h:
     193        * runtime/NativeExecutable.cpp:
     194        (JSC::NativeExecutable::finishCreation):
     195        * runtime/NativeFunction.h:
     196        (JSC::TaggedNativeFunction::TaggedNativeFunction):
     197        (JSC::TaggedNativeFunction::operator NativeFunction):
     198        * runtime/PropertySlot.h:
     199        (JSC::PropertySlot::setCustom):
     200        (JSC::PropertySlot::setCacheableCustom):
     201        * runtime/PtrTag.h:
     202        * runtime/PutPropertySlot.h:
     203        (JSC::PutPropertySlot::setCustomValue):
     204        (JSC::PutPropertySlot::setCustomAccessor):
     205        * runtime/SamplingProfiler.cpp:
     206        (JSC::SamplingProfiler::takeSample):
     207        * runtime/VMTraps.cpp:
     208        (JSC::SignalContext::SignalContext):
     209        (JSC::VMTraps::tryInstallTrapBreakpoints):
     210        * tools/SigillCrashAnalyzer.cpp:
     211        (JSC::installCrashHandler):
     212        * yarr/YarrJIT.cpp:
     213        (JSC::Yarr::YarrGenerator::generateTryReadUnicodeCharacterHelper):
     214        (JSC::Yarr::YarrGenerator::generateEnter):
     215
    12162018-03-30  Devin Rousso  <webkit@devinrousso.com>
    2217

  • trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h

    r229911 r230129  
    873873    }
    874874
    875     // FIXME: remove the default PtrTag value once we've tagged all the clients.
    876875    static void* getLinkerAddress(void* code, AssemblerLabel label, PtrTag tag = NoPtrTag)
    877876    {

  • trunk/Source/JavaScriptCore/assembler/LinkBuffer.h

    r229609 r230129  
    183183        ASSERT(call.isFlagSet(Call::Linkable));
    184184        ASSERT(call.isFlagSet(Call::Near));
    185         return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label), NearCallPtrTag),
     185        return CodeLocationNearCall(MacroAssembler::getLinkerAddress(code(), applyOffset(call.m_label)),
    186186            call.isFlagSet(Call::Tail) ? NearCallMode::Tail : NearCallMode::Regular);
    187187    }
    … …  
    192192    }
    193193
    194     // FIXME: remove the default PtrTag value once we've tagged all the clients.
    195194    CodeLocationLabel locationOf(Label label, PtrTag tag = NoPtrTag)
    196195    {

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

    r229988 r230129  
    37753775    static FunctionPtr readCallTarget(CodeLocationCall call)
    37763776    {
    3777         return FunctionPtr(reinterpret_cast<void(*)()>(Assembler::readCallTarget(call.dataLocation())), CodeEntryPtrTag);
     3777        return FunctionPtr(MacroAssemblerCodePtr(Assembler::readCallTarget(call.dataLocation())));
    37783778    }
    37793779
    … …  
    44434443        if (!call.isFlagSet(Call::Near))
    44444444            Assembler::linkPointer(code, call.m_label.labelAtOffset(REPATCH_OFFSET_CALL_TO_POINTER), function.executableAddress());
    4445         else if (call.isFlagSet(Call::Tail))
     4445        else if (call.isFlagSet(Call::Tail)) {
     4446            assertIsNotTagged(function.executableAddress());
    44464447            Assembler::linkJump(code, call.m_label, function.executableAddress());
    4447         else
     4448        } else {
     4449            assertIsNotTagged(function.executableAddress());
    44484450            Assembler::linkCall(code, call.m_label, function.executableAddress());
     4451        }
    44494452    }
    44504453

  • trunk/Source/JavaScriptCore/bytecode/AccessCase.cpp

    r229842 r230129  
    868868            jit.storePtr(GPRInfo::callFrameRegister, &vm.topCallFrame);
    869869
    870             PtrTag callTag = ptrTag(JITOperationPtrTag, nextPtrTagID());
     870            PtrTag callTag = ptrTag(GetterSetterPtrTag, nextPtrTagID());
    871871            operationCall = jit.call(callTag);
    872872            jit.addLinkTask([=] (LinkBuffer& linkBuffer) {

  • trunk/Source/JavaScriptCore/bytecode/AccessCaseSnippetParams.cpp

    r229609 r230129  
    11/*
    2  * Copyright (C) 2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2016-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    6262        jit.setupArguments<FunctionType>(std::get<ArgumentsIndex>(m_arguments)...);
    6363
    64         CCallHelpers::Call operationCall = jit.call(NoPtrTag);
     64        PtrTag tag = ptrTag(JITOperationPtrTag, nextPtrTagID());
     65        CCallHelpers::Call operationCall = jit.call(tag);
    6566        auto function = m_function;
    6667        jit.addLinkTask([=] (LinkBuffer& linkBuffer) {
    67             linkBuffer.link(operationCall, FunctionPtr(function));
     68            linkBuffer.link(operationCall, FunctionPtr(function, tag));
    6869        });
    6970

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

    r229815 r230129  
    14311431}
    14321432
    1433 JITAddIC* CodeBlock::addJITAddIC(ArithProfile* arithProfile)
    1434 {
    1435     return m_addICs.add(arithProfile);
    1436 }
    1437 
    1438 JITMulIC* CodeBlock::addJITMulIC(ArithProfile* arithProfile)
    1439 {
    1440     return m_mulICs.add(arithProfile);
    1441 }
    1442 
    1443 JITSubIC* CodeBlock::addJITSubIC(ArithProfile* arithProfile)
    1444 {
    1445     return m_subICs.add(arithProfile);
    1446 }
    1447 
    1448 JITNegIC* CodeBlock::addJITNegIC(ArithProfile* arithProfile)
    1449 {
    1450     return m_negICs.add(arithProfile);
     1433JITAddIC* CodeBlock::addJITAddIC(ArithProfile* arithProfile, Instruction* instruction)
     1434{
     1435    return m_addICs.add(arithProfile, instruction);
     1436}
     1437
     1438JITMulIC* CodeBlock::addJITMulIC(ArithProfile* arithProfile, Instruction* instruction)
     1439{
     1440    return m_mulICs.add(arithProfile, instruction);
     1441}
     1442
     1443JITSubIC* CodeBlock::addJITSubIC(ArithProfile* arithProfile, Instruction* instruction)
     1444{
     1445    return m_subICs.add(arithProfile, instruction);
     1446}
     1447
     1448JITNegIC* CodeBlock::addJITNegIC(ArithProfile* arithProfile, Instruction* instruction)
     1449{
     1450    return m_negICs.add(arithProfile, instruction);
    14511451}
    14521452

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

    r228500 r230129  
    249249   
    250250#if ENABLE(JIT)
    251     JITAddIC* addJITAddIC(ArithProfile*);
    252     JITMulIC* addJITMulIC(ArithProfile*);
    253     JITNegIC* addJITNegIC(ArithProfile*);
    254     JITSubIC* addJITSubIC(ArithProfile*);
     251    JITAddIC* addJITAddIC(ArithProfile*, Instruction*);
     252    JITMulIC* addJITMulIC(ArithProfile*, Instruction*);
     253    JITNegIC* addJITNegIC(ArithProfile*, Instruction*);
     254    JITSubIC* addJITSubIC(ArithProfile*, Instruction*);
    255255
    256256    template <typename Generator, typename = typename std::enable_if<std::is_same<Generator, JITAddGenerator>::value>::type>
    257     JITAddIC* addMathIC(ArithProfile* profile) { return addJITAddIC(profile); }
     257    JITAddIC* addMathIC(ArithProfile* profile, Instruction* instruction) { return addJITAddIC(profile, instruction); }
    258258
    259259    template <typename Generator, typename = typename std::enable_if<std::is_same<Generator, JITMulGenerator>::value>::type>
    260     JITMulIC* addMathIC(ArithProfile* profile) { return addJITMulIC(profile); }
     260    JITMulIC* addMathIC(ArithProfile* profile, Instruction* instruction) { return addJITMulIC(profile, instruction); }
    261261
    262262    template <typename Generator, typename = typename std::enable_if<std::is_same<Generator, JITNegGenerator>::value>::type>
    263     JITNegIC* addMathIC(ArithProfile* profile) { return addJITNegIC(profile); }
     263    JITNegIC* addMathIC(ArithProfile* profile, Instruction* instruction) { return addJITNegIC(profile, instruction); }
    264264
    265265    template <typename Generator, typename = typename std::enable_if<std::is_same<Generator, JITSubGenerator>::value>::type>
    266     JITSubIC* addMathIC(ArithProfile* profile) { return addJITSubIC(profile); }
     266    JITSubIC* addMathIC(ArithProfile* profile, Instruction* instruction) { return addJITSubIC(profile, instruction); }
    267267
    268268    StructureStubInfo* addStubInfo(AccessType);
    … …  
    311311    }
    312312   
     313    typedef JSC::Instruction Instruction;
     314    typedef PoisonedRefCountedArray<CodeBlockPoison, Instruction>& UnpackedInstructions;
     315
    313316    static void clearLLIntGetByIdCache(Instruction*);
    314317
    … …  
    318321        return static_cast<Instruction*>(returnAddress) - instructions().begin();
    319322    }
    320 
    321     typedef JSC::Instruction Instruction;
    322     typedef PoisonedRefCountedArray<CodeBlockPoison, Instruction>& UnpackedInstructions;
    323323
    324324    unsigned numberOfInstructions() const { return m_instructions.size(); }

  • trunk/Source/JavaScriptCore/bytecode/InlineAccess.cpp

    r229609 r230129  
    291291    linkBuffer.link(jump, target);
    292292
    293     FINALIZE_CODE(linkBuffer, JITCodePtrTag, "InlineAccess: linking constant jump");
     293    FINALIZE_CODE(linkBuffer, NearJumpPtrTag, "InlineAccess: linking constant jump");
    294294}
    295295

  • trunk/Source/JavaScriptCore/bytecode/LLIntCallLinkInfo.h

    r229481 r230129  
    5252        callee.clear();
    5353        machineCodeTarget = MacroAssemblerCodePtr();
    54         callPtrTag = NoPtrTag;
    5554        if (isOnList())
    5655            remove();
    … …  
    6059    WriteBarrier<JSObject> lastSeenCallee;
    6160    MacroAssemblerCodePtr machineCodeTarget;
    62     PtrTag callPtrTag { NoPtrTag };
    6361};
    6462

  • trunk/Source/JavaScriptCore/bytecode/PolymorphicAccess.cpp

    r229609 r230129  
    200200    } else {
    201201        jit->setupArguments<decltype(lookupExceptionHandler)>(CCallHelpers::TrustedImmPtr(&m_vm), GPRInfo::callFrameRegister);
    202         CCallHelpers::Call lookupExceptionHandlerCall = jit->call(NoPtrTag);
     202        PtrTag tag = ptrTag(JITOperationPtrTag, nextPtrTagID());
     203        CCallHelpers::Call lookupExceptionHandlerCall = jit->call(tag);
    203204        jit->addLinkTask(
    204205            [=] (LinkBuffer& linkBuffer) {
    205                 linkBuffer.link(lookupExceptionHandlerCall, lookupExceptionHandler, NoPtrTag);
     206                linkBuffer.link(lookupExceptionHandlerCall, FunctionPtr(lookupExceptionHandler, tag));
    206207            });
    207208        jit->jumpToExceptionHandler(m_vm);
    … …  
    539540
    540541                HandlerInfo handlerToRegister = oldHandler;
    541                 handlerToRegister.nativeCode = linkBuffer.locationOf(makeshiftCatchHandler, NoPtrTag);
     542                handlerToRegister.nativeCode = linkBuffer.locationOf(makeshiftCatchHandler, NearJumpPtrTag);
    542543                handlerToRegister.start = newExceptionHandlingCallSite.bits();
    543544                handlerToRegister.end = newExceptionHandlingCallSite.bits() + 1;
    … …  
    569570
    570571    MacroAssemblerCodeRef code = FINALIZE_CODE_FOR(
    571         codeBlock, linkBuffer, NoPtrTag,
     572        codeBlock, linkBuffer, NearJumpPtrTag,
    572573        "%s", toCString("Access stub for ", *codeBlock, " ", stubInfo.codeOrigin, " with return point ", successLabel, ": ", listDump(cases)).data());
    573574

  • trunk/Source/JavaScriptCore/dfg/DFGJITFinalizer.cpp

    r229609 r230129  
    5757bool JITFinalizer::finalize()
    5858{
    59     m_jitCode->initializeCodeRef(
    60         FINALIZE_DFG_CODE(*m_linkBuffer, NoPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::DFGJIT)).data()),
    61         MacroAssemblerCodePtr());
     59    MacroAssemblerCodeRef codeRef = FINALIZE_DFG_CODE(*m_linkBuffer, CodeEntryPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::DFGJIT)).data());
     60    m_jitCode->initializeCodeRef(codeRef, codeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag));
    6261   
    6362    m_plan.codeBlock->setJITCode(m_jitCode.copyRef());
    … …  
    7271    RELEASE_ASSERT(!m_withArityCheck.isEmptyValue());
    7372    m_jitCode->initializeCodeRef(
    74         FINALIZE_DFG_CODE(*m_linkBuffer, NoPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::DFGJIT)).data()),
     73        FINALIZE_DFG_CODE(*m_linkBuffer, CodeEntryPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::DFGJIT)).data()),
    7574        m_withArityCheck);
    7675    m_plan.codeBlock->setJITCode(m_jitCode.copyRef());

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

    r230022 r230129  
    37703770#endif
    37713771
    3772     ArithProfile* arithProfile = m_jit.graph().baselineCodeBlockFor(node->origin.semantic)->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
    3773     JITAddIC* addIC = m_jit.codeBlock()->addJITAddIC(arithProfile);
     3772    CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
     3773    ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
     3774    Instruction* instruction = &baselineCodeBlock->instructions()[node->origin.semantic.bytecodeIndex];
     3775    JITAddIC* addIC = m_jit.codeBlock()->addJITAddIC(arithProfile, instruction);
    37743776    auto repatchingFunction = operationValueAddOptimize;
    37753777    auto nonRepatchingFunction = operationValueAdd;
    … …  
    44354437#endif
    44364438
    4437         ArithProfile* arithProfile = m_jit.graph().baselineCodeBlockFor(node->origin.semantic)->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
    4438         JITSubIC* subIC = m_jit.codeBlock()->addJITSubIC(arithProfile);
     4439        CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
     4440        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
     4441        Instruction* instruction = &baselineCodeBlock->instructions()[node->origin.semantic.bytecodeIndex];
     4442        JITSubIC* subIC = m_jit.codeBlock()->addJITSubIC(arithProfile, instruction);
    44394443        auto repatchingFunction = operationValueSubOptimize;
    44404444        auto nonRepatchingFunction = operationValueSub;
    … …  
    45244528       
    45254529    default: {
    4526         ArithProfile* arithProfile = m_jit.graph().baselineCodeBlockFor(node->origin.semantic)->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
    4527         JITNegIC* negIC = m_jit.codeBlock()->addJITNegIC(arithProfile);
     4530        CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
     4531        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
     4532        Instruction* instruction = &baselineCodeBlock->instructions()[node->origin.semantic.bytecodeIndex];
     4533        JITNegIC* negIC = m_jit.codeBlock()->addJITNegIC(arithProfile, instruction);
    45284534        auto repatchingFunction = operationArithNegateOptimize;
    45294535        auto nonRepatchingFunction = operationArithNegate;
    … …  
    47894795#endif
    47904796
    4791         ArithProfile* arithProfile = m_jit.graph().baselineCodeBlockFor(node->origin.semantic)->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
    4792         JITMulIC* mulIC = m_jit.codeBlock()->addJITMulIC(arithProfile);
     4797        CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
     4798        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
     4799        Instruction* instruction = &baselineCodeBlock->instructions()[node->origin.semantic.bytecodeIndex];
     4800        JITMulIC* mulIC = m_jit.codeBlock()->addJITMulIC(arithProfile, instruction);
    47934801        auto repatchingFunction = operationValueMulOptimize;
    47944802        auto nonRepatchingFunction = operationValueMul;
    … …  
    99019909    m_jit.xor64(poisonScratch, scratch);
    99029910#endif
    9903     m_jit.jump(scratch, NoPtrTag);
     9911    PtrTag tag = ptrTag(SwitchTablePtrTag, &table);
     9912    m_jit.jump(scratch, tag);
    99049913    data->didUseJumpTable = true;
    99059914}
    … …  
    99269935
    99279936        value.use();
    9928        
     9937
     9938        SimpleJumpTable& table = m_jit.codeBlock()->switchJumpTable(data->switchTableIndex);
     9939        PtrTag tag = ptrTag(SwitchTablePtrTag, &table);
    99299940        auto notInt32 = m_jit.branchIfNotInt32(valueRegs);
    99309941        emitSwitchIntJump(data, valueRegs.payloadGPR(), scratch, scratch2);
    … …  
    99359946        silentFillAllRegisters();
    99369947
    9937         m_jit.jump(scratch, NoPtrTag);
     9948        m_jit.jump(scratch, tag);
    99389949        noResult(node, UseChildrenCalledExplicitly);
    99399950        break;
    … …  
    1019310204    }
    1019410205   
     10206    auto* codeBlock = m_jit.codeBlock();
    1019510207    if (!canDoBinarySwitch || totalLength > Options::maximumBinaryStringSwitchTotalLength()) {
     10208        StringJumpTable& table = codeBlock->stringSwitchJumpTable(data->switchTableIndex);
     10209        PtrTag tag = ptrTag(SwitchTablePtrTag, &table);
    1019610210        flushRegisters();
    1019710211        callOperation(
    1019810212            operationSwitchString, string, static_cast<size_t>(data->switchTableIndex), string);
    1019910213        m_jit.exceptionCheck();
    10200         m_jit.jump(string, NoPtrTag);
     10214        m_jit.jump(string, tag);
    1020110215        return;
    1020210216    }
    … …  
    1023110245        data, cases, 0, 0, cases.size(), string, lengthGPR, tempGPR, 0, false);
    1023210246   
     10247    StringJumpTable& table = codeBlock->stringSwitchJumpTable(data->switchTableIndex);
     10248    PtrTag tag = ptrTag(SwitchTablePtrTag, &table);
     10249
    1023310250    slowCases.link(&m_jit);
    1023410251    silentSpillAllRegisters(string);
    … …  
    1023610253    silentFillAllRegisters();
    1023710254    m_jit.exceptionCheck();
    10238     m_jit.jump(string, NoPtrTag);
     10255    m_jit.jump(string, tag);
    1023910256}
    1024010257

  • trunk/Source/JavaScriptCore/disassembler/ARM64Disassembler.cpp

    r228105 r230129  
    11/*
    2  * Copyright (C) 2012, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3838    A64DOpcode arm64Opcode;
    3939
    40     uint32_t* currentPC = reinterpret_cast<uint32_t*>(codePtr.executableAddress());
     40    uint32_t* currentPC = removeCodePtrTag<uint32_t*>(codePtr.executableAddress());
    4141    size_t byteCount = size;
    4242

  • trunk/Source/JavaScriptCore/ftl/FTLJITFinalizer.cpp

    r229609 r230129  
    7474    bool dumpDisassembly = shouldDumpDisassembly() || Options::asyncDisassembly();
    7575   
    76     jitCode->initializeB3Code(
    77         FINALIZE_CODE_IF(
    78             dumpDisassembly, *b3CodeLinkBuffer, CodeEntryPtrTag,
    79             "FTL B3 code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::FTLJIT)).data()));
     76    MacroAssemblerCodeRef b3CodeRef =
     77        FINALIZE_CODE_IF(dumpDisassembly, *b3CodeLinkBuffer, CodeEntryPtrTag,
     78            "FTL B3 code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::FTLJIT)).data());
    8079
    81     if (entrypointLinkBuffer) {
    82         jitCode->initializeArityCheckEntrypoint(
    83             FINALIZE_CODE_IF(
    84                 dumpDisassembly, *entrypointLinkBuffer, CodeEntryWithArityCheckPtrTag,
    85                 "FTL entrypoint thunk for %s with B3 generated code at %p", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::FTLJIT)).data(), function));
    86     }
    87    
     80    MacroAssemblerCodeRef arityCheckCodeRef = entrypointLinkBuffer
     81        ? FINALIZE_CODE_IF(dumpDisassembly, *entrypointLinkBuffer, CodeEntryWithArityCheckPtrTag,
     82            "FTL entrypoint thunk for %s with B3 generated code at %p", toCString(CodeBlockWithJITType(m_plan.codeBlock, JITCode::FTLJIT)).data(), function)
     83        : MacroAssemblerCodeRef::createSelfManagedCodeRef(b3CodeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag));
     84
     85    jitCode->initializeB3Code(b3CodeRef);
     86    jitCode->initializeArityCheckEntrypoint(arityCheckCodeRef);
     87
    8888    m_plan.codeBlock->setJITCode(*jitCode);
    8989

  • trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

    r230098 r230129  
    18061806    void compileValueAdd()
    18071807    {
    1808         ArithProfile* arithProfile = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic)->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     1808        CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
     1809        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     1810        Instruction* instruction = &baselineCodeBlock->instructions()[m_node->origin.semantic.bytecodeIndex];
    18091811        auto repatchingFunction = operationValueAddOptimize;
    18101812        auto nonRepatchingFunction = operationValueAdd;
    1811         compileBinaryMathIC<JITAddGenerator>(arithProfile, repatchingFunction, nonRepatchingFunction);
    1812     }
    1813 
    1814     template <typename Generator>
    1815     void compileUnaryMathIC(ArithProfile* arithProfile, FunctionPtr repatchingFunction, FunctionPtr nonRepatchingFunction)
     1813        compileBinaryMathIC<JITAddGenerator>(arithProfile, instruction, repatchingFunction, nonRepatchingFunction);
     1814    }
     1815
     1816    template <typename Generator, typename Func1, typename Func2,
     1817        typename = std::enable_if_t<std::is_function<typename std::remove_pointer<Func1>::type>::value && std::is_function<typename std::remove_pointer<Func2>::type>::value>>
     1818    void compileUnaryMathIC(ArithProfile* arithProfile, Instruction* instruction, Func1 repatchingFunction, Func2 nonRepatchingFunction)
    18161819    {
    18171820        Node* node = m_node;
    … …  
    18391842
    18401843                Box<MathICGenerationState> mathICGenerationState = Box<MathICGenerationState>::create();
    1841                 JITUnaryMathIC<Generator>* mathIC = jit.codeBlock()->addMathIC<Generator>(arithProfile);
     1844                JITUnaryMathIC<Generator>* mathIC = jit.codeBlock()->addMathIC<Generator>(arithProfile, instruction);
    18421845                mathIC->m_generator = Generator(JSValueRegs(params[0].gpr()), JSValueRegs(params[1].gpr()), params.gpScratch(0));
    18431846
    … …  
    18971900    }
    18981901
    1899     template <typename Generator>
    1900     void compileBinaryMathIC(ArithProfile* arithProfile, FunctionPtr repatchingFunction, FunctionPtr nonRepatchingFunction)
     1902    template <typename Generator, typename Func1, typename Func2,
     1903        typename = std::enable_if_t<std::is_function<typename std::remove_pointer<Func1>::type>::value && std::is_function<typename std::remove_pointer<Func2>::type>::value>>
     1904    void compileBinaryMathIC(ArithProfile* arithProfile, Instruction* instruction, Func1 repatchingFunction, Func2 nonRepatchingFunction)
    19011905    {
    19021906        Node* node = m_node;
    … …  
    19321936
    19331937                Box<MathICGenerationState> mathICGenerationState = Box<MathICGenerationState>::create();
    1934                 JITBinaryMathIC<Generator>* mathIC = jit.codeBlock()->addMathIC<Generator>(arithProfile);
     1938                JITBinaryMathIC<Generator>* mathIC = jit.codeBlock()->addMathIC<Generator>(arithProfile, instruction);
    19351939                mathIC->m_generator = Generator(leftOperand, rightOperand, JSValueRegs(params[0].gpr()),
    19361940                    JSValueRegs(params[1].gpr()), JSValueRegs(params[2].gpr()), params.fpScratch(0),
    … …  
    20632067            }
    20642068
    2065             ArithProfile* arithProfile = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic)->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     2069            CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
     2070            ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     2071            Instruction* instruction = &baselineCodeBlock->instructions()[m_node->origin.semantic.bytecodeIndex];
    20662072            auto repatchingFunction = operationValueSubOptimize;
    20672073            auto nonRepatchingFunction = operationValueSub;
    2068             compileBinaryMathIC<JITSubGenerator>(arithProfile, repatchingFunction, nonRepatchingFunction);
     2074            compileBinaryMathIC<JITSubGenerator>(arithProfile, instruction, repatchingFunction, nonRepatchingFunction);
    20692075            break;
    20702076        }
    … …  
    21572163
    21582164        case UntypedUse: {
    2159             ArithProfile* arithProfile = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic)->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     2165            CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
     2166            ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     2167            Instruction* instruction = &baselineCodeBlock->instructions()[m_node->origin.semantic.bytecodeIndex];
    21602168            auto repatchingFunction = operationValueMulOptimize;
    21612169            auto nonRepatchingFunction = operationValueMul;
    2162             compileBinaryMathIC<JITMulGenerator>(arithProfile, repatchingFunction, nonRepatchingFunction);
     2170            compileBinaryMathIC<JITMulGenerator>(arithProfile, instruction, repatchingFunction, nonRepatchingFunction);
    21632171            break;
    21642172        }
    … …  
    27382746        default:
    27392747            DFG_ASSERT(m_graph, m_node, m_node->child1().useKind() == UntypedUse, m_node->child1().useKind());
    2740             ArithProfile* arithProfile = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic)->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     2748            CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
     2749            ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
     2750            Instruction* instruction = &baselineCodeBlock->instructions()[m_node->origin.semantic.bytecodeIndex];
    27412751            auto repatchingFunction = operationArithNegateOptimize;
    27422752            auto nonRepatchingFunction = operationArithNegate;
    2743             compileUnaryMathIC<JITNegGenerator>(arithProfile, repatchingFunction, nonRepatchingFunction);
     2753            compileUnaryMathIC<JITNegGenerator>(arithProfile, instruction, repatchingFunction, nonRepatchingFunction);
    27442754            break;
    27452755        }

  • trunk/Source/JavaScriptCore/heap/JITStubRoutineSet.h

    r206525 r230129  
    11/*
    2  * Copyright (C) 2012 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5252    void mark(void* candidateAddress)
    5353    {
    54         uintptr_t address = reinterpret_cast<uintptr_t>(candidateAddress);
     54        uintptr_t address = removeCodePtrTag<uintptr_t>(candidateAddress);
    5555        if (!JITStubRoutine::passesFilter(address))
    5656            return;

  • trunk/Source/JavaScriptCore/jit/AssemblyHelpers.cpp

    r229609 r230129  
    347347    move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    348348#endif
    349     move(TrustedImmPtr(tagCFunctionPtr(operationExceptionFuzz, SlowPathPtrTag)), GPRInfo::nonPreservedNonReturnGPR);
    350     call(GPRInfo::nonPreservedNonReturnGPR, SlowPathPtrTag);
     349    PtrTag tag = ptrTag(JITOperationPtrTag, nextPtrTagID());
     350    move(TrustedImmPtr(tagCFunctionPtr(operationExceptionFuzz, tag)), GPRInfo::nonPreservedNonReturnGPR);
     351    call(GPRInfo::nonPreservedNonReturnGPR, tag);
    351352
    352353    for (unsigned i = 0; i < FPRInfo::numberOfRegisters; ++i) {
    … …  
    941942#error "JIT not supported on this platform."
    942943#endif
    943     move(TrustedImmPtr(tagCFunctionPtr(function, SlowPathPtrTag)), scratch);
    944     call(scratch, SlowPathPtrTag);
     944    PtrTag tag = ptrTag(JITOperationPtrTag, nextPtrTagID());
     945    move(TrustedImmPtr(tagCFunctionPtr(function, tag)), scratch);
     946    call(scratch, tag);
    945947
    946948    move(TrustedImmPtr(scratchBuffer->addressOfActiveLength()), GPRInfo::regT0);

  • trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

    r229444 r230129  
    530530    void emitFunctionPrologue()
    531531    {
     532        tagReturnAddress();
    532533        pushPair(framePointerRegister, linkRegister);
    533534        move(stackPointerRegister, framePointerRegister);

  • trunk/Source/JavaScriptCore/jit/CCallHelpers.cpp

    r229609 r230129  
    6060    Jump ok = branchPtr(Below, shadowPacket, TrustedImmPtr(vm.shadowChicken().logEnd()));
    6161    setupArguments<decltype(operationProcessShadowChickenLog)>();
    62     move(TrustedImmPtr(tagCFunctionPtr(operationProcessShadowChickenLog, SlowPathPtrTag)), scratch1NonArgGPR);
    63     call(scratch1NonArgGPR, SlowPathPtrTag);
     62    PtrTag tag = ptrTag(JITOperationPtrTag, nextPtrTagID());
     63    move(TrustedImmPtr(tagCFunctionPtr(operationProcessShadowChickenLog, tag)), scratch1NonArgGPR);
     64    call(scratch1NonArgGPR, tag);
    6465    move(TrustedImmPtr(vm.shadowChicken().addressOfLogCursor()), scratch1NonArgGPR);
    6566    loadPtr(Address(scratch1NonArgGPR), shadowPacket);

  • trunk/Source/JavaScriptCore/jit/CCallHelpers.h

    r230091 r230129  
    587587        // caller.
    588588#if CPU(ARM) || CPU(ARM64)
    589         loadPtr(Address(framePointerRegister, sizeof(void*)), linkRegister);
     589        loadPtr(Address(framePointerRegister, CallFrame::returnPCOffset()), linkRegister);
    590590        subPtr(TrustedImm32(2 * sizeof(void*)), newFrameSizeGPR);
     591#if USE(POINTER_PROFILING)
     592        addPtr(TrustedImm32(sizeof(CallerFrameAndPC)), MacroAssembler::framePointerRegister, tempGPR);
     593        untagPtr(linkRegister, tempGPR);
     594#endif
    591595#elif CPU(MIPS)
    592596        loadPtr(Address(framePointerRegister, sizeof(void*)), returnAddressRegister);

  • trunk/Source/JavaScriptCore/jit/CallFrameShuffler.cpp

    r223047 r230129  
    11/*
    2  * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2015-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    447447    // We load the link register manually for architectures that have one
    448448#if CPU(ARM) || CPU(ARM64)
    449     m_jit.loadPtr(MacroAssembler::Address(MacroAssembler::framePointerRegister, sizeof(void*)),
     449    m_jit.loadPtr(MacroAssembler::Address(MacroAssembler::framePointerRegister, CallFrame::returnPCOffset()),
    450450        MacroAssembler::linkRegister);
     451#if USE(POINTER_PROFILING)
     452    m_jit.addPtr(MacroAssembler::TrustedImm32(sizeof(CallerFrameAndPC)), MacroAssembler::framePointerRegister);
     453    m_jit.untagPtr(MacroAssembler::linkRegister, MacroAssembler::framePointerRegister);
     454    m_jit.subPtr(MacroAssembler::TrustedImm32(sizeof(CallerFrameAndPC)), MacroAssembler::framePointerRegister);
     455#endif
     456
    451457#elif CPU(MIPS)
    452458    m_jit.loadPtr(MacroAssembler::Address(MacroAssembler::framePointerRegister, sizeof(void*)),

  • trunk/Source/JavaScriptCore/jit/ExecutableAllocator.cpp

    r230092 r230129  
    239239        MacroAssembler jit;
    240240
     241        jit.tagReturnAddress();
    241242        jit.move(MacroAssembler::TrustedImmPtr(writableAddr), x7);
    242243        jit.addPtr(x7, x0);
    … …  
    299300        // The second is we can't guarantee that the code is readable when using the
    300301        // asyncDisassembly option as our caller will set our pages execute only.
    301         return linkBuffer.finalizeCodeWithoutDisassembly(NoPtrTag);
     302        PtrTag tag = ptrTag(JITWriteThunkPtrTag, &jitWriteSeparateHeapsFunction);
     303        return linkBuffer.finalizeCodeWithoutDisassembly(tag);
    302304    }
    303305#else // CPU(ARM64) && USE(EXECUTE_ONLY_JIT_WRITE_FUNCTION)

  • trunk/Source/JavaScriptCore/jit/ExecutableAllocator.h

    r230092 r230129  
    11/*
    2  * Copyright (C) 2008, 2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2727
    2828#include "JITCompilationEffort.h"
     29#include "PtrTag.h"
    2930#include <stddef.h> // for ptrdiff_t
    3031#include <limits>
    … …  
    9192            // memcpy that takes an offset into the JIT region as its destination (first) parameter.
    9293            off_t offset = (off_t)((uintptr_t)dst - startOfFixedExecutableMemoryPool);
    93             jitWriteSeparateHeapsFunction(offset, src, n);
     94            PtrTag tag = ptrTag(JITWriteThunkPtrTag, &jitWriteSeparateHeapsFunction);
     95            retagCodePtr(jitWriteSeparateHeapsFunction, tag, CFunctionPtrTag)(offset, src, n);
    9496            return dst;
    9597        }

  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r229957 r230129  
    650650    m_pcToCodeOriginMapBuilder.appendItem(label(), CodeOrigin(0, nullptr));
    651651
     652    Label entryLabel(this);
    652653    if (m_disassembler)
    653         m_disassembler->setStartOfCode(label());
     654        m_disassembler->setStartOfCode(entryLabel);
    654655
    655656    // Just add a little bit of randomness to the codegen
    … …  
    736737            addPtr(TrustedImm32(maxFrameExtentForSlowPathCall), stackPointerRegister);
    737738        branchTest32(Zero, returnValueGPR).linkTo(beginLabel, this);
     739#if CPU(ARM64) && USE(POINTER_PROFILING)
     740        loadPtr(Address(callFrameRegister, CallFrame::returnPCOffset()), linkRegister);
     741        addPtr(TrustedImm32(sizeof(CallerFrameAndPC)), callFrameRegister, regT1);
     742        untagPtr(linkRegister, regT1);
     743        PtrTag tempTag = ptrTag(JITThunkPtrTag, nextPtrTagID());
     744        move(TrustedImmPtr(tempTag), regT1);
     745        tagPtr(linkRegister, regT1);
     746        storePtr(linkRegister, Address(callFrameRegister, CallFrame::returnPCOffset()));
     747#endif
    738748        move(returnValueGPR, GPRInfo::argumentGPR0);
    739         emitNakedCall(m_vm->getCTIStub(arityFixupGenerator).code());
     749        emitNakedCall(m_vm->getCTIStub(arityFixupGenerator).retaggedCode(ptrTag(JITThunkPtrTag, m_vm), NearCallPtrTag));
     750#if CPU(ARM64) && USE(POINTER_PROFILING)
     751        loadPtr(Address(callFrameRegister, CallFrame::returnPCOffset()), linkRegister);
     752        move(TrustedImmPtr(tempTag), regT1);
     753        untagPtr(linkRegister, regT1);
     754        addPtr(TrustedImm32(sizeof(CallerFrameAndPC)), callFrameRegister, regT1);
     755        tagPtr(linkRegister, regT1);
     756        storePtr(linkRegister, Address(callFrameRegister, CallFrame::returnPCOffset()));
     757#endif
    740758
    741759#if !ASSERT_DISABLED
    … …  
    744762
    745763        jump(beginLabel);
    746     }
     764    } else
     765        m_arityCheck = entryLabel; // Not a function.
    747766
    748767    ASSERT(m_jmpTable.isEmpty());
    … …  
    785804            ASSERT(record.jumpTable.simpleJumpTable->branchOffsets.size() == record.jumpTable.simpleJumpTable->ctiOffsets.size());
    786805
    787             record.jumpTable.simpleJumpTable->ctiDefault = patchBuffer.locationOf(m_labels[bytecodeOffset + record.defaultOffset], NoPtrTag);
     806            auto* simpleJumpTable = record.jumpTable.simpleJumpTable;
     807            PtrTag tag = ptrTag(SwitchTablePtrTag, simpleJumpTable);
     808            simpleJumpTable->ctiDefault = patchBuffer.locationOf(m_labels[bytecodeOffset + record.defaultOffset], tag);
    788809
    789810            for (unsigned j = 0; j < record.jumpTable.simpleJumpTable->branchOffsets.size(); ++j) {
    790811                unsigned offset = record.jumpTable.simpleJumpTable->branchOffsets[j];
    791                 record.jumpTable.simpleJumpTable->ctiOffsets[j] = offset ? patchBuffer.locationOf(m_labels[bytecodeOffset + offset], NoPtrTag) : record.jumpTable.simpleJumpTable->ctiDefault;
     812                simpleJumpTable->ctiOffsets[j] = offset
     813                    ? patchBuffer.locationOf(m_labels[bytecodeOffset + offset], tag)
     814                    : simpleJumpTable->ctiDefault;
    792815            }
    793816        } else {
    … …  
    795818
    796819            auto* stringJumpTable = record.jumpTable.stringJumpTable;
     820            PtrTag tag = ptrTag(SwitchTablePtrTag, stringJumpTable);
    797821            stringJumpTable->ctiDefault =
    798                 patchBuffer.locationOf(m_labels[bytecodeOffset + record.defaultOffset], NoPtrTag);
     822                patchBuffer.locationOf(m_labels[bytecodeOffset + record.defaultOffset], tag);
    799823
    800824            for (auto& location : stringJumpTable->offsetTable.values()) {
    801825                unsigned offset = location.branchOffset;
    802826                location.ctiOffset = offset
    803                     ? patchBuffer.locationOf(m_labels[bytecodeOffset + offset], NoPtrTag)
     827                    ? patchBuffer.locationOf(m_labels[bytecodeOffset + offset], tag)
    804828                    : stringJumpTable->ctiDefault;
    805829            }
    … …  
    833857                notIndexJump = CodeLocationJump(patchBuffer.locationOf(patchableNotIndexJump));
    834858            CodeLocationJump badTypeJump = CodeLocationJump(patchBuffer.locationOf(byValCompilationInfo.badTypeJump));
    835             CodeLocationLabel doneTarget = patchBuffer.locationOf(byValCompilationInfo.doneTarget, NoPtrTag);
    836             CodeLocationLabel nextHotPathTarget = patchBuffer.locationOf(byValCompilationInfo.nextHotPathTarget, NoPtrTag);
    837             CodeLocationLabel slowPathTarget = patchBuffer.locationOf(byValCompilationInfo.slowPathTarget, NoPtrTag);
     859            CodeLocationLabel doneTarget = patchBuffer.locationOf(byValCompilationInfo.doneTarget);
     860            CodeLocationLabel nextHotPathTarget = patchBuffer.locationOf(byValCompilationInfo.nextHotPathTarget);
     861            CodeLocationLabel slowPathTarget = patchBuffer.locationOf(byValCompilationInfo.slowPathTarget);
    838862            CodeLocationCall returnAddress = patchBuffer.locationOf(byValCompilationInfo.returnAddress);
    839863
    … …  
    866890    m_codeBlock->setJITCodeMap(jitCodeMapEncoder.finish());
    867891
    868     MacroAssemblerCodePtr withArityCheck;
    869     if (m_codeBlock->codeType() == FunctionCode)
    870         withArityCheck = patchBuffer.locationOf(m_arityCheck, CodeEntryWithArityCheckPtrTag);
     892    MacroAssemblerCodePtr withArityCheck = patchBuffer.locationOf(m_arityCheck, CodeEntryWithArityCheckPtrTag);
    871893
    872894    if (Options::dumpDisassembly()) {

  • trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp

    r229767 r230129  
    11/*
    2  * Copyright (C) 2008-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    515515{
    516516    ArithProfile* arithProfile = m_codeBlock->arithProfileForPC(currentInstruction);
    517     JITNegIC* negateIC = m_codeBlock->addJITNegIC(arithProfile);
     517    JITNegIC* negateIC = m_codeBlock->addJITNegIC(arithProfile, currentInstruction);
    518518    m_instructionToMathIC.add(currentInstruction, negateIC);
    519519    emitMathICFast(negateIC, currentInstruction, operationArithNegateProfiled, operationArithNegate);
    … …  
    663663{
    664664    ArithProfile* arithProfile = m_codeBlock->arithProfileForPC(currentInstruction);
    665     JITAddIC* addIC = m_codeBlock->addJITAddIC(arithProfile);
     665    JITAddIC* addIC = m_codeBlock->addJITAddIC(arithProfile, currentInstruction);
    666666    m_instructionToMathIC.add(currentInstruction, addIC);
    667667    emitMathICFast(addIC, currentInstruction, operationValueAddProfiled, operationValueAdd);
    … …  
    706706    bool generatedInlineCode = mathIC->generateInline(*this, mathICGenerationState);
    707707    if (!generatedInlineCode) {
     708        PtrTag tag = ptrTag(MathICPtrTag, currentInstruction);
    708709        ArithProfile* arithProfile = mathIC->arithProfile();
    709710        if (arithProfile && shouldEmitProfiling())
    710             callOperationWithResult(profiledFunction, NoPtrTag, resultRegs, srcRegs, arithProfile);
     711            callOperationWithResult(profiledFunction, tag, resultRegs, srcRegs, arithProfile);
    711712        else
    712             callOperationWithResult(nonProfiledFunction, NoPtrTag, resultRegs, srcRegs);
     713            callOperationWithResult(nonProfiledFunction, tag, resultRegs, srcRegs);
    713714    } else
    714715        addSlowCase(mathICGenerationState.slowPathJumps);
    … …  
    779780        else if (rightOperand.isConst())
    780781            emitGetVirtualRegister(op2, rightRegs);
     782        PtrTag tag = ptrTag(MathICPtrTag, currentInstruction);
    781783        ArithProfile* arithProfile = mathIC->arithProfile();
    782784        if (arithProfile && shouldEmitProfiling())
    783             callOperationWithResult(profiledFunction, NoPtrTag, resultRegs, leftRegs, rightRegs, arithProfile);
     785            callOperationWithResult(profiledFunction, tag, resultRegs, leftRegs, rightRegs, arithProfile);
    784786        else
    785             callOperationWithResult(nonProfiledFunction, NoPtrTag, resultRegs, leftRegs, rightRegs);
     787            callOperationWithResult(nonProfiledFunction, tag, resultRegs, leftRegs, rightRegs);
    786788    } else
    787789        addSlowCase(mathICGenerationState.slowPathJumps);
    … …  
    818820#endif
    819821
     822    PtrTag tag = ptrTag(MathICPtrTag, currentInstruction);
    820823    ArithProfile* arithProfile = mathIC->arithProfile();
    821824    if (arithProfile && shouldEmitProfiling()) {
    822825        if (mathICGenerationState.shouldSlowPathRepatch)
    823             mathICGenerationState.slowPathCall = callOperationWithResult(reinterpret_cast<J_JITOperation_EJMic>(profiledRepatchFunction), NoPtrTag, resultRegs, srcRegs, TrustedImmPtr(mathIC));
     826            mathICGenerationState.slowPathCall = callOperationWithResult(reinterpret_cast<J_JITOperation_EJMic>(profiledRepatchFunction), tag, resultRegs, srcRegs, TrustedImmPtr(mathIC));
    824827        else
    825             mathICGenerationState.slowPathCall = callOperationWithResult(profiledFunction, NoPtrTag, resultRegs, srcRegs, arithProfile);
     828            mathICGenerationState.slowPathCall = callOperationWithResult(profiledFunction, tag, resultRegs, srcRegs, arithProfile);
    826829    } else
    827         mathICGenerationState.slowPathCall = callOperationWithResult(reinterpret_cast<J_JITOperation_EJMic>(repatchFunction), NoPtrTag, resultRegs, srcRegs, TrustedImmPtr(mathIC));
     830        mathICGenerationState.slowPathCall = callOperationWithResult(reinterpret_cast<J_JITOperation_EJMic>(repatchFunction), tag, resultRegs, srcRegs, TrustedImmPtr(mathIC));
    828831
    829832#if ENABLE(MATH_IC_STATS)
    … …  
    884887#endif
    885888
     889    PtrTag callTag = ptrTag(MathICPtrTag, currentInstruction);
    886890    ArithProfile* arithProfile = mathIC->arithProfile();
    887891    if (arithProfile && shouldEmitProfiling()) {
    888892        if (mathICGenerationState.shouldSlowPathRepatch)
    889             mathICGenerationState.slowPathCall = callOperationWithResult(bitwise_cast<J_JITOperation_EJJMic>(profiledRepatchFunction), NoPtrTag, resultRegs, leftRegs, rightRegs, TrustedImmPtr(mathIC));
     893            mathICGenerationState.slowPathCall = callOperationWithResult(bitwise_cast<J_JITOperation_EJJMic>(profiledRepatchFunction), callTag, resultRegs, leftRegs, rightRegs, TrustedImmPtr(mathIC));
    890894        else
    891             mathICGenerationState.slowPathCall = callOperationWithResult(profiledFunction, NoPtrTag, resultRegs, leftRegs, rightRegs, arithProfile);
     895            mathICGenerationState.slowPathCall = callOperationWithResult(profiledFunction, callTag, resultRegs, leftRegs, rightRegs, arithProfile);
    892896    } else
    893         mathICGenerationState.slowPathCall = callOperationWithResult(bitwise_cast<J_JITOperation_EJJMic>(repatchFunction), NoPtrTag, resultRegs, leftRegs, rightRegs, TrustedImmPtr(mathIC));
     897        mathICGenerationState.slowPathCall = callOperationWithResult(bitwise_cast<J_JITOperation_EJJMic>(repatchFunction), callTag, resultRegs, leftRegs, rightRegs, TrustedImmPtr(mathIC));
    894898
    895899#if ENABLE(MATH_IC_STATS)
    … …  
    978982{
    979983    ArithProfile* arithProfile = m_codeBlock->arithProfileForPC(currentInstruction);
    980     JITMulIC* mulIC = m_codeBlock->addJITMulIC(arithProfile);
     984    JITMulIC* mulIC = m_codeBlock->addJITMulIC(arithProfile, currentInstruction);
    981985    m_instructionToMathIC.add(currentInstruction, mulIC);
    982986    emitMathICFast(mulIC, currentInstruction, operationValueMulProfiled, operationValueMul);
    … …  
    994998{
    995999    ArithProfile* arithProfile = m_codeBlock->arithProfileForPC(currentInstruction);
    996     JITSubIC* subIC = m_codeBlock->addJITSubIC(arithProfile);
     1000    JITSubIC* subIC = m_codeBlock->addJITSubIC(arithProfile, currentInstruction);
    9971001    m_instructionToMathIC.add(currentInstruction, subIC);
    9981002    emitMathICFast(subIC, currentInstruction, operationValueSubProfiled, operationValueSub);

  • trunk/Source/JavaScriptCore/jit/JITCode.cpp

    r225363 r230129  
    11/*
    2  * Copyright (C) 2008-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    7272    auto scope = DECLARE_THROW_SCOPE(*vm);
    7373    void* entryAddress;
    74     JSFunction* function = jsDynamicCast<JSFunction*>(*vm, protoCallFrame->callee());
    75 
    76     if (!function || !protoCallFrame->needArityCheck()) {
    77         ASSERT(!protoCallFrame->needArityCheck());
    78         entryAddress = executableAddress();
    79     } else
    80         entryAddress = addressForCall(MustCheckArity).executableAddress();
     74    entryAddress = addressForCall(MustCheckArity).executableAddress();
    8175    JSValue result = JSValue::decode(vmEntryToJavaScript(entryAddress, vm, protoCallFrame));
    8276    return scope.exception() ? jsNull() : result;
    … …  
    128122{
    129123    RELEASE_ASSERT(m_ref);
    130     return m_ref.code().executableAddress<char*>() + offset;
     124    assertIsTaggedWith(m_ref.code().executableAddress(), CodeEntryPtrTag);
     125    if (!offset)
     126        return m_ref.code().executableAddress();
     127
     128    char* executableAddress = untagCodePtr<char*>(m_ref.code().executableAddress(), CodeEntryPtrTag);
     129    return tagCodePtr(executableAddress + offset, CodeEntryPtrTag);
    131130}
    132131
    … …  
    167166    , m_withArityCheck(withArityCheck)
    168167{
     168    ASSERT(m_ref);
     169    ASSERT(m_withArityCheck);
    169170}
    170171
    … …  
    178179    m_ref = ref;
    179180    m_withArityCheck = withArityCheck;
     181    ASSERT(m_ref);
     182    ASSERT(m_withArityCheck);
    180183}
    181184
    … …  
    214217}
    215218
    216 JITCode::CodePtr NativeJITCode::addressForCall(ArityCheckMode)
    217 {
    218     RELEASE_ASSERT(!!m_ref);
    219     return m_ref.code();
     219JITCode::CodePtr NativeJITCode::addressForCall(ArityCheckMode arity)
     220{
     221    RELEASE_ASSERT(m_ref);
     222    switch (arity) {
     223    case ArityCheckNotRequired:
     224        return m_ref.code();
     225    case MustCheckArity:
     226        return m_ref.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag);
     227    }
     228    RELEASE_ASSERT_NOT_REACHED();
     229    return CodePtr();
    220230}
    221231

  • trunk/Source/JavaScriptCore/jit/JITExceptions.cpp

    r223738 r230129  
    11/*
    2  * Copyright (C) 2012-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    8787    ASSERT(bitwise_cast<uintptr_t>(callFrame) < bitwise_cast<uintptr_t>(vm->topEntryFrame));
    8888
     89    assertIsTaggedWith(catchRoutine, ExceptionHandlerPtrTag);
    8990    vm->callFrameForCatch = callFrame;
    9091    vm->targetMachinePCForThrow = catchRoutine;

  • trunk/Source/JavaScriptCore/jit/JITMathIC.h

    r229609 r230129  
    5757    WTF_MAKE_FAST_ALLOCATED;
    5858public:
    59     JITMathIC(ArithProfile* arithProfile)
     59    JITMathIC(ArithProfile* arithProfile, Instruction* instruction)
    6060        : m_arithProfile(arithProfile)
     61        , m_instruction(instruction)
    6162    {
    6263    }
    … …  
    140141            RELEASE_ASSERT(linkBuffer.isValid());
    141142            linkBuffer.link(jump, CodeLocationLabel(m_code.code()));
    142             FINALIZE_CODE(linkBuffer, NoPtrTag, "JITMathIC: linking constant jump to out of line stub");
     143            FINALIZE_CODE(linkBuffer, NearJumpPtrTag, "JITMathIC: linking constant jump to out of line stub");
    143144        };
    144145
    145146        auto replaceCall = [&] () {
    146             ftlThunkAwareRepatchCall(codeBlock, slowPathCallLocation(), callReplacement);
     147            PtrTag tag = ptrTag(MathICPtrTag, m_instruction);
     148            ftlThunkAwareRepatchCall(codeBlock, slowPathCallLocation(), FunctionPtr(callReplacement, tag));
    147149        };
    148150
    … …  
    167169
    168170                    m_code = FINALIZE_CODE_FOR(
    169                         codeBlock, linkBuffer, NoPtrTag, "JITMathIC: generating out of line fast IC snippet");
     171                        codeBlock, linkBuffer, NearJumpPtrTag, "JITMathIC: generating out of line fast IC snippet");
    170172
    171173                    if (!generationState.shouldSlowPathRepatch) {
    … …  
    209211
    210212            m_code = FINALIZE_CODE_FOR(
    211                 codeBlock, linkBuffer, NoPtrTag, "JITMathIC: generating out of line IC snippet");
     213                codeBlock, linkBuffer, NearJumpPtrTag, "JITMathIC: generating out of line IC snippet");
    212214        }
    213215
    … …  
    217219    void finalizeInlineCode(const MathICGenerationState& state, LinkBuffer& linkBuffer)
    218220    {
    219         CodeLocationLabel start = linkBuffer.locationOf(state.fastPathStart, NoPtrTag);
     221        CodeLocationLabel start = linkBuffer.locationOf(state.fastPathStart, NearJumpPtrTag);
    220222        m_inlineStart = start;
    221223
    … …  
    227229            start, linkBuffer.locationOf(state.slowPathCall));
    228230        m_deltaFromStartToSlowPathStart = MacroAssembler::differenceBetweenCodePtr(
    229             start, linkBuffer.locationOf(state.slowPathStart, SlowPathPtrTag));
     231            start, linkBuffer.locationOf(state.slowPathStart, NoPtrTag));
    230232    }
    231233
    … …  
    244246
    245247    ArithProfile* m_arithProfile;
     248    Instruction* m_instruction;
    246249    MacroAssemblerCodeRef m_code;
    247250    CodeLocationLabel m_inlineStart;
    … …  
    260263class JITBinaryMathIC : public JITMathIC<GeneratorType, isBinaryProfileEmpty> {
    261264public:
    262     JITBinaryMathIC(ArithProfile* arithProfile)
    263         : JITMathIC<GeneratorType, isBinaryProfileEmpty>(arithProfile)
     265    JITBinaryMathIC(ArithProfile* arithProfile, Instruction* instruction)
     266        : JITMathIC<GeneratorType, isBinaryProfileEmpty>(arithProfile, instruction)
    264267    {
    265268    }
    … …  
    278281class JITUnaryMathIC : public JITMathIC<GeneratorType, isUnaryProfileEmpty> {
    279282public:
    280     JITUnaryMathIC(ArithProfile* arithProfile)
    281         : JITMathIC<GeneratorType, isUnaryProfileEmpty>(arithProfile)
     283    JITUnaryMathIC(ArithProfile* arithProfile, Instruction* instruction)
     284        : JITMathIC<GeneratorType, isUnaryProfileEmpty>(arithProfile, instruction)
    282285    {
    283286    }

  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r229957 r230129  
    682682    emitGetVirtualRegister(scrutinee, regT0);
    683683    callOperation(operationSwitchImmWithUnknownKeyType, regT0, tableIndex);
    684     jump(returnValueGPR, NoPtrTag);
     684    jump(returnValueGPR, ptrTag(SwitchTablePtrTag, jumpTable));
    685685}
    686686
    … …  
    698698    emitGetVirtualRegister(scrutinee, regT0);
    699699    callOperation(operationSwitchCharWithUnknownKeyType, regT0, tableIndex);
    700     jump(returnValueGPR, NoPtrTag);
     700    jump(returnValueGPR, ptrTag(SwitchTablePtrTag, jumpTable));
    701701}
    702702
    … …  
    713713    emitGetVirtualRegister(scrutinee, regT0);
    714714    callOperation(operationSwitchStringWithUnknownKeyType, regT0, tableIndex);
    715     jump(returnValueGPR, NoPtrTag);
     715    jump(returnValueGPR, ptrTag(SwitchTablePtrTag, jumpTable));
    716716}
    717717
    … …  
    11711171   
    11721172    byValInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
    1173         m_codeBlock, patchBuffer, NoPtrTag,
     1173        m_codeBlock, patchBuffer, NearJumpPtrTag,
    11741174        "Baseline has_indexed_property stub for %s, return point %p", toCString(*m_codeBlock).data(), returnAddress.value());
    11751175   
    11761176    MacroAssembler::repatchJump(byValInfo->badTypeJump, CodeLocationLabel(byValInfo->stubRoutine->code().code()));
    1177     MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationHasIndexedPropertyGeneric, SlowPathPtrTag));
     1177    MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationHasIndexedPropertyGeneric, HasPropertyPtrTag));
    11781178}
    11791179
    … …  
    12341234    emitGetVirtualRegister(base, regT0);
    12351235    emitGetVirtualRegister(property, regT1);
    1236     Call call = callOperation(operationHasIndexedPropertyDefault, dst, regT0, regT1, byValInfo);
     1236    Call call = callOperation(operationHasIndexedPropertyDefault, HasPropertyPtrTag, dst, regT0, regT1, byValInfo);
    12371237
    12381238    m_byValCompilationInfo[m_byValInstructionIndex].slowPathTarget = slowPath;

  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r229957 r230129  
    10441044   
    10451045    patchBuffer.link(done, byValInfo->badTypeJump.labelAtOffset(byValInfo->badTypeJumpToDone));
    1046    
     1046
    10471047    byValInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
    10481048        m_codeBlock, patchBuffer, NoPtrTag,
    … …  
    10501050   
    10511051    MacroAssembler::repatchJump(byValInfo->badTypeJump, CodeLocationLabel(byValInfo->stubRoutine->code().code()));
    1052     MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationHasIndexedPropertyGeneric, SlowPathPtrTag));
     1052    MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationHasIndexedPropertyGeneric, NoPtrTag));
    10531053}
    10541054

  • trunk/Source/JavaScriptCore/jit/JITOperations.cpp

    r229957 r230129  
    11/*
    2  * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    6565#include "ProgramCodeBlock.h"
    6666#include "PropertyName.h"
     67#include "PtrTag.h"
    6768#include "RegExpObject.h"
    6869#include "Repatch.h"
    … …  
    731732        // Don't ever try to optimize.
    732733        byValInfo->tookSlowPath = true;
    733         ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationPutByValGeneric));
     734        ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationPutByValGeneric, PutPropertyPtrTag));
    734735    }
    735736    putByVal(exec, baseValue, subscript, value, byValInfo);
    … …  
    815816        // Don't ever try to optimize.
    816817        byValInfo->tookSlowPath = true;
    817         ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationDirectPutByValGeneric));
     818        ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationDirectPutByValGeneric, PutPropertyPtrTag));
    818819    }
    819820
    … …  
    862863}
    863864
    864 static SlowPathReturnType handleHostCall(ExecState* execCallee, JSValue callee, CallLinkInfo* callLinkInfo)
     865static SlowPathReturnType handleHostCall(ExecState* execCallee, JSValue callee, CallLinkInfo* callLinkInfo, PtrTag resultTag)
    865866{
    866867    ExecState* exec = execCallee->callerFrame();
    … …  
    881882            vm->hostCallReturnValue = JSValue::decode(callData.native.function(execCallee));
    882883            if (UNLIKELY(scope.exception())) {
     884                PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
    883885                return encodeResult(
    884                     vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
     886                    vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode(thunkTag, resultTag).executableAddress(),
    885887                    reinterpret_cast<void*>(KeepTheFrame));
    886888            }
    887889
    888890            return encodeResult(
    889                 bitwise_cast<void*>(getHostCallReturnValue),
     891                tagCFunctionPtr<void*>(getHostCallReturnValue, resultTag),
    890892                reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
    891893        }
    … …  
    893895        ASSERT(callType == CallType::None);
    894896        throwException(exec, scope, createNotAFunctionError(exec, callee));
     897        PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
    895898        return encodeResult(
    896             vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
     899            vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode(thunkTag, resultTag).executableAddress(),
    897900            reinterpret_cast<void*>(KeepTheFrame));
    898901    }
    … …  
    910913        vm->hostCallReturnValue = JSValue::decode(constructData.native.function(execCallee));
    911914        if (UNLIKELY(scope.exception())) {
     915            PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
    912916            return encodeResult(
    913                 vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
     917                vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode(thunkTag, resultTag).executableAddress(),
    914918                reinterpret_cast<void*>(KeepTheFrame));
    915919        }
    916920
    917         return encodeResult(bitwise_cast<void*>(getHostCallReturnValue), reinterpret_cast<void*>(KeepTheFrame));
     921        return encodeResult(tagCFunctionPtr<void*>(getHostCallReturnValue, resultTag), reinterpret_cast<void*>(KeepTheFrame));
    918922    }
    919923   
    920924    ASSERT(constructType == ConstructType::None);
    921925    throwException(exec, scope, createNotAConstructorError(exec, callee));
     926    PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
    922927    return encodeResult(
    923         vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
     928        vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode(thunkTag, resultTag).executableAddress(),
    924929        reinterpret_cast<void*>(KeepTheFrame));
    925930}
    … …  
    931936    auto throwScope = DECLARE_THROW_SCOPE(*vm);
    932937
     938    PtrTag linkedTargetTag = ptrTag(OperationLinkCallPtrTag, vm);
    933939    CodeSpecializationKind kind = callLinkInfo->specializationKind();
    934940    NativeCallFrameTracer tracer(vm, exec);
    … …  
    946952                callLinkInfo->setSeen();
    947953            else
    948                 linkFor(execCallee, *callLinkInfo, nullptr, internalFunction, codePtr);
    949 
    950             return encodeResult(codePtr.executableAddress(), reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
     954                linkFor(execCallee, *callLinkInfo, nullptr, internalFunction, codePtr, CodeEntryPtrTag);
     955
     956            void* linkedTarget = retagCodePtr(codePtr.executableAddress(), CodeEntryPtrTag, linkedTargetTag);
     957            return encodeResult(linkedTarget, reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
    951958        }
    952959        throwScope.release();
    953         return handleHostCall(execCallee, calleeAsValue, callLinkInfo);
     960        return handleHostCall(execCallee, calleeAsValue, callLinkInfo, linkedTargetTag);
    954961    }
    955962
    … …  
    960967    MacroAssemblerCodePtr codePtr;
    961968    CodeBlock* codeBlock = nullptr;
     969    PtrTag codeTag = NoPtrTag;
    962970    if (executable->isHostFunction()) {
    963971        codePtr = executable->entrypointFor(kind, MustCheckArity);
     972        codeTag = CodeEntryWithArityCheckPtrTag;
    964973    } else {
    965974        FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
    966975
     976        auto handleThrowException = [&] () {
     977            PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
     978            void* throwTarget = retagCodePtr(vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(), thunkTag, linkedTargetTag);
     979            return encodeResult(throwTarget, reinterpret_cast<void*>(KeepTheFrame));
     980        };
     981
    967982        if (!isCall(kind) && functionExecutable->constructAbility() == ConstructAbility::CannotConstruct) {
    968983            throwException(exec, throwScope, createNotAConstructorError(exec, callee));
    969             return encodeResult(
    970                 vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
    971                 reinterpret_cast<void*>(KeepTheFrame));
     984            return handleThrowException();
    972985        }
    973986
    … …  
    975988        JSObject* error = functionExecutable->prepareForExecution<FunctionExecutable>(*vm, callee, scope, kind, *codeBlockSlot);
    976989        EXCEPTION_ASSERT(throwScope.exception() == reinterpret_cast<Exception*>(error));
    977         if (error) {
    978             return encodeResult(
    979                 vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
    980                 reinterpret_cast<void*>(KeepTheFrame));
    981         }
     990        if (error)
     991            return handleThrowException();
    982992        codeBlock = *codeBlockSlot;
    983993        ArityCheckMode arity;
    984         if (execCallee->argumentCountIncludingThis() < static_cast<size_t>(codeBlock->numParameters()) || callLinkInfo->isVarargs())
     994        if (execCallee->argumentCountIncludingThis() < static_cast<size_t>(codeBlock->numParameters()) || callLinkInfo->isVarargs()) {
    985995            arity = MustCheckArity;
    986         else
     996            codeTag = CodeEntryWithArityCheckPtrTag;
     997        } else {
    987998            arity = ArityCheckNotRequired;
     999            codeTag = CodeEntryPtrTag;
     1000        }
    9881001        codePtr = functionExecutable->entrypointFor(kind, arity);
    9891002    }
    … …  
    9911004        callLinkInfo->setSeen();
    9921005    else
    993         linkFor(execCallee, *callLinkInfo, codeBlock, callee, codePtr);
    994    
    995     return encodeResult(codePtr.executableAddress(), reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
     1006        linkFor(execCallee, *callLinkInfo, codeBlock, callee, codePtr, codeTag);
     1007
     1008    return encodeResult(codePtr.retagged(codeTag, linkedTargetTag).executableAddress(), reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
    9961009}
    9971010
    … …  
    10261039    CodeBlock* codeBlock = nullptr;
    10271040    if (executable->isHostFunction())
    1028         codePtr = executable->entrypointFor(kind, MustCheckArity);
     1041        codePtr = executable->entrypointFor(kind, MustCheckArity).retagged(CodeEntryWithArityCheckPtrTag, NearCallPtrTag);
    10291042    else {
    10301043        FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
    … …  
    10361049        if (error)
    10371050            return;
    1038         ArityCheckMode arity;
    10391051        unsigned argumentStackSlots = callLinkInfo->maxNumArguments();
    10401052        if (argumentStackSlots < static_cast<size_t>(codeBlock->numParameters()))
    1041             arity = MustCheckArity;
     1053            codePtr = functionExecutable->entrypointFor(kind, MustCheckArity).retagged(CodeEntryWithArityCheckPtrTag, NearCallPtrTag);
    10421054        else
    1043             arity = ArityCheckNotRequired;
    1044         codePtr = functionExecutable->entrypointFor(kind, arity);
     1055            codePtr = functionExecutable->entrypointFor(kind, ArityCheckNotRequired).retagged(CodeEntryPtrTag, NearCallPtrTag);
    10451056    }
    10461057   
    … …  
    10491060
    10501061inline SlowPathReturnType virtualForWithFunction(
    1051     ExecState* execCallee, CallLinkInfo* callLinkInfo, JSCell*& calleeAsFunctionCell)
     1062    ExecState* execCallee, CallLinkInfo* callLinkInfo, JSCell*& calleeAsFunctionCell, PtrTag resultTag)
    10521063{
    10531064    ExecState* exec = execCallee->callerFrame();
    … …  
    10641075            MacroAssemblerCodePtr codePtr = vm->getCTIInternalFunctionTrampolineFor(kind);
    10651076            ASSERT(!!codePtr);
    1066             return encodeResult(codePtr.executableAddress(), reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
     1077            return encodeResult(codePtr.retagged(CodeEntryPtrTag, resultTag).executableAddress(), reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
    10671078        }
    10681079        throwScope.release();
    1069         return handleHostCall(execCallee, calleeAsValue, callLinkInfo);
     1080        return handleHostCall(execCallee, calleeAsValue, callLinkInfo, resultTag);
    10701081    }
    10711082   
    … …  
    10781089        if (!isCall(kind) && functionExecutable->constructAbility() == ConstructAbility::CannotConstruct) {
    10791090            throwException(exec, throwScope, createNotAConstructorError(exec, function));
     1091            PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
    10801092            return encodeResult(
    1081                 vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
     1093                vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode(thunkTag, resultTag).executableAddress(),
    10821094                reinterpret_cast<void*>(KeepTheFrame));
    10831095        }
    … …  
    10871099        EXCEPTION_ASSERT(throwScope.exception() == reinterpret_cast<Exception*>(error));
    10881100        if (error) {
     1101            PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
    10891102            return encodeResult(
    1090                 vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress(),
     1103                vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode(thunkTag, resultTag).executableAddress(),
    10911104                reinterpret_cast<void*>(KeepTheFrame));
    10921105        }
    10931106    }
    10941107    return encodeResult(executable->entrypointFor(
    1095         kind, MustCheckArity).executableAddress(),
     1108        kind, MustCheckArity).retagged(CodeEntryWithArityCheckPtrTag, resultTag).executableAddress(),
    10961109        reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
    10971110}
    … …  
    10991112SlowPathReturnType JIT_OPERATION operationLinkPolymorphicCall(ExecState* execCallee, CallLinkInfo* callLinkInfo)
    11001113{
     1114    ExecState* exec = execCallee->callerFrame();
     1115    VM* vm = &exec->vm();
    11011116    ASSERT(callLinkInfo->specializationKind() == CodeForCall);
    11021117    JSCell* calleeAsFunctionCell;
    1103     SlowPathReturnType result = virtualForWithFunction(execCallee, callLinkInfo, calleeAsFunctionCell);
     1118    PtrTag resultTag = ptrTag(OperationLinkPolymorphicCallPtrTag, vm);
     1119    SlowPathReturnType result = virtualForWithFunction(execCallee, callLinkInfo, calleeAsFunctionCell, resultTag);
    11041120
    11051121    linkPolymorphicCall(execCallee, *callLinkInfo, CallVariant(calleeAsFunctionCell));
    … …  
    11101126SlowPathReturnType JIT_OPERATION operationVirtualCall(ExecState* execCallee, CallLinkInfo* callLinkInfo)
    11111127{
     1128    ExecState* exec = execCallee->callerFrame();
     1129    VM* vm = &exec->vm();
    11121130    JSCell* calleeAsFunctionCellIgnored;
    1113     return virtualForWithFunction(execCallee, callLinkInfo, calleeAsFunctionCellIgnored);
     1131    PtrTag resultTag = ptrTag(OperationVirtualCallPtrTag, vm);
     1132    return virtualForWithFunction(execCallee, callLinkInfo, calleeAsFunctionCellIgnored, resultTag);
    11141133}
    11151134
    … …  
    17621781        if (isJSString(baseValue)) {
    17631782            if (asString(baseValue)->canGetIndex(i)) {
    1764                 ctiPatchCallByReturnAddress(returnAddress, FunctionPtr(operationGetByValString));
     1783                ctiPatchCallByReturnAddress(returnAddress, FunctionPtr(operationGetByValString, GetPropertyPtrTag));
    17651784                scope.release();
    17661785                return asString(baseValue)->getIndex(exec, i);
    … …  
    18301849                byValInfo->arrayProfile->computeUpdatedPrediction(locker, codeBlock, structure);
    18311850
    1832                 JIT::compileGetByVal(&vm, exec->codeBlock(), byValInfo, returnAddress, arrayMode);
     1851                JIT::compileGetByVal(&vm, codeBlock, byValInfo, returnAddress, arrayMode);
    18331852                optimizationResult = OptimizationResult::Optimized;
    18341853            }
    … …  
    19021921        // Don't ever try to optimize.
    19031922        byValInfo->tookSlowPath = true;
    1904         ctiPatchCallByReturnAddress(returnAddress, FunctionPtr(operationGetByValGeneric));
     1923        ctiPatchCallByReturnAddress(returnAddress, FunctionPtr(operationGetByValGeneric, GetPropertyPtrTag));
    19051924    }
    19061925
    … …  
    19421961            || object->structure(vm)->typeInfo().interceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero()) {
    19431962            // Don't ever try to optimize.
    1944             ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationHasIndexedPropertyGeneric));
     1963            ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationHasIndexedPropertyGeneric, HasPropertyPtrTag));
    19451964        }
    19461965    }
    … …  
    20022021        if (!isJSString(baseValue)) {
    20032022            ASSERT(exec->bytecodeOffset());
    2004             ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(byValInfo->stubRoutine ? operationGetByValGeneric : operationGetByValOptimize));
     2023            auto getByValFunction = byValInfo->stubRoutine ? operationGetByValGeneric : operationGetByValOptimize;
     2024            ctiPatchCallByReturnAddress(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(getByValFunction, GetPropertyPtrTag));
    20052025        }
    20062026    } else {
    … …  
    21512171    }
    21522172
     2173    assertIsTaggedWith(result, ptrTag(SwitchTablePtrTag, &jumpTable));
    21532174    return reinterpret_cast<char*>(result);
    21542175}
    … …  
    21692190    else
    21702191        result = jumpTable.ctiDefault.executableAddress();
     2192    assertIsTaggedWith(result, ptrTag(SwitchTablePtrTag, &jumpTable));
    21712193    return reinterpret_cast<char*>(result);
    21722194}
    … …  
    21882210        result = jumpTable.ctiDefault.executableAddress();
    21892211
     2212    assertIsTaggedWith(result, ptrTag(SwitchTablePtrTag, &jumpTable));
    21902213    return reinterpret_cast<char*>(result);
    21912214}

  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

    r229852 r230129  
    5555    JSInterfaceJIT jit(vm);
    5656    JumpList failures;
     57    jit.tagReturnAddress();
    5758    failures.append(jit.branchStructure(
    5859        NotEqual,
    … …  
    9192   
    9293    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    93     return FINALIZE_CODE(patchBuffer, NoPtrTag, "String get_by_val stub");
     94    return FINALIZE_CODE(patchBuffer, NearCallPtrTag, "String get_by_val stub");
    9495}
    9596
    … …  
    238239    gen.slowPathJump().link(this);
    239240
    240     Call call = callOperationWithProfile(operationGetByIdOptimize, dst, gen.stubInfo(), regT0, propertyName.impl());
     241    Call call = callOperationWithProfile(operationGetByIdOptimize, GetPropertyPtrTag, dst, gen.stubInfo(), regT0, propertyName.impl());
    241242    gen.reportSlowPathCall(coldPathBegin, call);
    242243    slowDoneCase = jump();
    … …  
    276277    emitGetVirtualRegister(base, regT0);
    277278    emitGetVirtualRegister(property, regT1);
    278     Call call = callOperation(operationGetByValOptimize, NoPtrTag, dst, regT0, regT1, byValInfo);
     279    Call call = callOperation(operationGetByValOptimize, GetPropertyPtrTag, dst, regT0, regT1, byValInfo);
    279280
    280281    m_byValCompilationInfo[m_byValInstructionIndex].slowPathTarget = slowPath;
    … …  
    456457    gen.slowPathJump().link(this);
    457458
    458     Call call = callOperation(gen.slowPathFunction(), gen.stubInfo(), regT1, regT0, propertyName.impl());
     459    Call call = callOperation(gen.slowPathFunction(), PutPropertyPtrTag, gen.stubInfo(), regT1, regT0, propertyName.impl());
    459460    gen.reportSlowPathCall(coldPathBegin, call);
    460461    doneCases.append(jump());
    … …  
    493494    emitGetVirtualRegister(value, regT2);
    494495    bool isDirect = Interpreter::getOpcodeID(currentInstruction->u.opcode) == op_put_by_val_direct;
    495     Call call = callOperation(isDirect ? operationDirectPutByValOptimize : operationPutByValOptimize, NoPtrTag, regT0, regT1, regT2, byValInfo);
     496    Call call = callOperation(isDirect ? operationDirectPutByValOptimize : operationPutByValOptimize, PutPropertyPtrTag, regT0, regT1, regT2, byValInfo);
    496497
    497498    m_byValCompilationInfo[m_byValInstructionIndex].slowPathTarget = slowPath;
    … …  
    594595    Label coldPathBegin = label();
    595596
    596     Call call = callOperation(operationTryGetByIdOptimize, resultVReg, gen.stubInfo(), regT0, ident->impl());
     597    Call call = callOperation(operationTryGetByIdOptimize, GetPropertyPtrTag, resultVReg, gen.stubInfo(), regT0, ident->impl());
    597598   
    598599    gen.reportSlowPathCall(coldPathBegin, call);
    … …  
    656657   
    657658    Label coldPathBegin = label();
    658    
    659     Call call = callOperationWithProfile(operationGetByIdOptimize, resultVReg, gen.stubInfo(), regT0, ident->impl());
     659
     660    Call call = callOperationWithProfile(operationGetByIdOptimize, GetPropertyPtrTag, resultVReg, gen.stubInfo(), regT0, ident->impl());
    660661
    661662    gen.reportSlowPathCall(coldPathBegin, call);
    … …  
    672673   
    673674    Label coldPathBegin = label();
    674    
    675     Call call = callOperationWithProfile(operationGetByIdWithThisOptimize, resultVReg, gen.stubInfo(), regT0, regT1, ident->impl());
     675
     676    Call call = callOperationWithProfile(operationGetByIdWithThisOptimize, GetPropertyPtrTag, resultVReg, gen.stubInfo(), regT0, regT1, ident->impl());
    676677
    677678    gen.reportSlowPathCall(coldPathBegin, call);
    … …  
    715716    JITPutByIdGenerator& gen = m_putByIds[m_putByIdIndex++];
    716717
    717     Call call = callOperation(
    718         gen.slowPathFunction(), gen.stubInfo(), regT1, regT0, ident->impl());
     718    Call call = callOperation(gen.slowPathFunction(), PutPropertyPtrTag, gen.stubInfo(), regT1, regT0, ident->impl());
    719719
    720720    gen.reportSlowPathCall(coldPathBegin, call);
    … …  
    12591259   
    12601260    byValInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
    1261         m_codeBlock, patchBuffer, NoPtrTag,
     1261        m_codeBlock, patchBuffer, NearJumpPtrTag,
    12621262        "Baseline get_by_val stub for %s, return point %p", toCString(*m_codeBlock).data(), returnAddress.value());
    12631263   
    12641264    MacroAssembler::repatchJump(byValInfo->badTypeJump, CodeLocationLabel(byValInfo->stubRoutine->code().code()));
    1265     MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationGetByValGeneric, SlowPathPtrTag));
     1265    MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationGetByValGeneric, GetPropertyPtrTag));
    12661266}
    12671267
    … …  
    12911291
    12921292    byValInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
    1293         m_codeBlock, patchBuffer, NoPtrTag,
     1293        m_codeBlock, patchBuffer, NearJumpPtrTag,
    12941294        "Baseline get_by_val with cached property name '%s' stub for %s, return point %p", propertyName.impl()->utf8().data(), toCString(*m_codeBlock).data(), returnAddress.value());
    12951295    byValInfo->stubInfo = gen.stubInfo();
    12961296
    12971297    MacroAssembler::repatchJump(byValInfo->notIndexJump, CodeLocationLabel(byValInfo->stubRoutine->code().code()));
    1298     MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationGetByValGeneric, SlowPathPtrTag));
     1298    MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(operationGetByValGeneric, GetPropertyPtrTag));
    12991299}
    13001300
    … …  
    13391339    patchBuffer.link(done, byValInfo->badTypeJump.labelAtOffset(byValInfo->badTypeJumpToDone));
    13401340    if (needsLinkForWriteBarrier) {
    1341         ASSERT(m_calls.last().callee.executableAddress() == operationWriteBarrierSlowPath);
    1342         patchBuffer.link(m_calls.last().from, FunctionPtr(operationWriteBarrierSlowPath, SlowPathPtrTag));
     1341        ASSERT(removeCodePtrTag(m_calls.last().callee.executableAddress()) == removeCodePtrTag(operationWriteBarrierSlowPath));
     1342        patchBuffer.link(m_calls.last().from, m_calls.last().callee);
    13431343    }
    13441344   
    … …  
    13461346    if (!isDirect) {
    13471347        byValInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
    1348             m_codeBlock, patchBuffer, NoPtrTag,
     1348            m_codeBlock, patchBuffer, NearJumpPtrTag,
    13491349            "Baseline put_by_val stub for %s, return point %p", toCString(*m_codeBlock).data(), returnAddress.value());
    13501350       
    13511351    } else {
    13521352        byValInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
    1353             m_codeBlock, patchBuffer, NoPtrTag,
     1353            m_codeBlock, patchBuffer, NearJumpPtrTag,
    13541354            "Baseline put_by_val_direct stub for %s, return point %p", toCString(*m_codeBlock).data(), returnAddress.value());
    13551355    }
    13561356    MacroAssembler::repatchJump(byValInfo->badTypeJump, CodeLocationLabel(byValInfo->stubRoutine->code().code()));
    1357     MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(isDirect ? operationDirectPutByValGeneric : operationPutByValGeneric, SlowPathPtrTag));
     1357    MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(isDirect ? operationDirectPutByValGeneric : operationPutByValGeneric, PutPropertyPtrTag));
    13581358}
    13591359
    … …  
    13811381
    13821382    byValInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
    1383         m_codeBlock, patchBuffer, NoPtrTag,
     1383        m_codeBlock, patchBuffer, NearJumpPtrTag,
    13841384        "Baseline put_by_val%s with cached property name '%s' stub for %s, return point %p", (putKind == Direct) ? "_direct" : "", propertyName.impl()->utf8().data(), toCString(*m_codeBlock).data(), returnAddress.value());
    13851385    byValInfo->stubInfo = gen.stubInfo();
    13861386
    13871387    MacroAssembler::repatchJump(byValInfo->notIndexJump, CodeLocationLabel(byValInfo->stubRoutine->code().code()));
    1388     MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(putKind == Direct ? operationDirectPutByValGeneric : operationPutByValGeneric, SlowPathPtrTag));
     1388    MacroAssembler::repatchCall(CodeLocationCall(MacroAssemblerCodePtr(returnAddress)), FunctionPtr(putKind == Direct ? operationDirectPutByValGeneric : operationPutByValGeneric, PutPropertyPtrTag));
    13891389}
    13901390

  • trunk/Source/JavaScriptCore/jit/JITThunks.cpp

    r229547 r230129  
    125125    if (generator) {
    126126        MacroAssemblerCodeRef entry = generator(vm);
    127         forCall = adoptRef(new DirectJITCode(entry, entry.code(), JITCode::HostCallThunk));
     127        forCall = adoptRef(new DirectJITCode(entry, entry.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag), JITCode::HostCallThunk));
    128128    } else
    129129        forCall = adoptRef(new NativeJITCode(MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeCall(vm)), JITCode::HostCallThunk));

  • trunk/Source/JavaScriptCore/jit/Repatch.cpp

    r229856 r230129  
    194194                    bool generatedCodeInline = InlineAccess::generateArrayLength(stubInfo, jsCast<JSArray*>(baseCell));
    195195                    if (generatedCodeInline) {
    196                         ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), appropriateOptimizingGetByIdFunction(kind));
     196                        ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), FunctionPtr(appropriateOptimizingGetByIdFunction(kind), GetPropertyPtrTag));
    197197                        stubInfo.initArrayLength();
    198198                        return RetryCacheLater;
    … …  
    251251                    LOG_IC((ICEvent::GetByIdSelfPatch, structure->classInfo(), propertyName));
    252252                    structure->startWatchingPropertyForReplacements(vm, slot.cachedOffset());
    253                     ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), appropriateOptimizingGetByIdFunction(kind));
     253                    ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), FunctionPtr(appropriateOptimizingGetByIdFunction(kind), GetPropertyPtrTag));
    254254                    stubInfo.initGetByIdSelf(codeBlock, structure, slot.cachedOffset());
    255255                    return RetryCacheLater;
    … …  
    369369    SuperSamplerScope superSamplerScope(false);
    370370   
    371     if (tryCacheGetByID(exec, baseValue, propertyName, slot, stubInfo, kind) == GiveUpOnCache)
    372         ftlThunkAwareRepatchCall(exec->codeBlock(), stubInfo.slowPathCallLocation(), appropriateGenericGetByIdFunction(kind));
     371    if (tryCacheGetByID(exec, baseValue, propertyName, slot, stubInfo, kind) == GiveUpOnCache) {
     372        CodeBlock* codeBlock = exec->codeBlock();
     373        ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), FunctionPtr(appropriateGenericGetByIdFunction(kind), GetPropertyPtrTag));
     374    }
    373375}
    374376
    … …  
    387389static V_JITOperation_ESsiJJI appropriateOptimizingPutByIdFunction(const PutPropertySlot &slot, PutKind putKind)
    388390{
    389     auto pickSlowPath = [&] () -> V_JITOperation_ESsiJJI {
    390         if (slot.isStrictMode()) {
    391             if (putKind == Direct)
    392                 return operationPutByIdDirectStrictOptimize;
    393             return operationPutByIdStrictOptimize;
    394         }
     391    if (slot.isStrictMode()) {
    395392        if (putKind == Direct)
    396             return operationPutByIdDirectNonStrictOptimize;
    397         return operationPutByIdNonStrictOptimize;
    398     };
    399     return tagCFunctionPtr(pickSlowPath(), SlowPathPtrTag);
     393            return operationPutByIdDirectStrictOptimize;
     394        return operationPutByIdStrictOptimize;
     395    }
     396    if (putKind == Direct)
     397        return operationPutByIdDirectNonStrictOptimize;
     398    return operationPutByIdNonStrictOptimize;
    400399}
    401400
    … …  
    444443                    if (generatedCodeInline) {
    445444                        LOG_IC((ICEvent::PutByIdSelfPatch, structure->classInfo(), ident));
    446                         ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), appropriateOptimizingPutByIdFunction(slot, putKind));
     445                        ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), FunctionPtr(appropriateOptimizingPutByIdFunction(slot, putKind), PutPropertyPtrTag));
    447446                        stubInfo.initPutByIdReplace(codeBlock, structure, slot.cachedOffset());
    448447                        return RetryCacheLater;
    … …  
    576575    SuperSamplerScope superSamplerScope(false);
    577576   
    578     if (tryCachePutByID(exec, baseValue, structure, propertyName, slot, stubInfo, putKind) == GiveUpOnCache)
    579         ftlThunkAwareRepatchCall(exec->codeBlock(), stubInfo.slowPathCallLocation(), appropriateGenericPutByIdFunction(slot, putKind));
     577    if (tryCachePutByID(exec, baseValue, structure, propertyName, slot, stubInfo, putKind) == GiveUpOnCache) {
     578        CodeBlock* codeBlock = exec->codeBlock();
     579        ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), FunctionPtr(appropriateGenericPutByIdFunction(slot, putKind), PutPropertyPtrTag));
     580    }
    580581}
    581582
    … …  
    699700void linkFor(
    700701    ExecState* exec, CallLinkInfo& callLinkInfo, CodeBlock* calleeCodeBlock,
    701     JSObject* callee, MacroAssemblerCodePtr codePtr)
     702    JSObject* callee, MacroAssemblerCodePtr codePtr, PtrTag codeTag)
    702703{
    703704    ASSERT(!callLinkInfo.stub());
    … …  
    721722        dataLog("Linking call in ", FullCodeOrigin(callerCodeBlock, callLinkInfo.codeOrigin()), " to ", pointerDump(calleeCodeBlock), ", entrypoint at ", codePtr, "\n");
    722723
    723     MacroAssembler::repatchNearCall(callLinkInfo.hotPathOther(), CodeLocationLabel(codePtr));
     724    MacroAssembler::repatchNearCall(callLinkInfo.hotPathOther(), CodeLocationLabel(codePtr.retagged(codeTag, NearCallPtrTag)));
    724725
    725726    if (calleeCodeBlock)
    … …  
    768769static void revertCall(VM* vm, CallLinkInfo& callLinkInfo, MacroAssemblerCodeRef codeRef)
    769770{
     771    assertIsTaggedWith(codeRef.code().executableAddress(), NearCallPtrTag);
    770772    if (callLinkInfo.isDirect()) {
    771773        callLinkInfo.clearCodeBlock();
    … …  
    10861088    auto stubRoutine = adoptRef(*new PolymorphicCallStubRoutine(
    10871089        FINALIZE_CODE_FOR(
    1088             callerCodeBlock, patchBuffer, NoPtrTag,
     1090            callerCodeBlock, patchBuffer, NearJumpPtrTag,
    10891091            "Polymorphic call stub for %s, return point %p, targets %s",
    10901092                isWebAssembly ? "WebAssembly" : toCString(*callerCodeBlock).data(), callLinkInfo.callReturnLocation().labelAtOffset(0).executableAddress(),
    … …  
    11131115void resetGetByID(CodeBlock* codeBlock, StructureStubInfo& stubInfo, GetByIDKind kind)
    11141116{
    1115     ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), appropriateOptimizingGetByIdFunction(kind));
     1117    ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), FunctionPtr(appropriateOptimizingGetByIdFunction(kind), GetPropertyPtrTag));
    11161118    InlineAccess::rewireStubAsJump(stubInfo, stubInfo.slowPathStartLocation());
    11171119}
    … …  
    11191121void resetPutByID(CodeBlock* codeBlock, StructureStubInfo& stubInfo)
    11201122{
    1121     V_JITOperation_ESsiJJI unoptimizedFunction = bitwise_cast<V_JITOperation_ESsiJJI>(readCallTarget(codeBlock, stubInfo.slowPathCallLocation()).executableAddress());
     1123    V_JITOperation_ESsiJJI unoptimizedFunction = untagCFunctionPtr<V_JITOperation_ESsiJJI>(readCallTarget(codeBlock, stubInfo.slowPathCallLocation()).executableAddress(), PutPropertyPtrTag);
    11221124    V_JITOperation_ESsiJJI optimizedFunction;
    11231125    if (unoptimizedFunction == operationPutByIdStrict || unoptimizedFunction == operationPutByIdStrictOptimize)
    … …  
    11321134    }
    11331135
    1134     ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), tagCFunctionPtr(optimizedFunction, SlowPathPtrTag));
     1136    ftlThunkAwareRepatchCall(codeBlock, stubInfo.slowPathCallLocation(), FunctionPtr(optimizedFunction, PutPropertyPtrTag));
    11351137    InlineAccess::rewireStubAsJump(stubInfo, stubInfo.slowPathStartLocation());
    11361138}

  • trunk/Source/JavaScriptCore/jit/Repatch.h

    r224487 r230129  
    11/*
    2  * Copyright (C) 2011, 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    4545void buildPutByIdList(ExecState*, JSValue, Structure*, const Identifier&, const PutPropertySlot&, StructureStubInfo&, PutKind);
    4646void repatchIn(ExecState*, JSCell*, const Identifier&, bool wasFound, const PropertySlot&, StructureStubInfo&);
    47 void linkFor(ExecState*, CallLinkInfo&, CodeBlock*, JSObject* callee, MacroAssemblerCodePtr);
     47void linkFor(ExecState*, CallLinkInfo&, CodeBlock*, JSObject* callee, MacroAssemblerCodePtr, PtrTag);
    4848void linkDirectFor(ExecState*, CallLinkInfo&, CodeBlock*, MacroAssemblerCodePtr);
    4949void linkSlowFor(ExecState*, CallLinkInfo&);

  • trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h

    r229609 r230129  
    171171            for (unsigned i = 0; i < m_calls.size(); i++)
    172172                patchBuffer.link(m_calls[i].first, m_calls[i].second);
    173             return FINALIZE_CODE(patchBuffer, NoPtrTag, "Specialized thunk for %s", thunkKind);
     173            return FINALIZE_CODE(patchBuffer, CodeEntryPtrTag, "Specialized thunk for %s", thunkKind);
    174174        }
    175175
    … …  
    178178        void callDoubleToDouble(FunctionPtr function)
    179179        {
    180             m_calls.append(std::make_pair(call(SlowPathPtrTag), function));
     180            assertIsCFunctionPtr(function.executableAddress());
     181            PtrTag tag = ptrTag(SpecializedThunkPtrTag, nextPtrTagID());
     182            m_calls.append(std::make_pair(call(tag), FunctionPtr(function, tag)));
    181183        }
    182184       

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r229767 r230129  
    4545namespace JSC {
    4646
    47 inline void emitPointerValidation(CCallHelpers& jit, GPRReg pointerGPR)
     47template<typename TagType>
     48inline void emitPointerValidation(CCallHelpers& jit, GPRReg pointerGPR, TagType tag)
    4849{
    4950    if (ASSERT_DISABLED)
    … …  
    5354    isNonZero.link(&jit);
    5455    jit.pushToSave(pointerGPR);
     56    jit.untagPtr(pointerGPR, tag);
    5557    jit.load8(pointerGPR, pointerGPR);
    5658    jit.popToRestore(pointerGPR);
    … …  
    6971    jit.copyCalleeSavesToEntryFrameCalleeSavesBuffer(vm->topEntryFrame);
    7072
     73    PtrTag callTag = ptrTag(JITThunkPtrTag, nextPtrTagID());
    7174    jit.setupArguments<decltype(lookupExceptionHandler)>(CCallHelpers::TrustedImmPtr(vm), GPRInfo::callFrameRegister);
    72     jit.move(CCallHelpers::TrustedImmPtr(bitwise_cast<void*>(lookupExceptionHandler)), GPRInfo::nonArgGPR0);
    73     emitPointerValidation(jit, GPRInfo::nonArgGPR0);
    74     jit.call(GPRInfo::nonArgGPR0, NoPtrTag);
     75    jit.move(CCallHelpers::TrustedImmPtr(tagCFunctionPtr(lookupExceptionHandler, callTag)), GPRInfo::nonArgGPR0);
     76    emitPointerValidation(jit, GPRInfo::nonArgGPR0, callTag);
     77    jit.call(GPRInfo::nonArgGPR0, callTag);
    7578    jit.jumpToExceptionHandler(*vm);
    7679
     80    PtrTag thunkTag = ptrTag(JITThunkPtrTag, vm, throwExceptionFromCallSlowPathGenerator);
    7781    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    78     return FINALIZE_CODE(patchBuffer, NoPtrTag, "Throw exception from call slow path thunk");
     82    return FINALIZE_CODE(patchBuffer, thunkTag, "Throw exception from call slow path thunk");
    7983}
    8084
    8185static void slowPathFor(
    82     CCallHelpers& jit, VM* vm, Sprt_JITOperation_ECli slowPathFunction)
    83 {
     86    CCallHelpers& jit, VM* vm, Sprt_JITOperation_ECli slowPathFunction, PtrTag expectedLinkedTargetTag)
     87{
     88    PtrTag callTag = ptrTag(JITThunkPtrTag, nextPtrTagID());
     89
    8490    jit.sanitizeStackInline(*vm, GPRInfo::nonArgGPR0);
    8591    jit.emitFunctionPrologue();
    … …  
    94100    jit.addPtr(CCallHelpers::TrustedImm32(32), CCallHelpers::stackPointerRegister, GPRInfo::argumentGPR0);
    95101    jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR1);
    96     jit.move(CCallHelpers::TrustedImmPtr(bitwise_cast<void*>(slowPathFunction)), GPRInfo::nonArgGPR0);
    97     emitPointerValidation(jit, GPRInfo::nonArgGPR0);
    98     jit.call(GPRInfo::nonArgGPR0, NoPtrTag);
     102    jit.move(CCallHelpers::TrustedImmPtr(tagCFunctionPtr(slowPathFunction, callTag)), GPRInfo::nonArgGPR0);
     103    emitPointerValidation(jit, GPRInfo::nonArgGPR0, callTag);
     104    jit.call(GPRInfo::nonArgGPR0, callTag);
    99105    jit.loadPtr(CCallHelpers::Address(GPRInfo::returnValueGPR, 8), GPRInfo::returnValueGPR2);
    100106    jit.loadPtr(CCallHelpers::Address(GPRInfo::returnValueGPR), GPRInfo::returnValueGPR);
    … …  
    104110        jit.addPtr(CCallHelpers::TrustedImm32(-maxFrameExtentForSlowPathCall), CCallHelpers::stackPointerRegister);
    105111    jit.setupArguments<decltype(slowPathFunction)>(GPRInfo::regT2);
    106     jit.move(CCallHelpers::TrustedImmPtr(bitwise_cast<void*>(slowPathFunction)), GPRInfo::nonArgGPR0);
    107     emitPointerValidation(jit, GPRInfo::nonArgGPR0);
    108     jit.call(GPRInfo::nonArgGPR0, NoPtrTag);
     112    jit.move(CCallHelpers::TrustedImmPtr(tagCFunctionPtr(slowPathFunction, callTag)), GPRInfo::nonArgGPR0);
     113    emitPointerValidation(jit, GPRInfo::nonArgGPR0, callTag);
     114    jit.call(GPRInfo::nonArgGPR0, callTag);
    109115    if (maxFrameExtentForSlowPathCall)
    110116        jit.addPtr(CCallHelpers::TrustedImm32(maxFrameExtentForSlowPathCall), CCallHelpers::stackPointerRegister);
    … …  
    117123    // The second return value GPR will hold a non-zero value for tail calls.
    118124
    119     emitPointerValidation(jit, GPRInfo::returnValueGPR);
     125    emitPointerValidation(jit, GPRInfo::returnValueGPR, expectedLinkedTargetTag);
    120126    jit.emitFunctionEpilogue();
     127    jit.untagReturnAddress();
    121128
    122129    RELEASE_ASSERT(reinterpret_cast<void*>(KeepTheFrame) == reinterpret_cast<void*>(0));
    … …  
    127134
    128135    doNotTrash.link(&jit);
    129     jit.jump(GPRInfo::returnValueGPR, NoPtrTag);
     136    jit.jump(GPRInfo::returnValueGPR, expectedLinkedTargetTag);
    130137}
    131138
    … …  
    138145    // been adjusted, and all other registers to be available for use.
    139146    CCallHelpers jit;
    140    
    141     slowPathFor(jit, vm, operationLinkCall);
    142    
     147
     148    PtrTag expectedLinkedTargetTag = ptrTag(OperationLinkCallPtrTag, vm);
     149    slowPathFor(jit, vm, operationLinkCall, expectedLinkedTargetTag);
     150
    143151    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    144     return FINALIZE_CODE(patchBuffer, NoPtrTag, "Link call slow path thunk");
     152    return FINALIZE_CODE(patchBuffer, NearCallPtrTag, "Link call slow path thunk");
    145153}
    146154
    … …  
    150158{
    151159    CCallHelpers jit;
    152    
    153     slowPathFor(jit, vm, operationLinkPolymorphicCall);
    154    
     160
     161    PtrTag expectedLinkedTargetTag = ptrTag(OperationLinkPolymorphicCallPtrTag, vm);
     162    slowPathFor(jit, vm, operationLinkPolymorphicCall, expectedLinkedTargetTag);
     163
    155164    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    156     return FINALIZE_CODE(patchBuffer, NoPtrTag, "Link polymorphic call slow path thunk");
     165    return FINALIZE_CODE(patchBuffer, NearCallPtrTag, "Link polymorphic call slow path thunk");
    157166}
    158167
    … …  
    201210   
    202211    // Now we know we have a JSFunction.
    203    
     212
    204213    jit.loadPtr(
    205214        CCallHelpers::Address(GPRInfo::regT0, JSFunction::offsetOfExecutable()),
    … …  
    222231    // Make a tail call. This will return back to JIT code.
    223232    JSInterfaceJIT::Label callCode(jit.label());
    224     emitPointerValidation(jit, GPRInfo::regT4);
     233    emitPointerValidation(jit, GPRInfo::regT4, CodeEntryWithArityCheckPtrTag);
    225234    if (callLinkInfo.isTailCall()) {
    226235        jit.preserveReturnAddressAfterCall(GPRInfo::regT0);
    227236        jit.prepareForTailCallSlow(GPRInfo::regT4);
    228237    }
    229     jit.jump(GPRInfo::regT4, NoPtrTag);
     238    jit.jump(GPRInfo::regT4, CodeEntryWithArityCheckPtrTag);
    230239
    231240    notJSFunction.link(&jit);
    232241    slowCase.append(jit.branchIfNotType(GPRInfo::regT0, InternalFunctionType));
    233     jit.move(CCallHelpers::TrustedImmPtr(vm->getCTIInternalFunctionTrampolineFor(callLinkInfo.specializationKind()).executableAddress()), GPRInfo::regT4);
     242    void* executableAddress = vm->getCTIInternalFunctionTrampolineFor(callLinkInfo.specializationKind()).retagged(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag).executableAddress();
     243    jit.move(CCallHelpers::TrustedImmPtr(executableAddress), GPRInfo::regT4);
    234244    jit.jump().linkTo(callCode, &jit);
    235245
    … …  
    237247   
    238248    // Here we don't know anything, so revert to the full slow path.
    239     slowPathFor(jit, vm, operationVirtualCall);
     249    PtrTag expectedLinkedTargetTag = ptrTag(OperationVirtualCallPtrTag, vm);
     250    slowPathFor(jit, vm, operationVirtualCall, expectedLinkedTargetTag);
    240251
    241252    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    242253    return FINALIZE_CODE(
    243         patchBuffer, NoPtrTag,
     254        patchBuffer, NearCallPtrTag,
    244255        "Virtual %s slow path thunk",
    245256        callLinkInfo.callMode() == CallMode::Regular ? "call" : callLinkInfo.callMode() == CallMode::Tail ? "tail call" : "construct");
    … …  
    294305        jit.loadPtr(JSInterfaceJIT::Address(JSInterfaceJIT::regT1, JSFunction::offsetOfExecutable()), JSInterfaceJIT::regT1);
    295306        jit.xorPtr(JSInterfaceJIT::TrustedImmPtr(JSFunctionPoison::key()), JSInterfaceJIT::regT1);
    296         jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT1, executableOffsetToFunction), NoPtrTag);
     307        jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT1, executableOffsetToFunction), CodeEntryPtrTag);
    297308    } else
    298         jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT1, InternalFunction::offsetOfNativeFunctionFor(kind)), NoPtrTag);
     309        jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT1, InternalFunction::offsetOfNativeFunctionFor(kind)), CodeEntryPtrTag);
    299310
    300311    jit.addPtr(JSInterfaceJIT::TrustedImm32(8), JSInterfaceJIT::stackPointerRegister);
    … …  
    315326    jit.move(JSInterfaceJIT::TrustedImm64(NativeCodePoison::key()), X86Registers::esi);
    316327    jit.xor64(X86Registers::esi, X86Registers::r9);
    317     jit.call(X86Registers::r9, NoPtrTag);
     328    jit.call(X86Registers::r9, CodeEntryPtrTag);
    318329
    319330#else
    … …  
    330341        jit.loadPtr(JSInterfaceJIT::Address(X86Registers::edx, JSFunction::offsetOfExecutable()), X86Registers::r9);
    331342        jit.xorPtr(JSInterfaceJIT::TrustedImmPtr(JSFunctionPoison::key()), X86Registers::r9);
    332         jit.call(JSInterfaceJIT::Address(X86Registers::r9, executableOffsetToFunction), NoPtrTag);
     343        jit.call(JSInterfaceJIT::Address(X86Registers::r9, executableOffsetToFunction), CodeEntryPtrTag);
    333344    } else
    334         jit.call(JSInterfaceJIT::Address(X86Registers::edx, InternalFunction::offsetOfNativeFunctionFor(kind)), NoPtrTag);
     345        jit.call(JSInterfaceJIT::Address(X86Registers::edx, InternalFunction::offsetOfNativeFunctionFor(kind)), CodeEntryPtrTag);
    335346
    336347    jit.addPtr(JSInterfaceJIT::TrustedImm32(4 * sizeof(int64_t)), JSInterfaceJIT::stackPointerRegister);
    … …  
    354365    jit.move(JSInterfaceJIT::TrustedImm64(NativeCodePoison::key()), ARM64Registers::x1);
    355366    jit.xor64(ARM64Registers::x1, ARM64Registers::x2);
    356     jit.call(ARM64Registers::x2, NoPtrTag);
     367    jit.call(ARM64Registers::x2, CodeEntryPtrTag);
    357368
    358369#elif CPU(ARM) || CPU(MIPS)
    … …  
    370381        jit.loadPtr(JSInterfaceJIT::Address(JSInterfaceJIT::argumentGPR1, JSFunction::offsetOfExecutable()), JSInterfaceJIT::regT2);
    371382        jit.xorPtr(JSInterfaceJIT::TrustedImmPtr(JSFunctionPoison::key()), JSInterfaceJIT::regT2);
    372         jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT2, executableOffsetToFunction), NoPtrTag);
     383        jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT2, executableOffsetToFunction), CodeEntryPtrTag);
    373384    } else
    374         jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::argumentGPR1, InternalFunction::offsetOfNativeFunctionFor(kind)), NoPtrTag);
     385        jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::argumentGPR1, InternalFunction::offsetOfNativeFunctionFor(kind)), CodeEntryPtrTag);
    375386
    376387#if CPU(MIPS)
    … …  
    428439
    429440    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    430     return FINALIZE_CODE(patchBuffer, NoPtrTag, "%s %s%s trampoline", thunkFunctionType == ThunkFunctionType::JSFunction ? "native" : "internal", entryType == EnterViaJumpWithSavedTags ? "Tail With Saved Tags " : entryType == EnterViaJumpWithoutSavedTags ? "Tail Without Saved Tags " : "", toCString(kind).data());
     441    return FINALIZE_CODE(patchBuffer, CodeEntryPtrTag, "%s %s%s trampoline", thunkFunctionType == ThunkFunctionType::JSFunction ? "native" : "internal", entryType == EnterViaJumpWithSavedTags ? "Tail With Saved Tags " : entryType == EnterViaJumpWithoutSavedTags ? "Tail Without Saved Tags " : "", toCString(kind).data());
    431442}
    432443
    … …  
    476487    jit.pop(JSInterfaceJIT::regT4);
    477488#  endif
     489    jit.tagReturnAddress();
    478490    jit.move(JSInterfaceJIT::callFrameRegister, JSInterfaceJIT::regT3);
    479491    jit.load32(JSInterfaceJIT::Address(JSInterfaceJIT::callFrameRegister, CallFrameSlot::argumentCount * sizeof(Register)), JSInterfaceJIT::argumentGPR2);
    … …  
    502514    jit.lshift64(JSInterfaceJIT::TrustedImm32(3), extraTemp);
    503515    jit.addPtr(extraTemp, JSInterfaceJIT::callFrameRegister);
     516    jit.untagReturnAddress();
    504517    jit.addPtr(extraTemp, JSInterfaceJIT::stackPointerRegister);
     518    jit.tagReturnAddress();
    505519
    506520    // Move current frame down argumentGPR0 number of slots
    … …  
    525539#  endif
    526540    jit.ret();
    527 #else
     541#else // USE(JSVALUE64) section above, USE(JSVALUE32_64) section below.
    528542#  if CPU(X86)
    529543    jit.pop(JSInterfaceJIT::regT4);
    … …  
    582596#  endif
    583597    jit.ret();
    584 #endif
     598#endif // End of USE(JSVALUE32_64) section.
    585599
    586600    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    587     return FINALIZE_CODE(patchBuffer, NoPtrTag, "fixup arity");
     601    PtrTag tag = ptrTag(JITThunkPtrTag, vm);
     602    return FINALIZE_CODE(patchBuffer, tag, "fixup arity");
    588603}
    589604
    … …  
    595610
    596611    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
    597     return FINALIZE_CODE(patchBuffer, NoPtrTag, "unreachable thunk");
     612    return FINALIZE_CODE(patchBuffer, NearCallPtrTag, "unreachable thunk");
    598613}
    599614
    … …  
    11821197    jit.xor64(GPRInfo::regT1, GPRInfo::regT0);
    11831198#endif
    1184     emitPointerValidation(jit, GPRInfo::regT0);
    1185     jit.call(GPRInfo::regT0, NoPtrTag);
    1186    
     1199    emitPointerValidation(jit, GPRInfo::regT0, CodeEntryWithArityCheckPtrTag);
     1200    jit.call(GPRInfo::regT0, CodeEntryWithArityCheckPtrTag);
     1201
    11871202    jit.emitFunctionEpilogue();
    11881203    jit.ret();
    … …  
    11911206    linkBuffer.link(noCode, CodeLocationLabel(vm->jitStubs->ctiNativeTailCallWithoutSavedTags(vm)));
    11921207    return FINALIZE_CODE(
    1193         linkBuffer, NoPtrTag, "Specialized thunk for bound function calls with no arguments");
     1208        linkBuffer, CodeEntryPtrTag, "Specialized thunk for bound function calls with no arguments");
    11941209}
    11951210

  • trunk/Source/JavaScriptCore/llint/LLIntData.cpp

    r229547 r230129  
    6464    }
    6565
    66     if (VM::canUseJIT()) {
    67         for (int i = NUMBER_OF_BYTECODE_IDS; i < NUMBER_OF_BYTECODE_IDS + NUMBER_OF_BYTECODE_HELPER_IDS; ++i)
    68             Data::s_opcodeMap[i] = tagCodePtr(Data::s_opcodeMap[i], ptrTag(BytecodeHelperPtrTag, i));
    69     } else {
    70         static const PtrTag tagsForOpcode[] = {
    71             CodeEntryPtrTag, // llint_program_prologue
    72             CodeEntryPtrTag, // llint_eval_prologue
    73             CodeEntryPtrTag, // llint_module_program_prologue
    74             CodeEntryPtrTag, // llint_function_for_call_prologue
    75             CodeEntryPtrTag, // llint_function_for_construct_prologue
    76             CodeEntryWithArityCheckPtrTag, // llint_function_for_call_arity_check
    77             CodeEntryWithArityCheckPtrTag, // llint_function_for_construct_arity_check
    78             CodeEntryPtrTag, // llint_generic_return_point
    79             BytecodePtrTag, // llint_throw_from_slow_path_trampoline
    80             ExceptionHandlerPtrTag, // llint_throw_during_call_trampoline
    81             NativeCodePtrTag, // llint_native_call_trampoline
    82             NativeCodePtrTag, // llint_native_construct_trampoline
    83             NativeCodePtrTag, // llint_internal_function_call_trampoline
    84             NativeCodePtrTag, // llint_internal_function_construct_trampoline
    85             ExceptionHandlerPtrTag, // handleUncaughtException
    86         };
    87 
    88         static_assert(sizeof(tagsForOpcode) / sizeof(tagsForOpcode[0]) == NUMBER_OF_BYTECODE_HELPER_IDS, "");
    89         static_assert(static_cast<uintptr_t>(llint_program_prologue) == NUMBER_OF_BYTECODE_IDS, "");
    90 
    91         for (int i = 0; i < NUMBER_OF_BYTECODE_HELPER_IDS; ++i) {
    92             int opcodeID = i + NUMBER_OF_BYTECODE_IDS;
    93             Data::s_opcodeMap[opcodeID] = tagCodePtr(Data::s_opcodeMap[opcodeID], tagsForOpcode[i]);
    94         }
     66    static const PtrTag tagsForOpcode[] = {
     67        CodeEntryPtrTag, // llint_program_prologue
     68        CodeEntryPtrTag, // llint_eval_prologue
     69        CodeEntryPtrTag, // llint_module_program_prologue
     70        CodeEntryPtrTag, // llint_function_for_call_prologue
     71        CodeEntryPtrTag, // llint_function_for_construct_prologue
     72        CodeEntryWithArityCheckPtrTag, // llint_function_for_call_arity_check
     73        CodeEntryWithArityCheckPtrTag, // llint_function_for_construct_arity_check
     74        CodeEntryPtrTag, // llint_generic_return_point
     75        BytecodePtrTag, // llint_throw_from_slow_path_trampoline
     76        ExceptionHandlerPtrTag, // llint_throw_during_call_trampoline
     77        CodeEntryPtrTag, // llint_native_call_trampoline
     78        CodeEntryPtrTag, // llint_native_construct_trampoline
     79        CodeEntryPtrTag, // llint_internal_function_call_trampoline
     80        CodeEntryPtrTag, // llint_internal_function_construct_trampoline
     81        ExceptionHandlerPtrTag, // handleUncaughtException
     82    };
     83
     84    static_assert(sizeof(tagsForOpcode) / sizeof(tagsForOpcode[0]) == NUMBER_OF_BYTECODE_HELPER_IDS, "");
     85    static_assert(static_cast<uintptr_t>(llint_program_prologue) == NUMBER_OF_BYTECODE_IDS, "");
     86
     87    for (int i = 0; i < NUMBER_OF_BYTECODE_HELPER_IDS; ++i) {
     88        int opcodeID = i + NUMBER_OF_BYTECODE_IDS;
     89        Data::s_opcodeMap[opcodeID] = tagCodePtr(Data::s_opcodeMap[opcodeID], tagsForOpcode[i]);
    9590    }
    9691

  • trunk/Source/JavaScriptCore/llint/LLIntData.h

    r229481 r230129  
    8686
    8787#if ENABLE(JIT)
     88
    8889ALWAYS_INLINE LLIntCode getCodeFunctionPtr(OpcodeID codeId)
    8990{
    … …  
    9495ALWAYS_INLINE void* getCodePtr(JSC::EncodedJSValue glueHelper())
    9596{
    96     return WTF_PREPARE_FUNCTION_POINTER_FOR_EXECUTION(glueHelper);
     97    return bitwise_cast<void*>(glueHelper);
    9798}
    9899

  • trunk/Source/JavaScriptCore/llint/LLIntEntrypoint.cpp

    r226011 r230129  
    11/*
    2  * Copyright (C) 2012, 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    7272#if ENABLE(JIT)
    7373    if (VM::canUseJIT()) {
     74        MacroAssemblerCodeRef codeRef = vm.getCTIStub(evalEntryThunkGenerator);
    7475        codeBlock->setJITCode(
    75             adoptRef(*new DirectJITCode(vm.getCTIStub(evalEntryThunkGenerator), MacroAssemblerCodePtr(), JITCode::InterpreterThunk)));
     76            adoptRef(*new DirectJITCode(codeRef, codeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag), JITCode::InterpreterThunk)));
    7677        return;
    7778    }
    … …  
    7980
    8081    UNUSED_PARAM(vm);
     82    MacroAssemblerCodeRef codeRef = MacroAssemblerCodeRef::createLLIntCodeRef(llint_eval_prologue);
    8183    codeBlock->setJITCode(
    82         adoptRef(*new DirectJITCode(MacroAssemblerCodeRef::createLLIntCodeRef(llint_eval_prologue), MacroAssemblerCodePtr(), JITCode::InterpreterThunk)));
     84        adoptRef(*new DirectJITCode(codeRef, codeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag), JITCode::InterpreterThunk)));
    8385}
    8486
    … …  
    8789#if ENABLE(JIT)
    8890    if (VM::canUseJIT()) {
     91        MacroAssemblerCodeRef codeRef = vm.getCTIStub(programEntryThunkGenerator);
    8992        codeBlock->setJITCode(
    90             adoptRef(*new DirectJITCode(vm.getCTIStub(programEntryThunkGenerator), MacroAssemblerCodePtr(), JITCode::InterpreterThunk)));
     93            adoptRef(*new DirectJITCode(codeRef, codeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag), JITCode::InterpreterThunk)));
    9194        return;
    9295    }
    … …  
    9497
    9598    UNUSED_PARAM(vm);
     99    MacroAssemblerCodeRef codeRef = MacroAssemblerCodeRef::createLLIntCodeRef(llint_program_prologue);
    96100    codeBlock->setJITCode(
    97         adoptRef(*new DirectJITCode(MacroAssemblerCodeRef::createLLIntCodeRef(llint_program_prologue), MacroAssemblerCodePtr(), JITCode::InterpreterThunk)));
     101        adoptRef(*new DirectJITCode(codeRef, codeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag), JITCode::InterpreterThunk)));
    98102}
    99103
    … …  
    102106#if ENABLE(JIT)
    103107    if (VM::canUseJIT()) {
     108        MacroAssemblerCodeRef codeRef = vm.getCTIStub(moduleProgramEntryThunkGenerator);
    104109        codeBlock->setJITCode(
    105             adoptRef(*new DirectJITCode(vm.getCTIStub(moduleProgramEntryThunkGenerator), MacroAssemblerCodePtr(), JITCode::InterpreterThunk)));
     110            adoptRef(*new DirectJITCode(codeRef, codeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag), JITCode::InterpreterThunk)));
    106111        return;
    107112    }
    … …  
    109114
    110115    UNUSED_PARAM(vm);
     116    MacroAssemblerCodeRef codeRef = MacroAssemblerCodeRef::createLLIntCodeRef(llint_module_program_prologue);
    111117    codeBlock->setJITCode(
    112         adoptRef(*new DirectJITCode(MacroAssemblerCodeRef::createLLIntCodeRef(llint_module_program_prologue), MacroAssemblerCodePtr(), JITCode::InterpreterThunk)));
     118        adoptRef(*new DirectJITCode(codeRef, codeRef.retaggedCode(CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag), JITCode::InterpreterThunk)));
    113119}
    114120

  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r229957 r230129  
    14021402                callLinkInfo->callee.set(vm, callerCodeBlock, internalFunction);
    14031403                callLinkInfo->lastSeenCallee.set(vm, callerCodeBlock, internalFunction);
    1404                 callLinkInfo->machineCodeTarget = codePtr;
    1405                 callLinkInfo->callPtrTag = NativeCodePtrTag;
     1404                callLinkInfo->machineCodeTarget = codePtr.retagged(CodeEntryPtrTag, LLIntCallICPtrTag);
    14061405            }
    14071406
     1407            assertIsTaggedWith(codePtr.executableAddress(), CodeEntryPtrTag);
    14081408            PoisonedMasmPtr::assertIsNotPoisoned(codePtr.executableAddress());
    1409             LLINT_CALL_RETURN(exec, execCallee, codePtr.executableAddress(), NativeCodePtrTag);
     1409            LLINT_CALL_RETURN(exec, execCallee, codePtr.executableAddress(), CodeEntryPtrTag);
    14101410        }
    14111411        throwScope.release();
    … …  
    14211421    if (executable->isHostFunction()) {
    14221422        codePtr = executable->entrypointFor(kind, MustCheckArity);
    1423         callPtrTag = NativeCodePtrTag;
     1423        callPtrTag = CodeEntryWithArityCheckPtrTag;
    14241424    } else {
    14251425        FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
    … …  
    14451445        codePtr = functionExecutable->entrypointFor(kind, arity);
    14461446    }
     1447    assertIsTaggedWith(codePtr.executableAddress(), callPtrTag);
    14471448
    14481449    ASSERT(!!codePtr);
    … …  
    14571458        callLinkInfo->callee.set(vm, callerCodeBlock, callee);
    14581459        callLinkInfo->lastSeenCallee.set(vm, callerCodeBlock, callee);
    1459         callLinkInfo->machineCodeTarget = codePtr;
     1460        callLinkInfo->machineCodeTarget = codePtr.retagged(callPtrTag, LLIntCallICPtrTag);
    14601461        RELEASE_ASSERT(callPtrTag != NoPtrTag);
    1461         callLinkInfo->callPtrTag = callPtrTag;
    14621462        if (codeBlock)
    14631463            codeBlock->linkIncomingCall(exec, callLinkInfo);
    14641464    }
    14651465
     1466    assertIsTaggedWith(codePtr.executableAddress(), callPtrTag);
    14661467    PoisonedMasmPtr::assertIsNotPoisoned(codePtr.executableAddress());
    14671468    LLINT_CALL_RETURN(exec, execCallee, codePtr.executableAddress(), callPtrTag);

  • trunk/Source/JavaScriptCore/llint/LLIntThunks.cpp

    r229609 r230129  
    5959    LLIntCode target = LLInt::getCodeFunctionPtr(opcodeID);
    6060    jit.move(JSInterfaceJIT::TrustedImmPtr(bitwise_cast<void*>(target)), JSInterfaceJIT::regT0);
    61     jit.jump(JSInterfaceJIT::regT0, ptrTag(BytecodeHelperPtrTag, opcodeID));
     61    jit.jump(JSInterfaceJIT::regT0, thunkTag);
    6262
    6363    LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r229957 r230129  
    265265const CodeEntryWithArityCheckPtrTag = constexpr CodeEntryWithArityCheckPtrTag
    266266const ExceptionHandlerPtrTag = constexpr ExceptionHandlerPtrTag
    267 const NativeCodePtrTag = constexpr NativeCodePtrTag
     267const LLIntCallICPtrTag = constexpr LLIntCallICPtrTag
    268268const NoPtrTag = constexpr NoPtrTag
    269269const SlowPathPtrTag = constexpr SlowPathPtrTag
    … …  
    854854end
    855855
    856 macro prepareForRegularCall(callee, temp1, temp2, temp3, prepareCallPtrTag)
     856macro prepareForRegularCall(callee, temp1, temp2, temp3, callPtrTag)
    857857    addp CallerFrameAndPCSize, sp
    858858end
    859859
    860860# sp points to the new frame
    861 macro prepareForTailCall(callee, temp1, temp2, temp3, prepareCallPtrTag)
     861macro prepareForTailCall(callee, temp1, temp2, temp3, callPtrTag)
    862862    restoreCalleeSavesUsedByLLInt()
    863863
    … …  
    908908    btinz temp2, .copyLoop
    909909
    910     prepareCallPtrTag(temp2)
    911910    move temp1, sp
    912     jmp callee, temp2
     911    jmp callee, callPtrTag
    913912end
    914913
    … …  
    920919            btpz calleeFramePtr, .dontUpdateSP
    921920            move calleeFramePtr, sp
    922             prepareCall(callee, t2, t3, t4, macro (callPtrTagReg)
    923                 if POINTER_PROFILING
    924                     move SlowPathPtrTag, callPtrTagReg
    925                 end
    926             end)
     921            prepareCall(callee, t2, t3, t4, SlowPathPtrTag)
    927922        .dontUpdateSP:
    928923            callTargetFunction(callee, SlowPathPtrTag)
    … …  
    10061001# Do the bare minimum required to execute code. Sets up the PC, leave the CodeBlock*
    10071002# in t1. May also trigger prologue entry OSR.
    1008 macro prologue(codeBlockGetter, codeBlockSetter, osrSlowPath, traceSlowPath)
     1003macro prologue(codeBlockGetter, codeBlockSetter, osrSlowPath, traceSlowPath, targetPtrTag)
    10091004    # Set up the call frame and check if we should OSR.
    10101005    tagReturnAddress sp
    … …  
    10371032        if ARM64 or ARM64E
    10381033            pop lr, cfr
     1034            untagReturnAddress sp
    10391035        elsif ARM or ARMv7 or ARMv7_TRADITIONAL or MIPS
    10401036            pop cfr
    … …  
    10431039            pop cfr
    10441040        end
    1045         jmp r0, CodeEntryPtrTag
     1041        jmp r0, targetPtrTag
    10461042    .recover:
    10471043        codeBlockGetter(t1, t2)
    … …  
    11611157    _vmEntryToJavaScript:
    11621158end
    1163     doVMEntry(makeJavaScriptCall, CodeEntryPtrTag, CodeEntryWithArityCheckPtrTag)
     1159    doVMEntry(makeJavaScriptCall)
    11641160
    11651161
    … …  
    11701166    _vmEntryToNative:
    11711167end
    1172     doVMEntry(makeHostFunctionCall, NativeCodePtrTag, NativeCodePtrTag)
     1168    doVMEntry(makeHostFunctionCall)
    11731169
    11741170
    … …  
    12881284
    12891285_llint_program_prologue:
    1290     prologue(notFunctionCodeBlockGetter, notFunctionCodeBlockSetter, _llint_entry_osr, _llint_trace_prologue)
     1286    prologue(notFunctionCodeBlockGetter, notFunctionCodeBlockSetter, _llint_entry_osr, _llint_trace_prologue, CodeEntryPtrTag)
    12911287    dispatch(0)
    12921288
    12931289
    12941290_llint_module_program_prologue:
    1295     prologue(notFunctionCodeBlockGetter, notFunctionCodeBlockSetter, _llint_entry_osr, _llint_trace_prologue)
     1291    prologue(notFunctionCodeBlockGetter, notFunctionCodeBlockSetter, _llint_entry_osr, _llint_trace_prologue, CodeEntryPtrTag)
    12961292    dispatch(0)
    12971293
    12981294
    12991295_llint_eval_prologue:
    1300     prologue(notFunctionCodeBlockGetter, notFunctionCodeBlockSetter, _llint_entry_osr, _llint_trace_prologue)
     1296    prologue(notFunctionCodeBlockGetter, notFunctionCodeBlockSetter, _llint_entry_osr, _llint_trace_prologue, CodeEntryPtrTag)
    13011297    dispatch(0)
    13021298
    13031299
    13041300_llint_function_for_call_prologue:
    1305     prologue(functionForCallCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_call, _llint_trace_prologue_function_for_call)
     1301    prologue(functionForCallCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_call, _llint_trace_prologue_function_for_call, CodeEntryPtrTag)
    13061302    functionInitialization(0)
    13071303    dispatch(0)
    … …  
    13091305
    13101306_llint_function_for_construct_prologue:
    1311     prologue(functionForConstructCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_construct, _llint_trace_prologue_function_for_construct)
     1307    prologue(functionForConstructCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_construct, _llint_trace_prologue_function_for_construct, CodeEntryPtrTag)
    13121308    functionInitialization(1)
    13131309    dispatch(0)
    … …  
    13151311
    13161312_llint_function_for_call_arity_check:
    1317     prologue(functionForCallCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_call_arityCheck, _llint_trace_arityCheck_for_call)
     1313    prologue(functionForCallCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_call_arityCheck, _llint_trace_arityCheck_for_call, CodeEntryWithArityCheckPtrTag)
    13181314    functionArityCheck(.functionForCallBegin, _slow_path_call_arityCheck)
    13191315.functionForCallBegin:
    … …  
    13231319
    13241320_llint_function_for_construct_arity_check:
    1325     prologue(functionForConstructCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_construct_arityCheck, _llint_trace_arityCheck_for_construct)
     1321    prologue(functionForConstructCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_construct_arityCheck, _llint_trace_arityCheck_for_construct, CodeEntryWithArityCheckPtrTag)
    13261322    functionArityCheck(.functionForConstructBegin, _slow_path_construct_arityCheck)
    13271323.functionForConstructBegin:

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

    r229957 r230129  
    9797end
    9898
    99 macro doVMEntry(makeCall, unused1, unused2)
     99macro doVMEntry(makeCall)
    100100    functionPrologue()
    101101    pushCalleeSaves()
    … …  
    19961996    storei CellTag, Callee + TagOffset[t3]
    19971997    move t3, sp
    1998     prepareCall(LLIntCallLinkInfo::machineCodeTarget[t1], t2, t3, t4, macro (callPtrTag) end)
    1999     callTargetFunction(LLIntCallLinkInfo::machineCodeTarget[t1], NoPtrTag)
     1998    prepareCall(LLIntCallLinkInfo::machineCodeTarget[t1], t2, t3, t4, LLIntCallICPtrTag)
     1999    callTargetFunction(LLIntCallLinkInfo::machineCodeTarget[t1], LLIntCallICPtrTag)
    20002000
    20012001.opCallSlow:

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r229957 r230129  
    116116end
    117117
    118 macro doVMEntry(makeCall, callTag, callWithArityCheckTag)
     118macro doVMEntry(makeCall)
    119119    functionPrologue()
    120120    pushCalleeSaves()
    … …  
    226226    checkStackPointerAlignment(extraTempReg, 0xbad0dc02)
    227227
    228     if POINTER_PROFILING
    229         btbnz ProtoCallFrame::hasArityMismatch[protoCallFrame], .doCallWithArityCheck
    230         move callTag, t2
    231         jmp .readyToCall
    232     .doCallWithArityCheck:
    233         move callWithArityCheckTag, t2
    234     .readyToCall:
    235     end
    236 
    237     makeCall(entry, t3, t2)
     228    makeCall(entry, t3)
    238229
    239230    # We may have just made a call into a JS function, so we can't rely on sp
    … …  
    259250
    260251
    261 macro makeJavaScriptCall(entry, temp, callTag)
     252macro makeJavaScriptCall(entry, temp)
    262253    addp 16, sp
    263254    if C_LOOP
    264255        cloopCallJSFunction entry
    265256    else
    266         call entry, callTag
     257        call entry, CodeEntryWithArityCheckPtrTag
    267258    end
    268259    subp 16, sp
    … …  
    270261
    271262
    272 macro makeHostFunctionCall(entry, temp, callTag)
     263macro makeHostFunctionCall(entry, temp)
    273264    move entry, temp
    274265    storep cfr, [sp]
    … …  
    280271        # We need to allocate 32 bytes on the stack for the shadow space.
    281272        subp 32, sp
    282         call temp, callTag
     273        call temp, CodeEntryPtrTag
    283274        addp 32, sp
    284275    else
    285         call temp, callTag
     276        call temp, CodeEntryPtrTag
    286277    end
    287278end
    … …  
    20612052        loadp _g_JITCodePoison, t2
    20622053        xorp LLIntCallLinkInfo::machineCodeTarget[t1], t2
    2063         prepareCall(t2, t1, t3, t4, macro (callPtrTag)
    2064             if POINTER_PROFILING
    2065                 loadp LLIntCallLinkInfo::callPtrTag[t5], callPtrTag
    2066             end
    2067         end)
    2068         if POINTER_PROFILING
    2069             loadp LLIntCallLinkInfo::callPtrTag[t5], t3
    2070         end
    2071         callTargetFunction(t2, t3)
     2054        prepareCall(t2, t1, t3, t4, LLIntCallICPtrTag)
     2055        callTargetFunction(t2, LLIntCallICPtrTag)
    20722056    else
    2073         prepareCall(LLIntCallLinkInfo::machineCodeTarget[t1], t2, t3, t4, macro (callPtrTag)
    2074             if POINTER_PROFILING
    2075                 loadp LLIntCallLinkInfo::callPtrTag[t5], callPtrTag
    2076             end
    2077         end)
    2078         if POINTER_PROFILING
    2079             loadp LLIntCallLinkInfo::callPtrTag[t5], t3
    2080         end
    2081         callTargetFunction(LLIntCallLinkInfo::machineCodeTarget[t1], t3)
     2057        prepareCall(LLIntCallLinkInfo::machineCodeTarget[t1], t2, t3, t4, LLIntCallICPtrTag)
     2058        callTargetFunction(LLIntCallLinkInfo::machineCodeTarget[t1], LLIntCallICPtrTag)
    20822059    end
    20832060
    … …  
    22102187        if X86_64_WIN
    22112188            subp 32, sp
    2212             call executableOffsetToFunction[t1], NativeCodePtrTag
     2189            call executableOffsetToFunction[t1], CodeEntryPtrTag
    22132190            addp 32, sp
    22142191        else
    22152192            loadp _g_NativeCodePoison, t2
    22162193            xorp executableOffsetToFunction[t1], t2
    2217             call t2, NativeCodePtrTag
     2194            call t2, CodeEntryPtrTag
    22182195        end
    22192196    end
    … …  
    22532230        if X86_64_WIN
    22542231            subp 32, sp
    2255             call offsetOfFunction[t1], NativeCodePtrTag
     2232            call offsetOfFunction[t1], CodeEntryPtrTag
    22562233            addp 32, sp
    22572234        else
    22582235            loadp _g_NativeCodePoison, t2
    22592236            xorp offsetOfFunction[t1], t2
    2260             call t2, NativeCodePtrTag
     2237            call t2, CodeEntryPtrTag
    22612238        end
    22622239    end

  • trunk/Source/JavaScriptCore/runtime/ExecutableBase.h

    r225314 r230129  
    11/*
    2  * Copyright (C) 2009, 2010, 2013-2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5858class ExecutableBase : public JSCell {
    5959    friend class JIT;
     60    friend MacroAssemblerCodeRef boundThisNoArgsFunctionCallGenerator(VM*);
    6061
    6162protected:

  • trunk/Source/JavaScriptCore/runtime/NativeExecutable.cpp

    r229547 r230129  
    6767    m_jitCodeForConstructWithArityCheck = m_jitCodeForConstruct->addressForCall(MustCheckArity);
    6868    m_name = name;
     69
     70    assertIsTaggedWith(m_jitCodeForCall->addressForCall(ArityCheckNotRequired).executableAddress(), CodeEntryPtrTag);
     71    assertIsTaggedWith(m_jitCodeForConstruct->addressForCall(ArityCheckNotRequired).executableAddress(), CodeEntryPtrTag);
     72    assertIsTaggedWith(m_jitCodeForCallWithArityCheck.executableAddress(), CodeEntryWithArityCheckPtrTag);
     73    assertIsTaggedWith(m_jitCodeForConstructWithArityCheck.executableAddress(), CodeEntryWithArityCheckPtrTag);
    6974}
    7075

  • trunk/Source/JavaScriptCore/runtime/NativeFunction.h

    r229574 r230129  
    7171
    7272    TaggedNativeFunction(NativeFunction func)
    73         : m_ptr(tagCFunctionPtr<void*>(func.m_ptr, NativeCodePtrTag))
     73        : m_ptr(tagCFunctionPtr<void*>(func.m_ptr, CodeEntryPtrTag))
    7474    { }
    7575    TaggedNativeFunction(RawNativeFunction func)
    76         : m_ptr(tagCFunctionPtr<void*>(func, NativeCodePtrTag))
     76        : m_ptr(tagCFunctionPtr<void*>(func, CodeEntryPtrTag))
    7777    { }
    7878
    … …  
    8787    {
    8888        ASSERT(m_ptr);
    89         return untagCFunctionPtr<NativeFunction>(m_ptr, NativeCodePtrTag);
     89        return untagCFunctionPtr<NativeFunction>(m_ptr, CodeEntryPtrTag);
    9090    }
    9191

  • trunk/Source/JavaScriptCore/runtime/PropertySlot.h

    r222671 r230129  
    11/*
    2  *  Copyright (C) 2005, 2007, 2008, 2015-2016 Apple Inc. All rights reserved.
     2 *  Copyright (C) 2005-2018 Apple Inc. All rights reserved.
    33 *
    44 *  This library is free software; you can redistribute it and/or
    … …  
    258258       
    259259        ASSERT(getValue);
     260        assertIsCFunctionPtr(getValue);
    260261        m_data.custom.getValue = getValue;
    261262        m_attributes = attributes;
    … …  
    279280       
    280281        ASSERT(getValue);
     282        assertIsCFunctionPtr(getValue);
    281283        m_data.custom.getValue = getValue;
    282284        m_attributes = attributes;

  • trunk/Source/JavaScriptCore/runtime/PtrTag.h

    r230106 r230129  
    4242    v(CodeEntryWithArityCheckPtrTag) \
    4343    v(ExceptionHandlerPtrTag) \
     44    v(GetPropertyPtrTag) \
     45    v(GetterSetterPtrTag) \
     46    v(HasPropertyPtrTag) \
    4447    v(JITCodePtrTag) \
    4548    v(JITOperationPtrTag) \
    4649    v(JITThunkPtrTag) \
     50    v(JITWriteThunkPtrTag) \
     51    v(LLIntCallICPtrTag) \
     52    v(MathICPtrTag) \
    4753    v(NativeCodePtrTag) \
     54    v(OperationLinkCallPtrTag) \
     55    v(OperationLinkPolymorphicCallPtrTag) \
     56    v(OperationVirtualCallPtrTag) \
     57    v(PutPropertyPtrTag) \
    4858    v(SlowPathPtrTag) \
     59    v(SpecializedThunkPtrTag) \
    4960    v(SwitchTablePtrTag) \
    5061    \

  • trunk/Source/JavaScriptCore/runtime/PutPropertySlot.h

    r206525 r230129  
    11/*
    2  * Copyright (C) 2008-2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    7070    void setCustomValue(JSObject* base, PutValueFunc function)
    7171    {
     72        assertIsNullOrCFunctionPtr(function);
    7273        m_type = CustomValue;
    7374        m_base = base;
    … …  
    7778    void setCustomAccessor(JSObject* base, PutValueFunc function)
    7879    {
     80        assertIsNullOrCFunctionPtr(function);
    7981        m_type = CustomAccessor;
    8082        m_base = base;

  • trunk/Source/JavaScriptCore/runtime/SamplingProfiler.cpp

    r229815 r230129  
    11/*
    2  * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2016-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    358358                callFrame = static_cast<ExecState*>(machineFrame);
    359359                machinePC = MachineContext::instructionPointer(registers);
    360                 llintPC = MachineContext::llintInstructionPointer(registers);
     360                llintPC = removeCodePtrTag(MachineContext::llintInstructionPointer(registers));
     361                assertIsNotTagged(machinePC);
    361362            }
    362363            // FIXME: Lets have a way of detecting when we're parsing code.

  • trunk/Source/JavaScriptCore/runtime/VMTraps.cpp

    r228488 r230129  
    11/*
    2  * Copyright (C) 2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2017-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    6060        , framePointer(MachineContext::framePointer(registers))
    6161    {
     62        assertIsNotTagged(trapPC);
    6263    }
    6364
    … …  
    9495    // mallocs, and we must prove the JS thread isn't holding the malloc lock
    9596    // to be able to do that without risking a deadlock.
     97    assertIsNotTagged(trapPC);
    9698    if (!isJITPC(trapPC) && !LLInt::isLLIntPC(trapPC))
    9799        return;
    … …  
    188190                SignalContext context(registers);
    189191
     192                assertIsNotTagged(context.trapPC);
    190193                if (!isJITPC(context.trapPC))
    191194                    return SignalAction::NotHandled;

  • trunk/Source/JavaScriptCore/tools/SigillCrashAnalyzer.cpp

    r217669 r230129  
    11/*
    2  * Copyright (C) 2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2017-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    146146        SignalContext context(registers);
    147147
     148        assertIsNotTagged(context.machinePC);
    148149        if (!isJITPC(context.machinePC))
    149150            return SignalAction::NotHandled;

  • trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp

    r229609 r230129  
    32833283        m_tryReadUnicodeCharacterEntry = label();
    32843284
    3285 #if CPU(ARM64)
    3286         tagPtr(linkRegister, stackPointerRegister);
    3287 #endif
     3285        tagReturnAddress();
    32883286
    32893287        tryReadUnicodeCharImpl(regT0);
    … …  
    33483346    #endif
    33493347#elif CPU(ARM64)
    3350         tagPtr(linkRegister, stackPointerRegister);
     3348        tagReturnAddress();
    33513349        if (m_decodeSurrogatePairs) {
    33523350            pushPair(framePointerRegister, linkRegister);

  • trunk/Source/WTF/ChangeLog

    r230116 r230129  
     12018-03-30  Mark Lam  <mark.lam@apple.com>
     2
     3        Add pointer profiling support in baseline JIT and supporting files.
     4        https://bugs.webkit.org/show_bug.cgi?id=184200
     5        <rdar://problem/39057300>
     6
     7        Reviewed by Filip Pizlo.
     8
     9        * wtf/PointerPreparations.h:
     10        - Remove WTF_PREPARE_FUNCTION_POINTER_FOR_EXECUTION.  It is no longer needed.
     11
    1122018-03-30  JF Bastien  <jfbastien@apple.com>
    213

  • trunk/Source/WTF/wtf/PointerPreparations.h

    r228397 r230129  
    3030#endif
    3131
    32 #ifndef WTF_PREPARE_FUNCTION_POINTER_FOR_EXECUTION
    33 #define WTF_PREPARE_FUNCTION_POINTER_FOR_EXECUTION(vtblPtr) (reinterpret_cast<void*>(vtblPtr))
    34 #endif
    35 
    3632#ifndef WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION
    3733#define WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION(vtblPtr) (reinterpret_cast<void*>(vtblPtr))
Note: See TracChangeset for help on using the changeset viewer.