⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 240041 in webkit


Ignore:
Timestamp:
Jan 16, 2019, 10:44:25 AM (8 years ago)
Author:
mark.lam@apple.com
Message:

Refactor new bytecode structs so that the fields are prefixed with "m_".
​https://bugs.webkit.org/show_bug.cgi?id=193467

Reviewed by Saam Barati and Tadeu Zagallo.

This makes it easier to do a manual audit of type correctness of the LLInt
instructions used to access these fields. Without this change, it would be
difficult (and error prone) to distinguish the difference between field names and
macro variables. This audit will be done after this patch lands.

  • bytecode/BytecodeGeneratorification.cpp:

(JSC::BytecodeGeneratorification::BytecodeGeneratorification):

  • bytecode/BytecodeUseDef.h:

(JSC::computeUsesForBytecodeOffset):

  • bytecode/CallLinkStatus.cpp:

(JSC::CallLinkStatus::computeFromLLInt):

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::finishCreation):
(JSC::CodeBlock::propagateTransitions):
(JSC::CodeBlock::finalizeLLIntInlineCaches):
(JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffset):
(JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffsetSlow):
(JSC::CodeBlock::getArrayProfile):
(JSC::CodeBlock::notifyLexicalBindingShadowing):
(JSC::CodeBlock::tryGetValueProfileForBytecodeOffset):
(JSC::CodeBlock::arithProfileForPC):
(JSC::CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler):

  • bytecode/CodeBlockInlines.h:

(JSC::CodeBlock::forEachValueProfile):
(JSC::CodeBlock::forEachArrayProfile):
(JSC::CodeBlock::forEachArrayAllocationProfile):
(JSC::CodeBlock::forEachObjectAllocationProfile):
(JSC::CodeBlock::forEachLLIntCallLinkInfo):

  • bytecode/GetByIdStatus.cpp:

(JSC::GetByIdStatus::computeFromLLInt):

  • bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp:

(JSC::LLIntPrototypeLoadAdaptiveStructureWatchpoint::clearLLIntGetByIdCache):

  • bytecode/PreciseJumpTargetsInlines.h:

(JSC::jumpTargetForInstruction):
(JSC::extractStoredJumpTargetsForInstruction):
(JSC::updateStoredJumpTargetsForInstruction):

  • bytecode/PutByIdStatus.cpp:

(JSC::PutByIdStatus::computeFromLLInt):

  • bytecode/UnlinkedCodeBlock.cpp:

(JSC::dumpLineColumnEntry):

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::fuseCompareAndJump):
(JSC::BytecodeGenerator::fuseTestAndJmp):
(JSC::BytecodeGenerator::emitEqualityOp):
(JSC::BytecodeGenerator::endSwitch):
(JSC::StructureForInContext::finalize):

  • dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::handleCall):
(JSC::DFG::ByteCodeParser::handleVarargsCall):
(JSC::DFG::ByteCodeParser::parseGetById):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::handlePutByVal):
(JSC::DFG::ByteCodeParser::handlePutAccessorById):
(JSC::DFG::ByteCodeParser::handlePutAccessorByVal):
(JSC::DFG::ByteCodeParser::handleNewFunc):
(JSC::DFG::ByteCodeParser::handleNewFuncExp):

  • dfg/DFGOSREntry.cpp:

(JSC::DFG::prepareCatchOSREntry):

  • ftl/FTLOperations.cpp:

(JSC::FTL::operationMaterializeObjectInOSR):

  • generator/Argument.rb:
  • generator/Metadata.rb:
  • generator/Opcode.rb:
  • jit/JIT.h:
  • jit/JITArithmetic.cpp:

(JSC::JIT::emit_op_unsigned):
(JSC::JIT::emit_compareAndJump):
(JSC::JIT::emit_compareUnsignedAndJump):
(JSC::JIT::emit_compareUnsigned):
(JSC::JIT::emit_compareAndJumpSlow):
(JSC::JIT::emit_op_inc):
(JSC::JIT::emit_op_dec):
(JSC::JIT::emit_op_mod):
(JSC::JIT::emit_op_negate):
(JSC::JIT::emitBitBinaryOpFastPath):
(JSC::JIT::emit_op_bitnot):
(JSC::JIT::emitRightShiftFastPath):
(JSC::JIT::emit_op_add):
(JSC::JIT::emitMathICFast):
(JSC::JIT::emitMathICSlow):
(JSC::JIT::emit_op_div):
(JSC::JIT::emit_op_mul):
(JSC::JIT::emit_op_sub):

  • jit/JITArithmetic32_64.cpp:

(JSC::JIT::emit_compareAndJump):
(JSC::JIT::emit_compareUnsignedAndJump):
(JSC::JIT::emit_compareUnsigned):
(JSC::JIT::emit_compareAndJumpSlow):
(JSC::JIT::emit_op_unsigned):
(JSC::JIT::emit_op_inc):
(JSC::JIT::emit_op_dec):
(JSC::JIT::emitBinaryDoubleOp):
(JSC::JIT::emit_op_mod):

  • jit/JITCall.cpp:

(JSC::JIT::emitPutCallResult):
(JSC::JIT::compileSetupFrame):
(JSC::JIT::compileCallEvalSlowCase):
(JSC::JIT::compileTailCall):
(JSC::JIT::compileOpCall):

  • jit/JITCall32_64.cpp:

(JSC::JIT::emitPutCallResult):
(JSC::JIT::emit_op_ret):
(JSC::JIT::compileSetupFrame):
(JSC::JIT::compileCallEvalSlowCase):
(JSC::JIT::compileOpCall):

  • jit/JITInlines.h:

(JSC::JIT::emitValueProfilingSiteIfProfiledOpcode):
(JSC::JIT::emitValueProfilingSite):
(JSC::JIT::copiedGetPutInfo):
(JSC::JIT::copiedArithProfile):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_mov):
(JSC::JIT::emit_op_end):
(JSC::JIT::emit_op_jmp):
(JSC::JIT::emit_op_new_object):
(JSC::JIT::emitSlow_op_new_object):
(JSC::JIT::emit_op_overrides_has_instance):
(JSC::JIT::emit_op_instanceof):
(JSC::JIT::emitSlow_op_instanceof):
(JSC::JIT::emit_op_is_empty):
(JSC::JIT::emit_op_is_undefined):
(JSC::JIT::emit_op_is_undefined_or_null):
(JSC::JIT::emit_op_is_boolean):
(JSC::JIT::emit_op_is_number):
(JSC::JIT::emit_op_is_cell_with_type):
(JSC::JIT::emit_op_is_object):
(JSC::JIT::emit_op_ret):
(JSC::JIT::emit_op_to_primitive):
(JSC::JIT::emit_op_set_function_name):
(JSC::JIT::emit_op_not):
(JSC::JIT::emit_op_jfalse):
(JSC::JIT::emit_op_jeq_null):
(JSC::JIT::emit_op_jneq_null):
(JSC::JIT::emit_op_jneq_ptr):
(JSC::JIT::emit_op_eq):
(JSC::JIT::emit_op_jeq):
(JSC::JIT::emit_op_jtrue):
(JSC::JIT::emit_op_neq):
(JSC::JIT::emit_op_jneq):
(JSC::JIT::emit_op_throw):
(JSC::JIT::compileOpStrictEq):
(JSC::JIT::compileOpStrictEqJump):
(JSC::JIT::emitSlow_op_jstricteq):
(JSC::JIT::emitSlow_op_jnstricteq):
(JSC::JIT::emit_op_to_number):
(JSC::JIT::emit_op_to_string):
(JSC::JIT::emit_op_to_object):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_get_parent_scope):
(JSC::JIT::emit_op_switch_imm):
(JSC::JIT::emit_op_switch_char):
(JSC::JIT::emit_op_switch_string):
(JSC::JIT::emit_op_debug):
(JSC::JIT::emit_op_eq_null):
(JSC::JIT::emit_op_neq_null):
(JSC::JIT::emit_op_get_scope):
(JSC::JIT::emit_op_to_this):
(JSC::JIT::emit_op_create_this):
(JSC::JIT::emit_op_check_tdz):
(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::emitSlow_op_jeq):
(JSC::JIT::emitSlow_op_jneq):
(JSC::JIT::emitSlow_op_instanceof_custom):
(JSC::JIT::emit_op_new_regexp):
(JSC::JIT::emitNewFuncCommon):
(JSC::JIT::emitNewFuncExprCommon):
(JSC::JIT::emit_op_new_array):
(JSC::JIT::emit_op_new_array_with_size):
(JSC::JIT::emit_op_has_structure_property):
(JSC::JIT::emit_op_has_indexed_property):
(JSC::JIT::emitSlow_op_has_indexed_property):
(JSC::JIT::emit_op_get_direct_pname):
(JSC::JIT::emit_op_enumerator_structure_pname):
(JSC::JIT::emit_op_enumerator_generic_pname):
(JSC::JIT::emit_op_profile_type):
(JSC::JIT::emit_op_log_shadow_chicken_prologue):
(JSC::JIT::emit_op_log_shadow_chicken_tail):
(JSC::JIT::emit_op_profile_control_flow):
(JSC::JIT::emit_op_argument_count):
(JSC::JIT::emit_op_get_rest_length):
(JSC::JIT::emit_op_get_argument):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_mov):
(JSC::JIT::emit_op_end):
(JSC::JIT::emit_op_jmp):
(JSC::JIT::emit_op_new_object):
(JSC::JIT::emitSlow_op_new_object):
(JSC::JIT::emit_op_overrides_has_instance):
(JSC::JIT::emit_op_instanceof):
(JSC::JIT::emitSlow_op_instanceof):
(JSC::JIT::emitSlow_op_instanceof_custom):
(JSC::JIT::emit_op_is_empty):
(JSC::JIT::emit_op_is_undefined):
(JSC::JIT::emit_op_is_undefined_or_null):
(JSC::JIT::emit_op_is_boolean):
(JSC::JIT::emit_op_is_number):
(JSC::JIT::emit_op_is_cell_with_type):
(JSC::JIT::emit_op_is_object):
(JSC::JIT::emit_op_to_primitive):
(JSC::JIT::emit_op_set_function_name):
(JSC::JIT::emit_op_not):
(JSC::JIT::emit_op_jfalse):
(JSC::JIT::emit_op_jtrue):
(JSC::JIT::emit_op_jeq_null):
(JSC::JIT::emit_op_jneq_null):
(JSC::JIT::emit_op_jneq_ptr):
(JSC::JIT::emit_op_eq):
(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::emit_op_jeq):
(JSC::JIT::emitSlow_op_jeq):
(JSC::JIT::emit_op_neq):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::emit_op_jneq):
(JSC::JIT::emitSlow_op_jneq):
(JSC::JIT::compileOpStrictEq):
(JSC::JIT::compileOpStrictEqJump):
(JSC::JIT::emitSlow_op_jstricteq):
(JSC::JIT::emitSlow_op_jnstricteq):
(JSC::JIT::emit_op_eq_null):
(JSC::JIT::emit_op_neq_null):
(JSC::JIT::emit_op_throw):
(JSC::JIT::emit_op_to_number):
(JSC::JIT::emit_op_to_string):
(JSC::JIT::emit_op_to_object):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_get_parent_scope):
(JSC::JIT::emit_op_switch_imm):
(JSC::JIT::emit_op_switch_char):
(JSC::JIT::emit_op_switch_string):
(JSC::JIT::emit_op_debug):
(JSC::JIT::emit_op_get_scope):
(JSC::JIT::emit_op_create_this):
(JSC::JIT::emit_op_to_this):
(JSC::JIT::emit_op_check_tdz):
(JSC::JIT::emit_op_has_structure_property):
(JSC::JIT::emit_op_has_indexed_property):
(JSC::JIT::emitSlow_op_has_indexed_property):
(JSC::JIT::emit_op_get_direct_pname):
(JSC::JIT::emit_op_enumerator_structure_pname):
(JSC::JIT::emit_op_enumerator_generic_pname):
(JSC::JIT::emit_op_profile_type):
(JSC::JIT::emit_op_log_shadow_chicken_prologue):
(JSC::JIT::emit_op_log_shadow_chicken_tail):

  • jit/JITOperations.cpp:
  • jit/JITPropertyAccess.cpp:

(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emitGetByValWithCachedId):
(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::emitGenericContiguousPutByVal):
(JSC::JIT::emitArrayStoragePutByVal):
(JSC::JIT::emitPutByValWithCachedId):
(JSC::JIT::emitSlow_op_put_by_val):
(JSC::JIT::emit_op_put_getter_by_id):
(JSC::JIT::emit_op_put_setter_by_id):
(JSC::JIT::emit_op_put_getter_setter_by_id):
(JSC::JIT::emit_op_put_getter_by_val):
(JSC::JIT::emit_op_put_setter_by_val):
(JSC::JIT::emit_op_del_by_id):
(JSC::JIT::emit_op_del_by_val):
(JSC::JIT::emit_op_try_get_by_id):
(JSC::JIT::emitSlow_op_try_get_by_id):
(JSC::JIT::emit_op_get_by_id_direct):
(JSC::JIT::emitSlow_op_get_by_id_direct):
(JSC::JIT::emit_op_get_by_id):
(JSC::JIT::emit_op_get_by_id_with_this):
(JSC::JIT::emitSlow_op_get_by_id):
(JSC::JIT::emitSlow_op_get_by_id_with_this):
(JSC::JIT::emit_op_put_by_id):
(JSC::JIT::emitSlow_op_put_by_id):
(JSC::JIT::emit_op_in_by_id):
(JSC::JIT::emitSlow_op_in_by_id):
(JSC::JIT::emit_op_resolve_scope):
(JSC::JIT::emit_op_get_from_scope):
(JSC::JIT::emitSlow_op_get_from_scope):
(JSC::JIT::emit_op_put_to_scope):
(JSC::JIT::emit_op_get_from_arguments):
(JSC::JIT::emit_op_put_to_arguments):
(JSC::JIT::emitIntTypedArrayPutByVal):
(JSC::JIT::emitFloatTypedArrayPutByVal):

  • jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::emit_op_put_getter_by_id):
(JSC::JIT::emit_op_put_setter_by_id):
(JSC::JIT::emit_op_put_getter_setter_by_id):
(JSC::JIT::emit_op_put_getter_by_val):
(JSC::JIT::emit_op_put_setter_by_val):
(JSC::JIT::emit_op_del_by_id):
(JSC::JIT::emit_op_del_by_val):
(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emitGetByValWithCachedId):
(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::emitGenericContiguousPutByVal):
(JSC::JIT::emitArrayStoragePutByVal):
(JSC::JIT::emitPutByValWithCachedId):
(JSC::JIT::emitSlow_op_put_by_val):
(JSC::JIT::emit_op_try_get_by_id):
(JSC::JIT::emitSlow_op_try_get_by_id):
(JSC::JIT::emit_op_get_by_id_direct):
(JSC::JIT::emitSlow_op_get_by_id_direct):
(JSC::JIT::emit_op_get_by_id):
(JSC::JIT::emitSlow_op_get_by_id):
(JSC::JIT::emit_op_get_by_id_with_this):
(JSC::JIT::emitSlow_op_get_by_id_with_this):
(JSC::JIT::emit_op_put_by_id):
(JSC::JIT::emitSlow_op_put_by_id):
(JSC::JIT::emit_op_in_by_id):
(JSC::JIT::emitSlow_op_in_by_id):
(JSC::JIT::emit_op_resolve_scope):
(JSC::JIT::emit_op_get_from_scope):
(JSC::JIT::emitSlow_op_get_from_scope):
(JSC::JIT::emit_op_put_to_scope):
(JSC::JIT::emit_op_get_from_arguments):
(JSC::JIT::emit_op_put_to_arguments):

  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(JSC::LLInt::setupGetByIdPrototypeCache):
(JSC::LLInt::getByVal):
(JSC::LLInt::genericCall):
(JSC::LLInt::varargsSetup):
(JSC::LLInt::commonCallEval):

  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
  • llint/LowLevelInterpreter64.asm:
  • runtime/CommonSlowPaths.cpp:

(JSC::SLOW_PATH_DECL):
(JSC::updateArithProfileForUnaryArithOp):

  • runtime/CommonSlowPaths.h:

(JSC::CommonSlowPaths::tryCachePutToScopeGlobal):
(JSC::CommonSlowPaths::tryCacheGetFromScopeGlobal):

Location:
trunk/Source/JavaScriptCore
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r240040 r240041  
     12019-01-16  Mark Lam  <mark.lam@apple.com>
     2
     3        Refactor new bytecode structs so that the fields are prefixed with "m_".
     4        https://bugs.webkit.org/show_bug.cgi?id=193467
     5
     6        Reviewed by Saam Barati and Tadeu Zagallo.
     7
     8        This makes it easier to do a manual audit of type correctness of the LLInt
     9        instructions used to access these fields.  Without this change, it would be
     10        difficult (and error prone) to distinguish the difference between field names and
     11        macro variables.  This audit will be done after this patch lands.
     12
     13        * bytecode/BytecodeGeneratorification.cpp:
     14        (JSC::BytecodeGeneratorification::BytecodeGeneratorification):
     15        * bytecode/BytecodeUseDef.h:
     16        (JSC::computeUsesForBytecodeOffset):
     17        * bytecode/CallLinkStatus.cpp:
     18        (JSC::CallLinkStatus::computeFromLLInt):
     19        * bytecode/CodeBlock.cpp:
     20        (JSC::CodeBlock::finishCreation):
     21        (JSC::CodeBlock::propagateTransitions):
     22        (JSC::CodeBlock::finalizeLLIntInlineCaches):
     23        (JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffset):
     24        (JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffsetSlow):
     25        (JSC::CodeBlock::getArrayProfile):
     26        (JSC::CodeBlock::notifyLexicalBindingShadowing):
     27        (JSC::CodeBlock::tryGetValueProfileForBytecodeOffset):
     28        (JSC::CodeBlock::arithProfileForPC):
     29        (JSC::CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler):
     30        * bytecode/CodeBlockInlines.h:
     31        (JSC::CodeBlock::forEachValueProfile):
     32        (JSC::CodeBlock::forEachArrayProfile):
     33        (JSC::CodeBlock::forEachArrayAllocationProfile):
     34        (JSC::CodeBlock::forEachObjectAllocationProfile):
     35        (JSC::CodeBlock::forEachLLIntCallLinkInfo):
     36        * bytecode/GetByIdStatus.cpp:
     37        (JSC::GetByIdStatus::computeFromLLInt):
     38        * bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp:
     39        (JSC::LLIntPrototypeLoadAdaptiveStructureWatchpoint::clearLLIntGetByIdCache):
     40        * bytecode/PreciseJumpTargetsInlines.h:
     41        (JSC::jumpTargetForInstruction):
     42        (JSC::extractStoredJumpTargetsForInstruction):
     43        (JSC::updateStoredJumpTargetsForInstruction):
     44        * bytecode/PutByIdStatus.cpp:
     45        (JSC::PutByIdStatus::computeFromLLInt):
     46        * bytecode/UnlinkedCodeBlock.cpp:
     47        (JSC::dumpLineColumnEntry):
     48        * bytecompiler/BytecodeGenerator.cpp:
     49        (JSC::BytecodeGenerator::fuseCompareAndJump):
     50        (JSC::BytecodeGenerator::fuseTestAndJmp):
     51        (JSC::BytecodeGenerator::emitEqualityOp):
     52        (JSC::BytecodeGenerator::endSwitch):
     53        (JSC::StructureForInContext::finalize):
     54        * dfg/DFGByteCodeParser.cpp:
     55        (JSC::DFG::ByteCodeParser::handleCall):
     56        (JSC::DFG::ByteCodeParser::handleVarargsCall):
     57        (JSC::DFG::ByteCodeParser::parseGetById):
     58        (JSC::DFG::ByteCodeParser::parseBlock):
     59        (JSC::DFG::ByteCodeParser::handlePutByVal):
     60        (JSC::DFG::ByteCodeParser::handlePutAccessorById):
     61        (JSC::DFG::ByteCodeParser::handlePutAccessorByVal):
     62        (JSC::DFG::ByteCodeParser::handleNewFunc):
     63        (JSC::DFG::ByteCodeParser::handleNewFuncExp):
     64        * dfg/DFGOSREntry.cpp:
     65        (JSC::DFG::prepareCatchOSREntry):
     66        * ftl/FTLOperations.cpp:
     67        (JSC::FTL::operationMaterializeObjectInOSR):
     68        * generator/Argument.rb:
     69        * generator/Metadata.rb:
     70        * generator/Opcode.rb:
     71        * jit/JIT.h:
     72        * jit/JITArithmetic.cpp:
     73        (JSC::JIT::emit_op_unsigned):
     74        (JSC::JIT::emit_compareAndJump):
     75        (JSC::JIT::emit_compareUnsignedAndJump):
     76        (JSC::JIT::emit_compareUnsigned):
     77        (JSC::JIT::emit_compareAndJumpSlow):
     78        (JSC::JIT::emit_op_inc):
     79        (JSC::JIT::emit_op_dec):
     80        (JSC::JIT::emit_op_mod):
     81        (JSC::JIT::emit_op_negate):
     82        (JSC::JIT::emitBitBinaryOpFastPath):
     83        (JSC::JIT::emit_op_bitnot):
     84        (JSC::JIT::emitRightShiftFastPath):
     85        (JSC::JIT::emit_op_add):
     86        (JSC::JIT::emitMathICFast):
     87        (JSC::JIT::emitMathICSlow):
     88        (JSC::JIT::emit_op_div):
     89        (JSC::JIT::emit_op_mul):
     90        (JSC::JIT::emit_op_sub):
     91        * jit/JITArithmetic32_64.cpp:
     92        (JSC::JIT::emit_compareAndJump):
     93        (JSC::JIT::emit_compareUnsignedAndJump):
     94        (JSC::JIT::emit_compareUnsigned):
     95        (JSC::JIT::emit_compareAndJumpSlow):
     96        (JSC::JIT::emit_op_unsigned):
     97        (JSC::JIT::emit_op_inc):
     98        (JSC::JIT::emit_op_dec):
     99        (JSC::JIT::emitBinaryDoubleOp):
     100        (JSC::JIT::emit_op_mod):
     101        * jit/JITCall.cpp:
     102        (JSC::JIT::emitPutCallResult):
     103        (JSC::JIT::compileSetupFrame):
     104        (JSC::JIT::compileCallEvalSlowCase):
     105        (JSC::JIT::compileTailCall):
     106        (JSC::JIT::compileOpCall):
     107        * jit/JITCall32_64.cpp:
     108        (JSC::JIT::emitPutCallResult):
     109        (JSC::JIT::emit_op_ret):
     110        (JSC::JIT::compileSetupFrame):
     111        (JSC::JIT::compileCallEvalSlowCase):
     112        (JSC::JIT::compileOpCall):
     113        * jit/JITInlines.h:
     114        (JSC::JIT::emitValueProfilingSiteIfProfiledOpcode):
     115        (JSC::JIT::emitValueProfilingSite):
     116        (JSC::JIT::copiedGetPutInfo):
     117        (JSC::JIT::copiedArithProfile):
     118        * jit/JITOpcodes.cpp:
     119        (JSC::JIT::emit_op_mov):
     120        (JSC::JIT::emit_op_end):
     121        (JSC::JIT::emit_op_jmp):
     122        (JSC::JIT::emit_op_new_object):
     123        (JSC::JIT::emitSlow_op_new_object):
     124        (JSC::JIT::emit_op_overrides_has_instance):
     125        (JSC::JIT::emit_op_instanceof):
     126        (JSC::JIT::emitSlow_op_instanceof):
     127        (JSC::JIT::emit_op_is_empty):
     128        (JSC::JIT::emit_op_is_undefined):
     129        (JSC::JIT::emit_op_is_undefined_or_null):
     130        (JSC::JIT::emit_op_is_boolean):
     131        (JSC::JIT::emit_op_is_number):
     132        (JSC::JIT::emit_op_is_cell_with_type):
     133        (JSC::JIT::emit_op_is_object):
     134        (JSC::JIT::emit_op_ret):
     135        (JSC::JIT::emit_op_to_primitive):
     136        (JSC::JIT::emit_op_set_function_name):
     137        (JSC::JIT::emit_op_not):
     138        (JSC::JIT::emit_op_jfalse):
     139        (JSC::JIT::emit_op_jeq_null):
     140        (JSC::JIT::emit_op_jneq_null):
     141        (JSC::JIT::emit_op_jneq_ptr):
     142        (JSC::JIT::emit_op_eq):
     143        (JSC::JIT::emit_op_jeq):
     144        (JSC::JIT::emit_op_jtrue):
     145        (JSC::JIT::emit_op_neq):
     146        (JSC::JIT::emit_op_jneq):
     147        (JSC::JIT::emit_op_throw):
     148        (JSC::JIT::compileOpStrictEq):
     149        (JSC::JIT::compileOpStrictEqJump):
     150        (JSC::JIT::emitSlow_op_jstricteq):
     151        (JSC::JIT::emitSlow_op_jnstricteq):
     152        (JSC::JIT::emit_op_to_number):
     153        (JSC::JIT::emit_op_to_string):
     154        (JSC::JIT::emit_op_to_object):
     155        (JSC::JIT::emit_op_catch):
     156        (JSC::JIT::emit_op_get_parent_scope):
     157        (JSC::JIT::emit_op_switch_imm):
     158        (JSC::JIT::emit_op_switch_char):
     159        (JSC::JIT::emit_op_switch_string):
     160        (JSC::JIT::emit_op_debug):
     161        (JSC::JIT::emit_op_eq_null):
     162        (JSC::JIT::emit_op_neq_null):
     163        (JSC::JIT::emit_op_get_scope):
     164        (JSC::JIT::emit_op_to_this):
     165        (JSC::JIT::emit_op_create_this):
     166        (JSC::JIT::emit_op_check_tdz):
     167        (JSC::JIT::emitSlow_op_eq):
     168        (JSC::JIT::emitSlow_op_neq):
     169        (JSC::JIT::emitSlow_op_jeq):
     170        (JSC::JIT::emitSlow_op_jneq):
     171        (JSC::JIT::emitSlow_op_instanceof_custom):
     172        (JSC::JIT::emit_op_new_regexp):
     173        (JSC::JIT::emitNewFuncCommon):
     174        (JSC::JIT::emitNewFuncExprCommon):
     175        (JSC::JIT::emit_op_new_array):
     176        (JSC::JIT::emit_op_new_array_with_size):
     177        (JSC::JIT::emit_op_has_structure_property):
     178        (JSC::JIT::emit_op_has_indexed_property):
     179        (JSC::JIT::emitSlow_op_has_indexed_property):
     180        (JSC::JIT::emit_op_get_direct_pname):
     181        (JSC::JIT::emit_op_enumerator_structure_pname):
     182        (JSC::JIT::emit_op_enumerator_generic_pname):
     183        (JSC::JIT::emit_op_profile_type):
     184        (JSC::JIT::emit_op_log_shadow_chicken_prologue):
     185        (JSC::JIT::emit_op_log_shadow_chicken_tail):
     186        (JSC::JIT::emit_op_profile_control_flow):
     187        (JSC::JIT::emit_op_argument_count):
     188        (JSC::JIT::emit_op_get_rest_length):
     189        (JSC::JIT::emit_op_get_argument):
     190        * jit/JITOpcodes32_64.cpp:
     191        (JSC::JIT::emit_op_mov):
     192        (JSC::JIT::emit_op_end):
     193        (JSC::JIT::emit_op_jmp):
     194        (JSC::JIT::emit_op_new_object):
     195        (JSC::JIT::emitSlow_op_new_object):
     196        (JSC::JIT::emit_op_overrides_has_instance):
     197        (JSC::JIT::emit_op_instanceof):
     198        (JSC::JIT::emitSlow_op_instanceof):
     199        (JSC::JIT::emitSlow_op_instanceof_custom):
     200        (JSC::JIT::emit_op_is_empty):
     201        (JSC::JIT::emit_op_is_undefined):
     202        (JSC::JIT::emit_op_is_undefined_or_null):
     203        (JSC::JIT::emit_op_is_boolean):
     204        (JSC::JIT::emit_op_is_number):
     205        (JSC::JIT::emit_op_is_cell_with_type):
     206        (JSC::JIT::emit_op_is_object):
     207        (JSC::JIT::emit_op_to_primitive):
     208        (JSC::JIT::emit_op_set_function_name):
     209        (JSC::JIT::emit_op_not):
     210        (JSC::JIT::emit_op_jfalse):
     211        (JSC::JIT::emit_op_jtrue):
     212        (JSC::JIT::emit_op_jeq_null):
     213        (JSC::JIT::emit_op_jneq_null):
     214        (JSC::JIT::emit_op_jneq_ptr):
     215        (JSC::JIT::emit_op_eq):
     216        (JSC::JIT::emitSlow_op_eq):
     217        (JSC::JIT::emit_op_jeq):
     218        (JSC::JIT::emitSlow_op_jeq):
     219        (JSC::JIT::emit_op_neq):
     220        (JSC::JIT::emitSlow_op_neq):
     221        (JSC::JIT::emit_op_jneq):
     222        (JSC::JIT::emitSlow_op_jneq):
     223        (JSC::JIT::compileOpStrictEq):
     224        (JSC::JIT::compileOpStrictEqJump):
     225        (JSC::JIT::emitSlow_op_jstricteq):
     226        (JSC::JIT::emitSlow_op_jnstricteq):
     227        (JSC::JIT::emit_op_eq_null):
     228        (JSC::JIT::emit_op_neq_null):
     229        (JSC::JIT::emit_op_throw):
     230        (JSC::JIT::emit_op_to_number):
     231        (JSC::JIT::emit_op_to_string):
     232        (JSC::JIT::emit_op_to_object):
     233        (JSC::JIT::emit_op_catch):
     234        (JSC::JIT::emit_op_get_parent_scope):
     235        (JSC::JIT::emit_op_switch_imm):
     236        (JSC::JIT::emit_op_switch_char):
     237        (JSC::JIT::emit_op_switch_string):
     238        (JSC::JIT::emit_op_debug):
     239        (JSC::JIT::emit_op_get_scope):
     240        (JSC::JIT::emit_op_create_this):
     241        (JSC::JIT::emit_op_to_this):
     242        (JSC::JIT::emit_op_check_tdz):
     243        (JSC::JIT::emit_op_has_structure_property):
     244        (JSC::JIT::emit_op_has_indexed_property):
     245        (JSC::JIT::emitSlow_op_has_indexed_property):
     246        (JSC::JIT::emit_op_get_direct_pname):
     247        (JSC::JIT::emit_op_enumerator_structure_pname):
     248        (JSC::JIT::emit_op_enumerator_generic_pname):
     249        (JSC::JIT::emit_op_profile_type):
     250        (JSC::JIT::emit_op_log_shadow_chicken_prologue):
     251        (JSC::JIT::emit_op_log_shadow_chicken_tail):
     252        * jit/JITOperations.cpp:
     253        * jit/JITPropertyAccess.cpp:
     254        (JSC::JIT::emit_op_get_by_val):
     255        (JSC::JIT::emitGetByValWithCachedId):
     256        (JSC::JIT::emitSlow_op_get_by_val):
     257        (JSC::JIT::emit_op_put_by_val):
     258        (JSC::JIT::emitGenericContiguousPutByVal):
     259        (JSC::JIT::emitArrayStoragePutByVal):
     260        (JSC::JIT::emitPutByValWithCachedId):
     261        (JSC::JIT::emitSlow_op_put_by_val):
     262        (JSC::JIT::emit_op_put_getter_by_id):
     263        (JSC::JIT::emit_op_put_setter_by_id):
     264        (JSC::JIT::emit_op_put_getter_setter_by_id):
     265        (JSC::JIT::emit_op_put_getter_by_val):
     266        (JSC::JIT::emit_op_put_setter_by_val):
     267        (JSC::JIT::emit_op_del_by_id):
     268        (JSC::JIT::emit_op_del_by_val):
     269        (JSC::JIT::emit_op_try_get_by_id):
     270        (JSC::JIT::emitSlow_op_try_get_by_id):
     271        (JSC::JIT::emit_op_get_by_id_direct):
     272        (JSC::JIT::emitSlow_op_get_by_id_direct):
     273        (JSC::JIT::emit_op_get_by_id):
     274        (JSC::JIT::emit_op_get_by_id_with_this):
     275        (JSC::JIT::emitSlow_op_get_by_id):
     276        (JSC::JIT::emitSlow_op_get_by_id_with_this):
     277        (JSC::JIT::emit_op_put_by_id):
     278        (JSC::JIT::emitSlow_op_put_by_id):
     279        (JSC::JIT::emit_op_in_by_id):
     280        (JSC::JIT::emitSlow_op_in_by_id):
     281        (JSC::JIT::emit_op_resolve_scope):
     282        (JSC::JIT::emit_op_get_from_scope):
     283        (JSC::JIT::emitSlow_op_get_from_scope):
     284        (JSC::JIT::emit_op_put_to_scope):
     285        (JSC::JIT::emit_op_get_from_arguments):
     286        (JSC::JIT::emit_op_put_to_arguments):
     287        (JSC::JIT::emitIntTypedArrayPutByVal):
     288        (JSC::JIT::emitFloatTypedArrayPutByVal):
     289        * jit/JITPropertyAccess32_64.cpp:
     290        (JSC::JIT::emit_op_put_getter_by_id):
     291        (JSC::JIT::emit_op_put_setter_by_id):
     292        (JSC::JIT::emit_op_put_getter_setter_by_id):
     293        (JSC::JIT::emit_op_put_getter_by_val):
     294        (JSC::JIT::emit_op_put_setter_by_val):
     295        (JSC::JIT::emit_op_del_by_id):
     296        (JSC::JIT::emit_op_del_by_val):
     297        (JSC::JIT::emit_op_get_by_val):
     298        (JSC::JIT::emitGetByValWithCachedId):
     299        (JSC::JIT::emitSlow_op_get_by_val):
     300        (JSC::JIT::emit_op_put_by_val):
     301        (JSC::JIT::emitGenericContiguousPutByVal):
     302        (JSC::JIT::emitArrayStoragePutByVal):
     303        (JSC::JIT::emitPutByValWithCachedId):
     304        (JSC::JIT::emitSlow_op_put_by_val):
     305        (JSC::JIT::emit_op_try_get_by_id):
     306        (JSC::JIT::emitSlow_op_try_get_by_id):
     307        (JSC::JIT::emit_op_get_by_id_direct):
     308        (JSC::JIT::emitSlow_op_get_by_id_direct):
     309        (JSC::JIT::emit_op_get_by_id):
     310        (JSC::JIT::emitSlow_op_get_by_id):
     311        (JSC::JIT::emit_op_get_by_id_with_this):
     312        (JSC::JIT::emitSlow_op_get_by_id_with_this):
     313        (JSC::JIT::emit_op_put_by_id):
     314        (JSC::JIT::emitSlow_op_put_by_id):
     315        (JSC::JIT::emit_op_in_by_id):
     316        (JSC::JIT::emitSlow_op_in_by_id):
     317        (JSC::JIT::emit_op_resolve_scope):
     318        (JSC::JIT::emit_op_get_from_scope):
     319        (JSC::JIT::emitSlow_op_get_from_scope):
     320        (JSC::JIT::emit_op_put_to_scope):
     321        (JSC::JIT::emit_op_get_from_arguments):
     322        (JSC::JIT::emit_op_put_to_arguments):
     323        * llint/LLIntSlowPaths.cpp:
     324        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
     325        (JSC::LLInt::setupGetByIdPrototypeCache):
     326        (JSC::LLInt::getByVal):
     327        (JSC::LLInt::genericCall):
     328        (JSC::LLInt::varargsSetup):
     329        (JSC::LLInt::commonCallEval):
     330        * llint/LowLevelInterpreter.asm:
     331        * llint/LowLevelInterpreter32_64.asm:
     332        * llint/LowLevelInterpreter64.asm:
     333        * runtime/CommonSlowPaths.cpp:
     334        (JSC::SLOW_PATH_DECL):
     335        (JSC::updateArithProfileForUnaryArithOp):
     336        * runtime/CommonSlowPaths.h:
     337        (JSC::CommonSlowPaths::tryCachePutToScopeGlobal):
     338        (JSC::CommonSlowPaths::tryCacheGetFromScopeGlobal):
     339
    13402019-01-15  Mark Lam  <mark.lam@apple.com>
    2341

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

    r239427 r240041  
    11/*
    22 * Copyright (C) 2016 Yusuke Suzuki <utatane.tea@gmail.com>
    3  * Copyright (C) 2016 Apple Inc. All rights reserved.
     3 * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
    44 *
    55 * Redistribution and use in source and binary forms, with or without
    … …  
    7575                case op_yield: {
    7676                    auto bytecode = instruction->as<OpYield>();
    77                     unsigned liveCalleeLocalsIndex = bytecode.yieldPoint;
     77                    unsigned liveCalleeLocalsIndex = bytecode.m_yieldPoint;
    7878                    if (liveCalleeLocalsIndex >= m_yields.size())
    7979                        m_yields.resize(liveCalleeLocalsIndex + 1);
    8080                    YieldData& data = m_yields[liveCalleeLocalsIndex];
    8181                    data.point = instruction.offset();
    82                     data.argument = bytecode.argument;
     82                    data.argument = bytecode.m_argument;
    8383                    break;
    8484                }

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

    r239761 r240041  
    11/*
    2  * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3333
    3434#define CALL_FUNCTOR(__arg) \
    35     functor(__bytecode.__arg);
     35    functor(__bytecode.m_##__arg);
    3636
    3737#define USES_OR_DEFS(__opcode, ...) \
    … …  
    5252
    5353    auto handleNewArrayLike = [&](auto op) {
    54         int base = op.argv.offset();
    55         for (int i = 0; i < static_cast<int>(op.argc); i++)
     54        int base = op.m_argv.offset();
     55        for (int i = 0; i < static_cast<int>(op.m_argc); i++)
    5656            functor(VirtualRegister { base - i });
    5757    };
    5858
    5959    auto handleOpCallLike = [&](auto op) {
    60         functor(op.callee);
    61         int lastArg = -static_cast<int>(op.argv) + CallFrame::thisArgumentOffset();
    62         for (int i = 0; i < static_cast<int>(op.argc); i++)
     60        functor(op.m_callee);
     61        int lastArg = -static_cast<int>(op.m_argv) + CallFrame::thisArgumentOffset();
     62        for (int i = 0; i < static_cast<int>(op.m_argc); i++)
    6363            functor(VirtualRegister { lastArg + i });
    6464        if (opcodeID == op_call_eval)
    … …  
    259259    case op_strcat: {
    260260        auto bytecode = instruction->as<OpStrcat>();
    261         int base = bytecode.src.offset();
    262         for (int i = 0; i < bytecode.count; i++)
     261        int base = bytecode.m_src.offset();
     262        for (int i = 0; i < bytecode.m_count; i++)
    263263            functor(VirtualRegister { base - i });
    264264        return;

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

    r237547 r240041  
    11/*
    2  * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    7474    switch (op) {
    7575    case op_call:
    76         callLinkInfo = &instruction->as<OpCall>().metadata(profiledBlock).callLinkInfo;
     76        callLinkInfo = &instruction->as<OpCall>().metadata(profiledBlock).m_callLinkInfo;
    7777        break;
    7878    case op_construct:
    79         callLinkInfo = &instruction->as<OpConstruct>().metadata(profiledBlock).callLinkInfo;
     79        callLinkInfo = &instruction->as<OpConstruct>().metadata(profiledBlock).m_callLinkInfo;
    8080        break;
    8181    case op_tail_call:
    82         callLinkInfo = &instruction->as<OpTailCall>().metadata(profiledBlock).callLinkInfo;
     82        callLinkInfo = &instruction->as<OpTailCall>().metadata(profiledBlock).m_callLinkInfo;
    8383        break;
    8484    default:

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

    r239898 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
    44 *
    … …  
    508508    auto link_profile = [&](const auto& instruction, auto /*bytecode*/, auto& metadata) {
    509509        m_numberOfNonArgumentValueProfiles++;
    510         metadata.profile.m_bytecodeOffset = instruction.offset();
     510        metadata.m_profile.m_bytecodeOffset = instruction.offset();
    511511    };
    512512
    513513    auto link_arrayProfile = [&](const auto& instruction, auto /*bytecode*/, auto& metadata) {
    514         metadata.arrayProfile.m_bytecodeOffset = instruction.offset();
     514        metadata.m_arrayProfile.m_bytecodeOffset = instruction.offset();
    515515    };
    516516
    517517    auto link_objectAllocationProfile = [&](const auto& /*instruction*/, auto bytecode, auto& metadata) {
    518         metadata.objectAllocationProfile.initializeProfile(vm, m_globalObject.get(), this, m_globalObject->objectPrototype(), bytecode.inlineCapacity);
     518        metadata.m_objectAllocationProfile.initializeProfile(vm, m_globalObject.get(), this, m_globalObject->objectPrototype(), bytecode.m_inlineCapacity);
    519519    };
    520520
    521521    auto link_arrayAllocationProfile = [&](const auto& /*instruction*/, auto bytecode, auto& metadata) {
    522         metadata.arrayAllocationProfile.initializeIndexingMode(bytecode.recommendedIndexingType);
     522        metadata.m_arrayAllocationProfile.initializeIndexingMode(bytecode.m_recommendedIndexingType);
    523523    };
    524524
    525525    auto link_hitCountForLLIntCaching = [&](const auto& /*instruction*/, auto /*bytecode*/, auto& metadata) {
    526         metadata.hitCountForLLIntCaching = Options::prototypeHitCountForLLIntCaching();
     526        metadata.m_hitCountForLLIntCaching = Options::prototypeHitCountForLLIntCaching();
    527527    };
    528528
    … …  
    608608            INITIALIZE_METADATA(OpResolveScope)
    609609
    610             const Identifier& ident = identifier(bytecode.var);
    611             RELEASE_ASSERT(bytecode.resolveType != LocalClosureVar);
    612 
    613             ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, scope, ident, Get, bytecode.resolveType, InitializationMode::NotInitialization);
     610            const Identifier& ident = identifier(bytecode.m_var);
     611            RELEASE_ASSERT(bytecode.m_resolveType != LocalClosureVar);
     612
     613            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, scope, ident, Get, bytecode.m_resolveType, InitializationMode::NotInitialization);
    614614            RETURN_IF_EXCEPTION(throwScope, false);
    615615
    616             metadata.resolveType = op.type;
    617             metadata.localScopeDepth = op.depth;
     616            metadata.m_resolveType = op.type;
     617            metadata.m_localScopeDepth = op.depth;
    618618            if (op.lexicalEnvironment) {
    619619                if (op.type == ModuleVar) {
    … …  
    621621                    if (stronglyReferencedModuleEnvironments.add(jsCast<JSModuleEnvironment*>(op.lexicalEnvironment)).isNewEntry)
    622622                        addConstant(op.lexicalEnvironment);
    623                     metadata.lexicalEnvironment.set(vm, this, op.lexicalEnvironment);
     623                    metadata.m_lexicalEnvironment.set(vm, this, op.lexicalEnvironment);
    624624                } else
    625                     metadata.symbolTable.set(vm, this, op.lexicalEnvironment->symbolTable());
     625                    metadata.m_symbolTable.set(vm, this, op.lexicalEnvironment->symbolTable());
    626626            } else if (JSScope* constantScope = JSScope::constantScopeForCodeBlock(op.type, this)) {
    627                 metadata.constantScope.set(vm, this, constantScope);
     627                metadata.m_constantScope.set(vm, this, constantScope);
    628628                if (op.type == GlobalLexicalVar || op.type == GlobalLexicalVarWithVarInjectionChecks)
    629                     metadata.localScopeDepth = 0;
     629                    metadata.m_localScopeDepth = 0;
    630630            } else
    631                 metadata.globalObject = nullptr;
     631                metadata.m_globalObject = nullptr;
    632632            break;
    633633        }
    … …  
    637637
    638638            link_profile(instruction, bytecode, metadata);
    639             metadata.watchpointSet = nullptr;
    640 
    641             ASSERT(!isInitialization(bytecode.getPutInfo.initializationMode()));
    642             if (bytecode.getPutInfo.resolveType() == LocalClosureVar) {
    643                 metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), ClosureVar, bytecode.getPutInfo.initializationMode());
     639            metadata.m_watchpointSet = nullptr;
     640
     641            ASSERT(!isInitialization(bytecode.m_getPutInfo.initializationMode()));
     642            if (bytecode.m_getPutInfo.resolveType() == LocalClosureVar) {
     643                metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), ClosureVar, bytecode.m_getPutInfo.initializationMode());
    644644                break;
    645645            }
    646646
    647             const Identifier& ident = identifier(bytecode.var);
    648             ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, scope, ident, Get, bytecode.getPutInfo.resolveType(), InitializationMode::NotInitialization);
     647            const Identifier& ident = identifier(bytecode.m_var);
     648            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, scope, ident, Get, bytecode.m_getPutInfo.resolveType(), InitializationMode::NotInitialization);
    649649            RETURN_IF_EXCEPTION(throwScope, false);
    650650
    651             metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), op.type, bytecode.getPutInfo.initializationMode());
     651            metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), op.type, bytecode.m_getPutInfo.initializationMode());
    652652            if (op.type == ModuleVar)
    653                 metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), ClosureVar, bytecode.getPutInfo.initializationMode());
     653                metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), ClosureVar, bytecode.m_getPutInfo.initializationMode());
    654654            if (op.type == GlobalVar || op.type == GlobalVarWithVarInjectionChecks || op.type == GlobalLexicalVar || op.type == GlobalLexicalVarWithVarInjectionChecks)
    655                 metadata.watchpointSet = op.watchpointSet;
     655                metadata.m_watchpointSet = op.watchpointSet;
    656656            else if (op.structure)
    657                 metadata.structure.set(vm, this, op.structure);
    658             metadata.operand = op.operand;
     657                metadata.m_structure.set(vm, this, op.structure);
     658            metadata.m_operand = op.operand;
    659659            break;
    660660        }
    … …  
    663663            INITIALIZE_METADATA(OpPutToScope)
    664664
    665             if (bytecode.getPutInfo.resolveType() == LocalClosureVar) {
     665            if (bytecode.m_getPutInfo.resolveType() == LocalClosureVar) {
    666666                // Only do watching if the property we're putting to is not anonymous.
    667                 if (bytecode.var != UINT_MAX) {
    668                     SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(bytecode.symbolTableOrScopeDepth));
    669                     const Identifier& ident = identifier(bytecode.var);
     667                if (bytecode.m_var != UINT_MAX) {
     668                    SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(bytecode.m_symbolTableOrScopeDepth));
     669                    const Identifier& ident = identifier(bytecode.m_var);
    670670                    ConcurrentJSLocker locker(symbolTable->m_lock);
    671671                    auto iter = symbolTable->find(locker, ident.impl());
    672672                    ASSERT(iter != symbolTable->end(locker));
    673673                    iter->value.prepareToWatch();
    674                     metadata.watchpointSet = iter->value.watchpointSet();
     674                    metadata.m_watchpointSet = iter->value.watchpointSet();
    675675                } else
    676                     metadata.watchpointSet = nullptr;
     676                    metadata.m_watchpointSet = nullptr;
    677677                break;
    678678            }
    679679
    680             const Identifier& ident = identifier(bytecode.var);
    681             metadata.watchpointSet = nullptr;
    682             ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.symbolTableOrScopeDepth, scope, ident, Put, bytecode.getPutInfo.resolveType(), bytecode.getPutInfo.initializationMode());
     680            const Identifier& ident = identifier(bytecode.m_var);
     681            metadata.m_watchpointSet = nullptr;
     682            ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_symbolTableOrScopeDepth, scope, ident, Put, bytecode.m_getPutInfo.resolveType(), bytecode.m_getPutInfo.initializationMode());
    683683            RETURN_IF_EXCEPTION(throwScope, false);
    684684
    685             metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), op.type, bytecode.getPutInfo.initializationMode());
     685            metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), op.type, bytecode.m_getPutInfo.initializationMode());
    686686            if (op.type == GlobalVar || op.type == GlobalVarWithVarInjectionChecks || op.type == GlobalLexicalVar || op.type == GlobalLexicalVarWithVarInjectionChecks)
    687                 metadata.watchpointSet = op.watchpointSet;
     687                metadata.m_watchpointSet = op.watchpointSet;
    688688            else if (op.type == ClosureVar || op.type == ClosureVarWithVarInjectionChecks) {
    689689                if (op.watchpointSet)
    690690                    op.watchpointSet->invalidate(vm, PutToScopeFireDetail(this, ident));
    691691            } else if (op.structure)
    692                 metadata.structure.set(vm, this, op.structure);
    693             metadata.operand = op.operand;
     692                metadata.m_structure.set(vm, this, op.structure);
     693            metadata.m_operand = op.operand;
    694694            break;
    695695        }
    … …  
    707707            SymbolTable* symbolTable = nullptr;
    708708
    709             switch (bytecode.flag) {
     709            switch (bytecode.m_flag) {
    710710            case ProfileTypeBytecodeClosureVar: {
    711                 const Identifier& ident = identifier(bytecode.identifier);
    712                 unsigned localScopeDepth = bytecode.symbolTableOrScopeDepth;
     711                const Identifier& ident = identifier(bytecode.m_identifier);
     712                unsigned localScopeDepth = bytecode.m_symbolTableOrScopeDepth;
    713713                // Even though type profiling may be profiling either a Get or a Put, we can always claim a Get because
    714714                // we're abstractly "read"ing from a JSScope.
    715                 ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Get, bytecode.resolveType, InitializationMode::NotInitialization);
     715                ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), localScopeDepth, scope, ident, Get, bytecode.m_resolveType, InitializationMode::NotInitialization);
    716716                RETURN_IF_EXCEPTION(throwScope, false);
    717717
    … …  
    734734            }
    735735            case ProfileTypeBytecodeLocallyResolved: {
    736                 int symbolTableIndex = bytecode.symbolTableOrScopeDepth;
     736                int symbolTableIndex = bytecode.m_symbolTableOrScopeDepth;
    737737                SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(symbolTableIndex));
    738                 const Identifier& ident = identifier(bytecode.identifier);
     738                const Identifier& ident = identifier(bytecode.m_identifier);
    739739                ConcurrentJSLocker locker(symbolTable->m_lock);
    740740                // If our parent scope was created while profiling was disabled, it will not have prepared for profiling yet.
    … …  
    771771            bool isNewLocation = locationPair.second;
    772772
    773             if (bytecode.flag == ProfileTypeBytecodeFunctionReturnStatement)
     773            if (bytecode.m_flag == ProfileTypeBytecodeFunctionReturnStatement)
    774774                location->m_divotForFunctionOffsetIfReturnStatement = ownerExecutable->typeProfilingStartOffset();
    775775
    … …  
    777777                vm.typeProfiler()->insertNewLocation(location);
    778778
    779             metadata.typeLocation = location;
     779            metadata.m_typeLocation = location;
    780780            break;
    781781        }
    782782
    783783        case op_debug: {
    784             if (instruction->as<OpDebug>().debugHookType == DidReachBreakpoint)
     784            if (instruction->as<OpDebug>().m_debugHookType == DidReachBreakpoint)
    785785                m_hasDebuggerStatement = true;
    786786            break;
    … …  
    788788
    789789        case op_create_rest: {
    790             int numberOfArgumentsToSkip = instruction->as<OpCreateRest>().numParametersToSkip;
     790            int numberOfArgumentsToSkip = instruction->as<OpCreateRest>().m_numParametersToSkip;
    791791            ASSERT_UNUSED(numberOfArgumentsToSkip, numberOfArgumentsToSkip >= 0);
    792792            // This is used when rematerializing the rest parameter during OSR exit in the FTL JIT.");
    … …  
    10961096            if (instruction->is<OpPutById>()) {
    10971097                auto& metadata = instruction->as<OpPutById>().metadata(this);
    1098                 StructureID oldStructureID = metadata.oldStructure;
    1099                 StructureID newStructureID = metadata.newStructure;
     1098                StructureID oldStructureID = metadata.m_oldStructure;
     1099                StructureID newStructureID = metadata.m_newStructure;
    11001100                if (!oldStructureID || !newStructureID)
    11011101                    continue;
    … …  
    12081208
    12091209    auto handleGetPutFromScope = [](auto& metadata) {
    1210         GetPutInfo getPutInfo = metadata.getPutInfo;
     1210        GetPutInfo getPutInfo = metadata.m_getPutInfo;
    12111211        if (getPutInfo.resolveType() == GlobalVar || getPutInfo.resolveType() == GlobalVarWithVarInjectionChecks
    12121212            || getPutInfo.resolveType() == LocalClosureVar || getPutInfo.resolveType() == GlobalLexicalVar || getPutInfo.resolveType() == GlobalLexicalVarWithVarInjectionChecks)
    12131213            return;
    1214         WriteBarrierBase<Structure>& structure = metadata.structure;
     1214        WriteBarrierBase<Structure>& structure = metadata.m_structure;
    12151215        if (!structure || Heap::isMarked(structure.get()))
    12161216            return;
    … …  
    12251225        case op_get_by_id: {
    12261226            auto& metadata = curInstruction->as<OpGetById>().metadata(this);
    1227             if (metadata.mode != GetByIdMode::Default)
     1227            if (metadata.m_mode != GetByIdMode::Default)
    12281228                break;
    1229             StructureID oldStructureID = metadata.modeMetadata.defaultMode.structure;
     1229            StructureID oldStructureID = metadata.m_modeMetadata.defaultMode.structure;
    12301230            if (!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
    12311231                break;
    … …  
    12371237        case op_get_by_id_direct: {
    12381238            auto& metadata = curInstruction->as<OpGetByIdDirect>().metadata(this);
    1239             StructureID oldStructureID = metadata.structure;
     1239            StructureID oldStructureID = metadata.m_structure;
    12401240            if (!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
    12411241                break;
    12421242            if (Options::verboseOSR())
    12431243                dataLogF("Clearing LLInt property access.\n");
    1244             metadata.structure = 0;
    1245             metadata.offset = 0;
     1244            metadata.m_structure = 0;
     1245            metadata.m_offset = 0;
    12461246            break;
    12471247        }
    12481248        case op_put_by_id: {
    12491249            auto& metadata = curInstruction->as<OpPutById>().metadata(this);
    1250             StructureID oldStructureID = metadata.oldStructure;
    1251             StructureID newStructureID = metadata.newStructure;
    1252             StructureChain* chain = metadata.structureChain.get();
     1250            StructureID oldStructureID = metadata.m_oldStructure;
     1251            StructureID newStructureID = metadata.m_newStructure;
     1252            StructureChain* chain = metadata.m_structureChain.get();
    12531253            if ((!oldStructureID || Heap::isMarked(vm.heap.structureIDTable().get(oldStructureID)))
    12541254                && (!newStructureID || Heap::isMarked(vm.heap.structureIDTable().get(newStructureID)))
    … …  
    12571257            if (Options::verboseOSR())
    12581258                dataLogF("Clearing LLInt put transition.\n");
    1259             metadata.oldStructure = 0;
    1260             metadata.offset = 0;
    1261             metadata.newStructure = 0;
    1262             metadata.structureChain.clear();
     1259            metadata.m_oldStructure = 0;
     1260            metadata.m_offset = 0;
     1261            metadata.m_newStructure = 0;
     1262            metadata.m_structureChain.clear();
    12631263            break;
    12641264        }
    … …  
    12691269        case op_to_this: {
    12701270            auto& metadata = curInstruction->as<OpToThis>().metadata(this);
    1271             if (!metadata.cachedStructure || Heap::isMarked(metadata.cachedStructure.get()))
     1271            if (!metadata.m_cachedStructure || Heap::isMarked(metadata.m_cachedStructure.get()))
    12721272                break;
    12731273            if (Options::verboseOSR())
    1274                 dataLogF("Clearing LLInt to_this with structure %p.\n", metadata.cachedStructure.get());
    1275             metadata.cachedStructure.clear();
    1276             metadata.toThisStatus = merge(metadata.toThisStatus, ToThisClearedByGC);
     1274                dataLogF("Clearing LLInt to_this with structure %p.\n", metadata.m_cachedStructure.get());
     1275            metadata.m_cachedStructure.clear();
     1276            metadata.m_toThisStatus = merge(metadata.m_toThisStatus, ToThisClearedByGC);
    12771277            break;
    12781278        }
    12791279        case op_create_this: {
    12801280            auto& metadata = curInstruction->as<OpCreateThis>().metadata(this);
    1281             auto& cacheWriteBarrier = metadata.cachedCallee;
     1281            auto& cacheWriteBarrier = metadata.m_cachedCallee;
    12821282            if (!cacheWriteBarrier || cacheWriteBarrier.unvalidatedGet() == JSCell::seenMultipleCalleeObjects())
    12831283                break;
    … …  
    12951295            // to the symbol table strongly. But it's nice to be on the safe side.
    12961296            auto& metadata = curInstruction->as<OpResolveScope>().metadata(this);
    1297             WriteBarrierBase<SymbolTable>& symbolTable = metadata.symbolTable;
     1297            WriteBarrierBase<SymbolTable>& symbolTable = metadata.m_symbolTable;
    12981298            if (!symbolTable || Heap::isMarked(symbolTable.get()))
    12991299                break;
    … …  
    16661666    OpCatch op = instruction->as<OpCatch>();
    16671667    auto& metadata = op.metadata(this);
    1668     if (!!metadata.buffer) {
     1668    if (!!metadata.m_buffer) {
    16691669#if !ASSERT_DISABLED
    16701670        ConcurrentJSLocker locker(m_lock);
    16711671        bool found = false;
    16721672        for (auto& profile : m_catchProfiles) {
    1673             if (profile.get() == metadata.buffer) {
     1673            if (profile.get() == metadata.m_buffer) {
    16741674                found = true;
    16751675                break;
    … …  
    17141714    WTF::storeStoreFence();
    17151715
    1716     op.metadata(this).buffer = profiles.get();
     1716    op.metadata(this).m_buffer = profiles.get();
    17171717
    17181718    {
    … …  
    24922492#define CASE(Op) \
    24932493    case Op::opcodeID: \
    2494         return &instruction->as<Op>().metadata(this).arrayProfile;
     2494        return &instruction->as<Op>().metadata(this).m_arrayProfile;
    24952495
    24962496    FOR_EACH_OPCODE_WITH_ARRAY_PROFILE(CASE)
    … …  
    25002500        auto bytecode = instruction->as<OpGetById>();
    25012501        auto& metadata = bytecode.metadata(this);
    2502         if (metadata.mode == GetByIdMode::ArrayLength)
    2503             return &metadata.modeMetadata.arrayLengthMode.arrayProfile;
     2502        if (metadata.m_mode == GetByIdMode::ArrayLength)
     2503            return &metadata.m_modeMetadata.arrayLengthMode.arrayProfile;
    25042504        break;
    25052505    }
    … …  
    26872687            auto bytecode = instruction->as<OpResolveScope>();
    26882688            auto& metadata = bytecode.metadata(this);
    2689             ResolveType originalResolveType = metadata.resolveType;
     2689            ResolveType originalResolveType = metadata.m_resolveType;
    26902690            if (originalResolveType == GlobalProperty || originalResolveType == GlobalPropertyWithVarInjectionChecks) {
    2691                 const Identifier& ident = identifier(bytecode.var);
     2691                const Identifier& ident = identifier(bytecode.m_var);
    26922692                if (set.contains(ident.impl())) {
    26932693                    // We pass JSGlobalLexicalScope as a start point of the scope chain.
    26942694                    // It should immediately find the lexical binding because that's the reason why we perform this rewriting now.
    2695                     ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.resolveType, InitializationMode::NotInitialization);
     2695                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.m_resolveType, InitializationMode::NotInitialization);
    26962696                    scope.releaseAssertNoException();
    26972697                    ASSERT(op.type == GlobalLexicalVarWithVarInjectionChecks || op.type == GlobalLexicalVar);
    2698                     metadata.resolveType = needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar;
    2699                     metadata.localScopeDepth = 0;
     2698                    metadata.m_resolveType = needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar;
     2699                    metadata.m_localScopeDepth = 0;
    27002700                    ASSERT(!op.lexicalEnvironment);
    2701                     JSScope* constantScope = JSScope::constantScopeForCodeBlock(metadata.resolveType, this);
     2701                    JSScope* constantScope = JSScope::constantScopeForCodeBlock(metadata.m_resolveType, this);
    27022702                    ASSERT(constantScope == globalObject->globalScope());
    2703                     metadata.constantScope.set(vm, this, constantScope);
    2704                     dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_resolve_scope from ", originalResolveType, " to ", metadata.resolveType);
     2703                    metadata.m_constantScope.set(vm, this, constantScope);
     2704                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_resolve_scope from ", originalResolveType, " to ", metadata.m_resolveType);
    27052705                }
    27062706            }
    … …  
    27112711            auto bytecode = instruction->as<OpGetFromScope>();
    27122712            auto& metadata = bytecode.metadata(this);
    2713             ResolveType originalResolveType = metadata.getPutInfo.resolveType();
     2713            ResolveType originalResolveType = metadata.m_getPutInfo.resolveType();
    27142714            if (originalResolveType == GlobalProperty || originalResolveType == GlobalPropertyWithVarInjectionChecks) {
    2715                 const Identifier& ident = identifier(bytecode.var);
     2715                const Identifier& ident = identifier(bytecode.m_var);
    27162716                if (set.contains(ident.impl())) {
    27172717                    // We pass JSGlobalLexicalScope as a start point of the scope chain.
    27182718                    // It should immediately find the lexical binding because that's the reason why we perform this rewriting now.
    2719                     ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.getPutInfo.resolveType(), InitializationMode::NotInitialization);
     2719                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_localScopeDepth, globalObject->globalScope(), ident, Get, bytecode.m_getPutInfo.resolveType(), InitializationMode::NotInitialization);
    27202720                    scope.releaseAssertNoException();
    27212721                    ASSERT(op.type == GlobalLexicalVarWithVarInjectionChecks || op.type == GlobalLexicalVar);
    2722                     metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar, bytecode.getPutInfo.initializationMode());
    2723                     metadata.watchpointSet = op.watchpointSet;
    2724                     metadata.operand = op.operand;
    2725                     dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_get_from_scope from ", originalResolveType, " to ", metadata.getPutInfo.resolveType());
     2722                    metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar, bytecode.m_getPutInfo.initializationMode());
     2723                    metadata.m_watchpointSet = op.watchpointSet;
     2724                    metadata.m_operand = op.operand;
     2725                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_get_from_scope from ", originalResolveType, " to ", metadata.m_getPutInfo.resolveType());
    27262726                }
    27272727            }
    … …  
    27322732            auto bytecode = instruction->as<OpPutToScope>();
    27332733            auto& metadata = bytecode.metadata(this);
    2734             ResolveType originalResolveType = metadata.getPutInfo.resolveType();
     2734            ResolveType originalResolveType = metadata.m_getPutInfo.resolveType();
    27352735            if (originalResolveType == GlobalProperty || originalResolveType == GlobalPropertyWithVarInjectionChecks) {
    2736                 const Identifier& ident = identifier(bytecode.var);
     2736                const Identifier& ident = identifier(bytecode.m_var);
    27372737                if (set.contains(ident.impl())) {
    27382738                    // We pass JSGlobalLexicalScope as a start point of the scope chain.
    27392739                    // It should immediately find the lexical binding because that's the reason why we perform this rewriting now.
    2740                     ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.symbolTableOrScopeDepth, globalObject->globalScope(), ident, Put, bytecode.getPutInfo.resolveType(), bytecode.getPutInfo.initializationMode());
     2740                    ResolveOp op = JSScope::abstractResolve(m_globalObject->globalExec(), bytecode.m_symbolTableOrScopeDepth, globalObject->globalScope(), ident, Put, bytecode.m_getPutInfo.resolveType(), bytecode.m_getPutInfo.initializationMode());
    27412741                    scope.releaseAssertNoException();
    27422742                    ASSERT(op.type == GlobalLexicalVarWithVarInjectionChecks || op.type == GlobalLexicalVar || op.type == Dynamic);
    27432743
    27442744                    ResolveType resolveType = op.type;
    2745                     metadata.watchpointSet = nullptr;
     2745                    metadata.m_watchpointSet = nullptr;
    27462746                    if (resolveType == GlobalLexicalVarWithVarInjectionChecks || resolveType == GlobalLexicalVar) {
    27472747                        resolveType = needsVarInjectionChecks(originalResolveType) ? GlobalLexicalVarWithVarInjectionChecks : GlobalLexicalVar;
    2748                         metadata.watchpointSet = op.watchpointSet;
     2748                        metadata.m_watchpointSet = op.watchpointSet;
    27492749                    }
    2750                     metadata.getPutInfo = GetPutInfo(bytecode.getPutInfo.resolveMode(), resolveType, bytecode.getPutInfo.initializationMode());
    2751                     metadata.operand = op.operand;
    2752                     dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_put_to_scope from ", originalResolveType, " to ", metadata.getPutInfo.resolveType());
     2750                    metadata.m_getPutInfo = GetPutInfo(bytecode.m_getPutInfo.resolveMode(), resolveType, bytecode.m_getPutInfo.initializationMode());
     2751                    metadata.m_operand = op.operand;
     2752                    dataLogLnIf(CodeBlockInternal::verbose, "Rewrite op_put_to_scope from ", originalResolveType, " to ", metadata.m_getPutInfo.resolveType());
    27532753                }
    27542754            }
    … …  
    28802880#define CASE(Op) \
    28812881    case Op::opcodeID: \
    2882         return &instruction->as<Op>().metadata(this).profile;
     2882        return &instruction->as<Op>().metadata(this).m_profile;
    28832883
    28842884        FOR_EACH_OPCODE_WITH_VALUE_PROFILE(CASE)
    … …  
    30193019    switch (pc->opcodeID()) {
    30203020    case op_negate:
    3021         return &pc->as<OpNegate>().metadata(this).arithProfile;
     3021        return &pc->as<OpNegate>().metadata(this).m_arithProfile;
    30223022    case op_add:
    3023         return &pc->as<OpAdd>().metadata(this).arithProfile;
     3023        return &pc->as<OpAdd>().metadata(this).m_arithProfile;
    30243024    case op_mul:
    3025         return &pc->as<OpMul>().metadata(this).arithProfile;
     3025        return &pc->as<OpMul>().metadata(this).m_arithProfile;
    30263026    case op_sub:
    3027         return &pc->as<OpSub>().metadata(this).arithProfile;
     3027        return &pc->as<OpSub>().metadata(this).m_arithProfile;
    30283028    case op_div:
    3029         return &pc->as<OpDiv>().metadata(this).arithProfile;
     3029        return &pc->as<OpDiv>().metadata(this).m_arithProfile;
    30303030    default:
    30313031        break;
    … …  
    30673067        auto bytecode = instruction->as<OpProfileControlFlow>();
    30683068        auto& metadata = bytecode.metadata(this);
    3069         int basicBlockStartOffset = bytecode.textOffset;
     3069        int basicBlockStartOffset = bytecode.m_textOffset;
    30703070        int basicBlockEndOffset;
    30713071        if (i + 1 < offsetsLength) {
    … …  
    30733073            auto endInstruction = m_instructions->at(endIdx);
    30743074            RELEASE_ASSERT(endInstruction->opcodeID() == op_profile_control_flow);
    3075             basicBlockEndOffset = endInstruction->as<OpProfileControlFlow>().textOffset - 1;
     3075            basicBlockEndOffset = endInstruction->as<OpProfileControlFlow>().m_textOffset - 1;
    30763076        } else {
    30773077            basicBlockEndOffset = m_sourceOffset + ownerScriptExecutable()->source().length() - 1; // Offset before the closing brace.
    … …  
    30993099        if (basicBlockEndOffset < basicBlockStartOffset) {
    31003100            RELEASE_ASSERT(i + 1 < offsetsLength); // We should never encounter dummy blocks at the end of a CodeBlock.
    3101             metadata.basicBlockLocation = vm()->controlFlowProfiler()->dummyBasicBlock();
     3101            metadata.m_basicBlockLocation = vm()->controlFlowProfiler()->dummyBasicBlock();
    31023102            continue;
    31033103        }
    … …  
    31233123            insertFunctionGaps(executable);
    31243124
    3125         metadata.basicBlockLocation = basicBlockLocation;
     3125        metadata.m_basicBlockLocation = basicBlockLocation;
    31263126    }
    31273127}

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

    r239626 r240041  
    4040    if (m_metadata) {
    4141#define VISIT(__op) \
    42     m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.profile); });
     42    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_profile); });
    4343
    4444        FOR_EACH_OPCODE_WITH_VALUE_PROFILE(VISIT)
    … …  
    5454    if (m_metadata) {
    5555        m_metadata->forEach<OpGetById>([&] (auto& metadata) {
    56             if (metadata.mode == GetByIdMode::ArrayLength)
    57                 func(metadata.modeMetadata.arrayLengthMode.arrayProfile);
     56            if (metadata.m_mode == GetByIdMode::ArrayLength)
     57                func(metadata.m_modeMetadata.arrayLengthMode.arrayProfile);
    5858        });
    5959
    6060#define VISIT(__op) \
    61     m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.arrayProfile); });
     61    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_arrayProfile); });
    6262
    6363        FOR_EACH_OPCODE_WITH_ARRAY_PROFILE(VISIT)
    … …  
    7272    if (m_metadata) {
    7373#define VISIT(__op) \
    74     m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.arrayAllocationProfile); });
     74    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_arrayAllocationProfile); });
    7575
    7676        FOR_EACH_OPCODE_WITH_ARRAY_ALLOCATION_PROFILE(VISIT)
    … …  
    8585    if (m_metadata) {
    8686#define VISIT(__op) \
    87     m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.objectAllocationProfile); });
     87    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_objectAllocationProfile); });
    8888
    8989        FOR_EACH_OPCODE_WITH_OBJECT_ALLOCATION_PROFILE(VISIT)
    … …  
    9898    if (m_metadata) {
    9999#define VISIT(__op) \
    100     m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.callLinkInfo); });
     100    m_metadata->forEach<__op>([&] (auto& metadata) { func(metadata.m_callLinkInfo); });
    101101
    102102        FOR_EACH_OPCODE_WITH_LLINT_CALL_LINK_INFO(VISIT)

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

    r239427 r240041  
    11/*
    2  * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    6565        // FIXME: We should not just bail if we see a get_by_id_proto_load.
    6666        // https://bugs.webkit.org/show_bug.cgi?id=158039
    67         if (metadata.mode != GetByIdMode::Default)
     67        if (metadata.m_mode != GetByIdMode::Default)
    6868            return GetByIdStatus(NoInformation, false);
    69         structureID = metadata.modeMetadata.defaultMode.structure;
     69        structureID = metadata.m_modeMetadata.defaultMode.structure;
    7070        break;
    7171    }
    7272    case op_get_by_id_direct:
    73         structureID = instruction->as<OpGetByIdDirect>().metadata(profiledBlock).structure;
     73        structureID = instruction->as<OpGetByIdDirect>().metadata(profiledBlock).m_structure;
    7474        break;
    7575    case op_try_get_by_id: {

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

    r237547 r240041  
    11/*
    2  * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    6060void LLIntPrototypeLoadAdaptiveStructureWatchpoint::clearLLIntGetByIdCache(OpGetById::Metadata& metadata)
    6161{
    62     metadata.mode = GetByIdMode::Default;
    63     metadata.modeMetadata.defaultMode.cachedOffset = 0;
    64     metadata.modeMetadata.defaultMode.structure = 0;
     62    metadata.m_mode = GetByIdMode::Default;
     63    metadata.m_modeMetadata.defaultMode.cachedOffset = 0;
     64    metadata.m_modeMetadata.defaultMode.structure = 0;
    6565}
    6666

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

    r238499 r240041  
    11/*
    2  * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5959    case op_switch_imm: { \
    6060        auto bytecode = instruction->as<OpSwitchImm>(); \
    61         auto& table = codeBlock->switchJumpTable(bytecode.tableIndex); \
     61        auto& table = codeBlock->switchJumpTable(bytecode.m_tableIndex); \
    6262        for (unsigned i = table.branchOffsets.size(); i--;) \
    6363            SWITCH_CASE(table.branchOffsets[i]); \
    … …  
    6767    case op_switch_char: { \
    6868        auto bytecode = instruction->as<OpSwitchChar>(); \
    69         auto& table = codeBlock->switchJumpTable(bytecode.tableIndex); \
     69        auto& table = codeBlock->switchJumpTable(bytecode.m_tableIndex); \
    7070        for (unsigned i = table.branchOffsets.size(); i--;) \
    7171            SWITCH_CASE(table.branchOffsets[i]); \
    … …  
    7575    case op_switch_string: { \
    7676        auto bytecode = instruction->as<OpSwitchString>(); \
    77         auto& table = codeBlock->stringSwitchJumpTable(bytecode.tableIndex); \
     77        auto& table = codeBlock->stringSwitchJumpTable(bytecode.m_tableIndex); \
    7878        auto iter = table.offsetTable.begin(); \
    7979        auto end = table.offsetTable.end(); \
    … …  
    109109{
    110110    auto bytecode = instruction->as<Op>();
    111     return jumpTargetForInstruction(codeBlock, instruction, bytecode.target);
     111    return jumpTargetForInstruction(codeBlock, instruction, bytecode.m_target);
    112112}
    113113
    … …  
    124124
    125125#define SWITCH_DEFAULT_OFFSET(__op) \
    126     function(jumpTargetForInstruction(codeBlock, instruction, bytecode.defaultOffset)) \
     126    function(jumpTargetForInstruction(codeBlock, instruction, bytecode.m_defaultOffset)) \
    127127
    128128SWITCH_JMP(CASE_OP, SWITCH_CASE, SWITCH_DEFAULT_OFFSET)
    … …  
    155155#define SWITCH_DEFAULT_OFFSET(__op) \
    156156    do { \
    157         int32_t target = jumpTargetForInstruction(codeBlockOrHashMap, instruction, bytecode.defaultOffset); \
     157        int32_t target = jumpTargetForInstruction(codeBlockOrHashMap, instruction, bytecode.m_defaultOffset); \
    158158        int32_t newTarget = function(target); \
    159159        instruction->cast<__op>()->setDefaultOffset(BoundLabel(newTarget), [&]() { \

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

    r240023 r240041  
    11/*
    2  * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5656    auto& metadata = bytecode.metadata(profiledBlock);
    5757
    58     StructureID structureID = metadata.oldStructure;
     58    StructureID structureID = metadata.m_oldStructure;
    5959    if (!structureID)
    6060        return PutByIdStatus(NoInformation);
    … …  
    6262    Structure* structure = vm.heap.structureIDTable().get(structureID);
    6363
    64     StructureID newStructureID = metadata.newStructure;
     64    StructureID newStructureID = metadata.m_newStructure;
    6565    if (!newStructureID) {
    6666        PropertyOffset offset = structure->getConcurrently(uid);
    … …  
    8080   
    8181    ObjectPropertyConditionSet conditionSet;
    82     if (!(bytecode.flags & PutByIdIsDirect)) {
     82    if (!(bytecode.m_flags & PutByIdIsDirect)) {
    8383        conditionSet =
    8484            generateConditionsForPropertySetterMissConcurrently(

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

    r237547 r240041  
    11/*
    2  * Copyright (C) 2012-2018 Apple Inc. All Rights Reserved.
     2 * Copyright (C) 2012-2019 Apple Inc. All Rights Reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    146146    const char* event = "";
    147147    if (instruction->is<OpDebug>()) {
    148         switch (instruction->as<OpDebug>().debugHookType) {
     148        switch (instruction->as<OpDebug>().m_debugHookType) {
    149149        case WillExecuteProgram: event = " WillExecuteProgram"; break;
    150150        case DidExecuteProgram: event = " DidExecuteProgram"; break;

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

    r239774 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
    44 * Copyright (C) 2012 Igalia, S.L.
    … …  
    13901390{
    13911391    auto binop = m_lastInstruction->as<BinOp>();
    1392     if (cond->index() == binop.dst.offset() && cond->isTemporary() && !cond->refCount()) {
     1392    if (cond->index() == binop.m_dst.offset() && cond->isTemporary() && !cond->refCount()) {
    13931393        rewind();
    13941394
    13951395        if (swapOperands)
    1396             std::swap(binop.lhs, binop.rhs);
    1397 
    1398         JmpOp::emit(this, binop.lhs, binop.rhs, target.bind(this));
     1396            std::swap(binop.m_lhs, binop.m_rhs);
     1397
     1398        JmpOp::emit(this, binop.m_lhs, binop.m_rhs, target.bind(this));
    13991399        return true;
    14001400    }
    … …  
    14061406{
    14071407    auto unop = m_lastInstruction->as<UnaryOp>();
    1408     if (cond->index() == unop.dst.offset() && cond->isTemporary() && !cond->refCount()) {
     1408    if (cond->index() == unop.m_dst.offset() && cond->isTemporary() && !cond->refCount()) {
    14091409        rewind();
    14101410
    1411         JmpOp::emit(this, unop.operand, target.bind(this));
     1411        JmpOp::emit(this, unop.m_operand, target.bind(this));
    14121412        return true;
    14131413    }
    … …  
    17101710    if (m_lastInstruction->is<OpTypeof>()) {
    17111711        auto op = m_lastInstruction->as<OpTypeof>();
    1712         if (src1->index() == op.dst.offset()
     1712        if (src1->index() == op.m_dst.offset()
    17131713            && src1->isTemporary()
    17141714            && m_codeBlock->isConstantRegisterIndex(src2->index())
    … …  
    17171717            if (value == "undefined") {
    17181718                rewind();
    1719                 OpIsUndefined::emit(this, dst, op.value);
     1719                OpIsUndefined::emit(this, dst, op.m_value);
    17201720                return dst;
    17211721            }
    17221722            if (value == "boolean") {
    17231723                rewind();
    1724                 OpIsBoolean::emit(this, dst, op.value);
     1724                OpIsBoolean::emit(this, dst, op.m_value);
    17251725                return dst;
    17261726            }
    17271727            if (value == "number") {
    17281728                rewind();
    1729                 OpIsNumber::emit(this, dst, op.value);
     1729                OpIsNumber::emit(this, dst, op.m_value);
    17301730                return dst;
    17311731            }
    17321732            if (value == "string") {
    17331733                rewind();
    1734                 OpIsCellWithType::emit(this, dst, op.value, StringType);
     1734                OpIsCellWithType::emit(this, dst, op.m_value, StringType);
    17351735                return dst;
    17361736            }
    17371737            if (value == "symbol") {
    17381738                rewind();
    1739                 OpIsCellWithType::emit(this, dst, op.value, SymbolType);
     1739                OpIsCellWithType::emit(this, dst, op.m_value, SymbolType);
    17401740                return dst;
    17411741            }
    17421742            if (Options::useBigInt() && value == "bigint") {
    17431743                rewind();
    1744                 OpIsCellWithType::emit(this, dst, op.value, BigIntType);
     1744                OpIsCellWithType::emit(this, dst, op.m_value, BigIntType);
    17451745                return dst;
    17461746            }
    17471747            if (value == "object") {
    17481748                rewind();
    1749                 OpIsObjectOrNull::emit(this, dst, op.value);
     1749                OpIsObjectOrNull::emit(this, dst, op.m_value);
    17501750                return dst;
    17511751            }
    17521752            if (value == "function") {
    17531753                rewind();
    1754                 OpIsFunction::emit(this, dst, op.value);
     1754                OpIsFunction::emit(this, dst, op.m_value);
    17551755                return dst;
    17561756            }
    … …  
    38903890        });
    38913891
    3892         UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->switchJumpTable(bytecode.tableIndex);
     3892        UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->switchJumpTable(bytecode.m_tableIndex);
    38933893        prepareJumpTableForSwitch(
    38943894            jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes, min, max,
    … …  
    39153915        });
    39163916
    3917         UnlinkedStringJumpTable& jumpTable = m_codeBlock->stringSwitchJumpTable(ref->as<OpSwitchString>().tableIndex);
     3917        UnlinkedStringJumpTable& jumpTable = m_codeBlock->stringSwitchJumpTable(ref->as<OpSwitchString>().m_tableIndex);
    39183918        prepareJumpTableForStringSwitch(jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes);
    39193919        break;
    … …  
    48614861        // 2. base stays the same.
    48624862        // 3. property gets switched to the original property.
    4863         OpGetByVal::emit<OpcodeSize::Wide>(&generator, bytecode.dst, bytecode.base, VirtualRegister(propertyRegIndex));
     4863        OpGetByVal::emit<OpcodeSize::Wide>(&generator, bytecode.m_dst, bytecode.m_base, VirtualRegister(propertyRegIndex));
    48644864
    48654865        // 4. nop out the remaining bytes

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

    r240023 r240041  
    11/*
    2  * Copyright (C) 2011-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    12321232{
    12331233    auto bytecode = pc->as<CallOp>();
    1234     Node* callTarget = get(bytecode.callee);
    1235     int registerOffset = -static_cast<int>(bytecode.argv);
     1234    Node* callTarget = get(bytecode.m_callee);
     1235    int registerOffset = -static_cast<int>(bytecode.m_argv);
    12361236
    12371237    CallLinkStatus callLinkStatus = CallLinkStatus::computeFor(
    … …  
    12411241    InlineCallFrame::Kind kind = InlineCallFrame::kindFor(callMode);
    12421242
    1243     return handleCall(bytecode.dst, op, kind, pc->size(), callTarget,
    1244         bytecode.argc, registerOffset, callLinkStatus, getPrediction());
     1243    return handleCall(bytecode.m_dst, op, kind, pc->size(), callTarget,
     1244        bytecode.m_argc, registerOffset, callLinkStatus, getPrediction());
    12451245}
    12461246
    … …  
    12881288{
    12891289    auto bytecode = pc->as<CallOp>();
    1290     int firstFreeReg = bytecode.firstFree.offset();
    1291     int firstVarArgOffset = bytecode.firstVarArg;
     1290    int firstFreeReg = bytecode.m_firstFree.offset();
     1291    int firstVarArgOffset = bytecode.m_firstVarArg;
    12921292   
    12931293    SpeculatedType prediction = getPrediction();
    12941294   
    1295     Node* callTarget = get(bytecode.callee);
     1295    Node* callTarget = get(bytecode.m_callee);
    12961296   
    12971297    CallLinkStatus callLinkStatus = CallLinkStatus::computeFor(
    … …  
    13051305        addToGraph(FilterCallLinkStatus, OpInfo(m_graph.m_plan.recordedStatuses().addCallLinkStatus(currentCodeOrigin(), callLinkStatus)), callTarget);
    13061306
    1307         if (handleVarargsInlining(callTarget, bytecode.dst,
    1308             callLinkStatus, firstFreeReg, bytecode.thisValue, bytecode.arguments,
     1307        if (handleVarargsInlining(callTarget, bytecode.m_dst,
     1308            callLinkStatus, firstFreeReg, bytecode.m_thisValue, bytecode.m_arguments,
    13091309            firstVarArgOffset, op,
    13101310            InlineCallFrame::varargsKindFor(callMode))) {
    … …  
    13181318    data->firstVarArgOffset = firstVarArgOffset;
    13191319   
    1320     Node* thisChild = get(bytecode.thisValue);
     1320    Node* thisChild = get(bytecode.m_thisValue);
    13211321    Node* argumentsChild = nullptr;
    13221322    if (op != TailCallForwardVarargs)
    1323         argumentsChild = get(bytecode.arguments);
     1323        argumentsChild = get(bytecode.m_arguments);
    13241324
    13251325    if (op == TailCallVarargs || op == TailCallForwardVarargs) {
    … …  
    13321332
    13331333    Node* call = addToGraph(op, OpInfo(data), OpInfo(prediction), callTarget, thisChild, argumentsChild);
    1334     if (bytecode.dst.isValid())
    1335         set(bytecode.dst, call);
     1334    if (bytecode.m_dst.isValid())
     1335        set(bytecode.m_dst, call);
    13361336    return NonTerminal;
    13371337}
    … …  
    45804580    SpeculatedType prediction = getPrediction();
    45814581   
    4582     Node* base = get(bytecode.base);
    4583     unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
     4582    Node* base = get(bytecode.m_base);
     4583    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
    45844584   
    45854585    UniquedStringImpl* uid = m_graph.identifiers()[identifierNumber];
    … …  
    45974597
    45984598    handleGetById(
    4599         bytecode.dst, prediction, base, identifierNumber, getByIdStatus, type, opcodeLength);
     4599        bytecode.m_dst, prediction, base, identifierNumber, getByIdStatus, type, opcodeLength);
    46004600
    46014601}
    … …  
    47344734            if (op1->op() != ToThis) {
    47354735                auto& metadata = currentInstruction->as<OpToThis>().metadata(codeBlock);
    4736                 Structure* cachedStructure = metadata.cachedStructure.get();
    4737                 if (metadata.toThisStatus != ToThisOK
     4736                Structure* cachedStructure = metadata.m_cachedStructure.get();
     4737                if (metadata.m_toThisStatus != ToThisOK
    47384738                    || !cachedStructure
    47394739                    || cachedStructure->classInfo()->methodTable.toThis != JSObject::info()->methodTable.toThis
    … …  
    47544754        case op_create_this: {
    47554755            auto bytecode = currentInstruction->as<OpCreateThis>();
    4756             Node* callee = get(VirtualRegister(bytecode.callee));
     4756            Node* callee = get(VirtualRegister(bytecode.m_callee));
    47574757
    47584758            JSFunction* function = callee->dynamicCastConstant<JSFunction*>(*m_vm);
    47594759            if (!function) {
    4760                 JSCell* cachedFunction = bytecode.metadata(codeBlock).cachedCallee.unvalidatedGet();
     4760                JSCell* cachedFunction = bytecode.metadata(codeBlock).m_cachedCallee.unvalidatedGet();
    47614761                if (cachedFunction
    47624762                    && cachedFunction != JSCell::seenMultipleCalleeObjects()
    … …  
    47944794                                addToGraph(PutByOffset, OpInfo(data), object, object, weakJSConstant(prototype));
    47954795                            }
    4796                             set(VirtualRegister(bytecode.dst), object);
     4796                            set(VirtualRegister(bytecode.m_dst), object);
    47974797                            alreadyEmitted = true;
    47984798                        }
    … …  
    48014801            }
    48024802            if (!alreadyEmitted) {
    4803                 set(VirtualRegister(bytecode.dst),
    4804                     addToGraph(CreateThis, OpInfo(bytecode.inlineCapacity), callee));
     4803                set(VirtualRegister(bytecode.m_dst),
     4804                    addToGraph(CreateThis, OpInfo(bytecode.m_inlineCapacity), callee));
    48054805            }
    48064806            NEXT_OPCODE(op_create_this);
    … …  
    48094809        case op_new_object: {
    48104810            auto bytecode = currentInstruction->as<OpNewObject>();
    4811             set(bytecode.dst,
     4811            set(bytecode.m_dst,
    48124812                addToGraph(NewObject,
    4813                     OpInfo(m_graph.registerStructure(bytecode.metadata(codeBlock).objectAllocationProfile.structure()))));
     4813                    OpInfo(m_graph.registerStructure(bytecode.metadata(codeBlock).m_objectAllocationProfile.structure()))));
    48144814            NEXT_OPCODE(op_new_object);
    48154815        }
    … …  
    48174817        case op_new_array: {
    48184818            auto bytecode = currentInstruction->as<OpNewArray>();
    4819             int startOperand = bytecode.argv.offset();
    4820             int numOperands = bytecode.argc;
    4821             ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).arrayAllocationProfile;
     4819            int startOperand = bytecode.m_argv.offset();
     4820            int numOperands = bytecode.m_argc;
     4821            ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).m_arrayAllocationProfile;
    48224822            for (int operandIdx = startOperand; operandIdx > startOperand - numOperands; --operandIdx)
    48234823                addVarArgChild(get(VirtualRegister(operandIdx)));
    48244824            unsigned vectorLengthHint = std::max<unsigned>(profile.vectorLengthHint(), numOperands);
    4825             set(bytecode.dst, addToGraph(Node::VarArg, NewArray, OpInfo(profile.selectIndexingType()), OpInfo(vectorLengthHint)));
     4825            set(bytecode.m_dst, addToGraph(Node::VarArg, NewArray, OpInfo(profile.selectIndexingType()), OpInfo(vectorLengthHint)));
    48264826            NEXT_OPCODE(op_new_array);
    48274827        }
    … …  
    48294829        case op_new_array_with_spread: {
    48304830            auto bytecode = currentInstruction->as<OpNewArrayWithSpread>();
    4831             int startOperand = bytecode.argv.offset();
    4832             int numOperands = bytecode.argc;
    4833             const BitVector& bitVector = m_inlineStackTop->m_profiledBlock->unlinkedCodeBlock()->bitVector(bytecode.bitVector);
     4831            int startOperand = bytecode.m_argv.offset();
     4832            int numOperands = bytecode.m_argc;
     4833            const BitVector& bitVector = m_inlineStackTop->m_profiledBlock->unlinkedCodeBlock()->bitVector(bytecode.m_bitVector);
    48344834            for (int operandIdx = startOperand; operandIdx > startOperand - numOperands; --operandIdx)
    48354835                addVarArgChild(get(VirtualRegister(operandIdx)));
    … …  
    48384838            ASSERT(*copy == bitVector);
    48394839
    4840             set(bytecode.dst,
     4840            set(bytecode.m_dst,
    48414841                addToGraph(Node::VarArg, NewArrayWithSpread, OpInfo(copy)));
    48424842            NEXT_OPCODE(op_new_array_with_spread);
    … …  
    48454845        case op_spread: {
    48464846            auto bytecode = currentInstruction->as<OpSpread>();
    4847             set(bytecode.dst,
    4848                 addToGraph(Spread, get(bytecode.argument)));
     4847            set(bytecode.m_dst,
     4848                addToGraph(Spread, get(bytecode.m_argument)));
    48494849            NEXT_OPCODE(op_spread);
    48504850        }
    … …  
    48524852        case op_new_array_with_size: {
    48534853            auto bytecode = currentInstruction->as<OpNewArrayWithSize>();
    4854             ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).arrayAllocationProfile;
    4855             set(bytecode.dst, addToGraph(NewArrayWithSize, OpInfo(profile.selectIndexingType()), get(bytecode.length)));
     4854            ArrayAllocationProfile& profile = bytecode.metadata(codeBlock).m_arrayAllocationProfile;
     4855            set(bytecode.m_dst, addToGraph(NewArrayWithSize, OpInfo(profile.selectIndexingType()), get(bytecode.m_length)));
    48564856            NEXT_OPCODE(op_new_array_with_size);
    48574857        }
    … …  
    48624862            // cannot allocate from compilation threads.
    48634863            WTF::loadLoadFence();
    4864             FrozenValue* frozen = get(VirtualRegister(bytecode.immutableButterfly))->constant();
     4864            FrozenValue* frozen = get(VirtualRegister(bytecode.m_immutableButterfly))->constant();
    48654865            WTF::loadLoadFence();
    48664866            JSImmutableButterfly* immutableButterfly = frozen->cast<JSImmutableButterfly*>();
    … …  
    48694869            data.vectorLengthHint = immutableButterfly->toButterfly()->vectorLength();
    48704870
    4871             set(VirtualRegister(bytecode.dst), addToGraph(NewArrayBuffer, OpInfo(frozen), OpInfo(data.asQuadWord)));
     4871            set(VirtualRegister(bytecode.m_dst), addToGraph(NewArrayBuffer, OpInfo(frozen), OpInfo(data.asQuadWord)));
    48724872            NEXT_OPCODE(op_new_array_buffer);
    48734873        }
    … …  
    48754875        case op_new_regexp: {
    48764876            auto bytecode = currentInstruction->as<OpNewRegexp>();
    4877             ASSERT(bytecode.regexp.isConstant());
    4878             FrozenValue* frozenRegExp = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.regexp.offset()));
    4879             set(bytecode.dst, addToGraph(NewRegexp, OpInfo(frozenRegExp), jsConstant(jsNumber(0))));
     4877            ASSERT(bytecode.m_regexp.isConstant());
     4878            FrozenValue* frozenRegExp = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.m_regexp.offset()));
     4879            set(bytecode.m_dst, addToGraph(NewRegexp, OpInfo(frozenRegExp), jsConstant(jsNumber(0))));
    48804880            NEXT_OPCODE(op_new_regexp);
    48814881        }
    … …  
    48884888                unsigned argumentsLength = inlineCallFrame->argumentCountIncludingThis - 1;
    48894889                JSValue restLength;
    4890                 if (argumentsLength <= bytecode.numParametersToSkip)
     4890                if (argumentsLength <= bytecode.m_numParametersToSkip)
    48914891                    restLength = jsNumber(0);
    48924892                else
    4893                     restLength = jsNumber(argumentsLength - bytecode.numParametersToSkip);
     4893                    restLength = jsNumber(argumentsLength - bytecode.m_numParametersToSkip);
    48944894
    48954895                length = jsConstant(restLength);
    48964896            } else
    4897                 length = addToGraph(GetRestLength, OpInfo(bytecode.numParametersToSkip));
    4898             set(bytecode.dst, length);
     4897                length = addToGraph(GetRestLength, OpInfo(bytecode.m_numParametersToSkip));
     4898            set(bytecode.m_dst, length);
    48994899            NEXT_OPCODE(op_get_rest_length);
    49004900        }
    … …  
    49034903            auto bytecode = currentInstruction->as<OpCreateRest>();
    49044904            noticeArgumentsUse();
    4905             Node* arrayLength = get(bytecode.arraySize);
    4906             set(bytecode.dst,
    4907                 addToGraph(CreateRest, OpInfo(bytecode.numParametersToSkip), arrayLength));
     4905            Node* arrayLength = get(bytecode.m_arraySize);
     4906            set(bytecode.m_dst,
     4907                addToGraph(CreateRest, OpInfo(bytecode.m_numParametersToSkip), arrayLength));
    49084908            NEXT_OPCODE(op_create_rest);
    49094909        }
    … …  
    49134913        case op_bitnot: {
    49144914            auto bytecode = currentInstruction->as<OpBitnot>();
    4915             Node* op1 = get(bytecode.operand);
    4916             set(bytecode.dst, addToGraph(ArithBitNot, op1));
     4915            Node* op1 = get(bytecode.m_operand);
     4916            set(bytecode.m_dst, addToGraph(ArithBitNot, op1));
    49174917            NEXT_OPCODE(op_bitnot);
    49184918        }
    … …  
    49214921            auto bytecode = currentInstruction->as<OpBitand>();
    49224922            SpeculatedType prediction = getPrediction();
    4923             Node* op1 = get(bytecode.lhs);
    4924             Node* op2 = get(bytecode.rhs);
     4923            Node* op1 = get(bytecode.m_lhs);
     4924            Node* op2 = get(bytecode.m_rhs);
    49254925            if (op1->hasNumberOrAnyIntResult() && op2->hasNumberOrAnyIntResult())
    4926                 set(bytecode.dst, addToGraph(ArithBitAnd, op1, op2));
     4926                set(bytecode.m_dst, addToGraph(ArithBitAnd, op1, op2));
    49274927            else
    4928                 set(bytecode.dst, addToGraph(ValueBitAnd, OpInfo(), OpInfo(prediction), op1, op2));
     4928                set(bytecode.m_dst, addToGraph(ValueBitAnd, OpInfo(), OpInfo(prediction), op1, op2));
    49294929            NEXT_OPCODE(op_bitand);
    49304930        }
    … …  
    49334933            auto bytecode = currentInstruction->as<OpBitor>();
    49344934            SpeculatedType prediction = getPrediction();
    4935             Node* op1 = get(bytecode.lhs);
    4936             Node* op2 = get(bytecode.rhs);
     4935            Node* op1 = get(bytecode.m_lhs);
     4936            Node* op2 = get(bytecode.m_rhs);
    49374937            if (op1->hasNumberOrAnyIntResult() && op2->hasNumberOrAnyIntResult())
    4938                 set(bytecode.dst, addToGraph(ArithBitOr, op1, op2));
     4938                set(bytecode.m_dst, addToGraph(ArithBitOr, op1, op2));
    49394939            else
    4940                 set(bytecode.dst, addToGraph(ValueBitOr, OpInfo(), OpInfo(prediction), op1, op2));
     4940                set(bytecode.m_dst, addToGraph(ValueBitOr, OpInfo(), OpInfo(prediction), op1, op2));
    49414941            NEXT_OPCODE(op_bitor);
    49424942        }
    … …  
    49454945            auto bytecode = currentInstruction->as<OpBitxor>();
    49464946            SpeculatedType prediction = getPrediction();
    4947             Node* op1 = get(bytecode.lhs);
    4948             Node* op2 = get(bytecode.rhs);
     4947            Node* op1 = get(bytecode.m_lhs);
     4948            Node* op2 = get(bytecode.m_rhs);
    49494949            if (op1->hasNumberOrAnyIntResult() && op2->hasNumberOrAnyIntResult())
    4950                 set(bytecode.dst, addToGraph(ArithBitXor, op1, op2));
     4950                set(bytecode.m_dst, addToGraph(ArithBitXor, op1, op2));
    49514951            else
    4952                 set(bytecode.dst, addToGraph(ValueBitXor, OpInfo(), OpInfo(prediction), op1, op2));
    4953             NEXT_OPCODE(op_bitor);
     4952                set(bytecode.m_dst, addToGraph(ValueBitXor, OpInfo(), OpInfo(prediction), op1, op2));
     4953            NEXT_OPCODE(op_bitxor);
    49544954        }
    49554955
    49564956        case op_rshift: {
    49574957            auto bytecode = currentInstruction->as<OpRshift>();
    4958             Node* op1 = get(bytecode.lhs);
    4959             Node* op2 = get(bytecode.rhs);
    4960             set(bytecode.dst, addToGraph(BitRShift, op1, op2));
     4958            Node* op1 = get(bytecode.m_lhs);
     4959            Node* op2 = get(bytecode.m_rhs);
     4960            set(bytecode.m_dst, addToGraph(BitRShift, op1, op2));
    49614961            NEXT_OPCODE(op_rshift);
    49624962        }
    … …  
    49644964        case op_lshift: {
    49654965            auto bytecode = currentInstruction->as<OpLshift>();
    4966             Node* op1 = get(bytecode.lhs);
    4967             Node* op2 = get(bytecode.rhs);
    4968             set(bytecode.dst, addToGraph(BitLShift, op1, op2));
     4966            Node* op1 = get(bytecode.m_lhs);
     4967            Node* op2 = get(bytecode.m_rhs);
     4968            set(bytecode.m_dst, addToGraph(BitLShift, op1, op2));
    49694969            NEXT_OPCODE(op_lshift);
    49704970        }
    … …  
    49724972        case op_urshift: {
    49734973            auto bytecode = currentInstruction->as<OpUrshift>();
    4974             Node* op1 = get(bytecode.lhs);
    4975             Node* op2 = get(bytecode.rhs);
    4976             set(bytecode.dst, addToGraph(BitURShift, op1, op2));
     4974            Node* op1 = get(bytecode.m_lhs);
     4975            Node* op2 = get(bytecode.m_rhs);
     4976            set(bytecode.m_dst, addToGraph(BitURShift, op1, op2));
    49774977            NEXT_OPCODE(op_urshift);
    49784978        }
    … …  
    49804980        case op_unsigned: {
    49814981            auto bytecode = currentInstruction->as<OpUnsigned>();
    4982             set(bytecode.dst, makeSafe(addToGraph(UInt32ToNumber, get(bytecode.operand))));
     4982            set(bytecode.m_dst, makeSafe(addToGraph(UInt32ToNumber, get(bytecode.m_operand))));
    49834983            NEXT_OPCODE(op_unsigned);
    49844984        }
    … …  
    49884988        case op_inc: {
    49894989            auto bytecode = currentInstruction->as<OpInc>();
    4990             Node* op = get(bytecode.srcDst);
    4991             set(bytecode.srcDst, makeSafe(addToGraph(ArithAdd, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
     4990            Node* op = get(bytecode.m_srcDst);
     4991            set(bytecode.m_srcDst, makeSafe(addToGraph(ArithAdd, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
    49924992            NEXT_OPCODE(op_inc);
    49934993        }
    … …  
    49954995        case op_dec: {
    49964996            auto bytecode = currentInstruction->as<OpDec>();
    4997             Node* op = get(bytecode.srcDst);
    4998             set(bytecode.srcDst, makeSafe(addToGraph(ArithSub, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
     4997            Node* op = get(bytecode.m_srcDst);
     4998            set(bytecode.m_srcDst, makeSafe(addToGraph(ArithSub, op, addToGraph(JSConstant, OpInfo(m_constantOne)))));
    49994999            NEXT_OPCODE(op_dec);
    50005000        }
    … …  
    50045004        case op_add: {
    50055005            auto bytecode = currentInstruction->as<OpAdd>();
    5006             Node* op1 = get(bytecode.lhs);
    5007             Node* op2 = get(bytecode.rhs);
     5006            Node* op1 = get(bytecode.m_lhs);
     5007            Node* op2 = get(bytecode.m_rhs);
    50085008            if (op1->hasNumberResult() && op2->hasNumberResult())
    5009                 set(bytecode.dst, makeSafe(addToGraph(ArithAdd, op1, op2)));
     5009                set(bytecode.m_dst, makeSafe(addToGraph(ArithAdd, op1, op2)));
    50105010            else
    5011                 set(bytecode.dst, makeSafe(addToGraph(ValueAdd, op1, op2)));
     5011                set(bytecode.m_dst, makeSafe(addToGraph(ValueAdd, op1, op2)));
    50125012            NEXT_OPCODE(op_add);
    50135013        }
    … …  
    50155015        case op_sub: {
    50165016            auto bytecode = currentInstruction->as<OpSub>();
    5017             Node* op1 = get(bytecode.lhs);
    5018             Node* op2 = get(bytecode.rhs);
     5017            Node* op1 = get(bytecode.m_lhs);
     5018            Node* op2 = get(bytecode.m_rhs);
    50195019            if (op1->hasNumberResult() && op2->hasNumberResult())
    5020                 set(bytecode.dst, makeSafe(addToGraph(ArithSub, op1, op2)));
     5020                set(bytecode.m_dst, makeSafe(addToGraph(ArithSub, op1, op2)));
    50215021            else
    5022                 set(bytecode.dst, makeSafe(addToGraph(ValueSub, op1, op2)));
     5022                set(bytecode.m_dst, makeSafe(addToGraph(ValueSub, op1, op2)));
    50235023            NEXT_OPCODE(op_sub);
    50245024        }
    … …  
    50265026        case op_negate: {
    50275027            auto bytecode = currentInstruction->as<OpNegate>();
    5028             Node* op1 = get(bytecode.operand);
     5028            Node* op1 = get(bytecode.m_operand);
    50295029            if (op1->hasNumberResult())
    5030                 set(bytecode.dst, makeSafe(addToGraph(ArithNegate, op1)));
     5030                set(bytecode.m_dst, makeSafe(addToGraph(ArithNegate, op1)));
    50315031            else
    5032                 set(bytecode.dst, makeSafe(addToGraph(ValueNegate, op1)));
     5032                set(bytecode.m_dst, makeSafe(addToGraph(ValueNegate, op1)));
    50335033            NEXT_OPCODE(op_negate);
    50345034        }
    … …  
    50375037            // Multiply requires that the inputs are not truncated, unfortunately.
    50385038            auto bytecode = currentInstruction->as<OpMul>();
    5039             Node* op1 = get(bytecode.lhs);
    5040             Node* op2 = get(bytecode.rhs);
     5039            Node* op1 = get(bytecode.m_lhs);
     5040            Node* op2 = get(bytecode.m_rhs);
    50415041            if (op1->hasNumberResult() && op2->hasNumberResult())
    5042                 set(bytecode.dst, makeSafe(addToGraph(ArithMul, op1, op2)));
     5042                set(bytecode.m_dst, makeSafe(addToGraph(ArithMul, op1, op2)));
    50435043            else
    5044                 set(bytecode.dst, makeSafe(addToGraph(ValueMul, op1, op2)));
     5044                set(bytecode.m_dst, makeSafe(addToGraph(ValueMul, op1, op2)));
    50455045            NEXT_OPCODE(op_mul);
    50465046        }
    … …  
    50485048        case op_mod: {
    50495049            auto bytecode = currentInstruction->as<OpMod>();
    5050             Node* op1 = get(bytecode.lhs);
    5051             Node* op2 = get(bytecode.rhs);
    5052             set(bytecode.dst, makeSafe(addToGraph(ArithMod, op1, op2)));
     5050            Node* op1 = get(bytecode.m_lhs);
     5051            Node* op2 = get(bytecode.m_rhs);
     5052            set(bytecode.m_dst, makeSafe(addToGraph(ArithMod, op1, op2)));
    50535053            NEXT_OPCODE(op_mod);
    50545054        }
    … …  
    50585058            // https://bugs.webkit.org/show_bug.cgi?id=160012
    50595059            auto bytecode = currentInstruction->as<OpPow>();
    5060             Node* op1 = get(bytecode.lhs);
    5061             Node* op2 = get(bytecode.rhs);
    5062             set(bytecode.dst, addToGraph(ArithPow, op1, op2));
     5060            Node* op1 = get(bytecode.m_lhs);
     5061            Node* op2 = get(bytecode.m_rhs);
     5062            set(bytecode.m_dst, addToGraph(ArithPow, op1, op2));
    50635063            NEXT_OPCODE(op_pow);
    50645064        }
    … …  
    50665066        case op_div: {
    50675067            auto bytecode = currentInstruction->as<OpDiv>();
    5068             Node* op1 = get(bytecode.lhs);
    5069             Node* op2 = get(bytecode.rhs);
     5068            Node* op1 = get(bytecode.m_lhs);
     5069            Node* op2 = get(bytecode.m_rhs);
    50705070            if (op1->hasNumberResult() && op2->hasNumberResult())
    5071                 set(bytecode.dst, makeDivSafe(addToGraph(ArithDiv, op1, op2)));
     5071                set(bytecode.m_dst, makeDivSafe(addToGraph(ArithDiv, op1, op2)));
    50725072            else
    5073                 set(bytecode.dst, makeDivSafe(addToGraph(ValueDiv, op1, op2)));
     5073                set(bytecode.m_dst, makeDivSafe(addToGraph(ValueDiv, op1, op2)));
    50745074            NEXT_OPCODE(op_div);
    50755075        }
    … …  
    50865086        case op_mov: {
    50875087            auto bytecode = currentInstruction->as<OpMov>();
    5088             Node* op = get(bytecode.src);
    5089             set(bytecode.dst, op);
     5088            Node* op = get(bytecode.m_src);
     5089            set(bytecode.m_dst, op);
    50905090            NEXT_OPCODE(op_mov);
    50915091        }
    … …  
    50935093        case op_check_tdz: {
    50945094            auto bytecode = currentInstruction->as<OpCheckTdz>();
    5095             addToGraph(CheckNotEmpty, get(bytecode.target));
     5095            addToGraph(CheckNotEmpty, get(bytecode.m_target));
    50965096            NEXT_OPCODE(op_check_tdz);
    50975097        }
    … …  
    51015101            JSFunction* defaultHasInstanceSymbolFunction = m_inlineStackTop->m_codeBlock->globalObjectFor(currentCodeOrigin())->functionProtoHasInstanceSymbolFunction();
    51025102
    5103             Node* constructor = get(VirtualRegister(bytecode.constructor));
    5104             Node* hasInstanceValue = get(VirtualRegister(bytecode.hasInstanceValue));
    5105 
    5106             set(VirtualRegister(bytecode.dst), addToGraph(OverridesHasInstance, OpInfo(m_graph.freeze(defaultHasInstanceSymbolFunction)), constructor, hasInstanceValue));
     5103            Node* constructor = get(VirtualRegister(bytecode.m_constructor));
     5104            Node* hasInstanceValue = get(VirtualRegister(bytecode.m_hasInstanceValue));
     5105
     5106            set(VirtualRegister(bytecode.m_dst), addToGraph(OverridesHasInstance, OpInfo(m_graph.freeze(defaultHasInstanceSymbolFunction)), constructor, hasInstanceValue));
    51075107            NEXT_OPCODE(op_overrides_has_instance);
    51085108        }
    … …  
    51105110        case op_identity_with_profile: {
    51115111            auto bytecode = currentInstruction->as<OpIdentityWithProfile>();
    5112             Node* srcDst = get(bytecode.srcDst);
    5113             SpeculatedType speculation = static_cast<SpeculatedType>(bytecode.topProfile) << 32 | static_cast<SpeculatedType>(bytecode.bottomProfile);
    5114             set(bytecode.srcDst, addToGraph(IdentityWithProfile, OpInfo(speculation), srcDst));
     5112            Node* srcDst = get(bytecode.m_srcDst);
     5113            SpeculatedType speculation = static_cast<SpeculatedType>(bytecode.m_topProfile) << 32 | static_cast<SpeculatedType>(bytecode.m_bottomProfile);
     5114            set(bytecode.m_srcDst, addToGraph(IdentityWithProfile, OpInfo(speculation), srcDst));
    51155115            NEXT_OPCODE(op_identity_with_profile);
    51165116        }
    … …  
    51235123                m_currentIndex);
    51245124           
    5125             Node* value = get(bytecode.value);
    5126             Node* prototype = get(bytecode.prototype);
     5125            Node* value = get(bytecode.m_value);
     5126            Node* prototype = get(bytecode.m_prototype);
    51275127
    51285128            // Only inline it if it's Simple with a commonPrototype; bottom/top or variable
    … …  
    51525152                if (allOK) {
    51535153                    Node* match = addToGraph(MatchStructure, OpInfo(data), value);
    5154                     set(bytecode.dst, match);
     5154                    set(bytecode.m_dst, match);
    51555155                    NEXT_OPCODE(op_instanceof);
    51565156                }
    51575157            }
    51585158           
    5159             set(bytecode.dst, addToGraph(InstanceOf, value, prototype));
     5159            set(bytecode.m_dst, addToGraph(InstanceOf, value, prototype));
    51605160            NEXT_OPCODE(op_instanceof);
    51615161        }
    … …  
    51635163        case op_instanceof_custom: {
    51645164            auto bytecode = currentInstruction->as<OpInstanceofCustom>();
    5165             Node* value = get(bytecode.value);
    5166             Node* constructor = get(bytecode.constructor);
    5167             Node* hasInstanceValue = get(bytecode.hasInstanceValue);
    5168             set(bytecode.dst, addToGraph(InstanceOfCustom, value, constructor, hasInstanceValue));
     5165            Node* value = get(bytecode.m_value);
     5166            Node* constructor = get(bytecode.m_constructor);
     5167            Node* hasInstanceValue = get(bytecode.m_hasInstanceValue);
     5168            set(bytecode.m_dst, addToGraph(InstanceOfCustom, value, constructor, hasInstanceValue));
    51695169            NEXT_OPCODE(op_instanceof_custom);
    51705170        }
    51715171        case op_is_empty: {
    51725172            auto bytecode = currentInstruction->as<OpIsEmpty>();
    5173             Node* value = get(bytecode.operand);
    5174             set(bytecode.dst, addToGraph(IsEmpty, value));
     5173            Node* value = get(bytecode.m_operand);
     5174            set(bytecode.m_dst, addToGraph(IsEmpty, value));
    51755175            NEXT_OPCODE(op_is_empty);
    51765176        }
    51775177        case op_is_undefined: {
    51785178            auto bytecode = currentInstruction->as<OpIsUndefined>();
    5179             Node* value = get(bytecode.operand);
    5180             set(bytecode.dst, addToGraph(IsUndefined, value));
     5179            Node* value = get(bytecode.m_operand);
     5180            set(bytecode.m_dst, addToGraph(IsUndefined, value));
    51815181            NEXT_OPCODE(op_is_undefined);
    51825182        }
    51835183        case op_is_undefined_or_null: {
    51845184            auto bytecode = currentInstruction->as<OpIsUndefinedOrNull>();
    5185             Node* value = get(bytecode.operand);
    5186             set(bytecode.dst, addToGraph(IsUndefinedOrNull, value));
     5185            Node* value = get(bytecode.m_operand);
     5186            set(bytecode.m_dst, addToGraph(IsUndefinedOrNull, value));
    51875187            NEXT_OPCODE(op_is_undefined_or_null);
    51885188        }
    … …  
    51905190        case op_is_boolean: {
    51915191            auto bytecode = currentInstruction->as<OpIsBoolean>();
    5192             Node* value = get(bytecode.operand);
    5193             set(bytecode.dst, addToGraph(IsBoolean, value));
     5192            Node* value = get(bytecode.m_operand);
     5193            set(bytecode.m_dst, addToGraph(IsBoolean, value));
    51945194            NEXT_OPCODE(op_is_boolean);
    51955195        }
    … …  
    51975197        case op_is_number: {
    51985198            auto bytecode = currentInstruction->as<OpIsNumber>();
    5199             Node* value = get(bytecode.operand);
    5200             set(bytecode.dst, addToGraph(IsNumber, value));
     5199            Node* value = get(bytecode.m_operand);
     5200            set(bytecode.m_dst, addToGraph(IsNumber, value));
    52015201            NEXT_OPCODE(op_is_number);
    52025202        }
    … …  
    52045204        case op_is_cell_with_type: {
    52055205            auto bytecode = currentInstruction->as<OpIsCellWithType>();
    5206             Node* value = get(bytecode.operand);
    5207             set(bytecode.dst, addToGraph(IsCellWithType, OpInfo(bytecode.type), value));
     5206            Node* value = get(bytecode.m_operand);
     5207            set(bytecode.m_dst, addToGraph(IsCellWithType, OpInfo(bytecode.m_type), value));
    52085208            NEXT_OPCODE(op_is_cell_with_type);
    52095209        }
    … …  
    52115211        case op_is_object: {
    52125212            auto bytecode = currentInstruction->as<OpIsObject>();
    5213             Node* value = get(bytecode.operand);
    5214             set(bytecode.dst, addToGraph(IsObject, value));
     5213            Node* value = get(bytecode.m_operand);
     5214            set(bytecode.m_dst, addToGraph(IsObject, value));
    52155215            NEXT_OPCODE(op_is_object);
    52165216        }
    … …  
    52185218        case op_is_object_or_null: {
    52195219            auto bytecode = currentInstruction->as<OpIsObjectOrNull>();
    5220             Node* value = get(bytecode.operand);
    5221             set(bytecode.dst, addToGraph(IsObjectOrNull, value));
     5220            Node* value = get(bytecode.m_operand);
     5221            set(bytecode.m_dst, addToGraph(IsObjectOrNull, value));
    52225222            NEXT_OPCODE(op_is_object_or_null);
    52235223        }
    … …  
    52255225        case op_is_function: {
    52265226            auto bytecode = currentInstruction->as<OpIsFunction>();
    5227             Node* value = get(bytecode.operand);
    5228             set(bytecode.dst, addToGraph(IsFunction, value));
     5227            Node* value = get(bytecode.m_operand);
     5228            set(bytecode.m_dst, addToGraph(IsFunction, value));
    52295229            NEXT_OPCODE(op_is_function);
    52305230        }
    … …  
    52325232        case op_not: {
    52335233            auto bytecode = currentInstruction->as<OpNot>();
    5234             Node* value = get(bytecode.operand);
    5235             set(bytecode.dst, addToGraph(LogicalNot, value));
     5234            Node* value = get(bytecode.m_operand);
     5235            set(bytecode.m_dst, addToGraph(LogicalNot, value));
    52365236            NEXT_OPCODE(op_not);
    52375237        }
    … …  
    52395239        case op_to_primitive: {
    52405240            auto bytecode = currentInstruction->as<OpToPrimitive>();
    5241             Node* value = get(bytecode.src);
    5242             set(bytecode.dst, addToGraph(ToPrimitive, value));
     5241            Node* value = get(bytecode.m_src);
     5242            set(bytecode.m_dst, addToGraph(ToPrimitive, value));
    52435243            NEXT_OPCODE(op_to_primitive);
    52445244        }
    … …  
    52465246        case op_strcat: {
    52475247            auto bytecode = currentInstruction->as<OpStrcat>();
    5248             int startOperand = bytecode.src.offset();
    5249             int numOperands = bytecode.count;
     5248            int startOperand = bytecode.m_src.offset();
     5249            int numOperands = bytecode.m_count;
    52505250#if CPU(X86)
    52515251            // X86 doesn't have enough registers to compile MakeRope with three arguments. The
    … …  
    52725272                operands[indexInOperands++] = get(VirtualRegister(startOperand - operandIdx));
    52735273            }
    5274             set(bytecode.dst, addToGraph(StrCat, operands[0], operands[1], operands[2]));
     5274            set(bytecode.m_dst, addToGraph(StrCat, operands[0], operands[1], operands[2]));
    52755275            NEXT_OPCODE(op_strcat);
    52765276        }
    … …  
    52785278        case op_less: {
    52795279            auto bytecode = currentInstruction->as<OpLess>();
    5280             Node* op1 = get(bytecode.lhs);
    5281             Node* op2 = get(bytecode.rhs);
    5282             set(bytecode.dst, addToGraph(CompareLess, op1, op2));
     5280            Node* op1 = get(bytecode.m_lhs);
     5281            Node* op2 = get(bytecode.m_rhs);
     5282            set(bytecode.m_dst, addToGraph(CompareLess, op1, op2));
    52835283            NEXT_OPCODE(op_less);
    52845284        }
    … …  
    52865286        case op_lesseq: {
    52875287            auto bytecode = currentInstruction->as<OpLesseq>();
    5288             Node* op1 = get(bytecode.lhs);
    5289             Node* op2 = get(bytecode.rhs);
    5290             set(bytecode.dst, addToGraph(CompareLessEq, op1, op2));
     5288            Node* op1 = get(bytecode.m_lhs);
     5289            Node* op2 = get(bytecode.m_rhs);
     5290            set(bytecode.m_dst, addToGraph(CompareLessEq, op1, op2));
    52915291            NEXT_OPCODE(op_lesseq);
    52925292        }
    … …  
    52945294        case op_greater: {
    52955295            auto bytecode = currentInstruction->as<OpGreater>();
    5296             Node* op1 = get(bytecode.lhs);
    5297             Node* op2 = get(bytecode.rhs);
    5298             set(bytecode.dst, addToGraph(CompareGreater, op1, op2));
     5296            Node* op1 = get(bytecode.m_lhs);
     5297            Node* op2 = get(bytecode.m_rhs);
     5298            set(bytecode.m_dst, addToGraph(CompareGreater, op1, op2));
    52995299            NEXT_OPCODE(op_greater);
    53005300        }
    … …  
    53025302        case op_greatereq: {
    53035303            auto bytecode = currentInstruction->as<OpGreatereq>();
    5304             Node* op1 = get(bytecode.lhs);
    5305             Node* op2 = get(bytecode.rhs);
    5306             set(bytecode.dst, addToGraph(CompareGreaterEq, op1, op2));
     5304            Node* op1 = get(bytecode.m_lhs);
     5305            Node* op2 = get(bytecode.m_rhs);
     5306            set(bytecode.m_dst, addToGraph(CompareGreaterEq, op1, op2));
    53075307            NEXT_OPCODE(op_greatereq);
    53085308        }
    … …  
    53105310        case op_below: {
    53115311            auto bytecode = currentInstruction->as<OpBelow>();
    5312             Node* op1 = get(bytecode.lhs);
    5313             Node* op2 = get(bytecode.rhs);
    5314             set(bytecode.dst, addToGraph(CompareBelow, op1, op2));
     5312            Node* op1 = get(bytecode.m_lhs);
     5313            Node* op2 = get(bytecode.m_rhs);
     5314            set(bytecode.m_dst, addToGraph(CompareBelow, op1, op2));
    53155315            NEXT_OPCODE(op_below);
    53165316        }
    … …  
    53185318        case op_beloweq: {
    53195319            auto bytecode = currentInstruction->as<OpBeloweq>();
    5320             Node* op1 = get(bytecode.lhs);
    5321             Node* op2 = get(bytecode.rhs);
    5322             set(bytecode.dst, addToGraph(CompareBelowEq, op1, op2));
     5320            Node* op1 = get(bytecode.m_lhs);
     5321            Node* op2 = get(bytecode.m_rhs);
     5322            set(bytecode.m_dst, addToGraph(CompareBelowEq, op1, op2));
    53235323            NEXT_OPCODE(op_beloweq);
    53245324        }
    … …  
    53265326        case op_eq: {
    53275327            auto bytecode = currentInstruction->as<OpEq>();
    5328             Node* op1 = get(bytecode.lhs);
    5329             Node* op2 = get(bytecode.rhs);
    5330             set(bytecode.dst, addToGraph(CompareEq, op1, op2));
     5328            Node* op1 = get(bytecode.m_lhs);
     5329            Node* op2 = get(bytecode.m_rhs);
     5330            set(bytecode.m_dst, addToGraph(CompareEq, op1, op2));
    53315331            NEXT_OPCODE(op_eq);
    53325332        }
    … …  
    53345334        case op_eq_null: {
    53355335            auto bytecode = currentInstruction->as<OpEqNull>();
    5336             Node* value = get(bytecode.operand);
     5336            Node* value = get(bytecode.m_operand);
    53375337            Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
    5338             set(bytecode.dst, addToGraph(CompareEq, value, nullConstant));
     5338            set(bytecode.m_dst, addToGraph(CompareEq, value, nullConstant));
    53395339            NEXT_OPCODE(op_eq_null);
    53405340        }
    … …  
    53425342        case op_stricteq: {
    53435343            auto bytecode = currentInstruction->as<OpStricteq>();
    5344             Node* op1 = get(bytecode.lhs);
    5345             Node* op2 = get(bytecode.rhs);
    5346             set(bytecode.dst, addToGraph(CompareStrictEq, op1, op2));
     5344            Node* op1 = get(bytecode.m_lhs);
     5345            Node* op2 = get(bytecode.m_rhs);
     5346            set(bytecode.m_dst, addToGraph(CompareStrictEq, op1, op2));
    53475347            NEXT_OPCODE(op_stricteq);
    53485348        }
    … …  
    53505350        case op_neq: {
    53515351            auto bytecode = currentInstruction->as<OpNeq>();
    5352             Node* op1 = get(bytecode.lhs);
    5353             Node* op2 = get(bytecode.rhs);
    5354             set(bytecode.dst, addToGraph(LogicalNot, addToGraph(CompareEq, op1, op2)));
     5352            Node* op1 = get(bytecode.m_lhs);
     5353            Node* op2 = get(bytecode.m_rhs);
     5354            set(bytecode.m_dst, addToGraph(LogicalNot, addToGraph(CompareEq, op1, op2)));
    53555355            NEXT_OPCODE(op_neq);
    53565356        }
    … …  
    53585358        case op_neq_null: {
    53595359            auto bytecode = currentInstruction->as<OpNeqNull>();
    5360             Node* value = get(bytecode.operand);
     5360            Node* value = get(bytecode.m_operand);
    53615361            Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
    5362             set(bytecode.dst, addToGraph(LogicalNot, addToGraph(CompareEq, value, nullConstant)));
     5362            set(bytecode.m_dst, addToGraph(LogicalNot, addToGraph(CompareEq, value, nullConstant)));
    53635363            NEXT_OPCODE(op_neq_null);
    53645364        }
    … …  
    53665366        case op_nstricteq: {
    53675367            auto bytecode = currentInstruction->as<OpNstricteq>();
    5368             Node* op1 = get(bytecode.lhs);
    5369             Node* op2 = get(bytecode.rhs);
     5368            Node* op1 = get(bytecode.m_lhs);
     5369            Node* op2 = get(bytecode.m_rhs);
    53705370            Node* invertedResult;
    53715371            invertedResult = addToGraph(CompareStrictEq, op1, op2);
    5372             set(bytecode.dst, addToGraph(LogicalNot, invertedResult));
     5372            set(bytecode.m_dst, addToGraph(LogicalNot, invertedResult));
    53735373            NEXT_OPCODE(op_nstricteq);
    53745374        }
    … …  
    53805380            SpeculatedType prediction = getPredictionWithoutOSRExit();
    53815381
    5382             Node* base = get(bytecode.base);
    5383             Node* property = get(bytecode.property);
     5382            Node* base = get(bytecode.m_base);
     5383            Node* property = get(bytecode.m_property);
    53845384            bool compiledAsGetById = false;
    53855385            GetByIdStatus getByIdStatus;
    … …  
    54155415
    54165416            if (compiledAsGetById)
    5417                 handleGetById(bytecode.dst, prediction, base, identifierNumber, getByIdStatus, AccessType::Get, currentInstruction->size());
     5417                handleGetById(bytecode.m_dst, prediction, base, identifierNumber, getByIdStatus, AccessType::Get, currentInstruction->size());
    54185418            else {
    5419                 ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).arrayProfile, Array::Read);
     5419                ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).m_arrayProfile, Array::Read);
    54205420                // FIXME: We could consider making this not vararg, since it only uses three child
    54215421                // slots.
    … …  
    54265426                Node* getByVal = addToGraph(Node::VarArg, GetByVal, OpInfo(arrayMode.asWord()), OpInfo(prediction));
    54275427                m_exitOK = false; // GetByVal must be treated as if it clobbers exit state, since FixupPhase may make it generic.
    5428                 set(bytecode.dst, getByVal);
     5428                set(bytecode.m_dst, getByVal);
    54295429            }
    54305430
    … …  
    54365436            SpeculatedType prediction = getPrediction();
    54375437
    5438             Node* base = get(bytecode.base);
    5439             Node* thisValue = get(bytecode.thisValue);
    5440             Node* property = get(bytecode.property);
     5438            Node* base = get(bytecode.m_base);
     5439            Node* thisValue = get(bytecode.m_thisValue);
     5440            Node* property = get(bytecode.m_property);
    54415441            Node* getByValWithThis = addToGraph(GetByValWithThis, OpInfo(), OpInfo(prediction), base, thisValue, property);
    5442             set(bytecode.dst, getByValWithThis);
     5442            set(bytecode.m_dst, getByValWithThis);
    54435443
    54445444            NEXT_OPCODE(op_get_by_val_with_this);
    … …  
    54565456        case op_put_by_val_with_this: {
    54575457            auto bytecode = currentInstruction->as<OpPutByValWithThis>();
    5458             Node* base = get(bytecode.base);
    5459             Node* thisValue = get(bytecode.thisValue);
    5460             Node* property = get(bytecode.property);
    5461             Node* value = get(bytecode.value);
     5458            Node* base = get(bytecode.m_base);
     5459            Node* thisValue = get(bytecode.m_thisValue);
     5460            Node* property = get(bytecode.m_property);
     5461            Node* value = get(bytecode.m_value);
    54625462
    54635463            addVarArgChild(base);
    … …  
    54725472        case op_define_data_property: {
    54735473            auto bytecode = currentInstruction->as<OpDefineDataProperty>();
    5474             Node* base = get(bytecode.base);
    5475             Node* property = get(bytecode.property);
    5476             Node* value = get(bytecode.value);
    5477             Node* attributes = get(bytecode.attributes);
     5474            Node* base = get(bytecode.m_base);
     5475            Node* property = get(bytecode.m_property);
     5476            Node* value = get(bytecode.m_value);
     5477            Node* attributes = get(bytecode.m_attributes);
    54785478
    54795479            addVarArgChild(base);
    … …  
    54885488        case op_define_accessor_property: {
    54895489            auto bytecode = currentInstruction->as<OpDefineAccessorProperty>();
    5490             Node* base = get(bytecode.base);
    5491             Node* property = get(bytecode.property);
    5492             Node* getter = get(bytecode.getter);
    5493             Node* setter = get(bytecode.setter);
    5494             Node* attributes = get(bytecode.attributes);
     5490            Node* base = get(bytecode.m_base);
     5491            Node* property = get(bytecode.m_property);
     5492            Node* getter = get(bytecode.m_getter);
     5493            Node* setter = get(bytecode.m_setter);
     5494            Node* attributes = get(bytecode.m_attributes);
    54955495
    54965496            addVarArgChild(base);
    … …  
    55205520
    55215521            auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
    5522             Node* base = get(bytecode.base);
    5523             Node* thisValue = get(bytecode.thisValue);
    5524             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
    5525 
    5526             set(bytecode.dst,
     5522            Node* base = get(bytecode.m_base);
     5523            Node* thisValue = get(bytecode.m_thisValue);
     5524            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
     5525
     5526            set(bytecode.m_dst,
    55275527                addToGraph(GetByIdWithThis, OpInfo(identifierNumber), OpInfo(prediction), base, thisValue));
    55285528
    … …  
    55315531        case op_put_by_id: {
    55325532            auto bytecode = currentInstruction->as<OpPutById>();
    5533             Node* value = get(bytecode.value);
    5534             Node* base = get(bytecode.base);
    5535             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
    5536             bool direct = !!(bytecode.flags & PutByIdIsDirect);
     5533            Node* value = get(bytecode.m_value);
     5534            Node* base = get(bytecode.m_base);
     5535            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
     5536            bool direct = !!(bytecode.m_flags & PutByIdIsDirect);
    55375537
    55385538            PutByIdStatus putByIdStatus = PutByIdStatus::computeFor(
    … …  
    55475547        case op_put_by_id_with_this: {
    55485548            auto bytecode = currentInstruction->as<OpPutByIdWithThis>();
    5549             Node* base = get(bytecode.base);
    5550             Node* thisValue = get(bytecode.thisValue);
    5551             Node* value = get(bytecode.value);
    5552             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
     5549            Node* base = get(bytecode.m_base);
     5550            Node* thisValue = get(bytecode.m_thisValue);
     5551            Node* value = get(bytecode.m_value);
     5552            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
    55535553
    55545554            addToGraph(PutByIdWithThis, OpInfo(identifierNumber), base, thisValue, value);
    … …  
    55665566        case op_put_getter_setter_by_id: {
    55675567            auto bytecode = currentInstruction->as<OpPutGetterSetterById>();
    5568             Node* base = get(bytecode.base);
    5569             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
    5570             Node* getter = get(bytecode.getter);
    5571             Node* setter = get(bytecode.setter);
    5572             addToGraph(PutGetterSetterById, OpInfo(identifierNumber), OpInfo(bytecode.attributes), base, getter, setter);
     5568            Node* base = get(bytecode.m_base);
     5569            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
     5570            Node* getter = get(bytecode.m_getter);
     5571            Node* setter = get(bytecode.m_setter);
     5572            addToGraph(PutGetterSetterById, OpInfo(identifierNumber), OpInfo(bytecode.m_attributes), base, getter, setter);
    55735573            NEXT_OPCODE(op_put_getter_setter_by_id);
    55745574        }
    … …  
    55845584        case op_del_by_id: {
    55855585            auto bytecode = currentInstruction->as<OpDelById>();
    5586             Node* base = get(bytecode.base);
    5587             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
    5588             set(bytecode.dst, addToGraph(DeleteById, OpInfo(identifierNumber), base));
     5586            Node* base = get(bytecode.m_base);
     5587            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
     5588            set(bytecode.m_dst, addToGraph(DeleteById, OpInfo(identifierNumber), base));
    55895589            NEXT_OPCODE(op_del_by_id);
    55905590        }
    … …  
    55925592        case op_del_by_val: {
    55935593            auto bytecode = currentInstruction->as<OpDelByVal>();
    5594             Node* base = get(bytecode.base);
    5595             Node* key = get(bytecode.property);
    5596             set(bytecode.dst, addToGraph(DeleteByVal, base, key));
     5594            Node* base = get(bytecode.m_base);
     5595            Node* key = get(bytecode.m_property);
     5596            set(bytecode.m_dst, addToGraph(DeleteByVal, base, key));
    55975597            NEXT_OPCODE(op_del_by_val);
    55985598        }
    … …  
    56015601            auto bytecode = currentInstruction->as<OpProfileType>();
    56025602            auto& metadata = bytecode.metadata(codeBlock);
    5603             Node* valueToProfile = get(bytecode.target);
    5604             addToGraph(ProfileType, OpInfo(metadata.typeLocation), valueToProfile);
     5603            Node* valueToProfile = get(bytecode.m_target);
     5604            addToGraph(ProfileType, OpInfo(metadata.m_typeLocation), valueToProfile);
    56055605            NEXT_OPCODE(op_profile_type);
    56065606        }
    … …  
    56085608        case op_profile_control_flow: {
    56095609            auto bytecode = currentInstruction->as<OpProfileControlFlow>();
    5610             BasicBlockLocation* basicBlockLocation = bytecode.metadata(codeBlock).basicBlockLocation;
     5610            BasicBlockLocation* basicBlockLocation = bytecode.metadata(codeBlock).m_basicBlockLocation;
    56115611            addToGraph(ProfileControlFlow, OpInfo(basicBlockLocation));
    56125612            NEXT_OPCODE(op_profile_control_flow);
    … …  
    56185618            ASSERT(!m_currentBlock->terminal());
    56195619            auto bytecode = currentInstruction->as<OpJmp>();
    5620             int relativeOffset = jumpTarget(bytecode.target);
     5620            int relativeOffset = jumpTarget(bytecode.m_target);
    56215621            addToGraph(Jump, OpInfo(m_currentIndex + relativeOffset));
    56225622            if (relativeOffset <= 0)
    … …  
    56275627        case op_jtrue: {
    56285628            auto bytecode = currentInstruction->as<OpJtrue>();
    5629             unsigned relativeOffset = jumpTarget(bytecode.target);
    5630             Node* condition = get(bytecode.condition);
     5629            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5630            Node* condition = get(bytecode.m_condition);
    56315631            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    56325632            LAST_OPCODE(op_jtrue);
    … …  
    56355635        case op_jfalse: {
    56365636            auto bytecode = currentInstruction->as<OpJfalse>();
    5637             unsigned relativeOffset = jumpTarget(bytecode.target);
    5638             Node* condition = get(bytecode.condition);
     5637            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5638            Node* condition = get(bytecode.m_condition);
    56395639            addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    56405640            LAST_OPCODE(op_jfalse);
    … …  
    56435643        case op_jeq_null: {
    56445644            auto bytecode = currentInstruction->as<OpJeqNull>();
    5645             unsigned relativeOffset = jumpTarget(bytecode.target);
    5646             Node* value = get(bytecode.value);
     5645            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5646            Node* value = get(bytecode.m_value);
    56475647            Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
    56485648            Node* condition = addToGraph(CompareEq, value, nullConstant);
    … …  
    56535653        case op_jneq_null: {
    56545654            auto bytecode = currentInstruction->as<OpJneqNull>();
    5655             unsigned relativeOffset = jumpTarget(bytecode.target);
    5656             Node* value = get(bytecode.value);
     5655            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5656            Node* value = get(bytecode.m_value);
    56575657            Node* nullConstant = addToGraph(JSConstant, OpInfo(m_constantNull));
    56585658            Node* condition = addToGraph(CompareEq, value, nullConstant);
    … …  
    56635663        case op_jless: {
    56645664            auto bytecode = currentInstruction->as<OpJless>();
    5665             unsigned relativeOffset = jumpTarget(bytecode.target);
    5666             Node* op1 = get(bytecode.lhs);
    5667             Node* op2 = get(bytecode.rhs);
     5665            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5666            Node* op1 = get(bytecode.m_lhs);
     5667            Node* op2 = get(bytecode.m_rhs);
    56685668            Node* condition = addToGraph(CompareLess, op1, op2);
    56695669            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    56735673        case op_jlesseq: {
    56745674            auto bytecode = currentInstruction->as<OpJlesseq>();
    5675             unsigned relativeOffset = jumpTarget(bytecode.target);
    5676             Node* op1 = get(bytecode.lhs);
    5677             Node* op2 = get(bytecode.rhs);
     5675            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5676            Node* op1 = get(bytecode.m_lhs);
     5677            Node* op2 = get(bytecode.m_rhs);
    56785678            Node* condition = addToGraph(CompareLessEq, op1, op2);
    56795679            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    56835683        case op_jgreater: {
    56845684            auto bytecode = currentInstruction->as<OpJgreater>();
    5685             unsigned relativeOffset = jumpTarget(bytecode.target);
    5686             Node* op1 = get(bytecode.lhs);
    5687             Node* op2 = get(bytecode.rhs);
     5685            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5686            Node* op1 = get(bytecode.m_lhs);
     5687            Node* op2 = get(bytecode.m_rhs);
    56885688            Node* condition = addToGraph(CompareGreater, op1, op2);
    56895689            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    56935693        case op_jgreatereq: {
    56945694            auto bytecode = currentInstruction->as<OpJgreatereq>();
    5695             unsigned relativeOffset = jumpTarget(bytecode.target);
    5696             Node* op1 = get(bytecode.lhs);
    5697             Node* op2 = get(bytecode.rhs);
     5695            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5696            Node* op1 = get(bytecode.m_lhs);
     5697            Node* op2 = get(bytecode.m_rhs);
    56985698            Node* condition = addToGraph(CompareGreaterEq, op1, op2);
    56995699            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    57035703        case op_jeq: {
    57045704            auto bytecode = currentInstruction->as<OpJeq>();
    5705             unsigned relativeOffset = jumpTarget(bytecode.target);
    5706             Node* op1 = get(bytecode.lhs);
    5707             Node* op2 = get(bytecode.rhs);
     5705            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5706            Node* op1 = get(bytecode.m_lhs);
     5707            Node* op2 = get(bytecode.m_rhs);
    57085708            Node* condition = addToGraph(CompareEq, op1, op2);
    57095709            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    57135713        case op_jstricteq: {
    57145714            auto bytecode = currentInstruction->as<OpJstricteq>();
    5715             unsigned relativeOffset = jumpTarget(bytecode.target);
    5716             Node* op1 = get(bytecode.lhs);
    5717             Node* op2 = get(bytecode.rhs);
     5715            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5716            Node* op1 = get(bytecode.m_lhs);
     5717            Node* op2 = get(bytecode.m_rhs);
    57185718            Node* condition = addToGraph(CompareStrictEq, op1, op2);
    57195719            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    57235723        case op_jnless: {
    57245724            auto bytecode = currentInstruction->as<OpJnless>();
    5725             unsigned relativeOffset = jumpTarget(bytecode.target);
    5726             Node* op1 = get(bytecode.lhs);
    5727             Node* op2 = get(bytecode.rhs);
     5725            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5726            Node* op1 = get(bytecode.m_lhs);
     5727            Node* op2 = get(bytecode.m_rhs);
    57285728            Node* condition = addToGraph(CompareLess, op1, op2);
    57295729            addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    … …  
    57335733        case op_jnlesseq: {
    57345734            auto bytecode = currentInstruction->as<OpJnlesseq>();
    5735             unsigned relativeOffset = jumpTarget(bytecode.target);
    5736             Node* op1 = get(bytecode.lhs);
    5737             Node* op2 = get(bytecode.rhs);
     5735            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5736            Node* op1 = get(bytecode.m_lhs);
     5737            Node* op2 = get(bytecode.m_rhs);
    57385738            Node* condition = addToGraph(CompareLessEq, op1, op2);
    57395739            addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    … …  
    57435743        case op_jngreater: {
    57445744            auto bytecode = currentInstruction->as<OpJngreater>();
    5745             unsigned relativeOffset = jumpTarget(bytecode.target);
    5746             Node* op1 = get(bytecode.lhs);
    5747             Node* op2 = get(bytecode.rhs);
     5745            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5746            Node* op1 = get(bytecode.m_lhs);
     5747            Node* op2 = get(bytecode.m_rhs);
    57485748            Node* condition = addToGraph(CompareGreater, op1, op2);
    57495749            addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    … …  
    57535753        case op_jngreatereq: {
    57545754            auto bytecode = currentInstruction->as<OpJngreatereq>();
    5755             unsigned relativeOffset = jumpTarget(bytecode.target);
    5756             Node* op1 = get(bytecode.lhs);
    5757             Node* op2 = get(bytecode.rhs);
     5755            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5756            Node* op1 = get(bytecode.m_lhs);
     5757            Node* op2 = get(bytecode.m_rhs);
    57585758            Node* condition = addToGraph(CompareGreaterEq, op1, op2);
    57595759            addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    … …  
    57635763        case op_jneq: {
    57645764            auto bytecode = currentInstruction->as<OpJneq>();
    5765             unsigned relativeOffset = jumpTarget(bytecode.target);
    5766             Node* op1 = get(bytecode.lhs);
    5767             Node* op2 = get(bytecode.rhs);
     5765            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5766            Node* op1 = get(bytecode.m_lhs);
     5767            Node* op2 = get(bytecode.m_rhs);
    57685768            Node* condition = addToGraph(CompareEq, op1, op2);
    57695769            addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    … …  
    57735773        case op_jnstricteq: {
    57745774            auto bytecode = currentInstruction->as<OpJnstricteq>();
    5775             unsigned relativeOffset = jumpTarget(bytecode.target);
    5776             Node* op1 = get(bytecode.lhs);
    5777             Node* op2 = get(bytecode.rhs);
     5775            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5776            Node* op1 = get(bytecode.m_lhs);
     5777            Node* op2 = get(bytecode.m_rhs);
    57785778            Node* condition = addToGraph(CompareStrictEq, op1, op2);
    57795779            addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    … …  
    57835783        case op_jbelow: {
    57845784            auto bytecode = currentInstruction->as<OpJbelow>();
    5785             unsigned relativeOffset = jumpTarget(bytecode.target);
    5786             Node* op1 = get(bytecode.lhs);
    5787             Node* op2 = get(bytecode.rhs);
     5785            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5786            Node* op1 = get(bytecode.m_lhs);
     5787            Node* op2 = get(bytecode.m_rhs);
    57885788            Node* condition = addToGraph(CompareBelow, op1, op2);
    57895789            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    57935793        case op_jbeloweq: {
    57945794            auto bytecode = currentInstruction->as<OpJbeloweq>();
    5795             unsigned relativeOffset = jumpTarget(bytecode.target);
    5796             Node* op1 = get(bytecode.lhs);
    5797             Node* op2 = get(bytecode.rhs);
     5795            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     5796            Node* op1 = get(bytecode.m_lhs);
     5797            Node* op2 = get(bytecode.m_rhs);
    57985798            Node* condition = addToGraph(CompareBelowEq, op1, op2);
    57995799            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + currentInstruction->size())), condition);
    … …  
    58055805            SwitchData& data = *m_graph.m_switchData.add();
    58065806            data.kind = SwitchImm;
    5807             data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.tableIndex];
    5808             data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.defaultOffset));
     5807            data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.m_tableIndex];
     5808            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.m_defaultOffset));
    58095809            SimpleJumpTable& table = m_codeBlock->switchJumpTable(data.switchTableIndex);
    58105810            for (unsigned i = 0; i < table.branchOffsets.size(); ++i) {
    … …  
    58165816                data.cases.append(SwitchCase::withBytecodeIndex(m_graph.freeze(jsNumber(static_cast<int32_t>(table.min + i))), target));
    58175817            }
    5818             addToGraph(Switch, OpInfo(&data), get(bytecode.scrutinee));
     5818            addToGraph(Switch, OpInfo(&data), get(bytecode.m_scrutinee));
    58195819            flushIfTerminal(data);
    58205820            LAST_OPCODE(op_switch_imm);
    … …  
    58255825            SwitchData& data = *m_graph.m_switchData.add();
    58265826            data.kind = SwitchChar;
    5827             data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.tableIndex];
    5828             data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.defaultOffset));
     5827            data.switchTableIndex = m_inlineStackTop->m_switchRemap[bytecode.m_tableIndex];
     5828            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.m_defaultOffset));
    58295829            SimpleJumpTable& table = m_codeBlock->switchJumpTable(data.switchTableIndex);
    58305830            for (unsigned i = 0; i < table.branchOffsets.size(); ++i) {
    … …  
    58375837                    SwitchCase::withBytecodeIndex(LazyJSValue::singleCharacterString(table.min + i), target));
    58385838            }
    5839             addToGraph(Switch, OpInfo(&data), get(bytecode.scrutinee));
     5839            addToGraph(Switch, OpInfo(&data), get(bytecode.m_scrutinee));
    58405840            flushIfTerminal(data);
    58415841            LAST_OPCODE(op_switch_char);
    … …  
    58465846            SwitchData& data = *m_graph.m_switchData.add();
    58475847            data.kind = SwitchString;
    5848             data.switchTableIndex = bytecode.tableIndex;
    5849             data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.defaultOffset));
     5848            data.switchTableIndex = bytecode.m_tableIndex;
     5849            data.fallThrough.setBytecodeIndex(m_currentIndex + jumpTarget(bytecode.m_defaultOffset));
    58505850            StringJumpTable& table = m_codeBlock->stringSwitchJumpTable(data.switchTableIndex);
    58515851            StringJumpTable::StringOffsetTable::iterator iter;
    … …  
    58585858                    SwitchCase::withBytecodeIndex(LazyJSValue::knownStringImpl(iter->key.get()), target));
    58595859            }
    5860             addToGraph(Switch, OpInfo(&data), get(bytecode.scrutinee));
     5860            addToGraph(Switch, OpInfo(&data), get(bytecode.m_scrutinee));
    58615861            flushIfTerminal(data);
    58625862            LAST_OPCODE(op_switch_string);
    … …  
    58685868            if (!inlineCallFrame()) {
    58695869                // Simple case: we are just producing a return
    5870                 addToGraph(Return, get(bytecode.value));
     5870                addToGraph(Return, get(bytecode.m_value));
    58715871                flushForReturn();
    58725872                LAST_OPCODE(op_ret);
    … …  
    58755875            flushForReturn();
    58765876            if (m_inlineStackTop->m_returnValue.isValid())
    5877                 setDirect(m_inlineStackTop->m_returnValue, get(bytecode.value), ImmediateSetWithFlush);
     5877                setDirect(m_inlineStackTop->m_returnValue, get(bytecode.m_value), ImmediateSetWithFlush);
    58785878
    58795879            if (!m_inlineStackTop->m_continuationBlock && m_currentIndex + currentInstruction->size() != m_inlineStackTop->m_codeBlock->instructions().size()) {
    … …  
    58945894        case op_end:
    58955895            ASSERT(!inlineCallFrame());
    5896             addToGraph(Return, get(currentInstruction->as<OpEnd>().value));
     5896            addToGraph(Return, get(currentInstruction->as<OpEnd>().m_value));
    58975897            flushForReturn();
    58985898            LAST_OPCODE(op_end);
    58995899
    59005900        case op_throw:
    5901             addToGraph(Throw, get(currentInstruction->as<OpThrow>().value));
     5901            addToGraph(Throw, get(currentInstruction->as<OpThrow>().m_value));
    59025902            flushForTerminal();
    59035903            LAST_OPCODE(op_throw);
    … …  
    59055905        case op_throw_static_error: {
    59065906            auto bytecode = currentInstruction->as<OpThrowStaticError>();
    5907             addToGraph(ThrowStaticError, OpInfo(bytecode.errorType), get(bytecode.message));
     5907            addToGraph(ThrowStaticError, OpInfo(bytecode.m_errorType), get(bytecode.m_message));
    59085908            flushForTerminal();
    59095909            LAST_OPCODE(op_throw_static_error);
    … …  
    59255925            RELEASE_ASSERT(!m_currentBlock->size() || (m_graph.compilation() && m_currentBlock->size() == 1 && m_currentBlock->at(0)->op() == CountExecution));
    59265926
    5927             ValueProfileAndOperandBuffer* buffer = bytecode.metadata(codeBlock).buffer;
     5927            ValueProfileAndOperandBuffer* buffer = bytecode.metadata(codeBlock).m_buffer;
    59285928
    59295929            if (!buffer) {
    … …  
    60986098        case op_call_eval: {
    60996099            auto bytecode = currentInstruction->as<OpCallEval>();
    6100             int registerOffset = -bytecode.argv;
    6101             addCall(bytecode.dst, CallEval, nullptr, get(bytecode.callee), bytecode.argc, registerOffset, getPrediction());
     6100            int registerOffset = -bytecode.m_argv;
     6101            addCall(bytecode.m_dst, CallEval, nullptr, get(bytecode.m_callee), bytecode.m_argc, registerOffset, getPrediction());
    61026102            NEXT_OPCODE(op_call_eval);
    61036103        }
    … …  
    61056105        case op_jneq_ptr: {
    61066106            auto bytecode = currentInstruction->as<OpJneqPtr>();
    6107             Special::Pointer specialPointer = bytecode.specialPointer;
     6107            Special::Pointer specialPointer = bytecode.m_specialPointer;
    61086108            ASSERT(pointerIsCell(specialPointer));
    61096109            JSCell* actualPointer = static_cast<JSCell*>(
    61106110                actualPointerFor(m_inlineStackTop->m_codeBlock, specialPointer));
    61116111            FrozenValue* frozenPointer = m_graph.freeze(actualPointer);
    6112             unsigned relativeOffset = jumpTarget(bytecode.target);
    6113             Node* child = get(bytecode.value);
    6114             if (bytecode.metadata(codeBlock).hasJumped) {
     6112            unsigned relativeOffset = jumpTarget(bytecode.m_target);
     6113            Node* child = get(bytecode.m_value);
     6114            if (bytecode.metadata(codeBlock).m_hasJumped) {
    61156115                Node* condition = addToGraph(CompareEqPtr, OpInfo(frozenPointer), child);
    61166116                addToGraph(Branch, OpInfo(branchData(m_currentIndex + currentInstruction->size(), m_currentIndex + relativeOffset)), condition);
    … …  
    61326132            {
    61336133                ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
    6134                 resolveType = metadata.resolveType;
    6135                 depth = metadata.localScopeDepth;
     6134                resolveType = metadata.m_resolveType;
     6135                depth = metadata.m_localScopeDepth;
    61366136                switch (resolveType) {
    61376137                case GlobalProperty:
    … …  
    61416141                case GlobalLexicalVar:
    61426142                case GlobalLexicalVarWithVarInjectionChecks:
    6143                     constantScope = metadata.constantScope.get();
     6143                    constantScope = metadata.m_constantScope.get();
    61446144                    break;
    61456145                case ModuleVar:
    6146                     lexicalEnvironment = metadata.lexicalEnvironment.get();
     6146                    lexicalEnvironment = metadata.m_lexicalEnvironment.get();
    61476147                    break;
    61486148                case LocalClosureVar:
    61496149                case ClosureVar:
    61506150                case ClosureVarWithVarInjectionChecks:
    6151                     symbolTable = metadata.symbolTable.get();
     6151                    symbolTable = metadata.m_symbolTable.get();
    61526152                    break;
    61536153                default:
    … …  
    61576157
    61586158            if (needsDynamicLookup(resolveType, op_resolve_scope)) {
    6159                 unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.var];
    6160                 set(bytecode.dst, addToGraph(ResolveScope, OpInfo(identifierNumber), get(bytecode.scope)));
     6159                unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_var];
     6160                set(bytecode.m_dst, addToGraph(ResolveScope, OpInfo(identifierNumber), get(bytecode.m_scope)));
    61616161                NEXT_OPCODE(op_resolve_scope);
    61626162            }
    … …  
    61706170            if (m_inlineStackTop->m_codeBlock->scriptMode() != JSParserScriptMode::Module) {
    61716171                if (resolveType == GlobalProperty || resolveType == GlobalPropertyWithVarInjectionChecks) {
    6172                     unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.var];
     6172                    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_var];
    61736173                    JSGlobalObject* globalObject = m_inlineStackTop->m_codeBlock->globalObject();
    61746174                    m_graph.globalProperties().addLazily(DesiredGlobalProperty(globalObject, identifierNumber));
    … …  
    61856185                RELEASE_ASSERT(constantScope);
    61866186                RELEASE_ASSERT(constantScope == JSScope::constantScopeForCodeBlock(resolveType, m_inlineStackTop->m_codeBlock));
    6187                 set(bytecode.dst, weakJSConstant(constantScope));
    6188                 addToGraph(Phantom, get(bytecode.scope));
     6187                set(bytecode.m_dst, weakJSConstant(constantScope));
     6188                addToGraph(Phantom, get(bytecode.m_scope));
    61896189                break;
    61906190            }
    … …  
    61936193                // we need not to keep it alive by the Phantom node.
    61946194                // Module environment is already strongly referenced by the CodeBlock.
    6195                 set(bytecode.dst, weakJSConstant(lexicalEnvironment));
     6195                set(bytecode.m_dst, weakJSConstant(lexicalEnvironment));
    61966196                break;
    61976197            }
    … …  
    61996199            case ClosureVar:
    62006200            case ClosureVarWithVarInjectionChecks: {
    6201                 Node* localBase = get(bytecode.scope);
     6201                Node* localBase = get(bytecode.m_scope);
    62026202                addToGraph(Phantom, localBase); // OSR exit cannot handle resolve_scope on a DCE'd scope.
    62036203               
    … …  
    62086208                    if (JSValue value = singleton->inferredValue()) {
    62096209                        m_graph.watchpoints().addLazily(singleton);
    6210                         set(bytecode.dst, weakJSConstant(value));
     6210                        set(bytecode.m_dst, weakJSConstant(value));
    62116211                        break;
    62126212                    }
    … …  
    62156215                    for (unsigned n = depth; n--;)
    62166216                        scope = scope->next();
    6217                     set(bytecode.dst, weakJSConstant(scope));
     6217                    set(bytecode.m_dst, weakJSConstant(scope));
    62186218                    break;
    62196219                }
    62206220                for (unsigned n = depth; n--;)
    62216221                    localBase = addToGraph(SkipScope, localBase);
    6222                 set(bytecode.dst, localBase);
     6222                set(bytecode.m_dst, localBase);
    62236223                break;
    62246224            }
    62256225            case UnresolvedProperty:
    62266226            case UnresolvedPropertyWithVarInjectionChecks: {
    6227                 addToGraph(Phantom, get(bytecode.scope));
     6227                addToGraph(Phantom, get(bytecode.m_scope));
    62286228                addToGraph(ForceOSRExit);
    6229                 set(bytecode.dst, addToGraph(JSConstant, OpInfo(m_constantNull)));
     6229                set(bytecode.m_dst, addToGraph(JSConstant, OpInfo(m_constantNull)));
    62306230                break;
    62316231            }
    … …  
    62386238        case op_resolve_scope_for_hoisting_func_decl_in_eval: {
    62396239            auto bytecode = currentInstruction->as<OpResolveScopeForHoistingFuncDeclInEval>();
    6240             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
    6241 
    6242             set(bytecode.dst, addToGraph(ResolveScopeForHoistingFuncDeclInEval, OpInfo(identifierNumber), get(bytecode.scope)));
     6240            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
     6241
     6242            set(bytecode.m_dst, addToGraph(ResolveScopeForHoistingFuncDeclInEval, OpInfo(identifierNumber), get(bytecode.m_scope)));
    62436243
    62446244            NEXT_OPCODE(op_resolve_scope_for_hoisting_func_decl_in_eval);
    … …  
    62486248            auto bytecode = currentInstruction->as<OpGetFromScope>();
    62496249            auto& metadata = bytecode.metadata(codeBlock);
    6250             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.var];
     6250            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_var];
    62516251            UniquedStringImpl* uid = m_graph.identifiers()[identifierNumber];
    62526252
    … …  
    62586258            {
    62596259                ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
    6260                 getPutInfo = metadata.getPutInfo;
     6260                getPutInfo = metadata.m_getPutInfo;
    62616261                resolveType = getPutInfo.resolveType();
    62626262                if (resolveType == GlobalVar || resolveType == GlobalVarWithVarInjectionChecks || resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
    6263                     watchpoints = metadata.watchpointSet;
     6263                    watchpoints = metadata.m_watchpointSet;
    62646264                else if (resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
    6265                     structure = metadata.structure.get();
    6266                 operand = metadata.operand;
     6265                    structure = metadata.m_structure.get();
     6266                operand = metadata.m_operand;
    62676267            }
    62686268
    … …  
    62706270                uint64_t opInfo1 = makeDynamicVarOpInfo(identifierNumber, getPutInfo.operand());
    62716271                SpeculatedType prediction = getPrediction();
    6272                 set(bytecode.dst,
    6273                     addToGraph(GetDynamicVar, OpInfo(opInfo1), OpInfo(prediction), get(bytecode.scope)));
     6272                set(bytecode.m_dst,
     6273                    addToGraph(GetDynamicVar, OpInfo(opInfo1), OpInfo(prediction), get(bytecode.m_scope)));
    62746274                NEXT_OPCODE(op_get_from_scope);
    62756275            }
    … …  
    62936293                    || status.numVariants() != 1
    62946294                    || status[0].structureSet().size() != 1) {
    6295                     set(bytecode.dst, addToGraph(GetByIdFlush, OpInfo(identifierNumber), OpInfo(prediction), get(bytecode.scope)));
     6295                    set(bytecode.m_dst, addToGraph(GetByIdFlush, OpInfo(identifierNumber), OpInfo(prediction), get(bytecode.m_scope)));
    62966296                    break;
    62976297                }
    … …  
    62996299                Node* base = weakJSConstant(globalObject);
    63006300                Node* result = load(prediction, base, identifierNumber, status[0]);
    6301                 addToGraph(Phantom, get(bytecode.scope));
    6302                 set(bytecode.dst, result);
     6301                addToGraph(Phantom, get(bytecode.m_scope));
     6302                set(bytecode.m_dst, result);
    63036303                break;
    63046304            }
    … …  
    63076307            case GlobalLexicalVar:
    63086308            case GlobalLexicalVarWithVarInjectionChecks: {
    6309                 addToGraph(Phantom, get(bytecode.scope));
     6309                addToGraph(Phantom, get(bytecode.m_scope));
    63106310                WatchpointSet* watchpointSet;
    63116311                ScopeOffset offset;
    … …  
    63636363                    if (value) {
    63646364                        m_graph.watchpoints().addLazily(watchpointSet);
    6365                         set(bytecode.dst, weakJSConstant(value));
     6365                        set(bytecode.m_dst, weakJSConstant(value));
    63666366                        break;
    63676367                    }
    … …  
    63776377                if (resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
    63786378                    addToGraph(CheckNotEmpty, value);
    6379                 set(bytecode.dst, value);
     6379                set(bytecode.m_dst, value);
    63806380                break;
    63816381            }
    … …  
    63836383            case ClosureVar:
    63846384            case ClosureVarWithVarInjectionChecks: {
    6385                 Node* scopeNode = get(bytecode.scope);
     6385                Node* scopeNode = get(bytecode.m_scope);
    63866386               
    63876387                // Ideally we wouldn't have to do this Phantom. But:
    … …  
    63996399                // would recompile. But if we can fold it here, we avoid the exit.
    64006400                if (JSValue value = m_graph.tryGetConstantClosureVar(scopeNode, ScopeOffset(operand))) {
    6401                     set(bytecode.dst, weakJSConstant(value));
     6401                    set(bytecode.m_dst, weakJSConstant(value));
    64026402                    break;
    64036403                }
    64046404                SpeculatedType prediction = getPrediction();
    6405                 set(bytecode.dst,
     6405                set(bytecode.m_dst,
    64066406                    addToGraph(GetClosureVar, OpInfo(operand), OpInfo(prediction), scopeNode));
    64076407                break;
    … …  
    64206420            auto bytecode = currentInstruction->as<OpPutToScope>();
    64216421            auto& metadata = bytecode.metadata(codeBlock);
    6422             unsigned identifierNumber = bytecode.var;
     6422            unsigned identifierNumber = bytecode.m_var;
    64236423            if (identifierNumber != UINT_MAX)
    64246424                identifierNumber = m_inlineStackTop->m_identifierRemap[identifierNumber];
    … …  
    64366436            {
    64376437                ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
    6438                 getPutInfo = metadata.getPutInfo;
     6438                getPutInfo = metadata.m_getPutInfo;
    64396439                resolveType = getPutInfo.resolveType();
    64406440                if (resolveType == GlobalVar || resolveType == GlobalVarWithVarInjectionChecks || resolveType == LocalClosureVar || resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
    6441                     watchpoints = metadata.watchpointSet;
     6441                    watchpoints = metadata.m_watchpointSet;
    64426442                else if (resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
    6443                     structure = metadata.structure.get();
    6444                 operand = metadata.operand;
     6443                    structure = metadata.m_structure.get();
     6444                operand = metadata.m_operand;
    64456445            }
    64466446
    … …  
    64506450                ASSERT(identifierNumber != UINT_MAX);
    64516451                uint64_t opInfo1 = makeDynamicVarOpInfo(identifierNumber, getPutInfo.operand());
    6452                 addToGraph(PutDynamicVar, OpInfo(opInfo1), OpInfo(), get(bytecode.scope), get(bytecode.value));
     6452                addToGraph(PutDynamicVar, OpInfo(opInfo1), OpInfo(), get(bytecode.m_scope), get(bytecode.m_value));
    64536453                NEXT_OPCODE(op_put_to_scope);
    64546454            }
    … …  
    64706470                    || status[0].kind() != PutByIdVariant::Replace
    64716471                    || status[0].structure().size() != 1) {
    6472                     addToGraph(PutById, OpInfo(identifierNumber), get(bytecode.scope), get(bytecode.value));
     6472                    addToGraph(PutById, OpInfo(identifierNumber), get(bytecode.m_scope), get(bytecode.m_value));
    64736473                    break;
    64746474                }
    64756475                Node* base = weakJSConstant(globalObject);
    6476                 store(base, identifierNumber, status[0], get(bytecode.value));
     6476                store(base, identifierNumber, status[0], get(bytecode.m_value));
    64776477                // Keep scope alive until after put.
    6478                 addToGraph(Phantom, get(bytecode.scope));
     6478                addToGraph(Phantom, get(bytecode.m_scope));
    64796479                break;
    64806480            }
    … …  
    64946494                    ASSERT_UNUSED(entry, watchpoints == entry.watchpointSet());
    64956495                }
    6496                 Node* valueNode = get(bytecode.value);
     6496                Node* valueNode = get(bytecode.m_value);
    64976497                addToGraph(PutGlobalVariable, OpInfo(operand), weakJSConstant(scopeObject), valueNode);
    64986498                if (watchpoints && watchpoints->state() != IsInvalidated) {
    … …  
    65016501                }
    65026502                // Keep scope alive until after put.
    6503                 addToGraph(Phantom, get(bytecode.scope));
     6503                addToGraph(Phantom, get(bytecode.m_scope));
    65046504                break;
    65056505            }
    … …  
    65076507            case ClosureVar:
    65086508            case ClosureVarWithVarInjectionChecks: {
    6509                 Node* scopeNode = get(bytecode.scope);
    6510                 Node* valueNode = get(bytecode.value);
     6509                Node* scopeNode = get(bytecode.m_scope);
     6510                Node* valueNode = get(bytecode.m_value);
    65116511
    65126512                addToGraph(PutClosureVar, OpInfo(operand), scopeNode, valueNode);
    … …  
    65726572        case op_create_lexical_environment: {
    65736573            auto bytecode = currentInstruction->as<OpCreateLexicalEnvironment>();
    6574             ASSERT(bytecode.symbolTable.isConstant() && bytecode.initialValue.isConstant());
    6575             FrozenValue* symbolTable = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.symbolTable.offset()));
    6576             FrozenValue* initialValue = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.initialValue.offset()));
    6577             Node* scope = get(bytecode.scope);
     6574            ASSERT(bytecode.m_symbolTable.isConstant() && bytecode.m_initialValue.isConstant());
     6575            FrozenValue* symbolTable = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.m_symbolTable.offset()));
     6576            FrozenValue* initialValue = m_graph.freezeStrong(m_inlineStackTop->m_codeBlock->getConstant(bytecode.m_initialValue.offset()));
     6577            Node* scope = get(bytecode.m_scope);
    65786578            Node* lexicalEnvironment = addToGraph(CreateActivation, OpInfo(symbolTable), OpInfo(initialValue), scope);
    6579             set(bytecode.dst, lexicalEnvironment);
     6579            set(bytecode.m_dst, lexicalEnvironment);
    65806580            NEXT_OPCODE(op_create_lexical_environment);
    65816581        }
    … …  
    65836583        case op_push_with_scope: {
    65846584            auto bytecode = currentInstruction->as<OpPushWithScope>();
    6585             Node* currentScope = get(bytecode.currentScope);
    6586             Node* object = get(bytecode.newScope);
    6587             set(bytecode.dst, addToGraph(PushWithScope, currentScope, object));
     6585            Node* currentScope = get(bytecode.m_currentScope);
     6586            Node* object = get(bytecode.m_newScope);
     6587            set(bytecode.m_dst, addToGraph(PushWithScope, currentScope, object));
    65886588            NEXT_OPCODE(op_push_with_scope);
    65896589        }
    … …  
    65916591        case op_get_parent_scope: {
    65926592            auto bytecode = currentInstruction->as<OpGetParentScope>();
    6593             Node* currentScope = get(bytecode.scope);
     6593            Node* currentScope = get(bytecode.m_scope);
    65946594            Node* newScope = addToGraph(SkipScope, currentScope);
    6595             set(bytecode.dst, newScope);
     6595            set(bytecode.m_dst, newScope);
    65966596            addToGraph(Phantom, currentScope);
    65976597            NEXT_OPCODE(op_get_parent_scope);
    … …  
    66106610            else
    66116611                result = addToGraph(GetScope, callee);
    6612             set(bytecode.dst, result);
     6612            set(bytecode.m_dst, result);
    66136613            NEXT_OPCODE(op_get_scope);
    66146614        }
    … …  
    66176617            auto bytecode = currentInstruction->as<OpArgumentCount>();
    66186618            Node* sub = addToGraph(ArithSub, OpInfo(Arith::Unchecked), OpInfo(SpecInt32Only), getArgumentCount(), addToGraph(JSConstant, OpInfo(m_constantOne)));
    6619             set(bytecode.dst, sub);
     6619            set(bytecode.m_dst, sub);
    66206620            NEXT_OPCODE(op_argument_count);
    66216621        }
    … …  
    66256625            noticeArgumentsUse();
    66266626            Node* createArguments = addToGraph(CreateDirectArguments);
    6627             set(bytecode.dst, createArguments);
     6627            set(bytecode.m_dst, createArguments);
    66286628            NEXT_OPCODE(op_create_direct_arguments);
    66296629        }
    … …  
    66326632            auto bytecode = currentInstruction->as<OpCreateScopedArguments>();
    66336633            noticeArgumentsUse();
    6634             Node* createArguments = addToGraph(CreateScopedArguments, get(bytecode.scope));
    6635             set(bytecode.dst, createArguments);
     6634            Node* createArguments = addToGraph(CreateScopedArguments, get(bytecode.m_scope));
     6635            set(bytecode.m_dst, createArguments);
    66366636            NEXT_OPCODE(op_create_scoped_arguments);
    66376637        }
    … …  
    66416641            noticeArgumentsUse();
    66426642            Node* createArguments = addToGraph(CreateClonedArguments);
    6643             set(bytecode.dst, createArguments);
     6643            set(bytecode.m_dst, createArguments);
    66446644            NEXT_OPCODE(op_create_cloned_arguments);
    66456645        }
    … …  
    66476647        case op_get_from_arguments: {
    66486648            auto bytecode = currentInstruction->as<OpGetFromArguments>();
    6649             set(bytecode.dst,
     6649            set(bytecode.m_dst,
    66506650                addToGraph(
    66516651                    GetFromArguments,
    6652                     OpInfo(bytecode.index),
     6652                    OpInfo(bytecode.m_index),
    66536653                    OpInfo(getPrediction()),
    6654                     get(bytecode.arguments)));
     6654                    get(bytecode.m_arguments)));
    66556655            NEXT_OPCODE(op_get_from_arguments);
    66566656        }
    … …  
    66606660            addToGraph(
    66616661                PutToArguments,
    6662                 OpInfo(bytecode.index),
    6663                 get(bytecode.arguments),
    6664                 get(bytecode.value));
     6662                OpInfo(bytecode.m_index),
     6663                get(bytecode.m_arguments),
     6664                get(bytecode.m_value));
    66656665            NEXT_OPCODE(op_put_to_arguments);
    66666666        }
    … …  
    66706670            InlineCallFrame* inlineCallFrame = this->inlineCallFrame();
    66716671            Node* argument;
    6672             int32_t argumentIndexIncludingThis = bytecode.index;
     6672            int32_t argumentIndexIncludingThis = bytecode.m_index;
    66736673            if (inlineCallFrame && !inlineCallFrame->isVarargs()) {
    66746674                int32_t argumentCountIncludingThisWithFixup = inlineCallFrame->argumentsWithFixup.size();
    … …  
    66796679            } else
    66806680                argument = addToGraph(GetArgument, OpInfo(argumentIndexIncludingThis), OpInfo(getPrediction()));
    6681             set(bytecode.dst, argument);
     6681            set(bytecode.m_dst, argument);
    66826682            NEXT_OPCODE(op_get_argument);
    66836683        }
    … …  
    67106710        case op_set_function_name: {
    67116711            auto bytecode = currentInstruction->as<OpSetFunctionName>();
    6712             Node* func = get(bytecode.function);
    6713             Node* name = get(bytecode.name);
     6712            Node* func = get(bytecode.m_function);
     6713            Node* name = get(bytecode.m_name);
    67146714            addToGraph(SetFunctionName, func, name);
    67156715            NEXT_OPCODE(op_set_function_name);
    … …  
    67186718        case op_typeof: {
    67196719            auto bytecode = currentInstruction->as<OpTypeof>();
    6720             set(bytecode.dst, addToGraph(TypeOf, get(bytecode.value)));
     6720            set(bytecode.m_dst, addToGraph(TypeOf, get(bytecode.m_value)));
    67216721            NEXT_OPCODE(op_typeof);
    67226722        }
    … …  
    67256725            auto bytecode = currentInstruction->as<OpToNumber>();
    67266726            SpeculatedType prediction = getPrediction();
    6727             Node* value = get(bytecode.operand);
    6728             set(bytecode.dst, addToGraph(ToNumber, OpInfo(0), OpInfo(prediction), value));
     6727            Node* value = get(bytecode.m_operand);
     6728            set(bytecode.m_dst, addToGraph(ToNumber, OpInfo(0), OpInfo(prediction), value));
    67296729            NEXT_OPCODE(op_to_number);
    67306730        }
    … …  
    67326732        case op_to_string: {
    67336733            auto bytecode = currentInstruction->as<OpToString>();
    6734             Node* value = get(bytecode.operand);
    6735             set(bytecode.dst, addToGraph(ToString, value));
     6734            Node* value = get(bytecode.m_operand);
     6735            set(bytecode.m_dst, addToGraph(ToString, value));
    67366736            NEXT_OPCODE(op_to_string);
    67376737        }
    … …  
    67406740            auto bytecode = currentInstruction->as<OpToObject>();
    67416741            SpeculatedType prediction = getPrediction();
    6742             Node* value = get(bytecode.operand);
    6743             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.message];
    6744             set(bytecode.dst, addToGraph(ToObject, OpInfo(identifierNumber), OpInfo(prediction), value));
     6742            Node* value = get(bytecode.m_operand);
     6743            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_message];
     6744            set(bytecode.m_dst, addToGraph(ToObject, OpInfo(identifierNumber), OpInfo(prediction), value));
    67456745            NEXT_OPCODE(op_to_object);
    67466746        }
    … …  
    67486748        case op_in_by_val: {
    67496749            auto bytecode = currentInstruction->as<OpInByVal>();
    6750             ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).arrayProfile, Array::Read);
    6751             set(bytecode.dst, addToGraph(InByVal, OpInfo(arrayMode.asWord()), get(bytecode.base), get(bytecode.property)));
     6750            ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).m_arrayProfile, Array::Read);
     6751            set(bytecode.m_dst, addToGraph(InByVal, OpInfo(arrayMode.asWord()), get(bytecode.m_base), get(bytecode.m_property)));
    67526752            NEXT_OPCODE(op_in_by_val);
    67536753        }
    … …  
    67556755        case op_in_by_id: {
    67566756            auto bytecode = currentInstruction->as<OpInById>();
    6757             Node* base = get(bytecode.base);
    6758             unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
     6757            Node* base = get(bytecode.m_base);
     6758            unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
    67596759            UniquedStringImpl* uid = m_graph.identifiers()[identifierNumber];
    67606760
    … …  
    67856785
    67866786                    Node* match = addToGraph(MatchStructure, OpInfo(data), base);
    6787                     set(bytecode.dst, match);
     6787                    set(bytecode.m_dst, match);
    67886788                    NEXT_OPCODE(op_in_by_id);
    67896789                }
    67906790            }
    67916791
    6792             set(bytecode.dst, addToGraph(InById, OpInfo(identifierNumber), base));
     6792            set(bytecode.m_dst, addToGraph(InById, OpInfo(identifierNumber), base));
    67936793            NEXT_OPCODE(op_in_by_id);
    67946794        }
    … …  
    67966796        case op_get_enumerable_length: {
    67976797            auto bytecode = currentInstruction->as<OpGetEnumerableLength>();
    6798             set(bytecode.dst, addToGraph(GetEnumerableLength, get(bytecode.base)));
     6798            set(bytecode.m_dst, addToGraph(GetEnumerableLength, get(bytecode.m_base)));
    67996799            NEXT_OPCODE(op_get_enumerable_length);
    68006800        }
    … …  
    68026802        case op_has_generic_property: {
    68036803            auto bytecode = currentInstruction->as<OpHasGenericProperty>();
    6804             set(bytecode.dst, addToGraph(HasGenericProperty, get(bytecode.base), get(bytecode.property)));
     6804            set(bytecode.m_dst, addToGraph(HasGenericProperty, get(bytecode.m_base), get(bytecode.m_property)));
    68056805            NEXT_OPCODE(op_has_generic_property);
    68066806        }
    … …  
    68086808        case op_has_structure_property: {
    68096809            auto bytecode = currentInstruction->as<OpHasStructureProperty>();
    6810             set(bytecode.dst, addToGraph(HasStructureProperty,
    6811                 get(bytecode.base),
    6812                 get(bytecode.property),
    6813                 get(bytecode.enumerator)));
     6810            set(bytecode.m_dst, addToGraph(HasStructureProperty,
     6811                get(bytecode.m_base),
     6812                get(bytecode.m_property),
     6813                get(bytecode.m_enumerator)));
    68146814            NEXT_OPCODE(op_has_structure_property);
    68156815        }
    … …  
    68176817        case op_has_indexed_property: {
    68186818            auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
    6819             Node* base = get(bytecode.base);
    6820             ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).arrayProfile, Array::Read);
    6821             Node* property = get(bytecode.property);
     6819            Node* base = get(bytecode.m_base);
     6820            ArrayMode arrayMode = getArrayMode(bytecode.metadata(codeBlock).m_arrayProfile, Array::Read);
     6821            Node* property = get(bytecode.m_property);
    68226822            Node* hasIterableProperty = addToGraph(HasIndexedProperty, OpInfo(arrayMode.asWord()), OpInfo(static_cast<uint32_t>(PropertySlot::InternalMethodType::GetOwnProperty)), base, property);
    6823             set(bytecode.dst, hasIterableProperty);
     6823            set(bytecode.m_dst, hasIterableProperty);
    68246824            NEXT_OPCODE(op_has_indexed_property);
    68256825        }
    … …  
    68296829            SpeculatedType prediction = getPredictionWithoutOSRExit();
    68306830           
    6831             Node* base = get(bytecode.base);
    6832             Node* property = get(bytecode.property);
    6833             Node* index = get(bytecode.index);
    6834             Node* enumerator = get(bytecode.enumerator);
     6831            Node* base = get(bytecode.m_base);
     6832            Node* property = get(bytecode.m_property);
     6833            Node* index = get(bytecode.m_index);
     6834            Node* enumerator = get(bytecode.m_enumerator);
    68356835
    68366836            addVarArgChild(base);
    … …  
    68386838            addVarArgChild(index);
    68396839            addVarArgChild(enumerator);
    6840             set(bytecode.dst, addToGraph(Node::VarArg, GetDirectPname, OpInfo(0), OpInfo(prediction)));
     6840            set(bytecode.m_dst, addToGraph(Node::VarArg, GetDirectPname, OpInfo(0), OpInfo(prediction)));
    68416841
    68426842            NEXT_OPCODE(op_get_direct_pname);
    … …  
    68456845        case op_get_property_enumerator: {
    68466846            auto bytecode = currentInstruction->as<OpGetPropertyEnumerator>();
    6847             set(bytecode.dst, addToGraph(GetPropertyEnumerator, get(bytecode.base)));
     6847            set(bytecode.m_dst, addToGraph(GetPropertyEnumerator, get(bytecode.m_base)));
    68486848            NEXT_OPCODE(op_get_property_enumerator);
    68496849        }
    … …  
    68516851        case op_enumerator_structure_pname: {
    68526852            auto bytecode = currentInstruction->as<OpEnumeratorStructurePname>();
    6853             set(bytecode.dst, addToGraph(GetEnumeratorStructurePname,
    6854                 get(bytecode.enumerator),
    6855                 get(bytecode.index)));
     6853            set(bytecode.m_dst, addToGraph(GetEnumeratorStructurePname,
     6854                get(bytecode.m_enumerator),
     6855                get(bytecode.m_index)));
    68566856            NEXT_OPCODE(op_enumerator_structure_pname);
    68576857        }
    … …  
    68596859        case op_enumerator_generic_pname: {
    68606860            auto bytecode = currentInstruction->as<OpEnumeratorGenericPname>();
    6861             set(bytecode.dst, addToGraph(GetEnumeratorGenericPname,
    6862                 get(bytecode.enumerator),
    6863                 get(bytecode.index)));
     6861            set(bytecode.m_dst, addToGraph(GetEnumeratorGenericPname,
     6862                get(bytecode.m_enumerator),
     6863                get(bytecode.m_index)));
    68646864            NEXT_OPCODE(op_enumerator_generic_pname);
    68656865        }
    … …  
    68676867        case op_to_index_string: {
    68686868            auto bytecode = currentInstruction->as<OpToIndexString>();
    6869             set(bytecode.dst, addToGraph(ToIndexString, get(bytecode.index)));
     6869            set(bytecode.m_dst, addToGraph(ToIndexString, get(bytecode.m_index)));
    68706870            NEXT_OPCODE(op_to_index_string);
    68716871        }
    … …  
    68746874            auto bytecode = currentInstruction->as<OpLogShadowChickenPrologue>();
    68756875            if (!m_inlineStackTop->m_inlineCallFrame)
    6876                 addToGraph(LogShadowChickenPrologue, get(bytecode.scope));
     6876                addToGraph(LogShadowChickenPrologue, get(bytecode.m_scope));
    68776877            NEXT_OPCODE(op_log_shadow_chicken_prologue);
    68786878        }
    … …  
    68846884                // ends up being inlined.
    68856885                // https://bugs.webkit.org/show_bug.cgi?id=155686
    6886                 addToGraph(LogShadowChickenTail, get(bytecode.thisValue), get(bytecode.scope));
     6886                addToGraph(LogShadowChickenTail, get(bytecode.m_thisValue), get(bytecode.m_scope));
    68876887            }
    68886888            NEXT_OPCODE(op_log_shadow_chicken_tail);
    … …  
    71487148void ByteCodeParser::handlePutByVal(Bytecode bytecode, unsigned instructionSize)
    71497149{
    7150     Node* base = get(bytecode.base);
    7151     Node* property = get(bytecode.property);
    7152     Node* value = get(bytecode.value);
     7150    Node* base = get(bytecode.m_base);
     7151    Node* property = get(bytecode.m_property);
     7152    Node* value = get(bytecode.m_value);
    71537153    bool isDirect = Bytecode::opcodeID == op_put_by_val_direct;
    71547154    bool compiledAsPutById = false;
    … …  
    71917191
    71927192    if (!compiledAsPutById) {
    7193         ArrayMode arrayMode = getArrayMode(bytecode.metadata(m_inlineStackTop->m_codeBlock).arrayProfile, Array::Write);
     7193        ArrayMode arrayMode = getArrayMode(bytecode.metadata(m_inlineStackTop->m_codeBlock).m_arrayProfile, Array::Write);
    71947194
    71957195        addVarArgChild(base);
    … …  
    72057205void ByteCodeParser::handlePutAccessorById(NodeType op, Bytecode bytecode)
    72067206{
    7207     Node* base = get(bytecode.base);
    7208     unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.property];
    7209     Node* accessor = get(bytecode.accessor);
    7210     addToGraph(op, OpInfo(identifierNumber), OpInfo(bytecode.attributes), base, accessor);
     7207    Node* base = get(bytecode.m_base);
     7208    unsigned identifierNumber = m_inlineStackTop->m_identifierRemap[bytecode.m_property];
     7209    Node* accessor = get(bytecode.m_accessor);
     7210    addToGraph(op, OpInfo(identifierNumber), OpInfo(bytecode.m_attributes), base, accessor);
    72117211}
    72127212
    … …  
    72147214void ByteCodeParser::handlePutAccessorByVal(NodeType op, Bytecode bytecode)
    72157215{
    7216     Node* base = get(bytecode.base);
    7217     Node* subscript = get(bytecode.property);
    7218     Node* accessor = get(bytecode.accessor);
    7219     addToGraph(op, OpInfo(bytecode.attributes), base, subscript, accessor);
     7216    Node* base = get(bytecode.m_base);
     7217    Node* subscript = get(bytecode.m_property);
     7218    Node* accessor = get(bytecode.m_accessor);
     7219    addToGraph(op, OpInfo(bytecode.m_attributes), base, subscript, accessor);
    72207220}
    72217221
    … …  
    72237223void ByteCodeParser::handleNewFunc(NodeType op, Bytecode bytecode)
    72247224{
    7225     FunctionExecutable* decl = m_inlineStackTop->m_profiledBlock->functionDecl(bytecode.functionDecl);
     7225    FunctionExecutable* decl = m_inlineStackTop->m_profiledBlock->functionDecl(bytecode.m_functionDecl);
    72267226    FrozenValue* frozen = m_graph.freezeStrong(decl);
    7227     Node* scope = get(bytecode.scope);
    7228     set(bytecode.dst, addToGraph(op, OpInfo(frozen), scope));
     7227    Node* scope = get(bytecode.m_scope);
     7228    set(bytecode.m_dst, addToGraph(op, OpInfo(frozen), scope));
    72297229    // Ideally we wouldn't have to do this Phantom. But:
    72307230    //
    … …  
    72407240void ByteCodeParser::handleNewFuncExp(NodeType op, Bytecode bytecode)
    72417241{
    7242     FunctionExecutable* expr = m_inlineStackTop->m_profiledBlock->functionExpr(bytecode.functionDecl);
     7242    FunctionExecutable* expr = m_inlineStackTop->m_profiledBlock->functionExpr(bytecode.m_functionDecl);
    72437243    FrozenValue* frozen = m_graph.freezeStrong(expr);
    7244     Node* scope = get(bytecode.scope);
    7245     set(bytecode.dst, addToGraph(op, OpInfo(frozen), scope));
     7244    Node* scope = get(bytecode.m_scope);
     7245    set(bytecode.m_dst, addToGraph(op, OpInfo(frozen), scope));
    72467246    // Ideally we wouldn't have to do this Phantom. But:
    72477247    //

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

    r237547 r240041  
    11/*
    2  * Copyright (C) 2011-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    393393    auto instruction = exec->codeBlock()->instructions().at(exec->bytecodeOffset());
    394394    ASSERT(instruction->is<OpCatch>());
    395     ValueProfileAndOperandBuffer* buffer = instruction->as<OpCatch>().metadata(exec).buffer;
     395    ValueProfileAndOperandBuffer* buffer = instruction->as<OpCatch>().metadata(exec).m_buffer;
    396396    JSValue* dataBuffer = reinterpret_cast<JSValue*>(dfgCommon->catchOSREntryBuffer->dataBuffer());
    397397    unsigned index = 0;

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

    r237547 r240041  
    11/*
    2  * Copyright (C) 2014-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2014-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    478478        RELEASE_ASSERT(currentInstruction->is<OpNewArrayBuffer>());
    479479        auto newArrayBuffer = currentInstruction->as<OpNewArrayBuffer>();
    480         ArrayAllocationProfile* profile = &newArrayBuffer.metadata(codeBlock).arrayAllocationProfile;
     480        ArrayAllocationProfile* profile = &newArrayBuffer.metadata(codeBlock).m_arrayAllocationProfile;
    481481
    482482        // FIXME: Share the code with CommonSlowPaths. Currently, codeBlock etc. are slightly different.
    … …  
    496496            // a compilation thread.
    497497            WTF::storeStoreFence();
    498             codeBlock->constantRegister(newArrayBuffer.immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
     498            codeBlock->constantRegister(newArrayBuffer.m_immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
    499499            WTF::storeStoreFence();
    500500        }

  • trunk/Source/JavaScriptCore/generator/Argument.rb

    r238804 r240041  
    1 # Copyright (C) 2018 Apple Inc. All rights reserved.
     1# Copyright (C) 2018-2019 Apple Inc. All rights reserved.
    22#
    33# Redistribution and use in source and binary forms, with or without
    … …  
    3636
    3737    def field
    38         "#{@type.to_s} #{@name};"
     38        "#{@type.to_s} #{field_name};"
    3939    end
    4040
    4141    def create_param
    4242        "#{@type.to_s} #{@name}"
     43    end
     44
     45    def field_name
     46        "m_#{@name}"
    4347    end
    4448
    … …  
    5660
    5761    def load_from_stream(index, size)
    58         "#{@name}(#{Fits::convert(size, "stream[#{index}]", @type)})"
     62        "#{field_name}(#{Fits::convert(size, "stream[#{index}]", @type)})"
    5963    end
    6064

  • trunk/Source/JavaScriptCore/generator/Metadata.rb

    r238804 r240041  
    1 # Copyright (C) 2018 Apple Inc. All rights reserved.
     1# Copyright (C) 2018-2019 Apple Inc. All rights reserved.
    22#
    33# Redistribution and use in source and binary forms, with or without
    … …  
    4848                    "#{prefix}union {\n#{convertFields(prefix + '    ', type)}\n#{prefix}};"
    4949                else
    50                     "#{prefix}#{type.to_s} #{field.to_s};"
     50                    "#{prefix}#{type.to_s} m_#{field.to_s};"
    5151                end
    5252            end.join("\n")
    … …  
    5858        if @initializers && (not @initializers.empty?)
    5959            inits = "\n            : " + @initializers.map do |metadata, arg|
    60                 "#{metadata}(__op.#{arg})"
     60                "m_#{metadata}(__op.m_#{arg})"
    6161            end.join("\n            , ").concat("\n       ");
    6262        end
    … …  
    122122
    123123    def self.field_name
    124         "metadataID"
     124        "m_metadataID"
    125125    end
    126126end

  • trunk/Source/JavaScriptCore/generator/Opcode.rb

    r239009 r240041  
    1 # Copyright (C) 2018 Apple Inc. All rights reserved.
     1# Copyright (C) 2018-2019 Apple Inc. All rights reserved.
    22#
    33# Redistribution and use in source and binary forms, with or without
    … …  
    165165#{print_args { |arg|
    166166<<-EOF.chomp
    167         dumper->dumpOperand(#{arg.name}, #{arg.index == 1});
     167        dumper->dumpOperand(#{arg.field_name}, #{arg.index == 1});
    168168EOF
    169169    }}
    … …  
    226226    def struct_indices
    227227        out = []
    228         out += @args.map(&:name) unless @args.nil?
     228        out += @args.map(&:field_name) unless @args.nil?
    229229        out << Metadata.field_name unless @metadata.empty?
    230230        out.map.with_index do |name, index|

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

    r239761 r240041  
    362362        void emitValueProfilingSiteIfProfiledOpcode(...);
    363363        template<typename Op>
    364         std::enable_if_t<std::is_same<decltype(Op::Metadata::profile), ValueProfile>::value, void>
     364        std::enable_if_t<std::is_same<decltype(Op::Metadata::m_profile), ValueProfile>::value, void>
    365365        emitValueProfilingSiteIfProfiledOpcode(Op bytecode);
    366366

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

    r238732 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    158158{
    159159    auto bytecode = currentInstruction->as<OpUnsigned>();
    160     int result = bytecode.dst.offset();
    161     int op1 = bytecode.operand.offset();
     160    int result = bytecode.m_dst.offset();
     161    int op1 = bytecode.m_operand.offset();
    162162   
    163163    emitGetVirtualRegister(op1, regT0);
    … …  
    177177
    178178    auto bytecode = instruction->as<Op>();
    179     int op1 = bytecode.lhs.offset();
    180     int op2 = bytecode.rhs.offset();
    181     unsigned target = jumpTarget(instruction, bytecode.target);
     179    int op1 = bytecode.m_lhs.offset();
     180    int op2 = bytecode.m_rhs.offset();
     181    unsigned target = jumpTarget(instruction, bytecode.m_target);
    182182    if (isOperandConstantChar(op1)) {
    183183        emitGetVirtualRegister(op2, regT0);
    … …  
    224224{
    225225    auto bytecode = instruction->as<Op>();
    226     int op1 = bytecode.lhs.offset();
    227     int op2 = bytecode.rhs.offset();
    228     unsigned target = jumpTarget(instruction, bytecode.target);
     226    int op1 = bytecode.m_lhs.offset();
     227    int op2 = bytecode.m_rhs.offset();
     228    unsigned target = jumpTarget(instruction, bytecode.m_target);
    229229    if (isOperandConstantInt(op2)) {
    230230        emitGetVirtualRegister(op1, regT0);
    … …  
    245245{
    246246    auto bytecode = instruction->as<Op>();
    247     int dst = bytecode.dst.offset();
    248     int op1 = bytecode.lhs.offset();
    249     int op2 = bytecode.rhs.offset();
     247    int dst = bytecode.m_dst.offset();
     248    int op1 = bytecode.m_lhs.offset();
     249    int op2 = bytecode.m_rhs.offset();
    250250    if (isOperandConstantInt(op2)) {
    251251        emitGetVirtualRegister(op1, regT0);
    … …  
    268268{
    269269    auto bytecode = instruction->as<Op>();
    270     int op1 = bytecode.lhs.offset();
    271     int op2 = bytecode.rhs.offset();
    272     unsigned target = jumpTarget(instruction, bytecode.target);
     270    int op1 = bytecode.m_lhs.offset();
     271    int op2 = bytecode.m_rhs.offset();
     272    unsigned target = jumpTarget(instruction, bytecode.m_target);
    273273
    274274    // We generate inline code for the following cases in the slow path:
    … …  
    366366{
    367367    auto bytecode = currentInstruction->as<OpInc>();
    368     int srcDst = bytecode.srcDst.offset();
     368    int srcDst = bytecode.m_srcDst.offset();
    369369
    370370    emitGetVirtualRegister(srcDst, regT0);
    … …  
    378378{
    379379    auto bytecode = currentInstruction->as<OpDec>();
    380     int srcDst = bytecode.srcDst.offset();
     380    int srcDst = bytecode.m_srcDst.offset();
    381381
    382382    emitGetVirtualRegister(srcDst, regT0);
    … …  
    394394{
    395395    auto bytecode = currentInstruction->as<OpMod>();
    396     int result = bytecode.dst.offset();
    397     int op1 = bytecode.lhs.offset();
    398     int op2 = bytecode.rhs.offset();
     396    int result = bytecode.m_dst.offset();
     397    int op1 = bytecode.m_lhs.offset();
     398    int op2 = bytecode.m_rhs.offset();
    399399
    400400    // Make sure registers are correct for x86 IDIV instructions.
    … …  
    452452void JIT::emit_op_negate(const Instruction* currentInstruction)
    453453{
    454     ArithProfile* arithProfile = &currentInstruction->as<OpNegate>().metadata(m_codeBlock).arithProfile;
     454    ArithProfile* arithProfile = &currentInstruction->as<OpNegate>().metadata(m_codeBlock).m_arithProfile;
    455455    JITNegIC* negateIC = m_codeBlock->addJITNegIC(arithProfile, currentInstruction);
    456456    m_instructionToMathIC.add(currentInstruction, negateIC);
    … …  
    470470{
    471471    auto bytecode = currentInstruction->as<Op>();
    472     int result = bytecode.dst.offset();
    473     int op1 = bytecode.lhs.offset();
    474     int op2 = bytecode.rhs.offset();
     472    int result = bytecode.m_dst.offset();
     473    int op1 = bytecode.m_lhs.offset();
     474    int op2 = bytecode.m_rhs.offset();
    475475
    476476#if USE(JSVALUE64)
    … …  
    517517{
    518518    auto bytecode = currentInstruction->as<OpBitnot>();
    519     int result = bytecode.dst.offset();
    520     int op1 = bytecode.operand.offset();
     519    int result = bytecode.m_dst.offset();
     520    int op1 = bytecode.m_operand.offset();
    521521
    522522#if USE(JSVALUE64)
    … …  
    578578{
    579579    auto bytecode = currentInstruction->as<Op>();
    580     int result = bytecode.dst.offset();
    581     int op1 = bytecode.lhs.offset();
    582     int op2 = bytecode.rhs.offset();
     580    int result = bytecode.m_dst.offset();
     581    int op1 = bytecode.m_lhs.offset();
     582    int op2 = bytecode.m_rhs.offset();
    583583
    584584#if USE(JSVALUE64)
    … …  
    640640void JIT::emit_op_add(const Instruction* currentInstruction)
    641641{
    642     ArithProfile* arithProfile = &currentInstruction->as<OpAdd>().metadata(m_codeBlock).arithProfile;
     642    ArithProfile* arithProfile = &currentInstruction->as<OpAdd>().metadata(m_codeBlock).m_arithProfile;
    643643    JITAddIC* addIC = m_codeBlock->addJITAddIC(arithProfile, currentInstruction);
    644644    m_instructionToMathIC.add(currentInstruction, addIC);
    … …  
    658658{
    659659    auto bytecode = currentInstruction->as<Op>();
    660     int result = bytecode.dst.offset();
    661     int operand = bytecode.operand.offset();
     660    int result = bytecode.m_dst.offset();
     661    int operand = bytecode.m_operand.offset();
    662662
    663663#if USE(JSVALUE64)
    … …  
    709709    auto bytecode = currentInstruction->as<Op>();
    710710    OperandTypes types = getOperandTypes(copiedArithProfile(bytecode));
    711     int result = bytecode.dst.offset();
    712     int op1 = bytecode.lhs.offset();
    713     int op2 = bytecode.rhs.offset();
     711    int result = bytecode.m_dst.offset();
     712    int op1 = bytecode.m_lhs.offset();
     713    int op2 = bytecode.m_rhs.offset();
    714714
    715715#if USE(JSVALUE64)
    … …  
    784784
    785785    auto bytecode = currentInstruction->as<Op>();
    786     int result = bytecode.dst.offset();
     786    int result = bytecode.m_dst.offset();
    787787
    788788#if USE(JSVALUE64)
    … …  
    831831    auto bytecode = currentInstruction->as<Op>();
    832832    OperandTypes types = getOperandTypes(copiedArithProfile(bytecode));
    833     int result = bytecode.dst.offset();
    834     int op1 = bytecode.lhs.offset();
    835     int op2 = bytecode.rhs.offset();
     833    int result = bytecode.m_dst.offset();
     834    int op1 = bytecode.m_lhs.offset();
     835    int op2 = bytecode.m_rhs.offset();
    836836
    837837#if USE(JSVALUE64)
    … …  
    893893    auto bytecode = currentInstruction->as<OpDiv>();
    894894    auto& metadata = bytecode.metadata(m_codeBlock);
    895     int result = bytecode.dst.offset();
    896     int op1 = bytecode.lhs.offset();
    897     int op2 = bytecode.rhs.offset();
    898 
    899 #if USE(JSVALUE64)
    900     OperandTypes types = getOperandTypes(metadata.arithProfile);
     895    int result = bytecode.m_dst.offset();
     896    int op1 = bytecode.m_lhs.offset();
     897    int op2 = bytecode.m_rhs.offset();
     898
     899#if USE(JSVALUE64)
     900    OperandTypes types = getOperandTypes(metadata.m_arithProfile);
    901901    JSValueRegs leftRegs = JSValueRegs(regT0);
    902902    JSValueRegs rightRegs = JSValueRegs(regT1);
    … …  
    904904    GPRReg scratchGPR = regT2;
    905905#else
    906     OperandTypes types = getOperandTypes(metadata.arithProfile);
     906    OperandTypes types = getOperandTypes(metadata.m_arithProfile);
    907907    JSValueRegs leftRegs = JSValueRegs(regT1, regT0);
    908908    JSValueRegs rightRegs = JSValueRegs(regT3, regT2);
    … …  
    914914    ArithProfile* arithProfile = nullptr;
    915915    if (shouldEmitProfiling())
    916         arithProfile = &currentInstruction->as<OpDiv>().metadata(m_codeBlock).arithProfile;
     916        arithProfile = &currentInstruction->as<OpDiv>().metadata(m_codeBlock).m_arithProfile;
    917917
    918918    SnippetOperand leftOperand(types.first());
    … …  
    959959void JIT::emit_op_mul(const Instruction* currentInstruction)
    960960{
    961     ArithProfile* arithProfile = &currentInstruction->as<OpMul>().metadata(m_codeBlock).arithProfile;
     961    ArithProfile* arithProfile = &currentInstruction->as<OpMul>().metadata(m_codeBlock).m_arithProfile;
    962962    JITMulIC* mulIC = m_codeBlock->addJITMulIC(arithProfile, currentInstruction);
    963963    m_instructionToMathIC.add(currentInstruction, mulIC);
    … …  
    975975void JIT::emit_op_sub(const Instruction* currentInstruction)
    976976{
    977     ArithProfile* arithProfile = &currentInstruction->as<OpSub>().metadata(m_codeBlock).arithProfile;
     977    ArithProfile* arithProfile = &currentInstruction->as<OpSub>().metadata(m_codeBlock).m_arithProfile;
    978978    JITSubIC* subIC = m_codeBlock->addJITSubIC(arithProfile, currentInstruction);
    979979    m_instructionToMathIC.add(currentInstruction, subIC);

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

    r238414 r240041  
    11/*
    2 * Copyright (C) 2008, 2015 Apple Inc. All rights reserved.
     2* Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33*
    44* Redistribution and use in source and binary forms, with or without
    … …  
    4949
    5050    auto bytecode = instruction->as<Op>();
    51     int op1 = bytecode.lhs.offset();
    52     int op2 = bytecode.rhs.offset();
    53     unsigned target = jumpTarget(instruction, bytecode.target);
     51    int op1 = bytecode.m_lhs.offset();
     52    int op2 = bytecode.m_rhs.offset();
     53    unsigned target = jumpTarget(instruction, bytecode.m_target);
    5454
    5555    // Character less.
    … …  
    103103{
    104104    auto bytecode = instruction->as<Op>();
    105     int op1 = bytecode.lhs.offset();
    106     int op2 = bytecode.rhs.offset();
    107     unsigned target = jumpTarget(instruction, bytecode.target);
     105    int op1 = bytecode.m_lhs.offset();
     106    int op2 = bytecode.m_rhs.offset();
     107    unsigned target = jumpTarget(instruction, bytecode.m_target);
    108108
    109109    if (isOperandConstantInt(op1)) {
    … …  
    123123{
    124124    auto bytecode = instruction->as<Op>();
    125     int dst = bytecode.dst.offset();
    126     int op1 = bytecode.lhs.offset();
    127     int op2 = bytecode.rhs.offset();
     125    int dst = bytecode.m_dst.offset();
     126    int op1 = bytecode.m_lhs.offset();
     127    int op2 = bytecode.m_rhs.offset();
    128128
    129129    if (isOperandConstantInt(op1)) {
    … …  
    144144{
    145145    auto bytecode = instruction->as<Op>();
    146     int op1 = bytecode.lhs.offset();
    147     int op2 = bytecode.rhs.offset();
    148     unsigned target = jumpTarget(instruction, bytecode.target);
     146    int op1 = bytecode.m_lhs.offset();
     147    int op2 = bytecode.m_rhs.offset();
     148    unsigned target = jumpTarget(instruction, bytecode.m_target);
    149149
    150150    linkAllSlowCases(iter);
    … …  
    159159{
    160160    auto bytecode = currentInstruction->as<OpUnsigned>();
    161     int result = bytecode.dst.offset();
    162     int op1 = bytecode.operand.offset();
     161    int result = bytecode.m_dst.offset();
     162    int op1 = bytecode.m_operand.offset();
    163163   
    164164    emitLoad(op1, regT1, regT0);
    … …  
    172172{
    173173    auto bytecode = currentInstruction->as<OpInc>();
    174     int srcDst = bytecode.srcDst.offset();
     174    int srcDst = bytecode.m_srcDst.offset();
    175175
    176176    emitLoad(srcDst, regT1, regT0);
    … …  
    184184{
    185185    auto bytecode = currentInstruction->as<OpDec>();
    186     int srcDst = bytecode.srcDst.offset();
     186    int srcDst = bytecode.m_srcDst.offset();
    187187
    188188    emitLoad(srcDst, regT1, regT0);
    … …  
    200200    auto bytecode = instruction->as<Op>();
    201201    int opcodeID = Op::opcodeID;
    202     int target = jumpTarget(instruction, bytecode.target);
    203     int op1 = bytecode.lhs.offset();
    204     int op2 = bytecode.rhs.offset();
     202    int target = jumpTarget(instruction, bytecode.m_target);
     203    int op1 = bytecode.m_lhs.offset();
     204    int op2 = bytecode.m_rhs.offset();
    205205
    206206    if (!notInt32Op1.empty()) {
    … …  
    337337#if CPU(X86)
    338338    auto bytecode = instruction->as<OpMod>();
    339     int dst = bytecode.dst.offset();
    340     int op1 = bytecode.lhs.offset();
    341     int op2 = bytecode.rhs.offset();
     339    int dst = bytecode.m_dst.offset();
     340    int op1 = bytecode.m_lhs.offset();
     341    int op2 = bytecode.m_rhs.offset();
    342342
    343343    // Make sure registers are correct for x86 IDIV instructions.

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

    r237547 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5252{
    5353    emitValueProfilingSite(bytecode.metadata(m_codeBlock));
    54     emitPutVirtualRegister(bytecode.dst.offset());
     54    emitPutVirtualRegister(bytecode.m_dst.offset());
    5555}
    5656
    … …  
    6363{
    6464    auto& metadata = bytecode.metadata(m_codeBlock);
    65     int argCount = bytecode.argc;
    66     int registerOffset = -static_cast<int>(bytecode.argv);
     65    int argCount = bytecode.m_argc;
     66    int registerOffset = -static_cast<int>(bytecode.m_argv);
    6767
    6868    if (Op::opcodeID == op_call && shouldEmitProfiling()) {
    … …  
    7070        Jump done = branchIfNotCell(regT0);
    7171        load32(Address(regT0, JSCell::structureIDOffset()), regT0);
    72         store32(regT0, metadata.arrayProfile.addressOfLastSeenStructureID());
     72        store32(regT0, metadata.m_arrayProfile.addressOfLastSeenStructureID());
    7373        done.link(this);
    7474    }
    … …  
    8686JIT::compileSetupFrame(const Op& bytecode, CallLinkInfo* info)
    8787{
    88     int thisValue = bytecode.thisValue.offset();
    89     int arguments = bytecode.arguments.offset();
    90     int firstFreeRegister = bytecode.firstFree.offset();
    91     int firstVarArgOffset = bytecode.firstVarArg;
     88    int thisValue = bytecode.m_thisValue.offset();
     89    int arguments = bytecode.m_arguments.offset();
     90    int firstFreeRegister = bytecode.m_firstFree.offset();
     91    int firstVarArgOffset = bytecode.m_firstVarArg;
    9292
    9393    emitGetVirtualRegister(arguments, regT1);
    … …  
    158158    info->setUpCall(CallLinkInfo::Call, CodeOrigin(m_bytecodeOffset), regT0);
    159159
    160     int registerOffset = -bytecode.argv;
     160    int registerOffset = -bytecode.m_argv;
    161161
    162162    addPtr(TrustedImm32(registerOffset * sizeof(Register) + sizeof(CallerFrameAndPC)), callFrameRegister, stackPointerRegister);
    … …  
    182182{
    183183    CallFrameShuffleData shuffleData;
    184     shuffleData.numPassedArgs = bytecode.argc;
     184    shuffleData.numPassedArgs = bytecode.m_argc;
    185185    shuffleData.tagTypeNumber = GPRInfo::tagTypeNumberRegister;
    186186    shuffleData.numLocals =
    187         bytecode.argv - sizeof(CallerFrameAndPC) / sizeof(Register);
    188     shuffleData.args.resize(bytecode.argc);
    189     for (unsigned i = 0; i < bytecode.argc; ++i) {
     187        bytecode.m_argv - sizeof(CallerFrameAndPC) / sizeof(Register);
     188    shuffleData.args.resize(bytecode.m_argc);
     189    for (unsigned i = 0; i < bytecode.m_argc; ++i) {
    190190        shuffleData.args[i] =
    191191            ValueRecovery::displacedInJSStack(
    192                 virtualRegisterForArgument(i) - bytecode.argv,
     192                virtualRegisterForArgument(i) - bytecode.m_argv,
    193193                DataFormatJS);
    194194    }
    … …  
    207207    OpcodeID opcodeID = Op::opcodeID;
    208208    auto bytecode = instruction->as<Op>();
    209     int callee = bytecode.callee.offset();
     209    int callee = bytecode.m_callee.offset();
    210210
    211211    /* Caller always:

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

    r238414 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5050{
    5151    emitValueProfilingSite(bytecode.metadata(m_codeBlock));
    52     emitStore(bytecode.dst.offset(), regT1, regT0);
     52    emitStore(bytecode.m_dst.offset(), regT1, regT0);
    5353}
    5454
    … …  
    5656{
    5757    auto bytecode = currentInstruction->as<OpRet>();
    58     int value = bytecode.value.offset();
     58    int value = bytecode.m_value.offset();
    5959
    6060    emitLoad(value, regT1, regT0);
    … …  
    154154{
    155155    auto& metadata = bytecode.metadata(m_codeBlock);
    156     int argCount = bytecode.argc;
    157     int registerOffset = -static_cast<int>(bytecode.argv);
     156    int argCount = bytecode.m_argc;
     157    int registerOffset = -static_cast<int>(bytecode.m_argv);
    158158
    159159    if (Op::opcodeID == op_call && shouldEmitProfiling()) {
    … …  
    161161        Jump done = branchIfNotCell(regT0);
    162162        load32(Address(regT1, JSCell::structureIDOffset()), regT1);
    163         store32(regT1, metadata.arrayProfile.addressOfLastSeenStructureID());
     163        store32(regT1, metadata.m_arrayProfile.addressOfLastSeenStructureID());
    164164        done.link(this);
    165165    }
    … …  
    177177{
    178178    OpcodeID opcodeID = Op::opcodeID;
    179     int thisValue = bytecode.thisValue.offset();
    180     int arguments = bytecode.arguments.offset();
    181     int firstFreeRegister = bytecode.firstFree.offset();
    182     int firstVarArgOffset = bytecode.firstVarArg;
     179    int thisValue = bytecode.m_thisValue.offset();
     180    int arguments = bytecode.m_arguments.offset();
     181    int firstFreeRegister = bytecode.m_firstFree.offset();
     182    int firstVarArgOffset = bytecode.m_firstVarArg;
    183183
    184184    emitLoad(arguments, regT1, regT0);
    … …  
    249249    info->setUpCall(CallLinkInfo::Call, CodeOrigin(m_bytecodeOffset), regT0);
    250250
    251     int registerOffset = -bytecode.argv;
    252     int callee = bytecode.callee.offset();
     251    int registerOffset = -bytecode.m_argv;
     252    int callee = bytecode.m_callee.offset();
    253253
    254254    addPtr(TrustedImm32(registerOffset * sizeof(Register) + sizeof(CallerFrameAndPC)), callFrameRegister, stackPointerRegister);
    … …  
    269269    OpcodeID opcodeID = Op::opcodeID;
    270270    auto bytecode = instruction->as<Op>();
    271     int callee = bytecode.callee.offset();
     271    int callee = bytecode.m_callee.offset();
    272272
    273273    /* Caller always:

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

    r239951 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    330330
    331331template<typename Op>
    332 inline std::enable_if_t<std::is_same<decltype(Op::Metadata::profile), ValueProfile>::value, void> JIT::emitValueProfilingSiteIfProfiledOpcode(Op bytecode)
     332inline std::enable_if_t<std::is_same<decltype(Op::Metadata::m_profile), ValueProfile>::value, void> JIT::emitValueProfilingSiteIfProfiledOpcode(Op bytecode)
    333333{
    334334    emitValueProfilingSite(bytecode.metadata(m_codeBlock));
    … …  
    342342    if (!shouldEmitProfiling())
    343343        return;
    344     emitValueProfilingSite(metadata.profile);
     344    emitValueProfilingSite(metadata.m_profile);
    345345}
    346346
    … …  
    711711ALWAYS_INLINE GetPutInfo JIT::copiedGetPutInfo(OpPutToScope bytecode)
    712712{
    713     unsigned key = bytecode.metadataID + 1; // HashMap doesn't like 0 as a key
     713    unsigned key = bytecode.m_metadataID + 1; // HashMap doesn't like 0 as a key
    714714    auto iterator = m_copiedGetPutInfos.find(key);
    715715    if (iterator != m_copiedGetPutInfos.end())
    716716        return GetPutInfo(iterator->value);
    717     GetPutInfo getPutInfo = bytecode.metadata(m_codeBlock).getPutInfo;
     717    GetPutInfo getPutInfo = bytecode.metadata(m_codeBlock).m_getPutInfo;
    718718    m_copiedGetPutInfos.add(key, getPutInfo.operand());
    719719    return getPutInfo;
    … …  
    723723ALWAYS_INLINE ArithProfile JIT::copiedArithProfile(BinaryOp bytecode)
    724724{
    725     uint64_t key = static_cast<uint64_t>(BinaryOp::opcodeID) << 32 | static_cast<uint64_t>(bytecode.metadataID);
     725    uint64_t key = static_cast<uint64_t>(BinaryOp::opcodeID) << 32 | static_cast<uint64_t>(bytecode.m_metadataID);
    726726    auto iterator = m_copiedArithProfiles.find(key);
    727727    if (iterator != m_copiedArithProfiles.end())
    728728        return iterator->value;
    729     ArithProfile arithProfile = bytecode.metadata(m_codeBlock).arithProfile;
     729    ArithProfile arithProfile = bytecode.metadata(m_codeBlock).m_arithProfile;
    730730    m_copiedArithProfiles.add(key, arithProfile);
    731731    return arithProfile;

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

    r239761 r240041  
    11/*
    2  * Copyright (C) 2009-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009-2019 Apple Inc. All rights reserved.
    33 * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
    44 *
    … …  
    5757{
    5858    auto bytecode = currentInstruction->as<OpMov>();
    59     int dst = bytecode.dst.offset();
    60     int src = bytecode.src.offset();
     59    int dst = bytecode.m_dst.offset();
     60    int src = bytecode.m_src.offset();
    6161
    6262    if (m_codeBlock->isConstantRegisterIndex(src)) {
    … …  
    7878    auto bytecode = currentInstruction->as<OpEnd>();
    7979    RELEASE_ASSERT(returnValueGPR != callFrameRegister);
    80     emitGetVirtualRegister(bytecode.value.offset(), returnValueGPR);
     80    emitGetVirtualRegister(bytecode.m_value.offset(), returnValueGPR);
    8181    emitRestoreCalleeSaves();
    8282    emitFunctionEpilogue();
    … …  
    8787{
    8888    auto bytecode = currentInstruction->as<OpJmp>();
    89     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     89    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    9090    addJump(jump(), target);
    9191}
    … …  
    9595    auto bytecode = currentInstruction->as<OpNewObject>();
    9696    auto& metadata = bytecode.metadata(m_codeBlock);
    97     Structure* structure = metadata.objectAllocationProfile.structure();
     97    Structure* structure = metadata.m_objectAllocationProfile.structure();
    9898    size_t allocationSize = JSFinalObject::allocationSize(structure->inlineCapacity());
    9999    Allocator allocator = subspaceFor<JSFinalObject>(*m_vm)->allocatorForNonVirtual(allocationSize, AllocatorForMode::AllocatorIfExists);
    … …  
    111111        emitInitializeInlineStorage(resultReg, structure->inlineCapacity());
    112112        addSlowCase(slowCases);
    113         emitPutVirtualRegister(bytecode.dst.offset());
     113        emitPutVirtualRegister(bytecode.m_dst.offset());
    114114    }
    115115}
    … …  
    121121    auto bytecode = currentInstruction->as<OpNewObject>();
    122122    auto& metadata = bytecode.metadata(m_codeBlock);
    123     int dst = bytecode.dst.offset();
    124     Structure* structure = metadata.objectAllocationProfile.structure();
     123    int dst = bytecode.m_dst.offset();
     124    Structure* structure = metadata.m_objectAllocationProfile.structure();
    125125    callOperation(operationNewObject, structure);
    126126    emitStoreCell(dst, returnValueGPR);
    … …  
    130130{
    131131    auto bytecode = currentInstruction->as<OpOverridesHasInstance>();
    132     int dst = bytecode.dst.offset();
    133     int constructor = bytecode.constructor.offset();
    134     int hasInstanceValue = bytecode.hasInstanceValue.offset();
     132    int dst = bytecode.m_dst.offset();
     133    int constructor = bytecode.m_constructor.offset();
     134    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
    135135
    136136    emitGetVirtualRegister(hasInstanceValue, regT0);
    … …  
    156156{
    157157    auto bytecode = currentInstruction->as<OpInstanceof>();
    158     int dst = bytecode.dst.offset();
    159     int value = bytecode.value.offset();
    160     int proto = bytecode.prototype.offset();
     158    int dst = bytecode.m_dst.offset();
     159    int value = bytecode.m_value.offset();
     160    int proto = bytecode.m_prototype.offset();
    161161
    162162    // Load the operands (baseVal, proto, and value respectively) into registers.
    … …  
    187187   
    188188    auto bytecode = currentInstruction->as<OpInstanceof>();
    189     int resultVReg = bytecode.dst.offset();
     189    int resultVReg = bytecode.m_dst.offset();
    190190   
    191191    JITInstanceOfGenerator& gen = m_instanceOfs[m_instanceOfIndex++];
    … …  
    205205{
    206206    auto bytecode = currentInstruction->as<OpIsEmpty>();
    207     int dst = bytecode.dst.offset();
    208     int value = bytecode.operand.offset();
     207    int dst = bytecode.m_dst.offset();
     208    int value = bytecode.m_operand.offset();
    209209
    210210    emitGetVirtualRegister(value, regT0);
    … …  
    218218{
    219219    auto bytecode = currentInstruction->as<OpIsUndefined>();
    220     int dst = bytecode.dst.offset();
    221     int value = bytecode.operand.offset();
     220    int dst = bytecode.m_dst.offset();
     221    int value = bytecode.m_operand.offset();
    222222   
    223223    emitGetVirtualRegister(value, regT0);
    … …  
    247247{
    248248    auto bytecode = currentInstruction->as<OpIsUndefinedOrNull>();
    249     int dst = bytecode.dst.offset();
    250     int value = bytecode.operand.offset();
     249    int dst = bytecode.m_dst.offset();
     250    int value = bytecode.m_operand.offset();
    251251
    252252    emitGetVirtualRegister(value, regT0);
    … …  
    262262{
    263263    auto bytecode = currentInstruction->as<OpIsBoolean>();
    264     int dst = bytecode.dst.offset();
    265     int value = bytecode.operand.offset();
     264    int dst = bytecode.m_dst.offset();
     265    int value = bytecode.m_operand.offset();
    266266   
    267267    emitGetVirtualRegister(value, regT0);
    … …  
    275275{
    276276    auto bytecode = currentInstruction->as<OpIsNumber>();
    277     int dst = bytecode.dst.offset();
    278     int value = bytecode.operand.offset();
     277    int dst = bytecode.m_dst.offset();
     278    int value = bytecode.m_operand.offset();
    279279   
    280280    emitGetVirtualRegister(value, regT0);
    … …  
    287287{
    288288    auto bytecode = currentInstruction->as<OpIsCellWithType>();
    289     int dst = bytecode.dst.offset();
    290     int value = bytecode.operand.offset();
    291     int type = bytecode.type;
     289    int dst = bytecode.m_dst.offset();
     290    int value = bytecode.m_operand.offset();
     291    int type = bytecode.m_type;
    292292
    293293    emitGetVirtualRegister(value, regT0);
    … …  
    308308{
    309309    auto bytecode = currentInstruction->as<OpIsObject>();
    310     int dst = bytecode.dst.offset();
    311     int value = bytecode.operand.offset();
     310    int dst = bytecode.m_dst.offset();
     311    int value = bytecode.m_operand.offset();
    312312
    313313    emitGetVirtualRegister(value, regT0);
    … …  
    333333    // Return the result in %eax.
    334334    auto bytecode = currentInstruction->as<OpRet>();
    335     emitGetVirtualRegister(bytecode.value.offset(), returnValueGPR);
     335    emitGetVirtualRegister(bytecode.m_value.offset(), returnValueGPR);
    336336
    337337    checkStackPointerAlignment();
    … …  
    344344{
    345345    auto bytecode = currentInstruction->as<OpToPrimitive>();
    346     int dst = bytecode.dst.offset();
    347     int src = bytecode.src.offset();
     346    int dst = bytecode.m_dst.offset();
     347    int src = bytecode.m_src.offset();
    348348
    349349    emitGetVirtualRegister(src, regT0);
    … …  
    361361{
    362362    auto bytecode = currentInstruction->as<OpSetFunctionName>();
    363     emitGetVirtualRegister(bytecode.function.offset(), regT0);
    364     emitGetVirtualRegister(bytecode.name.offset(), regT1);
     363    emitGetVirtualRegister(bytecode.m_function.offset(), regT0);
     364    emitGetVirtualRegister(bytecode.m_name.offset(), regT1);
    365365    callOperation(operationSetFunctionName, regT0, regT1);
    366366}
    … …  
    369369{
    370370    auto bytecode = currentInstruction->as<OpNot>();
    371     emitGetVirtualRegister(bytecode.operand.offset(), regT0);
     371    emitGetVirtualRegister(bytecode.m_operand.offset(), regT0);
    372372
    373373    // Invert against JSValue(false); if the value was tagged as a boolean, then all bits will be
    … …  
    378378    xor64(TrustedImm32(static_cast<int32_t>(ValueTrue)), regT0);
    379379
    380     emitPutVirtualRegister(bytecode.dst.offset());
     380    emitPutVirtualRegister(bytecode.m_dst.offset());
    381381}
    382382
    … …  
    384384{
    385385    auto bytecode = currentInstruction->as<OpJfalse>();
    386     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     386    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    387387
    388388    GPRReg value = regT0;
    … …  
    391391    bool shouldCheckMasqueradesAsUndefined = true;
    392392
    393     emitGetVirtualRegister(bytecode.condition.offset(), value);
     393    emitGetVirtualRegister(bytecode.m_condition.offset(), value);
    394394    addJump(branchIfFalsey(*vm(), JSValueRegs(value), scratch1, scratch2, fpRegT0, fpRegT1, shouldCheckMasqueradesAsUndefined, m_codeBlock->globalObject()), target);
    395395}
    … …  
    398398{
    399399    auto bytecode = currentInstruction->as<OpJeqNull>();
    400     int src = bytecode.value.offset();
    401     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     400    int src = bytecode.m_value.offset();
     401    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    402402
    403403    emitGetVirtualRegister(src, regT0);
    … …  
    422422{
    423423    auto bytecode = currentInstruction->as<OpJneqNull>();
    424     int src = bytecode.value.offset();
    425     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     424    int src = bytecode.m_value.offset();
     425    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    426426
    427427    emitGetVirtualRegister(src, regT0);
    … …  
    447447    auto bytecode = currentInstruction->as<OpJneqPtr>();
    448448    auto& metadata = bytecode.metadata(m_codeBlock);
    449     int src = bytecode.value.offset();
    450     Special::Pointer ptr = bytecode.specialPointer;
    451     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     449    int src = bytecode.m_value.offset();
     450    Special::Pointer ptr = bytecode.m_specialPointer;
     451    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    452452   
    453453    emitGetVirtualRegister(src, regT0);
    454454    CCallHelpers::Jump equal = branchPtr(Equal, regT0, TrustedImmPtr(actualPointerFor(m_codeBlock, ptr)));
    455     store8(TrustedImm32(1), &metadata.hasJumped);
     455    store8(TrustedImm32(1), &metadata.m_hasJumped);
    456456    addJump(jump(), target);
    457457    equal.link(this);
    … …  
    461461{
    462462    auto bytecode = currentInstruction->as<OpEq>();
    463     emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
     463    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
    464464    emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
    465465    compare32(Equal, regT1, regT0, regT0);
    466466    boxBoolean(regT0, JSValueRegs { regT0 });
    467     emitPutVirtualRegister(bytecode.dst.offset());
     467    emitPutVirtualRegister(bytecode.m_dst.offset());
    468468}
    469469
    … …  
    471471{
    472472    auto bytecode = currentInstruction->as<OpJeq>();
    473     unsigned target = jumpTarget(currentInstruction, bytecode.target);
    474     emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
     473    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     474    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
    475475    emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
    476476    addJump(branch32(Equal, regT0, regT1), target);
    … …  
    480480{
    481481    auto bytecode = currentInstruction->as<OpJtrue>();
    482     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     482    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    483483
    484484    GPRReg value = regT0;
    … …  
    486486    GPRReg scratch2 = regT2;
    487487    bool shouldCheckMasqueradesAsUndefined = true;
    488     emitGetVirtualRegister(bytecode.condition.offset(), value);
     488    emitGetVirtualRegister(bytecode.m_condition.offset(), value);
    489489    addJump(branchIfTruthy(*vm(), JSValueRegs(value), scratch1, scratch2, fpRegT0, fpRegT1, shouldCheckMasqueradesAsUndefined, m_codeBlock->globalObject()), target);
    490490}
    … …  
    493493{
    494494    auto bytecode = currentInstruction->as<OpNeq>();
    495     emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
     495    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
    496496    emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
    497497    compare32(NotEqual, regT1, regT0, regT0);
    498498    boxBoolean(regT0, JSValueRegs { regT0 });
    499499
    500     emitPutVirtualRegister(bytecode.dst.offset());
     500    emitPutVirtualRegister(bytecode.m_dst.offset());
    501501}
    502502
    … …  
    504504{
    505505    auto bytecode = currentInstruction->as<OpJneq>();
    506     unsigned target = jumpTarget(currentInstruction, bytecode.target);
    507     emitGetVirtualRegisters(bytecode.lhs.offset(), regT0, bytecode.rhs.offset(), regT1);
     506    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     507    emitGetVirtualRegisters(bytecode.m_lhs.offset(), regT0, bytecode.m_rhs.offset(), regT1);
    508508    emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
    509509    addJump(branch32(NotEqual, regT0, regT1), target);
    … …  
    515515    ASSERT(regT0 == returnValueGPR);
    516516    copyCalleeSavesToEntryFrameCalleeSavesBuffer(vm()->topEntryFrame);
    517     emitGetVirtualRegister(bytecode.value.offset(), regT0);
     517    emitGetVirtualRegister(bytecode.m_value.offset(), regT0);
    518518    callOperationNoExceptionCheck(operationThrow, regT0);
    519519    jumpToExceptionHandler(*vm());
    … …  
    524524{
    525525    auto bytecode = currentInstruction->as<Op>();
    526     int dst = bytecode.dst.offset();
    527     int src1 = bytecode.lhs.offset();
    528     int src2 = bytecode.rhs.offset();
     526    int dst = bytecode.m_dst.offset();
     527    int src1 = bytecode.m_lhs.offset();
     528    int src2 = bytecode.m_rhs.offset();
    529529
    530530    emitGetVirtualRegisters(src1, regT0, src2, regT1);
    … …  
    567567{
    568568    auto bytecode = currentInstruction->as<Op>();
    569     int target = jumpTarget(currentInstruction, bytecode.target);
    570     int src1 = bytecode.lhs.offset();
    571     int src2 = bytecode.rhs.offset();
     569    int target = jumpTarget(currentInstruction, bytecode.m_target);
     570    int src1 = bytecode.m_lhs.offset();
     571    int src2 = bytecode.m_rhs.offset();
    572572
    573573    emitGetVirtualRegisters(src1, regT0, src2, regT1);
    … …  
    608608
    609609    auto bytecode = currentInstruction->as<OpJstricteq>();
    610     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     610    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    611611    callOperation(operationCompareStrictEq, regT0, regT1);
    612612    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
    … …  
    618618
    619619    auto bytecode = currentInstruction->as<OpJnstricteq>();
    620     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     620    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    621621    callOperation(operationCompareStrictEq, regT0, regT1);
    622622    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
    … …  
    626626{
    627627    auto bytecode = currentInstruction->as<OpToNumber>();
    628     int dstVReg = bytecode.dst.offset();
    629     int srcVReg = bytecode.operand.offset();
     628    int dstVReg = bytecode.m_dst.offset();
     629    int srcVReg = bytecode.m_operand.offset();
    630630    emitGetVirtualRegister(srcVReg, regT0);
    631631   
    … …  
    640640{
    641641    auto bytecode = currentInstruction->as<OpToString>();
    642     int srcVReg = bytecode.operand.offset();
     642    int srcVReg = bytecode.m_operand.offset();
    643643    emitGetVirtualRegister(srcVReg, regT0);
    644644
    … …  
    646646    addSlowCase(branchIfNotString(regT0));
    647647
    648     emitPutVirtualRegister(bytecode.dst.offset());
     648    emitPutVirtualRegister(bytecode.m_dst.offset());
    649649}
    650650
    … …  
    652652{
    653653    auto bytecode = currentInstruction->as<OpToObject>();
    654     int dstVReg = bytecode.dst.offset();
    655     int srcVReg = bytecode.operand.offset();
     654    int dstVReg = bytecode.m_dst.offset();
     655    int srcVReg = bytecode.m_operand.offset();
    656656    emitGetVirtualRegister(srcVReg, regT0);
    657657
    … …  
    684684    load64(Address(regT3, VM::exceptionOffset()), regT0);
    685685    store64(TrustedImm64(JSValue::encode(JSValue())), Address(regT3, VM::exceptionOffset()));
    686     emitPutVirtualRegister(bytecode.exception.offset());
     686    emitPutVirtualRegister(bytecode.m_exception.offset());
    687687
    688688    load64(Address(regT0, Exception::valueOffset()), regT0);
    689     emitPutVirtualRegister(bytecode.thrownValue.offset());
     689    emitPutVirtualRegister(bytecode.m_thrownValue.offset());
    690690
    691691#if ENABLE(DFG_JIT)
    … …  
    695695
    696696    auto& metadata = bytecode.metadata(m_codeBlock);
    697     ValueProfileAndOperandBuffer* buffer = metadata.buffer;
     697    ValueProfileAndOperandBuffer* buffer = metadata.m_buffer;
    698698    if (buffer || !shouldEmitProfiling())
    699699        callOperation(operationTryOSREnterAtCatch, m_bytecodeOffset);
    … …  
    722722{
    723723    auto bytecode = currentInstruction->as<OpGetParentScope>();
    724     int currentScope = bytecode.scope.offset();
     724    int currentScope = bytecode.m_scope.offset();
    725725    emitGetVirtualRegister(currentScope, regT0);
    726726    loadPtr(Address(regT0, JSScope::offsetOfNext()), regT0);
    727     emitStoreCell(bytecode.dst.offset(), regT0);
     727    emitStoreCell(bytecode.m_dst.offset(), regT0);
    728728}
    729729
    … …  
    731731{
    732732    auto bytecode = currentInstruction->as<OpSwitchImm>();
    733     size_t tableIndex = bytecode.tableIndex;
    734     unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
    735     unsigned scrutinee = bytecode.scrutinee.offset();
     733    size_t tableIndex = bytecode.m_tableIndex;
     734    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
     735    unsigned scrutinee = bytecode.m_scrutinee.offset();
    736736
    737737    // create jump table for switch destinations, track this switch statement.
    … …  
    748748{
    749749    auto bytecode = currentInstruction->as<OpSwitchChar>();
    750     size_t tableIndex = bytecode.tableIndex;
    751     unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
    752     unsigned scrutinee = bytecode.scrutinee.offset();
     750    size_t tableIndex = bytecode.m_tableIndex;
     751    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
     752    unsigned scrutinee = bytecode.m_scrutinee.offset();
    753753
    754754    // create jump table for switch destinations, track this switch statement.
    … …  
    765765{
    766766    auto bytecode = currentInstruction->as<OpSwitchString>();
    767     size_t tableIndex = bytecode.tableIndex;
    768     unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
    769     unsigned scrutinee = bytecode.scrutinee.offset();
     767    size_t tableIndex = bytecode.m_tableIndex;
     768    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
     769    unsigned scrutinee = bytecode.m_scrutinee.offset();
    770770
    771771    // create jump table for switch destinations, track this switch statement.
    … …  
    783783    load32(codeBlock()->debuggerRequestsAddress(), regT0);
    784784    Jump noDebuggerRequests = branchTest32(Zero, regT0);
    785     callOperation(operationDebug, static_cast<int>(bytecode.debugHookType));
     785    callOperation(operationDebug, static_cast<int>(bytecode.m_debugHookType));
    786786    noDebuggerRequests.link(this);
    787787}
    … …  
    790790{
    791791    auto bytecode = currentInstruction->as<OpEqNull>();
    792     int dst = bytecode.dst.offset();
    793     int src1 = bytecode.operand.offset();
     792    int dst = bytecode.m_dst.offset();
     793    int src1 = bytecode.m_operand.offset();
    794794
    795795    emitGetVirtualRegister(src1, regT0);
    … …  
    823823{
    824824    auto bytecode = currentInstruction->as<OpNeqNull>();
    825     int dst = bytecode.dst.offset();
    826     int src1 = bytecode.operand.offset();
     825    int dst = bytecode.m_dst.offset();
     826    int src1 = bytecode.m_operand.offset();
    827827
    828828    emitGetVirtualRegister(src1, regT0);
    … …  
    869869{
    870870    auto bytecode = currentInstruction->as<OpGetScope>();
    871     int dst = bytecode.dst.offset();
     871    int dst = bytecode.m_dst.offset();
    872872    emitGetFromCallFrameHeaderPtr(CallFrameSlot::callee, regT0);
    873873    loadPtr(Address(regT0, JSFunction::offsetOfScopeChain()), regT0);
    … …  
    879879    auto bytecode = currentInstruction->as<OpToThis>();
    880880    auto& metadata = bytecode.metadata(m_codeBlock);
    881     WriteBarrierBase<Structure>* cachedStructure = &metadata.cachedStructure;
    882     emitGetVirtualRegister(bytecode.srcDst.offset(), regT1);
     881    WriteBarrierBase<Structure>* cachedStructure = &metadata.m_cachedStructure;
     882    emitGetVirtualRegister(bytecode.m_srcDst.offset(), regT1);
    883883
    884884    emitJumpSlowCaseIfNotJSCell(regT1);
    … …  
    895895    auto bytecode = currentInstruction->as<OpCreateThis>();
    896896    auto& metadata = bytecode.metadata(m_codeBlock);
    897     int callee = bytecode.callee.offset();
    898     WriteBarrierBase<JSCell>* cachedFunction = &metadata.cachedCallee;
     897    int callee = bytecode.m_callee.offset();
     898    WriteBarrierBase<JSCell>* cachedFunction = &metadata.m_cachedCallee;
    899899    RegisterID calleeReg = regT0;
    900900    RegisterID rareDataReg = regT4;
    … …  
    927927    emitInitializeInlineStorage(resultReg, scratchReg);
    928928    addSlowCase(slowCases);
    929     emitPutVirtualRegister(bytecode.dst.offset());
     929    emitPutVirtualRegister(bytecode.m_dst.offset());
    930930}
    931931
    … …  
    933933{
    934934    auto bytecode = currentInstruction->as<OpCheckTdz>();
    935     emitGetVirtualRegister(bytecode.target.offset(), regT0);
     935    emitGetVirtualRegister(bytecode.m_target.offset(), regT0);
    936936    addSlowCase(branchIfEmpty(regT0));
    937937}
    … …  
    947947    callOperation(operationCompareEq, regT0, regT1);
    948948    boxBoolean(returnValueGPR, JSValueRegs { returnValueGPR });
    949     emitPutVirtualRegister(bytecode.dst.offset(), returnValueGPR);
     949    emitPutVirtualRegister(bytecode.m_dst.offset(), returnValueGPR);
    950950}
    951951
    … …  
    958958    xor32(TrustedImm32(0x1), regT0);
    959959    boxBoolean(returnValueGPR, JSValueRegs { returnValueGPR });
    960     emitPutVirtualRegister(bytecode.dst.offset(), returnValueGPR);
     960    emitPutVirtualRegister(bytecode.m_dst.offset(), returnValueGPR);
    961961}
    962962
    … …  
    966966
    967967    auto bytecode = currentInstruction->as<OpJeq>();
    968     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     968    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    969969    callOperation(operationCompareEq, regT0, regT1);
    970970    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
    … …  
    976976
    977977    auto bytecode = currentInstruction->as<OpJneq>();
    978     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     978    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    979979    callOperation(operationCompareEq, regT0, regT1);
    980980    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
    … …  
    986986
    987987    auto bytecode = currentInstruction->as<OpInstanceofCustom>();
    988     int dst = bytecode.dst.offset();
    989     int value = bytecode.value.offset();
    990     int constructor = bytecode.constructor.offset();
    991     int hasInstanceValue = bytecode.hasInstanceValue.offset();
     988    int dst = bytecode.m_dst.offset();
     989    int value = bytecode.m_value.offset();
     990    int constructor = bytecode.m_constructor.offset();
     991    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
    992992
    993993    emitGetVirtualRegister(value, regT0);
    … …  
    10661066{
    10671067    auto bytecode = currentInstruction->as<OpNewRegexp>();
    1068     int dst = bytecode.dst.offset();
    1069     int regexp = bytecode.regexp.offset();
     1068    int dst = bytecode.m_dst.offset();
     1069    int regexp = bytecode.m_regexp.offset();
    10701070    callOperation(operationNewRegexp, jsCast<RegExp*>(m_codeBlock->getConstant(regexp)));
    10711071    emitStoreCell(dst, returnValueGPR);
    … …  
    10771077    Jump lazyJump;
    10781078    auto bytecode = currentInstruction->as<Op>();
    1079     int dst = bytecode.dst.offset();
     1079    int dst = bytecode.m_dst.offset();
    10801080
    10811081#if USE(JSVALUE64)
    1082     emitGetVirtualRegister(bytecode.scope.offset(), regT0);
     1082    emitGetVirtualRegister(bytecode.m_scope.offset(), regT0);
    10831083#else
    1084     emitLoadPayload(bytecode.scope.offset(), regT0);
     1084    emitLoadPayload(bytecode.m_scope.offset(), regT0);
    10851085#endif
    1086     FunctionExecutable* funcExec = m_codeBlock->functionDecl(bytecode.functionDecl);
     1086    FunctionExecutable* funcExec = m_codeBlock->functionDecl(bytecode.m_functionDecl);
    10871087
    10881088    OpcodeID opcodeID = Op::opcodeID;
    … …  
    11231123{
    11241124    auto bytecode = currentInstruction->as<Op>();
    1125     int dst = bytecode.dst.offset();
     1125    int dst = bytecode.m_dst.offset();
    11261126#if USE(JSVALUE64)
    1127     emitGetVirtualRegister(bytecode.scope.offset(), regT0);
     1127    emitGetVirtualRegister(bytecode.m_scope.offset(), regT0);
    11281128#else
    1129     emitLoadPayload(bytecode.scope.offset(), regT0);
     1129    emitLoadPayload(bytecode.m_scope.offset(), regT0);
    11301130#endif
    11311131
    1132     FunctionExecutable* function = m_codeBlock->functionExpr(bytecode.functionDecl);
     1132    FunctionExecutable* function = m_codeBlock->functionExpr(bytecode.m_functionDecl);
    11331133    OpcodeID opcodeID = Op::opcodeID;
    11341134
    … …  
    11691169    auto bytecode = currentInstruction->as<OpNewArray>();
    11701170    auto& metadata = bytecode.metadata(m_codeBlock);
    1171     int dst = bytecode.dst.offset();
    1172     int valuesIndex = bytecode.argv.offset();
    1173     int size = bytecode.argc;
     1171    int dst = bytecode.m_dst.offset();
     1172    int valuesIndex = bytecode.m_argv.offset();
     1173    int size = bytecode.m_argc;
    11741174    addPtr(TrustedImm32(valuesIndex * sizeof(Register)), callFrameRegister, regT0);
    11751175    callOperation(operationNewArrayWithProfile, dst,
    1176         &metadata.arrayAllocationProfile, regT0, size);
     1176        &metadata.m_arrayAllocationProfile, regT0, size);
    11771177}
    11781178
    … …  
    11811181    auto bytecode = currentInstruction->as<OpNewArrayWithSize>();
    11821182    auto& metadata = bytecode.metadata(m_codeBlock);
    1183     int dst = bytecode.dst.offset();
    1184     int sizeIndex = bytecode.length.offset();
     1183    int dst = bytecode.m_dst.offset();
     1184    int sizeIndex = bytecode.m_length.offset();
    11851185#if USE(JSVALUE64)
    11861186    emitGetVirtualRegister(sizeIndex, regT0);
    11871187    callOperation(operationNewArrayWithSizeAndProfile, dst,
    1188         &metadata.arrayAllocationProfile, regT0);
     1188        &metadata.m_arrayAllocationProfile, regT0);
    11891189#else
    11901190    emitLoad(sizeIndex, regT1, regT0);
    11911191    callOperation(operationNewArrayWithSizeAndProfile, dst,
    1192         &metadata.arrayAllocationProfile, JSValueRegs(regT1, regT0));
     1192        &metadata.m_arrayAllocationProfile, JSValueRegs(regT1, regT0));
    11931193#endif
    11941194}
    … …  
    11981198{
    11991199    auto bytecode = currentInstruction->as<OpHasStructureProperty>();
    1200     int dst = bytecode.dst.offset();
    1201     int base = bytecode.base.offset();
    1202     int enumerator = bytecode.enumerator.offset();
     1200    int dst = bytecode.m_dst.offset();
     1201    int base = bytecode.m_base.offset();
     1202    int enumerator = bytecode.m_enumerator.offset();
    12031203
    12041204    emitGetVirtualRegister(base, regT0);
    … …  
    12441244    auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
    12451245    auto& metadata = bytecode.metadata(m_codeBlock);
    1246     int dst = bytecode.dst.offset();
    1247     int base = bytecode.base.offset();
    1248     int property = bytecode.property.offset();
    1249     ArrayProfile* profile = &metadata.arrayProfile;
     1246    int dst = bytecode.m_dst.offset();
     1247    int base = bytecode.m_base.offset();
     1248    int property = bytecode.m_property.offset();
     1249    ArrayProfile* profile = &metadata.m_arrayProfile;
    12501250    ByValInfo* byValInfo = m_codeBlock->addByValInfo();
    12511251   
    … …  
    12901290
    12911291    auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
    1292     int dst = bytecode.dst.offset();
    1293     int base = bytecode.base.offset();
    1294     int property = bytecode.property.offset();
     1292    int dst = bytecode.m_dst.offset();
     1293    int base = bytecode.m_base.offset();
     1294    int property = bytecode.m_property.offset();
    12951295    ByValInfo* byValInfo = m_byValCompilationInfo[m_byValInstructionIndex].byValInfo;
    12961296
    … …  
    13091309{
    13101310    auto bytecode = currentInstruction->as<OpGetDirectPname>();
    1311     int dst = bytecode.dst.offset();
    1312     int base = bytecode.base.offset();
    1313     int index = bytecode.index.offset();
    1314     int enumerator = bytecode.enumerator.offset();
     1311    int dst = bytecode.m_dst.offset();
     1312    int base = bytecode.m_base.offset();
     1313    int index = bytecode.m_index.offset();
     1314    int enumerator = bytecode.m_enumerator.offset();
    13151315
    13161316    // Check that base is a cell
    … …  
    13501350{
    13511351    auto bytecode = currentInstruction->as<OpEnumeratorStructurePname>();
    1352     int dst = bytecode.dst.offset();
    1353     int enumerator = bytecode.enumerator.offset();
    1354     int index = bytecode.index.offset();
     1352    int dst = bytecode.m_dst.offset();
     1353    int enumerator = bytecode.m_enumerator.offset();
     1354    int index = bytecode.m_index.offset();
    13551355
    13561356    emitGetVirtualRegister(index, regT0);
    … …  
    13741374{
    13751375    auto bytecode = currentInstruction->as<OpEnumeratorGenericPname>();
    1376     int dst = bytecode.dst.offset();
    1377     int enumerator = bytecode.enumerator.offset();
    1378     int index = bytecode.index.offset();
     1376    int dst = bytecode.m_dst.offset();
     1377    int enumerator = bytecode.m_enumerator.offset();
     1378    int index = bytecode.m_index.offset();
    13791379
    13801380    emitGetVirtualRegister(index, regT0);
    … …  
    13991399    auto bytecode = currentInstruction->as<OpProfileType>();
    14001400    auto& metadata = bytecode.metadata(m_codeBlock);
    1401     TypeLocation* cachedTypeLocation = metadata.typeLocation;
    1402     int valueToProfile = bytecode.target.offset();
     1401    TypeLocation* cachedTypeLocation = metadata.m_typeLocation;
     1402    int valueToProfile = bytecode.m_target.offset();
    14031403
    14041404    emitGetVirtualRegister(valueToProfile, regT0);
    … …  
    14681468    GPRReg scratch2Reg = regT2;
    14691469    ensureShadowChickenPacket(*vm(), shadowPacketReg, scratch1Reg, scratch2Reg);
    1470     emitGetVirtualRegister(bytecode.scope.offset(), regT3);
     1470    emitGetVirtualRegister(bytecode.m_scope.offset(), regT3);
    14711471    logShadowChickenProloguePacket(shadowPacketReg, scratch1Reg, regT3);
    14721472}
    … …  
    14811481    GPRReg scratch2Reg = regT2;
    14821482    ensureShadowChickenPacket(*vm(), shadowPacketReg, scratch1Reg, scratch2Reg);
    1483     emitGetVirtualRegister(bytecode.thisValue.offset(), regT2);
    1484     emitGetVirtualRegister(bytecode.scope.offset(), regT3);
     1483    emitGetVirtualRegister(bytecode.m_thisValue.offset(), regT2);
     1484    emitGetVirtualRegister(bytecode.m_scope.offset(), regT3);
    14851485    logShadowChickenTailPacket(shadowPacketReg, JSValueRegs(regT2), regT3, m_codeBlock, CallSiteIndex(m_bytecodeOffset));
    14861486}
    … …  
    14921492    auto bytecode = currentInstruction->as<OpProfileControlFlow>();
    14931493    auto& metadata = bytecode.metadata(m_codeBlock);
    1494     BasicBlockLocation* basicBlockLocation = metadata.basicBlockLocation;
     1494    BasicBlockLocation* basicBlockLocation = metadata.m_basicBlockLocation;
    14951495#if USE(JSVALUE64)
    14961496    basicBlockLocation->emitExecuteCode(*this);
    … …  
    15031503{
    15041504    auto bytecode = currentInstruction->as<OpArgumentCount>();
    1505     int dst = bytecode.dst.offset();
     1505    int dst = bytecode.m_dst.offset();
    15061506    load32(payloadFor(CallFrameSlot::argumentCount), regT0);
    15071507    sub32(TrustedImm32(1), regT0);
    … …  
    15141514{
    15151515    auto bytecode = currentInstruction->as<OpGetRestLength>();
    1516     int dst = bytecode.dst.offset();
    1517     unsigned numParamsToSkip = bytecode.numParametersToSkip;
     1516    int dst = bytecode.m_dst.offset();
     1517    unsigned numParamsToSkip = bytecode.m_numParametersToSkip;
    15181518    load32(payloadFor(CallFrameSlot::argumentCount), regT0);
    15191519    sub32(TrustedImm32(1), regT0);
    … …  
    15441544{
    15451545    auto bytecode = currentInstruction->as<OpGetArgument>();
    1546     int dst = bytecode.dst.offset();
    1547     int index = bytecode.index;
     1546    int dst = bytecode.m_dst.offset();
     1547    int index = bytecode.m_index;
    15481548#if USE(JSVALUE64)
    15491549    JSValueRegs resultRegs(regT0);

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

    r239761 r240041  
    11/*
    2  * Copyright (C) 2009-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009-2019 Apple Inc. All rights reserved.
    33 * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
    44 *
    … …  
    5151{
    5252    auto bytecode = currentInstruction->as<OpMov>();
    53     int dst = bytecode.dst.offset();
    54     int src = bytecode.src.offset();
     53    int dst = bytecode.m_dst.offset();
     54    int src = bytecode.m_src.offset();
    5555   
    5656    if (m_codeBlock->isConstantRegisterIndex(src))
    … …  
    6666    ASSERT(returnValueGPR != callFrameRegister);
    6767    auto bytecode = currentInstruction->as<OpEnd>();
    68     emitLoad(bytecode.value.offset(), regT1, returnValueGPR);
     68    emitLoad(bytecode.m_value.offset(), regT1, returnValueGPR);
    6969    emitRestoreCalleeSaves();
    7070    emitFunctionEpilogue();
    … …  
    7575{
    7676    auto bytecode = currentInstruction->as<OpJmp>();
    77     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     77    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    7878    addJump(jump(), target);
    7979}
    … …  
    8383    auto bytecode = currentInstruction->as<OpNewObject>();
    8484    auto& metadata = bytecode.metadata(m_codeBlock);
    85     Structure* structure = metadata.objectAllocationProfile.structure();
     85    Structure* structure = metadata.m_objectAllocationProfile.structure();
    8686    size_t allocationSize = JSFinalObject::allocationSize(structure->inlineCapacity());
    8787    Allocator allocator = subspaceFor<JSFinalObject>(*m_vm)->allocatorForNonVirtual(allocationSize, AllocatorForMode::AllocatorIfExists);
    … …  
    9999        emitInitializeInlineStorage(resultReg, structure->inlineCapacity());
    100100        addSlowCase(slowCases);
    101         emitStoreCell(bytecode.dst.offset(), resultReg);
     101        emitStoreCell(bytecode.m_dst.offset(), resultReg);
    102102    }
    103103}
    … …  
    109109    auto bytecode = currentInstruction->as<OpNewObject>();
    110110    auto& metadata = bytecode.metadata(m_codeBlock);
    111     int dst = bytecode.dst.offset();
    112     Structure* structure = metadata.objectAllocationProfile.structure();
     111    int dst = bytecode.m_dst.offset();
     112    Structure* structure = metadata.m_objectAllocationProfile.structure();
    113113    callOperation(operationNewObject, structure);
    114114    emitStoreCell(dst, returnValueGPR);
    … …  
    118118{
    119119    auto bytecode = currentInstruction->as<OpOverridesHasInstance>();
    120     int dst = bytecode.dst.offset();
    121     int constructor = bytecode.constructor.offset();
    122     int hasInstanceValue = bytecode.hasInstanceValue.offset();
     120    int dst = bytecode.m_dst.offset();
     121    int constructor = bytecode.m_constructor.offset();
     122    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
    123123
    124124    emitLoadPayload(hasInstanceValue, regT0);
    … …  
    146146{
    147147    auto bytecode = currentInstruction->as<OpInstanceof>();
    148     int dst = bytecode.dst.offset();
    149     int value = bytecode.value.offset();
    150     int proto = bytecode.prototype.offset();
     148    int dst = bytecode.m_dst.offset();
     149    int value = bytecode.m_value.offset();
     150    int proto = bytecode.m_prototype.offset();
    151151
    152152    // Load the operands into registers.
    … …  
    183183   
    184184    auto bytecode = currentInstruction->as<OpInstanceof>();
    185     int dst = bytecode.dst.offset();
    186     int value = bytecode.value.offset();
    187     int proto = bytecode.prototype.offset();
     185    int dst = bytecode.m_dst.offset();
     186    int value = bytecode.m_value.offset();
     187    int proto = bytecode.m_prototype.offset();
    188188   
    189189    JITInstanceOfGenerator& gen = m_instanceOfs[m_instanceOfIndex++];
    … …  
    201201
    202202    auto bytecode = currentInstruction->as<OpInstanceofCustom>();
    203     int dst = bytecode.dst.offset();
    204     int value = bytecode.value.offset();
    205     int constructor = bytecode.constructor.offset();
    206     int hasInstanceValue = bytecode.hasInstanceValue.offset();
     203    int dst = bytecode.m_dst.offset();
     204    int value = bytecode.m_value.offset();
     205    int constructor = bytecode.m_constructor.offset();
     206    int hasInstanceValue = bytecode.m_hasInstanceValue.offset();
    207207
    208208    emitLoad(value, regT1, regT0);
    … …  
    216216{
    217217    auto bytecode = currentInstruction->as<OpIsEmpty>();
    218     int dst = bytecode.dst.offset();
    219     int value = bytecode.operand.offset();
     218    int dst = bytecode.m_dst.offset();
     219    int value = bytecode.m_operand.offset();
    220220   
    221221    emitLoad(value, regT1, regT0);
    … …  
    228228{
    229229    auto bytecode = currentInstruction->as<OpIsUndefined>();
    230     int dst = bytecode.dst.offset();
    231     int value = bytecode.operand.offset();
     230    int dst = bytecode.m_dst.offset();
     231    int value = bytecode.m_operand.offset();
    232232   
    233233    emitLoad(value, regT1, regT0);
    … …  
    256256{
    257257    auto bytecode = currentInstruction->as<OpIsUndefinedOrNull>();
    258     int dst = bytecode.dst.offset();
    259     int value = bytecode.operand.offset();
     258    int dst = bytecode.m_dst.offset();
     259    int value = bytecode.m_operand.offset();
    260260
    261261    emitLoadTag(value, regT0);
    … …  
    269269{
    270270    auto bytecode = currentInstruction->as<OpIsBoolean>();
    271     int dst = bytecode.dst.offset();
    272     int value = bytecode.operand.offset();
     271    int dst = bytecode.m_dst.offset();
     272    int value = bytecode.m_operand.offset();
    273273   
    274274    emitLoadTag(value, regT0);
    … …  
    280280{
    281281    auto bytecode = currentInstruction->as<OpIsNumber>();
    282     int dst = bytecode.dst.offset();
    283     int value = bytecode.operand.offset();
     282    int dst = bytecode.m_dst.offset();
     283    int value = bytecode.m_operand.offset();
    284284   
    285285    emitLoadTag(value, regT0);
    … …  
    292292{
    293293    auto bytecode = currentInstruction->as<OpIsCellWithType>();
    294     int dst = bytecode.dst.offset();
    295     int value = bytecode.operand.offset();
    296     int type = bytecode.type;
     294    int dst = bytecode.m_dst.offset();
     295    int value = bytecode.m_operand.offset();
     296    int type = bytecode.m_type;
    297297
    298298    emitLoad(value, regT1, regT0);
    … …  
    312312{
    313313    auto bytecode = currentInstruction->as<OpIsObject>();
    314     int dst = bytecode.dst.offset();
    315     int value = bytecode.operand.offset();
     314    int dst = bytecode.m_dst.offset();
     315    int value = bytecode.m_operand.offset();
    316316
    317317    emitLoad(value, regT1, regT0);
    … …  
    331331{
    332332    auto bytecode = currentInstruction->as<OpToPrimitive>();
    333     int dst = bytecode.dst.offset();
    334     int src = bytecode.src.offset();
     333    int dst = bytecode.m_dst.offset();
     334    int src = bytecode.m_src.offset();
    335335
    336336    emitLoad(src, regT1, regT0);
    … …  
    347347{
    348348    auto bytecode = currentInstruction->as<OpSetFunctionName>();
    349     int func = bytecode.function.offset();
    350     int name = bytecode.name.offset();
     349    int func = bytecode.m_function.offset();
     350    int name = bytecode.m_name.offset();
    351351    emitLoadPayload(func, regT1);
    352352    emitLoad(name, regT3, regT2);
    … …  
    357357{
    358358    auto bytecode = currentInstruction->as<OpNot>();
    359     int dst = bytecode.dst.offset();
    360     int src = bytecode.operand.offset();
     359    int dst = bytecode.m_dst.offset();
     360    int src = bytecode.m_operand.offset();
    361361
    362362    emitLoadTag(src, regT0);
    … …  
    372372{
    373373    auto bytecode = currentInstruction->as<OpJfalse>();
    374     int cond = bytecode.condition.offset();
    375     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     374    int cond = bytecode.m_condition.offset();
     375    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    376376
    377377    emitLoad(cond, regT1, regT0);
    … …  
    387387{
    388388    auto bytecode = currentInstruction->as<OpJtrue>();
    389     int cond = bytecode.condition.offset();
    390     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     389    int cond = bytecode.m_condition.offset();
     390    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    391391
    392392    emitLoad(cond, regT1, regT0);
    … …  
    401401{
    402402    auto bytecode = currentInstruction->as<OpJeqNull>();
    403     int src = bytecode.value.offset();
    404     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     403    int src = bytecode.m_value.offset();
     404    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    405405
    406406    emitLoad(src, regT1, regT0);
    … …  
    427427{
    428428    auto bytecode = currentInstruction->as<OpJneqNull>();
    429     int src = bytecode.value.offset();
    430     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     429    int src = bytecode.m_value.offset();
     430    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    431431
    432432    emitLoad(src, regT1, regT0);
    … …  
    454454    auto bytecode = currentInstruction->as<OpJneqPtr>();
    455455    auto& metadata = bytecode.metadata(m_codeBlock);
    456     int src = bytecode.value.offset();
    457     Special::Pointer ptr = bytecode.specialPointer;
    458     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     456    int src = bytecode.m_value.offset();
     457    Special::Pointer ptr = bytecode.m_specialPointer;
     458    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    459459
    460460    emitLoad(src, regT1, regT0);
    … …  
    462462    Jump equal = branchPtr(Equal, regT0, TrustedImmPtr(actualPointerFor(m_codeBlock, ptr)));
    463463    notCell.link(this);
    464     store8(TrustedImm32(1), &metadata.hasJumped);
     464    store8(TrustedImm32(1), &metadata.m_hasJumped);
    465465    addJump(jump(), target);
    466466    equal.link(this);
    … …  
    471471    auto bytecode = currentInstruction->as<OpEq>();
    472472
    473     int dst = bytecode.dst.offset();
    474     int src1 = bytecode.lhs.offset();
    475     int src2 = bytecode.rhs.offset();
     473    int dst = bytecode.m_dst.offset();
     474    int src1 = bytecode.m_lhs.offset();
     475    int src2 = bytecode.m_rhs.offset();
    476476
    477477    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
    … …  
    488488{
    489489    auto bytecode = currentInstruction->as<OpEq>();
    490     int dst = bytecode.dst.offset();
     490    int dst = bytecode.m_dst.offset();
    491491
    492492    JumpList storeResult;
    … …  
    515515{
    516516    auto bytecode = currentInstruction->as<OpJeq>();
    517     unsigned target = jumpTarget(currentInstruction, bytecode.target);
    518     int src1 = bytecode.lhs.offset();
    519     int src2 = bytecode.rhs.offset();
     517    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     518    int src1 = bytecode.m_lhs.offset();
     519    int src2 = bytecode.m_rhs.offset();
    520520
    521521    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
    … …  
    555555{
    556556    auto bytecode = currentInstruction->as<OpJeq>();
    557     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     557    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    558558    compileOpEqJumpSlow(iter, CompileOpEqType::Eq, target);
    559559}
    … …  
    562562{
    563563    auto bytecode = currentInstruction->as<OpNeq>();
    564     int dst = bytecode.dst.offset();
    565     int src1 = bytecode.lhs.offset();
    566     int src2 = bytecode.rhs.offset();
     564    int dst = bytecode.m_dst.offset();
     565    int src1 = bytecode.m_lhs.offset();
     566    int src2 = bytecode.m_rhs.offset();
    567567
    568568    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
    … …  
    579579{
    580580    auto bytecode = currentInstruction->as<OpNeq>();
    581     int dst = bytecode.dst.offset();
     581    int dst = bytecode.m_dst.offset();
    582582
    583583    JumpList storeResult;
    … …  
    607607{
    608608    auto bytecode = currentInstruction->as<OpJneq>();
    609     unsigned target = jumpTarget(currentInstruction, bytecode.target);
    610     int src1 = bytecode.lhs.offset();
    611     int src2 = bytecode.rhs.offset();
     609    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
     610    int src1 = bytecode.m_lhs.offset();
     611    int src2 = bytecode.m_rhs.offset();
    612612
    613613    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
    … …  
    622622{
    623623    auto bytecode = currentInstruction->as<OpJneq>();
    624     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     624    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    625625    compileOpEqJumpSlow(iter, CompileOpEqType::NEq, target);
    626626}
    … …  
    630630{
    631631    auto bytecode = currentInstruction->as<Op>();
    632     int dst = bytecode.dst.offset();
    633     int src1 = bytecode.lhs.offset();
    634     int src2 = bytecode.rhs.offset();
     632    int dst = bytecode.m_dst.offset();
     633    int src1 = bytecode.m_lhs.offset();
     634    int src2 = bytecode.m_rhs.offset();
    635635
    636636    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
    … …  
    670670{
    671671    auto bytecode = currentInstruction->as<Op>();
    672     int target = jumpTarget(currentInstruction, bytecode.target);
    673     int src1 = bytecode.lhs.offset();
    674     int src2 = bytecode.rhs.offset();
     672    int target = jumpTarget(currentInstruction, bytecode.m_target);
     673    int src1 = bytecode.m_lhs.offset();
     674    int src2 = bytecode.m_rhs.offset();
    675675
    676676    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
    … …  
    709709
    710710    auto bytecode = currentInstruction->as<OpJstricteq>();
    711     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     711    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    712712    callOperation(operationCompareStrictEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
    713713    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
    … …  
    719719
    720720    auto bytecode = currentInstruction->as<OpJnstricteq>();
    721     unsigned target = jumpTarget(currentInstruction, bytecode.target);
     721    unsigned target = jumpTarget(currentInstruction, bytecode.m_target);
    722722    callOperation(operationCompareStrictEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
    723723    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
    … …  
    727727{
    728728    auto bytecode = currentInstruction->as<OpEqNull>();
    729     int dst = bytecode.dst.offset();
    730     int src = bytecode.operand.offset();
     729    int dst = bytecode.m_dst.offset();
     730    int src = bytecode.m_operand.offset();
    731731
    732732    emitLoad(src, regT1, regT0);
    … …  
    759759{
    760760    auto bytecode = currentInstruction->as<OpNeqNull>();
    761     int dst = bytecode.dst.offset();
    762     int src = bytecode.operand.offset();
     761    int dst = bytecode.m_dst.offset();
     762    int src = bytecode.m_operand.offset();
    763763
    764764    emitLoad(src, regT1, regT0);
    … …  
    793793    ASSERT(regT0 == returnValueGPR);
    794794    copyCalleeSavesToEntryFrameCalleeSavesBuffer(vm()->topEntryFrame);
    795     emitLoad(bytecode.value.offset(), regT1, regT0);
     795    emitLoad(bytecode.m_value.offset(), regT1, regT0);
    796796    callOperationNoExceptionCheck(operationThrow, JSValueRegs(regT1, regT0));
    797797    jumpToExceptionHandler(*vm());
    … …  
    801801{
    802802    auto bytecode = currentInstruction->as<OpToNumber>();
    803     int dst = bytecode.dst.offset();
    804     int src = bytecode.operand.offset();
     803    int dst = bytecode.m_dst.offset();
     804    int src = bytecode.m_operand.offset();
    805805
    806806    emitLoad(src, regT1, regT0);
    … …  
    818818{
    819819    auto bytecode = currentInstruction->as<OpToString>();
    820     int dst = bytecode.dst.offset();
    821     int src = bytecode.operand.offset();
     820    int dst = bytecode.m_dst.offset();
     821    int src = bytecode.m_operand.offset();
    822822
    823823    emitLoad(src, regT1, regT0);
    … …  
    833833{
    834834    auto bytecode = currentInstruction->as<OpToObject>();
    835     int dst = bytecode.dst.offset();
    836     int src = bytecode.operand.offset();
     835    int dst = bytecode.m_dst.offset();
     836    int src = bytecode.m_operand.offset();
    837837
    838838    emitLoad(src, regT1, regT0);
    … …  
    872872    store32(TrustedImm32(0), Address(regT3, VM::exceptionOffset()));
    873873
    874     unsigned exception = bytecode.exception.offset();
     874    unsigned exception = bytecode.m_exception.offset();
    875875    emitStore(exception, regT1, regT2);
    876876
    … …  
    878878    load32(Address(regT2, Exception::valueOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
    879879
    880     unsigned thrownValue = bytecode.thrownValue.offset();
     880    unsigned thrownValue = bytecode.m_thrownValue.offset();
    881881    emitStore(thrownValue, regT1, regT0);
    882882
    … …  
    887887
    888888    auto& metadata = bytecode.metadata(m_codeBlock);
    889     ValueProfileAndOperandBuffer* buffer = metadata.buffer;
     889    ValueProfileAndOperandBuffer* buffer = metadata.m_buffer;
    890890    if (buffer || !shouldEmitProfiling())
    891891        callOperation(operationTryOSREnterAtCatch, m_bytecodeOffset);
    … …  
    914914{
    915915    auto bytecode = currentInstruction->as<OpGetParentScope>();
    916     int currentScope = bytecode.scope.offset();
     916    int currentScope = bytecode.m_scope.offset();
    917917    emitLoadPayload(currentScope, regT0);
    918918    loadPtr(Address(regT0, JSScope::offsetOfNext()), regT0);
    919     emitStoreCell(bytecode.dst.offset(), regT0);
     919    emitStoreCell(bytecode.m_dst.offset(), regT0);
    920920}
    921921
    … …  
    923923{
    924924    auto bytecode = currentInstruction->as<OpSwitchImm>();
    925     size_t tableIndex = bytecode.tableIndex;
    926     unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
    927     unsigned scrutinee = bytecode.scrutinee.offset();
     925    size_t tableIndex = bytecode.m_tableIndex;
     926    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
     927    unsigned scrutinee = bytecode.m_scrutinee.offset();
    928928
    929929    // create jump table for switch destinations, track this switch statement.
    … …  
    940940{
    941941    auto bytecode = currentInstruction->as<OpSwitchChar>();
    942     size_t tableIndex = bytecode.tableIndex;
    943     unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
    944     unsigned scrutinee = bytecode.scrutinee.offset();
     942    size_t tableIndex = bytecode.m_tableIndex;
     943    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
     944    unsigned scrutinee = bytecode.m_scrutinee.offset();
    945945
    946946    // create jump table for switch destinations, track this switch statement.
    … …  
    957957{
    958958    auto bytecode = currentInstruction->as<OpSwitchString>();
    959     size_t tableIndex = bytecode.tableIndex;
    960     unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.defaultOffset);
    961     unsigned scrutinee = bytecode.scrutinee.offset();
     959    size_t tableIndex = bytecode.m_tableIndex;
     960    unsigned defaultOffset = jumpTarget(currentInstruction, bytecode.m_defaultOffset);
     961    unsigned scrutinee = bytecode.m_scrutinee.offset();
    962962
    963963    // create jump table for switch destinations, track this switch statement.
    … …  
    975975    load32(codeBlock()->debuggerRequestsAddress(), regT0);
    976976    Jump noDebuggerRequests = branchTest32(Zero, regT0);
    977     callOperation(operationDebug, static_cast<int>(bytecode.debugHookType));
     977    callOperation(operationDebug, static_cast<int>(bytecode.m_debugHookType));
    978978    noDebuggerRequests.link(this);
    979979}
    … …  
    997997{
    998998    auto bytecode = currentInstruction->as<OpGetScope>();
    999     int dst = bytecode.dst.offset();
     999    int dst = bytecode.m_dst.offset();
    10001000    emitGetFromCallFrameHeaderPtr(CallFrameSlot::callee, regT0);
    10011001    loadPtr(Address(regT0, JSFunction::offsetOfScopeChain()), regT0);
    … …  
    10071007    auto bytecode = currentInstruction->as<OpCreateThis>();
    10081008    auto& metadata = bytecode.metadata(m_codeBlock);
    1009     int callee = bytecode.callee.offset();
    1010     WriteBarrierBase<JSCell>* cachedFunction = &metadata.cachedCallee;
     1009    int callee = bytecode.m_callee.offset();
     1010    WriteBarrierBase<JSCell>* cachedFunction = &metadata.m_cachedCallee;
    10111011    RegisterID calleeReg = regT0;
    10121012    RegisterID rareDataReg = regT4;
    … …  
    10371037    emitInitializeInlineStorage(resultReg, scratchReg);
    10381038    addSlowCase(slowCases);
    1039     emitStoreCell(bytecode.dst.offset(), resultReg);
     1039    emitStoreCell(bytecode.m_dst.offset(), resultReg);
    10401040}
    10411041
    … …  
    10441044    auto bytecode = currentInstruction->as<OpToThis>();
    10451045    auto& metadata = bytecode.metadata(m_codeBlock);
    1046     WriteBarrierBase<Structure>* cachedStructure = &metadata.cachedStructure;
    1047     int thisRegister = bytecode.srcDst.offset();
     1046    WriteBarrierBase<Structure>* cachedStructure = &metadata.m_cachedStructure;
     1047    int thisRegister = bytecode.m_srcDst.offset();
    10481048
    10491049    emitLoad(thisRegister, regT3, regT2);
    … …  
    10591059{
    10601060    auto bytecode = currentInstruction->as<OpCheckTdz>();
    1061     emitLoadTag(bytecode.target.offset(), regT0);
     1061    emitLoadTag(bytecode.m_target.offset(), regT0);
    10621062    addSlowCase(branchIfEmpty(regT0));
    10631063}
    … …  
    10661066{
    10671067    auto bytecode = currentInstruction->as<OpHasStructureProperty>();
    1068     int dst = bytecode.dst.offset();
    1069     int base = bytecode.base.offset();
    1070     int enumerator = bytecode.enumerator.offset();
     1068    int dst = bytecode.m_dst.offset();
     1069    int base = bytecode.m_base.offset();
     1070    int enumerator = bytecode.m_enumerator.offset();
    10711071
    10721072    emitLoadPayload(base, regT0);
    … …  
    11131113    auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
    11141114    auto& metadata = bytecode.metadata(m_codeBlock);
    1115     int dst = bytecode.dst.offset();
    1116     int base = bytecode.base.offset();
    1117     int property = bytecode.property.offset();
    1118     ArrayProfile* profile = &metadata.arrayProfile;
     1115    int dst = bytecode.m_dst.offset();
     1116    int base = bytecode.m_base.offset();
     1117    int property = bytecode.m_property.offset();
     1118    ArrayProfile* profile = &metadata.m_arrayProfile;
    11191119    ByValInfo* byValInfo = m_codeBlock->addByValInfo();
    11201120   
    … …  
    11601160
    11611161    auto bytecode = currentInstruction->as<OpHasIndexedProperty>();
    1162     int dst = bytecode.dst.offset();
    1163     int base = bytecode.base.offset();
    1164     int property = bytecode.property.offset();
     1162    int dst = bytecode.m_dst.offset();
     1163    int base = bytecode.m_base.offset();
     1164    int property = bytecode.m_property.offset();
    11651165    ByValInfo* byValInfo = m_byValCompilationInfo[m_byValInstructionIndex].byValInfo;
    11661166
    … …  
    11791179{
    11801180    auto bytecode = currentInstruction->as<OpGetDirectPname>();
    1181     int dst = bytecode.dst.offset();
    1182     int base = bytecode.base.offset();
    1183     int index = bytecode.index.offset();
    1184     int enumerator = bytecode.enumerator.offset();
     1181    int dst = bytecode.m_dst.offset();
     1182    int base = bytecode.m_base.offset();
     1183    int index = bytecode.m_index.offset();
     1184    int enumerator = bytecode.m_enumerator.offset();
    11851185
    11861186    // Check that base is a cell
    … …  
    12201220{
    12211221    auto bytecode = currentInstruction->as<OpEnumeratorStructurePname>();
    1222     int dst = bytecode.dst.offset();
    1223     int enumerator = bytecode.enumerator.offset();
    1224     int index = bytecode.index.offset();
     1222    int dst = bytecode.m_dst.offset();
     1223    int enumerator = bytecode.m_enumerator.offset();
     1224    int index = bytecode.m_index.offset();
    12251225
    12261226    emitLoadPayload(index, regT0);
    … …  
    12451245{
    12461246    auto bytecode = currentInstruction->as<OpEnumeratorGenericPname>();
    1247     int dst = bytecode.dst.offset();
    1248     int enumerator = bytecode.enumerator.offset();
    1249     int index = bytecode.index.offset();
     1247    int dst = bytecode.m_dst.offset();
     1248    int enumerator = bytecode.m_enumerator.offset();
     1249    int index = bytecode.m_index.offset();
    12501250
    12511251    emitLoadPayload(index, regT0);
    … …  
    12711271    auto bytecode = currentInstruction->as<OpProfileType>();
    12721272    auto& metadata = bytecode.metadata(m_codeBlock);
    1273     TypeLocation* cachedTypeLocation = metadata.typeLocation;
    1274     int valueToProfile = bytecode.target.offset();
     1273    TypeLocation* cachedTypeLocation = metadata.m_typeLocation;
     1274    int valueToProfile = bytecode.m_target.offset();
    12751275
    12761276    // Load payload in T0. Load tag in T3.
    … …  
    13451345
    13461346    scratch1Reg = regT4;
    1347     emitLoadPayload(bytecode.scope.offset(), regT3);
     1347    emitLoadPayload(bytecode.m_scope.offset(), regT3);
    13481348    logShadowChickenProloguePacket(shadowPacketReg, scratch1Reg, regT3);
    13491349}
    … …  
    13581358    GPRReg scratch2Reg = regT2;
    13591359    ensureShadowChickenPacket(*vm(), shadowPacketReg, scratch1Reg, scratch2Reg);
    1360     emitLoadPayload(bytecode.thisValue.offset(), regT2);
    1361     emitLoadTag(bytecode.thisValue.offset(), regT1);
     1360    emitLoadPayload(bytecode.m_thisValue.offset(), regT2);
     1361    emitLoadTag(bytecode.m_thisValue.offset(), regT1);
    13621362    JSValueRegs thisRegs(regT1, regT2);
    1363     emitLoadPayload(bytecode.scope.offset(), regT3);
     1363    emitLoadPayload(bytecode.m_scope.offset(), regT3);
    13641364    logShadowChickenTailPacket(shadowPacketReg, thisRegs, regT3, m_codeBlock, CallSiteIndex(currentInstruction));
    13651365}

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

    r239455 r240041  
    11/*
    2  * Copyright (C) 2013-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    16621662    auto bytecode = codeBlock->instructions().at(bytecodeIndex)->as<OpCatch>();
    16631663    auto& metadata = bytecode.metadata(codeBlock);
    1664     metadata.buffer->forEach([&] (ValueProfileAndOperand& profile) {
     1664    metadata.m_buffer->forEach([&] (ValueProfileAndOperand& profile) {
    16651665        profile.m_profile.m_buckets[0] = JSValue::encode(exec->uncheckedR(profile.m_operand).jsValue());
    16661666    });
    … …  
    22932293
    22942294    auto bytecode = pc->as<OpGetFromScope>();
    2295     const Identifier& ident = codeBlock->identifier(bytecode.var);
    2296     JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.scope.offset()).jsValue());
    2297     GetPutInfo& getPutInfo = bytecode.metadata(codeBlock).getPutInfo;
     2295    const Identifier& ident = codeBlock->identifier(bytecode.m_var);
     2296    JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.m_scope.offset()).jsValue());
     2297    GetPutInfo& getPutInfo = bytecode.metadata(codeBlock).m_getPutInfo;
    22982298
    22992299    // ModuleVar is always converted to ClosureVar for get_from_scope.
    … …  
    23352335    auto& metadata = bytecode.metadata(codeBlock);
    23362336
    2337     const Identifier& ident = codeBlock->identifier(bytecode.var);
    2338     JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.scope.offset()).jsValue());
    2339     JSValue value = exec->r(bytecode.value.offset()).jsValue();
    2340     GetPutInfo& getPutInfo = metadata.getPutInfo;
     2337    const Identifier& ident = codeBlock->identifier(bytecode.m_var);
     2338    JSObject* scope = jsCast<JSObject*>(exec->uncheckedR(bytecode.m_scope.offset()).jsValue());
     2339    JSValue value = exec->r(bytecode.m_value.offset()).jsValue();
     2340    GetPutInfo& getPutInfo = metadata.m_getPutInfo;
    23412341
    23422342    // ModuleVar does not keep the scope register value alive in DFG.
    … …  
    23452345    if (getPutInfo.resolveType() == LocalClosureVar) {
    23462346        JSLexicalEnvironment* environment = jsCast<JSLexicalEnvironment*>(scope);
    2347         environment->variableAt(ScopeOffset(metadata.operand)).set(vm, environment, value);
    2348         if (WatchpointSet* set = metadata.watchpointSet)
     2347        environment->variableAt(ScopeOffset(metadata.m_operand)).set(vm, environment, value);
     2348        if (WatchpointSet* set = metadata.m_watchpointSet)
    23492349            set->touch(vm, "Executed op_put_scope<LocalClosureVar>");
    23502350        return;

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

    r240023 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5656    auto bytecode = currentInstruction->as<OpGetByVal>();
    5757    auto& metadata = bytecode.metadata(m_codeBlock);
    58     int dst = bytecode.dst.offset();
    59     int base = bytecode.base.offset();
    60     int property = bytecode.property.offset();
    61     ArrayProfile* profile = &metadata.arrayProfile;
     58    int dst = bytecode.m_dst.offset();
     59    int base = bytecode.m_base.offset();
     60    int property = bytecode.m_property.offset();
     61    ArrayProfile* profile = &metadata.m_arrayProfile;
    6262    ByValInfo* byValInfo = m_codeBlock->addByValInfo();
    6363
    … …  
    135135    // scratch: regT3
    136136
    137     int dst = bytecode.dst.offset();
     137    int dst = bytecode.m_dst.offset();
    138138
    139139    slowCases.append(branchIfNotCell(regT1));
    … …  
    160160{
    161161    auto bytecode = currentInstruction->as<OpGetByVal>();
    162     int dst = bytecode.dst.offset();
    163     int base = bytecode.base.offset();
    164     int property = bytecode.property.offset();
     162    int dst = bytecode.m_dst.offset();
     163    int base = bytecode.m_base.offset();
     164    int property = bytecode.m_property.offset();
    165165    ByValInfo* byValInfo = m_byValCompilationInfo[m_byValInstructionIndex].byValInfo;
    166166   
    … …  
    206206    auto bytecode = currentInstruction->as<Op>();
    207207    auto& metadata = bytecode.metadata(m_codeBlock);
    208     int base = bytecode.base.offset();
    209     int property = bytecode.property.offset();
    210     ArrayProfile* profile = &metadata.arrayProfile;
     208    int base = bytecode.m_base.offset();
     209    int property = bytecode.m_property.offset();
     210    ArrayProfile* profile = &metadata.m_arrayProfile;
    211211    ByValInfo* byValInfo = m_codeBlock->addByValInfo();
    212212
    … …  
    266266{
    267267    auto& metadata = bytecode.metadata(m_codeBlock);
    268     int value = bytecode.value.offset();
    269     ArrayProfile* profile = &metadata.arrayProfile;
     268    int value = bytecode.m_value.offset();
     269    ArrayProfile* profile = &metadata.m_arrayProfile;
    270270   
    271271    JumpList slowCases;
    … …  
    297297    case ContiguousShape:
    298298        store64(regT3, BaseIndex(regT2, regT1, TimesEight));
    299         emitWriteBarrier(bytecode.base.offset(), value, ShouldFilterValue);
     299        emitWriteBarrier(bytecode.m_base.offset(), value, ShouldFilterValue);
    300300        break;
    301301    default:
    … …  
    324324{
    325325    auto& metadata = bytecode.metadata(m_codeBlock);
    326     int value = bytecode.value.offset();
    327     ArrayProfile* profile = &metadata.arrayProfile;
     326    int value = bytecode.m_value.offset();
     327    ArrayProfile* profile = &metadata.m_arrayProfile;
    328328   
    329329    JumpList slowCases;
    … …  
    338338    emitGetVirtualRegister(value, regT3);
    339339    store64(regT3, BaseIndex(regT2, regT1, TimesEight, ArrayStorage::vectorOffset()));
    340     emitWriteBarrier(bytecode.base.offset(), value, ShouldFilterValue);
     340    emitWriteBarrier(bytecode.m_base.offset(), value, ShouldFilterValue);
    341341    Jump end = jump();
    342342   
    … …  
    363363    // scratch: regT2
    364364
    365     int base = bytecode.base.offset();
    366     int value = bytecode.value.offset();
     365    int base = bytecode.m_base.offset();
     366    int value = bytecode.m_value.offset();
    367367
    368368    slowCases.append(branchIfNotCell(regT1));
    … …  
    398398
    399399    auto load = [&](auto bytecode) {
    400         base = bytecode.base.offset();
    401         property = bytecode.property.offset();
    402         value = bytecode.value.offset();
     400        base = bytecode.m_base.offset();
     401        property = bytecode.m_property.offset();
     402        value = bytecode.m_value.offset();
    403403    };
    404404
    … …  
    426426{
    427427    auto bytecode = currentInstruction->as<OpPutGetterById>();
    428     emitGetVirtualRegister(bytecode.base.offset(), regT0);
    429     int32_t options = bytecode.attributes;
    430     emitGetVirtualRegister(bytecode.accessor.offset(), regT1);
    431     callOperation(operationPutGetterById, regT0, m_codeBlock->identifier(bytecode.property).impl(), options, regT1);
     428    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
     429    int32_t options = bytecode.m_attributes;
     430    emitGetVirtualRegister(bytecode.m_accessor.offset(), regT1);
     431    callOperation(operationPutGetterById, regT0, m_codeBlock->identifier(bytecode.m_property).impl(), options, regT1);
    432432}
    433433
    … …  
    435435{
    436436    auto bytecode = currentInstruction->as<OpPutSetterById>();
    437     emitGetVirtualRegister(bytecode.base.offset(), regT0);
    438     int32_t options = bytecode.attributes;
    439     emitGetVirtualRegister(bytecode.accessor.offset(), regT1);
    440     callOperation(operationPutSetterById, regT0, m_codeBlock->identifier(bytecode.property).impl(), options, regT1);
     437    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
     438    int32_t options = bytecode.m_attributes;
     439    emitGetVirtualRegister(bytecode.m_accessor.offset(), regT1);
     440    callOperation(operationPutSetterById, regT0, m_codeBlock->identifier(bytecode.m_property).impl(), options, regT1);
    441441}
    442442
    … …  
    444444{
    445445    auto bytecode = currentInstruction->as<OpPutGetterSetterById>();
    446     emitGetVirtualRegister(bytecode.base.offset(), regT0);
    447     int32_t attribute = bytecode.attributes;
    448     emitGetVirtualRegister(bytecode.getter.offset(), regT1);
    449     emitGetVirtualRegister(bytecode.setter.offset(), regT2);
    450     callOperation(operationPutGetterSetter, regT0, m_codeBlock->identifier(bytecode.property).impl(), attribute, regT1, regT2);
     446    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
     447    int32_t attribute = bytecode.m_attributes;
     448    emitGetVirtualRegister(bytecode.m_getter.offset(), regT1);
     449    emitGetVirtualRegister(bytecode.m_setter.offset(), regT2);
     450    callOperation(operationPutGetterSetter, regT0, m_codeBlock->identifier(bytecode.m_property).impl(), attribute, regT1, regT2);
    451451}
    452452
    … …  
    454454{
    455455    auto bytecode = currentInstruction->as<OpPutGetterByVal>();
    456     emitGetVirtualRegister(bytecode.base.offset(), regT0);
    457     emitGetVirtualRegister(bytecode.property.offset(), regT1);
    458     int32_t attributes = bytecode.attributes;
    459     emitGetVirtualRegister(bytecode.accessor, regT2);
     456    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
     457    emitGetVirtualRegister(bytecode.m_property.offset(), regT1);
     458    int32_t attributes = bytecode.m_attributes;
     459    emitGetVirtualRegister(bytecode.m_accessor, regT2);
    460460    callOperation(operationPutGetterByVal, regT0, regT1, attributes, regT2);
    461461}
    … …  
    464464{
    465465    auto bytecode = currentInstruction->as<OpPutSetterByVal>();
    466     emitGetVirtualRegister(bytecode.base.offset(), regT0);
    467     emitGetVirtualRegister(bytecode.property.offset(), regT1);
    468     int32_t attributes = bytecode.attributes;
    469     emitGetVirtualRegister(bytecode.accessor.offset(), regT2);
     466    emitGetVirtualRegister(bytecode.m_base.offset(), regT0);
     467    emitGetVirtualRegister(bytecode.m_property.offset(), regT1);
     468    int32_t attributes = bytecode.m_attributes;
     469    emitGetVirtualRegister(bytecode.m_accessor.offset(), regT2);
    470470    callOperation(operationPutSetterByVal, regT0, regT1, attributes, regT2);
    471471}
    … …  
    474474{
    475475    auto bytecode = currentInstruction->as<OpDelById>();
    476     int dst = bytecode.dst.offset();
    477     int base = bytecode.base.offset();
    478     int property = bytecode.property;
     476    int dst = bytecode.m_dst.offset();
     477    int base = bytecode.m_base.offset();
     478    int property = bytecode.m_property;
    479479    emitGetVirtualRegister(base, regT0);
    480480    callOperation(operationDeleteByIdJSResult, dst, regT0, m_codeBlock->identifier(property).impl());
    … …  
    484484{
    485485    auto bytecode = currentInstruction->as<OpDelByVal>();
    486     int dst = bytecode.dst.offset();
    487     int base = bytecode.base.offset();
    488     int property = bytecode.property.offset();
     486    int dst = bytecode.m_dst.offset();
     487    int base = bytecode.m_base.offset();
     488    int property = bytecode.m_property.offset();
    489489    emitGetVirtualRegister(base, regT0);
    490490    emitGetVirtualRegister(property, regT1);
    … …  
    495495{
    496496    auto bytecode = currentInstruction->as<OpTryGetById>();
    497     int resultVReg = bytecode.dst.offset();
    498     int baseVReg = bytecode.base.offset();
    499     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     497    int resultVReg = bytecode.m_dst.offset();
     498    int baseVReg = bytecode.m_base.offset();
     499    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    500500
    501501    emitGetVirtualRegister(baseVReg, regT0);
    … …  
    519519
    520520    auto bytecode = currentInstruction->as<OpTryGetById>();
    521     int resultVReg = bytecode.dst.offset();
    522     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     521    int resultVReg = bytecode.m_dst.offset();
     522    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    523523
    524524    JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
    … …  
    534534{
    535535    auto bytecode = currentInstruction->as<OpGetByIdDirect>();
    536     int resultVReg = bytecode.dst.offset();
    537     int baseVReg = bytecode.base.offset();
    538     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     536    int resultVReg = bytecode.m_dst.offset();
     537    int baseVReg = bytecode.m_base.offset();
     538    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    539539
    540540    emitGetVirtualRegister(baseVReg, regT0);
    … …  
    558558
    559559    auto bytecode = currentInstruction->as<OpGetByIdDirect>();
    560     int resultVReg = bytecode.dst.offset();
    561     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     560    int resultVReg = bytecode.m_dst.offset();
     561    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    562562
    563563    JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
    … …  
    574574    auto bytecode = currentInstruction->as<OpGetById>();
    575575    auto& metadata = bytecode.metadata(m_codeBlock);
    576     int resultVReg = bytecode.dst.offset();
    577     int baseVReg = bytecode.base.offset();
    578     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     576    int resultVReg = bytecode.m_dst.offset();
     577    int baseVReg = bytecode.m_base.offset();
     578    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    579579
    580580    emitGetVirtualRegister(baseVReg, regT0);
    … …  
    583583   
    584584    if (*ident == m_vm->propertyNames->length && shouldEmitProfiling()) {
    585         Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
    586         emitArrayProfilingSiteWithCell(regT0, regT1, &metadata.modeMetadata.arrayLengthMode.arrayProfile);
     585        Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.m_mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
     586        emitArrayProfilingSiteWithCell(regT0, regT1, &metadata.m_modeMetadata.arrayLengthMode.arrayProfile);
    587587        notArrayLengthMode.link(this);
    588588    }
    … …  
    602602{
    603603    auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
    604     int resultVReg = bytecode.dst.offset();
    605     int baseVReg = bytecode.base.offset();
    606     int thisVReg = bytecode.thisValue.offset();
    607     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     604    int resultVReg = bytecode.m_dst.offset();
     605    int baseVReg = bytecode.m_base.offset();
     606    int thisVReg = bytecode.m_thisValue.offset();
     607    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    608608
    609609    emitGetVirtualRegister(baseVReg, regT0);
    … …  
    628628
    629629    auto bytecode = currentInstruction->as<OpGetById>();
    630     int resultVReg = bytecode.dst.offset();
    631     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     630    int resultVReg = bytecode.m_dst.offset();
     631    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    632632
    633633    JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
    … …  
    645645
    646646    auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
    647     int resultVReg = bytecode.dst.offset();
    648     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     647    int resultVReg = bytecode.m_dst.offset();
     648    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    649649
    650650    JITGetByIdWithThisGenerator& gen = m_getByIdsWithThis[m_getByIdWithThisIndex++];
    … …  
    660660{
    661661    auto bytecode = currentInstruction->as<OpPutById>();
    662     int baseVReg = bytecode.base.offset();
    663     int valueVReg = bytecode.value.offset();
    664     bool direct = !!(bytecode.flags & PutByIdIsDirect);
     662    int baseVReg = bytecode.m_base.offset();
     663    int valueVReg = bytecode.m_value.offset();
     664    bool direct = !!(bytecode.m_flags & PutByIdIsDirect);
    665665
    666666    // In order to be able to patch both the Structure, and the object offset, we store one pointer,
    … …  
    690690
    691691    auto bytecode = currentInstruction->as<OpPutById>();
    692     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     692    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    693693
    694694    Label coldPathBegin(this);
    … …  
    704704{
    705705    auto bytecode = currentInstruction->as<OpInById>();
    706     int resultVReg = bytecode.dst.offset();
    707     int baseVReg = bytecode.base.offset();
    708     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     706    int resultVReg = bytecode.m_dst.offset();
     707    int baseVReg = bytecode.m_base.offset();
     708    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    709709
    710710    emitGetVirtualRegister(baseVReg, regT0);
    … …  
    727727
    728728    auto bytecode = currentInstruction->as<OpInById>();
    729     int resultVReg = bytecode.dst.offset();
    730     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     729    int resultVReg = bytecode.m_dst.offset();
     730    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    731731
    732732    JITInByIdGenerator& gen = m_inByIds[m_inByIdIndex++];
    … …  
    759759    auto bytecode = currentInstruction->as<OpResolveScope>();
    760760    auto& metadata = bytecode.metadata(m_codeBlock);
    761     int dst = bytecode.dst.offset();
    762     int scope = bytecode.scope.offset();
    763     ResolveType resolveType = metadata.resolveType;
    764     unsigned depth = metadata.localScopeDepth;
     761    int dst = bytecode.m_dst.offset();
     762    int scope = bytecode.m_scope.offset();
     763    ResolveType resolveType = metadata.m_resolveType;
     764    unsigned depth = metadata.m_localScopeDepth;
    765765
    766766    auto emitCode = [&] (ResolveType resolveType) {
    … …  
    784784            break;
    785785        case ModuleVar:
    786             move(TrustedImmPtr(metadata.lexicalEnvironment.get()), regT0);
     786            move(TrustedImmPtr(metadata.m_lexicalEnvironment.get()), regT0);
    787787            emitPutVirtualRegister(dst);
    788788            break;
    … …  
    801801    case GlobalPropertyWithVarInjectionChecks: {
    802802        // Since these GlobalProperty can be changed to GlobalLexicalVar, we should load the value from metadata.
    803         JSScope** constantScopeSlot = metadata.constantScope.slot();
     803        JSScope** constantScopeSlot = metadata.m_constantScope.slot();
    804804        emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
    805805        loadPtr(constantScopeSlot, regT0);
    … …  
    810810    case UnresolvedPropertyWithVarInjectionChecks: {
    811811        JumpList skipToEnd;
    812         load32(&metadata.resolveType, regT0);
     812        load32(&metadata.m_resolveType, regT0);
    813813
    814814        Jump notGlobalProperty = branch32(NotEqual, regT0, TrustedImm32(GlobalProperty));
    … …  
    873873    auto bytecode = currentInstruction->as<OpGetFromScope>();
    874874    auto& metadata = bytecode.metadata(m_codeBlock);
    875     int dst = bytecode.dst.offset();
    876     int scope = bytecode.scope.offset();
    877     ResolveType resolveType = metadata.getPutInfo.resolveType();
    878     Structure** structureSlot = metadata.structure.slot();
    879     uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
     875    int dst = bytecode.m_dst.offset();
     876    int scope = bytecode.m_scope.offset();
     877    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
     878    Structure** structureSlot = metadata.m_structure.slot();
     879    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
    880880
    881881    auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
    … …  
    937937    case GlobalPropertyWithVarInjectionChecks: {
    938938        JumpList skipToEnd;
    939         load32(&metadata.getPutInfo, regT0);
     939        load32(&metadata.m_getPutInfo, regT0);
    940940        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    941941
    … …  
    953953    case UnresolvedPropertyWithVarInjectionChecks: {
    954954        JumpList skipToEnd;
    955         load32(&metadata.getPutInfo, regT0);
     955        load32(&metadata.m_getPutInfo, regT0);
    956956        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    957957
    … …  
    992992
    993993    auto bytecode = currentInstruction->as<OpGetFromScope>();
    994     int dst = bytecode.dst.offset();
     994    int dst = bytecode.m_dst.offset();
    995995    callOperationWithProfile(bytecode.metadata(m_codeBlock), operationGetFromScope, dst, currentInstruction);
    996996}
    … …  
    10231023    auto bytecode = currentInstruction->as<OpPutToScope>();
    10241024    auto& metadata = bytecode.metadata(m_codeBlock);
    1025     int scope = bytecode.scope.offset();
    1026     int value = bytecode.value.offset();
     1025    int scope = bytecode.m_scope.offset();
     1026    int value = bytecode.m_value.offset();
    10271027    GetPutInfo getPutInfo = copiedGetPutInfo(bytecode);
    10281028    ResolveType resolveType = getPutInfo.resolveType();
    1029     Structure** structureSlot = metadata.structure.slot();
    1030     uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
     1029    Structure** structureSlot = metadata.m_structure.slot();
     1030    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
    10311031
    10321032    auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
    … …  
    10641064            }
    10651065            if (indirectLoadForOperand)
    1066                 emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.watchpointSet);
     1066                emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.m_watchpointSet);
    10671067            else
    1068                 emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.watchpointSet);
     1068                emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.m_watchpointSet);
    10691069            emitWriteBarrier(constantScope, value, ShouldFilterValue);
    10701070            break;
    … …  
    10741074        case ClosureVarWithVarInjectionChecks:
    10751075            emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
    1076             emitPutClosureVar(scope, *operandSlot, value, metadata.watchpointSet);
     1076            emitPutClosureVar(scope, *operandSlot, value, metadata.m_watchpointSet);
    10771077            emitWriteBarrier(scope, value, ShouldFilterValue);
    10781078            break;
    … …  
    10921092    case GlobalPropertyWithVarInjectionChecks: {
    10931093        JumpList skipToEnd;
    1094         load32(&metadata.getPutInfo, regT0);
     1094        load32(&metadata.m_getPutInfo, regT0);
    10951095        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    10961096
    … …  
    11111111    case UnresolvedPropertyWithVarInjectionChecks: {
    11121112        JumpList skipToEnd;
    1113         load32(&metadata.getPutInfo, regT0);
     1113        load32(&metadata.m_getPutInfo, regT0);
    11141114        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    11151115
    … …  
    11591159{
    11601160    auto bytecode = currentInstruction->as<OpGetFromArguments>();
    1161     int dst = bytecode.dst.offset();
    1162     int arguments = bytecode.arguments.offset();
    1163     int index = bytecode.index;
     1161    int dst = bytecode.m_dst.offset();
     1162    int arguments = bytecode.m_arguments.offset();
     1163    int index = bytecode.m_index;
    11641164   
    11651165    emitGetVirtualRegister(arguments, regT0);
    … …  
    11721172{
    11731173    auto bytecode = currentInstruction->as<OpPutToArguments>();
    1174     int arguments = bytecode.arguments.offset();
    1175     int index = bytecode.index;
    1176     int value = bytecode.value.offset();
     1174    int arguments = bytecode.m_arguments.offset();
     1175    int index = bytecode.m_index;
     1176    int value = bytecode.m_value.offset();
    11771177   
    11781178    emitGetVirtualRegister(arguments, regT0);
    … …  
    17381738{
    17391739    auto& metadata = bytecode.metadata(m_codeBlock);
    1740     ArrayProfile* profile = &metadata.arrayProfile;
     1740    ArrayProfile* profile = &metadata.m_arrayProfile;
    17411741    ASSERT(isInt(type));
    17421742   
    1743     int value = bytecode.value.offset();
     1743    int value = bytecode.m_value.offset();
    17441744
    17451745#if USE(JSVALUE64)
    … …  
    18131813{
    18141814    auto& metadata = bytecode.metadata(m_codeBlock);
    1815     ArrayProfile* profile = &metadata.arrayProfile;
     1815    ArrayProfile* profile = &metadata.m_arrayProfile;
    18161816    ASSERT(isFloat(type));
    18171817   
    1818     int value = bytecode.value.offset();
     1818    int value = bytecode.m_value.offset();
    18191819
    18201820#if USE(JSVALUE64)

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

    r240023 r240041  
    11/*
    2  * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5151{
    5252    auto bytecode = currentInstruction->as<OpPutGetterById>();
    53     int base = bytecode.base.offset();
    54     int property = bytecode.property;
    55     int options = bytecode.attributes;
    56     int getter = bytecode.accessor.offset();
     53    int base = bytecode.m_base.offset();
     54    int property = bytecode.m_property;
     55    int options = bytecode.m_attributes;
     56    int getter = bytecode.m_accessor.offset();
    5757
    5858    emitLoadPayload(base, regT1);
    … …  
    6464{
    6565    auto bytecode = currentInstruction->as<OpPutSetterById>();
    66     int base = bytecode.base.offset();
    67     int property = bytecode.property;
    68     int options = bytecode.attributes;
    69     int setter = bytecode.accessor.offset();
     66    int base = bytecode.m_base.offset();
     67    int property = bytecode.m_property;
     68    int options = bytecode.m_attributes;
     69    int setter = bytecode.m_accessor.offset();
    7070
    7171    emitLoadPayload(base, regT1);
    … …  
    7777{
    7878    auto bytecode = currentInstruction->as<OpPutGetterSetterById>();
    79     int base = bytecode.base.offset();
    80     int property = bytecode.property;
    81     int attributes = bytecode.attributes;
    82     int getter = bytecode.getter.offset();
    83     int setter = bytecode.setter.offset();
     79    int base = bytecode.m_base.offset();
     80    int property = bytecode.m_property;
     81    int attributes = bytecode.m_attributes;
     82    int getter = bytecode.m_getter.offset();
     83    int setter = bytecode.m_setter.offset();
    8484
    8585    emitLoadPayload(base, regT1);
    … …  
    9292{
    9393    auto bytecode = currentInstruction->as<OpPutGetterByVal>();
    94     int base = bytecode.base.offset();
    95     int property = bytecode.property.offset();
    96     int32_t attributes = bytecode.attributes;
    97     int getter = bytecode.accessor.offset();
     94    int base = bytecode.m_base.offset();
     95    int property = bytecode.m_property.offset();
     96    int32_t attributes = bytecode.m_attributes;
     97    int getter = bytecode.m_accessor.offset();
    9898
    9999    emitLoadPayload(base, regT2);
    … …  
    106106{
    107107    auto bytecode = currentInstruction->as<OpPutSetterByVal>();
    108     int base = bytecode.base.offset();
    109     int property = bytecode.property.offset();
    110     int32_t attributes = bytecode.attributes;
    111     int setter = bytecode.accessor.offset();
     108    int base = bytecode.m_base.offset();
     109    int property = bytecode.m_property.offset();
     110    int32_t attributes = bytecode.m_attributes;
     111    int setter = bytecode.m_accessor.offset();
    112112
    113113    emitLoadPayload(base, regT2);
    … …  
    120120{
    121121    auto bytecode = currentInstruction->as<OpDelById>();
    122     int dst = bytecode.dst.offset();
    123     int base = bytecode.base.offset();
    124     int property = bytecode.property;
     122    int dst = bytecode.m_dst.offset();
     123    int base = bytecode.m_base.offset();
     124    int property = bytecode.m_property;
    125125    emitLoad(base, regT1, regT0);
    126126    callOperation(operationDeleteByIdJSResult, dst, JSValueRegs(regT1, regT0), m_codeBlock->identifier(property).impl());
    … …  
    130130{
    131131    auto bytecode = currentInstruction->as<OpDelByVal>();
    132     int dst = bytecode.dst.offset();
    133     int base = bytecode.base.offset();
    134     int property = bytecode.property.offset();
     132    int dst = bytecode.m_dst.offset();
     133    int base = bytecode.m_base.offset();
     134    int property = bytecode.m_property.offset();
    135135    emitLoad2(base, regT1, regT0, property, regT3, regT2);
    136136    callOperation(operationDeleteByValJSResult, dst, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
    … …  
    141141    auto bytecode = currentInstruction->as<OpGetByVal>();
    142142    auto& metadata = bytecode.metadata(m_codeBlock);
    143     int dst = bytecode.dst.offset();
    144     int base = bytecode.base.offset();
    145     int property = bytecode.property.offset();
    146     ArrayProfile* profile = &metadata.arrayProfile;
     143    int dst = bytecode.m_dst.offset();
     144    int base = bytecode.m_base.offset();
     145    int property = bytecode.m_property.offset();
     146    ArrayProfile* profile = &metadata.m_arrayProfile;
    147147    ByValInfo* byValInfo = m_codeBlock->addByValInfo();
    148148
    … …  
    201201    // scratch: regT4
    202202
    203     int dst = bytecode.dst.offset();
     203    int dst = bytecode.m_dst.offset();
    204204
    205205    slowCases.append(branchIfNotCell(regT3));
    … …  
    227227{
    228228    auto bytecode = currentInstruction->as<OpGetByVal>();
    229     int dst = bytecode.dst.offset();
    230     int base = bytecode.base.offset();
    231     int property = bytecode.property.offset();
     229    int dst = bytecode.m_dst.offset();
     230    int base = bytecode.m_base.offset();
     231    int property = bytecode.m_property.offset();
    232232    ByValInfo* byValInfo = m_byValCompilationInfo[m_byValInstructionIndex].byValInfo;
    233233
    … …  
    272272    auto bytecode = currentInstruction->as<Op>();
    273273    auto& metadata = bytecode.metadata(m_codeBlock);
    274     int base = bytecode.base.offset();
    275     int property = bytecode.property.offset();
    276     ArrayProfile* profile = &metadata.arrayProfile;
     274    int base = bytecode.m_base.offset();
     275    int property = bytecode.m_property.offset();
     276    ArrayProfile* profile = &metadata.m_arrayProfile;
    277277    ByValInfo* byValInfo = m_codeBlock->addByValInfo();
    278278   
    … …  
    322322{
    323323    auto& metadata = bytecode.metadata(m_codeBlock);
    324     int base = bytecode.base.offset();
    325     int value = bytecode.value.offset();
    326     ArrayProfile* profile = &metadata.arrayProfile;
     324    int base = bytecode.m_base.offset();
     325    int value = bytecode.m_value.offset();
     326    ArrayProfile* profile = &metadata.m_arrayProfile;
    327327
    328328    JumpList slowCases;
    … …  
    383383{
    384384    auto& metadata = bytecode.metadata(m_codeBlock);
    385     int base = bytecode.base.offset();
    386     int value = bytecode.value.offset();
    387     ArrayProfile* profile = &metadata.arrayProfile;
     385    int base = bytecode.m_base.offset();
     386    int value = bytecode.m_value.offset();
     387    ArrayProfile* profile = &metadata.m_arrayProfile;
    388388
    389389    JumpList slowCases;
    … …  
    424424    // property: tag(regT3), payload(regT2)
    425425
    426     int base = bytecode.base.offset();
    427     int value = bytecode.value.offset();
     426    int base = bytecode.m_base.offset();
     427    int value = bytecode.m_value.offset();
    428428
    429429    slowCases.append(branchIfNotCell(regT3));
    … …  
    464464
    465465    auto load = [&](auto bytecode) {
    466         base = bytecode.base.offset();
    467         property = bytecode.property.offset();
    468         value = bytecode.value.offset();
     466        base = bytecode.m_base.offset();
     467        property = bytecode.m_property.offset();
     468        value = bytecode.m_value.offset();
    469469    };
    470470
    … …  
    494494{
    495495    auto bytecode = currentInstruction->as<OpTryGetById>();
    496     int dst = bytecode.dst.offset();
    497     int base = bytecode.base.offset();
    498     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     496    int dst = bytecode.m_dst.offset();
     497    int base = bytecode.m_base.offset();
     498    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    499499
    500500    emitLoad(base, regT1, regT0);
    … …  
    517517
    518518    auto bytecode = currentInstruction->as<OpTryGetById>();
    519     int resultVReg = bytecode.dst.offset();
    520     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     519    int resultVReg = bytecode.m_dst.offset();
     520    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    521521
    522522    JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
    … …  
    533533{
    534534    auto bytecode = currentInstruction->as<OpGetByIdDirect>();
    535     int dst = bytecode.dst.offset();
    536     int base = bytecode.base.offset();
    537     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     535    int dst = bytecode.m_dst.offset();
     536    int base = bytecode.m_base.offset();
     537    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    538538
    539539    emitLoad(base, regT1, regT0);
    … …  
    556556
    557557    auto bytecode = currentInstruction->as<OpGetByIdDirect>();
    558     int resultVReg = bytecode.dst.offset();
    559     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     558    int resultVReg = bytecode.m_dst.offset();
     559    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    560560
    561561    JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
    … …  
    573573    auto bytecode = currentInstruction->as<OpGetById>();
    574574    auto& metadata = bytecode.metadata(m_codeBlock);
    575     int dst = bytecode.dst.offset();
    576     int base = bytecode.base.offset();
    577     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     575    int dst = bytecode.m_dst.offset();
     576    int base = bytecode.m_base.offset();
     577    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    578578   
    579579    emitLoad(base, regT1, regT0);
    … …  
    581581
    582582    if (*ident == m_vm->propertyNames->length && shouldEmitProfiling()) {
    583         Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
    584         emitArrayProfilingSiteWithCell(regT0, regT2, &metadata.modeMetadata.arrayLengthMode.arrayProfile);
     583        Jump notArrayLengthMode = branch8(NotEqual, AbsoluteAddress(&metadata.m_mode), TrustedImm32(static_cast<uint8_t>(GetByIdMode::ArrayLength)));
     584        emitArrayProfilingSiteWithCell(regT0, regT2, &metadata.m_modeMetadata.arrayLengthMode.arrayProfile);
    585585        notArrayLengthMode.link(this);
    586586    }
    … …  
    602602
    603603    auto bytecode = currentInstruction->as<OpGetById>();
    604     int resultVReg = bytecode.dst.offset();
    605     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     604    int resultVReg = bytecode.m_dst.offset();
     605    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    606606
    607607    JITGetByIdGenerator& gen = m_getByIds[m_getByIdIndex++];
    … …  
    617617{
    618618    auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
    619     int dst = bytecode.dst.offset();
    620     int base = bytecode.base.offset();
    621     int thisVReg = bytecode.thisValue.offset();
    622     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     619    int dst = bytecode.m_dst.offset();
     620    int base = bytecode.m_base.offset();
     621    int thisVReg = bytecode.m_thisValue.offset();
     622    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    623623   
    624624    emitLoad(base, regT1, regT0);
    … …  
    643643
    644644    auto bytecode = currentInstruction->as<OpGetByIdWithThis>();
    645     int resultVReg = bytecode.dst.offset();
    646     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     645    int resultVReg = bytecode.m_dst.offset();
     646    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    647647
    648648    JITGetByIdWithThisGenerator& gen = m_getByIdsWithThis[m_getByIdWithThisIndex++];
    … …  
    662662   
    663663    auto bytecode = currentInstruction->as<OpPutById>();
    664     int base = bytecode.base.offset();
    665     int value = bytecode.value.offset();
    666     bool direct = !!(bytecode.flags & PutByIdIsDirect);
     664    int base = bytecode.m_base.offset();
     665    int value = bytecode.m_value.offset();
     666    bool direct = !!(bytecode.m_flags & PutByIdIsDirect);
    667667   
    668668    emitLoad2(base, regT1, regT0, value, regT3, regT2);
    … …  
    688688
    689689    auto bytecode = currentInstruction->as<OpPutById>();
    690     int base = bytecode.base.offset();
    691     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     690    int base = bytecode.m_base.offset();
     691    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    692692
    693693    Label coldPathBegin(this);
    … …  
    707707{
    708708    auto bytecode = currentInstruction->as<OpInById>();
    709     int dst = bytecode.dst.offset();
    710     int base = bytecode.base.offset();
    711     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     709    int dst = bytecode.m_dst.offset();
     710    int base = bytecode.m_base.offset();
     711    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    712712
    713713    emitLoad(base, regT1, regT0);
    … …  
    729729
    730730    auto bytecode = currentInstruction->as<OpInById>();
    731     int resultVReg = bytecode.dst.offset();
    732     const Identifier* ident = &(m_codeBlock->identifier(bytecode.property));
     731    int resultVReg = bytecode.m_dst.offset();
     732    const Identifier* ident = &(m_codeBlock->identifier(bytecode.m_property));
    733733
    734734    JITInByIdGenerator& gen = m_inByIds[m_inByIdIndex++];
    … …  
    762762    auto bytecode = currentInstruction->as<OpResolveScope>();
    763763    auto& metadata = bytecode.metadata(m_codeBlock);
    764     int dst = bytecode.dst.offset();
    765     int scope = bytecode.scope.offset();
    766     ResolveType resolveType = metadata.resolveType;
    767     unsigned depth = metadata.localScopeDepth;
     764    int dst = bytecode.m_dst.offset();
     765    int scope = bytecode.m_scope.offset();
     766    ResolveType resolveType = metadata.m_resolveType;
     767    unsigned depth = metadata.m_localScopeDepth;
    768768
    769769    auto emitCode = [&] (ResolveType resolveType) {
    … …  
    789789        case ModuleVar:
    790790            move(TrustedImm32(JSValue::CellTag), regT1);
    791             move(TrustedImmPtr(metadata.lexicalEnvironment.get()), regT0);
     791            move(TrustedImmPtr(metadata.m_lexicalEnvironment.get()), regT0);
    792792            emitStore(dst, regT1, regT0);
    793793            break;
    … …  
    805805    case GlobalPropertyWithVarInjectionChecks: {
    806806        // Since these GlobalProperty can be changed to GlobalLexicalVar, we should load the value from metadata.
    807         JSScope** constantScopeSlot = metadata.constantScope.slot();
     807        JSScope** constantScopeSlot = metadata.m_constantScope.slot();
    808808        emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
    809809        move(TrustedImm32(JSValue::CellTag), regT1);
    … …  
    815815    case UnresolvedPropertyWithVarInjectionChecks: {
    816816        JumpList skipToEnd;
    817         load32(&metadata.resolveType, regT0);
     817        load32(&metadata.m_resolveType, regT0);
    818818
    819819        Jump notGlobalProperty = branch32(NotEqual, regT0, TrustedImm32(GlobalProperty));
    … …  
    879879    auto bytecode = currentInstruction->as<OpGetFromScope>();
    880880    auto& metadata = bytecode.metadata(m_codeBlock);
    881     int dst = bytecode.dst.offset();
    882     int scope = bytecode.scope.offset();
    883     ResolveType resolveType = metadata.getPutInfo.resolveType();
    884     Structure** structureSlot = metadata.structure.slot();
    885     uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
     881    int dst = bytecode.m_dst.offset();
     882    int scope = bytecode.m_scope.offset();
     883    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
     884    Structure** structureSlot = metadata.m_structure.slot();
     885    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
    886886   
    887887    auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
    … …  
    940940    case GlobalPropertyWithVarInjectionChecks: {
    941941        JumpList skipToEnd;
    942         load32(&metadata.getPutInfo, regT0);
     942        load32(&metadata.m_getPutInfo, regT0);
    943943        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    944944
    … …  
    955955    case UnresolvedPropertyWithVarInjectionChecks: {
    956956        JumpList skipToEnd;
    957         load32(&metadata.getPutInfo, regT0);
     957        load32(&metadata.m_getPutInfo, regT0);
    958958        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    959959
    … …  
    994994
    995995    auto bytecode = currentInstruction->as<OpGetFromScope>();
    996     int dst = bytecode.dst.offset();
     996    int dst = bytecode.m_dst.offset();
    997997    callOperationWithProfile(bytecode.metadata(m_codeBlock), operationGetFromScope, dst, currentInstruction);
    998998}
    … …  
    10301030    auto bytecode = currentInstruction->as<OpPutToScope>();
    10311031    auto& metadata = bytecode.metadata(m_codeBlock);
    1032     int scope = bytecode.scope.offset();
    1033     int value = bytecode.value.offset();
     1032    int scope = bytecode.m_scope.offset();
     1033    int value = bytecode.m_value.offset();
    10341034    GetPutInfo getPutInfo = copiedGetPutInfo(bytecode);
    10351035    ResolveType resolveType = getPutInfo.resolveType();
    1036     Structure** structureSlot = metadata.structure.slot();
    1037     uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.operand);
     1036    Structure** structureSlot = metadata.m_structure.slot();
     1037    uintptr_t* operandSlot = reinterpret_cast<uintptr_t*>(&metadata.m_operand);
    10381038   
    10391039    auto emitCode = [&] (ResolveType resolveType, bool indirectLoadForOperand) {
    … …  
    10691069            }
    10701070            if (indirectLoadForOperand)
    1071                 emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.watchpointSet);
     1071                emitPutGlobalVariableIndirect(bitwise_cast<JSValue**>(operandSlot), value, &metadata.m_watchpointSet);
    10721072            else
    1073                 emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.watchpointSet);
     1073                emitPutGlobalVariable(bitwise_cast<JSValue*>(*operandSlot), value, metadata.m_watchpointSet);
    10741074            break;
    10751075        }
    … …  
    10791079            emitWriteBarrier(scope, value, ShouldFilterValue);
    10801080            emitVarInjectionCheck(needsVarInjectionChecks(resolveType));
    1081             emitPutClosureVar(scope, *operandSlot, value, metadata.watchpointSet);
     1081            emitPutClosureVar(scope, *operandSlot, value, metadata.m_watchpointSet);
    10821082            break;
    10831083        case ModuleVar:
    … …  
    10951095    case GlobalPropertyWithVarInjectionChecks: {
    10961096        JumpList skipToEnd;
    1097         load32(&metadata.getPutInfo, regT0);
     1097        load32(&metadata.m_getPutInfo, regT0);
    10981098        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    10991099
    … …  
    11141114    case UnresolvedPropertyWithVarInjectionChecks: {
    11151115        JumpList skipToEnd;
    1116         load32(&metadata.getPutInfo, regT0);
     1116        load32(&metadata.m_getPutInfo, regT0);
    11171117        and32(TrustedImm32(GetPutInfo::typeBits), regT0); // Load ResolveType into T0
    11181118
    … …  
    11621162{
    11631163    auto bytecode = currentInstruction->as<OpGetFromArguments>();
    1164     int dst = bytecode.dst.offset();
    1165     int arguments = bytecode.arguments.offset();
    1166     int index = bytecode.index;
     1164    int dst = bytecode.m_dst.offset();
     1165    int arguments = bytecode.m_arguments.offset();
     1166    int index = bytecode.m_index;
    11671167   
    11681168    emitLoadPayload(arguments, regT0);
    … …  
    11761176{
    11771177    auto bytecode = currentInstruction->as<OpPutToArguments>();
    1178     int arguments = bytecode.arguments.offset();
    1179     int index = bytecode.index;
    1180     int value = bytecode.value.offset();
     1178    int arguments = bytecode.m_arguments.offset();
     1179    int index = bytecode.m_index;
     1180    int value = bytecode.m_value.offset();
    11811181   
    11821182    emitWriteBarrier(arguments, value, ShouldFilterValue);

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

    r240023 r240041  
    11/*
    2  * Copyright (C) 2011-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    134134        LLINT_CHECK_EXCEPTION();                                  \
    135135        if (__b_condition)                                        \
    136             JUMP_TO(JUMP_OFFSET(bytecode.target)); \
     136            JUMP_TO(JUMP_OFFSET(bytecode.m_target)); \
    137137        else                                                      \
    138138            JUMP_TO(pc->size()); \
    … …  
    143143        JSValue __r_returnValue = (value);      \
    144144        LLINT_CHECK_EXCEPTION();                \
    145         LLINT_OP(bytecode.dst) = __r_returnValue;          \
     145        LLINT_OP(bytecode.m_dst) = __r_returnValue;          \
    146146        LLINT_END_IMPL();                       \
    147147    } while (false)
    … …  
    150150        JSValue __rp_returnValue = (value);                     \
    151151        LLINT_CHECK_EXCEPTION();                                \
    152         LLINT_OP(bytecode.dst) = __rp_returnValue;                         \
     152        LLINT_OP(bytecode.m_dst) = __rp_returnValue;                         \
    153153        LLINT_PROFILE_VALUE(__rp_returnValue);          \
    154154        LLINT_END_IMPL();                                       \
    … …  
    156156
    157157#define LLINT_PROFILE_VALUE(value) do { \
    158         bytecode.metadata(exec).profile.m_buckets[0] = JSValue::encode(value); \
     158        bytecode.metadata(exec).m_profile.m_buckets[0] = JSValue::encode(value); \
    159159    } while (false)
    160160
    … …  
    572572    auto bytecode = pc->as<OpNewObject>();
    573573    auto& metadata = bytecode.metadata(exec);
    574     LLINT_RETURN(constructEmptyObject(exec, metadata.objectAllocationProfile.structure()));
     574    LLINT_RETURN(constructEmptyObject(exec, metadata.m_objectAllocationProfile.structure()));
    575575}
    576576
    … …  
    580580    auto bytecode = pc->as<OpNewArray>();
    581581    auto& metadata = bytecode.metadata(exec);
    582     LLINT_RETURN(constructArrayNegativeIndexed(exec, &metadata.arrayAllocationProfile, bitwise_cast<JSValue*>(&LLINT_OP(bytecode.argv)), bytecode.argc));
     582    LLINT_RETURN(constructArrayNegativeIndexed(exec, &metadata.m_arrayAllocationProfile, bitwise_cast<JSValue*>(&LLINT_OP(bytecode.m_argv)), bytecode.m_argc));
    583583}
    584584
    … …  
    588588    auto bytecode = pc->as<OpNewArrayWithSize>();
    589589    auto& metadata = bytecode.metadata(exec);
    590     LLINT_RETURN(constructArrayWithSizeQuirk(exec, &metadata.arrayAllocationProfile, exec->lexicalGlobalObject(), LLINT_OP_C(bytecode.length).jsValue()));
     590    LLINT_RETURN(constructArrayWithSizeQuirk(exec, &metadata.m_arrayAllocationProfile, exec->lexicalGlobalObject(), LLINT_OP_C(bytecode.m_length).jsValue()));
    591591}
    592592
    … …  
    595595    LLINT_BEGIN();
    596596    auto bytecode = pc->as<OpNewRegexp>();
    597     RegExp* regExp = jsCast<RegExp*>(LLINT_OP_C(bytecode.regexp).jsValue());
     597    RegExp* regExp = jsCast<RegExp*>(LLINT_OP_C(bytecode.m_regexp).jsValue());
    598598    ASSERT(regExp->isValid());
    599599    LLINT_RETURN(RegExpObject::create(vm, exec->lexicalGlobalObject()->regExpStructure(), regExp));
    … …  
    604604    LLINT_BEGIN();
    605605    auto bytecode = pc->as<OpInstanceof>();
    606     JSValue value = LLINT_OP_C(bytecode.value).jsValue();
    607     JSValue proto = LLINT_OP_C(bytecode.prototype).jsValue();
     606    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
     607    JSValue proto = LLINT_OP_C(bytecode.m_prototype).jsValue();
    608608    LLINT_RETURN(jsBoolean(JSObject::defaultHasInstance(exec, value, proto)));
    609609}
    … …  
    614614
    615615    auto bytecode = pc->as<OpInstanceofCustom>();
    616     JSValue value = LLINT_OP_C(bytecode.value).jsValue();
    617     JSValue constructor = LLINT_OP_C(bytecode.constructor).jsValue();
    618     JSValue hasInstanceValue = LLINT_OP_C(bytecode.hasInstanceValue).jsValue();
     616    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
     617    JSValue constructor = LLINT_OP_C(bytecode.m_constructor).jsValue();
     618    JSValue hasInstanceValue = LLINT_OP_C(bytecode.m_hasInstanceValue).jsValue();
    619619
    620620    ASSERT(constructor.isObject());
    … …  
    630630    auto bytecode = pc->as<OpTryGetById>();
    631631    CodeBlock* codeBlock = exec->codeBlock();
    632     const Identifier& ident = codeBlock->identifier(bytecode.property);
    633     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
     632    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
     633    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
    634634    PropertySlot slot(baseValue, PropertySlot::PropertySlot::InternalMethodType::VMInquiry);
    635635
    … …  
    645645    auto bytecode = pc->as<OpGetByIdDirect>();
    646646    CodeBlock* codeBlock = exec->codeBlock();
    647     const Identifier& ident = codeBlock->identifier(bytecode.property);
    648     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
     647    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
     648    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
    649649    PropertySlot slot(baseValue, PropertySlot::PropertySlot::InternalMethodType::GetOwnProperty);
    650650
    … …  
    657657        auto& metadata = bytecode.metadata(exec);
    658658        {
    659             StructureID oldStructureID = metadata.structure;
     659            StructureID oldStructureID = metadata.m_structure;
    660660            if (oldStructureID) {
    661661                Structure* a = vm.heap.structureIDTable().get(oldStructureID);
    … …  
    673673        if (slot.isValue()) {
    674674            // Start out by clearing out the old cache.
    675             metadata.structure = 0;
    676             metadata.offset = 0;
     675            metadata.m_structure = 0;
     676            metadata.m_offset = 0;
    677677
    678678            if (structure->propertyAccessesAreCacheable()
    … …  
    682682                ConcurrentJSLocker locker(codeBlock->m_lock);
    683683
    684                 metadata.structure = structure->id();
    685                 metadata.offset = slot.cachedOffset();
     684                metadata.m_structure = structure->id();
     685                metadata.m_offset = slot.cachedOffset();
    686686            }
    687687        }
    … …  
    736736
    737737    if (slot.isUnset()) {
    738         metadata.mode = GetByIdMode::Unset;
    739         metadata.modeMetadata.unsetMode.structure = structure->id();
     738        metadata.m_mode = GetByIdMode::Unset;
     739        metadata.m_modeMetadata.unsetMode.structure = structure->id();
    740740        return;
    741741    }
    742742    ASSERT(slot.isValue());
    743743
    744     metadata.mode = GetByIdMode::ProtoLoad;
    745     metadata.modeMetadata.protoLoadMode.structure = structure->id();
    746     metadata.modeMetadata.protoLoadMode.cachedOffset = offset;
    747     metadata.modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
     744    metadata.m_mode = GetByIdMode::ProtoLoad;
     745    metadata.m_modeMetadata.protoLoadMode.structure = structure->id();
     746    metadata.m_modeMetadata.protoLoadMode.cachedOffset = offset;
     747    metadata.m_modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
    748748    // We know that this pointer will remain valid because it will be cleared by either a watchpoint fire or
    749749    // during GC when we clear the LLInt caches.
    750     metadata.modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
     750    metadata.m_modeMetadata.protoLoadMode.cachedSlot = slot.slotBase();
    751751}
    752752
    … …  
    758758    auto& metadata = bytecode.metadata(exec);
    759759    CodeBlock* codeBlock = exec->codeBlock();
    760     const Identifier& ident = codeBlock->identifier(bytecode.property);
    761     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
     760    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
     761    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
    762762    PropertySlot slot(baseValue, PropertySlot::PropertySlot::InternalMethodType::Get);
    763763
    764764    JSValue result = baseValue.get(exec, ident, slot);
    765765    LLINT_CHECK_EXCEPTION();
    766     LLINT_OP(bytecode.dst) = result;
     766    LLINT_OP(bytecode.m_dst) = result;
    767767   
    768768    if (!LLINT_ALWAYS_ACCESS_SLOW
    … …  
    771771        {
    772772            StructureID oldStructureID;
    773             auto mode = metadata.mode;
     773            auto mode = metadata.m_mode;
    774774            switch (mode) {
    775775            case GetByIdMode::Default:
    776                 oldStructureID = metadata.modeMetadata.defaultMode.structure;
     776                oldStructureID = metadata.m_modeMetadata.defaultMode.structure;
    777777                break;
    778778            case GetByIdMode::Unset:
    779                 oldStructureID = metadata.modeMetadata.unsetMode.structure;
     779                oldStructureID = metadata.m_modeMetadata.unsetMode.structure;
    780780                break;
    781781            case GetByIdMode::ProtoLoad:
    782                 oldStructureID = metadata.modeMetadata.protoLoadMode.structure;
     782                oldStructureID = metadata.m_modeMetadata.protoLoadMode.structure;
    783783                break;
    784784            default:
    … …  
    800800        if (slot.isValue() && slot.slotBase() == baseValue) {
    801801            // Start out by clearing out the old cache.
    802             metadata.mode = GetByIdMode::Default;
    803             metadata.modeMetadata.defaultMode.structure = 0;
    804             metadata.modeMetadata.defaultMode.cachedOffset = 0;
     802            metadata.m_mode = GetByIdMode::Default;
     803            metadata.m_modeMetadata.defaultMode.structure = 0;
     804            metadata.m_modeMetadata.defaultMode.cachedOffset = 0;
    805805
    806806            // Prevent the prototype cache from ever happening.
    807             metadata.hitCountForLLIntCaching = 0;
     807            metadata.m_hitCountForLLIntCaching = 0;
    808808       
    809809            if (structure->propertyAccessesAreCacheable()
    … …  
    813813                ConcurrentJSLocker locker(codeBlock->m_lock);
    814814
    815                 metadata.modeMetadata.defaultMode.structure = structure->id();
    816                 metadata.modeMetadata.defaultMode.cachedOffset = slot.cachedOffset();
     815                metadata.m_modeMetadata.defaultMode.structure = structure->id();
     816                metadata.m_modeMetadata.defaultMode.cachedOffset = slot.cachedOffset();
    817817            }
    818         } else if (UNLIKELY(metadata.hitCountForLLIntCaching && (slot.isValue() || slot.isUnset()))) {
     818        } else if (UNLIKELY(metadata.m_hitCountForLLIntCaching && (slot.isValue() || slot.isUnset()))) {
    819819            ASSERT(slot.slotBase() != baseValue);
    820820
    821             if (!(--metadata.hitCountForLLIntCaching))
     821            if (!(--metadata.m_hitCountForLLIntCaching))
    822822                setupGetByIdPrototypeCache(exec, vm, pc, metadata, baseCell, slot, ident);
    823823        }
    … …  
    825825        && isJSArray(baseValue)
    826826        && ident == vm.propertyNames->length) {
    827         metadata.mode = GetByIdMode::ArrayLength;
    828         new (&metadata.modeMetadata.arrayLengthMode.arrayProfile) ArrayProfile(codeBlock->bytecodeOffset(pc));
    829         metadata.modeMetadata.arrayLengthMode.arrayProfile.observeStructure(baseValue.asCell()->structure(vm));
     827        metadata.m_mode = GetByIdMode::ArrayLength;
     828        new (&metadata.m_modeMetadata.arrayLengthMode.arrayProfile) ArrayProfile(codeBlock->bytecodeOffset(pc));
     829        metadata.m_modeMetadata.arrayLengthMode.arrayProfile.observeStructure(baseValue.asCell()->structure(vm));
    830830
    831831        // Prevent the prototype cache from ever happening.
    832         metadata.hitCountForLLIntCaching = 0;
     832        metadata.m_hitCountForLLIntCaching = 0;
    833833    }
    834834
    … …  
    843843    auto& metadata = bytecode.metadata(exec);
    844844    CodeBlock* codeBlock = exec->codeBlock();
    845     const Identifier& ident = codeBlock->identifier(bytecode.property);
    846    
    847     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
     845    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
     846   
     847    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
    848848    PutPropertySlot slot(baseValue, codeBlock->isStrictMode(), codeBlock->putByIdContext());
    849     if (bytecode.flags & PutByIdIsDirect)
    850         CommonSlowPaths::putDirectWithReify(vm, exec, asObject(baseValue), ident, LLINT_OP_C(bytecode.value).jsValue(), slot);
     849    if (bytecode.m_flags & PutByIdIsDirect)
     850        CommonSlowPaths::putDirectWithReify(vm, exec, asObject(baseValue), ident, LLINT_OP_C(bytecode.m_value).jsValue(), slot);
    851851    else
    852         baseValue.putInline(exec, ident, LLINT_OP_C(bytecode.value).jsValue(), slot);
     852        baseValue.putInline(exec, ident, LLINT_OP_C(bytecode.m_value).jsValue(), slot);
    853853    LLINT_CHECK_EXCEPTION();
    854854   
    … …  
    858858
    859859        {
    860             StructureID oldStructureID = metadata.oldStructure;
     860            StructureID oldStructureID = metadata.m_oldStructure;
    861861            if (oldStructureID) {
    862862                Structure* a = vm.heap.structureIDTable().get(oldStructureID);
    … …  
    873873
    874874        // Start out by clearing out the old cache.
    875         metadata.oldStructure = 0;
    876         metadata.offset = 0;
    877         metadata.newStructure = 0;
    878         metadata.structureChain.clear();
     875        metadata.m_oldStructure = 0;
     876        metadata.m_offset = 0;
     877        metadata.m_newStructure = 0;
     878        metadata.m_structureChain.clear();
    879879       
    880880        JSCell* baseCell = baseValue.asCell();
    … …  
    897897                    if (result != InvalidPrototypeChain && !sawPolyProto) {
    898898                        ASSERT(structure->previousID()->isObject());
    899                         metadata.oldStructure = structure->previousID()->id();
    900                         metadata.offset = slot.cachedOffset();
    901                         metadata.newStructure = structure->id();
    902                         if (!(bytecode.flags & PutByIdIsDirect)) {
     899                        metadata.m_oldStructure = structure->previousID()->id();
     900                        metadata.m_offset = slot.cachedOffset();
     901                        metadata.m_newStructure = structure->id();
     902                        if (!(bytecode.m_flags & PutByIdIsDirect)) {
    903903                            StructureChain* chain = structure->prototypeChain(exec, asObject(baseCell));
    904904                            ASSERT(chain);
    905                             metadata.structureChain.set(vm, codeBlock, chain);
     905                            metadata.m_structureChain.set(vm, codeBlock, chain);
    906906                        }
    907907                    }
    … …  
    909909            } else {
    910910                structure->didCachePropertyReplacement(vm, slot.cachedOffset());
    911                 metadata.oldStructure = structure->id();
    912                 metadata.offset = slot.cachedOffset();
     911                metadata.m_oldStructure = structure->id();
     912                metadata.m_offset = slot.cachedOffset();
    913913            }
    914914        }
    … …  
    923923    auto bytecode = pc->as<OpDelById>();
    924924    CodeBlock* codeBlock = exec->codeBlock();
    925     JSObject* baseObject = LLINT_OP_C(bytecode.base).jsValue().toObject(exec);
     925    JSObject* baseObject = LLINT_OP_C(bytecode.m_base).jsValue().toObject(exec);
    926926    LLINT_CHECK_EXCEPTION();
    927     bool couldDelete = baseObject->methodTable(vm)->deleteProperty(baseObject, exec, codeBlock->identifier(bytecode.property));
     927    bool couldDelete = baseObject->methodTable(vm)->deleteProperty(baseObject, exec, codeBlock->identifier(bytecode.m_property));
    928928    LLINT_CHECK_EXCEPTION();
    929929    if (!couldDelete && codeBlock->isStrictMode())
    … …  
    934934static ALWAYS_INLINE JSValue getByVal(VM& vm, ExecState* exec, OpGetByVal bytecode)
    935935{
    936     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
    937     JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
     936    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
     937    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
    938938    auto scope = DECLARE_THROW_SCOPE(vm);
    939939
    … …  
    951951        uint32_t i = subscript.asUInt32();
    952952        auto& metadata = bytecode.metadata(exec);
    953         ArrayProfile* arrayProfile = &metadata.arrayProfile;
     953        ArrayProfile* arrayProfile = &metadata.m_arrayProfile;
    954954
    955955        if (isJSString(baseValue)) {
    … …  
    10011001   
    10021002    auto bytecode = pc->as<OpPutByVal>();
    1003     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
    1004     JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
    1005     JSValue value = LLINT_OP_C(bytecode.value).jsValue();
     1003    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
     1004    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
     1005    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
    10061006    bool isStrictMode = exec->codeBlock()->isStrictMode();
    10071007   
    … …  
    10321032   
    10331033    auto bytecode = pc->as<OpPutByValDirect>();
    1034     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
    1035     JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
    1036     JSValue value = LLINT_OP_C(bytecode.value).jsValue();
     1034    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
     1035    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
     1036    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
    10371037    RELEASE_ASSERT(baseValue.isObject());
    10381038    JSObject* baseObject = asObject(baseValue);
    … …  
    10721072    LLINT_BEGIN();
    10731073    auto bytecode = pc->as<OpDelByVal>();
    1074     JSValue baseValue = LLINT_OP_C(bytecode.base).jsValue();
     1074    JSValue baseValue = LLINT_OP_C(bytecode.m_base).jsValue();
    10751075    JSObject* baseObject = baseValue.toObject(exec);
    10761076    LLINT_CHECK_EXCEPTION();
    10771077
    1078     JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
     1078    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
    10791079   
    10801080    bool couldDelete;
    … …  
    11011101    LLINT_BEGIN();
    11021102    auto bytecode = pc->as<OpPutGetterById>();
    1103     ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
    1104     JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
    1105 
    1106     unsigned options = bytecode.attributes;
    1107 
    1108     JSValue getter = LLINT_OP(bytecode.accessor).jsValue();
     1103    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
     1104    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
     1105
     1106    unsigned options = bytecode.m_attributes;
     1107
     1108    JSValue getter = LLINT_OP(bytecode.m_accessor).jsValue();
    11091109    ASSERT(getter.isObject());
    11101110
    1111     baseObj->putGetter(exec, exec->codeBlock()->identifier(bytecode.property), asObject(getter), options);
     1111    baseObj->putGetter(exec, exec->codeBlock()->identifier(bytecode.m_property), asObject(getter), options);
    11121112    LLINT_END();
    11131113}
    … …  
    11171117    LLINT_BEGIN();
    11181118    auto bytecode = pc->as<OpPutSetterById>();
    1119     ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
    1120     JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
    1121 
    1122     unsigned options = bytecode.attributes;
    1123 
    1124     JSValue setter = LLINT_OP(bytecode.accessor).jsValue();
     1119    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
     1120    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
     1121
     1122    unsigned options = bytecode.m_attributes;
     1123
     1124    JSValue setter = LLINT_OP(bytecode.m_accessor).jsValue();
    11251125    ASSERT(setter.isObject());
    11261126
    1127     baseObj->putSetter(exec, exec->codeBlock()->identifier(bytecode.property), asObject(setter), options);
     1127    baseObj->putSetter(exec, exec->codeBlock()->identifier(bytecode.m_property), asObject(setter), options);
    11281128    LLINT_END();
    11291129}
    … …  
    11331133    LLINT_BEGIN();
    11341134    auto bytecode = pc->as<OpPutGetterSetterById>();
    1135     ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
    1136     JSObject* baseObject = asObject(LLINT_OP(bytecode.base).jsValue());
    1137 
    1138     JSValue getter = LLINT_OP(bytecode.getter).jsValue();
    1139     JSValue setter = LLINT_OP(bytecode.setter).jsValue();
     1135    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
     1136    JSObject* baseObject = asObject(LLINT_OP(bytecode.m_base).jsValue());
     1137
     1138    JSValue getter = LLINT_OP(bytecode.m_getter).jsValue();
     1139    JSValue setter = LLINT_OP(bytecode.m_setter).jsValue();
    11401140    ASSERT(getter.isObject() || setter.isObject());
    11411141    GetterSetter* accessor = GetterSetter::create(vm, exec->lexicalGlobalObject(), getter, setter);
    11421142
    1143     CommonSlowPaths::putDirectAccessorWithReify(vm, exec, baseObject, exec->codeBlock()->identifier(bytecode.property), accessor, bytecode.attributes);
     1143    CommonSlowPaths::putDirectAccessorWithReify(vm, exec, baseObject, exec->codeBlock()->identifier(bytecode.m_property), accessor, bytecode.m_attributes);
    11441144    LLINT_END();
    11451145}
    … …  
    11491149    LLINT_BEGIN();
    11501150    auto bytecode = pc->as<OpPutGetterByVal>();
    1151     ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
    1152     JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
    1153     JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
    1154 
    1155     unsigned options = bytecode.attributes;
    1156 
    1157     JSValue getter = LLINT_OP(bytecode.accessor).jsValue();
     1151    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
     1152    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
     1153    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
     1154
     1155    unsigned options = bytecode.m_attributes;
     1156
     1157    JSValue getter = LLINT_OP(bytecode.m_accessor).jsValue();
    11581158    ASSERT(getter.isObject());
    11591159
    … …  
    11691169    LLINT_BEGIN();
    11701170    auto bytecode = pc->as<OpPutSetterByVal>();
    1171     ASSERT(LLINT_OP(bytecode.base).jsValue().isObject());
    1172     JSObject* baseObj = asObject(LLINT_OP(bytecode.base).jsValue());
    1173     JSValue subscript = LLINT_OP_C(bytecode.property).jsValue();
    1174 
    1175     unsigned options = bytecode.attributes;
    1176 
    1177     JSValue setter = LLINT_OP(bytecode.accessor).jsValue();
     1171    ASSERT(LLINT_OP(bytecode.m_base).jsValue().isObject());
     1172    JSObject* baseObj = asObject(LLINT_OP(bytecode.m_base).jsValue());
     1173    JSValue subscript = LLINT_OP_C(bytecode.m_property).jsValue();
     1174
     1175    unsigned options = bytecode.m_attributes;
     1176
     1177    JSValue setter = LLINT_OP(bytecode.m_accessor).jsValue();
    11781178    ASSERT(setter.isObject());
    11791179
    … …  
    11891189    LLINT_BEGIN();
    11901190    auto bytecode = pc->as<OpJtrue>();
    1191     LLINT_BRANCH(LLINT_OP_C(bytecode.condition).jsValue().toBoolean(exec));
     1191    LLINT_BRANCH(LLINT_OP_C(bytecode.m_condition).jsValue().toBoolean(exec));
    11921192}
    11931193
    … …  
    11961196    LLINT_BEGIN();
    11971197    auto bytecode = pc->as<OpJfalse>();
    1198     LLINT_BRANCH(!LLINT_OP_C(bytecode.condition).jsValue().toBoolean(exec));
     1198    LLINT_BRANCH(!LLINT_OP_C(bytecode.m_condition).jsValue().toBoolean(exec));
    11991199}
    12001200
    … …  
    12031203    LLINT_BEGIN();
    12041204    auto bytecode = pc->as<OpJless>();
    1205     LLINT_BRANCH(jsLess<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1205    LLINT_BRANCH(jsLess<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12061206}
    12071207
    … …  
    12101210    LLINT_BEGIN();
    12111211    auto bytecode = pc->as<OpJnless>();
    1212     LLINT_BRANCH(!jsLess<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1212    LLINT_BRANCH(!jsLess<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12131213}
    12141214
    … …  
    12171217    LLINT_BEGIN();
    12181218    auto bytecode = pc->as<OpJgreater>();
    1219     LLINT_BRANCH(jsLess<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
     1219    LLINT_BRANCH(jsLess<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
    12201220}
    12211221
    … …  
    12241224    LLINT_BEGIN();
    12251225    auto bytecode = pc->as<OpJngreater>();
    1226     LLINT_BRANCH(!jsLess<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
     1226    LLINT_BRANCH(!jsLess<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
    12271227}
    12281228
    … …  
    12311231    LLINT_BEGIN();
    12321232    auto bytecode = pc->as<OpJlesseq>();
    1233     LLINT_BRANCH(jsLessEq<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1233    LLINT_BRANCH(jsLessEq<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12341234}
    12351235
    … …  
    12381238    LLINT_BEGIN();
    12391239    auto bytecode = pc->as<OpJnlesseq>();
    1240     LLINT_BRANCH(!jsLessEq<true>(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1240    LLINT_BRANCH(!jsLessEq<true>(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12411241}
    12421242
    … …  
    12451245    LLINT_BEGIN();
    12461246    auto bytecode = pc->as<OpJgreatereq>();
    1247     LLINT_BRANCH(jsLessEq<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
     1247    LLINT_BRANCH(jsLessEq<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
    12481248}
    12491249
    … …  
    12521252    LLINT_BEGIN();
    12531253    auto bytecode = pc->as<OpJngreatereq>();
    1254     LLINT_BRANCH(!jsLessEq<false>(exec, LLINT_OP_C(bytecode.rhs).jsValue(), LLINT_OP_C(bytecode.lhs).jsValue()));
     1254    LLINT_BRANCH(!jsLessEq<false>(exec, LLINT_OP_C(bytecode.m_rhs).jsValue(), LLINT_OP_C(bytecode.m_lhs).jsValue()));
    12551255}
    12561256
    … …  
    12591259    LLINT_BEGIN();
    12601260    auto bytecode = pc->as<OpJeq>();
    1261     LLINT_BRANCH(JSValue::equal(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1261    LLINT_BRANCH(JSValue::equal(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12621262}
    12631263
    … …  
    12661266    LLINT_BEGIN();
    12671267    auto bytecode = pc->as<OpJneq>();
    1268     LLINT_BRANCH(!JSValue::equal(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1268    LLINT_BRANCH(!JSValue::equal(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12691269}
    12701270
    … …  
    12731273    LLINT_BEGIN();
    12741274    auto bytecode = pc->as<OpJstricteq>();
    1275     LLINT_BRANCH(JSValue::strictEqual(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1275    LLINT_BRANCH(JSValue::strictEqual(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12761276}
    12771277
    … …  
    12801280    LLINT_BEGIN();
    12811281    auto bytecode = pc->as<OpJnstricteq>();
    1282     LLINT_BRANCH(!JSValue::strictEqual(exec, LLINT_OP_C(bytecode.lhs).jsValue(), LLINT_OP_C(bytecode.rhs).jsValue()));
     1282    LLINT_BRANCH(!JSValue::strictEqual(exec, LLINT_OP_C(bytecode.m_lhs).jsValue(), LLINT_OP_C(bytecode.m_rhs).jsValue()));
    12831283}
    12841284
    … …  
    12871287    LLINT_BEGIN();
    12881288    auto bytecode = pc->as<OpSwitchImm>();
    1289     JSValue scrutinee = LLINT_OP_C(bytecode.scrutinee).jsValue();
     1289    JSValue scrutinee = LLINT_OP_C(bytecode.m_scrutinee).jsValue();
    12901290    ASSERT(scrutinee.isDouble());
    12911291    double value = scrutinee.asDouble();
    12921292    int32_t intValue = static_cast<int32_t>(value);
    1293     int defaultOffset = JUMP_OFFSET(bytecode.defaultOffset);
     1293    int defaultOffset = JUMP_OFFSET(bytecode.m_defaultOffset);
    12941294    if (value == intValue) {
    12951295        CodeBlock* codeBlock = exec->codeBlock();
    1296         JUMP_TO(codeBlock->switchJumpTable(bytecode.tableIndex).offsetForValue(intValue, defaultOffset));
     1296        JUMP_TO(codeBlock->switchJumpTable(bytecode.m_tableIndex).offsetForValue(intValue, defaultOffset));
    12971297    } else
    12981298        JUMP_TO(defaultOffset);
    … …  
    13041304    LLINT_BEGIN();
    13051305    auto bytecode = pc->as<OpSwitchChar>();
    1306     JSValue scrutinee = LLINT_OP_C(bytecode.scrutinee).jsValue();
     1306    JSValue scrutinee = LLINT_OP_C(bytecode.m_scrutinee).jsValue();
    13071307    ASSERT(scrutinee.isString());
    13081308    JSString* string = asString(scrutinee);
    13091309    ASSERT(string->length() == 1);
    1310     int defaultOffset = JUMP_OFFSET(bytecode.defaultOffset);
     1310    int defaultOffset = JUMP_OFFSET(bytecode.m_defaultOffset);
    13111311    StringImpl* impl = string->value(exec).impl();
    13121312    CodeBlock* codeBlock = exec->codeBlock();
    1313     JUMP_TO(codeBlock->switchJumpTable(bytecode.tableIndex).offsetForValue((*impl)[0], defaultOffset));
     1313    JUMP_TO(codeBlock->switchJumpTable(bytecode.m_tableIndex).offsetForValue((*impl)[0], defaultOffset));
    13141314    LLINT_END();
    13151315}
    … …  
    13191319    LLINT_BEGIN();
    13201320    auto bytecode = pc->as<OpSwitchString>();
    1321     JSValue scrutinee = LLINT_OP_C(bytecode.scrutinee).jsValue();
    1322     int defaultOffset = JUMP_OFFSET(bytecode.defaultOffset);
     1321    JSValue scrutinee = LLINT_OP_C(bytecode.m_scrutinee).jsValue();
     1322    int defaultOffset = JUMP_OFFSET(bytecode.m_defaultOffset);
    13231323    if (!scrutinee.isString())
    13241324        JUMP_TO(defaultOffset);
    13251325    else {
    13261326        CodeBlock* codeBlock = exec->codeBlock();
    1327         JUMP_TO(codeBlock->stringSwitchJumpTable(bytecode.tableIndex).offsetForValue(asString(scrutinee)->value(exec).impl(), defaultOffset));
     1327        JUMP_TO(codeBlock->stringSwitchJumpTable(bytecode.m_tableIndex).offsetForValue(asString(scrutinee)->value(exec).impl(), defaultOffset));
    13281328    }
    13291329    LLINT_END();
    … …  
    13351335    auto bytecode = pc->as<OpNewFunc>();
    13361336    CodeBlock* codeBlock = exec->codeBlock();
    1337     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
     1337    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
    13381338    slowPathLogF("Creating function!\n");
    1339     LLINT_RETURN(JSFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
     1339    LLINT_RETURN(JSFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
    13401340}
    13411341
    … …  
    13451345    auto bytecode = pc->as<OpNewGeneratorFunc>();
    13461346    CodeBlock* codeBlock = exec->codeBlock();
    1347     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
     1347    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
    13481348    slowPathLogF("Creating function!\n");
    1349     LLINT_RETURN(JSGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
     1349    LLINT_RETURN(JSGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
    13501350}
    13511351
    … …  
    13551355    auto bytecode = pc->as<OpNewAsyncFunc>();
    13561356    CodeBlock* codeBlock = exec->codeBlock();
    1357     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
     1357    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
    13581358    slowPathLogF("Creating async function!\n");
    1359     LLINT_RETURN(JSAsyncFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
     1359    LLINT_RETURN(JSAsyncFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
    13601360}
    13611361
    … …  
    13651365    auto bytecode = pc->as<OpNewAsyncGeneratorFunc>();
    13661366    CodeBlock* codeBlock = exec->codeBlock();
    1367     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
     1367    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
    13681368    slowPathLogF("Creating async generator function!\n");
    1369     LLINT_RETURN(JSAsyncGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.functionDecl), scope));
     1369    LLINT_RETURN(JSAsyncGeneratorFunction::create(vm, codeBlock->functionDecl(bytecode.m_functionDecl), scope));
    13701370}
    13711371   
    … …  
    13761376    auto bytecode = pc->as<OpNewFuncExp>();
    13771377    CodeBlock* codeBlock = exec->codeBlock();
    1378     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
    1379     FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
     1378    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
     1379    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
    13801380   
    13811381    LLINT_RETURN(JSFunction::create(vm, executable, scope));
    … …  
    13881388    auto bytecode = pc->as<OpNewGeneratorFuncExp>();
    13891389    CodeBlock* codeBlock = exec->codeBlock();
    1390     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
    1391     FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
     1390    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
     1391    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
    13921392
    13931393    LLINT_RETURN(JSGeneratorFunction::create(vm, executable, scope));
    … …  
    14001400    auto bytecode = pc->as<OpNewAsyncFuncExp>();
    14011401    CodeBlock* codeBlock = exec->codeBlock();
    1402     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
    1403     FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
     1402    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
     1403    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
    14041404   
    14051405    LLINT_RETURN(JSAsyncFunction::create(vm, executable, scope));
    … …  
    14121412    auto bytecode = pc->as<OpNewAsyncGeneratorFuncExp>();
    14131413    CodeBlock* codeBlock = exec->codeBlock();
    1414     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
    1415     FunctionExecutable* executable = codeBlock->functionExpr(bytecode.functionDecl);
     1414    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
     1415    FunctionExecutable* executable = codeBlock->functionExpr(bytecode.m_functionDecl);
    14161416       
    14171417    LLINT_RETURN(JSAsyncGeneratorFunction::create(vm, executable, scope));
    … …  
    14221422    LLINT_BEGIN();
    14231423    auto bytecode = pc->as<OpSetFunctionName>();
    1424     JSFunction* func = jsCast<JSFunction*>(LLINT_OP(bytecode.function).Register::unboxedCell());
    1425     JSValue name = LLINT_OP_C(bytecode.name).Register::jsValue();
     1424    JSFunction* func = jsCast<JSFunction*>(LLINT_OP(bytecode.m_function).Register::unboxedCell());
     1425    JSValue name = LLINT_OP_C(bytecode.m_name).Register::jsValue();
    14261426    func->setFunctionName(exec, name);
    14271427    LLINT_END();
    … …  
    15731573    // - Return a tuple of machine code address to call and the new call frame.
    15741574   
    1575     JSValue calleeAsValue = LLINT_OP_C(bytecode.callee).jsValue();
    1576    
    1577     ExecState* execCallee = exec - bytecode.argv;
    1578    
    1579     execCallee->setArgumentCountIncludingThis(bytecode.argc);
     1575    JSValue calleeAsValue = LLINT_OP_C(bytecode.m_callee).jsValue();
     1576   
     1577    ExecState* execCallee = exec - bytecode.m_argv;
     1578   
     1579    execCallee->setArgumentCountIncludingThis(bytecode.m_argc);
    15801580    execCallee->uncheckedR(CallFrameSlot::callee) = calleeAsValue;
    15811581    execCallee->setCallerFrame(exec);
    15821582   
    15831583    auto& metadata = bytecode.metadata(exec);
    1584     return setUpCall(execCallee, kind, calleeAsValue, &metadata.callLinkInfo);
     1584    return setUpCall(execCallee, kind, calleeAsValue, &metadata.m_callLinkInfo);
    15851585}
    15861586
    … …  
    16151615    case op_call_varargs: {
    16161616        auto bytecode = pc->as<OpCallVarargs>();
    1617         numUsedStackSlots = -bytecode.firstFree.offset();
    1618         arguments = LLINT_OP_C(bytecode.arguments).jsValue();
    1619         firstVarArg = bytecode.firstVarArg;
     1617        numUsedStackSlots = -bytecode.m_firstFree.offset();
     1618        arguments = LLINT_OP_C(bytecode.m_arguments).jsValue();
     1619        firstVarArg = bytecode.m_firstVarArg;
    16201620        break;
    16211621    }
    16221622    case op_tail_call_varargs: {
    16231623        auto bytecode = pc->as<OpTailCallVarargs>();
    1624         numUsedStackSlots = -bytecode.firstFree.offset();
    1625         arguments = LLINT_OP_C(bytecode.arguments).jsValue();
    1626         firstVarArg = bytecode.firstVarArg;
     1624        numUsedStackSlots = -bytecode.m_firstFree.offset();
     1625        arguments = LLINT_OP_C(bytecode.m_arguments).jsValue();
     1626        firstVarArg = bytecode.m_firstVarArg;
    16271627        break;
    16281628    }
    16291629    case op_construct_varargs: {
    16301630        auto bytecode = pc->as<OpConstructVarargs>();
    1631         numUsedStackSlots = -bytecode.firstFree.offset();
    1632         arguments = LLINT_OP_C(bytecode.arguments).jsValue();
    1633         firstVarArg = bytecode.firstVarArg;
     1631        numUsedStackSlots = -bytecode.m_firstFree.offset();
     1632        arguments = LLINT_OP_C(bytecode.m_arguments).jsValue();
     1633        firstVarArg = bytecode.m_firstVarArg;
    16341634        break;
    16351635    }
    … …  
    16541654
    16551655    auto bytecode = pc->as<OpTailCallForwardArguments>();
    1656     unsigned numUsedStackSlots = -bytecode.firstFree.offset();
     1656    unsigned numUsedStackSlots = -bytecode.m_firstFree.offset();
    16571657
    16581658    unsigned arguments = sizeFrameForForwardArguments(exec, vm, numUsedStackSlots);
    … …  
    16811681
    16821682    auto bytecode = pc->as<Op>();
    1683     JSValue calleeAsValue = LLINT_OP_C(bytecode.callee).jsValue();
     1683    JSValue calleeAsValue = LLINT_OP_C(bytecode.m_callee).jsValue();
    16841684
    16851685    ExecState* execCallee = vm.newCallFrameReturnValue;
    16861686
    16871687    if (set == SetArgumentsWith::Object) {
    1688         setupVarargsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.thisValue).jsValue(), LLINT_OP_C(bytecode.arguments).jsValue(), bytecode.firstVarArg, vm.varargsLength);
     1688        setupVarargsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.m_thisValue).jsValue(), LLINT_OP_C(bytecode.m_arguments).jsValue(), bytecode.m_firstVarArg, vm.varargsLength);
    16891689        LLINT_CALL_CHECK_EXCEPTION(exec, exec);
    16901690    } else
    1691         setupForwardArgumentsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.thisValue).jsValue(), vm.varargsLength);
     1691        setupForwardArgumentsFrameAndSetThis(exec, execCallee, LLINT_OP_C(bytecode.m_thisValue).jsValue(), vm.varargsLength);
    16921692
    16931693    execCallee->setCallerFrame(exec);
    … …  
    17221722    LLINT_BEGIN_NO_SET_PC();
    17231723    auto bytecode = pc->as<OpCallEval>();
    1724     JSValue calleeAsValue = LLINT_OP(bytecode.callee).jsValue();
    1725    
    1726     ExecState* execCallee = exec - bytecode.argv;
    1727    
    1728     execCallee->setArgumentCountIncludingThis(bytecode.argc);
     1724    JSValue calleeAsValue = LLINT_OP(bytecode.m_callee).jsValue();
     1725   
     1726    ExecState* execCallee = exec - bytecode.m_argv;
     1727   
     1728    execCallee->setArgumentCountIncludingThis(bytecode.m_argc);
    17291729    execCallee->setCallerFrame(exec);
    17301730    execCallee->uncheckedR(CallFrameSlot::callee) = calleeAsValue;
    … …  
    17541754    LLINT_BEGIN();
    17551755    auto bytecode = pc->as<OpStrcat>();
    1756     LLINT_RETURN(jsStringFromRegisterArray(exec, &LLINT_OP(bytecode.src), bytecode.count));
     1756    LLINT_RETURN(jsStringFromRegisterArray(exec, &LLINT_OP(bytecode.m_src), bytecode.m_count));
    17571757}
    17581758
    … …  
    17611761    LLINT_BEGIN();
    17621762    auto bytecode = pc->as<OpToPrimitive>();
    1763     LLINT_RETURN(LLINT_OP_C(bytecode.src).jsValue().toPrimitive(exec));
     1763    LLINT_RETURN(LLINT_OP_C(bytecode.m_src).jsValue().toPrimitive(exec));
    17641764}
    17651765
    … …  
    17681768    LLINT_BEGIN();
    17691769    auto bytecode = pc->as<OpThrow>();
    1770     LLINT_THROW(LLINT_OP_C(bytecode.value).jsValue());
     1770    LLINT_THROW(LLINT_OP_C(bytecode.m_value).jsValue());
    17711771}
    17721772
    … …  
    17841784    LLINT_BEGIN();
    17851785    auto bytecode = pc->as<OpDebug>();
    1786     vm.interpreter->debug(exec, bytecode.debugHookType);
     1786    vm.interpreter->debug(exec, bytecode.m_debugHookType);
    17871787   
    17881788    LLINT_END();
    … …  
    18021802    auto bytecode = pc->as<OpGetFromScope>();
    18031803    auto& metadata = bytecode.metadata(exec);
    1804     const Identifier& ident = exec->codeBlock()->identifier(bytecode.var);
    1805     JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.scope).jsValue());
     1804    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_var);
     1805    JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.m_scope).jsValue());
    18061806
    18071807    // ModuleVar is always converted to ClosureVar for get_from_scope.
    1808     ASSERT(metadata.getPutInfo.resolveType() != ModuleVar);
     1808    ASSERT(metadata.m_getPutInfo.resolveType() != ModuleVar);
    18091809
    18101810    LLINT_RETURN(scope->getPropertySlot(exec, ident, [&] (bool found, PropertySlot& slot) -> JSValue {
    18111811        if (!found) {
    1812             if (metadata.getPutInfo.resolveMode() == ThrowIfNotFound)
     1812            if (metadata.m_getPutInfo.resolveMode() == ThrowIfNotFound)
    18131813                return throwException(exec, throwScope, createUndefinedVariableError(exec, ident));
    18141814            return jsUndefined();
    … …  
    18381838    auto& metadata = bytecode.metadata(exec);
    18391839    CodeBlock* codeBlock = exec->codeBlock();
    1840     const Identifier& ident = codeBlock->identifier(bytecode.var);
    1841     JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.scope).jsValue());
    1842     JSValue value = LLINT_OP_C(bytecode.value).jsValue();
    1843     if (metadata.getPutInfo.resolveType() == LocalClosureVar) {
     1840    const Identifier& ident = codeBlock->identifier(bytecode.m_var);
     1841    JSObject* scope = jsCast<JSObject*>(LLINT_OP(bytecode.m_scope).jsValue());
     1842    JSValue value = LLINT_OP_C(bytecode.m_value).jsValue();
     1843    if (metadata.m_getPutInfo.resolveType() == LocalClosureVar) {
    18441844        JSLexicalEnvironment* environment = jsCast<JSLexicalEnvironment*>(scope);
    1845         environment->variableAt(ScopeOffset(metadata.operand)).set(vm, environment, value);
     1845        environment->variableAt(ScopeOffset(metadata.m_operand)).set(vm, environment, value);
    18461846       
    18471847        // Have to do this *after* the write, because if this puts the set into IsWatched, then we need
    18481848        // to have already changed the value of the variable. Otherwise we might watch and constant-fold
    18491849        // to the Undefined value from before the assignment.
    1850         if (metadata.watchpointSet)
    1851             metadata.watchpointSet->touch(vm, "Executed op_put_scope<LocalClosureVar>");
     1850        if (metadata.m_watchpointSet)
     1851            metadata.m_watchpointSet->touch(vm, "Executed op_put_scope<LocalClosureVar>");
    18521852        LLINT_END();
    18531853    }
    … …  
    18571857    if (hasProperty
    18581858        && scope->isGlobalLexicalEnvironment()
    1859         && !isInitialization(metadata.getPutInfo.initializationMode())) {
     1859        && !isInitialization(metadata.m_getPutInfo.initializationMode())) {
    18601860        // When we can't statically prove we need a TDZ check, we must perform the check on the slow path.
    18611861        PropertySlot slot(scope, PropertySlot::InternalMethodType::Get);
    … …  
    18651865    }
    18661866
    1867     if (metadata.getPutInfo.resolveMode() == ThrowIfNotFound && !hasProperty)
     1867    if (metadata.m_getPutInfo.resolveMode() == ThrowIfNotFound && !hasProperty)
    18681868        LLINT_THROW(createUndefinedVariableError(exec, ident));
    18691869
    1870     PutPropertySlot slot(scope, codeBlock->isStrictMode(), PutPropertySlot::UnknownContext, isInitialization(metadata.getPutInfo.initializationMode()));
     1870    PutPropertySlot slot(scope, codeBlock->isStrictMode(), PutPropertySlot::UnknownContext, isInitialization(metadata.m_getPutInfo.initializationMode()));
    18711871    scope->methodTable(vm)->put(scope, exec, ident, value, slot);
    18721872   
    … …  
    18911891   
    18921892    auto bytecode = pc->as<OpLogShadowChickenPrologue>();
    1893     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
     1893    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
    18941894    vm.shadowChicken().log(vm, exec, ShadowChicken::Packet::prologue(exec->jsCallee(), exec, exec->callerFrame(), scope));
    18951895   
    … …  
    19021902
    19031903    auto bytecode = pc->as<OpLogShadowChickenTail>();
    1904     JSValue thisValue = LLINT_OP(bytecode.thisValue).jsValue();
    1905     JSScope* scope = exec->uncheckedR(bytecode.scope).Register::scope();
     1904    JSValue thisValue = LLINT_OP(bytecode.m_thisValue).jsValue();
     1905    JSScope* scope = exec->uncheckedR(bytecode.m_scope).Register::scope();
    19061906   
    19071907#if USE(JSVALUE64)
    … …  
    19231923    auto bytecode = pc->as<OpCatch>();
    19241924    auto& metadata = bytecode.metadata(exec);
    1925     metadata.buffer->forEach([&] (ValueProfileAndOperand& profile) {
     1925    metadata.m_buffer->forEach([&] (ValueProfileAndOperand& profile) {
    19261926        profile.m_profile.m_buckets[0] = JSValue::encode(exec->uncheckedR(profile.m_operand).jsValue());
    19271927    });

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

    r240023 r240041  
    1 # Copyright (C) 2011-2018 Apple Inc. All rights reserved.
     1# Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    22#
    33# Redistribution and use in source and binary forms, with or without
    … …  
    307307end
    308308
    309 macro getu(size, op, field, dst)
     309macro getu(size, op, fieldName, dst)
    310310    size(getuOperandNarrow, getuOperandWide, macro (getu)
    311         getu(op, field, dst)
     311        getu(op, fieldName, dst)
    312312    end)
    313313end
    314314
    315 macro get(size, op, field, dst)
     315macro get(size, op, fieldName, dst)
    316316    size(getOperandNarrow, getOperandWide, macro (get)
    317         get(op, field, dst)
     317        get(op, fieldName, dst)
    318318    end)
    319319end
    … …  
    329329macro metadata(size, opcode, dst, scratch)
    330330    loadi constexpr %opcode%::opcodeID * 4[metadataTable], dst # offset = metadataTable<unsigned*>[opcodeID]
    331     getu(size, opcode, metadataID, scratch) # scratch = bytecode.metadataID
     331    getu(size, opcode, m_metadataID, scratch) # scratch = bytecode.m_metadataID
    332332    muli sizeof %opcode%::Metadata, scratch # scratch *= sizeof(Op::Metadata)
    333333    addi scratch, dst # offset += scratch
    … …  
    361361macro llintOp(name, op, fn)
    362362    commonOp(llint_%name%, traceExecution, macro(size)
    363         macro getImpl(field, dst)
    364             get(size, op, field, dst)
     363        macro getImpl(fieldName, dst)
     364            get(size, op, fieldName, dst)
    365365        end
    366366
    … …  
    392392macro llintOpWithJump(name, op, impl)
    393393    llintOpWithMetadata(name, op, macro(size, get, dispatch, metadata, return)
    394         macro jump(field)
    395             get(field, t0)
     394        macro jump(fieldName)
     395            get(fieldName, t0)
    396396            jumpImpl(t0)
    397397        end
    … …  
    838838end
    839839
    840 macro unpoison(poison, field, scratch)
     840macro unpoison(poison, fieldReg, scratch)
    841841    if POISON
    842842        loadp poison, scratch
    843         xorp scratch, field
     843        xorp scratch, fieldReg
    844844    end
    845845end
    … …  
    15391539
    15401540llintOpWithJump(op_jmp, OpJmp, macro (size, get, jump, dispatch)
    1541     jump(target)
     1541    jump(m_target)
    15421542end)
    15431543

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

    r240023 r240041  
    1 # Copyright (C) 2011-2018 Apple Inc. All rights reserved.
     1# Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    22#
    33# Redistribution and use in source and binary forms, with or without
    … …  
    3636end
    3737
    38 macro getuOperandNarrow(op, field, dst)
    39     loadb constexpr %op%_%field%_index[PC], dst
    40 end
    41 
    42 macro getOperandNarrow(op, field, dst)
    43     loadbsp constexpr %op%_%field%_index[PC], dst
    44 end
    45 
    46 macro getuOperandWide(op, field, dst)
    47     loadi constexpr %op%_%field%_index * 4 + 1[PC], dst
    48 end
    49 
    50 macro getOperandWide(op, field, dst)
    51     loadis constexpr %op%_%field%_index * 4 + 1[PC], dst
     38macro getuOperandNarrow(op, fieldName, dst)
     39    loadb constexpr %op%_%fieldName%_index[PC], dst
     40end
     41
     42macro getOperandNarrow(op, fieldName, dst)
     43    loadbsp constexpr %op%_%fieldName%_index[PC], dst
     44end
     45
     46macro getuOperandWide(op, fieldName, dst)
     47    loadi constexpr %op%_%fieldName%_index * 4 + 1[PC], dst
     48end
     49
     50macro getOperandWide(op, fieldName, dst)
     51    loadis constexpr %op%_%fieldName%_index * 4 + 1[PC], dst
    5252end
    5353
    … …  
    5656        move tag, t5
    5757        move payload, t3
    58         get(dst, t2)
     58        get(m_dst, t2)
    5959        storei t5, TagOffset[cfr, t2, 8]
    6060        storei t3, PayloadOffset[cfr, t2, 8]
    … …  
    7070        metadata(t5, t2)
    7171        valueProfile(op, t5, t1, t0)
    72         get(dst, t2)
     72        get(m_dst, t2)
    7373        storei t1, TagOffset[cfr, t2, 8]
    7474        storei t0, PayloadOffset[cfr, t2, 8]
    … …  
    8080macro dispatchAfterCall(size, op, dispatch)
    8181    loadi ArgumentCount + TagOffset[cfr], PC
    82     get(size, op, dst, t3)
     82    get(size, op, m_dst, t3)
    8383    storei r1, TagOffset[cfr, t3, 8]
    8484    storei r0, PayloadOffset[cfr, t3, 8]
    … …  
    439439end
    440440
    441 macro loadVariable(get, operand, index, tag, payload)
    442     get(operand, index)
    443     loadi TagOffset[cfr, index, 8], tag
    444     loadi PayloadOffset[cfr, index, 8], payload
     441macro loadVariable(get, fieldName, indexReg, tagReg, payloadReg)
     442    get(fieldName, indexReg)
     443    loadi TagOffset[cfr, indexReg, 8], tagReg
     444    loadi PayloadOffset[cfr, indexReg, 8], payloadReg
    445445end
    446446
    … …  
    533533end
    534534
    535 macro writeBarrierOnOperand(size, get, cellOperand)
    536     get(cellOperand, t1)
     535macro writeBarrierOnOperand(size, get, cellFieldName)
     536    get(cellFieldName, t1)
    537537    loadConstantOrVariablePayload(size, t1, CellTag, t2, .writeBarrierDone)
    538538    skipIfIsRememberedOrInEden(
    … …  
    551551end
    552552
    553 macro writeBarrierOnOperands(size, get, cellOperand, valueOperand)
    554     get(valueOperand, t1)
     553macro writeBarrierOnOperands(size, get, cellFieldName, valueFieldName)
     554    get(valueFieldName, t1)
    555555    loadConstantOrVariableTag(size, t1, t0)
    556556    bineq t0, CellTag, .writeBarrierDone
    557557
    558     writeBarrierOnOperand(size, get, cellOperand)
     558    writeBarrierOnOperand(size, get, cellFieldName)
    559559.writeBarrierDone:
    560560end
    561561
    562 macro writeBarrierOnGlobal(size, get, valueOperand, loadHelper)
    563     get(valueOperand, t1)
     562macro writeBarrierOnGlobal(size, get, valueFieldName, loadMacro)
     563    get(valueFieldName, t1)
    564564    loadConstantOrVariableTag(size, t1, t0)
    565565    bineq t0, CellTag, .writeBarrierDone
    566566
    567     loadHelper(t3)
     567    loadMacro(t3)
    568568
    569569    skipIfIsRememberedOrInEden(
    … …  
    582582end
    583583
    584 macro writeBarrierOnGlobalObject(size, get, valueOperand)
    585     writeBarrierOnGlobal(size, get, valueOperand,
     584macro writeBarrierOnGlobalObject(size, get, valueFieldName)
     585    writeBarrierOnGlobal(size, get, valueFieldName,
    586586        macro(registerToStoreGlobal)
    587587            loadp CodeBlock[cfr], registerToStoreGlobal
    … …  
    590590end
    591591
    592 macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueOperand)
    593     writeBarrierOnGlobal(size, get, valueOperand,
     592macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueFieldName)
     593    writeBarrierOnGlobal(size, get, valueFieldName,
    594594        macro(registerToStoreGlobal)
    595595            loadp CodeBlock[cfr], registerToStoreGlobal
    … …  
    600600
    601601macro valueProfile(op, metadata, tag, payload)
    602     storei tag, %op%::Metadata::profile.m_buckets + TagOffset[metadata]
    603     storei payload, %op%::Metadata::profile.m_buckets + PayloadOffset[metadata]
     602    storei tag, %op%::Metadata::m_profile.m_buckets + TagOffset[metadata]
     603    storei payload, %op%::Metadata::m_profile.m_buckets + PayloadOffset[metadata]
    604604end
    605605
    … …  
    714714
    715715llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)
    716     get(index, t2)
     716    get(m_index, t2)
    717717    loadi PayloadOffset + ArgumentCount[cfr], t0
    718718    bilteq t0, t2, .opGetArgumentOutOfBounds
    … …  
    741741
    742742llintOpWithMetadata(op_to_this, OpToThis, macro (size, get, dispatch, metadata, return)
    743     get(srcDst, t0)
     743    get(m_srcDst, t0)
    744744    bineq TagOffset[cfr, t0, 8], CellTag, .opToThisSlow
    745745    loadi PayloadOffset[cfr, t0, 8], t0
    746746    bbneq JSCell::m_type[t0], FinalObjectType, .opToThisSlow
    747747    metadata(t2, t3)
    748     loadp OpToThis::Metadata::cachedStructure[t2], t2
     748    loadp OpToThis::Metadata::m_cachedStructure[t2], t2
    749749    bpneq JSCell::m_structureID[t0], t2, .opToThisSlow
    750750    dispatch()
    … …  
    757757
    758758llintOp(op_check_tdz, OpCheckTdz, macro (size, get, dispatch)
    759     get(target, t0)
     759    get(m_target, t0)
    760760    loadConstantOrVariableTag(size, t0, t1)
    761761    bineq t1, EmptyValueTag, .opNotTDZ
    … …  
    768768
    769769llintOpWithReturn(op_mov, OpMov, macro (size, get, dispatch, return)
    770     get(src, t1)
     770    get(m_src, t1)
    771771    loadConstantOrVariable(size, t1, t2, t3)
    772772    return(t2, t3)
    … …  
    775775
    776776llintOpWithReturn(op_not, OpNot, macro (size, get, dispatch, return)
    777     get(operand, t0)
     777    get(m_operand, t0)
    778778    loadConstantOrVariable(size, t0, t2, t3)
    779779    bineq t2, BooleanTag, .opNotSlow
    … …  
    789789macro equalityComparisonOp(name, op, integerComparison)
    790790    llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
    791         get(rhs, t2)
    792         get(lhs, t0)
     791        get(m_rhs, t2)
     792        get(m_lhs, t0)
    793793        loadConstantOrVariable(size, t2, t3, t1)
    794794        loadConstantOrVariable2Reg(size, t0, t2, t0)
    … …  
    808808macro equalityJumpOp(name, op, integerComparison)
    809809    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    810         get(rhs, t2)
    811         get(lhs, t0)
     810        get(m_rhs, t2)
     811        get(m_lhs, t0)
    812812        loadConstantOrVariable(size, t2, t3, t1)
    813813        loadConstantOrVariable2Reg(size, t0, t2, t0)
    … …  
    819819
    820820    .jumpTarget:
    821         jump(target)
     821        jump(m_target)
    822822
    823823    .slow:
    … …  
    830830macro equalNullComparisonOp(name, op, fn)
    831831    llintOpWithReturn(name, op, macro (size, get, dispatch, return)
    832         get(operand, t0)
     832        get(m_operand, t0)
    833833        assertNotConstant(size, t0)
    834834        loadi TagOffset[cfr, t0, 8], t1
    … …  
    861861
    862862llintOpWithReturn(op_is_undefined_or_null, OpIsUndefinedOrNull, macro (size, get, dispatch, return)
    863     get(operand, t0)
     863    get(m_operand, t0)
    864864    assertNotConstant(size, t0)
    865865    loadi TagOffset[cfr, t0, 8], t1
    … …  
    872872macro strictEqOp(name, op, equalityOperation)
    873873    llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
    874         get(rhs, t2)
    875         get(lhs, t0)
     874        get(m_rhs, t2)
     875        get(m_lhs, t0)
    876876        loadConstantOrVariable(size, t2, t3, t1)
    877877        loadConstantOrVariable2Reg(size, t0, t2, t0)
    … …  
    894894macro strictEqualityJumpOp(name, op, equalityOperation)
    895895    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    896         get(rhs, t2)
    897         get(lhs, t0)
     896        get(m_rhs, t2)
     897        get(m_lhs, t0)
    898898        loadConstantOrVariable(size, t2, t3, t1)
    899899        loadConstantOrVariable2Reg(size, t0, t2, t0)
    … …  
    908908
    909909    .jumpTarget:
    910         jump(target)
     910        jump(m_target)
    911911
    912912    .slow:
    … …  
    935935macro preOp(name, op, operation)
    936936    llintOp(op_%name%, op, macro (size, get, dispatch)
    937         get(srcDst, t0)
     937        get(m_srcDst, t0)
    938938        bineq TagOffset[cfr, t0, 8], Int32Tag, .slow
    939939        loadi PayloadOffset[cfr, t0, 8], t1
    … …  
    950950
    951951llintOpWithProfile(op_to_number, OpToNumber, macro (size, get, dispatch, return)
    952     get(operand, t0)
     952    get(m_operand, t0)
    953953    loadConstantOrVariable(size, t0, t2, t3)
    954954    bieq t2, Int32Tag, .opToNumberIsInt
    … …  
    964964
    965965llintOpWithReturn(op_to_string, OpToString, macro (size, get, dispatch, return)
    966     get(operand, t0)
     966    get(m_operand, t0)
    967967    loadConstantOrVariable(size, t0, t2, t3)
    968968    bineq t2, CellTag, .opToStringSlow
    … …  
    978978
    979979llintOpWithProfile(op_to_object, OpToObject, macro (size, get, dispatch, return)
    980     get(operand, t0)
     980    get(m_operand, t0)
    981981    loadConstantOrVariable(size, t0, t2, t3)
    982982    bineq t2, CellTag, .opToObjectSlow
    … …  
    993993
    994994    macro arithProfile(type)
    995         ori type, OpNegate::Metadata::arithProfile[t5]
     995        ori type, OpNegate::Metadata::m_arithProfile[t5]
    996996    end
    997997
    998998    metadata(t5, t0)
    999     get(operand, t0)
     999    get(m_operand, t0)
    10001000    loadConstantOrVariable(size, t0, t1, t2)
    10011001    bineq t1, Int32Tag, .opNegateSrcNotInt
    … …  
    10191019    llintOpWithMetadata(op_%name%, op, macro (size, get, dispatch, metadata, return)
    10201020        macro arithProfile(type)
    1021             ori type, %op%::Metadata::arithProfile[t5]
     1021            ori type, %op%::Metadata::m_arithProfile[t5]
    10221022        end
    10231023
    10241024        metadata(t5, t2)
    1025         get(rhs, t2)
    1026         get(lhs, t0)
     1025        get(m_rhs, t2)
     1026        get(m_lhs, t0)
    10271027        loadConstantOrVariable(size, t2, t3, t1)
    10281028        loadConstantOrVariable2Reg(size, t0, t2, t0)
    … …  
    10301030        bineq t3, Int32Tag, .op2NotInt
    10311031        arithProfile(ArithProfileIntInt)
    1032         get(dst, t2)
     1032        get(m_dst, t2)
    10331033        integerOperationAndStore(t3, t1, t0, .slow, t2)
    10341034        dispatch()
    … …  
    10461046        arithProfile(ArithProfileNumberNumber)
    10471047    .op1NotIntReady:
    1048         get(dst, t1)
     1048        get(m_dst, t1)
    10491049        fii2d t0, t2, ft0
    10501050        doubleOperation(ft1, ft0)
    … …  
    10541054    .op2NotInt:
    10551055        # First operand is definitely an int, the second operand is definitely not.
    1056         get(dst, t2)
     1056        get(m_dst, t2)
    10571057        bia t3, LowestTag, .slow
    10581058        arithProfile(ArithProfileIntNumber)
    … …  
    11211121
    11221122llintOpWithReturn(op_unsigned, OpUnsigned, macro (size, get, dispatch, return)
    1123     get(operand, t1)
     1123    get(m_operand, t1)
    11241124    loadConstantOrVariablePayload(size, t1, Int32Tag, t2, .opUnsignedSlow)
    11251125    bilt t2, 0, .opUnsignedSlow
    … …  
    11331133macro commonBitOp(opKind, name, op, operation)
    11341134    opKind(op_%name%, op, macro (size, get, dispatch, return)
    1135         get(rhs, t2)
    1136         get(lhs, t0)
     1135        get(m_rhs, t2)
     1136        get(m_lhs, t0)
    11371137        loadConstantOrVariable(size, t2, t3, t1)
    11381138        loadConstantOrVariable2Reg(size, t0, t2, t0)
    … …  
    11781178
    11791179llintOpWithProfile(op_bitnot, OpBitnot, macro (size, get, dispatch, return)
    1180     get(operand, t0)
     1180    get(m_operand, t0)
    11811181    loadConstantOrVariable(size, t0, t2, t3)
    11821182    bineq t2, Int32Tag, .opBitNotSlow
    … …  
    11901190
    11911191llintOp(op_overrides_has_instance, OpOverridesHasInstance, macro (size, get, dispatch)
    1192     get(dst, t3)
     1192    get(m_dst, t3)
    11931193    storei BooleanTag, TagOffset[cfr, t3, 8]
    11941194
    11951195    # First check if hasInstanceValue is the one on Function.prototype[Symbol.hasInstance]
    1196     get(hasInstanceValue, t0)
     1196    get(m_hasInstanceValue, t0)
    11971197    loadConstantOrVariablePayload(size, t0, CellTag, t2, .opOverrideshasInstanceValueNotCell)
    11981198    loadConstantOrVariable(size, t0, t1, t2)
    … …  
    12061206
    12071207    # We know the constructor is a cell.
    1208     get(constructor, t0)
     1208    get(m_constructor, t0)
    12091209    loadConstantOrVariablePayloadUnchecked(size, t0, t1)
    12101210    tbz JSCell::m_flags[t1], ImplementsDefaultHasInstance, t0
    … …  
    12201220
    12211221llintOpWithReturn(op_is_empty, OpIsEmpty, macro (size, get, dispatch, return)
    1222     get(operand, t1)
     1222    get(m_operand, t1)
    12231223    loadConstantOrVariable(size, t1, t2, t3)
    12241224    cieq t2, EmptyValueTag, t3
    … …  
    12281228
    12291229llintOpWithReturn(op_is_undefined, OpIsUndefined, macro (size, get, dispatch, return)
    1230     get(operand, t1)
     1230    get(m_operand, t1)
    12311231    loadConstantOrVariable(size, t1, t2, t3)
    12321232    bieq t2, CellTag, .opIsUndefinedCell
    … …  
    12461246
    12471247llintOpWithReturn(op_is_boolean, OpIsBoolean, macro (size, get, dispatch, return)
    1248     get(operand, t1)
     1248    get(m_operand, t1)
    12491249    loadConstantOrVariableTag(size, t1, t0)
    12501250    cieq t0, BooleanTag, t0
    … …  
    12541254
    12551255llintOpWithReturn(op_is_number, OpIsNumber, macro (size, get, dispatch, return)
    1256     get(operand, t1)
     1256    get(m_operand, t1)
    12571257    loadConstantOrVariableTag(size, t1, t0)
    12581258    addi 1, t0
    … …  
    12631263
    12641264llintOpWithReturn(op_is_cell_with_type, OpIsCellWithType, macro (size, get, dispatch, return)
    1265     get(operand, t1)
     1265    get(m_operand, t1)
    12661266    loadConstantOrVariable(size, t1, t0, t3)
    12671267    bineq t0, CellTag, .notCellCase
    1268     getu(size, OpIsCellWithType, type, t0)
     1268    getu(size, OpIsCellWithType, m_type, t0)
    12691269    cbeq JSCell::m_type[t3], t0, t1
    12701270    return(BooleanTag, t1)
    … …  
    12751275
    12761276llintOpWithReturn(op_is_object, OpIsObject, macro (size, get, dispatch, return)
    1277     get(operand, t1)
     1277    get(m_operand, t1)
    12781278    loadConstantOrVariable(size, t1, t0, t3)
    12791279    bineq t0, CellTag, .opIsObjectNotCell
    … …  
    13281328llintOpWithMetadata(op_get_by_id_direct, OpGetByIdDirect, macro (size, get, dispatch, metadata, return)
    13291329    metadata(t5, t0)
    1330     get(base, t0)
    1331     loadi OpGetByIdDirect::Metadata::structure[t5], t1
     1330    get(m_base, t0)
     1331    loadi OpGetByIdDirect::Metadata::m_structure[t5], t1
    13321332    loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdDirectSlow)
    1333     loadi OpGetByIdDirect::Metadata::offset[t5], t2
     1333    loadi OpGetByIdDirect::Metadata::m_offset[t5], t2
    13341334    bineq JSCell::m_structureID[t3], t1, .opGetByIdDirectSlow
    13351335    loadPropertyAtVariableOffset(t2, t3, t0, t1)
    … …  
    13451345llintOpWithMetadata(op_get_by_id, OpGetById, macro (size, get, dispatch, metadata, return)
    13461346    metadata(t5, t0)
    1347     loadb OpGetById::Metadata::mode[t5], t1
    1348     get(base, t0)
     1347    loadb OpGetById::Metadata::m_mode[t5], t1
     1348    get(m_base, t0)
    13491349
    13501350.opGetByIdProtoLoad:
    13511351    bbneq t1, constexpr GetByIdMode::ProtoLoad, .opGetByIdArrayLength
    1352     loadi OpGetById::Metadata::modeMetadata.protoLoadMode.structure[t5], t1
     1352    loadi OpGetById::Metadata::m_modeMetadata.protoLoadMode.structure[t5], t1
    13531353    loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
    1354     loadis OpGetById::Metadata::modeMetadata.protoLoadMode.cachedOffset[t5], t2
     1354    loadis OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedOffset[t5], t2
    13551355    bineq JSCell::m_structureID[t3], t1, .opGetByIdSlow
    1356     loadp OpGetById::Metadata::modeMetadata.protoLoadMode.cachedSlot[t5], t3
     1356    loadp OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedSlot[t5], t3
    13571357    loadPropertyAtVariableOffset(t2, t3, t0, t1)
    13581358    valueProfile(OpGetById, t5, t0, t1)
    … …  
    13631363    loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
    13641364    move t3, t2
    1365     arrayProfile(OpGetById::Metadata::modeMetadata.arrayLengthMode.arrayProfile, t2, t5, t0)
     1365    arrayProfile(OpGetById::Metadata::m_modeMetadata.arrayLengthMode.arrayProfile, t2, t5, t0)
    13661366    btiz t2, IsArray, .opGetByIdSlow
    13671367    btiz t2, IndexingShapeMask, .opGetByIdSlow
    … …  
    13741374.opGetByIdUnset:
    13751375    bbneq t1, constexpr GetByIdMode::Unset, .opGetByIdDefault
    1376     loadi OpGetById::Metadata::modeMetadata.unsetMode.structure[t5], t1
     1376    loadi OpGetById::Metadata::m_modeMetadata.unsetMode.structure[t5], t1
    13771377    loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
    13781378    bineq JSCell::m_structureID[t3], t1, .opGetByIdSlow
    … …  
    13811381
    13821382.opGetByIdDefault:
    1383     loadi OpGetById::Metadata::modeMetadata.defaultMode.structure[t5], t1
     1383    loadi OpGetById::Metadata::m_modeMetadata.defaultMode.structure[t5], t1
    13841384    loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetByIdSlow)
    1385     loadis OpGetById::Metadata::modeMetadata.defaultMode.cachedOffset[t5], t2
     1385    loadis OpGetById::Metadata::m_modeMetadata.defaultMode.cachedOffset[t5], t2
    13861386    bineq JSCell::m_structureID[t3], t1, .opGetByIdSlow
    13871387    loadPropertyAtVariableOffset(t2, t3, t0, t1)
    … …  
    13961396
    13971397llintOpWithMetadata(op_put_by_id, OpPutById, macro (size, get, dispatch, metadata, return)
    1398     writeBarrierOnOperands(size, get, base, value)
     1398    writeBarrierOnOperands(size, get, m_base, m_value)
    13991399    metadata(t5, t3)
    1400     get(base, t3)
     1400    get(m_base, t3)
    14011401    loadConstantOrVariablePayload(size, t3, CellTag, t0, .opPutByIdSlow)
    14021402    loadi JSCell::m_structureID[t0], t2
    1403     bineq t2, OpPutById::Metadata::oldStructure[t5], .opPutByIdSlow
     1403    bineq t2, OpPutById::Metadata::m_oldStructure[t5], .opPutByIdSlow
    14041404
    14051405    # At this point, we have:
    … …  
    14091409    # We will lose currentStructureID in the shenanigans below.
    14101410
    1411     loadi OpPutById::Metadata::newStructure[t5], t1
     1411    loadi OpPutById::Metadata::m_newStructure[t5], t1
    14121412
    14131413    btiz t1, .opPutByIdNotTransition
    … …  
    14151415    # This is the transition case. t1 holds the new Structure*. If we have a chain, we need to
    14161416    # check it. t0 is the base. We may clobber t1 to use it as scratch.
    1417     loadp OpPutById::Metadata::structureChain[t5], t3
     1417    loadp OpPutById::Metadata::m_structureChain[t5], t3
    14181418    btpz t3, .opPutByIdTransitionDirect
    14191419
    1420     loadi OpPutById::Metadata::oldStructure[t5], t2 # Need old structure again.
     1420    loadi OpPutById::Metadata::m_oldStructure[t5], t2 # Need old structure again.
    14211421    loadp StructureChain::m_vector[t3], t3
    14221422    assert(macro (ok) btpnz t3, ok end)
    … …  
    14321432
    14331433.opPutByIdTransitionChainDone:
    1434     loadi OpPutById::Metadata::newStructure[t5], t1
     1434    loadi OpPutById::Metadata::m_newStructure[t5], t1
    14351435
    14361436.opPutByIdTransitionDirect:
    14371437    storei t1, JSCell::m_structureID[t0]
    1438     get(value, t1)
     1438    get(m_value, t1)
    14391439    loadConstantOrVariable(size, t1, t2, t3)
    1440     loadi OpPutById::Metadata::offset[t5], t1
     1440    loadi OpPutById::Metadata::m_offset[t5], t1
    14411441    storePropertyAtVariableOffset(t1, t0, t2, t3)
    1442     writeBarrierOnOperand(size, get, base)
     1442    writeBarrierOnOperand(size, get, m_base)
    14431443    dispatch()
    14441444
    14451445.opPutByIdNotTransition:
    14461446    # The only thing live right now is t0, which holds the base.
    1447     get(value, t1)
     1447    get(m_value, t1)
    14481448    loadConstantOrVariable(size, t1, t2, t3)
    1449     loadi OpPutById::Metadata::offset[t5], t1
     1449    loadi OpPutById::Metadata::m_offset[t5], t1
    14501450    storePropertyAtVariableOffset(t1, t0, t2, t3)
    14511451    dispatch()
    … …  
    14591459llintOpWithMetadata(op_get_by_val, OpGetByVal, macro (size, get, dispatch, metadata, return)
    14601460    metadata(t5, t2)
    1461     get(base, t2)
     1461    get(m_base, t2)
    14621462    loadConstantOrVariablePayload(size, t2, CellTag, t0, .opGetByValSlow)
    14631463    move t0, t2
    1464     arrayProfile(OpGetByVal::Metadata::arrayProfile, t2, t5, t1)
    1465     get(property, t3)
     1464    arrayProfile(OpGetByVal::Metadata::m_arrayProfile, t2, t5, t1)
     1465    get(m_property, t3)
    14661466    loadConstantOrVariablePayload(size, t3, Int32Tag, t1, .opGetByValSlow)
    14671467    loadp JSObject::m_butterfly[t0], t3
    … …  
    14831483    # FIXME: This could be massively optimized.
    14841484    fd2ii ft0, t1, t2
    1485     get(dst, t0)
     1485    get(m_dst, t0)
    14861486    jmp .opGetByValNotEmpty
    14871487
    … …  
    14941494
    14951495.opGetByValDone:
    1496     get(dst, t0)
     1496    get(m_dst, t0)
    14971497    bieq t2, EmptyValueTag, .opGetByValSlow
    14981498.opGetByValNotEmpty:
    … …  
    15131513            biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .outOfBounds
    15141514        .storeResult:
    1515             get(value, t2)
     1515            get(m_value, t2)
    15161516            storeCallback(t2, t1, t0, t3)
    15171517            dispatch()
    … …  
    15191519        .outOfBounds:
    15201520            biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t0], .opPutByValOutOfBounds
    1521             storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
     1521            storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
    15221522            addi 1, t3, t2
    15231523            storei t2, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0]
    … …  
    15251525        end
    15261526
    1527         writeBarrierOnOperands(size, get, base, value)
     1527        writeBarrierOnOperands(size, get, m_base, m_value)
    15281528        metadata(t5, t0)
    1529         get(base, t0)
     1529        get(m_base, t0)
    15301530        loadConstantOrVariablePayload(size, t0, CellTag, t1, .opPutByValSlow)
    15311531        move t1, t2
    1532         arrayProfile(%op%::Metadata::arrayProfile, t2, t5, t0)
    1533         get(property, t0)
     1532        arrayProfile(%op%::Metadata::m_arrayProfile, t2, t5, t0)
     1533        get(m_property, t0)
    15341534        loadConstantOrVariablePayload(size, t0, Int32Tag, t3, .opPutByValSlow)
    15351535        loadp JSObject::m_butterfly[t1], t0
    … …  
    15771577        bieq ArrayStorage::m_vector + TagOffset[t0, t3, 8], EmptyValueTag, .opPutByValArrayStorageEmpty
    15781578    .opPutByValArrayStorageStoreResult:
    1579         get(value, t2)
     1579        get(m_value, t2)
    15801580        loadConstantOrVariable2Reg(size, t2, t1, t2)
    15811581        storei t1, ArrayStorage::m_vector + TagOffset[t0, t3, 8]
    … …  
    15841584
    15851585    .opPutByValArrayStorageEmpty:
    1586         storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
     1586        storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
    15871587        addi 1, ArrayStorage::m_numValuesInVector[t0]
    15881588        bib t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .opPutByValArrayStorageStoreResult
    … …  
    15921592
    15931593    .opPutByValOutOfBounds:
    1594         storeb 1, %op%::Metadata::arrayProfile.m_outOfBounds[t5]
     1594        storeb 1, %op%::Metadata::m_arrayProfile.m_outOfBounds[t5]
    15951595    .opPutByValSlow:
    15961596        callSlowPath(_llint_slow_path_%name%)
    … …  
    16071607macro llintJumpTrueOrFalseOp(name, op, conditionOp)
    16081608    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1609         get(condition, t1)
     1609        get(m_condition, t1)
    16101610        loadConstantOrVariablePayload(size, t1, BooleanTag, t0, .slow)
    16111611        conditionOp(t0, .target)
    … …  
    16131613
    16141614    .target:
    1615         jump(target)
     1615        jump(m_target)
    16161616
    16171617    .slow:
    … …  
    16241624macro equalNullJumpOp(name, op, cellHandler, immediateHandler)
    16251625    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1626         get(value, t0)
     1626        get(m_value, t0)
    16271627        assertNotConstant(size, t0)
    16281628        loadi TagOffset[cfr, t0, 8], t1
    … …  
    16341634
    16351635    .target:
    1636         jump(target)
     1636        jump(m_target)
    16371637
    16381638    .immediate:
    … …  
    16651665
    16661666llintOpWithMetadata(op_jneq_ptr, OpJneqPtr, macro (size, get, dispatch, metadata, return)
    1667     get(value, t0)
    1668     get(specialPointer, t1)
     1667    get(m_value, t0)
     1668    get(m_specialPointer, t1)
    16691669    loadp CodeBlock[cfr], t2
    16701670    loadp CodeBlock::m_globalObject[t2], t2
    … …  
    16741674.opJneqPtrBranch:
    16751675    metadata(t5, t2)
    1676     storeb 1, OpJneqPtr::Metadata::hasJumped[t5]
    1677     get(target, t0)
     1676    storeb 1, OpJneqPtr::Metadata::m_hasJumped[t5]
     1677    get(m_target, t0)
    16781678    jumpImpl(t0)
    16791679.opJneqPtrFallThrough:
    … …  
    16841684macro compareUnsignedJumpOp(name, op, integerCompare)
    16851685    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1686         get(lhs, t2)
    1687         get(rhs, t3)
     1686        get(m_lhs, t2)
     1687        get(m_rhs, t3)
    16881688        loadConstantOrVariable(size, t2, t0, t1)
    16891689        loadConstantOrVariable2Reg(size, t3, t2, t3)
    … …  
    16921692
    16931693    .jumpTarget:
    1694         jump(target)
     1694        jump(m_target)
    16951695    end)
    16961696end
    … …  
    16991699macro compareUnsignedOp(name, op, integerCompareAndSet)
    17001700    llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
    1701         get(rhs, t2)
    1702         get(lhs, t0)
     1701        get(m_rhs, t2)
     1702        get(m_lhs, t0)
    17031703        loadConstantOrVariable(size, t2, t3, t1)
    17041704        loadConstantOrVariable2Reg(size, t0, t2, t0)
    … …  
    17111711macro compareJumpOp(name, op, integerCompare, doubleCompare)
    17121712    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1713         get(lhs, t2)
    1714         get(rhs, t3)
     1713        get(m_lhs, t2)
     1714        get(m_rhs, t3)
    17151715        loadConstantOrVariable(size, t2, t0, t1)
    17161716        loadConstantOrVariable2Reg(size, t3, t2, t3)
    … …  
    17411741
    17421742    .jumpTarget:
    1743         jump(target)
     1743        jump(m_target)
    17441744
    17451745    .slow:
    … …  
    17511751
    17521752llintOpWithJump(op_switch_imm, OpSwitchImm, macro (size, get, jump, dispatch)
    1753     get(scrutinee, t2)
    1754     get(tableIndex, t3)
     1753    get(m_scrutinee, t2)
     1754    get(m_tableIndex, t3)
    17551755    loadConstantOrVariable(size, t2, t1, t0)
    17561756    loadp CodeBlock[cfr], t2
    … …  
    17701770    bib t1, LowestTag, .opSwitchImmSlow  # Go to slow path if it's a double.
    17711771.opSwitchImmFallThrough:
    1772     jump(defaultOffset)
     1772    jump(m_defaultOffset)
    17731773
    17741774.opSwitchImmSlow:
    … …  
    17791779
    17801780llintOpWithJump(op_switch_char, OpSwitchChar, macro (size, get, jump, dispatch)
    1781     get(scrutinee, t2)
    1782     get(tableIndex, t3)
     1781    get(m_scrutinee, t2)
     1782    get(m_tableIndex, t3)
    17831783    loadConstantOrVariable(size, t2, t1, t0)
    17841784    loadp CodeBlock[cfr], t2
    … …  
    18071807
    18081808.opSwitchCharFallThrough:
    1809     jump(defaultOffset)
     1809    jump(m_defaultOffset)
    18101810
    18111811.opSwitchOnRope:
    … …  
    18161816
    18171817macro arrayProfileForCall(op, getu)
    1818     getu(argv, t3)
     1818    getu(m_argv, t3)
    18191819    negi t3
    18201820    bineq ThisArgumentOffset + TagOffset[cfr, t3, 8], CellTag, .done
    18211821    loadi ThisArgumentOffset + PayloadOffset[cfr, t3, 8], t0
    18221822    loadp JSCell::m_structureID[t0], t0
    1823     storep t0, %op%::Metadata::arrayProfile.m_lastSeenStructureID[t5]
     1823    storep t0, %op%::Metadata::m_arrayProfile.m_lastSeenStructureID[t5]
    18241824.done:
    18251825end
    … …  
    18291829        metadata(t5, t0)
    18301830
    1831         prologue(macro (field, dst)
    1832             getu(size, op, field, dst)
     1831        prologue(macro (fieldName, dst)
     1832            getu(size, op, fieldName, dst)
    18331833        end, metadata)
    18341834
    1835         get(callee, t0)
    1836         loadp %op%::Metadata::callLinkInfo.callee[t5], t2
     1835        get(m_callee, t0)
     1836        loadp %op%::Metadata::m_callLinkInfo.callee[t5], t2
    18371837        loadConstantOrVariablePayload(size, t0, CellTag, t3, .opCallSlow)
    18381838        bineq t3, t2, .opCallSlow
    1839         getu(size, op, argv, t3)
     1839        getu(size, op, m_argv, t3)
    18401840        lshifti 3, t3
    18411841        negi t3
    18421842        addp cfr, t3  # t3 contains the new value of cfr
    18431843        storei t2, Callee + PayloadOffset[t3]
    1844         getu(size, op, argc, t2)
     1844        getu(size, op, m_argc, t2)
    18451845        storei PC, ArgumentCount + TagOffset[cfr]
    18461846        storei t2, ArgumentCount + PayloadOffset[t3]
    18471847        storei CellTag, Callee + TagOffset[t3]
    18481848        move t3, sp
    1849         prepareCall(%op%::Metadata::callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
    1850         callTargetFunction(size, op, dispatch, %op%::Metadata::callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
     1849        prepareCall(%op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
     1850        callTargetFunction(size, op, dispatch, %op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
    18511851
    18521852    .opCallSlow:
    … …  
    18571857llintOp(op_ret, OpRet, macro (size, get, dispatch)
    18581858    checkSwitchToJITForEpilogue()
    1859     get(value, t2)
     1859    get(m_value, t2)
    18601860    loadConstantOrVariable(size, t2, t1, t0)
    18611861    doReturn()
    … …  
    18641864
    18651865llintOpWithReturn(op_to_primitive, OpToPrimitive, macro (size, get, dispatch, return)
    1866     get(src, t2)
     1866    get(m_src, t2)
    18671867    loadConstantOrVariable(size, t2, t1, t0)
    18681868    bineq t1, CellTag, .opToPrimitiveIsImm
    … …  
    19081908    loadi VM::m_exception[t3], t0
    19091909    storei 0, VM::m_exception[t3]
    1910     get(size, OpCatch, exception, t2)
     1910    get(size, OpCatch, m_exception, t2)
    19111911    storei t0, PayloadOffset[cfr, t2, 8]
    19121912    storei CellTag, TagOffset[cfr, t2, 8]
    … …  
    19141914    loadi Exception::m_value + TagOffset[t0], t1
    19151915    loadi Exception::m_value + PayloadOffset[t0], t0
    1916     get(size, OpCatch, thrownValue, t2)
     1916    get(size, OpCatch, m_thrownValue, t2)
    19171917    storei t0, PayloadOffset[cfr, t2, 8]
    19181918    storei t1, TagOffset[cfr, t2, 8]
    … …  
    19271927llintOp(op_end, OpEnd, macro (size, get, dispatch)
    19281928    checkSwitchToJITForEpilogue()
    1929     get(value, t0)
     1929    get(m_value, t0)
    19301930    assertNotConstant(size, t0)
    19311931    loadi TagOffset[cfr, t0, 8], t1
    … …  
    20942094
    20952095    macro getConstantScope()
    2096         loadp OpResolveScope::Metadata::constantScope[t5],  t0
     2096        loadp OpResolveScope::Metadata::m_constantScope[t5],  t0
    20972097        return(CellTag, t0)
    20982098    end
    20992099
    21002100    macro resolveScope()
    2101         loadi OpResolveScope::Metadata::localScopeDepth[t5], t2
    2102         get(scope, t0)
     2101        loadi OpResolveScope::Metadata::m_localScopeDepth[t5], t2
     2102        get(m_scope, t0)
    21032103        loadp PayloadOffset[cfr, t0, 8], t0
    21042104        btiz t2, .resolveScopeLoopEnd
    … …  
    21142114
    21152115    metadata(t5, t0)
    2116     loadp OpResolveScope::Metadata::resolveType[t5], t0
     2116    loadp OpResolveScope::Metadata::m_resolveType[t5], t0
    21172117
    21182118#rGlobalProperty:
    … …  
    21632163
    21642164macro loadWithStructureCheck(op, get, operand, slowPath)
    2165     get(scope, t0)
     2165    get(m_scope, t0)
    21662166    loadp PayloadOffset[cfr, t0, 8], t0
    2167     loadp %op%::Metadata::structure[t5], t1
     2167    loadp %op%::Metadata::m_structure[t5], t1
    21682168    bpneq JSCell::m_structureID[t0], t1, slowPath
    21692169end
    … …  
    21722172llintOpWithMetadata(op_get_from_scope, OpGetFromScope, macro (size, get, dispatch, metadata, return)
    21732173    macro getProperty()
    2174         loadp OpGetFromScope::Metadata::operand[t5], t3
     2174        loadp OpGetFromScope::Metadata::m_operand[t5], t3
    21752175        loadPropertyAtVariableOffset(t3, t0, t1, t2)
    21762176        valueProfile(OpGetFromScope, t5, t1, t2)
    … …  
    21792179
    21802180    macro getGlobalVar(tdzCheckIfNecessary)
    2181         loadp OpGetFromScope::Metadata::operand[t5], t0
     2181        loadp OpGetFromScope::Metadata::m_operand[t5], t0
    21822182        loadp TagOffset[t0], t1
    21832183        loadp PayloadOffset[t0], t2
    … …  
    21882188
    21892189    macro getClosureVar()
    2190         loadp OpGetFromScope::Metadata::operand[t5], t3
     2190        loadp OpGetFromScope::Metadata::m_operand[t5], t3
    21912191        loadp JSLexicalEnvironment_variables + TagOffset[t0, t3, 8], t1
    21922192        loadp JSLexicalEnvironment_variables + PayloadOffset[t0, t3, 8], t2
    … …  
    21962196
    21972197    metadata(t5, t0)
    2198     loadi OpGetFromScope::Metadata::getPutInfo[t5], t0
     2198    loadi OpGetFromScope::Metadata::m_getPutInfo[t5], t0
    21992199    andi ResolveTypeMask, t0
    22002200
    … …  
    22172217.gClosureVar:
    22182218    bineq t0, ClosureVar, .gGlobalPropertyWithVarInjectionChecks
    2219     loadVariable(get, scope, t2, t1, t0)
     2219    loadVariable(get, m_scope, t2, t1, t0)
    22202220    getClosureVar()
    22212221
    … …  
    22412241    bineq t0, ClosureVarWithVarInjectionChecks, .gDynamic
    22422242    varInjectionCheck(.gDynamic)
    2243     loadVariable(get, scope, t2, t1, t0)
     2243    loadVariable(get, m_scope, t2, t1, t0)
    22442244    getClosureVar()
    22452245
    … …  
    22522252llintOpWithMetadata(op_put_to_scope, OpPutToScope, macro (size, get, dispatch, metadata, return)
    22532253    macro putProperty()
    2254         get(value, t1)
     2254        get(m_value, t1)
    22552255        loadConstantOrVariable(size, t1, t2, t3)
    2256         loadis OpPutToScope::Metadata::operand[t5], t1
     2256        loadis OpPutToScope::Metadata::m_operand[t5], t1
    22572257        storePropertyAtVariableOffset(t1, t0, t2, t3)
    22582258    end
    22592259
    22602260    macro putGlobalVariable()
    2261         get(value, t0)
     2261        get(m_value, t0)
    22622262        loadConstantOrVariable(size, t0, t1, t2)
    2263         loadp OpPutToScope::Metadata::watchpointSet[t5], t3
     2263        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t3
    22642264        notifyWrite(t3, .pDynamic)
    2265         loadp OpPutToScope::Metadata::operand[t5], t0
     2265        loadp OpPutToScope::Metadata::m_operand[t5], t0
    22662266        storei t1, TagOffset[t0]
    22672267        storei t2, PayloadOffset[t0]
    … …  
    22692269
    22702270    macro putClosureVar()
    2271         get(value, t1)
     2271        get(m_value, t1)
    22722272        loadConstantOrVariable(size, t1, t2, t3)
    2273         loadis OpPutToScope::Metadata::operand[t5], t1
     2273        loadis OpPutToScope::Metadata::m_operand[t5], t1
    22742274        storei t2, JSLexicalEnvironment_variables + TagOffset[t0, t1, 8]
    22752275        storei t3, JSLexicalEnvironment_variables + PayloadOffset[t0, t1, 8]
    … …  
    22772277
    22782278    macro putLocalClosureVar()
    2279         get(value, t1)
     2279        get(m_value, t1)
    22802280        loadConstantOrVariable(size, t1, t2, t3)
    2281         loadp OpPutToScope::Metadata::watchpointSet[t5], t1
     2281        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t1
    22822282        btpz t1, .noVariableWatchpointSet
    22832283        notifyWrite(t1, .pDynamic)
    22842284    .noVariableWatchpointSet:
    2285         loadis OpPutToScope::Metadata::operand[t5], t1
     2285        loadis OpPutToScope::Metadata::m_operand[t5], t1
    22862286        storei t2, JSLexicalEnvironment_variables + TagOffset[t0, t1, 8]
    22872287        storei t3, JSLexicalEnvironment_variables + PayloadOffset[t0, t1, 8]
    … …  
    22902290
    22912291    metadata(t5, t0)
    2292     loadi OpPutToScope::Metadata::getPutInfo[t5], t0
     2292    loadi OpPutToScope::Metadata::m_getPutInfo[t5], t0
    22932293    andi ResolveTypeMask, t0
    22942294
    22952295#pLocalClosureVar:
    22962296    bineq t0, LocalClosureVar, .pGlobalProperty
    2297     loadVariable(get, scope, t2, t1, t0)
     2297    loadVariable(get, m_scope, t2, t1, t0)
    22982298    putLocalClosureVar()
    2299     writeBarrierOnOperands(size, get, scope, value)
     2299    writeBarrierOnOperands(size, get, m_scope, m_value)
    23002300    dispatch()
    23012301
    … …  
    23042304    loadWithStructureCheck(OpPutToScope, get, scope, .pDynamic)
    23052305    putProperty()
    2306     writeBarrierOnOperands(size, get, scope, value)
     2306    writeBarrierOnOperands(size, get, m_scope, m_value)
    23072307    dispatch()
    23082308
    … …  
    23102310    bineq t0, GlobalVar, .pGlobalLexicalVar
    23112311    putGlobalVariable()
    2312     writeBarrierOnGlobalObject(size, get, value)
     2312    writeBarrierOnGlobalObject(size, get, m_value)
    23132313    dispatch()
    23142314
    … …  
    23162316    bineq t0, GlobalLexicalVar, .pClosureVar
    23172317    putGlobalVariable()
    2318     writeBarrierOnGlobalLexicalEnvironment(size, get, value)
     2318    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
    23192319    dispatch()
    23202320
    23212321.pClosureVar:
    23222322    bineq t0, ClosureVar, .pGlobalPropertyWithVarInjectionChecks
    2323     loadVariable(get, scope, t2, t1, t0)
     2323    loadVariable(get, m_scope, t2, t1, t0)
    23242324    putClosureVar()
    2325     writeBarrierOnOperands(size, get, scope, value)
     2325    writeBarrierOnOperands(size, get, m_scope, m_value)
    23262326    dispatch()
    23272327
    … …  
    23302330    loadWithStructureCheck(OpPutToScope, get, scope, .pDynamic)
    23312331    putProperty()
    2332     writeBarrierOnOperands(size, get, scope, value)
     2332    writeBarrierOnOperands(size, get, m_scope, m_value)
    23332333    dispatch()
    23342334
    … …  
    23372337    varInjectionCheck(.pDynamic)
    23382338    putGlobalVariable()
    2339     writeBarrierOnGlobalObject(size, get, value)
     2339    writeBarrierOnGlobalObject(size, get, m_value)
    23402340    dispatch()
    23412341
    … …  
    23442344    varInjectionCheck(.pDynamic)
    23452345    putGlobalVariable()
    2346     writeBarrierOnGlobalLexicalEnvironment(size, get, value)
     2346    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
    23472347    dispatch()
    23482348
    … …  
    23502350    bineq t0, ClosureVarWithVarInjectionChecks, .pModuleVar
    23512351    varInjectionCheck(.pDynamic)
    2352     loadVariable(get, scope, t2, t1, t0)
     2352    loadVariable(get, m_scope, t2, t1, t0)
    23532353    putClosureVar()
    2354     writeBarrierOnOperands(size, get, scope, value)
     2354    writeBarrierOnOperands(size, get, m_scope, m_value)
    23552355    dispatch()
    23562356
    … …  
    23672367
    23682368llintOpWithProfile(op_get_from_arguments, OpGetFromArguments, macro (size, get, dispatch, return)
    2369     get(arguments, t0)
     2369    get(m_arguments, t0)
    23702370    loadi PayloadOffset[cfr, t0, 8], t0
    2371     get(index, t1)
     2371    get(m_index, t1)
    23722372    loadi DirectArguments_storage + TagOffset[t0, t1, 8], t2
    23732373    loadi DirectArguments_storage + PayloadOffset[t0, t1, 8], t3
    … …  
    23772377
    23782378llintOp(op_put_to_arguments, OpPutToArguments, macro (size, get, dispatch)
    2379     writeBarrierOnOperands(size, get, arguments, value)
    2380     get(arguments, t0)
     2379    writeBarrierOnOperands(size, get, m_arguments, m_value)
     2380    get(m_arguments, t0)
    23812381    loadi PayloadOffset[cfr, t0, 8], t0
    2382     get(value, t1)
     2382    get(m_value, t1)
    23832383    loadConstantOrVariable(size, t1, t2, t3)
    2384     get(index, t1)
     2384    get(m_index, t1)
    23852385    storei t2, DirectArguments_storage + TagOffset[t0, t1, 8]
    23862386    storei t3, DirectArguments_storage + PayloadOffset[t0, t1, 8]
    … …  
    23902390
    23912391llintOpWithReturn(op_get_parent_scope, OpGetParentScope, macro (size, get, dispatch, return)
    2392     get(scope, t0)
     2392    get(m_scope, t0)
    23932393    loadp PayloadOffset[cfr, t0, 8], t0
    23942394    loadp JSScope::m_next[t0], t0
    … …  
    24052405
    24062406    # t0 is holding the payload, t5 is holding the tag.
    2407     get(target, t2)
     2407    get(m_target, t2)
    24082408    loadConstantOrVariable(size, t2, t5, t0)
    24092409
    … …  
    24192419
    24202420    # Store the TypeLocation onto the log entry.
    2421     loadp OpProfileType::Metadata::typeLocation[t3], t3
     2421    loadp OpProfileType::Metadata::m_typeLocation[t3], t3
    24222422    storep t3, TypeProfilerLog::LogEntry::location[t2]
    24232423
    … …  
    24452445llintOpWithMetadata(op_profile_control_flow, OpProfileControlFlow, macro (size, get, dispatch, metadata, return)
    24462446    metadata(t5, t0)
    2447     loadp OpProfileControlFlow::Metadata::basicBlockLocation[t5], t0
     2447    loadp OpProfileControlFlow::Metadata::m_basicBlockLocation[t5], t0
    24482448    loadi BasicBlockLocation::m_executionCount[t0], t1
    24492449    baddio 1, t1, .done
    … …  
    24572457    loadi PayloadOffset + ArgumentCount[cfr], t0
    24582458    subi 1, t0
    2459     get(numParametersToSkip, t1)
     2459    get(m_numParametersToSkip, t1)
    24602460    bilteq t0, t1, .storeZero
    24612461    subi t1, t0
    … …  
    24752475    loadp Callee + PayloadOffset[cfr], t1
    24762476    storep t1, ShadowChicken::Packet::callee[t0]
    2477     get(scope, t1)
     2477    get(m_scope, t1)
    24782478    loadi PayloadOffset[cfr, t1, 8], t1
    24792479    storep t1, ShadowChicken::Packet::scope[t0]
    … …  
    24892489    storep cfr, ShadowChicken::Packet::frame[t0]
    24902490    storep ShadowChickenTailMarker, ShadowChicken::Packet::callee[t0]
    2491     loadVariable(get, thisValue, t3, t2, t1)
     2491    loadVariable(get, m_thisValue, t3, t2, t1)
    24922492    storei t2, TagOffset + ShadowChicken::Packet::thisValue[t0]
    24932493    storei t1, PayloadOffset + ShadowChicken::Packet::thisValue[t0]
    2494     get(scope, t1)
     2494    get(m_scope, t1)
    24952495    loadi PayloadOffset[cfr, t1, 8], t1
    24962496    storep t1, ShadowChicken::Packet::scope[t0]

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

    r240023 r240041  
    1 
    2 # Copyright (C) 2011-2018 Apple Inc. All rights reserved.
     1# Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    32#
    43# Redistribution and use in source and binary forms, with or without
    … …  
    3837end
    3938
    40 macro getuOperandNarrow(op, field, dst)
    41     loadb constexpr %op%_%field%_index[PB, PC, 1], dst
    42 end
    43 
    44 macro getOperandNarrow(op, field, dst)
    45     loadbsp constexpr %op%_%field%_index[PB, PC, 1], dst
    46 end
    47 
    48 macro getuOperandWide(op, field, dst)
    49     loadi constexpr %op%_%field%_index * 4 + 1[PB, PC, 1], dst
    50 end
    51 
    52 macro getOperandWide(op, field, dst)
    53     loadis constexpr %op%_%field%_index * 4 + 1[PB, PC, 1], dst
     39macro getuOperandNarrow(op, fieldName, dst)
     40    loadb constexpr %op%_%fieldName%_index[PB, PC, 1], dst
     41end
     42
     43macro getOperandNarrow(op, fieldName, dst)
     44    loadbsp constexpr %op%_%fieldName%_index[PB, PC, 1], dst
     45end
     46
     47macro getuOperandWide(op, fieldName, dst)
     48    loadi constexpr %op%_%fieldName%_index * 4 + 1[PB, PC, 1], dst
     49end
     50
     51macro getOperandWide(op, fieldName, dst)
     52    loadis constexpr %op%_%fieldName%_index * 4 + 1[PB, PC, 1], dst
    5453end
    5554
    … …  
    5756    fn(macro (value)
    5857        move value, t2
    59         get(dst, t1)
     58        get(m_dst, t1)
    6059        storeq t2, [cfr, t1, 8]
    6160        dispatch()
    … …  
    6867        metadata(t1, t2)
    6968        valueProfile(op, t1, t3)
    70         get(dst, t1)
     69        get(m_dst, t1)
    7170        storeq t3, [cfr, t1, 8]
    7271        dispatch()
    … …  
    7574
    7675macro valueProfile(op, metadata, value)
    77     storeq value, %op%::Metadata::profile.m_buckets[metadata]
     76    storeq value, %op%::Metadata::m_profile.m_buckets[metadata]
    7877end
    7978
    … …  
    8382    loadp CodeBlock::m_instructionsRawPointer[PB], PB
    8483    unpoison(_g_CodeBlockPoison, PB, t1)
    85     get(size, op, dst, t1)
     84    get(size, op, m_dst, t1)
    8685    storeq r0, [cfr, t1, 8]
    8786    metadata(size, op, t2, t1)
    … …  
    426425end
    427426
    428 macro loadVariable(get, field, value)
    429     get(field, value)
    430     loadq [cfr, value, 8], value
     427macro loadVariable(get, fieldName, valueReg)
     428    get(fieldName, valueReg)
     429    loadq [cfr, valueReg, 8], valueReg
    431430end
    432431
    … …  
    469468end
    470469
    471 macro writeBarrierOnOperandWithReload(size, get, cellOperand, reloadAfterSlowPath)
    472     get(cellOperand, t1)
     470macro writeBarrierOnOperandWithReload(size, get, cellFieldName, reloadAfterSlowPath)
     471    get(cellFieldName, t1)
    473472    loadConstantOrVariableCell(size, t1, t2, .writeBarrierDone)
    474473    skipIfIsRememberedOrInEden(
    … …  
    485484end
    486485
    487 macro writeBarrierOnOperand(size, get, cellOperand)
    488     writeBarrierOnOperandWithReload(size, get, cellOperand, macro () end)
    489 end
    490 
    491 macro writeBarrierOnOperands(size, get, cellOperand, valueOperand)
    492     get(valueOperand, t1)
     486macro writeBarrierOnOperand(size, get, cellFieldName)
     487    writeBarrierOnOperandWithReload(size, get, cellFieldName, macro () end)
     488end
     489
     490macro writeBarrierOnOperands(size, get, cellFieldName, valueFieldName)
     491    get(valueFieldName, t1)
    493492    loadConstantOrVariableCell(size, t1, t0, .writeBarrierDone)
    494493    btpz t0, .writeBarrierDone
    495494
    496     writeBarrierOnOperand(size, get, cellOperand)
     495    writeBarrierOnOperand(size, get, cellFieldName)
    497496.writeBarrierDone:
    498497end
    499498
    500 macro writeBarrierOnGlobal(size, get, valueOperand, loadHelper)
    501     get(valueOperand, t1)
     499macro writeBarrierOnGlobal(size, get, valueFieldName, loadMacro)
     500    get(valueFieldName, t1)
    502501    loadConstantOrVariableCell(size, t1, t0, .writeBarrierDone)
    503502    btpz t0, .writeBarrierDone
    504503
    505     loadHelper(t3)
     504    loadMacro(t3)
    506505    skipIfIsRememberedOrInEden(
    507506        t3,
    … …  
    516515end
    517516
    518 macro writeBarrierOnGlobalObject(size, get, valueOperand)
    519     writeBarrierOnGlobal(size, get, valueOperand,
     517macro writeBarrierOnGlobalObject(size, get, valueFieldName)
     518    writeBarrierOnGlobal(size, get, valueFieldName,
    520519        macro(registerToStoreGlobal)
    521520            loadp CodeBlock[cfr], registerToStoreGlobal
    … …  
    524523end
    525524
    526 macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueOperand)
    527     writeBarrierOnGlobal(size, get, valueOperand,
     525macro writeBarrierOnGlobalLexicalEnvironment(size, get, valueFieldName)
     526    writeBarrierOnGlobal(size, get, valueFieldName,
    528527        macro(registerToStoreGlobal)
    529528            loadp CodeBlock[cfr], registerToStoreGlobal
    … …  
    668667
    669668llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)
    670     get(index, t2)
     669    get(m_index, t2)
    671670    loadi PayloadOffset + ArgumentCount[cfr], t0
    672671    bilteq t0, t2, .opGetArgumentOutOfBounds
    … …  
    695694
    696695llintOpWithMetadata(op_to_this, OpToThis, macro (size, get, dispatch, metadata, return)
    697     get(srcDst, t0)
     696    get(m_srcDst, t0)
    698697    loadq [cfr, t0, 8], t0
    699698    btqnz t0, tagMask, .opToThisSlow
    … …  
    701700    loadStructureWithScratch(t0, t1, t2, t3)
    702701    metadata(t2, t3)
    703     loadp OpToThis::Metadata::cachedStructure[t2], t2
     702    loadp OpToThis::Metadata::m_cachedStructure[t2], t2
    704703    bpneq t1, t2, .opToThisSlow
    705704    dispatch()
    … …  
    712711
    713712llintOp(op_check_tdz, OpCheckTdz, macro (size, get, dispatch)
    714     get(target, t0)
     713    get(m_target, t0)
    715714    loadConstantOrVariable(size, t0, t1)
    716715    bqneq t1, ValueEmpty, .opNotTDZ
    … …  
    723722
    724723llintOpWithReturn(op_mov, OpMov, macro (size, get, dispatch, return)
    725     get(src, t1)
     724    get(m_src, t1)
    726725    loadConstantOrVariable(size, t1, t2)
    727726    return(t2)
    … …  
    730729
    731730llintOpWithReturn(op_not, OpNot, macro (size, get, dispatch, return)
    732     get(operand, t0)
     731    get(m_operand, t0)
    733732    loadConstantOrVariable(size, t0, t2)
    734733    xorq ValueFalse, t2
    … …  
    745744macro equalityComparisonOp(name, op, integerComparison)
    746745    llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
    747         get(rhs, t0)
    748         get(lhs, t2)
     746        get(m_rhs, t0)
     747        get(m_lhs, t2)
    749748        loadConstantOrVariableInt32(size, t0, t1, .slow)
    750749        loadConstantOrVariableInt32(size, t2, t0, .slow)
    … …  
    762761macro equalNullComparisonOp(name, op, fn)
    763762    llintOpWithReturn(name, op, macro (size, get, dispatch, return)
    764         get(operand, t0)
     763        get(m_operand, t0)
    765764        loadq [cfr, t0, 8], t0
    766765        btqnz t0, tagMask, .immediate
    … …  
    792791
    793792llintOpWithReturn(op_is_undefined_or_null, OpIsUndefinedOrNull, macro (size, get, dispatch, return)
    794     get(operand, t0)
     793    get(m_operand, t0)
    795794    loadq [cfr, t0, 8], t0
    796795    andq ~TagBitUndefined, t0
    … …  
    803802macro strictEqOp(name, op, equalityOperation)
    804803    llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
    805         get(rhs, t0)
    806         get(lhs, t2)
     804        get(m_rhs, t0)
     805        get(m_lhs, t2)
    807806        loadConstantOrVariable(size, t0, t1)
    808807        loadConstantOrVariable(size, t2, t0)
    … …  
    837836macro strictEqualityJumpOp(name, op, equalityOperation)
    838837    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    839         get(lhs, t2)
    840         get(rhs, t3)
     838        get(m_lhs, t2)
     839        get(m_rhs, t3)
    841840        loadConstantOrVariable(size, t2, t0)
    842841        loadConstantOrVariable(size, t3, t1)
    … …  
    854853
    855854    .jumpTarget:
    856         jump(target)
     855        jump(m_target)
    857856
    858857    .slow:
    … …  
    873872macro preOp(name, op, arithmeticOperation)
    874873    llintOp(op_%name%, op, macro (size, get, dispatch)
    875         get(srcDst, t0)
     874        get(m_srcDst, t0)
    876875        loadq [cfr, t0, 8], t1
    877876        bqb t1, tagTypeNumber, .slow
    … …  
    887886
    888887llintOpWithProfile(op_to_number, OpToNumber, macro (size, get, dispatch, return)
    889     get(operand, t0)
     888    get(m_operand, t0)
    890889    loadConstantOrVariable(size, t0, t2)
    891890    bqaeq t2, tagTypeNumber, .opToNumberIsImmediate
    … …  
    901900
    902901llintOpWithReturn(op_to_string, OpToString, macro (size, get, dispatch, return)
    903     get(operand, t1)
     902    get(m_operand, t1)
    904903    loadConstantOrVariable(size, t1, t0)
    905904    btqnz t0, tagMask, .opToStringSlow
    … …  
    915914
    916915llintOpWithProfile(op_to_object, OpToObject, macro (size, get, dispatch, return)
    917     get(operand, t0)
     916    get(m_operand, t0)
    918917    loadConstantOrVariable(size, t0, t2)
    919918    btqnz t2, tagMask, .opToObjectSlow
    … …  
    928927
    929928llintOpWithMetadata(op_negate, OpNegate, macro (size, get, dispatch, metadata, return)
    930     get(operand, t0)
     929    get(m_operand, t0)
    931930    loadConstantOrVariable(size, t0, t3)
    932931    metadata(t1, t2)
    933     loadis OpNegate::Metadata::arithProfile[t1], t2
     932    loadis OpNegate::Metadata::m_arithProfile[t1], t2
    934933    bqb t3, tagTypeNumber, .opNegateNotInt
    935934    btiz t3, 0x7fffffff, .opNegateSlow
    … …  
    937936    orq tagTypeNumber, t3
    938937    ori ArithProfileInt, t2
    939     storei t2, OpNegate::Metadata::arithProfile[t1]
     938    storei t2, OpNegate::Metadata::m_arithProfile[t1]
    940939    return(t3)
    941940.opNegateNotInt:
    … …  
    943942    xorq 0x8000000000000000, t3
    944943    ori ArithProfileNumber, t2
    945     storei t2, OpNegate::Metadata::arithProfile[t1]
     944    storei t2, OpNegate::Metadata::m_arithProfile[t1]
    946945    return(t3)
    947946
    … …  
    957956
    958957        macro profile(type)
    959             ori type, %op%::Metadata::arithProfile[t5]
     958            ori type, %op%::Metadata::m_arithProfile[t5]
    960959        end
    961960
    962         get(rhs, t0)
    963         get(lhs, t2)
     961        get(m_rhs, t0)
     962        get(m_lhs, t2)
    964963        loadConstantOrVariable(size, t0, t1)
    965964        loadConstantOrVariable(size, t2, t0)
    966965        bqb t0, tagTypeNumber, .op1NotInt
    967966        bqb t1, tagTypeNumber, .op2NotInt
    968         get(dst, t2)
     967        get(m_dst, t2)
    969968        integerOperationAndStore(t1, t0, .slow, t2)
    970969
    … …  
    985984        ci2d t1, ft1
    986985    .op1NotIntReady:
    987         get(dst, t2)
     986        get(m_dst, t2)
    988987        addq tagTypeNumber, t0
    989988        fq2d t0, ft0
    … …  
    996995    .op2NotInt:
    997996        # First operand is definitely an int, the second is definitely not.
    998         get(dst, t2)
     997        get(m_dst, t2)
    999998        btqz t1, tagTypeNumber, .slow
    1000999        profile(ArithProfileIntNumber)
    … …  
    10751074
    10761075llintOpWithReturn(op_unsigned, OpUnsigned, macro (size, get, dispatch, return)
    1077     get(operand, t1)
     1076    get(m_operand, t1)
    10781077    loadConstantOrVariable(size, t1, t2)
    10791078    bilt t2, 0, .opUnsignedSlow
    … …  
    10871086macro commonBitOp(opKind, name, op, operation)
    10881087    opKind(op_%name%, op, macro (size, get, dispatch, return)
    1089         get(rhs, t0)
    1090         get(lhs, t2)
     1088        get(m_rhs, t0)
     1089        get(m_lhs, t2)
    10911090        loadConstantOrVariable(size, t0, t1)
    10921091        loadConstantOrVariable(size, t2, t0)
    … …  
    11321131
    11331132llintOpWithProfile(op_bitnot, OpBitnot, macro (size, get, dispatch, return)
    1134     get(operand, t0)
     1133    get(m_operand, t0)
    11351134    loadConstantOrVariableInt32(size, t0, t3, .opBitNotSlow)
    11361135    noti t3
    … …  
    11441143
    11451144llintOp(op_overrides_has_instance, OpOverridesHasInstance, macro (size, get, dispatch)
    1146     get(dst, t3)
    1147 
    1148     get(hasInstanceValue, t1)
     1145    get(m_dst, t3)
     1146
     1147    get(m_hasInstanceValue, t1)
    11491148    loadConstantOrVariable(size, t1, t0)
    11501149    loadp CodeBlock[cfr], t2
    … …  
    11531152    bqneq t0, t2, .opOverridesHasInstanceNotDefaultSymbol
    11541153
    1155     get(constructor, t1)
     1154    get(m_constructor, t1)
    11561155    loadConstantOrVariable(size, t1, t0)
    11571156    tbz JSCell::m_flags[t0], ImplementsDefaultHasInstance, t1
    … …  
    11671166
    11681167llintOpWithReturn(op_is_empty, OpIsEmpty, macro (size, get, dispatch, return)
    1169     get(operand, t1)
     1168    get(m_operand, t1)
    11701169    loadConstantOrVariable(size, t1, t0)
    11711170    cqeq t0, ValueEmpty, t3
    … …  
    11761175
    11771176llintOpWithReturn(op_is_undefined, OpIsUndefined, macro (size, get, dispatch, return)
    1178     get(operand, t1)
     1177    get(m_operand, t1)
    11791178    loadConstantOrVariable(size, t1, t0)
    11801179    btqz t0, tagMask, .opIsUndefinedCell
    … …  
    11971196
    11981197llintOpWithReturn(op_is_boolean, OpIsBoolean, macro (size, get, dispatch, return)
    1199     get(operand, t1)
     1198    get(m_operand, t1)
    12001199    loadConstantOrVariable(size, t1, t0)
    12011200    xorq ValueFalse, t0
    … …  
    12071206
    12081207llintOpWithReturn(op_is_number, OpIsNumber, macro (size, get, dispatch, return)
    1209     get(operand, t1)
     1208    get(m_operand, t1)
    12101209    loadConstantOrVariable(size, t1, t0)
    12111210    tqnz t0, tagTypeNumber, t1
    … …  
    12161215
    12171216llintOpWithReturn(op_is_cell_with_type, OpIsCellWithType, macro (size, get, dispatch, return)
    1218     getu(size, OpIsCellWithType, type, t0)
    1219     get(operand, t1)
     1217    getu(size, OpIsCellWithType, m_type, t0)
     1218    get(m_operand, t1)
    12201219    loadConstantOrVariable(size, t1, t3)
    12211220    btqnz t3, tagMask, .notCellCase
    … …  
    12291228
    12301229llintOpWithReturn(op_is_object, OpIsObject, macro (size, get, dispatch, return)
    1231     get(operand, t1)
     1230    get(m_operand, t1)
    12321231    loadConstantOrVariable(size, t1, t0)
    12331232    btqnz t0, tagMask, .opIsObjectNotCell
    … …  
    12681267llintOpWithMetadata(op_get_by_id_direct, OpGetByIdDirect, macro (size, get, dispatch, metadata, return)
    12691268    metadata(t2, t0)
    1270     get(base, t0)
     1269    get(m_base, t0)
    12711270    loadConstantOrVariableCell(size, t0, t3, .opGetByIdDirectSlow)
    12721271    loadi JSCell::m_structureID[t3], t1
    1273     loadi OpGetByIdDirect::Metadata::structure[t2], t0
     1272    loadi OpGetByIdDirect::Metadata::m_structure[t2], t0
    12741273    bineq t0, t1, .opGetByIdDirectSlow
    1275     loadi OpGetByIdDirect::Metadata::offset[t2], t1
     1274    loadi OpGetByIdDirect::Metadata::m_offset[t2], t1
    12761275    loadPropertyAtVariableOffset(t1, t3, t0)
    12771276    valueProfile(OpGetByIdDirect, t2, t0)
    … …  
    12861285llintOpWithMetadata(op_get_by_id, OpGetById, macro (size, get, dispatch, metadata, return)
    12871286    metadata(t2, t1)
    1288     loadb OpGetById::Metadata::mode[t2], t1
    1289     get(base, t0)
     1287    loadb OpGetById::Metadata::m_mode[t2], t1
     1288    get(m_base, t0)
    12901289    loadConstantOrVariableCell(size, t0, t3, .opGetByIdSlow)
    12911290
    … …  
    12931292    bbneq t1, constexpr GetByIdMode::Default, .opGetByIdProtoLoad
    12941293    loadi JSCell::m_structureID[t3], t1
    1295     loadi OpGetById::Metadata::modeMetadata.defaultMode.structure[t2], t0
     1294    loadi OpGetById::Metadata::m_modeMetadata.defaultMode.structure[t2], t0
    12961295    bineq t0, t1, .opGetByIdSlow
    1297     loadis OpGetById::Metadata::modeMetadata.defaultMode.cachedOffset[t2], t1
     1296    loadis OpGetById::Metadata::m_modeMetadata.defaultMode.cachedOffset[t2], t1
    12981297    loadPropertyAtVariableOffset(t1, t3, t0)
    12991298    valueProfile(OpGetById, t2, t0)
    … …  
    13031302    bbneq t1, constexpr GetByIdMode::ProtoLoad, .opGetByIdArrayLength
    13041303    loadi JSCell::m_structureID[t3], t1
    1305     loadi OpGetById::Metadata::modeMetadata.protoLoadMode.structure[t2], t3
     1304    loadi OpGetById::Metadata::m_modeMetadata.protoLoadMode.structure[t2], t3
    13061305    bineq t3, t1, .opGetByIdSlow
    1307     loadis OpGetById::Metadata::modeMetadata.protoLoadMode.cachedOffset[t2], t1
    1308     loadp OpGetById::Metadata::modeMetadata.protoLoadMode.cachedSlot[t2], t3
     1306    loadis OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedOffset[t2], t1
     1307    loadp OpGetById::Metadata::m_modeMetadata.protoLoadMode.cachedSlot[t2], t3
    13091308    loadPropertyAtVariableOffset(t1, t3, t0)
    13101309    valueProfile(OpGetById, t2, t0)
    … …  
    13141313    bbneq t1, constexpr GetByIdMode::ArrayLength, .opGetByIdUnset
    13151314    move t3, t0
    1316     arrayProfile(OpGetById::Metadata::modeMetadata.arrayLengthMode.arrayProfile, t0, t2, t5)
     1315    arrayProfile(OpGetById::Metadata::m_modeMetadata.arrayLengthMode.arrayProfile, t0, t2, t5)
    13171316    btiz t0, IsArray, .opGetByIdSlow
    13181317    btiz t0, IndexingShapeMask, .opGetByIdSlow
    … …  
    13261325.opGetByIdUnset:
    13271326    loadi JSCell::m_structureID[t3], t1
    1328     loadi OpGetById::Metadata::modeMetadata.unsetMode.structure[t2], t0
     1327    loadi OpGetById::Metadata::m_modeMetadata.unsetMode.structure[t2], t0
    13291328    bineq t0, t1, .opGetByIdSlow
    13301329    valueProfile(OpGetById, t2, ValueUndefined)
    … …  
    13381337
    13391338llintOpWithMetadata(op_put_by_id, OpPutById, macro (size, get, dispatch, metadata, return)
    1340     get(base, t3)
     1339    get(m_base, t3)
    13411340    loadConstantOrVariableCell(size, t3, t0, .opPutByIdSlow)
    13421341    metadata(t5, t2)
    1343     loadis OpPutById::Metadata::oldStructure[t5], t2
     1342    loadis OpPutById::Metadata::m_oldStructure[t5], t2
    13441343    bineq t2, JSCell::m_structureID[t0], .opPutByIdSlow
    13451344
    … …  
    13491348    # t5 -> metadata
    13501349
    1351     loadi OpPutById::Metadata::newStructure[t5], t1
     1350    loadi OpPutById::Metadata::m_newStructure[t5], t1
    13521351    btiz t1, .opPutByIdNotTransition
    13531352
    … …  
    13551354    # If we have a chain, we need to check it. t0 is the base. We may clobber t1 to use it as
    13561355    # scratch.
    1357     loadp OpPutById::Metadata::structureChain[t5], t3
     1356    loadp OpPutById::Metadata::m_structureChain[t5], t3
    13581357    btpz t3, .opPutByIdTransitionDirect
    13591358
    … …  
    13611360
    13621361    # reload the StructureChain since we used t3 as a scratch above
    1363     loadp OpPutById::Metadata::structureChain[t5], t3
     1362    loadp OpPutById::Metadata::m_structureChain[t5], t3
    13641363
    13651364    loadp StructureChain::m_vector[t3], t3
    … …  
    13821381.opPutByIdTransitionChainDone:
    13831382    # Reload the new structure, since we clobbered it above.
    1384     loadi OpPutById::Metadata::newStructure[t5], t1
     1383    loadi OpPutById::Metadata::m_newStructure[t5], t1
    13851384
    13861385.opPutByIdTransitionDirect:
    13871386    storei t1, JSCell::m_structureID[t0]
    1388     writeBarrierOnOperandWithReload(size, get, base, macro ()
     1387    writeBarrierOnOperandWithReload(size, get, m_base, macro ()
    13891388        # Reload metadata into t5
    13901389        metadata(t5, t1)
    13911390        # Reload base into t0
    1392         get(base, t1)
     1391        get(m_base, t1)
    13931392        loadConstantOrVariable(size, t1, t0)
    13941393    end)
    … …  
    13961395.opPutByIdNotTransition:
    13971396    # The only thing live right now is t0, which holds the base.
    1398     get(value, t1)
     1397    get(m_value, t1)
    13991398    loadConstantOrVariable(size, t1, t2)
    1400     loadi OpPutById::Metadata::offset[t5], t1
     1399    loadi OpPutById::Metadata::m_offset[t5], t1
    14011400    storePropertyAtVariableOffset(t1, t0, t2)
    1402     writeBarrierOnOperands(size, get, base, value)
     1401    writeBarrierOnOperands(size, get, m_base, m_value)
    14031402    dispatch()
    14041403
    … …  
    14111410llintOpWithMetadata(op_get_by_val, OpGetByVal, macro (size, get, dispatch, metadata, return)
    14121411    macro finishGetByVal(result, scratch)
    1413         get(dst, scratch)
     1412        get(m_dst, scratch)
    14141413        storeq result, [cfr, scratch, 8]
    14151414        valueProfile(OpGetByVal, t5, result)
    … …  
    14301429    metadata(t5, t2)
    14311430
    1432     get(base, t2)
     1431    get(m_base, t2)
    14331432    loadConstantOrVariableCell(size, t2, t0, .opGetByValSlow)
    14341433
    14351434    move t0, t2
    1436     arrayProfile(OpGetByVal::Metadata::arrayProfile, t2, t5, t1)
    1437 
    1438     get(property, t3)
     1435    arrayProfile(OpGetByVal::Metadata::m_arrayProfile, t2, t5, t1)
     1436
     1437    get(m_property, t3)
    14391438    loadConstantOrVariableInt32(size, t3, t1, .opGetByValSlow)
    14401439    sxi2q t1, t1
    … …  
    14491448.opGetByValIsContiguous:
    14501449    biaeq t1, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t3], .opGetByValSlow
    1451     get(dst, t0)
     1450    get(m_dst, t0)
    14521451    loadq [t3, t1, 8], t2
    14531452    btqz t2, .opGetByValSlow
    … …  
    14571456    bineq t2, DoubleShape, .opGetByValNotDouble
    14581457    biaeq t1, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t3], .opGetByValSlow
    1459     get(dst, t0)
     1458    get(m_dst, t0)
    14601459    loadd [t3, t1, 8], ft0
    14611460    bdnequn ft0, ft0, .opGetByValSlow
    … …  
    14681467    bia t2, SlowPutArrayStorageShape - ArrayStorageShape, .opGetByValNotIndexedStorage
    14691468    biaeq t1, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t3], .opGetByValSlow
    1470     get(dst, t0)
     1469    get(m_dst, t0)
    14711470    loadq ArrayStorage::m_vector[t3, t1, 8], t2
    14721471    btqz t2, .opGetByValSlow
    … …  
    15811580            biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .outOfBounds
    15821581        .storeResult:
    1583             get(value, t2)
     1582            get(m_value, t2)
    15841583            storeCallback(t2, t1, [t0, t3, 8])
    15851584            dispatch()
    … …  
    15871586        .outOfBounds:
    15881587            biaeq t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.vectorLength[t0], .opPutByValOutOfBounds
    1589             storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
     1588            storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
    15901589            addi 1, t3, t2
    15911590            storei t2, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0]
    … …  
    15931592        end
    15941593
    1595         get(base, t0)
     1594        get(m_base, t0)
    15961595        loadConstantOrVariableCell(size, t0, t1, .opPutByValSlow)
    15971596        move t1, t2
    15981597        metadata(t5, t0)
    1599         arrayProfile(%op%::Metadata::arrayProfile, t2, t5, t0)
    1600         get(property, t0)
     1598        arrayProfile(%op%::Metadata::m_arrayProfile, t2, t5, t0)
     1599        get(m_property, t0)
    16011600        loadConstantOrVariableInt32(size, t0, t3, .opPutByValSlow)
    16021601        sxi2q t3, t3
    … …  
    16111610                bqb scratch, tagTypeNumber, .opPutByValSlow
    16121611                storeq scratch, address
    1613                 writeBarrierOnOperands(size, get, base, value)
     1612                writeBarrierOnOperands(size, get, m_base, m_value)
    16141613            end)
    16151614
    … …  
    16281627            .ready:
    16291628                stored ft0, address
    1630                 writeBarrierOnOperands(size, get, base, value)
     1629                writeBarrierOnOperands(size, get, m_base, m_value)
    16311630            end)
    16321631
    … …  
    16371636                loadConstantOrVariable(size, operand, scratch)
    16381637                storeq scratch, address
    1639                 writeBarrierOnOperands(size, get, base, value)
     1638                writeBarrierOnOperands(size, get, m_base, m_value)
    16401639            end)
    16411640
    … …  
    16451644        btqz ArrayStorage::m_vector[t0, t3, 8], .opPutByValArrayStorageEmpty
    16461645    .opPutByValArrayStorageStoreResult:
    1647         get(value, t2)
     1646        get(m_value, t2)
    16481647        loadConstantOrVariable(size, t2, t1)
    16491648        storeq t1, ArrayStorage::m_vector[t0, t3, 8]
    1650         writeBarrierOnOperands(size, get, base, value)
     1649        writeBarrierOnOperands(size, get, m_base, m_value)
    16511650        dispatch()
    16521651
    16531652    .opPutByValArrayStorageEmpty:
    1654         storeb 1, %op%::Metadata::arrayProfile.m_mayStoreToHole[t5]
     1653        storeb 1, %op%::Metadata::m_arrayProfile.m_mayStoreToHole[t5]
    16551654        addi 1, ArrayStorage::m_numValuesInVector[t0]
    16561655        bib t3, -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], .opPutByValArrayStorageStoreResult
    … …  
    16601659
    16611660    .opPutByValOutOfBounds:
    1662         storeb 1, %op%::Metadata::arrayProfile.m_outOfBounds[t5]
     1661        storeb 1, %op%::Metadata::m_arrayProfile.m_outOfBounds[t5]
    16631662    .opPutByValSlow:
    16641663        callSlowPath(_llint_slow_path_%name%)
    … …  
    16741673macro llintJumpTrueOrFalseOp(name, op, conditionOp)
    16751674    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1676         get(condition, t1)
     1675        get(m_condition, t1)
    16771676        loadConstantOrVariable(size, t1, t0)
    16781677        btqnz t0, ~0xf, .slow
    … …  
    16811680
    16821681    .target:
    1683         jump(target)
     1682        jump(m_target)
    16841683
    16851684    .slow:
    … …  
    16921691macro equalNullJumpOp(name, op, cellHandler, immediateHandler)
    16931692    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1694         get(value, t0)
     1693        get(m_value, t0)
    16951694        assertNotConstant(size, t0)
    16961695        loadq [cfr, t0, 8], t0
    … …  
    17011700
    17021701    .target:
    1703         jump(target)
     1702        jump(m_target)
    17041703
    17051704    .immediate:
    … …  
    17321731
    17331732llintOpWithMetadata(op_jneq_ptr, OpJneqPtr, macro (size, get, dispatch, metadata, return)
    1734     get(value, t0)
    1735     get(specialPointer, t1)
     1733    get(m_value, t0)
     1734    get(m_specialPointer, t1)
    17361735    loadp CodeBlock[cfr], t2
    17371736    loadp CodeBlock::m_globalObject[t2], t2
    … …  
    17421741.opJneqPtrTarget:
    17431742    metadata(t5, t0)
    1744     storeb 1, OpJneqPtr::Metadata::hasJumped[t5]
    1745     get(target, t0)
     1743    storeb 1, OpJneqPtr::Metadata::m_hasJumped[t5]
     1744    get(m_target, t0)
    17461745    jumpImpl(t0)
    17471746end)
    … …  
    17501749macro compareJumpOp(name, op, integerCompare, doubleCompare)
    17511750    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1752         get(lhs, t2)
    1753         get(rhs, t3)
     1751        get(m_lhs, t2)
     1752        get(m_rhs, t3)
    17541753        loadConstantOrVariable(size, t2, t0)
    17551754        loadConstantOrVariable(size, t3, t1)
    … …  
    17831782
    17841783    .jumpTarget:
    1785         jump(target)
     1784        jump(m_target)
    17861785
    17871786    .slow:
    … …  
    17941793macro equalityJumpOp(name, op, integerComparison)
    17951794    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1796         get(lhs, t2)
    1797         get(rhs, t3)
     1795        get(m_lhs, t2)
     1796        get(m_rhs, t3)
    17981797        loadConstantOrVariableInt32(size, t2, t0, .slow)
    17991798        loadConstantOrVariableInt32(size, t3, t1, .slow)
    … …  
    18021801
    18031802    .jumpTarget:
    1804         jump(target)
     1803        jump(m_target)
    18051804
    18061805    .slow:
    … …  
    18111810
    18121811
    1813 macro compareUnsignedJumpOp(name, op, integerCompare)
     1812macro compareUnsignedJumpOp(name, op, integerCompareMacro)
    18141813    llintOpWithJump(op_%name%, op, macro (size, get, jump, dispatch)
    1815         get(lhs, t2)
    1816         get(rhs, t3)
     1814        get(m_lhs, t2)
     1815        get(m_rhs, t3)
    18171816        loadConstantOrVariable(size, t2, t0)
    18181817        loadConstantOrVariable(size, t3, t1)
    1819         integerCompare(t0, t1, .jumpTarget)
     1818        integerCompareMacro(t0, t1, .jumpTarget)
    18201819        dispatch()
    18211820
    18221821    .jumpTarget:
    1823         jump(target)
     1822        jump(m_target)
    18241823    end)
    18251824end
    … …  
    18281827macro compareUnsignedOp(name, op, integerCompareAndSet)
    18291828    llintOpWithReturn(op_%name%, op, macro (size, get, dispatch, return)
    1830         get(lhs, t2)
    1831         get(rhs,  t0)
     1829        get(m_lhs, t2)
     1830        get(m_rhs,  t0)
    18321831        loadConstantOrVariable(size, t0, t1)
    18331832        loadConstantOrVariable(size, t2, t0)
    … …  
    18401839
    18411840llintOpWithJump(op_switch_imm, OpSwitchImm, macro (size, get, jump, dispatch)
    1842     get(scrutinee, t2)
    1843     get(tableIndex, t3)
     1841    get(m_scrutinee, t2)
     1842    get(m_tableIndex, t3)
    18441843    loadConstantOrVariable(size, t2, t1)
    18451844    loadp CodeBlock[cfr], t2
    … …  
    18591858    btqnz t1, tagTypeNumber, .opSwitchImmSlow   # Go slow if it's a double.
    18601859.opSwitchImmFallThrough:
    1861     jump(defaultOffset)
     1860    jump(m_defaultOffset)
    18621861
    18631862.opSwitchImmSlow:
    … …  
    18681867
    18691868llintOpWithJump(op_switch_char, OpSwitchChar, macro (size, get, jump, dispatch)
    1870     get(scrutinee, t2)
    1871     get(tableIndex, t3)
     1869    get(m_scrutinee, t2)
     1870    get(m_tableIndex, t3)
    18721871    loadConstantOrVariable(size, t2, t1)
    18731872    loadp CodeBlock[cfr], t2
    … …  
    18961895
    18971896.opSwitchCharFallThrough:
    1898     jump(defaultOffset)
     1897    jump(m_defaultOffset)
    18991898
    19001899.opSwitchOnRope:
    … …  
    19061905# we assume t5 contains the metadata, and we should not scratch that
    19071906macro arrayProfileForCall(op, getu)
    1908     getu(argv, t3)
     1907    getu(m_argv, t3)
    19091908    negp t3
    19101909    loadq ThisArgumentOffset[cfr, t3, 8], t0
    19111910    btqnz t0, tagMask, .done
    19121911    loadi JSCell::m_structureID[t0], t3
    1913     storei t3, %op%::Metadata::arrayProfile.m_lastSeenStructureID[t5]
     1912    storei t3, %op%::Metadata::m_arrayProfile.m_lastSeenStructureID[t5]
    19141913.done:
    19151914end
    … …  
    19191918        metadata(t5, t0)
    19201919
    1921         prologue(macro (field, dst)
    1922             getu(size, op, field, dst)
     1920        prologue(macro (fieldName, dst)
     1921            getu(size, op, fieldName, dst)
    19231922        end, metadata)
    19241923
    1925         get(callee, t0)
    1926         loadp %op%::Metadata::callLinkInfo.callee[t5], t2
     1924        get(m_callee, t0)
     1925        loadp %op%::Metadata::m_callLinkInfo.callee[t5], t2
    19271926        loadConstantOrVariable(size, t0, t3)
    19281927        bqneq t3, t2, .opCallSlow
    1929         getu(size, op, argv, t3)
     1928        getu(size, op, m_argv, t3)
    19301929        lshifti 3, t3
    19311930        negp t3
    19321931        addp cfr, t3
    19331932        storeq t2, Callee[t3]
    1934         getu(size, op, argc, t2)
     1933        getu(size, op, m_argc, t2)
    19351934        storei PC, ArgumentCount + TagOffset[cfr]
    19361935        storei t2, ArgumentCount + PayloadOffset[t3]
    … …  
    19381937        if POISON
    19391938            loadp _g_JITCodePoison, t2
    1940             xorp %op%::Metadata::callLinkInfo.machineCodeTarget[t5], t2
     1939            xorp %op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], t2
    19411940            prepareCall(t2, t1, t3, t4, JSEntryPtrTag)
    19421941            callTargetFunction(size, op, dispatch, t2, JSEntryPtrTag)
    19431942        else
    1944             prepareCall(%op%::Metadata::callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
    1945             callTargetFunction(size, op, dispatch, %op%::Metadata::callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
     1943            prepareCall(%op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], t2, t3, t4, JSEntryPtrTag)
     1944            callTargetFunction(size, op, dispatch, %op%::Metadata::m_callLinkInfo.machineCodeTarget[t5], JSEntryPtrTag)
    19461945        end
    19471946
    … …  
    19531952llintOp(op_ret, OpRet, macro (size, get, dispatch)
    19541953    checkSwitchToJITForEpilogue()
    1955     get(value, t2)
     1954    get(m_value, t2)
    19561955    loadConstantOrVariable(size, t2, r0)
    19571956    doReturn()
    … …  
    19601959
    19611960llintOpWithReturn(op_to_primitive, OpToPrimitive, macro (size, get, dispatch, return)
    1962     get(src, t2)
     1961    get(m_src, t2)
    19631962    loadConstantOrVariable(size, t2, t0)
    19641963    btqnz t0, tagMask, .opToPrimitiveIsImm
    … …  
    20052004    loadp VM::m_exception[t3], t0
    20062005    storep 0, VM::m_exception[t3]
    2007     get(size, OpCatch, exception, t2)
     2006    get(size, OpCatch, m_exception, t2)
    20082007    storeq t0, [cfr, t2, 8]
    20092008
    20102009    loadq Exception::m_value[t0], t3
    2011     get(size, OpCatch, thrownValue, t2)
     2010    get(size, OpCatch, m_thrownValue, t2)
    20122011    storeq t3, [cfr, t2, 8]
    20132012
    … …  
    20222021llintOp(op_end, OpEnd, macro (size, get, dispatch)
    20232022    checkSwitchToJITForEpilogue()
    2024     get(value, t0)
     2023    get(m_value, t0)
    20252024    assertNotConstant(size, t0)
    20262025    loadq [cfr, t0, 8], r0
    … …  
    21532152
    21542153    macro getConstantScope()
    2155         loadp OpResolveScope::Metadata::constantScope[t5],  t0
     2154        loadp OpResolveScope::Metadata::m_constantScope[t5],  t0
    21562155        return(t0)
    21572156    end
    21582157
    21592158    macro resolveScope()
    2160         loadi OpResolveScope::Metadata::localScopeDepth[t5], t2
    2161         get(scope, t0)
     2159        loadi OpResolveScope::Metadata::m_localScopeDepth[t5], t2
     2160        get(m_scope, t0)
    21622161        loadq [cfr, t0, 8], t0
    21632162        btiz t2, .resolveScopeLoopEnd
    … …  
    21722171    end
    21732172
    2174     loadp OpResolveScope::Metadata::resolveType[t5], t0
     2173    loadp OpResolveScope::Metadata::m_resolveType[t5], t0
    21752174
    21762175#rGlobalProperty:
    … …  
    22212220
    22222221macro loadWithStructureCheck(op, get, slowPath)
    2223     get(scope, t0)
     2222    get(m_scope, t0)
    22242223    loadq [cfr, t0, 8], t0
    22252224    loadStructureWithScratch(t0, t2, t1, t3)
    2226     loadp %op%::Metadata::structure[t5], t1
     2225    loadp %op%::Metadata::m_structure[t5], t1
    22272226    bpneq t2, t1, slowPath
    22282227end
    … …  
    22322231
    22332232    macro getProperty()
    2234         loadp OpGetFromScope::Metadata::operand[t5], t1
     2233        loadp OpGetFromScope::Metadata::m_operand[t5], t1
    22352234        loadPropertyAtVariableOffset(t1, t0, t2)
    22362235        valueProfile(OpGetFromScope, t5, t2)
    … …  
    22392238
    22402239    macro getGlobalVar(tdzCheckIfNecessary)
    2241         loadp OpGetFromScope::Metadata::operand[t5], t0
     2240        loadp OpGetFromScope::Metadata::m_operand[t5], t0
    22422241        loadq [t0], t0
    22432242        tdzCheckIfNecessary(t0)
    … …  
    22472246
    22482247    macro getClosureVar()
    2249         loadp OpGetFromScope::Metadata::operand[t5], t1
     2248        loadp OpGetFromScope::Metadata::m_operand[t5], t1
    22502249        loadq JSLexicalEnvironment_variables[t0, t1, 8], t0
    22512250        valueProfile(OpGetFromScope, t5, t0)
    … …  
    22532252    end
    22542253
    2255     loadi OpGetFromScope::Metadata::getPutInfo[t5], t0
     2254    loadi OpGetFromScope::Metadata::m_getPutInfo[t5], t0
    22562255    andi ResolveTypeMask, t0
    22572256
    … …  
    22742273.gClosureVar:
    22752274    bineq t0, ClosureVar, .gGlobalPropertyWithVarInjectionChecks
    2276     loadVariable(get, scope, t0)
     2275    loadVariable(get, m_scope, t0)
    22772276    getClosureVar()
    22782277
    … …  
    22982297    bineq t0, ClosureVarWithVarInjectionChecks, .gDynamic
    22992298    varInjectionCheck(.gDynamic, t2)
    2300     loadVariable(get, scope, t0)
     2299    loadVariable(get, m_scope, t0)
    23012300    getClosureVar()
    23022301
    … …  
    23092308llintOpWithMetadata(op_put_to_scope, OpPutToScope, macro (size, get, dispatch, metadata, return)
    23102309    macro putProperty()
    2311         get(value, t1)
     2310        get(m_value, t1)
    23122311        loadConstantOrVariable(size, t1, t2)
    2313         loadis OpPutToScope::Metadata::operand[t5], t1
     2312        loadis OpPutToScope::Metadata::m_operand[t5], t1
    23142313        storePropertyAtVariableOffset(t1, t0, t2)
    23152314    end
    23162315
    23172316    macro putGlobalVariable()
    2318         get(value, t0)
     2317        get(m_value, t0)
    23192318        loadConstantOrVariable(size, t0, t1)
    2320         loadp OpPutToScope::Metadata::watchpointSet[t5], t2
    2321         loadp OpPutToScope::Metadata::operand[t5], t0
     2319        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t2
     2320        loadp OpPutToScope::Metadata::m_operand[t5], t0
    23222321        notifyWrite(t2, .pDynamic)
    23232322        storeq t1, [t0]
    … …  
    23252324
    23262325    macro putClosureVar()
    2327         get(value, t1)
     2326        get(m_value, t1)
    23282327        loadConstantOrVariable(size, t1, t2)
    2329         loadis OpPutToScope::Metadata::operand[t5], t1
     2328        loadis OpPutToScope::Metadata::m_operand[t5], t1
    23302329        storeq t2, JSLexicalEnvironment_variables[t0, t1, 8]
    23312330    end
    23322331
    23332332    macro putLocalClosureVar()
    2334         get(value, t1)
     2333        get(m_value, t1)
    23352334        loadConstantOrVariable(size, t1, t2)
    2336         loadp OpPutToScope::Metadata::watchpointSet[t5], t3
     2335        loadp OpPutToScope::Metadata::m_watchpointSet[t5], t3
    23372336        btpz t3, .noVariableWatchpointSet
    23382337        notifyWrite(t3, .pDynamic)
    23392338    .noVariableWatchpointSet:
    2340         loadis OpPutToScope::Metadata::operand[t5], t1
     2339        loadis OpPutToScope::Metadata::m_operand[t5], t1
    23412340        storeq t2, JSLexicalEnvironment_variables[t0, t1, 8]
    23422341    end
    23432342
    23442343    macro checkTDZInGlobalPutToScopeIfNecessary()
    2345         loadis OpPutToScope::Metadata::getPutInfo[t5], t0
     2344        loadis OpPutToScope::Metadata::m_getPutInfo[t5], t0
    23462345        andi InitializationModeMask, t0
    23472346        rshifti InitializationModeShift, t0
    23482347        bineq t0, NotInitialization, .noNeedForTDZCheck
    2349         loadp OpPutToScope::Metadata::operand[t5], t0
     2348        loadp OpPutToScope::Metadata::m_operand[t5], t0
    23502349        loadq [t0], t0
    23512350        bqeq t0, ValueEmpty, .pDynamic
    … …  
    23542353
    23552354    metadata(t5, t0)
    2356     loadi OpPutToScope::Metadata::getPutInfo[t5], t0
     2355    loadi OpPutToScope::Metadata::m_getPutInfo[t5], t0
    23572356    andi ResolveTypeMask, t0
    23582357
    23592358#pLocalClosureVar:
    23602359    bineq t0, LocalClosureVar, .pGlobalProperty
    2361     loadVariable(get, scope, t0)
     2360    loadVariable(get, m_scope, t0)
    23622361    putLocalClosureVar()
    2363     writeBarrierOnOperands(size, get, scope, value)
     2362    writeBarrierOnOperands(size, get, m_scope, m_value)
    23642363    dispatch()
    23652364
    … …  
    23682367    loadWithStructureCheck(OpPutToScope, get, .pDynamic)
    23692368    putProperty()
    2370     writeBarrierOnOperands(size, get, scope, value)
     2369    writeBarrierOnOperands(size, get, m_scope, m_value)
    23712370    dispatch()
    23722371
    … …  
    23742373    bineq t0, GlobalVar, .pGlobalLexicalVar
    23752374    putGlobalVariable()
    2376     writeBarrierOnGlobalObject(size, get, value)
     2375    writeBarrierOnGlobalObject(size, get, m_value)
    23772376    dispatch()
    23782377
    … …  
    23812380    checkTDZInGlobalPutToScopeIfNecessary()
    23822381    putGlobalVariable()
    2383     writeBarrierOnGlobalLexicalEnvironment(size, get, value)
     2382    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
    23842383    dispatch()
    23852384
    23862385.pClosureVar:
    23872386    bineq t0, ClosureVar, .pGlobalPropertyWithVarInjectionChecks
    2388     loadVariable(get, scope, t0)
     2387    loadVariable(get, m_scope, t0)
    23892388    putClosureVar()
    2390     writeBarrierOnOperands(size, get, scope, value)
     2389    writeBarrierOnOperands(size, get, m_scope, m_value)
    23912390    dispatch()
    23922391
    … …  
    23952394    loadWithStructureCheck(OpPutToScope, get, .pDynamic)
    23962395    putProperty()
    2397     writeBarrierOnOperands(size, get, scope, value)
     2396    writeBarrierOnOperands(size, get, m_scope, m_value)
    23982397    dispatch()
    23992398
    … …  
    24022401    varInjectionCheck(.pDynamic, t2)
    24032402    putGlobalVariable()
    2404     writeBarrierOnGlobalObject(size, get, value)
     2403    writeBarrierOnGlobalObject(size, get, m_value)
    24052404    dispatch()
    24062405
    … …  
    24102409    checkTDZInGlobalPutToScopeIfNecessary()
    24112410    putGlobalVariable()
    2412     writeBarrierOnGlobalLexicalEnvironment(size, get, value)
     2411    writeBarrierOnGlobalLexicalEnvironment(size, get, m_value)
    24132412    dispatch()
    24142413
    … …  
    24162415    bineq t0, ClosureVarWithVarInjectionChecks, .pModuleVar
    24172416    varInjectionCheck(.pDynamic, t2)
    2418     loadVariable(get, scope, t0)
     2417    loadVariable(get, m_scope, t0)
    24192418    putClosureVar()
    2420     writeBarrierOnOperands(size, get, scope, value)
     2419    writeBarrierOnOperands(size, get, m_scope, m_value)
    24212420    dispatch()
    24222421
    … …  
    24332432
    24342433llintOpWithProfile(op_get_from_arguments, OpGetFromArguments, macro (size, get, dispatch, return)
    2435     loadVariable(get, arguments, t0)
    2436     getu(size, OpGetFromArguments, index, t1)
     2434    loadVariable(get, m_arguments, t0)
     2435    getu(size, OpGetFromArguments, m_index, t1)
    24372436    loadq DirectArguments_storage[t0, t1, 8], t0
    24382437    return(t0)
    … …  
    24412440
    24422441llintOp(op_put_to_arguments, OpPutToArguments, macro (size, get, dispatch)
    2443     loadVariable(get, arguments, t0)
    2444     getu(size, OpPutToArguments, index, t1)
    2445     get(value, t3)
     2442    loadVariable(get, m_arguments, t0)
     2443    getu(size, OpPutToArguments, m_index, t1)
     2444    get(m_value, t3)
    24462445    loadConstantOrVariable(size, t3, t2)
    24472446    storeq t2, DirectArguments_storage[t0, t1, 8]
    2448     writeBarrierOnOperands(size, get, arguments, value)
     2447    writeBarrierOnOperands(size, get, m_arguments, m_value)
    24492448    dispatch()
    24502449end)
    … …  
    24522451
    24532452llintOpWithReturn(op_get_parent_scope, OpGetParentScope, macro (size, get, dispatch, return)
    2454     loadVariable(get, scope, t0)
     2453    loadVariable(get, m_scope, t0)
    24552454    loadp JSScope::m_next[t0], t0
    24562455    return(t0)
    … …  
    24682467
    24692468    # t0 is holding the JSValue argument.
    2470     get(target, t3)
     2469    get(m_target, t3)
    24712470    loadConstantOrVariable(size, t3, t0)
    24722471
    … …  
    24772476    # Store the TypeLocation onto the log entry.
    24782477    metadata(t5, t3)
    2479     loadp OpProfileType::Metadata::typeLocation[t5], t3
     2478    loadp OpProfileType::Metadata::m_typeLocation[t5], t3
    24802479    storep t3, TypeProfilerLog::LogEntry::location[t2]
    24812480
    … …  
    25032502llintOpWithMetadata(op_profile_control_flow, OpProfileControlFlow, macro (size, get, dispatch, metadata, return)
    25042503    metadata(t5, t0)
    2505     loadp OpProfileControlFlow::Metadata::basicBlockLocation[t5], t0
     2504    loadp OpProfileControlFlow::Metadata::m_basicBlockLocation[t5], t0
    25062505    addq 1, BasicBlockLocation::m_executionCount[t0]
    25072506    dispatch()
    … …  
    25122511    loadi PayloadOffset + ArgumentCount[cfr], t0
    25132512    subi 1, t0
    2514     getu(size, OpGetRestLength, numParametersToSkip, t1)
     2513    getu(size, OpGetRestLength, m_numParametersToSkip, t1)
    25152514    bilteq t0, t1, .storeZero
    25162515    subi t1, t0
    … …  
    25312530    loadp Callee[cfr], t1
    25322531    storep t1, ShadowChicken::Packet::callee[t0]
    2533     loadVariable(get, scope, t1)
     2532    loadVariable(get, m_scope, t1)
    25342533    storep t1, ShadowChicken::Packet::scope[t0]
    25352534    dispatch()
    … …  
    25442543    storep cfr, ShadowChicken::Packet::frame[t0]
    25452544    storep ShadowChickenTailMarker, ShadowChicken::Packet::callee[t0]
    2546     loadVariable(get, thisValue, t1)
     2545    loadVariable(get, m_thisValue, t1)
    25472546    storep t1, ShadowChicken::Packet::thisValue[t0]
    2548     loadVariable(get, scope, t1)
     2547    loadVariable(get, m_scope, t1)
    25492548    storep t1, ShadowChicken::Packet::scope[t0]
    25502549    loadp CodeBlock[cfr], t1

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

    r240040 r240041  
    11/*
    2  * Copyright (C) 2011-2018 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    126126        CHECK_EXCEPTION();                                  \
    127127        if (bCondition)                                        \
    128             pc = bytecode.target \
    129                 ? reinterpret_cast<const Instruction*>(reinterpret_cast<const uint8_t*>(pc) + bytecode.target) \
     128            pc = bytecode.m_target \
     129                ? reinterpret_cast<const Instruction*>(reinterpret_cast<const uint8_t*>(pc) + bytecode.m_target) \
    130130                : exec->codeBlock()->outOfLineJumpTarget(pc);                              \
    131131        else                                                      \
    … …  
    142142    } while (false)
    143143
    144 #define RETURN_WITH_PROFILING(value__, profilingAction__) RETURN_WITH_PROFILING_CUSTOM(bytecode.dst, value__, profilingAction__)
     144#define RETURN_WITH_PROFILING(value__, profilingAction__) RETURN_WITH_PROFILING_CUSTOM(bytecode.m_dst, value__, profilingAction__)
    145145
    146146#define RETURN(value) \
    … …  
    151151
    152152#define PROFILE_VALUE(value) do { \
    153         bytecode.metadata(exec).profile.m_buckets[0] = JSValue::encode(value); \
     153        bytecode.metadata(exec).m_profile.m_buckets[0] = JSValue::encode(value); \
    154154    } while (false)
    155155
    … …  
    216216    BEGIN();
    217217    auto bytecode = pc->as<OpCreateScopedArguments>();
    218     JSLexicalEnvironment* scope = jsCast<JSLexicalEnvironment*>(GET(bytecode.scope).jsValue());
     218    JSLexicalEnvironment* scope = jsCast<JSLexicalEnvironment*>(GET(bytecode.m_scope).jsValue());
    219219    ScopedArgumentsTable* table = scope->symbolTable()->arguments();
    220220    RETURN(ScopedArguments::createByCopying(exec, table, scope));
    … …  
    233233    auto bytecode = pc->as<OpCreateThis>();
    234234    JSObject* result;
    235     JSObject* constructorAsObject = asObject(GET(bytecode.callee).jsValue());
     235    JSObject* constructorAsObject = asObject(GET(bytecode.m_callee).jsValue());
    236236    if (constructorAsObject->type() == JSFunctionType && jsCast<JSFunction*>(constructorAsObject)->canUseAllocationProfile()) {
    237237        JSFunction* constructor = jsCast<JSFunction*>(constructorAsObject);
    238         WriteBarrier<JSCell>& cachedCallee = bytecode.metadata(exec).cachedCallee;
     238        WriteBarrier<JSCell>& cachedCallee = bytecode.metadata(exec).m_cachedCallee;
    239239        if (!cachedCallee)
    240240            cachedCallee.set(vm, exec->codeBlock(), constructor);
    … …  
    242242            cachedCallee.setWithoutWriteBarrier(JSCell::seenMultipleCalleeObjects());
    243243
    244         size_t inlineCapacity = bytecode.inlineCapacity;
     244        size_t inlineCapacity = bytecode.m_inlineCapacity;
    245245        ObjectAllocationProfile* allocationProfile = constructor->ensureRareDataAndAllocationProfile(exec, inlineCapacity)->objectAllocationProfile();
    246246        throwScope.releaseAssertNoException();
    … …  
    271271    auto bytecode = pc->as<OpToThis>();
    272272    auto& metadata = bytecode.metadata(exec);
    273     JSValue v1 = GET(bytecode.srcDst).jsValue();
     273    JSValue v1 = GET(bytecode.m_srcDst).jsValue();
    274274    if (v1.isCell()) {
    275275        Structure* myStructure = v1.asCell()->structure(vm);
    276         Structure* otherStructure = metadata.cachedStructure.get();
     276        Structure* otherStructure = metadata.m_cachedStructure.get();
    277277        if (myStructure != otherStructure) {
    278278            if (otherStructure)
    279                 metadata.toThisStatus = ToThisConflicted;
    280             metadata.cachedStructure.set(vm, exec->codeBlock(), myStructure);
     279                metadata.m_toThisStatus = ToThisConflicted;
     280            metadata.m_cachedStructure.set(vm, exec->codeBlock(), myStructure);
    281281        }
    282282    } else {
    283         metadata.toThisStatus = ToThisConflicted;
    284         metadata.cachedStructure.clear();
     283        metadata.m_toThisStatus = ToThisConflicted;
     284        metadata.m_cachedStructure.clear();
    285285    }
    286286    // Note: We only need to do this value profiling here on the slow path. The fast path
    … …  
    291291    // fast path.
    292292    auto value = v1.toThis(exec, exec->codeBlock()->isStrictMode() ? StrictMode : NotStrictMode);
    293     RETURN_WITH_PROFILING_CUSTOM(bytecode.srcDst, value, PROFILE_VALUE(value));
     293    RETURN_WITH_PROFILING_CUSTOM(bytecode.m_srcDst, value, PROFILE_VALUE(value));
    294294}
    295295
    … …  
    316316    BEGIN();
    317317    auto bytecode = pc->as<OpNot>();
    318     RETURN(jsBoolean(!GET_C(bytecode.operand).jsValue().toBoolean(exec)));
     318    RETURN(jsBoolean(!GET_C(bytecode.m_operand).jsValue().toBoolean(exec)));
    319319}
    320320
    … …  
    323323    BEGIN();
    324324    auto bytecode = pc->as<OpEq>();
    325     RETURN(jsBoolean(JSValue::equal(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
     325    RETURN(jsBoolean(JSValue::equal(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
    326326}
    327327
    … …  
    330330    BEGIN();
    331331    auto bytecode = pc->as<OpNeq>();
    332     RETURN(jsBoolean(!JSValue::equal(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
     332    RETURN(jsBoolean(!JSValue::equal(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
    333333}
    334334
    … …  
    337337    BEGIN();
    338338    auto bytecode = pc->as<OpStricteq>();
    339     RETURN(jsBoolean(JSValue::strictEqual(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
     339    RETURN(jsBoolean(JSValue::strictEqual(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
    340340}
    341341
    … …  
    344344    BEGIN();
    345345    auto bytecode = pc->as<OpNstricteq>();
    346     RETURN(jsBoolean(!JSValue::strictEqual(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
     346    RETURN(jsBoolean(!JSValue::strictEqual(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
    347347}
    348348
    … …  
    351351    BEGIN();
    352352    auto bytecode = pc->as<OpLess>();
    353     RETURN(jsBoolean(jsLess<true>(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
     353    RETURN(jsBoolean(jsLess<true>(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
    354354}
    355355
    … …  
    358358    BEGIN();
    359359    auto bytecode = pc->as<OpLesseq>();
    360     RETURN(jsBoolean(jsLessEq<true>(exec, GET_C(bytecode.lhs).jsValue(), GET_C(bytecode.rhs).jsValue())));
     360    RETURN(jsBoolean(jsLessEq<true>(exec, GET_C(bytecode.m_lhs).jsValue(), GET_C(bytecode.m_rhs).jsValue())));
    361361}
    362362
    … …  
    365365    BEGIN();
    366366    auto bytecode = pc->as<OpGreater>();
    367     RETURN(jsBoolean(jsLess<false>(exec, GET_C(bytecode.rhs).jsValue(), GET_C(bytecode.lhs).jsValue())));
     367    RETURN(jsBoolean(jsLess<false>(exec, GET_C(bytecode.m_rhs).jsValue(), GET_C(bytecode.m_lhs).jsValue())));
    368368}
    369369
    … …  
    372372    BEGIN();
    373373    auto bytecode = pc->as<OpGreatereq>();
    374     RETURN(jsBoolean(jsLessEq<false>(exec, GET_C(bytecode.rhs).jsValue(), GET_C(bytecode.lhs).jsValue())));
     374    RETURN(jsBoolean(jsLessEq<false>(exec, GET_C(bytecode.m_rhs).jsValue(), GET_C(bytecode.m_lhs).jsValue())));
    375375}
    376376
    … …  
    379379    BEGIN();
    380380    auto bytecode = pc->as<OpInc>();
    381     RETURN_WITH_PROFILING_CUSTOM(bytecode.srcDst, jsNumber(GET(bytecode.srcDst).jsValue().toNumber(exec) + 1), { });
     381    RETURN_WITH_PROFILING_CUSTOM(bytecode.m_srcDst, jsNumber(GET(bytecode.m_srcDst).jsValue().toNumber(exec) + 1), { });
    382382}
    383383
    … …  
    386386    BEGIN();
    387387    auto bytecode = pc->as<OpDec>();
    388     RETURN_WITH_PROFILING_CUSTOM(bytecode.srcDst, jsNumber(GET(bytecode.srcDst).jsValue().toNumber(exec) - 1), { });
     388    RETURN_WITH_PROFILING_CUSTOM(bytecode.m_srcDst, jsNumber(GET(bytecode.m_srcDst).jsValue().toNumber(exec) - 1), { });
    389389}
    390390
    … …  
    393393    BEGIN();
    394394    auto bytecode = pc->as<OpToString>();
    395     RETURN(GET_C(bytecode.operand).jsValue().toString(exec));
     395    RETURN(GET_C(bytecode.m_operand).jsValue().toString(exec));
    396396}
    397397
    … …  
    399399static void updateArithProfileForUnaryArithOp(OpNegate::Metadata& metadata, JSValue result, JSValue operand)
    400400{
    401     ArithProfile& profile = metadata.arithProfile;
     401    ArithProfile& profile = metadata.m_arithProfile;
    402402    profile.observeLHS(operand);
    403403    ASSERT(result.isNumber() || result.isBigInt());
    … …  
    436436    auto bytecode = pc->as<OpNegate>();
    437437    auto& metadata = bytecode.metadata(exec);
    438     JSValue operand = GET_C(bytecode.operand).jsValue();
     438    JSValue operand = GET_C(bytecode.m_operand).jsValue();
    439439    JSValue primValue = operand.toPrimitive(exec, PreferNumber);
    440440    CHECK_EXCEPTION();
    … …  
    493493    BEGIN();
    494494    auto bytecode = pc->as<OpToNumber>();
    495     JSValue argument = GET_C(bytecode.operand).jsValue();
     495    JSValue argument = GET_C(bytecode.m_operand).jsValue();
    496496    JSValue result = jsNumber(argument.toNumber(exec));
    497497    RETURN_PROFILED(result);
    … …  
    502502    BEGIN();
    503503    auto bytecode = pc->as<OpToObject>();
    504     JSValue argument = GET_C(bytecode.operand).jsValue();
     504    JSValue argument = GET_C(bytecode.m_operand).jsValue();
    505505    if (UNLIKELY(argument.isUndefinedOrNull())) {
    506         const Identifier& ident = exec->codeBlock()->identifier(bytecode.message);
     506        const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_message);
    507507        if (!ident.isEmpty())
    508508            THROW(createTypeError(exec, ident.impl()));
    … …  
    516516    BEGIN();
    517517    auto bytecode = pc->as<OpAdd>();
    518     JSValue v1 = GET_C(bytecode.lhs).jsValue();
    519     JSValue v2 = GET_C(bytecode.rhs).jsValue();
     518    JSValue v1 = GET_C(bytecode.m_lhs).jsValue();
     519    JSValue v2 = GET_C(bytecode.m_rhs).jsValue();
    520520    JSValue result;
    521521
    … …  
    545545    BEGIN();
    546546    auto bytecode = pc->as<OpMul>();
    547     JSValue left = GET_C(bytecode.lhs).jsValue();
    548     JSValue right = GET_C(bytecode.rhs).jsValue();
     547    JSValue left = GET_C(bytecode.m_lhs).jsValue();
     548    JSValue right = GET_C(bytecode.m_rhs).jsValue();
    549549    JSValue result = jsMul(exec, left, right);
    550550    CHECK_EXCEPTION();
    … …  
    558558    BEGIN();
    559559    auto bytecode = pc->as<OpSub>();
    560     JSValue left = GET_C(bytecode.lhs).jsValue();
    561     JSValue right = GET_C(bytecode.rhs).jsValue();
     560    JSValue left = GET_C(bytecode.m_lhs).jsValue();
     561    JSValue right = GET_C(bytecode.m_rhs).jsValue();
    562562    auto leftNumeric = left.toNumeric(exec);
    563563    CHECK_EXCEPTION();
    … …  
    587587    BEGIN();
    588588    auto bytecode = pc->as<OpDiv>();
    589     JSValue left = GET_C(bytecode.lhs).jsValue();
    590     JSValue right = GET_C(bytecode.rhs).jsValue();
     589    JSValue left = GET_C(bytecode.m_lhs).jsValue();
     590    JSValue right = GET_C(bytecode.m_rhs).jsValue();
    591591    auto leftNumeric = left.toNumeric(exec);
    592592    CHECK_EXCEPTION();
    … …  
    618618    BEGIN();
    619619    auto bytecode = pc->as<OpMod>();
    620     JSValue left = GET_C(bytecode.lhs).jsValue();
    621     JSValue right = GET_C(bytecode.rhs).jsValue();
     620    JSValue left = GET_C(bytecode.m_lhs).jsValue();
     621    JSValue right = GET_C(bytecode.m_rhs).jsValue();
    622622    auto leftNumeric = left.toNumeric(exec);
    623623    CHECK_EXCEPTION();
    … …  
    644644    BEGIN();
    645645    auto bytecode = pc->as<OpPow>();
    646     double a = GET_C(bytecode.lhs).jsValue().toNumber(exec);
     646    double a = GET_C(bytecode.m_lhs).jsValue().toNumber(exec);
    647647    if (UNLIKELY(throwScope.exception()))
    648648        RETURN(JSValue());
    649     double b = GET_C(bytecode.rhs).jsValue().toNumber(exec);
     649    double b = GET_C(bytecode.m_rhs).jsValue().toNumber(exec);
    650650    if (UNLIKELY(throwScope.exception()))
    651651        RETURN(JSValue());
    … …  
    657657    BEGIN();
    658658    auto bytecode = pc->as<OpLshift>();
    659     JSValue left = GET_C(bytecode.lhs).jsValue();
    660     JSValue right = GET_C(bytecode.rhs).jsValue();
     659    JSValue left = GET_C(bytecode.m_lhs).jsValue();
     660    JSValue right = GET_C(bytecode.m_rhs).jsValue();
    661661    auto leftNumeric = left.toBigIntOrInt32(exec);
    662662    CHECK_EXCEPTION();
    … …  
    681681    BEGIN();
    682682    auto bytecode = pc->as<OpRshift>();
    683     JSValue left = GET_C(bytecode.lhs).jsValue();
    684     JSValue right = GET_C(bytecode.rhs).jsValue();
     683    JSValue left = GET_C(bytecode.m_lhs).jsValue();
     684    JSValue right = GET_C(bytecode.m_rhs).jsValue();
    685685    auto leftNumeric = left.toBigIntOrInt32(exec);
    686686    CHECK_EXCEPTION();
    … …  
    705705    BEGIN();
    706706    auto bytecode = pc->as<OpUrshift>();
    707     uint32_t a = GET_C(bytecode.lhs).jsValue().toUInt32(exec);
     707    uint32_t a = GET_C(bytecode.m_lhs).jsValue().toUInt32(exec);
    708708    if (UNLIKELY(throwScope.exception()))
    709709        RETURN(JSValue());
    710     uint32_t b = GET_C(bytecode.rhs).jsValue().toUInt32(exec);
     710    uint32_t b = GET_C(bytecode.m_rhs).jsValue().toUInt32(exec);
    711711    RETURN(jsNumber(static_cast<int32_t>(a >> (b & 31))));
    712712}
    … …  
    716716    BEGIN();
    717717    auto bytecode = pc->as<OpUnsigned>();
    718     uint32_t a = GET_C(bytecode.operand).jsValue().toUInt32(exec);
     718    uint32_t a = GET_C(bytecode.m_operand).jsValue().toUInt32(exec);
    719719    RETURN(jsNumber(a));
    720720}
    … …  
    724724    BEGIN();
    725725    auto bytecode = pc->as<OpBitnot>();
    726     int32_t operand = GET_C(bytecode.operand).jsValue().toInt32(exec);
     726    int32_t operand = GET_C(bytecode.m_operand).jsValue().toInt32(exec);
    727727    CHECK_EXCEPTION();
    728728    RETURN_PROFILED(jsNumber(~operand));
    … …  
    733733    BEGIN();
    734734    auto bytecode = pc->as<OpBitand>();
    735     auto leftNumeric = GET_C(bytecode.lhs).jsValue().toBigIntOrInt32(exec);
    736     CHECK_EXCEPTION();
    737     auto rightNumeric = GET_C(bytecode.rhs).jsValue().toBigIntOrInt32(exec);
     735    auto leftNumeric = GET_C(bytecode.m_lhs).jsValue().toBigIntOrInt32(exec);
     736    CHECK_EXCEPTION();
     737    auto rightNumeric = GET_C(bytecode.m_rhs).jsValue().toBigIntOrInt32(exec);
    738738    CHECK_EXCEPTION();
    739739    if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
    … …  
    754754    BEGIN();
    755755    auto bytecode = pc->as<OpBitor>();
    756     auto leftNumeric = GET_C(bytecode.lhs).jsValue().toBigIntOrInt32(exec);
    757     CHECK_EXCEPTION();
    758     auto rightNumeric = GET_C(bytecode.rhs).jsValue().toBigIntOrInt32(exec);
     756    auto leftNumeric = GET_C(bytecode.m_lhs).jsValue().toBigIntOrInt32(exec);
     757    CHECK_EXCEPTION();
     758    auto rightNumeric = GET_C(bytecode.m_rhs).jsValue().toBigIntOrInt32(exec);
    759759    CHECK_EXCEPTION();
    760760    if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
    … …  
    775775    BEGIN();
    776776    auto bytecode = pc->as<OpBitxor>();
    777     auto leftNumeric = GET_C(bytecode.lhs).jsValue().toBigIntOrInt32(exec);
    778     CHECK_EXCEPTION();
    779     auto rightNumeric = GET_C(bytecode.rhs).jsValue().toBigIntOrInt32(exec);
     777    auto leftNumeric = GET_C(bytecode.m_lhs).jsValue().toBigIntOrInt32(exec);
     778    CHECK_EXCEPTION();
     779    auto rightNumeric = GET_C(bytecode.m_rhs).jsValue().toBigIntOrInt32(exec);
    780780    CHECK_EXCEPTION();
    781781    if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
    … …  
    796796    BEGIN();
    797797    auto bytecode = pc->as<OpTypeof>();
    798     RETURN(jsTypeStringForValue(exec, GET_C(bytecode.value).jsValue()));
     798    RETURN(jsTypeStringForValue(exec, GET_C(bytecode.m_value).jsValue()));
    799799}
    800800
    … …  
    803803    BEGIN();
    804804    auto bytecode = pc->as<OpIsObjectOrNull>();
    805     RETURN(jsBoolean(jsIsObjectTypeOrNull(exec, GET_C(bytecode.operand).jsValue())));
     805    RETURN(jsBoolean(jsIsObjectTypeOrNull(exec, GET_C(bytecode.m_operand).jsValue())));
    806806}
    807807
    … …  
    810810    BEGIN();
    811811    auto bytecode = pc->as<OpIsFunction>();
    812     RETURN(jsBoolean(GET_C(bytecode.operand).jsValue().isFunction(vm)));
     812    RETURN(jsBoolean(GET_C(bytecode.m_operand).jsValue().isFunction(vm)));
    813813}
    814814
    … …  
    818818    auto bytecode = pc->as<OpInByVal>();
    819819    auto& metadata = bytecode.metadata(exec);
    820     RETURN(jsBoolean(CommonSlowPaths::opInByVal(exec, GET_C(bytecode.base).jsValue(), GET_C(bytecode.property).jsValue(), &metadata.arrayProfile)));
     820    RETURN(jsBoolean(CommonSlowPaths::opInByVal(exec, GET_C(bytecode.m_base).jsValue(), GET_C(bytecode.m_property).jsValue(), &metadata.m_arrayProfile)));
    821821}
    822822
    … …  
    826826
    827827    auto bytecode = pc->as<OpInById>();
    828     JSValue baseValue = GET_C(bytecode.base).jsValue();
     828    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
    829829    if (!baseValue.isObject())
    830830        THROW(createInvalidInParameterError(exec, baseValue));
    831831
    832     RETURN(jsBoolean(asObject(baseValue)->hasProperty(exec, exec->codeBlock()->identifier(bytecode.property))));
     832    RETURN(jsBoolean(asObject(baseValue)->hasProperty(exec, exec->codeBlock()->identifier(bytecode.m_property))));
    833833}
    834834
    … …  
    837837    BEGIN();
    838838    auto bytecode = pc->as<OpDelByVal>();
    839     JSValue baseValue = GET_C(bytecode.base).jsValue();
     839    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
    840840    JSObject* baseObject = baseValue.toObject(exec);
    841841    CHECK_EXCEPTION();
    842842   
    843     JSValue subscript = GET_C(bytecode.property).jsValue();
     843    JSValue subscript = GET_C(bytecode.m_property).jsValue();
    844844   
    845845    bool couldDelete;
    … …  
    865865    BEGIN();
    866866    auto bytecode = pc->as<OpStrcat>();
    867     RETURN(jsStringFromRegisterArray(exec, &GET(bytecode.src), bytecode.count));
     867    RETURN(jsStringFromRegisterArray(exec, &GET(bytecode.m_src), bytecode.m_count));
    868868}
    869869
    … …  
    872872    BEGIN();
    873873    auto bytecode = pc->as<OpToPrimitive>();
    874     RETURN(GET_C(bytecode.src).jsValue().toPrimitive(exec));
     874    RETURN(GET_C(bytecode.m_src).jsValue().toPrimitive(exec));
    875875}
    876876
    … …  
    887887    BEGIN();
    888888    auto bytecode = pc->as<OpGetEnumerableLength>();
    889     JSValue enumeratorValue = GET(bytecode.base).jsValue();
     889    JSValue enumeratorValue = GET(bytecode.m_base).jsValue();
    890890    if (enumeratorValue.isUndefinedOrNull())
    891891        RETURN(jsNumber(0));
    … …  
    901901    auto bytecode = pc->as<OpHasIndexedProperty>();
    902902    auto& metadata = bytecode.metadata(exec);
    903     JSObject* base = GET(bytecode.base).jsValue().toObject(exec);
    904     CHECK_EXCEPTION();
    905     JSValue property = GET(bytecode.property).jsValue();
    906     metadata.arrayProfile.observeStructure(base->structure(vm));
     903    JSObject* base = GET(bytecode.m_base).jsValue().toObject(exec);
     904    CHECK_EXCEPTION();
     905    JSValue property = GET(bytecode.m_property).jsValue();
     906    metadata.m_arrayProfile.observeStructure(base->structure(vm));
    907907    ASSERT(property.isUInt32());
    908908    RETURN(jsBoolean(base->hasPropertyGeneric(exec, property.asUInt32(), PropertySlot::InternalMethodType::GetOwnProperty)));
    … …  
    913913    BEGIN();
    914914    auto bytecode = pc->as<OpHasStructureProperty>();
    915     JSObject* base = GET(bytecode.base).jsValue().toObject(exec);
    916     CHECK_EXCEPTION();
    917     JSValue property = GET(bytecode.property).jsValue();
     915    JSObject* base = GET(bytecode.m_base).jsValue().toObject(exec);
     916    CHECK_EXCEPTION();
     917    JSValue property = GET(bytecode.m_property).jsValue();
    918918    ASSERT(property.isString());
    919     JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.enumerator).jsValue().asCell());
     919    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.m_enumerator).jsValue().asCell());
    920920    if (base->structure(vm)->id() == enumerator->cachedStructureID())
    921921        RETURN(jsBoolean(true));
    … …  
    930930    BEGIN();
    931931    auto bytecode = pc->as<OpHasGenericProperty>();
    932     JSObject* base = GET(bytecode.base).jsValue().toObject(exec);
    933     CHECK_EXCEPTION();
    934     JSValue property = GET(bytecode.property).jsValue();
     932    JSObject* base = GET(bytecode.m_base).jsValue().toObject(exec);
     933    CHECK_EXCEPTION();
     934    JSValue property = GET(bytecode.m_property).jsValue();
    935935    ASSERT(property.isString());
    936936    JSString* string = asString(property);
    … …  
    944944    BEGIN();
    945945    auto bytecode = pc->as<OpGetDirectPname>();
    946     JSValue baseValue = GET_C(bytecode.base).jsValue();
    947     JSValue property = GET(bytecode.property).jsValue();
     946    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
     947    JSValue property = GET(bytecode.m_property).jsValue();
    948948    ASSERT(property.isString());
    949949    JSString* string = asString(property);
    … …  
    957957    BEGIN();
    958958    auto bytecode = pc->as<OpGetPropertyEnumerator>();
    959     JSValue baseValue = GET(bytecode.base).jsValue();
     959    JSValue baseValue = GET(bytecode.m_base).jsValue();
    960960    if (baseValue.isUndefinedOrNull())
    961961        RETURN(JSPropertyNameEnumerator::create(vm));
    … …  
    971971    BEGIN();
    972972    auto bytecode = pc->as<OpEnumeratorStructurePname>();
    973     JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.enumerator).jsValue().asCell());
    974     uint32_t index = GET(bytecode.index).jsValue().asUInt32();
     973    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.m_enumerator).jsValue().asCell());
     974    uint32_t index = GET(bytecode.m_index).jsValue().asUInt32();
    975975
    976976    JSString* propertyName = nullptr;
    … …  
    984984    BEGIN();
    985985    auto bytecode = pc->as<OpEnumeratorGenericPname>();
    986     JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.enumerator).jsValue().asCell());
    987     uint32_t index = GET(bytecode.index).jsValue().asUInt32();
     986    JSPropertyNameEnumerator* enumerator = jsCast<JSPropertyNameEnumerator*>(GET(bytecode.m_enumerator).jsValue().asCell());
     987    uint32_t index = GET(bytecode.m_index).jsValue().asUInt32();
    988988
    989989    JSString* propertyName = nullptr;
    … …  
    997997    BEGIN();
    998998    auto bytecode = pc->as<OpToIndexString>();
    999     RETURN(jsString(exec, Identifier::from(exec, GET(bytecode.index).jsValue().asUInt32()).string()));
     999    RETURN(jsString(exec, Identifier::from(exec, GET(bytecode.m_index).jsValue().asUInt32()).string()));
    10001000}
    10011001
    … …  
    10181018    BEGIN();
    10191019    auto bytecode = pc->as<OpCreateLexicalEnvironment>();
    1020     int scopeReg = bytecode.scope.offset();
     1020    int scopeReg = bytecode.m_scope.offset();
    10211021    JSScope* currentScope = exec->uncheckedR(scopeReg).Register::scope();
    1022     SymbolTable* symbolTable = jsCast<SymbolTable*>(GET_C(bytecode.symbolTable).jsValue());
    1023     JSValue initialValue = GET_C(bytecode.initialValue).jsValue();
     1022    SymbolTable* symbolTable = jsCast<SymbolTable*>(GET_C(bytecode.m_symbolTable).jsValue());
     1023    JSValue initialValue = GET_C(bytecode.m_initialValue).jsValue();
    10241024    ASSERT(initialValue == jsUndefined() || initialValue == jsTDZValue());
    10251025    JSScope* newScope = JSLexicalEnvironment::create(vm, exec->lexicalGlobalObject(), currentScope, symbolTable, initialValue);
    … …  
    10311031    BEGIN();
    10321032    auto bytecode = pc->as<OpPushWithScope>();
    1033     JSObject* newScope = GET_C(bytecode.newScope).jsValue().toObject(exec);
    1034     CHECK_EXCEPTION();
    1035 
    1036     int scopeReg = bytecode.currentScope.offset();
     1033    JSObject* newScope = GET_C(bytecode.m_newScope).jsValue().toObject(exec);
     1034    CHECK_EXCEPTION();
     1035
     1036    int scopeReg = bytecode.m_currentScope.offset();
    10371037    JSScope* currentScope = exec->uncheckedR(scopeReg).Register::scope();
    10381038    RETURN(JSWithScope::create(vm, exec->lexicalGlobalObject(), currentScope, newScope));
    … …  
    10431043    BEGIN();
    10441044    auto bytecode = pc->as<OpResolveScopeForHoistingFuncDeclInEval>();
    1045     const Identifier& ident = exec->codeBlock()->identifier(bytecode.property);
    1046     JSScope* scope = exec->uncheckedR(bytecode.scope.offset()).Register::scope();
     1045    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_property);
     1046    JSScope* scope = exec->uncheckedR(bytecode.m_scope.offset()).Register::scope();
    10471047    JSValue resolvedScope = JSScope::resolveScopeForHoistingFuncDeclInEval(exec, scope, ident);
    10481048
    … …  
    10571057    auto bytecode = pc->as<OpResolveScope>();
    10581058    auto& metadata = bytecode.metadata(exec);
    1059     const Identifier& ident = exec->codeBlock()->identifier(bytecode.var);
    1060     JSScope* scope = exec->uncheckedR(bytecode.scope.offset()).Register::scope();
     1059    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_var);
     1060    JSScope* scope = exec->uncheckedR(bytecode.m_scope.offset()).Register::scope();
    10611061    JSObject* resolvedScope = JSScope::resolve(exec, scope, ident);
    10621062    // Proxy can throw an error here, e.g. Proxy in with statement's @unscopables.
    10631063    CHECK_EXCEPTION();
    10641064
    1065     ResolveType resolveType = metadata.resolveType;
     1065    ResolveType resolveType = metadata.m_resolveType;
    10661066
    10671067    // ModuleVar does not keep the scope register value alive in DFG.
    … …  
    10761076                ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
    10771077                if (resolveType == UnresolvedProperty)
    1078                     metadata.resolveType = GlobalProperty;
     1078                    metadata.m_resolveType = GlobalProperty;
    10791079                else
    1080                     metadata.resolveType = GlobalPropertyWithVarInjectionChecks;
    1081 
    1082                 metadata.globalObject = globalObject;
     1080                    metadata.m_resolveType = GlobalPropertyWithVarInjectionChecks;
     1081
     1082                metadata.m_globalObject = globalObject;
    10831083            }
    10841084        } else if (resolvedScope->isGlobalLexicalEnvironment()) {
    … …  
    10861086            ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
    10871087            if (resolveType == UnresolvedProperty)
    1088                 metadata.resolveType = GlobalLexicalVar;
     1088                metadata.m_resolveType = GlobalLexicalVar;
    10891089            else
    1090                 metadata.resolveType = GlobalLexicalVarWithVarInjectionChecks;
    1091             metadata.globalLexicalEnvironment = globalLexicalEnvironment;
     1090                metadata.m_resolveType = GlobalLexicalVarWithVarInjectionChecks;
     1091            metadata.m_globalLexicalEnvironment = globalLexicalEnvironment;
    10921092        }
    10931093    }
    … …  
    11001100    BEGIN();
    11011101    auto bytecode = pc->as<OpCreateRest>();
    1102     unsigned arraySize = GET_C(bytecode.arraySize).jsValue().asUInt32();
     1102    unsigned arraySize = GET_C(bytecode.m_arraySize).jsValue().asUInt32();
    11031103    JSGlobalObject* globalObject = exec->lexicalGlobalObject();
    11041104    Structure* structure = globalObject->restParameterStructure();
    1105     unsigned numParamsToSkip = bytecode.numParametersToSkip;
     1105    unsigned numParamsToSkip = bytecode.m_numParametersToSkip;
    11061106    JSValue* argumentsToCopyRegion = exec->addressOfArgumentsStart() + numParamsToSkip;
    11071107    RETURN(constructArray(exec, structure, argumentsToCopyRegion, arraySize));
    … …  
    11121112    BEGIN();
    11131113    auto bytecode = pc->as<OpGetByIdWithThis>();
    1114     const Identifier& ident = exec->codeBlock()->identifier(bytecode.property);
    1115     JSValue baseValue = GET_C(bytecode.base).jsValue();
    1116     JSValue thisVal = GET_C(bytecode.thisValue).jsValue();
     1114    const Identifier& ident = exec->codeBlock()->identifier(bytecode.m_property);
     1115    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
     1116    JSValue thisVal = GET_C(bytecode.m_thisValue).jsValue();
    11171117    PropertySlot slot(thisVal, PropertySlot::PropertySlot::InternalMethodType::Get);
    11181118    JSValue result = baseValue.get(exec, ident, slot);
    … …  
    11251125
    11261126    auto bytecode = pc->as<OpGetByValWithThis>();
    1127     JSValue baseValue = GET_C(bytecode.base).jsValue();
    1128     JSValue thisValue = GET_C(bytecode.thisValue).jsValue();
    1129     JSValue subscript = GET_C(bytecode.property).jsValue();
     1127    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
     1128    JSValue thisValue = GET_C(bytecode.m_thisValue).jsValue();
     1129    JSValue subscript = GET_C(bytecode.m_property).jsValue();
    11301130
    11311131    if (LIKELY(baseValue.isCell() && subscript.isString())) {
    … …  
    11601160    auto bytecode = pc->as<OpPutByIdWithThis>();
    11611161    CodeBlock* codeBlock = exec->codeBlock();
    1162     const Identifier& ident = codeBlock->identifier(bytecode.property);
    1163     JSValue baseValue = GET_C(bytecode.base).jsValue();
    1164     JSValue thisVal = GET_C(bytecode.thisValue).jsValue();
    1165     JSValue putValue = GET_C(bytecode.value).jsValue();
     1162    const Identifier& ident = codeBlock->identifier(bytecode.m_property);
     1163    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
     1164    JSValue thisVal = GET_C(bytecode.m_thisValue).jsValue();
     1165    JSValue putValue = GET_C(bytecode.m_value).jsValue();
    11661166    PutPropertySlot slot(thisVal, codeBlock->isStrictMode(), codeBlock->putByIdContext());
    11671167    baseValue.putInline(exec, ident, putValue, slot);
    … …  
    11731173    BEGIN();
    11741174    auto bytecode = pc->as<OpPutByValWithThis>();
    1175     JSValue baseValue = GET_C(bytecode.base).jsValue();
    1176     JSValue thisValue = GET_C(bytecode.thisValue).jsValue();
    1177     JSValue subscript = GET_C(bytecode.property).jsValue();
    1178     JSValue value = GET_C(bytecode.value).jsValue();
     1175    JSValue baseValue = GET_C(bytecode.m_base).jsValue();
     1176    JSValue thisValue = GET_C(bytecode.m_thisValue).jsValue();
     1177    JSValue subscript = GET_C(bytecode.m_property).jsValue();
     1178    JSValue value = GET_C(bytecode.m_value).jsValue();
    11791179   
    11801180    auto property = subscript.toPropertyKey(exec);
    … …  
    11891189    BEGIN();
    11901190    auto bytecode = pc->as<OpDefineDataProperty>();
    1191     JSObject* base = asObject(GET_C(bytecode.base).jsValue());
    1192     JSValue property = GET_C(bytecode.property).jsValue();
    1193     JSValue value = GET_C(bytecode.value).jsValue();
    1194     JSValue attributes = GET_C(bytecode.attributes).jsValue();
     1191    JSObject* base = asObject(GET_C(bytecode.m_base).jsValue());
     1192    JSValue property = GET_C(bytecode.m_property).jsValue();
     1193    JSValue value = GET_C(bytecode.m_value).jsValue();
     1194    JSValue attributes = GET_C(bytecode.m_attributes).jsValue();
    11951195    ASSERT(attributes.isInt32());
    11961196
    … …  
    12071207    BEGIN();
    12081208    auto bytecode = pc->as<OpDefineAccessorProperty>();
    1209     JSObject* base = asObject(GET_C(bytecode.base).jsValue());
    1210     JSValue property = GET_C(bytecode.property).jsValue();
    1211     JSValue getter = GET_C(bytecode.getter).jsValue();
    1212     JSValue setter = GET_C(bytecode.setter).jsValue();
    1213     JSValue attributes = GET_C(bytecode.attributes).jsValue();
     1209    JSObject* base = asObject(GET_C(bytecode.m_base).jsValue());
     1210    JSValue property = GET_C(bytecode.m_property).jsValue();
     1211    JSValue getter = GET_C(bytecode.m_getter).jsValue();
     1212    JSValue setter = GET_C(bytecode.m_setter).jsValue();
     1213    JSValue attributes = GET_C(bytecode.m_attributes).jsValue();
    12141214    ASSERT(attributes.isInt32());
    12151215
    … …  
    12261226    BEGIN();
    12271227    auto bytecode = pc->as<OpThrowStaticError>();
    1228     JSValue errorMessageValue = GET_C(bytecode.message).jsValue();
     1228    JSValue errorMessageValue = GET_C(bytecode.m_message).jsValue();
    12291229    RELEASE_ASSERT(errorMessageValue.isString());
    12301230    String errorMessage = asString(errorMessageValue)->value(exec);
    1231     ErrorType errorType = bytecode.errorType;
     1231    ErrorType errorType = bytecode.m_errorType;
    12321232    THROW(createError(exec, errorType, errorMessage));
    12331233}
    … …  
    12371237    BEGIN();
    12381238    auto bytecode = pc->as<OpNewArrayWithSpread>();
    1239     int numItems = bytecode.argc;
     1239    int numItems = bytecode.m_argc;
    12401240    ASSERT(numItems >= 0);
    1241     const BitVector& bitVector = exec->codeBlock()->unlinkedCodeBlock()->bitVector(bytecode.bitVector);
    1242 
    1243     JSValue* values = bitwise_cast<JSValue*>(&GET(bytecode.argv));
     1241    const BitVector& bitVector = exec->codeBlock()->unlinkedCodeBlock()->bitVector(bytecode.m_bitVector);
     1242
     1243    JSValue* values = bitwise_cast<JSValue*>(&GET(bytecode.m_argv));
    12441244
    12451245    Checked<unsigned, RecordOverflow> checkedArraySize = 0;
    … …  
    12911291    BEGIN();
    12921292    auto bytecode = pc->as<OpNewArrayBuffer>();
    1293     ASSERT(exec->codeBlock()->isConstantRegisterIndex(bytecode.immutableButterfly.offset()));
    1294     JSImmutableButterfly* immutableButterfly = bitwise_cast<JSImmutableButterfly*>(GET_C(bytecode.immutableButterfly).jsValue().asCell());
    1295     auto& profile = bytecode.metadata(exec).arrayAllocationProfile;
     1293    ASSERT(exec->codeBlock()->isConstantRegisterIndex(bytecode.m_immutableButterfly.offset()));
     1294    JSImmutableButterfly* immutableButterfly = bitwise_cast<JSImmutableButterfly*>(GET_C(bytecode.m_immutableButterfly).jsValue().asCell());
     1295    auto& profile = bytecode.metadata(exec).m_arrayAllocationProfile;
    12961296
    12971297    IndexingType indexingMode = profile.selectIndexingType();
    … …  
    13111311        // a compilation thread.
    13121312        WTF::storeStoreFence();
    1313         codeBlock->constantRegister(bytecode.immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
     1313        codeBlock->constantRegister(bytecode.m_immutableButterfly.offset()).set(vm, codeBlock, immutableButterfly);
    13141314        WTF::storeStoreFence();
    13151315    }
    … …  
    13261326
    13271327    auto bytecode = pc->as<OpSpread>();
    1328     JSValue iterable = GET_C(bytecode.argument).jsValue();
     1328    JSValue iterable = GET_C(bytecode.m_argument).jsValue();
    13291329
    13301330    if (iterable.isCell() && isJSArray(iterable.asCell())) {

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

    r239244 r240041  
    11/*
    2  * Copyright (C) 2011-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    124124    // Covers implicit globals. Since they don't exist until they first execute, we didn't know how to cache them at compile time.
    125125    auto& metadata = bytecode.metadata(exec);
    126     ResolveType resolveType = metadata.getPutInfo.resolveType();
     126    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
    127127    if (resolveType != GlobalProperty && resolveType != GlobalPropertyWithVarInjectionChecks
    128128        && resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
    … …  
    134134            resolveType = newResolveType;
    135135            ConcurrentJSLocker locker(codeBlock->m_lock);
    136             metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
     136            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
    137137        } else if (scope->isGlobalLexicalEnvironment()) {
    138138            JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope);
    139139            ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalLexicalVar : GlobalLexicalVarWithVarInjectionChecks;
    140             metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
     140            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
    141141            SymbolTableEntry entry = globalLexicalEnvironment->symbolTable()->get(ident.impl());
    142142            ASSERT(!entry.isNull());
    143143            ConcurrentJSLocker locker(codeBlock->m_lock);
    144             metadata.watchpointSet = entry.watchpointSet();
    145             metadata.operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
     144            metadata.m_watchpointSet = entry.watchpointSet();
     145            metadata.m_operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
    146146        }
    147147    }
    … …  
    166166
    167167        ConcurrentJSLocker locker(codeBlock->m_lock);
    168         metadata.structure.set(vm, codeBlock, scope->structure(vm));
    169         metadata.operand = slot.cachedOffset();
     168        metadata.m_structure.set(vm, codeBlock, scope->structure(vm));
     169        metadata.m_operand = slot.cachedOffset();
    170170    }
    171171}
    … …  
    175175{
    176176    auto& metadata = bytecode.metadata(exec);
    177     ResolveType resolveType = metadata.getPutInfo.resolveType();
     177    ResolveType resolveType = metadata.m_getPutInfo.resolveType();
    178178
    179179    if (resolveType == UnresolvedProperty || resolveType == UnresolvedPropertyWithVarInjectionChecks) {
    … …  
    182182            resolveType = newResolveType; // Allow below caching mechanism to kick in.
    183183            ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
    184             metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
     184            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
    185185        } else if (scope->isGlobalLexicalEnvironment()) {
    186186            JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope);
    … …  
    189189            ASSERT(!entry.isNull());
    190190            ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
    191             metadata.getPutInfo = GetPutInfo(metadata.getPutInfo.resolveMode(), newResolveType, metadata.getPutInfo.initializationMode());
    192             metadata.watchpointSet = entry.watchpointSet();
    193             metadata.operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
     191            metadata.m_getPutInfo = GetPutInfo(metadata.m_getPutInfo.resolveMode(), newResolveType, metadata.m_getPutInfo.initializationMode());
     192            metadata.m_watchpointSet = entry.watchpointSet();
     193            metadata.m_operand = reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
    194194        }
    195195    }
    … …  
    204204            {
    205205                ConcurrentJSLocker locker(codeBlock->m_lock);
    206                 metadata.structure.set(vm, codeBlock, structure);
    207                 metadata.operand = slot.cachedOffset();
     206                metadata.m_structure.set(vm, codeBlock, structure);
     207                metadata.m_operand = slot.cachedOffset();
    208208            }
    209209            structure->startWatchingPropertyForReplacements(vm, slot.cachedOffset());
Note: See TracChangeset for help on using the changeset viewer.